logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

x264代码剖析（十一）：核心算法之宏块分析函数x264_macroblock_analyse()

 托尼虎 2018-12-25

x264代码剖析（十一）：核心算法之宏块分析函数x264_macroblock_analyse()

2016年03月13日 12:22:44  阅读数：2132更多
所属专栏： x264代码剖析
版权声明：本文为博主原创文章，转载请标注转载网址：http://blog.csdn.net/frd2009041510 https://blog.csdn.net/FRD2009041510/article/details/50877029

x264代码剖析（十一）：核心算法之宏块分析函数x264_macroblock_analyse()

 

        x264的 x264_slice_write()函数中调用了宏块分析函数x264_macroblock_analyse()，该模块主要完成2大任务：一是对于帧内宏块，分析帧内预测模式；二是对于帧间宏块，进行运动估计，分析帧间预测模式。

 

        如下图所示是x264_macroblock_analyse()的函数关系图。




        从图中可以总结出x264_macroblock_analyse()函数调用了如下几个主要的函数：

x264_ratecontrol_mb_qp( )：通过码率控制方法获取本宏块QP

x264_mb_analyse_init()：Analysis模块初始化。

x264_mb_analyse_intra()：Intra宏块帧内预测模式分析。

x264_macroblock_probe_pskip()：分析是否是skip模式。

x264_mb_analyse_inter_p16x16()：P16x16宏块帧间预测模式分析。

x264_mb_analyse_inter_p8x8()：P8x8宏块帧间预测模式分析。

x264_mb_analyse_inter_p16x8()：P16x8宏块帧间预测模式分析。

x264_mb_analyse_inter_b16x16()：B16x16宏块帧间预测模式分析。

x264_mb_analyse_inter_b8x8()：B8x8宏块帧间预测模式分析。

x264_mb_analyse_inter_b16x8()：B16x8宏块帧间预测模式分析。

 

        x264_macroblock_analyse()用于分析宏块的预测模式。该函数的定义位于encoder\analyse.c，对应的代码分析如下：


  1. /******************************************************************/
  2. /******************************************************************/
  3. /*
  4. ======Analysed by RuiDong Fang
  5. ======Csdn Blog:http://blog.csdn.net/frd2009041510
  6. ======Date:2016.03.13（今天当舅舅啦！！！哈哈哈）
  7.  */
  8. /******************************************************************/
  9. /******************************************************************/
  10.  
  11. /************====== x264_macroblock_analyse()函数 ======************/
  12. /*
  13. 功能：分析函数，调用了帧内预测与帧间预测
  14. */
  15. /*****************************************************************************
  16.  * x264_macroblock_analyse:
  17.  *****************************************************************************/
  18. void x264_macroblock_analyse( x264_t *h )
  19. {
  20.     x264_mb_analysis_t analysis;
  21.     int i_cost = COST_MAX;
  22.  
  23.     h->mb.i_qp = x264_ratecontrol_mb_qp( h );	///////////////////通过码率控制方法，获取本宏块QP
  24.     /* If the QP of this MB is within 1 of the previous MB, code the same QP as the previous MB,
  25.      * to lower the bit cost of the qp_delta.  Don't do this if QPRD is enabled. */
  26.     if( h->param.rc.i_aq_mode && h->param.analyse.i_subpel_refine < 10 )
  27.         h->mb.i_qp = abs(h->mb.i_qp - h->mb.i_last_qp) == 1 ? h->mb.i_last_qp : h->mb.i_qp;
  28.  
  29.     if( h->param.analyse.b_mb_info )
  30.         h->fdec->effective_qp[h->mb.i_mb_xy] = h->mb.i_qp; /* Store the real analysis QP. */
  31.     x264_mb_analyse_init( h, &analysis, h->mb.i_qp );	///////////////////Analysis模块初始化
  32.  
  33.     /*--------------------------- Do the analysis ---------------------------*/
  34. 	/*******************************************************/
  35. 	/*
  36. 	I帧：只使用帧内预测，分别计算亮度16x16（4种）和4x4（9种）所有模式的代价值，选出代价最小的模式
  37. 	*/
  38. 	/*******************************************************/
  39.     if( h->sh.i_type == SLICE_TYPE_I )
  40.     {
  41. 		//I slice  
  42.         //通过一系列帧内预测模式（16x16的4种,4x4的9种）代价的计算得出代价最小的最优模式
  43. intra_analysis:
  44.         if( analysis.i_mbrd )
  45.             x264_mb_init_fenc_cache( h, analysis.i_mbrd >= 2 );
  46. 		
  47. 		//帧内预测分析  
  48.         //从16×16的SAD,4个8×8的SAD和，16个4×4SAD中选出最优方式
  49.         x264_mb_analyse_intra( h, &analysis, COST_MAX );	///////////////////Intra宏块帧内预测模式分析
  50.         
  51. 		if( analysis.i_mbrd )
  52.             x264_intra_rd( h, &analysis, COST_MAX );
  53.  
  54. 		//分析结果(开销)都存储在analysis结构体中  
  55.         i_cost = analysis.i_satd_i16x16;
  56.         h->mb.i_type = I_16x16;
  57.  
  58. 		//如果I4x4或者I8x8开销更小的话就拷贝  
  59.         //copy if little
  60.         COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, h->mb.i_type, I_4x4 );
  61.         COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, h->mb.i_type, I_8x8 );
  62.         
  63. 		//画面极其特殊的时候，才有可能用到PCM
  64. 		if( analysis.i_satd_pcm < i_cost )
  65.             h->mb.i_type = I_PCM;
  66.  
  67.         else if( analysis.i_mbrd >= 2 )
  68.             x264_intra_rd_refine( h, &analysis );
  69.     }
  70. 	/*******************************************************/
  71. 	/*
  72. 	P帧：计算帧内模式和帧间模式（ P Slice允许有Intra宏块和P宏块；同理B帧也支持Intra宏块）。
  73. 	对P帧的每一种分割进行帧间预测，得到最佳的运动矢量及最佳匹配块。  
  74.     帧间预测过程：选出最佳矢量——>找到最佳的整像素点——>找到最佳的二分之一像素点——>找到最佳的1/4像素点  
  75.     然后取代价最小的为最佳MV和分割方式  
  76.     最后从帧内模式和帧间模式中选择代价比较小的方式（有可能没有找到很好的匹配块，这时候就直接使用帧内预测而不是帧间预测）。  
  77. 	*/
  78. 	/*******************************************************/
  79.     else if( h->sh.i_type == SLICE_TYPE_P )
  80.     {
  81.         int b_skip = 0;
  82.  
  83.         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 0 );
  84.  
  85.         analysis.b_try_skip = 0;
  86.         if( analysis.b_force_intra )
  87.         {
  88.             if( !h->param.analyse.b_psy )
  89.             {
  90.                 x264_mb_analyse_init_qp( h, &analysis, X264_MAX( h->mb.i_qp - h->mb.ip_offset, h->param.rc.i_qp_min ) );
  91.                 goto intra_analysis;
  92.             }
  93.         }
  94.         else
  95.         {
  96.             /* Special fast-skip logic using information from mb_info. */
  97.             if( h->fdec->mb_info && (h->fdec->mb_info[h->mb.i_mb_xy]&X264_MBINFO_CONSTANT) )
  98.             {
  99.                 if( !SLICE_MBAFF && (h->fdec->i_frame - h->fref[0][0]->i_frame) == 1 && !h->sh.b_weighted_pred &&
  100.                     h->fref[0][0]->effective_qp[h->mb.i_mb_xy] <= h->mb.i_qp )
  101.                 {
  102.                     h->mb.i_partition = D_16x16;
  103.                     /* Use the P-SKIP MV if we can... */
  104.                     if( !M32(h->mb.cache.pskip_mv) )
  105.                     {
  106.                         b_skip = 1;
  107.                         h->mb.i_type = P_SKIP;
  108.                     }
  109.                     /* Otherwise, just force a 16x16 block. */
  110.                     else
  111.                     {
  112.                         h->mb.i_type = P_L0;
  113.                         analysis.l0.me16x16.i_ref = 0;
  114.                         M32( analysis.l0.me16x16.mv ) = 0;
  115.                     }
  116.                     goto skip_analysis;
  117.                 }
  118.                 /* Reset the information accordingly */
  119.                 else if( h->param.analyse.b_mb_info_update )
  120.                     h->fdec->mb_info[h->mb.i_mb_xy] &= ~X264_MBINFO_CONSTANT;
  121.             }
  122.  
  123.             int skip_invalid = h->i_thread_frames > 1 && h->mb.cache.pskip_mv[1] > h->mb.mv_max_spel[1];
  124.             /* If the current macroblock is off the frame, just skip it. */
  125.             if( HAVE_INTERLACED && !MB_INTERLACED && h->mb.i_mb_y * 16 >= h->param.i_height && !skip_invalid )
  126.                 b_skip = 1;
  127.             /* Fast P_SKIP detection */
  128.             else if( h->param.analyse.b_fast_pskip )
  129.             {
  130.                 if( skip_invalid )
  131.                     // FIXME don't need to check this if the reference frame is done
  132.                     {}
  133.                 else if( h->param.analyse.i_subpel_refine >= 3 )
  134.                     analysis.b_try_skip = 1;
  135.                 else if( h->mb.i_mb_type_left[0] == P_SKIP ||
  136.                          h->mb.i_mb_type_top == P_SKIP ||
  137.                          h->mb.i_mb_type_topleft == P_SKIP ||
  138.                          h->mb.i_mb_type_topright == P_SKIP )
  139.                     b_skip = x264_macroblock_probe_pskip( h );	///////////////////分析是否是skip模式--P
  140.             }
  141.         }
  142.  
  143.         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 1 );
  144.  
  145.         if( b_skip )
  146.         {
  147.             h->mb.i_type = P_SKIP;
  148.             h->mb.i_partition = D_16x16;
  149.             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->i_thread_frames == 1 );
  150. skip_analysis:
  151.             /* Set up MVs for future predictors */
  152.             for( int i = 0; i < h->mb.pic.i_fref[0]; i++ )
  153.                 M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
  154.         }
  155.         else
  156.         {
  157.             const unsigned int flags = h->param.analyse.inter;
  158.             int i_type;
  159.             int i_partition;
  160.             int i_satd_inter, i_satd_intra;
  161.  
  162.             x264_mb_analyse_load_costs( h, &analysis );
  163.  
  164.             x264_mb_analyse_inter_p16x16( h, &analysis );	///////////////////16x16 帧间预测宏块分析--P
  165.  
  166.             if( h->mb.i_type == P_SKIP )
  167.             {
  168.                 for( int i = 1; i < h->mb.pic.i_fref[0]; i++ )
  169.                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
  170.                 return;
  171.             }
  172.  
  173.             if( flags & X264_ANALYSE_PSUB16x16 )
  174.             {
  175.                 if( h->param.analyse.b_mixed_references )
  176.                     x264_mb_analyse_inter_p8x8_mixed_ref( h, &analysis );
  177.                 else
  178.                     x264_mb_analyse_inter_p8x8( h, &analysis );	///////////////////8x8帧间预测宏块分析--P
  179.             }
  180.  
  181.             /* Select best inter mode */
  182.             i_type = P_L0;
  183.             i_partition = D_16x16;
  184.             i_cost = analysis.l0.me16x16.cost;
  185.  
  186. 			//如果8x8的代价值小于16x16  
  187.             //则进行8x8子块分割的处理
  188. 			//处理的数据源自于l0?
  189.             if( ( flags & X264_ANALYSE_PSUB16x16 ) && (!analysis.b_early_terminate ||
  190.                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost) )
  191.             {
  192.                 i_type = P_8x8;
  193.                 i_partition = D_8x8;
  194.                 i_cost = analysis.l0.i_cost8x8;
  195.  
  196.                 /* Do sub 8x8 */
  197.                 if( flags & X264_ANALYSE_PSUB8x8 )
  198.                 {
  199.                     for( int i = 0; i < 4; i++ )//8x8块的子块的分析
  200.                     {
  201.                         x264_mb_analyse_inter_p4x4( h, &analysis, i );	///////////////////4x4帧间预测宏块分析--P
  202.                         int i_thresh8x4 = analysis.l0.me4x4[i][1].cost_mv + analysis.l0.me4x4[i][2].cost_mv;
  203.                         
  204. 						//如果4x4小于8x8,则再分析8x4，4x8的代价
  205.                      	if( !analysis.b_early_terminate || analysis.l0.i_cost4x4[i] < analysis.l0.me8x8[i].cost + i_thresh8x4 )
  206.                         {
  207.                             int i_cost8x8 = analysis.l0.i_cost4x4[i];
  208.                             h->mb.i_sub_partition[i] = D_L0_4x4;
  209.  
  210.                             x264_mb_analyse_inter_p8x4( h, &analysis, i );	///////////////////8x4帧间预测宏块分析--P
  211.                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost8x4[i],
  212.                                          h->mb.i_sub_partition[i], D_L0_8x4 );//如果8x4小于8x8
  213.  
  214.                             x264_mb_analyse_inter_p4x8( h, &analysis, i );	///////////////////4x8帧间预测宏块分析--P
  215.                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost4x8[i],
  216.                                          h->mb.i_sub_partition[i], D_L0_4x8 );//如果4x8小于8x8
  217.  
  218.                             i_cost += i_cost8x8 - analysis.l0.me8x8[i].cost;
  219.                         }
  220.                         x264_mb_cache_mv_p8x8( h, &analysis, i );
  221.                     }
  222.                     analysis.l0.i_cost8x8 = i_cost;
  223.                 }
  224.             }
  225.  
  226.             /* Now do 16x8/8x16 */
  227.             int i_thresh16x8 = analysis.l0.me8x8[1].cost_mv + analysis.l0.me8x8[2].cost_mv;
  228.             
  229. 			//前提要求8x8的代价值小于16x16
  230. 			if( ( flags & X264_ANALYSE_PSUB16x16 ) && (!analysis.b_early_terminate ||
  231.                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost + i_thresh16x8) )
  232.             {
  233.                 int i_avg_mv_ref_cost = (analysis.l0.me8x8[2].cost_mv + analysis.l0.me8x8[2].i_ref_cost
  234.                                       + analysis.l0.me8x8[3].cost_mv + analysis.l0.me8x8[3].i_ref_cost + 1) >> 1;
  235.                 analysis.i_cost_est16x8[1] = analysis.i_satd8x8[0][2] + analysis.i_satd8x8[0][3] + i_avg_mv_ref_cost;
  236.  
  237.                 x264_mb_analyse_inter_p16x8( h, &analysis, i_cost );	///////////////////16x8帧间预测宏块分析--P
  238.                 COPY3_IF_LT( i_cost, analysis.l0.i_cost16x8, i_type, P_L0, i_partition, D_16x8 );
  239.  
  240.                 i_avg_mv_ref_cost = (analysis.l0.me8x8[1].cost_mv + analysis.l0.me8x8[1].i_ref_cost
  241.                                   + analysis.l0.me8x8[3].cost_mv + analysis.l0.me8x8[3].i_ref_cost + 1) >> 1;
  242.                 analysis.i_cost_est8x16[1] = analysis.i_satd8x8[0][1] + analysis.i_satd8x8[0][3] + i_avg_mv_ref_cost;
  243.  
  244.                 x264_mb_analyse_inter_p8x16( h, &analysis, i_cost );	///////////////////8x16帧间预测宏块分析--P
  245.                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x16, i_type, P_L0, i_partition, D_8x16 );
  246.             }
  247.  
  248.             h->mb.i_partition = i_partition;
  249.  
  250.             /* refine qpel */
  251. 			//亚像素精度搜索
  252.             //FIXME mb_type costs?
  253.             if( analysis.i_mbrd || !h->mb.i_subpel_refine )
  254.             {
  255.                 /* refine later */
  256.             }
  257.             else if( i_partition == D_16x16 )
  258.             {
  259.                 x264_me_refine_qpel( h, &analysis.l0.me16x16 );	///////////////////////亚像素精度搜索
  260.                 i_cost = analysis.l0.me16x16.cost;
  261.             }
  262.             else if( i_partition == D_16x8 )
  263.             {
  264.                 x264_me_refine_qpel( h, &analysis.l0.me16x8[0] );
  265.                 x264_me_refine_qpel( h, &analysis.l0.me16x8[1] );
  266.                 i_cost = analysis.l0.me16x8[0].cost + analysis.l0.me16x8[1].cost;
  267.             }
  268.             else if( i_partition == D_8x16 )
  269.             {
  270.                 x264_me_refine_qpel( h, &analysis.l0.me8x16[0] );
  271.                 x264_me_refine_qpel( h, &analysis.l0.me8x16[1] );
  272.                 i_cost = analysis.l0.me8x16[0].cost + analysis.l0.me8x16[1].cost;
  273.             }
  274.             else if( i_partition == D_8x8 )
  275.             {
  276.                 i_cost = 0;
  277.                 for( int i8x8 = 0; i8x8 < 4; i8x8++ )
  278.                 {
  279.                     switch( h->mb.i_sub_partition[i8x8] )
  280.                     {
  281.                         case D_L0_8x8:
  282.                             x264_me_refine_qpel( h, &analysis.l0.me8x8[i8x8] );
  283.                             i_cost += analysis.l0.me8x8[i8x8].cost;
  284.                             break;
  285.                         case D_L0_8x4:
  286.                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][0] );
  287.                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][1] );
  288.                             i_cost += analysis.l0.me8x4[i8x8][0].cost +
  289.                                       analysis.l0.me8x4[i8x8][1].cost;
  290.                             break;
  291.                         case D_L0_4x8:
  292.                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][0] );
  293.                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][1] );
  294.                             i_cost += analysis.l0.me4x8[i8x8][0].cost +
  295.                                       analysis.l0.me4x8[i8x8][1].cost;
  296.                             break;
  297.  
  298.                         case D_L0_4x4:
  299.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][0] );
  300.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][1] );
  301.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][2] );
  302.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][3] );
  303.                             i_cost += analysis.l0.me4x4[i8x8][0].cost +
  304.                                       analysis.l0.me4x4[i8x8][1].cost +
  305.                                       analysis.l0.me4x4[i8x8][2].cost +
  306.                                       analysis.l0.me4x4[i8x8][3].cost;
  307.                             break;
  308.                         default:
  309.                             x264_log( h, X264_LOG_ERROR, "internal error (!8x8 && !4x4)\n" );
  310.                             break;
  311.                     }
  312.                 }
  313.             }
  314.  
  315.             if( h->mb.b_chroma_me )
  316.             {
  317.                 if( CHROMA444 )
  318.                 {
  319.                     x264_mb_analyse_intra( h, &analysis, i_cost );
  320.                     x264_mb_analyse_intra_chroma( h, &analysis );
  321.                 }
  322.                 else
  323.                 {
  324.                     x264_mb_analyse_intra_chroma( h, &analysis );
  325.                     x264_mb_analyse_intra( h, &analysis, i_cost - analysis.i_satd_chroma );
  326.                 }
  327.                 analysis.i_satd_i16x16 += analysis.i_satd_chroma;
  328.                 analysis.i_satd_i8x8   += analysis.i_satd_chroma;
  329.                 analysis.i_satd_i4x4   += analysis.i_satd_chroma;
  330.             }
  331.             else
  332.                 x264_mb_analyse_intra( h, &analysis, i_cost );//P Slice中也允许有Intra宏块，所以也要进行分析
  333.  
  334.             i_satd_inter = i_cost;
  335.             i_satd_intra = X264_MIN3( analysis.i_satd_i16x16,
  336.                                       analysis.i_satd_i8x8,
  337.                                       analysis.i_satd_i4x4 );
  338.  
  339.             if( analysis.i_mbrd )
  340.             {
  341.                 x264_mb_analyse_p_rd( h, &analysis, X264_MIN(i_satd_inter, i_satd_intra) );
  342.                 i_type = P_L0;
  343.                 i_partition = D_16x16;
  344.                 i_cost = analysis.l0.i_rd16x16;
  345.                 COPY2_IF_LT( i_cost, analysis.l0.i_cost16x8, i_partition, D_16x8 );
  346.                 COPY2_IF_LT( i_cost, analysis.l0.i_cost8x16, i_partition, D_8x16 );
  347.                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x8, i_partition, D_8x8, i_type, P_8x8 );
  348.                 h->mb.i_type = i_type;
  349.                 h->mb.i_partition = i_partition;
  350.                 if( i_cost < COST_MAX )
  351.                     x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
  352.                 x264_intra_rd( h, &analysis, i_satd_inter * 5/4 + 1 );
  353.             }
  354.  
  355. 			//获取最小的代价
  356.             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
  357.             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
  358.             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
  359.             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
  360.  
  361.             h->mb.i_type = i_type;
  362.  
  363.             if( analysis.b_force_intra && !IS_INTRA(i_type) )
  364.             {
  365.                 /* Intra masking: copy fdec to fenc and re-encode the block as intra in order to make it appear as if
  366.                  * it was an inter block. */
  367.                 x264_analyse_update_cache( h, &analysis );	/////////////////////
  368.                 x264_macroblock_encode( h );	/////////////////////
  369.                 for( int p = 0; p < (CHROMA444 ? 3 : 1); p++ )
  370.                     h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fenc[p], FENC_STRIDE, h->mb.pic.p_fdec[p], FDEC_STRIDE, 16 );
  371.                 if( !CHROMA444 )
  372.                 {
  373.                     int height = 16 >> CHROMA_V_SHIFT;
  374.                     h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fenc[1], FENC_STRIDE, h->mb.pic.p_fdec[1], FDEC_STRIDE, height );
  375.                     h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fenc[2], FENC_STRIDE, h->mb.pic.p_fdec[2], FDEC_STRIDE, height );
  376.                 }
  377.                 x264_mb_analyse_init_qp( h, &analysis, X264_MAX( h->mb.i_qp - h->mb.ip_offset, h->param.rc.i_qp_min ) );
  378.                 goto intra_analysis;
  379.             }
  380.  
  381.             if( analysis.i_mbrd >= 2 && h->mb.i_type != I_PCM )
  382.             {
  383.                 if( IS_INTRA( h->mb.i_type ) )
  384.                 {
  385.                     x264_intra_rd_refine( h, &analysis );
  386.                 }
  387.                 else if( i_partition == D_16x16 )
  388.                 {
  389.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.i_ref );
  390.                     analysis.l0.me16x16.cost = i_cost;
  391.                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
  392.                 }
  393.                 else if( i_partition == D_16x8 )
  394.                 {
  395.                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
  396.                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
  397.                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, analysis.l0.me16x8[0].i_ref );
  398.                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, analysis.l0.me16x8[1].i_ref );
  399.                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[0], analysis.i_lambda2, 0, 0 );
  400.                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[1], analysis.i_lambda2, 8, 0 );
  401.                 }
  402.                 else if( i_partition == D_8x16 )
  403.                 {
  404.                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
  405.                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
  406.                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, analysis.l0.me8x16[0].i_ref );
  407.                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, analysis.l0.me8x16[1].i_ref );
  408.                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[0], analysis.i_lambda2, 0, 0 );
  409.                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[1], analysis.i_lambda2, 4, 0 );
  410.                 }
  411.                 else if( i_partition == D_8x8 )
  412.                 {
  413.                     x264_analyse_update_cache( h, &analysis );
  414.                     for( int i8x8 = 0; i8x8 < 4; i8x8++ )
  415.                     {
  416.                         if( h->mb.i_sub_partition[i8x8] == D_L0_8x8 )
  417.                         {
  418.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i8x8], analysis.i_lambda2, i8x8*4, 0 );
  419.                         }
  420.                         else if( h->mb.i_sub_partition[i8x8] == D_L0_8x4 )
  421.                         {
  422.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
  423.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][1], analysis.i_lambda2, i8x8*4+2, 0 );
  424.                         }
  425.                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x8 )
  426.                         {
  427.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
  428.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
  429.                         }
  430.                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x4 )
  431.                         {
  432.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
  433.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
  434.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][2], analysis.i_lambda2, i8x8*4+2, 0 );
  435.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][3], analysis.i_lambda2, i8x8*4+3, 0 );
  436.                         }
  437.                     }
  438.                 }
  439.             }
  440.         }
  441.     }
  442. 	/*******************************************************/
  443. 	/*
  444. 	B Slice的时候 
  445. 	*/
  446. 	/*******************************************************/
  447.     else if( h->sh.i_type == SLICE_TYPE_B )
  448.     {
  449.         int i_bskip_cost = COST_MAX;
  450.         int b_skip = 0;
  451.  
  452.         if( analysis.i_mbrd )
  453.             x264_mb_init_fenc_cache( h, analysis.i_mbrd >= 2 );
  454.  
  455.         h->mb.i_type = B_SKIP;
  456.         if( h->mb.b_direct_auto_write )
  457.         {
  458.             /* direct=auto heuristic: prefer whichever mode allows more Skip macroblocks */
  459.             for( int i = 0; i < 2; i++ )
  460.             {
  461.                 int b_changed = 1;
  462.                 h->sh.b_direct_spatial_mv_pred ^= 1;
  463.                 analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, i && analysis.b_direct_available ? &b_changed : NULL );
  464.                 if( analysis.b_direct_available )
  465.                 {
  466.                     if( b_changed )
  467.                     {
  468.                         x264_mb_mc( h );
  469.                         b_skip = x264_macroblock_probe_bskip( h );	///////////////////////分析是否是skip模式--B
  470.                     }
  471.                     h->stat.frame.i_direct_score[ h->sh.b_direct_spatial_mv_pred ] += b_skip;
  472.                 }
  473.                 else
  474.                     b_skip = 0;
  475.             }
  476.         }
  477.         else
  478.             analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, NULL );
  479.  
  480.         analysis.b_try_skip = 0;
  481.         if( analysis.b_direct_available )
  482.         {
  483.             if( !h->mb.b_direct_auto_write )
  484.                 x264_mb_mc( h );
  485.             /* If the current macroblock is off the frame, just skip it. */
  486.             if( HAVE_INTERLACED && !MB_INTERLACED && h->mb.i_mb_y * 16 >= h->param.i_height )
  487.                 b_skip = 1;
  488.             else if( analysis.i_mbrd )
  489.             {
  490.                 i_bskip_cost = ssd_mb( h );
  491.                 /* 6 = minimum cavlc cost of a non-skipped MB */
  492.                 b_skip = h->mb.b_skip_mc = i_bskip_cost <= ((6 * analysis.i_lambda2 + 128) >> 8);
  493.             }
  494.             else if( !h->mb.b_direct_auto_write )
  495.             {
  496.                 /* Conditioning the probe on neighboring block types
  497.                  * doesn't seem to help speed or quality. */
  498.                 analysis.b_try_skip = x264_macroblock_probe_bskip( h );
  499.                 if( h->param.analyse.i_subpel_refine < 3 )
  500.                     b_skip = analysis.b_try_skip;
  501.             }
  502.             /* Set up MVs for future predictors */
  503.             if( b_skip )
  504.             {
  505.                 for( int i = 0; i < h->mb.pic.i_fref[0]; i++ )
  506.                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
  507.                 for( int i = 0; i < h->mb.pic.i_fref[1]; i++ )
  508.                     M32( h->mb.mvr[1][i][h->mb.i_mb_xy] ) = 0;
  509.             }
  510.         }
  511.  
  512.         if( !b_skip )
  513.         {
  514.             const unsigned int flags = h->param.analyse.inter;
  515.             int i_type;
  516.             int i_partition;
  517.             int i_satd_inter;
  518.             h->mb.b_skip_mc = 0;
  519.             h->mb.i_type = B_DIRECT;
  520.  
  521.             x264_mb_analyse_load_costs( h, &analysis );
  522.  
  523.             /* select best inter mode */
  524.             /* direct must be first */
  525.             if( analysis.b_direct_available )
  526.                 x264_mb_analyse_inter_direct( h, &analysis );
  527.  
  528.             x264_mb_analyse_inter_b16x16( h, &analysis );	///////////////////////16x16 帧间预测宏块分析--B
  529.  
  530.             if( h->mb.i_type == B_SKIP )
  531.             {
  532.                 for( int i = 1; i < h->mb.pic.i_fref[0]; i++ )
  533.                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
  534.                 for( int i = 1; i < h->mb.pic.i_fref[1]; i++ )
  535.                     M32( h->mb.mvr[1][i][h->mb.i_mb_xy] ) = 0;
  536.                 return;
  537.             }
  538.  
  539.             i_type = B_L0_L0;
  540.             i_partition = D_16x16;
  541.             i_cost = analysis.l0.me16x16.cost;
  542.             COPY2_IF_LT( i_cost, analysis.l1.me16x16.cost, i_type, B_L1_L1 );
  543.             COPY2_IF_LT( i_cost, analysis.i_cost16x16bi, i_type, B_BI_BI );
  544.             COPY2_IF_LT( i_cost, analysis.i_cost16x16direct, i_type, B_DIRECT );
  545.  
  546.             if( analysis.i_mbrd && analysis.b_early_terminate && analysis.i_cost16x16direct <= i_cost * 33/32 )
  547.             {
  548.                 x264_mb_analyse_b_rd( h, &analysis, i_cost );
  549.                 if( i_bskip_cost < analysis.i_rd16x16direct &&
  550.                     i_bskip_cost < analysis.i_rd16x16bi &&
  551.                     i_bskip_cost < analysis.l0.i_rd16x16 &&
  552.                     i_bskip_cost < analysis.l1.i_rd16x16 )
  553.                 {
  554.                     h->mb.i_type = B_SKIP;
  555.                     x264_analyse_update_cache( h, &analysis );
  556.                     return;
  557.                 }
  558.             }
  559.  
  560.             if( flags & X264_ANALYSE_BSUB16x16 )
  561.             {
  562.                 if( h->param.analyse.b_mixed_references )
  563.                     x264_mb_analyse_inter_b8x8_mixed_ref( h, &analysis );
  564.                 else
  565.                     x264_mb_analyse_inter_b8x8( h, &analysis );	///////////////////////8x8 帧间预测宏块分析--B
  566.  
  567.                 COPY3_IF_LT( i_cost, analysis.i_cost8x8bi, i_type, B_8x8, i_partition, D_8x8 );
  568.  
  569.                 /* Try to estimate the cost of b16x8/b8x16 based on the satd scores of the b8x8 modes */
  570.                 int i_cost_est16x8bi_total = 0, i_cost_est8x16bi_total = 0;
  571.                 int i_mb_type, i_partition16x8[2], i_partition8x16[2];
  572.                 for( int i = 0; i < 2; i++ )
  573.                 {
  574.                     int avg_l0_mv_ref_cost, avg_l1_mv_ref_cost;
  575.                     int i_l0_satd, i_l1_satd, i_bi_satd, i_best_cost;
  576.                     // 16x8
  577.                     i_best_cost = COST_MAX;
  578.                     i_l0_satd = analysis.i_satd8x8[0][i*2] + analysis.i_satd8x8[0][i*2+1];
  579.                     i_l1_satd = analysis.i_satd8x8[1][i*2] + analysis.i_satd8x8[1][i*2+1];
  580.                     i_bi_satd = analysis.i_satd8x8[2][i*2] + analysis.i_satd8x8[2][i*2+1];
  581.                     avg_l0_mv_ref_cost = ( analysis.l0.me8x8[i*2].cost_mv + analysis.l0.me8x8[i*2].i_ref_cost
  582.                                          + analysis.l0.me8x8[i*2+1].cost_mv + analysis.l0.me8x8[i*2+1].i_ref_cost + 1 ) >> 1;
  583.                     avg_l1_mv_ref_cost = ( analysis.l1.me8x8[i*2].cost_mv + analysis.l1.me8x8[i*2].i_ref_cost
  584.                                          + analysis.l1.me8x8[i*2+1].cost_mv + analysis.l1.me8x8[i*2+1].i_ref_cost + 1 ) >> 1;
  585.                     COPY2_IF_LT( i_best_cost, i_l0_satd + avg_l0_mv_ref_cost, i_partition16x8[i], D_L0_8x8 );
  586.                     COPY2_IF_LT( i_best_cost, i_l1_satd + avg_l1_mv_ref_cost, i_partition16x8[i], D_L1_8x8 );
  587.                     COPY2_IF_LT( i_best_cost, i_bi_satd + avg_l0_mv_ref_cost + avg_l1_mv_ref_cost, i_partition16x8[i], D_BI_8x8 );
  588.                     analysis.i_cost_est16x8[i] = i_best_cost;
  589.  
  590.                     // 8x16
  591.                     i_best_cost = COST_MAX;
  592.                     i_l0_satd = analysis.i_satd8x8[0][i] + analysis.i_satd8x8[0][i+2];
  593.                     i_l1_satd = analysis.i_satd8x8[1][i] + analysis.i_satd8x8[1][i+2];
  594.                     i_bi_satd = analysis.i_satd8x8[2][i] + analysis.i_satd8x8[2][i+2];
  595.                     avg_l0_mv_ref_cost = ( analysis.l0.me8x8[i].cost_mv + analysis.l0.me8x8[i].i_ref_cost
  596.                                          + analysis.l0.me8x8[i+2].cost_mv + analysis.l0.me8x8[i+2].i_ref_cost + 1 ) >> 1;
  597.                     avg_l1_mv_ref_cost = ( analysis.l1.me8x8[i].cost_mv + analysis.l1.me8x8[i].i_ref_cost
  598.                                          + analysis.l1.me8x8[i+2].cost_mv + analysis.l1.me8x8[i+2].i_ref_cost + 1 ) >> 1;
  599.                     COPY2_IF_LT( i_best_cost, i_l0_satd + avg_l0_mv_ref_cost, i_partition8x16[i], D_L0_8x8 );
  600.                     COPY2_IF_LT( i_best_cost, i_l1_satd + avg_l1_mv_ref_cost, i_partition8x16[i], D_L1_8x8 );
  601.                     COPY2_IF_LT( i_best_cost, i_bi_satd + avg_l0_mv_ref_cost + avg_l1_mv_ref_cost, i_partition8x16[i], D_BI_8x8 );
  602.                     analysis.i_cost_est8x16[i] = i_best_cost;
  603.                 }
  604.                 i_mb_type = B_L0_L0 + (i_partition16x8[0]>>2) * 3 + (i_partition16x8[1]>>2);
  605.                 analysis.i_cost_est16x8[1] += analysis.i_lambda * i_mb_b16x8_cost_table[i_mb_type];
  606.                 i_cost_est16x8bi_total = analysis.i_cost_est16x8[0] + analysis.i_cost_est16x8[1];
  607.                 i_mb_type = B_L0_L0 + (i_partition8x16[0]>>2) * 3 + (i_partition8x16[1]>>2);
  608.                 analysis.i_cost_est8x16[1] += analysis.i_lambda * i_mb_b16x8_cost_table[i_mb_type];
  609.                 i_cost_est8x16bi_total = analysis.i_cost_est8x16[0] + analysis.i_cost_est8x16[1];
  610.  
  611.                 /* We can gain a little speed by checking the mode with the lowest estimated cost first */
  612.                 int try_16x8_first = i_cost_est16x8bi_total < i_cost_est8x16bi_total;
  613.                 if( try_16x8_first && (!analysis.b_early_terminate || i_cost_est16x8bi_total < i_cost) )
  614.                 {
  615.                     x264_mb_analyse_inter_b16x8( h, &analysis, i_cost );	///////////////////////16x8 帧间预测宏块分析--B
  616.                     COPY3_IF_LT( i_cost, analysis.i_cost16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
  617.                 }
  618.                 if( !analysis.b_early_terminate || i_cost_est8x16bi_total < i_cost )
  619.                 {
  620.                     x264_mb_analyse_inter_b8x16( h, &analysis, i_cost );	///////////////////////8x16 帧间预测宏块分析--B
  621.                     COPY3_IF_LT( i_cost, analysis.i_cost8x16bi, i_type, analysis.i_mb_type8x16, i_partition, D_8x16 );
  622.                 }
  623.                 if( !try_16x8_first && (!analysis.b_early_terminate || i_cost_est16x8bi_total < i_cost) )
  624.                 {
  625.                     x264_mb_analyse_inter_b16x8( h, &analysis, i_cost );	///////////////////////16x8 帧间预测宏块分析--B
  626.                     COPY3_IF_LT( i_cost, analysis.i_cost16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
  627.                 }
  628.             }
  629.  
  630.             if( analysis.i_mbrd || !h->mb.i_subpel_refine )
  631.             {
  632.                 /* refine later */
  633.             }
  634.             /* refine qpel */
  635.             else if( i_partition == D_16x16 )
  636.             {
  637.                 analysis.l0.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
  638.                 analysis.l1.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
  639.                 if( i_type == B_L0_L0 )
  640.                 {
  641.                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );	/////////////////////亚像素精度搜索
  642.                     i_cost = analysis.l0.me16x16.cost
  643.                            + analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
  644.                 }
  645.                 else if( i_type == B_L1_L1 )
  646.                 {
  647.                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
  648.                     i_cost = analysis.l1.me16x16.cost
  649.                            + analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
  650.                 }
  651.                 else if( i_type == B_BI_BI )
  652.                 {
  653.                     x264_me_refine_qpel( h, &analysis.l0.bi16x16 );
  654.                     x264_me_refine_qpel( h, &analysis.l1.bi16x16 );
  655.                 }
  656.             }
  657.             else if( i_partition == D_16x8 )
  658.             {
  659.                 for( int i = 0; i < 2; i++ )
  660.                 {
  661.                     if( analysis.i_mb_partition16x8[i] != D_L1_8x8 )
  662.                         x264_me_refine_qpel( h, &analysis.l0.me16x8[i] );
  663.                     if( analysis.i_mb_partition16x8[i] != D_L0_8x8 )
  664.                         x264_me_refine_qpel( h, &analysis.l1.me16x8[i] );
  665.                 }
  666.             }
  667.             else if( i_partition == D_8x16 )
  668.             {
  669.                 for( int i = 0; i < 2; i++ )
  670.                 {
  671.                     if( analysis.i_mb_partition8x16[i] != D_L1_8x8 )
  672.                         x264_me_refine_qpel( h, &analysis.l0.me8x16[i] );
  673.                     if( analysis.i_mb_partition8x16[i] != D_L0_8x8 )
  674.                         x264_me_refine_qpel( h, &analysis.l1.me8x16[i] );
  675.                 }
  676.             }
  677.             else if( i_partition == D_8x8 )
  678.             {
  679.                 for( int i = 0; i < 4; i++ )
  680.                 {
  681.                     x264_me_t *m;
  682.                     int i_part_cost_old;
  683.                     int i_type_cost;
  684.                     int i_part_type = h->mb.i_sub_partition[i];
  685.                     int b_bidir = (i_part_type == D_BI_8x8);
  686.  
  687.                     if( i_part_type == D_DIRECT_8x8 )
  688.                         continue;
  689.                     if( x264_mb_partition_listX_table[0][i_part_type] )
  690.                     {
  691.                         m = &analysis.l0.me8x8[i];
  692.                         i_part_cost_old = m->cost;
  693.                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
  694.                         m->cost -= i_type_cost;
  695.                         x264_me_refine_qpel( h, m );
  696.                         if( !b_bidir )
  697.                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
  698.                     }
  699.                     if( x264_mb_partition_listX_table[1][i_part_type] )
  700.                     {
  701.                         m = &analysis.l1.me8x8[i];
  702.                         i_part_cost_old = m->cost;
  703.                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
  704.                         m->cost -= i_type_cost;
  705.                         x264_me_refine_qpel( h, m );
  706.                         if( !b_bidir )
  707.                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
  708.                     }
  709.                     /* TODO: update mvp? */
  710.                 }
  711.             }
  712.  
  713.             i_satd_inter = i_cost;
  714.  
  715.             if( analysis.i_mbrd )
  716.             {
  717.                 x264_mb_analyse_b_rd( h, &analysis, i_satd_inter );
  718.                 i_type = B_SKIP;
  719.                 i_cost = i_bskip_cost;
  720.                 i_partition = D_16x16;
  721.                 COPY2_IF_LT( i_cost, analysis.l0.i_rd16x16, i_type, B_L0_L0 );
  722.                 COPY2_IF_LT( i_cost, analysis.l1.i_rd16x16, i_type, B_L1_L1 );
  723.                 COPY2_IF_LT( i_cost, analysis.i_rd16x16bi, i_type, B_BI_BI );
  724.                 COPY2_IF_LT( i_cost, analysis.i_rd16x16direct, i_type, B_DIRECT );
  725.                 COPY3_IF_LT( i_cost, analysis.i_rd16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
  726.                 COPY3_IF_LT( i_cost, analysis.i_rd8x16bi, i_type, analysis.i_mb_type8x16, i_partition, D_8x16 );
  727.                 COPY3_IF_LT( i_cost, analysis.i_rd8x8bi, i_type, B_8x8, i_partition, D_8x8 );
  728.  
  729.                 h->mb.i_type = i_type;
  730.                 h->mb.i_partition = i_partition;
  731.             }
  732.  
  733.             if( h->mb.b_chroma_me )
  734.             {
  735.                 if( CHROMA444 )
  736.                 {
  737.                     x264_mb_analyse_intra( h, &analysis, i_satd_inter );
  738.                     x264_mb_analyse_intra_chroma( h, &analysis );
  739.                 }
  740.                 else
  741.                 {
  742.                     x264_mb_analyse_intra_chroma( h, &analysis );
  743.                     x264_mb_analyse_intra( h, &analysis, i_satd_inter - analysis.i_satd_chroma );
  744.                 }
  745.                 analysis.i_satd_i16x16 += analysis.i_satd_chroma;
  746.                 analysis.i_satd_i8x8   += analysis.i_satd_chroma;
  747.                 analysis.i_satd_i4x4   += analysis.i_satd_chroma;
  748.             }
  749.             else
  750.                 x264_mb_analyse_intra( h, &analysis, i_satd_inter );//B Slice中也允许有Intra宏块，所以也要进行分析
  751.  
  752.             if( analysis.i_mbrd )
  753.             {
  754.                 x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
  755.                 x264_intra_rd( h, &analysis, i_satd_inter * 17/16 + 1 );
  756.             }
  757.  
  758.             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
  759.             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
  760.             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
  761.             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
  762.  
  763.             h->mb.i_type = i_type;
  764.             h->mb.i_partition = i_partition;
  765.  
  766.             if( analysis.i_mbrd >= 2 && IS_INTRA( i_type ) && i_type != I_PCM )
  767.                 x264_intra_rd_refine( h, &analysis );
  768.             if( h->mb.i_subpel_refine >= 5 )
  769.                 x264_refine_bidir( h, &analysis );
  770.  
  771.             if( analysis.i_mbrd >= 2 && i_type > B_DIRECT && i_type < B_SKIP )
  772.             {
  773.                 int i_biweight;
  774.                 x264_analyse_update_cache( h, &analysis );	/////////////////////
  775.  
  776.                 if( i_partition == D_16x16 )
  777.                 {
  778.                     if( i_type == B_L0_L0 )
  779.                     {
  780.                         analysis.l0.me16x16.cost = i_cost;
  781.                         x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
  782.                     }
  783.                     else if( i_type == B_L1_L1 )
  784.                     {
  785.                         analysis.l1.me16x16.cost = i_cost;
  786.                         x264_me_refine_qpel_rd( h, &analysis.l1.me16x16, analysis.i_lambda2, 0, 1 );
  787.                     }
  788.                     else if( i_type == B_BI_BI )
  789.                     {
  790.                         i_biweight = h->mb.bipred_weight[analysis.l0.bi16x16.i_ref][analysis.l1.bi16x16.i_ref];
  791.                         x264_me_refine_bidir_rd( h, &analysis.l0.bi16x16, &analysis.l1.bi16x16, i_biweight, 0, analysis.i_lambda2 );
  792.                     }
  793.                 }
  794.                 else if( i_partition == D_16x8 )
  795.                 {
  796.                     for( int i = 0; i < 2; i++ )
  797.                     {
  798.                         h->mb.i_sub_partition[i*2] = h->mb.i_sub_partition[i*2+1] = analysis.i_mb_partition16x8[i];
  799.                         if( analysis.i_mb_partition16x8[i] == D_L0_8x8 )
  800.                             x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[i], analysis.i_lambda2, i*8, 0 );
  801.                         else if( analysis.i_mb_partition16x8[i] == D_L1_8x8 )
  802.                             x264_me_refine_qpel_rd( h, &analysis.l1.me16x8[i], analysis.i_lambda2, i*8, 1 );
  803.                         else if( analysis.i_mb_partition16x8[i] == D_BI_8x8 )
  804.                         {
  805.                             i_biweight = h->mb.bipred_weight[analysis.l0.me16x8[i].i_ref][analysis.l1.me16x8[i].i_ref];
  806.                             x264_me_refine_bidir_rd( h, &analysis.l0.me16x8[i], &analysis.l1.me16x8[i], i_biweight, i*2, analysis.i_lambda2 );
  807.                         }
  808.                     }
  809.                 }
  810.                 else if( i_partition == D_8x16 )
  811.                 {
  812.                     for( int i = 0; i < 2; i++ )
  813.                     {
  814.                         h->mb.i_sub_partition[i] = h->mb.i_sub_partition[i+2] = analysis.i_mb_partition8x16[i];
  815.                         if( analysis.i_mb_partition8x16[i] == D_L0_8x8 )
  816.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[i], analysis.i_lambda2, i*4, 0 );
  817.                         else if( analysis.i_mb_partition8x16[i] == D_L1_8x8 )
  818.                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x16[i], analysis.i_lambda2, i*4, 1 );
  819.                         else if( analysis.i_mb_partition8x16[i] == D_BI_8x8 )
  820.                         {
  821.                             i_biweight = h->mb.bipred_weight[analysis.l0.me8x16[i].i_ref][analysis.l1.me8x16[i].i_ref];
  822.                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x16[i], &analysis.l1.me8x16[i], i_biweight, i, analysis.i_lambda2 );
  823.                         }
  824.                     }
  825.                 }
  826.                 else if( i_partition == D_8x8 )
  827.                 {
  828.                     for( int i = 0; i < 4; i++ )
  829.                     {
  830.                         if( h->mb.i_sub_partition[i] == D_L0_8x8 )
  831.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i], analysis.i_lambda2, i*4, 0 );
  832.                         else if( h->mb.i_sub_partition[i] == D_L1_8x8 )
  833.                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x8[i], analysis.i_lambda2, i*4, 1 );
  834.                         else if( h->mb.i_sub_partition[i] == D_BI_8x8 )
  835.                         {
  836.                             i_biweight = h->mb.bipred_weight[analysis.l0.me8x8[i].i_ref][analysis.l1.me8x8[i].i_ref];
  837.                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x8[i], &analysis.l1.me8x8[i], i_biweight, i, analysis.i_lambda2 );
  838.                         }
  839.                     }
  840.                 }
  841.             }
  842.         }
  843.     }
  844.  
  845.     x264_analyse_update_cache( h, &analysis );	///////////////////////
  846.  
  847.     /* In rare cases we can end up qpel-RDing our way back to a larger partition size
  848.      * without realizing it.  Check for this and account for it if necessary. */
  849.     if( analysis.i_mbrd >= 2 )
  850.     {
  851.         /* Don't bother with bipred or 8x8-and-below, the odds are incredibly low. */
  852.         static const uint8_t check_mv_lists[X264_MBTYPE_MAX] = {[P_L0]=1, [B_L0_L0]=1, [B_L1_L1]=2};
  853.         int list = check_mv_lists[h->mb.i_type] - 1;
  854.         if( list >= 0 && h->mb.i_partition != D_16x16 &&
  855.             M32( &h->mb.cache.mv[list][x264_scan8[0]] ) == M32( &h->mb.cache.mv[list][x264_scan8[12]] ) &&
  856.             h->mb.cache.ref[list][x264_scan8[0]] == h->mb.cache.ref[list][x264_scan8[12]] )
  857.                 h->mb.i_partition = D_16x16;
  858.     }
  859.  
  860.     if( !analysis.i_mbrd )
  861.         x264_mb_analyse_transform( h );	///////////////////////
  862.  
  863.     if( analysis.i_mbrd == 3 && !IS_SKIP(h->mb.i_type) )
  864.         x264_mb_analyse_qp_rd( h, &analysis );	///////////////////////
  865.  
  866.     h->mb.b_trellis = h->param.analyse.i_trellis;
  867.     h->mb.b_noise_reduction = h->mb.b_noise_reduction || (!!h->param.analyse.i_noise_reduction && !IS_INTRA( h->mb.i_type ));
  868.  
  869.     if( !IS_SKIP(h->mb.i_type) && h->mb.i_psy_trellis && h->param.analyse.i_trellis == 1 )
  870.         x264_psy_trellis_init( h, 0 );
  871.     if( h->mb.b_trellis == 1 || h->mb.b_noise_reduction )
  872.         h->mb.i_skip_intra = 0;
  873. }


        尽管x264_macroblock_analyse()的源代码比较长，但是它的逻辑比较清晰，如下所示：

