diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c
index 9cc6290..9daaaec 100644
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -50,6 +50,7 @@
 void vp8_setup_block_ptrs(MACROBLOCK *x);
 int vp8cx_encode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t, int recon_yoffset, int recon_uvoffset);
 int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t);
+static void adjust_act_zbin( VP8_COMP *cpi, MACROBLOCK *x );
 
 #ifdef MODE_STATS
 unsigned int inter_y_modes[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
@@ -103,70 +104,122 @@
 }
 
 // Stub for alternative experimental activity measures.
-static unsigned int alt_activity_measure( VP8_COMP *cpi, MACROBLOCK *x )
+extern int encode_intra(VP8_COMP *cpi, MACROBLOCK *x, int use_dc_pred);
+static unsigned int alt_activity_measure( VP8_COMP *cpi,
+                                          MACROBLOCK *x, int use_dc_pred )
 {
-    unsigned int mb_activity = VP8_ACTIVITY_AVG_MIN;
-
-    x->e_mbd.mode_info_context->mbmi.mode = DC_PRED;
-    x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
-    x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
-
-    vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
-
-    mb_activity = VARIANCE_INVOKE(&cpi->rtcd.variance, getmbss)(x->src_diff);
-
-    return mb_activity;
+    return encode_intra(cpi,x, use_dc_pred);
 }
 
 
 // Measure the activity of the current macroblock
 // What we measure here is TBD so abstracted to this function
-static unsigned int mb_activity_measure( VP8_COMP *cpi, MACROBLOCK *x )
+#define ALT_ACT_MEASURE 1
+static unsigned int mb_activity_measure( VP8_COMP *cpi, MACROBLOCK *x,
+                                  int mb_row, int mb_col)
 {
     unsigned int mb_activity;
 
-    if  ( 1 )
+    if  ( ALT_ACT_MEASURE )
+    {
+        int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
+
+        // Or use and alternative.
+        mb_activity = alt_activity_measure( cpi, x, use_dc_pred );
+    }
+    else
     {
         // Original activity measure from Tim T's code.
         mb_activity = tt_activity_measure( cpi, x );
     }
-    else
-    {
-        // Or use and alternative.
-        mb_activity = alt_activity_measure( cpi, x );
-    }
+
+    if ( mb_activity < VP8_ACTIVITY_AVG_MIN )
+        mb_activity = VP8_ACTIVITY_AVG_MIN;
 
     return mb_activity;
 }
 
 // Calculate an "average" mb activity value for the frame
+#define ACT_MEDIAN 0
 static void calc_av_activity( VP8_COMP *cpi, INT64 activity_sum )
 {
+#if ACT_MEDIAN
+    // Find median: Simple n^2 algorithm for experimentation
+    {
+        unsigned int median;
+        unsigned int i,j;
+        unsigned int * sortlist;
+        unsigned int tmp;
+
+        // Create a list to sort to
+        CHECK_MEM_ERROR(sortlist,
+                        vpx_calloc(sizeof(unsigned int),
+                        cpi->common.MBs));
+
+        // Copy map to sort list
+        vpx_memcpy( sortlist, cpi->mb_activity_map,
+                    sizeof(unsigned int) * cpi->common.MBs );
+
+
+        // Ripple each value down to its correct position
+        for ( i = 1; i < cpi->common.MBs; i ++ )
+        {
+            for ( j = i; j > 0; j -- )
+            {
+                if ( sortlist[j] < sortlist[j-1] )
+                {
+                    // Swap values
+                    tmp = sortlist[j-1];
+                    sortlist[j-1] = sortlist[j];
+                    sortlist[j] = tmp;
+                }
+                else
+                    break;
+            }
+        }
+
+        // Even number MBs so estimate median as mean of two either side.
+        median = ( 1 + sortlist[cpi->common.MBs >> 1] +
+                   sortlist[(cpi->common.MBs >> 1) + 1] ) >> 1;
+
+        cpi->activity_avg = median;
+
+        vpx_free(sortlist);
+    }
+#else
     // Simple mean for now
     cpi->activity_avg = (unsigned int)(activity_sum/cpi->common.MBs);
+#endif
+
     if (cpi->activity_avg < VP8_ACTIVITY_AVG_MIN)
         cpi->activity_avg = VP8_ACTIVITY_AVG_MIN;
+
+    // Experimental code: return fixed value normalized for several clips
+    if  ( ALT_ACT_MEASURE )
+        cpi->activity_avg = 100000;
 }
 
+#define USE_ACT_INDEX   0
 #define OUTPUT_NORM_ACT_STATS   0
-// Calculate a normalized activity value for each mb
-static void calc_norm_activity( VP8_COMP *cpi, MACROBLOCK *x )
+
+#if USE_ACT_INDEX
+// Calculate and activity index for each mb
+static void calc_activity_index( VP8_COMP *cpi, MACROBLOCK *x )
 {
     VP8_COMMON *const cm = & cpi->common;
     int mb_row, mb_col;
 
-    unsigned int act;
-    unsigned int a;
-    unsigned int b;
+    INT64 act;
+    INT64 a;
+    INT64 b;
 
 #if OUTPUT_NORM_ACT_STATS
     FILE *f = fopen("norm_act.stt", "a");
-    fprintf(f, "\n");
+    fprintf(f, "\n%12d\n", cpi->activity_avg );
 #endif
 
     // Reset pointers to start of activity map
     x->mb_activity_ptr = cpi->mb_activity_map;
-    x->mb_norm_activity_ptr = cpi->mb_norm_activity_map;
 
     // Calculate normalized mb activity number.
     for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
@@ -178,25 +231,19 @@
             act = *(x->mb_activity_ptr);
 
             // Calculate a normalized activity number
-            a = act + 2*cpi->activity_avg;
-            b = 2*act + cpi->activity_avg;
+            a = act + 4*cpi->activity_avg;
+            b = 4*act + cpi->activity_avg;
 
             if ( b >= a )
-                *(x->mb_norm_activity_ptr) = (int)((b + (a>>1))/a);
+                *(x->activity_ptr) = (int)((b + (a>>1))/a) - 1;
             else
-                *(x->mb_norm_activity_ptr) = -(int)((a + (b>>1))/b);
-
-            if ( *(x->mb_norm_activity_ptr) == 0 )
-            {
-                *(x->mb_norm_activity_ptr) = 1;
-            }
+                *(x->activity_ptr) = 1 - (int)((a + (b>>1))/b);
 
 #if OUTPUT_NORM_ACT_STATS
-            fprintf(f, " %6d", *(x->mb_norm_activity_ptr));
+            fprintf(f, " %6d", *(x->mb_activity_ptr));
 #endif
             // Increment activity map pointers
             x->mb_activity_ptr++;
-            x->mb_norm_activity_ptr++;
         }
 
 #if OUTPUT_NORM_ACT_STATS
@@ -210,33 +257,44 @@
 #endif
 
 }
-
+#endif
 
 // Loop through all MBs. Note activity of each, average activity and
 // calculate a normalized activity for each
 static void build_activity_map( VP8_COMP *cpi )
 {
     MACROBLOCK *const x = & cpi->mb;
+    MACROBLOCKD *xd = &x->e_mbd;
     VP8_COMMON *const cm = & cpi->common;
 
+#if ALT_ACT_MEASURE
+    YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
+    int recon_yoffset;
+    int recon_y_stride = new_yv12->y_stride;
+#endif
+
     int mb_row, mb_col;
     unsigned int mb_activity;
     INT64 activity_sum = 0;
 
-    // Initialise source buffer pointer
-    x->src = *cpi->Source;
-
-    // Set pointer to start of activity map
-    x->mb_activity_ptr = cpi->mb_activity_map;
-
     // for each macroblock row in image
     for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
     {
+#if ALT_ACT_MEASURE
+        // reset above block coeffs
+        xd->up_available = (mb_row != 0);
+        recon_yoffset = (mb_row * recon_y_stride * 16);
+#endif
         // for each macroblock col in image
         for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
         {
+#if ALT_ACT_MEASURE
+            xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
+            xd->left_available = (mb_col != 0);
+            recon_yoffset += 16;
+#endif
             // measure activity
-            mb_activity = mb_activity_measure( cpi, x );
+            mb_activity = mb_activity_measure( cpi, x, mb_row, mb_col );
 
             // Keep frame sum
             activity_sum += mb_activity;
@@ -251,49 +309,50 @@
             x->src.y_buffer += 16;
         }
 
+
         // adjust to the next row of mbs
         x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
+
+#if ALT_ACT_MEASURE
+        //extend the recon for intra prediction
+        vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16,
+                          xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
+#endif
+
     }
 
     // Calculate an "average" MB activity
     calc_av_activity(cpi, activity_sum);
 
-    // Calculate a normalized activity number of each mb
-    calc_norm_activity( cpi, x );
+#if USE_ACT_INDEX
+    // Calculate an activity index number of each mb
+    calc_activity_index( cpi, x );
+#endif
+
 }
 
