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


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

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

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

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

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

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

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

#define SEARCH_NEWP
static int update_bits[255];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // Set the prediction probability structures to defaults
192
  if (cm->frame_type != KEY_FRAME) {
John Koleszar's avatar
John Koleszar committed
193
194
    // From the prediction counts set the probabilities for each context
    for (i = 0; i < PREDICTION_PROBS; i++) {
John Koleszar's avatar
John Koleszar committed
195
196
      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
197
198
199
200

      // Decide whether or not to update the reference frame probs.
      // Returned costs are in 1/256 bit units.
      old_cost =
201
202
        (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
203
204

      new_cost =
205
206
        (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
207
208
209
210
211
212
213

      // 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;
214
    }
John Koleszar's avatar
John Koleszar committed
215
  }
216
217
}

218
219
220
221
222
223
// 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
224
225
static void update_mode_probs(VP9_COMMON *cm,
                              int mode_context[INTER_MODE_CONTEXTS][4]) {
226
  int i, j;
Jim Bankoski's avatar
Jim Bankoski committed
227
  unsigned int (*mv_ref_ct)[4][2];
228
229
230
231
232
233
234
235

  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++) {
236
      int new_prob, old_cost, new_cost;
237
238
239

      // 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]);
240
      new_prob = get_binary_prob(mv_ref_ct[i][j][0], mv_ref_ct[i][j][1]);
241
242
243
244
245
246
247
248
249
250
251
      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;
      }
    }
  }
}
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301

#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

302
303
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
304
305
}

306
307
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
308
309
}

310
311
312
313
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);
}

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

318
319
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
320
}
Yaowu Xu's avatar
Yaowu Xu committed
321

322
323
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
324
325
326
}


327
static void write_bmode(vp9_writer *bc, int m, const vp9_prob *p) {
328
329
330
331
#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
332
  write_token(bc, vp9_bmode_tree, p, vp9_bmode_encodings + m);
John Koleszar's avatar
John Koleszar committed
333
334
}

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

339
static void write_split(vp9_writer *bc, int x, const vp9_prob *p) {
340
341
  write_token(
    bc, vp9_mbsplit_tree, p, vp9_mbsplit_encodings + x);
John Koleszar's avatar
John Koleszar committed
342
343
}

344
static int prob_update_savings(const unsigned int *ct,
345
346
347
348
349
                               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
350
  return (old_b - new_b - update_b);
351
352
}

353
static int prob_diff_update_savings(const unsigned int *ct,
354
355
356
357
                                    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
358
  const int update_b = (newp == oldp ? 0 :
359
                        prob_diff_update_cost(newp, oldp) + vp9_cost_upd256);
John Koleszar's avatar
John Koleszar committed
360
  return (old_b - new_b - update_b);
361
362
363
}

static int prob_diff_update_savings_search(const unsigned int *ct,
364
365
366
                                           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
367
  int new_b, update_b, savings, bestsavings, step;
368
  vp9_prob newp, bestnewp;
John Koleszar's avatar
John Koleszar committed
369
370
371
372
373
374

  bestsavings = 0;
  bestnewp = oldp;

  step = (*bestp > oldp ? -1 : 1);
  for (newp = *bestp; newp != oldp; newp += step) {
375
376
    new_b = cost_branch256(ct, newp);
    update_b = prob_diff_update_cost(newp, oldp) + vp9_cost_upd256;
John Koleszar's avatar
John Koleszar committed
377
378
379
380
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
381
    }
John Koleszar's avatar
John Koleszar committed
382
383
384
  }
  *bestp = bestnewp;
  return bestsavings;
385
386
}

387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
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);
  }
}

