vp9_bitstream.c 80.3 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]);
540
        vp9_write(bc, 0, xd->mb_segment_tree_probs[2]);
John Koleszar's avatar
John Koleszar committed
541
542
        break;
      case 1:
543
        vp9_write(bc, 0, xd->mb_segment_tree_probs[0]);
544
545
        vp9_write(bc, 0, xd->mb_segment_tree_probs[1]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[2]);
John Koleszar's avatar
John Koleszar committed
546
547
        break;
      case 2:
548
549
550
        vp9_write(bc, 0, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[1]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[3]);
John Koleszar's avatar
John Koleszar committed
551
552
        break;
      case 3:
553
554
555
556
557
        vp9_write(bc, 0, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[1]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[3]);
        break;
      case 4:
558
        vp9_write(bc, 1, xd->mb_segment_tree_probs[0]);
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
        vp9_write(bc, 0, xd->mb_segment_tree_probs[4]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[5]);
        break;
      case 5:
        vp9_write(bc, 1, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[4]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[5]);
        break;
      case 6:
        vp9_write(bc, 1, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[4]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[6]);
        break;
      case 7:
        vp9_write(bc, 1, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[4]);
        vp9_write(bc, 1, xd->mb_segment_tree_probs[6]);
John Koleszar's avatar
John Koleszar committed
576
577
578
579
        break;

        // TRAP.. This should not happen
      default:
580
581
        vp9_write(bc, 0, xd->mb_segment_tree_probs[0]);
        vp9_write(bc, 0, xd->mb_segment_tree_probs[1]);
582
        vp9_write(bc, 0, xd->mb_segment_tree_probs[2]);
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
  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;
700
701
  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
702
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
703

Ronald S. Bultje's avatar
Ronald S. Bultje committed
704
705
706
707
  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);
708

Ronald S. Bultje's avatar
Ronald S. Bultje committed
709
710
711
  // 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
712

713
  set_mb_row_col(pc, xd, mb_row, bh, mb_col, bw);
714

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
719
720
721
722
723
  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
724

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

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

737
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
738
739
    skip_coeff = 1;
  } else {
740
    skip_coeff = m->mbmi.mb_skip_coeff;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
741
742
743
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
744

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
748
  if (rf == INTRA_FRAME) {
749
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
750
    active_section = 6;
751
#endif
Paul Wilkins's avatar
Paul Wilkins committed
752

753
    if (m->mbmi.sb_type > BLOCK_SIZE_MB16X16)
Paul Wilkins's avatar
Paul Wilkins committed
754
755
756
757
      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
758
    if (mode == I4X4_PRED) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
      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];
780

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

John Koleszar's avatar
John Koleszar committed
783
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
784
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
785
786
#endif

787
    // If segment skip is not enabled code the mode.
Paul Wilkins's avatar
Paul Wilkins committed
788
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
789
      if (mi->sb_type > BLOCK_SIZE_MB16X16) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
790
        write_sb_mv_ref(bc, mode, mv_ref_p);
791
      } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
792
793
794
795
        write_mv_ref(bc, mode, mv_ref_p);
      }
      vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
    }
796

797
    if (is_inter_mode(mode)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
798
799
800
801
802
803
804
805
806
807
      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);
      }
    }
808

Ronald S. Bultje's avatar
Ronald S. Bultje committed
809
810
811
812
813
814
    // 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));
    }
815
#if CONFIG_COMP_INTERINTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
816
817
818
819
820
821
822
823
824
825
826
827
828
    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);
829
#if SEPARATE_INTERINTRA_UV
Ronald S. Bultje's avatar
Ronald S. Bultje committed
830
831
        write_uv_mode(bc, mi->interintra_uv_mode,
                      pc->fc.uv_mode_prob[mi->interintra_mode]);
832
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
833
834
      }
    }
835
#endif
John Koleszar's avatar
John Koleszar committed
836

Ronald S. Bultje's avatar
Ronald S. Bultje committed
837
838
    switch (mode) { /* new, split require MVs */
      case NEWMV:
839
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
840
        active_section = 5;
841
#endif
842
        write_nmv(cpi, bc, &mi->mv[0].as_mv, &mi->best_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
843
844
                  (const nmv_context*) nmvc,
                  xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
845

Ronald S. Bultje's avatar
Ronald S. Bultje committed
846
        if (mi->second_ref_frame > 0) {
847
          write_nmv(cpi, bc, &mi->mv[1].as_mv, &mi->best_second_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
848
849
850
851
852
853
                    (const nmv_context*) nmvc,
                    xd->allow_high_precision_mv);
        }
        break;
      case SPLITMV: {
        int j = 0;
John Koleszar's avatar
John Koleszar committed
854

855
#ifdef MODE_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
856
        ++count_mb_seg[mi->partitioning];
857
#endif
John Koleszar's avatar
John Koleszar committed
858

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
862
863
864
865
866
867
868
869
870
871
        do {
          B_PREDICTION_MODE blockmode;
          int_mv blockmv;
          const int *const  L = vp9_mbsplits[mi->partitioning];
          int k = -1;  /* first block in subset j */
          int mv_contz;
          int_mv leftmv, abovemv;

          blockmode = cpi->mb.partition_info->bmi[j].mode;
          blockmv = cpi->mb.partition_info->bmi[j].mv;
872
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
873
874
875
          while (j != L[++k])
            if (k >= 16)
              assert(0);
876
#else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
877
          while (j != L[++k]);
878
#endif
879
          leftmv.as_int = left_block_mv(xd, m, k);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
880
881
          abovemv.as_int = above_block_mv(m, k, mis);
          mv_contz = vp9_mv_cont(&leftmv, &abovemv);
882

Ronald S. Bultje's avatar
Ronald S. Bultje committed
883
884
885
886
          write_sub_mv_ref(bc, blockmode,
                           cpi->common.fc.sub_mv_ref_prob[mv_contz]);
          cpi->sub_mv_ref_count[mv_contz][blockmode - LEFT4X4]++;
          if (blockmode == NEW4X4) {
887
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
888
889
            active_section = 11;
#endif
890
            write_nmv(cpi, bc, &blockmv.as_mv, &mi->best_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
891
892
893
894
                      (const nmv_context*) nmvc,
                      xd->allow_high_precision_mv);

            if (mi->second_ref_frame > 0) {
895
              write_nmv(cpi, bc,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
896
897
898
899
                        &cpi->mb.partition_info->bmi[j].second_mv.as_mv,
                        &mi->best_second_mv,
                        (const nmv_context*) nmvc,
                        xd->allow_high_precision_mv);
Adrian Grange's avatar
Adrian Grange committed
900
            }
John Koleszar's avatar
John Koleszar committed
901
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
902
903
904
905
906
907
908
        } while (++j < cpi->mb.partition_info->count);
        break;
      }
      default:
        break;
    }
  }
John Koleszar's avatar
John Koleszar committed
909

Ronald S. Bultje's avatar
Ronald S. Bultje committed
910
911
912
913
  if (((rf == INTRA_FRAME && mode <= I8X8_PRED) ||
       (rf != INTRA_FRAME && !(mode == SPLITMV &&
                               mi->partitioning == PARTITIONING_4X4))) &&
      pc->txfm_mode == TX_MODE_SELECT &&
914
915
          !(skip_coeff || vp9_segfeature_active(xd, segment_id,
                                                SEG_LVL_SKIP))) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
916
917
918
919
920
    TX_SIZE sz = mi->txfm_size;
    // FIXME(rbultje) code ternary symbol once all experiments are merged
    vp9_write(bc, sz != TX_4X4, pc->prob_tx[0]);
    if (sz != TX_4X4 && mode != I8X8_PRED && mode != SPLITMV) {
      vp9_write(bc, sz != TX_8X8, pc->prob_tx[1]);
921
      if (mi->sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
922
        vp9_write(bc, sz != TX_16X16, pc->prob_tx[2]);
John Koleszar's avatar
John Koleszar committed
923
    }
John Koleszar's avatar
John Koleszar committed
924
  }
John Koleszar's avatar
John Koleszar committed
925
}
926

Ronald S. Bultje's avatar
Ronald S. Bultje committed
927
static void write_mb_modes_kf(const VP9_COMP *cpi,
928
                              MODE_INFO *m,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
929
930
931
932
933
934
935
936
                              vp9_writer *bc,
                              int mb_rows_left, int mb_cols_left) {
  const VP9_COMMON *const c = &cpi->common;
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
  const int mis = c->mode_info_stride;
  const int ym = m->mbmi.mode;
  const int segment_id = m->mbmi.segment_id;
  int skip_coeff;