Subversion Repositories shark

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 pj 1
/*
2
 * mb_ordered.c
3
 *
4
 *      This file contains C code to implement an macroblock ordered dither.
5
 *
6
 */
7
 
8
/*  
9
 * Copyright (c) 1995 The Regents of the University of California.
10
 * All rights reserved.
11
 *
12
 * Permission to use, copy, modify, and distribute this software and its
13
 * documentation for any purpose, without fee, and without written agreement is
14
 * hereby granted, provided that the above copyright notice and the following
15
 * two paragraphs appear in all copies of this software.
16
 *
17
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
18
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
19
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
20
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
21
 *
22
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
23
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
24
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
25
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
26
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
27
 */
28
 
29
/*
30
 * Portions of this software Copyright (c) 1995 Brown University.
31
 * All rights reserved.
32
 *
33
 * Permission to use, copy, modify, and distribute this software and its
34
 * documentation for any purpose, without fee, and without written agreement
35
 * is hereby granted, provided that the above copyright notice and the
36
 * following two paragraphs appear in all copies of this software.
37
 *
38
 * IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR
39
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
40
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN
41
 * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42
 *
43
 * BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
44
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
45
 * PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
46
 * BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
47
 * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
48
 */
49
 
50
#include "video.h"
51
#include "proto.h"
52
#include "dither.h"
53
 
54
/*
55
   Changes to make the code reentrant:
56
     ditherFlags now not global, passed to MBOrderedDitherImage
57
 
58
    -lsh@cs.brown.edu (Loring Holden)
59
 */
60
 
61
#define DITH_SIZE 16
62
 
63
 
64
/* Structures used to implement macroblock ordered
65
   dither algorithm.
66
*/
67
 
68
static unsigned char ***ditherPtr[DITH_SIZE];
69
 
70
 
71
/*
72
 *--------------------------------------------------------------
73
 *
74
 *  InitMBOrderedDither--
75
 *
76
 *    Structures intialized for ordered dithering.
77
 *
78
 * Results:
79
 *    None.
80
 *
81
 * Side effects:
82
 *      None.
83
 *
84
 *--------------------------------------------------------------
85
 */
86
 
