generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote branch 'origin/master' into experimental

Browse Source 
Change-Id: Idf2dead51d2936984eb9827dd6d2cb704817f4c8
This commit is contained in:
John Koleszar 2011-05-13 00:05:14 -04:00
commit 71a0eaf33c
15 changed files with 579 additions and 573 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
vp8/common/blockd.h
View File

@ -140,11 +140,7 @@ typedef enum
typedef struct typedef struct
{ {
B_PREDICTION_MODE mode; B_PREDICTION_MODE mode;
union int_mv mv;
{
int as_int;
MV as_mv;
} mv;
} B_MODE_INFO; } B_MODE_INFO;
@ -161,11 +157,7 @@ typedef struct
{ {
MB_PREDICTION_MODE mode, uv_mode; MB_PREDICTION_MODE mode, uv_mode;
MV_REFERENCE_FRAME ref_frame; MV_REFERENCE_FRAME ref_frame;
union int_mv mv;
{
int as_int;
MV as_mv;
} mv;
unsigned char partitioning; unsigned char partitioning;
unsigned char mb_skip_coeff; /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */ unsigned char mb_skip_coeff; /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */

19
vp8/common/findnearmv.c
View File

@ -25,9 +25,9 @@ void vp8_find_near_mvs
( (
MACROBLOCKD *xd, MACROBLOCKD *xd,
const MODE_INFO *here, const MODE_INFO *here,
MV *nearest, int_mv *nearest,
MV *nearby, int_mv *nearby,
MV *best_mv, int_mv *best_mv,
int cnt[4], int cnt[4],
int refframe, int refframe,
int *ref_frame_sign_bias int *ref_frame_sign_bias
@ -131,13 +131,14 @@ void vp8_find_near_mvs
near_mvs[CNT_INTRA] = near_mvs[CNT_NEAREST]; near_mvs[CNT_INTRA] = near_mvs[CNT_NEAREST];
/* Set up return values */ /* Set up return values */
*best_mv = near_mvs[0].as_mv; best_mv->as_int = near_mvs[0].as_int;
*nearest = near_mvs[CNT_NEAREST].as_mv; nearest->as_int = near_mvs[CNT_NEAREST].as_int;
*nearby = near_mvs[CNT_NEAR].as_mv; nearby->as_int = near_mvs[CNT_NEAR].as_int;
vp8_clamp_mv(nearest, xd); //TODO: move clamp outside findnearmv
vp8_clamp_mv(nearby, xd); vp8_clamp_mv2(nearest, xd);
vp8_clamp_mv(best_mv, xd); /*TODO: move this up before the copy*/ vp8_clamp_mv2(nearby, xd);
vp8_clamp_mv2(best_mv, xd);
} }
vp8_prob *vp8_mv_ref_probs( vp8_prob *vp8_mv_ref_probs(

49
vp8/common/findnearmv.h
View File

@ -17,11 +17,6 @@
#include "modecont.h" #include "modecont.h"
#include "treecoder.h" #include "treecoder.h"
typedef union
{
unsigned int as_int;
MV as_mv;
} int_mv; /* facilitates rapid equality tests */
static void mv_bias(int refmb_ref_frame_sign_bias, int refframe, int_mv *mvp, const int *ref_frame_sign_bias) static void mv_bias(int refmb_ref_frame_sign_bias, int refframe, int_mv *mvp, const int *ref_frame_sign_bias)
{ {
@ -39,24 +34,48 @@ static void mv_bias(int refmb_ref_frame_sign_bias, int refframe, int_mv *mvp, co
#define LEFT_TOP_MARGIN (16 << 3) #define LEFT_TOP_MARGIN (16 << 3)
#define RIGHT_BOTTOM_MARGIN (16 << 3) #define RIGHT_BOTTOM_MARGIN (16 << 3)
static void vp8_clamp_mv(MV *mv, const MACROBLOCKD *xd) static void vp8_clamp_mv2(int_mv *mv, const MACROBLOCKD *xd)
{ {
if (mv->col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN)) if (mv->as_mv.col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
mv->col = xd->mb_to_left_edge - LEFT_TOP_MARGIN; mv->as_mv.col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
else if (mv->col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN) else if (mv->as_mv.col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
mv->col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN; mv->as_mv.col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
if (mv->row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN)) if (mv->as_mv.row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
mv->row = xd->mb_to_top_edge - LEFT_TOP_MARGIN; mv->as_mv.row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
else if (mv->row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN) else if (mv->as_mv.row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
mv->row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN; mv->as_mv.row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
}
static void vp8_clamp_mv(int_mv *mv, int mb_to_left_edge, int mb_to_right_edge,
int mb_to_top_edge, int mb_to_bottom_edge)
{
mv->as_mv.col = (mv->as_mv.col < mb_to_left_edge) ?
mb_to_left_edge : mv->as_mv.col;
mv->as_mv.col = (mv->as_mv.col > mb_to_right_edge) ?
mb_to_right_edge : mv->as_mv.col;
mv->as_mv.row = (mv->as_mv.row < mb_to_top_edge) ?
mb_to_top_edge : mv->as_mv.row;
mv->as_mv.row = (mv->as_mv.row > mb_to_bottom_edge) ?
mb_to_bottom_edge : mv->as_mv.row;
}
static unsigned int vp8_check_mv_bounds(int_mv *mv, int mb_to_left_edge,
int mb_to_right_edge, int mb_to_top_edge,
int mb_to_bottom_edge)
{
unsigned int need_to_clamp;
need_to_clamp = (mv->as_mv.col < mb_to_left_edge) ? 1 : 0;
need_to_clamp |= (mv->as_mv.col > mb_to_right_edge) ? 1 : 0;
need_to_clamp |= (mv->as_mv.row < mb_to_top_edge) ? 1 : 0;
need_to_clamp |= (mv->as_mv.row > mb_to_bottom_edge) ? 1 : 0;
return need_to_clamp;
} }
void vp8_find_near_mvs void vp8_find_near_mvs
( (
MACROBLOCKD *xd, MACROBLOCKD *xd,
const MODE_INFO *here, const MODE_INFO *here,
MV *nearest, MV *nearby, MV *best, int_mv *nearest, int_mv *nearby, int_mv *best,
int near_mv_ref_cts[4], int near_mv_ref_cts[4],
int refframe, int refframe,
int *ref_frame_sign_bias int *ref_frame_sign_bias

7
vp8/common/mv.h
View File

@ -11,6 +11,7 @@
#ifndef __INC_MV_H #ifndef __INC_MV_H
#define __INC_MV_H #define __INC_MV_H
#include "vpx/vpx_integer.h"
typedef struct typedef struct
{ {
@ -18,4 +19,10 @@ typedef struct
short col; short col;
} MV; } MV;
typedef union
{
uint32_t as_int;
MV as_mv;
} int_mv; /* facilitates faster equality tests and copies */
#endif #endif

104
vp8/decoder/decodemv.c
View File

@ -283,12 +283,11 @@ static void mb_mode_mv_init(VP8D_COMP *pbi)
static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
int mb_row, int mb_col) int mb_row, int mb_col)
{ {
const MV Zero = { 0, 0};
vp8_reader *const bc = & pbi->bc; vp8_reader *const bc = & pbi->bc;
MV_CONTEXT *const mvc = pbi->common.fc.mvc; MV_CONTEXT *const mvc = pbi->common.fc.mvc;
const int mis = pbi->common.mode_info_stride; const int mis = pbi->common.mode_info_stride;
MV *const mv = & mbmi->mv.as_mv; int_mv *const mv = & mbmi->mv;
int mb_to_left_edge; int mb_to_left_edge;
int mb_to_right_edge; int mb_to_right_edge;
int mb_to_top_edge; int mb_to_top_edge;
@ -325,7 +324,7 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
{ {
int rct[4]; int rct[4];
vp8_prob mv_ref_p [VP8_MVREFS-1]; vp8_prob mv_ref_p [VP8_MVREFS-1];
MV nearest, nearby, best_mv; int_mv nearest, nearby, best_mv;
if (vp8_read(bc, pbi->prob_last)) if (vp8_read(bc, pbi->prob_last))
{ {
@ -349,8 +348,6 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
do /* for each subset j */ do /* for each subset j */
{ {
B_MODE_INFO bmi; B_MODE_INFO bmi;
MV *const mv = & bmi.mv.as_mv;
int k; /* first block in subset j */ int k; /* first block in subset j */
int mv_contz; int mv_contz;
k = vp8_mbsplit_offset[s][j]; k = vp8_mbsplit_offset[s][j];
@ -360,27 +357,27 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
switch (bmi.mode = (B_PREDICTION_MODE) sub_mv_ref(bc, vp8_sub_mv_ref_prob2 [mv_contz])) /*pc->fc.sub_mv_ref_prob))*/ switch (bmi.mode = (B_PREDICTION_MODE) sub_mv_ref(bc, vp8_sub_mv_ref_prob2 [mv_contz])) /*pc->fc.sub_mv_ref_prob))*/
{ {
case NEW4X4: case NEW4X4:
read_mv(bc, mv, (const MV_CONTEXT *) mvc); read_mv(bc, &bmi.mv.as_mv, (const MV_CONTEXT *) mvc);
mv->row += best_mv.row; bmi.mv.as_mv.row += best_mv.as_mv.row;
mv->col += best_mv.col; bmi.mv.as_mv.col += best_mv.as_mv.col;
#ifdef VPX_MODE_COUNT #ifdef VPX_MODE_COUNT
vp8_mv_cont_count[mv_contz][3]++; vp8_mv_cont_count[mv_contz][3]++;
#endif #endif
break; break;
case LEFT4X4: case LEFT4X4:
*mv = vp8_left_bmi(mi, k)->mv.as_mv; bmi.mv.as_int = vp8_left_bmi(mi, k)->mv.as_int;
#ifdef VPX_MODE_COUNT #ifdef VPX_MODE_COUNT
vp8_mv_cont_count[mv_contz][0]++; vp8_mv_cont_count[mv_contz][0]++;
#endif #endif
break; break;
case ABOVE4X4: case ABOVE4X4:
*mv = vp8_above_bmi(mi, k, mis)->mv.as_mv; bmi.mv.as_int = vp8_above_bmi(mi, k, mis)->mv.as_int;
#ifdef VPX_MODE_COUNT #ifdef VPX_MODE_COUNT
vp8_mv_cont_count[mv_contz][1]++; vp8_mv_cont_count[mv_contz][1]++;
#endif #endif
break; break;
case ZERO4X4: case ZERO4X4:
*mv = Zero; bmi.mv.as_int = 0;
#ifdef VPX_MODE_COUNT #ifdef VPX_MODE_COUNT
vp8_mv_cont_count[mv_contz][2]++; vp8_mv_cont_count[mv_contz][2]++;
#endif #endif
@ -389,10 +386,11 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
break; break;
} }
mbmi->need_to_clamp_mvs |= (mv->col < mb_to_left_edge) ? 1 : 0; mbmi->need_to_clamp_mvs = vp8_check_mv_bounds(&bmi.mv,
mbmi->need_to_clamp_mvs |= (mv->col > mb_to_right_edge) ? 1 : 0; mb_to_left_edge,
mbmi->need_to_clamp_mvs |= (mv->row < mb_to_top_edge) ? 1 : 0; mb_to_right_edge,
mbmi->need_to_clamp_mvs |= (mv->row > mb_to_bottom_edge) ? 1 : 0; mb_to_top_edge,
mb_to_bottom_edge);
{ {
/* Fill (uniform) modes, mvs of jth subset. /* Fill (uniform) modes, mvs of jth subset.
@ -414,72 +412,62 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
while (++j < num_p); while (++j < num_p);
} }
*mv = mi->bmi[15].mv.as_mv; mv->as_int = mi->bmi[15].mv.as_int;
break; /* done with SPLITMV */ break; /* done with SPLITMV */
case NEARMV: case NEARMV:
*mv = nearby; mv->as_int = nearby.as_int;
/* Clip "next_nearest" so that it does not extend to far out of image */ /* Clip "next_nearest" so that it does not extend to far out of image */
mv->col = (mv->col < mb_to_left_edge) ? mb_to_left_edge : mv->col; vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
mv->col = (mv->col > mb_to_right_edge) ? mb_to_right_edge : mv->col; mb_to_top_edge, mb_to_bottom_edge);
mv->row = (mv->row < mb_to_top_edge) ? mb_to_top_edge : mv->row;
mv->row = (mv->row > mb_to_bottom_edge) ? mb_to_bottom_edge : mv->row;
goto propagate_mv; goto propagate_mv;
case NEARESTMV: case NEARESTMV:
*mv = nearest; mv->as_int = nearest.as_int;
/* Clip "next_nearest" so that it does not extend to far out of image */ /* Clip "next_nearest" so that it does not extend to far out of image */
mv->col = (mv->col < mb_to_left_edge) ? mb_to_left_edge : mv->col; vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
mv->col = (mv->col > mb_to_right_edge) ? mb_to_right_edge : mv->col; mb_to_top_edge, mb_to_bottom_edge);
mv->row = (mv->row < mb_to_top_edge) ? mb_to_top_edge : mv->row;
mv->row = (mv->row > mb_to_bottom_edge) ? mb_to_bottom_edge : mv->row;
goto propagate_mv; goto propagate_mv;
case ZEROMV: case ZEROMV:
*mv = Zero; mv->as_int = 0;
goto propagate_mv; goto propagate_mv;
case NEWMV: case NEWMV:
read_mv(bc, mv, (const MV_CONTEXT *) mvc); read_mv(bc, &mv->as_mv, (const MV_CONTEXT *) mvc);
mv->row += best_mv.row; mv->as_mv.row += best_mv.as_mv.row;
mv->col += best_mv.col; mv->as_mv.col += best_mv.as_mv.col;
/* Don't need to check this on NEARMV and NEARESTMV modes /* Don't need to check this on NEARMV and NEARESTMV modes
* since those modes clamp the MV. The NEWMV mode does not, * since those modes clamp the MV. The NEWMV mode does not,
* so signal to the prediction stage whether special * so signal to the prediction stage whether special
* handling may be required. * handling may be required.
*/ */
mbmi->need_to_clamp_mvs = (mv->col < mb_to_left_edge) ? 1 : 0; mbmi->need_to_clamp_mvs = vp8_check_mv_bounds(mv,
mbmi->need_to_clamp_mvs |= (mv->col > mb_to_right_edge) ? 1 : 0; mb_to_left_edge,
mbmi->need_to_clamp_mvs |= (mv->row < mb_to_top_edge) ? 1 : 0; mb_to_right_edge,
mbmi->need_to_clamp_mvs |= (mv->row > mb_to_bottom_edge) ? 1 : 0; mb_to_top_edge,
mb_to_bottom_edge);
propagate_mv: /* same MV throughout */ propagate_mv: /* same MV throughout */
{ {
/*int i=0; mi->bmi[ 0].mv.as_int =
do mi->bmi[ 1].mv.as_int =
{ mi->bmi[ 2].mv.as_int =
mi->bmi[i].mv.as_mv = *mv; mi->bmi[ 3].mv.as_int =
} mi->bmi[ 4].mv.as_int =
while( ++i < 16);*/ mi->bmi[ 5].mv.as_int =
mi->bmi[ 6].mv.as_int =
mi->bmi[0].mv.as_mv = *mv; mi->bmi[ 7].mv.as_int =
mi->bmi[1].mv.as_mv = *mv; mi->bmi[ 8].mv.as_int =
mi->bmi[2].mv.as_mv = *mv; mi->bmi[ 9].mv.as_int =
mi->bmi[3].mv.as_mv = *mv; mi->bmi[10].mv.as_int =
mi->bmi[4].mv.as_mv = *mv; mi->bmi[11].mv.as_int =
mi->bmi[5].mv.as_mv = *mv; mi->bmi[12].mv.as_int =
mi->bmi[6].mv.as_mv = *mv; mi->bmi[13].mv.as_int =
mi->bmi[7].mv.as_mv = *mv; mi->bmi[14].mv.as_int =
mi->bmi[8].mv.as_mv = *mv; mi->bmi[15].mv.as_int = mv->as_int;
mi->bmi[9].mv.as_mv = *mv;
mi->bmi[10].mv.as_mv = *mv;
mi->bmi[11].mv.as_mv = *mv;
mi->bmi[12].mv.as_mv = *mv;
mi->bmi[13].mv.as_mv = *mv;
mi->bmi[14].mv.as_mv = *mv;
mi->bmi[15].mv.as_mv = *mv;
} }
break; break;
default:; default:;
@ -494,7 +482,7 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
int j = 0; int j = 0;
do do
{ {
mi->bmi[j].mv.as_mv = Zero; mi->bmi[j].mv.as_int = 0;
} }
while (++j < 16); while (++j < 16);

10
vp8/encoder/bitstream.c
View File

@ -799,12 +799,12 @@ static void write_sub_mv_ref
static void write_mv static void write_mv
( (
vp8_writer *w, const MV *mv, const MV *ref, const MV_CONTEXT *mvc vp8_writer *w, const MV *mv, const int_mv *ref, const MV_CONTEXT *mvc
) )
{ {
MV e; MV e;
e.row = mv->row - ref->row; e.row = mv->row - ref->as_mv.row;
e.col = mv->col - ref->col; e.col = mv->col - ref->as_mv.col;
vp8_encode_motion_vector(w, &e, mvc); vp8_encode_motion_vector(w, &e, mvc);
} }
@ -957,7 +957,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi)
} }
else /* inter coded */ else /* inter coded */
{ {
MV best_mv; int_mv best_mv;
vp8_prob mv_ref_p [VP8_MVREFS-1]; vp8_prob mv_ref_p [VP8_MVREFS-1];
vp8_write(w, 1, cpi->prob_intra_coded); vp8_write(w, 1, cpi->prob_intra_coded);
@ -971,7 +971,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi)
} }
{ {
MV n1, n2; int_mv n1, n2;
int ct[4]; int ct[4];
vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, cpi->common.ref_frame_sign_bias); vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, cpi->common.ref_frame_sign_bias);

12
vp8/encoder/encodeframe.c
View File

@ -1342,8 +1342,8 @@ int vp8cx_encode_inter_macroblock
} }
else else
{ {
MV best_ref_mv; int_mv best_ref_mv;
MV nearest, nearby; int_mv nearest, nearby;
int mdcounts[4]; int mdcounts[4];
int ref_fb_idx; int ref_fb_idx;
@ -1371,15 +1371,15 @@ int vp8cx_encode_inter_macroblock
{ {
if (xd->block[i].bmi.mode == NEW4X4) if (xd->block[i].bmi.mode == NEW4X4)
{ {
cpi->MVcount[0][mv_max+((xd->block[i].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++; cpi->MVcount[0][mv_max+((xd->block[i].bmi.mv.as_mv.row - best_ref_mv.as_mv.row) >> 1)]++;
cpi->MVcount[1][mv_max+((xd->block[i].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++; cpi->MVcount[1][mv_max+((xd->block[i].bmi.mv.as_mv.col - best_ref_mv.as_mv.col) >> 1)]++;
} }
} }
} }
else if (xd->mode_info_context->mbmi.mode == NEWMV) else if (xd->mode_info_context->mbmi.mode == NEWMV)
{ {
cpi->MVcount[0][mv_max+((xd->block[0].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++; cpi->MVcount[0][mv_max+((xd->block[0].bmi.mv.as_mv.row - best_ref_mv.as_mv.row) >> 1)]++;
cpi->MVcount[1][mv_max+((xd->block[0].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++; cpi->MVcount[1][mv_max+((xd->block[0].bmi.mv.as_mv.col - best_ref_mv.as_mv.col) >> 1)]++;
} }
if (!x->skip) if (!x->skip)

26
vp8/encoder/firstpass.c
View File

@ -39,7 +39,7 @@
extern void vp8_build_block_offsets(MACROBLOCK *x); extern void vp8_build_block_offsets(MACROBLOCK *x);
extern void vp8_setup_block_ptrs(MACROBLOCK *x); extern void vp8_setup_block_ptrs(MACROBLOCK *x);
extern void vp8cx_frame_init_quantizer(VP8_COMP *cpi); extern void vp8cx_frame_init_quantizer(VP8_COMP *cpi);
extern void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, MV *mv); extern void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv);
extern void vp8_alloc_compressor_data(VP8_COMP *cpi); extern void vp8_alloc_compressor_data(VP8_COMP *cpi);
//#define GFQ_ADJUSTMENT (40 + ((15*Q)/10)) //#define GFQ_ADJUSTMENT (40 + ((15*Q)/10))
@ -423,14 +423,17 @@ static void zz_motion_search( VP8_COMP *cpi, MACROBLOCK * x, YV12_BUFFER_CONFIG
VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16) ( src_ptr, src_stride, ref_ptr, ref_stride, (unsigned int *)(best_motion_err)); VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16) ( src_ptr, src_stride, ref_ptr, ref_stride, (unsigned int *)(best_motion_err));
} }
static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x, MV *ref_mv, MV *best_mv, YV12_BUFFER_CONFIG *recon_buffer, int *best_motion_err, int recon_yoffset ) static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x,
int_mv *ref_mv, MV *best_mv,
YV12_BUFFER_CONFIG *recon_buffer,
int *best_motion_err, int recon_yoffset )
{ {
MACROBLOCKD *const xd = & x->e_mbd; MACROBLOCKD *const xd = & x->e_mbd;
BLOCK *b = &x->block[0]; BLOCK *b = &x->block[0];
BLOCKD *d = &x->e_mbd.block[0]; BLOCKD *d = &x->e_mbd.block[0];
int num00; int num00;
MV tmp_mv = {0, 0}; int_mv tmp_mv;
int tmp_err; int tmp_err;
int step_param = 3; //3; // Dont search over full range for first pass int step_param = 3; //3; // Dont search over full range for first pass
@ -446,6 +449,7 @@ static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x, MV *ref_mv, M
xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset; xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
// Initial step/diamond search centred on best mv // Initial step/diamond search centred on best mv
tmp_mv.as_int = 0;
tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv, step_param, x->errorperbit, &num00, &v_fn_ptr, x->mvcost, ref_mv); tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv, step_param, x->errorperbit, &num00, &v_fn_ptr, x->mvcost, ref_mv);
if ( tmp_err < INT_MAX-new_mv_mode_penalty ) if ( tmp_err < INT_MAX-new_mv_mode_penalty )
tmp_err += new_mv_mode_penalty; tmp_err += new_mv_mode_penalty;
@ -453,8 +457,8 @@ static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x, MV *ref_mv, M
if (tmp_err < *best_motion_err) if (tmp_err < *best_motion_err)
{ {
*best_motion_err = tmp_err; *best_motion_err = tmp_err;
best_mv->row = tmp_mv.row; best_mv->row = tmp_mv.as_mv.row;
best_mv->col = tmp_mv.col; best_mv->col = tmp_mv.as_mv.col;
} }
// Further step/diamond searches as necessary // Further step/diamond searches as necessary
@ -476,8 +480,8 @@ static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x, MV *ref_mv, M
if (tmp_err < *best_motion_err) if (tmp_err < *best_motion_err)
{ {
*best_motion_err = tmp_err; *best_motion_err = tmp_err;
best_mv->row = tmp_mv.row; best_mv->row = tmp_mv.as_mv.row;
best_mv->col = tmp_mv.col; best_mv->col = tmp_mv.as_mv.col;
} }
} }
} }
@ -510,7 +514,9 @@ void vp8_first_pass(VP8_COMP *cpi)
int sum_in_vectors = 0; int sum_in_vectors = 0;
MV zero_ref_mv = {0, 0}; int_mv zero_ref_mv;
zero_ref_mv.as_int = 0;
vp8_clear_system_state(); //__asm emms; vp8_clear_system_state(); //__asm emms;
@ -602,7 +608,7 @@ void vp8_first_pass(VP8_COMP *cpi)
// Test last reference frame using the previous best mv as the // Test last reference frame using the previous best mv as the
// starting point (best reference) for the search // starting point (best reference) for the search
first_pass_motion_search(cpi, x, &best_ref_mv.as_mv, first_pass_motion_search(cpi, x, &best_ref_mv,
&d->bmi.mv.as_mv, lst_yv12, &d->bmi.mv.as_mv, lst_yv12,
&motion_error, recon_yoffset); &motion_error, recon_yoffset);
@ -666,7 +672,7 @@ void vp8_first_pass(VP8_COMP *cpi)
d->bmi.mv.as_mv.row <<= 3; d->bmi.mv.as_mv.row <<= 3;
d->bmi.mv.as_mv.col <<= 3; d->bmi.mv.as_mv.col <<= 3;
this_error = motion_error; this_error = motion_error;
vp8_set_mbmode_and_mvs(x, NEWMV, &d->bmi.mv.as_mv); vp8_set_mbmode_and_mvs(x, NEWMV, &d->bmi.mv);
vp8_encode_inter16x16y(IF_RTCD(&cpi->rtcd), x); vp8_encode_inter16x16y(IF_RTCD(&cpi->rtcd), x);
sum_mvr += d->bmi.mv.as_mv.row; sum_mvr += d->bmi.mv.as_mv.row;
sum_mvr_abs += abs(d->bmi.mv.as_mv.row); sum_mvr_abs += abs(d->bmi.mv.as_mv.row);

600
vp8/encoder/mcomp.c
View File

File diff suppressed because it is too large Load Diff

27
vp8/encoder/mcomp.h
View File

@ -26,7 +26,7 @@ extern void accum_mv_refs(MB_PREDICTION_MODE, const int near_mv_ref_cts[4]);
#define MAX_FIRST_STEP (1 << (MAX_MVSEARCH_STEPS-1)) // Maximum size of the first step in full pel units #define MAX_FIRST_STEP (1 << (MAX_MVSEARCH_STEPS-1)) // Maximum size of the first step in full pel units
extern void print_mode_context(void); extern void print_mode_context(void);
extern int vp8_mv_bit_cost(MV *mv, MV *ref, int *mvcost[2], int Weight); extern int vp8_mv_bit_cost(int_mv *mv, int_mv *ref, int *mvcost[2], int Weight);
extern void vp8_init_dsmotion_compensation(MACROBLOCK *x, int stride); extern void vp8_init_dsmotion_compensation(MACROBLOCK *x, int stride);
extern void vp8_init3smotion_compensation(MACROBLOCK *x, int stride); extern void vp8_init3smotion_compensation(MACROBLOCK *x, int stride);
@ -36,20 +36,21 @@ extern int vp8_hex_search
MACROBLOCK *x, MACROBLOCK *x,
BLOCK *b, BLOCK *b,
BLOCKD *d, BLOCKD *d,
MV *ref_mv, int_mv *ref_mv,
MV *best_mv, int_mv *best_mv,
int search_param, int search_param,
int error_per_bit, int error_per_bit,
int *num00, int *num00,
const vp8_variance_fn_ptr_t *vf, const vp8_variance_fn_ptr_t *vf,
int *mvsadcost[2], int *mvsadcost[2],
int *mvcost[2], int *mvcost[2],
MV *center_mv int_mv *center_mv
); );
typedef int (fractional_mv_step_fp) typedef int (fractional_mv_step_fp)
(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv, MV *ref_mv, (MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *bestmv, int_mv *ref_mv,
int error_per_bit, const vp8_variance_fn_ptr_t *vfp, int *mvcost[2], int *distortion, unsigned int *sse); int error_per_bit, const vp8_variance_fn_ptr_t *vfp, int *mvcost[2],
int *distortion, unsigned int *sse);
extern fractional_mv_step_fp vp8_find_best_sub_pixel_step_iteratively; extern fractional_mv_step_fp vp8_find_best_sub_pixel_step_iteratively;
extern fractional_mv_step_fp vp8_find_best_sub_pixel_step; extern fractional_mv_step_fp vp8_find_best_sub_pixel_step;
extern fractional_mv_step_fp vp8_find_best_half_pixel_step; extern fractional_mv_step_fp vp8_find_best_half_pixel_step;
@ -61,12 +62,12 @@ extern fractional_mv_step_fp vp8_skip_fractional_mv_step;
MACROBLOCK *x, \ MACROBLOCK *x, \
BLOCK *b, \ BLOCK *b, \
BLOCKD *d, \ BLOCKD *d, \
MV *ref_mv, \ int_mv *ref_mv, \
int error_per_bit, \ int error_per_bit, \
int distance, \ int distance, \
vp8_variance_fn_ptr_t *fn_ptr, \ vp8_variance_fn_ptr_t *fn_ptr, \
int *mvcost[2], \ int *mvcost[2], \
MV *center_mv \ int_mv *center_mv \
) )
#define prototype_refining_search_sad(sym)\ #define prototype_refining_search_sad(sym)\
@ -75,12 +76,12 @@ extern fractional_mv_step_fp vp8_skip_fractional_mv_step;
MACROBLOCK *x, \ MACROBLOCK *x, \
BLOCK *b, \ BLOCK *b, \
BLOCKD *d, \ BLOCKD *d, \
MV *ref_mv, \ int_mv *ref_mv, \
int error_per_bit, \ int error_per_bit, \
int distance, \ int distance, \
vp8_variance_fn_ptr_t *fn_ptr, \ vp8_variance_fn_ptr_t *fn_ptr, \
int *mvcost[2], \ int *mvcost[2], \
MV *center_mv \ int_mv *center_mv \
) )
#define prototype_diamond_search_sad(sym)\ #define prototype_diamond_search_sad(sym)\
@ -89,14 +90,14 @@ extern fractional_mv_step_fp vp8_skip_fractional_mv_step;
MACROBLOCK *x, \ MACROBLOCK *x, \
BLOCK *b, \ BLOCK *b, \
BLOCKD *d, \ BLOCKD *d, \
MV *ref_mv, \ int_mv *ref_mv, \
MV *best_mv, \ int_mv *best_mv, \
int search_param, \ int search_param, \
int error_per_bit, \ int error_per_bit, \
int *num00, \ int *num00, \
vp8_variance_fn_ptr_t *fn_ptr, \ vp8_variance_fn_ptr_t *fn_ptr, \
int *mvcost[2], \ int *mvcost[2], \
MV *center_mv \ int_mv *center_mv \
) )
#if ARCH_X86 || ARCH_X86_64 #if ARCH_X86 || ARCH_X86_64

2
vp8/encoder/onyx_if.c
View File

@ -46,7 +46,6 @@
#define RTCD(x) NULL #define RTCD(x) NULL
#endif #endif
extern void vp8cx_init_mv_bits_sadcost();
extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi); extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val); extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi); extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
@ -300,7 +299,6 @@ void vp8_initialize()
//vp8_dmachine_specific_config(); //vp8_dmachine_specific_config();
vp8_tokenize_initialize(); vp8_tokenize_initialize();
vp8cx_init_mv_bits_sadcost();
init_done = 1; init_done = 1;
} }
} }

