Merge CONFIGURE_SEGMENTATION experiment.

Removal of CONFIGURE_SEGMENTATION ifdefs.

Removal of legacy support code fo the old coding mechanism.

Use local reference "xd" for MACROBLOCKD structure in
encode_frame_to_data_rate()

Moved call to choose_segmap_coding_method() out of encode
loop as the cost of segmentation is not properly accounted
in the loop anyway. If this is desirable in the future it
can be moved back. The use of this function to do all the
analysis and set the probabilities also removes the need
to track segment useage in threading code.

Change-Id: I85bc8fd63440e7176c73d26cb742698f9b70cade

12 files changed, 92 insertions, 174 deletions

diff --git a/vp8/common/blockd.h b/vp8/common/blockd.h
index 9e23f4d7d..222cff574 100644
--- a/vp8/common/blockd.h
+++ b/vp8/common/blockd.h
@@ -185,11 +185,10 @@ typedef struct
     unsigned char mb_skip_coeff;                                /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */
     unsigned char need_to_clamp_mvs;
     unsigned char segment_id;                  /* Which set of segmentation parameters should be used for this MB */
-#if CONFIG_SEGMENTATION
+
     // Flag used when temporal prediction of segment map is enabled.
     // 1 means it is predicted 0 that it must be coded explicitly
     unsigned char seg_id_predicted;
-#endif
 
 } MB_MODE_INFO;
 
@@ -266,11 +265,9 @@ typedef struct MacroBlockD
     // Probability Tree used to code Segment number
     vp8_prob mb_segment_tree_probs[MB_FEATURE_TREE_PROBS];
 
-#if CONFIG_SEGMENTATION
     // Context probabilities when using predictive coding of segment id
     vp8_prob mb_segment_pred_probs[SEGMENT_PREDICTION_PROBS];
     unsigned char temporal_update;
-#endif
 
     // Segment features
     signed char segment_feature_data[MAX_MB_SEGMENTS][SEG_LVL_MAX];
diff --git a/vp8/decoder/decodemv.c b/vp8/decoder/decodemv.c
index d75469f87..f7c0e9e64 100644
--- a/vp8/decoder/decodemv.c
+++ b/vp8/decoder/decodemv.c
@@ -374,9 +374,6 @@ static void mb_mode_mv_init(VP8D_COMP *pbi)
 {
     vp8_reader *const bc = & pbi->bc;
     MV_CONTEXT *const mvc = pbi->common.fc.mvc;
-#if CONFIG_SEGMENTATION
-    MACROBLOCKD *const xd  = & pbi->mb;
-#endif
 
 #if CONFIG_ERROR_CONCEALMENT
     /* Default is that no macroblock is corrupt, therefore we initialize
@@ -429,10 +426,8 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
     const int mis = pbi->common.mode_info_stride;
     MACROBLOCKD *const xd  = & pbi->mb;
 
-#if CONFIG_SEGMENTATION
     int pred_context;
     int index = mb_row * pbi->common.mb_cols + mb_col;
-#endif
     int_mv *const mv = & mbmi->mv;
     int mb_to_left_edge;
     int mb_to_right_edge;
@@ -457,47 +452,44 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
 
     /* If required read in new segmentation data for this MB */
     if (xd->update_mb_segmentation_map)
+    {
+        // Is temporal coding of the segment id for this mb enabled.
+        if (xd->temporal_update)
+        {
+            // Work out a context for decoding seg_id_predicted.
+            pred_context = 0;
+            if (mb_col != 0)
+                pred_context += (mi-1)->mbmi.seg_id_predicted;
+            if (mb_row != 0)
+                pred_context +=
+                    (mi-pbi->common.mb_cols)->mbmi.seg_id_predicted;
+
+            mbmi->seg_id_predicted =
+                vp8_read(bc,
+                         xd->mb_segment_pred_probs[pred_context]);
+
+            if ( mbmi->seg_id_predicted )
+            {
+                mbmi->segment_id = pbi->segmentation_map[index];
+            }
+            // If the segment id was not predicted decode it explicitly
+            else
             {
-#if CONFIG_SEGMENTATION
-                // Is temporal coding of the segment id for this mb enabled.
-                if (xd->temporal_update)
-                {
-                    // Work out a context for decoding seg_id_predicted.
-                    pred_context = 0;
-                    if (mb_col != 0)
-                        pred_context += (mi-1)->mbmi.seg_id_predicted;
-                    if (mb_row != 0)
-                        pred_context +=
-                            (mi-pbi->common.mb_cols)->mbmi.seg_id_predicted;
-
-                    mbmi->seg_id_predicted =
-                        vp8_read(bc,
-                                 xd->mb_segment_pred_probs[pred_context]);
-
-                    if ( mbmi->seg_id_predicted )
-                    {
-                        mbmi->segment_id = pbi->segmentation_map[index];
-                    }
-                    // If the segment id was not predicted decode it explicitly
-                    else
-                    {
-                        vp8_read_mb_segid(bc, &mi->mbmi, xd);
-                        pbi->segmentation_map[index] = mbmi->segment_id;
-                    }
-
-                }
-                // Normal unpredicted coding mode
-                else
-                {
-                    vp8_read_mb_segid(bc, &mi->mbmi, xd);
-                    pbi->segmentation_map[index] = mbmi->segment_id;
-                }
-                index++;
-#else
                 vp8_read_mb_segid(bc, &mi->mbmi, xd);
-#endif
+                pbi->segmentation_map[index] = mbmi->segment_id;
             }
 
+        }
+        // Normal unpredicted coding mode
+        else
+        {
+            vp8_read_mb_segid(bc, &mi->mbmi, xd);
+            pbi->segmentation_map[index] = mbmi->segment_id;
+        }
+        index++;
+
+    }
+
 //#if CONFIG_SEGFEATURES
     if ( pbi->common.mb_no_coeff_skip &&
          ( !segfeature_active( xd,
diff --git a/vp8/decoder/decodframe.c b/vp8/decoder/decodframe.c
index c572b0714..3d2ba2da9 100644
--- a/vp8/decoder/decodframe.c
+++ b/vp8/decoder/decodframe.c
@@ -1008,11 +1008,9 @@ int vp8_decode_frame(VP8D_COMP *pbi)
         // updated this frame.
         xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc);
 
-#if CONFIG_SEGMENTATION
         // If so what method will be used.
         if ( xd->update_mb_segmentation_map )
             xd->temporal_update = (unsigned char)vp8_read_bit(bc);
-#endif
 
         // Is the segment data being updated
         xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc);
@@ -1060,7 +1058,7 @@ int vp8_decode_frame(VP8D_COMP *pbi)
 
         if (xd->update_mb_segmentation_map)
         {
-            /* Which macro block level features are enabled */
+            // Which macro block level features are enabled
             vpx_memset(xd->mb_segment_tree_probs, 255,
                        sizeof(xd->mb_segment_tree_probs));
             vpx_memset(xd->mb_segment_pred_probs, 255,
@@ -1076,7 +1074,7 @@ int vp8_decode_frame(VP8D_COMP *pbi)
                     xd->mb_segment_tree_probs[i] =
                         (vp8_prob)vp8_read_literal(bc, 8);
             }
-#if CONFIG_SEGMENTATION
+
             // If predictive coding of segment map is enabled read the
             // prediction probabilities.
             if ( xd->temporal_update )
@@ -1092,7 +1090,6 @@ int vp8_decode_frame(VP8D_COMP *pbi)
                             (vp8_prob)vp8_read_literal(bc, 8);
                 }
             }
-#endif
         }
     }
 
@@ -1282,11 +1279,9 @@ int vp8_decode_frame(VP8D_COMP *pbi)
     vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG));
     vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG));
 
-#if CONFIG_SEGMENTATION
      // Create the encoder segmentation map and set all entries to 0
      if (!pbi->segmentation_map)
        CHECK_MEM_ERROR(pbi->segmentation_map, vpx_calloc((pc->mb_rows * pc->mb_cols), 1));
