vp9_bitstream.c 78.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 13
#include <assert.h>
#include <stdio.h>
#include <limits.h>
John Koleszar's avatar
John Koleszar committed
14

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

29 30 31 32 33 34
#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"
35
#include "vp9/common/vp9_treecoder.h"
Paul Wilkins's avatar
Paul Wilkins committed
36

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

#ifdef ENTROPY_STATS
42 43 44
int intra_mode_stats[VP9_KF_BINTRAMODES]
                    [VP9_KF_BINTRAMODES]
                    [VP9_KF_BINTRAMODES];
45 46 47
vp9_coeff_stats tree_update_hist_4x4[BLOCK_TYPES];
vp9_coeff_stats tree_update_hist_8x8[BLOCK_TYPES];
vp9_coeff_stats tree_update_hist_16x16[BLOCK_TYPES];
48
vp9_coeff_stats tree_update_hist_32x32[BLOCK_TYPES];
49

John Koleszar's avatar
John Koleszar committed
50 51 52
extern unsigned int active_section;
#endif

53 54 55 56 57 58 59 60 61 62 63
#if CONFIG_CODE_ZEROGROUP
#ifdef ZPC_STATS
vp9_zpc_count zpc_stats_4x4;
vp9_zpc_count zpc_stats_8x8;
vp9_zpc_count zpc_stats_16x16;
vp9_zpc_count zpc_stats_32x32;
void init_zpcstats();
void update_zpcstats(VP9_COMMON *const cm);
void print_zpcstats();
#endif
#endif
64

John Koleszar's avatar
John Koleszar committed
65 66 67 68
#ifdef MODE_STATS
int count_mb_seg[4] = { 0, 0, 0, 0 };
#endif

69 70
#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)))
71 72 73 74

#define SEARCH_NEWP
static int update_bits[255];

75 76 77 78 79 80 81 82 83 84 85 86
static INLINE void write_le16(uint8_t *p, int value) {
  p[0] = value;
  p[1] = value >> 8;
}

static INLINE void write_le32(uint8_t *p, int value) {
  p[0] = value;
  p[1] = value >> 8;
  p[2] = value >> 16;
  p[3] = value >> 24;
}

John Koleszar's avatar
John Koleszar committed
87 88 89
static void compute_update_table() {
  int i;
  for (i = 0; i < 255; i++)
90
    update_bits[i] = vp9_count_term_subexp(i, SUBEXP_PARAM, 255);
91 92
}

John Koleszar's avatar
John Koleszar committed
93 94 95 96 97
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;
98 99
}

John Koleszar's avatar
John Koleszar committed
100 101 102 103 104
static int remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
  int i;
  if ((m << 1) <= n)
105
    i = vp9_recenter_nonneg(v, m) - 1;
John Koleszar's avatar
John Koleszar committed
106
  else
107
    i = vp9_recenter_nonneg(n - 1 - v, n - 1 - m) - 1;
John Koleszar's avatar
John Koleszar committed
108 109 110

  i = split_index(i, n - 1, modulus);
  return i;
111
}
112

113 114
static void write_prob_diff_update(vp9_writer *const bc,
                                   vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
115
  int delp = remap_prob(newp, oldp);
116
  vp9_encode_term_subexp(bc, delp, SUBEXP_PARAM, 255);
117 118
}

119
static int prob_diff_update_cost(vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
120 121
  int delp = remap_prob(newp, oldp);
  return update_bits[delp] * 256;
122
}
123

John Koleszar's avatar
John Koleszar committed
124
static void update_mode(
125
  vp9_writer *const bc,
John Koleszar's avatar
John Koleszar committed
126
  int n,
127
  const struct vp9_token tok[/* n */],
128 129 130
  vp9_tree tree,
  vp9_prob Pnew               [/* n-1 */],
  vp9_prob Pcur               [/* n-1 */],
John Koleszar's avatar
John Koleszar committed
131 132 133 134 135 136
  unsigned int bct            [/* n-1 */] [2],
  const unsigned int num_events[/* n */]
) {
  unsigned int new_b = 0, old_b = 0;
  int i = 0;

137 138
  vp9_tree_probs_from_distribution(tree, Pnew, bct, num_events, 0);
  n--;
John Koleszar's avatar
John Koleszar committed
139 140

  do {
141 142
    new_b += cost_branch(bct[i], Pnew[i]);
    old_b += cost_branch(bct[i], Pcur[i]);
John Koleszar's avatar
John Koleszar committed
143 144 145
  } while (++i < n);

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

148
    vp9_write_bit(bc, 1);
John Koleszar's avatar
John Koleszar committed
149

John Koleszar's avatar
John Koleszar committed
150
    do {
151
      const vp9_prob p = Pnew[i];
John Koleszar's avatar
John Koleszar committed
152

153
      vp9_write_literal(bc, Pcur[i] = p ? p : 1, 8);
John Koleszar's avatar
John Koleszar committed
154 155
    } while (++i < n);
  } else
156
    vp9_write_bit(bc, 0);
John Koleszar's avatar
John Koleszar committed
157 158
}

159
static void update_mbintra_mode_probs(VP9_COMP* const cpi,
160
                                      vp9_writer* const bc) {
161
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
162

John Koleszar's avatar
John Koleszar committed
163
  {
164 165
    vp9_prob Pnew   [VP9_YMODES - 1];
    unsigned int bct [VP9_YMODES - 1] [2];
John Koleszar's avatar
John Koleszar committed
166

John Koleszar's avatar
John Koleszar committed
167
    update_mode(
168
      bc, VP9_YMODES, vp9_ymode_encodings, vp9_ymode_tree,
Paul Wilkins's avatar
Paul Wilkins committed
169
      Pnew, cm->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
John Koleszar's avatar
John Koleszar committed
170
    );
171 172 173
    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
174
  }
John Koleszar's avatar
John Koleszar committed
175 176
}

177 178
void vp9_update_skip_probs(VP9_COMP *cpi) {
  VP9_COMMON *const pc = &cpi->common;
John Koleszar's avatar
John Koleszar committed
179
  int k;
Paul Wilkins's avatar
Paul Wilkins committed
180

John Koleszar's avatar
John Koleszar committed
181
  for (k = 0; k < MBSKIP_CONTEXTS; ++k) {
John Koleszar's avatar
John Koleszar committed
182 183
    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
184
  }
Paul Wilkins's avatar
Paul Wilkins committed
185 186
}

187
static void update_switchable_interp_probs(VP9_COMP *cpi,
188
                                           vp9_writer* const bc) {
189
  VP9_COMMON *const pc = &cpi->common;
190 191
  unsigned int branch_ct[32][2];
  int i, j;
192
  for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j) {
193
    vp9_tree_probs_from_distribution(
194
        vp9_switchable_interp_tree,
195
        pc->fc.switchable_interp_prob[j], branch_ct,
196
        cpi->switchable_interp_count[j], 0);
197
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i) {
198 199
      if (pc->fc.switchable_interp_prob[j][i] < 1)
        pc->fc.switchable_interp_prob[j][i] = 1;
200
      vp9_write_prob(bc, pc->fc.switchable_interp_prob[j][i]);
201 202 203 204
    }
  }
}

205
// This function updates the reference frame prediction stats
206 207
static void update_refpred_stats(VP9_COMP *cpi) {
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
208
  int i;
209
  vp9_prob new_pred_probs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
210 211 212
  int old_cost, new_cost;

  // Set the prediction probability structures to defaults
213
  if (cm->frame_type != KEY_FRAME) {
John Koleszar's avatar
John Koleszar committed
214 215
    // From the prediction counts set the probabilities for each context
    for (i = 0; i < PREDICTION_PROBS; i++) {
John Koleszar's avatar
John Koleszar committed
216 217
      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
218 219 220 221

      // Decide whether or not to update the reference frame probs.
      // Returned costs are in 1/256 bit units.
      old_cost =
222 223
        (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
224 225

      new_cost =
226 227
        (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
228 229 230 231 232 233 234

      // 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;
235
    }
John Koleszar's avatar
John Koleszar committed
236
  }
237 238
}

239 240 241 242 243 244
// 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.
245 246
static void update_inter_mode_probs(VP9_COMMON *cm,
                                    int mode_context[INTER_MODE_CONTEXTS][4]) {
247
  int i, j;
Jim Bankoski's avatar
Jim Bankoski committed
248
  unsigned int (*mv_ref_ct)[4][2];
249 250 251 252 253 254 255 256

  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++) {
257
      int new_prob, old_cost, new_cost;
258 259 260

      // 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]);
261
      new_prob = get_binary_prob(mv_ref_ct[i][j][0], mv_ref_ct[i][j][1]);
262 263 264 265 266 267 268 269 270 271 272
      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;
      }
    }
  }
}
273

274 275
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
276 277
}

278 279
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
280 281
}

282 283 284 285
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);
}

286 287
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
288 289
}

290 291
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
292
}
Yaowu Xu's avatar
Yaowu Xu committed
293

294 295
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
296 297 298
}


299
static void write_bmode(vp9_writer *bc, int m, const vp9_prob *p) {
300 301 302 303
#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
304
  write_token(bc, vp9_bmode_tree, p, vp9_bmode_encodings + m);
John Koleszar's avatar
John Koleszar committed
305 306
}

307 308 309 310
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);
}

311
static void write_split(vp9_writer *bc, int x, const vp9_prob *p) {
312 313
  write_token(
    bc, vp9_mbsplit_tree, p, vp9_mbsplit_encodings + x);
John Koleszar's avatar
John Koleszar committed
314 315
}

316
static int prob_update_savings(const unsigned int *ct,
317 318 319 320 321
                               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
322
  return (old_b - new_b - update_b);
323 324
}

325
static int prob_diff_update_savings(const unsigned int *ct,
326 327 328 329
                                    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
330
  const int update_b = (newp == oldp ? 0 :
331
                        prob_diff_update_cost(newp, oldp) + vp9_cost_upd256);
John Koleszar's avatar
John Koleszar committed
332
  return (old_b - new_b - update_b);
333 334 335
}

static int prob_diff_update_savings_search(const unsigned int *ct,
336 337 338
                                           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
339
  int new_b, update_b, savings, bestsavings, step;
340
  vp9_prob newp, bestnewp;
John Koleszar's avatar
John Koleszar committed
341 342 343 344 345 346

  bestsavings = 0;
  bestnewp = oldp;

  step = (*bestp > oldp ? -1 : 1);
  for (newp = *bestp; newp != oldp; newp += step) {
347 348
    new_b = cost_branch256(ct, newp);
    update_b = prob_diff_update_cost(newp, oldp) + vp9_cost_upd256;
John Koleszar's avatar
John Koleszar committed
349 350 351 352
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
353
    }
John Koleszar's avatar
John Koleszar committed
354 355 356
  }
  *bestp = bestnewp;
  return bestsavings;
357 358
}

359 360 361 362 363
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
static int prob_diff_update_savings_search_model(const unsigned int *ct,
                                                 const vp9_prob *oldp,
                                                 vp9_prob *bestp,
                                                 const vp9_prob upd,
364
                                                 int b, int r, int q) {
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
  int i, old_b, new_b, update_b, savings, bestsavings, step;
  int newp;
  vp9_prob bestnewp, newplist[ENTROPY_NODES];
  for (i = UNCONSTRAINED_NODES - 1, old_b = 0; i < ENTROPY_NODES; ++i)
    old_b += cost_branch256(ct + 2 * i, oldp[i]);

  bestsavings = 0;
  bestnewp = oldp[UNCONSTRAINED_NODES - 1];

  step = (*bestp > oldp[UNCONSTRAINED_NODES - 1] ? -1 : 1);
  newp = *bestp;
  // newp = *bestp - step * (abs(*bestp - oldp[UNCONSTRAINED_NODES - 1]) >> 1);
  for (; newp != oldp[UNCONSTRAINED_NODES - 1]; newp += step) {
    if (newp < 1 || newp > 255) continue;
    newplist[UNCONSTRAINED_NODES - 1] = newp;
    vp9_get_model_distribution(newp, newplist, b, r);
    for (i = UNCONSTRAINED_NODES - 1, new_b = 0; i < ENTROPY_NODES; ++i)
      new_b += cost_branch256(ct + 2 * i, newplist[i]);
    update_b = prob_diff_update_cost(newp, oldp[UNCONSTRAINED_NODES - 1]) +
        vp9_cost_upd256;
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
    }
  }
  *bestp = bestnewp;
  return bestsavings;
}
#endif

396 397 398 399 400 401 402 403
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);
404
    vp9_write_prob(bc, newp);
