src/gdcmmpeg2/src/mpeg2dec/getblk.c

   1 /* getblk.c, DCT block decoding                                             */
   2
   3 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
   4
   5 /*
   6  * Disclaimer of Warranty
   7  *
   8  * These software programs are available to the user without any license fee or
   9  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10  * any and all warranties, whether express, implied, or statuary, including any
  11  * implied warranties or merchantability or of fitness for a particular
  12  * purpose.  In no event shall the copyright-holder be liable for any
  13  * incidental, punitive, or consequential damages of any kind whatsoever
  14  * arising from the use of these programs.
  15  *
  16  * This disclaimer of warranty extends to the user of these programs and user's
  17  * customers, employees, agents, transferees, successors, and assigns.
  18  *
  19  * The MPEG Software Simulation Group does not represent or warrant that the
  20  * programs furnished hereunder are free of infringement of any third-party
  21  * patents.
  22  *
  23  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24  * are subject to royalty fees to patent holders.  Many of these patents are
  25  * general enough such that they are unavoidable regardless of implementation
  26  * design.
  27  *
  28  */
  29
  30 #include <stdio.h>
  31
  32 #include "config.h"
  33 #include "global.h"
  34
  35
  36 /* defined in getvlc.h */
  37 typedef struct {
  38   char run, level, len;
  39 } DCTtab;
  40
  41 extern DCTtab DCTtabfirst[],DCTtabnext[],DCTtab0[],DCTtab1[];
  42 extern DCTtab DCTtab2[],DCTtab3[],DCTtab4[],DCTtab5[],DCTtab6[];
  43 extern DCTtab DCTtab0a[],DCTtab1a[];
  44
  45
  46 /* decode one intra coded MPEG-1 block */
  47
  48 void Decode_MPEG1_Intra_Block(comp,dc_dct_pred)
  49 int comp;
  50 int dc_dct_pred[];
  51 {
  52   int val, i, j, sign;
  53   unsigned int code;
  54   DCTtab *tab;
  55   short *bp;
  56
  57   bp = ld->block[comp];
  58
  59   /* ISO/IEC 11172-2 section 2.4.3.7: Block layer. */
  60   /* decode DC coefficients */
  61   if (comp<4)
  62     bp[0] = (dc_dct_pred[0]+=Get_Luma_DC_dct_diff()) << 3;
  63   else if (comp==4)
  64     bp[0] = (dc_dct_pred[1]+=Get_Chroma_DC_dct_diff()) << 3;
  65   else
  66     bp[0] = (dc_dct_pred[2]+=Get_Chroma_DC_dct_diff()) << 3;
  67
  68   if (Fault_Flag) return;
  69
  70   /* D-pictures do not contain AC coefficients */
  71   if(picture_coding_type == D_TYPE)
  72     return;
  73
  74   /* decode AC coefficients */
  75   for (i=1; ; i++)
  76   {
  77     code = Show_Bits(16);
  78     if (code>=16384)
  79       tab = &DCTtabnext[(code>>12)-4];
  80     else if (code>=1024)
  81       tab = &DCTtab0[(code>>8)-4];
  82     else if (code>=512)
  83       tab = &DCTtab1[(code>>6)-8];
  84     else if (code>=256)
  85       tab = &DCTtab2[(code>>4)-16];
  86     else if (code>=128)
  87       tab = &DCTtab3[(code>>3)-16];
  88     else if (code>=64)
  89       tab = &DCTtab4[(code>>2)-16];
  90     else if (code>=32)
  91       tab = &DCTtab5[(code>>1)-16];
  92     else if (code>=16)
  93       tab = &DCTtab6[code-16];
  94     else
  95     {
  96       if (!Quiet_Flag)
  97         printf("invalid Huffman code in Decode_MPEG1_Intra_Block()\n");
  98       Fault_Flag = 1;
  99       return;
 100     }
 101
 102     Flush_Buffer(tab->len);
 103
 104     if (tab->run==64) /* end_of_block */
 105       return;
 106
 107     if (tab->run==65) /* escape */
 108     {
 109       i+= Get_Bits(6);
 110
 111       val = Get_Bits(8);
 112       if (val==0)
 113         val = Get_Bits(8);
 114       else if (val==128)
 115         val = Get_Bits(8) - 256;
 116       else if (val>128)
 117         val -= 256;
 118
 119       if((sign = (val<0)))
 120         val = -val;
 121     }
 122     else
 123     {
 124       i+= tab->run;
 125       val = tab->level;
 126       sign = Get_Bits(1);
 127     }
 128
 129     if (i>=64)
 130     {
 131       if (!Quiet_Flag)
 132         fprintf(stderr,"DCT coeff index (i) out of bounds (intra)\n");
 133       Fault_Flag = 1;
 134       return;
 135     }
 136
 137     j = scan[ZIG_ZAG][i];
 138     val = (val*ld->quantizer_scale*ld->intra_quantizer_matrix[j]) >> 3;
 139
 140     /* mismatch control ('oddification') */
 141     if (val!=0) /* should always be true, but it's not guaranteed */
 142       val = (val-1) | 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
 143
 144     /* saturation */
 145     if (!sign)
 146       bp[j] = (val>2047) ?  2047 :  val; /* positive */
 147     else
 148       bp[j] = (val>2048) ? -2048 : -val; /* negative */
 149   }
 150 }
 151
 152
 153 /* decode one non-intra coded MPEG-1 block */
 154
 155 void Decode_MPEG1_Non_Intra_Block(comp)
 156 int comp;
 157 {
 158   int val, i, j, sign;
 159   unsigned int code;
 160   DCTtab *tab;
 161   short *bp;
 162
 163   bp = ld->block[comp];
 164
 165   /* decode AC coefficients */
 166   for (i=0; ; i++)
 167   {
 168     code = Show_Bits(16);
 169     if (code>=16384)
 170     {
 171       if (i==0)
 172         tab = &DCTtabfirst[(code>>12)-4];
 173       else
 174         tab = &DCTtabnext[(code>>12)-4];
 175     }
 176     else if (code>=1024)
 177       tab = &DCTtab0[(code>>8)-4];
 178     else if (code>=512)
 179       tab = &DCTtab1[(code>>6)-8];
 180     else if (code>=256)
 181       tab = &DCTtab2[(code>>4)-16];
 182     else if (code>=128)
 183       tab = &DCTtab3[(code>>3)-16];
 184     else if (code>=64)
 185       tab = &DCTtab4[(code>>2)-16];
 186     else if (code>=32)
 187       tab = &DCTtab5[(code>>1)-16];
 188     else if (code>=16)
 189       tab = &DCTtab6[code-16];
 190     else
 191     {
 192       if (!Quiet_Flag)
 193         printf("invalid Huffman code in Decode_MPEG1_Non_Intra_Block()\n");
 194       Fault_Flag = 1;
 195       return;
 196     }
 197
 198     Flush_Buffer(tab->len);
 199
 200     if (tab->run==64) /* end_of_block */
 201       return;
 202
 203     if (tab->run==65) /* escape */
 204     {
 205       i+= Get_Bits(6);
 206
 207       val = Get_Bits(8);
 208       if (val==0)
 209         val = Get_Bits(8);
 210       else if (val==128)
 211         val = Get_Bits(8) - 256;
 212       else if (val>128)
 213         val -= 256;
 214
 215       if((sign = (val<0)))
 216         val = -val;
 217     }
 218     else
 219     {
 220       i+= tab->run;
 221       val = tab->level;
 222       sign = Get_Bits(1);
 223     }
 224
 225     if (i>=64)
 226     {
 227       if (!Quiet_Flag)
 228         fprintf(stderr,"DCT coeff index (i) out of bounds (inter)\n");
 229       Fault_Flag = 1;
 230       return;
 231     }
 232
 233     j = scan[ZIG_ZAG][i];
 234     val = (((val<<1)+1)*ld->quantizer_scale*ld->non_intra_quantizer_matrix[j]) >> 4;
 235
 236     /* mismatch control ('oddification') */
 237     if (val!=0) /* should always be true, but it's not guaranteed */
 238       val = (val-1) | 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
 239
 240     /* saturation */
 241     if (!sign)
 242       bp[j] = (val>2047) ?  2047 :  val; /* positive */
 243     else
 244       bp[j] = (val>2048) ? -2048 : -val; /* negative */
 245   }
 246 }
 247
 248
 249 /* decode one intra coded MPEG-2 block */
 250
 251 void Decode_MPEG2_Intra_Block(comp,dc_dct_pred)
 252 int comp;
 253 int dc_dct_pred[];
 254 {
 255   int val, i, j, sign, nc, cc, run;
 256   unsigned int code;
 257   DCTtab *tab;
 258   short *bp;
 259   int *qmat;
 260   struct layer_data *ld1;
 261
 262   /* with data partitioning, data always goes to base layer */
 263   ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
 264   bp = ld1->block[comp];
 265
 266   if (base.scalable_mode==SC_DP)
 267     if (base.priority_breakpoint<64)
 268       ld = &enhan;
 269     else
 270       ld = &base;
 271
 272   cc = (comp<4) ? 0 : (comp&1)+1;
 273
 274   qmat = (comp<4 || chroma_format==CHROMA420)
 275          ? ld1->intra_quantizer_matrix
 276          : ld1->chroma_intra_quantizer_matrix;
 277
 278   /* ISO/IEC 13818-2 section 7.2.1: decode DC coefficients */
 279   if (cc==0)
 280     val = (dc_dct_pred[0]+= Get_Luma_DC_dct_diff());
 281   else if (cc==1)
 282     val = (dc_dct_pred[1]+= Get_Chroma_DC_dct_diff());
 283   else
 284     val = (dc_dct_pred[2]+= Get_Chroma_DC_dct_diff());
 285
 286   if (Fault_Flag) return;
 287
 288   bp[0] = val << (3-intra_dc_precision);
 289
 290   nc=0;
 291
 292 #ifdef TRACE
 293   if (Trace_Flag)
 294     printf("DCT(%d)i:",comp);
 295 #endif /* TRACE */
 296
 297   /* decode AC coefficients */
 298   for (i=1; ; i++)
 299   {
 300     code = Show_Bits(16);
 301     if (code>=16384 && !intra_vlc_format)
 302       tab = &DCTtabnext[(code>>12)-4];
 303     else if (code>=1024)
 304     {
 305       if (intra_vlc_format)
 306         tab = &DCTtab0a[(code>>8)-4];
 307       else
 308         tab = &DCTtab0[(code>>8)-4];
 309     }
 310     else if (code>=512)
 311     {
 312       if (intra_vlc_format)
 313         tab = &DCTtab1a[(code>>6)-8];
 314       else
 315         tab = &DCTtab1[(code>>6)-8];
 316     }
 317     else if (code>=256)
 318       tab = &DCTtab2[(code>>4)-16];
 319     else if (code>=128)
 320       tab = &DCTtab3[(code>>3)-16];
 321     else if (code>=64)
 322       tab = &DCTtab4[(code>>2)-16];
 323     else if (code>=32)
 324       tab = &DCTtab5[(code>>1)-16];
 325     else if (code>=16)
 326       tab = &DCTtab6[code-16];
 327     else
 328     {
 329       if (!Quiet_Flag)
 330         printf("invalid Huffman code in Decode_MPEG2_Intra_Block()\n");
 331       Fault_Flag = 1;
 332       return;
 333     }
 334
 335     Flush_Buffer(tab->len);
 336
 337 #ifdef TRACE
 338     if (Trace_Flag)
 339     {
 340       printf(" (");
 341       Print_Bits(code,16,tab->len);
 342     }
 343 #endif /* TRACE */
 344
 345     if (tab->run==64) /* end_of_block */
 346     {
 347 #ifdef TRACE
 348       if (Trace_Flag)
 349         printf("): EOB\n");
 350 #endif /* TRACE */
 351       return;
 352     }
 353
 354     if (tab->run==65) /* escape */
 355     {
 356 #ifdef TRACE
 357       if (Trace_Flag)
 358       {
 359         putchar(' ');
 360         Print_Bits(Show_Bits(6),6,6);
 361       }
 362 #endif /* TRACE */
 363
 364       i+= run = Get_Bits(6);
 365
 366 #ifdef TRACE
 367       if (Trace_Flag)
 368       {
 369         putchar(' ');
 370         Print_Bits(Show_Bits(12),12,12);
 371       }
 372 #endif /* TRACE */
 373
 374       val = Get_Bits(12);
 375       if ((val&2047)==0)
 376       {
 377         if (!Quiet_Flag)
 378           printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
 379         Fault_Flag = 1;
 380         return;
 381       }
 382       if((sign = (val>=2048)))
 383         val = 4096 - val;
 384     }
 385     else
 386     {
 387       i+= run = tab->run;
 388       val = tab->level;
 389       sign = Get_Bits(1);
 390
 391 #ifdef TRACE
 392       if (Trace_Flag)
 393         printf("%d",sign);
 394 #endif /* TRACE */
 395     }
 396
 397     if (i>=64)
 398     {
 399       if (!Quiet_Flag)
 400         fprintf(stderr,"DCT coeff index (i) out of bounds (intra2)\n");
 401       Fault_Flag = 1;
 402       return;
 403     }
 404
 405 #ifdef TRACE
 406     if (Trace_Flag)
 407       printf("): %d/%d",run,sign ? -val : val);
 408 #endif /* TRACE */
 409
 410     j = scan[ld1->alternate_scan][i];
 411     val = (val * ld1->quantizer_scale * qmat[j]) >> 4;
 412     bp[j] = sign ? -val : val;
 413     nc++;
 414
 415     if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
 416       ld = &enhan;
 417   }
 418 }
 419
 420
 421 /* decode one non-intra coded MPEG-2 block */
 422
 423 void Decode_MPEG2_Non_Intra_Block(comp)
 424 int comp;
 425 {
 426   int val, i, j, sign, nc, run;
 427   unsigned int code;
 428   DCTtab *tab;
 429   short *bp;
 430   int *qmat;
 431   struct layer_data *ld1;
 432
 433   /* with data partitioning, data always goes to base layer */
 434   ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
 435   bp = ld1->block[comp];
 436
 437   if (base.scalable_mode==SC_DP)
 438     if (base.priority_breakpoint<64)
 439       ld = &enhan;
 440     else
 441       ld = &base;
 442
 443   qmat = (comp<4 || chroma_format==CHROMA420)
 444          ? ld1->non_intra_quantizer_matrix
 445          : ld1->chroma_non_intra_quantizer_matrix;
 446
 447   nc = 0;
 448
 449 #ifdef TRACE
 450   if (Trace_Flag)
 451     printf("DCT(%d)n:",comp);
 452 #endif /* TRACE */
 453
 454   /* decode AC coefficients */
 455   for (i=0; ; i++)
 456   {
 457     code = Show_Bits(16);
 458     if (code>=16384)
 459     {
 460       if (i==0)
 461         tab = &DCTtabfirst[(code>>12)-4];
 462       else
 463         tab = &DCTtabnext[(code>>12)-4];
 464     }
 465     else if (code>=1024)
 466       tab = &DCTtab0[(code>>8)-4];
 467     else if (code>=512)
 468       tab = &DCTtab1[(code>>6)-8];
 469     else if (code>=256)
 470       tab = &DCTtab2[(code>>4)-16];
 471     else if (code>=128)
 472       tab = &DCTtab3[(code>>3)-16];
 473     else if (code>=64)
 474       tab = &DCTtab4[(code>>2)-16];
 475     else if (code>=32)
 476       tab = &DCTtab5[(code>>1)-16];
 477     else if (code>=16)
 478       tab = &DCTtab6[code-16];
 479     else
 480     {
 481       if (!Quiet_Flag)
 482         printf("invalid Huffman code in Decode_MPEG2_Non_Intra_Block()\n");
 483       Fault_Flag = 1;
 484       return;
 485     }
 486
 487     Flush_Buffer(tab->len);
 488
 489 #ifdef TRACE
 490     if (Trace_Flag)
 491     {
 492       printf(" (");
 493       Print_Bits(code,16,tab->len);
 494     }
 495 #endif /* TRACE */
 496
 497     if (tab->run==64) /* end_of_block */
 498     {
 499 #ifdef TRACE
 500       if (Trace_Flag)
 501         printf("): EOB\n");
 502 #endif /* TRACE */
 503       return;
 504     }
 505
 506     if (tab->run==65) /* escape */
 507     {
 508 #ifdef TRACE
 509       if (Trace_Flag)
 510       {
 511         putchar(' ');
 512         Print_Bits(Show_Bits(6),6,6);
 513       }
 514 #endif /* TRACE */
 515
 516       i+= run = Get_Bits(6);
 517
 518 #ifdef TRACE
 519       if (Trace_Flag)
 520       {
 521         putchar(' ');
 522         Print_Bits(Show_Bits(12),12,12);
 523       }
 524 #endif /* TRACE */
 525
 526       val = Get_Bits(12);
 527       if ((val&2047)==0)
 528       {
 529         if (!Quiet_Flag)
 530           printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
 531         Fault_Flag = 1;
 532         return;
 533       }
 534       if((sign = (val>=2048)))
 535         val = 4096 - val;
 536     }
 537     else
 538     {
 539       i+= run = tab->run;
 540       val = tab->level;
 541       sign = Get_Bits(1);
 542
 543 #ifdef TRACE
 544       if (Trace_Flag)
 545         printf("%d",sign);
 546 #endif /* TRACE */
 547     }
 548
 549     if (i>=64)
 550     {
 551       if (!Quiet_Flag)
 552         fprintf(stderr,"DCT coeff index (i) out of bounds (inter2)\n");
 553       Fault_Flag = 1;
 554       return;
 555     }
 556
 557 #ifdef TRACE
 558     if (Trace_Flag)
 559       printf("): %d/%d",run,sign?-val:val);
 560 #endif /* TRACE */
 561
 562     j = scan[ld1->alternate_scan][i];
 563     val = (((val<<1)+1) * ld1->quantizer_scale * qmat[j]) >> 5;
 564     bp[j] = sign ? -val : val;
 565     nc++;
 566
 567     if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
 568       ld = &enhan;
 569   }
 570 }