logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

x264代码剖析（十四）：核心算法之宏块编码函数x264_macroblock_encode()

 托尼虎 2018-12-25

x264代码剖析（十四）：核心算法之宏块编码函数x264_macroblock_encode()

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

x264代码剖析（十四）：核心算法之宏块编码函数x264_macroblock_encode()

 

        宏块编码函数x264_macroblock_encode()是完成变换与量化的主要函数，而x264_macroblock_encode()调用了x264_macroblock_encode_internal()函数，在x264_macroblock_encode_internal()函数中，主要完成了如下功能：

 

x264_macroblock_encode_skip()：编码Skip类型宏块。

x264_mb_encode_i16x16()：编码Intra16x16类型的宏块。该函数除了进行DCT变换之外，还对16个小块的DC系数进行了Hadamard变换。

x264_mb_encode_i4x4()：编码Intra4x4类型的宏块。

帧间宏块编码：这一部分代码直接写在了函数体里面。

x264_mb_encode_chroma()：编码色度块。

 

        x264_macroblock_encode()函数与x264_macroblock_encode_internal()函数都处于encoder文件夹内的macroblock.c中，其调用关系图如下所示：

 



1、x264_macroblock_encode()函数

 

        x264_macroblock_encode()函数处于encoder文件夹内的macroblock.c中，x264_macroblock_encode()封装了x264_macroblock_encode_internal()。如果色度模式是YUV444的话，传递的参数plane_count=3而chroma=0；如果不是YUV444的话，传递的参数plane_count=1而chroma=1。

 

对应的代码如下：

 

  1. /******************************************************************/
  2. /******************************************************************/
  3. /*
  4. ======Analysed by RuiDong Fang
  5. ======Csdn Blog:http://blog.csdn.net/frd2009041510
  6. ======Date:2016.03.22
  7.  */
  8. /******************************************************************/
  9. /******************************************************************/
  10.  
  11. /************====== 宏块编码函数x264_macroblock_encode() ======************/
  12. /*
  13. 功能：x264_macroblock_encode()封装了x264_macroblock_encode_internal(),即编码的内部函数——残差DCT变换、量化
  14. */
  15. void x264_macroblock_encode( x264_t *h )
  16. {
  17.     if( CHROMA444 )
  18.         x264_macroblock_encode_internal( h, 3, 0 );//YUV444相当于把YUV3个分量都当做Y编码
  19.     else
  20.         x264_macroblock_encode_internal( h, 1, 1 );
  21. }

 