89
vp8/encoder/pickinter.c
View File

@ -47,10 +47,15 @@ extern unsigned int (*vp8_get16x16pred_error)(unsigned char *src_ptr, int src_st
extern unsigned int (*vp8_get4x4sse_cs)(unsigned char *src_ptr, int source_stride, unsigned char *ref_ptr, int recon_stride); extern unsigned int (*vp8_get4x4sse_cs)(unsigned char *src_ptr, int source_stride, unsigned char *ref_ptr, int recon_stride);
extern int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x, MV *best_ref_mv, int best_rd, int *, int *, int *, int, int *mvcost[2], int, int fullpixel); extern int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x, MV *best_ref_mv, int best_rd, int *, int *, int *, int, int *mvcost[2], int, int fullpixel);
extern int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]); extern int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]);
extern void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, MV *mv); extern void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv);
int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestmv, MV *ref_mv, int error_per_bit, const vp8_variance_fn_ptr_t *vfp, int *mvcost[2], int *distortion, unsigned int *sse) int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d,
int_mv *bestmv, int_mv *ref_mv,
int error_per_bit,
const vp8_variance_fn_ptr_t *vfp,
int *mvcost[2], int *distortion,
unsigned int *sse)
{ {
(void) b; (void) b;
(void) d; (void) d;
@ -60,8 +65,8 @@ int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestmv,
(void) mvcost; (void) mvcost;
(void) distortion; (void) distortion;
(void) sse; (void) sse;
bestmv->row <<= 3; bestmv->as_mv.row <<= 3;
bestmv->col <<= 3; bestmv->as_mv.col <<= 3;
return 0; return 0;
} }
@ -429,8 +434,8 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
B_MODE_INFO best_bmodes[16]; B_MODE_INFO best_bmodes[16];
MB_MODE_INFO best_mbmode; MB_MODE_INFO best_mbmode;
PARTITION_INFO best_partition; PARTITION_INFO best_partition;
MV best_ref_mv; int_mv best_ref_mv;
MV mode_mv[MB_MODE_COUNT]; int_mv mode_mv[MB_MODE_COUNT];
MB_PREDICTION_MODE this_mode; MB_PREDICTION_MODE this_mode;
int num00; int num00;
int i; int i;
@ -447,14 +452,14 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
int best_mode_index = 0; int best_mode_index = 0;
unsigned int sse = INT_MAX; unsigned int sse = INT_MAX;
MV mvp; int_mv mvp;
int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7}; int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
int saddone=0; int saddone=0;
int sr=0; //search range got from mv_pred(). It uses step_param levels. (0-7) int sr=0; //search range got from mv_pred(). It uses step_param levels. (0-7)
MV nearest_mv[4]; int_mv nearest_mv[4];
MV near_mv[4]; int_mv near_mv[4];
MV frame_best_ref_mv[4]; int_mv frame_best_ref_mv[4];
int MDCounts[4][4]; int MDCounts[4][4];
unsigned char *y_buffer[4]; unsigned char *y_buffer[4];
unsigned char *u_buffer[4]; unsigned char *u_buffer[4];
@ -631,14 +636,11 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
x->e_mbd.mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]); x->e_mbd.mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]);
/* adjust mvp to make sure it is within MV range */ /* adjust mvp to make sure it is within MV range */
if(mvp.row > best_ref_mv.row + MAX_FULL_PEL_VAL) vp8_clamp_mv(&mvp,
mvp.row = best_ref_mv.row + MAX_FULL_PEL_VAL; best_ref_mv.as_mv.row - MAX_FULL_PEL_VAL,
else if(mvp.row < best_ref_mv.row - MAX_FULL_PEL_VAL) best_ref_mv.as_mv.row + MAX_FULL_PEL_VAL,
mvp.row = best_ref_mv.row - MAX_FULL_PEL_VAL; best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL,
if(mvp.col > best_ref_mv.col + MAX_FULL_PEL_VAL) best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL);
mvp.col = best_ref_mv.col + MAX_FULL_PEL_VAL;
else if(mvp.col < best_ref_mv.col - MAX_FULL_PEL_VAL)
mvp.col = best_ref_mv.col - MAX_FULL_PEL_VAL;
} }
switch (this_mode) switch (this_mode)
@ -723,10 +725,10 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
if(sr > step_param) if(sr > step_param)
step_param = sr; step_param = sr;
col_min = (best_ref_mv.col - MAX_FULL_PEL_VAL) >>3; col_min = (best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL) >>3;
col_max = (best_ref_mv.col + MAX_FULL_PEL_VAL) >>3; col_max = (best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL) >>3;
row_min = (best_ref_mv.row - MAX_FULL_PEL_VAL) >>3; row_min = (best_ref_mv.as_mv.row - MAX_FULL_PEL_VAL) >>3;
row_max = (best_ref_mv.row + MAX_FULL_PEL_VAL) >>3; row_max = (best_ref_mv.as_mv.row + MAX_FULL_PEL_VAL) >>3;
// Get intersection of UMV window and valid MV window to reduce # of checks in diamond search. // Get intersection of UMV window and valid MV window to reduce # of checks in diamond search.
if (x->mv_col_min < col_min ) if (x->mv_col_min < col_min )
@ -739,23 +741,20 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
x->mv_row_max = row_max; x->mv_row_max = row_max;
}else }else
{ {
mvp.row = best_ref_mv.row; mvp.as_int = best_ref_mv.as_int;
mvp.col = best_ref_mv.col;
} }
further_steps = (cpi->Speed >= 8)? 0: (cpi->sf.max_step_search_steps - 1 - step_param); further_steps = (cpi->Speed >= 8)? 0: (cpi->sf.max_step_search_steps - 1 - step_param);
if (cpi->sf.search_method == HEX) if (cpi->sf.search_method == HEX)
{ {
bestsme = vp8_hex_search(x, b, d, &mvp, &d->bmi.mv.as_mv, step_param, sadpb/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvsadcost, x->mvcost, &best_ref_mv); bestsme = vp8_hex_search(x, b, d, &mvp, &d->bmi.mv, step_param, sadpb/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvsadcost, x->mvcost, &best_ref_mv);
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
} }
else else
{ {
bestsme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv.as_mv, step_param, sadpb / 2/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //sadpb < 9 bestsme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv, step_param, sadpb / 2/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //sadpb < 9
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
// Further step/diamond searches as necessary // Further step/diamond searches as necessary
n = 0; n = 0;
@ -772,18 +771,21 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
num00--; num00--;
else else
{ {
thissme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv.as_mv, step_param + n, sadpb / 4/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //sadpb = 9 thissme =
cpi->diamond_search_sad(x, b, d, &mvp,
&d->bmi.mv,
step_param + n,
sadpb / 4, &num00,
&cpi->fn_ptr[BLOCK_16X16],
x->mvcost, &best_ref_mv);
if (thissme < bestsme) if (thissme < bestsme)
{ {
bestsme = thissme; bestsme = thissme;
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
} }
else else
{ {
d->bmi.mv.as_mv.row = mode_mv[NEWMV].row; d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
} }
} }
} }
@ -798,10 +800,9 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
} }
if (bestsme < INT_MAX) if (bestsme < INT_MAX)
cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv.as_mv, &best_ref_mv, x->errorperbit, &cpi->fn_ptr[BLOCK_16X16], cpi->mb.mvcost, &distortion2, &sse); cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, &best_ref_mv, x->errorperbit, &cpi->fn_ptr[BLOCK_16X16], cpi->mb.mvcost, &distortion2, &sse);
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
// mv cost; // mv cost;
rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, cpi->mb.mvcost, 128); rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, cpi->mb.mvcost, 128);
@ -810,7 +811,7 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
case NEARESTMV: case NEARESTMV:
case NEARMV: case NEARMV:
if (mode_mv[this_mode].row == 0 && mode_mv[this_mode].col == 0) if (mode_mv[this_mode].as_int == 0)
continue; continue;
case ZEROMV: case ZEROMV:
@ -818,13 +819,13 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
// Trap vectors that reach beyond the UMV borders // Trap vectors that reach beyond the UMV borders
// Note that ALL New MV, Nearest MV Near MV and Zero MV code drops through to this point // Note that ALL New MV, Nearest MV Near MV and Zero MV code drops through to this point
// because of the lack of break statements in the previous two cases. // because of the lack of break statements in the previous two cases.
if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) || if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max)) ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
continue; continue;
rate2 += vp8_cost_mv_ref(this_mode, mdcounts); rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
x->e_mbd.mode_info_context->mbmi.mode = this_mode; x->e_mbd.mode_info_context->mbmi.mode = this_mode;
x->e_mbd.mode_info_context->mbmi.mv.as_mv = mode_mv[this_mode]; x->e_mbd.mode_info_context->mbmi.mv.as_mv = mode_mv[this_mode].as_mv;
x->e_mbd.block[0].bmi.mode = this_mode; x->e_mbd.block[0].bmi.mode = this_mode;
x->e_mbd.block[0].bmi.mv.as_int = x->e_mbd.mode_info_context->mbmi.mv.as_int; x->e_mbd.block[0].bmi.mv.as_int = x->e_mbd.mode_info_context->mbmi.mv.as_int;
@ -965,7 +966,7 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
} }
else else
{ {
vp8_set_mbmode_and_mvs(x, x->e_mbd.mode_info_context->mbmi.mode, &best_bmodes[0].mv.as_mv); vp8_set_mbmode_and_mvs(x, x->e_mbd.mode_info_context->mbmi.mode, &best_bmodes[0].mv);
} }
x->e_mbd.mode_info_context->mbmi.mv.as_mv = x->e_mbd.block[15].bmi.mv.as_mv; x->e_mbd.mode_info_context->mbmi.mv.as_mv = x->e_mbd.block[15].bmi.mv.as_mv;

183
vp8/encoder/rdopt.c
View File

@ -909,20 +909,18 @@ int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4])
vp8_mv_ref_encoding_array - NEARESTMV + m); vp8_mv_ref_encoding_array - NEARESTMV + m);
} }
void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, MV *mv) void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv)
{ {
int i; int i;
x->e_mbd.mode_info_context->mbmi.mode = mb; x->e_mbd.mode_info_context->mbmi.mode = mb;
x->e_mbd.mode_info_context->mbmi.mv.as_mv.row = mv->row; x->e_mbd.mode_info_context->mbmi.mv.as_int = mv->as_int;
x->e_mbd.mode_info_context->mbmi.mv.as_mv.col = mv->col;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
B_MODE_INFO *bmi = &x->e_mbd.block[i].bmi; B_MODE_INFO *bmi = &x->e_mbd.block[i].bmi;
bmi->mode = (B_PREDICTION_MODE) mb; bmi->mode = (B_PREDICTION_MODE) mb;
bmi->mv.as_mv.row = mv->row; bmi->mv.as_int = mv->as_int;
bmi->mv.as_mv.col = mv->col;
} }
} }
@ -930,7 +928,7 @@ static int labels2mode(
MACROBLOCK *x, MACROBLOCK *x,
int const *labelings, int which_label, int const *labelings, int which_label,
B_PREDICTION_MODE this_mode, B_PREDICTION_MODE this_mode,
MV *this_mv, MV *best_ref_mv, int_mv *this_mv, int_mv *best_ref_mv,
int *mvcost[2] int *mvcost[2]
) )
{ {
@ -971,13 +969,13 @@ static int labels2mode(
thismvcost = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102); thismvcost = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102);
break; break;
case LEFT4X4: case LEFT4X4:
*this_mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv; this_mv->as_int = col ? d[-1].bmi.mv.as_int : vp8_left_bmi(mic, i)->mv.as_int;
break; break;
case ABOVE4X4: case ABOVE4X4:
*this_mv = row ? d[-4].bmi.mv.as_mv : vp8_above_bmi(mic, i, mis)->mv.as_mv; this_mv->as_int = row ? d[-4].bmi.mv.as_int : vp8_above_bmi(mic, i, mis)->mv.as_int;
break; break;
case ZERO4X4: case ZERO4X4:
this_mv->row = this_mv->col = 0; this_mv->as_int = 0;
break; break;
default: default:
break; break;
@ -985,9 +983,11 @@ static int labels2mode(
if (m == ABOVE4X4) // replace above with left if same if (m == ABOVE4X4) // replace above with left if same
{ {
const MV mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv; int_mv left_mv;
left_mv.as_int = col ? d[-1].bmi.mv.as_int :
vp8_left_bmi(mic, i)->mv.as_int;
if (mv.row == this_mv->row && mv.col == this_mv->col) if (left_mv.as_int == this_mv->as_int)
m = LEFT4X4; m = LEFT4X4;
} }
@ -995,7 +995,7 @@ static int labels2mode(
} }
d->bmi.mode = m; d->bmi.mode = m;
d->bmi.mv.as_mv = *this_mv; d->bmi.mv.as_int = this_mv->as_int;
} }
while (++i < 16); while (++i < 16);
@ -1059,8 +1059,8 @@ static const unsigned int segmentation_to_sseshift[4] = {3, 3, 2, 0};
typedef struct typedef struct
{ {
MV *ref_mv; int_mv *ref_mv;
MV *mvp; int_mv mvp;
int segment_rd; int segment_rd;
int segment_num; int segment_num;
@ -1074,7 +1074,7 @@ typedef struct
int mvthresh; int mvthresh;
int *mdcounts; int *mdcounts;
MV sv_mvp[4]; // save 4 mvp from 8x8 int_mv sv_mvp[4]; // save 4 mvp from 8x8
int sv_istep[2]; // save 2 initial step_param for 16x8/8x16 int sv_istep[2]; // save 2 initial step_param for 16x8/8x16
} BEST_SEG_INFO; } BEST_SEG_INFO;
@ -1136,7 +1136,7 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
for (i = 0; i < label_count; i++) for (i = 0; i < label_count; i++)
{ {
MV mode_mv[B_MODE_COUNT]; int_mv mode_mv[B_MODE_COUNT];
int best_label_rd = INT_MAX; int best_label_rd = INT_MAX;
B_PREDICTION_MODE mode_selected = ZERO4X4; B_PREDICTION_MODE mode_selected = ZERO4X4;
int bestlabelyrate = 0; int bestlabelyrate = 0;
@ -1166,7 +1166,7 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
int n; int n;
int thissme; int thissme;
int bestsme = INT_MAX; int bestsme = INT_MAX;
MV temp_mv; int_mv temp_mv;
BLOCK *c; BLOCK *c;
BLOCKD *e; BLOCKD *e;
@ -1178,8 +1178,9 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
{ {
if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8) if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8)
{ {
bsi->mvp = &bsi->sv_mvp[i]; bsi->mvp.as_int = bsi->sv_mvp[i].as_int;
if (i==1 && segmentation == BLOCK_16X8) bsi->mvp = &bsi->sv_mvp[2]; if (i==1 && segmentation == BLOCK_16X8)
bsi->mvp.as_int = bsi->sv_mvp[2].as_int;
step_param = bsi->sv_istep[i]; step_param = bsi->sv_istep[i];
} }
@ -1187,8 +1188,9 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
// use previous block's result as next block's MV predictor. // use previous block's result as next block's MV predictor.
if (segmentation == BLOCK_4X4 && i>0) if (segmentation == BLOCK_4X4 && i>0)
{ {
bsi->mvp = &(x->e_mbd.block[i-1].bmi.mv.as_mv); bsi->mvp.as_int = x->e_mbd.block[i-1].bmi.mv.as_int;
if (i==4 || i==8 || i==12) bsi->mvp = &(x->e_mbd.block[i-4].bmi.mv.as_mv); if (i==4 || i==8 || i==12)
bsi->mvp.as_int = x->e_mbd.block[i-4].bmi.mv.as_int;
step_param = 2; step_param = 2;
} }
} }
@ -1210,7 +1212,7 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
else else
{ {
bestsme = cpi->diamond_search_sad(x, c, e, bsi->mvp, bestsme = cpi->diamond_search_sad(x, c, e, &bsi->mvp,
&mode_mv[NEW4X4], step_param, &mode_mv[NEW4X4], step_param,
sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv); sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv);
@ -1225,15 +1227,14 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
num00--; num00--;
else else
{ {
thissme = cpi->diamond_search_sad(x, c, e, bsi->mvp, thissme = cpi->diamond_search_sad(x, c, e, &bsi->mvp,
&temp_mv, step_param + n, &temp_mv, step_param + n,
sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv); sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv);
if (thissme < bestsme) if (thissme < bestsme)
{ {
bestsme = thissme; bestsme = thissme;
mode_mv[NEW4X4].row = temp_mv.row; mode_mv[NEW4X4].as_int = temp_mv.as_int;
mode_mv[NEW4X4].col = temp_mv.col;
} }
} }
} }
@ -1244,10 +1245,10 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
// Should we do a full search (best quality only) // Should we do a full search (best quality only)
if ((cpi->compressor_speed == 0) && (bestsme >> sseshift) > 4000) if ((cpi->compressor_speed == 0) && (bestsme >> sseshift) > 4000)
{ {
MV full_mvp; int_mv full_mvp;
full_mvp.row = bsi->mvp->row >>3; full_mvp.as_mv.row = bsi->mvp.as_mv.row >>3;
full_mvp.col = bsi->mvp->col >>3; full_mvp.as_mv.col = bsi->mvp.as_mv.col >>3;
thissme = cpi->full_search_sad(x, c, e, &full_mvp, thissme = cpi->full_search_sad(x, c, e, &full_mvp,
sadpb / 4, 16, v_fn_ptr, x->mvcost, bsi->ref_mv); sadpb / 4, 16, v_fn_ptr, x->mvcost, bsi->ref_mv);
@ -1255,12 +1256,12 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
if (thissme < bestsme) if (thissme < bestsme)
{ {
bestsme = thissme; bestsme = thissme;
mode_mv[NEW4X4] = e->bmi.mv.as_mv; mode_mv[NEW4X4].as_int = e->bmi.mv.as_int;
} }
else else
{ {
// The full search result is actually worse so re-instate the previous best vector // The full search result is actually worse so re-instate the previous best vector
e->bmi.mv.as_mv = mode_mv[NEW4X4]; e->bmi.mv.as_int = mode_mv[NEW4X4].as_int;
} }
} }
} }
@ -1283,8 +1284,8 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
bsi->ref_mv, x->mvcost); bsi->ref_mv, x->mvcost);
// Trap vectors that reach beyond the UMV borders // Trap vectors that reach beyond the UMV borders
if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) || if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max)) ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
{ {
continue; continue;
} }
@ -1361,7 +1362,7 @@ void vp8_cal_step_param(int sr, int *sp)
} }
static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x, static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
MV *best_ref_mv, int best_rd, int_mv *best_ref_mv, int best_rd,
int *mdcounts, int *returntotrate, int *mdcounts, int *returntotrate,
int *returnyrate, int *returndistortion, int *returnyrate, int *returndistortion,
int mvthresh) int mvthresh)
@ -1373,7 +1374,7 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
bsi.segment_rd = best_rd; bsi.segment_rd = best_rd;
bsi.ref_mv = best_ref_mv; bsi.ref_mv = best_ref_mv;
bsi.mvp = best_ref_mv; bsi.mvp.as_int = best_ref_mv->as_int;
bsi.mvthresh = mvthresh; bsi.mvthresh = mvthresh;
bsi.mdcounts = mdcounts; bsi.mdcounts = mdcounts;
@ -1399,10 +1400,10 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
if (bsi.segment_rd < best_rd) if (bsi.segment_rd < best_rd)
{ {
int col_min = (best_ref_mv->col - MAX_FULL_PEL_VAL) >>3; int col_min = (best_ref_mv->as_mv.col - MAX_FULL_PEL_VAL) >>3;
int col_max = (best_ref_mv->col + MAX_FULL_PEL_VAL) >>3; int col_max = (best_ref_mv->as_mv.col + MAX_FULL_PEL_VAL) >>3;
int row_min = (best_ref_mv->row - MAX_FULL_PEL_VAL) >>3; int row_min = (best_ref_mv->as_mv.row - MAX_FULL_PEL_VAL) >>3;
int row_max = (best_ref_mv->row + MAX_FULL_PEL_VAL) >>3; int row_max = (best_ref_mv->as_mv.row + MAX_FULL_PEL_VAL) >>3;
int tmp_col_min = x->mv_col_min; int tmp_col_min = x->mv_col_min;
int tmp_col_max = x->mv_col_max; int tmp_col_max = x->mv_col_max;
@ -1420,18 +1421,18 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
x->mv_row_max = row_max; x->mv_row_max = row_max;
/* Get 8x8 result */ /* Get 8x8 result */
bsi.sv_mvp[0] = bsi.mvs[0].as_mv; bsi.sv_mvp[0].as_int = bsi.mvs[0].as_int;
bsi.sv_mvp[1] = bsi.mvs[2].as_mv; bsi.sv_mvp[1].as_int = bsi.mvs[2].as_int;
bsi.sv_mvp[2] = bsi.mvs[8].as_mv; bsi.sv_mvp[2].as_int = bsi.mvs[8].as_int;
bsi.sv_mvp[3] = bsi.mvs[10].as_mv; bsi.sv_mvp[3].as_int = bsi.mvs[10].as_int;
/* Use 8x8 result as 16x8/8x16's predictor MV. Adjust search range according to the closeness of 2 MV. */ /* Use 8x8 result as 16x8/8x16's predictor MV. Adjust search range according to the closeness of 2 MV. */
/* block 8X16 */ /* block 8X16 */
{ {
sr = MAXF((abs(bsi.sv_mvp[0].row - bsi.sv_mvp[2].row))>>3, (abs(bsi.sv_mvp[0].col - bsi.sv_mvp[2].col))>>3); sr = MAXF((abs(bsi.sv_mvp[0].as_mv.row - bsi.sv_mvp[2].as_mv.row))>>3, (abs(bsi.sv_mvp[0].as_mv.col - bsi.sv_mvp[2].as_mv.col))>>3);
vp8_cal_step_param(sr, &bsi.sv_istep[0]); vp8_cal_step_param(sr, &bsi.sv_istep[0]);
sr = MAXF((abs(bsi.sv_mvp[1].row - bsi.sv_mvp[3].row))>>3, (abs(bsi.sv_mvp[1].col - bsi.sv_mvp[3].col))>>3); sr = MAXF((abs(bsi.sv_mvp[1].as_mv.row - bsi.sv_mvp[3].as_mv.row))>>3, (abs(bsi.sv_mvp[1].as_mv.col - bsi.sv_mvp[3].as_mv.col))>>3);
vp8_cal_step_param(sr, &bsi.sv_istep[1]); vp8_cal_step_param(sr, &bsi.sv_istep[1]);
rd_check_segment(cpi, x, &bsi, BLOCK_8X16); rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
@ -1439,10 +1440,10 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
/* block 16X8 */ /* block 16X8 */
{ {
sr = MAXF((abs(bsi.sv_mvp[0].row - bsi.sv_mvp[1].row))>>3, (abs(bsi.sv_mvp[0].col - bsi.sv_mvp[1].col))>>3); sr = MAXF((abs(bsi.sv_mvp[0].as_mv.row - bsi.sv_mvp[1].as_mv.row))>>3, (abs(bsi.sv_mvp[0].as_mv.col - bsi.sv_mvp[1].as_mv.col))>>3);
vp8_cal_step_param(sr, &bsi.sv_istep[0]); vp8_cal_step_param(sr, &bsi.sv_istep[0]);
sr = MAXF((abs(bsi.sv_mvp[2].row - bsi.sv_mvp[3].row))>>3, (abs(bsi.sv_mvp[2].col - bsi.sv_mvp[3].col))>>3); sr = MAXF((abs(bsi.sv_mvp[2].as_mv.row - bsi.sv_mvp[3].as_mv.row))>>3, (abs(bsi.sv_mvp[2].as_mv.col - bsi.sv_mvp[3].as_mv.col))>>3);
vp8_cal_step_param(sr, &bsi.sv_istep[1]); vp8_cal_step_param(sr, &bsi.sv_istep[1]);
rd_check_segment(cpi, x, &bsi, BLOCK_16X8); rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
@ -1452,7 +1453,7 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
/* Not skip 4x4 if speed=0 (good quality) */ /* Not skip 4x4 if speed=0 (good quality) */
if (cpi->sf.no_skip_block4x4_search || bsi.segment_num == BLOCK_8X8) /* || (sv_segment_rd8x8-bsi.segment_rd) < sv_segment_rd8x8>>5) */ if (cpi->sf.no_skip_block4x4_search || bsi.segment_num == BLOCK_8X8) /* || (sv_segment_rd8x8-bsi.segment_rd) < sv_segment_rd8x8>>5) */
{ {
bsi.mvp = &bsi.sv_mvp[0]; bsi.mvp.as_int = bsi.sv_mvp[0].as_int;
rd_check_segment(cpi, x, &bsi, BLOCK_4X4); rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
} }
@ -1552,7 +1553,7 @@ void vp8_mv_pred
VP8_COMP *cpi, VP8_COMP *cpi,
MACROBLOCKD *xd, MACROBLOCKD *xd,
const MODE_INFO *here, const MODE_INFO *here,
MV *mvp, int_mv *mvp,
int refframe, int refframe,
int *ref_frame_sign_bias, int *ref_frame_sign_bias,
int *sr, int *sr,
@ -1691,8 +1692,8 @@ void vp8_mv_pred
} }
/* Set up return values */ /* Set up return values */
*mvp = mv.as_mv; mvp->as_int = mv.as_int;
vp8_clamp_mv(mvp, xd); vp8_clamp_mv2(mvp, xd);
} }
void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x, int recon_yoffset, int near_sadidx[]) void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x, int recon_yoffset, int near_sadidx[])
@ -1758,8 +1759,8 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
B_MODE_INFO best_bmodes[16]; B_MODE_INFO best_bmodes[16];
MB_MODE_INFO best_mbmode; MB_MODE_INFO best_mbmode;
PARTITION_INFO best_partition; PARTITION_INFO best_partition;
MV best_ref_mv; int_mv best_ref_mv;
MV mode_mv[MB_MODE_COUNT]; int_mv mode_mv[MB_MODE_COUNT];
MB_PREDICTION_MODE this_mode; MB_PREDICTION_MODE this_mode;
int num00; int num00;
int best_mode_index = 0; int best_mode_index = 0;
@ -1784,14 +1785,14 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
//int intermodecost[MAX_MODES]; //int intermodecost[MAX_MODES];
MB_PREDICTION_MODE uv_intra_mode; MB_PREDICTION_MODE uv_intra_mode;
MV mvp; int_mv mvp;
int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7}; int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
int saddone=0; int saddone=0;
int sr=0; //search range got from mv_pred(). It uses step_param levels. (0-7) int sr=0; //search range got from mv_pred(). It uses step_param levels. (0-7)
MV frame_nearest_mv[4]; int_mv frame_nearest_mv[4];
MV frame_near_mv[4]; int_mv frame_near_mv[4];
MV frame_best_ref_mv[4]; int_mv frame_best_ref_mv[4];
int frame_mdcounts[4][4]; int frame_mdcounts[4][4];
int frame_lf_or_gf[4]; int frame_lf_or_gf[4];
unsigned char *y_buffer[4]; unsigned char *y_buffer[4];
@ -1941,14 +1942,11 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
x->e_mbd.mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]); x->e_mbd.mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]);
/* adjust mvp to make sure it is within MV range */ /* adjust mvp to make sure it is within MV range */
if(mvp.row > best_ref_mv.row + MAX_FULL_PEL_VAL) vp8_clamp_mv(&mvp,
mvp.row = best_ref_mv.row + MAX_FULL_PEL_VAL; best_ref_mv.as_mv.row - MAX_FULL_PEL_VAL,
else if(mvp.row < best_ref_mv.row - MAX_FULL_PEL_VAL) best_ref_mv.as_mv.row + MAX_FULL_PEL_VAL,
mvp.row = best_ref_mv.row - MAX_FULL_PEL_VAL; best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL,
if(mvp.col > best_ref_mv.col + MAX_FULL_PEL_VAL) best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL);
mvp.col = best_ref_mv.col + MAX_FULL_PEL_VAL;
else if(mvp.col < best_ref_mv.col - MAX_FULL_PEL_VAL)
mvp.col = best_ref_mv.col - MAX_FULL_PEL_VAL;
} }
// Check to see if the testing frequency for this mode is at its max // Check to see if the testing frequency for this mode is at its max
@ -2080,10 +2078,10 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
int sadpb = x->sadperbit16; int sadpb = x->sadperbit16;
int col_min = (best_ref_mv.col - MAX_FULL_PEL_VAL) >>3; int col_min = (best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL) >>3;
int col_max = (best_ref_mv.col + MAX_FULL_PEL_VAL) >>3; int col_max = (best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL) >>3;
int row_min = (best_ref_mv.row - MAX_FULL_PEL_VAL) >>3; int row_min = (best_ref_mv.as_mv.row - MAX_FULL_PEL_VAL) >>3;
int row_max = (best_ref_mv.row + MAX_FULL_PEL_VAL) >>3; int row_max = (best_ref_mv.as_mv.row + MAX_FULL_PEL_VAL) >>3;
int tmp_col_min = x->mv_col_min; int tmp_col_min = x->mv_col_min;
int tmp_col_max = x->mv_col_max; int tmp_col_max = x->mv_col_max;
@ -2107,15 +2105,13 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
// Initial step/diamond search // Initial step/diamond search
if (cpi->sf.search_method == HEX) if (cpi->sf.search_method == HEX)
{ {
bestsme = vp8_hex_search(x, b, d, &best_ref_mv, &d->bmi.mv.as_mv, step_param, sadpb/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvsadcost, x->mvcost, &best_ref_mv); bestsme = vp8_hex_search(x, b, d, &best_ref_mv, &d->bmi.mv, step_param, sadpb/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvsadcost, x->mvcost, &best_ref_mv);
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
} }
else else
{ {
bestsme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv.as_mv, step_param, sadpb / 2/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //sadpb < 9 bestsme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv, step_param, sadpb / 2/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //sadpb < 9
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
// Further step/diamond searches as necessary // Further step/diamond searches as necessary
n = 0; n = 0;
@ -2136,7 +2132,7 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
num00--; num00--;
else else
{ {
thissme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv.as_mv, step_param + n, sadpb / 4/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //sadpb = 9 thissme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv, step_param + n, sadpb / 4/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //sadpb = 9
/* check to see if refining search is needed. */ /* check to see if refining search is needed. */
if (num00 > (further_steps-n)) if (num00 > (further_steps-n))
@ -2145,13 +2141,11 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
if (thissme < bestsme) if (thissme < bestsme)
{ {
bestsme = thissme; bestsme = thissme;
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
} }
else else
{ {
d->bmi.mv.as_mv.row = mode_mv[NEWMV].row; d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
} }
} }
} }
@ -2167,18 +2161,16 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
search_range = 8; search_range = 8;
//thissme = cpi->full_search_sad(x, b, d, &d->bmi.mv.as_mv, sadpb, search_range, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); //thissme = cpi->full_search_sad(x, b, d, &d->bmi.mv.as_mv, sadpb, search_range, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
thissme = cpi->refining_search_sad(x, b, d, &d->bmi.mv.as_mv, sadpb/4, search_range, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv); thissme = cpi->refining_search_sad(x, b, d, &d->bmi.mv, sadpb/4, search_range, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
if (thissme < bestsme) if (thissme < bestsme)
{ {
bestsme = thissme; bestsme = thissme;
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
} }
else else
{ {
d->bmi.mv.as_mv.row = mode_mv[NEWMV].row; d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
} }
} }
@ -2191,11 +2183,10 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
{ {
int dis; /* TODO: use dis in distortion calculation later. */ int dis; /* TODO: use dis in distortion calculation later. */
unsigned int sse; unsigned int sse;
cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv.as_mv, &best_ref_mv, x->errorperbit / 4, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &dis, &sse); cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, &best_ref_mv, x->errorperbit / 4, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &dis, &sse);
} }
mode_mv[NEWMV].row = d->bmi.mv.as_mv.row; mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
// Add the new motion vector cost to our rolling cost variable // Add the new motion vector cost to our rolling cost variable
rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, x->mvcost, 96); rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, x->mvcost, 96);
@ -2203,21 +2194,11 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
case NEARESTMV: case NEARESTMV:
case NEARMV: case NEARMV:
// Clip "next_nearest" so that it does not extend to far out of image // Clip "next_nearest" so that it does not extend to far out of image
if (mode_mv[this_mode].col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN)) vp8_clamp_mv2(&mode_mv[this_mode], xd);
mode_mv[this_mode].col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
else if (mode_mv[this_mode].col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
mode_mv[this_mode].col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
if (mode_mv[this_mode].row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
mode_mv[this_mode].row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
else if (mode_mv[this_mode].row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
mode_mv[this_mode].row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
// Do not bother proceeding if the vector (from newmv,nearest or near) is 0,0 as this should then be coded using the zeromv mode. // Do not bother proceeding if the vector (from newmv,nearest or near) is 0,0 as this should then be coded using the zeromv mode.
if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) && if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) && (mode_mv[this_mode].as_int == 0))
((mode_mv[this_mode].row == 0) && (mode_mv[this_mode].col == 0)))
continue; continue;
case ZEROMV: case ZEROMV:
@ -2225,8 +2206,8 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
// Trap vectors that reach beyond the UMV borders // Trap vectors that reach beyond the UMV borders
// Note that ALL New MV, Nearest MV Near MV and Zero MV code drops through to this point // Note that ALL New MV, Nearest MV Near MV and Zero MV code drops through to this point
// because of the lack of break statements in the previous two cases. // because of the lack of break statements in the previous two cases.
if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) || if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max)) ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
continue; continue;
vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]); vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]);

