x265-1.8版本-common/ipfilter.cpp注释
司寇烨伟
注：问号以及未注释部分 会在x265-1.9版本内更新
/*****************************************************************************
* Copyright (C) 2013 x265 project
*
* Authors: Deepthi Devaki <deepthidevaki@multicorewareinc.com>,
* Rajesh Paulraj <rajesh@multicorewareinc.com>
* Praveen Kumar Tiwari <praveen@multicorewareinc.com>
*
* 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_NS;
#if _MSC_VER
#pragma warning(disable: 4127) // conditional expression is constant, typical for templated functions
#endif
namespace {
// file local namespace
template<int width, int height>
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;
}
}
static 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<int N, int width, int height>
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<int N, int width, int height>
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<int N, int width, int height>
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<int N, int width, int height>
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<int N, int width, int height>
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<int N, int width, int height>
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<int N>
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<int N, int width, int height>
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<N, width, height>(src, srcStride, immedVals, width, idxX, 1); // 水平插值，得到整数行非整数列的像素值
filterVertical_sp_c<N>(immedVals + 3 * width, width, dst, dstStride, width, height, idxY); // 纵向插值，得到分像素位置的像素值，由于水平插值中扩展了行数(向上扩展了3行)，所以这里原数据地址+3*width。
}
}
namespace X265_NS {
// 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<W, H>;
#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<W, H>;
#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<W, H>;
#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<W, H>;
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;
}
}
类似资料：