vp9_bitstream.c 68.8 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9 10 11
 */


12
#include "vp9/common/vp9_header.h"
13
#include "vp9/encoder/vp9_encodemv.h"
14
#include "vp9/common/vp9_entropymode.h"
15
#include "vp9/common/vp9_entropymv.h"
16
#include "vp9/common/vp9_findnearmv.h"
17
#include "vp9/encoder/vp9_mcomp.h"
18
#include "vp9/common/vp9_systemdependent.h"
John Koleszar's avatar
John Koleszar committed
19 20
#include <assert.h>
#include <stdio.h>
21
#include <limits.h>
22
#include "vp9/common/vp9_pragmas.h"
23
#include "vpx/vpx_encoder.h"
John Koleszar's avatar
John Koleszar committed
24
#include "vpx_mem/vpx_mem.h"
25 26
#include "vp9/encoder/vp9_bitstream.h"
#include "vp9/encoder/vp9_segmentation.h"
27

28 29 30 31 32 33
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_entropy.h"
#include "vp9/encoder/vp9_encodemv.h"
#include "vp9/common/vp9_entropymv.h"
#include "vp9/common/vp9_mvref_common.h"
34
#include "vp9/common/vp9_treecoder.h"
Paul Wilkins's avatar
Paul Wilkins committed
35

John Koleszar's avatar
John Koleszar committed
36 37 38 39 40
#if defined(SECTIONBITS_OUTPUT)
unsigned __int64 Sectionbits[500];
#endif

#ifdef ENTROPY_STATS
41 42 43
int intra_mode_stats[VP9_KF_BINTRAMODES]
                    [VP9_KF_BINTRAMODES]
                    [VP9_KF_BINTRAMODES];
44 45 46 47 48 49 50
vp9_coeff_stats tree_update_hist_4x4[BLOCK_TYPES_4X4];
vp9_coeff_stats hybrid_tree_update_hist_4x4[BLOCK_TYPES_4X4];
vp9_coeff_stats tree_update_hist_8x8[BLOCK_TYPES_8X8];
vp9_coeff_stats hybrid_tree_update_hist_8x8[BLOCK_TYPES_8X8];
vp9_coeff_stats tree_update_hist_16x16[BLOCK_TYPES_16X16];
vp9_coeff_stats hybrid_tree_update_hist_16x16[BLOCK_TYPES_16X16];
vp9_coeff_stats tree_update_hist_32x32[BLOCK_TYPES_32X32];
51

John Koleszar's avatar
John Koleszar committed
52 53 54 55 56 57 58
extern unsigned int active_section;
#endif

#ifdef MODE_STATS
int count_mb_seg[4] = { 0, 0, 0, 0 };
#endif

59 60
#define vp9_cost_upd  ((int)(vp9_cost_one(upd) - vp9_cost_zero(upd)) >> 8)
#define vp9_cost_upd256  ((int)(vp9_cost_one(upd) - vp9_cost_zero(upd)))
61 62 63 64

#define SEARCH_NEWP
static int update_bits[255];

John Koleszar's avatar
John Koleszar committed
65 66 67
static void compute_update_table() {
  int i;
  for (i = 0; i < 255; i++)
68
    update_bits[i] = vp9_count_term_subexp(i, SUBEXP_PARAM, 255);
69 70
}

John Koleszar's avatar
John Koleszar committed
71 72 73 74 75
static int split_index(int i, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
  if (i % modulus == modulus / 2) i = i / modulus;
  else i = max1 + i - (i + modulus - modulus / 2) / modulus;
  return i;
76 77
}

John Koleszar's avatar
John Koleszar committed
78 79 80 81 82
static int remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
  int i;
  if ((m << 1) <= n)
83
    i = vp9_recenter_nonneg(v, m) - 1;
John Koleszar's avatar
John Koleszar committed
84
  else
85
    i = vp9_recenter_nonneg(n - 1 - v, n - 1 - m) - 1;
John Koleszar's avatar
John Koleszar committed
86 87 88

  i = split_index(i, n - 1, modulus);
  return i;
89
}
90

91 92
static void write_prob_diff_update(vp9_writer *const bc,
                                   vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
93
  int delp = remap_prob(newp, oldp);
94
  vp9_encode_term_subexp(bc, delp, SUBEXP_PARAM, 255);
95 96
}

97
static int prob_diff_update_cost(vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
98 99
  int delp = remap_prob(newp, oldp);
  return update_bits[delp] * 256;
100
}
101

John Koleszar's avatar
John Koleszar committed
102
static void update_mode(
103
  vp9_writer *const bc,
John Koleszar's avatar
John Koleszar committed
104
  int n,
105 106 107 108
  vp9_token tok               [/* n */],
  vp9_tree tree,
  vp9_prob Pnew               [/* n-1 */],
  vp9_prob Pcur               [/* n-1 */],
John Koleszar's avatar
John Koleszar committed
109 110 111 112 113 114
  unsigned int bct            [/* n-1 */] [2],
  const unsigned int num_events[/* n */]
) {
  unsigned int new_b = 0, old_b = 0;
  int i = 0;

115 116
  vp9_tree_probs_from_distribution(n--, tok, tree,
                                   Pnew, bct, num_events);
John Koleszar's avatar
John Koleszar committed
117 118

  do {
119 120
    new_b += cost_branch(bct[i], Pnew[i]);
    old_b += cost_branch(bct[i], Pcur[i]);
John Koleszar's avatar
John Koleszar committed
121 122 123
  } while (++i < n);

  if (new_b + (n << 8) < old_b) {
John Koleszar's avatar
John Koleszar committed
124 125
    int i = 0;

126
    vp9_write_bit(bc, 1);
John Koleszar's avatar
John Koleszar committed
127

John Koleszar's avatar
John Koleszar committed
128
    do {
129
      const vp9_prob p = Pnew[i];
John Koleszar's avatar
John Koleszar committed
130

131
      vp9_write_literal(bc, Pcur[i] = p ? p : 1, 8);
John Koleszar's avatar
John Koleszar committed
132 133
    } while (++i < n);
  } else
134
    vp9_write_bit(bc, 0);
John Koleszar's avatar
John Koleszar committed
135 136
}

137
static void update_mbintra_mode_probs(VP9_COMP* const cpi,
138
                                      vp9_writer* const bc) {
139
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
140

John Koleszar's avatar
John Koleszar committed
141
  {
142 143
    vp9_prob Pnew   [VP9_YMODES - 1];
    unsigned int bct [VP9_YMODES - 1] [2];
John Koleszar's avatar
John Koleszar committed
144

John Koleszar's avatar
John Koleszar committed
145
    update_mode(
146
      bc, VP9_YMODES, vp9_ymode_encodings, vp9_ymode_tree,
Paul Wilkins's avatar
Paul Wilkins committed
147
      Pnew, cm->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
John Koleszar's avatar
John Koleszar committed
148
    );
149 150 151
    update_mode(bc, VP9_I32X32_MODES, vp9_sb_ymode_encodings,
                vp9_sb_ymode_tree, Pnew, cm->fc.sb_ymode_prob, bct,
                (unsigned int *)cpi->sb_ymode_count);
John Koleszar's avatar
John Koleszar committed
152
  }
John Koleszar's avatar
John Koleszar committed
153 154
}

155 156
void vp9_update_skip_probs(VP9_COMP *cpi) {
  VP9_COMMON *const pc = &cpi->common;
John Koleszar's avatar
John Koleszar committed
157
  int k;
Paul Wilkins's avatar
Paul Wilkins committed
158

John Koleszar's avatar
John Koleszar committed
159
  for (k = 0; k < MBSKIP_CONTEXTS; ++k) {
John Koleszar's avatar
John Koleszar committed
160 161
    pc->mbskip_pred_probs[k] = get_binary_prob(cpi->skip_false_count[k],
                                               cpi->skip_true_count[k]);
John Koleszar's avatar
John Koleszar committed
162
  }
Paul Wilkins's avatar
Paul Wilkins committed
163 164
}

165
static void update_switchable_interp_probs(VP9_COMP *cpi,
166
                                           vp9_writer* const bc) {
167
  VP9_COMMON *const pc = &cpi->common;
168 169
  unsigned int branch_ct[32][2];
  int i, j;
170
  for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j) {
171
    vp9_tree_probs_from_distribution(
172
        VP9_SWITCHABLE_FILTERS,
173
        vp9_switchable_interp_encodings, vp9_switchable_interp_tree,
174
        pc->fc.switchable_interp_prob[j], branch_ct,
175
        cpi->switchable_interp_count[j]);
176
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i) {
177 178
      if (pc->fc.switchable_interp_prob[j][i] < 1)
        pc->fc.switchable_interp_prob[j][i] = 1;
179
      vp9_write_literal(bc, pc->fc.switchable_interp_prob[j][i], 8);
180 181 182 183
    }
  }
}

184
// This function updates the reference frame prediction stats
185 186
static void update_refpred_stats(VP9_COMP *cpi) {
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
187
  int i;
188
  vp9_prob new_pred_probs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
189 190 191 192 193 194 195 196 197 198 199 200 201 202
  int old_cost, new_cost;

  // Set the prediction probability structures to defaults
  if (cm->frame_type == KEY_FRAME) {
    // Set the prediction probabilities to defaults
    cm->ref_pred_probs[0] = 120;
    cm->ref_pred_probs[1] = 80;
    cm->ref_pred_probs[2] = 40;

    vpx_memset(cpi->ref_pred_probs_update, 0,
               sizeof(cpi->ref_pred_probs_update));
  } else {
    // From the prediction counts set the probabilities for each context
    for (i = 0; i < PREDICTION_PROBS; i++) {
John Koleszar's avatar
John Koleszar committed
203 204
      new_pred_probs[i] = get_binary_prob(cpi->ref_pred_count[i][0],
                                          cpi->ref_pred_count[i][1]);
John Koleszar's avatar
John Koleszar committed
205 206 207 208

      // Decide whether or not to update the reference frame probs.
      // Returned costs are in 1/256 bit units.
      old_cost =
209 210
        (cpi->ref_pred_count[i][0] * vp9_cost_zero(cm->ref_pred_probs[i])) +
        (cpi->ref_pred_count[i][1] * vp9_cost_one(cm->ref_pred_probs[i]));
John Koleszar's avatar
John Koleszar committed
211 212

      new_cost =
213 214
        (cpi->ref_pred_count[i][0] * vp9_cost_zero(new_pred_probs[i])) +
        (cpi->ref_pred_count[i][1] * vp9_cost_one(new_pred_probs[i]));
John Koleszar's avatar
John Koleszar committed
215 216 217 218 219 220 221

      // Cost saving must be >= 8 bits (2048 in these units)
      if ((old_cost - new_cost) >= 2048) {
        cpi->ref_pred_probs_update[i] = 1;
        cm->ref_pred_probs[i] = new_pred_probs[i];
      } else
        cpi->ref_pred_probs_update[i] = 0;
222 223

    }
John Koleszar's avatar
John Koleszar committed
224
  }
225 226
}

227 228 229 230 231 232
// This function is called to update the mode probability context used to encode
// inter modes. It assumes the branch counts table has already been populated
// prior to the actual packing of the bitstream (in rd stage or dummy pack)
//
// The branch counts table is re-populated during the actual pack stage and in
// the decoder to facilitate backwards update of the context.
Jim Bankoski's avatar
Jim Bankoski committed
233 234
static void update_mode_probs(VP9_COMMON *cm,
                              int mode_context[INTER_MODE_CONTEXTS][4]) {
235
  int i, j;
Jim Bankoski's avatar
Jim Bankoski committed
236
  unsigned int (*mv_ref_ct)[4][2];
237 238 239 240 241 242 243 244

  vpx_memcpy(mode_context, cm->fc.vp9_mode_contexts,
             sizeof(cm->fc.vp9_mode_contexts));

  mv_ref_ct = cm->fc.mv_ref_ct;

  for (i = 0; i < INTER_MODE_CONTEXTS; i++) {
    for (j = 0; j < 4; j++) {
245
      int new_prob, old_cost, new_cost;
246 247 248

      // Work out cost of coding branches with the old and optimal probability
      old_cost = cost_branch256(mv_ref_ct[i][j], mode_context[i][j]);
249
      new_prob = get_binary_prob(mv_ref_ct[i][j][0], mv_ref_ct[i][j][1]);
250 251 252 253 254 255 256 257 258 259 260
      new_cost = cost_branch256(mv_ref_ct[i][j], new_prob);

      // If cost saving is >= 14 bits then update the mode probability.
      // This is the approximate net cost of updating one probability given
      // that the no update case ismuch more common than the update case.
      if (new_cost <= (old_cost - (14 << 8))) {
        mode_context[i][j] = new_prob;
      }
    }
  }
}
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310

#if CONFIG_NEW_MVREF
static void update_mv_ref_probs(VP9_COMP *cpi,
                                int mvref_probs[MAX_REF_FRAMES]
                                               [MAX_MV_REF_CANDIDATES-1]) {
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
  int rf;     // Reference frame
  int ref_c;  // Motion reference candidate
  int node;   // Probability node index

  for (rf = 0; rf < MAX_REF_FRAMES; ++rf) {
    int count = 0;

    // Skip the dummy entry for intra ref frame.
    if (rf == INTRA_FRAME) {
      continue;
    }

    // Sum the counts for all candidates
    for (ref_c = 0; ref_c < MAX_MV_REF_CANDIDATES; ++ref_c) {
      count += cpi->mb_mv_ref_count[rf][ref_c];
    }

    // Calculate the tree node probabilities
    for (node = 0; node < MAX_MV_REF_CANDIDATES-1; ++node) {
      int new_prob, old_cost, new_cost;
      unsigned int branch_cnts[2];

      // How many hits on each branch at this node
      branch_cnts[0] = cpi->mb_mv_ref_count[rf][node];
      branch_cnts[1] = count - cpi->mb_mv_ref_count[rf][node];

      // Work out cost of coding branches with the old and optimal probability
      old_cost = cost_branch256(branch_cnts, xd->mb_mv_ref_probs[rf][node]);
      new_prob = get_prob(branch_cnts[0], count);
      new_cost = cost_branch256(branch_cnts, new_prob);

      // Take current 0 branch cases out of residual count
      count -= cpi->mb_mv_ref_count[rf][node];

      if ((new_cost + VP9_MV_REF_UPDATE_COST) <= old_cost) {
        mvref_probs[rf][node] = new_prob;
      } else {
        mvref_probs[rf][node] = xd->mb_mv_ref_probs[rf][node];
      }
    }
  }
}
#endif

311 312
static void write_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_ymode_tree, p, vp9_ymode_encodings + m);
John Koleszar's avatar
John Koleszar committed
313 314
}

315 316
static void kfwrite_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_kf_ymode_tree, p, vp9_kf_ymode_encodings + m);
John Koleszar's avatar
John Koleszar committed
317 318
}

319 320 321 322
static void write_sb_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_sb_ymode_tree, p, vp9_sb_ymode_encodings + m);
}

323 324
static void sb_kfwrite_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_uv_mode_tree, p, vp9_sb_kf_ymode_encodings + m);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
325 326
}

327 328
static void write_i8x8_mode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_i8x8_mode_tree, p, vp9_i8x8_mode_encodings + m);
Yaowu Xu's avatar
Yaowu Xu committed
329
}
Yaowu Xu's avatar
Yaowu Xu committed
330

331 332
static void write_uv_mode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_uv_mode_tree, p, vp9_uv_mode_encodings + m);
John Koleszar's avatar
John Koleszar committed
333 334 335
}