2
vp8/encoder/rdopt.h
View File

@ -25,7 +25,7 @@ extern void vp8_mv_pred
VP8_COMP *cpi, VP8_COMP *cpi,
MACROBLOCKD *xd, MACROBLOCKD *xd,
const MODE_INFO *here, const MODE_INFO *here,
MV *mvp, int_mv *mvp,
int refframe, int refframe,
int *ref_frame_sign_bias, int *ref_frame_sign_bias,
int *sr, int *sr,

8
vp8/encoder/temporal_filter.c
View File

@ -157,7 +157,7 @@ static int vp8_temporal_filter_find_matching_mb_c
BLOCK *b = &x->block[0]; BLOCK *b = &x->block[0];
BLOCKD *d = &x->e_mbd.block[0]; BLOCKD *d = &x->e_mbd.block[0];
MV best_ref_mv1 = {0,0}; int_mv best_ref_mv1;
int *mvcost[2] = { &dummy_cost[mv_max+1], &dummy_cost[mv_max+1] }; int *mvcost[2] = { &dummy_cost[mv_max+1], &dummy_cost[mv_max+1] };
int *mvsadcost[2] = { &dummy_cost[mv_max+1], &dummy_cost[mv_max+1] }; int *mvsadcost[2] = { &dummy_cost[mv_max+1], &dummy_cost[mv_max+1] };
@ -170,6 +170,8 @@ static int vp8_temporal_filter_find_matching_mb_c
int pre = d->pre; int pre = d->pre;
int pre_stride = d->pre_stride; int pre_stride = d->pre_stride;
best_ref_mv1.as_int = 0;
// Setup frame pointers // Setup frame pointers
b->base_src = &arf_frame->y_buffer; b->base_src = &arf_frame->y_buffer;
b->src_stride = arf_frame->y_stride; b->src_stride = arf_frame->y_stride;
@ -196,7 +198,7 @@ static int vp8_temporal_filter_find_matching_mb_c
/*cpi->sf.search_method == HEX*/ /*cpi->sf.search_method == HEX*/
// TODO Check that the 16x16 vf & sdf are selected here // TODO Check that the 16x16 vf & sdf are selected here
bestsme = vp8_hex_search(x, b, d, bestsme = vp8_hex_search(x, b, d,
&best_ref_mv1, &d->bmi.mv.as_mv, &best_ref_mv1, &d->bmi.mv,
step_param, step_param,
sadpb/*x->errorperbit*/, sadpb/*x->errorperbit*/,
&num00, &cpi->fn_ptr[BLOCK_16X16], &num00, &cpi->fn_ptr[BLOCK_16X16],
@ -209,7 +211,7 @@ static int vp8_temporal_filter_find_matching_mb_c
int distortion; int distortion;
unsigned int sse; unsigned int sse;
bestsme = cpi->find_fractional_mv_step(x, b, d, bestsme = cpi->find_fractional_mv_step(x, b, d,
&d->bmi.mv.as_mv, &best_ref_mv1, &d->bmi.mv, &best_ref_mv1,
x->errorperbit, &cpi->fn_ptr[BLOCK_16X16], x->errorperbit, &cpi->fn_ptr[BLOCK_16X16],
mvcost, &distortion, &sse); mvcost, &distortion, &sse);
} }