405 406 407 408 409 410
    *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
  while (p < stop) {
417
    const int t = p->token;
418
    const struct vp9_token *const a = vp9_coef_encodings + t;
419
    const vp9_extra_bit *const b = vp9_extra_bits + t;
John Koleszar's avatar
John Koleszar committed
420 421 422
    int i = 0;
    const unsigned char *pp = p->context_tree;
    int v = a->value;
423
    int n = a->len;
424
    int ncount = n;
John Koleszar's avatar
John Koleszar committed
425

426 427 428 429 430
    if (t == EOSB_TOKEN)
    {
      ++p;
      break;
    }
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
    assert(pp != 0);
#if CONFIG_CODE_ZEROGROUP
    if (t == ZPC_ISOLATED || t == ZPC_EOORIENT) {
      assert((p - 1)->token == ZERO_TOKEN);
      encode_bool(bc, t == ZPC_ISOLATED, *pp);
      ++p;
      continue;
    } else if (p->skip_coef_val) {
      assert(p->skip_eob_node == 0);
      assert(t == DCT_EOB_TOKEN || t == ZERO_TOKEN);
      encode_bool(bc, t == ZERO_TOKEN, *pp);
      ++p;
      continue;
    }
#endif
446

John Koleszar's avatar
John Koleszar committed
447 448 449 450
    /* skip one or two nodes */
    if (p->skip_eob_node) {
      n -= p->skip_eob_node;
      i = 2 * p->skip_eob_node;
451
      ncount -= p->skip_eob_node;
John Koleszar's avatar
John Koleszar committed
452
    }
John Koleszar's avatar
John Koleszar committed
453

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


John Koleszar's avatar
John Koleszar committed
462
    if (b->base_val) {
463
      const int e = p->extra, l = b->len;
John Koleszar's avatar
John Koleszar committed
464

465
      if (l) {
John Koleszar's avatar
John Koleszar committed
466 467
        const unsigned char *pp = b->prob;
        int v = e >> 1;
468
        int n = l;              /* number of bits in v, assumed nonzero */
John Koleszar's avatar
John Koleszar committed
469
        int i = 0;
John Koleszar's avatar
John Koleszar committed
470

John Koleszar's avatar
John Koleszar committed
471 472
        do {
          const int bb = (v >> --n) & 1;
473
          vp9_write(bc, bb, pp[i >> 1]);
John Koleszar's avatar
John Koleszar committed
474 475 476
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
477

478
      vp9_write_bit(bc, e & 1);
John Koleszar's avatar
John Koleszar committed
479
    }
John Koleszar's avatar
John Koleszar committed
480 481 482
    ++p;
  }

483
  *tp = p;
John Koleszar's avatar
John Koleszar committed
484 485 486 487
}

static void write_mv_ref
(
488
  vp9_writer *bc, MB_PREDICTION_MODE m, const vp9_prob *p
John Koleszar's avatar
John Koleszar committed
489
) {
490
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
491
  assert(NEARESTMV <= m  &&  m <= SPLITMV);
492
#endif
493 494
  write_token(bc, vp9_mv_ref_tree, p,
              vp9_mv_ref_encoding_array - NEARESTMV + m);
John Koleszar's avatar
John Koleszar committed
495 496
}

497 498
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
499 500 501
#if CONFIG_DEBUG
  assert(NEARESTMV <= m  &&  m < SPLITMV);
#endif
502 503
  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
504 505
}

John Koleszar's avatar
John Koleszar committed
506 507
static void write_sub_mv_ref
(
508
  vp9_writer *bc, B_PREDICTION_MODE m, const vp9_prob *p
John Koleszar's avatar
John Koleszar committed
509
) {
510
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
511
  assert(LEFT4X4 <= m  &&  m <= NEW4X4);
512
#endif
513 514
  write_token(bc, vp9_sub_mv_ref_tree, p,
              vp9_sub_mv_ref_encoding_array - LEFT4X4 + m);
John Koleszar's avatar
John Koleszar committed
515 516
}

517 518
static void write_nmv(VP9_COMP *cpi, vp9_writer *bc,
                      const MV *mv, const int_mv *ref,
John Koleszar's avatar
John Koleszar committed
519
                      const nmv_context *nmvc, int usehp) {
520 521 522 523
  MV e;
  e.row = mv->row - ref->as_mv.row;
  e.col = mv->col - ref->as_mv.col;

524 525
  vp9_encode_nmv(bc, &e, &ref->as_mv, nmvc);
  vp9_encode_nmv_fp(bc, &e, &ref->as_mv, nmvc, usehp);
526 527
}

Paul Wilkins's avatar
Paul Wilkins committed
528 529
// 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.
530
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
531
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
532
  // Encode the MB segment id.
Ronald S. Bultje's avatar
Ronald S. Bultje committed
533
  int seg_id = mi->segment_id;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
534

Paul Wilkins's avatar
Paul Wilkins committed
535
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
536
    switch (seg_id) {
John Koleszar's avatar
John Koleszar committed
537
      case 0:
538 539
        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
540 541
        break;
      case 1:
542 543
        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
544 545
        break;
      case 2:
546 547
        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
548 549
        break;
      case 3:
550 551
        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
552 553 554 555
        break;

        // TRAP.. This should not happen
      default:
556 557
        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
558
        break;
John Koleszar's avatar
John Koleszar committed
559
    }
John Koleszar's avatar
John Koleszar committed
560
  }
John Koleszar's avatar
John Koleszar committed
561 562
}

Paul Wilkins's avatar
Paul Wilkins committed
563
// This function encodes the reference frame
564
static void encode_ref_frame(vp9_writer *const bc,
565
                             VP9_COMMON *const cm,
John Koleszar's avatar
John Koleszar committed
566 567 568 569 570
                             MACROBLOCKD *xd,
                             int segment_id,
                             MV_REFERENCE_FRAME rf) {
  int seg_ref_active;
  int seg_ref_count = 0;
571 572 573
  seg_ref_active = vp9_segfeature_active(xd,
                                         segment_id,
                                         SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
574 575

  if (seg_ref_active) {
576 577 578 579
    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
580 581 582 583 584 585 586
  }

  // 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;
587
    vp9_prob pred_prob;
John Koleszar's avatar
John Koleszar committed
588 589 590
    MV_REFERENCE_FRAME pred_rf;

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

    // Get the predicted value.
Paul Wilkins's avatar
Paul Wilkins committed
594
    pred_rf = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
595 596 597 598 599

    // 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
600
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
601
    vp9_write(bc, prediction_flag, pred_prob);
John Koleszar's avatar
John Koleszar committed
602 603 604

    // If not predicted correctly then code value explicitly
    if (!prediction_flag) {
605
      vp9_prob mod_refprobs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
606 607 608 609 610 611 612 613

      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] *=
614
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
615
        mod_refprobs[LAST_FRAME] *=
616
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
617
        mod_refprobs[GOLDEN_FRAME] *=
618 619
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
620 621 622
      }

      if (mod_refprobs[0]) {
623
        vp9_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
624 625 626 627 628
      }

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

John Koleszar's avatar
John Koleszar committed
632 633
        if (rf != LAST_FRAME) {
          if (mod_refprobs[2]) {
634
            vp9_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]);
John Koleszar's avatar
John Koleszar committed
635
          }
636
        }
John Koleszar's avatar
John Koleszar committed
637
      }
Paul Wilkins's avatar
Paul Wilkins committed
638
    }
John Koleszar's avatar
John Koleszar committed
639
  }
Paul Wilkins's avatar
Paul Wilkins committed
640

John Koleszar's avatar
John Koleszar committed
641 642
  // 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
643
}
John Koleszar's avatar
John Koleszar committed
644

645
// Update the probabilities used to encode reference frame data
646 647
static void update_ref_probs(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
648

John Koleszar's avatar
John Koleszar committed
649 650 651 652
  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];
653

John Koleszar's avatar
John Koleszar committed
654 655 656
  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]);
657

John Koleszar's avatar
John Koleszar committed
658 659
  // Compute a modified set of probabilities to use when prediction of the
  // reference frame fails
Paul Wilkins's avatar
Paul Wilkins committed
660
  vp9_compute_mod_refprobs(cm);
661 662
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
663 664 665
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
                                vp9_writer *bc,
                                int mb_rows_left, int mb_cols_left) {
666
  VP9_COMMON *const pc = &cpi->common;
667
  const nmv_context *nmvc = &pc->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
668 669
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
670
  const int mis = pc->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
671 672 673 674
  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;
675 676
  const int bw = 1 << mb_width_log2(mi->sb_type);
  const int bh = 1 << mb_height_log2(mi->sb_type);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
677
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
678

Ronald S. Bultje's avatar
Ronald S. Bultje committed
679 680 681 682
  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);