-#endif
 
     /* set up frame new frame for intra coded blocks */
 #if CONFIG_MULTITHREAD
diff --git a/vp8/decoder/onyxd_if.c b/vp8/decoder/onyxd_if.c
index 6c8840304..4f77a6b83 100644
--- a/vp8/decoder/onyxd_if.c
+++ b/vp8/decoder/onyxd_if.c
@@ -161,11 +161,10 @@ void vp8dx_remove_decompressor(VP8D_PTR ptr)
 
     if (!pbi)
         return;
-#if CONFIG_SEGMENTATION
-     // Delete sementation map
+
+    // Delete sementation map
     if (pbi->segmentation_map != 0)
         vpx_free(pbi->segmentation_map);
-#endif
 
 #if CONFIG_MULTITHREAD
     if (pbi->b_multithreaded_rd)
diff --git a/vp8/decoder/onyxd_int.h b/vp8/decoder/onyxd_int.h
index 12aed4666..14ac2f5d4 100644
--- a/vp8/decoder/onyxd_int.h
+++ b/vp8/decoder/onyxd_int.h
@@ -89,9 +89,8 @@ typedef struct VP8Decompressor
     const unsigned char *partitions[MAX_PARTITIONS];
     unsigned int   partition_sizes[MAX_PARTITIONS];
     unsigned int   num_partitions;
-#if CONFIG_SEGMENTATION
     unsigned char *segmentation_map;
-#endif
+
 #if CONFIG_MULTITHREAD
     /* variable for threading */
 
diff --git a/vp8/encoder/bitstream.c b/vp8/encoder/bitstream.c
index cea5a6ce4..f239d8107 100644
--- a/vp8/encoder/bitstream.c
+++ b/vp8/encoder/bitstream.c
@@ -939,11 +939,11 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi)
     vp8_writer *const w = & cpi->bc;
     const MV_CONTEXT *mvc = pc->fc.mvc;
     MACROBLOCKD *xd = &cpi->mb.e_mbd;
-#if CONFIG_SEGMENTATION
+
     int i;
     int pred_context;
     int index = 0;
-#endif
+
     const int *const rfct = cpi->count_mb_ref_frame_usage;
     const int rf_intra = rfct[INTRA_FRAME];
     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
@@ -1040,7 +1040,6 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi)
 
             if (cpi->mb.e_mbd.update_mb_segmentation_map)
             {
-#if CONFIG_SEGMENTATION
                 // Is temporal coding of the segment map enabled
                 if (xd->temporal_update)
                 {
@@ -1066,9 +1065,6 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi)
                     write_mb_segid(w, mi, &cpi->mb.e_mbd);
                 }
                 index++;
-#else
-                write_mb_segid(w, mi, &cpi->mb.e_mbd);
-#endif
             }
 
 //#if CONFIG_SEGFEATURES
@@ -1212,10 +1208,8 @@ static void write_kfmodes(VP8_COMP *cpi)
     const VP8_COMMON *const c = & cpi->common;
     /* const */
     MODE_INFO *m = c->mi;
-#if CONFIG_SEGMENTATION
     int i;
     int index = 0;
-#endif
     int mb_row = -1;
     int prob_skip_false = 0;
 
@@ -1261,9 +1255,7 @@ static void write_kfmodes(VP8_COMP *cpi)
 
             if (cpi->mb.e_mbd.update_mb_segmentation_map)
             {
-#if CONFIG_SEGMENTATION
                 index++;
-#endif
                 write_mb_segid(bc, &m->mbmi, &cpi->mb.e_mbd);
             }
 
@@ -1972,11 +1964,11 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
     {
         // Indicate whether or not the segmentation map is being updated.
         vp8_write_bit(bc, (xd->update_mb_segmentation_map) ? 1 : 0);
-#if CONFIG_SEGMENTATION
+
         // If it is, then indicate the method that will be used.
         if ( xd->update_mb_segmentation_map )
             vp8_write_bit(bc, (xd->temporal_update) ? 1:0);
-#endif
+
         vp8_write_bit(bc, (xd->update_mb_segmentation_data) ? 1 : 0);
 
         if (xd->update_mb_segmentation_data)
@@ -2046,7 +2038,7 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
                 else
                     vp8_write_bit(bc, 0);
             }
