logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

x264代码剖析（十八）：核心算法之滤波

 托尼虎 2018-12-25

x264代码剖析（十八）：核心算法之滤波

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

x264代码剖析（十八）：核心算法之滤波

 

        H.264/MPEG-4 AVC视频编码标准中，在编解码器反变换量化后，图像会出现方块效应，主要原因是：1）基于块的帧内和帧间预测残差的DCT变换，变换系数的量化过程相对粗糙，因而反量化过程恢复的变换系数有误差，会造成在图像块边界上的视觉不连续；2）运动补偿可能是从不是同一帧的不同位置上内插样点数据复制而来，因为运动补偿块的匹配不可能是绝对准确的，所以就会在复制块的边界上产生数据不连续；3）参考帧中的存在的不连续也被复制到需要补偿的图像块内。

 

        尽管H.264采用较小的4×4变换尺寸可以降低这种不连续现象，但仍需要一个去方块滤波器，以最大程度提高编码性能。在x264中，x264_slice_write()函数中调用了x264_fdec_filter_row()的源代码。x264_fdec_filter_row()对应着x264中的滤波模块。滤波模块主要完成了下面3个方面的功能：

（1）环路滤波（去块效应滤波）；

（2）半像素内插；

（3）视频质量指标PSNR和SSIM的计算。

 

        滤波模块对应的函数关系调用图如下：

 


 

        下面对x264中的滤波模块对应的主要函数分别进行分析。

 

1、x264_slice_write()函数

 

        x264_slice_write()函数中调用了x264_fdec_filter_row()函数，对应于滤波模块。具体的代码分析见《x264代码剖析（九）：x264_encoder_encode()函数之x264_slice's'_write()函数》。

 

2、x264_fdec_filter_row()函数

 

        x264_fdec_filter_row()函数用于对一行宏块进行滤波。该函数的定义位于encoder\encoder.c，x264_fdec_filter_row()完成了三步工作：

（1）环路滤波（去块效应滤波）。通过调用x264_frame_deblock_row()函数实现。

（2）半像素内插。通过调用x264_frame_filter()函数实现。

