getpic.c
上传用户:hkgotone
上传日期:2013-02-17
资源大小:293k
文件大小:33k
源码类别:

Windows Mobile

开发平台:

C/C++

  1. /* getpic.c, picture decoding                                               */
  2. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  27. #include <stdio.h>
  28. #include "config.h"
  29. #include "global.h"
  30. /* private prototypes*/
  31. static void picture_data _ANSI_ARGS_((int framenum));
  32. static void macroblock_modes _ANSI_ARGS_((int *pmacroblock_type, int *pstwtype,
  33.   int *pstwclass, int *pmotion_type, int *pmotion_vector_count, int *pmv_format, int *pdmv,
  34.   int *pmvscale, int *pdct_type));
  35. static void Clear_Block _ANSI_ARGS_((int comp));
  36. static void Sum_Block _ANSI_ARGS_((int comp));
  37. static void Saturate _ANSI_ARGS_((short *bp));
  38. static void Add_Block _ANSI_ARGS_((int comp, int bx, int by,
  39.   int dct_type, int addflag));
  40. static void Update_Picture_Buffers _ANSI_ARGS_((void));
  41. static void frame_reorder _ANSI_ARGS_((int bitstream_framenum, 
  42.   int sequence_framenum));
  43. static void Decode_SNR_Macroblock _ANSI_ARGS_((int *SNRMBA, int *SNRMBAinc, 
  44.   int MBA, int MBAmax, int *dct_type));
  45. static void motion_compensation _ANSI_ARGS_((int MBA, int macroblock_type, 
  46.  int motion_type, int PMV[2][2][2], int motion_vertical_field_select[2][2], 
  47.  int dmvector[2], int stwtype, int dct_type));
  48. static void skipped_macroblock _ANSI_ARGS_((int dc_dct_pred[3], 
  49.   int PMV[2][2][2], int *motion_type, int motion_vertical_field_select[2][2],
  50.   int *stwtype, int *macroblock_type));
  51. static int slice _ANSI_ARGS_((int framenum, int MBAmax));
  52. static int start_of_slice _ANSI_ARGS_ ((int MBAmax, int *MBA,
  53.   int *MBAinc, int dc_dct_pred[3], int PMV[2][2][2]));
  54. static int decode_macroblock _ANSI_ARGS_((int *macroblock_type, 
  55.   int *stwtype, int *stwclass, int *motion_type, int *dct_type,
  56.   int PMV[2][2][2], int dc_dct_pred[3], 
  57.   int motion_vertical_field_select[2][2], int dmvector[2]));
  58. /* decode one frame or field picture */
  59. void Decode_Picture(bitstream_framenum, sequence_framenum)
  60. int bitstream_framenum, sequence_framenum;
  61. {
  62.   if (picture_structure==FRAME_PICTURE && Second_Field)
  63.   {
  64.     /* recover from illegal number of field pictures */
  65.     printf("odd number of field picturesn");
  66.     Second_Field = 0;
  67.   }
  68.   /* IMPLEMENTATION: update picture buffer pointers */
  69.   Update_Picture_Buffers();
  70. #ifdef VERIFY 
  71.   Check_Headers(bitstream_framenum, sequence_framenum);
  72. #endif /* VERIFY */
  73.   /* ISO/IEC 13818-4 section 2.4.5.4 "frame buffer intercept method" */
  74.   /* (section number based on November 1995 (Dallas) draft of the 
  75.       conformance document) */
  76.   if(Ersatz_Flag)
  77.     Substitute_Frame_Buffer(bitstream_framenum, sequence_framenum);
  78.   /* form spatial scalable picture */
  79.  
  80.   /* form spatial scalable picture */
  81.   /* ISO/IEC 13818-2 section 7.7: Spatial scalability */
  82.   if (base.pict_scal && !Second_Field) 
  83.   {
  84.     Spatial_Prediction();
  85.   }
  86.   /* decode picture data ISO/IEC 13818-2 section 6.2.3.7 */
  87.   picture_data(bitstream_framenum);
  88.   /* write or display current or previously decoded reference frame */
  89.   /* ISO/IEC 13818-2 section 6.1.1.11: Frame reordering */
  90.   frame_reorder(bitstream_framenum, sequence_framenum);
  91.   if (picture_structure!=FRAME_PICTURE)
  92.     Second_Field = !Second_Field;
  93. }
  94. /* decode all macroblocks of the current picture */
  95. /* stages described in ISO/IEC 13818-2 section 7 */
  96. static void picture_data(framenum)
  97. int framenum;
  98. {
  99.   int MBAmax;
  100.   int ret;
  101.   /* number of macroblocks per picture */
  102.   MBAmax = mb_width*mb_height;
  103.   if (picture_structure!=FRAME_PICTURE)
  104.     MBAmax>>=1; /* field picture has half as mnay macroblocks as frame */
  105.   for(;;)
  106.   {
  107.     if((ret=slice(framenum, MBAmax))<0)
  108.       return;
  109.   }
  110. }
  111. /* decode all macroblocks of the current picture */
  112. /* ISO/IEC 13818-2 section 6.3.16 */
  113. static int slice(framenum, MBAmax)
  114. int framenum, MBAmax;
  115. {
  116.   int MBA; 
  117.   int MBAinc, macroblock_type, motion_type, dct_type;
  118.   int dc_dct_pred[3];
  119.   int PMV[2][2][2], motion_vertical_field_select[2][2];
  120.   int dmvector[2];
  121.   int stwtype, stwclass;
  122.   int SNRMBA, SNRMBAinc;
  123.   int ret;
  124.   MBA = 0; /* macroblock address */
  125.   MBAinc = 0;
  126.   if((ret=start_of_slice(MBAmax, &MBA, &MBAinc, dc_dct_pred, PMV))!=1)
  127.     return(ret);
  128.   if (Two_Streams && enhan.scalable_mode==SC_SNR)
  129.   {
  130.     SNRMBA=0;
  131.     SNRMBAinc=0;
  132.   }
  133.   Fault_Flag=0;
  134.   for (;;)
  135.   {
  136.     /* this is how we properly exit out of picture */
  137.     if (MBA>=MBAmax)
  138.       return(-1); /* all macroblocks decoded */
  139. #ifdef TRACE
  140.     if (Trace_Flag)
  141.       printf("frame %d, MB %dn",framenum,MBA);
  142. #endif /* TRACE */
  143. #ifdef DISPLAY
  144.     if (!progressive_frame && picture_structure==FRAME_PICTURE 
  145.       && MBA==(MBAmax>>1) && framenum!=0 && Output_Type==T_X11 
  146.        && !Display_Progressive_Flag)
  147.     {
  148.       Display_Second_Field();
  149.     }
  150. #endif
  151.     ld = &base;
  152.     if (MBAinc==0)
  153.     {
  154.       if (base.scalable_mode==SC_DP && base.priority_breakpoint==1)
  155.           ld = &enhan;
  156.       if (!Show_Bits(23) || Fault_Flag) /* next_start_code or fault */
  157.       {
  158. resync: /* if Fault_Flag: resynchronize to next next_start_code */
  159.         Fault_Flag = 0;
  160.         return(0);     /* trigger: go to next slice */
  161.       }
  162.       else /* neither next_start_code nor Fault_Flag */
  163.       {
  164.         if (base.scalable_mode==SC_DP && base.priority_breakpoint==1)
  165.           ld = &enhan;
  166.         /* decode macroblock address increment */
  167.         MBAinc = Get_macroblock_address_increment();
  168.         if (Fault_Flag) goto resync;
  169.       }
  170.     }
  171.     if (MBA>=MBAmax)
  172.     {
  173.       /* MBAinc points beyond picture dimensions */
  174.       if (!Quiet_Flag)
  175.         printf("Too many macroblocks in picturen");
  176.       return(-1);
  177.     }
  178.     if (MBAinc==1) /* not skipped */
  179.     {
  180.       ret = decode_macroblock(&macroblock_type, &stwtype, &stwclass,
  181.               &motion_type, &dct_type, PMV, dc_dct_pred, 
  182.               motion_vertical_field_select, dmvector);
  183.       if(ret==-1)
  184.         return(-1);
  185.    
  186.       if(ret==0)
  187.         goto resync;
  188.     }
  189.     else /* MBAinc!=1: skipped macroblock */
  190.     {      
  191.       /* ISO/IEC 13818-2 section 7.6.6 */
  192.       skipped_macroblock(dc_dct_pred, PMV, &motion_type, 
  193.         motion_vertical_field_select, &stwtype, &macroblock_type);
  194.     }
  195.     /* SCALABILITY: SNR */
  196.     /* ISO/IEC 13818-2 section 7.8 */
  197.     /* NOTE: we currently ignore faults encountered in this routine */
  198.     if (Two_Streams && enhan.scalable_mode==SC_SNR)
  199.       Decode_SNR_Macroblock(&SNRMBA, &SNRMBAinc, MBA, MBAmax, &dct_type);
  200.     /* ISO/IEC 13818-2 section 7.6 */
  201.     motion_compensation(MBA, macroblock_type, motion_type, PMV, 
  202.       motion_vertical_field_select, dmvector, stwtype, dct_type);
  203.     /* advance to next macroblock */
  204.     MBA++;
  205.     MBAinc--;
  206.  
  207.     /* SCALABILITY: SNR */
  208.     if (Two_Streams && enhan.scalable_mode==SC_SNR)
  209.     {
  210.       SNRMBA++;
  211.       SNRMBAinc--;
  212.     }
  213.     if (MBA>=MBAmax)
  214.       return(-1); /* all macroblocks decoded */
  215.   }
  216. }
  217.  
  218. /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
  219. static void macroblock_modes(pmacroblock_type,pstwtype,pstwclass,
  220.   pmotion_type,pmotion_vector_count,pmv_format,pdmv,pmvscale,pdct_type)
  221.   int *pmacroblock_type, *pstwtype, *pstwclass;
  222.   int *pmotion_type, *pmotion_vector_count, *pmv_format, *pdmv, *pmvscale;
  223.   int *pdct_type;
  224. {
  225.   int macroblock_type;
  226.   int stwtype, stwcode, stwclass;
  227.   int motion_type = 0;
  228.   int motion_vector_count, mv_format, dmv, mvscale;
  229.   int dct_type;
  230.   static unsigned char stwc_table[3][4]
  231.     = { {6,3,7,4}, {2,1,5,4}, {2,5,7,4} };
  232.   static unsigned char stwclass_table[9]
  233.     = {0, 1, 2, 1, 1, 2, 3, 3, 4};
  234.   /* get macroblock_type */
  235.   macroblock_type = Get_macroblock_type();
  236.   if (Fault_Flag) return;
  237.   /* get spatial_temporal_weight_code */
  238.   if (macroblock_type & MB_WEIGHT)
  239.   {
  240.     if (spatial_temporal_weight_code_table_index==0)
  241.       stwtype = 4;
  242.     else
  243.     {
  244.       stwcode = Get_Bits(2);
  245. #ifdef TRACE
  246.       if (Trace_Flag)
  247.       {
  248.         printf("spatial_temporal_weight_code (");
  249.         Print_Bits(stwcode,2,2);
  250.         printf("): %dn",stwcode);
  251.       }
  252. #endif /* TRACE */
  253.       stwtype = stwc_table[spatial_temporal_weight_code_table_index-1][stwcode];
  254.     }
  255.   }
  256.   else
  257.     stwtype = (macroblock_type & MB_CLASS4) ? 8 : 0;
  258.   /* SCALABILITY: derive spatial_temporal_weight_class (Table 7-18) */
  259.   stwclass = stwclass_table[stwtype];
  260.   /* get frame/field motion type */
  261.   if (macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD))
  262.   {
  263.     if (picture_structure==FRAME_PICTURE) /* frame_motion_type */
  264.     {
  265.       motion_type = frame_pred_frame_dct ? MC_FRAME : Get_Bits(2);
  266. #ifdef TRACE
  267.       if (!frame_pred_frame_dct && Trace_Flag)
  268.       {
  269.         printf("frame_motion_type (");
  270.         Print_Bits(motion_type,2,2);
  271.         printf("): %sn",motion_type==MC_FIELD?"Field":
  272.                          motion_type==MC_FRAME?"Frame":
  273.                          motion_type==MC_DMV?"Dual_Prime":"Invalid");
  274.       }
  275. #endif /* TRACE */
  276.     }
  277.     else /* field_motion_type */
  278.     {
  279.       motion_type = Get_Bits(2);
  280. #ifdef TRACE
  281.       if (Trace_Flag)
  282.       {
  283.         printf("field_motion_type (");
  284.         Print_Bits(motion_type,2,2);
  285.         printf("): %sn",motion_type==MC_FIELD?"Field":
  286.                          motion_type==MC_16X8?"16x8 MC":
  287.                          motion_type==MC_DMV?"Dual_Prime":"Invalid");
  288.       }
  289. #endif /* TRACE */
  290.     }
  291.   }
  292.   else if ((macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
  293.   {
  294.     /* concealment motion vectors */
  295.     motion_type = (picture_structure==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
  296.   }
  297. #if 0
  298.   else
  299.   {
  300.     printf("maroblock_modes(): unknown macroblock typen");
  301.     motion_type = -1;
  302.   }
  303. #endif
  304.   /* derive motion_vector_count, mv_format and dmv, (table 6-17, 6-18) */
  305.   if (picture_structure==FRAME_PICTURE)
  306.   {
  307.     motion_vector_count = (motion_type==MC_FIELD && stwclass<2) ? 2 : 1;
  308.     mv_format = (motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
  309.   }
  310.   else
  311.   {
  312.     motion_vector_count = (motion_type==MC_16X8) ? 2 : 1;
  313.     mv_format = MV_FIELD;
  314.   }
  315.   dmv = (motion_type==MC_DMV); /* dual prime */
  316.   /* field mv predictions in frame pictures have to be scaled
  317.    * ISO/IEC 13818-2 section 7.6.3.1 Decoding the motion vectors
  318.    * IMPLEMENTATION: mvscale is derived for later use in motion_vectors()
  319.    * it displaces the stage:
  320.    *
  321.    *    if((mv_format=="field")&&(t==1)&&(picture_structure=="Frame picture"))
  322.    *      prediction = PMV[r][s][t] DIV 2;
  323.    */
  324.   mvscale = ((mv_format==MV_FIELD) && (picture_structure==FRAME_PICTURE));
  325.   /* get dct_type (frame DCT / field DCT) */
  326.   dct_type = (picture_structure==FRAME_PICTURE)
  327.              && (!frame_pred_frame_dct)
  328.              && (macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA))
  329.              ? Get_Bits(1)
  330.              : 0;
  331. #ifdef TRACE
  332.   if (Trace_Flag  && (picture_structure==FRAME_PICTURE)
  333.              && (!frame_pred_frame_dct)
  334.              && (macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA)))
  335.     printf("dct_type (%d): %sn",dct_type,dct_type?"Field":"Frame");
  336. #endif /* TRACE */
  337.   /* return values */
  338.   *pmacroblock_type = macroblock_type;
  339.   *pstwtype = stwtype;
  340.   *pstwclass = stwclass;
  341.   *pmotion_type = motion_type;
  342.   *pmotion_vector_count = motion_vector_count;
  343.   *pmv_format = mv_format;
  344.   *pdmv = dmv;
  345.   *pmvscale = mvscale;
  346.   *pdct_type = dct_type;
  347. }
  348. /* move/add 8x8-Block from block[comp] to backward_reference_frame */
  349. /* copy reconstructed 8x8 block from block[comp] to current_frame[]
  350.  * ISO/IEC 13818-2 section 7.6.8: Adding prediction and coefficient data
  351.  * This stage also embodies some of the operations implied by:
  352.  *   - ISO/IEC 13818-2 section 7.6.7: Combining predictions
  353.  *   - ISO/IEC 13818-2 section 6.1.3: Macroblock
  354. */
  355. static void Add_Block(comp,bx,by,dct_type,addflag)
  356. int comp,bx,by,dct_type,addflag;
  357. {
  358.   int cc,i, j, iincr;
  359.   unsigned char *rfp;
  360.   short *bp;
  361.   
  362.   /* derive color component index */
  363.   /* equivalent to ISO/IEC 13818-2 Table 7-1 */
  364.   cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */
  365.   if (cc==0)
  366.   {
  367.     /* luminance */
  368.     if (picture_structure==FRAME_PICTURE)
  369.       if (dct_type)
  370.       {
  371.         /* field DCT coding */
  372.         rfp = current_frame[0]
  373.               + Coded_Picture_Width*(by+((comp&2)>>1)) + bx + ((comp&1)<<3);
  374.         iincr = (Coded_Picture_Width<<1) - 8;
  375.       }
  376.       else
  377.       {
  378.         /* frame DCT coding */
  379.         rfp = current_frame[0]
  380.               + Coded_Picture_Width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  381.         iincr = Coded_Picture_Width - 8;
  382.       }
  383.     else
  384.     {
  385.       /* field picture */
  386.       rfp = current_frame[0]
  387.             + (Coded_Picture_Width<<1)*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  388.       iincr = (Coded_Picture_Width<<1) - 8;
  389.     }
  390.   }
  391.   else
  392.   {
  393.     /* chrominance */
  394.     /* scale coordinates */
  395.     if (chroma_format!=CHROMA444)
  396.       bx >>= 1;
  397.     if (chroma_format==CHROMA420)
  398.       by >>= 1;
  399.     if (picture_structure==FRAME_PICTURE)
  400.     {
  401.       if (dct_type && (chroma_format!=CHROMA420))
  402.       {
  403.         /* field DCT coding */
  404.         rfp = current_frame[cc]
  405.               + Chroma_Width*(by+((comp&2)>>1)) + bx + (comp&8);
  406.         iincr = (Chroma_Width<<1) - 8;
  407.       }
  408.       else
  409.       {
  410.         /* frame DCT coding */
  411.         rfp = current_frame[cc]
  412.               + Chroma_Width*(by+((comp&2)<<2)) + bx + (comp&8);
  413.         iincr = Chroma_Width - 8;
  414.       }
  415.     }
  416.     else
  417.     {
  418.       /* field picture */
  419.       rfp = current_frame[cc]
  420.             + (Chroma_Width<<1)*(by+((comp&2)<<2)) + bx + (comp&8);
  421.       iincr = (Chroma_Width<<1) - 8;
  422.     }
  423.   }
  424.   bp = ld->block[comp];
  425.   if (addflag)
  426.   {
  427.     for (i=0; i<8; i++)
  428.     {
  429.       for (j=0; j<8; j++)
  430.       {
  431.         *rfp = Clip[*bp++ + *rfp];
  432.         rfp++;
  433.       }
  434.       rfp+= iincr;
  435.     }
  436.   }
  437.   else
  438.   {
  439.     for (i=0; i<8; i++)
  440.     {
  441.       for (j=0; j<8; j++)
  442.         *rfp++ = Clip[*bp++ + 128];
  443.       rfp+= iincr;
  444.     }
  445.   }
  446. }
  447. /* ISO/IEC 13818-2 section 7.8 */
  448. static void Decode_SNR_Macroblock(SNRMBA, SNRMBAinc, MBA, MBAmax, dct_type)
  449.   int *SNRMBA, *SNRMBAinc;
  450.   int MBA, MBAmax;
  451.   int *dct_type;
  452. {
  453.   int SNRmacroblock_type, SNRcoded_block_pattern, SNRdct_type, dummy; 
  454.   int slice_vert_pos_ext, quantizer_scale_code, comp, code;
  455.   ld = &enhan;
  456.   if (*SNRMBAinc==0)
  457.   {
  458.     if (!Show_Bits(23)) /* next_start_code */
  459.     {
  460.       next_start_code();
  461.       code = Show_Bits(32);
  462.       if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
  463.       {
  464.         /* only slice headers are allowed in picture_data */
  465.         if (!Quiet_Flag)
  466.           printf("SNR: Premature end of picturen");
  467.         return;
  468.       }
  469.       Flush_Buffer32();
  470.       /* decode slice header (may change quantizer_scale) */
  471.       slice_vert_pos_ext = slice_header();
  472.       /* decode macroblock address increment */
  473.       *SNRMBAinc = Get_macroblock_address_increment();
  474.       /* set current location */
  475.       *SNRMBA =
  476.         ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + *SNRMBAinc - 1;
  477.       *SNRMBAinc = 1; /* first macroblock in slice: not skipped */
  478.     }
  479.     else /* not next_start_code */
  480.     {
  481.       if (*SNRMBA>=MBAmax)
  482.       {
  483.         if (!Quiet_Flag)
  484.           printf("Too many macroblocks in picturen");
  485.         return;
  486.       }
  487.       /* decode macroblock address increment */
  488.       *SNRMBAinc = Get_macroblock_address_increment();
  489.     }
  490.   }
  491.   if (*SNRMBA!=MBA)
  492.   {
  493.     /* streams out of sync */
  494.     if (!Quiet_Flag)
  495.       printf("Cant't synchronize streamsn");
  496.     return;
  497.   }
  498.   if (*SNRMBAinc==1) /* not skipped */
  499.   {
  500.     macroblock_modes(&SNRmacroblock_type, &dummy, &dummy,
  501.       &dummy, &dummy, &dummy, &dummy, &dummy,
  502.       &SNRdct_type);
  503.     if (SNRmacroblock_type & MACROBLOCK_PATTERN)
  504.       *dct_type = SNRdct_type;
  505.     if (SNRmacroblock_type & MACROBLOCK_QUANT)
  506.     {
  507.       quantizer_scale_code = Get_Bits(5);
  508.       ld->quantizer_scale =
  509.         ld->q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] : quantizer_scale_code<<1;
  510.     }
  511.     /* macroblock_pattern */
  512.     if (SNRmacroblock_type & MACROBLOCK_PATTERN)
  513.     {
  514.       SNRcoded_block_pattern = Get_coded_block_pattern();
  515.       if (chroma_format==CHROMA422)
  516.         SNRcoded_block_pattern = (SNRcoded_block_pattern<<2) | Get_Bits(2); /* coded_block_pattern_1 */
  517.       else if (chroma_format==CHROMA444)
  518.         SNRcoded_block_pattern = (SNRcoded_block_pattern<<6) | Get_Bits(6); /* coded_block_pattern_2 */
  519.     }
  520.     else
  521.       SNRcoded_block_pattern = 0;
  522.     /* decode blocks */
  523.     for (comp=0; comp<block_count; comp++)
  524.     {
  525.       Clear_Block(comp);
  526.       if (SNRcoded_block_pattern & (1<<(block_count-1-comp)))
  527.         Decode_MPEG2_Non_Intra_Block(comp);
  528.     }
  529.   }
  530.   else /* SNRMBAinc!=1: skipped macroblock */
  531.   {
  532.     for (comp=0; comp<block_count; comp++)
  533.       Clear_Block(comp);
  534.   }
  535.   ld = &base;
  536. }
  537. /* IMPLEMENTATION: set scratch pad macroblock to zero */
  538. static void Clear_Block(comp)
  539. int comp;
  540. {
  541.   short *Block_Ptr;
  542.   int i;
  543.   Block_Ptr = ld->block[comp];
  544.   for (i=0; i<64; i++)
  545.     *Block_Ptr++ = 0;
  546. }
  547. /* SCALABILITY: add SNR enhancement layer block data to base layer */
  548. /* ISO/IEC 13818-2 section 7.8.3.4: Addition of coefficients from the two layes */
  549. static void Sum_Block(comp)
  550. int comp;
  551. {
  552.   short *Block_Ptr1, *Block_Ptr2;
  553.   int i;
  554.   Block_Ptr1 = base.block[comp];
  555.   Block_Ptr2 = enhan.block[comp];
  556.   for (i=0; i<64; i++)
  557.     *Block_Ptr1++ += *Block_Ptr2++;
  558. }
  559. /* limit coefficients to -2048..2047 */
  560. /* ISO/IEC 13818-2 section 7.4.3 and 7.4.4: Saturation and Mismatch control */
  561. static void Saturate(Block_Ptr)
  562. short *Block_Ptr;
  563. {
  564.   int i, sum, val;
  565.   sum = 0;
  566.   /* ISO/IEC 13818-2 section 7.4.3: Saturation */
  567.   for (i=0; i<64; i++)
  568.   {
  569.     val = Block_Ptr[i];
  570.     if (val>2047)
  571.       val = 2047;
  572.     else if (val<-2048)
  573.       val = -2048;
  574.     Block_Ptr[i] = val;
  575.     sum+= val;
  576.   }
  577.   /* ISO/IEC 13818-2 section 7.4.4: Mismatch control */
  578.   if ((sum&1)==0)
  579.     Block_Ptr[63]^= 1;
  580. }
  581. /* reuse old picture buffers as soon as they are no longer needed 
  582.    based on life-time axioms of MPEG */
  583. static void Update_Picture_Buffers()
  584. {                           
  585.   int cc;              /* color component index */
  586.   unsigned char *tmp;  /* temporary swap pointer */
  587.   for (cc=0; cc<3; cc++)
  588.   {
  589.     /* B pictures do not need to be save for future reference */
  590.     if (picture_coding_type==B_TYPE)
  591.     {
  592.       current_frame[cc] = auxframe[cc];
  593.     }
  594.     else
  595.     {
  596.       /* only update at the beginning of the coded frame */
  597.       if (!Second_Field)
  598.       {
  599.         tmp = forward_reference_frame[cc];
  600.         /* the previously decoded reference frame is stored
  601.            coincident with the location where the backward 
  602.            reference frame is stored (backwards prediction is not
  603.            needed in P pictures) */
  604.         forward_reference_frame[cc] = backward_reference_frame[cc];
  605.         
  606.         /* update pointer for potential future B pictures */
  607.         backward_reference_frame[cc] = tmp;
  608.       }
  609.       /* can erase over old backward reference frame since it is not used
  610.          in a P picture, and since any subsequent B pictures will use the 
  611.          previously decoded I or P frame as the backward_reference_frame */
  612.       current_frame[cc] = backward_reference_frame[cc];
  613.     }
  614.     /* IMPLEMENTATION:
  615.        one-time folding of a line offset into the pointer which stores the
  616.        memory address of the current frame saves offsets and conditional 
  617.        branches throughout the remainder of the picture processing loop */
  618.     if (picture_structure==BOTTOM_FIELD)
  619.       current_frame[cc]+= (cc==0) ? Coded_Picture_Width : Chroma_Width;
  620.   }
  621. }
  622. /* store last frame */
  623. void Output_Last_Frame_of_Sequence(Framenum)
  624. int Framenum;
  625. {
  626.   if (Second_Field)
  627.     printf("last frame incomplete, not storedn");
  628.   else
  629.     Write_Frame(backward_reference_frame,Framenum-1);
  630. }
  631. static void frame_reorder(Bitstream_Framenum, Sequence_Framenum)
  632. int Bitstream_Framenum, Sequence_Framenum;
  633. {
  634.   /* tracking variables to insure proper output in spatial scalability */
  635.   static int Oldref_progressive_frame, Newref_progressive_frame;
  636.   if (Sequence_Framenum!=0)
  637.   {
  638.     if (picture_structure==FRAME_PICTURE || Second_Field)
  639.     {
  640.       if (picture_coding_type==B_TYPE)
  641.         Write_Frame(auxframe,Bitstream_Framenum-1);
  642.       else
  643.       {
  644.         Newref_progressive_frame = progressive_frame;
  645.         progressive_frame = Oldref_progressive_frame;
  646.         Write_Frame(forward_reference_frame,Bitstream_Framenum-1);
  647.         Oldref_progressive_frame = progressive_frame = Newref_progressive_frame;
  648.       }
  649.     }
  650. #ifdef DISPLAY
  651.     else if (Output_Type==T_X11)
  652.     {
  653.       if(!Display_Progressive_Flag)
  654.         Display_Second_Field();
  655.     }
  656. #endif
  657.   }
  658.   else
  659.     Oldref_progressive_frame = progressive_frame;
  660. }
  661. /* ISO/IEC 13818-2 section 7.6 */
  662. static void motion_compensation(MBA, macroblock_type, motion_type, PMV, 
  663.   motion_vertical_field_select, dmvector, stwtype, dct_type)
  664. int MBA;
  665. int macroblock_type;
  666. int motion_type;
  667. int PMV[2][2][2];
  668. int motion_vertical_field_select[2][2];
  669. int dmvector[2];
  670. int stwtype;
  671. int dct_type;
  672. {
  673.   int bx, by;
  674.   int comp;
  675.   /* derive current macroblock position within picture */
  676.   /* ISO/IEC 13818-2 section 6.3.1.6 and 6.3.1.7 */
  677.   bx = 16*(MBA%mb_width);
  678.   by = 16*(MBA/mb_width);
  679.   /* motion compensation */
  680.   if (!(macroblock_type & MACROBLOCK_INTRA))
  681.     form_predictions(bx,by,macroblock_type,motion_type,PMV,
  682.       motion_vertical_field_select,dmvector,stwtype);
  683.   
  684.   /* SCALABILITY: Data Partitioning */
  685.   if (base.scalable_mode==SC_DP)
  686.     ld = &base;
  687.   /* copy or add block data into picture */
  688.   for (comp=0; comp<block_count; comp++)
  689.   {
  690.     /* SCALABILITY: SNR */
  691.     /* ISO/IEC 13818-2 section 7.8.3.4: Addition of coefficients from 
  692.        the two a layers */
  693.     if (Two_Streams && enhan.scalable_mode==SC_SNR)
  694.       Sum_Block(comp); /* add SNR enhancement layer data to base layer */
  695.     /* MPEG-2 saturation and mismatch control */
  696.     /* base layer could be MPEG-1 stream, enhancement MPEG-2 SNR */
  697.     /* ISO/IEC 13818-2 section 7.4.3 and 7.4.4: Saturation and Mismatch control */
  698.     if ((Two_Streams && enhan.scalable_mode==SC_SNR) || ld->MPEG2_Flag)
  699.       Saturate(ld->block[comp]);
  700.     /* ISO/IEC 13818-2 section Annex A: inverse DCT */
  701.     if (Reference_IDCT_Flag)
  702.       Reference_IDCT(ld->block[comp]);
  703.     else
  704.       Fast_IDCT(ld->block[comp]);
  705.     
  706.     /* ISO/IEC 13818-2 section 7.6.8: Adding prediction and coefficient data */
  707.     Add_Block(comp,bx,by,dct_type,(macroblock_type & MACROBLOCK_INTRA)==0);
  708.   }
  709. }
  710. /* ISO/IEC 13818-2 section 7.6.6 */
  711. static void skipped_macroblock(dc_dct_pred, PMV, motion_type, 
  712.   motion_vertical_field_select, stwtype, macroblock_type)
  713. int dc_dct_pred[3];
  714. int PMV[2][2][2];
  715. int *motion_type;
  716. int motion_vertical_field_select[2][2];
  717. int *stwtype;
  718. int *macroblock_type;
  719. {
  720.   int comp;
  721.   
  722.   /* SCALABILITY: Data Paritioning */
  723.   if (base.scalable_mode==SC_DP)
  724.     ld = &base;
  725.   for (comp=0; comp<block_count; comp++)
  726.     Clear_Block(comp);
  727.   /* reset intra_dc predictors */
  728.   /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  729.   dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  730.   /* reset motion vector predictors */
  731.   /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  732.   if (picture_coding_type==P_TYPE)
  733.     PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  734.   /* derive motion_type */
  735.   if (picture_structure==FRAME_PICTURE)
  736.     *motion_type = MC_FRAME;
  737.   else
  738.   {
  739.     *motion_type = MC_FIELD;
  740.     /* predict from field of same parity */
  741.     /* ISO/IEC 13818-2 section 7.6.6.1 and 7.6.6.3: P field picture and B field
  742.        picture */
  743.     motion_vertical_field_select[0][0]=motion_vertical_field_select[0][1] = 
  744.       (picture_structure==BOTTOM_FIELD);
  745.   }
  746.   /* skipped I are spatial-only predicted, */
  747.   /* skipped P and B are temporal-only predicted */
  748.   /* ISO/IEC 13818-2 section 7.7.6: Skipped macroblocks */
  749.   *stwtype = (picture_coding_type==I_TYPE) ? 8 : 0;
  750.  /* IMPLEMENTATION: clear MACROBLOCK_INTRA */
  751.   *macroblock_type&= ~MACROBLOCK_INTRA;
  752. }
  753. /* return==-1 means go to next picture */
  754. /* the expression "start of slice" is used throughout the normative
  755.    body of the MPEG specification */
  756. static int start_of_slice(MBAmax, MBA, MBAinc, 
  757.   dc_dct_pred, PMV)
  758. int MBAmax;
  759. int *MBA;
  760. int *MBAinc;
  761. int dc_dct_pred[3];
  762. int PMV[2][2][2];
  763. {
  764.   unsigned int code;
  765.   int slice_vert_pos_ext;
  766.   ld = &base;
  767.   Fault_Flag = 0;
  768.   next_start_code();
  769.   code = Show_Bits(32);
  770.   if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
  771.   {
  772.     /* only slice headers are allowed in picture_data */
  773.     if (!Quiet_Flag)
  774.       printf("start_of_slice(): Premature end of picturen");
  775.     return(-1);  /* trigger: go to next picture */
  776.   }
  777.   Flush_Buffer32(); 
  778.   /* decode slice header (may change quantizer_scale) */
  779.   slice_vert_pos_ext = slice_header();
  780.  
  781.   /* SCALABILITY: Data Partitioning */
  782.   if (base.scalable_mode==SC_DP)
  783.   {
  784.     ld = &enhan;
  785.     next_start_code();
  786.     code = Show_Bits(32);
  787.     if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
  788.     {
  789.       /* only slice headers are allowed in picture_data */
  790.       if (!Quiet_Flag)
  791.         printf("DP: Premature end of picturen");
  792.       return(-1);    /* trigger: go to next picture */
  793.     }
  794.     Flush_Buffer32();
  795.     /* decode slice header (may change quantizer_scale) */
  796.     slice_vert_pos_ext = slice_header();
  797.     if (base.priority_breakpoint!=1)
  798.       ld = &base;
  799.   }
  800.   /* decode macroblock address increment */
  801.   *MBAinc = Get_macroblock_address_increment();
  802.   if (Fault_Flag) 
  803.   {
  804.     printf("start_of_slice(): MBAinc unsuccessfuln");
  805.     return(0);   /* trigger: go to next slice */
  806.   }
  807.   /* set current location */
  808.   /* NOTE: the arithmetic used to derive macroblock_address below is
  809.    *       equivalent to ISO/IEC 13818-2 section 6.3.17: Macroblock
  810.    */
  811.   *MBA = ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + *MBAinc - 1;
  812.   *MBAinc = 1; /* first macroblock in slice: not skipped */
  813.   /* reset all DC coefficient and motion vector predictors */
  814.   /* reset all DC coefficient and motion vector predictors */
  815.   /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  816.   dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  817.   
  818.   /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  819.   PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  820.   PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  821.   /* successfull: trigger decode macroblocks in slice */
  822.   return(1);
  823. }
  824. /* ISO/IEC 13818-2 sections 7.2 through 7.5 */
  825. static int decode_macroblock(macroblock_type, stwtype, stwclass,
  826.   motion_type, dct_type, PMV, dc_dct_pred, 
  827.   motion_vertical_field_select, dmvector)
  828. int *macroblock_type; 
  829. int *stwtype;
  830. int *stwclass;
  831. int *motion_type; 
  832. int *dct_type;
  833. int PMV[2][2][2]; 
  834. int dc_dct_pred[3]; 
  835. int motion_vertical_field_select[2][2];
  836. int dmvector[2];
  837. {
  838.   /* locals */
  839.   int quantizer_scale_code; 
  840.   int comp;
  841.   int motion_vector_count; 
  842.   int mv_format; 
  843.   int dmv; 
  844.   int mvscale;
  845.   int coded_block_pattern;
  846.   /* SCALABILITY: Data Patitioning */
  847.   if (base.scalable_mode==SC_DP)
  848.   {
  849.     if (base.priority_breakpoint<=2)
  850.       ld = &enhan;
  851.     else
  852.       ld = &base;
  853.   }
  854.   /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
  855.   macroblock_modes(macroblock_type, stwtype, stwclass,
  856.     motion_type, &motion_vector_count, &mv_format, &dmv, &mvscale,
  857.     dct_type);
  858.   if (Fault_Flag) return(0);  /* trigger: go to next slice */
  859.   if (*macroblock_type & MACROBLOCK_QUANT)
  860.   {
  861.     quantizer_scale_code = Get_Bits(5);
  862. #ifdef TRACE
  863.     if (Trace_Flag)
  864.     {
  865.       printf("quantiser_scale_code (");
  866.       Print_Bits(quantizer_scale_code,5,5);
  867.       printf("): %dn",quantizer_scale_code);
  868.     }
  869. #endif /* TRACE */
  870.     /* ISO/IEC 13818-2 section 7.4.2.2: Quantizer scale factor */
  871.     if (ld->MPEG2_Flag)
  872.       ld->quantizer_scale =
  873.       ld->q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] 
  874.        : (quantizer_scale_code << 1);
  875.     else
  876.       ld->quantizer_scale = quantizer_scale_code;
  877.     /* SCALABILITY: Data Partitioning */
  878.     if (base.scalable_mode==SC_DP)
  879.       /* make sure base.quantizer_scale is valid */
  880.       base.quantizer_scale = ld->quantizer_scale;
  881.   }
  882.   /* motion vectors */
  883.   /* ISO/IEC 13818-2 section 6.3.17.2: Motion vectors */
  884.   /* decode forward motion vectors */
  885.   if ((*macroblock_type & MACROBLOCK_MOTION_FORWARD) 
  886.     || ((*macroblock_type & MACROBLOCK_INTRA) 
  887.     && concealment_motion_vectors))
  888.   {
  889.     if (ld->MPEG2_Flag)
  890.       motion_vectors(PMV,dmvector,motion_vertical_field_select,
  891.         0,motion_vector_count,mv_format,f_code[0][0]-1,f_code[0][1]-1,
  892.         dmv,mvscale);
  893.     else
  894.       motion_vector(PMV[0][0],dmvector,
  895.       forward_f_code-1,forward_f_code-1,0,0,full_pel_forward_vector);
  896.   }
  897.   if (Fault_Flag) return(0);  /* trigger: go to next slice */
  898.   /* decode backward motion vectors */
  899.   if (*macroblock_type & MACROBLOCK_MOTION_BACKWARD)
  900.   {
  901.     if (ld->MPEG2_Flag)
  902.       motion_vectors(PMV,dmvector,motion_vertical_field_select,
  903.         1,motion_vector_count,mv_format,f_code[1][0]-1,f_code[1][1]-1,0,
  904.         mvscale);
  905.     else
  906.       motion_vector(PMV[0][1],dmvector,
  907.         backward_f_code-1,backward_f_code-1,0,0,full_pel_backward_vector);
  908.   }
  909.   if (Fault_Flag) return(0);  /* trigger: go to next slice */
  910.   if ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
  911.     Flush_Buffer(1); /* remove marker_bit */
  912.   if (base.scalable_mode==SC_DP && base.priority_breakpoint==3)
  913.     ld = &enhan;
  914.   /* macroblock_pattern */
  915.   /* ISO/IEC 13818-2 section 6.3.17.4: Coded block pattern */
  916.   if (*macroblock_type & MACROBLOCK_PATTERN)
  917.   {
  918.     coded_block_pattern = Get_coded_block_pattern();
  919.     if (chroma_format==CHROMA422)
  920.     {
  921.       /* coded_block_pattern_1 */
  922.       coded_block_pattern = (coded_block_pattern<<2) | Get_Bits(2); 
  923. #ifdef TRACE
  924.        if (Trace_Flag)
  925.        {
  926.          printf("coded_block_pattern_1: ");
  927.          Print_Bits(coded_block_pattern,2,2);
  928.          printf(" (%d)n",coded_block_pattern&3);
  929.        }
  930. #endif /* TRACE */
  931.      }
  932.      else if (chroma_format==CHROMA444)
  933.      {
  934.       /* coded_block_pattern_2 */
  935.       coded_block_pattern = (coded_block_pattern<<6) | Get_Bits(6); 
  936. #ifdef TRACE
  937.       if (Trace_Flag)
  938.       {
  939.         printf("coded_block_pattern_2: ");
  940.         Print_Bits(coded_block_pattern,6,6);
  941.         printf(" (%d)n",coded_block_pattern&63);
  942.       }
  943. #endif /* TRACE */
  944.     }
  945.   }
  946.   else
  947.     coded_block_pattern = (*macroblock_type & MACROBLOCK_INTRA) ? 
  948.       (1<<block_count)-1 : 0;
  949.   if (Fault_Flag) return(0);  /* trigger: go to next slice */
  950.   /* decode blocks */
  951.   for (comp=0; comp<block_count; comp++)
  952.   {
  953.     /* SCALABILITY: Data Partitioning */
  954.     if (base.scalable_mode==SC_DP)
  955.     ld = &base;
  956.     Clear_Block(comp);
  957.     if (coded_block_pattern & (1<<(block_count-1-comp)))
  958.     {
  959.       if (*macroblock_type & MACROBLOCK_INTRA)
  960.       {
  961.         if (ld->MPEG2_Flag)
  962.           Decode_MPEG2_Intra_Block(comp,dc_dct_pred);
  963.         else
  964.           Decode_MPEG1_Intra_Block(comp,dc_dct_pred);
  965.       }
  966.       else
  967.       {
  968.         if (ld->MPEG2_Flag)
  969.           Decode_MPEG2_Non_Intra_Block(comp);
  970.         else
  971.           Decode_MPEG1_Non_Intra_Block(comp);
  972.       }
  973.       if (Fault_Flag) return(0);  /* trigger: go to next slice */
  974.     }
  975.   }
  976.   if(picture_coding_type==D_TYPE)
  977.   {
  978.     /* remove end_of_macroblock (always 1, prevents startcode emulation) */
  979.     /* ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
  980.     marker_bit("D picture end_of_macroblock bit");
  981.   }
  982.   /* reset intra_dc predictors */
  983.   /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  984.   if (!(*macroblock_type & MACROBLOCK_INTRA))
  985.     dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  986.   /* reset motion vector predictors */
  987.   if ((*macroblock_type & MACROBLOCK_INTRA) && !concealment_motion_vectors)
  988.   {
  989.     /* intra mb without concealment motion vectors */
  990.     /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  991.     PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  992.     PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  993.   }
  994.   /* special "No_MC" macroblock_type case */
  995.   /* ISO/IEC 13818-2 section 7.6.3.5: Prediction in P pictures */
  996.   if ((picture_coding_type==P_TYPE) 
  997.     && !(*macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_INTRA)))
  998.   {
  999.     /* non-intra mb without forward mv in a P picture */
  1000.     /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  1001.     PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  1002.     /* derive motion_type */
  1003.     /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes, frame_motion_type */
  1004.     if (picture_structure==FRAME_PICTURE)
  1005.       *motion_type = MC_FRAME;
  1006.     else
  1007.     {
  1008.       *motion_type = MC_FIELD;
  1009.       /* predict from field of same parity */
  1010.       motion_vertical_field_select[0][0] = (picture_structure==BOTTOM_FIELD);
  1011.     }
  1012.   }
  1013.   if (*stwclass==4)
  1014.   {
  1015.     /* purely spatially predicted macroblock */
  1016.     /* ISO/IEC 13818-2 section 7.7.5.1: Resetting motion vector predictions */
  1017.     PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  1018.     PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  1019.   }
  1020.   /* successfully decoded macroblock */
  1021.   return(1);
  1022. } /* decode_macroblock */