-#if CONFIG_SEGMENTATION
+
             // If predictive coding of segment map is enabled send the
             // prediction probabilities.
             if ( xd->temporal_update )
@@ -2064,7 +2056,6 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
                         vp8_write_bit(bc, 0);
                 }
             }
-#endif
         }
     }
 
diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c
index 4cde41df4..860beb4ad 100644
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -568,7 +568,6 @@ void encode_mb_row(VP8_COMP *cpi,
                    MACROBLOCK  *x,
                    MACROBLOCKD *xd,
                    TOKENEXTRA **tp,
-                   int *segment_counts,
                    int *totalrate)
 {
     int recon_yoffset, recon_uvoffset;
@@ -766,9 +765,6 @@ void encode_mb_row(VP8_COMP *cpi,
         recon_yoffset += 16;
         recon_uvoffset += 8;
 
-#if !CONFIG_SEGMENTATION
-        segment_counts[xd->mode_info_context->mbmi.segment_id] ++;
-#endif
         // skip to next mb
         xd->mode_info_context++;
         x->partition_info++;
@@ -910,7 +906,6 @@ void vp8_encode_frame(VP8_COMP *cpi)
     MACROBLOCKD *const xd = & x->e_mbd;
 
     TOKENEXTRA *tp = cpi->tok;
-    int segment_counts[MAX_MB_SEGMENTS];
     int totalrate;
 
 
@@ -925,7 +920,6 @@ void vp8_encode_frame(VP8_COMP *cpi)
     }
 #endif
 
-    vpx_memset(segment_counts, 0, sizeof(segment_counts));
     totalrate = 0;
 
     if (cpi->compressor_speed == 2)
@@ -963,8 +957,6 @@ void vp8_encode_frame(VP8_COMP *cpi)
     // Reset frame count of inter 0,0 motion vector usage.
     cpi->inter_zz_count = 0;
 
-    vpx_memset(segment_counts, 0, sizeof(segment_counts));
-
     cpi->prediction_error = 0;
     cpi->intra_error = 0;
     cpi->skip_true_count = 0;
@@ -1023,7 +1015,7 @@ void vp8_encode_frame(VP8_COMP *cpi)
 
                 tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
 
-                encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
+                encode_mb_row(cpi, cm, mb_row, x, xd, &tp, &totalrate);
 
                 // adjust to the next row of mbs
                 x->src.y_buffer += 16 * x->src.y_stride * (cpi->encoding_thread_count + 1) - 16 * cm->mb_cols;
@@ -1045,17 +1037,6 @@ void vp8_encode_frame(VP8_COMP *cpi)
                 cpi->tok_count += cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start;
             }
 
-            if (xd->segmentation_enabled)
-            {
-                int i, j;
-
-                for (i = 0; i < cpi->encoding_thread_count; i++)
-                {
-                    for (j = 0; j < 4; j++)
-                        segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
-                }
-            }
-
             for (i = 0; i < cpi->encoding_thread_count; i++)
             {
                 totalrate += cpi->mb_row_ei[i].totalrate;
@@ -1071,7 +1052,7 @@ void vp8_encode_frame(VP8_COMP *cpi)
 
                 vp8_zero(cm->left_context)
 
-                encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
+                encode_mb_row(cpi, cm, mb_row, x, xd, &tp, &totalrate);
 
                 // adjust to the next row of mbs
                 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
@@ -1090,41 +1071,11 @@ void vp8_encode_frame(VP8_COMP *cpi)
 
     // Work out the segment probabilites if segmentation is enabled and
     // the map is due to be updated
-    if (xd->segmentation_enabled && xd->update_mb_segmentation_map)
-    {
-        int tot_count;
-        int i;
-        int count1,count2,count3,count4;
-
-        // Set to defaults
-        vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs));
-
-#if CONFIG_SEGMENTATION
-        // Select the coding strategy for the segment map (temporal or spatial)
-        choose_segmap_coding_method( cpi );
-#else
-        tot_count = segment_counts[0] + segment_counts[1] + segment_counts[2] + segment_counts[3];
-        count1 = segment_counts[0] + segment_counts[1];
-        count2 = segment_counts[2] + segment_counts[3];
-
-        if (tot_count)
-            xd->mb_segment_tree_probs[0] = (count1 * 255) / tot_count;
-
-        if (count1 > 0)
-            xd->mb_segment_tree_probs[1] = (segment_counts[0] * 255) /count1;
-
-        if (count2 > 0)
-            xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) /count2;
-
-        // Zero probabilities not allowed
-        for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
-
-        {
-            if (xd->mb_segment_tree_probs[i] == 0)
-                xd->mb_segment_tree_probs[i] = 1;
-        }
-#endif
-    }
+    //if (xd->segmentation_enabled && xd->update_mb_segmentation_map)
+    //{
+    //    // Select the coding strategy for the segment map (temporal or spatial)
+    //    choose_segmap_coding_method( cpi );
+    //}
 
     // 256 rate units to the bit
     cpi->projected_frame_size = totalrate >> 8;   // projected_frame_size in units of BYTES
diff --git a/vp8/encoder/ethreading.c b/vp8/encoder/ethreading.c
index 94fb429d8..bd0b1c718 100644
--- a/vp8/encoder/ethreading.c
+++ b/vp8/encoder/ethreading.c
@@ -83,7 +83,6 @@ THREAD_FUNCTION thread_encoding_proc(void *p_data)
             MACROBLOCKD *xd = &x->e_mbd;
             TOKENEXTRA *tp ;
 
-            int *segment_counts = mbri->segment_counts;
             int *totalrate = &mbri->totalrate;
 
             if (cpi->b_multi_threaded == FALSE) // we're shutting down
@@ -248,9 +247,6 @@ THREAD_FUNCTION thread_encoding_proc(void *p_data)
                     recon_yoffset += 16;
                     recon_uvoffset += 8;
 
-                    // Keep track of segment useage
-                    segment_counts[xd->mode_info_context->mbmi.segment_id]++;
-
                     // skip to next mb
                     xd->mode_info_context++;
                     x->partition_info++;
@@ -437,7 +433,6 @@ void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
 
         mb->vector_range             = 32;
 
-        vpx_memset(mbr_ei[i].segment_counts, 0, sizeof(mbr_ei[i].segment_counts));
         mbr_ei[i].totalrate = 0;
 
         mb->partition_info = x->pi + x->e_mbd.mode_info_stride * (i + 1);
diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c
index 991b469d2..e5212acf6 100644
--- a/vp8/encoder/onyx_if.c
+++ b/vp8/encoder/onyx_if.c
@@ -363,10 +363,9 @@ static void dealloc_compressor_data(VP8_COMP *cpi)
 
     // Delete sementation map
     vpx_free(cpi->segmentation_map);
-#if CONFIG_SEGMENTATION
-    vpx_free(cpi->last_segmentation_map);
-#endif
     cpi->segmentation_map = 0;
+    vpx_free(cpi->last_segmentation_map);
+    cpi->last_segmentation_map = 0;
 
     vpx_free(cpi->active_map);
     cpi->active_map = 0;
@@ -2124,11 +2123,9 @@ VP8_PTR vp8_create_compressor(VP8_CONFIG *oxcf)
     // Create the encoder segmentation map and set all entries to 0
     CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
 
-#if CONFIG_SEGMENTATION
     // And a copy "last_segmentation_map" for temporal coding
     CHECK_MEM_ERROR(cpi->last_segmentation_map,
         vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
-#endif
 
     CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
     vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
@@ -3566,6 +3563,9 @@ static void encode_frame_to_data_rate
     unsigned int *frame_flags
 )
 {
+    VP8_COMMON *cm = &cpi->common;
+    MACROBLOCKD *xd = &cpi->mb.e_mbd;
+
     int Q;
     int frame_over_shoot_limit;
     int frame_under_shoot_limit;
@@ -3581,7 +3581,6 @@ static void encode_frame_to_data_rate
     int zbin_oq_low = 0;
     int top_index;
     int bottom_index;
-    VP8_COMMON *cm = &cpi->common;
     int active_worst_qchanged = FALSE;
 
     int overshoot_seen = FALSE;
@@ -3591,7 +3590,6 @@ static void encode_frame_to_data_rate
     int drop_mark50 = drop_mark / 4;
     int drop_mark25 = drop_mark / 8;
 
-
     // Clear down mmx registers to allow floating point in what follows
     vp8_clear_system_state();
 
@@ -3609,7 +3607,6 @@ static void encode_frame_to_data_rate
 
     // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
 #if !(CONFIG_REALTIME_ONLY)
-
     if (cpi->pass == 2)
     {
         if (cpi->common.refresh_alt_ref_frame)
@@ -3660,7 +3657,7 @@ static void encode_frame_to_data_rate
     }
 
     // Set default state for segment based loop filter update flags
-    cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
+    xd->mode_ref_lf_delta_update = 0;
 
     // Set various flags etc to special state if it is a key frame
     if (cm->frame_type == KEY_FRAME)
@@ -3671,10 +3668,10 @@ static void encode_frame_to_data_rate
         setup_features(cpi);
 
         // If segmentation is enabled force a map update for key frames
-        if (cpi->mb.e_mbd.segmentation_enabled)
+        if (xd->segmentation_enabled)
         {
-            cpi->mb.e_mbd.update_mb_segmentation_map = 1;
-            cpi->mb.e_mbd.update_mb_segmentation_data = 1;
+            xd->update_mb_segmentation_map = 1;
+            xd->update_mb_segmentation_data = 1;
         }
 
         // The alternate reference frame cannot be active for a key frame
@@ -4168,10 +4165,10 @@ static void encode_frame_to_data_rate
                 setup_features(cpi);
 
                 // If segmentation is enabled force a map update for key frames
-                if (cpi->mb.e_mbd.segmentation_enabled)
+                if (xd->segmentation_enabled)
                 {
-                    cpi->mb.e_mbd.update_mb_segmentation_map = 1;
-                    cpi->mb.e_mbd.update_mb_segmentation_data = 1;
+                    xd->update_mb_segmentation_map = 1;
+                    xd->update_mb_segmentation_data = 1;
                 }
 
                 vp8_restore_coding_context(cpi);
@@ -4502,6 +4499,18 @@ static void encode_frame_to_data_rate
         sem_wait(&cpi->h_event_end_lpf);
 #endif
 
+    // Work out the segment probabilites if segmentation is enabled and
+    // the map is due to be updated
+    if (xd->segmentation_enabled && xd->update_mb_segmentation_map)
+    {
+        // Select the coding strategy for the segment map (temporal or spatial)
+        choose_segmap_coding_method( cpi );
+
+        // Take a copy of the segment map if it changed for future comparison
+        vpx_memcpy( cpi->last_segmentation_map,
+                    cpi->segmentation_map, cm->MBs );
+    }
+
     // build the bitstream
     vp8_pack_bitstream(cpi, dest, size);
 
@@ -4798,20 +4807,10 @@ static void encode_frame_to_data_rate
         cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
     }
 
-    // Take a copy of the segment map if it changed for future comparison
-#if CONFIG_SEGMENTATION
-    if ( cpi->mb.e_mbd.segmentation_enabled &&
-         cpi->mb.e_mbd.update_mb_segmentation_map )
-    {
-        vpx_memcpy( cpi->last_segmentation_map,
-                    cpi->segmentation_map, cm->MBs );
-    }
-#endif
-
     // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
-    cpi->mb.e_mbd.update_mb_segmentation_map = 0;
-    cpi->mb.e_mbd.update_mb_segmentation_data = 0;
-    cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
+    xd->update_mb_segmentation_map = 0;
+    xd->update_mb_segmentation_data = 0;
+    xd->mode_ref_lf_delta_update = 0;
 
 
     // Dont increment frame counters if this was an altref buffer update not a real frame
diff --git a/vp8/encoder/onyx_int.h b/vp8/encoder/onyx_int.h
index c35dfed08..465faeec7 100644
--- a/vp8/encoder/onyx_int.h
+++ b/vp8/encoder/onyx_int.h
@@ -220,7 +220,6 @@ typedef struct
 typedef struct
 {
     MACROBLOCK  mb;
-    int segment_counts[MAX_MB_SEGMENTS];
     int totalrate;
 } MB_ROW_COMP;
 
@@ -506,9 +505,7 @@ typedef struct VP8_COMP
 #endif
 
     unsigned char *segmentation_map;
-#if CONFIG_SEGMENTATION
     unsigned char *last_segmentation_map;
-#endif
 
     // segment threashold for encode breakout
     int  segment_encode_breakout[MAX_MB_SEGMENTS];
diff --git a/vp8/encoder/segmentation.c b/vp8/encoder/segmentation.c
index 2dc96c61b..da6c68648 100644
--- a/vp8/encoder/segmentation.c
+++ b/vp8/encoder/segmentation.c
@@ -115,11 +115,10 @@ void vp8_set_segment_data(VP8_PTR ptr,
     //            sizeof(cpi->mb.e_mbd.segment_feature_mask));
 }
 
-#if CONFIG_SEGMENTATION
 // Based on set of segment counts calculate a probability tree
-void calc_segtree_probs( MACROBLOCKD * xd,
-                         int * segcounts,
-                         vp8_prob * segment_tree_probs )
+static void calc_segtree_probs( MACROBLOCKD * xd,
+                                int * segcounts,
+                                vp8_prob * segment_tree_probs )
 {
     int count1,count2;
     int tot_count;
@@ -150,9 +149,9 @@ void calc_segtree_probs( MACROBLOCKD * xd,
 }
 
 // Based on set of segment counts and probabilities calculate a cost estimate
-int cost_segmap( MACROBLOCKD * xd,
-                 int * segcounts,
-                 vp8_prob * probs )
+static int cost_segmap( MACROBLOCKD * xd,
+                        int * segcounts,
+                        vp8_prob * probs )
 {
     int cost;
     int count1,count2;
@@ -199,6 +198,13 @@ void choose_segmap_coding_method( VP8_COMP *cpi )
     vp8_prob t_pred_tree[MB_FEATURE_TREE_PROBS];
     vp8_prob t_nopred_prob[SEGMENT_PREDICTION_PROBS];
 
+    // Set default state for the segment tree probabilities and the
+    // temporal coding probabilities
+    vpx_memset(xd->mb_segment_tree_probs, 255,
+               sizeof(xd->mb_segment_tree_probs));
+    vpx_memset(xd->mb_segment_pred_probs, 255,
+               sizeof(xd->mb_segment_pred_probs));
+
     vpx_memset(no_pred_segcounts, 0, sizeof(no_pred_segcounts));
     vpx_memset(t_unpred_seg_counts, 0, sizeof(t_unpred_seg_counts));
     vpx_memset(temporal_predictor_count, 0, sizeof(temporal_predictor_count));
@@ -320,4 +326,3 @@ void choose_segmap_coding_method( VP8_COMP *cpi )
                      no_pred_tree, sizeof(no_pred_tree) );
     }
 }
-#endif
diff --git a/vp8/encoder/segmentation.h b/vp8/encoder/segmentation.h
index f3f2b9c6f..a7e1f7cfe 100644
--- a/vp8/encoder/segmentation.h
+++ b/vp8/encoder/segmentation.h
@@ -38,8 +38,6 @@ extern void vp8_set_segmentation_map(VP8_PTR ptr, unsigned char *segmentation_ma
 //
 extern void vp8_set_segment_data(VP8_PTR ptr, signed char *feature_data, unsigned char abs_delta);
 
-#if CONFIG_SEGMENTATION
 extern void choose_segmap_coding_method( VP8_COMP *cpi );
-#endif
 
 #endif /* __INC_SEGMENTATION_H__ */