rdopt.c

包含了从MPEG4的视频解码到H.264的视频编码部分的源代码

        if (img->type==BS_IMG)
        {
          bwMV [0][by][bx] = all_bmv[i][j][bw_ref][mode8][0];
          bwMV [1][by][bx] = all_bmv[i][j][bw_ref][mode8][1];
          mv   [0][by][bx] = 0;
          mv   [1][by][bx] = 0;
        }
        else
        {
          bwMV [0][by][bx] = all_bmv[i][j][   0][mode8][0];
          bwMV [1][by][bx] = all_bmv[i][j][   0][mode8][1];
        }
        dfMV     [0][by][bx] = 0;
        dfMV     [1][by][bx] = 0;
        dbMV     [0][by][bx] = 0;
        dbMV     [1][by][bx] = 0;
      }
      else if (mode8!=0) // bidirect
      {
        fwMV [0][by][bx] = all_mv [i][j][ ref][mode8][0];
        fwMV [1][by][bx] = all_mv [i][j][ ref][mode8][1];
        if (img->type==BS_IMG)
        {
          bwMV [0][by][bx] = all_bmv[i][j][bw_ref][mode8][0];
          bwMV [1][by][bx] = all_bmv[i][j][bw_ref][mode8][1];
          mv   [0][by][bx] = all_mv [i][j][ref][mode8][0];
          mv   [1][by][bx] = all_mv [i][j][ref][mode8][1];
        }
        else
        {
          bwMV [0][by][bx] = all_bmv[i][j][   0][mode8][0];
          bwMV [1][by][bx] = all_bmv[i][j][   0][mode8][1];
        }
        dfMV     [0][by][bx] = 0;
        dfMV     [1][by][bx] = 0;
        dbMV     [0][by][bx] = 0;
        dbMV     [1][by][bx] = 0;
      }
      else // direct
      {
        if(img->type==BS_IMG)
        {
          fwMV [0][by][bx] = dfMV     [0][by][bx] = all_mv [i][j][max(0,fwdir_refFrArr[by][bxr])][    0][0];
          fwMV [1][by][bx] = dfMV     [1][by][bx] = all_mv [i][j][max(0,fwdir_refFrArr[by][bxr])][    0][1];
          if(bwdir_refFrArr[by][bxr]==-1)
          {
            bwMV [0][by][bx] = dbMV     [0][by][bx] = all_bmv[i][j][                             1][    0][0];
            bwMV [1][by][bx] = dbMV     [1][by][bx] = all_bmv[i][j][                             1][    0][1];
          }
          else
          {
            bwMV [0][by][bx] = dbMV     [0][by][bx] = all_bmv[i][j][bwdir_refFrArr[by][bxr]][    0][0];
            bwMV [1][by][bx] = dbMV     [1][by][bx] = all_bmv[i][j][bwdir_refFrArr[by][bxr]][    0][1];
          }
          mv   [0][by][bx] = fwMV [0][by][bx];
          mv   [1][by][bx] = fwMV [1][by][bx];
        }
        else
        {
          if (input->direct_type)
            dref = max(0,fwdir_refFrArr[by][bxr]);        
          else
            dref = max(0,refar[by][bxr]);        

          fwMV [0][by][bx] = dfMV     [0][by][bx] = all_mv [i][j][dref][    0][0];
          fwMV [1][by][bx] = dfMV     [1][by][bx] = all_mv [i][j][dref][    0][1];
          bwMV [0][by][bx] = dbMV     [0][by][bx] = all_bmv[i][j][   0][    0][0];
          bwMV [1][by][bx] = dbMV     [1][by][bx] = all_bmv[i][j][   0][    0][1];
        }
      }

      if(img->type==BS_IMG)
      {
        if(input->InterlaceCodingOption >= MB_CODING && mb_adaptive)
        {
          rdopt->tmp_mv[0][j][i]  = mv[0][by][bx];
          rdopt->tmp_mv[1][j][i]  = mv[1][by][bx];
        }
      }
      if(input->InterlaceCodingOption >= MB_CODING && mb_adaptive)
      {
        rdopt->tmp_fwMV[0][j][i]  = fwMV[0][by][bx];
        rdopt->tmp_fwMV[1][j][i]  = fwMV[1][by][bx];
        rdopt->tmp_bwMV[0][j][i]  = bwMV[0][by][bx];
        rdopt->tmp_bwMV[1][j][i]  = bwMV[1][by][bx];
        rdopt->dfMV[0][j][i] = dfMV     [0][by][bx];
        rdopt->dfMV[1][j][i] = dfMV     [1][by][bx];                  
        rdopt->dbMV[0][j][i] = dbMV     [0][by][bx];
        rdopt->dbMV[1][j][i] = dbMV     [1][by][bx];                  
      }
    }
  }