336
static void write_bmode(vp9_writer *bc, int m, const vp9_prob *p) {
337 338 339 340
#if CONFIG_NEWBINTRAMODES
  assert(m < B_CONTEXT_PRED - CONTEXT_PRED_REPLACEMENTS || m == B_CONTEXT_PRED);
  if (m == B_CONTEXT_PRED) m -= CONTEXT_PRED_REPLACEMENTS;
#endif
341
  write_token(bc, vp9_bmode_tree, p, vp9_bmode_encodings + m);
John Koleszar's avatar
John Koleszar committed
342 343
}

344 345 346 347
static void write_kf_bmode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_kf_bmode_tree, p, vp9_kf_bmode_encodings + m);
}

348
static void write_split(vp9_writer *bc, int x, const vp9_prob *p) {
349 350
  write_token(
    bc, vp9_mbsplit_tree, p, vp9_mbsplit_encodings + x);
John Koleszar's avatar
John Koleszar committed
351 352
}

353
static int prob_update_savings(const unsigned int *ct,
354 355 356 357 358
                               const vp9_prob oldp, const vp9_prob newp,
                               const vp9_prob upd) {
  const int old_b = cost_branch256(ct, oldp);
  const int new_b = cost_branch256(ct, newp);
  const int update_b = 2048 + vp9_cost_upd256;
John Koleszar's avatar
John Koleszar committed
359
  return (old_b - new_b - update_b);
360 361
}

362
static int prob_diff_update_savings(const unsigned int *ct,
363 364 365 366
                                    const vp9_prob oldp, const vp9_prob newp,
                                    const vp9_prob upd) {
  const int old_b = cost_branch256(ct, oldp);
  const int new_b = cost_branch256(ct, newp);
John Koleszar's avatar
John Koleszar committed
367
  const int update_b = (newp == oldp ? 0 :
368
                        prob_diff_update_cost(newp, oldp) + vp9_cost_upd256);
John Koleszar's avatar
John Koleszar committed
369
  return (old_b - new_b - update_b);
370 371 372
}

static int prob_diff_update_savings_search(const unsigned int *ct,
373 374 375
                                           const vp9_prob oldp, vp9_prob *bestp,
                                           const vp9_prob upd) {
  const int old_b = cost_branch256(ct, oldp);
John Koleszar's avatar
John Koleszar committed
376
  int new_b, update_b, savings, bestsavings, step;
377
  vp9_prob newp, bestnewp;
John Koleszar's avatar
John Koleszar committed
378 379 380 381 382 383

  bestsavings = 0;
  bestnewp = oldp;

  step = (*bestp > oldp ? -1 : 1);
  for (newp = *bestp; newp != oldp; newp += step) {
384 385
    new_b = cost_branch256(ct, newp);
    update_b = prob_diff_update_cost(newp, oldp) + vp9_cost_upd256;
John Koleszar's avatar
John Koleszar committed
386 387 388 389
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
390
    }
John Koleszar's avatar
John Koleszar committed
391 392 393
  }
  *bestp = bestnewp;
  return bestsavings;
394 395
}

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
static void vp9_cond_prob_update(vp9_writer *bc, vp9_prob *oldp, vp9_prob upd,
                                 unsigned int *ct) {
  vp9_prob newp;
  int savings;
  newp = get_binary_prob(ct[0], ct[1]);
  savings = prob_update_savings(ct, *oldp, newp, upd);
  if (savings > 0) {
    vp9_write(bc, 1, upd);
    vp9_write_literal(bc, newp, 8);
    *oldp = newp;
  } else {
    vp9_write(bc, 0, upd);
  }
}

411
static void pack_mb_tokens(vp9_writer* const bc,
412 413 414
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
415

John Koleszar's avatar
John Koleszar committed
416 417
  while (p < stop) {
    const int t = p->Token;
418 419
    vp9_token *const a = vp9_coef_encodings + t;
    const vp9_extra_bit_struct *const b = vp9_extra_bits + t;
John Koleszar's avatar
John Koleszar committed
420 421 422 423 424
    int i = 0;
    const unsigned char *pp = p->context_tree;
    int v = a->value;
    int n = a->Len;

425 426 427 428 429 430
    if (t == EOSB_TOKEN)
    {
      ++p;
      break;
    }

John Koleszar's avatar
John Koleszar committed
431 432 433 434 435
    /* skip one or two nodes */
    if (p->skip_eob_node) {
      n -= p->skip_eob_node;
      i = 2 * p->skip_eob_node;
    }
John Koleszar's avatar
John Koleszar committed
436

John Koleszar's avatar
John Koleszar committed
437 438
    do {
      const int bb = (v >> --n) & 1;
439
      encode_bool(bc, bb, pp[i >> 1]);
440
      i = vp9_coef_tree[i + bb];
John Koleszar's avatar
John Koleszar committed
441
    } while (n);
John Koleszar's avatar
John Koleszar committed
442 443


John Koleszar's avatar
John Koleszar committed
444 445
    if (b->base_val) {
      const int e = p->Extra, L = b->Len;
John Koleszar's avatar
John Koleszar committed
446

John Koleszar's avatar
John Koleszar committed
447 448 449 450 451
      if (L) {
        const unsigned char *pp = b->prob;
        int v = e >> 1;
        int n = L;              /* number of bits in v, assumed nonzero */
        int i = 0;
John Koleszar's avatar
John Koleszar committed
452

John Koleszar's avatar
John Koleszar committed
453 454
        do {
          const int bb = (v >> --n) & 1;
455
          encode_bool(bc, bb, pp[i >> 1]);
John Koleszar's avatar
John Koleszar committed
456 457 458
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
459

460
      encode_bool(bc, e & 1, 128);
John Koleszar's avatar
John Koleszar committed
461
    }
John Koleszar's avatar
John Koleszar committed
462 463 464
    ++p;
  }

465
  *tp = p;
John Koleszar's avatar
John Koleszar committed
466 467
}

John Koleszar's avatar
John Koleszar committed
468 469
static void write_partition_size(unsigned char *cx_data, int size) {
  signed char csize;
John Koleszar's avatar
John Koleszar committed
470

John Koleszar's avatar
John Koleszar committed
471 472 473 474 475 476
  csize = size & 0xff;
  *cx_data = csize;
  csize = (size >> 8) & 0xff;
  *(cx_data + 1) = csize;
  csize = (size >> 16) & 0xff;
  *(cx_data + 2) = csize;
John Koleszar's avatar
John Koleszar committed
477 478 479 480 481

}

static void write_mv_ref
(
482
  vp9_writer *bc, MB_PREDICTION_MODE m, const vp9_prob *p
John Koleszar's avatar
John Koleszar committed
483
) {
484
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
485
  assert(NEARESTMV <= m  &&  m <= SPLITMV);
486
#endif
487 488
  write_token(bc, vp9_mv_ref_tree, p,
              vp9_mv_ref_encoding_array - NEARESTMV + m);
John Koleszar's avatar
John Koleszar committed
489 490
}

491 492
static void write_sb_mv_ref(vp9_writer *bc, MB_PREDICTION_MODE m,
                            const vp9_prob *p) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
493 494 495
#if CONFIG_DEBUG
  assert(NEARESTMV <= m  &&  m < SPLITMV);
#endif
496 497
  write_token(bc, vp9_sb_mv_ref_tree, p,
              vp9_sb_mv_ref_encoding_array - NEARESTMV + m);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
498 499
}

John Koleszar's avatar
John Koleszar committed
500 501
static void write_sub_mv_ref
(
502
  vp9_writer *bc, B_PREDICTION_MODE m, const vp9_prob *p
John Koleszar's avatar
John Koleszar committed
503
) {
504
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
505
  assert(LEFT4X4 <= m  &&  m <= NEW4X4);
506
#endif
507 508
  write_token(bc, vp9_sub_mv_ref_tree, p,
              vp9_sub_mv_ref_encoding_array - LEFT4X4 + m);
John Koleszar's avatar
John Koleszar committed
509 510
}

511
static void write_nmv(vp9_writer *bc, const MV *mv, const int_mv *ref,
John Koleszar's avatar
John Koleszar committed
512
                      const nmv_context *nmvc, int usehp) {
513 514 515 516
  MV e;
  e.row = mv->row - ref->as_mv.row;
  e.col = mv->col - ref->as_mv.col;

517 518
  vp9_encode_nmv(bc, &e, &ref->as_mv, nmvc);
  vp9_encode_nmv_fp(bc, &e, &ref->as_mv, nmvc, usehp);
519 520
}

521
#if CONFIG_NEW_MVREF
522 523
static void vp9_write_mv_ref_id(vp9_writer *w,
                                vp9_prob * ref_id_probs,
524 525 526 527
                                int mv_ref_id) {
  // Encode the index for the MV reference.
  switch (mv_ref_id) {
    case 0:
528
      vp9_write(w, 0, ref_id_probs[0]);
529 530
      break;
    case 1:
531 532
      vp9_write(w, 1, ref_id_probs[0]);
      vp9_write(w, 0, ref_id_probs[1]);
533 534
      break;
    case 2:
535 536 537
      vp9_write(w, 1, ref_id_probs[0]);
      vp9_write(w, 1, ref_id_probs[1]);
      vp9_write(w, 0, ref_id_probs[2]);
538 539
      break;
    case 3:
540 541 542
      vp9_write(w, 1, ref_id_probs[0]);
      vp9_write(w, 1, ref_id_probs[1]);
      vp9_write(w, 1, ref_id_probs[2]);
543 544 545 546 547 548 549 550 551 552
      break;

      // TRAP.. This should not happen
    default:
      assert(0);
      break;
  }
}
#endif

Paul Wilkins's avatar
Paul Wilkins committed
553 554
// This function writes the current macro block's segnment id to the bitstream
// It should only be called if a segment map update is indicated.
555
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
556
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
557
  // Encode the MB segment id.
Ronald S. Bultje's avatar
Ronald S. Bultje committed
558
  int seg_id = mi->segment_id;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
559

Paul Wilkins's avatar
Paul Wilkins committed
560
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
561
    switch (seg_id) {
John Koleszar's avatar
John Koleszar committed
562
      case 0:
563 564
        vp9_write(bc, 0, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[1]);
John Koleszar's avatar
John Koleszar committed
565 566
        break;
      case 1:
567 568
        vp9_write(bc, 0, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[1]);
John Koleszar's avatar
John Koleszar committed
569 570
        break;
      case 2:
571 572
        vp9_write(bc, 1, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[2]);
John Koleszar's avatar
John Koleszar committed
573 574
        break;
      case 3:
575 576
        vp9_write(bc, 1, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[2]);
John Koleszar's avatar
John Koleszar committed
577 578 579 580
        break;

        // TRAP.. This should not happen
      default:
581 582
        vp9_write(bc, 0, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[1]);
John Koleszar's avatar
John Koleszar committed
583
        break;
John Koleszar's avatar
John Koleszar committed
584
    }
John Koleszar's avatar
John Koleszar committed
585
  }
John Koleszar's avatar
John Koleszar committed
586 587
}

Paul Wilkins's avatar
Paul Wilkins committed
588
// This function encodes the reference frame
589
static void encode_ref_frame(vp9_writer *const bc,
590
                             VP9_COMMON *const cm,
John Koleszar's avatar
John Koleszar committed
591 592 593 594 595
                             MACROBLOCKD *xd,
                             int segment_id,
                             MV_REFERENCE_FRAME rf) {
  int seg_ref_active;
  int seg_ref_count = 0;
596 597 598
  seg_ref_active = vp9_segfeature_active(xd,
                                         segment_id,
                                         SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
599 600

  if (seg_ref_active) {
601 602 603 604
    seg_ref_count = vp9_check_segref(xd, segment_id, INTRA_FRAME) +
                    vp9_check_segref(xd, segment_id, LAST_FRAME) +
                    vp9_check_segref(xd, segment_id, GOLDEN_FRAME) +
                    vp9_check_segref(xd, segment_id, ALTREF_FRAME);
John Koleszar's avatar
John Koleszar committed
605 606 607 608 609 610 611
  }

  // If segment level coding of this signal is disabled...
  // or the segment allows multiple reference frame options
  if (!seg_ref_active || (seg_ref_count > 1)) {
    // Values used in prediction model coding
    unsigned char prediction_flag;
612
    vp9_prob pred_prob;
John Koleszar's avatar
John Koleszar committed
613 614 615
    MV_REFERENCE_FRAME pred_rf;

    // Get the context probability the prediction flag
Paul Wilkins's avatar
Paul Wilkins committed
616
    pred_prob = vp9_get_pred_prob(cm, xd, PRED_REF);
John Koleszar's avatar
John Koleszar committed
617 618

    // Get the predicted value.
Paul Wilkins's avatar
Paul Wilkins committed
619
    pred_rf = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
620 621 622 623 624

    // Did the chosen reference frame match its predicted value.
    prediction_flag =
      (xd->mode_info_context->mbmi.ref_frame == pred_rf);

Paul Wilkins's avatar
Paul Wilkins committed
625
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
626
    vp9_write(bc, prediction_flag, pred_prob);
John Koleszar's avatar
John Koleszar committed
627 628 629

    // If not predicted correctly then code value explicitly
    if (!prediction_flag) {
630
      vp9_prob mod_refprobs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
631 632 633 634 635 636 637 638

      vpx_memcpy(mod_refprobs,
                 cm->mod_refprobs[pred_rf], sizeof(mod_refprobs));

      // If segment coding enabled blank out options that cant occur by
      // setting the branch probability to 0.
      if (seg_ref_active) {
        mod_refprobs[INTRA_FRAME] *=
639
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
640
        mod_refprobs[LAST_FRAME] *=
641
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
642
        mod_refprobs[GOLDEN_FRAME] *=
643 644
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
645 646 647
      }

      if (mod_refprobs[0]) {
648
        vp9_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
649 650 651 652 653
      }

      // Inter coded
      if (rf != INTRA_FRAME) {
        if (mod_refprobs[1]) {
654
          vp9_write(bc, (rf != LAST_FRAME), mod_refprobs[1]);
John Koleszar's avatar
John Koleszar committed
655
        }
656

John Koleszar's avatar
John Koleszar committed
657 658
        if (rf != LAST_FRAME) {
          if (mod_refprobs[2]) {
659
            vp9_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]);
John Koleszar's avatar
John Koleszar committed
660
          }
661
        }
John Koleszar's avatar
John Koleszar committed
662
      }
Paul Wilkins's avatar
Paul Wilkins committed
663
    }
John Koleszar's avatar
John Koleszar committed
664
  }
Paul Wilkins's avatar
Paul Wilkins committed
665

John Koleszar's avatar
John Koleszar committed
666 667
  // if using the prediction mdoel we have nothing further to do because
  // the reference frame is fully coded by the segment
Paul Wilkins's avatar
Paul Wilkins committed
668
}
John Koleszar's avatar
John Koleszar committed
669

670
// Update the probabilities used to encode reference frame data
671 672
static void update_ref_probs(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
673

John Koleszar's avatar
John Koleszar committed
674 675 676 677
  const int *const rfct = cpi->count_mb_ref_frame_usage;
  const int rf_intra = rfct[INTRA_FRAME];
  const int rf_inter = rfct[LAST_FRAME] +
                       rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
678

John Koleszar's avatar
John Koleszar committed
679 680 681
  cm->prob_intra_coded = get_binary_prob(rf_intra, rf_inter);
  cm->prob_last_coded = get_prob(rfct[LAST_FRAME], rf_inter);
  cm->prob_gf_coded = get_binary_prob(rfct[GOLDEN_FRAME], rfct[ALTREF_FRAME]);
682

John Koleszar's avatar
John Koleszar committed
683 684
  // Compute a modified set of probabilities to use when prediction of the
  // reference frame fails
Paul Wilkins's avatar
Paul Wilkins committed
685
  vp9_compute_mod_refprobs(cm);
686 687
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
688 689 690
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
                                vp9_writer *bc,
                                int mb_rows_left, int mb_cols_left) {
691
  VP9_COMMON *const pc = &cpi->common;
692
  const nmv_context *nmvc = &pc->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
693 694
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
695
  const int mis = pc->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
696 697 698 699 700 701
  MB_MODE_INFO *const mi = &m->mbmi;
  const MV_REFERENCE_FRAME rf = mi->ref_frame;
  const MB_PREDICTION_MODE mode = mi->mode;
  const int segment_id = mi->segment_id;
  const int mb_size = 1 << mi->sb_type;
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
702

Ronald S. Bultje's avatar
Ronald S. Bultje committed
703 704 705 706
  int mb_row = pc->mb_rows - mb_rows_left;
  int mb_col = pc->mb_cols - mb_cols_left;
  xd->prev_mode_info_context = pc->prev_mi + (m - pc->mi);
  x->partition_info = x->pi + (m - pc->mi);
707

Ronald S. Bultje's avatar
Ronald S. Bultje committed
708 709 710 711 712 713 714
  // 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_top_edge = -((mb_row * 16)) << 3;
  xd->mb_to_right_edge = ((pc->mb_cols - mb_size - mb_col) * 16) << 3;
  xd->mb_to_bottom_edge = ((pc->mb_rows - mb_size - mb_row) * 16) << 3;
715

Ronald S. Bultje's avatar
Ronald S. Bultje committed
716 717
#ifdef ENTROPY_STATS
  active_section = 9;
718
#endif
719

Ronald S. Bultje's avatar
Ronald S. Bultje committed
720 721 722 723 724
  if (cpi->mb.e_mbd.update_mb_segmentation_map) {
    // Is temporal coding of the segment map enabled
    if (pc->temporal_update) {
      unsigned char prediction_flag = vp9_get_pred_flag(xd, PRED_SEG_ID);
      vp9_prob pred_prob = vp9_get_pred_prob(pc, xd, PRED_SEG_ID);
Paul Wilkins's avatar
Paul Wilkins committed
725

Ronald S. Bultje's avatar
Ronald S. Bultje committed
726 727
      // Code the segment id prediction flag for this mb
      vp9_write(bc, prediction_flag, pred_prob);
728

Ronald S. Bultje's avatar
Ronald S. Bultje committed
729 730 731 732 733 734 735 736
      // If the mb segment id wasn't predicted code explicitly
      if (!prediction_flag)
        write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    } else {
      // Normal unpredicted coding
      write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    }
  }
737

Ronald S. Bultje's avatar
Ronald S. Bultje committed
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
  if (!pc->mb_no_coeff_skip) {
    skip_coeff = 0;
  } else if (vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB) &&
             vp9_get_segdata(xd, segment_id, SEG_LVL_EOB) == 0) {
    skip_coeff = 1;
  } else {
    const int nmbs = mb_size;
    const int xmbs = MIN(nmbs, mb_cols_left);
    const int ymbs = MIN(nmbs, mb_rows_left);
    int x, y;

    skip_coeff = 1;
    for (y = 0; y < ymbs; y++) {
      for (x = 0; x < xmbs; x++) {
        skip_coeff = skip_coeff && m[y * mis + x].mbmi.mb_skip_coeff;
      }
    }
John Koleszar's avatar
John Koleszar committed
755

Ronald S. Bultje's avatar
Ronald S. Bultje committed
756 757 758
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
759

Ronald S. Bultje's avatar
Ronald S. Bultje committed
760 761 762 763 764 765 766
  // Encode the reference frame.
  if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)
      || vp9_get_segdata(xd, segment_id, SEG_LVL_MODE) >= NEARESTMV) {
    encode_ref_frame(bc, pc, xd, segment_id, rf);
  } else {
    assert(rf == INTRA_FRAME);
  }
Paul Wilkins's avatar
Paul Wilkins committed
767

Ronald S. Bultje's avatar
Ronald S. Bultje committed
768
  if (rf == INTRA_FRAME) {
769
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
770
    active_section = 6;
771
#endif
Paul Wilkins's avatar
Paul Wilkins committed
772

Ronald S. Bultje's avatar
Ronald S. Bultje committed
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)) {
      if (m->mbmi.sb_type)
        write_sb_ymode(bc, mode, pc->fc.sb_ymode_prob);
      else
        write_ymode(bc, mode, pc->fc.ymode_prob);
    }
    if (mode == B_PRED) {
      int j = 0;
      do {
        write_bmode(bc, m->bmi[j].as_mode.first,
                    pc->fc.bmode_prob);
      } while (++j < 16);
    }
    if (mode == I8X8_PRED) {
      write_i8x8_mode(bc, m->bmi[0].as_mode.first,
                      pc->fc.i8x8_mode_prob);
      write_i8x8_mode(bc, m->bmi[2].as_mode.first,
                      pc->fc.i8x8_mode_prob);
      write_i8x8_mode(bc, m->bmi[8].as_mode.first,
                      pc->fc.i8x8_mode_prob);
      write_i8x8_mode(bc, m->bmi[10].as_mode.first,
                      pc->fc.i8x8_mode_prob);
    } else {
      write_uv_mode(bc, mi->uv_mode,
                    pc->fc.uv_mode_prob[mode]);
    }
  } else {
    vp9_prob mv_ref_p[VP9_MVREFS - 1];
801

Ronald S. Bultje's avatar
Ronald S. Bultje committed
802
    vp9_mv_ref_probs(&cpi->common, mv_ref_p, mi->mb_mode_context[rf]);
Yaowu Xu's avatar
Yaowu Xu committed
803

Ronald S. Bultje's avatar
Ronald S. Bultje committed
804
    // #ifdef ENTROPY_STATS
John Koleszar's avatar
John Koleszar committed
805
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
806 807
    accum_mv_refs(mode, ct);
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
808 809
#endif

Ronald S. Bultje's avatar
Ronald S. Bultje committed
810 811 812 813
    // Is the segment coding of mode enabled
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)) {
      if (mi->sb_type) {
        write_sb_mv_ref(bc, mode, mv_ref_p);
814
      } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
815 816 817 818
        write_mv_ref(bc, mode, mv_ref_p);
      }
      vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
    }
