shithub: libvpx

--- a/vp8/encoder/block.h

+++ b/vp8/encoder/block.h

@@ -65,7 +65,9 @@

     DECLARE_ALIGNED(16, short, src_diff[400]);       // 16x16 Y 8x8 U 8x8 V 4x4 2nd Y

     DECLARE_ALIGNED(16, short, coeff[400]);     // 16x16 Y 8x8 U 8x8 V 4x4 2nd Y

+    DECLARE_ALIGNED(16, unsigned char, thismb[256]);

+    unsigned char *thismb_ptr;

     // 16 Y blocks, 4 U blocks, 4 V blocks, 1 DC 2nd order block each with 16 entries

     BLOCK block[25];

--- a/vp8/encoder/encodeframe.c

+++ b/vp8/encoder/encodeframe.c

@@ -292,6 +292,9 @@

             xd->left_available = (mb_col != 0);

             recon_yoffset += 16;

 #endif

+            //Copy current mb to a buffer

+            RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);

             // measure activity

             mb_activity = mb_activity_measure( cpi, x, mb_row, mb_col );

@@ -432,6 +435,9 @@

         x->rddiv = cpi->RDDIV;

         x->rdmult = cpi->RDMULT;

+        //Copy current mb to a buffer

+        RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);

 #if CONFIG_MULTITHREAD

         if ((cpi->b_multi_threaded != 0) && (mb_row != 0))

@@ -1013,14 +1019,18 @@

     vp8_build_block_doffsets(&x->e_mbd);

     // y blocks

+    x->thismb_ptr = &x->thismb[0];

     for (br = 0; br < 4; br++)

         for (bc = 0; bc < 4; bc++)

             BLOCK *this_block = &x->block[block];

-            this_block->base_src = &x->src.y_buffer;

-            this_block->src_stride = x->src.y_stride;

-            this_block->src = 4 * br * this_block->src_stride + 4 * bc;

+            //this_block->base_src = &x->src.y_buffer;

+            //this_block->src_stride = x->src.y_stride;

+            //this_block->src = 4 * br * this_block->src_stride + 4 * bc;

+            this_block->base_src = &x->thismb_ptr;

+            this_block->src_stride = 16;

+            this_block->src = 4 * br * 16 + 4 * bc;

             ++block;

--- a/vp8/encoder/encodeintra.c

+++ b/vp8/encoder/encodeintra.c

@@ -91,11 +91,11 @@

 void vp8_encode_intra16x16mby(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x)

-    int b;

+    BLOCK *b = &x->block[0];

     RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_mby)(&x->e_mbd);

-    ENCODEMB_INVOKE(&rtcd->encodemb, submby)(x->src_diff, x->src.y_buffer, x->e_mbd.predictor, x->src.y_stride);

+    ENCODEMB_INVOKE(&rtcd->encodemb, submby)(x->src_diff, *(b->base_src), x->e_mbd.predictor, b->src_stride);

     vp8_transform_intra_mby(x);

--- a/vp8/encoder/encodemb.c

+++ b/vp8/encoder/encodemb.c

@@ -101,7 +101,9 @@

 static void vp8_subtract_mb(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x)

-    ENCODEMB_INVOKE(&rtcd->encodemb, submby)(x->src_diff, x->src.y_buffer, x->e_mbd.predictor, x->src.y_stride);

+    BLOCK *b = &x->block[0];

+    ENCODEMB_INVOKE(&rtcd->encodemb, submby)(x->src_diff, *(b->base_src), x->e_mbd.predictor, b->src_stride);

     ENCODEMB_INVOKE(&rtcd->encodemb, submbuv)(x->src_diff, x->src.u_buffer, x->src.v_buffer, x->e_mbd.predictor, x->src.uv_stride);

@@ -602,9 +604,11 @@

 /* this funciton is used by first pass only */

 void vp8_encode_inter16x16y(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x)

+    BLOCK *b = &x->block[0];

     vp8_build_inter16x16_predictors_mby(&x->e_mbd);