402
static void pack_mb_tokens(vp9_writer* const bc,
403
404
405
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
406

John Koleszar's avatar
John Koleszar committed
407
408
  while (p < stop) {
    const int t = p->Token;
409
410
    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
411
412
413
414
415
    int i = 0;
    const unsigned char *pp = p->context_tree;
    int v = a->value;
    int n = a->Len;

416
417
418
419
420
421
    if (t == EOSB_TOKEN)
    {
      ++p;
      break;
    }

John Koleszar's avatar
John Koleszar committed
422
423
424
425
426
    /* 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
427

John Koleszar's avatar
John Koleszar committed
428
429
    do {
      const int bb = (v >> --n) & 1;
430
      encode_bool(bc, bb, pp[i >> 1]);
431
      i = vp9_coef_tree[i + bb];
John Koleszar's avatar
John Koleszar committed
432
    } while (n);
John Koleszar's avatar
John Koleszar committed
433
434


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

John Koleszar's avatar
John Koleszar committed
438
439
440
441
442
      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
443

John Koleszar's avatar
John Koleszar committed
444
445
        do {
          const int bb = (v >> --n) & 1;
446
          encode_bool(bc, bb, pp[i >> 1]);
John Koleszar's avatar
John Koleszar committed
447
448
449
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
450

451
      encode_bool(bc, e & 1, 128);
John Koleszar's avatar
John Koleszar committed
452
    }
John Koleszar's avatar
John Koleszar committed
453
454
455
    ++p;
  }

456
  *tp = p;
John Koleszar's avatar
John Koleszar committed
457
458
}

John Koleszar's avatar
John Koleszar committed
459
460
static void write_partition_size(unsigned char *cx_data, int size) {
  signed char csize;
John Koleszar's avatar
John Koleszar committed
461

John Koleszar's avatar
John Koleszar committed
462
463
464
465
466
467
  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
468
469
470
471
472

}

static void write_mv_ref
(
473
  vp9_writer *bc, MB_PREDICTION_MODE m, const vp9_prob *p
John Koleszar's avatar
John Koleszar committed
474
) {
475
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
476
  assert(NEARESTMV <= m  &&  m <= SPLITMV);
477
#endif
478
479
  write_token(bc, vp9_mv_ref_tree, p,
              vp9_mv_ref_encoding_array - NEARESTMV + m);
John Koleszar's avatar
John Koleszar committed
480
481
}

482
483
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
484
485
486
#if CONFIG_DEBUG
  assert(NEARESTMV <= m  &&  m < SPLITMV);
#endif
487
488
  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
489
490
}

John Koleszar's avatar
John Koleszar committed
491
492
static void write_sub_mv_ref
(
493
  vp9_writer *bc, B_PREDICTION_MODE m, const vp9_prob *p
John Koleszar's avatar
John Koleszar committed
494
) {
495
#if CONFIG_DEBUG
John Koleszar's avatar
John Koleszar committed
496
  assert(LEFT4X4 <= m  &&  m <= NEW4X4);
497
#endif
498
499
  write_token(bc, vp9_sub_mv_ref_tree, p,
              vp9_sub_mv_ref_encoding_array - LEFT4X4 + m);
John Koleszar's avatar
John Koleszar committed
500
501
}

502
503
static void write_nmv(VP9_COMP *cpi, vp9_writer *bc,
                      const MV *mv, const int_mv *ref,
John Koleszar's avatar
John Koleszar committed
504
                      const nmv_context *nmvc, int usehp) {
505
506
507
508
  MV e;
  e.row = mv->row - ref->as_mv.row;
  e.col = mv->col - ref->as_mv.col;

509
510
  vp9_encode_nmv(bc, &e, &ref->as_mv, nmvc);
  vp9_encode_nmv_fp(bc, &e, &ref->as_mv, nmvc, usehp);
511
512
}

513
#if CONFIG_NEW_MVREF
514
515
static void vp9_write_mv_ref_id(vp9_writer *w,
                                vp9_prob * ref_id_probs,
516
517
518
519
                                int mv_ref_id) {
  // Encode the index for the MV reference.
  switch (mv_ref_id) {
    case 0:
520
      vp9_write(w, 0, ref_id_probs[0]);
521
522
      break;
    case 1:
523
524
      vp9_write(w, 1, ref_id_probs[0]);
      vp9_write(w, 0, ref_id_probs[1]);
525
526
      break;
    case 2:
527
528
529
      vp9_write(w, 1, ref_id_probs[0]);
      vp9_write(w, 1, ref_id_probs[1]);
      vp9_write(w, 0, ref_id_probs[2]);
530
531
      break;
    case 3:
532
533
534
      vp9_write(w, 1, ref_id_probs[0]);
      vp9_write(w, 1, ref_id_probs[1]);
      vp9_write(w, 1, ref_id_probs[2]);
535
536
537
538
539
540
541
542
543
544
      break;

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

Paul Wilkins's avatar
Paul Wilkins committed
545
546
// 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.
547
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
548
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
549
  // Encode the MB segment id.
Ronald S. Bultje's avatar
Ronald S. Bultje committed
550
  int seg_id = mi->segment_id;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
551

Paul Wilkins's avatar
Paul Wilkins committed
552
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
553
    switch (seg_id) {
John Koleszar's avatar
John Koleszar committed
554
      case 0:
555
556
        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
557
558
        break;
      case 1:
559
560
        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
561
562
        break;
      case 2:
563
564
        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
565
566
        break;
      case 3:
567
568
        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
569
570
571
572
        break;

        // TRAP.. This should not happen
      default:
573
574
        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
575
        break;
John Koleszar's avatar
John Koleszar committed
576
    }
John Koleszar's avatar
John Koleszar committed
577
  }
John Koleszar's avatar
John Koleszar committed
578
579
}

Paul Wilkins's avatar
Paul Wilkins committed
580
// This function encodes the reference frame
581
static void encode_ref_frame(vp9_writer *const bc,
582
                             VP9_COMMON *const cm,
John Koleszar's avatar
John Koleszar committed
583
584
585
586
587
                             MACROBLOCKD *xd,
                             int segment_id,
                             MV_REFERENCE_FRAME rf) {
  int seg_ref_active;
  int seg_ref_count = 0;
588
589
590
  seg_ref_active = vp9_segfeature_active(xd,
                                         segment_id,
                                         SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
591
592

  if (seg_ref_active) {
593
594
595
596
    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
597
598
599
600
601
602
603
  }

  // 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;
604
    vp9_prob pred_prob;
John Koleszar's avatar
John Koleszar committed
605
606
607
    MV_REFERENCE_FRAME pred_rf;

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

    // Get the predicted value.
Paul Wilkins's avatar
Paul Wilkins committed
611
    pred_rf = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
612
613
614
615
616

    // 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
617
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
618
    vp9_write(bc, prediction_flag, pred_prob);
John Koleszar's avatar
John Koleszar committed
619
620
621

    // If not predicted correctly then code value explicitly
    if (!prediction_flag) {
622
      vp9_prob mod_refprobs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
623
624
625
626
627
628
629
630

      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] *=
631
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
632
        mod_refprobs[LAST_FRAME] *=
633
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
634
        mod_refprobs[GOLDEN_FRAME] *=
635
636
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
637
638
639
      }

      if (mod_refprobs[0]) {
640
        vp9_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
641
642
643
644
645
      }

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

John Koleszar's avatar
John Koleszar committed
649
650
        if (rf != LAST_FRAME) {
          if (mod_refprobs[2]) {
651
            vp9_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]);
John Koleszar's avatar
John Koleszar committed
652
          }
653
        }
John Koleszar's avatar
John Koleszar committed
654
      }
Paul Wilkins's avatar
Paul Wilkins committed
655
    }
John Koleszar's avatar
John Koleszar committed
656
  }
Paul Wilkins's avatar
Paul Wilkins committed
657

John Koleszar's avatar
John Koleszar committed
658
659
  // 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
660
}
John Koleszar's avatar
John Koleszar committed
661

662
// Update the probabilities used to encode reference frame data
663
664
static void update_ref_probs(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
665

John Koleszar's avatar
John Koleszar committed
666
667
668
669
  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];
670

John Koleszar's avatar
John Koleszar committed
671
672
673
  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]);
674

John Koleszar's avatar
John Koleszar committed
675
676
  // Compute a modified set of probabilities to use when prediction of the
  // reference frame fails
Paul Wilkins's avatar
Paul Wilkins committed
677
  vp9_compute_mod_refprobs(cm);
678
679
}

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

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
700
701
702
703
704
705
706
  // 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;
707

Ronald S. Bultje's avatar
Ronald S. Bultje committed
708
709
#ifdef ENTROPY_STATS
  active_section = 9;
710
#endif
711

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

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
721
722
723
724
725
726
727
728
      // 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);
    }
  }
729

Ronald S. Bultje's avatar
Ronald S. Bultje committed
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
  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
747

Ronald S. Bultje's avatar
Ronald S. Bultje committed
748
749
750
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
751

Ronald S. Bultje's avatar
Ronald S. Bultje committed
752
753
754
755
756
757
758
  // 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
759

Ronald S. Bultje's avatar
Ronald S. Bultje committed
760
  if (rf == INTRA_FRAME) {
761
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
762
    active_section = 6;
763
#endif
Paul Wilkins's avatar
Paul Wilkins committed
764

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

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

John Koleszar's avatar
John Koleszar committed
796
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
797
798
    accum_mv_refs(mode, ct);
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
799
800
#endif

Ronald S. Bultje's avatar
Ronald S. Bultje committed
801
802
803
804
    // Is the segment coding of mode enabled
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_MODE)) {
      if (mi->sb_type) {
        write_sb_mv_ref(bc, mode, mv_ref_p);
805
      } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
806
807
808
809
        write_mv_ref(bc, mode, mv_ref_p);
      }
      vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
    }
810

Ronald S. Bultje's avatar
Ronald S. Bultje committed
811
812
813
814
815
816
817
818
819
820
821
    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);
      }
    }
822

Ronald S. Bultje's avatar
Ronald S. Bultje committed
823
824
825
826
827
828
    // 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));
    }
829
#if CONFIG_COMP_INTERINTRA_PRED
Ronald S. Bultje's avatar
Ronald S. Bultje committed
830
831
832
833
834
835
836
837
838
839
840
841
842
    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);
843
#if SEPARATE_INTERINTRA_UV
Ronald S. Bultje's avatar
Ronald S. Bultje committed
844
845
        write_uv_mode(bc, mi->interintra_uv_mode,
                      pc->fc.uv_mode_prob[mi->interintra_mode]);
846
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
847
848
      }
    }
849
#endif
John Koleszar's avatar
John Koleszar committed
850

851
#if CONFIG_NEW_MVREF
Ronald S. Bultje's avatar
Ronald S. Bultje committed
852
853
854
855
856
857
858
859
860
861
862
863
864
    // 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);
      }
    }
865
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
866
867
868

    switch (mode) { /* new, split require MVs */
      case NEWMV:
869
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
870
        active_section = 5;
871
#endif
872
        write_nmv(cpi, bc, &mi->mv[0].as_mv, &mi->best_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
873
874
                  (const nmv_context*) nmvc,
                  xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
875

Ronald S. Bultje's avatar
Ronald S. Bultje committed
876
        if (mi->second_ref_frame > 0) {
877
          write_nmv(cpi, bc, &mi->mv[1].as_mv, &mi->best_second_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
878
879
880
881
882
883
                    (const nmv_context*) nmvc,
                    xd->allow_high_precision_mv);
        }
        break;
      case SPLITMV: {
        int j = 0;
John Koleszar's avatar
John Koleszar committed
884

885
#ifdef MODE_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
886
        ++count_mb_seg[mi->partitioning];
887
#endif
John Koleszar's avatar
John Koleszar committed
888

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
892
893
894
895
896
897
898
899
900
901
        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;
902
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
903
904
905
          while (j != L[++k])
            if (k >= 16)
              assert(0);
906
#else
Ronald S. Bultje's avatar
Ronald S. Bultje committed
907
          while (j != L[++k]);
908
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
909
910
911
          leftmv.as_int = left_block_mv(m, k);
          abovemv.as_int = above_block_mv(m, k, mis);
          mv_contz = vp9_mv_cont(&leftmv, &abovemv);
912

Ronald S. Bultje's avatar
Ronald S. Bultje committed
913
914
915
916
          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) {
917
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
918
919
            active_section = 11;
#endif
920
            write_nmv(cpi, bc, &blockmv.as_mv, &mi->best_mv,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
921
922
923
924
                      (const nmv_context*) nmvc,
                      xd->allow_high_precision_mv);

            if (mi->second_ref_frame > 0) {
925
              write_nmv(cpi, bc,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
926
927
928
929
                        &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
930
            }
John Koleszar's avatar
John Koleszar committed
931
          }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
932
933
934
935
936
937
938
        } while (++j < cpi->mb.partition_info->count);
        break;
      }
      default:
        break;
    }
  }