// copy all the motion vectors into rdopt structure
// Can simplify this by copying the MV's of the best mode (TBD)

  if(input->InterlaceCodingOption >= MB_CODING && mb_adaptive)
  {
    for(i=0;i<4;i++)
      for(j=0;j<4;j++)
        for(k=0;k<img->buf_cycle;k++)
          for(l=0;l<9;l++)
          {
            rdopt->all_mv[i][j][k][l][0] = all_mv[i][j][k][l][0];
            rdopt->all_bmv[i][j][k][l][0] = all_bmv[i][j][k][l][0];
            rdopt->p_fwMV[i][j][k][l][0] = p_fwMV[i][j][k][l][0];
            rdopt->p_bwMV[i][j][k][l][0] = p_bwMV[i][j][k][l][0];
            rdopt->mv[i][j][k][l][0]    = imgmv[i][j][k][l][0];
          
            rdopt->all_mv[i][j][k][l][1] = all_mv[i][j][k][l][1];
            rdopt->all_bmv[i][j][k][l][1] =all_bmv[i][j][k][l][1];
            rdopt->p_fwMV[i][j][k][l][1] = p_fwMV[i][j][k][l][1];
            rdopt->p_bwMV[i][j][k][l][1] = p_bwMV[i][j][k][l][1];
            rdopt->mv[i][j][k][l][1]    = imgmv[i][j][k][l][1];
          }
  }

}



/*! 
 *************************************************************************************
 * \brief
 *    R-D Cost for a macroblock
 *************************************************************************************
 */