-    ENCODEMB_INVOKE(&rtcd->encodemb, submby)(x->src_diff, x->src.y_buffer, x->e_mbd.predictor, x->src.y_stride);

+    ENCODEMB_INVOKE(&rtcd->encodemb, submby)(x->src_diff, *(b->base_src), x->e_mbd.predictor, b->src_stride);

     transform_mby(x);

--- a/vp8/encoder/ethreading.c

+++ b/vp8/encoder/ethreading.c

@@ -148,6 +148,9 @@

                     x->rddiv = cpi->RDDIV;

                     x->rdmult = cpi->RDMULT;

+                    //Copy current mb to a buffer

+                    RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);

                     if (cpi->oxcf.tuning == VP8_TUNE_SSIM)

                         vp8_activity_masking(cpi, x);

--- a/vp8/encoder/firstpass.c

+++ b/vp8/encoder/firstpass.c

@@ -579,6 +579,9 @@

             xd->dst.v_buffer = new_yv12->v_buffer + recon_uvoffset;

             xd->left_available = (mb_col != 0);

+            //Copy current mb to a buffer

+            RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);

             // do intra 16x16 prediction

             this_error = vp8_encode_intra(cpi, x, use_dc_pred);

--- a/vp8/encoder/mcomp.c

+++ b/vp8/encoder/mcomp.c

@@ -286,8 +286,8 @@

     bestmv->as_mv.row = br << 1;

     bestmv->as_mv.col = bc << 1;

-    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))

+    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)))

         return INT_MAX;

     return besterr;

--- a/vp8/encoder/mcomp.h

+++ b/vp8/encoder/mcomp.h

@@ -22,7 +22,7 @@

 #define MAX_MVSEARCH_STEPS 8                                    // The maximum number of steps in a step search given the largest allowed initial step

-#define MAX_FULL_PEL_VAL ((1 << (MAX_MVSEARCH_STEPS+3)) - 8)    // Max full pel mv specified in 1/8 pel units

+#define MAX_FULL_PEL_VAL ((1 << (MAX_MVSEARCH_STEPS)) - 1)      // Max full pel mv specified in 1 pel units

 #define MAX_FIRST_STEP (1 << (MAX_MVSEARCH_STEPS-1))            // Maximum size of the first step in full pel units

 extern void print_mode_context(void);

--- a/vp8/encoder/pickinter.c

+++ b/vp8/encoder/pickinter.c

@@ -588,10 +588,10 @@

             /* adjust mvp to make sure it is within MV range */

             vp8_clamp_mv(&mvp,

-                         best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL,

-                         best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL,

-                         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<<3),

+                         best_ref_mv.as_mv.col + (MAX_FULL_PEL_VAL<<3),

+                         best_ref_mv.as_mv.row - (MAX_FULL_PEL_VAL<<3),

+                         best_ref_mv.as_mv.row + (MAX_FULL_PEL_VAL<<3));

         switch (this_mode)

@@ -610,7 +610,7 @@

                 rate2 += rate;

                 distortion2 = VARIANCE_INVOKE

                                 (&cpi->rtcd.variance, var16x16)(

-                                    x->src.y_buffer, x->src.y_stride,

+                                    *(b->base_src), b->src_stride,

                                     x->e_mbd.predictor, 16, &sse);

                 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);

@@ -635,7 +635,7 @@

             RECON_INVOKE(&cpi->common.rtcd.recon, build_intra_predictors_mby)

                 (&x->e_mbd);

             distortion2 = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16)

-                                          (x->src.y_buffer, x->src.y_stride,

+                                          (*(b->base_src), b->src_stride,

                                           x->e_mbd.predictor, 16, &sse);

             rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode];

             this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);

@@ -681,10 +681,14 @@

                 mvp.as_int = best_ref_mv.as_int;

-            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;

+            col_min = (best_ref_mv.as_mv.col < 0)?(-((abs(best_ref_mv.as_mv.col))>>3) - MAX_FULL_PEL_VAL)

+                                                 :((best_ref_mv.as_mv.col>>3) - MAX_FULL_PEL_VAL);

+            col_max = (best_ref_mv.as_mv.col < 0)?(-((abs(best_ref_mv.as_mv.col))>>3) + MAX_FULL_PEL_VAL)

+                                                 :((best_ref_mv.as_mv.col>>3) + MAX_FULL_PEL_VAL);

+            row_min = (best_ref_mv.as_mv.row < 0)?(-((abs(best_ref_mv.as_mv.row))>>3) - MAX_FULL_PEL_VAL)

+                                                 :((best_ref_mv.as_mv.row>>3) - MAX_FULL_PEL_VAL);

+            row_max = (best_ref_mv.as_mv.row < 0)?(-((abs(best_ref_mv.as_mv.row))>>3) + MAX_FULL_PEL_VAL)

+                                                 :((best_ref_mv.as_mv.row>>3) + MAX_FULL_PEL_VAL);

             // Get intersection of UMV window and valid MV window to reduce # of checks in diamond search.

             if (x->mv_col_min < col_min )

@@ -904,6 +908,7 @@

     MB_PREDICTION_MODE mode, best_mode = DC_PRED;

     int this_rd;

     unsigned int sse;

+    BLOCK *b = &x->block[0];

     x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;

@@ -915,7 +920,7 @@

         RECON_INVOKE(&cpi->common.rtcd.recon, build_intra_predictors_mby)

             (&x->e_mbd);

         distortion = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16)

-            (x->src.y_buffer, x->src.y_stride, x->e_mbd.predictor, 16, &sse);

+            (*(b->base_src), b->src_stride, x->e_mbd.predictor, 16, &sse);

         rate = x->mbmode_cost[x->e_mbd.frame_type][mode];

         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);

--- a/vp8/encoder/picklpf.c

+++ b/vp8/encoder/picklpf.c

@@ -141,13 +141,11 @@

     // jbb chg: 20100118 - not so any more with this overquant stuff allow high values

     // with lots of intra coming in.

     int max_filter_level = MAX_LOOP_FILTER ;//* 3 / 4;

+    (void)base_qindex;

     if (cpi->twopass.section_intra_rating > 8)

         max_filter_level = MAX_LOOP_FILTER * 3 / 4;

-    (void) cpi;

-    (void) base_qindex;

     return max_filter_level;

@@ -157,8 +155,8 @@

     int best_err = 0;

     int filt_err = 0;

-    int min_filter_level = 0;

-    int max_filter_level = MAX_LOOP_FILTER * 3 / 4;   // PGW August 2006: Highest filter values almost always a bad idea

+    int min_filter_level = get_min_filter_level(cpi, cm->base_qindex);

+    int max_filter_level = get_max_filter_level(cpi, cm->base_qindex);

     int filt_val;

     int best_filt_val = cm->filter_level;

@@ -171,10 +169,6 @@

     else

         cm->sharpness_level = cpi->oxcf.Sharpness;

-    // Enforce a minimum filter level based upon Q

-    min_filter_level = get_min_filter_level(cpi, cm->base_qindex);

-    max_filter_level = get_max_filter_level(cpi, cm->base_qindex);

     // Start the search at the previous frame filter level unless it is now out of range.

     if (cm->filter_level < min_filter_level)

         cm->filter_level = min_filter_level;

@@ -294,8 +288,8 @@

     int best_err = 0;

     int filt_err = 0;

-    int min_filter_level;

-    int max_filter_level;

+    int min_filter_level = get_min_filter_level(cpi, cm->base_qindex);

+    int max_filter_level = get_max_filter_level(cpi, cm->base_qindex);

     int filter_step;

     int filt_high = 0;

@@ -328,10 +322,6 @@

         cm->sharpness_level = 0;

     else

         cm->sharpness_level = cpi->oxcf.Sharpness;

-    // Enforce a minimum filter level based upon Q

-    min_filter_level = get_min_filter_level(cpi, cm->base_qindex);

