Using int_mv instead of MV

The compiler produces better assembly when using int_mv
for assignments.  The compiler shifts and ors the two 16bit
values when assigning MV.

Change-Id: I52ce4bc2bfbfaf3f1151204b2f21e1e0654f960f

diff --git a/vp8/common/blockd.h b/vp8/common/blockd.h
index aef6927..0eb6ed3 100644 (file)
--- a/vp8/common/blockd.h
+++ b/vp8/common/blockd.h
@@ -140,11 +140,7 @@ typedef enum
 typedef struct
 {
     B_PREDICTION_MODE mode;
-    union
-    {
-        int as_int;
-        MV  as_mv;
-    } mv;
+    int_mv mv;
 } B_MODE_INFO;
 
 
@@ -161,11 +157,7 @@ typedef struct
 {
     MB_PREDICTION_MODE mode, uv_mode;
     MV_REFERENCE_FRAME ref_frame;
-    union
-    {
-        int as_int;
-        MV  as_mv;
-    } mv;
+    int_mv mv;
 
     unsigned char partitioning;
     unsigned char mb_skip_coeff;                                /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */

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

diff --git a/vp8/common/findnearmv.h b/vp8/common/findnearmv.h
index bdf9eca..20a77a5 100644 (file)
--- a/vp8/common/findnearmv.h
+++ b/vp8/common/findnearmv.h
@@ -17,11 +17,6 @@
 #include "modecont.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)
 {
@@ -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 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->as_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->as_mv.col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
+        mv->as_mv.col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
+
+    if (mv->as_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->as_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)
 {
-    if (mv->col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
-        mv->col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
-    else if (mv->col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
-        mv->col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
-
-    if (mv->row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
-        mv->row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
-    else if (mv->row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
-        mv->row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
+    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
 (
     MACROBLOCKD *xd,
     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 refframe,
     int *ref_frame_sign_bias

diff --git a/vp8/common/mv.h b/vp8/common/mv.h
index 73c91b9..35c4fe9 100644 (file)
--- a/vp8/common/mv.h
+++ b/vp8/common/mv.h
@@ -11,6 +11,7 @@
 
 #ifndef __INC_MV_H
 #define __INC_MV_H
+#include "vpx/vpx_integer.h"
 
 typedef struct
 {
@@ -18,4 +19,10 @@ typedef struct
     short col;
 } MV;
 
+typedef union
+{
+    uint32_t  as_int;
+    MV        as_mv;
+} int_mv;        /* facilitates faster equality tests and copies */
+
 #endif

diff --git a/vp8/decoder/decodemv.c b/vp8/decoder/decodemv.c
index e5830e8..4de2868 100644 (file)
--- a/vp8/decoder/decodemv.c
+++ b/vp8/decoder/decodemv.c
@@ -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,
                             int mb_row, int mb_col)
 {
-    const MV Zero = { 0, 0};
     vp8_reader *const bc = & pbi->bc;
     MV_CONTEXT *const mvc = pbi->common.fc.mvc;
     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_right_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];
         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))
         {
@@ -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 */
             {
                 B_MODE_INFO bmi;
-                MV *const mv = & bmi.mv.as_mv;
-
                 int k;  /* first block in subset j */
                 int mv_contz;
                 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))*/
                 {
                 case NEW4X4:
-                    read_mv(bc, mv, (const MV_CONTEXT *) mvc);
-                    mv->row += best_mv.row;
-                    mv->col += best_mv.col;
+                    read_mv(bc, &bmi.mv.as_mv, (const MV_CONTEXT *) mvc);
+                    bmi.mv.as_mv.row += best_mv.as_mv.row;
+                    bmi.mv.as_mv.col += best_mv.as_mv.col;
   #ifdef VPX_MODE_COUNT
                     vp8_mv_cont_count[mv_contz][3]++;
   #endif
                     break;
                 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
                     vp8_mv_cont_count[mv_contz][0]++;
   #endif
                     break;
                 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
                     vp8_mv_cont_count[mv_contz][1]++;
   #endif
                     break;
                 case ZERO4X4:
-                    *mv = Zero;
+                    bmi.mv.as_int = 0;
   #ifdef VPX_MODE_COUNT
                     vp8_mv_cont_count[mv_contz][2]++;
   #endif
@@ -389,10 +386,11 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
                     break;
                 }
 
-                mbmi->need_to_clamp_mvs |= (mv->col < mb_to_left_edge) ? 1 : 0;
-                mbmi->need_to_clamp_mvs |= (mv->col > mb_to_right_edge) ? 1 : 0;
-                mbmi->need_to_clamp_mvs |= (mv->row < mb_to_top_edge) ? 1 : 0;
-                mbmi->need_to_clamp_mvs |= (mv->row > mb_to_bottom_edge) ? 1 : 0;
+                mbmi->need_to_clamp_mvs = vp8_check_mv_bounds(&bmi.mv,
+                                                          mb_to_left_edge,
+                                                          mb_to_right_edge,
+                                                          mb_to_top_edge,
+                                                          mb_to_bottom_edge);
 
                 {
                     /* 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);
         }
 
-        *mv = mi->bmi[15].mv.as_mv;
+        mv->as_int = mi->bmi[15].mv.as_int;
 
         break;  /* done with SPLITMV */
 
         case NEARMV:
-            *mv = nearby;
+            mv->as_int = nearby.as_int;
             /* 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;
-            mv->col = (mv->col > mb_to_right_edge) ? mb_to_right_edge : mv->col;
-            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;
+            vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
+                         mb_to_top_edge, mb_to_bottom_edge);
             goto propagate_mv;
 
         case NEARESTMV:
-            *mv = nearest;
+            mv->as_int = nearest.as_int;
             /* 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;
-            mv->col = (mv->col > mb_to_right_edge) ? mb_to_right_edge : mv->col;
-            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;
+            vp8_clamp_mv(mv, mb_to_left_edge, mb_to_right_edge,
+                         mb_to_top_edge, mb_to_bottom_edge);
             goto propagate_mv;
 
         case ZEROMV:
-            *mv = Zero;
+            mv->as_int = 0;
             goto propagate_mv;
 
         case NEWMV:
-            read_mv(bc, mv, (const MV_CONTEXT *) mvc);
-            mv->row += best_mv.row;
-            mv->col += best_mv.col;
+            read_mv(bc, &mv->as_mv, (const MV_CONTEXT *) mvc);
+            mv->as_mv.row += best_mv.as_mv.row;
+            mv->as_mv.col += best_mv.as_mv.col;
 
             /* Don't need to check this on NEARMV and NEARESTMV modes
              * since those modes clamp the MV. The NEWMV mode does not,
              * so signal to the prediction stage whether special
              * handling may be required.
              */
-            mbmi->need_to_clamp_mvs = (mv->col < mb_to_left_edge) ? 1 : 0;
-            mbmi->need_to_clamp_mvs |= (mv->col > mb_to_right_edge) ? 1 : 0;
-            mbmi->need_to_clamp_mvs |= (mv->row < mb_to_top_edge) ? 1 : 0;
-            mbmi->need_to_clamp_mvs |= (mv->row > mb_to_bottom_edge) ? 1 : 0;
+            mbmi->need_to_clamp_mvs = vp8_check_mv_bounds(mv,
+                                                      mb_to_left_edge,
+                                                      mb_to_right_edge,
+                                                      mb_to_top_edge,
+                                                      mb_to_bottom_edge);
 
         propagate_mv:  /* same MV throughout */
             {
-                /*int i=0;
-                do
-                {
-                  mi->bmi[i].mv.as_mv = *mv;
-                }
-                while( ++i < 16);*/
-
-                mi->bmi[0].mv.as_mv = *mv;
-                mi->bmi[1].mv.as_mv = *mv;
-                mi->bmi[2].mv.as_mv = *mv;
-                mi->bmi[3].mv.as_mv = *mv;
-                mi->bmi[4].mv.as_mv = *mv;
-                mi->bmi[5].mv.as_mv = *mv;
-                mi->bmi[6].mv.as_mv = *mv;
-                mi->bmi[7].mv.as_mv = *mv;
-                mi->bmi[8].mv.as_mv = *mv;
-                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;
+                mi->bmi[ 0].mv.as_int =
+                mi->bmi[ 1].mv.as_int =
+                mi->bmi[ 2].mv.as_int =
+                mi->bmi[ 3].mv.as_int =
+                mi->bmi[ 4].mv.as_int =
+                mi->bmi[ 5].mv.as_int =
+                mi->bmi[ 6].mv.as_int =
+                mi->bmi[ 7].mv.as_int =
+                mi->bmi[ 8].mv.as_int =
+                mi->bmi[ 9].mv.as_int =
+                mi->bmi[10].mv.as_int =
+                mi->bmi[11].mv.as_int =
+                mi->bmi[12].mv.as_int =
+                mi->bmi[13].mv.as_int =
+                mi->bmi[14].mv.as_int =
+                mi->bmi[15].mv.as_int = mv->as_int;
             }
             break;
         default:;
@@ -494,7 +482,7 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
         int j = 0;
         do
         {
-            mi->bmi[j].mv.as_mv = Zero;
+            mi->bmi[j].mv.as_int = 0;
         }
         while (++j < 16);
 

diff --git a/vp8/encoder/bitstream.c b/vp8/encoder/bitstream.c
index adbd106..4427dfa 100644 (file)
--- a/vp8/encoder/bitstream.c
+++ b/vp8/encoder/bitstream.c
@@ -799,12 +799,12 @@ static void write_sub_mv_ref
 
 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;
-    e.row = mv->row - ref->row;
-    e.col = mv->col - ref->col;
+    e.row = mv->row - ref->as_mv.row;
+    e.col = mv->col - ref->as_mv.col;
 
     vp8_encode_motion_vector(w, &e, mvc);
 }
@@ -957,7 +957,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi)
             }
             else    /* inter coded */
             {
-                MV best_mv;
+                int_mv best_mv;
                 vp8_prob mv_ref_p [VP8_MVREFS-1];
 
                 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];
 
                     vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, cpi->common.ref_frame_sign_bias);

diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c
index 2f3905f..c8805a4 100644 (file)
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -1342,8 +1342,8 @@ int vp8cx_encode_inter_macroblock
     }
     else
     {
-        MV best_ref_mv;
-        MV nearest, nearby;
+        int_mv best_ref_mv;
+        int_mv nearest, nearby;
         int mdcounts[4];
         int ref_fb_idx;
 
@@ -1371,15 +1371,15 @@ int vp8cx_encode_inter_macroblock
             {
                 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[1][mv_max+((xd->block[i].bmi.mv.as_mv.col - best_ref_mv.col) >> 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.as_mv.col) >> 1)]++;
                 }
             }
         }
         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[1][mv_max+((xd->block[0].bmi.mv.as_mv.col - best_ref_mv.col) >> 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.as_mv.col) >> 1)]++;
         }
 
         if (!x->skip)

diff --git a/vp8/encoder/firstpass.c b/vp8/encoder/firstpass.c
index 6f33099..7334a46 100644 (file)
--- a/vp8/encoder/firstpass.c
+++ b/vp8/encoder/firstpass.c
@@ -39,7 +39,7 @@
 extern void vp8_build_block_offsets(MACROBLOCK *x);
 extern void vp8_setup_block_ptrs(MACROBLOCK *x);
 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);
 
 //#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));
 }
 
-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;
     BLOCK *b = &x->block[0];
     BLOCKD *d = &x->e_mbd.block[0];
     int num00;
 
-    MV tmp_mv = {0, 0};
+    int_mv tmp_mv;
 
     int tmp_err;
     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;
 
     // 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);
     if ( tmp_err < INT_MAX-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)
     {
         *best_motion_err = tmp_err;
-        best_mv->row = tmp_mv.row;
-        best_mv->col = tmp_mv.col;
+        best_mv->row = tmp_mv.as_mv.row;
+        best_mv->col = tmp_mv.as_mv.col;
     }
 
     // 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)
             {
                 *best_motion_err = tmp_err;
-                best_mv->row = tmp_mv.row;
-                best_mv->col = tmp_mv.col;
+                best_mv->row = tmp_mv.as_mv.row;
+                best_mv->col = tmp_mv.as_mv.col;
             }
         }
     }
@@ -510,7 +514,9 @@ void vp8_first_pass(VP8_COMP *cpi)
 
     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;
 
@@ -602,7 +608,7 @@ void vp8_first_pass(VP8_COMP *cpi)
 
                 // Test last reference frame using the previous best mv as the
                 // 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,
                                         &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.col <<= 3;
                     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);
                     sum_mvr += d->bmi.mv.as_mv.row;
                     sum_mvr_abs += abs(d->bmi.mv.as_mv.row);

diff --git a/vp8/encoder/mcomp.c b/vp8/encoder/mcomp.c
index a0afcd0..9189286 100644 (file)
--- a/vp8/encoder/mcomp.c
+++ b/vp8/encoder/mcomp.c
@@ -34,37 +34,28 @@ void vp8cx_init_mv_bits_sadcost()
 }
 
 
-int vp8_mv_bit_cost(MV *mv, MV *ref, int *mvcost[2], int Weight)
+int vp8_mv_bit_cost(int_mv *mv, int_mv *ref, int *mvcost[2], int Weight)
 {
     // MV costing is based on the distribution of vectors in the previous frame and as such will tend to
     // over state the cost of vectors. In addition coding a new vector can have a knock on effect on the
     // cost of subsequent vectors and the quality of prediction from NEAR and NEAREST for subsequent blocks.
     // The "Weight" parameter allows, to a limited extent, for some account to be taken of these factors.
-    return ((mvcost[0][(mv->row - ref->row) >> 1] + mvcost[1][(mv->col - ref->col) >> 1]) * Weight) >> 7;
+    return ((mvcost[0][(mv->as_mv.row - ref->as_mv.row) >> 1] + mvcost[1][(mv->as_mv.col - ref->as_mv.col) >> 1]) * Weight) >> 7;
 }
 
-static int mv_err_cost(MV *mv, MV *ref, int *mvcost[2], int error_per_bit)
+static int mv_err_cost(int_mv *mv, int_mv *ref, int *mvcost[2], int error_per_bit)
 {
-    //int i;
-    //return ((mvcost[0][(mv->row - ref->row)>>1] + mvcost[1][(mv->col - ref->col)>>1] + 128) * error_per_bit) >> 8;
-    //return ( (vp8_mv_bit_cost(mv,  ref, mvcost, 100) + 128) * error_per_bit) >> 8;
-
-    //i = (vp8_mv_bit_cost(mv,  ref, mvcost, 100) * error_per_bit + 128) >> 8;
-    return ((mvcost[0][(mv->row - ref->row) >> 1] + mvcost[1][(mv->col - ref->col) >> 1]) * error_per_bit + 128) >> 8;
-    //return (vp8_mv_bit_cost(mv,  ref, mvcost, 128) * error_per_bit + 128) >> 8;
+    return ((mvcost[0][(mv->as_mv.row - ref->as_mv.row) >> 1] +
+        mvcost[1][(mv->as_mv.col - ref->as_mv.col) >> 1])
+        * error_per_bit + 128) >> 8;
 }
 
-static int mvsad_err_cost(MV *mv, MV *ref, int *mvsadcost[2], int error_per_bit)
+static int mvsad_err_cost(int_mv *mv, int_mv *ref, int *mvsadcost[2], int error_per_bit)
 {
     /* Calculate sad error cost on full pixel basis. */
-    return ((mvsadcost[0][(mv->row - ref->row)] + mvsadcost[1][(mv->col - ref->col)]) * error_per_bit + 128) >> 8;
-}
-
-static int mv_bits(MV *mv, MV *ref, int *mvcost[2])
-{
-    // get the estimated number of bits for a motion vector, to be used for costing in SAD based
-    // motion estimation
-    return ((mvcost[0][(mv->row - ref->row) >> 1]  +  mvcost[1][(mv->col - ref->col)>> 1]) + 128) >> 8;
+    return ((mvsadcost[0][(mv->as_mv.row - ref->as_mv.row)] +
+        mvsadcost[1][(mv->as_mv.col - ref->as_mv.col)])
+        * error_per_bit + 128) >> 8;
 }
 
 void vp8_init_dsmotion_compensation(MACROBLOCK *x, int stride)
@@ -200,13 +191,18 @@ void vp8_init3smotion_compensation(MACROBLOCK *x, int stride)
 
 //#define CHECK_BETTER(v,r,c) if((v = ERR(r,c)) < besterr) { besterr = v; br=r; bc=c; }
 
-int vp8_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, 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 *sse1)
+int vp8_find_best_sub_pixel_step_iteratively(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 *sse1)
 {
-    unsigned char *y = *(d->base_pre) + d->pre + (bestmv->row) * d->pre_stride + bestmv->col;
+    unsigned char *y = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
     unsigned char *z = (*(b->base_src) + b->src);
 
-    int rr = ref_mv->row >> 1, rc = ref_mv->col >> 1;
-    int br = bestmv->row << 2, bc = bestmv->col << 2;
+    int rr = ref_mv->as_mv.row >> 1, rc = ref_mv->as_mv.col >> 1;
+    int br = bestmv->as_mv.row << 2, bc = bestmv->as_mv.col << 2;
     int tr = br, tc = bc;
     unsigned int besterr = INT_MAX;
     unsigned int left, right, up, down, diag;
@@ -216,14 +212,14 @@ int vp8_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
     unsigned int quarteriters = 4;
     int thismse;
 
-    int minc = MAX(x->mv_col_min << 2, (ref_mv->col >> 1) - ((1 << mvlong_width) - 1));
-    int maxc = MIN(x->mv_col_max << 2, (ref_mv->col >> 1) + ((1 << mvlong_width) - 1));
-    int minr = MAX(x->mv_row_min << 2, (ref_mv->row >> 1) - ((1 << mvlong_width) - 1));
-    int maxr = MIN(x->mv_row_max << 2, (ref_mv->row >> 1) + ((1 << mvlong_width) - 1));
+    int minc = MAX(x->mv_col_min << 2, (ref_mv->as_mv.col >> 1) - ((1 << mvlong_width) - 1));
+    int maxc = MIN(x->mv_col_max << 2, (ref_mv->as_mv.col >> 1) + ((1 << mvlong_width) - 1));
+    int minr = MAX(x->mv_row_min << 2, (ref_mv->as_mv.row >> 1) - ((1 << mvlong_width) - 1));
+    int maxr = MIN(x->mv_row_max << 2, (ref_mv->as_mv.row >> 1) + ((1 << mvlong_width) - 1));
 
     // central mv
-    bestmv->row <<= 3;
-    bestmv->col <<= 3;
+    bestmv->as_mv.row <<= 3;
+    bestmv->as_mv.col <<= 3;
 
     // calculate central point error
     besterr = vfp->vf(y, d->pre_stride, z, b->src_stride, sse1);
@@ -300,10 +296,11 @@ int vp8_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
         tc = bc;
     }
 
-    bestmv->row = br << 1;
-    bestmv->col = bc << 1;
+    bestmv->as_mv.row = br << 1;
+    bestmv->as_mv.col = bc << 1;
 
-    if ((abs(bestmv->col - ref_mv->col) > MAX_FULL_PEL_VAL) || (abs(bestmv->row - ref_mv->row) > MAX_FULL_PEL_VAL))
+    if ((abs(bestmv->as_mv.col - ref_mv->as_mv.col) > MAX_FULL_PEL_VAL) ||
+        (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > MAX_FULL_PEL_VAL))
         return INT_MAX;
 
     return besterr;
@@ -316,13 +313,17 @@ int vp8_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
 #undef CHECK_BETTER
 #undef MIN
 #undef MAX
-int vp8_find_best_sub_pixel_step(MACROBLOCK *x, 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 *sse1)
+int vp8_find_best_sub_pixel_step(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 *sse1)
 {
     int bestmse = INT_MAX;
-    MV startmv;
-    //MV this_mv;
-    MV this_mv;
-    unsigned char *y = *(d->base_pre) + d->pre + (bestmv->row) * d->pre_stride + bestmv->col;
+    int_mv startmv;
+    int_mv this_mv;
+    unsigned char *y = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
     unsigned char *z = (*(b->base_src) + b->src);
     int left, right, up, down, diag;
     unsigned int sse;
@@ -331,17 +332,18 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
 
 
     // Trap uncodable vectors
-    if ((abs((bestmv->col << 3) - ref_mv->col) > MAX_FULL_PEL_VAL) || (abs((bestmv->row << 3) - ref_mv->row) > MAX_FULL_PEL_VAL))
+    if ((abs((bestmv->as_mv.col << 3) - ref_mv->as_mv.col) > MAX_FULL_PEL_VAL)
+        || (abs((bestmv->as_mv.row << 3) - ref_mv->as_mv.row) > MAX_FULL_PEL_VAL))
     {
-        bestmv->row <<= 3;
-        bestmv->col <<= 3;
+        bestmv->as_mv.row <<= 3;
+        bestmv->as_mv.col <<= 3;
         *distortion = INT_MAX;
         return INT_MAX;
     }
 
     // central mv
-    bestmv->row <<= 3;
-    bestmv->col <<= 3;
+    bestmv->as_mv.row <<= 3;
+    bestmv->as_mv.col <<= 3;
     startmv = *bestmv;
 
     // calculate central point error
@@ -350,8 +352,8 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
     bestmse += mv_err_cost(bestmv, ref_mv, mvcost, error_per_bit);
 
     // go left then right and check error
-    this_mv.row = startmv.row;
-    this_mv.col = ((startmv.col - 8) | 4);
+    this_mv.as_mv.row = startmv.as_mv.row;
+    this_mv.as_mv.col = ((startmv.as_mv.col - 8) | 4);
     thismse = vfp->svf_halfpix_h(y - 1, d->pre_stride, z, b->src_stride, &sse);
     left = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -363,7 +365,7 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
         *sse1 = sse;
     }
 
-    this_mv.col += 8;
+    this_mv.as_mv.col += 8;
     thismse = vfp->svf_halfpix_h(y, d->pre_stride, z, b->src_stride, &sse);
     right = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -376,8 +378,8 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
     }
 
     // go up then down and check error
-    this_mv.col = startmv.col;
-    this_mv.row = ((startmv.row - 8) | 4);
+    this_mv.as_mv.col = startmv.as_mv.col;
+    this_mv.as_mv.row = ((startmv.as_mv.row - 8) | 4);
     thismse =  vfp->svf_halfpix_v(y - d->pre_stride, d->pre_stride, z, b->src_stride, &sse);
     up = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -389,7 +391,7 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
         *sse1 = sse;
     }
 
-    this_mv.row += 8;
+    this_mv.as_mv.row += 8;
     thismse = vfp->svf_halfpix_v(y, d->pre_stride, z, b->src_stride, &sse);
     down = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -411,24 +413,24 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
     switch (whichdir)
     {
     case 0:
-        this_mv.col = (this_mv.col - 8) | 4;
-        this_mv.row = (this_mv.row - 8) | 4;
+        this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
+        this_mv.as_mv.row = (this_mv.as_mv.row - 8) | 4;
         thismse = vfp->svf_halfpix_hv(y - 1 - d->pre_stride, d->pre_stride, z, b->src_stride, &sse);
         break;
     case 1:
-        this_mv.col += 4;
-        this_mv.row = (this_mv.row - 8) | 4;
+        this_mv.as_mv.col += 4;
+        this_mv.as_mv.row = (this_mv.as_mv.row - 8) | 4;
         thismse = vfp->svf_halfpix_hv(y - d->pre_stride, d->pre_stride, z, b->src_stride, &sse);
         break;
     case 2:
-        this_mv.col = (this_mv.col - 8) | 4;
-        this_mv.row += 4;
+        this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
+        this_mv.as_mv.row += 4;
         thismse = vfp->svf_halfpix_hv(y - 1, d->pre_stride, z, b->src_stride, &sse);
         break;
     case 3:
     default:
-        this_mv.col += 4;
-        this_mv.row += 4;
+        this_mv.as_mv.col += 4;
+        this_mv.as_mv.row += 4;
         thismse = vfp->svf_halfpix_hv(y, d->pre_stride, z, b->src_stride, &sse);
         break;
     }
@@ -447,10 +449,10 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
 
 
     // time to check quarter pels.
-    if (bestmv->row < startmv.row)
+    if (bestmv->as_mv.row < startmv.as_mv.row)
         y -= d->pre_stride;
 
-    if (bestmv->col < startmv.col)
+    if (bestmv->as_mv.col < startmv.as_mv.col)
         y--;
 
     startmv = *bestmv;
@@ -458,17 +460,17 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
 
 
     // go left then right and check error
-    this_mv.row = startmv.row;
+    this_mv.as_mv.row = startmv.as_mv.row;
 
-    if (startmv.col & 7)
+    if (startmv.as_mv.col & 7)
     {
-        this_mv.col = startmv.col - 2;
-        thismse = vfp->svf(y, d->pre_stride, this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+        this_mv.as_mv.col = startmv.as_mv.col - 2;
+        thismse = vfp->svf(y, d->pre_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
     }
     else
     {
-        this_mv.col = (startmv.col - 8) | 6;
-        thismse = vfp->svf(y - 1, d->pre_stride, 6, this_mv.row & 7, z, b->src_stride, &sse);
+        this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
+        thismse = vfp->svf(y - 1, d->pre_stride, 6, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
     }
 
     left = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
@@ -481,8 +483,8 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
         *sse1 = sse;
     }
 
-    this_mv.col += 4;
-    thismse = vfp->svf(y, d->pre_stride, this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+    this_mv.as_mv.col += 4;
+    thismse = vfp->svf(y, d->pre_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
     right = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
     if (right < bestmse)
@@ -494,17 +496,17 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
     }
 
     // go up then down and check error
-    this_mv.col = startmv.col;
+    this_mv.as_mv.col = startmv.as_mv.col;
 
-    if (startmv.row & 7)
+    if (startmv.as_mv.row & 7)
     {
-        this_mv.row = startmv.row - 2;
-        thismse = vfp->svf(y, d->pre_stride, this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+        this_mv.as_mv.row = startmv.as_mv.row - 2;
+        thismse = vfp->svf(y, d->pre_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
     }
     else
     {
-        this_mv.row = (startmv.row - 8) | 6;
-        thismse = vfp->svf(y - d->pre_stride, d->pre_stride, this_mv.col & 7, 6, z, b->src_stride, &sse);
+        this_mv.as_mv.row = (startmv.as_mv.row - 8) | 6;
+        thismse = vfp->svf(y - d->pre_stride, d->pre_stride, this_mv.as_mv.col & 7, 6, z, b->src_stride, &sse);
     }
 
     up = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
@@ -517,8 +519,8 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
         *sse1 = sse;
     }
 
-    this_mv.row += 4;
-    thismse = vfp->svf(y, d->pre_stride, this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+    this_mv.as_mv.row += 4;
+    thismse = vfp->svf(y, d->pre_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
     down = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
     if (down < bestmse)
@@ -541,72 +543,72 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
     {
     case 0:
 
-        if (startmv.row & 7)
+        if (startmv.as_mv.row & 7)
         {
-            this_mv.row -= 2;
+            this_mv.as_mv.row -= 2;
 
-            if (startmv.col & 7)
+            if (startmv.as_mv.col & 7)
             {
-                this_mv.col -= 2;
-                thismse = vfp->svf(y, d->pre_stride, this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+                this_mv.as_mv.col -= 2;
+                thismse = vfp->svf(y, d->pre_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
             }
             else
             {
-                this_mv.col = (startmv.col - 8) | 6;
-                thismse = vfp->svf(y - 1, d->pre_stride, 6, this_mv.row & 7, z, b->src_stride, &sse);;
+                this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
+                thismse = vfp->svf(y - 1, d->pre_stride, 6, this_mv.as_mv.row & 7, z, b->src_stride, &sse);;
             }
         }
         else
         {
-            this_mv.row = (startmv.row - 8) | 6;
+            this_mv.as_mv.row = (startmv.as_mv.row - 8) | 6;
 
-            if (startmv.col & 7)
+            if (startmv.as_mv.col & 7)
             {
-                this_mv.col -= 2;
-                thismse = vfp->svf(y - d->pre_stride, d->pre_stride, this_mv.col & 7, 6, z, b->src_stride, &sse);
+                this_mv.as_mv.col -= 2;
+                thismse = vfp->svf(y - d->pre_stride, d->pre_stride, this_mv.as_mv.col & 7, 6, z, b->src_stride, &sse);
             }
             else
             {
-                this_mv.col = (startmv.col - 8) | 6;
+                this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
                 thismse = vfp->svf(y - d->pre_stride - 1, d->pre_stride, 6, 6, z, b->src_stride, &sse);
             }
         }
 
         break;
     case 1:
-        this_mv.col += 2;
+        this_mv.as_mv.col += 2;
 
-        if (startmv.row & 7)
+        if (startmv.as_mv.row & 7)
         {
-            this_mv.row -= 2;
-            thismse = vfp->svf(y, d->pre_stride, this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+            this_mv.as_mv.row -= 2;
+            thismse = vfp->svf(y, d->pre_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
         }
         else
         {
-            this_mv.row = (startmv.row - 8) | 6;
-            thismse = vfp->svf(y - d->pre_stride, d->pre_stride, this_mv.col & 7, 6, z, b->src_stride, &sse);
+            this_mv.as_mv.row = (startmv.as_mv.row - 8) | 6;
+            thismse = vfp->svf(y - d->pre_stride, d->pre_stride, this_mv.as_mv.col & 7, 6, z, b->src_stride, &sse);
         }
 
         break;
     case 2:
-        this_mv.row += 2;
+        this_mv.as_mv.row += 2;
 
-        if (startmv.col & 7)
+        if (startmv.as_mv.col & 7)
         {
-            this_mv.col -= 2;
-            thismse = vfp->svf(y, d->pre_stride, this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+            this_mv.as_mv.col -= 2;
+            thismse = vfp->svf(y, d->pre_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
         }
         else
         {
-            this_mv.col = (startmv.col - 8) | 6;
-            thismse = vfp->svf(y - 1, d->pre_stride, 6, this_mv.row & 7, z, b->src_stride, &sse);;
+            this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
+            thismse = vfp->svf(y - 1, d->pre_stride, 6, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
         }
 
         break;
     case 3:
-        this_mv.col += 2;
-        this_mv.row += 2;
-        thismse = vfp->svf(y, d->pre_stride,  this_mv.col & 7, this_mv.row & 7, z, b->src_stride, &sse);
+        this_mv.as_mv.col += 2;
+        this_mv.as_mv.row += 2;
+        thismse = vfp->svf(y, d->pre_stride,  this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
         break;
     }
 
@@ -623,30 +625,35 @@ int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *bestmv,
     return bestmse;
 }
 
-int vp8_find_best_half_pixel_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 *sse1)
+int vp8_find_best_half_pixel_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 *sse1)
 {
     int bestmse = INT_MAX;
-    MV startmv;
-    //MV this_mv;
-    MV this_mv;
-    unsigned char *y = *(d->base_pre) + d->pre + (bestmv->row) * d->pre_stride + bestmv->col;
+    int_mv startmv;
+    int_mv this_mv;
+    unsigned char *y = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col;
     unsigned char *z = (*(b->base_src) + b->src);
     int left, right, up, down, diag;
     unsigned int sse;
     int thismse;
 
     // Trap uncodable vectors
-    if ((abs((bestmv->col << 3) - ref_mv->col) > MAX_FULL_PEL_VAL) || (abs((bestmv->row << 3) - ref_mv->row) > MAX_FULL_PEL_VAL))
+    if ((abs((bestmv->as_mv.col << 3) - ref_mv->as_mv.col) > MAX_FULL_PEL_VAL)
+        || (abs((bestmv->as_mv.row << 3) - ref_mv->as_mv.row) > MAX_FULL_PEL_VAL))
     {
-        bestmv->row <<= 3;
-        bestmv->col <<= 3;
+        bestmv->as_mv.row <<= 3;
+        bestmv->as_mv.col <<= 3;
         *distortion = INT_MAX;
         return INT_MAX;
     }
 
     // central mv
-    bestmv->row <<= 3;
-    bestmv->col <<= 3;
+    bestmv->as_mv.row <<= 3;
+    bestmv->as_mv.col <<= 3;
     startmv = *bestmv;
 
     // calculate central point error
@@ -655,8 +662,8 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
     bestmse += mv_err_cost(bestmv, ref_mv, mvcost, error_per_bit);
 
     // go left then right and check error
-    this_mv.row = startmv.row;
-    this_mv.col = ((startmv.col - 8) | 4);
+    this_mv.as_mv.row = startmv.as_mv.row;
+    this_mv.as_mv.col = ((startmv.as_mv.col - 8) | 4);
     thismse = vfp->svf_halfpix_h(y - 1, d->pre_stride, z, b->src_stride, &sse);
     left = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -668,7 +675,7 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
         *sse1 = sse;
     }
 
-    this_mv.col += 8;
+    this_mv.as_mv.col += 8;
     thismse = vfp->svf_halfpix_h(y, d->pre_stride, z, b->src_stride, &sse);
     right = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -681,8 +688,8 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
     }
 
     // go up then down and check error
-    this_mv.col = startmv.col;
-    this_mv.row = ((startmv.row - 8) | 4);
+    this_mv.as_mv.col = startmv.as_mv.col;
+    this_mv.as_mv.row = ((startmv.as_mv.row - 8) | 4);
     thismse = vfp->svf_halfpix_v(y - d->pre_stride, d->pre_stride, z, b->src_stride, &sse);
     up = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -694,7 +701,7 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
         *sse1 = sse;
     }
 
-    this_mv.row += 8;
+    this_mv.as_mv.row += 8;
     thismse = vfp->svf_halfpix_v(y, d->pre_stride, z, b->src_stride, &sse);
     down = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -745,8 +752,8 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
     }
 
 #else
-    this_mv.col = (this_mv.col - 8) | 4;
-    this_mv.row = (this_mv.row - 8) | 4;
+    this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
+    this_mv.as_mv.row = (this_mv.as_mv.row - 8) | 4;
     thismse = vfp->svf_halfpix_hv(y - 1 - d->pre_stride, d->pre_stride, z, b->src_stride, &sse);
     diag = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -758,7 +765,7 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
         *sse1 = sse;
     }
 
-    this_mv.col += 8;
+    this_mv.as_mv.col += 8;
     thismse = vfp->svf_halfpix_hv(y - d->pre_stride, d->pre_stride, z, b->src_stride, &sse);
     diag = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -770,8 +777,8 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
         *sse1 = sse;
     }
 
-    this_mv.col = (this_mv.col - 8) | 4;
-    this_mv.row = startmv.row + 4;
+    this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
+    this_mv.as_mv.row = startmv.as_mv.row + 4;
     thismse = vfp->svf_halfpix_hv(y - 1, d->pre_stride, z, b->src_stride, &sse);
     diag = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -783,7 +790,7 @@ int vp8_find_best_half_pixel_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestm
         *sse1 = sse;
     }
 
-    this_mv.col += 8;
+    this_mv.as_mv.col += 8;
     thismse = vfp->svf_halfpix_hv(y, d->pre_stride, z, b->src_stride, &sse);
     diag = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 
@@ -819,15 +826,15 @@ int vp8_hex_search
     MACROBLOCK *x,
     BLOCK *b,
     BLOCKD *d,
-    MV *ref_mv,
-    MV *best_mv,
+    int_mv *ref_mv,
+    int_mv *best_mv,
     int search_param,
     int error_per_bit,
     int *num00,
     const vp8_variance_fn_ptr_t *vfp,
     int *mvsadcost[2],
     int *mvcost[2],
-    MV *center_mv
+    int_mv *center_mv
 )
 {
     MV hex[6] = { { -1, -2}, {1, -2}, {2, 0}, {1, 2}, { -1, 2}, { -2, 0} } ;
@@ -837,8 +844,8 @@ int vp8_hex_search
     int i, j;
     unsigned char *src = (*(b->base_src) + b->src);
     int src_stride = b->src_stride;
-    int rr = center_mv->row, rc = center_mv->col;
-    int br = ref_mv->row >> 3, bc = ref_mv->col >> 3, tr, tc;
+    int rr = center_mv->as_mv.row, rc = center_mv->as_mv.col;
+    int br = ref_mv->as_mv.row >> 3, bc = ref_mv->as_mv.col >> 3, tr, tc;
     unsigned int besterr, thiserr = 0x7fffffff;
     int k = -1, tk;
 
@@ -947,8 +954,8 @@ cal_neighbors:
             break;
     }
 
-    best_mv->row = br;
-    best_mv->col = bc;
+    best_mv->as_mv.row = br;
+    best_mv->as_mv.col = bc;
 
     return vfp->vf(src, src_stride, PRE(br, bc), d->pre_stride, &thiserr) + mv_err_cost(best_mv, center_mv, mvcost, error_per_bit) ;
 }
@@ -965,14 +972,14 @@ int vp8_diamond_search_sad
     MACROBLOCK *x,
     BLOCK *b,
     BLOCKD *d,
-    MV *ref_mv,
-    MV *best_mv,
+    int_mv *ref_mv,
+    int_mv *best_mv,
     int search_param,
     int error_per_bit,
     int *num00,
     vp8_variance_fn_ptr_t *fn_ptr,
     int *mvcost[2],
-    MV *center_mv
+    int_mv *center_mv
 )
 {
     int i, j, step;
@@ -984,14 +991,14 @@ int vp8_diamond_search_sad
     unsigned char *best_address;
 
     int tot_steps;
-    MV this_mv;
+    int_mv this_mv;
 
     int bestsad = INT_MAX;
     int best_site = 0;
     int last_site = 0;
 
-    int ref_row = ref_mv->row >> 3;
-    int ref_col = ref_mv->col >> 3;
+    int ref_row = ref_mv->as_mv.row >> 3;
+    int ref_col = ref_mv->as_mv.col >> 3;
     int this_row_offset;
     int this_col_offset;
     search_site *ss;
@@ -1000,14 +1007,14 @@ int vp8_diamond_search_sad
     int thissad;
 
     int *mvsadcost[2] = {x->mvsadcost[0], x->mvsadcost[1]};
-    MV fcenter_mv;
-    fcenter_mv.row = center_mv->row >> 3;
-    fcenter_mv.col = center_mv->col >> 3;
+    int_mv fcenter_mv;
+    fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
+    fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     *num00 = 0;
 
-    best_mv->row = ref_row;
-    best_mv->col = ref_col;
+    best_mv->as_mv.row = ref_row;
+    best_mv->as_mv.col = ref_col;
 
     // Work out the start point for the search
     in_what = (unsigned char *)(*(d->base_pre) + d->pre + (ref_row * (d->pre_stride)) + ref_col);
@@ -1033,8 +1040,8 @@ int vp8_diamond_search_sad
         for (j = 0 ; j < x->searches_per_step ; j++)
         {
             // Trap illegal vectors
-            this_row_offset = best_mv->row + ss[i].mv.row;
-            this_col_offset = best_mv->col + ss[i].mv.col;
+            this_row_offset = best_mv->as_mv.row + ss[i].mv.row;
+            this_col_offset = best_mv->as_mv.col + ss[i].mv.col;
 
             if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
             (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
@@ -1045,8 +1052,8 @@ int vp8_diamond_search_sad
 
                 if (thissad < bestsad)
                 {
-                    this_mv.row = this_row_offset;
-                    this_mv.col = this_col_offset;
+                    this_mv.as_mv.row = this_row_offset;
+                    this_mv.as_mv.col = this_col_offset;
                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                     if (thissad < bestsad)
@@ -1062,8 +1069,8 @@ int vp8_diamond_search_sad
 
         if (best_site != last_site)
         {
-            best_mv->row += ss[best_site].mv.row;
-            best_mv->col += ss[best_site].mv.col;
+            best_mv->as_mv.row += ss[best_site].mv.row;
+            best_mv->as_mv.col += ss[best_site].mv.col;
             best_address += ss[best_site].offset;
             last_site = best_site;
         }
@@ -1071,8 +1078,8 @@ int vp8_diamond_search_sad
             (*num00)++;
     }
 
-    this_mv.row = best_mv->row << 3;
-    this_mv.col = best_mv->col << 3;
+    this_mv.as_mv.row = best_mv->as_mv.row << 3;
+    this_mv.as_mv.col = best_mv->as_mv.col << 3;
 
     if (bestsad == INT_MAX)
         return INT_MAX;
@@ -1086,14 +1093,14 @@ int vp8_diamond_search_sadx4
     MACROBLOCK *x,
     BLOCK *b,
     BLOCKD *d,
-    MV *ref_mv,
-    MV *best_mv,
+    int_mv *ref_mv,
+    int_mv *best_mv,
     int search_param,
     int error_per_bit,
     int *num00,
     vp8_variance_fn_ptr_t *fn_ptr,
     int *mvcost[2],
-    MV *center_mv
+    int_mv *center_mv
 )
 {
     int i, j, step;
@@ -1105,14 +1112,14 @@ int vp8_diamond_search_sadx4
     unsigned char *best_address;
 
     int tot_steps;
-    MV this_mv;
+    int_mv this_mv;
 
     int bestsad = INT_MAX;
     int best_site = 0;
     int last_site = 0;
 
-    int ref_row = ref_mv->row >> 3;
-    int ref_col = ref_mv->col >> 3;
+    int ref_row = ref_mv->as_mv.row >> 3;
+    int ref_col = ref_mv->as_mv.col >> 3;
     int this_row_offset;
     int this_col_offset;
     search_site *ss;
@@ -1121,13 +1128,13 @@ int vp8_diamond_search_sadx4
     unsigned int thissad;
 
     int *mvsadcost[2] = {x->mvsadcost[0], x->mvsadcost[1]};
-    MV fcenter_mv;
-    fcenter_mv.row = center_mv->row >> 3;
-    fcenter_mv.col = center_mv->col >> 3;
+    int_mv fcenter_mv;
+    fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
+    fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     *num00 = 0;
-    best_mv->row = ref_row;
-    best_mv->col = ref_col;
+    best_mv->as_mv.row = ref_row;
+    best_mv->as_mv.col = ref_col;
 
     // Work out the start point for the search
     in_what = (unsigned char *)(*(d->base_pre) + d->pre + (ref_row * (d->pre_stride)) + ref_col);
@@ -1154,10 +1161,10 @@ int vp8_diamond_search_sadx4
 
         // To know if all neighbor points are within the bounds, 4 bounds checking are enough instead of
         // checking 4 bounds for each points.
-        all_in &= ((best_mv->row + ss[i].mv.row)> x->mv_row_min);
-        all_in &= ((best_mv->row + ss[i+1].mv.row) < x->mv_row_max);
-        all_in &= ((best_mv->col + ss[i+2].mv.col) > x->mv_col_min);
-        all_in &= ((best_mv->col + ss[i+3].mv.col) < x->mv_col_max);
+        all_in &= ((best_mv->as_mv.row + ss[i].mv.row)> x->mv_row_min);
+        all_in &= ((best_mv->as_mv.row + ss[i+1].mv.row) < x->mv_row_max);
+        all_in &= ((best_mv->as_mv.col + ss[i+2].mv.col) > x->mv_col_min);
+        all_in &= ((best_mv->as_mv.col + ss[i+3].mv.col) < x->mv_col_max);
 
         if (all_in)
         {
@@ -1176,8 +1183,8 @@ int vp8_diamond_search_sadx4
                 {
                     if (sad_array[t] < bestsad)
                     {
-                        this_mv.row = best_mv->row + ss[i].mv.row;
-                        this_mv.col = best_mv->col + ss[i].mv.col;
+                        this_mv.as_mv.row = best_mv->as_mv.row + ss[i].mv.row;
+                        this_mv.as_mv.col = best_mv->as_mv.col + ss[i].mv.col;
                         sad_array[t] += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                         if (sad_array[t] < bestsad)
@@ -1194,8 +1201,8 @@ int vp8_diamond_search_sadx4
             for (j = 0 ; j < x->searches_per_step ; j++)
             {
                 // Trap illegal vectors
-                this_row_offset = best_mv->row + ss[i].mv.row;
-                this_col_offset = best_mv->col + ss[i].mv.col;
+                this_row_offset = best_mv->as_mv.row + ss[i].mv.row;
+                this_col_offset = best_mv->as_mv.col + ss[i].mv.col;
 
                 if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
                 (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
@@ -1205,8 +1212,8 @@ int vp8_diamond_search_sadx4
 
                     if (thissad < bestsad)
                     {
-                        this_mv.row = this_row_offset;
-                        this_mv.col = this_col_offset;
+                        this_mv.as_mv.row = this_row_offset;
+                        this_mv.as_mv.col = this_col_offset;
                         thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                         if (thissad < bestsad)
@@ -1222,8 +1229,8 @@ int vp8_diamond_search_sadx4
 
         if (best_site != last_site)
         {
-            best_mv->row += ss[best_site].mv.row;
-            best_mv->col += ss[best_site].mv.col;
+            best_mv->as_mv.row += ss[best_site].mv.row;
+            best_mv->as_mv.col += ss[best_site].mv.col;
             best_address += ss[best_site].offset;
             last_site = best_site;
         }
@@ -1231,8 +1238,8 @@ int vp8_diamond_search_sadx4
             (*num00)++;
     }
 
-    this_mv.row = best_mv->row << 3;
-    this_mv.col = best_mv->col << 3;
+    this_mv.as_mv.row = best_mv->as_mv.row << 3;
+    this_mv.as_mv.col = best_mv->as_mv.col << 3;
 
     if (bestsad == INT_MAX)
         return INT_MAX;
@@ -1241,7 +1248,10 @@ int vp8_diamond_search_sadx4
     + mv_err_cost(&this_mv, center_mv, mvcost, error_per_bit);
 }
 
-int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int error_per_bit, int distance, vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2], MV *center_mv)
+int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
+                        int error_per_bit, int distance,
+                        vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
+                        int_mv *center_mv)
 {
     unsigned char *what = (*(b->base_src) + b->src);
     int what_stride = b->src_stride;
@@ -1249,16 +1259,16 @@ int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int erro
     int in_what_stride = d->pre_stride;
     int mv_stride = d->pre_stride;
     unsigned char *bestaddress;
-    MV *best_mv = &d->bmi.mv.as_mv;
-    MV this_mv;
+    int_mv *best_mv = &d->bmi.mv;
+    int_mv this_mv;
     int bestsad = INT_MAX;
     int r, c;
 
     unsigned char *check_here;
     int thissad;
 
-    int ref_row = ref_mv->row;
-    int ref_col = ref_mv->col;
+    int ref_row = ref_mv->as_mv.row;
+    int ref_col = ref_mv->as_mv.col;
 
     int row_min = ref_row - distance;
     int row_max = ref_row + distance;
@@ -1266,16 +1276,16 @@ int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int erro
     int col_max = ref_col + distance;
 
     int *mvsadcost[2] = {x->mvsadcost[0], x->mvsadcost[1]};
-    MV fcenter_mv;
-    fcenter_mv.row = center_mv->row >> 3;
-    fcenter_mv.col = center_mv->col >> 3;
+    int_mv fcenter_mv;
+    fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
+    fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     // Work out the mid point for the search
     in_what = *(d->base_pre) + d->pre;
     bestaddress = in_what + (ref_row * d->pre_stride) + ref_col;
 
-    best_mv->row = ref_row;
-    best_mv->col = ref_col;
+    best_mv->as_mv.row = ref_row;
+    best_mv->as_mv.col = ref_col;
 
     // We need to check that the starting point for the search (as indicated by ref_mv) is within the buffer limits
     if ((ref_col > x->mv_col_min) && (ref_col < x->mv_col_max) &&
@@ -1302,14 +1312,14 @@ int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int erro
 
     for (r = row_min; r < row_max ; r++)
     {
-        this_mv.row = r;
+        this_mv.as_mv.row = r;
         check_here = r * mv_stride + in_what + col_min;
 
         for (c = col_min; c < col_max; c++)
         {
             thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride, bestsad);
 
-            this_mv.col = c;
+            this_mv.as_mv.col = c;
             //thissad += (int)sqrt(mv_err_cost(&this_mv,ref_mv, mvcost,error_per_bit*14));
             //thissad  += error_per_bit * mv_bits_sadcost[mv_bits(&this_mv, ref_mv, mvcost)];
             thissad  += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit); //mv_bits(error_per_bit, &this_mv, ref_mv, mvsadcost);
@@ -1317,8 +1327,8 @@ int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int erro
             if (thissad < bestsad)
             {
                 bestsad = thissad;
-                best_mv->row = r;
-                best_mv->col = c;
+                best_mv->as_mv.row = r;
+                best_mv->as_mv.col = c;
                 bestaddress = check_here;
             }
 
@@ -1326,8 +1336,8 @@ int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int erro
         }
     }
 
-    this_mv.row = best_mv->row << 3;
-    this_mv.col = best_mv->col << 3;
+    this_mv.as_mv.row = best_mv->as_mv.row << 3;
+    this_mv.as_mv.col = best_mv->as_mv.col << 3;
 
     if (bestsad < INT_MAX)
         return fn_ptr->vf(what, what_stride, bestaddress, in_what_stride, (unsigned int *)(&thissad))
@@ -1336,7 +1346,10 @@ int vp8_full_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int erro
         return INT_MAX;
 }
 
-int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int error_per_bit, int distance, vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2], MV *center_mv)
+int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
+                          int error_per_bit, int distance,
+                          vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
+                          int_mv *center_mv)
 {
     unsigned char *what = (*(b->base_src) + b->src);
     int what_stride = b->src_stride;
@@ -1344,16 +1357,16 @@ int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
     int in_what_stride = d->pre_stride;
     int mv_stride = d->pre_stride;
     unsigned char *bestaddress;
-    MV *best_mv = &d->bmi.mv.as_mv;
-    MV this_mv;
+    int_mv *best_mv = &d->bmi.mv;
+    int_mv this_mv;
     int bestsad = INT_MAX;
     int r, c;
 
     unsigned char *check_here;
     unsigned int thissad;
 
-    int ref_row = ref_mv->row;
-    int ref_col = ref_mv->col;
+    int ref_row = ref_mv->as_mv.row;
+    int ref_col = ref_mv->as_mv.col;
 
     int row_min = ref_row - distance;
     int row_max = ref_row + distance;
@@ -1363,16 +1376,16 @@ int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
     unsigned int sad_array[3];
 
     int *mvsadcost[2] = {x->mvsadcost[0], x->mvsadcost[1]};
-    MV fcenter_mv;
-    fcenter_mv.row = center_mv->row >> 3;
-    fcenter_mv.col = center_mv->col >> 3;
+    int_mv fcenter_mv;
+    fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
+    fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     // Work out the mid point for the search
     in_what = *(d->base_pre) + d->pre;
     bestaddress = in_what + (ref_row * d->pre_stride) + ref_col;
 
-    best_mv->row = ref_row;
-    best_mv->col = ref_col;
+    best_mv->as_mv.row = ref_row;
+    best_mv->as_mv.col = ref_col;
 
     // We need to check that the starting point for the search (as indicated by ref_mv) is within the buffer limits
     if ((ref_col > x->mv_col_min) && (ref_col < x->mv_col_max) &&
@@ -1397,7 +1410,7 @@ int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
     for (r = row_min; r < row_max ; r++)
     {
-        this_mv.row = r;
+        this_mv.as_mv.row = r;
         check_here = r * mv_stride + in_what + col_min;
         c = col_min;
 
@@ -1413,14 +1426,14 @@ int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
                 if (thissad < bestsad)
                 {
-                    this_mv.col = c;
+                    this_mv.as_mv.col = c;
                     thissad  += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                     if (thissad < bestsad)
                     {
                         bestsad = thissad;
-                        best_mv->row = r;
-                        best_mv->col = c;
+                        best_mv->as_mv.row = r;
+                        best_mv->as_mv.col = c;
                         bestaddress = check_here;
                     }
                 }
@@ -1436,14 +1449,14 @@ int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
             if (thissad < bestsad)
             {
-                this_mv.col = c;
+                this_mv.as_mv.col = c;
                 thissad  += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                 if (thissad < bestsad)
                 {
                     bestsad = thissad;
-                    best_mv->row = r;
-                    best_mv->col = c;
+                    best_mv->as_mv.row = r;
+                    best_mv->as_mv.col = c;
                     bestaddress = check_here;
                 }
             }
@@ -1454,8 +1467,8 @@ int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
     }
 
-    this_mv.row = best_mv->row << 3;
-    this_mv.col = best_mv->col << 3;
+    this_mv.as_mv.row = best_mv->as_mv.row << 3;
+    this_mv.as_mv.col = best_mv->as_mv.col << 3;
 
     if (bestsad < INT_MAX)
         return fn_ptr->vf(what, what_stride, bestaddress, in_what_stride, (unsigned int *)(&thissad))
@@ -1464,7 +1477,10 @@ int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
         return INT_MAX;
 }
 
-int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int error_per_bit, int distance, vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2], MV *center_mv)
+int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
+                          int error_per_bit, int distance,
+                          vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
+                          int_mv *center_mv)
 {
     unsigned char *what = (*(b->base_src) + b->src);
     int what_stride = b->src_stride;
@@ -1472,16 +1488,16 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
     int in_what_stride = d->pre_stride;
     int mv_stride = d->pre_stride;
     unsigned char *bestaddress;
-    MV *best_mv = &d->bmi.mv.as_mv;
-    MV this_mv;
+    int_mv *best_mv = &d->bmi.mv;
+    int_mv this_mv;
     int bestsad = INT_MAX;
     int r, c;
 
     unsigned char *check_here;
     unsigned int thissad;
 
-    int ref_row = ref_mv->row;
-    int ref_col = ref_mv->col;
+    int ref_row = ref_mv->as_mv.row;
+    int ref_col = ref_mv->as_mv.col;
 
     int row_min = ref_row - distance;
     int row_max = ref_row + distance;
@@ -1492,16 +1508,16 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
     unsigned int sad_array[3];
 
     int *mvsadcost[2] = {x->mvsadcost[0], x->mvsadcost[1]};
-    MV fcenter_mv;
-    fcenter_mv.row = center_mv->row >> 3;
-    fcenter_mv.col = center_mv->col >> 3;
+    int_mv fcenter_mv;
+    fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
+    fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     // Work out the mid point for the search
     in_what = *(d->base_pre) + d->pre;
     bestaddress = in_what + (ref_row * d->pre_stride) + ref_col;
 
-    best_mv->row = ref_row;
-    best_mv->col = ref_col;
+    best_mv->as_mv.row = ref_row;
+    best_mv->as_mv.col = ref_col;
 
     // We need to check that the starting point for the search (as indicated by ref_mv) is within the buffer limits
     if ((ref_col > x->mv_col_min) && (ref_col < x->mv_col_max) &&
@@ -1526,7 +1542,7 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
     for (r = row_min; r < row_max ; r++)
     {
-        this_mv.row = r;
+        this_mv.as_mv.row = r;
         check_here = r * mv_stride + in_what + col_min;
         c = col_min;
 
@@ -1542,14 +1558,14 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
                 if (thissad < bestsad)
                 {
-                    this_mv.col = c;
+                    this_mv.as_mv.col = c;
                     thissad  += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                     if (thissad < bestsad)
                     {
                         bestsad = thissad;
-                        best_mv->row = r;
-                        best_mv->col = c;
+                        best_mv->as_mv.row = r;
+                        best_mv->as_mv.col = c;
                         bestaddress = check_here;
                     }
                 }
@@ -1571,14 +1587,14 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
                 if (thissad < bestsad)
                 {
-                    this_mv.col = c;
+                    this_mv.as_mv.col = c;
                     thissad  += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                     if (thissad < bestsad)
                     {
                         bestsad = thissad;
-                        best_mv->row = r;
-                        best_mv->col = c;
+                        best_mv->as_mv.row = r;
+                        best_mv->as_mv.col = c;
                         bestaddress = check_here;
                     }
                 }
@@ -1594,14 +1610,14 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
 
             if (thissad < bestsad)
             {
-                this_mv.col = c;
+                this_mv.as_mv.col = c;
                 thissad  += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                 if (thissad < bestsad)
                 {
                     bestsad = thissad;
-                    best_mv->row = r;
-                    best_mv->col = c;
+                    best_mv->as_mv.row = r;
+                    best_mv->as_mv.col = c;
                     bestaddress = check_here;
                 }
             }
@@ -1611,8 +1627,8 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
         }
     }
 
-    this_mv.row = best_mv->row << 3;
-    this_mv.col = best_mv->col << 3;
+    this_mv.as_mv.row = best_mv->as_mv.row << 3;
+    this_mv.as_mv.col = best_mv->as_mv.col << 3;
 
     if (bestsad < INT_MAX)
         return fn_ptr->vf(what, what_stride, bestaddress, in_what_stride, (unsigned int *)(&thissad))
@@ -1621,7 +1637,10 @@ int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int er
         return INT_MAX;
 }
 
-int vp8_refining_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int error_per_bit, int search_range, vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2], MV *center_mv)
+int vp8_refining_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
+                            int error_per_bit, int search_range,
+                            vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
+                            int_mv *center_mv)
 {
     MV neighbors[4] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
     int i, j;
@@ -1630,17 +1649,18 @@ int vp8_refining_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int
     int what_stride = b->src_stride;
     int in_what_stride = d->pre_stride;
     unsigned char *what = (*(b->base_src) + b->src);
-    unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre + (ref_mv->row * (d->pre_stride)) + ref_mv->col);
+    unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre +
+        (ref_mv->as_mv.row * (d->pre_stride)) + ref_mv->as_mv.col);
     unsigned char *check_here;
     unsigned int thissad;
-    MV this_mv;
+    int_mv this_mv;
     unsigned int bestsad = INT_MAX;
 
     int *mvsadcost[2] = {x->mvsadcost[0], x->mvsadcost[1]};
-    MV fcenter_mv;
+    int_mv fcenter_mv;
 
-    fcenter_mv.row = center_mv->row >> 3;
-    fcenter_mv.col = center_mv->col >> 3;
+    fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
+    fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     bestsad = fn_ptr->sdf(what, what_stride, best_address, in_what_stride, 0x7fffffff) + mvsad_err_cost(ref_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
@@ -1650,8 +1670,8 @@ int vp8_refining_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int
 
         for (j = 0 ; j < 4 ; j++)
         {
-            this_row_offset = ref_mv->row + neighbors[j].row;
-            this_col_offset = ref_mv->col + neighbors[j].col;
+            this_row_offset = ref_mv->as_mv.row + neighbors[j].row;
+            this_col_offset = ref_mv->as_mv.col + neighbors[j].col;
 
             if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
             (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
@@ -1661,8 +1681,8 @@ int vp8_refining_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int
 
                 if (thissad < bestsad)
                 {
-                    this_mv.row = this_row_offset;
-                    this_mv.col = this_col_offset;
+                    this_mv.as_mv.row = this_row_offset;
+                    this_mv.as_mv.col = this_col_offset;
                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                     if (thissad < bestsad)
@@ -1678,14 +1698,14 @@ int vp8_refining_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int
             break;
         else
         {
-            ref_mv->row += neighbors[best_site].row;
-            ref_mv->col += neighbors[best_site].col;
+            ref_mv->as_mv.row += neighbors[best_site].row;
+            ref_mv->as_mv.col += neighbors[best_site].col;
             best_address += (neighbors[best_site].row)*in_what_stride + neighbors[best_site].col;
         }
     }
 
-    this_mv.row = ref_mv->row << 3;
-    this_mv.col = ref_mv->col << 3;
+    this_mv.as_mv.row = ref_mv->as_mv.row << 3;
+    this_mv.as_mv.col = ref_mv->as_mv.col << 3;
 
     if (bestsad < INT_MAX)
         return fn_ptr->vf(what, what_stride, best_address, in_what_stride, (unsigned int *)(&thissad))
@@ -1694,7 +1714,10 @@ int vp8_refining_search_sad(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int
         return INT_MAX;
 }
 
-int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, int error_per_bit, int search_range, vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2], MV *center_mv)
+int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
+                              int_mv *ref_mv, int error_per_bit,
+                              int search_range, vp8_variance_fn_ptr_t *fn_ptr,
+                              int *mvcost[2], int_mv *center_mv)
 {
     MV neighbors[4] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
     int i, j;
@@ -1703,17 +1726,18 @@ int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, in
     int what_stride = b->src_stride;
     int in_what_stride = d->pre_stride;
     unsigned char *what = (*(b->base_src) + b->src);
-    unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre + (ref_mv->row * (d->pre_stride)) + ref_mv->col);
+    unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre +
+        (ref_mv->as_mv.row * (d->pre_stride)) + ref_mv->as_mv.col);
     unsigned char *check_here;
     unsigned int thissad;
-    MV this_mv;
+    int_mv this_mv;
     unsigned int bestsad = INT_MAX;
 
     int *mvsadcost[2] = {x->mvsadcost[0], x->mvsadcost[1]};
-    MV fcenter_mv;
+    int_mv fcenter_mv;
 
-    fcenter_mv.row = center_mv->row >> 3;
-    fcenter_mv.col = center_mv->col >> 3;
+    fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
+    fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 
     bestsad = fn_ptr->sdf(what, what_stride, best_address, in_what_stride, 0x7fffffff) + mvsad_err_cost(ref_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
@@ -1722,10 +1746,10 @@ int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, in
         int best_site = -1;
         int all_in = 1;
 
-        all_in &= ((ref_mv->row - 1) > x->mv_row_min);
-        all_in &= ((ref_mv->row + 1) < x->mv_row_max);
-        all_in &= ((ref_mv->col - 1) > x->mv_col_min);
-        all_in &= ((ref_mv->col + 1) < x->mv_col_max);
+        all_in &= ((ref_mv->as_mv.row - 1) > x->mv_row_min);
+        all_in &= ((ref_mv->as_mv.row + 1) < x->mv_row_max);
+        all_in &= ((ref_mv->as_mv.col - 1) > x->mv_col_min);
+        all_in &= ((ref_mv->as_mv.col + 1) < x->mv_col_max);
 
         if(all_in)
         {
@@ -1742,8 +1766,8 @@ int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, in
             {
                 if (sad_array[j] < bestsad)
                 {
-                    this_mv.row = ref_mv->row + neighbors[j].row;
-                    this_mv.col = ref_mv->col + neighbors[j].col;
+                    this_mv.as_mv.row = ref_mv->as_mv.row + neighbors[j].row;
+                    this_mv.as_mv.col = ref_mv->as_mv.col + neighbors[j].col;
                     sad_array[j] += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                     if (sad_array[j] < bestsad)
@@ -1758,8 +1782,8 @@ int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, in
         {
             for (j = 0 ; j < 4 ; j++)
             {
-                this_row_offset = ref_mv->row + neighbors[j].row;
-                this_col_offset = ref_mv->col + neighbors[j].col;
+                this_row_offset = ref_mv->as_mv.row + neighbors[j].row;
+                this_col_offset = ref_mv->as_mv.col + neighbors[j].col;
 
                 if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
                 (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
@@ -1769,8 +1793,8 @@ int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, in
 
                     if (thissad < bestsad)
                     {
-                        this_mv.row = this_row_offset;
-                        this_mv.col = this_col_offset;
+                        this_mv.as_mv.row = this_row_offset;
+                        this_mv.as_mv.col = this_col_offset;
                         thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
 
                         if (thissad < bestsad)
@@ -1787,14 +1811,14 @@ int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, MV *ref_mv, in
             break;
         else
         {
-            ref_mv->row += neighbors[best_site].row;
-            ref_mv->col += neighbors[best_site].col;
+            ref_mv->as_mv.row += neighbors[best_site].row;
+            ref_mv->as_mv.col += neighbors[best_site].col;
             best_address += (neighbors[best_site].row)*in_what_stride + neighbors[best_site].col;
         }
     }
 
-    this_mv.row = ref_mv->row << 3;
-    this_mv.col = ref_mv->col << 3;
+    this_mv.as_mv.row = ref_mv->as_mv.row << 3;
+    this_mv.as_mv.col = ref_mv->as_mv.col << 3;
 
     if (bestsad < INT_MAX)
         return fn_ptr->vf(what, what_stride, best_address, in_what_stride, (unsigned int *)(&thissad))

diff --git a/vp8/encoder/mcomp.h b/vp8/encoder/mcomp.h
index d655b83..85c7513 100644 (file)
--- a/vp8/encoder/mcomp.h
+++ b/vp8/encoder/mcomp.h
@@ -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
 
 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_init3smotion_compensation(MACROBLOCK *x,  int stride);
 
@@ -36,20 +36,21 @@ extern int vp8_hex_search
     MACROBLOCK *x,
     BLOCK *b,
     BLOCKD *d,
-    MV *ref_mv,
-    MV *best_mv,
+    int_mv *ref_mv,
+    int_mv *best_mv,
     int search_param,
     int error_per_bit,
     int *num00,
     const vp8_variance_fn_ptr_t *vf,
     int *mvsadcost[2],
     int *mvcost[2],
-    MV *center_mv
+    int_mv *center_mv
 );
 
 typedef int (fractional_mv_step_fp)
-    (MACROBLOCK *x, 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);
+    (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);
 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_half_pixel_step;
@@ -61,12 +62,12 @@ extern fractional_mv_step_fp vp8_skip_fractional_mv_step;
      MACROBLOCK *x, \
      BLOCK *b, \
      BLOCKD *d, \
-     MV *ref_mv, \
+     int_mv *ref_mv, \
      int error_per_bit, \
      int distance, \
      vp8_variance_fn_ptr_t *fn_ptr, \
      int *mvcost[2], \
-     MV *center_mv \
+     int_mv *center_mv \
     )
 
 #define prototype_refining_search_sad(sym)\
@@ -75,12 +76,12 @@ extern fractional_mv_step_fp vp8_skip_fractional_mv_step;
      MACROBLOCK *x, \
      BLOCK *b, \
      BLOCKD *d, \
-     MV *ref_mv, \
+     int_mv *ref_mv, \
      int error_per_bit, \
      int distance, \
      vp8_variance_fn_ptr_t *fn_ptr, \
      int *mvcost[2], \
-     MV *center_mv \
+     int_mv *center_mv \
     )
 
 #define prototype_diamond_search_sad(sym)\
@@ -89,14 +90,14 @@ extern fractional_mv_step_fp vp8_skip_fractional_mv_step;
      MACROBLOCK *x, \
      BLOCK *b, \
      BLOCKD *d, \
-     MV *ref_mv, \
-     MV *best_mv, \
+     int_mv *ref_mv, \
+     int_mv *best_mv, \
      int search_param, \
      int error_per_bit, \
      int *num00, \
      vp8_variance_fn_ptr_t *fn_ptr, \
      int *mvcost[2], \
-     MV *center_mv \
+     int_mv *center_mv \
     )
 
 #if ARCH_X86 || ARCH_X86_64

diff --git a/vp8/encoder/pickinter.c b/vp8/encoder/pickinter.c
index ea4f01f..61d6612 100644 (file)
--- a/vp8/encoder/pickinter.c
+++ b/vp8/encoder/pickinter.c
@@ -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 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 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) d;
@@ -60,8 +65,8 @@ int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, MV *bestmv,
     (void) mvcost;
     (void) distortion;
     (void) sse;
-    bestmv->row <<= 3;
-    bestmv->col <<= 3;
+    bestmv->as_mv.row <<= 3;
+    bestmv->as_mv.col <<= 3;
     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];
     MB_MODE_INFO best_mbmode;
     PARTITION_INFO best_partition;
-    MV best_ref_mv;
-    MV mode_mv[MB_MODE_COUNT];
+    int_mv best_ref_mv;
+    int_mv mode_mv[MB_MODE_COUNT];
     MB_PREDICTION_MODE this_mode;
     int num00;
     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;
     unsigned int sse = INT_MAX;
 
-    MV mvp;
+    int_mv mvp;
     int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
     int saddone=0;
     int sr=0;    //search range got from mv_pred(). It uses step_param levels. (0-7)
 
-    MV nearest_mv[4];
-    MV near_mv[4];
-    MV frame_best_ref_mv[4];
+    int_mv nearest_mv[4];
+    int_mv near_mv[4];
+    int_mv frame_best_ref_mv[4];
     int MDCounts[4][4];
     unsigned char *y_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]);
 
             /* adjust mvp to make sure it is within MV range */
-            if(mvp.row > best_ref_mv.row + MAX_FULL_PEL_VAL)
-                mvp.row = best_ref_mv.row + MAX_FULL_PEL_VAL;
-            else if(mvp.row < best_ref_mv.row - MAX_FULL_PEL_VAL)
-                mvp.row = best_ref_mv.row - MAX_FULL_PEL_VAL;
-            if(mvp.col > best_ref_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;
+            vp8_clamp_mv(&mvp,
+                         best_ref_mv.as_mv.row - MAX_FULL_PEL_VAL,
+                         best_ref_mv.as_mv.row + MAX_FULL_PEL_VAL,
+                         best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL,
+                         best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL);
         }
 
         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)
                     step_param = sr;
 
-                col_min = (best_ref_mv.col - MAX_FULL_PEL_VAL) >>3;
-                col_max = (best_ref_mv.col + MAX_FULL_PEL_VAL) >>3;
-                row_min = (best_ref_mv.row - MAX_FULL_PEL_VAL) >>3;
-                row_max = (best_ref_mv.row + MAX_FULL_PEL_VAL) >>3;
+                col_min = (best_ref_mv.as_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.as_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.
                 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;
             }else
             {
-                mvp.row = best_ref_mv.row;
-                mvp.col = best_ref_mv.col;
+                mvp.as_int = best_ref_mv.as_int;
             }
 
             further_steps = (cpi->Speed >= 8)? 0: (cpi->sf.max_step_search_steps - 1 - step_param);
 
             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);
-                mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
-                mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
+                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].as_int = d->bmi.mv.as_int;
             }
             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
-                mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
-                mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
+                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].as_int = d->bmi.mv.as_int;
 
                 // Further step/diamond searches as necessary
                 n = 0;
@@ -772,18 +771,21 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
                         num00--;
                     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)
                         {
                             bestsme = thissme;
-                            mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
-                            mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
+                            mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
                         }
                         else
                         {
-                            d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
-                            d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
+                            d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
                         }
                     }
                 }
@@ -798,10 +800,9 @@ void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int re
             }
 
             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].col = d->bmi.mv.as_mv.col;
+            mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
 
             // mv cost;
             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 NEARMV:
 
-            if (mode_mv[this_mode].row == 0 && mode_mv[this_mode].col == 0)
+            if (mode_mv[this_mode].as_int == 0)
                 continue;
 
         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
             // 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.
-            if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].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))
+            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].as_mv.col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
                 continue;
 
             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.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.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
     {
-        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;

diff --git a/vp8/encoder/rdopt.c b/vp8/encoder/rdopt.c
index 880153f..85d617d 100644 (file)
--- a/vp8/encoder/rdopt.c
+++ b/vp8/encoder/rdopt.c
@@ -848,20 +848,18 @@ int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4])
                           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;
 
     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_mv.col = mv->col;
+    x->e_mbd.mode_info_context->mbmi.mv.as_int = mv->as_int;
 
     for (i = 0; i < 16; i++)
     {
         B_MODE_INFO *bmi = &x->e_mbd.block[i].bmi;
         bmi->mode = (B_PREDICTION_MODE) mb;
-        bmi->mv.as_mv.row = mv->row;
-        bmi->mv.as_mv.col = mv->col;
+        bmi->mv.as_int = mv->as_int;
     }
 }
 
@@ -869,7 +867,7 @@ static int labels2mode(
     MACROBLOCK *x,
     int const *labelings, int which_label,
     B_PREDICTION_MODE this_mode,
-    MV *this_mv, MV *best_ref_mv,
+    int_mv *this_mv, int_mv *best_ref_mv,
     int *mvcost[2]
 )
 {
@@ -910,13 +908,13 @@ static int labels2mode(
                 thismvcost  = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102);
                 break;
             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;
             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;
             case ZERO4X4:
-                this_mv->row = this_mv->col = 0;
+                this_mv->as_int = 0;
                 break;
             default:
                 break;
@@ -924,9 +922,11 @@ static int labels2mode(
 
             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;
             }
 
@@ -934,7 +934,7 @@ static int labels2mode(
         }
 
         d->bmi.mode = m;
-        d->bmi.mv.as_mv = *this_mv;
+        d->bmi.mv.as_int = this_mv->as_int;
 
     }
     while (++i < 16);
@@ -994,8 +994,8 @@ static const unsigned int segmentation_to_sseshift[4] = {3, 3, 2, 0};
 
 typedef struct
 {
-  MV *ref_mv;
-  MV *mvp;
+  int_mv *ref_mv;
+  int_mv mvp;
 
   int segment_rd;
   int segment_num;
@@ -1009,7 +1009,7 @@ typedef struct
   int mvthresh;
   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
 
 } BEST_SEG_INFO;
@@ -1071,7 +1071,7 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
 
     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;
         B_PREDICTION_MODE mode_selected = ZERO4X4;
         int bestlabelyrate = 0;
@@ -1101,7 +1101,7 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                 int n;
                 int thissme;
                 int bestsme = INT_MAX;
-                MV  temp_mv;
+                int_mv  temp_mv;
                 BLOCK *c;
                 BLOCKD *e;
 
@@ -1113,8 +1113,9 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                 {
                     if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8)
                     {
-                        bsi->mvp = &bsi->sv_mvp[i];
-                        if (i==1 && segmentation == BLOCK_16X8) bsi->mvp = &bsi->sv_mvp[2];
+                        bsi->mvp.as_int = bsi->sv_mvp[i].as_int;
+                        if (i==1 && segmentation == BLOCK_16X8)
+                          bsi->mvp.as_int = bsi->sv_mvp[2].as_int;
 
                         step_param = bsi->sv_istep[i];
                     }
@@ -1122,8 +1123,9 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                     // use previous block's result as next block's MV predictor.
                     if (segmentation == BLOCK_4X4 && i>0)
                     {
-                        bsi->mvp = &(x->e_mbd.block[i-1].bmi.mv.as_mv);
-                        if (i==4 || i==8 || i==12) bsi->mvp = &(x->e_mbd.block[i-4].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.as_int = x->e_mbd.block[i-4].bmi.mv.as_int;
                         step_param = 2;
                     }
                 }
@@ -1145,7 +1147,7 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
 
                     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,
                                                           sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv);
 
@@ -1160,15 +1162,14 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                                 num00--;
                             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,
                                                                   sadpb / 2, &num00, v_fn_ptr, x->mvcost, bsi->ref_mv);
 
                                 if (thissme < bestsme)
                                 {
                                     bestsme = thissme;
-                                    mode_mv[NEW4X4].row = temp_mv.row;
-                                    mode_mv[NEW4X4].col = temp_mv.col;
+                                    mode_mv[NEW4X4].as_int = temp_mv.as_int;
                                 }
                             }
                         }
@@ -1179,10 +1180,10 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                     // Should we do a full search (best quality only)
                     if ((cpi->compressor_speed == 0) && (bestsme >> sseshift) > 4000)
                     {
-                        MV full_mvp;
+                        int_mv full_mvp;
 
-                        full_mvp.row = bsi->mvp->row >>3;
-                        full_mvp.col = bsi->mvp->col >>3;
+                        full_mvp.as_mv.row = bsi->mvp.as_mv.row >>3;
+                        full_mvp.as_mv.col = bsi->mvp.as_mv.col >>3;
 
                         thissme = cpi->full_search_sad(x, c, e, &full_mvp,
                                                        sadpb / 4, 16, v_fn_ptr, x->mvcost, bsi->ref_mv);
@@ -1190,12 +1191,12 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                         if (thissme < bestsme)
                         {
                             bestsme = thissme;
-                            mode_mv[NEW4X4] = e->bmi.mv.as_mv;
+                            mode_mv[NEW4X4].as_int = e->bmi.mv.as_int;
                         }
                         else
                         {
                             // 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;
                         }
                     }
                 }
@@ -1218,8 +1219,8 @@ static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                                bsi->ref_mv, x->mvcost);
 
             // 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) ||
-                ((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_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].as_mv.col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
             {
                 continue;
             }
@@ -1296,7 +1297,7 @@ void vp8_cal_step_param(int sr, int *sp)
 }
 
 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 *returnyrate, int *returndistortion,
                                            int mvthresh)
@@ -1308,7 +1309,7 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
 
     bsi.segment_rd = best_rd;
     bsi.ref_mv = best_ref_mv;
-    bsi.mvp = best_ref_mv;
+    bsi.mvp.as_int = best_ref_mv->as_int;
     bsi.mvthresh = mvthresh;
     bsi.mdcounts = mdcounts;
 
@@ -1334,10 +1335,10 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
 
         if (bsi.segment_rd < best_rd)
         {
-            int col_min = (best_ref_mv->col - MAX_FULL_PEL_VAL) >>3;
-            int col_max = (best_ref_mv->col + MAX_FULL_PEL_VAL) >>3;
-            int row_min = (best_ref_mv->row - MAX_FULL_PEL_VAL) >>3;
-            int row_max = (best_ref_mv->row + 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->as_mv.col + 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->as_mv.row + MAX_FULL_PEL_VAL) >>3;
 
             int tmp_col_min = x->mv_col_min;
             int tmp_col_max = x->mv_col_max;
@@ -1355,18 +1356,18 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
                 x->mv_row_max = row_max;
 
             /* Get 8x8 result */
-            bsi.sv_mvp[0] = bsi.mvs[0].as_mv;
-            bsi.sv_mvp[1] = bsi.mvs[2].as_mv;
-            bsi.sv_mvp[2] = bsi.mvs[8].as_mv;
-            bsi.sv_mvp[3] = bsi.mvs[10].as_mv;
+            bsi.sv_mvp[0].as_int = bsi.mvs[0].as_int;
+            bsi.sv_mvp[1].as_int = bsi.mvs[2].as_int;
+            bsi.sv_mvp[2].as_int = bsi.mvs[8].as_int;
+            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. */
             /* 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]);
 
-                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]);
 
                 rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
@@ -1374,10 +1375,10 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
 
             /* 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]);
 
-                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]);
 
                 rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
@@ -1387,7 +1388,7 @@ static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
             /* 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) */
             {
-                bsi.mvp = &bsi.sv_mvp[0];
+                bsi.mvp.as_int = bsi.sv_mvp[0].as_int;
                 rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
             }
 
@@ -1487,7 +1488,7 @@ void vp8_mv_pred
     VP8_COMP *cpi,
     MACROBLOCKD *xd,
     const MODE_INFO *here,
-    MV *mvp,
+    int_mv *mvp,
     int refframe,
     int *ref_frame_sign_bias,
     int *sr,
@@ -1626,8 +1627,8 @@ void vp8_mv_pred
     }
 
     /* Set up return values */
-    *mvp = mv.as_mv;
-    vp8_clamp_mv(mvp, xd);
+    mvp->as_int = mv.as_int;
+    vp8_clamp_mv2(mvp, xd);
 }
 
 void vp8_cal_sad(VP8_COMP *cpi, MACROBLOCKD *xd, MACROBLOCK *x, int recon_yoffset, int near_sadidx[])
@@ -1693,8 +1694,8 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
     B_MODE_INFO best_bmodes[16];
     MB_MODE_INFO best_mbmode;
     PARTITION_INFO best_partition;
-    MV best_ref_mv;
-    MV mode_mv[MB_MODE_COUNT];
+    int_mv best_ref_mv;
+    int_mv mode_mv[MB_MODE_COUNT];
     MB_PREDICTION_MODE this_mode;
     int num00;
     int best_mode_index = 0;
@@ -1719,14 +1720,14 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
     //int intermodecost[MAX_MODES];
 
     MB_PREDICTION_MODE uv_intra_mode;
-    MV mvp;
+    int_mv mvp;
     int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
     int saddone=0;
     int sr=0;    //search range got from mv_pred(). It uses step_param levels. (0-7)
 
-    MV frame_nearest_mv[4];
-    MV frame_near_mv[4];
-    MV frame_best_ref_mv[4];
+    int_mv frame_nearest_mv[4];
+    int_mv frame_near_mv[4];
+    int_mv frame_best_ref_mv[4];
     int frame_mdcounts[4][4];
     int frame_lf_or_gf[4];
     unsigned char *y_buffer[4];
@@ -1876,14 +1877,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]);
 
             /* adjust mvp to make sure it is within MV range */
-            if(mvp.row > best_ref_mv.row + MAX_FULL_PEL_VAL)
-                mvp.row = best_ref_mv.row + MAX_FULL_PEL_VAL;
-            else if(mvp.row < best_ref_mv.row - MAX_FULL_PEL_VAL)
-                mvp.row = best_ref_mv.row - MAX_FULL_PEL_VAL;
-            if(mvp.col > best_ref_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;
+            vp8_clamp_mv(&mvp,
+                         best_ref_mv.as_mv.row - MAX_FULL_PEL_VAL,
+                         best_ref_mv.as_mv.row + MAX_FULL_PEL_VAL,
+                         best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL,
+                         best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL);
         }
 
         // Check to see if the testing frequency for this mode is at its max
@@ -2015,10 +2013,10 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
 
             int sadpb = x->sadperbit16;
 
-            int col_min = (best_ref_mv.col - MAX_FULL_PEL_VAL) >>3;
-            int col_max = (best_ref_mv.col + MAX_FULL_PEL_VAL) >>3;
-            int row_min = (best_ref_mv.row - MAX_FULL_PEL_VAL) >>3;
-            int row_max = (best_ref_mv.row + 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.as_mv.col + 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.as_mv.row + MAX_FULL_PEL_VAL) >>3;
 
             int tmp_col_min = x->mv_col_min;
             int tmp_col_max = x->mv_col_max;
@@ -2042,15 +2040,13 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
             // Initial step/diamond search
             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);
-                mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
-                mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
+                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].as_int = d->bmi.mv.as_int;
             }
             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
-                mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
-                mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
+                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].as_int = d->bmi.mv.as_int;
 
                 // Further step/diamond searches as necessary
                 n = 0;
@@ -2071,7 +2067,7 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
                         num00--;
                     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. */
                         if (num00 > (further_steps-n))
@@ -2080,13 +2076,11 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
                         if (thissme < bestsme)
                         {
                             bestsme = thissme;
-                            mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
-                            mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
+                            mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
                         }
                         else
                         {
-                            d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
-                            d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
+                            d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
                         }
                     }
                 }
@@ -2102,18 +2096,16 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
                 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->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)
                 {
                     bestsme = thissme;
-                    mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
-                    mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
+                    mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
                 }
                 else
                 {
-                    d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
-                    d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
+                    d->bmi.mv.as_int = mode_mv[NEWMV].as_int;
                 }
             }
 
@@ -2126,11 +2118,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. */
                 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].col = d->bmi.mv.as_mv.col;
+            mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
 
             // 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);
@@ -2138,21 +2129,11 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
 
         case NEARESTMV:
         case NEARMV:
-
             // 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))
-                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;
+            vp8_clamp_mv2(&mode_mv[this_mode], xd);
 
             // 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)) &&
-                ((mode_mv[this_mode].row == 0) && (mode_mv[this_mode].col == 0)))
+            if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) && (mode_mv[this_mode].as_int == 0))
                 continue;
 
         case ZEROMV:
@@ -2160,8 +2141,8 @@ void vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int
             // 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
             // 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) ||
-                ((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_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].as_mv.col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
                 continue;
 
             vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]);

diff --git a/vp8/encoder/rdopt.h b/vp8/encoder/rdopt.h
index 1d5f9a3..fbbf907 100644 (file)
--- a/vp8/encoder/rdopt.h
+++ b/vp8/encoder/rdopt.h
@@ -25,7 +25,7 @@ extern void vp8_mv_pred
     VP8_COMP *cpi,
     MACROBLOCKD *xd,
     const MODE_INFO *here,
-    MV *mvp,
+    int_mv *mvp,
     int refframe,
     int *ref_frame_sign_bias,
     int *sr,

diff --git a/vp8/encoder/temporal_filter.c b/vp8/encoder/temporal_filter.c
index 48e3b96..483a98c 100644 (file)
--- a/vp8/encoder/temporal_filter.c
+++ b/vp8/encoder/temporal_filter.c
@@ -157,7 +157,7 @@ static int vp8_temporal_filter_find_matching_mb_c
 
     BLOCK *b = &x->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 *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_stride = d->pre_stride;
 
+    best_ref_mv1.as_int = 0;
+
     // Setup frame pointers
     b->base_src = &arf_frame->y_buffer;
     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*/
     // TODO Check that the 16x16 vf & sdf are selected here
     bestsme = vp8_hex_search(x, b, d,
-        &best_ref_mv1, &d->bmi.mv.as_mv,
+        &best_ref_mv1, &d->bmi.mv,
         step_param,
         sadpb/*x->errorperbit*/,
         &num00, &cpi->fn_ptr[BLOCK_16X16],
@@ -209,7 +211,7 @@ static int vp8_temporal_filter_find_matching_mb_c
         int distortion;
         unsigned int sse;
         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],
                     mvcost, &distortion, &sse);
     }