vp9_encodemv.c revision 2ec72e65689c948e92b826ae1e867bf369e72f13
1/* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11#include <math.h> 12 13#include "vp9/common/vp9_common.h" 14#include "vp9/common/vp9_entropymode.h" 15#include "vp9/common/vp9_systemdependent.h" 16 17#include "vp9/encoder/vp9_cost.h" 18#include "vp9/encoder/vp9_encodemv.h" 19 20static struct vp9_token mv_joint_encodings[MV_JOINTS]; 21static struct vp9_token mv_class_encodings[MV_CLASSES]; 22static struct vp9_token mv_fp_encodings[MV_FP_SIZE]; 23static struct vp9_token mv_class0_encodings[CLASS0_SIZE]; 24 25void vp9_entropy_mv_init() { 26 vp9_tokens_from_tree(mv_joint_encodings, vp9_mv_joint_tree); 27 vp9_tokens_from_tree(mv_class_encodings, vp9_mv_class_tree); 28 vp9_tokens_from_tree(mv_class0_encodings, vp9_mv_class0_tree); 29 vp9_tokens_from_tree(mv_fp_encodings, vp9_mv_fp_tree); 30} 31 32static void encode_mv_component(vp9_writer* w, int comp, 33 const nmv_component* mvcomp, int usehp) { 34 int offset; 35 const int sign = comp < 0; 36 const int mag = sign ? -comp : comp; 37 const int mv_class = vp9_get_mv_class(mag - 1, &offset); 38 const int d = offset >> 3; // int mv data 39 const int fr = (offset >> 1) & 3; // fractional mv data 40 const int hp = offset & 1; // high precision mv data 41 42 assert(comp != 0); 43 44 // Sign 45 vp9_write(w, sign, mvcomp->sign); 46 47 // Class 48 vp9_write_token(w, vp9_mv_class_tree, mvcomp->classes, 49 &mv_class_encodings[mv_class]); 50 51 // Integer bits 52 if (mv_class == MV_CLASS_0) { 53 vp9_write_token(w, vp9_mv_class0_tree, mvcomp->class0, 54 &mv_class0_encodings[d]); 55 } else { 56 int i; 57 const int n = mv_class + CLASS0_BITS - 1; // number of bits 58 for (i = 0; i < n; ++i) 59 vp9_write(w, (d >> i) & 1, mvcomp->bits[i]); 60 } 61 62 // Fractional bits 63 vp9_write_token(w, vp9_mv_fp_tree, 64 mv_class == MV_CLASS_0 ? mvcomp->class0_fp[d] : mvcomp->fp, 65 &mv_fp_encodings[fr]); 66 67 // High precision bit 68 if (usehp) 69 vp9_write(w, hp, 70 mv_class == MV_CLASS_0 ? mvcomp->class0_hp : mvcomp->hp); 71} 72 73 74static void build_nmv_component_cost_table(int *mvcost, 75 const nmv_component* const mvcomp, 76 int usehp) { 77 int i, v; 78 int sign_cost[2], class_cost[MV_CLASSES], class0_cost[CLASS0_SIZE]; 79 int bits_cost[MV_OFFSET_BITS][2]; 80 int class0_fp_cost[CLASS0_SIZE][MV_FP_SIZE], fp_cost[MV_FP_SIZE]; 81 int class0_hp_cost[2], hp_cost[2]; 82 83 sign_cost[0] = vp9_cost_zero(mvcomp->sign); 84 sign_cost[1] = vp9_cost_one(mvcomp->sign); 85 vp9_cost_tokens(class_cost, mvcomp->classes, vp9_mv_class_tree); 86 vp9_cost_tokens(class0_cost, mvcomp->class0, vp9_mv_class0_tree); 87 for (i = 0; i < MV_OFFSET_BITS; ++i) { 88 bits_cost[i][0] = vp9_cost_zero(mvcomp->bits[i]); 89 bits_cost[i][1] = vp9_cost_one(mvcomp->bits[i]); 90 } 91 92 for (i = 0; i < CLASS0_SIZE; ++i) 93 vp9_cost_tokens(class0_fp_cost[i], mvcomp->class0_fp[i], vp9_mv_fp_tree); 94 vp9_cost_tokens(fp_cost, mvcomp->fp, vp9_mv_fp_tree); 95 96 if (usehp) { 97 class0_hp_cost[0] = vp9_cost_zero(mvcomp->class0_hp); 98 class0_hp_cost[1] = vp9_cost_one(mvcomp->class0_hp); 99 hp_cost[0] = vp9_cost_zero(mvcomp->hp); 100 hp_cost[1] = vp9_cost_one(mvcomp->hp); 101 } 102 mvcost[0] = 0; 103 for (v = 1; v <= MV_MAX; ++v) { 104 int z, c, o, d, e, f, cost = 0; 105 z = v - 1; 106 c = vp9_get_mv_class(z, &o); 107 cost += class_cost[c]; 108 d = (o >> 3); /* int mv data */ 109 f = (o >> 1) & 3; /* fractional pel mv data */ 110 e = (o & 1); /* high precision mv data */ 111 if (c == MV_CLASS_0) { 112 cost += class0_cost[d]; 113 } else { 114 int i, b; 115 b = c + CLASS0_BITS - 1; /* number of bits */ 116 for (i = 0; i < b; ++i) 117 cost += bits_cost[i][((d >> i) & 1)]; 118 } 119 if (c == MV_CLASS_0) { 120 cost += class0_fp_cost[d][f]; 121 } else { 122 cost += fp_cost[f]; 123 } 124 if (usehp) { 125 if (c == MV_CLASS_0) { 126 cost += class0_hp_cost[e]; 127 } else { 128 cost += hp_cost[e]; 129 } 130 } 131 mvcost[v] = cost + sign_cost[0]; 132 mvcost[-v] = cost + sign_cost[1]; 133 } 134} 135 136static int update_mv(vp9_writer *w, const unsigned int ct[2], vp9_prob *cur_p, 137 vp9_prob upd_p) { 138 const vp9_prob new_p = get_binary_prob(ct[0], ct[1]) | 1; 139 const int update = cost_branch256(ct, *cur_p) + vp9_cost_zero(upd_p) > 140 cost_branch256(ct, new_p) + vp9_cost_one(upd_p) + 7 * 256; 141 vp9_write(w, update, upd_p); 142 if (update) { 143 *cur_p = new_p; 144 vp9_write_literal(w, new_p >> 1, 7); 145 } 146 return update; 147} 148 149static void write_mv_update(const vp9_tree_index *tree, 150 vp9_prob probs[/*n - 1*/], 151 const unsigned int counts[/*n - 1*/], 152 int n, vp9_writer *w) { 153 int i; 154 unsigned int branch_ct[32][2]; 155 156 // Assuming max number of probabilities <= 32 157 assert(n <= 32); 158 159 vp9_tree_probs_from_distribution(tree, branch_ct, counts); 160 for (i = 0; i < n - 1; ++i) 161 update_mv(w, branch_ct[i], &probs[i], MV_UPDATE_PROB); 162} 163 164void vp9_write_nmv_probs(VP9_COMMON *cm, int usehp, vp9_writer *w) { 165 int i, j; 166 nmv_context *const mvc = &cm->fc.nmvc; 167 nmv_context_counts *const counts = &cm->counts.mv; 168 169 write_mv_update(vp9_mv_joint_tree, mvc->joints, counts->joints, MV_JOINTS, w); 170 171 for (i = 0; i < 2; ++i) { 172 nmv_component *comp = &mvc->comps[i]; 173 nmv_component_counts *comp_counts = &counts->comps[i]; 174 175 update_mv(w, comp_counts->sign, &comp->sign, MV_UPDATE_PROB); 176 write_mv_update(vp9_mv_class_tree, comp->classes, comp_counts->classes, 177 MV_CLASSES, w); 178 write_mv_update(vp9_mv_class0_tree, comp->class0, comp_counts->class0, 179 CLASS0_SIZE, w); 180 for (j = 0; j < MV_OFFSET_BITS; ++j) 181 update_mv(w, comp_counts->bits[j], &comp->bits[j], MV_UPDATE_PROB); 182 } 183 184 for (i = 0; i < 2; ++i) { 185 for (j = 0; j < CLASS0_SIZE; ++j) 186 write_mv_update(vp9_mv_fp_tree, mvc->comps[i].class0_fp[j], 187 counts->comps[i].class0_fp[j], MV_FP_SIZE, w); 188 189 write_mv_update(vp9_mv_fp_tree, mvc->comps[i].fp, counts->comps[i].fp, 190 MV_FP_SIZE, w); 191 } 192 193 if (usehp) { 194 for (i = 0; i < 2; ++i) { 195 update_mv(w, counts->comps[i].class0_hp, &mvc->comps[i].class0_hp, 196 MV_UPDATE_PROB); 197 update_mv(w, counts->comps[i].hp, &mvc->comps[i].hp, MV_UPDATE_PROB); 198 } 199 } 200} 201 202void vp9_encode_mv(VP9_COMP* cpi, vp9_writer* w, 203 const MV* mv, const MV* ref, 204 const nmv_context* mvctx, int usehp) { 205 const MV diff = {mv->row - ref->row, 206 mv->col - ref->col}; 207 const MV_JOINT_TYPE j = vp9_get_mv_joint(&diff); 208 usehp = usehp && vp9_use_mv_hp(ref); 209 210 vp9_write_token(w, vp9_mv_joint_tree, mvctx->joints, &mv_joint_encodings[j]); 211 if (mv_joint_vertical(j)) 212 encode_mv_component(w, diff.row, &mvctx->comps[0], usehp); 213 214 if (mv_joint_horizontal(j)) 215 encode_mv_component(w, diff.col, &mvctx->comps[1], usehp); 216 217 // If auto_mv_step_size is enabled then keep track of the largest 218 // motion vector component used. 219 if (!cpi->dummy_packing && cpi->sf.auto_mv_step_size) { 220 unsigned int maxv = MAX(abs(mv->row), abs(mv->col)) >> 3; 221 cpi->max_mv_magnitude = MAX(maxv, cpi->max_mv_magnitude); 222 } 223} 224 225void vp9_build_nmv_cost_table(int *mvjoint, int *mvcost[2], 226 const nmv_context* ctx, int usehp) { 227 vp9_cost_tokens(mvjoint, ctx->joints, vp9_mv_joint_tree); 228 build_nmv_component_cost_table(mvcost[0], &ctx->comps[0], usehp); 229 build_nmv_component_cost_table(mvcost[1], &ctx->comps[1], usehp); 230} 231 232static void inc_mvs(const MB_MODE_INFO *mbmi, const int_mv mvs[2], 233 nmv_context_counts *counts) { 234 int i; 235 236 for (i = 0; i < 1 + has_second_ref(mbmi); ++i) { 237 const MV *ref = &mbmi->ref_mvs[mbmi->ref_frame[i]][0].as_mv; 238 const MV diff = {mvs[i].as_mv.row - ref->row, 239 mvs[i].as_mv.col - ref->col}; 240 vp9_inc_mv(&diff, counts); 241 } 242} 243 244void vp9_update_mv_count(VP9_COMMON *cm, const MACROBLOCKD *xd) { 245 const MODE_INFO *mi = xd->mi_8x8[0]; 246 const MB_MODE_INFO *const mbmi = &mi->mbmi; 247 248 if (mbmi->sb_type < BLOCK_8X8) { 249 const int num_4x4_w = num_4x4_blocks_wide_lookup[mbmi->sb_type]; 250 const int num_4x4_h = num_4x4_blocks_high_lookup[mbmi->sb_type]; 251 int idx, idy; 252 253 for (idy = 0; idy < 2; idy += num_4x4_h) { 254 for (idx = 0; idx < 2; idx += num_4x4_w) { 255 const int i = idy * 2 + idx; 256 if (mi->bmi[i].as_mode == NEWMV) 257 inc_mvs(mbmi, mi->bmi[i].as_mv, &cm->counts.mv); 258 } 259 } 260 } else { 261 if (mbmi->mode == NEWMV) 262 inc_mvs(mbmi, mbmi->mv, &cm->counts.mv); 263 } 264} 265 266