x265-1.7版本-common/ipfilter.cpp注释-白红宇

x265-1.7版本-common/ipfilter.cpp注释
阅读量：2189 次
发布时间：2019-05-02
本文共 16708 字，大约阅读时间需要 55 分钟。
注：问号以及未注释部分会在x265-1.8版本内更新
/***************************************************************************** * Copyright (C) 2013 x265 project * * Authors: Deepthi Devaki 
   
    , *          Rajesh Paulraj 
    
      *          Praveen Kumar Tiwari 
     
       * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA. * * This program is also available under a commercial proprietary license. * For more information, contact us at license @ x265.com. *****************************************************************************/#include "common.h"#include "primitives.h"#include "x265.h"using namespace x265;#if _MSC_VER#pragma warning(disable: 4127) // conditional expression is constant, typical for templated functions#endifnamespace {template
      
       void filterPixelToShort_c(const pixel* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride){    int shift = IF_INTERNAL_PREC - X265_DEPTH;    int row, col;    for (row = 0; row < height; row++)    {        for (col = 0; col < width; col++)        {            int16_t val = src[col] << shift;            dst[col] = val - (int16_t)IF_INTERNAL_OFFS;        }        src += srcStride;        dst += dstStride;    }}void extendCURowColBorder(pixel* txt, intptr_t stride, int width, int height, int marginX){    for (int y = 0; y < height; y++)    {#if HIGH_BIT_DEPTH        for (int x = 0; x < marginX; x++)        {            txt[-marginX + x] = txt[0];            txt[width + x] = txt[width - 1];        }#else        memset(txt - marginX, txt[0], marginX);        memset(txt + width, txt[width - 1], marginX);#endif        txt += stride;    }}/** 函数功能         ： 水平分像素插值，C语言版本* \参数 N           ： 滤波器的抽头个数，色度分量都是4抽头，亮度分量根据插值位置不同分为7抽头和8抽头* \参数 width       ： 插值图像块的宽度* \参数 height      ： 插值图形块的高度* \参数 src         ： 输入的整像素图像* \参数 srcStride   ： 整像素图像的步长* \参数 dst         ： 返回的插值后的像素块地址* \参数 dstStride   ： 插值后像素块的步长* \参数 coeffIdx    ： 需要插值的分像素位置，根据分像素位置选择不同组系数进行插值*/template
       
        void interp_horiz_pp_c(const pixel* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int coeffIdx){    const int16_t* coeff = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; // 根据抽头数目判断是亮度还是色度分量，进而选择对应的插值系数    int headRoom = IF_FILTER_PREC; // 插值系数之和(=64)的log2值(=log2(64)=6)，相当于在插值之后像素值扩大了64倍，在插值完成后需要右移6位    int offset =  (1 << (headRoom - 1)); // offset = 1<<5 = 32    uint16_t maxVal = (1 << X265_DEPTH) - 1; // 根据最大bit数算出可能的最大值，用于在滤波中后clip    int cStride = 1;    src -= (N / 2 - 1) * cStride; // 使原像素位置向左移位，使滤波器系数的中心与边界第一列重合，从第一个列开始滤波    int row, col;    for (row = 0; row < height; row++)    {        for (col = 0; col < width; col++)        {            int sum;            sum  = src[col + 0 * cStride] * coeff[0];            sum += src[col + 1 * cStride] * coeff[1];            sum += src[col + 2 * cStride] * coeff[2];            sum += src[col + 3 * cStride] * coeff[3];            if (N == 8)            {                sum += src[col + 4 * cStride] * coeff[4];                sum += src[col + 5 * cStride] * coeff[5];                sum += src[col + 6 * cStride] * coeff[6];                sum += src[col + 7 * cStride] * coeff[7];            }            int16_t val = (int16_t)((sum + offset) >> headRoom); // 使插值后的像素与原图像中的像素有相同的数据宽度            if (val < 0) val = 0; // 进行clip操作，使结果保持在0~maxVal之间            if (val > maxVal) val = maxVal;            dst[col] = (pixel)val;        }        src += srcStride;        dst += dstStride;    }}/** 函数功能         ： 行列均为非整像素点插值，第一步：首先进行横向的插值，得到整数行的分像素值，C语言版本* \参数 N           ： 滤波器的抽头个数，色度分量都是4抽头，亮度分量根据插值位置不同分为7抽头和8抽头* \参数 width       ： 插值图像块的宽度* \参数 height      ： 插值图形块的高度* \参数 src         ： 输入的整像素图像* \参数 srcStride   ： 整像素图像的步长* \参数 dst         ： 返回的插值后的像素块地址* \参数 dstStride   ： 插值后像素块的步长* \参数 coeffIdx    ： 需要插值的分像素位置，根据分像素位置选择不同组系数进行插值* \参数 isRowExt    ： 是否扩展分像素图像块的行数，由于之后还需要进行纵向滤波，所以默认需要扩展行数*/template
        
         void interp_horiz_ps_c(const pixel* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride, int coeffIdx, int isRowExt){ const int16_t* coeff = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; // 根据抽头数目判断是亮度还是色度分量，进而选择对应的插值系数 int headRoom = IF_INTERNAL_PREC - X265_DEPTH; // = 14 - 8 = 6 int shift = IF_FILTER_PREC - headRoom; // = 6 - 6 = 0 int offset = -IF_INTERNAL_OFFS << shift; // = -(1<<13) int blkheight = height; src -= N / 2 - 1; // 使原像素位置向左移位，使滤波器系数的中心与边界第一列重合，从第一个列开始滤波 if (isRowExt) // 如果需要扩展行数，则将滤波的行数增加N-1行，图像上侧添加N/2-1行，图像下侧添加N/2行 { src -= (N / 2 - 1) * srcStride; blkheight += N - 1; } int row, col; for (row = 0; row < blkheight; row++) { for (col = 0; col < width; col++) { int sum; sum = src[col + 0] * coeff[0]; sum += src[col + 1] * coeff[1]; sum += src[col + 2] * coeff[2]; sum += src[col + 3] * coeff[3]; if (N == 8) { sum += src[col + 4] * coeff[4]; sum += src[col + 5] * coeff[5]; sum += src[col + 6] * coeff[6]; sum += src[col + 7] * coeff[7]; } int16_t val = (int16_t)((sum + offset) >> shift); // 对sum进行数值范围的转换，sum是使用滤波系数加权后得到的，数值范围是0~2^14-1，加上offset之后变为-2^13~2^13-1 // 从14位不带符号的非负数，变为14位带符号的数 dst[col] = val; } src += srcStride; dst += dstStride; }}/** 函数功能 ： 竖直分像素插值，C语言版本* \参数 N ： 滤波器的抽头个数，色度分量都是4抽头，亮度分量根据插值位置不同分为7抽头和8抽头* \参数 width ： 插值图像块的宽度* \参数 height ： 插值图形块的高度* \参数 src ： 输入的整像素图像* \参数 srcStride ： 整像素图像的步长* \参数 dst ： 返回的插值后的像素块地址* \参数 dstStride ： 插值后像素块的步长* \参数 coeffIdx ： 需要插值的分像素位置，根据分像素位置选择不同组系数进行插值*/template
         
          void interp_vert_pp_c(const pixel* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int coeffIdx){ const int16_t* c = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; // 根据抽头数目判断是亮度还是色度分量，进而选择对应的插值系数 int shift = IF_FILTER_PREC; // 插值系数之和(=64)的log2值(=log2(64)=6)，相当于在插值之后像素值扩大了64倍，在插值完成后需要右移6位 int offset = 1 << (shift - 1); // offset = 1<<5 = 32 uint16_t maxVal = (1 << X265_DEPTH) - 1; // 根据最大bit数算出可能的最大值，用于在滤波中后clip src -= (N / 2 - 1) * srcStride; // 与水平插值不同，使原像素位置向上移位，使滤波器系数的中心与边界第一行重合，从第一个行开始滤波 int row, col; for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { int sum; sum = src[col + 0 * srcStride] * c[0]; sum += src[col + 1 * srcStride] * c[1]; sum += src[col + 2 * srcStride] * c[2]; sum += src[col + 3 * srcStride] * c[3]; if (N == 8) // 如果是8抽头滤波器 { sum += src[col + 4 * srcStride] * c[4]; sum += src[col + 5 * srcStride] * c[5]; sum += src[col + 6 * srcStride] * c[6]; sum += src[col + 7 * srcStride] * c[7]; } int16_t val = (int16_t)((sum + offset) >> shift); // 使插值后的像素与原图像中的像素有相同的数据宽度 val = (val < 0) ? 0 : val; // 进行clip操作，使结果保持在0~maxVal之间 val = (val > maxVal) ? maxVal : val; dst[col] = (pixel)val; } src += srcStride; dst += dstStride; }}template
          
           void interp_vert_ps_c(const pixel* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride, int coeffIdx){ const int16_t* c = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; int headRoom = IF_INTERNAL_PREC - X265_DEPTH; int shift = IF_FILTER_PREC - headRoom; int offset = -IF_INTERNAL_OFFS << shift; src -= (N / 2 - 1) * srcStride; int row, col; for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { int sum; sum = src[col + 0 * srcStride] * c[0]; sum += src[col + 1 * srcStride] * c[1]; sum += src[col + 2 * srcStride] * c[2]; sum += src[col + 3 * srcStride] * c[3]; if (N == 8) { sum += src[col + 4 * srcStride] * c[4]; sum += src[col + 5 * srcStride] * c[5]; sum += src[col + 6 * srcStride] * c[6]; sum += src[col + 7 * srcStride] * c[7]; } int16_t val = (int16_t)((sum + offset) >> shift); dst[col] = val; } src += srcStride; dst += dstStride; }}template
           
            void interp_vert_sp_c(const int16_t* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int coeffIdx){ int headRoom = IF_INTERNAL_PREC - X265_DEPTH; int shift = IF_FILTER_PREC + headRoom; int offset = (1 << (shift - 1)) + (IF_INTERNAL_OFFS << IF_FILTER_PREC); uint16_t maxVal = (1 << X265_DEPTH) - 1; const int16_t* coeff = (N == 8 ? g_lumaFilter[coeffIdx] : g_chromaFilter[coeffIdx]); src -= (N / 2 - 1) * srcStride; int row, col; for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { int sum; sum = src[col + 0 * srcStride] * coeff[0]; sum += src[col + 1 * srcStride] * coeff[1]; sum += src[col + 2 * srcStride] * coeff[2]; sum += src[col + 3 * srcStride] * coeff[3]; if (N == 8) { sum += src[col + 4 * srcStride] * coeff[4]; sum += src[col + 5 * srcStride] * coeff[5]; sum += src[col + 6 * srcStride] * coeff[6]; sum += src[col + 7 * srcStride] * coeff[7]; } int16_t val = (int16_t)((sum + offset) >> shift); val = (val < 0) ? 0 : val; val = (val > maxVal) ? maxVal : val; dst[col] = (pixel)val; } src += srcStride; dst += dstStride; }}template
            
             void interp_vert_ss_c(const int16_t* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride, int coeffIdx){ const int16_t* c = (N == 8 ? g_lumaFilter[coeffIdx] : g_chromaFilter[coeffIdx]); int shift = IF_FILTER_PREC; int row, col; src -= (N / 2 - 1) * srcStride; for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { int sum; sum = src[col + 0 * srcStride] * c[0]; sum += src[col + 1 * srcStride] * c[1]; sum += src[col + 2 * srcStride] * c[2]; sum += src[col + 3 * srcStride] * c[3]; if (N == 8) { sum += src[col + 4 * srcStride] * c[4]; sum += src[col + 5 * srcStride] * c[5]; sum += src[col + 6 * srcStride] * c[6]; sum += src[col + 7 * srcStride] * c[7]; } int16_t val = (int16_t)((sum) >> shift); dst[col] = val; } src += srcStride; dst += dstStride; }}/** 函数功能 ： 行列均为非整像素点插值，第二步：将已经完成横向插值的像素值，进行纵向插值得到非整数行、非整像素列的分像素值。C语言版本* \参数 N ： 滤波器的抽头个数，色度分量都是4抽头，亮度分量根据插值位置不同分为7抽头和8抽头* \参数 width ： 插值图像块的宽度* \参数 height ： 插值图形块的高度* \参数 src ： 输入的整像素图像* \参数 srcStride ： 整像素图像的步长* \参数 dst ： 返回的插值后的像素块地址* \参数 dstStride ： 插值后像素块的步长* \参数 coeffIdx ： 需要插值的分像素位置，根据分像素位置选择不同组系数进行插值*/template
             
              void filterVertical_sp_c(const int16_t* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int width, int height, int coeffIdx){ int headRoom = IF_INTERNAL_PREC - X265_DEPTH; // = 14-8 = 6 int shift = IF_FILTER_PREC + headRoom; // 6+6=12 int offset = (1 << (shift - 1)) + (IF_INTERNAL_OFFS << IF_FILTER_PREC); // 1<<11 + 1<<19 uint16_t maxVal = (1 << X265_DEPTH) - 1; const int16_t* coeff = (N == 8 ? g_lumaFilter[coeffIdx] : g_chromaFilter[coeffIdx]); src -= (N / 2 - 1) * srcStride; int row, col; for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { int sum; sum = src[col + 0 * srcStride] * coeff[0]; sum += src[col + 1 * srcStride] * coeff[1]; sum += src[col + 2 * srcStride] * coeff[2]; sum += src[col + 3 * srcStride] * coeff[3]; if (N == 8) { sum += src[col + 4 * srcStride] * coeff[4]; sum += src[col + 5 * srcStride] * coeff[5]; sum += src[col + 6 * srcStride] * coeff[6]; sum += src[col + 7 * srcStride] * coeff[7]; } int16_t val = (int16_t)((sum + offset) >> shift); // src的数值范围为-2^13~2^13-1，进行滤波后得到sum的数值范围为-2^19~2^19-1，+offset之后的数值范围是0~2^20-1，右移12位之后得到最终的数值范围是0~2^8-1 val = (val < 0) ? 0 : val; val = (val > maxVal) ? maxVal : val; dst[col] = (pixel)val; } src += srcStride; dst += dstStride; }}/** 函数功能 ： 行列均为非整像素点插值，C语言版本，首先进行横向的插值，得到整数行的分像素值，再进行纵向插值得到非整数行、非整像素列的分像素值。* \参数 N ： 滤波器的抽头个数，色度分量都是4抽头，亮度分量根据插值位置不同分为7抽头和8抽头* \参数 width ： 插值图像块的宽度* \参数 height ： 插值图形块的高度* \参数 src ： 输入的整像素图像* \参数 srcStride ： 整像素图像的步长* \参数 dst ： 返回的插值后的像素块地址* \参数 dstStride ： 插值后像素块的步长* \参数 idxX ： 需要插值的X方向分像素位置，根据分像素位置选择不同组系数进行插值* \参数 idxY ： 需要插值的Y方向分像素位置，根据分像素位置选择不同组系数进行插值*/template
              
               void interp_hv_pp_c(const pixel* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int idxX, int idxY){ short immedVals[(64 + 8) * (64 + 8)]; // 临时缓冲区 interp_horiz_ps_c
               
                (src, srcStride, immedVals, width, idxX, 1); // 水平插值，得到整数行非整数列的像素值 filterVertical_sp_c
                
                 (immedVals + 3 * width, width, dst, dstStride, width, height, idxY); // 纵向插值，得到分像素位置的像素值，由于水平插值中扩展了行数(向上扩展了3行)，所以这里原数据地址+3*width。}}namespace x265 {// x265 private namespace#define CHROMA_420(W, H) \ p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_hpp = interp_horiz_pp_c<4, W, H>; \ p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_hps = interp_horiz_ps_c<4, W, H>; \ p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_vpp = interp_vert_pp_c<4, W, H>; \ p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_vps = interp_vert_ps_c<4, W, H>; \ p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_vsp = interp_vert_sp_c<4, W, H>; \ p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].filter_vss = interp_vert_ss_c<4, W, H>; \ p.chroma[X265_CSP_I420].pu[CHROMA_420_ ## W ## x ## H].p2s = filterPixelToShort_c
                 
                  ;#define CHROMA_422(W, H) \ p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_hpp = interp_horiz_pp_c<4, W, H>; \ p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_hps = interp_horiz_ps_c<4, W, H>; \ p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_vpp = interp_vert_pp_c<4, W, H>; \ p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_vps = interp_vert_ps_c<4, W, H>; \ p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_vsp = interp_vert_sp_c<4, W, H>; \ p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].filter_vss = interp_vert_ss_c<4, W, H>; \ p.chroma[X265_CSP_I422].pu[CHROMA_422_ ## W ## x ## H].p2s = filterPixelToShort_c
                  
                   ;#define CHROMA_444(W, H) \ p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_hpp = interp_horiz_pp_c<4, W, H>; \ p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_hps = interp_horiz_ps_c<4, W, H>; \ p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_vpp = interp_vert_pp_c<4, W, H>; \ p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_vps = interp_vert_ps_c<4, W, H>; \ p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_vsp = interp_vert_sp_c<4, W, H>; \ p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].filter_vss = interp_vert_ss_c<4, W, H>; \ p.chroma[X265_CSP_I444].pu[LUMA_ ## W ## x ## H].p2s = filterPixelToShort_c
                   
                    ;#define LUMA(W, H) \ p.pu[LUMA_ ## W ## x ## H].luma_hpp = interp_horiz_pp_c<8, W, H>; \ p.pu[LUMA_ ## W ## x ## H].luma_hps = interp_horiz_ps_c<8, W, H>; \ p.pu[LUMA_ ## W ## x ## H].luma_vpp = interp_vert_pp_c<8, W, H>; \ p.pu[LUMA_ ## W ## x ## H].luma_vps = interp_vert_ps_c<8, W, H>; \ p.pu[LUMA_ ## W ## x ## H].luma_vsp = interp_vert_sp_c<8, W, H>; \ p.pu[LUMA_ ## W ## x ## H].luma_vss = interp_vert_ss_c<8, W, H>; \ p.pu[LUMA_ ## W ## x ## H].luma_hvpp = interp_hv_pp_c<8, W, H>; \ p.pu[LUMA_ ## W ## x ## H].convert_p2s = filterPixelToShort_c
                    
                     ;void setupFilterPrimitives_c(EncoderPrimitives& p){ LUMA(4, 4); LUMA(8, 8); CHROMA_420(4, 4); LUMA(4, 8); CHROMA_420(2, 4); LUMA(8, 4); CHROMA_420(4, 2); LUMA(16, 16); CHROMA_420(8, 8); LUMA(16, 8); CHROMA_420(8, 4); LUMA(8, 16); CHROMA_420(4, 8); LUMA(16, 12); CHROMA_420(8, 6); LUMA(12, 16); CHROMA_420(6, 8); LUMA(16, 4); CHROMA_420(8, 2); LUMA(4, 16); CHROMA_420(2, 8); LUMA(32, 32); CHROMA_420(16, 16); LUMA(32, 16); CHROMA_420(16, 8); LUMA(16, 32); CHROMA_420(8, 16); LUMA(32, 24); CHROMA_420(16, 12); LUMA(24, 32); CHROMA_420(12, 16); LUMA(32, 8); CHROMA_420(16, 4); LUMA(8, 32); CHROMA_420(4, 16); LUMA(64, 64); CHROMA_420(32, 32); LUMA(64, 32); CHROMA_420(32, 16); LUMA(32, 64); CHROMA_420(16, 32); LUMA(64, 48); CHROMA_420(32, 24); LUMA(48, 64); CHROMA_420(24, 32); LUMA(64, 16); CHROMA_420(32, 8); LUMA(16, 64); CHROMA_420(8, 32); CHROMA_422(4, 8); CHROMA_422(4, 4); CHROMA_422(2, 4); CHROMA_422(2, 8); CHROMA_422(8, 16); CHROMA_422(8, 8); CHROMA_422(4, 16); CHROMA_422(8, 12); CHROMA_422(6, 16); CHROMA_422(8, 4); CHROMA_422(2, 16); CHROMA_422(16, 32); CHROMA_422(16, 16); CHROMA_422(8, 32); CHROMA_422(16, 24); CHROMA_422(12, 32); CHROMA_422(16, 8); CHROMA_422(4, 32); CHROMA_422(32, 64); CHROMA_422(32, 32); CHROMA_422(16, 64); CHROMA_422(32, 48); CHROMA_422(24, 64); CHROMA_422(32, 16); CHROMA_422(8, 64); CHROMA_444(4, 4); CHROMA_444(8, 8); CHROMA_444(4, 8); CHROMA_444(8, 4); CHROMA_444(16, 16); CHROMA_444(16, 8); CHROMA_444(8, 16); CHROMA_444(16, 12); CHROMA_444(12, 16); CHROMA_444(16, 4); CHROMA_444(4, 16); CHROMA_444(32, 32); CHROMA_444(32, 16); CHROMA_444(16, 32); CHROMA_444(32, 24); CHROMA_444(24, 32); CHROMA_444(32, 8); CHROMA_444(8, 32); CHROMA_444(64, 64); CHROMA_444(64, 32); CHROMA_444(32, 64); CHROMA_444(64, 48); CHROMA_444(48, 64); CHROMA_444(64, 16); CHROMA_444(16, 64); p.extendRowBorder = extendCURowColBorder;}}