vp9_bitstream.c 73.5 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 152 153
#if CONFIG_SUPERBLOCKS
    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);
#endif
John Koleszar's avatar
John Koleszar committed
154
  }
John Koleszar's avatar
John Koleszar committed
155 156
}

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

John Koleszar's avatar
John Koleszar committed
161
  for (k = 0; k < MBSKIP_CONTEXTS; ++k) {
John Koleszar's avatar
John Koleszar committed
162 163
    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
164
  }
Paul Wilkins's avatar
Paul Wilkins committed
165 166
}

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

186
// This function updates the reference frame prediction stats
187 188
static void update_refpred_stats(VP9_COMP *cpi) {
  VP9_COMMON *const cm = &cpi->common;
John Koleszar's avatar
John Koleszar committed
189
  int i;
190
  vp9_prob new_pred_probs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
191 192 193 194 195 196 197 198 199 200 201 202 203 204
  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
205 206
      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
207 208 209 210

      // Decide whether or not to update the reference frame probs.
      // Returned costs are in 1/256 bit units.
      old_cost =
211 212
        (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
213 214

      new_cost =
215 216
        (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
217 218 219 220 221 222 223

      // 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;
224 225

    }
John Koleszar's avatar
John Koleszar committed
226
  }
227 228
}

229 230 231 232 233 234
// 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
235 236
static void update_mode_probs(VP9_COMMON *cm,
                              int mode_context[INTER_MODE_CONTEXTS][4]) {
237
  int i, j;
Jim Bankoski's avatar
Jim Bankoski committed
238
  unsigned int (*mv_ref_ct)[4][2];
239 240 241 242 243 244 245 246

  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++) {
247
      int new_prob, old_cost, new_cost;
248 249 250

      // 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]);
251
      new_prob = get_binary_prob(mv_ref_ct[i][j][0], mv_ref_ct[i][j][1]);
252 253 254 255 256 257 258 259 260 261 262
      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;
      }
    }
  }
}
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 311 312

#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

313 314
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
315 316
}

317 318
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
319 320
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
321
#if CONFIG_SUPERBLOCKS
322 323 324 325
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);
}

326 327
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
328 329 330
}
#endif

331 332
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
333
}
Yaowu Xu's avatar
Yaowu Xu committed
334

335 336
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
337 338 339
}


340
static void write_bmode(vp9_writer *bc, int m, const vp9_prob *p) {
341 342 343 344
#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
345
  write_token(bc, vp9_bmode_tree, p, vp9_bmode_encodings + m);
John Koleszar's avatar
John Koleszar committed
346 347
}

348 349 350 351
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);
}

352
static void write_split(vp9_writer *bc, int x, const vp9_prob *p) {
353 354
  write_token(
    bc, vp9_mbsplit_tree, p, vp9_mbsplit_encodings + x);
John Koleszar's avatar
John Koleszar committed
355 356
}

357
static int prob_update_savings(const unsigned int *ct,
358 359 360 361 362
                               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
363
  return (old_b - new_b - update_b);
364 365
}

366
static int prob_diff_update_savings(const unsigned int *ct,
367 368 369 370
                                    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
371
  const int update_b = (newp == oldp ? 0 :
372
                        prob_diff_update_cost(newp, oldp) + vp9_cost_upd256);
John Koleszar's avatar
John Koleszar committed
373
  return (old_b - new_b - update_b);
374 375 376
}

static int prob_diff_update_savings_search(const unsigned int *ct,
377 378 379
                                           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
380
  int new_b, update_b, savings, bestsavings, step;
381
  vp9_prob newp, bestnewp;
John Koleszar's avatar
John Koleszar committed
382 383 384 385 386 387

  bestsavings = 0;
  bestnewp = oldp;

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

400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
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);
  }
}