（3）视频质量SSIM和PSNR的计算。PSNR通过调用x264_pixel_ssd_wxh()函数实现，在这里只计算了SSD；SSIM的计算则是通过x264_pixel_ssim_wxh()函数实现。

 

        对应的代码分析如下：

 

  1. /******************************************************************/
  2. /******************************************************************/
  3. /*
  4. ======Analysed by RuiDong Fang
  5. ======Csdn Blog:http://blog.csdn.net/frd2009041510
  6. ======Date:2016.04.06
  7.  */
  8. /******************************************************************/
  9. /******************************************************************/
  10.  
  11. /************====== x264_fdec_filter_row()函数 ======************/
  12. /*
  13. 功能：对一行宏块进行滤波-去块效应滤波、半像素插值、SSIM/PSNR计算等
  14. */
  15. static void x264_fdec_filter_row( x264_t *h, int mb_y, int pass )
  16. {
  17.     /* mb_y is the mb to be encoded next, not the mb to be filtered here */
  18.     int b_hpel = h->fdec->b_kept_as_ref;
  19.     int b_deblock = h->sh.i_disable_deblocking_filter_idc != 1;
  20.     int b_end = mb_y == h->i_threadslice_end;
  21.     int b_measure_quality = 1;
  22.     int min_y = mb_y - (1 << SLICE_MBAFF);
  23.     int b_start = min_y == h->i_threadslice_start;
  24.     /* Even in interlaced mode, deblocking never modifies more than 4 pixels
  25.      * above each MB, as bS=4 doesn't happen for the top of interlaced mbpairs. */
  26.     int minpix_y = min_y*16 - 4 * !b_start;
  27.     int maxpix_y = mb_y*16 - 4 * !b_end;
  28.     b_deblock &= b_hpel || h->param.b_full_recon || h->param.psz_dump_yuv;
  29.     if( h->param.b_sliced_threads )
  30.     {
  31.         switch( pass )
  32.         {
  33.             /* During encode: only do deblock if asked for */
  34.             default:
  35.             case 0:
  36.                 b_deblock &= h->param.b_full_recon;
  37.                 b_hpel = 0;
  38.                 break;
  39.             /* During post-encode pass: do deblock if not done yet, do hpel for all
  40.              * rows except those between slices. */
  41.             case 1:
  42.                 b_deblock &= !h->param.b_full_recon;
  43.                 b_hpel &= !(b_start && min_y > 0);
  44.                 b_measure_quality = 0;
  45.                 break;
  46.             /* Final pass: do the rows between slices in sequence. */
  47.             case 2:
  48.                 b_deblock = 0;
  49.                 b_measure_quality = 0;
  50.                 break;
  51.         }
  52.     }
  53.     if( mb_y & SLICE_MBAFF )
  54.         return;
  55.     if( min_y < h->i_threadslice_start )
  56.         return;
  57.  
  58.     if( b_deblock )
  59.         for( int y = min_y; y < mb_y; y += (1 << SLICE_MBAFF) )
  60.             x264_frame_deblock_row( h, y );	////////////////////////////去块效应滤波
  61.  
  62.     /* FIXME: Prediction requires different borders for interlaced/progressive mc,
  63.      * but the actual image data is equivalent. For now, maintain this
  64.      * consistency by copying deblocked pixels between planes. */
  65.     if( PARAM_INTERLACED && (!h->param.b_sliced_threads || pass == 1) )
  66.         for( int p = 0; p < h->fdec->i_plane; p++ )
  67.             for( int i = minpix_y>>(CHROMA_V_SHIFT && p); i < maxpix_y>>(CHROMA_V_SHIFT && p); i++ )
  68.                 memcpy( h->fdec->plane_fld[p] + i*h->fdec->i_stride[p],
  69.                         h->fdec->plane[p]     + i*h->fdec->i_stride[p],
  70.                         h->mb.i_mb_width*16*sizeof(pixel) );
  71.  
  72.     if( h->fdec->b_kept_as_ref && (!h->param.b_sliced_threads || pass == 1) )
  73.         x264_frame_expand_border( h, h->fdec, min_y );
  74.     if( b_hpel )
  75.     {
  76.         int end = mb_y == h->mb.i_mb_height;
  77.         /* Can't do hpel until the previous slice is done encoding. */
  78.         if( h->param.analyse.i_subpel_refine )
  79.         {
  80.             x264_frame_filter( h, h->fdec, min_y, end );	////////////////////////////半像素内插
  81.             x264_frame_expand_border_filtered( h, h->fdec, min_y, end );
  82.         }
  83.     }
  84.  
  85.     if( SLICE_MBAFF && pass == 0 )
  86.         for( int i = 0; i < 3; i++ )
  87.         {
  88.             XCHG( pixel *, h->intra_border_backup[0][i], h->intra_border_backup[3][i] );
  89.             XCHG( pixel *, h->intra_border_backup[1][i], h->intra_border_backup[4][i] );
  90.         }
  91.  
  92.     if( h->i_thread_frames > 1 && h->fdec->b_kept_as_ref )
  93.         x264_frame_cond_broadcast( h->fdec, mb_y*16 + (b_end ? 10000 : -(X264_THREAD_HEIGHT << SLICE_MBAFF)) );
  94.  
  95. 	//计算编码的质量
  96.     if( b_measure_quality )
  97.     {
  98.         maxpix_y = X264_MIN( maxpix_y, h->param.i_height );
  99.         
  100. 		//如果需要打印输出PSNR
  101. 		if( h->param.analyse.b_psnr )
  102.         {
  103.             //实际上是计算SSD  
  104.             //输出的时候调用x264_psnr()换算SSD为PSNR  
  105.             /** 
  106.              * 计算PSNR的过程 
  107.              * 
  108.              * MSE = SSD*1/(w*h) 
  109.              * PSNR= 10*log10(MAX^2/MSE) 
  110.              * 
  111.              * 其中MAX指的是图像的灰度级，对于8bit来说就是2^8-1=255 
  112.              */
  113. 			for( int p = 0; p < (CHROMA444 ? 3 : 1); p++ )
  114.                 h->stat.frame.i_ssd[p] += x264_pixel_ssd_wxh( &h->pixf,
  115.                     h->fdec->plane[p] + minpix_y * h->fdec->i_stride[p], h->fdec->i_stride[p],	//重建帧
  116.                     h->fenc->plane[p] + minpix_y * h->fenc->i_stride[p], h->fenc->i_stride[p],	//编码帧
  117.                     h->param.i_width, maxpix_y-minpix_y );
  118.             if( !CHROMA444 )
  119.             {
  120.                 uint64_t ssd_u, ssd_v;
  121.                 int v_shift = CHROMA_V_SHIFT;
  122.                 x264_pixel_ssd_nv12( &h->pixf,
  123.                     h->fdec->plane[1] + (minpix_y>>v_shift) * h->fdec->i_stride[1], h->fdec->i_stride[1],
  124.                     h->fenc->plane[1] + (minpix_y>>v_shift) * h->fenc->i_stride[1], h->fenc->i_stride[1],
  125.                     h->param.i_width>>1, (maxpix_y-minpix_y)>>v_shift, &ssd_u, &ssd_v );
  126.                 h->stat.frame.i_ssd[1] += ssd_u;
  127.                 h->stat.frame.i_ssd[2] += ssd_v;
  128.             }
  129.         }
  130.  
  131. 		//如果需要打印输出SSIM
  132.         if( h->param.analyse.b_ssim )
  133.         {
  134.             int ssim_cnt;
  135.             x264_emms();
  136.             /* offset by 2 pixels to avoid alignment of ssim blocks with dct blocks,
  137.              * and overlap by 4 */
  138.             minpix_y += b_start ? 2 : -6;
  139.             h->stat.frame.f_ssim +=
  140.                 x264_pixel_ssim_wxh( &h->pixf,
  141.                     h->fdec->plane[0] + 2+minpix_y*h->fdec->i_stride[0], h->fdec->i_stride[0],	//重建帧
  142.                     h->fenc->plane[0] + 2+minpix_y*h->fenc->i_stride[0], h->fenc->i_stride[0],	//编码帧
  143.                     h->param.i_width-2, maxpix_y-minpix_y, h->scratch_buffer, &ssim_cnt );
  144.             h->stat.frame.i_ssim_cnt += ssim_cnt;
  145.         }
  146.     }
  147. }