int RDCost_for_macroblocks (double   lambda,      // <-- lagrange multiplier
                        int      mode,        // <-- modus (0-COPY/DIRECT, 1-16x16, 2-16x8, 3-8x16, 4-8x8(+), 5-Intra4x4, 6-Intra16x16)
                        double*  min_rdcost)  // <-> minimum rate-distortion cost
{
  int         i, j, k; //, k, ****ip4;
  int         i16mode, rate=0, distortion=0;
  double      rdcost;
  Macroblock  *currMB   = &img->mb_data[img->current_mb_nr];
  int         bframe    = (img->type==B_IMG || img->type==BS_IMG);
  int         tmp_cc;
  int         use_of_cc =  (img->type!=INTRA_IMG &&  input->symbol_mode!=CABAC);
  int         cc_rate, dummy;
  byte        **imgY_orig = imgY_org;
  byte        ***imgUV_orig = imgUV_org;
  int         pix_y = img->pix_y;
  int         pix_c_y = img->pix_c_y;

  if(input->InterlaceCodingOption >= MB_CODING && mb_adaptive && img->field_mode)
  {
    pix_y = img->field_pix_y;
    pix_c_y = img->field_pix_c_y;
    imgY_orig = img->top_field ? imgY_org_top:imgY_org_bot;
    imgUV_orig = img->top_field ? imgUV_org_top:imgUV_org_bot;
  }


  //=====
  //=====  SET REFERENCE FRAMES AND BLOCK MODES
  //=====
  SetModesAndRefframeForBlocks (mode);

  //=====
  //=====  GET COEFFICIENTS, RECONSTRUCTIONS, CBP
  //=====
  if (mode<P8x8)
  {
    LumaResidualCoding ();
  }
  else if (mode==P8x8)
  {
    SetCoeffAndReconstruction8x8 (currMB);
  }
  else if (mode==I4MB)
  {
    currMB->cbp = Mode_Decision_for_Intra4x4Macroblock (lambda, &dummy);
  }
  else if (mode==I16MB)
  {
    Intra16x16_Mode_Decision  (currMB, &i16mode);
  }

  if (input->rdopt==2 && img->type!=B_IMG)
  {
    // We need the reconstructed prediction residue for the simulated decoders.
    compute_residue_mb (mode==I16MB?i16mode:-1);
  }

  img->i16offset = 0;
  dummy = 0;
  ChromaResidualCoding (&dummy);
  if (mode==I16MB)     img->i16offset = I16Offset  (currMB->cbp, i16mode);


  //=====
  //=====   GET DISTORTION
  //=====
  // LUMA
  if (input->rdopt==2 && img->type!=B_IMG)
  {
    for (k=0; k<input->NoOfDecoders ;k++)
    {
      decode_one_mb (k, currMB);
      for (j=0; j<MB_BLOCK_SIZE; j++)
      for (i=img->pix_x; i<img->pix_x+MB_BLOCK_SIZE; i++)
      {
        distortion += img->quad [imgY_orig[pix_y+j][i] - decs->decY[k][img->pix_y+j][i]];
      }
    }
    distortion /= input->NoOfDecoders;
  }
  else
  {
    for (j=0; j<16; j++)
    for (i=img->pix_x; i<img->pix_x+16; i++)
    {
      distortion += img->quad [imgY_orig[j+pix_y][i] - imgY[img->pix_y+j][i]];
    }
  }

  // CHROMA
  for (j=0; j<8; j++)
  for (i=img->pix_c_x; i<img->pix_c_x+8; i++)
  {
    distortion += img->quad [imgUV_orig[0][j+pix_c_y][i] - imgUV[0][img->pix_c_y+j][i]];
    distortion += img->quad [imgUV_orig[1][j+pix_c_y][i] - imgUV[1][img->pix_c_y+j][i]];
  }


  //=====   S T O R E   C O D I N G   S T A T E   =====
  //---------------------------------------------------
  store_coding_state (cs_cm);
  

  //=====
  //=====   GET RATE
  //=====
  //----- macroblock header -----
  if (use_of_cc)
  {
    if (currMB->mb_type!=0 || (bframe && currMB->cbp!=0))
    {
      // cod counter and macroblock mode are written ==> do not consider code counter
      tmp_cc = img->cod_counter;
      rate   = writeMBHeader (1); 
      ue_linfo (tmp_cc, dummy, &cc_rate, &dummy);
      rate  -= cc_rate;
      img->cod_counter = tmp_cc;
    }
    else
    {
      // cod counter is just increased  ==> get additional rate
      ue_linfo (img->cod_counter+1, dummy, &rate,    &dummy);
      ue_linfo (img->cod_counter,   dummy, &cc_rate, &dummy);
      rate -= cc_rate;
    }
  }
  else
  {
    rate = writeMBHeader (1); 
  }
  if (mode)
  {
    //----- motion information -----
    rate  += writeMotionInfo2NAL  ();
  }
  if (mode || (bframe && (currMB->cbp!=0 || input->symbol_mode==CABAC)))
  {
    rate  += writeCBPandLumaCoeff ();

    rate  += writeChromaCoeff     ();
  }


  //=====   R E S T O R E   C O D I N G   S T A T E   =====
  //-------------------------------------------------------
  reset_coding_state (cs_cm);


  rdcost = (double)distortion + lambda * (double)rate;
 
  if (rdcost >= *min_rdcost)
  {
    return 0;
  }


  if(input->InterlaceCodingOption >= MB_CODING && mb_adaptive && img->field_mode && mode == 0)
  {
    if(!bframe && TopFieldIsSkipped)
      return 0;
    else if(bframe && TopFieldIsSkipped && currMB->cbp == 0)
      return 0;
  }


  //=====   U P D A T E   M I N I M U M   C O S T   =====
  //-----------------------------------------------------
  *min_rdcost = rdcost;
 
  return 1;
}




