?? mv-search.c
字號:
(pic4_pix_y + *mv_y > 0) && (pic4_pix_y + *mv_y < max_pos_y4) )
{
get_line = FastLine4X;
}
else
{
get_line = UMVLine4X;
}
//===== loop over search positions =====
for (best_pos = 0, pos = qpelstart; pos < search_pos4; pos++)
{
cand_mv_x = *mv_x + spiral_search_x[pos]; // quarter-pel units
cand_mv_y = *mv_y + spiral_search_y[pos]; // quarter-pel units
//----- set motion vector cost -----
mcost = MV_COST (lambda_factor, 0, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);
if (mcost >= min_mcost) continue;
cmv_x = cand_mv_x + pic4_pix_x;
cmv_y = cand_mv_y + pic4_pix_y;
//----- add up SATD -----
for (y0=0, abort_search=0; y0<blocksize_y && !abort_search; y0+=4)
{
y_offset = (y0>7)*ypels;
ry0 = (y0<<2) + cmv_y;
ry4 = ry0 + 4;
ry8 = ry4 + 4;
ry12 = ry8 + 4;
y1 = y0 + 1;
y2 = y1 + 1;
y3 = y2 + 1;
for (x0=0; x0<blocksize_x; x0+=BLOCK_SIZE)
{
rx0 = (x0<<2) + cmv_x;
d = diff;
orig_line = &orig_pic [y0][x0];
ref_line = get_line (ref_pic, ry0, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y1][x0];
ref_line = get_line (ref_pic, ry4, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y2][x0];
ref_line = get_line (ref_pic, ry8, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y3][x0];
ref_line = get_line (ref_pic, ry12, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d = *orig_line - *(ref_line += 4);
if (!test8x8transform)
{
if ((mcost += SATD (diff, input->hadamard)) > min_mcost)
{
abort_search = 1;
break;
}
}
else
{
i = (x0&0x7) + (x0>7) * 64 + y_offset;
for(k=0, j=y0; j<y0 + BLOCK_SIZE; j++, k+=BLOCK_SIZE)
memcpy(&(c_diff[i + ((j&0x7)<<3)]), &diff[k], BLOCK_SIZE*sizeof(int));
}
}
}
if(test8x8transform)
mcost += find_SATD (c_diff, blocktype);
if (mcost < min_mcost)
{
min_mcost = mcost;
best_pos = pos;
}
}
if (best_pos)
{
*mv_x += spiral_search_x [best_pos];
*mv_y += spiral_search_y [best_pos];
}
//===== return minimum motion cost =====
return min_mcost;
}
/*!
***********************************************************************
* \brief
* Sub pixel block motion search enhanced
***********************************************************************
*/
int // ==> minimum motion cost after search
simplified_FastFullSubPelBlockMotionSearch (pel_t** orig_pic, // <-- original pixel values for the AxB block
short ref, // <-- reference frame (0... or -1 (backward))
int list, // <-- reference picture list
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
short* mv_x, // <--> in: search center (x) / out: motion vector (x) - in pel units
short* mv_y, // <--> in: search center (y) / out: motion vector (y) - in pel units
int search_pos2, // <-- search positions for half-pel search (default: 9)
int search_pos4, // <-- search positions for quarter-pel search (default: 9)
int min_mcost, // <-- minimum motion cost (cost for center or huge value)
int lambda_factor // <-- lagrangian parameter for determining motion cost
)
{
int j, i, k;
int c_diff[MB_PIXELS];
int diff[16], *d;
int pos, best_pos, mcost, abort_search;
int y0, y1, y2, y3;
int x0;
int ry0, ry4, ry8, ry12, rx0;
int cand_mv_x, cand_mv_y;
int y_offset, ypels =(128 - 64 * (blocktype == 3));
int check_position0 = (!input->rdopt && img->type!=B_SLICE && ref==0 && blocktype==1 && *mv_x==0 && *mv_y==0 && input->hadamard);
int blocksize_x = input->blc_size[blocktype][0];
int blocksize_y = input->blc_size[blocktype][1];
int pic4_pix_x = ((pic_pix_x + IMG_PAD_SIZE)<< 2);
int pic4_pix_y = ((pic_pix_y + IMG_PAD_SIZE)<< 2);
int min_pos2 = (input->hadamard == 1 ? 0 : 1);
int max_pos2 = (input->hadamard ? max(1,search_pos2) : search_pos2);
int list_offset = img->mb_data[img->current_mb_nr].list_offset;
int apply_weights = ((active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
(active_pps->weighted_bipred_idc && (img->type == B_SLICE)));
int halfpelhadamard = input->hadamard == 2 ? 0 : input->hadamard;
int qpelstart = input->hadamard == 2 ? 0 : 1;
int test8x8transform = input->Transform8x8Mode && blocktype <= 4 && halfpelhadamard;
int cmv_x, cmv_y;
StorablePicture *ref_picture = listX[list+list_offset][ref];
pel_t **ref_pic = (apply_weights && input->UseWeightedReferenceME)? ref_picture->imgY_ups_w : ref_picture->imgY_ups;
pel_t *ref_line;
pel_t *orig_line;
int img_width = ((ref_picture->size_x + 2*IMG_PAD_SIZE - 1)<<2);
int img_height = ((ref_picture->size_y + 2*IMG_PAD_SIZE - 1)<<2);
int max_pos_x4 = ((ref_picture->size_x - blocksize_x + 2*IMG_PAD_SIZE)<<2);
int max_pos_y4 = ((ref_picture->size_y - blocksize_y + 2*IMG_PAD_SIZE)<<2);
/*********************************
***** *****
***** HALF-PEL REFINEMENT *****
***** *****
*********************************/
//===== set function for getting pixel values =====
if ((pic4_pix_x + *mv_x > 1) && (pic4_pix_x + *mv_x < max_pos_x4 - 1) &&
(pic4_pix_y + *mv_y > 1) && (pic4_pix_y + *mv_y < max_pos_y4 - 1) )
{
get_line = FastLine4X;
}
else
{
get_line = UMVLine4X;
}
//===== loop over search positions =====
for (best_pos = 0, pos = min_pos2; pos < max_pos2; pos++)
{
cand_mv_x = *mv_x + (spiral_hpel_search_x[pos]); // quarter-pel units
cand_mv_y = *mv_y + (spiral_hpel_search_y[pos]); // quarter-pel units
//----- set motion vector cost -----
mcost = MV_COST (lambda_factor, 0, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);
if (check_position0 && pos==0)
{
mcost -= WEIGHTED_COST (lambda_factor, 16);
}
if (mcost >= min_mcost) continue;
cmv_x = cand_mv_x + pic4_pix_x;
cmv_y = cand_mv_y + pic4_pix_y;
//----- add up SATD -----
for (y0=0, abort_search=0; y0<blocksize_y && !abort_search; y0+=4)
{
y_offset = (y0>7)*ypels;
ry0 = (y0<<2) + cmv_y;
ry4 = ry0 + 4;
ry8 = ry4 + 4;
ry12 = ry8 + 4;
y1 = y0 + 1;
y2 = y1 + 1;
y3 = y2 + 1;
for (x0=0; x0<blocksize_x; x0+=BLOCK_SIZE)
{
rx0 = (x0<<2) + cmv_x;
d = diff;
orig_line = &orig_pic [y0][x0];
ref_line = get_line (ref_pic, ry0, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y1][x0];
ref_line = get_line (ref_pic, ry4, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y2][x0];
ref_line = get_line (ref_pic, ry8, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y3][x0];
ref_line = get_line (ref_pic, ry12, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
if (!test8x8transform)
{
if ((mcost += SATD (diff, halfpelhadamard)) >= min_mcost)
{
abort_search = 1;
break;
}
}
else
{
i = (x0&0x7) + (x0>7) * 64 + y_offset;
for(k=0, j=y0; j<BLOCK_SIZE + y0; j++, k+=BLOCK_SIZE)
memcpy(&(c_diff[i + ((j&0x7)<<3)]), &diff[k], BLOCK_SIZE*sizeof(int));
}
}
}
if(test8x8transform)
mcost += find_SATD (c_diff, blocktype);
if (mcost < min_mcost)
{
min_mcost = mcost;
best_pos = pos;
}
if (min_mcost < (SubPelThreshold3>>block_type_shift_factor[blocktype]))
{
break;
}
}
if (best_pos)
{
*mv_x += (spiral_hpel_search_x [best_pos]);
*mv_y += (spiral_hpel_search_y [best_pos]);
}
if ((*mv_x == 0) && (*mv_y == 0) && (pred_mv_x == 0 && pred_mv_y == 0) &&
(min_mcost < (SubPelThreshold1>>block_type_shift_factor[blocktype])) )
{
best_pos = 0;
return min_mcost;
}
if (input->hadamard == 2)
min_mcost = INT_MAX;
test8x8transform = input->Transform8x8Mode && blocktype <= 4 && input->hadamard;
/************************************
***** *****
***** QUARTER-PEL REFINEMENT *****
***** *****
************************************/
//===== set function for getting pixel values =====
if ((pic4_pix_x + *mv_x > 0) && (pic4_pix_x + *mv_x < max_pos_x4) &&
(pic4_pix_y + *mv_y > 0) && (pic4_pix_y + *mv_y < max_pos_y4) )
{
get_line = FastLine4X;
}
else
{
get_line = UMVLine4X;
}
//===== loop over search positions =====
for (best_pos = 0, pos = qpelstart; pos < search_pos4; pos++)
{
cand_mv_x = *mv_x + spiral_search_x[pos]; // quarter-pel units
cand_mv_y = *mv_y + spiral_search_y[pos]; // quarter-pel units
//----- set motion vector cost -----
mcost = MV_COST (lambda_factor, 0, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);
if (mcost >= min_mcost) continue;
cmv_x = cand_mv_x + pic4_pix_x;
cmv_y = cand_mv_y + pic4_pix_y;
//----- add up SATD -----
for (y0=0, abort_search=0; y0<blocksize_y && !abort_search; y0+=4)
{
y_offset = (y0>7)*ypels;
ry0 = (y0<<2) + cmv_y;
ry4 = ry0 + 4;
ry8 = ry4 + 4;
ry12 = ry8 + 4;
y1 = y0 + 1;
y2 = y1 + 1;
y3 = y2 + 1;
for (x0=0; x0<blocksize_x; x0+=BLOCK_SIZE)
{
rx0 = (x0<<2) + cmv_x;
d = diff;
orig_line = &orig_pic [y0][x0];
ref_line = get_line (ref_pic, ry0, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y1][x0];
ref_line = get_line (ref_pic, ry4, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y2][x0];
ref_line = get_line (ref_pic, ry8, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line - *(ref_line += 4);
orig_line = &orig_pic [y3][x0];
ref_line = get_line (ref_pic, ry12, rx0, img_height, img_width);
*d++ = *orig_line++ - *(ref_line );
*d++ = *orig_line++ - *(ref_line += 4);
*d++ = *orig_line++ - *(ref_line += 4);
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -