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