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

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

Audio

开发平台：

Visual C++

md_low.c：源码内容
  2. /*!
  3.  ***************************************************************************
  4.  * file md_low.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 "q_around.h"
  31. //==== MODULE PARAMETERS ====
  32. static imgpel temp_imgY[16][16]; // to temp store the Y data for 8x8 transform
  33. static imgpel temp_imgU[16][16];
  34. static imgpel temp_imgV[16][16];
  37. /*!
  38. *************************************************************************************
  39. * brief
  40. *    Mode Decision for a macroblock
  41. *************************************************************************************
  42. */
  43. void encode_one_macroblock_low (Macroblock *currMB)
  44. {
  46.   int         block, mode, i=0, j, k, dummy;
  47.   char        best_pdir;
  48.   RD_PARAMS   enc_mb;
  49.   char        best_ref[2] = {0, -1};
  50.   int         bmcost[5] = {INT_MAX};
  51.   double      rd_cost = 0, min_rd_cost = 1e30;
  52.   int         cost = 0;
  53.   int         min_cost = INT_MAX, cost_direct=0, have_direct=0, i16mode=0;
  54.   int         intra1 = 0;
  55.   int         temp_cpb = 0;
  56.   int         best_transform_flag = 0;
  57.   int         cost8x8_direct = 0;
  58.   short       islice      = (short) (img->type==I_SLICE);
  59.   short       bslice      = (short) (img->type==B_SLICE);
  60.   short       pslice      = (short) ((img->type==P_SLICE) || (img->type==SP_SLICE));
  61.   short       intra       = (short) (islice || (pslice && img->mb_y==img->mb_y_upd && img->mb_y_upd!=img->mb_y_intra));
  62.   int         lambda_mf[3];
  63.   int         prev_mb_nr  = FmoGetPreviousMBNr(img->current_mb_nr);
  64.   Macroblock* prevMB      = (prev_mb_nr >= 0) ? &img->mb_data[prev_mb_nr]:NULL ;
  65.   Block8x8Info *b8x8info   = img->b8x8info;
  67.   char   **ipredmodes = img->ipredmode;
  68.   short   *allmvs = params->IntraProfile ? NULL: img->all_mv[0][0][0][0][0];
  69.   int     ****i4p;  //for non-RD-opt. mode
  70.   imgpel  (*mb_pred)[16] = img->mb_pred[0];
  71.   int    is_cavlc = (img->currentSlice->symbol_mode == CAVLC);
  73.   int tmp_8x8_flag, tmp_no_mbpart;
  74.   // Fast Mode Decision
  75.   short bipred_me, inter_skip = 0;
  78.   if(params->SearchMode == UM_HEX)
  79.   {
  80.     UMHEX_decide_intrabk_SAD();
  81.   }
  82.   else if (params->SearchMode == UM_HEX_SIMPLE)
  83.   {
  84.     smpUMHEX_decide_intrabk_SAD();
  85.   }
  87.   intra |= RandomIntra (img->current_mb_nr);    // Forced Pseudo-Random Intra
  89.   //===== Setup Macroblock encoding parameters =====
  90.   init_enc_mb_params(currMB, &enc_mb, intra, bslice);
  92.   // reset chroma intra predictor to default
  93.   currMB->c_ipred_mode = DC_PRED_8;
  95.   //=====   S T O R E   C O D I N G   S T A T E   =====
  96.   //---------------------------------------------------
  97.   store_coding_state (currMB, cs_cm);
  99.   if (!intra)
  100.   {
  101.     //===== set direct motion vectors =====
  102.     best_mode = 1;
  103.     if (bslice)
  104.     {
  105.       Get_Direct_Motion_Vectors (currMB);
  106.     }
  108.     if (params->CtxAdptLagrangeMult == 1)
  109.     {
  110.       get_initial_mb16x16_cost(currMB);
  111.     }
  113.     //===== MOTION ESTIMATION FOR 16x16, 16x8, 8x16 BLOCKS =====
  114.     for (min_cost=INT_MAX, mode=1; mode<4; mode++)
  115.     {
  116.       bipred_me = 0;
  117.       b8x8info->bipred8x8me[mode][0] = 0;
  118.       if (enc_mb.valid[mode] && !inter_skip)
  119.       {
  120.         for (cost=0, block=0; block<(mode==1?1:2); block++)
  121.         {
  122.           update_lambda_costs(&enc_mb, lambda_mf);
  123.           PartitionMotionSearch (currMB, mode, block, lambda_mf);
  125.           //--- set 4x4 block indizes (for getting MV) ---
  126.           j = (block==1 && mode==2 ? 2 : 0);
  127.           i = (block==1 && mode==3 ? 2 : 0);
  129.           //--- get cost and reference frame for List 0 prediction ---
  130.           bmcost[LIST_0] = INT_MAX;
  131.           list_prediction_cost(currMB, LIST_0, block, mode, &enc_mb, bmcost, best_ref);
  133.           if (bslice)
  134.           {
  135.             //--- get cost and reference frame for List 1 prediction ---
  136.             bmcost[LIST_1] = INT_MAX;
  137.             list_prediction_cost(currMB, LIST_1, block, mode, &enc_mb, bmcost, best_ref);
  139.             // Compute bipredictive cost between best list 0 and best list 1 references
  140.             list_prediction_cost(currMB, BI_PRED, block, mode, &enc_mb, bmcost, best_ref);
  142.             // currently Bi prediction ME is only supported for modes 1, 2, 3
  143.             if (is_bipred_enabled(mode))
  144.             {
  145.               list_prediction_cost(currMB, BI_PRED_L0, block, mode, &enc_mb, bmcost, 0);
  146.               list_prediction_cost(currMB, BI_PRED_L1, block, mode, &enc_mb, bmcost, 0);
  147.             }
  148.             else
  149.             {
  150.               bmcost[BI_PRED_L0] = INT_MAX;
  151.               bmcost[BI_PRED_L1] = INT_MAX;
  152.             }
  154.             // Determine prediction list based on mode cost
  155.             determine_prediction_list(mode, bmcost, best_ref, &best_pdir, &cost, &bipred_me);
  156.           }
  157.           else // if (bslice)
  158.           {
  159.             best_pdir  = 0;
  160.             cost      += bmcost[LIST_0];
  161.           }
  163.           assign_enc_picture_params(mode, best_pdir, block, enc_mb.list_offset[LIST_0], best_ref[LIST_0], best_ref[LIST_1], bslice, bipred_me);          
  164.           //----- set reference frame and direction parameters -----
  165.           set_block8x8_info(b8x8info, mode, block, best_ref, best_pdir, bipred_me);
  167.           //--- set reference frames and motion vectors ---
  168.           if (mode>1 && block==0)
  169.             SetRefAndMotionVectors (currMB, block, mode, best_pdir, best_ref[LIST_0], best_ref[LIST_1], bipred_me);
  170.         } // for (block=0; block<(mode==1?1:2); block++)
  172.         currMB->luma_transform_size_8x8_flag = 0;
  173.         if (params->Transform8x8Mode) //for inter rd-off, set 8x8 to do 8x8 transform
  174.         {
  175.           SetModesAndRefframeForBlocks(currMB, mode);
  176.           currMB->luma_transform_size_8x8_flag = TransformDecision(currMB, -1, &cost);
  177.         }
  179.         if ((!inter_skip) && (cost < min_cost))
  180.         {
  181.           best_mode = (short) mode;
  182.           min_cost  = cost;
  183.           best_transform_flag = currMB->luma_transform_size_8x8_flag;
  185.           if (params->CtxAdptLagrangeMult == 1)
  186.           {
  187.             adjust_mb16x16_cost(cost);
  188.           }
  189.         }
  190.       } // if (enc_mb.valid[mode])
  191.     } // for (mode=1; mode<4; mode++)
  193.     if ((!inter_skip) && enc_mb.valid[P8x8])
  194.     {
  195.       giRDOpt_B8OnlyFlag = 1;
  197.       tr8x8.mb_p8x8_cost = INT_MAX;
  198.       tr4x4.mb_p8x8_cost = INT_MAX;
  199.       //===== store coding state of macroblock =====
  200.       store_coding_state (currMB, cs_mb);
  202.       currMB->all_blk_8x8 = -1;
  204.       if (params->Transform8x8Mode)
  205.       {
  206.         tr8x8.mb_p8x8_cost = 0;
  207.         //===========================================================
  208.         // Check 8x8 partition with transform size 8x8
  209.         //===========================================================
  210.         //=====  LOOP OVER 8x8 SUB-PARTITIONS  (Motion Estimation & Mode Decision) =====
  211.         for (cost_direct=cbp8x8=cbp_blk8x8=cnt_nonz_8x8=0, block = 0; block < 4; block++)
  212.         {
  213.           submacroblock_mode_decision(&enc_mb, &tr8x8, currMB, cofAC8x8ts[0][block], cofAC8x8ts[1][block], cofAC8x8ts[2][block],
  214.             &have_direct, bslice, block, &cost_direct, &cost, &cost8x8_direct, 1, is_cavlc);
  215.           set_subblock8x8_info(b8x8info, P8x8, block, &tr8x8);
  216.         }
  218.         // following params could be added in RD_8x8DATA structure
  219.         cbp8_8x8ts      = cbp8x8;
  220.         cbp_blk8_8x8ts  = cbp_blk8x8;
  221.         cnt_nonz8_8x8ts = cnt_nonz_8x8;
  222.         currMB->luma_transform_size_8x8_flag = 0; //switch to 4x4 transform size
  224.         //--- re-set coding state (as it was before 8x8 block coding) ---
  225.         //reset_coding_state (currMB, cs_mb);
  226.       }// if (params->Transform8x8Mode)
  229.       if (params->Transform8x8Mode != 2)
  230.       {
  231.         tr4x4.mb_p8x8_cost = 0;
  232.         //=================================================================
  233.         // Check 8x8, 8x4, 4x8 and 4x4 partitions with transform size 4x4
  234.         //=================================================================
  235.         //=====  LOOP OVER 8x8 SUB-PARTITIONS  (Motion Estimation & Mode Decision) =====
  236.         for (cost_direct=cbp8x8=cbp_blk8x8=cnt_nonz_8x8=0, block=0; block<4; block++)
  237.         {
  238.           submacroblock_mode_decision(&enc_mb, &tr4x4, currMB, cofAC8x8[block], cofAC8x8CbCr[0][block], cofAC8x8CbCr[1][block],
  239.             &have_direct, bslice, block, &cost_direct, &cost, &cost8x8_direct, 0, is_cavlc);
  240.           set_subblock8x8_info(b8x8info, P8x8, block, &tr4x4);
  241.         }
  242.         //--- re-set coding state (as it was before 8x8 block coding) ---
  243.         // reset_coding_state (currMB, cs_mb);
  244.       }// if (params->Transform8x8Mode != 2)
  246.       //--- re-set coding state (as it was before 8x8 block coding) ---
  247.       reset_coding_state (currMB, cs_mb);
  250.       // This is not enabled yet since mpr has reverse order.
  251.       if (params->RCEnable)
  252.         rc_store_diff(img->opix_x, img->opix_y, mb_pred);
  254.       //check cost for P8x8 for non-rdopt mode
  255.       if (tr4x4.mb_p8x8_cost < min_cost || tr8x8.mb_p8x8_cost < min_cost)
  256.       {
  257.         best_mode = P8x8;
  259.         if (img->AdaptiveRounding)
  260.           store_adaptive_rounding_parameters_luma (currMB, best_mode);
  262.         if (params->Transform8x8Mode == 2)
  263.         {
  264.           min_cost = tr8x8.mb_p8x8_cost;
  265.           currMB->luma_transform_size_8x8_flag=1;
  266.         }
  267.         else if (params->Transform8x8Mode)
  268.         {
  269.           if (tr8x8.mb_p8x8_cost < tr4x4.mb_p8x8_cost)
  270.           {
  271.             min_cost = tr8x8.mb_p8x8_cost;
  272.             currMB->luma_transform_size_8x8_flag=1;
  273.           }
  274.           else if(tr4x4.mb_p8x8_cost < tr8x8.mb_p8x8_cost)
  275.           {
  276.             min_cost = tr4x4.mb_p8x8_cost;
  277.             currMB->luma_transform_size_8x8_flag=0;
  278.           }
  279.           else
  280.           {
  281.             if (GetBestTransformP8x8() == 0)
  282.             {
  283.               min_cost = tr4x4.mb_p8x8_cost;
  284.               currMB->luma_transform_size_8x8_flag=0;
  285.             }
  286.             else
  287.             {
  288.               min_cost = tr8x8.mb_p8x8_cost;
  289.               currMB->luma_transform_size_8x8_flag=1;
  290.             }
  291.           }
  292.         }
  293.         else
  294.         {
  295.           min_cost = tr4x4.mb_p8x8_cost;
  296.           currMB->luma_transform_size_8x8_flag=0;
  297.         }
  298.       }// if ((tr4x4.mb_p8x8_cost < min_cost || tr8x8.mb_p8x8_cost < min_cost))
  299.       giRDOpt_B8OnlyFlag = 0;
  300.     }
  301.     else // if (enc_mb.valid[P8x8])
  302.     {
  303.       tr4x4.mb_p8x8_cost = INT_MAX;
  304.     }
  306.     // Find a motion vector for the Skip mode
  307.     if(pslice)
  308.       FindSkipModeMotionVector (currMB);
  309.   }
  310.   else // if (!intra)
  311.   {
  312.     min_cost = INT_MAX;
  313.   }
  315.   //========= C H O O S E   B E S T   M A C R O B L O C K   M O D E =========
  316.   //-------------------------------------------------------------------------
  317.   tmp_8x8_flag = currMB->luma_transform_size_8x8_flag;  //save 8x8_flag
  318.   tmp_no_mbpart = currMB->NoMbPartLessThan8x8Flag;      //save no-part-less
  319.   if ((img->yuv_format != YUV400) && (img->yuv_format != YUV444))
  320.     // precompute all chroma intra prediction modes
  321.     IntraChromaPrediction(currMB, NULL, NULL, NULL);
  323.   if (enc_mb.valid[0] && bslice) // check DIRECT MODE
  324.   {
  325.     if(have_direct)
  326.     {
  327.       switch(params->Transform8x8Mode)
  328.       {
  329.       case 1: // Mixture of 8x8 & 4x4 transform
  330.         cost = ((cost8x8_direct < cost_direct) || !(enc_mb.valid[5] && enc_mb.valid[6] && enc_mb.valid[7]))
  331.           ? cost8x8_direct : cost_direct;
  332.         break;
  333.       case 2: // 8x8 Transform only
  334.         cost = cost8x8_direct;
  335.         break;
  336.       default: // 4x4 Transform only
  337.         cost = cost_direct;
  338.         break;
  339.       }
  340.     }
  341.     else
  342.     { //!have_direct
  343.       cost = GetDirectCostMB (currMB, bslice);
  344.     }
  345.     if (cost!=INT_MAX)
  346.     {
  347.       cost -= (int)floor(16*enc_mb.lambda_md+0.4999);
  348.     }
  350.     if (cost <= min_cost)
  351.     {
  352.       if(active_sps->direct_8x8_inference_flag && params->Transform8x8Mode)
  353.       {
  354.         if(params->Transform8x8Mode==2)
  355.           currMB->luma_transform_size_8x8_flag=1;
  356.         else
  357.         {
  358.           if(cost8x8_direct < cost_direct)
  359.             currMB->luma_transform_size_8x8_flag=1;
  360.           else
  361.             currMB->luma_transform_size_8x8_flag=0;
  362.         }
  363.       }
  364.       else
  365.         currMB->luma_transform_size_8x8_flag=0;
  367.       //Rate control
  368.       if (params->RCEnable)
  369.         rc_store_diff(img->opix_x, img->opix_y, mb_pred);
  371.       min_cost  = cost;
  372.       best_mode = 0;
  373.       tmp_8x8_flag = currMB->luma_transform_size_8x8_flag;
  374.     }
  375.     else
  376.     {
  377.       currMB->luma_transform_size_8x8_flag = tmp_8x8_flag; // restore if not best
  378.       currMB->NoMbPartLessThan8x8Flag = tmp_no_mbpart; // restore if not best
  379.     }
  380.   }
  382.   min_rd_cost = (double) min_cost;
  384.   if (enc_mb.valid[I8MB]) // check INTRA8x8
  385.   {
  386.     currMB->luma_transform_size_8x8_flag = 1; // at this point cost will ALWAYS be less than min_cost
  388.     currMB->mb_type = I8MB;
  389.     temp_cpb = Mode_Decision_for_new_Intra8x8Macroblock (currMB, enc_mb.lambda_md, &rd_cost);
  392.     if (rd_cost <= min_rd_cost) //HYU_NOTE. bug fix. 08/15/07
  393.     {
  394.       currMB->cbp = temp_cpb;
  395.       if (img->P444_joined)
  396.       {
  397.         curr_cbp[0] = cmp_cbp[1];  
  398.         curr_cbp[1] = cmp_cbp[2];
  399.       }
  401.       if(enc_mb.valid[I4MB])   //KHHan. bug fix. Oct.15.2007
  402.       {
  403.         //coeffs
  404.         if (params->Transform8x8Mode != 2) 
  405.         {
  406.           i4p=cofAC; cofAC=img->cofAC; img->cofAC=i4p;
  407.         }
  408.       }
  410.       for(j=0; j<MB_BLOCK_SIZE; j++)
  411.       {
  412.         memcpy(temp_imgY[j], &enc_picture->imgY[img->pix_y + j][img->pix_x], MB_BLOCK_SIZE * sizeof (imgpel));
  413.       }
  415.       if (img->P444_joined)
  416.       {
  417.         for(j=0; j<MB_BLOCK_SIZE; j++)
  418.         {
  419.           memcpy(temp_imgU[j], &enc_picture->imgUV[0][img->pix_y + j][img->pix_x], MB_BLOCK_SIZE * sizeof (imgpel));
  420.           memcpy(temp_imgV[j], &enc_picture->imgUV[1][img->pix_y + j][img->pix_x], MB_BLOCK_SIZE * sizeof (imgpel));
  421.         }
  422.       }
  424.       //Rate control
  425.       if (params->RCEnable)
  426.         rc_store_diff(img->opix_x, img->opix_y, mb_pred);
  428.       min_rd_cost  = rd_cost; 
  429.       best_mode = I8MB;
  430.       tmp_8x8_flag = currMB->luma_transform_size_8x8_flag;
  431.     }
  432.     else
  433.     {
  434.       currMB->luma_transform_size_8x8_flag = tmp_8x8_flag; // restore if not best
  435.       if (img->P444_joined)
  436.       {
  437.         cmp_cbp[1] = curr_cbp[0]; 
  438.         cmp_cbp[2] = curr_cbp[1]; 
  439.         currMB->cbp |= cmp_cbp[1];    
  440.         currMB->cbp |= cmp_cbp[2];    
  441.         cmp_cbp[1] = currMB->cbp;   
  442.         cmp_cbp[2] = currMB->cbp;
  443.       }
  444.     }
  445.   }
  447.   if (enc_mb.valid[I4MB]) // check INTRA4x4
  448.   {
  449.     currMB->luma_transform_size_8x8_flag = 0;
  450.     currMB->mb_type = I4MB;
  451.     temp_cpb = Mode_Decision_for_Intra4x4Macroblock (currMB, enc_mb.lambda_md, &rd_cost, is_cavlc);
  453.     if (rd_cost <= min_rd_cost) 
  454.     {
  455.       currMB->cbp = temp_cpb;
  457.       //Rate control
  458.       if (params->RCEnable)
  459.         rc_store_diff(img->opix_x, img->opix_y, mb_pred);
  461.       min_rd_cost  = rd_cost; 
  462.       best_mode = I4MB;
  463.       tmp_8x8_flag = currMB->luma_transform_size_8x8_flag;
  465.       if (img->AdaptiveRounding)
  466.         store_adaptive_rounding_parameters_luma (currMB, best_mode);
  467.     }
  468.     else
  469.     {
  470.       currMB->luma_transform_size_8x8_flag = tmp_8x8_flag; // restore if not best
  471.       if (img->P444_joined)
  472.       {
  473.         cmp_cbp[1] = curr_cbp[0]; 
  474.         cmp_cbp[2] = curr_cbp[1]; 
  475.         currMB->cbp |= cmp_cbp[1];    
  476.         currMB->cbp |= cmp_cbp[2];    
  477.         cmp_cbp[1] = currMB->cbp;   
  478.         cmp_cbp[2] = currMB->cbp;
  479.       }
  480.       //coeffs
  481.       i4p=cofAC; cofAC=img->cofAC; img->cofAC=i4p;
  482.     }
  483.   }
  484.   if (enc_mb.valid[I16MB]) // check INTRA16x16
  485.   {
  486.     currMB->luma_transform_size_8x8_flag = 0;
  487.     intrapred_16x16 (currMB, PLANE_Y);
  488.     if (img->P444_joined)
  489.     {
  490.       select_plane(PLANE_U);
  491.       intrapred_16x16 (currMB, PLANE_U);
  492.       select_plane(PLANE_V);
  493.       intrapred_16x16 (currMB, PLANE_V);
  494.       select_plane(PLANE_Y);
  495.     }
  496.     switch(params->FastIntra16x16)
  497.     {
  498.     case 0:
  499.     default:
  500.       find_sad_16x16 = find_sad_16x16_JM;
  501.       break;
  502.     }
  504.     rd_cost = find_sad_16x16 (currMB, &i16mode);
  506.     if (rd_cost < min_rd_cost)
  507.     {
  508.       //Rate control      
  509.       if (params->RCEnable)
  510.         rc_store_diff(img->opix_x,img->opix_y,img->mpr_16x16[0][i16mode]);
  512.       best_mode   = I16MB;      
  513.       min_rd_cost  = rd_cost; 
  514.       currMB->cbp = pDCT_16x16 (currMB, PLANE_Y, i16mode, is_cavlc);
  516.       if (img->AdaptiveRounding)
  517.         store_adaptive_rounding_parameters_luma (currMB, best_mode);
  519.       if (img->P444_joined)
  520.       {
  521.         select_plane(PLANE_U);
  522.         cmp_cbp[1] = pDCT_16x16(currMB, PLANE_U, i16mode, is_cavlc);
  523.         select_plane(PLANE_V);
  524.         cmp_cbp[2] = pDCT_16x16(currMB, PLANE_V, i16mode, is_cavlc);   
  526.         select_plane(PLANE_Y);
  527.         currMB->cbp |= cmp_cbp[1];    
  528.         currMB->cbp |= cmp_cbp[2];    
  529.         cmp_cbp[1] = currMB->cbp;   
  530.         cmp_cbp[2] = currMB->cbp;
  531.       }
  533.     }
  534.     else
  535.     {
  536.       currMB->luma_transform_size_8x8_flag = tmp_8x8_flag; // restore
  537.       currMB->NoMbPartLessThan8x8Flag = tmp_no_mbpart;     // restore
  538.     }
  539.   }
  541.   intra1 = IS_INTRA(currMB);
  543.   //=====  S E T   F I N A L   M A C R O B L O C K   P A R A M E T E R S ======
  544.   //---------------------------------------------------------------------------
  545.   {
  546.     //===== set parameters for chosen mode =====
  547.     SetModesAndRefframeForBlocks (currMB, best_mode);
  549.     if (best_mode==P8x8)
  550.     {
  551.       if (currMB->luma_transform_size_8x8_flag && (cbp8_8x8ts == 0) && params->Transform8x8Mode != 2)
  552.         currMB->luma_transform_size_8x8_flag = 0;
  554.       SetCoeffAndReconstruction8x8 (currMB);
  556.       memset(currMB->intra_pred_modes, DC_PRED, MB_BLOCK_PARTITIONS * sizeof(char));
  557.       for (k=0, j = img->block_y; j < img->block_y + BLOCK_MULTIPLE; j++)
  558.         memset(&ipredmodes[j][img->block_x], DC_PRED, BLOCK_MULTIPLE * sizeof(char));
  559.     }
  560.     else
  561.     {
  562.       //===== set parameters for chosen mode =====
  563.       if (best_mode == I8MB)
  564.       {
  565.         memcpy(currMB->intra_pred_modes,currMB->intra_pred_modes8x8, MB_BLOCK_PARTITIONS * sizeof(char));
  566.         for(j = img->block_y; j < img->block_y + BLOCK_MULTIPLE; j++)
  567.           memcpy(&img->ipredmode[j][img->block_x],&img->ipredmode8x8[j][img->block_x], BLOCK_MULTIPLE * sizeof(char));
  569.         //--- restore reconstruction for 8x8 transform ---
  570.         for(j=0; j<MB_BLOCK_SIZE; j++)
  571.         {
  572.           memcpy(&enc_picture->imgY[img->pix_y + j][img->pix_x],temp_imgY[j], MB_BLOCK_SIZE * sizeof(imgpel));
  573.         }
  574.         if (img->P444_joined)
  575.         {
  576.           for(j=0; j<MB_BLOCK_SIZE; j++)
  577.           {
  578.             memcpy(&enc_picture->imgUV[0][img->pix_y + j][img->pix_x],temp_imgU[j], MB_BLOCK_SIZE * sizeof(imgpel)); 
  579.             memcpy(&enc_picture->imgUV[1][img->pix_y + j][img->pix_x],temp_imgV[j], MB_BLOCK_SIZE * sizeof(imgpel));
  580.           }
  581.         }
  582.       }
  584.       if ((best_mode!=I4MB)&&(best_mode != I8MB))
  585.       {
  586.         memset(currMB->intra_pred_modes,DC_PRED, MB_BLOCK_PARTITIONS * sizeof(char));
  587.         for(j = img->block_y; j < img->block_y + BLOCK_MULTIPLE; j++)
  588.           memset(&ipredmodes[j][img->block_x],DC_PRED, BLOCK_MULTIPLE * sizeof(char));
  590.         if (best_mode!=I16MB)
  591.         {
  592.           if((best_mode>=1) && (best_mode<=3))
  593.             currMB->luma_transform_size_8x8_flag = best_transform_flag;
  594.           LumaResidualCoding (currMB, is_cavlc);
  596.           if (img->AdaptiveRounding)
  597.             store_adaptive_rounding_parameters_luma (currMB, best_mode);
  599.           if (img->P444_joined)
  600.           {
  601.             if((currMB->cbp==0 && cmp_cbp[1] == 0 && cmp_cbp[2] == 0) &&(best_mode==0))
  602.               currMB->luma_transform_size_8x8_flag = 0;
  603.           }
  604.           else if((currMB->cbp==0)&&(best_mode==0))
  605.             currMB->luma_transform_size_8x8_flag = 0;
  607.           //Rate control
  608.           if (params->RCEnable)
  609.             rc_store_diff(img->opix_x,img->opix_y,mb_pred);
  610.         }
  611.       }
  612.     }
  613.     //check luma cbp for transform size flag
  614.     if (((currMB->cbp&15) == 0) && !(IS_OLDINTRA(currMB) || currMB->mb_type == I8MB))
  615.       currMB->luma_transform_size_8x8_flag = 0;
  617.     // precompute all chroma intra prediction modes
  618.     if ((img->yuv_format != YUV400) && (img->yuv_format != YUV444))
  619.       IntraChromaPrediction(currMB, NULL, NULL, NULL);
  621.     img->i16offset = 0;
  622.     dummy = 0;
  624.     if ((img->yuv_format != YUV400) && (img->yuv_format != YUV444))
  625.       ChromaResidualCoding (currMB, is_cavlc);
  627.     if (img->AdaptiveRounding)
  628.       store_adaptive_rounding_parameters_chroma (currMB, best_mode);
  630.     if (best_mode==I16MB)
  631.     {
  632.       img->i16offset = I16Offset  (currMB->cbp, i16mode);
  633.     }
  635.     SetMotionVectorsMB (currMB, bslice);
  637.     //===== check for SKIP mode =====
  638.     if(img->P444_joined)
  639.     {
  640.       if ((pslice) && best_mode==1 && currMB->cbp==0 && cmp_cbp[1] == 0 && cmp_cbp[2] == 0 &&
  641.         enc_picture->motion.ref_idx[LIST_0][img->block_y][img->block_x]    == 0 &&
  642.         enc_picture->motion.mv     [LIST_0][img->block_y][img->block_x][0] == allmvs[0] &&
  643.         enc_picture->motion.mv     [LIST_0][img->block_y][img->block_x][1] == allmvs[1])
  644.       {
  645.         currMB->mb_type = currMB->b8mode[0] = currMB->b8mode[1] = currMB->b8mode[2] = currMB->b8mode[3] = 0;
  646.         currMB->luma_transform_size_8x8_flag = 0;
  647.       }
  648.     }
  649.     else if ((pslice) && best_mode==1 && currMB->cbp==0 &&
  650.       enc_picture->motion.ref_idx[LIST_0][img->block_y][img->block_x]    == 0 &&
  651.       enc_picture->motion.mv     [LIST_0][img->block_y][img->block_x][0] == allmvs[0] &&
  652.       enc_picture->motion.mv     [LIST_0][img->block_y][img->block_x][1] == allmvs[1])
  653.     {
  654.       currMB->mb_type = currMB->b8mode[0] = currMB->b8mode[1] = currMB->b8mode[2] = currMB->b8mode[3] = 0;
  655.       currMB->luma_transform_size_8x8_flag = 0;
  656.     }
  658.     if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  659.       set_mbaff_parameters(currMB);
  660.   }
  662.   // Rate control
  663.   if(params->RCEnable && params->RCUpdateMode <= MAX_RC_MODE)
  664.     rc_store_mad(currMB);
  665.   update_qp_cbp(currMB, best_mode);
  667.   rdopt->min_rdcost = min_rd_cost;
  668.   rdopt->min_dcost = min_rd_cost;
  670.   if ( (img->MbaffFrameFlag)
  671.     && (img->current_mb_nr%2)
  672.     && (currMB->mb_type ? 0:((bslice) ? !currMB->cbp:1))  // bottom is skip
  673.     && (prevMB->mb_type ? 0:((bslice) ? !prevMB->cbp:1))
  674.     && !(field_flag_inference(currMB) == enc_mb.curr_mb_field)) // top is skip
  675.   {
  676.     rdopt->min_rdcost = 1e30;  // don't allow coding of a MB pair as skip if wrong inference
  677.   }
  679.   //===== Decide if this MB will restrict the reference frames =====
  680.   if (params->RestrictRef)
  681.     update_refresh_map(intra, intra1, currMB);
  683.   if(params->SearchMode == UM_HEX)
  684.   {
  685.     UMHEX_skip_intrabk_SAD(best_mode, listXsize[enc_mb.list_offset[LIST_0]]);
  686.   }
  687.   else if(params->SearchMode == UM_HEX_SIMPLE)
  688.   {
  689.     smpUMHEX_skip_intrabk_SAD(best_mode, listXsize[enc_mb.list_offset[LIST_0]]);
  690.   }
  692.   //--- constrain intra prediction ---
  693.   if(params->UseConstrainedIntraPred && (img->type==P_SLICE || img->type==B_SLICE))
  694.   {
  695.     img->intra_block[img->current_mb_nr] = IS_INTRA(currMB);
  696.   }
  698.   /*update adaptive rounding offset params*/
  699.   if (img->AdaptiveRounding)
  700.   {
  701.     update_offset_params(currMB, best_mode, currMB->luma_transform_size_8x8_flag);
  702.   }
  703. }