3、x264_frame_deblock_row()函数

 

        x264_frame_deblock_row()用于进行环路滤波（去块效应滤波）。该函数的定义位于common\deblock.c，x264_frame_deblock_row()中有一个很长的宏定义“FILTER()”定义了函数调用的方式。FILTER( intra, dir, edge, qp, chroma_qp )中：

（1）“intra”指定了是普通滤波（Bs=1，2，3）还是强滤波（Bs=4）；

（2）“dir”指定了滤波器的方向。0为水平滤波器（垂直边界），1为垂直滤波器（水平边界）；

（3）“edge”指定了边界的位置。“0”，“1”，“2”，“3”分别代表了水平（或者垂直）的4条边界。

 

        对应的代码分析如下：

 

  1. /************====== x264_frame_deblock_row()函数 ======************/
  2. /*
  3. 功能：去块效应滤波
  4. */
  5. void x264_frame_deblock_row( x264_t *h, int mb_y )
  6. {
  7.     int b_interlaced = SLICE_MBAFF;
  8.     int a = h->sh.i_alpha_c0_offset - QP_BD_OFFSET;
  9.     int b = h->sh.i_beta_offset - QP_BD_OFFSET;
  10.     int qp_thresh = 15 - X264_MIN( a, b ) - X264_MAX( 0, h->pps->i_chroma_qp_index_offset );
  11.     int stridey   = h->fdec->i_stride[0];
  12.     int strideuv  = h->fdec->i_stride[1];
  13.     int chroma444 = CHROMA444;
  14.     int chroma_height = 16 >> CHROMA_V_SHIFT;
  15.     intptr_t uvdiff = chroma444 ? h->fdec->plane[2] - h->fdec->plane[1] : 1;
  16.  
  17.     for( int mb_x = 0; mb_x < h->mb.i_mb_width; mb_x += (~b_interlaced | mb_y)&1, mb_y ^= b_interlaced )
  18.     {
  19.         x264_prefetch_fenc( h, h->fdec, mb_x, mb_y );
  20.         x264_macroblock_cache_load_neighbours_deblock( h, mb_x, mb_y );
  21.  
  22.         int mb_xy = h->mb.i_mb_xy;
  23.         int transform_8x8 = h->mb.mb_transform_size[mb_xy];
  24.         int intra_cur = IS_INTRA( h->mb.type[mb_xy] );
  25.         uint8_t (*bs)[8][4] = h->deblock_strength[mb_y&1][h->param.b_sliced_threads?mb_xy:mb_x];
  26.  
  27. 		//找到像素数据（宏块的大小是16x16）
  28.         pixel *pixy = h->fdec->plane[0] + 16*mb_y*stridey  + 16*mb_x;
  29.         pixel *pixuv = h->fdec->plane[1] + chroma_height*mb_y*strideuv + 16*mb_x;
  30.  
  31.         if( mb_y & MB_INTERLACED )
  32.         {
  33.             pixy -= 15*stridey;
  34.             pixuv -= (chroma_height-1)*strideuv;
  35.         }
  36.  
  37.         int stride2y  = stridey << MB_INTERLACED;
  38.         int stride2uv = strideuv << MB_INTERLACED;
  39.         
  40. 		//QP，用于计算环路滤波的门限值alpha和beta 
  41. 		int qp = h->mb.qp[mb_xy];
  42.         int qpc = h->chroma_qp_table[qp];
  43.         int first_edge_only = (h->mb.partition[mb_xy] == D_16x16 && !h->mb.cbp[mb_xy] && !intra_cur) || qp <= qp_thresh;
  44.  
  45. 		/* 
  46.          * 滤波顺序如下所示（大方框代表16x16块） 
  47.          * 
  48.          * +--4-+--4-+--4-+--4-+ 
  49.          * 0    1    2    3    | 
  50.          * +--5-+--5-+--5-+--5-+ 
  51.          * 0    1    2    3    | 
  52.          * +--6-+--6-+--6-+--6-+ 
  53.          * 0    1    2    3    | 
  54.          * +--7-+--7-+--7-+--7-+ 
  55.          * 0    1    2    3    | 
  56.          * +----+----+----+----+ 
  57.          * 
  58.          */  
  59.         //一个比较长的宏，用于进行环路滤波  
  60.         //根据不同的情况传递不同的参数  
  61.         //几个参数的含义：  
  62.         //intra：  
  63.         //为“_intra”的时候：  
  64.         //其中的“deblock_edge##intra()”展开为函数deblock_edge_intra()  
  65.         //其中的“h->loopf.deblock_luma##intra[dir]”展开为强滤波汇编函数h->loopf.deblock_luma_intra[dir]()  
  66.         //为“”（空），其中的“deblock_edge##intra()”展开为函数deblock_edge()  
  67.         //其中的“h->loopf.deblock_luma##intra[dir]”展开为普通滤波汇编函数h->loopf.deblock_luma[dir]()  
  68.         //dir：  
  69.         //决定了滤波的方向：0为水平滤波器（垂直边界），1为垂直滤波器（水平边界）
  70.  
  71.         #define FILTER( intra, dir, edge, qp, chroma_qp )\
  72.         do\
  73.         {\
  74.             if( !(edge & 1) || !transform_8x8 )\
  75.             {\
  76.                 deblock_edge##intra( h, pixy + 4*edge*(dir?stride2y:1),\
  77.                                      stride2y, bs[dir][edge], qp, a, b, 0,\
  78.                                      h->loopf.deblock_luma##intra[dir] );\
  79.                 if( CHROMA_FORMAT == CHROMA_444 )\
  80.                 {\
  81.                     deblock_edge##intra( h, pixuv          + 4*edge*(dir?stride2uv:1),\
  82.                                          stride2uv, bs[dir][edge], chroma_qp, a, b, 0,\
  83.                                          h->loopf.deblock_luma##intra[dir] );\
  84.                     deblock_edge##intra( h, pixuv + uvdiff + 4*edge*(dir?stride2uv:1),\
  85.                                          stride2uv, bs[dir][edge], chroma_qp, a, b, 0,\
  86.                                          h->loopf.deblock_luma##intra[dir] );\
  87.                 }\
  88.                 else if( CHROMA_FORMAT == CHROMA_420 && !(edge & 1) )\
  89.                 {\
  90.                     deblock_edge##intra( h, pixuv + edge*(dir?2*stride2uv:4),\
  91.                                          stride2uv, bs[dir][edge], chroma_qp, a, b, 1,\
  92.                                          h->loopf.deblock_chroma##intra[dir] );\
  93.                 }\
  94.             }\
  95.             if( CHROMA_FORMAT == CHROMA_422 && (dir || !(edge & 1)) )\
  96.             {\
  97.                 deblock_edge##intra( h, pixuv + edge*(dir?4*stride2uv:4),\
  98.                                      stride2uv, bs[dir][edge], chroma_qp, a, b, 1,\
  99.                                      h->loopf.deblock_chroma##intra[dir] );\
  100.             }\
  101.         } while(0)
  102.  
  103.         if( h->mb.i_neighbour & MB_LEFT )
  104.         {
  105.             if( b_interlaced && h->mb.field[h->mb.i_mb_left_xy[0]] != MB_INTERLACED )
  106.             {
  107.                 int luma_qp[2];
  108.                 int chroma_qp[2];
  109.                 int left_qp[2];
  110.                 x264_deblock_inter_t luma_deblock = h->loopf.deblock_luma_mbaff;
  111.                 x264_deblock_inter_t chroma_deblock = h->loopf.deblock_chroma_mbaff;
  112.                 x264_deblock_intra_t luma_intra_deblock = h->loopf.deblock_luma_intra_mbaff;
  113.                 x264_deblock_intra_t chroma_intra_deblock = h->loopf.deblock_chroma_intra_mbaff;
  114.                 int c = chroma444 ? 0 : 1;
  115.  
  116.                 left_qp[0] = h->mb.qp[h->mb.i_mb_left_xy[0]];
  117.                 luma_qp[0] = (qp + left_qp[0] + 1) >> 1;
  118.                 chroma_qp[0] = (qpc + h->chroma_qp_table[left_qp[0]] + 1) >> 1;
  119.                 if( intra_cur || IS_INTRA( h->mb.type[h->mb.i_mb_left_xy[0]] ) )
  120.                 {
  121.                     deblock_edge_intra( h, pixy,           2*stridey,  bs[0][0], luma_qp[0],   a, b, 0, luma_intra_deblock );
  122.                     deblock_edge_intra( h, pixuv,          2*strideuv, bs[0][0], chroma_qp[0], a, b, c, chroma_intra_deblock );
  123.                     if( chroma444 )
  124.                         deblock_edge_intra( h, pixuv + uvdiff, 2*strideuv, bs[0][0], chroma_qp[0], a, b, c, chroma_intra_deblock );
  125.                 }
  126.                 else
  127.                 {
  128.                     deblock_edge( h, pixy,           2*stridey,  bs[0][0], luma_qp[0],   a, b, 0, luma_deblock );
  129.                     deblock_edge( h, pixuv,          2*strideuv, bs[0][0], chroma_qp[0], a, b, c, chroma_deblock );
  130.                     if( chroma444 )
  131.                         deblock_edge( h, pixuv + uvdiff, 2*strideuv, bs[0][0], chroma_qp[0], a, b, c, chroma_deblock );
  132.                 }
  133.  
  134.                 int offy = MB_INTERLACED ? 4 : 0;
  135.                 int offuv = MB_INTERLACED ? 4-CHROMA_V_SHIFT : 0;
  136.                 left_qp[1] = h->mb.qp[h->mb.i_mb_left_xy[1]];
  137.                 luma_qp[1] = (qp + left_qp[1] + 1) >> 1;
  138.                 chroma_qp[1] = (qpc + h->chroma_qp_table[left_qp[1]] + 1) >> 1;
  139.                 if( intra_cur || IS_INTRA( h->mb.type[h->mb.i_mb_left_xy[1]] ) )
  140.                 {
  141.                     deblock_edge_intra( h, pixy           + (stridey<<offy),   2*stridey,  bs[0][4], luma_qp[1],   a, b, 0, luma_intra_deblock );
  142.                     deblock_edge_intra( h, pixuv          + (strideuv<<offuv), 2*strideuv, bs[0][4], chroma_qp[1], a, b, c, chroma_intra_deblock );
  143.                     if( chroma444 )
  144.                         deblock_edge_intra( h, pixuv + uvdiff + (strideuv<<offuv), 2*strideuv, bs[0][4], chroma_qp[1], a, b, c, chroma_intra_deblock );
  145.                 }
  146.                 else
  147.                 {
  148.                     deblock_edge( h, pixy           + (stridey<<offy),   2*stridey,  bs[0][4], luma_qp[1],   a, b, 0, luma_deblock );
  149.                     deblock_edge( h, pixuv          + (strideuv<<offuv), 2*strideuv, bs[0][4], chroma_qp[1], a, b, c, chroma_deblock );
  150.                     if( chroma444 )
  151.                         deblock_edge( h, pixuv + uvdiff + (strideuv<<offuv), 2*strideuv, bs[0][4], chroma_qp[1], a, b, c, chroma_deblock );
  152.                 }
  153.             }
  154.             else
  155.             {
  156.                 //左边宏块的qp
  157. 				int qpl = h->mb.qp[h->mb.i_mb_xy-1];
  158.                 int qp_left = (qp + qpl + 1) >> 1;
  159.                 int qpc_left = (qpc + h->chroma_qp_table[qpl] + 1) >> 1;
  160.                 //Intra宏块左边宏块的qp
  161. 				int intra_left = IS_INTRA( h->mb.type[h->mb.i_mb_xy-1] );
  162.                 int intra_deblock = intra_cur || intra_left;
  163.  
  164.                 /* Any MB that was coded, or that analysis decided to skip, has quality commensurate with its QP.
  165.                  * But if deblocking affects neighboring MBs that were force-skipped, blur might accumulate there.
  166.                  * So reset their effective QP to max, to indicate that lack of guarantee. */
  167.                 if( h->fdec->mb_info && M32( bs[0][0] ) )
  168.                 {
  169. #define RESET_EFFECTIVE_QP(xy) h->fdec->effective_qp[xy] |= 0xff * !!(h->fdec->mb_info[xy] & X264_MBINFO_CONSTANT);
  170.                     RESET_EFFECTIVE_QP(mb_xy);
  171.                     RESET_EFFECTIVE_QP(h->mb.i_mb_left_xy[0]);
  172.                 }
  173.  
  174.                 if( intra_deblock )
  175. 					//【0】强滤波，水平滤波器（垂直边界）
  176. 					FILTER( _intra, 0, 0, qp_left, qpc_left );
  177.                 else
  178.                     //【0】普通滤波，水平滤波器（垂直边界）
  179. 					FILTER(       , 0, 0, qp_left, qpc_left );
  180.             }
  181.         }
  182.         if( !first_edge_only )
  183.         {
  184.             //普通滤波，水平滤波器（垂直边界）
  185. 			FILTER( , 0, 1, qp, qpc );//【1】
  186.             FILTER( , 0, 2, qp, qpc );//【2】
  187.             FILTER( , 0, 3, qp, qpc );//【3】
  188.         }
  189.  
  190.         if( h->mb.i_neighbour & MB_TOP )
  191.         {
  192.             if( b_interlaced && !(mb_y&1) && !MB_INTERLACED && h->mb.field[h->mb.i_mb_top_xy] )
  193.             {
  194.                 int mbn_xy = mb_xy - 2 * h->mb.i_mb_stride;
  195.  
  196.                 for( int j = 0; j < 2; j++, mbn_xy += h->mb.i_mb_stride )
  197.                 {
  198.                     int qpt = h->mb.qp[mbn_xy];
  199.                     int qp_top = (qp + qpt + 1) >> 1;
  200.                     int qpc_top = (qpc + h->chroma_qp_table[qpt] + 1) >> 1;
  201.                     int intra_top = IS_INTRA( h->mb.type[mbn_xy] );
  202.                     if( intra_cur || intra_top )
  203.                         M32( bs[1][4*j] ) = 0x03030303;
  204.  
  205.                     // deblock the first horizontal edge of the even rows, then the first horizontal edge of the odd rows
  206.                     deblock_edge( h, pixy      + j*stridey,  2* stridey, bs[1][4*j], qp_top, a, b, 0, h->loopf.deblock_luma[1] );
  207.                     if( chroma444 )
  208.                     {
  209.                         deblock_edge( h, pixuv          + j*strideuv, 2*strideuv, bs[1][4*j], qpc_top, a, b, 0, h->loopf.deblock_luma[1] );
  210.                         deblock_edge( h, pixuv + uvdiff + j*strideuv, 2*strideuv, bs[1][4*j], qpc_top, a, b, 0, h->loopf.deblock_luma[1] );
  211.                     }
  212.                     else
  213.                         deblock_edge( h, pixuv          + j*strideuv, 2*strideuv, bs[1][4*j], qpc_top, a, b, 1, h->loopf.deblock_chroma[1] );
  214.                 }
  215.             }
  216.             else
  217.             {
  218.                 int qpt = h->mb.qp[h->mb.i_mb_top_xy];
  219.                 int qp_top = (qp + qpt + 1) >> 1;
  220.                 int qpc_top = (qpc + h->chroma_qp_table[qpt] + 1) >> 1;
  221.                 int intra_top = IS_INTRA( h->mb.type[h->mb.i_mb_top_xy] );
  222.                 int intra_deblock = intra_cur || intra_top;
  223.  
  224.                 /* This edge has been modified, reset effective qp to max. */
  225.                 if( h->fdec->mb_info && M32( bs[1][0] ) )
  226.                 {
  227.                     RESET_EFFECTIVE_QP(mb_xy);
  228.                     RESET_EFFECTIVE_QP(h->mb.i_mb_top_xy);
  229.                 }
  230.  
  231.                 if( (!b_interlaced || (!MB_INTERLACED && !h->mb.field[h->mb.i_mb_top_xy])) && intra_deblock )
  232.                 {
  233.                     FILTER( _intra, 1, 0, qp_top, qpc_top );//【4】普通滤波，垂直滤波器（水平边界）
  234.                 }
  235.                 else
  236.                 {
  237.                     if( intra_deblock )
  238.                         M32( bs[1][0] ) = 0x03030303;
  239.                     FILTER(       , 1, 0, qp_top, qpc_top );//【4】普通滤波，垂直滤波器（水平边界）
  240.                 }
  241.             }
  242.         }
  243.  
  244.         if( !first_edge_only )
  245.         {
  246.             //普通滤波，垂直滤波器（水平边界） 
  247. 			FILTER( , 1, 1, qp, qpc );//【5】
  248.             FILTER( , 1, 2, qp, qpc );//【6】
  249.             FILTER( , 1, 3, qp, qpc );//【7】
  250.         }
  251.  
  252.         #undef FILTER
  253.     }
  254. }


