mvvolvop.c

优化过的xvid1.1.2源代码

      mcbpc = get_mcbpc_intra(bs);
      mb->mode = mcbpc & 7;
      cbpc = (mcbpc >> 4);

      acpred_flag = BitstreamGetBit(bs);

      cbpy = get_cbpy(bs, 1);
      cbp = (cbpy << 2) | cbpc;

      if (mb->mode == MODE_INTRA_Q) {
        quant += dquant_table[BitstreamGetBits(bs, 2)];
        if (quant > 31) {
          quant = 31;
        } else if (quant < 1) {
          quant = 1;
        }
      }
      mb->quant = quant;
      mb->mvs[0].x = mb->mvs[0].y =
      mb->mvs[1].x = mb->mvs[1].y =
      mb->mvs[2].x = mb->mvs[2].y =
      mb->mvs[3].x = mb->mvs[3].y =0;

      if (dec->interlacing)
	  {
        mb->field_dct = BitstreamGetBit(bs);
      }

      decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
              intra_dc_threshold, bound);

    }
    
  }

}

void  decoder_pframe(DECODER * dec,
							        Bitstream * bs,
							        int rounding,
							        int quant,
							        int fcode,
							        int intra_dc_threshold,
							        const WARPPOINTS *const gmc_warp)
{
  uint32_t x, y;
  uint32_t bound;
  int cp_mb, st_mb;
  const uint32_t mb_width = dec->mb_width;
  const uint32_t mb_height = dec->mb_height;

  if (!dec->is_edged[0]) 
  {
    image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
            dec->width, dec->height, dec->bs_version);
    dec->is_edged[0] = 1;
  }

  if (gmc_warp)
  {
    generate_GMCparameters( dec->sprite_warping_points,
										        dec->sprite_warping_accuracy, gmc_warp,
										        dec->width, dec->height, &dec->new_gmc_data);

  }

  bound = 0;

  for (y = 0; y < mb_height; y++)
  {
    cp_mb = st_mb = 0;
    for (x = 0; x < mb_width; x++) 
    {
      MACROBLOCK *mb;
      if((y == 1)&&(x == 12))
		  y = y;

      /* skip stuffing */
      while (BitstreamShowBits(bs, 10) == 1)
             BitstreamSkip(bs, 10);

      if (check_resync_marker(bs, fcode - 1)) 
      {
        bound = read_video_packet_header(bs, dec, fcode - 1,
                                         &quant, &fcode, NULL, &intra_dc_threshold);
        x = bound % mb_width;
        y = bound / mb_width;
      }
      mb = &dec->mbs[y * dec->mb_width + x];

      if (!(BitstreamGetBit(bs)))
      { /* block _is_ coded */
        uint32_t mcbpc, cbpc, cbpy, cbp;
        uint32_t intra, acpred_flag = 0;
        int mcsel = 0;    /* mcsel: '0'=local motion, '1'=GMC */
        cp_mb++;
        mcbpc = get_mcbpc_inter(bs);
        mb->mode = mcbpc & 7;
        cbpc = (mcbpc >> 4);

       intra = (mb->mode == MODE_INTRA || mb->mode == MODE_INTRA_Q);

        if (gmc_warp && (mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q))
             mcsel = BitstreamGetBit(bs);
        else 
            if (intra)
                  acpred_flag = BitstreamGetBit(bs);

        cbpy = get_cbpy(bs, intra);
        cbp = (cbpy << 2) | cbpc;

        if (mb->mode == MODE_INTER_Q || mb->mode == MODE_INTRA_Q) 
        {
          int dquant = dquant_table[BitstreamGetBits(bs, 2)];
          quant += dquant;
             if (quant > 31) 
             {
                 quant = 31;
          		}
          		else 
          		   if(quant < 1) 
          		   {
                    quant = 1;
                 }
        }
        mb->quant = quant;
        mb->field_pred=0;
        if (dec->interlacing) 
        {
          if (cbp || intra) 
          {
            mb->field_dct = BitstreamGetBit(bs);
          }

          if ((mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) && !mcsel) 
          {
              mb->field_pred = BitstreamGetBit(bs);
              if (mb->field_pred) 
              {
                 mb->field_for_top = BitstreamGetBit(bs);
                 mb->field_for_bot = BitstreamGetBit(bs);
              }
          }
        }

        if (mcsel)
        {
          decoder_mbgmc(dec, mb, x, y, fcode, cbp, bs, rounding);
          continue;

        } 
        else
          if(mb->mode == MODE_INTER || mb->mode == MODE_INTER_Q) 
          {
             if(dec->interlacing) 
             {
                get_motion_vector_interlaced(dec, bs, x, y, 0, mb, fcode, bound);
             }
             else
             {
                get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
                mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];
             }
        	}
        	else
        	  if(mb->mode == MODE_INTER4V )
        	  {
               get_motion_vector(dec, bs, x, y, 0, &mb->mvs[0], fcode, bound);
          		 get_motion_vector(dec, bs, x, y, 1, &mb->mvs[1], fcode, bound);
          		 get_motion_vector(dec, bs, x, y, 2, &mb->mvs[2], fcode, bound);
               get_motion_vector(dec, bs, x, y, 3, &mb->mvs[3], fcode, bound);
            }
            else
            { /* MODE_INTRA, MODE_INTRA_Q */
              mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
              mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
          		decoder_mbintra(dec, mb, x, y, acpred_flag, cbp, bs, quant,
                              intra_dc_threshold, bound);
              continue;
            }

        /* See how to decode */
        if(!mb->field_pred)
             decoder_mbinter(dec, mb, x, y, cbp, bs, rounding, 0, 0);
        else 
              decoder_mbinter_field(dec, mb, x, y, cbp, bs, rounding, 0, 0);

      }
      else 
         if (gmc_warp)
         {  /* a not coded S(GMC)-VOP macroblock */
		        mb->mode = MODE_NOT_CODED_GMC;
		        mb->quant = quant;
		        decoder_mbgmc(dec, mb, x, y, fcode, 0x00, bs, rounding);
		
		        /*if(dec->out_frm && cp_mb > 0) 
		        {
		          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
		          cp_mb = 0;
		        }*/
		        st_mb = x+1;
		     }
		     else
		     { /* not coded P_VOP macroblock */
		        mb->mode = MODE_NOT_CODED;
		        mb->quant = quant;
		
		        mb->mvs[0].x = mb->mvs[1].x = mb->mvs[2].x = mb->mvs[3].x = 0;
		        mb->mvs[0].y = mb->mvs[1].y = mb->mvs[2].y = mb->mvs[3].y = 0;
		        mb->field_pred=0; /* (!) */
		
		        decoder_mbinter(dec, mb, x, y, 0, bs, 
		                        rounding, 0, 0);
		
		        /*if(dec->out_frm && cp_mb > 0) 
		        {
		          output_slice(&dec->cur, dec->edged_width,dec->width,dec->out_frm,st_mb,y,cp_mb);
		          cp_mb = 0;
		        }*/
		        st_mb = x+1;
        }
    }

  }
}

void decoder_bframe(DECODER * dec,
						        Bitstream * bs,
						        int quant,
						        int fcode_forward,
						        int fcode_backward)
{
  uint32_t x, y;
  VECTOR mv;
  const VECTOR zeromv = {0,0};
  int i;

  if (!dec->is_edged[0]) {
    image_setedges(&dec->refn[0], dec->edged_width, dec->edged_height,
            dec->width, dec->height, dec->bs_version);
    dec->is_edged[0] = 1;
    }

  if (!dec->is_edged[1]) {
    image_setedges(&dec->refn[1], dec->edged_width, dec->edged_height,
            dec->width, dec->height, dec->bs_version);
    dec->is_edged[1] = 1;
   }

  for (y = 0; y < dec->mb_height; y++) {
    /* Initialize Pred Motion Vector */
    dec->p_fmv = dec->p_bmv = zeromv;
    for (x = 0; x < dec->mb_width; x++) {
      MACROBLOCK *mb = &dec->mbs[y * dec->mb_width + x];
      MACROBLOCK *last_mb = &dec->last_mbs[y * dec->mb_width + x];
      const int fcode_max = (fcode_forward>fcode_backward) ? fcode_forward : fcode_backward;
      int intra_dc_threshold; /* fake variable */
     
      if (check_resync_marker(bs, fcode_max  - 1)) {
        int bound = read_video_packet_header(bs, dec, fcode_max - 1, &quant,
                           &fcode_forward, &fcode_backward, &intra_dc_threshold);
        x = bound % dec->mb_width;
        y = bound / dec->mb_width;
        /* reset predicted macroblocks */
        dec->p_fmv = dec->p_bmv = zeromv;
      }

      mv =
      mb->b_mvs[0] = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] =
      mb->mvs[0] = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = zeromv;
      mb->quant = quant;

      /*
       * skip if the co-located P_VOP macroblock is not coded
       * if not codec in co-located S_VOP macroblock is _not_
       * automatically skipped
       */

      if (last_mb->mode == MODE_NOT_CODED) {
        mb->cbp = 0;
        mb->mode = MODE_FORWARD;
        decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
        continue;
      }

      if (!BitstreamGetBit(bs)) { /* modb=='0' */
        const uint8_t modb2 = BitstreamGetBit(bs);

        mb->mode = get_mbtype(bs);

        if (!modb2)   /* modb=='00' */
          mb->cbp = BitstreamGetBits(bs, 6);
        else
          mb->cbp = 0;

        if (mb->mode && mb->cbp) {
          quant += get_dbquant(bs);
          if (quant > 31)
            quant = 31;
          else if (quant < 1)
            quant = 1;
        }
        mb->quant = quant;

        if (dec->interlacing) {
          if (mb->cbp) {
            mb->field_dct = BitstreamGetBit(bs);
            
          }

          if (mb->mode) {
            mb->field_pred = BitstreamGetBit(bs);
            if (mb->field_pred) {
              mb->field_for_top = BitstreamGetBit(bs);
              mb->field_for_bot = BitstreamGetBit(bs);
              }
          }
        }

      } else {
        mb->mode = MODE_DIRECT_NONE_MV;
        mb->cbp = 0;
      }

      switch (mb->mode) {
      case MODE_DIRECT:
        get_b_motion_vector(bs, &mv, 1, zeromv, dec, x, y);

      case MODE_DIRECT_NONE_MV:
        for (i = 0; i < 4; i++) {
          mb->mvs[i].x = last_mb->mvs[i].x*dec->time_bp/dec->time_pp + mv.x;
          mb->mvs[i].y = last_mb->mvs[i].y*dec->time_bp/dec->time_pp + mv.y;

          mb->b_mvs[i].x = (mv.x)
            ?  mb->mvs[i].x - last_mb->mvs[i].x
            : last_mb->mvs[i].x*(dec->time_bp - dec->time_pp)/dec->time_pp;
          mb->b_mvs[i].y = (mv.y)
            ? mb->mvs[i].y - last_mb->mvs[i].y
            : last_mb->mvs[i].y*(dec->time_bp - dec->time_pp)/dec->time_pp;
        }

        decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
                        mb, x, y, bs, 1);
        break;

      case MODE_INTERPOLATE:
        get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
        dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];

        get_b_motion_vector(bs, &mb->b_mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
        dec->p_bmv = mb->b_mvs[1] = mb->b_mvs[2] = mb->b_mvs[3] = mb->b_mvs[0];

        decoder_bf_interpolate_mbinter(dec, dec->refn[1], dec->refn[0],
                      mb, x, y, bs, 0);
        break;

      case MODE_BACKWARD:
        get_b_motion_vector(bs, &mb->mvs[0], fcode_backward, dec->p_bmv, dec, x, y);
        dec->p_bmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];

        decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 0, 1);
        break;

      case MODE_FORWARD:
        get_b_motion_vector(bs, &mb->mvs[0], fcode_forward, dec->p_fmv, dec, x, y);
        dec->p_fmv = mb->mvs[1] = mb->mvs[2] = mb->mvs[3] = mb->mvs[0];

        decoder_mbinter(dec, mb, x, y, mb->cbp, bs, 0, 1, 1);
        break;

      default:
        break;
      }
    } /* End of for */
  }
}