JM18.4运动估计--encode_one_macroblock_high

/*!

 ***************************************************************************

 * \file md_high.c

 *

 * \brief

 *   Main macroblock mode decision functions and helpers

 *

 **************************************************************************

 */

#include<math.h>

#include<limits.h>

#include<float.h>

#include"global.h"

#include"rdopt_coding_state.h"

#include"intrarefresh.h"

#include"image.h"

#include"ratectl.h"

#include"mode_decision.h"

#include"mode_decision_p8x8.h"

#include"fmo.h"

#include"me_umhex.h"

#include"me_umhexsmp.h"

#include"macroblock.h"

#include"md_common.h"

#include"conformance.h"

#include"vlc.h"

#include"rdopt.h"

#include"mv_search.h"

/*!

*************************************************************************************

* \brief

*    Mode Decision for a macroblock

*************************************************************************************

*/

void encode_one_macroblock_high (Macroblock *currMB)

{

  //当前macroblock所在的片

  Slice *currSlice =currMB->p_Slice;

  //一些相应的参数

  VideoParameters *p_Vid =currMB->p_Vid;

  InputParameters *p_Inp =currMB->p_Inp;

  PicMotionParams **motion =p_Vid->enc_picture->mv_info;

  RDOPTStructure *p_RDO = currSlice->p_RDO;

 

  int        max_index = 9;

  int        block, index, mode, i, j;

  RD_PARAMS  enc_mb;

  distblk    bmcost[5] = {DISTBLK_MAX};

  distblk    cost=0;

  distblk    min_cost =DISTBLK_MAX;

  int        intra1 = 0;

  int        mb_available[3];

  //当前slice是否B_SLICE

  short      bslice      = (short) (currSlice->slice_type == B_SLICE);

  //当前slice是否P_SLICE

  short      pslice      = (short) ((currSlice->slice_type == P_SLICE) || (currSlice->slice_type==SP_SLICE));

 

  short      intra       = (short) ((currSlice->slice_type == I_SLICE) ||

                                    (currSlice->slice_type ==SI_SLICE) ||

                                    (pslice &&currMB->mb_y == p_Vid->mb_y_upd &&

                                       p_Vid->mb_y_upd!= p_Vid->mb_y_intra));

  int        lambda_mf[3];

  imgpel   **mb_pred  =currSlice->mb_pred[0];

  Block8x8Info *b8x8info = p_Vid->b8x8info;

  char       chroma_pred_mode_range[2];

  short      inter_skip = 0;

  BestMode   md_best;

  Info8x8    best;

  init_md_best(&md_best);

  // Init best (need to create simplefunction)

  best.pdir = 0;

  best.bipred = 0;

  best.ref[LIST_0] = 0;

  best.ref[LIST_1] = -1;

  intra |= RandomIntra (p_Vid,currMB->mbAddrX);   // Forced Pseudo-Random Intra

  //===== Setup Macroblock encodingparameters =====

  init_enc_mb_params(currMB, &enc_mb, intra);

  if (p_Inp->AdaptiveRounding)

  {

    reset_adaptive_rounding(p_Vid);

  }

  if (currSlice->mb_aff_frame_flag)

  {

    reset_mb_nz_coeff(p_Vid,currMB->mbAddrX);

  }

  //=====  S T O R E  C O D I N G   S T A T E   =====

  //---------------------------------------------------

  currSlice->store_coding_state (currMB, currSlice->p_RDO->cs_cm);

  //不是帧内编码，即帧间编码

  if (!intra)

  {

    //===== set skip/direct motionvectors =====

    if (enc_mb.valid[0])

    {

      if (bslice)

       currSlice->Get_Direct_Motion_Vectors (currMB);

      else

        FindSkipModeMotionVector (currMB);

    }

    if (p_Inp->CtxAdptLagrangeMult == 1)

    {

      get_initial_mb16x16_cost(currMB);

    }

    //===== MOTION ESTIMATION FOR 16x16,16x8, 8x16 BLOCKS =====

    //  处理mode1，mode2，mode3

    for (mode = 1; mode < 4; mode++)

    {

      best.mode = (char) mode;

      best.bipred = 0;

     b8x8info->best[mode][0].bipred = 0;

      if (enc_mb.valid[mode])

      {

        //根据mode，决定有多少个MV

      //mode1  对应一个MV，mode2，mode3对应连个mv

        for (cost=0, block=0;block<(mode==1?1:2); block++)

        {

          update_lambda_costs(currMB, &enc_mb, lambda_mf);

           //处理分割，即搜索分割的最优运动向量和最小代价

            PartitionMotionSearch (currMB, mode, block, lambda_mf);

          //--- set 4x4 block indices (for getting MV) ---

          //    1  2  3

          // j= 0  1  0

          // i= 0  0  1

          //如上所示，i，j指示分割（subpatitiono）在macroblock中的位置，以8X8块为单位

          j = (block==1 &&mode==2 ? 2 : 0);

          i = (block==1 &&mode==3 ? 2 : 0);

          //--- get cost and reference framefor List 0 prediction ---

          bmcost[LIST_0] =DISTBLK_MAX;

          list_prediction_cost(currMB,LIST_0, block, mode, &enc_mb, bmcost,best.ref);

         //处理B_SLICE

          if (bslice)

          {

            //--- get cost and reference framefor List 1 prediction ---

            bmcost[LIST_1] =DISTBLK_MAX;

            list_prediction_cost(currMB,LIST_1, block, mode, &enc_mb, bmcost,best.ref);

            // Compute bipredictive cost betweenbest list 0 and best list 1 references

            list_prediction_cost(currMB,BI_PRED, block, mode, &enc_mb, bmcost,best.ref);

            // currently Bi predictive ME is onlysupported for modes 1, 2, 3 and ref 0

            if (is_bipred_enabled(p_Vid, mode))

            {

              get_bipred_cost(currMB, mode, block, i, j, &best,&enc_mb, bmcost);

            }

            else

            {

              bmcost[BI_PRED_L0] =DISTBLK_MAX;

              bmcost[BI_PRED_L1] =DISTBLK_MAX;

            }

            // Determine prediction list based onmode cost

           determine_prediction_list(bmcost, &best, &cost);

          }

          //P_SLICE

          else// if (bslice)

          {

            best.pdir = 0;

            cost      += bmcost[LIST_0];

          }

          assign_enc_picture_params(currMB, mode, &best, 2 * block);

          //----- set reference frame anddirection parameters -----

         set_block8x8_info(b8x8info, mode, block, &best);

          //--- set reference frames and motionvectors ---

          if (mode>1 && block == 0)

           currSlice->set_ref_and_motion_vectors (currMB, motion, &best, block);

        } // for (block=0;block<(mode==1?1:2); block++)

        if (cost < min_cost)

        {

          md_best.mode = (byte) mode;

          md_best.cost = cost;

          currMB->best_mode = (short) mode;

          min_cost = cost;

          if (p_Inp->CtxAdptLagrangeMult == 1)

          {

            adjust_mb16x16_cost(currMB, cost);

          }

        }

      } // if (enc_mb.valid[mode])

    } // for (mode=1; mode<4; mode++)

    if (enc_mb.valid[P8x8])  //处理8X8块

    {   

      currMB->valid_8x8 =FALSE;

    //采用8x8块做变换

      if (p_Inp->Transform8x8Mode)

      {

        ResetRD8x8Data(p_Vid,p_RDO->tr8x8);

        currMB->luma_transform_size_8x8_flag =TRUE;//switch to 8x8 transform size

        //===========================================================

        // Check 8x8 partition with transformsize 8x8

        //===========================================================

        //===== LOOP OVER 8x8 SUB-PARTITIONS  (Motion Estimation & Mode Decision) =====

        for (block = 0; block < 4; block++)

        {

         currSlice->submacroblock_mode_decision(currMB, &enc_mb, p_RDO->tr8x8,p_RDO->cofAC8x8ts[block], block, &cost);

          if(!currMB->valid_8x8)

            break;

          set_subblock8x8_info(b8x8info,P8x8, block, p_RDO->tr8x8);

        }

      }// if (p_Inp->Transform8x8Mode)

      currMB->valid_4x4 =FALSE;

      if (p_Inp->Transform8x8Mode != 2)/

      {

        currMB->luma_transform_size_8x8_flag =FALSE;//switch to 8x8 transform size

        ResetRD8x8Data(p_Vid,p_RDO->tr4x4);

        //=================================================================

        // Check 8x8, 8x4, 4x8 and 4x4partitions with transform size 4x4

        //=================================================================

        //===== LOOP OVER 8x8 SUB-PARTITIONS  (Motion Estimation & Mode Decision) =====

        for (block = 0; block < 4; block++)

        {

          //submacroblock_mode_decision函数指针，择机调用submacroblock_mode_decision_p_slice和
           submacroblock_mode_decision_b_slice函数，用于进一步处理该分割

         currSlice->submacroblock_mode_decision(currMB, &enc_mb, p_RDO->tr4x4,p_RDO->coefAC8x8[block], block, &cost);

          if(!currMB->valid_4x4)

            break;

         set_subblock8x8_info(b8x8info,P8x8, block, p_RDO->tr4x4);

        }

      }// if (p_Inp->Transform8x8Mode !=2)

      if (p_Inp->RCEnable)

       rc_store_diff(currSlice->diffy, &p_Vid->pCurImg[currMB->opix_y],currMB->pix_x, mb_pred);

      p_Vid->giRDOpt_B8OnlyFlag =FALSE;

    }

  }

  //帧内编码

 else// if (!intra)

  {

    min_cost =DISTBLK_MAX;

  }

 

  // Set Chroma mode

  set_chroma_pred_mode(currMB, enc_mb, mb_available,chroma_pred_mode_range);

  //========= C H O O S E  B E S T  M A C R O B L O C K   M O D E=========

  //-------------------------------------------------------------------------

  for (currMB->c_ipred_mode = chroma_pred_mode_range[0]; currMB->c_ipred_mode<=chroma_pred_mode_range[1];currMB->c_ipred_mode++)

  {

    // bypass if c_ipred_mode is notallowed

    if ( (p_Vid->yuv_format !=YUV400) &&

      (  ((!intra || !p_Inp->IntraDisableInterOnly)&& p_Inp->ChromaIntraDisable == 1 &&currMB->c_ipred_mode!=DC_PRED_8)

      || (currMB->c_ipred_mode ==VERT_PRED_8 && !mb_available[0])

      || (currMB->c_ipred_mode ==HOR_PRED_8 && !mb_available[1])

      || (currMB->c_ipred_mode ==PLANE_8    && (!mb_available[1] ||!mb_available[0] || !mb_available[2]))))

      continue;       

    //===== GET BEST MACROBLOCK MODE=====

    for (index=0; index < max_index;index++)

    {

      mode = mb_mode_table[index];

      //printf("mode %d %7.3f",mode, (double) currMB->min_rdcost);

      if (enc_mb.valid[mode])

      {

        //printf(" mode %d isvalid", mode);

        if (p_Vid->yuv_format !=YUV400)

        {          

          currMB->i16mode = 0;

        }

        // Skip intra modes in inter slicesif best mode is inter <P8x8 with cbp equal to 0   

        if (currSlice->P444_joined)

        {

          if (p_Inp->SkipIntraInInterSlices&& !intra && mode >=I16MB

            &&currMB->best_mode <=3 &&currMB->best_cbp == 0 &&currSlice->cmp_cbp[1] == 0 && currSlice->cmp_cbp[2] == 0&& (currMB->min_rdcost <weighted_cost(enc_mb.lambda_mdfp,5)))

            continue;

        }

        else

        {

          if (p_Inp->SkipIntraInInterSlices)

          {

            if (!intra && mode >=I4MB)

            {

              if (currMB->best_mode <=3 &&currMB->best_cbp == 0 && (currMB->min_rdcost <weighted_cost(enc_mb.lambda_mdfp, 5)))

              {

                continue;

              }

              elseif (currMB->best_mode == 0 && (currMB->min_rdcost <weighted_cost(enc_mb.lambda_mdfp,6)))

              {

                continue;

              }

            }

          }

        }

        compute_mode_RD_cost(currMB, &enc_mb, (short) mode, &inter_skip);

      }

      //printf(" best %d%7.2f\n", currMB->best_mode, (double) currMB->min_rdcost);

    }// for (index=0; index<max_index;index++)

  }// for(currMB->c_ipred_mode=DC_PRED_8;currMB->c_ipred_mode<=chroma_pred_mode_range[1];currMB->c_ipred_mode++)                    

  restore_nz_coeff(currMB);

  intra1 = is_intra(currMB);

  //===== S E T  F I N A L   M A C R O B L O CK   P A R A M E T E R S ======

  //---------------------------------------------------------------------------

  update_qp_cbp_tmp(currMB, p_RDO->cbp);

 currSlice->set_stored_mb_parameters (currMB);

  // Rate control

  if(p_Inp->RCEnable &&p_Inp->RCUpdateMode <=MAX_RC_MODE)

    rc_store_mad(currMB);

  //===== Decide if this MB willrestrict the reference frames =====

  if (p_Inp->RestrictRef)

    update_refresh_map(currMB, intra, intra1);

}