415
static void pack_mb_tokens(vp9_writer* const bc,
416 417 418
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
419

John Koleszar's avatar
John Koleszar committed
420 421
  while (p < stop) {
    const int t = p->Token;
422 423
    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
424 425 426 427 428
    int i = 0;
    const unsigned char *pp = p->context_tree;
    int v = a->value;
    int n = a->Len;

429 430 431 432 433 434
    if (t == EOSB_TOKEN)
    {
      ++p;
      break;
    }

John Koleszar's avatar
John Koleszar committed
435 436 437 438 439
    /* 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
440

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


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

John Koleszar's avatar
John Koleszar committed
451 452 453 454 455
      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
456

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

464
      encode_bool(bc, e & 1, 128);
John Koleszar's avatar
John Koleszar committed
465
    }
John Koleszar's avatar
John Koleszar committed
466 467 468
    ++p;
  }

469
  *tp = p;
John Koleszar's avatar
John Koleszar committed
470 471
}

John Koleszar's avatar
John Koleszar committed
472 473
static void write_partition_size(unsigned char *cx_data, int size) {
  signed char csize;
John Koleszar's avatar
John Koleszar committed
474

John Koleszar's avatar
John Koleszar committed
475 476 477 478 479 480
  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
481 482 483 484 485

}

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
495
#if CONFIG_SUPERBLOCKS
496 497
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
498 499 500
#if CONFIG_DEBUG
  assert(NEARESTMV <= m  &&  m < SPLITMV);
#endif
501 502
  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
503 504 505
}
#endif

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
static void write_nmv(vp9_writer *bc, const MV *mv, const int_mv *ref,
John Koleszar's avatar
John Koleszar committed
518
                      const nmv_context *nmvc, int usehp) {
519 520 521 522
  MV e;
  e.row = mv->row - ref->as_mv.row;
  e.col = mv->col - ref->as_mv.col;

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

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

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

Paul Wilkins's avatar
Paul Wilkins committed
559 560
// 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.
561
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
562
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
563
  // Encode the MB segment id.
Ronald S. Bultje's avatar
Ronald S. Bultje committed
564 565 566
  int seg_id = mi->segment_id;
#if CONFIG_SUPERBLOCKS
  if (mi->encoded_as_sb) {
567
    if (xd->mb_to_right_edge >= 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
568
      seg_id = seg_id && xd->mode_info_context[1].mbmi.segment_id;
569
    if (xd->mb_to_bottom_edge >= 0) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
570 571
      seg_id = seg_id &&
               xd->mode_info_context[xd->mode_info_stride].mbmi.segment_id;
572
      if (xd->mb_to_right_edge >= 0)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
573 574 575 576 577
        seg_id = seg_id &&
                xd->mode_info_context[xd->mode_info_stride + 1].mbmi.segment_id;
    }
  }
#endif
Paul Wilkins's avatar
Paul Wilkins committed
578
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
579
    switch (seg_id) {
John Koleszar's avatar
John Koleszar committed
580
      case 0:
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 584
        break;
      case 1:
585 586
        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
587 588
        break;
      case 2:
589 590
        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
591 592
        break;
      case 3:
593 594
        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
595 596 597 598
        break;

        // TRAP.. This should not happen
      default:
599 600
        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
601
        break;
John Koleszar's avatar
John Koleszar committed
602
    }
John Koleszar's avatar
John Koleszar committed
603
  }
John Koleszar's avatar
John Koleszar committed
604 605
}

Paul Wilkins's avatar
Paul Wilkins committed
606
// This function encodes the reference frame
607
static void encode_ref_frame(vp9_writer *const bc,
608
                             VP9_COMMON *const cm,
John Koleszar's avatar
John Koleszar committed
609 610 611 612 613
                             MACROBLOCKD *xd,
                             int segment_id,
                             MV_REFERENCE_FRAME rf) {
  int seg_ref_active;
  int seg_ref_count = 0;
614 615 616
  seg_ref_active = vp9_segfeature_active(xd,
                                         segment_id,
                                         SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
617 618

  if (seg_ref_active) {
619 620 621 622
    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
623 624 625 626 627 628 629
  }

  // 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;
630
    vp9_prob pred_prob;
John Koleszar's avatar
John Koleszar committed
631 632 633
    MV_REFERENCE_FRAME pred_rf;

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

    // Get the predicted value.
Paul Wilkins's avatar
Paul Wilkins committed
637
    pred_rf = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
638 639 640 641 642

    // 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
643
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
644
    vp9_write(bc, prediction_flag, pred_prob);
John Koleszar's avatar
John Koleszar committed
645 646 647

    // If not predicted correctly then code value explicitly
    if (!prediction_flag) {
648
      vp9_prob mod_refprobs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
649 650 651 652 653 654 655 656

      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] *=
657
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
658
        mod_refprobs[LAST_FRAME] *=
659
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
660
        mod_refprobs[GOLDEN_FRAME] *=
661 662
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
663 664 665
      }

      if (mod_refprobs[0]) {
666
        vp9_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
667 668 669 670 671
      }

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

John Koleszar's avatar
John Koleszar committed
675 676
        if (rf != LAST_FRAME) {
          if (mod_refprobs[2]) {
677
            vp9_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]);
John Koleszar's avatar
John Koleszar committed
678
          }
679
        }
John Koleszar's avatar
John Koleszar committed
680
      }
Paul Wilkins's avatar
Paul Wilkins committed
681
    }
John Koleszar's avatar
John Koleszar committed
682
  }
Paul Wilkins's avatar
Paul Wilkins committed
683

John Koleszar's avatar
John Koleszar committed
684 685
  // 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
686
}
John Koleszar's avatar
John Koleszar committed
687

688
// Update the probabilities used to encode reference frame data
689 690
static void update_ref_probs(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
691

John Koleszar's avatar
John Koleszar committed
692 693 694 695
  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];
696

John Koleszar's avatar
John Koleszar committed
697 698 699
  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]);
700

John Koleszar's avatar
John Koleszar committed
701 702
  // Compute a modified set of probabilities to use when prediction of the
  // reference frame fails
Paul Wilkins's avatar
Paul Wilkins committed
703
  vp9_compute_mod_refprobs(cm);
704 705
}

706
static void pack_inter_mode_mvs(VP9_COMP *const cpi, vp9_writer *const bc) {
707
  VP9_COMMON *const pc = &cpi->common;
708
  const nmv_context *nmvc = &pc->fc.nmvc;
John Koleszar's avatar
John Koleszar committed
709 710 711
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
  MODE_INFO *m;
  MODE_INFO *prev_m;
712 713
  TOKENEXTRA *tok = cpi->tok;
  TOKENEXTRA *tok_end = tok + cpi->tok_count;
714

John Koleszar's avatar
John Koleszar committed
715 716 717
  const int mis = pc->mode_info_stride;
  int mb_row, mb_col;
  int row, col;
John Koleszar's avatar
John Koleszar committed
718

John Koleszar's avatar
John Koleszar committed
719
  // Values used in prediction model coding
720
  vp9_prob pred_prob;
John Koleszar's avatar
John Koleszar committed
721
  unsigned char prediction_flag;
722

John Koleszar's avatar
John Koleszar committed
723 724
  int row_delta[4] = { 0, +1,  0, -1};
  int col_delta[4] = { +1, -1, +1, +1};
Adrian Grange's avatar
Adrian Grange committed
725

John Koleszar's avatar
John Koleszar committed
726
  cpi->mb.partition_info = cpi->mb.pi;
727

John Koleszar's avatar
John Koleszar committed
728 729 730 731 732 733 734 735 736 737 738
  mb_row = 0;
  for (row = 0; row < pc->mb_rows; row += 2) {
    m = pc->mi + row * mis;
    prev_m = pc->prev_mi + row * mis;

    mb_col = 0;
    for (col = 0; col < pc->mb_cols; col += 2) {
      int i;

      // Process the 4 MBs in the order:
      // top-left, top-right, bottom-left, bottom-right
Ronald S. Bultje's avatar
Ronald S. Bultje committed
739
#if CONFIG_SUPERBLOCKS
740
      vp9_write(bc, m->mbmi.encoded_as_sb, pc->sb_coded);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
741
#endif
John Koleszar's avatar
John Koleszar committed
742 743 744
      for (i = 0; i < 4; i++) {
        MB_MODE_INFO *mi;
        MV_REFERENCE_FRAME rf;
Deb Mukherjee's avatar
Deb Mukherjee committed
745
        MV_REFERENCE_FRAME sec_ref_frame;
John Koleszar's avatar
John Koleszar committed
746
        MB_PREDICTION_MODE mode;
747
        int segment_id, skip_coeff;
John Koleszar's avatar
John Koleszar committed
748 749 750 751 752 753 754 755 756 757 758 759 760 761

        int dy = row_delta[i];
        int dx = col_delta[i];
        int offset_extended = dy * mis + dx;

        if ((mb_row >= pc->mb_rows) || (mb_col >= pc->mb_cols)) {
          // MB lies outside frame, move on
          mb_row += dy;
          mb_col += dx;
          m += offset_extended;
          prev_m += offset_extended;
          cpi->mb.partition_info += offset_extended;
          continue;
        }
Adrian Grange's avatar
Adrian Grange committed
762

John Koleszar's avatar
John Koleszar committed
763
        mi = &m->mbmi;
John Koleszar's avatar
John Koleszar committed
764
        rf = mi->ref_frame;
Deb Mukherjee's avatar
Deb Mukherjee committed
765
        sec_ref_frame = mi->second_ref_frame;
John Koleszar's avatar
John Koleszar committed
766 767
        mode = mi->mode;
        segment_id = mi->segment_id;
768

John Koleszar's avatar
John Koleszar committed
769 770 771 772 773
        // 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;
774 775 776 777 778 779 780 781 782 783 784 785

#if CONFIG_SUPERBLOCKS
        if (mi->encoded_as_sb) {
          xd->mb_to_right_edge = ((pc->mb_cols - 2 - mb_col) * 16) << 3;
          xd->mb_to_bottom_edge = ((pc->mb_rows - 2 - mb_row) * 16) << 3;
        } else {
#endif
          xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
          xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
#if CONFIG_SUPERBLOCKS
        }
#endif
786

John Koleszar's avatar
John Koleszar committed
787 788 789
        // Make sure the MacroBlockD mode info pointer is set correctly
        xd->mode_info_context = m;
        xd->prev_mode_info_context = prev_m;
Paul Wilkins's avatar
Paul Wilkins committed
790

John Koleszar's avatar
John Koleszar committed
791
#ifdef ENTROPY_STATS
John Koleszar's avatar
John Koleszar committed
792
        active_section = 9;
John Koleszar's avatar
John Koleszar committed
793
#endif
John Koleszar's avatar
John Koleszar committed
794 795 796
        if (cpi->mb.e_mbd.update_mb_segmentation_map) {
          // Is temporal coding of the segment map enabled
          if (pc->temporal_update) {
Paul Wilkins's avatar
Paul Wilkins committed
797 798
            prediction_flag = vp9_get_pred_flag(xd, PRED_SEG_ID);
            pred_prob = vp9_get_pred_prob(pc, xd, PRED_SEG_ID);
799

John Koleszar's avatar
John Koleszar committed
800
            // Code the segment id prediction flag for this mb
801
            vp9_write(bc, prediction_flag, pred_prob);
802

John Koleszar's avatar
John Koleszar committed
803 804
            // If the mb segment id wasn't predicted code explicitly
            if (!prediction_flag)
John Koleszar's avatar
John Koleszar committed
805
              write_mb_segid(bc, mi, &cpi->mb.e_mbd);
John Koleszar's avatar
John Koleszar committed
806 807
          } else {
            // Normal unpredicted coding
John Koleszar's avatar
John Koleszar committed
808
            write_mb_segid(bc, mi, &cpi->mb.e_mbd);
John Koleszar's avatar
John Koleszar committed
809 810
          }
        }
John Koleszar's avatar
John Koleszar committed
811

812
        skip_coeff = 1;
John Koleszar's avatar
John Koleszar committed
813
        if (pc->mb_no_coeff_skip &&
814 815
            (!vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB) ||
             (vp9_get_segdata(xd, segment_id, SEG_LVL_EOB) != 0))) {
816
          skip_coeff = mi->mb_skip_coeff;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
817 818 819 820 821 822 823
#if CONFIG_SUPERBLOCKS
          if (mi->encoded_as_sb) {
            skip_coeff &= m[1].mbmi.mb_skip_coeff;
            skip_coeff &= m[mis].mbmi.mb_skip_coeff;
            skip_coeff &= m[mis + 1].mbmi.mb_skip_coeff;
          }
#endif
824 825
          vp9_write(bc, skip_coeff,
                    vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
John Koleszar's avatar
John Koleszar committed
826
        }
John Koleszar's avatar
John Koleszar committed
827

John Koleszar's avatar
John Koleszar committed
828
        // Encode the reference frame.
829 830 831 832 833 834
        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
835

John Koleszar's avatar
John Koleszar committed
836
        if (rf == INTRA_FRAME) {
837
#ifdef ENTROPY_STATS
John Koleszar's avatar
John Koleszar committed
838
          active_section = 6;
839
#endif
Paul Wilkins's avatar
Paul Wilkins committed
840

841
          if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)) {
842 843 844 845 846
#if CONFIG_SUPERBLOCKS
            if (m->mbmi.encoded_as_sb)
              write_sb_ymode(bc, mode, pc->fc.sb_ymode_prob);
            else
#endif
John Koleszar's avatar
John Koleszar committed
847
            write_ymode(bc, mode, pc->fc.ymode_prob);
John Koleszar's avatar
John Koleszar committed
848 849 850
          }
          if (mode == B_PRED) {
            int j = 0;
851
#if CONFIG_COMP_INTRA_PRED
John Koleszar's avatar
John Koleszar committed
852 853 854
            int uses_second =
              m->bmi[0].as_mode.second !=
              (B_PREDICTION_MODE)(B_DC_PRED - 1);
855
            vp9_write(bc, uses_second, DEFAULT_COMP_INTRA_PROB);
856
#endif
John Koleszar's avatar
John Koleszar committed
857
            do {
858
#if CONFIG_COMP_INTRA_PRED
John Koleszar's avatar
John Koleszar committed
859
              B_PREDICTION_MODE mode2 = m->bmi[j].as_mode.second;
860
#endif