4、x264_frame_filter()函数

 

        x264_frame_filter()用于完成半像素内插的工作。该函数的定义位于common\mc.c，x264_frame_filter()调用了汇编函数h->mc.hpel_filter()完成了半像素内插的工作。经过汇编半像素内插函数处理之后，得到的水平半像素内差点存储在x264_frame_t的filtered[][1]中，垂直半像素内差点存储在x264_frame_t的filtered[][2]中，对角线半像素内差点存储在x264_frame_t的filtered[][3]中（整像素点存储在x264_frame_t的filtered[][0]中）。

 

        对应的代码分析如下：

 

  1. /************====== x264_frame_filter()函数 ======************/
  2. /*
  3. 功能：半像素内插
  4. */
  5. void x264_frame_filter( x264_t *h, x264_frame_t *frame, int mb_y, int b_end )
  6. {
  7.     const int b_interlaced = PARAM_INTERLACED;
  8.     int start = mb_y*16 - 8; // buffer = 4 for deblock + 3 for 6tap, rounded to 8
  9.     int height = (b_end ? frame->i_lines[0] + 16*PARAM_INTERLACED : (mb_y+b_interlaced)*16) + 8;
  10.  
  11.     if( mb_y & b_interlaced )
  12.         return;
  13.  
  14.     for( int p = 0; p < (CHROMA444 ? 3 : 1); p++ )
  15.     {
  16.         int stride = frame->i_stride[p];
  17.         const int width = frame->i_width[p];
  18.         int offs = start*stride - 8; // buffer = 3 for 6tap, aligned to 8 for simd
  19.  
  20. 		//半像素内插
  21.         if( !b_interlaced || h->mb.b_adaptive_mbaff )
  22.             h->mc.hpel_filter(
  23.                 frame->filtered[p][1] + offs,//水平半像素内插
  24.                 frame->filtered[p][2] + offs,//垂直半像素内插
  25.                 frame->filtered[p][3] + offs,//中间半像素内插
  26.                 frame->plane[p] + offs,
  27.                 stride, width + 16, height - start,
  28.                 h->scratch_buffer );
  29.  
  30.         if( b_interlaced )
  31.         {
  32.             /* MC must happen between pixels in the same field. */
  33.             stride = frame->i_stride[p] << 1;
  34.             start = (mb_y*16 >> 1) - 8;
  35.             int height_fld = ((b_end ? frame->i_lines[p] : mb_y*16) >> 1) + 8;
  36.             offs = start*stride - 8;
  37.             for( int i = 0; i < 2; i++, offs += frame->i_stride[p] )
  38.             {
  39.                 h->mc.hpel_filter(
  40.                     frame->filtered_fld[p][1] + offs,
  41.                     frame->filtered_fld[p][2] + offs,
  42.                     frame->filtered_fld[p][3] + offs,
  43.                     frame->plane_fld[p] + offs,
  44.                     stride, width + 16, height_fld - start,
  45.                     h->scratch_buffer );
  46.             }
  47.         }
  48.     }
  49.  
  50.     /* generate integral image:
  51.      * frame->integral contains 2 planes. in the upper plane, each element is
  52.      * the sum of an 8x8 pixel region with top-left corner on that point.
  53.      * in the lower plane, 4x4 sums (needed only with --partitions p4x4). */
  54.  
  55.     if( frame->integral )
  56.     {
  57.         int stride = frame->i_stride[0];
  58.         if( start < 0 )
  59.         {
  60.             memset( frame->integral - PADV * stride - PADH, 0, stride * sizeof(uint16_t) );
  61.             start = -PADV;
  62.         }
  63.         if( b_end )
  64.             height += PADV-9;
  65.         for( int y = start; y < height; y++ )
  66.         {
  67.             pixel    *pix  = frame->plane[0] + y * stride - PADH;
  68.             uint16_t *sum8 = frame->integral + (y+1) * stride - PADH;
  69.             uint16_t *sum4;
  70.             if( h->frames.b_have_sub8x8_esa )
  71.             {
  72.                 h->mc.integral_init4h( sum8, pix, stride );
  73.                 sum8 -= 8*stride;
  74.                 sum4 = sum8 + stride * (frame->i_lines[0] + PADV*2);
  75.                 if( y >= 8-PADV )
  76.                     h->mc.integral_init4v( sum8, sum4, stride );
  77.             }
  78.             else
  79.             {
  80.                 h->mc.integral_init8h( sum8, pix, stride );
  81.                 if( y >= 8-PADV )
  82.                     h->mc.integral_init8v( sum8-8*stride, stride );
  83.             }
  84.         }
  85.     }
  86. }