-    max_filter_level = get_max_filter_level(cpi, cm->base_qindex);

     // Start the search at the previous frame filter level unless it is now out of range.

     filt_mid = cm->filter_level;

--- a/vp8/encoder/rdopt.c

+++ b/vp8/encoder/rdopt.c

@@ -605,8 +605,8 @@

     BLOCK *beptr;

     int d;

-    ENCODEMB_INVOKE(rtcd, submby)( mb->src_diff, mb->src.y_buffer,

-                                   mb->e_mbd.predictor, mb->src.y_stride );

+    ENCODEMB_INVOKE(rtcd, submby)( mb->src_diff, *(mb->block[0].base_src),

+                                   mb->e_mbd.predictor, mb->block[0].src_stride );

     // Fdct and building the 2nd order block

     for (beptr = mb->block; beptr < mb->block + 16; beptr += 2)

@@ -1398,10 +1398,14 @@

         if (bsi.segment_rd < best_rd)

-            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 col_min = (best_ref_mv->as_mv.col < 0)?(-((abs(best_ref_mv->as_mv.col))>>3) - MAX_FULL_PEL_VAL)

+                                                      :((best_ref_mv->as_mv.col>>3) - MAX_FULL_PEL_VAL);

+            int col_max = (best_ref_mv->as_mv.col < 0)?(-((abs(best_ref_mv->as_mv.col))>>3) + MAX_FULL_PEL_VAL)

+                                                      :((best_ref_mv->as_mv.col>>3) + MAX_FULL_PEL_VAL);

+            int row_min = (best_ref_mv->as_mv.row < 0)?(-((abs(best_ref_mv->as_mv.row))>>3) - MAX_FULL_PEL_VAL)

+                                                      :((best_ref_mv->as_mv.row>>3) - MAX_FULL_PEL_VAL);

+            int row_max = (best_ref_mv->as_mv.row < 0)?(-((abs(best_ref_mv->as_mv.row))>>3) + MAX_FULL_PEL_VAL)

+                                                      :((best_ref_mv->as_mv.row>>3) + MAX_FULL_PEL_VAL);

             int tmp_col_min = x->mv_col_min;

             int tmp_col_max = x->mv_col_max;

@@ -1701,6 +1705,8 @@

     int near_sad[8] = {0}; // 0-cf above, 1-cf left, 2-cf aboveleft, 3-lf current, 4-lf above, 5-lf left, 6-lf right, 7-lf below

+    BLOCK *b = &x->block[0];

+    unsigned char *src_y_ptr = *(b->base_src);

     //calculate sad for current frame 3 nearby MBs.

     if( xd->mb_to_top_edge==0 && xd->mb_to_left_edge ==0)

@@ -1709,16 +1715,16 @@

     }else if(xd->mb_to_top_edge==0)

     {   //only has left MB for sad calculation.

         near_sad[0] = near_sad[2] = INT_MAX;

-        near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - 16,xd->dst.y_stride, 0x7fffffff);

+        near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, xd->dst.y_buffer - 16,xd->dst.y_stride, 0x7fffffff);

     }else if(xd->mb_to_left_edge ==0)

     {   //only has left MB for sad calculation.

         near_sad[1] = near_sad[2] = INT_MAX;

-        near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - xd->dst.y_stride *16,xd->dst.y_stride, 0x7fffffff);

+        near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, xd->dst.y_buffer - xd->dst.y_stride *16,xd->dst.y_stride, 0x7fffffff);

     }else

-        near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - xd->dst.y_stride *16,xd->dst.y_stride, 0x7fffffff);

-        near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - 16,xd->dst.y_stride, 0x7fffffff);

-        near_sad[2] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - xd->dst.y_stride *16 -16,xd->dst.y_stride, 0x7fffffff);

+        near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, xd->dst.y_buffer - xd->dst.y_stride *16,xd->dst.y_stride, 0x7fffffff);

+        near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, xd->dst.y_buffer - 16,xd->dst.y_stride, 0x7fffffff);

+        near_sad[2] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, xd->dst.y_buffer - xd->dst.y_stride *16 -16,xd->dst.y_stride, 0x7fffffff);

     if(cpi->common.last_frame_type != KEY_FRAME)

@@ -1733,14 +1739,14 @@

         if(xd->mb_to_bottom_edge==0) near_sad[7] = INT_MAX;

         if(near_sad[4] != INT_MAX)

-            near_sad[4] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer - pre_y_stride *16, pre_y_stride, 0x7fffffff);

+            near_sad[4] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, pre_y_buffer - pre_y_stride *16, pre_y_stride, 0x7fffffff);

         if(near_sad[5] != INT_MAX)

-            near_sad[5] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer - 16, pre_y_stride, 0x7fffffff);

-        near_sad[3] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer, pre_y_stride, 0x7fffffff);

+            near_sad[5] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, pre_y_buffer - 16, pre_y_stride, 0x7fffffff);

+        near_sad[3] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, pre_y_buffer, pre_y_stride, 0x7fffffff);

         if(near_sad[6] != INT_MAX)

-            near_sad[6] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer + 16, pre_y_stride, 0x7fffffff);

+            near_sad[6] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, pre_y_buffer + 16, pre_y_stride, 0x7fffffff);

         if(near_sad[7] != INT_MAX)

-            near_sad[7] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer + pre_y_stride *16, pre_y_stride, 0x7fffffff);

+            near_sad[7] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride, pre_y_buffer + pre_y_stride *16, pre_y_stride, 0x7fffffff);

     if(cpi->common.last_frame_type != KEY_FRAME)

@@ -1944,10 +1950,10 @@

             /* adjust mvp to make sure it is within MV range */

             vp8_clamp_mv(&mvp,

-                         best_ref_mv.as_mv.col - MAX_FULL_PEL_VAL,

-                         best_ref_mv.as_mv.col + MAX_FULL_PEL_VAL,

-                         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<<3),

+                         best_ref_mv.as_mv.col + (MAX_FULL_PEL_VAL<<3),

+                         best_ref_mv.as_mv.row - (MAX_FULL_PEL_VAL<<3),

+                         best_ref_mv.as_mv.row + (MAX_FULL_PEL_VAL<<3));

         // Check to see if the testing frequency for this mode is at its max

@@ -2079,10 +2085,14 @@

             int sadpb = x->sadperbit16;

-            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 col_min = (best_ref_mv.as_mv.col < 0)?(-((abs(best_ref_mv.as_mv.col))>>3) - MAX_FULL_PEL_VAL)

+                                                     :((best_ref_mv.as_mv.col>>3) - MAX_FULL_PEL_VAL);

+            int col_max = (best_ref_mv.as_mv.col < 0)?(-((abs(best_ref_mv.as_mv.col))>>3) + MAX_FULL_PEL_VAL)

+                                                     :((best_ref_mv.as_mv.col>>3) + MAX_FULL_PEL_VAL);

+            int row_min = (best_ref_mv.as_mv.row < 0)?(-((abs(best_ref_mv.as_mv.row))>>3) - MAX_FULL_PEL_VAL)

+                                                     :((best_ref_mv.as_mv.row>>3) - MAX_FULL_PEL_VAL);

+            int row_max = (best_ref_mv.as_mv.row < 0)?(-((abs(best_ref_mv.as_mv.row))>>3) + MAX_FULL_PEL_VAL)

+                                                     :((best_ref_mv.as_mv.row>>3) + MAX_FULL_PEL_VAL);

             int tmp_col_min = x->mv_col_min;

             int tmp_col_max = x->mv_col_max;

@@ -2233,7 +2243,7 @@

                     threshold = x->encode_breakout;

                 var = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16)

-                        (x->src.y_buffer, x->src.y_stride,

+                        (*(b->base_src), b->src_stride,

                         x->e_mbd.predictor, 16, &sse);

                 if (sse < threshold)