87
void
88
InitMBOrderedDither()
89
{
90
  unsigned char ****pos_2_cb;
91
  unsigned char ***cb_2_cr;
92
  unsigned char **cr_2_l;
93
  int cb_val, cb_rval, cr_val, cr_rval, l_val, l_rval;
94
  int i, j, pos;
95
  int err_range, threshval;
96
 
97
  pos_2_cb = (unsigned char ****) malloc (DITH_SIZE*sizeof(unsigned char ***));
98
  cb_2_cr = (unsigned char ***) malloc(CB_RANGE*sizeof(unsigned char **));
99
  cr_2_l = (unsigned char **) malloc(CR_RANGE*sizeof(unsigned char *));
100
 
101
  for (pos=0; pos<DITH_SIZE; pos++) {
102
 
103
    pos_2_cb[pos] = (unsigned char ***) malloc(256*(sizeof(unsigned char **)));
104
 
105
    for (j=0; j<CB_RANGE; j++) {
106
      cb_2_cr[j] = (unsigned char **) malloc(256*(sizeof(unsigned char *)));
107
    }
108
 
109
    for (cb_val=0; cb_val<cb_values[0]; cb_val++) {
110
      (pos_2_cb[pos])[cb_val] = cb_2_cr[0];
111
    }
112
 
113
    for (cb_rval=0; cb_rval<(CB_RANGE-1); cb_rval++) {
114
      err_range = cb_values[cb_rval+1] - cb_values[cb_rval];
115
      threshval = ((pos*err_range)/DITH_SIZE)+cb_values[cb_rval];
116
 
117
      for (cb_val=cb_values[cb_rval]; cb_val<cb_values[cb_rval+1]; cb_val++) {
118
    if (cb_val>threshval) (pos_2_cb[pos])[cb_val] = cb_2_cr[cb_rval+1];
119
    else (pos_2_cb[pos])[cb_val] = cb_2_cr[cb_rval];
120
      }
121
    }
122
 
123
    for (cb_val=cb_values[CB_RANGE-1]; cb_val<256; cb_val++) {
124
      (pos_2_cb[pos])[cb_val] = cb_2_cr[CB_RANGE-1];
125
    }
126
 
127
    for (cb_rval=0; cb_rval<CB_RANGE; cb_rval++) {
128
 
129
      for (j=0; j<CR_RANGE; j++) {
130
    cr_2_l[j] = (unsigned char *) malloc(256*(sizeof(unsigned char)));
131
      }
132
 
133
      for (cr_val=0; cr_val < cr_values[0]; cr_val++) {
134
    (cb_2_cr[cb_rval])[cr_val] = cr_2_l[0];
135
      }
136
 
137
      for (cr_rval=0; cr_rval<(CR_RANGE-1); cr_rval++) {
138
    err_range = cr_values[cr_rval+1] - cr_values[cr_rval];
139
    threshval = ((pos*err_range)/DITH_SIZE)+cr_values[cr_rval];
140
 
141
    for (cr_val=cr_values[cr_rval]; cr_val<cr_values[cr_rval+1]; cr_val++) {
142
      if (cr_val>threshval) (cb_2_cr[cb_rval])[cr_val] = cr_2_l[cr_rval+1];
143
      else (cb_2_cr[cb_rval])[cr_val] = cr_2_l[cr_rval];
144
    }
145
      }
146
 
147
      for (cr_val=cr_values[CR_RANGE-1]; cr_val<256; cr_val++) {
148
    (cb_2_cr[cb_rval])[cr_val] = cr_2_l[CR_RANGE-1];
149
      }
150
 
151
      for (cr_rval=0; cr_rval<CR_RANGE; cr_rval++) {
152
 
153
    for (l_val = 0; l_val < lum_values[0]; l_val++) {
154
      (cr_2_l[cr_rval])[l_val] = pixel[cb_rval+(cr_rval*CB_RANGE)+
155
                        (0*CR_RANGE*CB_RANGE)];
156
    }
157
 
158
    for (l_rval=0; l_rval<(LUM_RANGE-1); l_rval++) {
159
      err_range = lum_values[l_rval+1] - lum_values[l_rval];
160
      threshval = ((pos*err_range) /DITH_SIZE) + lum_values[l_rval];
161
 
162
      for (l_val = lum_values[l_rval]; l_val < lum_values[l_rval+1]; l_val++) {
163
        if (l_val>threshval) (cr_2_l[cr_rval])[l_val] =
164
          pixel[cb_rval+(cr_rval*CB_RANGE)+((l_rval+1)*CR_RANGE*CB_RANGE)];
165
        else (cr_2_l[cr_rval])[l_val] =
166
          pixel[cb_rval+(cr_rval*CB_RANGE)+(l_rval*CR_RANGE*CB_RANGE)];
167
      }
168
    }
169
 
170
    for (l_val = lum_values[LUM_RANGE-1]; l_val < 256; l_val++) {
171
      (cr_2_l[cr_rval])[l_val] =
172
        pixel[cb_rval+(cr_rval*CB_RANGE)+((LUM_RANGE-1)*CR_RANGE*CB_RANGE)];
173
    }
174
      }
175
    }
176
  }
177
 
178
  for (i=0; i<DITH_SIZE; i++) {
179
    ditherPtr[i] = pos_2_cb[i];
180
  }
181
}
182
 
183
 
184
 
185
/*
186
 *--------------------------------------------------------------
187
 *
188
 * MBOrderedDitherImage --
189
 *
190
 *    Dithers an image using an ordered dither at macroblock level.
191
 *    Assumptions made:
192
 *      1) The color space is allocated y:cr:cb = 8:4:4
193
 *      2) The spatial resolution of y:cr:cb is 4:1:1
194
 *      The channels are dithered based on the standard
195
 *      ordered dither pattern for a 4x4 area.
196
 *
197
 * Results:
198
 *    None.
199
 *
200
 * Side effects:
201
 *    None.
202
 *
203
 *--------------------------------------------------------------
204
 */
205
void
206
MBOrderedDitherImage (lum, cr, cb, out, h, w, ditherFlags)
207
    unsigned char *lum;
208
    unsigned char *cr;