683

Ronald S. Bultje's avatar
Ronald S. Bultje committed
684 685 686
  // 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
687

688 689
  set_mb_row(pc, xd, mb_row, bh);
  set_mb_col(pc, xd, mb_col, bw);
690

Ronald S. Bultje's avatar
Ronald S. Bultje committed
691 692
#ifdef ENTROPY_STATS
  active_section = 9;
693
#endif
694

Ronald S. Bultje's avatar
Ronald S. Bultje committed
695 696 697 698 699
  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
700

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
704 705
      // If the mb segment id wasn't predicted code explicitly
      if (!prediction_flag)
Paul Wilkins's avatar
Paul Wilkins committed
706
        write_mb_segid(bc, mi, &cpi->mb.e_mbd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
707 708 709 710 711
    } else {
      // Normal unpredicted coding
      write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    }
  }
712

713
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
714 715
    skip_coeff = 1;
  } else {
716
    skip_coeff = m->mbmi.mb_skip_coeff;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
717 718 719
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
720

Ronald S. Bultje's avatar
Ronald S. Bultje committed
721
  // Encode the reference frame.
Paul Wilkins's avatar
Paul Wilkins committed
722
  encode_ref_frame(bc, pc, xd, segment_id, rf);
Paul Wilkins's avatar
Paul Wilkins committed
723

Ronald S. Bultje's avatar
Ronald S. Bultje committed
724
  if (rf == INTRA_FRAME) {
725
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
726
    active_section = 6;
727
#endif
Paul Wilkins's avatar
Paul Wilkins committed
728

729
    if (m->mbmi.sb_type > BLOCK_SIZE_MB16X16)
Paul Wilkins's avatar
Paul Wilkins committed
730 731 732 733
      write_sb_ymode(bc, mode, pc->fc.sb_ymode_prob);
    else
      write_ymode(bc, mode, pc->fc.ymode_prob);

Yaowu Xu's avatar
Yaowu Xu committed
734
    if (mode == I4X4_PRED) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
      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];
756

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

John Koleszar's avatar
John Koleszar committed
759
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
760
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
761 762
#endif

763
    // If segment skip is not enabled code the mode.
Paul Wilkins's avatar
Paul Wilkins committed
764
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
765
      if (mi->sb_type > BLOCK_SIZE_MB16X16) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
766
        write_sb_mv_ref(bc, mode, mv_ref_p);
767
      } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
768 769 770 771
        write_mv_ref(bc, mode, mv_ref_p);
      }
      vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
    }
772

Ronald S. Bultje's avatar
Ronald S. Bultje committed
773 774 775 776 777 778 779 780 781 782 783
    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);
      }
    }
784

Ronald S. Bultje's avatar
Ronald S. Bultje committed
785 786 787 788 789 790
    // 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));
    }
791
#if CONFIG_COMP_INTERINTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
792 793 794 795 796 797 798 799 800 801 802 803 804
    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);
805
#if SEPARATE_INTERINTRA_UV
Ronald S. Bultje's avatar
Ronald S. Bultje committed
806 807
        write_uv_mode(bc, mi->interintra_uv_mode,
                      pc->fc.uv_mode_prob[mi->interintra_mode]);
808
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
809 810
      }
    }
811
#endif
John Koleszar's avatar
John Koleszar committed
812

Ronald S. Bultje's avatar
Ronald S. Bultje committed
813 814
    switch (mode) { /* new, split require MVs */
      case NEWMV:
815
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
816
        active_section = 5;
817
#endif
818
        write_nmv(cpi, bc, &mi->mv[0].as_mv, &mi->best_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
819 820
                  (const nmv_context*) nmvc,
                  xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
821

Ronald S. Bultje's avatar
Ronald S. Bultje committed
822
        if (mi->second_ref_frame > 0) {
823
          write_nmv(cpi, bc, &mi->mv[1].as_mv, &mi->best_second_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
824 825 826 827 828 829
                    (const nmv_context*) nmvc,
                    xd->allow_high_precision_mv);
        }
        break;
      case SPLITMV: {
        int j = 0;
John Koleszar's avatar
John Koleszar committed
830

831
#ifdef MODE_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
832
        ++count_mb_seg[mi->partitioning];
833
#endif
John Koleszar's avatar
John Koleszar committed
834