📄 me_umhexsmp.c
字号:
/*!
*************************************************************************************
*
* \file me_umhexsmp.c
*
* \brief
* Fast integer pixel and sub pixel motion estimation
* Improved and simplified from the original UMHexagonS algorithms
* See JVT-P021 for details
*
* \author
* Main contributors: (see contributors.h for copyright, address and affiliation details)
* - Zhibo Chen <chenzhibo@tsinghua.org.cn>
* - JianFeng Xu <fenax@video.mdc.tsinghua.edu.cn>
* - Wenfang Fu <fwf@video.mdc.tsinghua.edu.cn>
*
* - Xiaoquan Yi <xyi@engr.scu.edu>
* - Jun Zhang <jzhang2@engr.scu.edu>
*
* \date
* 6. Nov. 2006
*************************************************************************************
*/
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "global.h"
#include "memalloc.h"
#include "me_umhexsmp.h"
#include "refbuf.h"
#include "me_distortion.h"
extern int *byte_abs;
extern int *mvbits;
static const short Diamond_X[4] = {-1, 1, 0, 0};
static const short Diamond_Y[4] = { 0, 0,-1, 1};
static const short Hexagon_X[6] = {-2, 2,-1, 1,-1, 1};
static const short Hexagon_Y[6] = { 0, 0,-2, 2, 2,-2};
static const short Big_Hexagon_X[16] = {-4, 4, 0, 0,-4, 4,-4, 4,-4, 4,-4, 4,-2, 2,-2, 2};
static const short Big_Hexagon_Y[16] = { 0, 0,-4, 4,-1, 1, 1,-1,-2, 2, 2,-2,-3, 3, 3,-3};
const short block_type_shift_factor[8] = {0, 0, 1, 1, 2, 3, 3, 1}; // last one relaxed to 1 instead 4
static StorablePicture *ref_pic_ptr;
static int dist_method;
extern short* spiral_hpel_search_x;
extern short* spiral_hpel_search_y;
extern short* spiral_search_x;
extern short* spiral_search_y;
// Macro for motion estimation cost computation per match
#define SEARCH_ONE_PIXEL_HELPER \
if(iabs(cand_x - center_x) <= search_range && iabs(cand_y - center_y) <= search_range) \
{ \
mcost = MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x, pred_y); \
mcost += computeUniPred[dist_method]( orig_pic, blocksize_y, blocksize_x, \
min_mcost - mcost, (cand_x + IMG_PAD_SIZE) << 2, (cand_y + IMG_PAD_SIZE) << 2); \
if (mcost < min_mcost) \
{ \
best_x = cand_x; \
best_y = cand_y; \
min_mcost = mcost; \
} \
}
#define SEARCH_ONE_PIXEL_BIPRED_HELPER \
if (iabs(cand_x - center2_x) <= search_range && iabs(cand_y - center2_y) <= search_range) \
{ \
mcost = MV_COST (lambda_factor, mvshift, center1_x, center1_y, pred_x1, pred_y1); \
mcost += MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x2, pred_y2); \
if (mcost < min_mcost) \
{ \
mcost += computeBiPred(cur_pic, blocksize_y, blocksize_x, \
min_mcost - mcost, \
(center1_x << 2) + IMG_PAD_SIZE_TIMES4, \
(center1_y << 2) + IMG_PAD_SIZE_TIMES4, \
(cand_x << 2) + IMG_PAD_SIZE_TIMES4, \
(cand_y << 2) + IMG_PAD_SIZE_TIMES4); \
if (mcost < min_mcost) \
{ \
best_x = cand_x; \
best_y = cand_y; \
min_mcost = mcost; \
} \
} \
}
/*!
************************************************************************
* \brief
* Set thresholds for fast motion estimation
* Those thresholds may be adjusted to trade off rate-distortion
* performance and simplified UMHEX speed
************************************************************************
*/
void smpUMHEX_init()
{
SymmetricalCrossSearchThreshold1 = 800;
SymmetricalCrossSearchThreshold2 = 7000;
ConvergeThreshold = 1000;
SubPelThreshold1 = 1000;
SubPelThreshold3 = 400;
}
/*!
************************************************************************
* \brief
* Allocation of space for fast motion estimation
************************************************************************
*/
int smpUMHEX_get_mem()
{
int memory_size = 0;
if (NULL==(smpUMHEX_flag_intra = calloc((img->width>>4)+1, sizeof(byte))))
no_mem_exit("smpUMHEX_get_mem: smpUMHEX_flag_intra");
memory_size += get_mem3Dint(&smpUMHEX_l0_cost, 9, img->height/4, img->width/4);
memory_size += get_mem3Dint(&smpUMHEX_l1_cost, 9, img->height/4, img->width/4);
memory_size += get_mem2D(&smpUMHEX_SearchState, 7, 7);
return memory_size;
}
/*!
************************************************************************
* \brief
* Free space for fast motion estimation
************************************************************************
*/
void smpUMHEX_free_mem()
{
free_mem3Dint(smpUMHEX_l0_cost, 9);
free_mem3Dint(smpUMHEX_l1_cost, 9);
free_mem2D(smpUMHEX_SearchState);
free (smpUMHEX_flag_intra);
}
/*!
************************************************************************
* \brief
* Fast integer pixel block motion estimation
************************************************************************
*/
int // ==> minimum motion cost after search
smpUMHEXIntegerPelBlockMotionSearch (
imgpel *orig_pic, // <-- not used
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)
short pred_mv_x, // <-- motion vector predictor (x) in sub-pel units
short pred_mv_y, // <-- motion vector predictor (y) in sub-pel units
short* mv_x, // --> motion vector (x) - in pel units
short* mv_y, // --> 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)
int lambda_factor) // <-- lagrangian parameter for determining motion cost
{
int list_offset = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))?
img->current_mb_nr%2 ? 4 : 2 : 0;
int mvshift = 2; // motion vector shift for getting sub-pel units
int blocksize_y = input->blc_size[blocktype][1]; // vertical block size
int blocksize_x = input->blc_size[blocktype][0]; // horizontal block size
int pred_x = (pic_pix_x << mvshift) + pred_mv_x; // predicted position x (in sub-pel units)
int pred_y = (pic_pix_y << mvshift) + 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 best_x = 0, best_y = 0;
int search_step, iYMinNow, iXMinNow;
int cand_x, cand_y, mcost;
unsigned short i, m;
//===== Use weighted Reference for ME ====
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))) && input->UseWeightedReferenceME;
dist_method = F_PEL + 3 * apply_weights;
ref_pic_ptr = listX[list+list_offset][ref];
// Note that following seem to be universal for all functions and could be moved to a separate, clean public function in me_distortion.c
ref_pic_sub.luma = ref_pic_ptr->curr_imgY_sub;
img_width = ref_pic_ptr->size_x;
img_height = ref_pic_ptr->size_y;
width_pad = ref_pic_ptr->size_x_pad;
height_pad = ref_pic_ptr->size_y_pad;
if (apply_weights)
{
weight_luma = wp_weight[list + list_offset][ref][0];
offset_luma = wp_offset[list + list_offset][ref][0];
}
if (ChromaMEEnable)
{
ref_pic_sub.crcb[0] = ref_pic_ptr->imgUV_sub[0];
ref_pic_sub.crcb[1] = ref_pic_ptr->imgUV_sub[1];
width_pad_cr = ref_pic_ptr->size_x_cr_pad;
height_pad_cr = ref_pic_ptr->size_y_cr_pad;
if (apply_weights)
{
weight_cr[0] = wp_weight[list + list_offset][ref][1];
weight_cr[1] = wp_weight[list + list_offset][ref][2];
offset_cr[0] = wp_offset[list + list_offset][ref][1];
offset_cr[1] = wp_offset[list + list_offset][ref][2];
}
}
//===== 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 < img_height - 1 - search_range - blocksize_y))
{
ref_access_method = FAST_ACCESS;
}
else
{
ref_access_method = UMV_ACCESS;
}
//check the center median predictor
cand_x = center_x ;
cand_y = center_y ;
mcost = MV_COST (lambda_factor, mvshift, cand_x, cand_y, pred_x, pred_y);
mcost += computeUniPred[dist_method](orig_pic, blocksize_y,blocksize_x, min_mcost - mcost,
(cand_x << 2) + IMG_PAD_SIZE_TIMES4, (cand_y << 2) + IMG_PAD_SIZE_TIMES4);
if (mcost < min_mcost)
{
min_mcost = mcost;
best_x = cand_x;
best_y = cand_y;
}
iXMinNow = best_x;
iYMinNow = best_y;
if ((0 != pred_mv_x) || (0 != pred_mv_y))
{
cand_x = pic_pix_x;
cand_y = pic_pix_y;
SEARCH_ONE_PIXEL_HELPER
}
// If the min_mcost is small enough, do a local search then terminate
// Ihis is good for stationary or quasi-stationary areas
if (min_mcost < (ConvergeThreshold>>block_type_shift_factor[blocktype]))
{
for (m = 0; m < 4; m++)
{
cand_x = iXMinNow + Diamond_X[m];
cand_y = iYMinNow + Diamond_Y[m];
SEARCH_ONE_PIXEL_HELPER
}
*mv_x = (short) (best_x - pic_pix_x);
*mv_y = (short) (best_y - pic_pix_y);
return min_mcost;
}
// Small local search
for (m = 0; m < 4; m++)
{
cand_x = iXMinNow + Diamond_X[m];
cand_y = iYMinNow + Diamond_Y[m];
SEARCH_ONE_PIXEL_HELPER
}
// First_step: Symmetrical-cross search
// If distortion is large, use large shapes. Otherwise, compact shapes are faster
if ( (blocktype == 1 &&
min_mcost > (SymmetricalCrossSearchThreshold1>>block_type_shift_factor[blocktype])) ||
(min_mcost > (SymmetricalCrossSearchThreshold2>>block_type_shift_factor[blocktype])) )
{
iXMinNow = best_x;
iYMinNow = best_y;
for(i = 1; i <= search_range/2; i++)
{
search_step = (i<<1) - 1;
cand_x = iXMinNow + search_step;
cand_y = iYMinNow;
SEARCH_ONE_PIXEL_HELPER
cand_x = iXMinNow - search_step;
SEARCH_ONE_PIXEL_HELPER
cand_x = iXMinNow;
cand_y = iYMinNow + search_step;
SEARCH_ONE_PIXEL_HELPER
cand_y = iYMinNow - search_step;
SEARCH_ONE_PIXEL_HELPER
}
// Hexagon Search
iXMinNow = best_x;
iYMinNow = best_y;
for (m = 0; m < 6; m++)
{
cand_x = iXMinNow + Hexagon_X[m];
cand_y = iYMinNow + Hexagon_Y[m];
SEARCH_ONE_PIXEL_HELPER
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -