1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 #include "mp4dec_lib.h"
19 #include "vlc_decode.h"
20 #include "zigzag.h"
21
22
23 typedef PV_STATUS(*VlcDecFuncP)(BitstreamDecVideo *stream, Tcoef *pTcoef);
24 static const uint8 AC_rowcol[64] = { 0, 0, 0, 0, 0, 0, 0, 0,
25 0, 1, 1, 1, 1, 1, 1, 1,
26 0, 1, 1, 1, 1, 1, 1, 1,
27 0, 1, 1, 1, 1, 1, 1, 1,
28 0, 1, 1, 1, 1, 1, 1, 1,
29 0, 1, 1, 1, 1, 1, 1, 1,
30 0, 1, 1, 1, 1, 1, 1, 1,
31 0, 1, 1, 1, 1, 1, 1, 1,
32 };
33 static const uint8 mask[8] = /* for fast bitmap */
34 {128, 64, 32, 16, 8, 4, 2, 1};
35
36
37
38 /***********************************************************CommentBegin******
39 *
40 * -- VlcDequantMpegBlock -- Decodes the DCT coefficients of one 8x8 block and perform
41 dequantization using Mpeg mode.
42 Date: 08/08/2000
43
44 Modified: 3/21/01
45 Added pre IDCT clipping, new ACDC prediction structure, ACDC prediction clipping,
46 16-bit int case, removed multiple zigzaging
47 ******************************************************************************/
48
49 #ifdef PV_SUPPORT_MAIN_PROFILE
VlcDequantMpegIntraBlock(void * vid,int comp,int switched,uint8 * bitmapcol,uint8 * bitmaprow)50 int VlcDequantMpegIntraBlock(void *vid, int comp, int switched,
51 uint8 *bitmapcol, uint8 *bitmaprow)
52 {
53 VideoDecData *video = (VideoDecData*) vid;
54 Vol *currVol = video->vol[video->currLayer];
55 BitstreamDecVideo *stream = video->bitstream;
56 int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
57 int mbnum = video->mbnum;
58 uint CBP = video->headerInfo.CBP[mbnum];
59 int QP = video->QPMB[mbnum];
60 typeDCStore *DC = video->predDC + mbnum;
61 int x_pos = video->mbnum_col;
62 typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
63 typeDCACStore *DCAC_col = video->predDCAC_col;
64 uint ACpred_flag = (uint) video->acPredFlag[mbnum];
65
66 /*** VLC *****/
67 int i, j, k;
68 Tcoef run_level;
69 int last, return_status;
70 VlcDecFuncP vlcDecCoeff;
71 int direction;
72 const int *inv_zigzag;
73 /*** Quantizer ****/
74 int dc_scaler;
75 int sum;
76 int *qmat;
77 int32 temp;
78
79 const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
80 const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
81
82 int16 *dcac_row, *dcac_col;
83
84 dcac_row = (*DCAC_row)[B_Xtab[comp]];
85 dcac_col = (*DCAC_col)[B_Ytab[comp]];
86
87
88 i = 1 - switched;
89
90 #ifdef FAST_IDCT
91 *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
92 *bitmaprow = 0;
93 #endif
94
95
96 /* select which Huffman table to be used */
97 vlcDecCoeff = video->vlcDecCoeffIntra;
98
99 dc_scaler = (comp < 4) ? video->mblock->DCScalarLum : video->mblock->DCScalarChr;
100
101 /* enter the zero run decoding loop */
102 sum = 0;
103 qmat = currVol->iqmat;
104
105 /* perform only VLC decoding */
106 /* We cannot do DCACrecon before VLC decoding. 10/17/2000 */
107 doDCACPrediction(video, comp, datablock, &direction);
108 if (!ACpred_flag) direction = 0;
109 inv_zigzag = zigzag_inv + (ACpred_flag << 6) + (direction << 6);
110 if (CBP & (1 << (5 - comp)))
111 {
112 do
113 {
114 return_status = (*vlcDecCoeff)(stream, &run_level);
115 if (return_status != PV_SUCCESS)
116 {
117 last = 1;/* 11/1/2000 let it slips undetected, just like
118 in original version */
119 i = VLC_ERROR;
120 ACpred_flag = 0; /* no of coefficients should not get reset 03/07/2002 */
121 break;
122 }
123
124 i += run_level.run;
125 last = run_level.last;
126 if (i >= 64)
127 {
128 /* i = NCOEFF_BLOCK; */ /* 11/1/00 */
129 ACpred_flag = 0; /* no of coefficients should not get reset 03/07/2002 */
130 i = VLC_NO_LAST_BIT;
131 last = 1;
132 break;
133 }
134
135 k = inv_zigzag[i];
136
137 if (run_level.sign == 1)
138 {
139 datablock[k] -= run_level.level;
140 }
141 else
142 {
143 datablock[k] += run_level.level;
144 }
145
146 if (AC_rowcol[k])
147 {
148 temp = (int32)datablock[k] * qmat[k] * QP;
149 temp = (temp + (0x7 & (temp >> 31))) >> 3;
150 if (temp > 2047) temp = 2047;
151 else if (temp < -2048) temp = -2048;
152 datablock[k] = (int) temp;
153
154 #ifdef FAST_IDCT
155 bitmapcol[k&0x7] |= mask[k>>3];
156 #endif
157 sum ^= temp;
158 }
159
160 i++;
161 }
162 while (!last);
163
164 }
165 else
166 {
167 i = 1; /* 04/26/01 needed for switched case */
168 }
169 ///// NEED TO DEQUANT THOSE PREDICTED AC COEFF
170 /* dequantize the rest of AC predicted coeff that haven't been dequant */
171 if (ACpred_flag)
172 {
173
174 i = NCOEFF_BLOCK; /* otherwise, FAST IDCT won't work correctly, 10/18/2000 */
175
176 if (!direction) /* check vertical */
177 {
178 dcac_row[0] = datablock[1];
179 dcac_row[1] = datablock[2];
180 dcac_row[2] = datablock[3];
181 dcac_row[3] = datablock[4];
182 dcac_row[4] = datablock[5];
183 dcac_row[5] = datablock[6];
184 dcac_row[6] = datablock[7];
185
186 for (j = 0, k = 8; k < 64; k += 8, j++)
187 {
188 if (dcac_col[j] = datablock[k])
189 { /* ACDC clipping 03/26/01 */
190 if (datablock[k] > 2047) dcac_col[j] = 2047;
191 else if (datablock[k] < -2048) dcac_col[j] = -2048;
192
193 temp = (int32)dcac_col[j] * qmat[k] * QP;
194 temp = (temp + (0x7 & (temp >> 31))) >> 3; /* 03/26/01*/
195 if (temp > 2047) temp = 2047;
196 else if (temp < -2048) temp = -2048;
197 datablock[k] = (int)temp;
198 sum ^= temp; /* 7/5/01 */
199 #ifdef FAST_IDCT
200 bitmapcol[0] |= mask[k>>3];
201 #endif
202
203 }
204 }
205 for (k = 1; k < 8; k++)
206 {
207 if (datablock[k])
208 {
209 temp = (int32)datablock[k] * qmat[k] * QP;
210 temp = (temp + (0x7 & (temp >> 31))) >> 3; /* 03/26/01*/
211 if (temp > 2047) temp = 2047;
212 else if (temp < -2048) temp = -2048;
213 datablock[k] = (int)temp;
214 sum ^= temp; /* 7/5/01 */
215 #ifdef FAST_IDCT
216 bitmapcol[k] |= 128;
217 #endif
218
219 }
220 }
221
222 }
223 else
224 {
225
226 dcac_col[0] = datablock[8];
227 dcac_col[1] = datablock[16];
228 dcac_col[2] = datablock[24];
229 dcac_col[3] = datablock[32];
230 dcac_col[4] = datablock[40];
231 dcac_col[5] = datablock[48];
232 dcac_col[6] = datablock[56];
233
234
235 for (j = 0, k = 1; k < 8; k++, j++)
236 {
237 if (dcac_row[j] = datablock[k])
238 { /* ACDC clipping 03/26/01 */
239 if (datablock[k] > 2047) dcac_row[j] = 2047;
240 else if (datablock[k] < -2048) dcac_row[j] = -2048;
241
242 temp = (int32)dcac_row[j] * qmat[k] * QP;
243 temp = (temp + (0x7 & (temp >> 31))) >> 3; /* 03/26/01 */
244 if (temp > 2047) temp = 2047;
245 else if (temp < -2048) temp = -2048;
246 datablock[k] = (int)temp;
247 sum ^= temp;
248 #ifdef FAST_IDCT
249 bitmapcol[k] |= 128;
250 #endif
251
252 }
253 }
254
255 for (k = 8; k < 64; k += 8)
256 {
257 if (datablock[k])
258 {
259 temp = (int32)datablock[k] * qmat[k] * QP;
260 temp = (temp + (0x7 & (temp >> 31))) >> 3; /* 03/26/01 */
261 if (temp > 2047) temp = 2047;
262 else if (temp < -2048) temp = -2048;
263 datablock[k] = (int)temp;
264 sum ^= temp;
265 #ifdef FAST_IDCT
266 bitmapcol[0] |= mask[k>>3];
267 #endif
268 }
269 }
270
271 }
272 }
273 else
274 {
275
276 /* Store the qcoeff-values needed later for prediction */
277
278 dcac_row[0] = datablock[1]; /* ACDC, no need for clipping */
279 dcac_row[1] = datablock[2];
280 dcac_row[2] = datablock[3];
281 dcac_row[3] = datablock[4];
282 dcac_row[4] = datablock[5];
283 dcac_row[5] = datablock[6];
284 dcac_row[6] = datablock[7];
285
286 dcac_col[0] = datablock[8];
287 dcac_col[1] = datablock[16];
288 dcac_col[2] = datablock[24];
289 dcac_col[3] = datablock[32];
290 dcac_col[4] = datablock[40];
291 dcac_col[5] = datablock[48];
292 dcac_col[6] = datablock[56];
293
294 for (k = 1; k < 8; k++)
295 {
296 if (datablock[k])
297 {
298 temp = (int32)datablock[k] * qmat[k] * QP;
299 temp = (temp + (0x7 & (temp >> 31))) >> 3; /* 03/26/01*/
300 if (temp > 2047) temp = 2047;
301 else if (temp < -2048) temp = -2048;
302 datablock[k] = (int)temp;
303 sum ^= temp; /* 7/5/01 */
304 #ifdef FAST_IDCT
305 bitmapcol[k] |= 128;
306 #endif
307
308 }
309 }
310 for (k = 8; k < 64; k += 8)
311 {
312 if (datablock[k])
313 {
314 temp = (int32)datablock[k] * qmat[k] * QP;
315 temp = (temp + (0x7 & (temp >> 31))) >> 3; /* 03/26/01 */
316 if (temp > 2047) temp = 2047;
317 else if (temp < -2048) temp = -2048;
318 datablock[k] = (int)temp;
319 sum ^= temp;
320 #ifdef FAST_IDCT
321 bitmapcol[0] |= mask[k>>3];
322 #endif
323 }
324 }
325
326 }
327
328
329
330 if (datablock[0])
331 {
332 temp = (int32)datablock[0] * dc_scaler;
333 if (temp > 2047) temp = 2047; /* 03/14/01 */
334 else if (temp < -2048) temp = -2048;
335 datablock[0] = (int)temp;
336 sum ^= temp;
337 #ifdef FAST_IDCT
338 bitmapcol[0] |= 128;
339 #endif
340 }
341
342 if ((sum & 1) == 0)
343 {
344 datablock[63] = datablock[63] ^ 0x1;
345 #ifdef FAST_IDCT /* 7/5/01, need to update bitmap */
346 if (datablock[63])
347 bitmapcol[7] |= 1;
348 #endif
349 i = (-64 & i) | NCOEFF_BLOCK; /* if i > -1 then i is set to NCOEFF_BLOCK */
350 }
351
352
353 #ifdef FAST_IDCT
354 if (i > 10)
355 {
356 for (k = 1; k < 4; k++)
357 {
358 if (bitmapcol[k] != 0)
359 {
360 (*bitmaprow) |= mask[k];
361 }
362 }
363 }
364 #endif
365
366 /* Store the qcoeff-values needed later for prediction */
367 (*DC)[comp] = datablock[0];
368 return i;
369
370 }
371
372
373 /***********************************************************CommentBegin******
374 *
375 * -- VlcDequantMpegInterBlock -- Decodes the DCT coefficients of one 8x8 block and perform
376 dequantization using Mpeg mode for INTER block.
377 Date: 08/08/2000
378 Modified: 3/21/01
379 clean up, added clipping, 16-bit int case, new ACDC prediction
380 ******************************************************************************/
381
382
VlcDequantMpegInterBlock(void * vid,int comp,uint8 * bitmapcol,uint8 * bitmaprow)383 int VlcDequantMpegInterBlock(void *vid, int comp,
384 uint8 *bitmapcol, uint8 *bitmaprow)
385 {
386 VideoDecData *video = (VideoDecData*) vid;
387 BitstreamDecVideo *stream = video->bitstream;
388 Vol *currVol = video->vol[video->currLayer];
389 int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
390 int mbnum = video->mbnum;
391 int QP = video->QPMB[mbnum];
392 /*** VLC *****/
393 int i, k;
394 Tcoef run_level;
395 int last, return_status;
396 VlcDecFuncP vlcDecCoeff;
397
398 /*** Quantizer ****/
399 int sum;
400 int *qmat;
401
402 int32 temp;
403
404 i = 0 ;
405
406 #ifdef FAST_IDCT
407 *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
408 *bitmaprow = 0;
409 #endif
410
411 /* select which Huffman table to be used */
412 vlcDecCoeff = video->vlcDecCoeffInter;
413
414 /* enter the zero run decoding loop */
415 sum = 0;
416 qmat = currVol->niqmat;
417 do
418 {
419 return_status = (*vlcDecCoeff)(stream, &run_level);
420 if (return_status != PV_SUCCESS)
421 {
422 last = 1;/* 11/1/2000 let it slips undetected, just like
423 in original version */
424 i = VLC_ERROR;
425 sum = 1; /* no of coefficients should not get reset 03/07/2002 */
426 break;
427 }
428
429 i += run_level.run;
430 last = run_level.last;
431 if (i >= 64)
432 {
433 /* i = NCOEFF_BLOCK; */ /* 11/1/00 */
434 //return VLC_NO_LAST_BIT;
435 i = VLC_NO_LAST_BIT;
436 last = 1;
437 sum = 1; /* no of coefficients should not get reset 03/07/2002 */
438 break;
439 }
440
441 k = zigzag_inv[i];
442
443 if (run_level.sign == 1)
444 {
445 temp = (-(int32)(2 * run_level.level + 1) * qmat[k] * QP + 15) >> 4; /* 03/23/01 */
446 if (temp < -2048) temp = - 2048;
447 }
448 else
449 {
450 temp = ((int32)(2 * run_level.level + 1) * qmat[k] * QP) >> 4; /* 03/23/01 */
451 if (temp > 2047) temp = 2047;
452 }
453
454 datablock[k] = (int)temp;
455
456 #ifdef FAST_IDCT
457 bitmapcol[k&0x7] |= mask[k>>3];
458 #endif
459 sum ^= temp;
460
461 i++;
462 }
463 while (!last);
464
465 if ((sum & 1) == 0)
466 {
467 datablock[63] = datablock[63] ^ 0x1;
468 #ifdef FAST_IDCT /* 7/5/01, need to update bitmap */
469 if (datablock[63])
470 bitmapcol[7] |= 1;
471 #endif
472 i = NCOEFF_BLOCK;
473 }
474
475
476 #ifdef FAST_IDCT
477 if (i > 10)
478 {
479 for (k = 1; k < 4; k++) /* 07/19/01 */
480 {
481 if (bitmapcol[k] != 0)
482 {
483 (*bitmaprow) |= mask[k];
484 }
485 }
486 }
487 #endif
488
489 return i;
490 }
491 #endif
492 /***********************************************************CommentBegin******
493 *
494 * -- VlcDequantIntraH263Block -- Decodes the DCT coefficients of one 8x8 block and perform
495 dequantization in H.263 mode for INTRA block.
496 Date: 08/08/2000
497 Modified: 3/21/01
498 clean up, added clipping, 16-bit int case, removed multiple zigzaging
499 ******************************************************************************/
500
501
VlcDequantH263IntraBlock(VideoDecData * video,int comp,int switched,uint8 * bitmapcol,uint8 * bitmaprow)502 int VlcDequantH263IntraBlock(VideoDecData *video, int comp, int switched,
503 uint8 *bitmapcol, uint8 *bitmaprow)
504 {
505 BitstreamDecVideo *stream = video->bitstream;
506 int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
507 int32 temp;
508 int mbnum = video->mbnum;
509 uint CBP = video->headerInfo.CBP[mbnum];
510 int QP = video->QPMB[mbnum];
511 typeDCStore *DC = video->predDC + mbnum;
512 int x_pos = video->mbnum_col;
513 typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
514 typeDCACStore *DCAC_col = video->predDCAC_col;
515 uint ACpred_flag = (uint) video->acPredFlag[mbnum];
516
517 /*** VLC *****/
518 int i, j, k;
519 Tcoef run_level;
520 int last, return_status;
521 VlcDecFuncP vlcDecCoeff;
522 int direction;
523 const int *inv_zigzag;
524
525 /*** Quantizer ****/
526 int dc_scaler;
527 int sgn_coeff;
528
529
530
531 const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
532 const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
533
534 int16 *dcac_row, *dcac_col;
535
536 dcac_row = (*DCAC_row)[B_Xtab[comp]];
537 dcac_col = (*DCAC_col)[B_Ytab[comp]];
538
539 #ifdef FAST_IDCT
540 *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
541 *bitmaprow = 0;
542 #endif
543 /* select which Huffman table to be used */
544 vlcDecCoeff = video->vlcDecCoeffIntra;
545
546 dc_scaler = (comp < 4) ? video->mblock->DCScalarLum : video->mblock->DCScalarChr;
547
548 /* perform only VLC decoding */
549 doDCACPrediction(video, comp, datablock, &direction);
550 if (!ACpred_flag) direction = 0;
551
552 inv_zigzag = zigzag_inv + (ACpred_flag << 6) + (direction << 6); /* 04/17/01 */
553
554 i = 1;
555 if (CBP & (1 << (5 - comp)))
556 {
557 i = 1 - switched;
558 do
559 {
560 return_status = (*vlcDecCoeff)(stream, &run_level);
561 if (return_status != PV_SUCCESS)
562 {
563 last = 1;/* 11/1/2000 let it slips undetected, just like
564 in original version */
565 i = VLC_ERROR;
566 ACpred_flag = 0; /* no of coefficients should not get reset 03/07/2002 */
567 break;
568 }
569
570 i += run_level.run;
571 last = run_level.last;
572 if (i >= 64)
573 {
574 ACpred_flag = 0; /* no of coefficients should not get reset 03/07/2002 */
575 i = VLC_NO_LAST_BIT;
576 last = 1;
577 break;
578 }
579
580 k = inv_zigzag[i];
581
582 if (run_level.sign == 1)
583 {
584 datablock[k] -= run_level.level;
585 sgn_coeff = -1;
586 }
587 else
588 {
589 datablock[k] += run_level.level;
590 sgn_coeff = 1;
591 }
592
593
594 if (AC_rowcol[k]) /* 10/25/2000 */
595 {
596 temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
597 if (temp > 2047) temp = 2047; /* 03/14/01 */
598 else if (temp < -2048) temp = -2048;
599 datablock[k] = (int16) temp;
600
601 #ifdef FAST_IDCT
602 bitmapcol[k&0x7] |= mask[k>>3];
603 #endif
604 }
605
606 i++;
607 }
608 while (!last);
609
610 }
611
612 ///// NEED TO DEQUANT THOSE PREDICTED AC COEFF
613 /* dequantize the rest of AC predicted coeff that haven't been dequant */
614 if (ACpred_flag)
615 {
616
617 i = NCOEFF_BLOCK; /* otherwise, FAST IDCT won't work correctly, 10/18/2000 */
618
619 if (!direction) /* check vertical */
620 {
621
622 dcac_row[0] = datablock[1];
623 dcac_row[1] = datablock[2];
624 dcac_row[2] = datablock[3];
625 dcac_row[3] = datablock[4];
626 dcac_row[4] = datablock[5];
627 dcac_row[5] = datablock[6];
628 dcac_row[6] = datablock[7];
629
630 for (j = 0, k = 8; k < 64; k += 8, j++)
631 {
632 dcac_col[j] = datablock[k];
633 if (dcac_col[j])
634 {
635 if (datablock[k] > 0)
636 {
637 if (datablock[k] > 2047) dcac_col[j] = 2047;
638 sgn_coeff = 1;
639 }
640 else
641 {
642 if (datablock[k] < -2048) dcac_col[j] = -2048;
643 sgn_coeff = -1;
644 }
645 temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
646 if (temp > 2047) temp = 2047; /* 03/14/01 */
647 else if (temp < -2048) temp = -2048;
648 datablock[k] = (int16) temp;
649 #ifdef FAST_IDCT
650 bitmapcol[0] |= mask[k>>3];
651 #endif
652
653 }
654 }
655
656 for (k = 1; k < 8; k++)
657 {
658 if (datablock[k])
659 {
660 sgn_coeff = (datablock[k] > 0) ? 1 : -1;
661 temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
662 if (temp > 2047) temp = 2047; /* 03/14/01 */
663 else if (temp < -2048) temp = -2048;
664 datablock[k] = (int16) temp;
665 #ifdef FAST_IDCT
666 bitmapcol[k] |= 128;
667 #endif
668
669 }
670 }
671 }
672 else
673 {
674
675 dcac_col[0] = datablock[8];
676 dcac_col[1] = datablock[16];
677 dcac_col[2] = datablock[24];
678 dcac_col[3] = datablock[32];
679 dcac_col[4] = datablock[40];
680 dcac_col[5] = datablock[48];
681 dcac_col[6] = datablock[56];
682
683
684 for (j = 0, k = 1; k < 8; k++, j++)
685 {
686 dcac_row[j] = datablock[k];
687 if (dcac_row[j])
688 {
689 if (datablock[k] > 0)
690 {
691 if (datablock[k] > 2047) dcac_row[j] = 2047;
692 sgn_coeff = 1;
693 }
694 else
695 {
696 if (datablock[k] < -2048) dcac_row[j] = -2048;
697 sgn_coeff = -1;
698 }
699
700 temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
701 if (temp > 2047) temp = 2047; /* 03/14/01 */
702 else if (temp < -2048) temp = -2048;
703 datablock[k] = (int) temp;
704 #ifdef FAST_IDCT
705 bitmapcol[k] |= 128;
706 #endif
707
708 }
709 }
710 for (k = 8; k < 64; k += 8)
711 {
712 if (datablock[k])
713 {
714 sgn_coeff = (datablock[k] > 0) ? 1 : -1;
715 temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
716 if (temp > 2047) temp = 2047; /* 03/14/01 */
717 else if (temp < -2048) temp = -2048;
718 datablock[k] = (int16) temp;
719 #ifdef FAST_IDCT
720 bitmapcol[0] |= mask[k>>3];
721 #endif
722 }
723 }
724
725 }
726 }
727 else
728 {
729 dcac_row[0] = datablock[1];
730 dcac_row[1] = datablock[2];
731 dcac_row[2] = datablock[3];
732 dcac_row[3] = datablock[4];
733 dcac_row[4] = datablock[5];
734 dcac_row[5] = datablock[6];
735 dcac_row[6] = datablock[7];
736
737 dcac_col[0] = datablock[8];
738 dcac_col[1] = datablock[16];
739 dcac_col[2] = datablock[24];
740 dcac_col[3] = datablock[32];
741 dcac_col[4] = datablock[40];
742 dcac_col[5] = datablock[48];
743 dcac_col[6] = datablock[56];
744
745 for (k = 1; k < 8; k++)
746 {
747 if (datablock[k])
748 {
749 sgn_coeff = (datablock[k] > 0) ? 1 : -1;
750 temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
751 if (temp > 2047) temp = 2047; /* 03/14/01 */
752 else if (temp < -2048) temp = -2048;
753 datablock[k] = (int16) temp;
754 #ifdef FAST_IDCT
755 bitmapcol[k] |= 128;
756 #endif
757 }
758 }
759 for (k = 8; k < 64; k += 8)
760 {
761 if (datablock[k])
762 {
763 sgn_coeff = (datablock[k] > 0) ? 1 : -1;
764 temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
765 if (temp > 2047) temp = 2047; /* 03/14/01 */
766 else if (temp < -2048) temp = -2048;
767 datablock[k] = (int16) temp;
768 #ifdef FAST_IDCT
769 bitmapcol[0] |= mask[k>>3];
770 #endif
771 }
772 }
773 }
774 if (datablock[0])
775 {
776 #ifdef FAST_IDCT
777 bitmapcol[0] |= 128;
778 #endif
779
780 temp = (int32)datablock[0] * dc_scaler;
781 if (temp > 2047) temp = 2047; /* 03/14/01 */
782 else if (temp < -2048) temp = -2048;
783 datablock[0] = (int16)temp;
784 }
785
786
787 #ifdef FAST_IDCT
788 if (i > 10)
789 {
790 for (k = 1; k < 4; k++) /* if i > 10 then k = 0 does not matter */
791 {
792 if (bitmapcol[k] != 0)
793 {
794 (*bitmaprow) |= mask[k]; /* (1<<(7-i)); */
795 }
796 }
797 }
798 #endif
799
800 /* Store the qcoeff-values needed later for prediction */
801 (*DC)[comp] = datablock[0];
802 return i;
803 }
804
VlcDequantH263IntraBlock_SH(VideoDecData * video,int comp,uint8 * bitmapcol,uint8 * bitmaprow)805 int VlcDequantH263IntraBlock_SH(VideoDecData *video, int comp, uint8 *bitmapcol, uint8 *bitmaprow)
806 {
807 BitstreamDecVideo *stream = video->bitstream;
808 int16 *datablock = video->mblock->block[comp]; /*, 10/20/2000, assume it has been reset of all-zero !!!*/
809 int32 temp;
810 int mbnum = video->mbnum;
811 uint CBP = video->headerInfo.CBP[mbnum];
812 int16 QP = video->QPMB[mbnum];
813 typeDCStore *DC = video->predDC + mbnum;
814 int x_pos = video->mbnum_col;
815 typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
816 typeDCACStore *DCAC_col = video->predDCAC_col;
817 uint ACpred_flag = (uint) video->acPredFlag[mbnum];
818
819 /*** VLC *****/
820 int i, k;
821 Tcoef run_level;
822 int last, return_status;
823 VlcDecFuncP vlcDecCoeff;
824 #ifdef PV_ANNEX_IJKT_SUPPORT
825 int direction;
826 const int *inv_zigzag;
827 #endif
828 /*** Quantizer ****/
829
830
831
832 const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
833 const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
834
835 int16 *dcac_row, *dcac_col;
836
837 dcac_row = (*DCAC_row)[B_Xtab[comp]];
838 dcac_col = (*DCAC_col)[B_Ytab[comp]];
839 i = 1;
840
841 #ifdef FAST_IDCT
842 *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
843 *bitmaprow = 0;
844 #endif
845
846 /* select which Huffman table to be used */
847 vlcDecCoeff = video->vlcDecCoeffIntra;
848
849 #ifdef PV_ANNEX_IJKT_SUPPORT
850 if (comp > 3) /* ANNEX_T */
851 {
852 QP = video->QP_CHR;
853 }
854 if (!video->advanced_INTRA)
855 {
856 #endif
857
858 if ((CBP & (1 << (5 - comp))) == 0)
859 {
860 #ifdef FAST_IDCT
861 bitmapcol[0] = 128;
862 bitmapcol[1] = bitmapcol[2] = bitmapcol[3] = bitmapcol[4] = bitmapcol[5] = bitmapcol[6] = bitmapcol[7] = 0;
863 #endif
864 datablock[0] <<= 3; /* no need to clip */
865 return 1;//ncoeffs;
866 }
867 else
868 {
869 /* enter the zero run decoding loop */
870 do
871 {
872 return_status = (*vlcDecCoeff)(stream, &run_level);
873 if (return_status != PV_SUCCESS)
874 {
875 last = 1;/* 11/1/2000 let it slips undetected, just like
876 in original version */
877 i = VLC_ERROR;
878 break;
879 }
880
881 i += run_level.run;
882 last = run_level.last;
883 if (i >= 64)
884 {
885 /* i = NCOEFF_BLOCK; */ /* 11/1/00 */
886 i = VLC_NO_LAST_BIT;
887 last = 1;
888 break;
889 }
890 k = zigzag_inv[i];
891
892 if (run_level.sign == 0)
893 {
894 temp = (int32)QP * (2 * run_level.level + 1) - 1 + (QP & 1);
895 if (temp > 2047) temp = 2047;
896 }
897 else
898 {
899 temp = -(int32)QP * (2 * run_level.level + 1) + 1 - (QP & 1);
900 if (temp < -2048) temp = -2048;
901 }
902
903
904 datablock[k] = (int16) temp;
905
906 #ifdef FAST_IDCT
907 bitmapcol[k&0x7] |= mask[k>>3];
908 #endif
909 i++;
910 }
911 while (!last);
912
913 }
914 /* no ACDC prediction when ACDC disable */
915 if (datablock[0])
916 {
917 #ifdef FAST_IDCT
918 bitmapcol[0] |= 128;
919 #endif
920 datablock[0] <<= 3; /* no need to clip 09/18/2001 */
921 }
922 #ifdef PV_ANNEX_IJKT_SUPPORT
923 }
924 else /* advanced_INTRA mode */
925 {
926 i = 1;
927 doDCACPrediction_I(video, comp, datablock);
928 /* perform only VLC decoding */
929 if (!ACpred_flag)
930 {
931 direction = 0;
932 }
933 else
934 {
935 direction = video->mblock->direction;
936 }
937
938 inv_zigzag = zigzag_inv + (ACpred_flag << 6) + (direction << 6); /* 04/17/01 */
939
940 if (CBP & (1 << (5 - comp)))
941 {
942 i = 0;
943 do
944 {
945 return_status = (*vlcDecCoeff)(stream, &run_level);
946 if (return_status != PV_SUCCESS)
947 {
948 last = 1;/* 11/1/2000 let it slips undetected, just like
949 in original version */
950 i = VLC_ERROR;
951 ACpred_flag = 0; /* no of coefficients should not get reset 03/07/2002 */
952 break;
953 }
954
955 i += run_level.run;
956 last = run_level.last;
957 if (i >= 64)
958 {
959 /* i = NCOEFF_BLOCK; */ /* 11/1/00 */
960 ACpred_flag = 0; /* no of coefficients should not get reset 03/07/2002 */
961 i = VLC_NO_LAST_BIT;
962 last = 1;
963 break;
964 }
965
966 k = inv_zigzag[i];
967
968 if (run_level.sign == 0)
969 {
970 datablock[k] += (int16)QP * 2 * run_level.level;
971 if (datablock[k] > 2047) datablock[k] = 2047;
972 }
973 else
974 {
975 datablock[k] -= (int16)QP * 2 * run_level.level;
976 if (datablock[k] < -2048) datablock[k] = -2048;
977 }
978 #ifdef FAST_IDCT
979 bitmapcol[k&0x7] |= mask[k>>3];
980 #endif
981
982 i++;
983 }
984 while (!last);
985
986 }
987 ///// NEED TO DEQUANT THOSE PREDICTED AC COEFF
988 /* dequantize the rest of AC predicted coeff that haven't been dequant */
989
990 if (ACpred_flag)
991 {
992 i = NCOEFF_BLOCK;
993 for (k = 1; k < 8; k++)
994 {
995 if (datablock[k])
996 {
997 bitmapcol[k] |= 128;
998 }
999
1000 if (datablock[k<<3])
1001 {
1002 bitmapcol[0] |= mask[k];
1003 }
1004 }
1005 }
1006
1007 dcac_row[0] = datablock[1];
1008 dcac_row[1] = datablock[2];
1009 dcac_row[2] = datablock[3];
1010 dcac_row[3] = datablock[4];
1011 dcac_row[4] = datablock[5];
1012 dcac_row[5] = datablock[6];
1013 dcac_row[6] = datablock[7];
1014
1015 dcac_col[0] = datablock[8];
1016 dcac_col[1] = datablock[16];
1017 dcac_col[2] = datablock[24];
1018 dcac_col[3] = datablock[32];
1019 dcac_col[4] = datablock[40];
1020 dcac_col[5] = datablock[48];
1021 dcac_col[6] = datablock[56];
1022
1023 if (datablock[0])
1024 {
1025 #ifdef FAST_IDCT
1026 bitmapcol[0] |= 128;
1027 #endif
1028
1029 datablock[0] |= 1;
1030 if (datablock[0] < 0)
1031 {
1032 datablock[0] = 0;
1033 }
1034 }
1035 }
1036 #endif
1037
1038 #ifdef FAST_IDCT
1039 if (i > 10)
1040 {
1041 for (k = 1; k < 4; k++) /* if i > 10 then k = 0 does not matter */
1042 {
1043 if (bitmapcol[k] != 0)
1044 {
1045 (*bitmaprow) |= mask[k]; /* (1<<(7-i)); */
1046 }
1047 }
1048 }
1049 #endif
1050
1051 /* Store the qcoeff-values needed later for prediction */
1052 (*DC)[comp] = datablock[0];
1053 return i;
1054 }
1055
1056 /***********************************************************CommentBegin******
1057 *
1058 * -- VlcDequantInterH263Block -- Decodes the DCT coefficients of one 8x8 block and perform
1059 dequantization in H.263 mode for INTER block.
1060 Date: 08/08/2000
1061 Modified: 3/21/01
1062 clean up, added clipping, 16-bit int case
1063 ******************************************************************************/
1064
1065
VlcDequantH263InterBlock(VideoDecData * video,int comp,uint8 * bitmapcol,uint8 * bitmaprow)1066 int VlcDequantH263InterBlock(VideoDecData *video, int comp,
1067 uint8 *bitmapcol, uint8 *bitmaprow)
1068 {
1069 BitstreamDecVideo *stream = video->bitstream;
1070 int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
1071 int32 temp;
1072 int mbnum = video->mbnum;
1073 int QP = video->QPMB[mbnum];
1074
1075 /*** VLC *****/
1076 int i, k;
1077 Tcoef run_level;
1078 int last, return_status;
1079 VlcDecFuncP vlcDecCoeff;
1080
1081 /*** Quantizer ****/
1082
1083
1084 i = 0;
1085
1086 #ifdef FAST_IDCT
1087 *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
1088 *bitmaprow = 0;
1089 #endif
1090
1091 /* select which Huffman table to be used */
1092 vlcDecCoeff = video->vlcDecCoeffInter;
1093
1094 /* enter the zero run decoding loop */
1095 do
1096 {
1097 return_status = (*vlcDecCoeff)(stream, &run_level);
1098 if (return_status != PV_SUCCESS)
1099 {
1100
1101
1102 last = 1;/* 11/1/2000 let it slips undetected, just like
1103 in original version */
1104 i = -1;
1105 break;
1106 }
1107
1108 i += run_level.run;
1109 last = run_level.last;
1110 if (i >= 64)
1111 {
1112 i = -1;
1113 last = 1;
1114 break;
1115 }
1116
1117 if (run_level.sign == 0)
1118 {
1119 temp = (int32)QP * (2 * run_level.level + 1) - 1 + (QP & 1);
1120 if (temp > 2047) temp = 2047;
1121
1122 }
1123 else
1124 {
1125 temp = -(int32)QP * (2 * run_level.level + 1) + 1 - (QP & 1);
1126 if (temp < -2048) temp = -2048;
1127 }
1128
1129 k = zigzag_inv[i];
1130 datablock[k] = (int16)temp;
1131 #ifdef FAST_IDCT
1132 bitmapcol[k&0x7] |= mask[k>>3];
1133 #endif
1134 i++;
1135 }
1136 while (!last);
1137
1138 #ifdef FAST_IDCT
1139 if (i > 10) /* 07/19/01 */
1140 {
1141 for (k = 1; k < 4; k++) /* if (i > 10 ) k = 0 does not matter */
1142 {
1143 if (bitmapcol[k] != 0)
1144 {
1145 (*bitmaprow) |= mask[k]; /* (1<<(7-i)); */
1146 }
1147 }
1148 }
1149 #endif
1150 return i;
1151 }
1152
1153