5、x264_pixel_ssd_wxh()函数

 

        x264_pixel_ssd_wxh()用于计算SSD（用于以后计算PSNR）。该函数的定义位于common\pixel.c，x264_pixel_ssd_wxh()在计算大部分块的SSD的时候是以16x16的块为单位；当宽度不是16的整数倍的时候，在左侧边缘处不足16像素的地方使用了8x16的块进行计算；当高度不是16的整数倍的时候，在下方不足16像素的地方使用了8x8的块进行计算；当宽高不是8的整数倍的时候，则再单独计算。

 

        对应的代码分析如下：

 

  1. /************====== x264_pixel_ssd_wxh()函数 ======************/
  2. /*
  3.  * 功能：计算SSD（可用于计算PSNR）
  4.  * pix1: 受损数据 
  5.  * pix2: 原始数据 
  6.  * i_width: 图像宽 
  7.  * i_height: 图像高
  8. */
  9. uint64_t x264_pixel_ssd_wxh( x264_pixel_function_t *pf, pixel *pix1, intptr_t i_pix1,
  10.                              pixel *pix2, intptr_t i_pix2, int i_width, int i_height )
  11. {
  12.     uint64_t i_ssd = 0;//计算结果都累加到i_ssd变量上
  13.     int y;
  14.     int align = !(((intptr_t)pix1 | (intptr_t)pix2 | i_pix1 | i_pix2) & 15);
  15.  
  16. #define SSD(size) i_ssd += pf->ssd[size]( pix1 + y*i_pix1 + x, i_pix1, \
  17.                                           pix2 + y*i_pix2 + x, i_pix2 );
  18.     /* 
  19.      * SSD计算过程： 
  20.      * 从左上角开始，绝大部分块使用16x16的SSD计算 
  21.      * 右边边界部分可能用16x8的SSD计算 
  22.      * 下边边界可能用8x8的SSD计算 
  23.      * 注意：这么做主要是出于汇编优化的考虑 
  24.      * 
  25.      * +----+----+----+----+----+----+----+----+----+----+-+ 
  26.      * |                   |                   |         | 
  27.      * +                   +                   +         + 
  28.      * |                   |                   |         | 
  29.      * +      16x16        +       16x16       +  8x16   + 
  30.      * |                   |                   |         | 
  31.      * +                   +                   +         + 
  32.      * |                   |                   |         | 
  33.      * +----+----+----+----+----+----+----+----+----+----+-+ 
  34.      * |         | 
  35.      * +   8x8   + 
  36.      * |         | 
  37.      * +----+----+ 
  38.      * +         + 
  39.      */
  40. 	for( y = 0; y < i_height-15; y += 16 )
  41.     {
  42.         int x = 0;
  43.         if( align )//大部分使用16x16的SSD 
  44.             for( ; x < i_width-15; x += 16 )
  45.                 SSD(PIXEL_16x16);
  46.         for( ; x < i_width-7; x += 8 )//右边边缘部分可能用8x16的SSD 
  47.             SSD(PIXEL_8x16);
  48.     }
  49.     if( y < i_height-7 )//下边边缘部分可能用到8x8的SSD
  50.         for( int x = 0; x < i_width-7; x += 8 )
  51.             SSD(PIXEL_8x8);
  52. #undef SSD
  53.  
  54. #define SSD1 { int d = pix1[y*i_pix1+x] - pix2[y*i_pix2+x]; i_ssd += d*d; }
  55.     if( i_width & 7 )//如果像素不是16/8的整数倍，边界上的点需要单独算
  56.     {
  57.         for( y = 0; y < (i_height & ~7); y++ )
  58.             for( int x = i_width & ~7; x < i_width; x++ )
  59.                 SSD1;
  60.     }
  61.     if( i_height & 7 )
  62.     {
  63.         for( y = i_height & ~7; y < i_height; y++ )
  64.             for( int x = 0; x < i_width; x++ )
  65.                 SSD1;
  66.     }
  67. #undef SSD1
  68.  
  69.     return i_ssd;
  70. }


6、x264_pixel_ssim_wxh()函数

 

        x264_pixel_ssim_wxh()用于计算SSIM。该函数的定义位于common\pixel.c，x264_pixel_ssim_wxh()中是按照4x4的块对像素进行处理的。使用sum1[]保存上一行块的“信息”，sum0[]保存当前一行块的“信息”。“信息”包含4个元素：

s1：原始像素之和；

s2：受损像素之和；

ss：原始像素平方之和+受损像素平方之和；

s12：原始像素*受损像素的值的和。

 

        对应的代码分析如下：

 

  1. /************====== x264_pixel_ssd_wxh()函数 ======************/
  2. /*
  3.  * 功能：计算SSIM
  4.  * pix1: 受损数据 
  5.  * pix2: 原始数据 
  6.  * i_width: 图像宽 
  7.  * i_height: 图像高
  8. */
  9. float x264_pixel_ssim_wxh( x264_pixel_function_t *pf,
  10.                            pixel *pix1, intptr_t stride1,
  11.                            pixel *pix2, intptr_t stride2,
  12.                            int width, int height, void *buf, int *cnt )
  13. {
  14.     /* 
  15.      * SSIM公式 
  16.      * SSIM = ((2*ux*uy+C1)(2*σxy+C2))/((ux^2+uy^2+C1)(σx^2+σy^2+C2)) 
  17.      * 
  18.      * 其中 
  19.      * ux=E(x) 
  20.      * uy=E(y) 
  21.      * σxy=cov(x,y)=E(XY)-ux*uy 
  22.      * σx^2=E(x^2)-E(x)^2 
  23.      * 
  24.      */
  25. 	
  26. 	int z = 0;
  27.     float ssim = 0.0;
  28.  
  29. 	//这是数组指针，注意和指针数组的区别  
  30.     //数组指针就是指向数组的指针
  31.     int (*sum0)[4] = buf;
  32. 	/* 
  33.      * sum0是一个数组指针，其中存储了一个4元素数组的地址 
  34.      * 换句话说，sum0[]中每一个元素对应一个4x4块的信息（该信息包含4个元素）。 
  35.      * 
  36.      * 4个元素中： 
  37.      * [0]原始像素之和 
  38.      * [1]受损像素之和 
  39.      * [2]原始像素平方之和+受损像素平方之和 
  40.      * [3]原始像素*受损像素的值的和 
  41.      * 
  42.      */
  43.     int (*sum1)[4] = sum0 + (width >> 2) + 3;
  44.     //除以4，编程以“4x4块”为单位
  45. 	width >>= 2;
  46.     height >>= 2;
  47.     //以8*8的块为单位计算SSIM值。然后以4个像素为step滑动窗口
  48. 	for( int y = 1; y < height; y++ )
  49.     {
  50.         //下面这个循环，只有在第一次执行的时候执行2次，处理第1行和第2行的块  
  51.         //后面的都只会执行一次
  52. 		for( ; z <= y; z++ )
  53.         {
  54.             //执行完XCHG()之后，sum1[]存储上1行块的值（在上面），而sum0[]等待ssim_4x4x2_core()计算当前行的值（在下面）
  55. 			XCHG( void*, sum0, sum1 );
  56.             //获取4x4块的信息（这里并没有代入公式计算SSIM结果）  
  57.             //结果存储在sum0[]中。从左到右每个4x4的块依次存储在sum0[0]，sum0[1]，sum0[2]...  
  58.             //每次x前进2个块  
  59.             /* 
  60.              * ssim_4x4x2_core()：计算2个4x4块 
  61.              * +----+----+ 
  62.              * |    |    | 
  63.              * +----+----+ 
  64.              */
  65. 			for( int x = 0; x < width; x+=2 )
  66.                 pf->ssim_4x4x2_core( &pix1[4*(x+z*stride1)], stride1, &pix2[4*(x+z*stride2)], stride2, &sum0[x] );
  67.         }
  68. 		//x每次增加4，前进4个块  
  69.         //以8*8的块为单位计算  
  70.         /* 
  71.          * sum1[]为上一行4x4块信息，sum0[]为当前行4x4块信息 
  72.          * 示例（line以4x4块为单位） 
  73.          * 第1次运行 
  74.          *       +----+----+----+----+ 
  75.          * 1line |   sum1[] 
  76.          *       +----+----+----+----+ 
  77.          * 2line |   sum0[] 
  78.          *       +----+----+----+----+ 
  79.          * 
  80.          * 第2次运行 
  81.          *       + 
  82.          * 1line | 
  83.          *       +----+----+----+----+ 
  84.          * 2line |   sum1[] 
  85.          *       +----+----+----+----+ 
  86.          * 3line |   sum0[] 
  87.          *       +----+----+----+----+ 
  88.          */
  89.         for( int x = 0; x < width-1; x += 4 )
  90.             ssim += pf->ssim_end4( sum0+x, sum1+x, X264_MIN(4,width-x-1) );
  91.     }
  92.     *cnt = (height-1) * (width-1);
  93.     return ssim;
  94. }

 大笑滤波模块的主要代码分析就到这儿，其实中间有很多实用且有效的函数块，待后面用到时更新。

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

    来自： 托尼虎 > 《X264》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多