Merge "Renaming in MB_MODE_INFO"

8 files changed, 33 insertions, 33 deletions

diff --git a/vp9/common/vp9_alloccommon.c b/vp9/common/vp9_alloccommon.c
index a9027b7df..b19256eae 100644
--- a/vp9/common/vp9_alloccommon.c
+++ b/vp9/common/vp9_alloccommon.c
@@ -38,7 +38,7 @@ void vp9_update_mode_info_in_image(VP9_COMMON *cm, MODE_INFO *mi) {
   for (i = 0; i < cm->mi_rows; i++) {
     MODE_INFO *ptr = mi;
     for (j = 0; j < cm->mi_cols; j++) {
-      ptr->mbmi.mb_in_image = 1;
+      ptr->mbmi.in_image = 1;
       ptr++;  // Next element in the row
     }
 
diff --git a/vp9/common/vp9_blockd.h b/vp9/common/vp9_blockd.h
index 77c952f57..b22f8c048 100644
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -130,26 +130,26 @@ static INLINE int mi_height_log2(BLOCK_SIZE_TYPE sb_type) {
   return mi_height_log2_lookup[sb_type];
 }
 
+// This structure now relates to 8x8 block regions.
 typedef struct {
   MB_PREDICTION_MODE mode, uv_mode;
   MV_REFERENCE_FRAME ref_frame[2];
   TX_SIZE txfm_size;
-  int_mv mv[2]; // for each reference frame used
+  int_mv mv[2];                // for each reference frame used
   int_mv ref_mvs[MAX_REF_FRAMES][MAX_MV_REF_CANDIDATES];
   int_mv best_mv, best_second_mv;
 
-  uint8_t mb_mode_context[MAX_REF_FRAMES];
+  uint8_t mode_context[MAX_REF_FRAMES];
 
-  unsigned char mb_skip_coeff;                                /* does this mb has coefficients at all, 1=no coefficients, 0=need decode tokens */
-  unsigned char segment_id;           // Segment id for current frame
+  unsigned char skip_coeff;    // 0=need to decode coeffs, 1=no coefficients
+  unsigned char segment_id;    // Segment id for this block.
 
   // Flags used for prediction status of various bit-stream signals
   unsigned char seg_id_predicted;
 
-  // Indicates if the mb is part of the image (1) vs border (0)
-  // This can be useful in determining whether the MB provides
-  // a valid predictor
-  unsigned char mb_in_image;
+  // Indicates if the block is part of the image (1) vs border (0)
+  // This can be useful in determining whether it provides a valid predictor
+  unsigned char in_image;
 
   INTERPOLATIONFILTERTYPE interp_filter;
 
diff --git a/vp9/common/vp9_debugmodes.c b/vp9/common/vp9_debugmodes.c
index 370ebe8f8..f2def5c9c 100644
--- a/vp9/common/vp9_debugmodes.c
+++ b/vp9/common/vp9_debugmodes.c
@@ -57,7 +57,7 @@ void vp9_print_modes_and_motion_vectors(VP9_COMMON *cm, char *file) {
 
   print_mi_data(cm, mvs, "Partitions:", offsetof(MB_MODE_INFO, sb_type));
   print_mi_data(cm, mvs, "Modes:", offsetof(MB_MODE_INFO, mode));
-  print_mi_data(cm, mvs, "Skips:", offsetof(MB_MODE_INFO, mb_skip_coeff));
+  print_mi_data(cm, mvs, "Skips:", offsetof(MB_MODE_INFO, skip_coeff));
   print_mi_data(cm, mvs, "Ref frame:", offsetof(MB_MODE_INFO, ref_frame[0]));
   print_mi_data(cm, mvs, "Transform:", offsetof(MB_MODE_INFO, txfm_size));
   print_mi_data(cm, mvs, "UV Modes:", offsetof(MB_MODE_INFO, uv_mode));
diff --git a/vp9/common/vp9_loopfilter.c b/vp9/common/vp9_loopfilter.c
index 9944487f1..de22c4c83 100644
--- a/vp9/common/vp9_loopfilter.c
+++ b/vp9/common/vp9_loopfilter.c
@@ -263,7 +263,7 @@ static void filter_block_plane(VP9_COMMON *const cm,
 
     // Determine the vertical edges that need filtering
     for (c = 0; c < MI_BLOCK_SIZE && mi_col + c < cm->mi_cols; c += col_step) {
-      const int skip_this = mi[c].mbmi.mb_skip_coeff
+      const int skip_this = mi[c].mbmi.skip_coeff
                             && is_inter_block(&mi[c].mbmi);
       // left edge of current unit is block/partition edge -> no skip
       const int block_edge_left = b_width_log2(mi[c].mbmi.sb_type) ?
diff --git a/vp9/common/vp9_mvref_common.c b/vp9/common/vp9_mvref_common.c
index bb02649ff..c4c1f37b2 100644
--- a/vp9/common/vp9_mvref_common.c
+++ b/vp9/common/vp9_mvref_common.c
@@ -281,7 +281,7 @@ void vp9_find_mv_refs_idx(VP9_COMMON *cm, MACROBLOCKD *xd, MODE_INFO *here,
 
  Done:
 
-  mbmi->mb_mode_context[ref_frame] = counter_to_context[context_counter];
+  mbmi->mode_context[ref_frame] = counter_to_context[context_counter];
 
   // Clamp vectors
   for (idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx)
diff --git a/vp9/common/vp9_postproc.c b/vp9/common/vp9_postproc.c
index f42833bcc..58e0e1d67 100644
--- a/vp9/common/vp9_postproc.c
+++ b/vp9/common/vp9_postproc.c
@@ -737,7 +737,7 @@ int vp9_post_proc_frame(struct VP9Common *oci,
         char zz[4];
         int dc_diff = !(mi[mb_index].mbmi.mode != I4X4_PRED &&
                         mi[mb_index].mbmi.mode != SPLITMV &&
-                        mi[mb_index].mbmi.mb_skip_coeff);
+                        mi[mb_index].mbmi.skip_coeff);
 
         if (oci->frame_type == KEY_FRAME)
           sprintf(zz, "a");
diff --git a/vp9/common/vp9_pred_common.c b/vp9/common/vp9_pred_common.c
index f4dd36b38..829bf45a6 100644
--- a/vp9/common/vp9_pred_common.c
+++ b/vp9/common/vp9_pred_common.c
@@ -21,8 +21,8 @@ unsigned char vp9_get_pred_context_switchable_interp(const MACROBLOCKD *xd) {
   const MODE_INFO *const mi = xd->mode_info_context;
   const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
-  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
-  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
+  const int left_in_image = xd->left_available && left_mbmi->in_image;
+  const int above_in_image = xd->up_available && above_mbmi->in_image;
   // Note:
   // The mode info data structure has a one element border above and to the
   // left of the entries correpsonding to real macroblocks.
@@ -56,8 +56,8 @@ unsigned char vp9_get_pred_context_intra_inter(const MACROBLOCKD *xd) {
   const MODE_INFO *const mi = xd->mode_info_context;
   const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
-  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
-  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
+  const int left_in_image = xd->left_available && left_mbmi->in_image;
+  const int above_in_image = xd->up_available && above_mbmi->in_image;
   const int left_intra = !is_inter_block(left_mbmi);
   const int above_intra = !is_inter_block(above_mbmi);
 
@@ -83,8 +83,8 @@ unsigned char vp9_get_pred_context_comp_inter_inter(const VP9_COMMON *cm,
   const MODE_INFO *const mi = xd->mode_info_context;
   const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
-  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
-  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
+  const int left_in_image = xd->left_available && left_mbmi->in_image;
+  const int above_in_image = xd->up_available && above_mbmi->in_image;
   // Note:
   // The mode info data structure has a one element border above and to the
   // left of the entries correpsonding to real macroblocks.
@@ -128,8 +128,8 @@ unsigned char vp9_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
   const MODE_INFO *const mi = xd->mode_info_context;
   const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
-  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
-  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
+  const int left_in_image = xd->left_available && left_mbmi->in_image;
+  const int above_in_image = xd->up_available && above_mbmi->in_image;
   const int left_intra = !is_inter_block(left_mbmi);
   const int above_intra = !is_inter_block(above_mbmi);
 
@@ -206,8 +206,8 @@ unsigned char vp9_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) {
   const MODE_INFO *const mi = xd->mode_info_context;
   const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
-  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
-  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
+  const int left_in_image = xd->left_available && left_mbmi->in_image;
+  const int above_in_image = xd->up_available && above_mbmi->in_image;
   const int left_intra = !is_inter_block(left_mbmi);
   const int above_intra = !is_inter_block(above_mbmi);
 
@@ -271,8 +271,8 @@ unsigned char vp9_get_pred_context_single_ref_p2(const MACROBLOCKD *xd) {
   const MODE_INFO *const mi = xd->mode_info_context;
   const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
-  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
-  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
+  const int left_in_image = xd->left_available && left_mbmi->in_image;
+  const int above_in_image = xd->up_available && above_mbmi->in_image;
   const int left_intra = !is_inter_block(left_mbmi);
   const int above_intra = !is_inter_block(above_mbmi);
 
@@ -361,18 +361,18 @@ unsigned char vp9_get_pred_context_tx_size(const MACROBLOCKD *xd) {
   const MODE_INFO *const mi = xd->mode_info_context;
   const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
-  const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
-  const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
+  const int left_in_image = xd->left_available && left_mbmi->in_image;
+  const int above_in_image = xd->up_available && above_mbmi->in_image;
   const int max_tx_size = max_txsize_lookup[mi->mbmi.sb_type];
   int above_context = max_tx_size;
   int left_context = max_tx_size;
 
   if (above_in_image)
-    above_context = above_mbmi->mb_skip_coeff ? max_tx_size
+    above_context = above_mbmi->skip_coeff ? max_tx_size
                                               : above_mbmi->txfm_size;
 
   if (left_in_image)
-    left_context = left_mbmi->mb_skip_coeff ? max_tx_size
+    left_context = left_mbmi->skip_coeff ? max_tx_size
                                             : left_mbmi->txfm_size;
 
   if (!left_in_image)
@@ -409,7 +409,7 @@ void vp9_set_pred_flag_mbskip(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,
 
   for (y = 0; y < ymis; y++)
     for (x = 0; x < xmis; x++)
-      mi[y * cm->mode_info_stride + x].mbmi.mb_skip_coeff = pred_flag;
+      mi[y * cm->mode_info_stride + x].mbmi.skip_coeff = pred_flag;
 }
 
 int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,
diff --git a/vp9/common/vp9_pred_common.h b/vp9/common/vp9_pred_common.h
index a09558fa4..4b024ed35 100644
--- a/vp9/common/vp9_pred_common.h
+++ b/vp9/common/vp9_pred_common.h
@@ -39,8 +39,8 @@ static INLINE int vp9_get_pred_context_mbskip(const MACROBLOCKD *xd) {
   const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
   const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
 
-  return above_mbmi->mb_skip_coeff +
-             (xd->left_available ? left_mbmi->mb_skip_coeff : 0);
+  return above_mbmi->skip_coeff +
+             (xd->left_available ? left_mbmi->skip_coeff : 0);
 }
 
 static INLINE vp9_prob vp9_get_pred_prob_mbskip(const VP9_COMMON *cm,
@@ -49,7 +49,7 @@ static INLINE vp9_prob vp9_get_pred_prob_mbskip(const VP9_COMMON *cm,
 }
 
 static INLINE unsigned char vp9_get_pred_flag_mbskip(const MACROBLOCKD *xd) {
-  return xd->mode_info_context->mbmi.mb_skip_coeff;
+  return xd->mode_info_context->mbmi.skip_coeff;
 }
 
 void vp9_set_pred_flag_mbskip(VP9_COMMON *cm, BLOCK_SIZE_TYPE bsize,