819

Ronald S. Bultje's avatar
Ronald S. Bultje committed
820 821 822 823 824 825 826 827 828 829 830
    if (mode >= NEARESTMV && mode <= SPLITMV) {
      if (cpi->common.mcomp_filter_type == SWITCHABLE) {
        write_token(bc, vp9_switchable_interp_tree,
                    vp9_get_pred_probs(&cpi->common, xd,
                                       PRED_SWITCHABLE_INTERP),
                    vp9_switchable_interp_encodings +
                    vp9_switchable_interp_map[mi->interp_filter]);
      } else {
        assert(mi->interp_filter == cpi->common.mcomp_filter_type);
      }
    }
831

Ronald S. Bultje's avatar
Ronald S. Bultje committed
832 833 834 835 836 837
    // does the feature use compound prediction or not
    // (if not specified at the frame/segment level)
    if (cpi->common.comp_pred_mode == HYBRID_PREDICTION) {
      vp9_write(bc, mi->second_ref_frame > INTRA_FRAME,
                vp9_get_pred_prob(pc, xd, PRED_COMP));
    }
838
#if CONFIG_COMP_INTERINTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
839 840 841 842 843 844 845 846 847 848 849 850 851
    if (cpi->common.use_interintra &&
        mode >= NEARESTMV && mode < SPLITMV &&
        mi->second_ref_frame <= INTRA_FRAME) {
      vp9_write(bc, mi->second_ref_frame == INTRA_FRAME,
                pc->fc.interintra_prob);
      // if (!cpi->dummy_packing)
      //   printf("-- %d (%d)\n", mi->second_ref_frame == INTRA_FRAME,
      //          pc->fc.interintra_prob);
      if (mi->second_ref_frame == INTRA_FRAME) {
        // if (!cpi->dummy_packing)
        //   printf("** %d %d\n", mi->interintra_mode,
        // mi->interintra_uv_mode);
        write_ymode(bc, mi->interintra_mode, pc->fc.ymode_prob);
852
#if SEPARATE_INTERINTRA_UV
Ronald S. Bultje's avatar
Ronald S. Bultje committed
853 854
        write_uv_mode(bc, mi->interintra_uv_mode,
                      pc->fc.uv_mode_prob[mi->interintra_mode]);
855
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
856 857
      }
    }
858
#endif
John Koleszar's avatar
John Koleszar committed
859

860
#if CONFIG_NEW_MVREF
Ronald S. Bultje's avatar
Ronald S. Bultje committed
861 862 863 864 865 866 867 868 869 870 871 872 873
    // if ((mode == NEWMV) || (mode == SPLITMV)) {
    if (mode == NEWMV) {
      // Encode the index of the choice.
      vp9_write_mv_ref_id(bc,
                          xd->mb_mv_ref_probs[rf], mi->best_index);

      if (mi->second_ref_frame > 0) {
        // Encode the index of the choice.
        vp9_write_mv_ref_id(
                            bc, xd->mb_mv_ref_probs[mi->second_ref_frame],
                            mi->best_second_index);
      }
    }
874
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
875 876 877

    switch (mode) { /* new, split require MVs */
      case NEWMV:
878
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
879
        active_section = 5;
880
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
881 882 883
        write_nmv(bc, &mi->mv[0].as_mv, &mi->best_mv,
                  (const nmv_context*) nmvc,
                  xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
884

Ronald S. Bultje's avatar
Ronald S. Bultje committed
885 886 887 888 889 890 891 892
        if (mi->second_ref_frame > 0) {
          write_nmv(bc, &mi->mv[1].as_mv, &mi->best_second_mv,
                    (const nmv_context*) nmvc,
                    xd->allow_high_precision_mv);
        }
        break;
      case SPLITMV: {
        int j = 0;
John Koleszar's avatar
John Koleszar committed
893

894
#ifdef MODE_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
895
        ++count_mb_seg[mi->partitioning];
896
#endif
John Koleszar's avatar
John Koleszar committed
897

Ronald S. Bultje's avatar
Ronald S. Bultje committed
898 899
        write_split(bc, mi->partitioning, cpi->common.fc.mbsplit_prob);
        cpi->mbsplit_count[mi->partitioning]++;
Adrian Grange's avatar
Adrian Grange committed
900

Ronald S. Bultje's avatar
Ronald S. Bultje committed
901 902 903 904 905