x264 - x264_me_search_ref
来源：互联网 发布：java软件编程培训费用 编辑：程序博客网 时间：2024/05/23 02:06
void x264_me_search_ref( x264_t *h, x264_me_t *m, int16_t (*mvc)[2], int i_mvc, int *p_halfpel_thresh )
{
const int bw = x264_pixel_size[m->i_pixel].w;
const int bh = x264_pixel_size[m->i_pixel].h;
const int i_pixel = m->i_pixel;
const int stride = m->i_stride[0];
int i_me_range = h->param.analyse.i_me_range;
int bmx, bmy, bcost = COST_MAX;
int bpred_cost = COST_MAX;
int omx, omy, pmx, pmy;
// 指向待编码帧的Y平面
pixel *p_fenc = m->p_fenc[0];
// 指向参考帧的整像素平面 Y
pixel *p_fref_w = m->p_fref_w;
// 声明堆栈变量 pixel pix[16 * 16]， 并且32字节对齐
ALIGNED_ARRAY_N( pixel, pix,[16*16] );
// 声明堆栈变量 int16_t mvc_temp[16][2], 并且8字节对齐
ALIGNED_ARRAY_8( int16_t, mvc_temp,[16],[2] );
// 声明堆栈变量 int costs[16], 并且16字节对齐
ALIGNED_ARRAY_16( int, costs,[16] );
// mv_limit_fpel 是一个 2x2 的 数组， 存放着整像素
// 运动矢量搜索范围， min_x, min_y, max_x, max_y
int mv_x_min = h->mb.mv_limit_fpel[0][0];
int mv_y_min = h->mb.mv_limit_fpel[0][1];
int mv_x_max = h->mb.mv_limit_fpel[1][0];
int mv_y_max = h->mb.mv_limit_fpel[1][1];
// pack16to32_mask2 主要是将两个整数分别放入高16位
// 和低16位， 组合成一个32位的整数
/* Special version of pack to allow shortcuts in CHECK_MVRANGE */
#define pack16to32_mask2(mx,my) ((mx<<16)|(my&0x7FFF))
uint32_t mv_min = pack16to32_mask2( -mv_x_min, -mv_y_min );
uint32_t mv_max = pack16to32_mask2( mv_x_max, mv_y_max )|0x8000;
uint32_t pmv, bpred_mv = 0;
// 这个宏很巧妙， 它将检查mx, my 是否超过了搜索范围
// 具体是， 如果mx, my有一个溢出， 其 or 运算的两边至少有一个的高位为1
// 从而将导致其or的结果与0x80004000进行与运算得到的结果不为0
#define CHECK_MVRANGE(mx,my) (!(((pack16to32_mask2(mx,my) + mv_min) | (mv_max - pack16to32_mask2(mx,my))) & 0x80004000))
// a->p_cost_mv = h->cost_mv[a->i_qp] 见 x264_mb_analyse_load_costs
// h->cost_mv 初始化， 见 x264_analyse_init_costs
// m->p_cost_mv = a->p_cost_mv 见宏定义 LOAD_FUNC
// 这个相减还真有点费解， 一个是地址， 一个是预测运动向量
const uint16_t *p_cost_mvx = m->p_cost_mv - m->mvp[0];
const uint16_t *p_cost_mvy = m->p_cost_mv - m->mvp[1];
/* Try extra predictors if provided. If subme >= 3, check subpel predictors,
* otherwise round them to fullpel. */
if( h->mb.i_subpel_refine >= 3 )
{
// 需要进行 1/4 像素插值
/* Calculate and check the MVP first */
// SPEL 将整像素坐标转换为 1/4 像素坐标
// 一个整数的低两位表示1/4像素坐标
// SPEL 将实参左移两位， 即将原来的坐标乘以 4，
// 比如：0 1 两个相邻的像素变成了0, 4, 其中空出来的1, 2, 3
// 就对应着 1/4 1/2 3/4 像素位
// 而 FPEL 将实参右移两位， 获得整像素位坐标
// 即将原来放大了的整像素坐标还原
// 从下面的程序来看， mvp保存的是1/4像素坐标
int bpred_mx = x264_clip3( m->mvp[0], SPEL(mv_x_min), SPEL(mv_x_max) );
int bpred_my = x264_clip3( m->mvp[1], SPEL(mv_y_min), SPEL(mv_y_max) );
pmv = pack16to32_mask( bpred_mx, bpred_my );
pmx = FPEL( bpred_mx );
pmy = FPEL( bpred_my );
// 见 COST_MV_HPEL， 对参考平面之参考宏块进行1/4 像素预插值
// 并求编码宏块和参考宏块整像素的SAD（绝对差之和）
// i_sum += abs( pix1[x] - pix2[x] );
COST_MV_HPEL( bpred_mx, bpred_my, bpred_cost );
// 将得到的预测运动向量的代价赋值给pmv_cost
int pmv_cost = bpred_cost;
if( i_mvc > 0 )
{
// 下面的英文注释已经表达的很清楚了，这翻译一下
// 裁减候选的运动向量，除掉那些 0 向量 或 等于 pmv (mvp) 的向量
// 并将裁减结果放在mvc_temp[2]及之后处
/* Clip MV candidates and eliminate those equal to zero and pmv. */
int valid_mvcs = x264_predictor_clip( mvc_temp+2, mvc, i_mvc, h->mb.mv_limit_fpel, pmv );
// 对其他候选向量进行处理
if( valid_mvcs > 0 )
{
int i = 1, cost;
/* We stuff pmv here to branchlessly pick between pmv and the various
* MV candidates. [0] gets skipped in order to maintain alignment for
* x264_predictor_clip. */
// mvc_temp[0] 空着， 为了维护对齐
// mvc_temp[1] 存放 pmv
M32( mvc_temp[1] ) = pmv;
bpred_cost <<= 4;
do
{
int mx = mvc_temp[i+1][0];
int my = mvc_temp[i+1][1];
COST_MV_HPEL( mx, my, cost );
COPY1_IF_LT( bpred_cost, (cost << 4) + i );
} while( ++i <= valid_mvcs );
// 确定最终的预测运动向量
bpred_mx = mvc_temp[(bpred_cost&15)+1][0];
bpred_my = mvc_temp[(bpred_cost&15)+1][1];
bpred_cost >>= 4;
}
}
/* Round the best predictor back to fullpel and get the cost, since this is where
* we'll be starting the fullpel motion search. */
// 从1/4像素坐标得到整像素坐标，因为我们将开始整像素运动搜索
bmx = FPEL( bpred_mx );
bmy = FPEL( bpred_my );
bpred_mv = pack16to32_mask(bpred_mx, bpred_my);
// 预测运动向量是 1/4 像素坐标，即是1/4像素预测(包括1/4, 2/4, 3/4)
if( bpred_mv&0x00030003 ) /* Only test if the tested predictor is actually subpel... */
COST_MV( bmx, bmy ); // call x264_pixel_sad_16x16 计算预测运动向量代价
else /* Otherwise just copy the cost (we already know it) */
bcost = bpred_cost;
/* Test the zero vector if it hasn't been tested yet. */
if( pmv ) // 如果 pmv 不是 0 向量
{
// 如果 bmx, bmy也不是0向量
// call x264_pixel_sad_16x16 以0向量为预测运动向量计算SAD,
// 如果代价更小，就替换代价和相应的预测运动向量
if( bmx|bmy ) COST_MV( 0, 0 );
}
/* If a subpel mv candidate was better than the zero vector, the previous
* fullpel check won't have gotten it even if the pmv was zero. So handle
* that possibility here. */
else
{
COPY3_IF_LT( bcost, pmv_cost, bmx, 0, bmy, 0 );
}
}
else
{
// 计算和检查整像素 MVP
/* Calculate and check the fullpel MVP first */
// mvp保存的是 1/4 像素坐标， 先转换为整像素坐标
bmx = pmx = x264_clip3( FPEL(m->mvp[0]), mv_x_min, mv_x_max );
bmy = pmy = x264_clip3( FPEL(m->mvp[1]), mv_y_min, mv_y_max );
// 对整像素坐标打包
pmv = pack16to32_mask( bmx, bmy );
/* Because we are rounding the predicted motion vector to fullpel, there will be
* an extra MV cost in 15 out of 16 cases. However, when the predicted MV is
* chosen as the best predictor, it is often the case that the subpel search will
* result in a vector at or next to the predicted motion vector. Therefore, we omit
* the cost of the MV from the rounded MVP to avoid unfairly biasing against use of
* the predicted motion vector.
*
* Disclaimer: this is a post-hoc rationalization for why this hack works. */
// call x264_pixel_sad_16x16 计算 SAD, 以预测运动向量(bmy, bmx)
bcost = h->pixf.fpelcmp[i_pixel]( p_fenc, FENC_STRIDE, &p_fref_w[bmy*stride+bmx], stride );
if( i_mvc > 0 )
{
/* Like in subme>=3, except we also round the candidates to fullpel. */
int valid_mvcs = x264_predictor_roundclip( mvc_temp+2, mvc, i_mvc, h->mb.mv_limit_fpel, pmv );
if( valid_mvcs > 0 )
{
int i = 1, cost;
M32( mvc_temp[1] ) = pmv;
bcost <<= 4;
do
{
int mx = mvc_temp[i+1][0];
int my = mvc_temp[i+1][1];
cost = h->pixf.fpelcmp[i_pixel]( p_fenc, FENC_STRIDE, &p_fref_w[my*stride+mx], stride ) + BITS_MVD( mx, my );
COPY1_IF_LT( bcost, (cost << 4) + i );
} while( ++i <= valid_mvcs );
bmx = mvc_temp[(bcost&15)+1][0];
bmy = mvc_temp[(bcost&15)+1][1];
bcost >>= 4;
}
}
/* Same as above, except the condition is simpler. */
// call x264_pixel_sad_16x16 以0向量为预测运动向量计算SAD,
// 如果代价更小，就替换代价和相应的预测运动向量
if( pmv )
COST_MV( 0, 0 );
}
// 根据设定的运动估计方法， 来执行搜索
switch( h->mb.i_me_method )
{
case X264_ME_DIA:
{
/* diamond search, radius 1 */
bcost <<= 4;
int i = i_me_range;
do
{
COST_MV_X4_DIR( 0,-1, 0,1, -1,0, 1,0, costs );
COPY1_IF_LT( bcost, (costs[0]<<4)+1 );
COPY1_IF_LT( bcost, (costs[1]<<4)+3 );
COPY1_IF_LT( bcost, (costs[2]<<4)+4 );
COPY1_IF_LT( bcost, (costs[3]<<4)+12 );
if( !(bcost&15) )
break;
bmx -= (bcost<<28)>>30;
bmy -= (bcost<<30)>>30;
bcost &= ~15;
} while( --i && CHECK_MVRANGE(bmx, bmy) );
bcost >>= 4;
break;
}
case X264_ME_HEX:
{
me_hex2:
/* hexagon search, radius 2 */
#if 0
for( int i = 0; i < i_me_range/2; i++ )
{
omx = bmx; omy = bmy;
COST_MV( omx-2, omy );
COST_MV( omx-1, omy+2 );
COST_MV( omx+1, omy+2 );
COST_MV( omx+2, omy );
COST_MV( omx+1, omy-2 );
COST_MV( omx-1, omy-2 );
if( bmx == omx && bmy == omy )
break;
if( !CHECK_MVRANGE(bmx, bmy) )
break;
}
#else
/* equivalent to the above, but eliminates duplicate candidates */
/* hexagon */
// call x264_pixel_sad_x3_16x16 分别计算三个点
// 分别为预测运动向量时的代价
COST_MV_X3_DIR( -2,0, -1, 2, 1, 2, costs );
// 计算另三个点为预测运动向量时的代价
COST_MV_X3_DIR( 2,0, 1,-2, -1,-2, costs+4 ); /* +4 for 16-byte alignment */
bcost <<= 3;
// 如果有代价更小的，替换原来的代价和相应的预测运动向量
COPY1_IF_LT( bcost, (costs[0]<<3)+2 );
COPY1_IF_LT( bcost, (costs[1]<<3)+3 );
COPY1_IF_LT( bcost, (costs[2]<<3)+4 );
COPY1_IF_LT( bcost, (costs[4]<<3)+5 );
COPY1_IF_LT( bcost, (costs[5]<<3)+6 );
COPY1_IF_LT( bcost, (costs[6]<<3)+7 );
if( bcost&7 )
{
// bcost & 7 为真， 说明存在更小的预测运动向量
// 获取是哪个预测点
int dir = (bcost&7)-2;
// 将bmx, bmy 沿这个方向前进（移动）
bmx += hex2[dir+1][0];
bmy += hex2[dir+1][1];
/* half hexagon, not overlapping the previous iteration */
// 判断是否越界(超过搜索范围)
for( int i = (i_me_range>>1) - 1; i > 0 && CHECK_MVRANGE(bmx, bmy); i-- )
{
// 仅仅对三个点进行预测求SAD代价，
// 因为另外的三个点已经预测求SAD代价过了
COST_MV_X3_DIR( hex2[dir+0][0], hex2[dir+0][1],
hex2[dir+1][0], hex2[dir+1][1],
hex2[dir+2][0], hex2[dir+2][1],
costs );
bcost &= ~7;
COPY1_IF_LT( bcost, (costs[0]<<3)+1 );
COPY1_IF_LT( bcost, (costs[1]<<3)+2 );
COPY1_IF_LT( bcost, (costs[2]<<3)+3 );
if( !(bcost&7) )
break;
dir += (bcost&7)-2;
dir = mod6m1[dir+1];
bmx += hex2[dir+1][0];
bmy += hex2[dir+1][1];
}
}
bcost >>= 3;
#endif
// 菱（方）形搜索，进一步求精
/* square refine */
bcost <<= 4;
COST_MV_X4_DIR( 0,-1, 0,1, -1,0, 1,0, costs );
COPY1_IF_LT( bcost, (costs[0]<<4)+1 );
COPY1_IF_LT( bcost, (costs[1]<<4)+2 );
COPY1_IF_LT( bcost, (costs[2]<<4)+3 );
COPY1_IF_LT( bcost, (costs[3]<<4)+4 );
COST_MV_X4_DIR( -1,-1, -1,1, 1,-1, 1,1, costs );
COPY1_IF_LT( bcost, (costs[0]<<4)+5 );
COPY1_IF_LT( bcost, (costs[1]<<4)+6 );
COPY1_IF_LT( bcost, (costs[2]<<4)+7 );
COPY1_IF_LT( bcost, (costs[3]<<4)+8 );
bmx += square1[bcost&15][0];
bmy += square1[bcost&15][1];
bcost >>= 4;
break;
}
case X264_ME_UMH:
{
/* Uneven-cross Multi-Hexagon-grid Search
* as in JM, except with different early termination */
static const uint8_t x264_pixel_size_shift[7] = { 0, 1, 1, 2, 3, 3, 4 };
int ucost1, ucost2;
int cross_start = 1;
/* refine predictors */
ucost1 = bcost;
// 以pmv为中心，取构成菱形的四个点进行预测求SAD，
// 如果有更小的，将替换bcost和bmx, bmy
DIA1_ITER( pmx, pmy );
if( pmx | pmy ) // 以0向量为中心，取构成菱形的四个点预测
DIA1_ITER( 0, 0 );
// 为什么？？？
if( i_pixel == PIXEL_4x4 )
goto me_hex2;
ucost2 = bcost;
// 如果bmx, bmy不是0向量， 且不等于pmv向量
// 搜索以bmx, bmy为中心构成菱形的四个点进行预测，
// 如果有更小的代价，则替换bcost和bmx, bmy
if( (bmx | bmy) && ((bmx-pmx) | (bmy-pmy)) )
DIA1_ITER( bmx, bmy );
// 如果上面的预测，没有预测到更佳的预测运动向量
// 则将cross_start赋值为3
if( bcost == ucost2 )
cross_start = 3;
// 保存当前的bmx, bmy
omx = bmx; omy = bmy;
/* early termination */
#define SAD_THRESH(v) ( bcost < ( v >> x264_pixel_size_shift[i_pixel] ) )
if( bcost == ucost2 && SAD_THRESH(2000) )
{
// 如果bcost == ucost2, 并且bcost小于某个阈值
// 以omx, omy为中心，对其周围的四个点进行预测
// 如果有更小的代价， 则替换bcost和bmx, bmy
COST_MV_X4( 0,-2, -1,-1, 1,-1, -2,0 );
// 以omx, omy为中心， 对其周围的另外四个点进行预测
// 如果有更小的代价，则替换bcost和bmx, bmy
COST_MV_X4( 2, 0, -1, 1, 1, 1, 0,2 );
// 如果bcost == ucost1，说明前面的预测都没有发现
// 代价更小的预测点，因此提前终止预测
if( bcost == ucost1 && SAD_THRESH(500) )
break;
// 如果bcost == ucost2，则继续预测
if( bcost == ucost2 )
{
// 设定预测范围
int range = (i_me_range>>1) | 1;
// x,y方向交叉预测omx, omy附近的点， 见CROSS
// 如果有更小的代价，则替换bcost和bmx, bmy
CROSS( 3, range, range );
// 预测omx, omy为中心的下述四个点
// 如果有更小的代价，则替换bcost和bmx, bmy
COST_MV_X4( -1,-2, 1,-2, -2,-1, 2,-1 );
// 预测omx, omy为中心的下述另外四个点
// 如果有更小的代价，则替换bcost和bmx, bmy
COST_MV_X4( -2, 1, 2, 1, -1, 2, 1, 2 );
// 如果依然没有搜索到更佳的预测运动向量
// 则终止搜索
if( bcost == ucost2 )
break;
// 如果有更佳的预测运动向量被搜索到，
// 则设定新的cross_start
cross_start = range + 2;
}
}
// 自适应预测搜索
/* adaptive search range */
if( i_mvc )
{
/* range multipliers based on casual inspection of some statistics of
* average distance between current predictor and final mv found by ESA.
* these have not been tuned much by actual encoding. */
static const uint8_t range_mul[4][4] =
{
{ 3, 3, 4, 4 },
{ 3, 4, 4, 4 },
{ 4, 4, 4, 5 },
{ 4, 4, 5, 6 },
};
int mvd;
int sad_ctx, mvd_ctx;
int denom = 1;
if( i_mvc == 1 )
{
if( i_pixel == PIXEL_16x16 )
/* mvc is probably the same as mvp, so the difference isn't meaningful.
* but prediction usually isn't too bad, so just use medium range */
mvd = 25;
else
mvd = abs( m->mvp[0] - mvc[0][0] )
+ abs( m->mvp[1] - mvc[0][1] );
}
else
{
/* calculate the degree of agreement between predictors. */
/* in 16x16, mvc includes all the neighbors used to make mvp,
* so don't count mvp separately. */
// 获得mvc的相邻格数
denom = i_mvc - 1;
// 初始化向量差的绝对值和
mvd = 0;
if( i_pixel != PIXEL_16x16 )
{
// 如果i_pixel不等于 0
// 计算mvp，与mvc[0]两个向量的x,y方向
// 的差的绝对值和
mvd = abs( m->mvp[0] - mvc[0][0] )
+ abs( m->mvp[1] - mvc[0][1] );
// 增加格数
denom++;
}
// 迭代计算mvc数组相邻两个mvc[i], mvc[i+1]之间的
// 的向量差的绝对值之和
mvd += x264_predictor_difference( mvc, i_mvc );
}
// 根据bcost与阈值之间的关系, 设定sad_ctx
sad_ctx = SAD_THRESH(1000) ? 0
: SAD_THRESH(2000) ? 1
: SAD_THRESH(4000) ? 2 : 3;
// 根据上面计算的mvd及denom， 设定mvc_ctx
mvd_ctx = mvd < 10*denom ? 0
: mvd < 20*denom ? 1
: mvd < 40*denom ? 2 : 3;
// 获取相应的搜索范围放大器， 更新搜索范围
i_me_range = i_me_range * range_mul[mvd_ctx][sad_ctx] >> 2;
}
/* FIXME if the above DIA2/OCT2/CROSS found a new mv, it has not updated omx/omy.
* we are still centered on the same place as the DIA2. is this desirable? */
// 在x, y方向交叉搜索， x方向的搜索范围i_me_range,
// y方向搜索范围i_me_range / 2
// 如果发现更佳的运动向量， 则替换bcost和bmx, bmy
CROSS( cross_start, i_me_range, i_me_range>>1 );
// 预测以omx, omy为中心的下述四个点
// 如果发现更佳的运动向量，则替换bcost和bmx, bmy
COST_MV_X4( -2,-2, -2,2, 2,-2, 2,2 );
/* hexagon grid */
// 保存新的候选的最佳预测运动向量
omx = bmx; omy = bmy;
// 让p_cost_omx, p_cost_omvy
// 指向p_cost_mvx, p_cost_mvy的某个偏移
// a->p_cost_mv = h->cost_mv[a->i_qp] 见 x264_mb_analyse_load_costs
// h->cost_mv 初始化， 见 x264_analyse_init_costs
// m->p_cost_mv = a->p_cost_mv 见宏定义 LOAD_FUNC
const uint16_t *p_cost_omvx = p_cost_mvx + omx*4;
const uint16_t *p_cost_omvy = p_cost_mvy + omy*4;
int i = 1;
do
{
static const int8_t hex4[16][2] = {
{ 0,-4}, { 0, 4}, {-2,-3}, { 2,-3},
{-4,-2}, { 4,-2}, {-4,-1}, { 4,-1},
{-4, 0}, { 4, 0}, {-4, 1}, { 4, 1},
{-4, 2}, { 4, 2}, {-2, 3}, { 2, 3},
};
// 如果 4*i 大于这四个值的最小值
if( 4*i > X264_MIN4( mv_x_max-omx, omx-mv_x_min,
mv_y_max-omy, omy-mv_y_min ) )
{
// 迭代搜索 16 次
for( int j = 0; j < 16; j++ )
{
// 将搜索点偏移某个向量
int mx = omx + hex4[j][0]*i;
int my = omy + hex4[j][1]*i;
// 新的预测运动向量是否越界
// 如果没有越界，则预测其代价
// 如果代价更小，则替换bcost和bmx, bmy
if( CHECK_MVRANGE(mx, my) )
COST_MV( mx, my );
}
}
else
{
int dir = 0;
// 根据omx, omy, i 调整预测中心
pixel *pix_base = p_fref_w + omx + (omy-4*i)*stride;
int dy = i*stride;
// h->pixf.fpelcmp_x4[0] = x264_pixel_sad_x4_16x16
// 这个宏定义有点特别， 这种语法pix_base x0*i+(y0-2*k+4)*dy
// 能表示pix_base的偏移 x0*i+(y0-2*k+4)*dy
// 我自己写类似的语法，根本无法编译
// 不知道 x264 如何做到
#define SADS(k,x0,y0,x1,y1,x2,y2,x3,y3)\
h->pixf.fpelcmp_x4[i_pixel]( p_fenc,\
pix_base x0*i+(y0-2*k+4)*dy,\
pix_base x1*i+(y1-2*k+4)*dy,\
pix_base x2*i+(y2-2*k+4)*dy,\
pix_base x3*i+(y3-2*k+4)*dy,\
stride, costs+4*k );\
pix_base += 2*dy;
#define ADD_MVCOST(k,x,y) costs[k] += p_cost_omvx[x*4*i] + p_cost_omvy[y*4*i]
#define MIN_MV(k,x,y) COPY2_IF_LT( bcost, costs[k], dir, x*16+(y&15) )
// 根据新的中心点， 预测其四个偏移点
// pix_base x0*i+(y0-2*k+4)*dy 等
// 其中 dy = i * stride; // stride在我的调试中=1344
// 并分别将预测代价保存在costs数组
SADS( 0, +0,-4, +0,+4, -2,-3, +2,-3 );
SADS( 1, -4,-2, +4,-2, -4,-1, +4,-1 );
SADS( 2, -4,+0, +4,+0, -4,+1, +4,+1 );
SADS( 3, -4,+2, +4,+2, -2,+3, +2,+3 );
// 将每个点预测代价加上该点的预设的相关代价
ADD_MVCOST( 0, 0,-4 );
ADD_MVCOST( 1, 0, 4 );
ADD_MVCOST( 2,-2,-3 );
ADD_MVCOST( 3, 2,-3 );
ADD_MVCOST( 4,-4,-2 );
ADD_MVCOST( 5, 4,-2 );
ADD_MVCOST( 6,-4,-1 );
ADD_MVCOST( 7, 4,-1 );
ADD_MVCOST( 8,-4, 0 );
ADD_MVCOST( 9, 4, 0 );
ADD_MVCOST( 10,-4, 1 );
ADD_MVCOST( 11, 4, 1 );
ADD_MVCOST( 12,-4, 2 );
ADD_MVCOST( 13, 4, 2 );
ADD_MVCOST( 14,-2, 3 );
ADD_MVCOST( 15, 2, 3 );
// #define MIN_MV(k,x,y)
// COPY2_IF_LT( bcost, costs[k], dir, x*16+(y&15) )
// 判断该点的预测代价是否更优
// 如果更佳，则替换bcost, 并将x, y进行复合
// 赋值给dir
MIN_MV( 0, 0,-4 );
MIN_MV( 1, 0, 4 );
MIN_MV( 2,-2,-3 );
MIN_MV( 3, 2,-3 );
MIN_MV( 4,-4,-2 );
MIN_MV( 5, 4,-2 );
MIN_MV( 6,-4,-1 );
MIN_MV( 7, 4,-1 );
MIN_MV( 8,-4, 0 );
MIN_MV( 9, 4, 0 );
MIN_MV( 10,-4, 1 );
MIN_MV( 11, 4, 1 );
MIN_MV( 12,-4, 2 );
MIN_MV( 13, 4, 2 );
MIN_MV( 14,-2, 3 );
MIN_MV( 15, 2, 3 );
#undef SADS
#undef ADD_MVCOST
#undef MIN_MV
// 如果dir不为0， 则说明前面的预测
// 获得了更佳的预测运动向量
if(dir)
{
// 更新最佳预测运动向量
// 为什么乘以i，暂时不是很清楚
bmx = omx + i*(dir>>4);
bmy = omy + i*((dir<<28)>>28);
}
}
} while( ++i <= i_me_range>>2 ); // i 是否越界
// 如果最佳预测运动向量没有越界，进行hex2预测
// 为什么没有越界，继续进行hex预测
// 而越界后终止
if( bmy <= mv_y_max && bmy >= mv_y_min && bmx <= mv_x_max && bmx >= mv_x_min )
goto me_hex2;
// 终止预测
break;
}
case X264_ME_ESA:
case X264_ME_TESA:
{
// 限制 min_x, min_y, max_x, max_y 的范围
const int min_x = X264_MAX( bmx - i_me_range, mv_x_min );
const int min_y = X264_MAX( bmy - i_me_range, mv_y_min );
const int max_x = X264_MIN( bmx + i_me_range, mv_x_max );
const int max_y = X264_MIN( bmy + i_me_range, mv_y_max );
// 获取 x 方向宽度，
// 除以4， 是否min_x, max_x 是 1/4像素坐标
// 转换为整像素坐标 ？？？
/* SEA is fastest in multiples of 4 */
const int width = (max_x - min_x + 3) & ~3;
#if 0
/* plain old exhaustive search */
for( int my = min_y; my <= max_y; my++ )
for( int mx = min_x; mx < min_x + width; mx++ )
COST_MV( mx, my );
#else
/* successive elimination by comparing DC before a full SAD,
* because sum(abs(diff)) >= abs(diff(sum)). */
uint16_t *sums_base = m->integral;
ALIGNED_16( static pixel zero[8*FENC_STRIDE] ) = {0};
// 声明一个整数数组 int enc_dc[4]
ALIGNED_ARRAY_16( int, enc_dc,[4] );
// PIXEL_8X8 = 3, PIXEL_4X4 = 6
// 因此 sad_size 要么=3, 要么=6
// sad_size在这是x264_pixel_size的索引号
// enum
// {
// PIXEL_16x16 = 0,
// PIXEL_16x8 = 1,
// PIXEL_8x16 = 2,
// PIXEL_8x8 = 3,
// PIXEL_8x4 = 4,
// PIXEL_4x8 = 5,
// PIXEL_4x4 = 6,
// /* Subsampled chroma only */
// PIXEL_4x16 = 7, /* 4:2:2 */
// PIXEL_4x2 = 8,
// PIXEL_2x8 = 9, /* 4:2:2 */
// PIXEL_2x4 = 10,
// PIXEL_2x2 = 11,
// };
// static const struct { uint8_t w, h; } x264_pixel_size[12] =
// {
// { 16, 16 }, { 16, 8 }, { 8, 16 }, { 8, 8 }, { 8, 4 }, { 4, 8 }, { 4, 4 },
// { 4, 16 }, { 4, 2 }, { 2, 8 }, { 2, 4 }, { 2, 2 },
// };
// x264_pixel_size表示的是像素的wxh
int sad_size = i_pixel <= PIXEL_8x8 ? PIXEL_8x8 : PIXEL_4x4;
int delta = x264_pixel_size[sad_size].w;
int16_t *xs = h->scratch_buffer;
int xn;
// 在 x264_analyse_init_costs 函数中
// if( h->param.analyse.i_me_method >= X264_ME_ESA && !h->cost_mv_fpel[qp][0] )
// {
// for( int j = 0; j < 4; j++ )
// {
// CHECKED_MALLOC( h->cost_mv_fpel[qp][j], (4*2048 + 1) * sizeof(uint16_t) );
// h->cost_mv_fpel[qp][j] += 2*2048;
// for( int i = -2*2048; i < 2*2048; i++ )
// h->cost_mv_fpel[qp][j][i] = h->cost_mv[qp][i*4+j];
// }
// }
// 由上面的代码可知， h->cost_mv_fpel数组
// 在x264_analyse_init_costs被初始化
// 因此 cost_fpel_mvx指向某个指针
// 从字面上看， 这块内存保存着整像素预设的预测向量？？？
uint16_t *cost_fpel_mvx = h->cost_mv_fpel[h->mb.i_qp][-m->mvp[0]&3] + (-m->mvp[0]>>2);
// 在我的调试中 sad_size = 3， delta = 8
// h->pixf.sad_x4[3] = x264_pixel_sad_x4_8x8
// SAD_X( 8x8 )将分别调x264_pixel_sad_8x8三次
// 如果p_fenc指向的宏块假定为索引0
// 那么p_fenc表示宏块0
// p_fenc+delta表示其右宏块1
// p_fenc + delta*FENC_STRIDE表示其底宏块2
// p_fenc + delta + delta * FENC_STRIDE表示其底右宏块
// 也就是p_fenc将与其右， 底， 底右宏块
// 分别x26_pixel_sad_8x8求SAD
// 将预测代价保存在enc_dc数组中
h->pixf.sad_x4[sad_size]( zero, p_fenc, p_fenc+delta,
p_fenc+delta*FENC_STRIDE, p_fenc+delta+delta*FENC_STRIDE,
FENC_STRIDE, enc_dc );
// PADV = 32, 在我的调试中 stride = 1344
// h->fenc->i_lines[0] + PADV*2 表示有多少行（包括padding lines）
if( delta == 4 )
sums_base += stride * (h->fenc->i_lines[0] + PADV*2);
// 在我的调试中， i_pixel = 0(PIXEL_16x16)
// 因此 delta = 8 * 1344 = 10752
if( i_pixel == PIXEL_16x16 || i_pixel == PIXEL_8x16 || i_pixel == PIXEL_4x8 )
delta *= stride;
if( i_pixel == PIXEL_8x16 || i_pixel == PIXEL_4x8 )
enc_dc[1] = enc_dc[2];
if( h->mb.i_me_method == X264_ME_TESA )
{
// ADS threshold, then SAD threshold, then keep the best few SADs, then SATD
mvsad_t *mvsads = (mvsad_t *)(xs + ((width+31)&~31) + 4);
int nmvsad = 0, limit;
// 根据 i_me_range 的值 设定 sad_thresh = 10, 11, or 12
int sad_thresh = i_me_range <= 16 ? 10 : i_me_range <= 24 ? 11 : 12;
// h->pixf.sad[0] = x264_pixel_sad_16x16
// 计算p_fenc 与 参考Y平面在预测向量bmx, bmy为原点
// 的sad计算， 得到的SAD赋值给bsad
int bsad = h->pixf.sad[i_pixel]( p_fenc, FENC_STRIDE, p_fref_w+bmy*stride+bmx, stride )
+ BITS_MVD( bmx, bmy );
for( int my = min_y; my <= max_y; my++ )
{
int i;
// 初始化y方向预测代价
int ycost = p_cost_mvy[my<<2];
// 如果bsad小于这个初始化代价值，则进行下一个迭代
if( bsad <= ycost )
continue;
// 得到剩余代价
bsad -= ycost;
// h->pixf.ads[0] = x264_pixel_ads4
// static int x264_pixel_ads4( int enc_dc[4], uint16_t *sums, int delta,
// uint16_t *cost_mvx, int16_t *mvs, int width, int thresh )
// {
// int nmv = 0;
// for( int i = 0; i < width; i++, sums++ )
// {
// int ads = abs( enc_dc[0] - sums[0] )
// + abs( enc_dc[1] - sums[8] )
// + abs( enc_dc[2] - sums[delta] )
// + abs( enc_dc[3] - sums[delta+8] )
// + cost_mvx[i];
// if( ads < thresh )
// mvs[nmv++] = i;
// }
// return nmv;
// }
xn = h->pixf.ads[i_pixel]( enc_dc, sums_base + min_x + my * stride, delta,
cost_fpel_mvx+min_x, xs, width, bsad * 17 >> 4 );
for( i = 0; i < xn-2; i += 3 )
{
// 指向min_X, my为原点的像素区
pixel *ref = p_fref_w+min_x+my*stride;
// 声明 int sads[4]
ALIGNED_ARRAY_16( int, sads,[4] ); /* padded to [4] for asm */
// h->pixf.sad_x3[0] = x264_pixel_sad_x3_16x16
// 求p_fenc分别于ref + xs[i], ref + xs[i+1], ref + xs[i+2]
// 三个像素点为原点的预测代价，并保存在sads数组
h->pixf.sad_x3[i_pixel]( p_fenc, ref+xs[i], ref+xs[i+1], ref+xs[i+2], stride, sads );
for( int j = 0; j < 3; j++ )
{
// 迭代求sad
int sad = sads[j] + cost_fpel_mvx[xs[i+j]];
// sad 满足某个条件
if( sad < bsad*sad_thresh>>3 )
{
// 如果sad < bsad, => bsad = sad
COPY1_IF_LT( bsad, sad );
// 保存补偿后的sad
mvsads[nmvsad].sad = sad + ycost;
// 保存候选的预测运动向量
mvsads[nmvsad].mv[0] = min_x+xs[i+j];
mvsads[nmvsad].mv[1] = my;
nmvsad++;
}
}
}
for( ; i < xn; i++ )
{
// 获取新的mx, 作为x方向的原点
int mx = min_x+xs[i];
// 在p_fenc和以mx, my为原点参考Y平面之间
// 求sad
int sad = h->pixf.sad[i_pixel]( p_fenc, FENC_STRIDE, p_fref_w+mx+my*stride, stride )
+ cost_fpel_mvx[xs[i]];
if( sad < bsad*sad_thresh>>3 )
{
// 执行类似上面的操作
COPY1_IF_LT( bsad, sad );
mvsads[nmvsad].sad = sad + ycost;
mvsads[nmvsad].mv[0] = mx;
mvsads[nmvsad].mv[1] = my;
nmvsad++;
}
}
// 补偿 bsad
bsad += ycost;
}
// 设定新的限制和阈值
limit = i_me_range >> 1;
sad_thresh = bsad*sad_thresh>>3;
while( nmvsad > limit*2 && sad_thresh > bsad )
{
int i;
// halve the range if the domain is too large... eh, close enough
// 更新阈值
sad_thresh = (sad_thresh + bsad) >> 1;
// 迭代直到 mvsads[i].sad > sad_thresh
for( i = 0; i < nmvsad && mvsads[i].sad <= sad_thresh; i++ );
// 从i开始， 拷贝后面的sad, mv到[i]
// 这段代码的主要作用是将小于sad_thresh的
// sad 和 mv 保存在 mvsads[0], [1], ..., [i - 1]中
for( int j = i; j < nmvsad; j++ )
{
uint32_t sad;
if( WORD_SIZE == 8 && sizeof(mvsad_t) == 8 )
{
uint64_t mvsad = M64( &mvsads[i] ) = M64( &mvsads[j] );
#if WORDS_BIGENDIAN
mvsad >>= 32;
#endif
sad = mvsad;
}
else
{
// 将数组后面的sad, mv拷贝给[i]
sad = mvsads[j].sad;
CP32( mvsads[i].mv, mvsads[j].mv );
mvsads[i].sad = sad;
}
// 第一遍迭代， i 保持不变，
// 因为j = i, 这时 mvsads[i].sad > sad_thresh
// 因为sad是uint32_t型，因此右边的取值只可能是0或1
i += (sad - (sad_thresh+1)) >> 31;
}
// 小于阈值的sad数目为i
nmvsad = i;
}
// 这段代码的作用是迭代剔除目前数组中的最大者
// 知道 nmvsad <= limit
while( nmvsad > limit )
{
int bi = 0;
for( int i = 1; i < nmvsad; i++ )
if( mvsads[i].sad > mvsads[bi].sad )
bi = i;
nmvsad--;
if( sizeof( mvsad_t ) == sizeof( uint64_t ) )
CP64( &mvsads[bi], &mvsads[nmvsad] );
else
mvsads[bi] = mvsads[nmvsad];
}
// 迭代在p_fenc 和 在以mvsads[i].mv[0], mvsads[i].mv[1]
// 为原点的参考帧的Y平面求sad
// 如果预测代价更小， 则替换bcost和bmx, bmy
for( int i = 0; i < nmvsad; i++ )
COST_MV( mvsads[i].mv[0], mvsads[i].mv[1] );
}
else
{
// h->mb.i_me_method == X264_ME_ESA
// just ADS and SAD
for( int my = min_y; my <= max_y; my++ )
{
int i;
// 初始化ycost
int ycost = p_cost_mvy[my<<2];
if( bcost <= ycost )
continue;
// 获得剩余代价
bcost -= ycost;
// h->pixf.ads[0] = x264_pixel_ads4
// static int x264_pixel_ads4( int enc_dc[4], uint16_t *sums, int delta,
// uint16_t *cost_mvx, int16_t *mvs, int width, int thresh )
// {
// int nmv = 0;
// for( int i = 0; i < width; i++, sums++ )
// {
// int ads = abs( enc_dc[0] - sums[0] )
// + abs( enc_dc[1] - sums[8] )
// + abs( enc_dc[2] - sums[delta] )
// + abs( enc_dc[3] - sums[delta+8] )
// + cost_mvx[i];
// if( ads < thresh )
// mvs[nmv++] = i;
// }
// return nmv;
// }
xn = h->pixf.ads[i_pixel]( enc_dc, sums_base + min_x + my * stride, delta,
cost_fpel_mvx+min_x, xs, width, bcost );
// #define COST_MV_X3_ABS( m0x, m0y, m1x, m1y, m2x, m2y )\
// {\
// // h->pixf.fpelcmp_x3 = x264_pixel_sad_x3_16x16
// h->pixf.fpelcmp_x3[i_pixel]( p_fenc,\
// p_fref_w + (m0x) + (m0y)*stride,\
// p_fref_w + (m1x) + (m1y)*stride,\
// p_fref_w + (m2x) + (m2y)*stride,\
// stride, costs );\
// costs[0] += p_cost_mvx[(m0x)<<2]; /* no cost_mvy */\
// costs[1] += p_cost_mvx[(m1x)<<2];\
// costs[2] += p_cost_mvx[(m2x)<<2];\
// COPY3_IF_LT( bcost, costs[0], bmx, m0x, bmy, m0y );\
// COPY3_IF_LT( bcost, costs[1], bmx, m1x, bmy, m1y );\
// COPY3_IF_LT( bcost, costs[2], bmx, m2x, bmy, m2y );\
// }
// 迭代预测三个点， 如果有更佳的候选者， 则替换bcost, bmx, bmy
for( i = 0; i < xn-2; i += 3 )
COST_MV_X3_ABS( min_x+xs[i],my, min_x+xs[i+1],my, min_x+xs[i+2],my );
// 补偿bcost
bcost += ycost;
// 迭代计算在p_fenc和以min_x + xs[i], my为原点的参考帧
// Y平面之间的SAD
// 如果有更佳的， 替换bcost和bmx, bmy
for( ; i < xn; i++ )
COST_MV( min_x+xs[i], my );
}
}
#endif
}
break;
}
/* -> qpel mv */
// 打包候选的预测运动向量
uint32_t bmv = pack16to32_mask(bmx,bmy);
// 打包1/4像素坐标
uint32_t bmv_spel = SPELx2(bmv);
if( h->mb.i_subpel_refine < 3 )
{
m->cost_mv = p_cost_mvx[bmx<<2] + p_cost_mvy[bmy<<2];
// 设定最后的cost
m->cost = bcost;
/* compute the real cost */
if( bmv == pmv ) m->cost += m->cost_mv;
// 设定最佳的预测运动向量
M32( m->mv ) = bmv_spel;
}
else
{
// 根据bpred_cost(from mvp) 与 bcost的大小
// 选择最佳预测运动向量 bpred_mv 或 bmv_spel
// 同时也选择最小代价
M32(m->mv) = bpred_cost < bcost ? bpred_mv : bmv_spel;
m->cost = X264_MIN( bpred_cost, bcost );
}
/* subpel refine */
if( h->mb.i_subpel_refine >= 2 )
{
// 子像素预测，进一步精化提炼
int hpel = subpel_iterations[h->mb.i_subpel_refine][2];
int qpel = subpel_iterations[h->mb.i_subpel_refine][3];
// 参见 refine_subpel 分析
refine_subpel( h, m, hpel, qpel, p_halfpel_thresh, 0 );
}
}
/* initialize an array of lambda*nbits for all possible mvs */
static void x264_mb_analyse_load_costs( x264_t *h, x264_mb_analysis_t *a )
{
a->p_cost_mv = h->cost_mv[a->i_qp];
a->p_cost_ref[0] = x264_cost_ref[a->i_qp][x264_clip3(h->sh.i_num_ref_idx_l0_active-1,0,2)];
a->p_cost_ref[1] = x264_cost_ref[a->i_qp][x264_clip3(h->sh.i_num_ref_idx_l1_active-1,0,2)];
}
int x264_analyse_init_costs( x264_t *h, float *logs, int qp )
{
int lambda = x264_lambda_tab[qp];
if( h->cost_mv[qp] )
return 0;
/* factor of 4 from qpel, 2 from sign, and 2 because mv can be opposite from mvp */
CHECKED_MALLOC( h->cost_mv[qp], (4*4*2048 + 1) * sizeof(uint16_t) );
h->cost_mv[qp] += 2*4*2048;
for( int i = 0; i <= 2*4*2048; i++ )
{
h->cost_mv[qp][-i] =
h->cost_mv[qp][i] = X264_MIN( lambda * logs[i] + .5f, (1<<16)-1 );
}
x264_pthread_mutex_lock( &cost_ref_mutex );
for( int i = 0; i < 3; i++ )
for( int j = 0; j < 33; j++ )
x264_cost_ref[qp][i][j] = X264_MIN( i ? lambda * bs_size_te( i, j ) : 0, (1<<16)-1 );
x264_pthread_mutex_unlock( &cost_ref_mutex );
if( h->param.analyse.i_me_method >= X264_ME_ESA && !h->cost_mv_fpel[qp][0] )
{
for( int j = 0; j < 4; j++ )
{
CHECKED_MALLOC( h->cost_mv_fpel[qp][j], (4*2048 + 1) * sizeof(uint16_t) );
h->cost_mv_fpel[qp][j] += 2*2048;
for( int i = -2*2048; i < 2*2048; i++ )
h->cost_mv_fpel[qp][j][i] = h->cost_mv[qp][i*4+j];
}
}
uint16_t *cost_i4x4_mode = (uint16_t*)ALIGN((intptr_t)x264_cost_i4x4_mode,64) + qp*32;
for( int i = 0; i < 17; i++ )
cost_i4x4_mode[i] = 3*lambda*(i!=8);
return 0;
fail:
return -1;
}
#define COST_MV_HPEL( mx, my, cost )\
do\
{\
intptr_t stride2 = 16;\
// call get_ref, 见 get_ref
pixel *src = h->mc.get_ref( pix, &stride2, m->p_fref, stride, mx, my, bw, bh, &m->weight[0] );\
// call h->pixf.fpelcmp[0] = x264_pixel_sad_16x16, 见 PIXEL_SAD_C( x264_pixel_sad_16x16, 16, 16 )
cost = h->pixf.fpelcmp[i_pixel]( p_fenc, FENC_STRIDE, src, stride2 )\
+ p_cost_mvx[ mx ] + p_cost_mvy[ my ];\
} while(0)
static pixel *get_ref( pixel *dst, intptr_t *i_dst_stride,
pixel *src[4], intptr_t i_src_stride,
int mvx, int mvy,
int i_width, int i_height, const x264_weight_t *weight )
{
// mvx, mvy 表示需要进行1/4像素插值的1/4 像素点的坐标
// 如(1, 1) 就表示需要求1/4像素点(1, 1)的插值
// 这需要用到水平1/2和垂直1/2像素点平面
// 对于水平两个相邻整像素位， 其位置可用0, 1表示
// 放大到子像素后， 其位置变为0, 4,
// 其中的1， 2，3 分别表示 1/4, 2/4, 3/4像素位
// 因此如果 mvx & 3 == 1, 表示水平1/4像素位
// mvx & 3 == 2， 表示水平2/4 = 1/2 像素位
// mvx & == 3, 表示水平 3/4 像素位
//
int qpel_idx = ((mvy&3)<<2) + (mvx&3);
int offset = (mvy>>2)*i_src_stride + (mvx>>2);
// 传入的 src = m->p_fref 是一个指针数组,
// 这个是在 x264_mb_analyse_inter_p16x16 函数中
// 调用 LOAD_HPELS 进行装载的
// src[0] 指向 整像素平面， src[1] 指向 1/2 像素平面
// src[2] 指向垂直 1/2 像素平面， src[3] 指向斜对角 1/2 像素平面
// 这些平面是为计算 1/4 像素准备的， 1/4 插值是取两个像素的中值
// 因此需要两个平面
// 对于 G x b x G
// y z y z y
// h x i x h
// y z y z y
// G x b x G
// 其中G是整像素，对应src[0]；
// b 水平方向 1/2 像素,对应src[1]；
// h 是垂直方向 1/2 像素，对应src[2]；
// i 是 斜对角方向 1/2 像素， 对应src[3]；
// 如想计算i左上角z的像素值， 即pixel(1, 1)的值
// 那么就需要水平1/2像素平面，和垂直1/2像素平面
// pixel(1,1) = (pixel(0,2 ) + pixel(2, 0) + 1) >>1
// 获取其中一个平面的像素位
// hpel_ref0[qpel_idx] 得到平面索引
// src[hpel_ref0[qpel_idx]] + offset 得到该平面整像素位地址
// 那么src1得到的上面地址，或向垂直方向移动一行，到下一个整像素
// 点
pixel *src1 = src[hpel_ref0[qpel_idx]] + offset + ((mvy&3) == 3) * i_src_stride;
// 需要进行 1/4 像素插值
if( qpel_idx & 5 ) /* qpel interpolation needed */
{
// 如果qpel_idx & 5 不为0,
// 则说明水平或垂直方向的 1/4，或 3/4 像素位需要插值
// src2 指向 hpel_ref1[pel_idx]平面索引所指平面
// 并偏移 offset, 在x方向可能需要偏移一个像素
pixel *src2 = src[hpel_ref1[qpel_idx]] + offset + ((mvx&3) == 3);
pixel_avg( dst, *i_dst_stride, src1, i_src_stride,
src2, i_src_stride, i_width, i_height );
if( weight->weightfn )
mc_weight( dst, *i_dst_stride, dst, *i_dst_stride, weight, i_width, i_height );
return dst;
}
else if( weight->weightfn )
{
mc_weight( dst, *i_dst_stride, src1, i_src_stride, weight, i_width, i_height );
return dst;
}
else
{
*i_dst_stride = i_src_stride;
return src1;
}
}
#define COST_MV_X3_DIR( m0x, m0y, m1x, m1y, m2x, m2y, costs )\
{\
// 根据候选的最佳预测运动向量，定位到参考帧的相应位置
pixel *pix_base = p_fref_w + bmx + bmy*stride;\
// call x264_pixel_sad_x3_16x16 对三个点方向分别计算 SAD
// 把每个方向计算的代价保存在costs数组中
h->pixf.fpelcmp_x3[i_pixel]( p_fenc,\
pix_base + (m0x) + (m0y)*stride,\
pix_base + (m1x) + (m1y)*stride,\
pix_base + (m2x) + (m2y)*stride,\
stride, costs );\
// 每个代价加上相应的实验数据
(costs)[0] += BITS_MVD( bmx+(m0x), bmy+(m0y) );\
(costs)[1] += BITS_MVD( bmx+(m1x), bmy+(m1y) );\
(costs)[2] += BITS_MVD( bmx+(m2x), bmy+(m2y) );\
}
#define BITS_MVD( mx, my )\
(p_cost_mvx[(mx)<<2] + p_cost_mvy[(my)<<2])
#define CROSS( start, x_max, y_max )\
{\
// 设定i=start, start表示以omx, omy为中心的起始搜索半径
int i = start;\
// 如果没有越界
// 搜索以omx, omy为中心， x方向正负方向对称的各两个点
// 如果有更小代价的，则替换bcost和bmx, bmy
if( (x_max) <= X264_MIN(mv_x_max-omx, omx-mv_x_min) )\
for( ; i < (x_max)-2; i+=4 )\
COST_MV_X4( i,0, -i,0, i+2,0, -i-2,0 );\
// 搜索剩余的搜索范围
for( ; i < (x_max); i+=2 )\
{\
// 如果omx + i 没有越界
// 预测omx+i, omy这个点，
// 如果其代价更小， 则替换bcost, bmx, bmy
if( omx+i <= mv_x_max )\
COST_MV( omx+i, omy );\
// 反向预测omx - i, omy点
// 如果其代价更小， 则替换bcost, bmx, bmy
if( omx-i >= mv_x_min )\
COST_MV( omx-i, omy );\
}\
// 对y方向进行类似搜索
i = start;\
if( (y_max) <= X264_MIN(mv_y_max-omy, omy-mv_y_min) )\
for( ; i < (y_max)-2; i+=4 )\
COST_MV_X4( 0,i, 0,-i, 0,i+2, 0,-i-2 );\
for( ; i < (y_max); i+=2 )\
{\
if( omy+i <= mv_y_max )\
COST_MV( omx, omy+i );\
if( omy-i >= mv_y_min )\
COST_MV( omx, omy-i );\
}\
}
#define LOAD_FENC(m, src, xoff, yoff) \
{ \
(m)->p_cost_mv = a->p_cost_mv; \
(m)->i_stride[0] = h->mb.pic.i_stride[0]; \
(m)->i_stride[1] = h->mb.pic.i_stride[1]; \
(m)->i_stride[2] = h->mb.pic.i_stride[2]; \
(m)->p_fenc[0] = &(src)[0][(xoff)+(yoff)*FENC_STRIDE]; \
(m)->p_fenc[1] = &(src)[1][((xoff)>>CHROMA_H_SHIFT)+((yoff)>>CHROMA_V_SHIFT)*FENC_STRIDE]; \
(m)->p_fenc[2] = &(src)[2][((xoff)>>CHROMA_H_SHIFT)+((yoff)>>CHROMA_V_SHIFT)*FENC_STRIDE]; \
}
- x264 - x264_me_search_ref
- x264中x264_me_search_ref的被调用分析
- x264中x264_me_search_ref的被调用分析
- x264_me_search_ref函数分析
- x264_me_search_ref函数分析
- x264
- x264 - x264.mb.i_neighbour8
- X264 笔记
- 编译x264
- x264编译
- x264 git
- x264优化
- X264设定
- X264分析
- X264设定
- 编译x264
- x264编译
- x264记录
- Swift 概述及Swift运算符和表达式
- 4-NLP有用资料整理
- Android 中Parcelable的作用
- create a cocos2d-x-3.0 project in Xcode
- 让powershell在不显示提示信息的情况下通过Internet上下载的ps脚本
- x264 - x264_me_search_ref
- ACM抽象基类
- Androidの共享登录之方案研究
- Android 怎么退出整个应用程序？
- 数据结构CCDictionary
- 幸运大转盘-jQuery+PHP实现的抽奖程序
- JS操作JSON读书笔记
- DSP/BIOS 常用API总结
- C++ 堆和栈的比较
