📄 mv-search.c
字号:
}
else if(blocktype == 4)
{
pred_MV_uplayer[0] = all_mv[block_x][block_y][list][ref][2][0];
pred_MV_uplayer[1] = all_mv[block_x][block_y][list][ref][2][1];
pred_SAD_uplayer = (list==1) ? (all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][0][2][0]) : (all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][2][0]);
pred_SAD_uplayer /= 2;
}
else if(blocktype > 1)
{
pred_MV_uplayer[0] = all_mv[block_x][block_y][list][ref][1][0];
pred_MV_uplayer[1] = all_mv[block_x][block_y][list][ref][1][1];
pred_SAD_uplayer = (list==1) ? (all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][0][1][0]) : (all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][1][0]);
pred_SAD_uplayer /= 2;
}
}
pred_SAD_uplayer = flag_intra_SAD ? 0 : pred_SAD_uplayer;// for irregular motion
//Coordinate prediction
if (img->number > ref+1)
{
pred_SAD_time = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][0];
pred_MV_time[0] = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][1];
pred_MV_time[1] = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][2];
}
if(list==1 && (Bframe_ctr%N_Bframe) > 1)
{
pred_SAD_time = all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][0];
pred_MV_time[0] = (int)(all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][0][blocktype][1] * ((n_Bframe==1) ? (N_Bframe) : (N_Bframe-n_Bframe+1.0)/(N_Bframe-n_Bframe+2.0)) );//should add a factor
pred_MV_time[1] = (int)(all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][0][blocktype][2] *((n_Bframe==1) ? (N_Bframe) : (N_Bframe-n_Bframe+1.0)/(N_Bframe-n_Bframe+2.0)) );//should add a factor
}
if (input->PicInterlace == FIELD_CODING)
{
if (img->type == P_SLICE && ref > 1)
{
pred_SAD_ref = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][(ref-2)][blocktype][0];
pred_SAD_ref = flag_intra_SAD ? 0 : pred_SAD_ref;//add this for irregular motion
pred_MV_ref[0] = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][(ref-2)][blocktype][1];
pred_MV_ref[0] = (int)(pred_MV_ref[0]*((ref>>1)+1)/(float)((ref>>1)));
pred_MV_ref[1] = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][(ref-2)][blocktype][2];
pred_MV_ref[1] = (int)(pred_MV_ref[1]*((ref>>1)+1)/(float)((ref>>1)));
}
if (img->type == B_SLICE && list==0 && (ref==0 || ref==1) )
{
pred_SAD_ref = all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][0][blocktype][0];
pred_SAD_ref = flag_intra_SAD ? 0 : pred_SAD_ref;//add this for irregular motion
pred_MV_ref[0] =(int) (all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][1]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f)); //should add a factor
pred_MV_ref[1] =(int) ( all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][2]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
}
}
else //frame case
{
if (ref > 0)
{//field_mode top_field
pred_SAD_ref = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][(ref-1)][blocktype][0];
pred_SAD_ref = flag_intra_SAD ? 0 : pred_SAD_ref;//add this for irregular motion
pred_MV_ref[0] = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][(ref-1)][blocktype][1];
pred_MV_ref[0] = (int)(pred_MV_ref[0]*(ref+1)/(float)(ref));
pred_MV_ref[1] = all_mincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][(ref-1)][blocktype][2];
pred_MV_ref[1] = (int)(pred_MV_ref[1]*(ref+1)/(float)(ref));
}
if (img->type == B_SLICE && (list==0 && ref==0)) //B frame forward prediction, first ref
{
pred_SAD_ref = all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][0][blocktype][0];
pred_SAD_ref = flag_intra_SAD ? 0 : pred_SAD_ref;//add this for irregular motion
pred_MV_ref[0] =(int) (all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][1]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f)); //should add a factor
pred_MV_ref[1] =(int) ( all_bwmincost[(img->pix_x>>2)+block_x][(img->pix_y>>2)+block_y][ref][blocktype][2]*(-n_Bframe)/(N_Bframe-n_Bframe+1.0f));
}
}
}
//===========================================
//===== GET MOTION VECTOR PREDICTOR =====
//===========================================
//wenfang fu 2004.3.30
if(input->FMEnable)
{
FME_SetMotionVectorPredictor (pred_mv, /*refFrArray*/ref_array, /*tmp_mv_array*/mv_array, ref, list, mb_x, mb_y, bsx, bsy, blocktype, ref);
}
else
{
SetMotionVectorPredictor (pred_mv, enc_picture->ref_idx, enc_picture->mv, ref, list, block_x, block_y, bsx, bsy);
}
pred_mv_x = pred_mv[0];
pred_mv_y = pred_mv[1];
//==================================
//===== INTEGER-PEL SEARCH =====
//==================================
if(input->FMEnable)
{
mv_x = pred_mv_x / 4;
mv_y = pred_mv_y / 4;
if (!input->rdopt)
{
//--- adjust search center so that the (0,0)-vector is inside ---
mv_x = max (-search_range, min (search_range, mv_x));
mv_y = max (-search_range, min (search_range, mv_y));
}
min_mcost = FastIntegerPelBlockMotionSearch(orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype,
pred_mv_x, pred_mv_y, &mv_x, &mv_y, search_range,
min_mcost, lambda);
//FAST MOTION ESTIMATION. ZHIBO CHEN 2003.3
for (i=0; i < (bsx>>2); i++)
{
for (j=0; j < (bsy>>2); j++)
{
if(list == 0)
all_mincost[(img->pix_x>>2)+block_x+i][(img->pix_y>>2)+block_y+j][ref][blocktype][0] = min_mcost;
else
all_bwmincost[(img->pix_x>>2)+block_x+i][(img->pix_y>>2)+block_y+j][ref][blocktype][0] = min_mcost;
}
}
}
else
{
#ifndef _FAST_FULL_ME_
//--- set search center ---
mv_x = pred_mv_x / 4;
mv_y = pred_mv_y / 4;
if (!input->rdopt)
{
//--- adjust search center so that the (0,0)-vector is inside ---
mv_x = max (-search_range, min (search_range, mv_x));
mv_y = max (-search_range, min (search_range, mv_y));
}
//--- perform motion search ---
min_mcost = FullPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype,
pred_mv_x, pred_mv_y, &mv_x, &mv_y, search_range,
min_mcost, lambda);
#else
// comments: - orig_pic is not used -> be careful
// - search center is automatically determined
min_mcost = FastFullPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype,
pred_mv_x, pred_mv_y, &mv_x, &mv_y, search_range,
min_mcost, lambda);
#endif
}
//==============================
//===== SUB-PEL SEARCH =====
//==============================
if (input->hadamard)
{
min_mcost = max_value;
}
if(input->FMEnable)
{
if(blocktype >3)
{
min_mcost = FastSubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype,
pred_mv_x, pred_mv_y, &mv_x, &mv_y, 9, 9,
min_mcost, lambda, /*useABT*/0);
}
else
{
min_mcost = SubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype,
pred_mv_x, pred_mv_y, &mv_x, &mv_y, 9, 9,
min_mcost, lambda);
}
for (i=0; i < (bsx>>2); i++)
{
for (j=0; j < (bsy>>2); j++)
{
if(list == 0)
{
all_mincost[(img->pix_x>>2)+block_x+i][(img->pix_y>>2)+block_y+j][ref][blocktype][1] = mv_x;
all_mincost[(img->pix_x>>2)+block_x+i][(img->pix_y>>2)+block_y+j][ref][blocktype][2] = mv_y;
}
else
{
all_bwmincost[(img->pix_x>>2)+block_x+i][(img->pix_y>>2)+block_y+j][ref][blocktype][1] = mv_x;
all_bwmincost[(img->pix_x>>2)+block_x+i][(img->pix_y>>2)+block_y+j][ref][blocktype][2] = mv_y;
}
}
}
}
else
{
min_mcost = SubPelBlockMotionSearch (orig_pic, ref, list, pic_pix_x, pic_pix_y, blocktype,
pred_mv_x, pred_mv_y, &mv_x, &mv_y, 9, 9,
min_mcost, lambda);
}
if (!input->rdopt)
{
// Get the skip mode cost
if (blocktype == 1 && (img->type == P_SLICE||img->type == SP_SLICE))
{
int cost;
FindSkipModeMotionVector ();
cost = GetSkipCostMB (lambda);
cost -= (int)floor(8*lambda+0.4999);
if (cost < min_mcost)
{
min_mcost = cost;
mv_x = img->all_mv [0][0][0][0][0][0];
mv_y = img->all_mv [0][0][0][0][0][1];
}
}
}
//===============================================
//===== SET MV'S AND RETURN MOTION COST =====
//===============================================
if(input->FMEnable)
{
{int h4x4blkno = (pic_pix_x>>2); int v4x4blkno = pic_pix_y>>2;
for (i=0; i < (bsx>>2); i++){
for (j=0; j < (bsy>>2); j++){
all_mv[block_x+i][block_y+j][list][ref][blocktype][0] = mv_x;
all_mv[block_x+i][block_y+j][list][ref][blocktype][1] = mv_y;
mv_array[h4x4blkno+i][v4x4blkno+j][0] = mv_x; //adding 4 is weird, also y,x instead of x,y????
mv_array[h4x4blkno+i][v4x4blkno+j][1] = mv_y;
}
}}
if (img->type==B_SLICE && img->nal_reference_idc>0) //probably wrong, executed even for list = 0. g050
{
for (i=0; i < (bsx>>2); i++)
for (j=0; j < (bsy>>2); j++)
{
// Backward
all_mv[block_x+i][block_y+j][list][ref][blocktype][0] = mv_x;
all_mv[block_x+i][block_y+j][list][ref][blocktype][1] = mv_y;
}
}
}
else
{
for (i=0; i < (bsx>>2); i++)
{
for (j=0; j < (bsy>>2); j++)
{
all_mv[block_x+i][block_y+j][list][ref][blocktype][0] = mv_x;
all_mv[block_x+i][block_y+j][list][ref][blocktype][1] = mv_y;
}
}
}
return min_mcost;
}
/*!
***********************************************************************
* \brief
* Motion Cost for Bidirectional modes
***********************************************************************
*/
int BIDPartitionCost (int blocktype,
int block8x8,
int fw_ref,
int bw_ref,
int lambda_factor)
{
static int bx0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,2,0,2}};
static int by0[5][4] = {{0,0,0,0}, {0,0,0,0}, {0,2,0,0}, {0,0,0,0}, {0,0,2,2}};
int diff[16];
int pic_pix_x, pic_pix_y, block_x, block_y;
int v, h, mcost, i, j, k;
int mvd_bits = 0;
int parttype = (blocktype<4?blocktype:4);
int step_h0 = (input->blc_size[ parttype][0]>>2);
int step_v0 = (input->blc_size[ parttype][1]>>2);
int step_h = (input->blc_size[blocktype][0]>>2);
int step_v = (input->blc_size[blocktype][1]>>2);
int bxx, byy; // indexing curr_blk
int ******all_mv = img->all_mv;
int ****** p_mv = img->pred_mv;
//----- cost for motion vector bits -----
for (v=by0[parttype][block8x8]; v<by0[parttype][block8x8]+step_v0; v+=step_v)
for (h=bx0[parttype][block8x8]; h<bx0[parttype][block8x8]+step_h0; h+=step_h)
{
mvd_bits += mvbits[ all_mv [h][v][LIST_0][fw_ref][blocktype][0] - p_mv[h][v][LIST_0][fw_ref][blocktype][0] ];
mvd_bits += mvbits[ all_mv [h][v][LIST_0][fw_ref][blocktype][1] - p_mv[h][v][LIST_0][fw_ref][blocktype][1] ];
mvd_bits += mvbits[ all_mv [h][v][LIST_1][bw_ref][blocktype][0] - p_mv[h][v][LIST_1][bw_ref][blocktype][0] ];
mvd_bits += mvbits[ all_mv [h][v][LIST_1][bw_ref][blocktype][1] - p_mv[h][v][LIST_1][bw_ref][blocktype][1] ];
}
mcost = WEIGHTED_COST (lambda_factor, mvd_bits);
//----- cost of residual signal -----
for (byy=0, v=by0[parttype][block8x8]; v<by0[parttype][block8x8]+step_v0; byy+=4, v++)
{
pic_pix_y = img->opix_y + (block_y = (v<<2));
for (bxx=0, h=bx0[parttype][block8x8]; h<bx0[parttype][block8x8]+step_h0; bxx+=4, h++)
{
pic_pix_x = img->opix_x + (block_x = (h<<2));
LumaPrediction4x4 (block_x, block_y, 2, blocktype, blocktype, fw_ref, bw_ref);
for (k=j=0; j<4; j++)
for ( i=0; i<4; i++, k++)
{
diff[k] = imgY_org[pic_pix_y+j][pic_pix_x+i] - img->mpr[i+block_x][j+block_y];
}
mcost += SATD (diff, input->hadamard);
}
}
return mcost;
}
/*!
************************************************************************
* \brief
* Get cost for skip mode for an macroblock
************************************************************************
*/
int GetSkipCostMB (double lambda)
{
int block_y, block_x, pic_pix_y, pic_pix_x, i, j, k;
int diff[16];
int cost = 0;
for (block_y=0; block_y<16; block_y+=4)
{
pic_pix_y = img->opix_y + block_y;
for (block_x=0; block_x<16; block_x+=4)
{
pic_pix_x = img->opix_x + block_x;
//===== prediction of 4x4 block =====
LumaPrediction4x4 (block_x, block_y, 0,⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -