shithub: libvpx

Info  •  Files  •  Log  •  Branches

Moving from int_mv* to MV* (2).

Updating fractional_mv_step_fp and fractional_mv_step_comp_fp function
types.

Change-Id: I601c4378bc39ac3ffd4e295d9cbd8e1f74829d46

--- a/vp9/encoder/vp9_mbgraph.c

+++ b/vp9/encoder/vp9_mbgraph.c

@@ -57,7 +57,7 @@

     unsigned int sse;

     best_err = cpi->find_fractional_mv_step(

         x,

-        dst_mv, ref_mv,

+        &dst_mv->as_mv, &ref_mv->as_mv,

         x->errorperbit, &v_fn_ptr,

         0, cpi->sf.subpel_iters_per_step, NULL, NULL,

         & distortion, &sse);

--- a/vp9/encoder/vp9_mcomp.c

+++ b/vp9/encoder/vp9_mcomp.c

@@ -274,7 +274,7 @@

   }

 int vp9_find_best_sub_pixel_iterative(MACROBLOCK *x,

-                                      int_mv *bestmv, int_mv *ref_mv,

+                                      MV *bestmv, const MV *ref_mv,

                                       int error_per_bit,

                                       const vp9_variance_fn_ptr_t *vfp,

                                       int forced_stop,

@@ -295,31 +295,30 @@

   int thismse;

   const int y_stride = xd->plane[0].pre[0].stride;

-  const int offset = (bestmv->as_mv.row) * y_stride + bestmv->as_mv.col;

+  const int offset = bestmv->row * y_stride + bestmv->col;

   uint8_t *y = xd->plane[0].pre[0].buf + offset;

-  int rr = ref_mv->as_mv.row;

-  int rc = ref_mv->as_mv.col;

-  int br = bestmv->as_mv.row * 8;

-  int bc = bestmv->as_mv.col * 8;

+  int rr = ref_mv->row;

+  int rc = ref_mv->col;

+  int br = bestmv->row * 8;

+  int bc = bestmv->col * 8;

   int hstep = 4;

-  const int minc = MAX(x->mv_col_min * 8, ref_mv->as_mv.col - MV_MAX);

-  const int maxc = MIN(x->mv_col_max * 8, ref_mv->as_mv.col + MV_MAX);

-  const int minr = MAX(x->mv_row_min * 8, ref_mv->as_mv.row - MV_MAX);

-  const int maxr = MIN(x->mv_row_max * 8, ref_mv->as_mv.row + MV_MAX);

+  const int minc = MAX(x->mv_col_min * 8, ref_mv->col - MV_MAX);

+  const int maxc = MIN(x->mv_col_max * 8, ref_mv->col + MV_MAX);

+  const int minr = MAX(x->mv_row_min * 8, ref_mv->row - MV_MAX);

+  const int maxr = MIN(x->mv_row_max * 8, ref_mv->row + MV_MAX);

   int tr = br;

   int tc = bc;

   // central mv

-  bestmv->as_mv.row <<= 3;

-  bestmv->as_mv.col <<= 3;

+  bestmv->row <<= 3;

+  bestmv->col <<= 3;

   // calculate central point error

   besterr = vfp->vf(y, y_stride, z, src_stride, sse1);

   *distortion = besterr;

-  besterr += mv_err_cost(&bestmv->as_mv, &ref_mv->as_mv,

-                         mvjcost, mvcost, error_per_bit);

+  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);

   // TODO: Each subsequent iteration checks at least one point in

   // common with the last iteration could be 2 ( if diag selected)

@@ -349,7 +348,7 @@

     }

   }

-  if (xd->allow_high_precision_mv && vp9_use_mv_hp(&ref_mv->as_mv) &&

+  if (xd->allow_high_precision_mv && vp9_use_mv_hp(ref_mv) &&

       forced_stop == 0) {

     hstep >>= 1;

     while (eighthiters--) {

@@ -362,11 +361,11 @@

     }

   }

-  bestmv->as_mv.row = br;

-  bestmv->as_mv.col = bc;

+  bestmv->row = br;

+  bestmv->col = bc;

-  if ((abs(bestmv->as_mv.col - ref_mv->as_mv.col) > (MAX_FULL_PEL_VAL << 3)) ||

-      (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > (MAX_FULL_PEL_VAL << 3)))

+  if ((abs(bestmv->col - ref_mv->col) > (MAX_FULL_PEL_VAL << 3)) ||

+      (abs(bestmv->row - ref_mv->row) > (MAX_FULL_PEL_VAL << 3)))

     return INT_MAX;

   return besterr;

@@ -373,7 +372,7 @@

 }

 int vp9_find_best_sub_pixel_tree(MACROBLOCK *x,

-                                 int_mv *bestmv, int_mv *ref_mv,

+                                 MV *bestmv, const MV *ref_mv,

                                  int error_per_bit,

                                  const vp9_variance_fn_ptr_t *vfp,

                                  int forced_stop,

@@ -393,31 +392,30 @@

   unsigned int eighthiters = iters_per_step;

   const int y_stride = xd->plane[0].pre[0].stride;

-  const int offset = bestmv->as_mv.row * y_stride + bestmv->as_mv.col;

+  const int offset = bestmv->row * y_stride + bestmv->col;

   uint8_t *y = xd->plane[0].pre[0].buf + offset;

-  int rr = ref_mv->as_mv.row;

-  int rc = ref_mv->as_mv.col;

-  int br = bestmv->as_mv.row * 8;

-  int bc = bestmv->as_mv.col * 8;

+  int rr = ref_mv->row;

+  int rc = ref_mv->col;

+  int br = bestmv->row * 8;

+  int bc = bestmv->col * 8;

   int hstep = 4;

-  const int minc = MAX(x->mv_col_min * 8, ref_mv->as_mv.col - MV_MAX);

-  const int maxc = MIN(x->mv_col_max * 8, ref_mv->as_mv.col + MV_MAX);

-  const int minr = MAX(x->mv_row_min * 8, ref_mv->as_mv.row - MV_MAX);

-  const int maxr = MIN(x->mv_row_max * 8, ref_mv->as_mv.row + MV_MAX);

+  const int minc = MAX(x->mv_col_min * 8, ref_mv->col - MV_MAX);

+  const int maxc = MIN(x->mv_col_max * 8, ref_mv->col + MV_MAX);

+  const int minr = MAX(x->mv_row_min * 8, ref_mv->row - MV_MAX);

+  const int maxr = MIN(x->mv_row_max * 8, ref_mv->row + MV_MAX);

   int tr = br;

   int tc = bc;

   // central mv

-  bestmv->as_mv.row *= 8;

-  bestmv->as_mv.col *= 8;

+  bestmv->row *= 8;

+  bestmv->col *= 8;

   // calculate central point error

   besterr = vfp->vf(y, y_stride, z, src_stride, sse1);

   *distortion = besterr;

-  besterr += mv_err_cost(&bestmv->as_mv, &ref_mv->as_mv,

-                         mvjcost, mvcost, error_per_bit);

+  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);

   // 1/2 pel

   FIRST_LEVEL_CHECKS;

@@ -438,7 +436,7 @@

     tc = bc;

   }

-  if (xd->allow_high_precision_mv && vp9_use_mv_hp(&ref_mv->as_mv) &&

+  if (xd->allow_high_precision_mv && vp9_use_mv_hp(ref_mv) &&

       forced_stop == 0) {

     hstep >>= 1;

     FIRST_LEVEL_CHECKS;

@@ -449,11 +447,11 @@

     tc = bc;

   }

-  bestmv->as_mv.row = br;

-  bestmv->as_mv.col = bc;

+  bestmv->row = br;

+  bestmv->col = bc;

-  if ((abs(bestmv->as_mv.col - ref_mv->as_mv.col) > (MAX_FULL_PEL_VAL << 3)) ||

-      (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > (MAX_FULL_PEL_VAL << 3)))

+  if ((abs(bestmv->col - ref_mv->col) > (MAX_FULL_PEL_VAL << 3)) ||

+      (abs(bestmv->row - ref_mv->row) > (MAX_FULL_PEL_VAL << 3)))

     return INT_MAX;

   return besterr;

@@ -466,7 +464,7 @@

               z, src_stride, &sse, second_pred)

 int vp9_find_best_sub_pixel_comp_iterative(MACROBLOCK *x,

-                                           int_mv *bestmv, int_mv *ref_mv,

+                                           MV *bestmv, const MV *ref_mv,

                                            int error_per_bit,

                                            const vp9_variance_fn_ptr_t *vfp,

                                            int forced_stop,

@@ -490,25 +488,25 @@

   DECLARE_ALIGNED_ARRAY(16, uint8_t, comp_pred, 64 * 64);

   const int y_stride = xd->plane[0].pre[0].stride;

-  const int offset = bestmv->as_mv.row * y_stride + bestmv->as_mv.col;

+  const int offset = bestmv->row * y_stride + bestmv->col;

   uint8_t *const y = xd->plane[0].pre[0].buf + offset;

-  int rr = ref_mv->as_mv.row;

-  int rc = ref_mv->as_mv.col;

-  int br = bestmv->as_mv.row * 8;

-  int bc = bestmv->as_mv.col * 8;

+  int rr = ref_mv->row;

+  int rc = ref_mv->col;

+  int br = bestmv->row * 8;

+  int bc = bestmv->col * 8;

   int hstep = 4;

-  const int minc = MAX(x->mv_col_min * 8, ref_mv->as_mv.col - MV_MAX);

-  const int maxc = MIN(x->mv_col_max * 8, ref_mv->as_mv.col + MV_MAX);

-  const int minr = MAX(x->mv_row_min * 8, ref_mv->as_mv.row - MV_MAX);

-  const int maxr = MIN(x->mv_row_max * 8, ref_mv->as_mv.row + MV_MAX);

+  const int minc = MAX(x->mv_col_min * 8, ref_mv->col - MV_MAX);

+  const int maxc = MIN(x->mv_col_max * 8, ref_mv->col + MV_MAX);

+  const int minr = MAX(x->mv_row_min * 8, ref_mv->row - MV_MAX);

+  const int maxr = MIN(x->mv_row_max * 8, ref_mv->row + MV_MAX);

   int tr = br;

   int tc = bc;

   // central mv

-  bestmv->as_mv.row *= 8;

-  bestmv->as_mv.col *= 8;

+  bestmv->row *= 8;

+  bestmv->col *= 8;

   // calculate central point error

   // TODO(yunqingwang): central pointer error was already calculated in full-

@@ -516,8 +514,7 @@

   comp_avg_pred(comp_pred, second_pred, w, h, y, y_stride);

   besterr = vfp->vf(comp_pred, w, z, src_stride, sse1);

   *distortion = besterr;

-  besterr += mv_err_cost(&bestmv->as_mv, &ref_mv->as_mv,

-                         mvjcost, mvcost, error_per_bit);

+  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);

   // Each subsequent iteration checks at least one point in

   // common with the last iteration could be 2 ( if diag selected)

@@ -547,7 +544,7 @@

     }

   }

-  if (xd->allow_high_precision_mv && vp9_use_mv_hp(&ref_mv->as_mv) &&

+  if (xd->allow_high_precision_mv && vp9_use_mv_hp(ref_mv) &&

       forced_stop == 0) {

     hstep >>= 1;

     while (eighthiters--) {

@@ -559,11 +556,11 @@

       tc = bc;

     }

   }

-  bestmv->as_mv.row = br;

-  bestmv->as_mv.col = bc;

+  bestmv->row = br;

+  bestmv->col = bc;

-  if ((abs(bestmv->as_mv.col - ref_mv->as_mv.col) > (MAX_FULL_PEL_VAL << 3)) ||

-      (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > (MAX_FULL_PEL_VAL << 3)))

+  if ((abs(bestmv->col - ref_mv->col) > (MAX_FULL_PEL_VAL << 3)) ||

+      (abs(bestmv->row - ref_mv->row) > (MAX_FULL_PEL_VAL << 3)))

     return INT_MAX;

   return besterr;

@@ -570,7 +567,7 @@

 }

 int vp9_find_best_sub_pixel_comp_tree(MACROBLOCK *x,

-                                      int_mv *bestmv, int_mv *ref_mv,

+                                      MV *bestmv, const MV *ref_mv,

                                       int error_per_bit,

                                       const vp9_variance_fn_ptr_t *vfp,

                                       int forced_stop,

@@ -593,25 +590,25 @@

   DECLARE_ALIGNED_ARRAY(16, uint8_t, comp_pred, 64 * 64);

   const int y_stride = xd->plane[0].pre[0].stride;

-  const int offset = (bestmv->as_mv.row) * y_stride + bestmv->as_mv.col;

+  const int offset = bestmv->row * y_stride + bestmv->col;

   uint8_t *y = xd->plane[0].pre[0].buf + offset;

-  int rr = ref_mv->as_mv.row;

-  int rc = ref_mv->as_mv.col;

-  int br = bestmv->as_mv.row * 8;

-  int bc = bestmv->as_mv.col * 8;

+  int rr = ref_mv->row;

+  int rc = ref_mv->col;

+  int br = bestmv->row * 8;

+  int bc = bestmv->col * 8;

   int hstep = 4;

-  const int minc = MAX(x->mv_col_min * 8, ref_mv->as_mv.col - MV_MAX);

-  const int maxc = MIN(x->mv_col_max * 8, ref_mv->as_mv.col + MV_MAX);

-  const int minr = MAX(x->mv_row_min * 8, ref_mv->as_mv.row - MV_MAX);

-  const int maxr = MIN(x->mv_row_max * 8, ref_mv->as_mv.row + MV_MAX);

+  const int minc = MAX(x->mv_col_min * 8, ref_mv->col - MV_MAX);

+  const int maxc = MIN(x->mv_col_max * 8, ref_mv->col + MV_MAX);

+  const int minr = MAX(x->mv_row_min * 8, ref_mv->row - MV_MAX);

+  const int maxr = MIN(x->mv_row_max * 8, ref_mv->row + MV_MAX);

   int tr = br;

   int tc = bc;

   // central mv

-  bestmv->as_mv.row *= 8;

-  bestmv->as_mv.col *= 8;

+  bestmv->row *= 8;

+  bestmv->col *= 8;

   // calculate central point error

   // TODO(yunqingwang): central pointer error was already calculated in full-

@@ -619,8 +616,7 @@

   comp_avg_pred(comp_pred, second_pred, w, h, y, y_stride);

   besterr = vfp->vf(comp_pred, w, z, src_stride, sse1);

   *distortion = besterr;

-  besterr += mv_err_cost(&bestmv->as_mv, &ref_mv->as_mv,

-                         mvjcost, mvcost, error_per_bit);

+  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);

   // Each subsequent iteration checks at least one point in

   // common with the last iteration could be 2 ( if diag selected)

@@ -646,7 +642,7 @@

     tc = bc;

   }

-  if (xd->allow_high_precision_mv && vp9_use_mv_hp(&ref_mv->as_mv) &&

+  if (xd->allow_high_precision_mv && vp9_use_mv_hp(ref_mv) &&

       forced_stop == 0) {

     hstep >>= 1;

     FIRST_LEVEL_CHECKS;

@@ -656,11 +652,11 @@

     tr = br;

     tc = bc;

   }

-  bestmv->as_mv.row = br;

-  bestmv->as_mv.col = bc;

+  bestmv->row = br;

+  bestmv->col = bc;

-  if ((abs(bestmv->as_mv.col - ref_mv->as_mv.col) > (MAX_FULL_PEL_VAL << 3)) ||

-      (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > (MAX_FULL_PEL_VAL << 3)))

+  if ((abs(bestmv->col - ref_mv->col) > (MAX_FULL_PEL_VAL << 3)) ||

+      (abs(bestmv->row - ref_mv->row) > (MAX_FULL_PEL_VAL << 3)))

     return INT_MAX;

   return besterr;

--- a/vp9/encoder/vp9_mcomp.h

+++ b/vp9/encoder/vp9_mcomp.h

@@ -69,8 +69,7 @@

 typedef int (fractional_mv_step_fp) (

     MACROBLOCK *x,

-    int_mv *bestmv,

-    int_mv *ref_mv,

+    MV *bestmv, const MV *ref_mv,

     int error_per_bit,

     const vp9_variance_fn_ptr_t *vfp,

     int forced_stop,  // 0 - full, 1 - qtr only, 2 - half only

@@ -84,7 +83,7 @@

 typedef int (fractional_mv_step_comp_fp) (

     MACROBLOCK *x,

-    int_mv *bestmv, int_mv *ref_mv,

+    MV *bestmv, const MV *ref_mv,

     int error_per_bit,

     const vp9_variance_fn_ptr_t *vfp,

     int forced_stop,  // 0 - full, 1 - qtr only, 2 - half only

--- a/vp9/encoder/vp9_rdopt.c

+++ b/vp9/encoder/vp9_rdopt.c

@@ -1860,8 +1860,10 @@

           if (bestsme < INT_MAX) {

             int distortion;

             unsigned int sse;

-            cpi->find_fractional_mv_step(x, &mode_mv[NEWMV],

-                                         bsi->ref_mv, x->errorperbit, v_fn_ptr,

+            cpi->find_fractional_mv_step(x,

+                                         &mode_mv[NEWMV].as_mv,

+                                         &bsi->ref_mv->as_mv,

+                                         x->errorperbit, v_fn_ptr,

                                          0, cpi->sf.subpel_iters_per_step,

                                          x->nmvjointcost, x->mvcost,

                                          &distortion, &sse);

@@ -2456,7 +2458,7 @@

   if (bestsme < INT_MAX) {

     int dis;  /* TODO: use dis in distortion calculation later. */

     unsigned int sse;

-    cpi->find_fractional_mv_step(x, tmp_mv, &ref_mv,

+    cpi->find_fractional_mv_step(x, &tmp_mv->as_mv, &ref_mv.as_mv,

                                  x->errorperbit,

                                  &cpi->fn_ptr[block_size],

                                  0, cpi->sf.subpel_iters_per_step,

@@ -2590,8 +2592,8 @@

       unsigned int sse;

       bestsme = cpi->find_fractional_mv_step_comp(

-          x, &tmp_mv,

-          &ref_mv[id],

+          x, &tmp_mv.as_mv,

+          &ref_mv[id].as_mv,

           x->errorperbit,

           &cpi->fn_ptr[block_size],

           0, cpi->sf.subpel_iters_per_step,

--- a/vp9/encoder/vp9_temporal_filter.c

+++ b/vp9/encoder/vp9_temporal_filter.c

@@ -166,8 +166,8 @@

     int distortion;

     unsigned int sse;

     // Ignore mv costing by sending NULL pointer instead of cost array

-    bestsme = cpi->find_fractional_mv_step(x, ref_mv,

-                                           &best_ref_mv1,

+    bestsme = cpi->find_fractional_mv_step(x, &ref_mv->as_mv,

+                                           &best_ref_mv1.as_mv,

                                            x->errorperbit,

                                            &cpi->fn_ptr[BLOCK_16X16],

                                            0, cpi->sf.subpel_iters_per_step,

-- 

⑨