-// Activity masking based on Tim T's original code
+// Macroblock activity masking
 void vp8_activity_masking(VP8_COMP *cpi, MACROBLOCK *x)
 {
-
-    unsigned int a;
-    unsigned int b;
-    unsigned int act = *(x->mb_activity_ptr);
+#if USE_ACT_INDEX
+    x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
+    x->errorperbit = x->rdmult/x->rddiv;
+#else
+    INT64 a;
+    INT64 b;
+    INT64 act = *(x->mb_activity_ptr);
 
     // Apply the masking to the RD multiplier.
-    a = act + 2*cpi->activity_avg;
-    b = 2*act + cpi->activity_avg;
+    a = act + (2*cpi->activity_avg);
+    b = (2*act) + cpi->activity_avg;
 
-    //tmp = (unsigned int)(((INT64)tmp*b + (a>>1))/a);
     x->rdmult = (unsigned int)(((INT64)x->rdmult*b + (a>>1))/a);
+    x->errorperbit = x->rdmult/x->rddiv;
 
-    // For now now zbin adjustment on mode choice
-    x->act_zbin_adj = 0;
-}
+#endif
 
-// Stub function to use a normalized activity measure stored at mb level.
-void vp8_norm_activity_masking(VP8_COMP *cpi, MACROBLOCK *x)
-{
-    int norm_act;
-
-    norm_act = *(x->mb_norm_activity_ptr);
-    if (norm_act > 0)
-        x->rdmult = norm_act * (x->rdmult);
-    else
-        x->rdmult = -(x->rdmult / norm_act);
-
-    // For now now zbin adjustment on mode choice
-    x->act_zbin_adj = 0;
+    // Activity based Zbin adjustment
+    adjust_act_zbin(cpi, x);
 }
 
 static
@@ -349,7 +408,6 @@
 
     // Set the mb activity pointer to the start of the row.
     x->mb_activity_ptr = &cpi->mb_activity_map[map_index];
-    x->mb_norm_activity_ptr = &cpi->mb_norm_activity_map[map_index];
 
     // for each macroblock col in image
     for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
@@ -469,7 +527,6 @@
 
         // Increment the activity mask pointers.
         x->mb_activity_ptr++;
-        x->mb_norm_activity_ptr++;
 
         /* save the block info */
         for (i = 0; i < 16; i++)
@@ -518,6 +575,65 @@
 #endif
 }
 
+void init_encode_frame_mb_context(VP8_COMP *cpi)
+{
+    MACROBLOCK *const x = & cpi->mb;
+    VP8_COMMON *const cm = & cpi->common;
+    MACROBLOCKD *const xd = & x->e_mbd;
+
+    // GF active flags data structure
+    x->gf_active_ptr = (signed char *)cpi->gf_active_flags;
+
+    // Activity map pointer
+    x->mb_activity_ptr = cpi->mb_activity_map;
+
+    x->vector_range = 32;
+
+    x->act_zbin_adj = 0;
+
+    x->partition_info = x->pi;
+
+    xd->mode_info_context = cm->mi;
+    xd->mode_info_stride = cm->mode_info_stride;
+
+    xd->frame_type = cm->frame_type;
+
+    xd->frames_since_golden = cm->frames_since_golden;
+    xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;
+
+    // reset intra mode contexts
+    if (cm->frame_type == KEY_FRAME)
+        vp8_init_mbmode_probs(cm);
+
+    // Copy data over into macro block data sturctures.
+    x->src = * cpi->Source;
+    xd->pre = cm->yv12_fb[cm->lst_fb_idx];
+    xd->dst = cm->yv12_fb[cm->new_fb_idx];
+
+    // set up frame for intra coded blocks
+    vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);
+
+    vp8_build_block_offsets(x);
+
+    vp8_setup_block_dptrs(&x->e_mbd);
+
+    vp8_setup_block_ptrs(x);
+
+    xd->mode_info_context->mbmi.mode = DC_PRED;
+    xd->mode_info_context->mbmi.uv_mode = DC_PRED;
+
+    xd->left_context = &cm->left_context;
+
+    vp8_zero(cpi->count_mb_ref_frame_usage)
+    vp8_zero(cpi->ymode_count)
+    vp8_zero(cpi->uv_mode_count)
+
+    x->mvc = cm->fc.mvc;
+
+    vpx_memset(cm->above_context, 0,
+               sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
+}
+
 void vp8_encode_frame(VP8_COMP *cpi)
 {
     int mb_row;
@@ -529,6 +645,17 @@
     int segment_counts[MAX_MB_SEGMENTS];
     int totalrate;
 
+    vpx_memset(segment_counts, 0, sizeof(segment_counts));
+    totalrate = 0;
+
+    if (cpi->compressor_speed == 2)
+    {
+        if (cpi->oxcf.cpu_used < 0)
+            cpi->Speed = -(cpi->oxcf.cpu_used);
+        else
+            vp8_auto_select_speed(cpi);
+    }
+
     // Functions setup for all frame types so we can use MC in AltRef
     if (cm->mcomp_filter_type == SIXTAP)
     {
@@ -553,10 +680,6 @@
                                       &cpi->common.rtcd.subpix, bilinear16x16);
     }
 
-    x->gf_active_ptr = (signed char *)cpi->gf_active_flags;     // Point to base of GF active flags data structure
-
-    x->vector_range = 32;
-
     // Reset frame count of inter 0,0 motion vector useage.
     cpi->inter_zz_count = 0;
 
@@ -567,89 +690,34 @@
     cpi->skip_true_count = 0;
     cpi->skip_false_count = 0;
 
-    x->act_zbin_adj = 0;
-
 #if 0
     // Experimental code
     cpi->frame_distortion = 0;
     cpi->last_mb_distortion = 0;
 #endif
 
-    totalrate = 0;
-
-    x->partition_info = x->pi;
-
-    xd->mode_info_context = cm->mi;
-    xd->mode_info_stride = cm->mode_info_stride;
-
-    xd->frame_type = cm->frame_type;
-
-    xd->frames_since_golden = cm->frames_since_golden;
-    xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;
     vp8_zero(cpi->MVcount);
-    // vp8_zero( Contexts)
     vp8_zero(cpi->coef_counts);
 
-    // reset intra mode contexts
-    if (cm->frame_type == KEY_FRAME)
-        vp8_init_mbmode_probs(cm);
-
-
     vp8cx_frame_init_quantizer(cpi);
 
-    if (cpi->compressor_speed == 2)
-    {
-        if (cpi->oxcf.cpu_used < 0)
-            cpi->Speed = -(cpi->oxcf.cpu_used);
-        else
-            vp8_auto_select_speed(cpi);
-    }
+    vp8_initialize_rd_consts(cpi,
+                             vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
 
-    vp8_initialize_rd_consts(cpi, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
     vp8cx_initialize_me_consts(cpi, cm->base_qindex);
 
-    // Copy data over into macro block data sturctures.
-    x->src = * cpi->Source;
-    xd->pre = cm->yv12_fb[cm->lst_fb_idx];
-    xd->dst = cm->yv12_fb[cm->new_fb_idx];
-
-    // set up frame new frame for intra coded blocks
-
-    vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);
-
-    vp8_build_block_offsets(x);
-
-    vp8_setup_block_dptrs(&x->e_mbd);
-
-    vp8_setup_block_ptrs(x);
-
-    xd->mode_info_context->mbmi.mode = DC_PRED;
-    xd->mode_info_context->mbmi.uv_mode = DC_PRED;
-
-    xd->left_context = &cm->left_context;
-
-    vp8_zero(cpi->count_mb_ref_frame_usage)
-    vp8_zero(cpi->ymode_count)
-    vp8_zero(cpi->uv_mode_count)
-
-    x->mvc = cm->fc.mvc;
-
-    vpx_memset(cm->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
-
     if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
     {
-        if(1)
-        {
-            // Build a frame level activity map
-            build_activity_map(cpi);
-        }
+        // Initialize encode frame context.
+        init_encode_frame_mb_context(cpi);
 
-        // Reset various MB pointers.
-        x->src = *cpi->Source;
-        x->mb_activity_ptr = cpi->mb_activity_map;
-        x->mb_norm_activity_ptr = cpi->mb_norm_activity_map;
+        // Build a frame level activity map
+        build_activity_map(cpi);
     }
 
+    // re-initencode frame context.
+    init_encode_frame_mb_context(cpi);
+
     {
         struct vpx_usec_timer  emr_timer;
         vpx_usec_timer_start(&emr_timer);
@@ -990,27 +1058,24 @@
 
 // Experimental stub function to create a per MB zbin adjustment based on
 // some previously calculated measure of MB activity.
-void adjust_act_zbin( VP8_COMP *cpi, int rate, MACROBLOCK *x )
+static void adjust_act_zbin( VP8_COMP *cpi, MACROBLOCK *x )
 {
-    INT64 act;
+#if USE_ACT_INDEX
+    x->act_zbin_adj = *(x->mb_activity_ptr);
+#else
     INT64 a;
     INT64 b;
+    INT64 act = *(x->mb_activity_ptr);
 
-    // Read activity from the map
-    act = (INT64)(*(x->mb_activity_ptr));
-
-    // Calculate a zbin adjustment for this mb
+    // Apply the masking to the RD multiplier.
     a = act + 4*cpi->activity_avg;
     b = 4*act + cpi->activity_avg;
-    if ( b > a )
-        //x->act_zbin_adj = (char)((b * 8) / a) - 8;
-        x->act_zbin_adj = 8;
+
+    if ( act > cpi->activity_avg )
+        x->act_zbin_adj = (int)(((INT64)b + (a>>1))/a) - 1;
     else
-        x->act_zbin_adj = 0;
-
-    // Tmp force to 0 to disable.
-    x->act_zbin_adj = 0;
-
+        x->act_zbin_adj = 1 - (int)(((INT64)a + (b>>1))/b);
+#endif
 }
 
 int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t)
@@ -1023,7 +1088,7 @@
 
         if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
         {
-            adjust_act_zbin( cpi, rate, x );
+            adjust_act_zbin( cpi, x );
             vp8_update_zbin_extra(cpi, x);
         }
     }
@@ -1107,7 +1172,7 @@
     if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
     {
         // Adjust the zbin based on this MB rate.
-        adjust_act_zbin( cpi, rate, x );
+        adjust_act_zbin( cpi, x );
     }
 
 #if 0
@@ -1137,11 +1202,10 @@
     {
         // Experimental code. Special case for gf and arf zeromv modes.
         // Increase zbin size to supress noise
+        cpi->zbin_mode_boost = 0;
         if (cpi->zbin_mode_boost_enabled)
         {
-            if ( xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME )
-                 cpi->zbin_mode_boost = 0;
-            else
+            if ( xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME )
             {
                 if (xd->mode_info_context->mbmi.mode == ZEROMV)
                 {
@@ -1156,9 +1220,6 @@
                     cpi->zbin_mode_boost = MV_ZBIN_BOOST;
             }
         }
-        else
-            cpi->zbin_mode_boost = 0;
-
         vp8_update_zbin_extra(cpi, x);
     }
 
diff --git a/vp8/encoder/ethreading.c b/vp8/encoder/ethreading.c
index 665b2d5..420ed8e 100644
--- a/vp8/encoder/ethreading.c
+++ b/vp8/encoder/ethreading.c
@@ -114,8 +114,6 @@
 
                 // Set the mb activity pointer to the start of the row.
                 x->mb_activity_ptr = &cpi->mb_activity_map[map_index];
-                x->mb_norm_activity_ptr =
-                    &cpi->mb_norm_activity_map[map_index];
 
                 // for each macroblock col in image
                 for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
@@ -230,7 +228,6 @@
 
                     // Increment the activity mask pointers.
                     x->mb_activity_ptr++;
-                    x->mb_norm_activity_ptr++;
 
                     /* save the block info */
                     for (i = 0; i < 16; i++)
diff --git a/vp8/encoder/firstpass.c b/vp8/encoder/firstpass.c
index 6bba5ec..bc18634 100644
--- a/vp8/encoder/firstpass.c
+++ b/vp8/encoder/firstpass.c
@@ -81,7 +81,7 @@
 
 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame);
 
-static int encode_intra(VP8_COMP *cpi, MACROBLOCK *x, int use_dc_pred)
+int encode_intra(VP8_COMP *cpi, MACROBLOCK *x, int use_dc_pred)
 {
 
     int i;
diff --git a/vp8/encoder/onyx_int.h b/vp8/encoder/onyx_int.h
index 84ddeeb..c460b9d 100644
--- a/vp8/encoder/onyx_int.h
+++ b/vp8/encoder/onyx_int.h
@@ -47,8 +47,8 @@
 #define MIN_THRESHMULT  32
 #define MAX_THRESHMULT  512
 
-#define GF_ZEROMV_ZBIN_BOOST 24
-#define LF_ZEROMV_ZBIN_BOOST 12
+#define GF_ZEROMV_ZBIN_BOOST 12
+#define LF_ZEROMV_ZBIN_BOOST 6
 #define MV_ZBIN_BOOST        4
 #define ZBIN_OQ_MAX 192
 
diff --git a/vp8/encoder/tokenize.c b/vp8/encoder/tokenize.c
index 2101432..329abac 100644
--- a/vp8/encoder/tokenize.c
+++ b/vp8/encoder/tokenize.c
@@ -98,7 +98,6 @@
     const BLOCKD *const b,
     TOKENEXTRA **tp,
     const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
-    const FRAME_TYPE frametype,
     ENTROPY_CONTEXT *a,
     ENTROPY_CONTEXT *l,
     VP8_COMP *cpi
@@ -149,7 +148,6 @@
     const BLOCKD *const b,
     TOKENEXTRA **tp,
     const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
-    const FRAME_TYPE frametype,
     ENTROPY_CONTEXT *a,
     ENTROPY_CONTEXT *l,
     VP8_COMP *cpi
@@ -196,14 +194,11 @@
 }
 
 
-static int mb_is_skippable(MACROBLOCKD *x)
+static int mb_is_skippable(MACROBLOCKD *x, int has_y2_block)
 {
-    int has_y2_block;
     int skip = 1;
     int i = 0;
 
-    has_y2_block = (x->mode_info_context->mbmi.mode != B_PRED
-                    && x->mode_info_context->mbmi.mode != SPLITMV);
     if (has_y2_block)
     {
         for (i = 0; i < 16; i++)
@@ -223,8 +218,12 @@
     ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)x->left_context;
     int plane_type;
     int b;
+    int has_y2_block;
 
-    x->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable(x);
+    has_y2_block = (x->mode_info_context->mbmi.mode != B_PRED
+                    && x->mode_info_context->mbmi.mode != SPLITMV);
+
+    x->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable(x, has_y2_block);
     if (x->mode_info_context->mbmi.mb_skip_coeff)
     {
         cpi->skip_true_count++;
@@ -241,29 +240,24 @@
 
     cpi->skip_false_count++;
 
-#if 0
-    vpx_memcpy(cpi->coef_counts_backup, cpi->coef_counts, sizeof(cpi->coef_counts));
-#endif
 
-    if (x->mode_info_context->mbmi.mode == B_PRED || x->mode_info_context->mbmi.mode == SPLITMV)
+
+    plane_type = 3;
+    if(has_y2_block)
     {
-        plane_type = 3;
-    }
-    else
-    {
-        tokenize2nd_order_b(x->block + 24, t, 1, x->frame_type,
+        tokenize2nd_order_b(x->block + 24, t, 1,
                    A + vp8_block2above[24], L + vp8_block2left[24], cpi);
         plane_type = 0;
 
     }
 
     for (b = 0; b < 16; b++)
-        tokenize1st_order_b(x->block + b, t, plane_type, x->frame_type,
+        tokenize1st_order_b(x->block + b, t, plane_type,
                             A + vp8_block2above[b],
                             L + vp8_block2left[b], cpi);
 
     for (b = 16; b < 24; b++)
-        tokenize1st_order_b(x->block + b, t, 2, x->frame_type,
+        tokenize1st_order_b(x->block + b, t, 2,
                             A + vp8_block2above[b],
                             L + vp8_block2left[b], cpi);
 
@@ -352,10 +346,7 @@
 
 static __inline void stuff2nd_order_b
 (
-    const BLOCKD *const b,
     TOKENEXTRA **tp,
-    const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
-    const FRAME_TYPE frametype,
     ENTROPY_CONTEXT *a,
     ENTROPY_CONTEXT *l,
     VP8_COMP *cpi
@@ -364,9 +355,6 @@
     int pt; /* near block/prev token context index */
     TOKENEXTRA *t = *tp;        /* store tokens starting here */
     VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
-    (void) frametype;
-    (void) type;
-    (void) b;
 
     t->Token = DCT_EOB_TOKEN;
     t->context_tree = cpi->common.fc.coef_probs [1] [0] [pt];
@@ -382,10 +370,7 @@
 
 static __inline void stuff1st_order_b
 (
-    const BLOCKD *const b,
     TOKENEXTRA **tp,
-    const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
-    const FRAME_TYPE frametype,
     ENTROPY_CONTEXT *a,
     ENTROPY_CONTEXT *l,
     VP8_COMP *cpi
@@ -394,9 +379,6 @@
     int pt; /* near block/prev token context index */
     TOKENEXTRA *t = *tp;        /* store tokens starting here */
     VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
-    (void) frametype;
-    (void) type;
-    (void) b;
 
     t->Token = DCT_EOB_TOKEN;
     t->context_tree = cpi->common.fc.coef_probs [0] [1] [pt];
@@ -411,10 +393,7 @@
 static __inline
 void stuff1st_order_buv
 (
-    const BLOCKD *const b,
     TOKENEXTRA **tp,
-    const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
-    const FRAME_TYPE frametype,
     ENTROPY_CONTEXT *a,
     ENTROPY_CONTEXT *l,
     VP8_COMP *cpi
@@ -423,9 +402,6 @@
     int pt; /* near block/prev token context index */
     TOKENEXTRA *t = *tp;        /* store tokens starting here */
     VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
-    (void) frametype;
-    (void) type;
-    (void) b;
 
     t->Token = DCT_EOB_TOKEN;
     t->context_tree = cpi->common.fc.coef_probs [2] [0] [pt];
@@ -445,17 +421,17 @@
     int plane_type;
     int b;
 
-    stuff2nd_order_b(x->block + 24, t, 1, x->frame_type,
+    stuff2nd_order_b(t,
                      A + vp8_block2above[24], L + vp8_block2left[24], cpi);
     plane_type = 0;
 
     for (b = 0; b < 16; b++)
-        stuff1st_order_b(x->block + b, t, plane_type, x->frame_type,
+        stuff1st_order_b(t,
                          A + vp8_block2above[b],
                          L + vp8_block2left[b], cpi);
 
     for (b = 16; b < 24; b++)
-        stuff1st_order_buv(x->block + b, t, 2, x->frame_type,
+        stuff1st_order_buv(t,
                            A + vp8_block2above[b],
                            L + vp8_block2left[b], cpi);