Moving segmentation related vars into separate struct.

Adding segmentation struct to vp9_seg_common.h. Struct members are from
macroblockd and VP9Common structs. Moving segmentation related constants
and enums to vp9_seg_common.h.

Change-Id: I23fabc33f11a359249f5f80d161daf569d02ec03

3 files changed, 47 insertions, 47 deletions

diff --git a/vp9/decoder/vp9_decodemv.c b/vp9/decoder/vp9_decodemv.c
index 369505c2f..3fc62c365 100644
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -44,8 +44,8 @@ static MB_PREDICTION_MODE read_inter_mode(vp9_reader *r, const vp9_prob *p) {
   return (MB_PREDICTION_MODE)treed_read(r, vp9_sb_mv_ref_tree, p);
 }
 
-static int read_segment_id(vp9_reader *r, MACROBLOCKD *xd) {
-  return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
+static int read_segment_id(vp9_reader *r, const struct segmentation *seg) {
+  return treed_read(r, vp9_segment_tree, seg->tree_probs);
 }
 
 static TX_SIZE read_selected_txfm_size(VP9_COMMON *cm, MACROBLOCKD *xd,
@@ -105,13 +105,13 @@ static void set_segment_id(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
 
 static int read_intra_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                  vp9_reader *r) {
-  VP9_COMMON *const cm = &pbi->common;
   MACROBLOCKD *const xd = &pbi->mb;
+  struct segmentation *const seg = &xd->seg;
   const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
 
-  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
-    const int segment_id = read_segment_id(r, xd);
-    set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
+  if (seg->enabled && seg->update_map) {
+    const int segment_id = read_segment_id(r, seg);
+    set_segment_id(&pbi->common, bsize, mi_row, mi_col, segment_id);
     return segment_id;
   } else {
     return 0;
@@ -121,7 +121,7 @@ static int read_intra_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
 static uint8_t read_skip_coeff(VP9D_COMP *pbi, int segment_id, vp9_reader *r) {
   VP9_COMMON *const cm = &pbi->common;
   MACROBLOCKD *const xd = &pbi->mb;
-  int skip_coeff = vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
+  int skip_coeff = vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_SKIP);
   if (!skip_coeff) {
     const uint8_t ctx = vp9_get_pred_context_mbskip(cm, xd);
     skip_coeff = vp9_read(r, vp9_get_pred_prob_mbskip(cm, xd));
@@ -290,8 +290,8 @@ static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
   MACROBLOCKD *const xd = &pbi->mb;
   FRAME_CONTEXT *const fc = &cm->fc;
 
-  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME)) {
-    ref_frame[0] = vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME);
+  if (vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_REF_FRAME)) {
+    ref_frame[0] = vp9_get_segdata(&xd->seg, segment_id, SEG_LVL_REF_FRAME);
     ref_frame[1] = NONE;
   } else {
     const int comp_ctx = vp9_get_pred_context_comp_inter_inter(cm, xd);
@@ -366,26 +366,28 @@ static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
                                  vp9_reader *r) {
   VP9_COMMON *const cm = &pbi->common;
   MACROBLOCKD *const xd = &pbi->mb;
+  struct segmentation *const seg = &xd->seg;
   const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
   int pred_segment_id;
   int segment_id;
 
-  if (!xd->segmentation_enabled)
+  if (!seg->enabled)
     return 0;  // Default for disabled segmentation
 
   pred_segment_id = vp9_get_segment_id(cm, cm->last_frame_seg_map,
-                                                   bsize, mi_row, mi_col);
-  if (!xd->update_mb_segmentation_map)
+                                       bsize, mi_row, mi_col);
+  if (!seg->update_map)
     return pred_segment_id;
 
-  if (cm->temporal_update) {
+
+  if (seg->temporal_update) {
     const vp9_prob pred_prob = vp9_get_pred_prob_seg_id(cm, xd);
     const int pred_flag = vp9_read(r, pred_prob);
     vp9_set_pred_flag_seg_id(xd, bsize, pred_flag);
     segment_id = pred_flag ? pred_segment_id
-                           : read_segment_id(r, xd);
+                           : read_segment_id(r, seg);
   } else {
-    segment_id = read_segment_id(r, xd);
+    segment_id = read_segment_id(r, seg);
   }
   set_segment_id(cm, bsize, mi_row, mi_col, segment_id);
   return segment_id;
@@ -455,14 +457,14 @@ static MV_REFERENCE_FRAME read_reference_frame(VP9D_COMP *pbi, int segment_id,
   MACROBLOCKD *const xd = &pbi->mb;
 
   MV_REFERENCE_FRAME ref;
-  if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME)) {
+  if (!vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_REF_FRAME)) {
     const int ctx = vp9_get_pred_context_intra_inter(cm, xd);
     ref = (MV_REFERENCE_FRAME)
               vp9_read(r, vp9_get_pred_prob_intra_inter(cm, xd));
     cm->fc.intra_inter_count[ctx][ref != INTRA_FRAME]++;
   } else {
-    ref = (MV_REFERENCE_FRAME)
-              vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME) != INTRA_FRAME;
+    ref = (MV_REFERENCE_FRAME) vp9_get_segdata(&xd->seg, segment_id,
+                                   SEG_LVL_REF_FRAME) != INTRA_FRAME;
   }
   return ref;
 }
@@ -515,7 +517,7 @@ static void read_inter_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
 
     mv_ref_p = cm->fc.inter_mode_probs[mbmi->mb_mode_context[ref0]];
 
-    if (vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
+    if (vp9_segfeature_active(&xd->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
       mbmi->mode = ZEROMV;
     } else if (bsize >= BLOCK_SIZE_SB8X8) {
       mbmi->mode = read_inter_mode(r, mv_ref_p);
diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c
index 37bdad29d..48be06946 100644
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -174,7 +174,7 @@ static int decode_tokens(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize, vp9_reader *r) {
     vp9_reset_sb_tokens_context(xd, bsize);
     return -1;
   } else {
-    if (xd->segmentation_enabled)
+    if (xd->seg.enabled)
       mb_init_dequantizer(&pbi->common, xd);
 
     // TODO(dkovalev) if (!vp9_reader_has_error(r))
@@ -395,55 +395,53 @@ static void read_coef_probs(FRAME_CONTEXT *fc, TXFM_MODE txfm_mode,
     read_coef_probs_common(fc, TX_32X32, r);
 }
 
-static void setup_segmentation(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
+static void setup_segmentation(struct segmentation *seg,
+                               struct vp9_read_bit_buffer *rb) {
   int i, j;
 
-  VP9_COMMON *const cm = &pbi->common;
-  MACROBLOCKD *const xd = &pbi->mb;
-
-  xd->update_mb_segmentation_map = 0;
-  xd->update_mb_segmentation_data = 0;
+  seg->update_map = 0;
+  seg->update_data = 0;
 
-  xd->segmentation_enabled = vp9_rb_read_bit(rb);
-  if (!xd->segmentation_enabled)
+  seg->enabled = vp9_rb_read_bit(rb);
+  if (!seg->enabled)
     return;
 
   // Segmentation map update
-  xd->update_mb_segmentation_map = vp9_rb_read_bit(rb);
-  if (xd->update_mb_segmentation_map) {
+  seg->update_map = vp9_rb_read_bit(rb);
+  if (seg->update_map) {
     for (i = 0; i < MB_SEG_TREE_PROBS; i++)
-      xd->mb_segment_tree_probs[i] = vp9_rb_read_bit(rb) ?
-                                         vp9_rb_read_literal(rb, 8) : MAX_PROB;
+      seg->tree_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
+                                               : MAX_PROB;
 
-    cm->temporal_update = vp9_rb_read_bit(rb);
-    if (cm->temporal_update) {
+    seg->temporal_update = vp9_rb_read_bit(rb);
+    if (seg->temporal_update) {
       for (i = 0; i < PREDICTION_PROBS; i++)
-        cm->segment_pred_probs[i] = vp9_rb_read_bit(rb) ?
-                                        vp9_rb_read_literal(rb, 8) : MAX_PROB;
+        seg->pred_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
+                                                 : MAX_PROB;
     } else {
       for (i = 0; i < PREDICTION_PROBS; i++)
-        cm->segment_pred_probs[i] = MAX_PROB;
+        seg->pred_probs[i] = MAX_PROB;
     }
   }
 
   // Segmentation data update
-  xd->update_mb_segmentation_data = vp9_rb_read_bit(rb);
-  if (xd->update_mb_segmentation_data) {
-    xd->mb_segment_abs_delta = vp9_rb_read_bit(rb);
+  seg->update_data = vp9_rb_read_bit(rb);
+  if (seg->update_data) {
+    seg->abs_delta = vp9_rb_read_bit(rb);
 
-    vp9_clearall_segfeatures(xd);
+    vp9_clearall_segfeatures(seg);
 
     for (i = 0; i < MAX_MB_SEGMENTS; i++) {
       for (j = 0; j < SEG_LVL_MAX; j++) {
         int data = 0;
         const int feature_enabled = vp9_rb_read_bit(rb);
         if (feature_enabled) {
-          vp9_enable_segfeature(xd, i, j);
+          vp9_enable_segfeature(seg, i, j);
           data = decode_unsigned_max(rb, vp9_seg_feature_data_max(j));
           if (vp9_is_segfeature_signed(j))
             data = vp9_rb_read_bit(rb) ? -data : data;
         }
-        vp9_set_segdata(xd, i, j, data);
+        vp9_set_segdata(seg, i, j, data);
       }
     }
   }
@@ -902,7 +900,7 @@ static size_t read_uncompressed_header(VP9D_COMP *pbi,
 
   setup_loopfilter(pbi, rb);
   setup_quantization(pbi, rb);
-  setup_segmentation(pbi, rb);
+  setup_segmentation(&pbi->mb.seg, rb);
 
   setup_tile_info(cm, rb);
 
diff --git a/vp9/decoder/vp9_detokenize.c b/vp9/decoder/vp9_detokenize.c
index 76889c477..3a4fae065 100644
--- a/vp9/decoder/vp9_detokenize.c
+++ b/vp9/decoder/vp9_detokenize.c
@@ -278,8 +278,8 @@ SKIP_START:
   return c;
 }
 
-static int get_eob(MACROBLOCKD* const xd, int segment_id, int eob_max) {
-  return vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP) ? 0 : eob_max;
+static int get_eob(struct segmentation *seg, int segment_id, int eob_max) {
+  return vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP) ? 0 : eob_max;
 }
 
 struct decode_block_args {
@@ -300,7 +300,7 @@ static void decode_block(int plane, int block,
   struct macroblockd_plane* pd = &xd->plane[plane];
   const int segment_id = xd->mode_info_context->mbmi.segment_id;
   const TX_SIZE ss_tx_size = ss_txfrm_size / 2;
-  const int seg_eob = get_eob(xd, segment_id, 16 << ss_txfrm_size);
+  const int seg_eob = get_eob(&xd->seg, segment_id, 16 << ss_txfrm_size);
   const int off = block >> ss_txfrm_size;
   const int mod = bw - ss_tx_size - pd->subsampling_x;
   const int aoff = (off & ((1 << mod) - 1)) << ss_tx_size;