/*! 
 *************************************************************************************
 * \brief
 *    Store macroblock parameters
 *************************************************************************************
 */
void store_macroblock_parameters (int mode)
{
  int  i, j, k, ****i4p, ***i3p;
  Macroblock *currMB  = &img->mb_data[img->current_mb_nr];
  int        bframe   = (img->type==B_IMG || img->type==BS_IMG);
  int        **frefar = ((img->type==B_IMG || img->type==BS_IMG)? fw_refFrArr : refFrArr);
  int        **abp_type_arr = abp_type_FrArr;
  int        **brefar = bw_refFrArr;
  int    block_y  = img->block_y;
  int    pix_y    = img->pix_y;
  int    pix_c_y  = img->pix_c_y;

  if(input->InterlaceCodingOption >= MB_CODING && mb_adaptive && img->field_mode)
  {
    block_y = img->field_block_y;
    pix_y   = img->field_pix_y;
    pix_c_y = img->field_pix_c_y;
    if(img->top_field)
    {
      frefar = ((img->type==B_IMG || img->type==BS_IMG) ? fw_refFrArr_top : refFrArr_top);
      abp_type_arr = abp_type_FrArr_top;
      brefar = bw_refFrArr_top;
    }
    else
    {
      frefar = ((img->type==B_IMG || img->type==BS_IMG) ? fw_refFrArr_bot : refFrArr_bot);
      abp_type_arr = abp_type_FrArr_bot;
      brefar = bw_refFrArr_bot;
    }

  }

  //--- store best mode ---
  best_mode = mode;
  best_c_imode = currMB->c_ipred_mode;
  best_i16offset = img->i16offset;
  for (i=0; i<4; i++)
  {
    b8mode[i]   = currMB->b8mode[i];
    b8pdir[i]   = currMB->b8pdir[i];
  }

  //--- reconstructed blocks ----
  for (j=0; j<16; j++)
  for (i=0; i<16; i++)
  {
    rec_mbY[j][i] = imgY[img->pix_y+j][img->pix_x+i];
  }
  for (j=0; j<8; j++)
  for (i=0; i<8; i++)
  {
    rec_mbU[j][i] = imgUV[0][img->pix_c_y+j][img->pix_c_x+i];
    rec_mbV[j][i] = imgUV[1][img->pix_c_y+j][img->pix_c_x+i];
  }


  //--- store results of decoders ---
  if (input->rdopt==2 && img->type!=B_IMG)
  {
    for (k=0; k<input->NoOfDecoders; k++)
    {
      for (j=img->pix_y; j<img->pix_y+16; j++)
      for (i=img->pix_x; i<img->pix_x+16; i++)
      {
        // Keep the decoded values of each MB for updating the ref frames
        decs->decY_best[k][j][i] = decs->decY[k][j][i];
      }
    }
  }

  //--- coeff, cbp, kac ---
  if (mode || bframe)
  {
    i4p=cofAC; cofAC=img->cofAC; img->cofAC=i4p;
    i3p=cofDC; cofDC=img->cofDC; img->cofDC=i3p;
    cbp     = currMB->cbp;
    cbp_blk = currMB->cbp_blk;
  }
  else
  {
    cbp = cbp_blk = 0;
  }

  for (j=0; j<4; j++)
  for (i=0; i<4; i++)
  {  
    frefframe[j][i] = frefar[block_y+j  ][img->block_x +i ];
    if (bframe)
    {
      brefframe[j][i] = brefar[block_y +j ][img->block_x+i  ];
      abp_typeframe[j][i] = abp_type_arr[block_y + j][img->block_x + i];     
    }
  }

/*
  //--- references ---
  frefframe[0] = frefar[block_y  ][img->block_x  ];