#include "entropymode.h"
#include "onyxd_int.h"
#include "findnearmv.h"
-#include "demode.h"
+
#if CONFIG_DEBUG
#include <assert.h>
#endif
+static int vp8_read_bmode(vp8_reader *bc, const vp8_prob *p)
+{
+ const int i = vp8_treed_read(bc, vp8_bmode_tree, p);
+
+ return i;
+}
+
+
+static int vp8_read_ymode(vp8_reader *bc, const vp8_prob *p)
+{
+ const int i = vp8_treed_read(bc, vp8_ymode_tree, p);
+
+ return i;
+}
+
+static int vp8_kfread_ymode(vp8_reader *bc, const vp8_prob *p)
+{
+ const int i = vp8_treed_read(bc, vp8_kf_ymode_tree, p);
+
+ return i;
+}
+
+
+
+static int vp8_read_uv_mode(vp8_reader *bc, const vp8_prob *p)
+{
+ const int i = vp8_treed_read(bc, vp8_uv_mode_tree, p);
+
+ return i;
+}
+
+static void vp8_read_mb_features(vp8_reader *r, MB_MODE_INFO *mi, MACROBLOCKD *x)
+{
+ // Is segmentation enabled
+ if (x->segmentation_enabled && x->update_mb_segmentation_map)
+ {
+ // If so then read the segment id.
+ if (vp8_read(r, x->mb_segment_tree_probs[0]))
+ mi->segment_id = (unsigned char)(2 + vp8_read(r, x->mb_segment_tree_probs[2]));
+ else
+ mi->segment_id = (unsigned char)(vp8_read(r, x->mb_segment_tree_probs[1]));
+ }
+}
+
+static void vp8_kfread_modes(VP8D_COMP *pbi, MODE_INFO *m, int mb_row, int mb_col)
+{
+ vp8_reader *const bc = & pbi->bc;
+ const int mis = pbi->common.mode_info_stride;
+
+ {
+ MB_PREDICTION_MODE y_mode;
+
+ // Read the Macroblock segmentation map if it is being updated explicitly this frame (reset to 0 above by default)
+ // By default on a key frame reset all MBs to segment 0
+ m->mbmi.segment_id = 0;
+
+ if (pbi->mb.update_mb_segmentation_map)
+ vp8_read_mb_features(bc, &m->mbmi, &pbi->mb);
+
+ // Read the macroblock coeff skip flag if this feature is in use, else default to 0
+ if (pbi->common.mb_no_coeff_skip)
+ m->mbmi.mb_skip_coeff = vp8_read(bc, pbi->prob_skip_false);
+ else
+ m->mbmi.mb_skip_coeff = 0;
+
+ y_mode = (MB_PREDICTION_MODE) vp8_kfread_ymode(bc, pbi->common.kf_ymode_prob);
+
+ m->mbmi.ref_frame = INTRA_FRAME;
+
+ if ((m->mbmi.mode = y_mode) == B_PRED)
+ {
+ int i = 0;
+
+ do
+ {
+ const B_PREDICTION_MODE A = vp8_above_bmi(m, i, mis)->mode;
+ const B_PREDICTION_MODE L = vp8_left_bmi(m, i)->mode;
+
+ m->bmi[i].mode = (B_PREDICTION_MODE) vp8_read_bmode(bc, pbi->common.kf_bmode_prob [A] [L]);
+ }
+ while (++i < 16);
+ }
+ else
+ {
+ int BMode;
+ int i = 0;
+
+ switch (y_mode)
+ {
+ case DC_PRED:
+ BMode = B_DC_PRED;
+ break;
+ case V_PRED:
+ BMode = B_VE_PRED;
+ break;
+ case H_PRED:
+ BMode = B_HE_PRED;
+ break;
+ case TM_PRED:
+ BMode = B_TM_PRED;
+ break;
+ default:
+ BMode = B_DC_PRED;
+ break;
+ }
+
+ do
+ {
+ m->bmi[i].mode = (B_PREDICTION_MODE)BMode;
+ }
+ while (++i < 16);
+ }
+
+ m->mbmi.uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc, pbi->common.kf_uv_mode_prob);
+ }
+}
static int read_mvcomponent(vp8_reader *r, const MV_CONTEXT *mvc)
{
return (MB_PREDICTION_MODE)i;
}
+
+#ifdef VPX_MODE_COUNT
unsigned int vp8_mv_cont_count[5][4] =
{
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 }
};
+#endif
-void vp8_decode_mode_mvs(VP8D_COMP *pbi)
-{
- const MV Zero = { 0, 0};
+unsigned char vp8_mbsplit_offset[4][16] = {
+ { 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 2, 8, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+};
- VP8_COMMON *const pc = & pbi->common;
- vp8_reader *const bc = & pbi->bc;
+unsigned char vp8_mbsplit_fill_count[4] = {8, 8, 4, 1};
+unsigned char vp8_mbsplit_fill_offset[4][16] = {
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+ { 0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15},
+ { 0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15},
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+};
- MODE_INFO *mi = pc->mi, *ms;
- const int mis = pc->mode_info_stride;
- MV_CONTEXT *const mvc = pc->fc.mvc;
- int mb_row = -1;
- vp8_prob prob_intra;
- vp8_prob prob_last;
- vp8_prob prob_gf;
- vp8_prob prob_skip_false = 0;
+void vp8_mb_mode_mv_init(VP8D_COMP *pbi)
+{
+ vp8_reader *const bc = & pbi->bc;
+ MV_CONTEXT *const mvc = pbi->common.fc.mvc;
- if (pc->mb_no_coeff_skip)
- prob_skip_false = (vp8_prob)vp8_read_literal(bc, 8);
+ pbi->prob_skip_false = 0;
+ if (pbi->common.mb_no_coeff_skip)
+ pbi->prob_skip_false = (vp8_prob)vp8_read_literal(bc, 8);
- prob_intra = (vp8_prob)vp8_read_literal(bc, 8);
- prob_last = (vp8_prob)vp8_read_literal(bc, 8);
- prob_gf = (vp8_prob)vp8_read_literal(bc, 8);
+ if(pbi->common.frame_type != KEY_FRAME)
+ {
+ pbi->prob_intra = (vp8_prob)vp8_read_literal(bc, 8);
+ pbi->prob_last = (vp8_prob)vp8_read_literal(bc, 8);
+ pbi->prob_gf = (vp8_prob)vp8_read_literal(bc, 8);
- ms = pc->mi - 1;
+ if (vp8_read_bit(bc))
+ {
+ int i = 0;
- if (vp8_read_bit(bc))
- {
- int i = 0;
+ do
+ {
+ pbi->common.fc.ymode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
+ }
+ while (++i < 4);
+ }
- do
+ if (vp8_read_bit(bc))
{
- pc->fc.ymode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
+ int i = 0;
+
+ do
+ {
+ pbi->common.fc.uv_mode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
+ }
+ while (++i < 3);
}
- while (++i < 4);
+
+ read_mvcontexts(bc, mvc);
}
+}
- if (vp8_read_bit(bc))
+void vp8_read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
+ int mb_row, int mb_col)
+{
+ const MV Zero = { 0, 0};
+ vp8_reader *const bc = & pbi->bc;
+ MV_CONTEXT *const mvc = pbi->common.fc.mvc;
+ const int mis = pbi->common.mode_info_stride;
+
+ MV *const mv = & mbmi->mv.as_mv;
+ int mb_to_left_edge;
+ int mb_to_right_edge;
+ int mb_to_top_edge;
+ int mb_to_bottom_edge;
+
+ mb_to_top_edge = pbi->mb.mb_to_top_edge;
+ mb_to_bottom_edge = pbi->mb.mb_to_bottom_edge;
+ mb_to_top_edge -= LEFT_TOP_MARGIN;
+ mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
+
+ mbmi->need_to_clamp_mvs = 0;
+ // Distance of Mb to the various image edges.
+ // These specified to 8th pel as they are always compared to MV values that are in 1/8th pel units
+ pbi->mb.mb_to_left_edge =
+ mb_to_left_edge = -((mb_col * 16) << 3);
+ mb_to_left_edge -= LEFT_TOP_MARGIN;
+
+ pbi->mb.mb_to_right_edge =
+ mb_to_right_edge = ((pbi->common.mb_cols - 1 - mb_col) * 16) << 3;
+ mb_to_right_edge += RIGHT_BOTTOM_MARGIN;
+
+ // If required read in new segmentation data for this MB
+ if (pbi->mb.update_mb_segmentation_map)
+ vp8_read_mb_features(bc, mbmi, &pbi->mb);
+
+ // Read the macroblock coeff skip flag if this feature is in use, else default to 0
+ if (pbi->common.mb_no_coeff_skip)
+ mbmi->mb_skip_coeff = vp8_read(bc, pbi->prob_skip_false);
+ else
+ mbmi->mb_skip_coeff = 0;
+
+ if ((mbmi->ref_frame = (MV_REFERENCE_FRAME) vp8_read(bc, pbi->prob_intra))) /* inter MB */
{
- int i = 0;
+ int rct[4];
+ vp8_prob mv_ref_p [VP8_MVREFS-1];
+ MV nearest, nearby, best_mv;
- do
+ if (vp8_read(bc, pbi->prob_last))
{
- pc->fc.uv_mode_prob[i] = (vp8_prob) vp8_read_literal(bc, 8);
+ mbmi->ref_frame = (MV_REFERENCE_FRAME)((int)mbmi->ref_frame + (int)(1 + vp8_read(bc, pbi->prob_gf)));
}
- while (++i < 3);
- }
- read_mvcontexts(bc, mvc);
+ vp8_find_near_mvs(&pbi->mb, mi, &nearest, &nearby, &best_mv, rct, mbmi->ref_frame, pbi->common.ref_frame_sign_bias);
- while (++mb_row < pc->mb_rows)
- {
- int mb_col = -1;
+ vp8_mv_ref_probs(mv_ref_p, rct);
- while (++mb_col < pc->mb_cols)
+ mbmi->uv_mode = DC_PRED;
+ switch (mbmi->mode = read_mv_ref(bc, mv_ref_p))
{
- MB_MODE_INFO *const mbmi = & mi->mbmi;
- MV *const mv = & mbmi->mv.as_mv;
- VP8_COMMON *const pc = &pbi->common;
- MACROBLOCKD *xd = &pbi->mb;
-
- mbmi->need_to_clamp_mvs = 0;
- // Distance of Mb to the various image edges.
- // These specified to 8th pel as they are always compared to MV values that are in 1/8th pel units
- xd->mb_to_left_edge = -((mb_col * 16) << 3);
- xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
- xd->mb_to_top_edge = -((mb_row * 16)) << 3;
- xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
-
- // If required read in new segmentation data for this MB
- if (pbi->mb.update_mb_segmentation_map)
- vp8_read_mb_features(bc, mbmi, &pbi->mb);
+ case SPLITMV:
+ {
+ const int s = mbmi->partitioning =
+ vp8_treed_read(bc, vp8_mbsplit_tree, vp8_mbsplit_probs);
+ const int num_p = vp8_mbsplit_count [s];
+ int j = 0;
- // Read the macroblock coeff skip flag if this feature is in use, else default to 0
- if (pc->mb_no_coeff_skip)
- mbmi->mb_skip_coeff = vp8_read(bc, prob_skip_false);
- else
- mbmi->mb_skip_coeff = 0;
+ do /* for each subset j */
+ {
+ B_MODE_INFO bmi;
+ MV *const mv = & bmi.mv.as_mv;
- mbmi->uv_mode = DC_PRED;
+ int k; /* first block in subset j */
+ int mv_contz;
+ k = vp8_mbsplit_offset[s][j];
- if ((mbmi->ref_frame = (MV_REFERENCE_FRAME) vp8_read(bc, prob_intra))) /* inter MB */
- {
- int rct[4];
- vp8_prob mv_ref_p [VP8_MVREFS-1];
- MV nearest, nearby, best_mv;
+ mv_contz = vp8_mv_cont(&(vp8_left_bmi(mi, k)->mv.as_mv), &(vp8_above_bmi(mi, k, mis)->mv.as_mv));
- if (vp8_read(bc, prob_last))
+ switch (bmi.mode = (B_PREDICTION_MODE) sub_mv_ref(bc, vp8_sub_mv_ref_prob2 [mv_contz])) //pc->fc.sub_mv_ref_prob))
{
- mbmi->ref_frame = (MV_REFERENCE_FRAME)((int)mbmi->ref_frame + (int)(1 + vp8_read(bc, prob_gf)));
+ case NEW4X4:
+ read_mv(bc, mv, (const MV_CONTEXT *) mvc);
+ mv->row += best_mv.row;
+ mv->col += best_mv.col;
+ #ifdef VPX_MODE_COUNT
+ vp8_mv_cont_count[mv_contz][3]++;
+ #endif
+ break;
+ case LEFT4X4:
+ *mv = vp8_left_bmi(mi, k)->mv.as_mv;
+ #ifdef VPX_MODE_COUNT
+ vp8_mv_cont_count[mv_contz][0]++;
+ #endif
+ break;
+ case ABOVE4X4:
+ *mv = vp8_above_bmi(mi, k, mis)->mv.as_mv;
+ #ifdef VPX_MODE_COUNT
+ vp8_mv_cont_count[mv_contz][1]++;
+ #endif
+ break;
+ case ZERO4X4:
+ *mv = Zero;
+ #ifdef VPX_MODE_COUNT
+ vp8_mv_cont_count[mv_contz][2]++;
+ #endif
+ break;
+ default:
+ break;
}
- vp8_find_near_mvs(xd, mi, &nearest, &nearby, &best_mv, rct, mbmi->ref_frame, pbi->common.ref_frame_sign_bias);
+ mbmi->need_to_clamp_mvs = (mv->col < mb_to_left_edge) ? 1 : 0;
+ mbmi->need_to_clamp_mvs |= (mv->col > mb_to_right_edge) ? 1 : 0;
+ mbmi->need_to_clamp_mvs |= (mv->row < mb_to_top_edge) ? 1 : 0;
+ mbmi->need_to_clamp_mvs |= (mv->row > mb_to_bottom_edge) ? 1 : 0;
- vp8_mv_ref_probs(mv_ref_p, rct);
-
- switch (mbmi->mode = read_mv_ref(bc, mv_ref_p))
- {
- case SPLITMV:
{
- const int s = mbmi->partitioning = vp8_treed_read(
- bc, vp8_mbsplit_tree, vp8_mbsplit_probs
- );
- const int num_p = vp8_mbsplit_count [s];
- const int *const L = vp8_mbsplits [s];
- int j = 0;
-
- do /* for each subset j */
- {
- B_MODE_INFO bmi;
- MV *const mv = & bmi.mv.as_mv;
-
- int k = -1; /* first block in subset j */
- int mv_contz;
-
- while (j != L[++k])
- {
-#if CONFIG_DEBUG
- if (k >= 16)
- {
- assert(0);
- }
-#endif
- }
-
- mv_contz = vp8_mv_cont(&(vp8_left_bmi(mi, k)->mv.as_mv), &(vp8_above_bmi(mi, k, mis)->mv.as_mv));
-
- switch (bmi.mode = (B_PREDICTION_MODE) sub_mv_ref(bc, vp8_sub_mv_ref_prob2 [mv_contz])) //pc->fc.sub_mv_ref_prob))
- {
- case NEW4X4:
- read_mv(bc, mv, (const MV_CONTEXT *) mvc);
- mv->row += best_mv.row;
- mv->col += best_mv.col;
-#ifdef VPX_MODE_COUNT
- vp8_mv_cont_count[mv_contz][3]++;
-#endif
- break;
- case LEFT4X4:
- *mv = vp8_left_bmi(mi, k)->mv.as_mv;
-#ifdef VPX_MODE_COUNT
- vp8_mv_cont_count[mv_contz][0]++;
-#endif
- break;
- case ABOVE4X4:
- *mv = vp8_above_bmi(mi, k, mis)->mv.as_mv;
-#ifdef VPX_MODE_COUNT
- vp8_mv_cont_count[mv_contz][1]++;
-#endif
- break;
- case ZERO4X4:
- *mv = Zero;
-#ifdef VPX_MODE_COUNT
- vp8_mv_cont_count[mv_contz][2]++;
-#endif
- break;
- default:
- break;
- }
-
- if (mv->col < xd->mb_to_left_edge
- - LEFT_TOP_MARGIN
- || mv->col > xd->mb_to_right_edge
- + RIGHT_BOTTOM_MARGIN
- || mv->row < xd->mb_to_top_edge
- - LEFT_TOP_MARGIN
- || mv->row > xd->mb_to_bottom_edge
- + RIGHT_BOTTOM_MARGIN
- )
- mbmi->need_to_clamp_mvs = 1;
-
- /* Fill (uniform) modes, mvs of jth subset.
- Must do it here because ensuing subsets can
- refer back to us via "left" or "above". */
- do
- if (j == L[k])
- mi->bmi[k] = bmi;
-
- while (++k < 16);
- }
- while (++j < num_p);
- }
-
- *mv = mi->bmi[15].mv.as_mv;
+ /* Fill (uniform) modes, mvs of jth subset.
+ Must do it here because ensuing subsets can
+ refer back to us via "left" or "above". */
+ unsigned char *fill_offset;
+ unsigned int fill_count = vp8_mbsplit_fill_count[s];
- break; /* done with SPLITMV */
+ fill_offset = &vp8_mbsplit_fill_offset[s][(unsigned char)j * vp8_mbsplit_fill_count[s]];
- case NEARMV:
- *mv = nearby;
+ do {
+ mi->bmi[ *fill_offset] = bmi;
+ fill_offset++;
- // Clip "next_nearest" so that it does not extend to far out of image
- if (mv->col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
- mv->col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
- else if (mv->col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
- mv->col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
+ }while (--fill_count);
+ }
- if (mv->row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
- mv->row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
- else if (mv->row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
- mv->row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
+ }
+ while (++j < num_p);
+ }
- goto propagate_mv;
+ *mv = mi->bmi[15].mv.as_mv;
+
+ break; /* done with SPLITMV */
+
+ case NEARMV:
+ *mv = nearby;
+ // Clip "next_nearest" so that it does not extend to far out of image
+ mv->col = (mv->col < mb_to_left_edge) ? mb_to_left_edge : mv->col;
+ mv->col = (mv->col > mb_to_right_edge) ? mb_to_right_edge : mv->col;
+ mv->row = (mv->row < mb_to_top_edge) ? mb_to_top_edge : mv->row;
+ mv->row = (mv->row > mb_to_bottom_edge) ? mb_to_bottom_edge : mv->row;
+ goto propagate_mv;
+
+ case NEARESTMV:
+ *mv = nearest;
+ // Clip "next_nearest" so that it does not extend to far out of image
+ mv->col = (mv->col < mb_to_left_edge) ? mb_to_left_edge : mv->col;
+ mv->col = (mv->col > mb_to_right_edge) ? mb_to_right_edge : mv->col;
+ mv->row = (mv->row < mb_to_top_edge) ? mb_to_top_edge : mv->row;
+ mv->row = (mv->row > mb_to_bottom_edge) ? mb_to_bottom_edge : mv->row;
+ goto propagate_mv;
+
+ case ZEROMV:
+ *mv = Zero;
+ goto propagate_mv;
+
+ case NEWMV:
+ read_mv(bc, mv, (const MV_CONTEXT *) mvc);
+ mv->row += best_mv.row;
+ mv->col += best_mv.col;
+
+ /* Don't need to check this on NEARMV and NEARESTMV modes
+ * since those modes clamp the MV. The NEWMV mode does not,
+ * so signal to the prediction stage whether special
+ * handling may be required.
+ */
+ mbmi->need_to_clamp_mvs = (mv->col < mb_to_left_edge) ? 1 : 0;
+ mbmi->need_to_clamp_mvs |= (mv->col > mb_to_right_edge) ? 1 : 0;
+ mbmi->need_to_clamp_mvs |= (mv->row < mb_to_top_edge) ? 1 : 0;
+ mbmi->need_to_clamp_mvs |= (mv->row > mb_to_bottom_edge) ? 1 : 0;
+
+ propagate_mv: /* same MV throughout */
+ {
+ //int i=0;
+ //do
+ //{
+ // mi->bmi[i].mv.as_mv = *mv;
+ //}
+ //while( ++i < 16);
+
+ mi->bmi[0].mv.as_mv = *mv;
+ mi->bmi[1].mv.as_mv = *mv;
+ mi->bmi[2].mv.as_mv = *mv;
+ mi->bmi[3].mv.as_mv = *mv;
+ mi->bmi[4].mv.as_mv = *mv;
+ mi->bmi[5].mv.as_mv = *mv;
+ mi->bmi[6].mv.as_mv = *mv;
+ mi->bmi[7].mv.as_mv = *mv;
+ mi->bmi[8].mv.as_mv = *mv;
+ mi->bmi[9].mv.as_mv = *mv;
+ mi->bmi[10].mv.as_mv = *mv;
+ mi->bmi[11].mv.as_mv = *mv;
+ mi->bmi[12].mv.as_mv = *mv;
+ mi->bmi[13].mv.as_mv = *mv;
+ mi->bmi[14].mv.as_mv = *mv;
+ mi->bmi[15].mv.as_mv = *mv;
+ }
+ break;
+ default:;
+ #if CONFIG_DEBUG
+ assert(0);
+ #endif
+ }
+ }
+ else
+ {
+ /* MB is intra coded */
+ int j = 0;
+ do
+ {
+ mi->bmi[j].mv.as_mv = Zero;
+ }
+ while (++j < 16);
- case NEARESTMV:
- *mv = nearest;
+ if ((mbmi->mode = (MB_PREDICTION_MODE) vp8_read_ymode(bc, pbi->common.fc.ymode_prob)) == B_PRED)
+ {
+ j = 0;
+ do
+ {
+ mi->bmi[j].mode = (B_PREDICTION_MODE)vp8_read_bmode(bc, pbi->common.fc.bmode_prob);
+ }
+ while (++j < 16);
+ }
- // Clip "next_nearest" so that it does not extend to far out of image
- if (mv->col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
- mv->col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
- else if (mv->col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
- mv->col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
+ mbmi->uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc, pbi->common.fc.uv_mode_prob);
+ }
- if (mv->row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
- mv->row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
- else if (mv->row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
- mv->row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
+}
- goto propagate_mv;
+void vp8_decode_mode_mvs(VP8D_COMP *pbi)
+{
+ MODE_INFO *mi = pbi->common.mi;
+ int mb_row = -1;
- case ZEROMV:
- *mv = Zero;
- goto propagate_mv;
+ vp8_mb_mode_mv_init(pbi);
- case NEWMV:
- read_mv(bc, mv, (const MV_CONTEXT *) mvc);
- mv->row += best_mv.row;
- mv->col += best_mv.col;
+ while (++mb_row < pbi->common.mb_rows)
+ {
+ int mb_col = -1;
+ int mb_to_top_edge;
+ int mb_to_bottom_edge;
- /* Don't need to check this on NEARMV and NEARESTMV modes
- * since those modes clamp the MV. The NEWMV mode does not,
- * so signal to the prediction stage whether special
- * handling may be required.
- */
- if (mv->col < xd->mb_to_left_edge - LEFT_TOP_MARGIN
- || mv->col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN
- || mv->row < xd->mb_to_top_edge - LEFT_TOP_MARGIN
- || mv->row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN
- )
- mbmi->need_to_clamp_mvs = 1;
-
- propagate_mv: /* same MV throughout */
- {
- //int i=0;
- //do
- //{
- // mi->bmi[i].mv.as_mv = *mv;
- //}
- //while( ++i < 16);
-
- mi->bmi[0].mv.as_mv = *mv;
- mi->bmi[1].mv.as_mv = *mv;
- mi->bmi[2].mv.as_mv = *mv;
- mi->bmi[3].mv.as_mv = *mv;
- mi->bmi[4].mv.as_mv = *mv;
- mi->bmi[5].mv.as_mv = *mv;
- mi->bmi[6].mv.as_mv = *mv;
- mi->bmi[7].mv.as_mv = *mv;
- mi->bmi[8].mv.as_mv = *mv;
- mi->bmi[9].mv.as_mv = *mv;
- mi->bmi[10].mv.as_mv = *mv;
- mi->bmi[11].mv.as_mv = *mv;
- mi->bmi[12].mv.as_mv = *mv;
- mi->bmi[13].mv.as_mv = *mv;
- mi->bmi[14].mv.as_mv = *mv;
- mi->bmi[15].mv.as_mv = *mv;
- }
+ pbi->mb.mb_to_top_edge =
+ mb_to_top_edge = -((mb_row * 16)) << 3;
+ mb_to_top_edge -= LEFT_TOP_MARGIN;
- break;
+ pbi->mb.mb_to_bottom_edge =
+ mb_to_bottom_edge = ((pbi->common.mb_rows - 1 - mb_row) * 16) << 3;
+ mb_to_bottom_edge += RIGHT_BOTTOM_MARGIN;
- default:;
-#if CONFIG_DEBUG
- assert(0);
-#endif
- }
- }
+ while (++mb_col < pbi->common.mb_cols)
+ {
+// vp8_read_mb_modes_mv(pbi, xd->mode_info_context, &xd->mode_info_context->mbmi, mb_row, mb_col);
+ if(pbi->common.frame_type == KEY_FRAME)
+ vp8_kfread_modes(pbi, mi, mb_row, mb_col);
else
- {
- /* MB is intra coded */
-
- int j = 0;
-
- do
- {
- mi->bmi[j].mv.as_mv = Zero;
- }
- while (++j < 16);
-
- *mv = Zero;
-
- if ((mbmi->mode = (MB_PREDICTION_MODE) vp8_read_ymode(bc, pc->fc.ymode_prob)) == B_PRED)
- {
- int j = 0;
-
- do
- {
- mi->bmi[j].mode = (B_PREDICTION_MODE)vp8_read_bmode(bc, pc->fc.bmode_prob);
- }
- while (++j < 16);
- }
-
- mbmi->uv_mode = (MB_PREDICTION_MODE)vp8_read_uv_mode(bc, pc->fc.uv_mode_prob);
- }
+ vp8_read_mb_modes_mv(pbi, mi, &mi->mbmi, mb_row, mb_col);
mi++; // next macroblock
}
mi++; // skip left predictor each row
}
}
+
projects / profile / ivi / libvpx.git / commitdiff