📄 mv-search.c
字号:
/* 1 A, B, D are set to 0 if unavailable */
/* 2 If C is not available it is replaced by D */
block_available_up = mb_available_up || (mb_pix_y > 0);
block_available_left = mb_available_left || (mb_pix_x > 0);
if (mb_pix_y > 0)
{
if (mb_pix_x < 8) // first column of 8x8 blocks
{
if (mb_pix_y==8)
{
if (blockshape_x == 16)
block_available_upright = 0;
else
block_available_upright = 1;
}
else
{
if (mb_pix_x+blockshape_x != 8)
block_available_upright = 1;
else
block_available_upright = 0;
}
}
else
{
if (mb_pix_x+blockshape_x != 16)
block_available_upright = 1;
else
block_available_upright = 0;
}
}
else if (mb_pix_x+blockshape_x != MB_BLOCK_SIZE)
{
block_available_upright = block_available_up;
}
else
{
block_available_upright = mb_available_upright;
}
if (mb_pix_x > 0)
{
block_available_upleft = (mb_pix_y > 0 ? 1 : block_available_up);
}
else if (mb_pix_y > 0)
{
block_available_upleft = block_available_left;
}
else
{
block_available_upleft = mb_available_upleft;
}
/*Lou 1016 Start*/
mvPredType = MVPRED_MEDIAN;
rFrameL = block_available_left ? refFrArr[pic_block_y -off_y/*lgp*/] [pic_block_x-1] : -1;
rFrameU = block_available_up ? refFrArr[pic_block_y-/*1*/y_up/*lgp*/][pic_block_x] : -1;
rFrameUR = block_available_upright ? refFrArr[pic_block_y-/*1*/y_upright/*lgp*/][pic_block_x+blockshape_x/8] :
block_available_upleft ? refFrArr[pic_block_y-/*1*/y_upleft/*lgp*/][pic_block_x-1] : -1;
rFrameUL = block_available_upleft ? refFrArr[pic_block_y-/*1*/y_upleft/*lgp*/][pic_block_x-1] : -1;
if((rFrameL != -1)&&(rFrameU == -1)&&(rFrameUR == -1))
mvPredType = MVPRED_L;
else if((rFrameL == -1)&&(rFrameU != -1)&&(rFrameUR == -1))
mvPredType = MVPRED_U;
else if((rFrameL == -1)&&(rFrameU == -1)&&(rFrameUR != -1))
mvPredType = MVPRED_UR;
/*Lou 1016 End*/
else if(blockshape_x == 8 && blockshape_y == 16)
{
if(mb_pix_x == 0)
{
if(rFrameL == ref_frame)
mvPredType = MVPRED_L;
}
else
{
if(rFrameUR == ref_frame)
mvPredType = MVPRED_UR;
}
}
//#endif
else if(blockshape_x == 16 && blockshape_y == 8)
{
if(mb_pix_y == 0)
{
if(rFrameU == ref_frame)
mvPredType = MVPRED_U;
}
else
{
if(rFrameL == ref_frame)
mvPredType = MVPRED_L;
}
}
for (hv=0; hv < 2; hv++)
{
mva[hv] = mv_a = block_available_left ? tmp_mv[hv][pic_block_y - off_y/*lgp*/][4+pic_block_x-1] : 0;
mvb[hv] = mv_b = block_available_up ? tmp_mv[hv][pic_block_y-/*1*/y_up/*lgp*/][4+pic_block_x] : 0;
mv_d = block_available_upleft ? tmp_mv[hv][pic_block_y-/*1*/y_upleft/*lgp*/][4+pic_block_x-1] : 0;
mvc[hv] = mv_c = block_available_upright ? tmp_mv[hv][pic_block_y-/*1*/y_upright/*lgp*/][4+pic_block_x+blockshape_x/8] : mv_d;
#ifdef half_pixel_compensation
if(!img->picture_structure && hv == 1){
mva[hv] = scale_motion_vector_pixel(mva[hv], ref_frame, rFrameL, smbtypecurr, smbtypeL, pic_block_y-off_y, pic_block_y, ref, direct_mv);
mvb[hv] = scale_motion_vector_pixel(mvb[hv], ref_frame, rFrameU, smbtypecurr, smbtypeU, pic_block_y-y_up, pic_block_y, ref, direct_mv);
mv_d = scale_motion_vector_pixel(mv_d, ref_frame, rFrameUL, smbtypecurr, smbtypeUL, pic_block_y-y_upleft, pic_block_y, ref, direct_mv);
mvc[hv] = block_available_upright ? scale_motion_vector_pixel(mvc[hv], ref_frame, rFrameUR, smbtypecurr, smbtypeUR, pic_block_y-y_upright, pic_block_y, ref, direct_mv): mv_d;
}
else
#endif
{
//--- Yulj 2004.07.04
// mv_a, mv_b... are not scaled.
mva[hv] = scale_motion_vector(mva[hv], ref_frame, rFrameL, smbtypecurr, smbtypeL, pic_block_y-off_y, pic_block_y, ref, direct_mv);
mvb[hv] = scale_motion_vector(mvb[hv], ref_frame, rFrameU, smbtypecurr, smbtypeU, pic_block_y-y_up, pic_block_y, ref, direct_mv);
mv_d = scale_motion_vector(mv_d, ref_frame, rFrameUL, smbtypecurr, smbtypeUL, pic_block_y-y_upleft, pic_block_y, ref, direct_mv);
mvc[hv] = block_available_upright ? scale_motion_vector(mvc[hv], ref_frame, rFrameUR, smbtypecurr, smbtypeUR, pic_block_y-y_upright, pic_block_y, ref, direct_mv): mv_d;
}
switch (mvPredType)
{
case MVPRED_MEDIAN:
if(hv == 1){
// jlzheng 7.2
// !! for A
//
mva[2] = abs(mva[0] - mvb[0]) + abs(mva[1] - mvb[1]) ;
// !! for B
//
mvb[2] = abs(mvb[0] - mvc[0]) + abs(mvb[1] - mvc[1]);
// !! for C
//
mvc[2] = abs(mvc[0] - mva[0]) + abs(mvc[1] - mva[1]) ;
pred_vec = MEDIAN(mva[2],mvb[2],mvc[2]);
if(pred_vec == mva[2]){
pmv[0] = mvc[0];
pmv[1] = mvc[1];
}
else if(pred_vec == mvb[2]){
pmv[0] = mva[0];
pmv[1] = mva[1];
}
else {
pmv[0] = mvb[0];
pmv[1] = mvb[1];
}// END
}
break;
case MVPRED_L:
pred_vec = mv_a;
break;
case MVPRED_U:
pred_vec = mv_b;
break;
case MVPRED_UR:
pred_vec = mv_c;
break;
default:
break;
}
if(mvPredType != MVPRED_MEDIAN)
pmv[hv] = pred_vec;
}
}
/*
*************************************************************************
* Function:Initialize the motion search
* Input:
* Output:
* Return:
* Attention:
*************************************************************************
*/
void Init_Motion_Search_Module ()
{
int bits, i, imin, imax, k, l;
int search_range = input->search_range;
int number_of_reference_frames = img->buf_cycle;
int max_search_points = (2*search_range+1)*(2*search_range+1);
int max_ref_bits = 1 + 2 * (int)floor(log(max(16,number_of_reference_frames+1)) / log(2) + 1e-10);
int max_ref = (1<<((max_ref_bits>>1)+1))-1;
int number_of_subpel_positions = 4 * (2*search_range+3);
int max_mv_bits = 3 + 2 * (int)ceil (log(number_of_subpel_positions+1) / log(2) + 1e-10);
max_mvd = (1<<(( max_mv_bits >>1)) )-1;
//===== CREATE ARRAYS =====
//-----------------------------
if ((spiral_search_x = (int*)calloc(max_search_points, sizeof(int))) == NULL)
no_mem_exit("Init_Motion_Search_Module: spiral_search_x");
if ((spiral_search_y = (int*)calloc(max_search_points, sizeof(int))) == NULL)
no_mem_exit("Init_Motion_Search_Module: spiral_search_y");
if ((mvbits = (int*)calloc(2*max_mvd+1, sizeof(int))) == NULL)
no_mem_exit("Init_Motion_Search_Module: mvbits");
if ((refbits = (int*)calloc(max_ref, sizeof(int))) == NULL)
no_mem_exit("Init_Motion_Search_Module: refbits");
if ((byte_abs = (int*)calloc(512, sizeof(int))) == NULL)
no_mem_exit("Init_Motion_Search_Module: byte_abs");
get_mem3Dint (&motion_cost, 8, 2*(img->buf_cycle+1), 4);
get_mem3Dint (&motion_cost_bid, 8, 2*(img->buf_cycle+1), 4);
//--- set array offsets ---
mvbits += max_mvd;
byte_abs += 256;
//===== INIT ARRAYS =====
//---------------------------
//--- init array: motion vector bits ---
mvbits[0] = 1;
for (bits=3; bits<=max_mv_bits; bits+=2)
{
imax = 1 << (bits >> 1);
imin = imax >> 1;
for (i = imin; i < imax; i++)
mvbits[-i] = mvbits[i] = bits;
}
//--- init array: reference frame bits ---
refbits[0] = 1;
for (bits=3; bits<=max_ref_bits; bits+=2)
{
imax = (1 << ((bits >> 1) + 1)) - 1;
imin = imax >> 1;
for (i = imin; i < imax; i++)
refbits[i] = bits;
}
//--- init array: absolute value ---
byte_abs[0] = 0;
for (i=1; i<256; i++)
byte_abs[i] = byte_abs[-i] = i;
//--- init array: search pattern ---
spiral_search_x[0] = spiral_search_y[0] = 0;
for (k=1, l=1; l<=max(1,search_range); l++)
{
for (i=-l+1; i< l; i++)
{
spiral_search_x[k] = i; spiral_search_y[k++] = -l;
spiral_search_x[k] = i; spiral_search_y[k++] = l;
}
for (i=-l; i<=l; i++)
{
spiral_search_x[k] = -l; spiral_search_y[k++] = i;
spiral_search_x[k] = l; spiral_search_y[k++] = i;
}
}
}
/*
*************************************************************************
* Function:Free memory used by motion search
* Input:
* Output:
* Return:
* Attention:
*************************************************************************
*/
void Clear_Motion_Search_Module ()
{
//--- correct array offset ---
mvbits -= max_mvd;
byte_abs -= 256;
//--- delete arrays ---
free (spiral_search_x);
free (spiral_search_y);
free (mvbits);
free (refbits);
free (byte_abs);
free_mem3Dint (motion_cost, 8);
}
/*
*************************************************************************
* Function:Full pixel block motion search
* Input:
* Output:
* Return:
* Attention:
*************************************************************************
*/
int // ==> minimum motion cost after search
FullPelBlockMotionSearch (pel_t** orig_pic, // <-- original pixel values for the AxB block
int ref, // <-- reference frame (0... or -1 (backward))
int pic_pix_x, // <-- absolute x-coordinate of regarded AxB block
int pic_pix_y, // <-- absolute y-coordinate of regarded AxB block
int blocktype, // <-- block type (1-16x16 ... 7-4x4)
int pred_mv_x, // <-- motion vector predictor (x) in sub-pel units
int pred_mv_y, // <-- motion vector predictor (y) in sub-pel units
int* mv_x, // <--> in: search center (x) / out: motion vector (x) - in pel units
int* mv_y, // <--> in: search center (y) / out: motion vector (y) - in pel units
int search_range, // <-- 1-d search range in pel units
int min_mcost, // <-- minimum motion cost (cost for center or huge value)
double lambda) // <-- lagrangian parameter for determining motion cost
{
int pos, cand_x, cand_y, y, x8, mcost;
pel_t *orig_line, *ref_line;
pel_t *(*get_ref_line)(int, pel_t*, int, int);
pel_t* ref_pic = img->type==B_IMG? Refbuf11 [/*ref+((mref==mref_fld)) +1*/ref+(!img->picture_structure) +1/*by oliver 0511*/] : Refbuf11[ref];
int best_pos = 0; // position with minimum motion cost
int max_pos = (2*search_range+1)*(2*search_range+1); // number of search positions
int lambda_factor = LAMBDA_FACTOR (lambda); // factor for determining lagragian motion cost
int blocksize_y = input->blc_size[blocktype][1]; // vertical block size
int blocksize_x = input->blc_size[blocktype][0]; // horizontal block size
int blocksize_x8 = blocksize_x >> 3; // horizontal block size in 4-pel units
int pred_x = (pic_pix_x << 2) + pred_mv_x; // predicted position x (in sub-pel units)
int pred_y = (pic_pix_y << 2) + pred_mv_y; // predicted position y (in sub-pel units)
int center_x = pic_pix_x + *mv_x; // center position x (in pel units)
int center_y = pic_pix_y + *mv_y; // center position y (in pel units)
int check_for_00 = (blocktype==1 && !input->rdopt && img->type!=B_IMG && ref==0);
int height = img->height;/*lgp*/
//===== set function for getting reference picture lines =====
if ((center_x > search_range) && (center_x < img->width -1-search_range-blocksize_x) &&
(center_y > search_range) && (center_y < height-1-search_range-blocksize_y) )
{
get_ref_line = FastLineX; //add by wuzhongmou 0610
}
else //add by wuzhongmou 0610
{
get_ref_line = UMVLineX;
}
//===== loop over all search positions =====
for (pos=0; pos<max_pos; pos++)
{
//--- set candidate position (absolute position in pel units) ---
cand_x = center_x + spiral_search_x[pos];
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -