static int read_mv_component(vpx_reader *r, const nmv_component *mvcomp, int usehp) { int mag, d, fr, hp; const int sign = vpx_read(r, mvcomp->sign); const int mv_class = vpx_read_tree(r, vp9_mv_class_tree, mvcomp->classes); const int class0 = mv_class == MV_CLASS_0; // Integer part if (class0) { d = vpx_read_tree(r, vp9_mv_class0_tree, mvcomp->class0); mag = 0; } else { int i; const int n = mv_class + CLASS0_BITS - 1; // number of bits d = 0; for (i = 0; i < n; ++i) d |= vpx_read(r, mvcomp->bits[i]) << i; mag = CLASS0_SIZE << (mv_class + 2); } // Fractional part fr = vpx_read_tree(r, vp9_mv_fp_tree, class0 ? mvcomp->class0_fp[d] : mvcomp->fp); // High precision part (if hp is not used, the default value of the hp is 1) hp = usehp ? vpx_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp) : 1; // Result mag += ((d << 3) | (fr << 1) | hp) + 1; return sign ? -mag : mag; }
static PREDICTION_MODE read_inter_mode(VP9_COMMON *cm, MACROBLOCKD *xd, vpx_reader *r, int ctx) { const int mode = vpx_read_tree(r, vp9_inter_mode_tree, cm->fc->inter_mode_probs[ctx]); FRAME_COUNTS *counts = xd->counts; if (counts) ++counts->inter_mode[ctx][mode]; return NEARESTMV + mode; }
static INLINE INTERP_FILTER read_switchable_interp_filter( VP9_COMMON *const cm, MACROBLOCKD *const xd, vpx_reader *r) { const int ctx = vp9_get_pred_context_switchable_interp(xd); const INTERP_FILTER type = (INTERP_FILTER)vpx_read_tree(r, vp9_switchable_interp_tree, cm->fc->switchable_interp_prob[ctx]); FRAME_COUNTS *counts = xd->counts; if (counts) ++counts->switchable_interp[ctx][type]; return type; }
static INLINE void read_mv(vpx_reader *r, MV *mv, const MV *ref, const nmv_context *ctx, nmv_context_counts *counts, int allow_hp) { const MV_JOINT_TYPE joint_type = (MV_JOINT_TYPE)vpx_read_tree(r, vp9_mv_joint_tree, ctx->joints); const int use_hp = allow_hp && vp9_use_mv_hp(ref); MV diff = {0, 0}; if (mv_joint_vertical(joint_type)) diff.row = read_mv_component(r, &ctx->comps[0], use_hp); if (mv_joint_horizontal(joint_type)) diff.col = read_mv_component(r, &ctx->comps[1], use_hp); vp9_inc_mv(&diff, counts); mv->row = ref->row + diff.row; mv->col = ref->col + diff.col; }
static int decode_coefs(const MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff, TX_SIZE tx_size, const int16_t *dq, int ctx, const int16_t *scan, const int16_t *nb, vpx_reader *r) #endif { FRAME_COUNTS *counts = xd->counts; const int max_eob = 16 << (tx_size << 1); const FRAME_CONTEXT *const fc = xd->fc; const int ref = is_inter_block(&xd->mi[0]->mbmi); #if CONFIG_AOM_QM const qm_val_t *iqmatrix = iqm[!ref][tx_size]; #endif int band, c = 0; const vpx_prob(*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] = fc->coef_probs[tx_size][type][ref]; const vpx_prob *prob; unsigned int(*coef_counts)[COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1]; unsigned int(*eob_branch_count)[COEFF_CONTEXTS]; uint8_t token_cache[32 * 32]; const uint8_t *band_translate = get_band_translate(tx_size); const int dq_shift = (tx_size == TX_32X32); int v, token; int16_t dqv = dq[0]; const uint8_t *cat1_prob; const uint8_t *cat2_prob; const uint8_t *cat3_prob; const uint8_t *cat4_prob; const uint8_t *cat5_prob; const uint8_t *cat6_prob; if (counts) { coef_counts = counts->coef[tx_size][type][ref]; eob_branch_count = counts->eob_branch[tx_size][type][ref]; } #if CONFIG_VPX_HIGHBITDEPTH if (xd->bd > VPX_BITS_8) { if (xd->bd == VPX_BITS_10) { cat1_prob = vp10_cat1_prob_high10; cat2_prob = vp10_cat2_prob_high10; cat3_prob = vp10_cat3_prob_high10; cat4_prob = vp10_cat4_prob_high10; cat5_prob = vp10_cat5_prob_high10; cat6_prob = vp10_cat6_prob_high10; } else { cat1_prob = vp10_cat1_prob_high12; cat2_prob = vp10_cat2_prob_high12; cat3_prob = vp10_cat3_prob_high12; cat4_prob = vp10_cat4_prob_high12; cat5_prob = vp10_cat5_prob_high12; cat6_prob = vp10_cat6_prob_high12; } } else { cat1_prob = vp10_cat1_prob; cat2_prob = vp10_cat2_prob; cat3_prob = vp10_cat3_prob; cat4_prob = vp10_cat4_prob; cat5_prob = vp10_cat5_prob; cat6_prob = vp10_cat6_prob; } #else cat1_prob = vp10_cat1_prob; cat2_prob = vp10_cat2_prob; cat3_prob = vp10_cat3_prob; cat4_prob = vp10_cat4_prob; cat5_prob = vp10_cat5_prob; cat6_prob = vp10_cat6_prob; #endif while (c < max_eob) { int val = -1; band = *band_translate++; prob = coef_probs[band][ctx]; if (counts) ++eob_branch_count[band][ctx]; if (!vpx_read(r, prob[EOB_CONTEXT_NODE])) { INCREMENT_COUNT(EOB_MODEL_TOKEN); break; } while (!vpx_read(r, prob[ZERO_CONTEXT_NODE])) { INCREMENT_COUNT(ZERO_TOKEN); dqv = dq[1]; token_cache[scan[c]] = 0; ++c; if (c >= max_eob) return c; // zero tokens at the end (no eob token) ctx = get_coef_context(nb, token_cache, c); band = *band_translate++; prob = coef_probs[band][ctx]; } if (!vpx_read(r, prob[ONE_CONTEXT_NODE])) { INCREMENT_COUNT(ONE_TOKEN); token = ONE_TOKEN; val = 1; } else { INCREMENT_COUNT(TWO_TOKEN); token = vpx_read_tree(r, vp10_coef_con_tree, vp10_pareto8_full[prob[PIVOT_NODE] - 1]); switch (token) { case TWO_TOKEN: case THREE_TOKEN: case FOUR_TOKEN: val = token; break; case CATEGORY1_TOKEN: val = CAT1_MIN_VAL + read_coeff(cat1_prob, 1, r); break; case CATEGORY2_TOKEN: val = CAT2_MIN_VAL + read_coeff(cat2_prob, 2, r); break; case CATEGORY3_TOKEN: val = CAT3_MIN_VAL + read_coeff(cat3_prob, 3, r); break; case CATEGORY4_TOKEN: val = CAT4_MIN_VAL + read_coeff(cat4_prob, 4, r); break; case CATEGORY5_TOKEN: val = CAT5_MIN_VAL + read_coeff(cat5_prob, 5, r); break; case CATEGORY6_TOKEN: { #if CONFIG_MISC_FIXES const int skip_bits = TX_SIZES - 1 - tx_size; #else const int skip_bits = 0; #endif const uint8_t *cat6p = cat6_prob + skip_bits; #if CONFIG_VPX_HIGHBITDEPTH switch (xd->bd) { case VPX_BITS_8: val = CAT6_MIN_VAL + read_coeff(cat6p, 14 - skip_bits, r); break; case VPX_BITS_10: val = CAT6_MIN_VAL + read_coeff(cat6p, 16 - skip_bits, r); break; case VPX_BITS_12: val = CAT6_MIN_VAL + read_coeff(cat6p, 18 - skip_bits, r); break; default: assert(0); return -1; } #else val = CAT6_MIN_VAL + read_coeff(cat6p, 14 - skip_bits, r); #endif break; } } } #if CONFIG_AOM_QM dqv = ((iqmatrix[scan[c]] * (int)dqv) + (1 << (AOM_QM_BITS - 1))) >> AOM_QM_BITS; #endif v = (val * dqv) >> dq_shift; #if CONFIG_COEFFICIENT_RANGE_CHECKING #if CONFIG_VPX_HIGHBITDEPTH dqcoeff[scan[c]] = highbd_check_range((vpx_read_bit(r) ? -v : v), xd->bd); #else dqcoeff[scan[c]] = check_range(vpx_read_bit(r) ? -v : v); #endif // CONFIG_VPX_HIGHBITDEPTH #else dqcoeff[scan[c]] = vpx_read_bit(r) ? -v : v; #endif // CONFIG_COEFFICIENT_RANGE_CHECKING token_cache[scan[c]] = vp10_pt_energy_class[token]; ++c; ctx = get_coef_context(nb, token_cache, c); dqv = dq[1]; } return c; }
static int read_segment_id(vpx_reader *r, const struct segmentation *seg) { return vpx_read_tree(r, vp9_segment_tree, seg->tree_probs); }
static PREDICTION_MODE read_intra_mode(vpx_reader *r, const vpx_prob *p) { return (PREDICTION_MODE)vpx_read_tree(r, vp9_intra_mode_tree, p); }
static int decode_coefs(const MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff, TX_SIZE tx_size, const int16_t *dq, int ctx, const int16_t *scan, const int16_t *nb, vpx_reader *r) { FRAME_COUNTS *counts = xd->counts; const int max_eob = 16 << (tx_size << 1); const FRAME_CONTEXT *const fc = xd->fc; const int ref = is_inter_block(xd->mi[0]); int band, c = 0; const vpx_prob(*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] = fc->coef_probs[tx_size][type][ref]; const vpx_prob *prob; unsigned int(*coef_counts)[COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1]; unsigned int(*eob_branch_count)[COEFF_CONTEXTS]; uint8_t token_cache[32 * 32]; const uint8_t *band_translate = get_band_translate(tx_size); const int dq_shift = (tx_size == TX_32X32); int v, token; int16_t dqv = dq[0]; const uint8_t *const cat6_prob = #if CONFIG_VP9_HIGHBITDEPTH (xd->bd == VPX_BITS_12) ? vp9_cat6_prob_high12 : (xd->bd == VPX_BITS_10) ? vp9_cat6_prob_high12 + 2 : #endif // CONFIG_VP9_HIGHBITDEPTH vp9_cat6_prob; const int cat6_bits = #if CONFIG_VP9_HIGHBITDEPTH (xd->bd == VPX_BITS_12) ? 18 : (xd->bd == VPX_BITS_10) ? 16 : #endif // CONFIG_VP9_HIGHBITDEPTH 14; if (counts) { coef_counts = counts->coef[tx_size][type][ref]; eob_branch_count = counts->eob_branch[tx_size][type][ref]; } while (c < max_eob) { int val = -1; band = *band_translate++; prob = coef_probs[band][ctx]; if (counts) ++eob_branch_count[band][ctx]; if (!vpx_read(r, prob[EOB_CONTEXT_NODE])) { INCREMENT_COUNT(EOB_MODEL_TOKEN); break; } while (!vpx_read(r, prob[ZERO_CONTEXT_NODE])) { INCREMENT_COUNT(ZERO_TOKEN); dqv = dq[1]; token_cache[scan[c]] = 0; ++c; if (c >= max_eob) return c; // zero tokens at the end (no eob token) ctx = get_coef_context(nb, token_cache, c); band = *band_translate++; prob = coef_probs[band][ctx]; } if (!vpx_read(r, prob[ONE_CONTEXT_NODE])) { INCREMENT_COUNT(ONE_TOKEN); token = ONE_TOKEN; val = 1; } else { INCREMENT_COUNT(TWO_TOKEN); token = vpx_read_tree(r, vp9_coef_con_tree, vp9_pareto8_full[prob[PIVOT_NODE] - 1]); switch (token) { case TWO_TOKEN: case THREE_TOKEN: case FOUR_TOKEN: val = token; break; case CATEGORY1_TOKEN: val = CAT1_MIN_VAL + read_coeff(vp9_cat1_prob, 1, r); break; case CATEGORY2_TOKEN: val = CAT2_MIN_VAL + read_coeff(vp9_cat2_prob, 2, r); break; case CATEGORY3_TOKEN: val = CAT3_MIN_VAL + read_coeff(vp9_cat3_prob, 3, r); break; case CATEGORY4_TOKEN: val = CAT4_MIN_VAL + read_coeff(vp9_cat4_prob, 4, r); break; case CATEGORY5_TOKEN: val = CAT5_MIN_VAL + read_coeff(vp9_cat5_prob, 5, r); break; case CATEGORY6_TOKEN: val = CAT6_MIN_VAL + read_coeff(cat6_prob, cat6_bits, r); break; } } v = (val * dqv) >> dq_shift; #if CONFIG_COEFFICIENT_RANGE_CHECKING #if CONFIG_VP9_HIGHBITDEPTH dqcoeff[scan[c]] = highbd_check_range((vpx_read_bit(r) ? -v : v), xd->bd); #else dqcoeff[scan[c]] = check_range(vpx_read_bit(r) ? -v : v); #endif // CONFIG_VP9_HIGHBITDEPTH #else dqcoeff[scan[c]] = vpx_read_bit(r) ? -v : v; #endif // CONFIG_COEFFICIENT_RANGE_CHECKING token_cache[scan[c]] = vp9_pt_energy_class[token]; ++c; ctx = get_coef_context(nb, token_cache, c); dqv = dq[1]; } return c; }