vp9_bitstream.c 70.8 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9
10
11
 */


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

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

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

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

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

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

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

#define SEARCH_NEWP
static int update_bits[255];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

John Koleszar's avatar
John Koleszar committed
145
    update_mode(
146
      bc, VP9_YMODES, vp9_ymode_encodings, vp9_ymode_tree,
Paul Wilkins's avatar
Paul Wilkins committed
147
      Pnew, cm->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
John Koleszar's avatar
John Koleszar committed
148
    );
149
150
151
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
  int seg_id = mi->segment_id;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
565

Paul Wilkins's avatar
Paul Wilkins committed
566
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
567
    switch (seg_id) {
John Koleszar's avatar
John Koleszar committed
568
      case 0:
569
570
        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
571
572
        break;
      case 1:
573
574
        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
575
576
        break;
      case 2:
577
578
        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
579
580
        break;
      case 3:
581
582
        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
583
584
585
586
        break;

        // TRAP.. This should not happen
      default:
587
588
        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
589
        break;
John Koleszar's avatar
John Koleszar committed
590
    }
John Koleszar's avatar
John Koleszar committed
591
  }
John Koleszar's avatar
John Koleszar committed
592
593
}

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

  if (seg_ref_active) {
607
608
609
610
    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
611
612
613
614
615
616
617
  }

  // 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;
618
    vp9_prob pred_prob;
John Koleszar's avatar
John Koleszar committed
619
620
621
    MV_REFERENCE_FRAME pred_rf;

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

    // Get the predicted value.
Paul Wilkins's avatar
Paul Wilkins committed
625
    pred_rf = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
626
627
628
629
630

    // 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
631
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
632
    vp9_write(bc, prediction_flag, pred_prob);
John Koleszar's avatar
John Koleszar committed
633
634
635

    // If not predicted correctly then code value explicitly
    if (!prediction_flag) {
636
      vp9_prob mod_refprobs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
637
638
639
640
641
642
643
644

      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] *=
645
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
646
        mod_refprobs[LAST_FRAME] *=
647
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
648
        mod_refprobs[GOLDEN_FRAME] *=
649
650
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
651
652
653
      }

      if (mod_refprobs[0]) {
654
        vp9_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
655
656
657
658
659
      }

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

John Koleszar's avatar
John Koleszar committed
663
664
        if (rf != LAST_FRAME) {
          if (mod_refprobs[2]) {
665
            vp9_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]);
John Koleszar's avatar
John Koleszar committed
666
          }
667
        }
John Koleszar's avatar
John Koleszar committed
668
      }
Paul Wilkins's avatar
Paul Wilkins committed
669
    }
John Koleszar's avatar
John Koleszar committed
670
  }
Paul Wilkins's avatar
Paul Wilkins committed
671

John Koleszar's avatar
John Koleszar committed
672
673
  // 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
674
}
John Koleszar's avatar
John Koleszar committed
675

676
// Update the probabilities used to encode reference frame data
677
678
static void update_ref_probs(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
679

John Koleszar's avatar
John Koleszar committed
680
681
682
683
  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];
684

John Koleszar's avatar
John Koleszar committed
685
686
687
  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]);
688

John Koleszar's avatar
John Koleszar committed
689
690
  // Compute a modified set of probabilities to use when prediction of the
  // reference frame fails
Paul Wilkins's avatar
Paul Wilkins committed
691
  vp9_compute_mod_refprobs(cm);
692
693
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
694
695
696
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
                                vp9_writer *bc,
                                int mb_rows_left, int mb_cols_left) {
697
  VP9_COMMON *const pc = &cpi->common;
698
  const nmv_context *nmvc = &pc->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
699
700
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
701
  const int mis = pc->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
702
703
704
705
  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;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
706
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
707
708
709
710
711
  const int mb_size = 1 << mi->sb_type;
#else
  const int mb_size = 1;
#endif
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
712

Ronald S. Bultje's avatar
Ronald S. Bultje committed
713
714
715
716
  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);
717

Ronald S. Bultje's avatar
Ronald S. Bultje committed
718
719
720
721
722
723
724
  // Distance of Mb to the various image edges.
  // These specified to 8th pel as they are always compared to MV
  // values that are in 1/8th pel units
  xd->mb_to_left_edge = -((mb_col * 16) << 3);
  xd->mb_to_top_edge = -((mb_row * 16)) << 3;
  xd->mb_to_right_edge = ((pc->mb_cols - mb_size - mb_col) * 16) << 3;
  xd->mb_to_bottom_edge = ((pc->mb_rows - mb_size - mb_row) * 16) << 3;
725

Ronald S. Bultje's avatar
Ronald S. Bultje committed
726
727
#ifdef ENTROPY_STATS
  active_section = 9;
728
#endif
729

Ronald S. Bultje's avatar
Ronald S. Bultje committed
730
731
732
733
734
  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
735

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
739
740
741
742
743
744
745
746
      // If the mb segment id wasn't predicted code explicitly
      if (!prediction_flag)
        write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    } else {
      // Normal unpredicted coding
      write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    }
  }
747

Ronald S. Bultje's avatar
Ronald S. Bultje committed
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
  if (!pc->mb_no_coeff_skip) {
    skip_coeff = 0;
  } else if (vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB) &&
             vp9_get_segdata(xd, segment_id, SEG_LVL_EOB) == 0) {
    skip_coeff = 1;
  } else {
    const int nmbs = mb_size;
    const int xmbs = MIN(nmbs, mb_cols_left);
    const int ymbs = MIN(nmbs, mb_rows_left);
    int x, y;

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
766
767
768
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
769

Ronald S. Bultje's avatar
Ronald S. Bultje committed
770
771
772
773
774
775
776
  // Encode the reference frame.
  if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)
      || vp9_get_segdata(xd, segment_id, SEG_LVL_MODE) >= NEARESTMV) {
    encode_ref_frame(bc, pc, xd, segment_id, rf);
  } else {
    assert(rf == INTRA_FRAME);
  }
Paul Wilkins's avatar
Paul Wilkins committed
777

Ronald S. Bultje's avatar
Ronald S. Bultje committed
778
  if (rf == INTRA_FRAME) {
779
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
780
    active_section = 6;
781
#endif
Paul Wilkins's avatar
Paul Wilkins committed
782

Ronald S. Bultje's avatar
Ronald S. Bultje committed
783
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)) {
784
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
785
786
787
      if (m->mbmi.sb_type)
        write_sb_ymode(bc, mode, pc->fc.sb_ymode_prob);
      else
788
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
789
790
791
792
        write_ymode(bc, mode, pc->fc.ymode_prob);
    }
    if (mode == B_PRED) {
      int j = 0;
793
#if CONFIG_COMP_INTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
794
795
796
797
      int uses_second =
      m->bmi[0].as_mode.second !=
      (B_PREDICTION_MODE)(B_DC_PRED - 1);
      vp9_write(bc, uses_second, DEFAULT_COMP_INTRA_PROB);
798
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
799
      do {
800
#if CONFIG_COMP_INTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
801
        B_PREDICTION_MODE mode2 = m->bmi[j].as_mode.second;
802
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
803
804
        write_bmode(bc, m->bmi[j].as_mode.first,
                    pc->fc.bmode_prob);
805
#if CONFIG_COMP_INTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
806
807
808
        if (uses_second) {
          write_bmode(bc, mode2, pc->fc.bmode_prob);
        }
John Koleszar's avatar
John Koleszar committed
809
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
      } 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];
827

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
830
    // #ifdef ENTROPY_STATS
John Koleszar's avatar
John Koleszar committed
831
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
832
833
    accum_mv_refs(mode, ct);
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
834
835
#endif

Ronald S. Bultje's avatar
Ronald S. Bultje committed
836
837
    // Is the segment coding of mode enabled
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
838
#if CONFIG_SUPERBLOCKS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
839
840
841
      if (mi->sb_type) {
        write_sb_mv_ref(bc, mode, mv_ref_p);
      } else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
842
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
843
844
845
846
847
      {
        write_mv_ref(bc, mode, mv_ref_p);
      }
      vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
    }
848

849
#if CONFIG_PRED_FILTER
Ronald S. Bultje's avatar
Ronald S. Bultje committed
850
851
852
853
854
855
856
857
858
    // Is the prediction filter enabled
    if (mode >= NEARESTMV && mode < SPLITMV) {
      if (cpi->common.pred_filter_mode == 2)
        vp9_write(bc, mi->pred_filter_enabled,
                  pc->prob_pred_filter_off);
      else
        assert(mi->pred_filter_enabled ==
               cpi->common.pred_filter_mode);
    }
859
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
860
861
862
863
864
865
866
867
868
869
870
    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);
      }
    }
871

Ronald S. Bultje's avatar
Ronald S. Bultje committed
872
873
874
875
876
877
    // 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));
    }
878
#if CONFIG_COMP_INTERINTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
879
880
881
882
883
884
885
886
887
888
889
890
891
    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);
892
#if SEPARATE_INTERINTRA_UV
Ronald S. Bultje's avatar
Ronald S. Bultje committed
893
894
        write_uv_mode(bc, mi->interintra_uv_mode,
                      pc->fc.uv_mode_prob[mi->interintra_mode]);
895
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
896
897
      }
    }
898
#endif
John Koleszar's avatar
John Koleszar committed
899

900
#if CONFIG_NEW_MVREF
Ronald S. Bultje's avatar
Ronald S. Bultje committed
901
902
903
904
905
906
907
908
909
910
911
912
913
    // if ((mode == NEWMV) || (mode == SPLITMV)) {
    if (mode == NEWMV) {
      // Encode the index of the choice.
      vp9_write_mv_ref_id(bc,
                          xd->mb_mv_ref_probs[rf], mi->best_index);

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

    switch (mode) { /* new, split require MVs */
      case NEWMV:
918
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
919
        active_section = 5;
920
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
921
922
923
        write_nmv(bc, &mi->mv[0].as_mv, &mi->best_mv,
                  (const nmv_context*) nmvc,
                  xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
924

Ronald S. Bultje's avatar
Ronald S. Bultje committed
925
926
927
928
929
930
931
932
        if (mi->second_ref_frame > 0) {
          write_nmv(bc, &mi->mv[1].as_mv, &mi->best_second_mv,
                    (const nmv_context*) nmvc,
                    xd->allow_high_precision_mv);
        }
        break;
      case SPLITMV: {
        int j = 0;
John Koleszar's avatar
John Koleszar committed
933

934
#ifdef MODE_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
935
        ++count_mb_seg[mi->partitioning];
936
#endif
John Koleszar's avatar
John Koleszar committed
937

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
941
942
943
944
945
946
947
948
949
950
        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;
951
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
952
953
954
          while (j != L[++k])
            if (k >= 16)
              assert(0);
955
#else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
956
          while (j != L[++k]);
957
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
958
959
960
          leftmv.as_int = left_block_mv(m, k);
          abovemv.as_int = above_block_mv(m, k, mis);
          mv_contz = vp9_mv_cont(&leftmv, &abovemv);
961

Ronald S. Bultje's avatar
Ronald S. Bultje committed
962
963
964
965
          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) {
966
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
967
968
969
970
971
972
973
974
975
976
977
978
            active_section = 11;
#endif
            write_nmv(bc, &blockmv.as_mv, &mi->best_mv,
                      (const nmv_context*) nmvc,
                      xd->allow_high_precision_mv);

            if (mi->second_ref_frame > 0) {
              write_nmv(bc,
                        &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
979
            }
John Koleszar's avatar
John Koleszar committed
980
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
981
982
983
984
985
986
987
        } while (++j < cpi->mb.partition_info->count);
        break;
      }
      default:
        break;
    }
  }
John Koleszar's avatar
John Koleszar committed
988

Ronald S. Bultje's avatar
Ronald S. Bultje committed
989
990
991
992
993
994
995
996
997
998
999
1000
  if (((rf == INTRA_FRAME && mode <= I8X8_PRED) ||
       (rf != INTRA_FRAME && !(mode == SPLITMV &&
                               mi->partitioning == PARTITIONING_4X4))) &&
      pc->txfm_mode == TX_MODE_SELECT &&
      !((pc->mb_no_coeff_skip && skip_coeff) ||
        (vp9_segfeature_active(xd, segment_id, SEG_LVL_EOB) &&
         vp9_get_segdata(xd, segment_id, SEG_LVL_EOB) == 0))) {
    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]);