（1）、如果当前是I Slice，调用x264_mb_analyse_intra()进行Intra宏块的帧内预测模式分析。


（2）、如果当前是P Slice，则进行下面流程的分析：

    a)、调用x264_macroblock_probe_pskip()分析是否为Skip宏块，如果是的话则不再进行下面分析。

    b)、调用x264_mb_analyse_inter_p16x16()分析P16x16帧间预测的代价。

    c)、调用x264_mb_analyse_inter_p8x8()分析P8x8帧间预测的代价。

    d)、如果P8x8代价值小于P16x16，则依次对4个8x8的子宏块分割进行判断：

        i、调用x264_mb_analyse_inter_p4x4()分析P4x4帧间预测的代价。

        ii、如果P4x4代价值小于P8x8，则调用 x264_mb_analyse_inter_p8x4()和x264_mb_analyse_inter_p4x8()分析P8x4和P4x8帧间预测的代价。

    e)、如果P8x8代价值小于P16x16，调用x264_mb_analyse_inter_p16x8()和x264_mb_analyse_inter_p8x16()分析P16x8和P8x16帧间预测的代价。

    f)、此外还要调用x264_mb_analyse_intra()，检查当前宏块作为Intra宏块编码的代价是否小于作为P宏块编码的代价（P Slice中也允许有Intra宏块）。


（3）、如果当前是B Slice，则进行和P Slice类似的处理。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 托尼虎 > 《X264》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多