2、x264_macroblock_encode_internal()函数

 

        x264_macroblock_encode_internal()函数也处于encoder文件夹内的macroblock.c中，具体的代码分析如下：

 

  1. /************====== 宏块编码函数x264_macroblock_encode_internal() ======************/
  2. /*
  3. 功能：调用了编码-残差DCT变换、量化-内部函数
  4. */
  5. /*****************************************************************************
  6.  * x264_macroblock_encode:
  7.  *****************************************************************************/
  8. static ALWAYS_INLINE void x264_macroblock_encode_internal( x264_t *h, int plane_count, int chroma )
  9. {
  10.     int i_qp = h->mb.i_qp;
  11.     int b_decimate = h->mb.b_dct_decimate;
  12.     int b_force_no_skip = 0;
  13.     int nz;
  14.     h->mb.i_cbp_luma = 0;
  15.     for( int p = 0; p < plane_count; p++ )
  16.         h->mb.cache.non_zero_count[x264_scan8[LUMA_DC+p]] = 0;
  17.  
  18. 	/*======== PCM ========*/
  19.     if( h->mb.i_type == I_PCM )//PCM
  20.     {
  21.         /* if PCM is chosen, we need to store reconstructed frame data */
  22.         for( int p = 0; p < plane_count; p++ )
  23.             h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[p], FDEC_STRIDE, h->mb.pic.p_fenc[p], FENC_STRIDE, 16 );
  24.         if( chroma )
  25.         {
  26.             int height = 16 >> CHROMA_V_SHIFT;
  27.             h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE, height );
  28.             h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE, height );
  29.         }
  30.         return;
  31.     }
  32.  
  33.     if( !h->mb.b_allow_skip )
  34.     {
  35.         b_force_no_skip = 1;
  36.         if( IS_SKIP(h->mb.i_type) )
  37.         {
  38.             if( h->mb.i_type == P_SKIP )
  39.                 h->mb.i_type = P_L0;
  40.             else if( h->mb.i_type == B_SKIP )
  41.                 h->mb.i_type = B_DIRECT;
  42.         }
  43.     }
  44.  
  45. 	//根据不同的宏块类型，进行编码
  46. 	/*======== P-skip ========*/
  47.     if( h->mb.i_type == P_SKIP )
  48.     {
  49.         /* don't do pskip motion compensation if it was already done in macroblock_analyse */
  50.         if( !h->mb.b_skip_mc )
  51.         {
  52.             int mvx = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][0],
  53.                                   h->mb.mv_min[0], h->mb.mv_max[0] );
  54.             int mvy = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][1],
  55.                                   h->mb.mv_min[1], h->mb.mv_max[1] );
  56.  
  57.             for( int p = 0; p < plane_count; p++ )
  58.                 h->mc.mc_luma( h->mb.pic.p_fdec[p], FDEC_STRIDE,
  59.                                &h->mb.pic.p_fref[0][0][p*4], h->mb.pic.i_stride[p],
  60.                                mvx, mvy, 16, 16, &h->sh.weight[0][p] );
  61.  
  62.             if( chroma )
  63.             {
  64.                 int v_shift = CHROMA_V_SHIFT;
  65.                 int height = 16 >> v_shift;
  66.  
  67.                 /* Special case for mv0, which is (of course) very common in P-skip mode. */
  68.                 if( mvx | mvy )
  69.                     h->mc.mc_chroma( h->mb.pic.p_fdec[1], h->mb.pic.p_fdec[2], FDEC_STRIDE,
  70.                                      h->mb.pic.p_fref[0][0][4], h->mb.pic.i_stride[1],
  71.                                      mvx, 2*mvy>>v_shift, 8, height );
  72.                 else
  73.                     h->mc.load_deinterleave_chroma_fdec( h->mb.pic.p_fdec[1], h->mb.pic.p_fref[0][0][4],
  74.                                                          h->mb.pic.i_stride[1], height );
  75.  
  76.                 if( h->sh.weight[0][1].weightfn )
  77.                     h->sh.weight[0][1].weightfn[8>>2]( h->mb.pic.p_fdec[1], FDEC_STRIDE,
  78.                                                        h->mb.pic.p_fdec[1], FDEC_STRIDE,
  79.                                                        &h->sh.weight[0][1], height );
  80.                 if( h->sh.weight[0][2].weightfn )
  81.                     h->sh.weight[0][2].weightfn[8>>2]( h->mb.pic.p_fdec[2], FDEC_STRIDE,
  82.                                                        h->mb.pic.p_fdec[2], FDEC_STRIDE,
  83.                                                        &h->sh.weight[0][2], height );
  84.             }
  85.         }
  86.  
  87.         x264_macroblock_encode_skip( h );	////////////////////////////编码skip类型宏块
  88.         return;
  89.     }
  90.  
  91. 	/*======== B-skip ========*/
  92.     if( h->mb.i_type == B_SKIP )
  93.     {
  94.         /* don't do bskip motion compensation if it was already done in macroblock_analyse */
  95.         if( !h->mb.b_skip_mc )
  96.             x264_mb_mc( h );
  97.         x264_macroblock_encode_skip( h );	////////////////////////////编码skip类型宏块
  98.         return;
  99.     }
  100.  
  101. 	/*======== 帧内 ========*/
  102.     if( h->mb.i_type == I_16x16 )
  103.     {
  104.         h->mb.b_transform_8x8 = 0;
  105.  
  106.         for( int p = 0; p < plane_count; p++, i_qp = h->mb.i_chroma_qp )
  107.             x264_mb_encode_i16x16( h, p, i_qp );	////////////////////////////如果是Intra16x16类型，调用x264_mb_encode_i16x16()编码宏块(分别编码Y，U，V)
  108.     }
  109.     else if( h->mb.i_type == I_8x8 )
  110.     {
  111.         h->mb.b_transform_8x8 = 1;
  112.         /* If we already encoded 3 of the 4 i8x8 blocks, we don't have to do them again. */
  113.         if( h->mb.i_skip_intra )
  114.         {
  115.             h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.i8x8_fdec_buf, 16, 16 );
  116.             M32( &h->mb.cache.non_zero_count[x264_scan8[ 0]] ) = h->mb.pic.i8x8_nnz_buf[0];
  117.             M32( &h->mb.cache.non_zero_count[x264_scan8[ 2]] ) = h->mb.pic.i8x8_nnz_buf[1];
  118.             M32( &h->mb.cache.non_zero_count[x264_scan8[ 8]] ) = h->mb.pic.i8x8_nnz_buf[2];
  119.             M32( &h->mb.cache.non_zero_count[x264_scan8[10]] ) = h->mb.pic.i8x8_nnz_buf[3];
  120.             h->mb.i_cbp_luma = h->mb.pic.i8x8_cbp;
  121.             /* In RD mode, restore the now-overwritten DCT data. */
  122.             if( h->mb.i_skip_intra == 2 )
  123.                 h->mc.memcpy_aligned( h->dct.luma8x8, h->mb.pic.i8x8_dct_buf, sizeof(h->mb.pic.i8x8_dct_buf) );
  124.         }
  125.         for( int p = 0; p < plane_count; p++, i_qp = h->mb.i_chroma_qp )
  126.         {
  127.             for( int i = (p == 0 && h->mb.i_skip_intra) ? 3 : 0 ; i < 4; i++ )
  128.             {
  129.                 int i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[4*i]];
  130.                 x264_mb_encode_i8x8( h, p, i, i_qp, i_mode, NULL, 1 );	////////////////////////////如果是Intra8x8类型，循环4次调用x264_mb_encode_i8x8()编码宏块
  131.             }
  132.         }
  133.     }
  134.     else if( h->mb.i_type == I_4x4 )
  135.     {
  136.         h->mb.b_transform_8x8 = 0;
  137.         /* If we already encoded 15 of the 16 i4x4 blocks, we don't have to do them again. */
  138.         if( h->mb.i_skip_intra )
  139.         {
  140.             h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.i4x4_fdec_buf, 16, 16 );
  141.             M32( &h->mb.cache.non_zero_count[x264_scan8[ 0]] ) = h->mb.pic.i4x4_nnz_buf[0];
  142.             M32( &h->mb.cache.non_zero_count[x264_scan8[ 2]] ) = h->mb.pic.i4x4_nnz_buf[1];
  143.             M32( &h->mb.cache.non_zero_count[x264_scan8[ 8]] ) = h->mb.pic.i4x4_nnz_buf[2];
  144.             M32( &h->mb.cache.non_zero_count[x264_scan8[10]] ) = h->mb.pic.i4x4_nnz_buf[3];
  145.             h->mb.i_cbp_luma = h->mb.pic.i4x4_cbp;
  146.             /* In RD mode, restore the now-overwritten DCT data. */
  147.             if( h->mb.i_skip_intra == 2 )
  148.                 h->mc.memcpy_aligned( h->dct.luma4x4, h->mb.pic.i4x4_dct_buf, sizeof(h->mb.pic.i4x4_dct_buf) );
  149.         }
  150.         for( int p = 0; p < plane_count; p++, i_qp = h->mb.i_chroma_qp )
  151.         {
  152.             for( int i = (p == 0 && h->mb.i_skip_intra) ? 15 : 0 ; i < 16; i++ )
  153.             {
  154.                 pixel *p_dst = &h->mb.pic.p_fdec[p][block_idx_xy_fdec[i]];
  155.                 int i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];
  156.  
  157.                 if( (h->mb.i_neighbour4[i] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
  158.                     /* emulate missing topright samples */
  159.                     MPIXEL_X4( &p_dst[4-FDEC_STRIDE] ) = PIXEL_SPLAT_X4( p_dst[3-FDEC_STRIDE] );
  160.  
  161.                 x264_mb_encode_i4x4( h, p, i, i_qp, i_mode, 1 );	////////////////////////////如果是Intra4x4类型，循环16次调用x264_mb_encode_i4x4()编码宏块
  162.             }
  163.         }
  164.     }
  165. 	/*======== 帧间 ========*/
  166.     else    /* Inter MB */
  167.     {
  168.         int i_decimate_mb = 0;
  169.  
  170.         /* Don't repeat motion compensation if it was already done in non-RD transform analysis */
  171.         if( !h->mb.b_skip_mc )
  172.             x264_mb_mc( h );
  173.  
  174.         if( h->mb.b_lossless )//===================lossless情况
  175.         {
  176.             if( h->mb.b_transform_8x8 )
  177.                 for( int p = 0; p < plane_count; p++ )
  178.                     for( int i8x8 = 0; i8x8 < 4; i8x8++ )
  179.                     {
  180.                         int x = i8x8&1;
  181.                         int y = i8x8>>1;
  182.                         nz = h->zigzagf.sub_8x8( h->dct.luma8x8[p*4+i8x8], h->mb.pic.p_fenc[p] + 8*x + 8*y*FENC_STRIDE,
  183.                                                                            h->mb.pic.p_fdec[p] + 8*x + 8*y*FDEC_STRIDE );
  184.                         STORE_8x8_NNZ( p, i8x8, nz );
  185.                         h->mb.i_cbp_luma |= nz << i8x8;
  186.                     }
  187.             else
  188.                 for( int p = 0; p < plane_count; p++ )
  189.                     for( int i4x4 = 0; i4x4 < 16; i4x4++ )
  190.                     {
  191.                         nz = h->zigzagf.sub_4x4( h->dct.luma4x4[p*16+i4x4],
  192.                                                  h->mb.pic.p_fenc[p]+block_idx_xy_fenc[i4x4],
  193.                                                  h->mb.pic.p_fdec[p]+block_idx_xy_fdec[i4x4] );
  194.                         h->mb.cache.non_zero_count[x264_scan8[p*16+i4x4]] = nz;
  195.                         h->mb.i_cbp_luma |= nz << (i4x4>>2);
  196.                     }
  197.         }
  198.         else if( h->mb.b_transform_8x8 )//===================DCT8x8情况
  199.         {
  200.             ALIGNED_ARRAY_N( dctcoef, dct8x8,[4],[64] );
  201.             b_decimate &= !h->mb.b_trellis || !h->param.b_cabac; // 8x8 trellis is inherently optimal decimation for CABAC
  202.  
  203.             for( int p = 0; p < plane_count; p++, i_qp = h->mb.i_chroma_qp )
  204.             {
  205.                 CLEAR_16x16_NNZ( p );
  206.                 h->dctf.sub16x16_dct8( dct8x8, h->mb.pic.p_fenc[p], h->mb.pic.p_fdec[p] );
  207.                 h->nr_count[1+!!p*2] += h->mb.b_noise_reduction * 4;
  208.  
  209.                 int plane_cbp = 0;
  210.                 for( int idx = 0; idx < 4; idx++ )
  211.                 {
  212.                     nz = x264_quant_8x8( h, dct8x8[idx], i_qp, ctx_cat_plane[DCT_LUMA_8x8][p], 0, p, idx );
  213.  
  214.                     if( nz )
  215.                     {
  216.                         h->zigzagf.scan_8x8( h->dct.luma8x8[p*4+idx], dct8x8[idx] );
  217.                         if( b_decimate )
  218.                         {
  219.                             int i_decimate_8x8 = h->quantf.decimate_score64( h->dct.luma8x8[p*4+idx] );
  220.                             i_decimate_mb += i_decimate_8x8;
  221.                             if( i_decimate_8x8 >= 4 )
  222.                                 plane_cbp |= 1<<idx;
  223.                         }
  224.                         else
  225.                             plane_cbp |= 1<<idx;
  226.                     }
  227.                 }
  228.  
  229.                 if( i_decimate_mb >= 6 || !b_decimate )
  230.                 {
  231.                     h->mb.i_cbp_luma |= plane_cbp;
  232.                     FOREACH_BIT( idx, 0, plane_cbp )
  233.                     {
  234.                         h->quantf.dequant_8x8( dct8x8[idx], h->dequant8_mf[p?CQM_8PC:CQM_8PY], i_qp );
  235.                         h->dctf.add8x8_idct8( &h->mb.pic.p_fdec[p][8*(idx&1) + 8*(idx>>1)*FDEC_STRIDE], dct8x8[idx] );
  236.                         STORE_8x8_NNZ( p, idx, 1 );
  237.                     }
  238.                 }
  239.             }
  240.         }
  241.         else//===================最普通的情况
  242.         {
  243.             // 帧间预测：16x16 宏块被划分为8x8,每个8x8再次被划分为4x4
  244. 			ALIGNED_ARRAY_N( dctcoef, dct4x4,[16],[16] );
  245.             for( int p = 0; p < plane_count; p++, i_qp = h->mb.i_chroma_qp )
  246.             {
  247.                 CLEAR_16x16_NNZ( p );
  248.                 
  249. 				//16x16DCT（实际上分解为16个4x4DCT）  
  250.                 //求编码帧p_fenc和重建帧p_fdec之间的残差，然后进行DCT变换
  251. 				h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[p], h->mb.pic.p_fdec[p] );	///////////////////对16x16块调用x264_dct_function_t的sub16x16_dct()汇编函数，求得编码宏块数据p_fenc与重建宏块数据p_fdec之间的残差（“sub”），并对残差进行DCT变换
  252.  
  253.                 if( h->mb.b_noise_reduction )
  254.                 {
  255.                     h->nr_count[0+!!p*2] += 16;
  256.                     for( int idx = 0; idx < 16; idx++ )
  257.                         h->quantf.denoise_dct( dct4x4[idx], h->nr_residual_sum[0+!!p*2], h->nr_offset[0+!!p*2], 16 );
  258.                 }
  259.  
  260.                 int plane_cbp = 0;
  261.  
  262.                 //16x16的块分成4个8x8的块
  263. 				for( int i8x8 = 0; i8x8 < 4; i8x8++ )
  264.                 {
  265.                     int i_decimate_8x8 = b_decimate ? 0 : 6;
  266.                     int nnz8x8 = 0;
  267.                     if( h->mb.b_trellis )
  268.                     {
  269.                         for( int i4x4 = 0; i4x4 < 4; i4x4++ )
  270.                         {
  271.                             int idx = i8x8*4+i4x4;
  272.                             if( x264_quant_4x4_trellis( h, dct4x4[idx], CQM_4PY, i_qp, ctx_cat_plane[DCT_LUMA_4x4][p], 0, !!p, p*16+idx ) )
  273.                             {
  274.                                 h->zigzagf.scan_4x4( h->dct.luma4x4[p*16+idx], dct4x4[idx] );
  275.                                 h->quantf.dequant_4x4( dct4x4[idx], h->dequant4_mf[p?CQM_4PC:CQM_4PY], i_qp );
  276.                                 if( i_decimate_8x8 < 6 )
  277.                                     i_decimate_8x8 += h->quantf.decimate_score16( h->dct.luma4x4[p*16+idx] );
  278.                                 h->mb.cache.non_zero_count[x264_scan8[p*16+idx]] = 1;
  279.                                 nnz8x8 = 1;
  280.                             }
  281.                         }
  282.                     }
  283.                     else
  284.                     {
  285.                         //8x8的块分成4个4x4的块，每个4x4的块再分别进行量化
  286. 						nnz8x8 = nz = h->quantf.quant_4x4x4( &dct4x4[i8x8*4], h->quant4_mf[CQM_4PY][i_qp], h->quant4_bias[CQM_4PY][i_qp] );	/////////////////分成4个8x8的块，对每个8x8块分别调用x264_quant_function_t的quant_4x4x4()汇编函数进行量化
  287.                         if( nz )
  288.                         {
  289.                             FOREACH_BIT( idx, i8x8*4, nz )
  290.                             {
  291.                                 h->zigzagf.scan_4x4( h->dct.luma4x4[p*16+idx], dct4x4[idx] );//建立重建帧
  292.                                 h->quantf.dequant_4x4( dct4x4[idx], h->dequant4_mf[p?CQM_4PC:CQM_4PY], i_qp );	//////////////////////分成16个4x4的块，对每个4x4块分别调用x264_quant_function_t的dequant_4x4()汇编函数进行反量化（用于重建帧）
  293.                                 if( i_decimate_8x8 < 6 )
  294.                                     i_decimate_8x8 += h->quantf.decimate_score16( h->dct.luma4x4[p*16+idx] );
  295.                                 h->mb.cache.non_zero_count[x264_scan8[p*16+idx]] = 1;
  296.                             }
  297.                         }
  298.                     }
  299.                     if( nnz8x8 )
  300.                     {
  301.                         i_decimate_mb += i_decimate_8x8;
  302.                         if( i_decimate_8x8 < 4 )
  303.                             STORE_8x8_NNZ( p, i8x8, 0 );
  304.                         else
  305.                             plane_cbp |= 1<<i8x8;
  306.                     }
  307.                 }
  308.  
  309.                 if( i_decimate_mb < 6 )
  310.                 {
  311.                     plane_cbp = 0;
  312.                     CLEAR_16x16_NNZ( p );
  313.                 }
  314.                 else
  315.                 {
  316.                     h->mb.i_cbp_luma |= plane_cbp;
  317.                     FOREACH_BIT( i8x8, 0, plane_cbp )
  318.                     {
  319.                         //用于建立重建帧  
  320.                         //残差进行DCT反变换之后，叠加到预测数据上
  321. 						h->dctf.add8x8_idct( &h->mb.pic.p_fdec[p][(i8x8&1)*8 + (i8x8>>1)*8*FDEC_STRIDE], &dct4x4[i8x8*4] );	////////////分成4个8x8的块，对每个8x8块分别调用x264_dct_function_t的add8x8_idct()汇编函数，对残差进行DCT反变换，并将反变换后的数据叠加（“add”）至预测数据上（用于重建帧）
  322.                     }
  323.                 }
  324.             }
  325.         }
  326.     }
  327.  
  328.     /* encode chroma */
  329.     if( chroma )
  330.     {
  331.         if( IS_INTRA( h->mb.i_type ) )
  332.         {
  333.             int i_mode = h->mb.i_chroma_pred_mode;
  334.             if( h->mb.b_lossless )
  335.                 x264_predict_lossless_chroma( h, i_mode );
  336.             else
  337.             {
  338.                 h->predict_chroma[i_mode]( h->mb.pic.p_fdec[1] );
  339.                 h->predict_chroma[i_mode]( h->mb.pic.p_fdec[2] );
  340.             }
  341.         }
  342.  
  343.         /* encode the 8x8 blocks */
  344.         x264_mb_encode_chroma( h, !IS_INTRA( h->mb.i_type ), h->mb.i_chroma_qp );	/////////////////////编码色度块
  345.     }
  346.     else
  347.         h->mb.i_cbp_chroma = 0;
  348.  
  349.     /* store cbp */
  350.     int cbp = h->mb.i_cbp_chroma << 4 | h->mb.i_cbp_luma;
  351.     if( h->param.b_cabac )
  352.         cbp |= h->mb.cache.non_zero_count[x264_scan8[LUMA_DC    ]] << 8
  353.             |  h->mb.cache.non_zero_count[x264_scan8[CHROMA_DC+0]] << 9
  354.             |  h->mb.cache.non_zero_count[x264_scan8[CHROMA_DC+1]] << 10;
  355.     h->mb.cbp[h->mb.i_mb_xy] = cbp;
  356.  
  357.     /* Check for P_SKIP
  358.      * XXX: in the me perhaps we should take x264_mb_predict_mv_pskip into account
  359.      *      (if multiple mv give same result)*/
  360.     if( !b_force_no_skip )
  361.     {
  362.         if( h->mb.i_type == P_L0 && h->mb.i_partition == D_16x16 &&
  363.             !(h->mb.i_cbp_luma | h->mb.i_cbp_chroma) &&
  364.             M32( h->mb.cache.mv[0][x264_scan8[0]] ) == M32( h->mb.cache.pskip_mv )
  365.             && h->mb.cache.ref[0][x264_scan8[0]] == 0 )
  366.         {
  367.             h->mb.i_type = P_SKIP;
  368.         }
  369.  
  370.         /* Check for B_SKIP */
  371.         if( h->mb.i_type == B_DIRECT && !(h->mb.i_cbp_luma | h->mb.i_cbp_chroma) )
  372.         {
  373.             h->mb.i_type = B_SKIP;
  374.         }
  375.     }
  376. }


        从源代码可以看出，x264_macroblock_encode_internal()的流程大致如下：