209
    unsigned char *cb;
210
    unsigned char *out;
211
    int h, w;
212
    char *ditherFlags;
213
{
214
  unsigned char *l, *r, *b, *o1, *o2;
215
  unsigned char *l2;
216
  unsigned char L, R, B;
217
  int i, j, mbaddr, mbwidth;
218
  unsigned char ***dp0 = ditherPtr[0];
219
  unsigned char ***dp2 = ditherPtr[2];
220
  unsigned char ***dp4 = ditherPtr[4];
221
  unsigned char ***dp6 = ditherPtr[6];
222
  unsigned char ***dp8 = ditherPtr[8];
223
  unsigned char ***dp10 = ditherPtr[10];
224
  unsigned char ***dp12 = ditherPtr[12];
225
  unsigned char ***dp14 = ditherPtr[14];
226
  unsigned char ***dp1 = ditherPtr[1];
227
  unsigned char ***dp3 = ditherPtr[3];
228
  unsigned char ***dp5 = ditherPtr[5];
229
  unsigned char ***dp7 = ditherPtr[7];
230
  unsigned char ***dp9 = ditherPtr[9];
231
  unsigned char ***dp11 = ditherPtr[11];
232
  unsigned char ***dp13 = ditherPtr[13];
233
  unsigned char ***dp15 = ditherPtr[15];
234
 
235
  l = lum;
236
  l2 = lum + w;
237
  r = cr;
238
  b = cb;
239
  o1 = out;
240
  o2 = out+w;
241
  mbwidth = w / 16;
242
 
243
  for (i=0; i<h; i+=4) {
244
 
245
    mbaddr = (i / 16) * mbwidth ;
246
 
247
    for (j=0; j<w; j+=8) {
248
 
249
      if (ditherFlags[mbaddr+(j/16)]) {
250
    R = r[0]; B = b[0];
251
 
252
    L = l[0];
253
    o1[0] = ((dp0[B])[R])[L];
254
    L = l[1];
255
    o1[1] = ((dp8[B])[R])[L];
256
    L = l2[0];
257
    o2[0] = ((dp12[B])[R])[L];
258
    L = l2[1];
259
    o2[1] = ((dp4[B])[R])[L];
260
 
261
    R = r[1]; B = b[1];
262
 
263
    L = l[2];
264
    o1[2] = ((dp2[B])[R])[L];
265
    L = l[3];
266
    o1[3] = ((dp10[B])[R])[L];
267
    L = l2[2];
268
    o2[2] = ((dp14[B])[R])[L];
269
    L = l2[3];
270
    o2[3] = ((dp6[B])[R])[L];
271
 
272
    R = r[2]; B = b[2];
273
 
274
    L = l[4];
275
    o1[4] = ((dp0[B])[R])[L];
276
    L = l[5];
277
    o1[5] = ((dp8[B])[R])[L];
278
    L = l2[4];
279
    o2[4] = ((dp12[B])[R])[L];
280
    L = l2[5];
281
    o2[5] = ((dp4[B])[R])[L];
282
 
283
    R = r[3]; B = b[3];
284
 
285
    L = l[6];
286
    o1[6] = ((dp2[B])[R])[L];
287
    L = l[7];
288
    o1[7] = ((dp10[B])[R])[L];
289
    L = l2[6];
290
    o2[6] = ((dp14[B])[R])[L];
291
    L = l2[7];
292
    o2[7] = ((dp6[B])[R])[L];
293
      }
294
 
295
      l += 8;
296
      l2 += 8;
297
      r += 4;
298
      b += 4;
299
      o1 += 8;
300
      o2 += 8;
301
    }
302
 
303
    l += w; l2 += w;
304
    o1 += w; o2 += w;
305
 
306
    for (j=0; j<w; j+=8) {
307
 
308
      if (ditherFlags[mbaddr+(j/16)]) {
309
 
310
    R = r[0]; B = b[0];
311
 
312
    L = l[0];
313
    o1[0] = ((dp3[B])[R])[L];
314
    L = l[1];
315
    o1[1] = ((dp11[B])[R])[L];
316
    L = l2[0];
317
    o2[0] = ((dp15[B])[R])[L];
318
    L = l2[1];
319
    o2[1] = ((dp7[B])[R])[L];
320
 
321
    R = r[1]; B = b[1];
322
 
323
    L = l[2];
324
    o1[2] = ((dp1[B])[R])[L];
325
    L = l[3];
326
    o1[3] = ((dp9[B])[R])[L];
327
    L = l2[2];
328
    o2[2] = ((dp13[B])[R])[L];
329
    L = l2[3];
330
    o2[3] = ((dp5[B])[R])[L];
331
 
332
    R = r[2]; B = b[2];
333
 
334
    L = l[4];
335
    o1[4] = ((dp3[B])[R])[L];
336
    L = l[5];
337
    o1[5] = ((dp11[B])[R])[L];
338
    L = l2[4];
339
    o2[4] = ((dp15[B])[R])[L];
340
    L = l2[5];
341
    o2[5] = ((dp7[B])[R])[L];
342
 
343
    R = r[3]; B = b[3];
344
 
345
    L = l[6];
346
    o1[6] = ((dp1[B])[R])[L];
347
    L = l[7];
348
    o1[7] = ((dp9[B])[R])[L];
349
    L = l2[6];
350
    o2[6] = ((dp13[B])[R])[L];
351
    L = l2[7];
352
    o2[7] = ((dp5[B])[R])[L];
353
      }
354
 
355
      l += 8;
356
      l2 += 8;
357
      r += 4;
358
      b += 4;
359
      o1 += 8;
360
      o2 += 8;
361
    }
362
 
363
    l += w; l2 += w;
364
    o1 += w; o2 += w;
365
  }
366
}
367
 
368
 
369
 
370
/*
371
 *--------------------------------------------------------------
372
 *
373
 * MBOrderedDitherDisplayCopy --
374
 *
375
 *    Copies an image to the display (?)
376
 *
377
 * Results:
378
 *    None.
379
 *
380
 * Side effects:
381
 *    None.
382
 *
383
 *--------------------------------------------------------------
384
 */
385
void
386
MBOrderedDitherDisplayCopy(vid_stream, mb_addr, motion_forw, r_right_forw,
387
        r_down_forw, motion_back, r_right_back, r_down_back, past, future)
388
    VidStream *vid_stream;
389
    int mb_addr;
390
    int motion_forw, r_right_forw, r_down_forw;
391
    int motion_back, r_right_back, r_down_back;
392
    unsigned char *past, *future;
393
{
394
  int right_back = 0, right_forw = 0, down_back, down_forw;
395
  unsigned char *dest;
396
  unsigned char *src1 = 0, *src2 = 0;
397
  int row, col, row_size, rr;
398
  int mc, mr;
399
 
400
  row = (mb_addr / vid_stream->mb_width) << 4;
401
  col = (mb_addr % vid_stream->mb_width) << 4;
402
  row_size = vid_stream->mb_width << 4;
403
 
404
  dest = vid_stream->current->display + (row * row_size) + col;
405
 
406
  if (motion_forw) {
407
    right_forw = r_right_forw >> 1;
408
    down_forw = r_down_forw >> 1;
409
    src1 = past + ((row + down_forw) * row_size) + (col + right_forw);
410
  }
411
 
412
  if (motion_back) {
413
    right_back = r_right_back >> 1;
414
    down_back = r_down_back >> 1;
415
    src2 = future + ((row + down_back) * row_size) + (col + right_back);
416
  }
417
 
418
  if (motion_forw) {
419
    if (motion_back) {
420
      for (rr = 0; rr<16; rr++) {
421
        dest[0] = src1[0];      dest[1] = src2[1];
422
        dest[2] = src1[2];      dest[3] = src2[3];
423
        dest[4] = src1[4];      dest[5] = src2[5];
424
        dest[6] = src1[6];      dest[7] = src2[7];
425
        dest[8] = src1[8];      dest[9] = src2[9];
426
        dest[10] = src1[10];    dest[11] = src2[11];
427
        dest[12] = src1[12];    dest[13] = src2[13];
428
        dest[14] = src1[14];    dest[15] = src2[15];
429
 
430
        dest += row_size;
431
        src1 += row_size;
432
        src2 += row_size;
433
      }
434
    }
435
    else {
436
      mc = col & 0x3;
437
      mr = right_forw & 0x3;
438
      if (!mc && !mr) {
439
    /* Use 32 bit copy */
440
    int *d, *s;
441
 
442
    d = (int *) dest;
443
    s = (int *) src1;
444
    row_size /= 4;
445
 
446
    for (rr = 0; rr < 16; rr++) {
447
      d[0] = s[0];
448
      d[1] = s[1];
449
      d[2] = s[2];
450
      d[3] = s[3];
451
      d += row_size;
452
      s += row_size;
453
    }
454
      } else if ((!mc || (mc == 2)) &&
455
         (!mr || (mr == 2))) {
456
    /* Use 16 bit copy */
457
    short int *d, * s;
458
 
459
    d = (short int *) dest;
460
    s = (short int *) src1;
461
    row_size /= 2;
462
 
463
    for (rr = 0; rr < 16; rr++) {
464
      d[0] = s[0];
465
      d[1] = s[1];
466
      d[2] = s[2];
467
      d[3] = s[3];
468
      d[4] = s[4];
469
      d[5] = s[5];
470
      d[6] = s[6];
471
      d[7] = s[7];
472
      d += row_size;
473
      s += row_size;
474
    }
475
      }
476
      else {
477
    for (rr = 0; rr < 16; rr++) {
478
      dest[0] = src1[0];
479
      dest[1] = src1[1];
480
      dest[2] = src1[2];
481
      dest[3] = src1[3];
482
      dest[4] = src1[4];
483
      dest[5] = src1[5];
484
      dest[6] = src1[6];
485
      dest[7] = src1[7];
486
      dest[8] = src1[8];
487
      dest[9] = src1[9];
488
      dest[10] = src1[10];
489
      dest[11] = src1[11];
490
      dest[12] = src1[12];
491
      dest[13] = src1[13];
492
      dest[14] = src1[14];
493
      dest[15] = src1[15];
494
 
495
      dest += row_size;
496
      src1 += row_size;
497
    }
498
      }
499
    }
500
  } else if (motion_back) {
501
    mc = col & 0x3;
502
    mr = right_back & 0x3;
503
    if (!mc && !mr) {
504
      /* Use 32 bit copy */
505
      int *d, *s;
506
 
507
      d = (int *) dest;
508
      s = (int *) src2;
509
      row_size /= 4;
510
 
511
      for (rr = 0; rr < 16; rr++) {
512
        d[0] = s[0];
513
        d[1] = s[1];
514
        d[2] = s[2];
515
        d[3] = s[3];
516
        d += row_size;
517
        s += row_size;
518
      }
519
    }
520
    else if ((!mc || mc == 2) &&
521
         (!mr || mr == 2)) {
522
      /* Use 8 bit copy */
523
      short int *d, *s;
524
 
525
      d = (short int *) dest;
526
      s = (short int *) src2;
527
      row_size /= 2;
528
 
529
      for (rr = 0; rr < 16; rr++) {
530
        d[0] = s[0];
531
        d[1] = s[1];
532
        d[2] = s[2];
533
        d[3] = s[3];
534
        d[4] = s[4];
535
        d[5] = s[5];
536
        d[6] = s[6];
537
        d[7] = s[7];
538
        d += row_size;
539
        s += row_size;
540
      }
541
    }
542
    else {
543
      for (rr = 0; rr < 16; rr++) {
544
        /* Use 8 bit copy */
545
        dest[0] = src2[0];
546
        dest[1] = src2[1];
547
        dest[2] = src2[2];
548
        dest[3] = src2[3];
549
        dest[4] = src2[4];
550
        dest[5] = src2[5];
551
        dest[6] = src2[6];
552
        dest[7] = src2[7];
553
        dest[8] = src2[8];
554
        dest[9] = src2[9];
555
        dest[10] = src2[10];
556
        dest[11] = src2[11];
557
        dest[12] = src2[12];
558
        dest[13] = src2[13];
559
        dest[14] = src2[14];
560
        dest[15] = src2[15];
561
 
562
        dest += row_size;
563
        src2 += row_size;
564
      }
565
    }
566
  }
567
}