John Koleszar's avatar
John Koleszar committed
939

Ronald S. Bultje's avatar
Ronald S. Bultje committed
940
941
942
943
944
945
946
947
948
949
950
951
952
953
  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]);
      if (mi->sb_type && sz != TX_8X8)
        vp9_write(bc, sz != TX_16X16, pc->prob_tx[2]);
John Koleszar's avatar
John Koleszar committed
954
    }
John Koleszar's avatar
John Koleszar committed
955
  }
John Koleszar's avatar
John Koleszar committed
956
}
957

Ronald S. Bultje's avatar
Ronald S. Bultje committed
958
959
960
961
962
963
964
965
966
967
static void write_mb_modes_kf(const VP9_COMP *cpi,
                              const MODE_INFO *m,
                              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;
968
969
970
971
972

  if (xd->update_mb_segmentation_map) {
    write_mb_segid(bc, &m->mbmi, xd);
  }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
  if (!c->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 = 1 << m->mbmi.sb_type;
    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;
      }
    }

    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(c, xd, PRED_MBSKIP));
993
994
  }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
995
  if (m->mbmi.sb_type) {
996
997
    sb_kfwrite_ymode(bc, ym,
                     c->sb_kf_ymode_prob[c->kf_ymode_probs_index]);
998
  } else {
999
1000
    kfwrite_ymode(bc, ym,
                  c->kf_ymode_prob[c->kf_ymode_probs_index]);