（1）、如果是Skip类型，调用x264_macroblock_encode_skip()编码宏块。

（2）、如果是Intra16x16类型，调用x264_mb_encode_i16x16()编码宏块。

（3）、如果是Intra4x4类型，循环16次调用x264_mb_encode_i4x4()编码宏块。

（4）、如果是Inter类型，则不再调用子函数，而是直接进行编码：

        a)、对16x16块调用x264_dct_function_t的sub16x16_dct()汇编函数，求得编码宏块数据p_fenc与重建宏块数据p_fdec之间的残差（“sub”），并对残差进行DCT变换。

        b)、分成4个8x8的块，对每个8x8块分别调用x264_quant_function_t的quant_4x4x4()汇编函数进行量化。

        c)、分成16个4x4的块，对每个4x4块分别调用x264_quant_function_t的dequant_4x4()汇编函数进行反量化（用于重建帧）。

        d)、分成4个8x8的块，对每个8x8块分别调用x264_dct_function_t的add8x8_idct()汇编函数，对残差进行DCT反变换，并将反变换后的数据叠加（“add”）至预测数据上（用于重建帧）。

（5）、如果对色度编码，调用x264_mb_encode_chroma()。

 

        从Inter宏块编码的步骤可以看出，编码就是“DCT变换+量化”两步的组合。在接下来的文章中将依次分析变换、量化的具体代码。

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

    来自： 托尼虎 > 《X264》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多