开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
mode_decision.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：36k
源码类别：

Audio

开发平台：

Visual C++

mode_decision.c：源码内容
  2. /*!
  3.  ***************************************************************************
  4.  * file mode_decision.c
  5.  *
  6.  * brief
  7.  *    Main macroblock mode decision functions and helpers
  8.  *
  9.  **************************************************************************
  10.  */
  12. #include <math.h>
  13. #include <limits.h>
  14. #include <float.h>
  16. #include "global.h"
  17. #include "rdopt_coding_state.h"
  18. #include "mb_access.h"
  19. #include "intrarefresh.h"
  20. #include "image.h"
  21. #include "transform8x8.h"
  22. #include "ratectl.h"
  23. #include "mode_decision.h"
  24. #include "fmo.h"
  25. #include "me_umhex.h"
  26. #include "me_umhexsmp.h"
  27. #include "macroblock.h"
  28. #include "rdoq.h"
  29. #include "errdo.h"
  32. //==== MODULE PARAMETERS ====
  33. const int  b8_mode_table[6]  = {0, 4, 5, 6, 7};         // DO NOT CHANGE ORDER !!!
  34. const int  mb_mode_table[9]  = {0, 1, 2, 3, P8x8, I16MB, I4MB, I8MB, IPCM}; // DO NOT CHANGE ORDER !!!
  36. //double *mb16x16_cost_frame;
  38. /*!
  39. *************************************************************************************
  40. * brief
  41. *    Reset Valid Modes
  42. *************************************************************************************
  43. */
  44. void reset_valid_modes(RD_PARAMS *enc_mb)
  45. {
  46.   memset(enc_mb->valid, 0, MAXMODE * sizeof(short));
  47. }
  50. /*!
  51. *************************************************************************************
  52. * brief
  53. *    Initialize Encoding parameters for Macroblock
  54. *************************************************************************************
  55. */
  56. void init_enc_mb_params(Macroblock* currMB, RD_PARAMS *enc_mb, int intra, int bslice)
  57. {
  58.   int l,k;
  60.   //Setup list offset
  61.   enc_mb->list_offset[LIST_0] = LIST_0 + currMB->list_offset;
  62.   enc_mb->list_offset[LIST_1] = LIST_1 + currMB->list_offset;
  64.   enc_mb->curr_mb_field = ((img->MbaffFrameFlag)&&(currMB->mb_field));
  65.  
  66.   // Set valid modes  
  67.   enc_mb->valid[I8MB]  = (!params->DisableIntraInInter || intra )?   params->Transform8x8Mode : 0;
  68.   enc_mb->valid[I4MB]  = (!params->DisableIntraInInter || intra )? ((params->Transform8x8Mode == 2) ? 0 : 1) : 0;
  69.   enc_mb->valid[I4MB]  = (!params->DisableIntra4x4  ) ? enc_mb->valid[I4MB] : 0;
  70.   enc_mb->valid[I16MB] = (!params->DisableIntraInInter || intra )? 1 : 0;
  71.   enc_mb->valid[I16MB] = (!params->DisableIntra16x16) ? enc_mb->valid[I16MB] : 0;
  72.   enc_mb->valid[IPCM]  = (!params->DisableIntraInInter || intra )? params->EnableIPCM : 0;
  74.   enc_mb->valid[0]     = (!intra && params->InterSearch[bslice][0]);
  75.   enc_mb->valid[1]     = (!intra && params->InterSearch[bslice][1]);
  76.   enc_mb->valid[2]     = (!intra && params->InterSearch[bslice][2]);
  77.   enc_mb->valid[3]     = (!intra && params->InterSearch[bslice][3]);
  78.   enc_mb->valid[4]     = (!intra && params->InterSearch[bslice][4]);
  79.   enc_mb->valid[5]     = (!intra && params->InterSearch[bslice][5] && !(params->Transform8x8Mode==2));
  80.   enc_mb->valid[6]     = (!intra && params->InterSearch[bslice][6] && !(params->Transform8x8Mode==2));
  81.   enc_mb->valid[7]     = (!intra && params->InterSearch[bslice][7] && !(params->Transform8x8Mode==2));
  82.   enc_mb->valid[P8x8]  = (enc_mb->valid[4] || enc_mb->valid[5] || enc_mb->valid[6] || enc_mb->valid[7]);
  83.   enc_mb->valid[12]    = (img->type == SI_SLICE);
  84.   
  85.   if (params->UseRDOQuant && params->RDOQ_CP_Mode && (img->qp != img->masterQP) )  
  86.     RDOQ_update_mode(enc_mb, bslice);
  88.   if(img->type==SP_SLICE)
  89.   {
  90.     if(si_frame_indicator)
  91.     {
  92.       reset_valid_modes(enc_mb);
  93.       if(check_for_SI16())
  94.       {
  95.         enc_mb->valid[I16MB] = 1;
  96.       }
  97.       else
  98.       {
  99.         enc_mb->valid[I4MB]  = 1;
  100.       }
  101.     }
  102.     
  103.     if(sp2_frame_indicator)
  104.     {
  105.       if(check_for_SI16())
  106.       {
  107.         reset_valid_modes(enc_mb);
  108.         enc_mb->valid[I16MB] = 1;
  109.       }
  110.       else
  111.       {
  112.         enc_mb->valid[I8MB]  = 0;
  113.         enc_mb->valid[IPCM]  = 0;
  114.         enc_mb->valid[0]     = 0;
  115.         enc_mb->valid[I16MB] = 0;
  116.       }
  117.     }
  118.   }
  120.   //===== SET LAGRANGE PARAMETERS =====
  121.   // Note that these are now computed at the slice level to reduce
  122.   // computations and cleanup code.
  123.   if (bslice && img->nal_reference_idc)
  124.   {
  125.     enc_mb->lambda_md = img->lambda_md[5][img->masterQP];
  127.     enc_mb->lambda_me[F_PEL] = img->lambda_me[5][img->masterQP][F_PEL];
  128.     enc_mb->lambda_me[H_PEL] = img->lambda_me[5][img->masterQP][H_PEL];
  129.     enc_mb->lambda_me[Q_PEL] = img->lambda_me[5][img->masterQP][Q_PEL];
  131.     enc_mb->lambda_mf[F_PEL] = img->lambda_mf[5][img->masterQP][F_PEL];
  132.     enc_mb->lambda_mf[H_PEL] = img->lambda_mf[5][img->masterQP][H_PEL];
  133.     enc_mb->lambda_mf[Q_PEL] = img->lambda_mf[5][img->masterQP][Q_PEL];
  134.   }
  135.   else
  136.   {
  137.     enc_mb->lambda_md = img->lambda_md[img->type][img->masterQP];
  138.     enc_mb->lambda_me[F_PEL] = img->lambda_me[img->type][img->masterQP][F_PEL];
  139.     enc_mb->lambda_me[H_PEL] = img->lambda_me[img->type][img->masterQP][H_PEL];
  140.     enc_mb->lambda_me[Q_PEL] = img->lambda_me[img->type][img->masterQP][Q_PEL];
  142.     enc_mb->lambda_mf[F_PEL] = img->lambda_mf[img->type][img->masterQP][F_PEL];
  143.     enc_mb->lambda_mf[H_PEL] = img->lambda_mf[img->type][img->masterQP][H_PEL];
  144.     enc_mb->lambda_mf[Q_PEL] = img->lambda_mf[img->type][img->masterQP][Q_PEL];
  145.   }
  146.  
  147.   if (!img->MbaffFrameFlag)
  148.   {
  149.     for (l = LIST_0; l < BI_PRED; l++)
  150.     {
  151.       for(k = 0; k < listXsize[l]; k++)
  152.       {
  153.         if(img->structure != listX[l][k]->structure)
  154.         {
  155.           if (img->structure == TOP_FIELD)
  156.             listX[l][k]->chroma_vector_adjustment = -2;
  157.           else if (img->structure == BOTTOM_FIELD)
  158.             listX[l][k]->chroma_vector_adjustment = 2;
  159.           else
  160.             listX[l][k]->chroma_vector_adjustment= 0;
  161.         }
  162.         else
  163.           listX[l][k]->chroma_vector_adjustment= 0;
  164.       }
  165.     }
  166.   }
  167.   else
  168.   {
  169.     if (enc_mb->curr_mb_field)
  170.     {
  171.       for (l = enc_mb->list_offset[LIST_0]; l <= enc_mb->list_offset[LIST_1]; l++)
  172.       {
  173.         for(k = 0; k < listXsize[l]; k++)
  174.         {
  175.           listX[l][k]->chroma_vector_adjustment= 0;
  176.           if((img->current_mb_nr & 0x01) == 0 && listX[l][k]->structure == BOTTOM_FIELD)
  177.             listX[l][k]->chroma_vector_adjustment = -2;
  178.           if((img->current_mb_nr & 0x01) == 1 && listX[l][k]->structure == TOP_FIELD)
  179.             listX[l][k]->chroma_vector_adjustment = 2;
  180.         }
  181.       }
  182.     }
  183.     else
  184.     {
  185.       for (l = enc_mb->list_offset[LIST_0]; l <= enc_mb->list_offset[LIST_1]; l++)
  186.       {
  187.         for(k = 0; k < listXsize[l]; k++)
  188.           listX[l][k]->chroma_vector_adjustment = 0;
  189.       }
  190.     }
  191.   }
  192. }
  194. /*!
  195. *************************************************************************************
  196. * brief
  197. *    computation of prediction list (including biprediction) cost
  198. *************************************************************************************
  199. */
  200. void list_prediction_cost(Macroblock *currMB, int list, int block, int mode, RD_PARAMS *enc_mb, int bmcost[5], char best_ref[2])
  201. {
  202.   short ref;
  203.   int mcost;
  204.   int cur_list = list < BI_PRED ? enc_mb->list_offset[list] : enc_mb->list_offset[LIST_0];
  206.   //--- get cost and reference frame for forward prediction ---
  208.   if (list < BI_PRED)
  209.   {
  210.     for (ref=0; ref < listXsize[cur_list]; ref++)
  211.     {
  212.       if (!img->checkref || list || ref==0 || (params->RestrictRef && CheckReliabilityOfRef (block, list, ref, mode)))
  213.       {
  214.         // limit the number of reference frames to 1 when switching SP frames are used
  215.         if((!params->sp2_frame_indicator && !params->sp_output_indicator)||
  216.           ((params->sp2_frame_indicator || params->sp_output_indicator) && (img->type != P_SLICE && img->type != SP_SLICE))||
  217.           ((params->sp2_frame_indicator || params->sp_output_indicator) && ((img->type == P_SLICE || img->type == SP_SLICE) &&(ref==0))))
  218.         {
  219.           mcost  = (params->rdopt
  220.             ? REF_COST (enc_mb->lambda_mf[Q_PEL], ref, cur_list)
  221.             : (int) (2 * enc_mb->lambda_me[Q_PEL] * imin(ref, 1)));
  223.           mcost += motion_cost[mode][list][ref][block];
  224.           if (mcost < bmcost[list])
  225.           {
  226.             bmcost[list]   = mcost;
  227.             best_ref[list] = (char)ref;
  228.           }
  229.         }
  230.       }
  231.     }
  232.   }
  233.   else if (list == BI_PRED)
  234.   {
  235.     if (active_pps->weighted_bipred_idc == 1)
  236.     {
  237.       int weight_sum = wbp_weight[0][(int) best_ref[LIST_0]][(int) best_ref[LIST_1]][0] + wbp_weight[1][(int) best_ref[LIST_0]][(int) best_ref[LIST_1]][0];
  238.       
  239.       if (weight_sum < -128 ||  weight_sum > 127)
  240.       {
  241.         bmcost[list] = INT_MAX;
  242.       }
  243.       else
  244.       {
  245.         bmcost[list]  = (params->rdopt
  246.           ? (REF_COST  (enc_mb->lambda_mf[Q_PEL], (short)best_ref[LIST_0], cur_list)
  247.           +  REF_COST  (enc_mb->lambda_mf[Q_PEL], (short)best_ref[LIST_1], cur_list + LIST_1))
  248.           : (int) (2 * (enc_mb->lambda_me[Q_PEL] * (imin((short)best_ref[LIST_0], 1) + imin((short)best_ref[LIST_1], 1)))));
  249.         bmcost[list] += BIDPartitionCost (currMB, mode, block, best_ref, enc_mb->lambda_mf[Q_PEL]);
  250.       }
  251.     }
  252.     else
  253.     {
  254.       bmcost[list]  = (params->rdopt
  255.         ? (REF_COST  (enc_mb->lambda_mf[Q_PEL], (short)best_ref[LIST_0], cur_list)
  256.         +  REF_COST  (enc_mb->lambda_mf[Q_PEL], (short)best_ref[LIST_1], cur_list + LIST_1))
  257.         : (int) (2 * (enc_mb->lambda_me[Q_PEL] * (imin((short)best_ref[LIST_0], 1) + imin((short)best_ref[LIST_1], 1)))));
  258.       bmcost[list] += BIDPartitionCost (currMB, mode, block, best_ref, enc_mb->lambda_mf[Q_PEL]);
  259.     }
  260.   }
  261.   else
  262.   {
  263.     bmcost[list]  = (params->rdopt
  264.       ? (REF_COST (enc_mb->lambda_mf[Q_PEL], 0, cur_list)
  265.       +  REF_COST (enc_mb->lambda_mf[Q_PEL], 0, cur_list + LIST_1))
  266.       : (int) (4 * enc_mb->lambda_me[Q_PEL]));
  267.     bmcost[list] += BPredPartitionCost(currMB, mode, block, 0, 0, enc_mb->lambda_mf[Q_PEL], !(list&1));
  268.   }
  269. }
  271. int compute_ref_cost(RD_PARAMS *enc_mb, int ref, int list)
  272. {
  273.   return WEIGHTED_COST(enc_mb->lambda_mf[Q_PEL],((listXsize[enc_mb->list_offset[list]] <= 1)? 0:refbits[ref]));
  274. }
  276. /*!
  277. *************************************************************************************
  278. * brief
  279. *    Determination of prediction list based on simple distortion computation
  280. *************************************************************************************
  281. */
  282. void determine_prediction_list(int mode, int bmcost[5], char best_ref[2], char *best_pdir, int *cost, short *bipred_me)
  283. {
  284.   int bestlist;  
  285.   
  286.   *cost += iminarray ( bmcost, 5, &bestlist);
  287.   
  288.   if (bestlist <= BI_PRED)  //LIST_0, LIST_1 & BI_DIR
  289.   {
  290.     *best_pdir = bestlist; 
  291.     *bipred_me = 0;
  292.   }
  293.   else                      //BI_PRED_L0 & BI_PRED_L1
  294.   {
  295.     *best_pdir = 2;    
  296.     *bipred_me = bestlist - 2;
  297.     best_ref[LIST_1] = 0;
  298.     best_ref[LIST_0] = 0;
  299.   }
  300. }
  302. /*!
  303. *************************************************************************************
  304. * brief
  305. *    RD decision process
  306. *************************************************************************************
  307. */
  308. void compute_mode_RD_cost(int mode,
  309.                           Macroblock *currMB,
  310.                           RD_PARAMS *enc_mb,
  311.                           double *min_rdcost,
  312.                           double *min_dcost,
  313.                           double *min_rate,
  314.                           int i16mode,
  315.                           short bslice,
  316.                           short *inter_skip,
  317.                           int   is_cavlc)
  318. {
  319.   //--- transform size ---
  320.   currMB->luma_transform_size_8x8_flag = params->Transform8x8Mode==2
  321.     ?  (mode >= 1 && mode <= 3)
  322.     || (mode == 0 && bslice && active_sps->direct_8x8_inference_flag)
  323.     || ((mode == P8x8) && (enc_mb->valid[4]))
  324.     :  0;
  325.   //store_coding_state (currMB, cs_cm); // RD
  326.   SetModesAndRefframeForBlocks (currMB, mode);
  328.   // Encode with coefficients
  329.   img->NoResidueDirect = 0;
  331.   if ((params->FastCrIntraDecision )
  332.     || (currMB->c_ipred_mode == DC_PRED_8 || (IS_INTRA(currMB) )))
  333.   {
  334.     while(1)
  335.     {
  336.       if (RDCost_for_macroblocks (currMB, enc_mb->lambda_md, mode, min_rdcost, min_dcost, min_rate, i16mode, is_cavlc))
  337.       {
  338.         //Rate control
  339.         if (params->RCEnable)
  340.         {
  341.           if(mode == P8x8)
  342.             rc_store_diff(img->opix_x, img->opix_y, currMB->luma_transform_size_8x8_flag == 1 ? tr8x8.mpr8x8 : tr4x4.mpr8x8);
  343.           else
  344.             rc_store_diff(img->opix_x, img->opix_y, pred);
  345.         }
  347.         store_macroblock_parameters (currMB, mode);
  349.         if(params->rdopt == 2 && mode == 0 && params->EarlySkipEnable)
  350.         {
  351.           // check transform quantized coeff.
  352.           if(currMB->cbp == 0)
  353.             *inter_skip = 1;
  354.         }
  355.       }
  357.       // Go through transform modes.
  358.       // Note that if currMB->cbp is 0 one could choose to skip 8x8 mode
  359.       // although this could be due to deadzoning decisions.
  360.       //if (params->Transform8x8Mode==1 && currMB->cbp!=0)
  361.       if (params->Transform8x8Mode==1)
  362.       {
  363.         //=========== try mb_types 1,2,3 with 8x8 transform ===========
  364.         if ((mode >= 1 && mode <= 3) && currMB->luma_transform_size_8x8_flag == 0)
  365.         {
  366.           //try with 8x8 transform size
  367.           currMB->luma_transform_size_8x8_flag = 1;
  368.           continue;
  369.         }
  370.         //=========== try DIRECT-MODE with 8x8 transform ===========
  371.         else if (mode == 0 && bslice && active_sps->direct_8x8_inference_flag && currMB->luma_transform_size_8x8_flag == 0)
  372.         {
  373.           //try with 8x8 transform size
  374.           currMB->luma_transform_size_8x8_flag = 1;
  375.           continue;
  376.         }
  377.         //=========== try mb_type P8x8 for mode 4 with 4x4/8x8 transform ===========
  378.         else if ((mode == P8x8) && (enc_mb->valid[4]) && (currMB->luma_transform_size_8x8_flag == 0))
  379.         {
  380.           currMB->luma_transform_size_8x8_flag = 1; //check 8x8 partition for transform size 8x8
  381.           continue;
  382.         }
  383.         else
  384.         {
  385.           currMB->luma_transform_size_8x8_flag = 0;
  386.           break;
  387.         }
  388.       }
  389.       else
  390.         break;
  391.     }
  393.     // Encode with no coefficients. Currently only for direct. This could be extended to all other modes as in example.
  394.     //if (mode < P8x8 && (*inter_skip == 0) && enc_mb->valid[mode] && currMB->cbp && (currMB->cbp&15) != 15 && !params->nobskip)
  395.     if ( bslice && mode == 0 && (*inter_skip == 0) && enc_mb->valid[mode] 
  396.     && currMB->cbp && (currMB->cbp&15) != 15 && !params->nobskip
  397.     && !(currMB->qp_scaled[0] == 0 && img->lossless_qpprime_flag==1) )
  398.     {
  399.       img->NoResidueDirect = 1;
  401.       if (RDCost_for_macroblocks (currMB, enc_mb->lambda_md, mode, min_rdcost, min_dcost, min_rate, i16mode, is_cavlc))
  402.       {
  403.         //Rate control
  404.         if (params->RCEnable)
  405.           rc_store_diff(img->opix_x,img->opix_y,pred);
  407.         store_macroblock_parameters (currMB, mode);
  408.       }
  409.     }
  410.   }
  411. }
  414. /*!
  415. *************************************************************************************
  416. * brief
  417. *    Mode Decision for an 8x8 sub-macroblock
  418. *************************************************************************************
  419. */
  420. void submacroblock_mode_decision(RD_PARAMS *enc_mb,
  421.                                  RD_8x8DATA *dataTr,
  422.                                  Macroblock *currMB,
  423.                                  int ***cofACtr,
  424.                                  int ***cofACCbCrtr1, 
  425.                                  int ***cofACCbCrtr2,
  426.                                  int *have_direct,
  427.                                  short bslice,
  428.                                  int block,
  429.                                  int *cost_direct,
  430.                                  int *cost,
  431.                                  int *cost8x8_direct,
  432.                                  int transform8x8,
  433.                                  int is_cavlc)
  434. {
  435.   int64 curr_cbp_blk;
  436.   double min_rdcost, rdcost = 0.0;
  437.   int j0, i0, j1, i1;
  438.   int i,j, k;
  439.   int min_cost8x8, index;
  440.   int mode;
  441.   int direct4x4_tmp, direct8x8_tmp;
  442.   int bmcost[5] = {INT_MAX};
  443.   int cnt_nonz = 0;
  444.   int dummy;
  445.   int best_cnt_nonz = 0;
  446.   int maxindex =  (transform8x8) ? 2 : 5;
  447.   int block_x, block_y;
  448.   int lambda_mf[3];
  449.   static int fadjust[16][16], fadjustCr[2][16][16];
  450.   int ***fadjustTransform = transform8x8? img->fadjust8x8 : img->fadjust4x4;
  451.   int ****fadjustTransformCr   = (params->AdaptRndChroma || (img->P444_joined )) 
  452.     ? (transform8x8 ? img->fadjust8x8Cr : img->fadjust4x4Cr): NULL;
  453.   int lumaAdjustIndex   = transform8x8 ? 2 : 3;
  454.   int chromaAdjustIndex = transform8x8 ? 0 : 2;
  455.   short pdir, bipred_me = 0;
  458.   char best_pdir = 0;
  459.   char best_ref[2] = {0, -1};
  460.   imgpel  (*mb_pred)[16] = img->mb_pred[0];
  462. #ifdef BEST_NZ_COEFF
  463.   int best_nz_coeff[2][2];
  464. #endif
  466.   //--- set coordinates ---
  467.   j0 = ((block>>1)<<3);
  468.   j1 = (j0>>2);
  469.   i0 = ((block&0x01)<<3);
  470.   i1 = (i0>>2);
  472. #ifdef BEST_NZ_COEFF
  473.   for(j = 0; j <= 1; j++)
  474.   {
  475.     for(i = 0; i <= 1; i++)
  476.       best_nz_coeff[i][j] = img->nz_coeff[img->current_mb_nr][i1 + i][j1 + j] = 0;
  477.   }
  478. #endif
  480.   if (transform8x8)
  481.     currMB->luma_transform_size_8x8_flag = 1; //switch to transform size 8x8
  483.   //--- store coding state before coding ---
  484.   store_coding_state (currMB, cs_cm);
  486.   //=====  LOOP OVER POSSIBLE CODING MODES FOR 8x8 SUB-PARTITION  =====
  487.   for (min_cost8x8 = INT_MAX, min_rdcost = 1e20, index = (bslice?0:1); index < maxindex; index++)
  488.   {
  489.     mode = b8_mode_table[index];
  490.     *cost = 0;
  491.     if (enc_mb->valid[mode] && (transform8x8 == 0 || mode != 0 || (mode == 0 && active_sps->direct_8x8_inference_flag)))
  492.     {
  493.       curr_cbp_blk = 0;
  495.       if (mode==0)
  496.       {
  497.         //--- Direct Mode ---
  498.         if (!params->rdopt )
  499.         {
  500.           direct4x4_tmp = 0;
  501.           direct8x8_tmp = 0;
  502.           direct4x4_tmp = GetDirectCost8x8 ( currMB, block, &direct8x8_tmp);
  504.           if ((direct4x4_tmp==INT_MAX)||(*cost_direct==INT_MAX))
  505.           {
  506.             *cost_direct = INT_MAX;
  507.             if (transform8x8)
  508.               *cost8x8_direct = INT_MAX;
  509.           }
  510.           else
  511.           {
  512.             *cost_direct += direct4x4_tmp;
  513.             if (transform8x8)
  514.               *cost8x8_direct += direct8x8_tmp;
  515.           }
  516.           (*have_direct) ++;
  518.           if (transform8x8)
  519.           {
  520.             switch(params->Transform8x8Mode)
  521.             {
  522.             case 1: // Mixture of 8x8 & 4x4 transform
  523.               if((direct8x8_tmp < direct4x4_tmp) || !(enc_mb->valid[5] && enc_mb->valid[6] && enc_mb->valid[7]))
  524.                 *cost = direct8x8_tmp;
  525.               else
  526.                 *cost = direct4x4_tmp;
  527.               break;
  528.             case 2: // 8x8 Transform only
  529.               *cost = direct8x8_tmp;
  530.               break;
  531.             default: // 4x4 Transform only
  532.               *cost = direct4x4_tmp;
  533.               break;
  534.             }
  535.             if (params->Transform8x8Mode==2)
  536.               *cost = INT_MAX;
  537.           }
  538.           else
  539.           {
  540.             *cost = direct4x4_tmp;
  541.           }
  542.         }
  544.         block_x = img->block_x + (block & 0x01)*2;
  545.         block_y = img->block_y + (block & 0x02);
  546.         best_ref[LIST_0] = direct_ref_idx[LIST_0][block_y][block_x];
  547.         best_ref[LIST_1] = direct_ref_idx[LIST_1][block_y][block_x];
  548.         best_pdir        = direct_pdir[block_y][block_x];
  549.       } // if (mode==0)
  550.       else
  551.       {
  552.         int64 ref_pic_num;
  553.         char b_ref;
  554.         //======= motion estimation for all reference frames ========
  555.         //-----------------------------------------------------------
  556.         memcpy(lambda_mf, enc_mb->lambda_mf, 3 * sizeof(int));
  557.         if (params->CtxAdptLagrangeMult == 1)
  558.         {
  559.           lambda_mf[F_PEL] = (int)(lambda_mf[F_PEL] * lambda_mf_factor);
  560.           lambda_mf[H_PEL] = (int)(lambda_mf[H_PEL] * lambda_mf_factor);
  561.           lambda_mf[Q_PEL] = (int)(lambda_mf[Q_PEL] * lambda_mf_factor);
  562.         }
  564.         PartitionMotionSearch (currMB, mode, block, lambda_mf);
  566.         //--- get cost and reference frame for LIST 0 prediction ---
  567.         bmcost[LIST_0] = INT_MAX;
  568.         list_prediction_cost(currMB, LIST_0, block, mode, enc_mb, bmcost, best_ref);
  570.         //store LIST 0 reference index for every block
  571.         block_x = img->block_x + (block & 0x01)*2;
  572.         block_y = img->block_y + (block & 0x02);
  573.         b_ref = best_ref[LIST_0];
  574.         ref_pic_num = enc_picture->ref_pic_num[enc_mb->list_offset[LIST_0]][(short) b_ref];
  576.         for (j = block_y; j< block_y + 2; j++)
  577.         {
  578.           memset(&enc_picture->motion.ref_idx [LIST_0][j][block_x], b_ref, 2 * sizeof(char));
  579.         }
  581.         for (j = block_y; j< block_y + 2; j++)
  582.         {
  583.           for (i = block_x; i < block_x + 2; i++)
  584.           {
  585.             enc_picture->motion.ref_pic_id[LIST_0][j][i] = ref_pic_num;
  586.           }
  587.         }
  589.         if (bslice)
  590.         {
  591.           //--- get cost and reference frame for LIST 1 prediction ---
  592.           bmcost[LIST_1] = INT_MAX;
  593.           bmcost[BI_PRED] = INT_MAX;
  594.           list_prediction_cost(currMB, LIST_1, block, mode, enc_mb, bmcost, best_ref);
  596.           // Compute bipredictive cost between best list 0 and best list 1 references
  597.           list_prediction_cost(currMB, BI_PRED, block, mode, enc_mb, bmcost, best_ref);
  598.           
  599.           // currently Bi prediction ME is only supported for modes 1, 2, 3 and only for ref 0 and only for ref 0
  600.           if (is_bipred_enabled(mode))
  601.           {
  602.             list_prediction_cost(currMB, BI_PRED_L0, block, mode, enc_mb, bmcost, 0);
  603.             list_prediction_cost(currMB, BI_PRED_L1, block, mode, enc_mb, bmcost, 0);
  604.           }
  605.           else
  606.           {
  607.             bmcost[BI_PRED_L0] = INT_MAX;
  608.             bmcost[BI_PRED_L1] = INT_MAX;
  609.           }
  611.           //--- get prediction direction ----
  612.           determine_prediction_list(mode, bmcost, best_ref, &best_pdir, cost, &bipred_me);
  613.         
  614.           //store backward reference index for every block
  615.           for (k = LIST_0; k <= LIST_1; k++)
  616.           {
  617.             for (j = block_y; j< block_y + 2; j++)
  618.             {
  619.               memset(&enc_picture->motion.ref_idx[k][j][block_x], best_ref[k], 2 * sizeof(char));
  620.             }
  621.           }
  622.         } // if (bslice)
  623.         else
  624.         {
  625.           best_pdir = 0;
  626.           *cost     = bmcost[LIST_0];
  627.         }
  628.       } // if (mode!=0)
  630.       if (params->rdopt)
  631.       {
  632.         //--- get and check rate-distortion cost ---
  633.         rdcost = RDCost_for_8x8blocks (currMB, &cnt_nonz, &curr_cbp_blk, enc_mb->lambda_md,
  634.           block, mode, best_pdir, best_ref[LIST_0], best_ref[LIST_1], bipred_me, is_cavlc);
  635.       }
  636.       else
  637.       {
  638.         if (*cost!=INT_MAX)
  639.           *cost += (REF_COST (enc_mb->lambda_mf[Q_PEL], B8Mode2Value (mode, best_pdir),
  640.           enc_mb->list_offset[(best_pdir < 1 ? LIST_0 : LIST_1)]) - 1);
  641.       }
  643.       //--- set variables if best mode has changed ---
  644.       if ( ( params->rdopt && rdcost < min_rdcost) || (!params->rdopt && *cost < min_cost8x8))
  645.       {
  646.         min_cost8x8                  = *cost;
  647.         min_rdcost                   = rdcost;
  648.         dataTr->part8x8mode  [block] = mode;
  649.         dataTr->part8x8pdir  [block] = best_pdir;
  650.         dataTr->part8x8l0ref [block] = best_ref[LIST_0];
  651.         dataTr->part8x8l1ref [block] = best_ref[LIST_1];
  652.         dataTr->part8x8bipred[block] = bipred_me;
  654.         currMB->b8mode[block] = mode;
  656. #ifdef BEST_NZ_COEFF
  657.         if (cnt_nonz)
  658.         {
  659.           for(i = 0; i <= 1; i++)
  660.           {
  661.             for(j = 0; j <= 1; j++)  
  662.               best_nz_coeff[i][j]= img->nz_coeff[img->current_mb_nr][i1 + i][j1 + j];
  663.           }
  664.         }
  665.         else
  666.         {
  667.           for(i = 0; i <= 1; i++)
  668.           {
  669.             best_nz_coeff[i][0]= 0;
  670.             best_nz_coeff[i][1]= 0;
  671.           }
  672.         }
  673. #endif
  675.         //--- store number of nonzero coefficients ---
  676.         best_cnt_nonz  = cnt_nonz;
  678.         if (params->rdopt)
  679.         {
  680.           //--- store block cbp ---
  681.           cbp_blk8x8 &= (~(0x33 << (((block>>1)<<3)+((block & 0x01)<<1)))); // delete bits for block
  682.           cbp_blk8x8 |= curr_cbp_blk;
  684.           //--- store coefficients ---
  685.           memcpy(&cofACtr[0][0][0],&img->cofAC[block][0][0][0], 4 * 2 * 65 * sizeof(int));
  687.           if( img->P444_joined ) 
  688.           {
  689.             //--- store coefficients ---
  690.             memcpy(&cofACCbCrtr1[0][0][0],&img->cofAC[block + 4][0][0][0], 4 * 2 * 65 * sizeof(int));
  691.             memcpy(&cofACCbCrtr2[0][0][0],&img->cofAC[block + 8][0][0][0], 4 * 2 * 65 * sizeof(int));
  692.           }
  693.           
  694.           //--- store reconstruction and prediction ---
  695.           for (j=j0; j<j0 + BLOCK_SIZE_8x8; j++)
  696.           {
  697.             memcpy(&dataTr->rec_mbY8x8[j][i0],&enc_picture->imgY[img->pix_y + j][img->pix_x + i0], BLOCK_SIZE_8x8 * sizeof(imgpel));
  698.             memcpy(&dataTr->mpr8x8[j][i0],&mb_pred[j][i0], BLOCK_SIZE_8x8 * sizeof(imgpel));
  699.           }
  701.           if (params->rdopt == 3)
  702.           {
  703.             errdo_store_best_block(img, decs->dec_mbY8x8, enc_picture->p_dec_img[0], i0, j0, BLOCK_SIZE_8x8);  //Store best 8x8 block for each hypothetical decoder
  704.           }
  706.           if(img->type==SP_SLICE && (!si_frame_indicator))
  707.           {
  708.             for (j=j0; j<j0 + BLOCK_SIZE_8x8; j++)
  709.             {
  710.               memcpy(&dataTr->lrec[j][i0],&lrec[img->pix_y + j][img->pix_x + i0], BLOCK_SIZE_8x8 * sizeof(int));
  711.             }
  712.           }
  713.  
  714.           if(img->P444_joined) 
  715.           {
  716.             for (j=j0; j<j0+8; j++)    
  717.             {
  718.               memcpy(&dataTr->rec_mb8x8_cr[0][j][i0],&enc_picture->imgUV[0][img->pix_y + j][img->pix_x + i0], BLOCK_SIZE_8x8 * sizeof(imgpel));
  719.               memcpy(&dataTr->rec_mb8x8_cr[1][j][i0],&enc_picture->imgUV[1][img->pix_y + j][img->pix_x + i0], BLOCK_SIZE_8x8 * sizeof(imgpel));
  720.               memcpy(&dataTr->mpr8x8CbCr[0][j][i0],&img->mb_pred[1][j][i0], BLOCK_SIZE_8x8 * sizeof(imgpel));
  721.               memcpy(&dataTr->mpr8x8CbCr[1][j][i0],&img->mb_pred[2][j][i0], BLOCK_SIZE_8x8 * sizeof(imgpel));
  722.             }
  723.           }
  724.           
  725.         }
  726.         if (img->AdaptiveRounding)
  727.         {
  728.           for (j=j0; j<j0+8; j++)
  729.           {
  730.             memcpy(&fadjust[j][i0], &fadjustTransform[0][j][i0], 8 * sizeof(int));
  731.           }
  733.           if (params->AdaptRndChroma || (img->P444_joined))
  734.           {
  735.             int j0_cr = (j0 * img->mb_cr_size_y) / MB_BLOCK_SIZE;
  736.             int i0_cr = (i0 * img->mb_cr_size_x) / MB_BLOCK_SIZE;
  737.             for (k = 0; k < 2; k++)
  738.             {
  739.               for (j=j0_cr; j < j0_cr + (img->mb_cr_size_y >> 1); j++)
  740.               {
  741.                 memcpy(&fadjustCr[k][j][i0_cr], &fadjustTransformCr[k][0][j][i0_cr], (img->mb_cr_size_x >> 1) * sizeof(int));
  742.               }
  743.             }
  744.           }
  745.         }
  746.         //--- store best 8x8 coding state ---
  747.         if (block < 3)
  748.           store_coding_state (currMB, cs_b8);
  749.       } // if (rdcost <= min_rdcost)
  751.       //--- re-set coding state as it was before coding with current mode was performed ---
  752.       reset_coding_state (currMB, cs_cm);
  753.     } // if ((enc_mb->valid[mode] && (transform8x8 == 0 || mode != 0 || (mode == 0 && active_sps->direct_8x8_inference_flag)))
  754.   } // for (min_rdcost=1e30, index=(bslice?0:1); index<6; index++)
  756. #ifdef BEST_NZ_COEFF
  757.   for(i = 0; i <= 1; i++)  
  758.   {
  759.     for(j = 0; j <= 1; j++)
  760.       img->nz_coeff[img->current_mb_nr][i1 + i][j1 + j] = best_nz_coeff[i][j];
  761.   }
  762. #endif
  764.   if (!transform8x8)
  765.     dataTr->mb_p8x8_cost += min_cost8x8;
  767.   if (!params->rdopt)
  768.   {
  769.     if (transform8x8)
  770.     {
  771.       dataTr->mb_p8x8_cost += min_cost8x8;
  772.       mode = dataTr->part8x8mode[block];
  773.       pdir = dataTr->part8x8pdir[block];
  774.     }
  775.     else
  776.     {
  777.       mode = dataTr->part8x8mode[block];
  778.       pdir = dataTr->part8x8pdir[block];
  779.     }
  781.     curr_cbp_blk  = 0;
  782.     currMB->bipred_me[block] = dataTr->part8x8bipred[block];
  783.     best_cnt_nonz = LumaResidualCoding8x8 (currMB, &dummy, &curr_cbp_blk, block, pdir,
  784.       (pdir == 0 || pdir == 2 ? mode : 0), (pdir == 1 || pdir == 2 ? mode : 0), 
  785.       dataTr->part8x8l0ref[block], dataTr->part8x8l1ref[block], is_cavlc);
  787.     if (img->P444_joined)
  788.       best_cnt_nonz += coeff_cost_cr[1] + coeff_cost_cr[2];
  790.     cbp_blk8x8   &= (~(0x33 << (((block>>1)<<3)+((block & 0x01)<<1)))); // delete bits for block
  791.     cbp_blk8x8   |= curr_cbp_blk;
  793.     //--- store coefficients ---
  794.     memcpy(cofACtr[0][0],img->cofAC[block][0][0],4 * 2 * 65 * sizeof(int));
  796.     if(img->P444_joined) 
  797.     {
  798.       //--- store coefficients ---
  799.       memcpy(cofACCbCrtr1[0][0],img->cofAC[block + 4][0][0], 4 * 2 * 65 * sizeof(int));
  800.       memcpy(cofACCbCrtr2[0][0],img->cofAC[block + 8][0][0], 4 * 2 * 65 * sizeof(int));
  801.     }
  804.     //--- store reconstruction and prediction ---
  805.     for (j = j0; j < j0 + BLOCK_SIZE_8x8; j++)
  806.     {
  807.       memcpy(&dataTr->rec_mbY8x8[j][i0], &enc_picture->imgY[img->pix_y + j][img->pix_x + i0], BLOCK_SIZE_8x8 * sizeof (imgpel));
  808.     }
  809.     for (j = j0; j < j0 + BLOCK_SIZE_8x8; j++)
  810.     {
  811.       memcpy(&dataTr->mpr8x8[j][i0], &mb_pred[j][i0], BLOCK_SIZE_8x8 * sizeof (imgpel));
  812.     }
  815.     //--- store reconstruction and prediction ---
  816.     if(img->type==SP_SLICE &&(!si_frame_indicator))
  817.     {
  818.       for (j=j0; j < j0 + BLOCK_SIZE_8x8; j++)
  819.       {
  820.         memcpy(&dataTr->lrec[j][i0],&lrec[img->pix_y+j][img->pix_x+i0],BLOCK_SIZE_8x8 * sizeof(int)); // store coefficients for primary SP slice
  821.       }
  822.     }
  823.     if(img->P444_joined) 
  824.     {
  825.       for (j=j0; j < j0 + BLOCK_SIZE_8x8; j++)
  826.       {   
  827.         memcpy(&dataTr->rec_mb8x8_cr[0][j][i0], &enc_picture->imgUV[0][img->pix_y + j][img->pix_x + i0], BLOCK_SIZE_8x8 * sizeof (imgpel));
  828.         memcpy(&dataTr->rec_mb8x8_cr[1][j][i0], &enc_picture->imgUV[1][img->pix_y + j][img->pix_x + i0], BLOCK_SIZE_8x8 * sizeof (imgpel));
  829.         memcpy(&dataTr->mpr8x8CbCr[0][j][i0], &img->mb_pred[1][j][i0], BLOCK_SIZE_8x8 * sizeof (imgpel)); 
  830.         memcpy(&dataTr->mpr8x8CbCr[1][j][i0], &img->mb_pred[2][j][i0], BLOCK_SIZE_8x8 * sizeof (imgpel));
  831.       }
  832.     }   
  833.   }
  835.   //----- set cbp and count of nonzero coefficients ---
  836.   if (best_cnt_nonz)
  837.   {
  838.     cbp8x8       |= (1 << block);
  839.     cnt_nonz_8x8 += best_cnt_nonz;
  840.   }
  842.   if (!transform8x8)
  843.   {
  844.     if (block<3)
  845.     {
  846.       //===== re-set reconstructed block =====
  847.       j0   = 8*(block >> 1);
  848.       i0   = 8*(block & 0x01);
  849.       for (j = j0; j < j0 + BLOCK_SIZE_8x8; j++)
  850.       {
  851.         memcpy(&enc_picture->imgY[img->pix_y + j][img->pix_x], dataTr->rec_mbY8x8[j], BLOCK_SIZE_8x8 * sizeof(imgpel));
  852.       }
  854.       if (params->rdopt == 3)
  855.       {
  856.         errdo_get_best_block(img, enc_picture->p_dec_img[0], decs->dec_mbY8x8, j0, BLOCK_SIZE_8x8);
  857.       }
  859.       if(img->type==SP_SLICE &&(!si_frame_indicator))
  860.       {
  861.         for (j = j0; j < j0 + BLOCK_SIZE_8x8; j++)
  862.         {
  863.           memcpy(&lrec[img->pix_y + j][img->pix_x], dataTr->lrec[j],2*BLOCK_SIZE*sizeof(imgpel)); // reset the coefficients for SP slice
  864.         }
  865.       }
  867.       if(img->P444_joined) 
  868.       {
  869.         for (k=0; k<2; k++)
  870.         {
  871.           for (j = j0; j < j0 + BLOCK_SIZE_8x8; j++)
  872.           {
  873.             memcpy(&enc_picture->imgUV[k][img->pix_y + j][img->pix_x], dataTr->rec_mb8x8_cr[k][j], BLOCK_SIZE_8x8 * sizeof(imgpel));
  874.           }
  875.         }
  876.       }
  877.     } // if (block<3)
  878.   }
  879.   else
  880.   {
  881.     //======= save motion data for 8x8 partition for transform size 8x8 ========
  882.     StoreNewMotionVectorsBlock8x8(0, block, dataTr->part8x8mode[block], dataTr->part8x8l0ref[block], dataTr->part8x8l1ref[block], dataTr->part8x8pdir[block], dataTr->part8x8bipred[block], bslice);
  883.   }
  884.   //===== set motion vectors and reference frames (prediction) =====
  885.   SetRefAndMotionVectors (currMB, block, dataTr->part8x8mode[block], dataTr->part8x8pdir[block], dataTr->part8x8l0ref[block], dataTr->part8x8l1ref[block], dataTr->part8x8bipred[block]);
  887.   //===== set the coding state after current block =====
  888.   //if (transform8x8 == 0 || block < 3)
  889.   if (block < 3)
  890.     reset_coding_state (currMB, cs_b8);
  892.   if (img->AdaptiveRounding)
  893.   {
  894.     for (j=j0; j < j0 + BLOCK_SIZE_8x8; j++)
  895.     {
  896.       memcpy(&fadjustTransform  [lumaAdjustIndex][j][i0], &fadjust[j][i0], BLOCK_SIZE_8x8 * sizeof(int));
  897.     }
  899.     if (params->AdaptRndChroma || (img->P444_joined))
  900.     {
  901.       int j0_cr = (j0 * img->mb_cr_size_y) >> MB_BLOCK_SHIFT;
  902.       int i0_cr = (i0 * img->mb_cr_size_x) >> MB_BLOCK_SHIFT;
  903.       for (k = 0; k < 2; k++)
  904.       {
  905.         for (j=j0_cr; j<j0_cr+(img->mb_cr_size_y >> 1); j++)
  906.         {
  907.           memcpy(&fadjustTransformCr[k][chromaAdjustIndex][j][i0_cr], &fadjustCr[k][j][i0_cr], (img->mb_cr_size_x >> 1) * sizeof(int));
  908.         }
  909.       }
  910.     }
  911.   }
  912. }
  915. /*!
  916. *************************************************************************************
  917. * brief
  918. *    Checks whether a primary SP slice macroblock was encoded as I16
  919. *************************************************************************************
  920. */
  921. int check_for_SI16()
  922. {
  923.   int i,j;
  924.   for(i=img->pix_y;i<img->pix_y+MB_BLOCK_SIZE;i++)
  925.   {
  926.     for(j=img->pix_x;j<img->pix_x+MB_BLOCK_SIZE;j++)
  927.       if(lrec[i][j]!=-16)
  928.         return 0;
  929.   }
  930.   return 1;
  931. }
  933. void get_initial_mb16x16_cost(Macroblock* currMB)
  934. {
  935.   if (currMB->mb_available_left && currMB->mb_available_up)
  936.   {
  937.     mb16x16_cost = (mb16x16_cost_frame[img->current_mb_nr - 1] +
  938.       mb16x16_cost_frame[img->current_mb_nr - (img->width>>4)] + 1)/2.0;
  939.   }
  940.   else if (currMB->mb_available_left)
  941.   {
  942.     mb16x16_cost = mb16x16_cost_frame[img->current_mb_nr - 1];
  943.   }
  944.   else if (currMB->mb_available_up)
  945.   {
  946.     mb16x16_cost = mb16x16_cost_frame[img->current_mb_nr - (img->width>>4)];
  947.   }
  948.   else
  949.   {
  950.     mb16x16_cost = CALM_MF_FACTOR_THRESHOLD;
  951.   }
  953.   lambda_mf_factor = mb16x16_cost < CALM_MF_FACTOR_THRESHOLD ? 1.0 : sqrt(mb16x16_cost / (CALM_MF_FACTOR_THRESHOLD * img->lambda_mf_factor[img->type][img->qp]));
  954. }
  956. void adjust_mb16x16_cost(int cost)
  957. {
  958.   mb16x16_cost = (double) cost;
  959.   mb16x16_cost_frame[img->current_mb_nr] = mb16x16_cost;
  961.   lambda_mf_factor = (mb16x16_cost < CALM_MF_FACTOR_THRESHOLD)
  962.   ? 1.0
  963.   : sqrt(mb16x16_cost / (CALM_MF_FACTOR_THRESHOLD * img->lambda_mf_factor[img->type][img->qp]));
  964. }
  966. void update_lambda_costs(RD_PARAMS *enc_mb, int lambda_mf[3])
  967. {
  968.   int MEPos;
  969.   for (MEPos = 0; MEPos < 3; MEPos ++)
  970.   {
  971.     lambda_mf[MEPos] = params->CtxAdptLagrangeMult == 0 ? enc_mb->lambda_mf[MEPos] : (int)(enc_mb->lambda_mf[MEPos] * sqrt(lambda_mf_factor));
  972.   }
  973. }
  975. /*!
  976.  *************************************************************************************
  977.  * brief
  978.  *    Return array's minimum and its index
  979.  *************************************************************************************
  980.  */
  981. int iminarray ( int arr[], int size, int *minind )
  982. {
  983.   int i; 
  984.   int mincand = arr[0];
  985.   *minind = 0;
  986.   for ( i = 1; i < size; i++ )
  987.   {
  988.     if (arr[i] < mincand)
  989.     {
  990.       mincand = arr[i];
  991.       *minind = i;
  992.     }
  993.   }
  994.   return mincand;
  995. } 
  997. /*!
  998.  *************************************************************************************
  999.  * brief
  1000.  *    Determines whether bi prediction is enabaled for current mode
  1001.  *************************************************************************************
  1002.  */
  1003. int is_bipred_enabled(int mode) 
  1004. {
  1005.   int enabled = 0;
  1006.   mode = (mode == P8x8) ? 4: mode;
  1007.   if (params->BiPredMotionEstimation)
  1008.   {
  1009.     if (mode > 0 && mode < 5)
  1010.     {
  1011.       enabled = (params->BiPredSearch[mode - 1]) ? 1: 0;
  1012.     }    
  1013.     else
  1014.     {
  1015.       enabled = 0;
  1016.     }
  1017.   }
  1018.   else
  1019.   {
  1020.     enabled = 0;
  1021.   }
  1022.   return enabled;
  1023. }
  1026. /*!
  1027.  *************************************************************************************
  1028.  * brief
  1029.  *    Update prediction direction for mode P16x16 to check all prediction directions
  1030.  *************************************************************************************
  1031.  */
  1032. void update_prediction_for_mode16x16(Block8x8Info *b8x8info, int ctr16x16, int *index)
  1033. {
  1034.   char pdir = 0;
  1035.   short i, bipred_me = 0;
  1036.   switch (ctr16x16)
  1037.   {
  1038.     case 0:
  1039.       *index = *index - 1;
  1040.       break;
  1041.     case 1:
  1042.       pdir = 1;
  1043.       *index = *index - 1;
  1044.       break;
  1045.     case 2:
  1046.       pdir = 2;
  1047.       if (params->BiPredMotionEstimation)
  1048.       {
  1049.         *index = *index - 1;
  1050.       }
  1051.       break;
  1052.     case 3:
  1053.       pdir = 2;
  1054.       bipred_me = 1;
  1055.       *index = *index - 1;
  1056.       break;
  1057.     case 4:
  1058.       pdir = 2;
  1059.       bipred_me = 2;
  1060.       break;
  1061.     default:
  1062.       error("invalid 'ctr16x16' value", -1);
  1063.       break;
  1064.   }
  1065.   for (i = 0; i< 4; i++)
  1066.   {
  1067.     b8x8info->bipred8x8me[1][i] = bipred_me;
  1068.     b8x8info->best8x8pdir[1][i] = pdir;
  1069.   }
  1070. }