rdopt.c

h.264/avc 视频编码程序,实现分数像素匹配功能,非原创.

        currMB->b8mode[i] = IBLOCK;
        currMB->b8pdir[i] = -1;
      }
      break;
    case I16MB:
      for(i=0;i<4;i++)
      {
        currMB->b8mode[i] = 0;
        currMB->b8pdir[i] = -1;
      }
      break;
    default:
      printf ("Unsupported mode in SetModesAndRefframeForBlocks!\n");
      exit (1);
  }

#define IS_FW ((best8x8pdir[mode][k]==0 || best8x8pdir[mode][k]==2) && (mode!=P8x8 || best8x8mode[k]!=0 || !bframe))
#define IS_BW ((best8x8pdir[mode][k]==1 || best8x8pdir[mode][k]==2) && (mode!=P8x8 || best8x8mode[k]!=0))
  //--- reference frame arrays ---
  if (mode==0 || mode==I4MB || mode==I16MB)
  {
    if (bframe)
    {
      for (j=0;j<4;j++)
      for (i=0;i<4;i++)
      {
        fw_refFrArr[img->block_y+j][img->block_x+i] = -1;
        bw_refFrArr[img->block_y+j][img->block_x+i] = -1;
      }
    }
    else
    {
      for (j=0;j<4;j++)
      for (i=0;i<4;i++)
      {
        refFrArr [img->block_y+j][img->block_x+i] = (mode==0?0:-1);
      }
    }
  }
  else
  {
    if (bframe)
    {
      for (j=0;j<4;j++)
      for (i=0;i<4;i++)
      {
        k = 2*(j/2)+(i/2);
        l = 2*(j%2)+(i%2);
        fw_refFrArr[img->block_y+j][img->block_x+i] = (IS_FW ? best8x8ref[mode][k] : -1);
        bw_refFrArr[img->block_y+j][img->block_x+i] = (IS_BW ?                   0 : -1);
      }
    }
    else
    {
      for (j=0;j<4;j++)
      for (i=0;i<4;i++)
      {
        k = 2*(j/2)+(i/2);
        l = 2*(j%2)+(i%2);
        refFrArr [img->block_y+j][img->block_x+i] = (IS_FW ? best8x8ref[mode][k] : -1);
      }
    }
  }
#undef IS_FW
#undef IS_BW
}


/*! 
 *************************************************************************************
 * \brief
 *    Intra 16x16 mode decision
 *************************************************************************************
 */
void
Intra16x16_Mode_Decision (Macroblock* currMB, int* i16mode)
{
  intrapred_luma_2 ();   /* make intra pred for all 4 new modes */
  find_sad2 (i16mode);   /* get best new intra mode */
  currMB->cbp = dct_luma2 (*i16mode);
}



/*! 
 *************************************************************************************
 * \brief
 *    Sets Coefficients and reconstruction for an 8x8 block
 *************************************************************************************
 */
void SetCoeffAndReconstruction8x8 (Macroblock* currMB)
{
  int ****ip4, k, j, i;

  ip4=img->cofAC; img->cofAC=cofAC8x8; cofAC8x8=ip4;
  if (cnt_nonz_8x8<=5 && img->types!=SP_IMG)
  {
    currMB->cbp     = 0;
    currMB->cbp_blk = 0;
    for (j=0; j<16; j++)
    for (i=0; i<16; i++)  imgY[img->pix_y+j][img->pix_x+i] = mpr8x8[j][i];
  }
  else
  {
    currMB->cbp     = cbp8x8;
    currMB->cbp_blk = cbp_blk8x8;
    for (j=0; j<16; j++)
    for (i=0; i<16; i++)  imgY[img->pix_y+j][img->pix_x+i] = rec_mbY8x8[j][i];
  }

  //===== restore intra prediction modes for 8x8+ macroblock mode =====
  for (k=0, j=img->block_y+1; j<img->block_y+5; j++)
  for (     i=img->block_x+1; i<img->block_x+5; i++, k++)
  {
    img   ->ipredmode    [i][j] = b8_ipredmode       [k];
    currMB->intra_pred_modes[k] = b8_intra_pred_modes[k];
  }
}


/*! 
 *************************************************************************************
 * \brief
 *    Sets motion vectors for an macroblock
 *************************************************************************************
 */
void SetMotionVectorsMB (Macroblock* currMB, int bframe)
{
  int i, j, k, l, mode8, pdir8, ref, by, bx, bxr, dref;

  for (j=0; j<4; j++)
  for (i=0; i<4; i++)
  {
    mode8 = currMB->b8mode[k=2*(j/2)+(i/2)];
    pdir8 = currMB->b8pdir[k];
    l     = 2*(j%2)+(i%2);
    by    = img->block_y+j;
    bxr   = img->block_x+i;
    bx    = img->block_x+i+4;
    ref   = (bframe?fw_refFrArr:refFrArr)[by][bxr];

    if (!bframe)
    {
      if (mode8!=IBLOCK && mode8!=0)
      {
        tmp_mv   [0][by][bx] = img->all_mv [i][j][ ref][mode8][0];
        tmp_mv   [1][by][bx] = img->all_mv [i][j][ ref][mode8][1];
      }
      else
      {
        tmp_mv   [0][by][bx] = 0;
        tmp_mv   [1][by][bx] = 0;
      }
    }
    else
    {
      if (pdir8==-1) // intra
      {
        tmp_fwMV [0][by][bx] = 0;
        tmp_fwMV [1][by][bx] = 0;
        tmp_bwMV [0][by][bx] = 0;
        tmp_bwMV [1][by][bx] = 0;
        dfMV     [0][by][bx] = 0;
        dfMV     [1][by][bx] = 0;
        dbMV     [0][by][bx] = 0;
        dbMV     [1][by][bx] = 0;
      }
      else if (pdir8==0) // forward
      {
        tmp_fwMV [0][by][bx] = img->all_mv [i][j][ ref][mode8][0];
        tmp_fwMV [1][by][bx] = img->all_mv [i][j][ ref][mode8][1];
        tmp_bwMV [0][by][bx] = 0;
        tmp_bwMV [1][by][bx] = 0;
        dfMV     [0][by][bx] = 0;
        dfMV     [1][by][bx] = 0;
        dbMV     [0][by][bx] = 0;
        dbMV     [1][by][bx] = 0;
      }
      else if (pdir8==1) // backward
      {
        tmp_fwMV [0][by][bx] = 0;
        tmp_fwMV [1][by][bx] = 0;
        tmp_bwMV [0][by][bx] = img->all_bmv[i][j][   0][mode8][0];
        tmp_bwMV [1][by][bx] = img->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
      {
        tmp_fwMV [0][by][bx] = img->all_mv [i][j][ ref][mode8][0];
        tmp_fwMV [1][by][bx] = img->all_mv [i][j][ ref][mode8][1];
        tmp_bwMV [0][by][bx] = img->all_bmv[i][j][   0][mode8][0];
        tmp_bwMV [1][by][bx] = img->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
      {
        dref = max(0,refFrArr[by][bxr]);
        tmp_fwMV [0][by][bx] = 0;
        tmp_fwMV [1][by][bx] = 0;
        tmp_bwMV [0][by][bx] = 0;
        tmp_bwMV [1][by][bx] = 0;
        dfMV     [0][by][bx] = img->all_mv [i][j][dref][    0][0];
        dfMV     [1][by][bx] = img->all_mv [i][j][dref][    0][1];
        dbMV     [0][by][bx] = img->all_bmv[i][j][   0][    0][0];
        dbMV     [1][by][bx] = img->all_bmv[i][j][   0][    0][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);
  int         tmp_cc;
  int         use_of_cc =  (img->type!=INTRA_IMG && img->types!=SP_IMG && input->symbol_mode!=CABAC);
  int         cc_rate, dummy;


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

  //=====
  //=====  GET COEFFICIENTS, RECONSTRUCTIONS, CBP
  //=====
  if      (mode<P8x8 && (mode>0 || bframe))
  {
    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 && !bframe)
  {
    // We need the reconstructed prediction residue for the simulated decoders.
    compute_residue_mb (mode==I16MB?i16mode:-1);
  }

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


  //=====
  //=====   GET DISTORTION
  //=====
  // LUMA
  if (input->rdopt==2 && !bframe)
  {
    for (k=0; k<input->NoOfDecoders ;k++)
    {
      decode_one_mb (k, currMB);
      for (j=img->pix_y; j<img->pix_y+MB_BLOCK_SIZE; j++)
      for (i=img->pix_x; i<img->pix_x+MB_BLOCK_SIZE; i++)
      {
        distortion += img->quad [imgY_org[j][i] - decs->decY[k][j][i]];
      }
    }
    distortion /= input->NoOfDecoders;
  }
  else if (!bframe && mode==0)
  {
    for (j=img->pix_y; j<img->pix_y+16; j++)
    for (i=img->pix_x; i<img->pix_x+16; i++)
    {
      distortion += img->quad [imgY_org[j][i] - FastPelY_14 (mref[0], j<<2, i<<2)];
    }
  }
  else
  {
    for (j=img->pix_y; j<img->pix_y+16; j++)
    for (i=img->pix_x; i<img->pix_x+16; i++)
    {
      distortion += img->quad [imgY_org[j][i] - imgY[j][i]];
    }
  }
  // CHROMA
  if (!bframe && mode==0)
  {
    for (j=img->pix_c_y; j<img->pix_c_y+8; j++)
    for (i=img->pix_c_x; i<img->pix_c_x+8; i++)
    {
      distortion += img->quad [imgUV_org[0][j][i] - mcef[0][0][j][i]];
      distortion += img->quad [imgUV_org[1][j][i] - mcef[0][1][j][i]];
    }
  }
  else
  {
    for (j=img->pix_c_y; j<img->pix_c_y+8; j++)
    for (i=img->pix_c_x; i<img->pix_c_x+8; i++)
    {
      distortion += img->quad [imgUV_org[0][j][i] - imgUV[0][j][i]];
      distortion += img->quad [imgUV_org[1][j][i] - imgUV[1][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 || (img->type==B_IMG && currMB->cbp!=0))
    {
      // cod counter and macroblock mode are written ==> do not consider code counter
      tmp_cc = img->cod_counter;
      rate   = writeMBHeader ();
      n_linfo2 (tmp_cc, dummy, &cc_rate, &dummy);
      rate  -= cc_rate;
      img->cod_counter = tmp_cc;
    }
    else
    {
      // cod counter is just increased  ==> get additional rate
      n_linfo2 (img->cod_counter+1, dummy, &rate,    &dummy);
      n_linfo2 (img->cod_counter,   dummy, &cc_rate, &dummy);
      rate -= cc_rate;
    }
  }
  else
  {
    rate = writeMBHeader ();
  }
  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;
  }



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





/*!