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

11
12
13
#include <assert.h>
#include <stdio.h>
#include <limits.h>
John Koleszar's avatar
John Koleszar committed
14

15
16
17
#include "vpx/vpx_encoder.h"
#include "vpx_mem/vpx_mem.h"

18
#include "vp9/common/vp9_entropymode.h"
19
#include "vp9/common/vp9_entropymv.h"
20
#include "vp9/common/vp9_findnearmv.h"
21
#include "vp9/common/vp9_tile_common.h"
22
23
24
25
26
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_entropy.h"
#include "vp9/common/vp9_entropymv.h"
#include "vp9/common/vp9_mvref_common.h"
27
#include "vp9/common/vp9_treecoder.h"
28
29
30
31
32
33
34
35
36
#include "vp9/common/vp9_systemdependent.h"
#include "vp9/common/vp9_pragmas.h"

#include "vp9/encoder/vp9_mcomp.h"
#include "vp9/encoder/vp9_encodemv.h"
#include "vp9/encoder/vp9_bitstream.h"
#include "vp9/encoder/vp9_segmentation.h"
#include "vp9/encoder/vp9_write_bit_buffer.h"

Paul Wilkins's avatar
Paul Wilkins committed
37

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

#ifdef ENTROPY_STATS
43
44
45
int intra_mode_stats[VP9_INTRA_MODES]
                    [VP9_INTRA_MODES]
                    [VP9_INTRA_MODES];
46
vp9_coeff_stats tree_update_hist[TX_SIZE_MAX_SB][BLOCK_TYPES];
47

John Koleszar's avatar
John Koleszar committed
48
49
50
extern unsigned int active_section;
#endif

51
52
#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)))
53
54
55

static int update_bits[255];

56
57
58
59
60
61
62
static INLINE void write_le32(uint8_t *p, int value) {
  p[0] = value;
  p[1] = value >> 8;
  p[2] = value >> 16;
  p[3] = value >> 24;
}

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
void vp9_encode_unsigned_max(vp9_writer *br, int data, int max) {
  assert(data <= max);
  while (max) {
    vp9_write_bit(br, data & 1);
    data >>= 1;
    max >>= 1;
  }
}

int recenter_nonneg(int v, int m) {
  if (v > (m << 1))
    return v;
  else if (v >= m)
    return ((v - m) << 1);
  else
    return ((m - v) << 1) - 1;
}

static int get_unsigned_bits(unsigned num_values) {
  int cat = 0;
  if ((num_values--) <= 1) return 0;
  while (num_values > 0) {
    cat++;
    num_values >>= 1;
  }
  return cat;
}

void encode_uniform(vp9_writer *w, int v, int n) {
  int l = get_unsigned_bits(n);
  int m;
  if (l == 0)
    return;
  m = (1 << l) - n;
  if (v < m) {
    vp9_write_literal(w, v, l - 1);
  } else {
    vp9_write_literal(w, m + ((v - m) >> 1), l - 1);
    vp9_write_literal(w, (v - m) & 1, 1);
  }
}

int count_uniform(int v, int n) {
  int l = get_unsigned_bits(n);
  int m;
  if (l == 0) return 0;
  m = (1 << l) - n;
  if (v < m)
    return l - 1;
  else
    return l;
}

void encode_term_subexp(vp9_writer *w, int word, int k, int num_syms) {
  int i = 0;
  int mk = 0;
  while (1) {
    int b = (i ? k + i - 1 : k);
    int a = (1 << b);
    if (num_syms <= mk + 3 * a) {
      encode_uniform(w, word - mk, num_syms - mk);
      break;
    } else {
      int t = (word >= mk + a);
      vp9_write_literal(w, t, 1);
      if (t) {
        i = i + 1;
        mk += a;
      } else {
        vp9_write_literal(w, word - mk, b);
        break;
      }
    }
  }
}

int count_term_subexp(int word, int k, int num_syms) {
  int count = 0;
  int i = 0;
  int mk = 0;
  while (1) {
    int b = (i ? k + i - 1 : k);
    int a = (1 << b);
    if (num_syms <= mk + 3 * a) {
      count += count_uniform(word - mk, num_syms - mk);
      break;
    } else {
      int t = (word >= mk + a);
      count++;
      if (t) {
        i = i + 1;
        mk += a;
      } else {
        count += b;
        break;
      }
    }
  }
  return count;
}

John Koleszar's avatar
John Koleszar committed
164
165
166
static void compute_update_table() {
  int i;
  for (i = 0; i < 255; i++)
167
    update_bits[i] = count_term_subexp(i, SUBEXP_PARAM, 255);
168
169
}

John Koleszar's avatar
John Koleszar committed
170
171
172
173
174
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;
175
176
}

John Koleszar's avatar
John Koleszar committed
177
178
179
180
181
static int remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
  int i;
  if ((m << 1) <= n)
182
    i = recenter_nonneg(v, m) - 1;
John Koleszar's avatar
John Koleszar committed
183
  else
184
    i = recenter_nonneg(n - 1 - v, n - 1 - m) - 1;
John Koleszar's avatar
John Koleszar committed
185
186
187

  i = split_index(i, n - 1, modulus);
  return i;
188
}
189

190
static void write_prob_diff_update(vp9_writer *w,
191
                                   vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
192
  int delp = remap_prob(newp, oldp);
193
  encode_term_subexp(w, delp, SUBEXP_PARAM, 255);
194
195
}

196
static int prob_diff_update_cost(vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
197
198
  int delp = remap_prob(newp, oldp);
  return update_bits[delp] * 256;
199
}
200

201
static int prob_update_savings(const unsigned int *ct,
202
203
204
205
206
                               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;
207
  return old_b - new_b - update_b;
208
209
210
}

static int prob_diff_update_savings_search(const unsigned int *ct,
211
212
213
                                           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
214
  int new_b, update_b, savings, bestsavings, step;
215
  vp9_prob newp, bestnewp;
John Koleszar's avatar
John Koleszar committed
216
217
218
219
220
221

  bestsavings = 0;
  bestnewp = oldp;

  step = (*bestp > oldp ? -1 : 1);
  for (newp = *bestp; newp != oldp; newp += step) {
222
223
    new_b = cost_branch256(ct, newp);
    update_b = prob_diff_update_cost(newp, oldp) + vp9_cost_upd256;
John Koleszar's avatar
John Koleszar committed
224
225
226
227
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
228
    }
John Koleszar's avatar
John Koleszar committed
229
230
231
  }
  *bestp = bestnewp;
  return bestsavings;
232
233
}

234
235
236
237
static int prob_diff_update_savings_search_model(const unsigned int *ct,
                                                 const vp9_prob *oldp,
                                                 vp9_prob *bestp,
                                                 const vp9_prob upd,
238
                                                 int b, int r) {
239
240
  int i, old_b, new_b, update_b, savings, bestsavings, step;
  int newp;
241
  vp9_prob bestnewp, newplist[ENTROPY_NODES], oldplist[ENTROPY_NODES];
242
243
  vp9_model_to_full_probs(oldp, oldplist);
  vpx_memcpy(newplist, oldp, sizeof(vp9_prob) * UNCONSTRAINED_NODES);
244
245
246
  for (i = UNCONSTRAINED_NODES, old_b = 0; i < ENTROPY_NODES; ++i)
    old_b += cost_branch256(ct + 2 * i, oldplist[i]);
  old_b += cost_branch256(ct + 2 * PIVOT_NODE, oldplist[PIVOT_NODE]);
247
248

  bestsavings = 0;
249
  bestnewp = oldp[PIVOT_NODE];
250

251
  step = (*bestp > oldp[PIVOT_NODE] ? -1 : 1);
252
  newp = *bestp;
253
  for (; newp != oldp[PIVOT_NODE]; newp += step) {
254
    if (newp < 1 || newp > 255) continue;
255
    newplist[PIVOT_NODE] = newp;
256
    vp9_model_to_full_probs(newplist, newplist);
257
    for (i = UNCONSTRAINED_NODES, new_b = 0; i < ENTROPY_NODES; ++i)
258
      new_b += cost_branch256(ct + 2 * i, newplist[i]);
259
260
    new_b += cost_branch256(ct + 2 * PIVOT_NODE, newplist[PIVOT_NODE]);
    update_b = prob_diff_update_cost(newp, oldp[PIVOT_NODE]) +
261
262
263
264
265
266
267
268
269
270
271
        vp9_cost_upd256;
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
    }
  }
  *bestp = bestnewp;
  return bestsavings;
}

272
273
274
275
276
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]);
277
  assert(newp >= 1);
278
279
280
  savings = prob_update_savings(ct, *oldp, newp, upd);
  if (savings > 0) {
    vp9_write(bc, 1, upd);
281
    vp9_write_prob(bc, newp);
282
283
284
285
286
287
    *oldp = newp;
  } else {
    vp9_write(bc, 0, upd);
  }
}

288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
static void vp9_cond_prob_diff_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]);
  assert(newp >= 1);
  savings = prob_diff_update_savings_search(ct, *oldp, &newp, upd);
  if (savings > 0) {
    vp9_write(bc, 1, upd);
    write_prob_diff_update(bc, newp, *oldp);
    *oldp = newp;
  } else {
    vp9_write(bc, 0, upd);
  }
}

305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
static void update_mode(
  vp9_writer *w,
  int n,
  const struct vp9_token tok[/* n */],
  vp9_tree tree,
  vp9_prob Pnew[/* n-1 */],
  vp9_prob Pcur[/* n-1 */],
  unsigned int bct[/* n-1 */] [2],
  const unsigned int num_events[/* n */]
) {
  int i = 0;

  vp9_tree_probs_from_distribution(tree, Pnew, bct, num_events, 0);
  n--;

  for (i = 0; i < n; ++i) {
    vp9_cond_prob_diff_update(w, &Pcur[i], VP9_DEF_UPDATE_PROB, bct[i]);
  }
}

static void update_mbintra_mode_probs(VP9_COMP* const cpi,
                                      vp9_writer* const bc) {
  VP9_COMMON *const cm = &cpi->common;
328
  int j;
329
330
331
  vp9_prob pnew[VP9_INTRA_MODES - 1];
  unsigned int bct[VP9_INTRA_MODES - 1][2];

332
333
334
335
336
  for (j = 0; j < BLOCK_SIZE_GROUPS; j++)
    update_mode(bc, VP9_INTRA_MODES, vp9_intra_mode_encodings,
                vp9_intra_mode_tree, pnew,
                cm->fc.y_mode_prob[j], bct,
                (unsigned int *)cpi->y_mode_count[j]);
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
}

void vp9_update_skip_probs(VP9_COMP *cpi) {
  VP9_COMMON *const pc = &cpi->common;
  int k;

  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
    pc->mbskip_pred_probs[k] = get_binary_prob(cpi->skip_false_count[k],
                                               cpi->skip_true_count[k]);
}

// This function updates the reference frame prediction stats
static void update_refpred_stats(VP9_COMP *cpi) {
  VP9_COMMON *const cm = &cpi->common;
  int i;
  vp9_prob new_pred_probs[PREDICTION_PROBS];
  int old_cost, new_cost;

  // Set the prediction probability structures to defaults
  if (cm->frame_type != KEY_FRAME) {
    // From the prediction counts set the probabilities for each context
    for (i = 0; i < PREDICTION_PROBS; i++) {
      const int c0 = cpi->ref_pred_count[i][0];
      const int c1 = cpi->ref_pred_count[i][1];

      new_pred_probs[i] = get_binary_prob(c0, c1);

      // Decide whether or not to update the reference frame probs.
      // Returned costs are in 1/256 bit units.
      old_cost = c0 * vp9_cost_zero(cm->ref_pred_probs[i]) +
                 c1 * vp9_cost_one(cm->ref_pred_probs[i]);

      new_cost = c0 * vp9_cost_zero(new_pred_probs[i]) +
                 c1 * vp9_cost_one(new_pred_probs[i]);

      // 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;
      }
    }
  }
}

static void write_intra_mode(vp9_writer *bc, int m, const vp9_prob *p) {
  write_token(bc, vp9_intra_mode_tree, p, vp9_intra_mode_encodings + m);
}

387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
static void update_switchable_interp_probs(VP9_COMMON *const pc,
                                           vp9_writer* const bc) {
  unsigned int branch_ct[VP9_SWITCHABLE_FILTERS + 1]
                        [VP9_SWITCHABLE_FILTERS - 1][2];
  vp9_prob new_prob[VP9_SWITCHABLE_FILTERS + 1][VP9_SWITCHABLE_FILTERS - 1];
  int i, j;
  for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j) {
    vp9_tree_probs_from_distribution(
        vp9_switchable_interp_tree,
        new_prob[j], branch_ct[j],
        pc->fc.switchable_interp_count[j], 0);
  }
  for (j = 0; j <= VP9_SWITCHABLE_FILTERS; ++j) {
    for (i = 0; i < VP9_SWITCHABLE_FILTERS - 1; ++i) {
      // vp9_cond_prob_update(bc, &pc->fc.switchable_interp_prob[j][i],
      //                      VP9_DEF_UPDATE_PROB, branch_ct[j][i]);
      vp9_cond_prob_diff_update(bc, &pc->fc.switchable_interp_prob[j][i],
                                VP9_DEF_UPDATE_PROB, branch_ct[j][i]);
    }
  }
}

static void update_inter_mode_probs(VP9_COMMON *pc, vp9_writer* const bc) {
  int i, j;

  for (i = 0; i < INTER_MODE_CONTEXTS; i++) {
413
    for (j = 0; j < VP9_INTER_MODES - 1; j++) {
414
415
416
417
418
419
420
421
422
423
      vp9_cond_prob_diff_update(bc, &pc->fc.inter_mode_probs[i][j],
                                VP9_DEF_UPDATE_PROB,
                                pc->fc.inter_mode_counts[i][j]);
      // vp9_cond_prob_update(
      //     bc, &pc->fc.inter_mode_probs[i][j],
      //     VP9_DEF_UPDATE_PROB, pc->fc.inter_mode_counts[i][j]);
    }
  }
}

424
static void pack_mb_tokens(vp9_writer* const bc,
425
426
427
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
428

John Koleszar's avatar
John Koleszar committed
429
  while (p < stop) {
430
    const int t = p->token;
431
    const struct vp9_token *const a = vp9_coef_encodings + t;
432
    const vp9_extra_bit *const b = vp9_extra_bits + t;
John Koleszar's avatar
John Koleszar committed
433
    int i = 0;
434
    const vp9_prob *pp;
John Koleszar's avatar
John Koleszar committed
435
    int v = a->value;
436
    int n = a->len;
437
    vp9_prob probs[ENTROPY_NODES];
John Koleszar's avatar
John Koleszar committed
438

439
    if (t == EOSB_TOKEN) {
440
441
442
      ++p;
      break;
    }
443
    if (t >= TWO_TOKEN) {
444
      vp9_model_to_full_probs(p->context_tree, probs);
445
446
447
448
      pp = probs;
    } else {
      pp = p->context_tree;
    }
449
    assert(pp != 0);
450

John Koleszar's avatar
John Koleszar committed
451
    /* skip one or two nodes */
452
#if !CONFIG_BALANCED_COEFTREE
John Koleszar's avatar
John Koleszar committed
453
454
455
456
    if (p->skip_eob_node) {
      n -= p->skip_eob_node;
      i = 2 * p->skip_eob_node;
    }
457
#endif
John Koleszar's avatar
John Koleszar committed
458

John Koleszar's avatar
John Koleszar committed
459
460
    do {
      const int bb = (v >> --n) & 1;
461
462
463
464
465
466
467
#if CONFIG_BALANCED_COEFTREE
      if (i == 2 && p->skip_eob_node) {
        i += 2;
        assert(bb == 1);
        continue;
      }
#endif
468
      vp9_write(bc, bb, pp[i >> 1]);
469
      i = vp9_coef_tree[i + bb];
470
    } while (n);
John Koleszar's avatar
John Koleszar committed
471

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

475
      if (l) {
476
        const unsigned char *pb = b->prob;
John Koleszar's avatar
John Koleszar committed
477
        int v = e >> 1;
478
        int n = l;              /* number of bits in v, assumed nonzero */
John Koleszar's avatar
John Koleszar committed
479
        int i = 0;
John Koleszar's avatar
John Koleszar committed
480

John Koleszar's avatar
John Koleszar committed
481
482
        do {
          const int bb = (v >> --n) & 1;
483
          vp9_write(bc, bb, pb[i >> 1]);
John Koleszar's avatar
John Koleszar committed
484
485
486
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
487

488
      vp9_write_bit(bc, e & 1);
John Koleszar's avatar
John Koleszar committed
489
    }
John Koleszar's avatar
John Koleszar committed
490
491
492
    ++p;
  }

493
  *tp = p;
John Koleszar's avatar
John Koleszar committed
494
495
}

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
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
499
  assert(NEARESTMV <= m && m <= NEWMV);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
500
#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
}

Paul Wilkins's avatar
Paul Wilkins committed
505
506
// 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.
507
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
508
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
509
510
511
  if (xd->segmentation_enabled && xd->update_mb_segmentation_map)
    treed_write(bc, vp9_segment_tree, xd->mb_segment_tree_probs,
                mi->segment_id, 3);
John Koleszar's avatar
John Koleszar committed
512
513
}

Paul Wilkins's avatar
Paul Wilkins committed
514
// This function encodes the reference frame
515
static void encode_ref_frame(vp9_writer *const bc,
516
                             VP9_COMMON *const cm,
John Koleszar's avatar
John Koleszar committed
517
518
519
520
521
                             MACROBLOCKD *xd,
                             int segment_id,
                             MV_REFERENCE_FRAME rf) {
  int seg_ref_active;
  int seg_ref_count = 0;
522
523
524
  seg_ref_active = vp9_segfeature_active(xd,
                                         segment_id,
                                         SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
525
526

  if (seg_ref_active) {
527
528
529
530
    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
531
532
533
534
535
536
537
  }

  // 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;
538
    vp9_prob pred_prob;
John Koleszar's avatar
John Koleszar committed
539
540
541
    MV_REFERENCE_FRAME pred_rf;

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

    // Get the predicted value.
Paul Wilkins's avatar
Paul Wilkins committed
545
    pred_rf = vp9_get_pred_ref(cm, xd);
John Koleszar's avatar
John Koleszar committed
546
547
548
549
550

    // 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
551
    vp9_set_pred_flag(xd, PRED_REF, prediction_flag);
552
    vp9_write(bc, prediction_flag, pred_prob);
John Koleszar's avatar
John Koleszar committed
553
554
555

    // If not predicted correctly then code value explicitly
    if (!prediction_flag) {
556
      vp9_prob mod_refprobs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
557
558
559
560
561
562
563
564

      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] *=
565
          vp9_check_segref(xd, segment_id, INTRA_FRAME);
John Koleszar's avatar
John Koleszar committed
566
        mod_refprobs[LAST_FRAME] *=
567
          vp9_check_segref(xd, segment_id, LAST_FRAME);
John Koleszar's avatar
John Koleszar committed
568
        mod_refprobs[GOLDEN_FRAME] *=
569
570
          (vp9_check_segref(xd, segment_id, GOLDEN_FRAME) *
           vp9_check_segref(xd, segment_id, ALTREF_FRAME));
John Koleszar's avatar
John Koleszar committed
571
572
573
      }

      if (mod_refprobs[0]) {
574
        vp9_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]);
John Koleszar's avatar
John Koleszar committed
575
576
577
578
579
      }

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

John Koleszar's avatar
John Koleszar committed
583
584
        if (rf != LAST_FRAME) {
          if (mod_refprobs[2]) {
585
            vp9_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]);
John Koleszar's avatar
John Koleszar committed
586
          }
587
        }
John Koleszar's avatar
John Koleszar committed
588
      }
Paul Wilkins's avatar
Paul Wilkins committed
589
    }
John Koleszar's avatar
John Koleszar committed
590
  }
Paul Wilkins's avatar
Paul Wilkins committed
591

John Koleszar's avatar
John Koleszar committed
592
593
  // 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
594
}
John Koleszar's avatar
John Koleszar committed
595

596
// Update the probabilities used to encode reference frame data
597
598
static void update_ref_probs(VP9_COMP *const cpi) {
  VP9_COMMON *const cm = &cpi->common;
599

John Koleszar's avatar
John Koleszar committed
600
601
602
603
  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];
604

John Koleszar's avatar
John Koleszar committed
605
606
607
  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]);
608

John Koleszar's avatar
John Koleszar committed
609
610
  // Compute a modified set of probabilities to use when prediction of the
  // reference frame fails
Paul Wilkins's avatar
Paul Wilkins committed
611
  vp9_compute_mod_refprobs(cm);
612
613
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
614
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
615
                                vp9_writer *bc, int mi_row, int mi_col) {
616
  VP9_COMMON *const pc = &cpi->common;
617
  const nmv_context *nmvc = &pc->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
618
619
620
621
622
623
624
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
  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;
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
625

Ronald S. Bultje's avatar
Ronald S. Bultje committed
626
627
  xd->prev_mode_info_context = pc->prev_mi + (m - pc->mi);
  x->partition_info = x->pi + (m - pc->mi);
628

Ronald S. Bultje's avatar
Ronald S. Bultje committed
629
630
#ifdef ENTROPY_STATS
  active_section = 9;
631
#endif
632

Ronald S. Bultje's avatar
Ronald S. Bultje committed
633
634
635
636
637
  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
638

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
642
643
      // If the mb segment id wasn't predicted code explicitly
      if (!prediction_flag)
Paul Wilkins's avatar
Paul Wilkins committed
644
        write_mb_segid(bc, mi, &cpi->mb.e_mbd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
645
646
647
648
649
    } else {
      // Normal unpredicted coding
      write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    }
  }
650

651
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
652
653
    skip_coeff = 1;
  } else {
654
    skip_coeff = m->mbmi.mb_skip_coeff;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
655
656
657
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
658

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

662
663
664
665
666
667
668
669
670
671
672
673
674
  if (mi->sb_type >= BLOCK_SIZE_SB8X8 && pc->txfm_mode == TX_MODE_SELECT &&
      !(rf != INTRA_FRAME &&
        (skip_coeff || vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)))) {
    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 (mi->sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
      vp9_write(bc, sz != TX_8X8, pc->prob_tx[1]);
      if (mi->sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
        vp9_write(bc, sz != TX_16X16, pc->prob_tx[2]);
    }
  }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
675
  if (rf == INTRA_FRAME) {
676
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
677
    active_section = 6;
678
#endif
Paul Wilkins's avatar
Paul Wilkins committed
679

680
    if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
681
682
683
684
      const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
      const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
      const int bsl = MIN(bwl, bhl);
      write_intra_mode(bc, mode, pc->fc.y_mode_prob[MIN(3, bsl)]);
685
    } else {
686
687
688
689
      int idx, idy;
      int bw = 1 << b_width_log2(mi->sb_type);
      int bh = 1 << b_height_log2(mi->sb_type);
      for (idy = 0; idy < 2; idy += bh)
690
691
692
693
        for (idx = 0; idx < 2; idx += bw) {
          MB_PREDICTION_MODE bm = m->bmi[idy * 2 + idx].as_mode.first;
          write_intra_mode(bc, bm, pc->fc.y_mode_prob[0]);
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
694
    }
695
696
    write_intra_mode(bc, mi->uv_mode,
                     pc->fc.uv_mode_prob[mode]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
697
  } else {
698
    vp9_prob mv_ref_p[VP9_INTER_MODES - 1];
699

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

John Koleszar's avatar
John Koleszar committed
702
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
703
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
704
705
#endif

706
    // If segment skip is not enabled code the mode.
Paul Wilkins's avatar
Paul Wilkins committed
707
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
708
      if (mi->sb_type >= BLOCK_SIZE_SB8X8) {
709
        write_sb_mv_ref(bc, mode, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
710
711
        vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
712
    }
713

Ronald S. Bultje's avatar
Ronald S. Bultje committed
714
715
716
717
718
719
720
721
    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);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
722
    }
723

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
    if (xd->mode_info_context->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
      int j;
      MB_PREDICTION_MODE blockmode;
      int_mv blockmv;
      int bwl = b_width_log2(mi->sb_type), bw = 1 << bwl;
      int bhl = b_height_log2(mi->sb_type), bh = 1 << bhl;
      int idx, idy;
      for (idy = 0; idy < 2; idy += bh) {
        for (idx = 0; idx < 2; idx += bw) {
          j = idy * 2 + idx;
          blockmode = cpi->mb.partition_info->bmi[j].mode;
          blockmv = cpi->mb.partition_info->bmi[j].mv;
          write_sb_mv_ref(bc, blockmode, mv_ref_p);
          vp9_accum_mv_refs(&cpi->common, blockmode, mi->mb_mode_context[rf]);
          if (blockmode == NEWMV) {
746
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
747
            active_section = 11;
748
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
749
750
            vp9_encode_mv(bc, &blockmv.as_mv, &mi->best_mv.as_mv,
                          nmvc, xd->allow_high_precision_mv);
751

Ronald S. Bultje's avatar
Ronald S. Bultje committed
752
753
754
755
            if (mi->second_ref_frame > 0)
              vp9_encode_mv(bc,
                            &cpi->mb.partition_info->bmi[j].second_mv.as_mv,
                            &mi->best_second_mv.as_mv,
756
                            nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
757
          }
758
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
759
      }
760
761

#ifdef MODE_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
762
      ++count_mb_seg[mi->partitioning];
763
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
764
765
766
767
768
769
770
771
772
773
774
775
    } else if (mode == NEWMV) {
#ifdef ENTROPY_STATS
      active_section = 5;
#endif
      vp9_encode_mv(bc,
                    &mi->mv[0].as_mv, &mi->best_mv.as_mv,
                    nmvc, xd->allow_high_precision_mv);

      if (mi->second_ref_frame > 0)
        vp9_encode_mv(bc,
                      &mi->mv[1].as_mv, &mi->best_second_mv.as_mv,
                      nmvc, xd->allow_high_precision_mv);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
776
777
    }
  }
John Koleszar's avatar
John Koleszar committed
778
}
779

Ronald S. Bultje's avatar
Ronald S. Bultje committed
780
static void write_mb_modes_kf(const VP9_COMP *cpi,
781
                              MODE_INFO *m,
782
                              vp9_writer *bc, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
783
784
785
  const VP9_COMMON *const c = &cpi->common;
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
  const int ym = m->mbmi.mode;
786
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
787
788
  const int segment_id = m->mbmi.segment_id;
  int skip_coeff;
789

790
  if (xd->update_mb_segmentation_map)
791
792
    write_mb_segid(bc, &m->mbmi, xd);

793
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
794
795
    skip_coeff = 1;
  } else {
796
    skip_coeff = m->mbmi.mb_skip_coeff;
797
    vp9_write(bc, skip_coeff, vp9_get_pred_prob(c, xd, PRED_MBSKIP));
798
799
  }

800
801
802
803
804
805
806
807
808
809
810
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8 && c->txfm_mode == TX_MODE_SELECT) {
    TX_SIZE sz = m->mbmi.txfm_size;
    // FIXME(rbultje) code ternary symbol once all experiments are merged
    vp9_write(bc, sz != TX_4X4, c->prob_tx[0]);
    if (m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
      vp9_write(bc, sz != TX_8X8, c->prob_tx[1]);
      if (m->mbmi.sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
        vp9_write(bc, sz != TX_16X16, c->prob_tx[2]);
    }
  }

811
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
Yaowu Xu's avatar
Yaowu Xu committed
812
813
    const MB_PREDICTION_MODE A = above_block_mode(m, 0, mis);
    const MB_PREDICTION_MODE L = xd->left_available ?
814
                                 left_block_mode(m, 0) : DC_PRED;
815
816
    write_intra_mode(bc, ym, c->kf_y_mode_prob[A][L]);
  } else {
817
818
819
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
820
821
822
    for (idy = 0; idy < 2; idy += bh) {
      for (idx = 0; idx < 2; idx += bw) {
        int i = idy * 2 + idx;
Yaowu Xu's avatar
Yaowu Xu committed
823
824
        const MB_PREDICTION_MODE A = above_block_mode(m, i, mis);
        const MB_PREDICTION_MODE L = (xd->left_available || idx) ?
825
                                     left_block_mode(m, i) : DC_PRED;
826
827
828
829
        const int bm = m->bmi[i].as_mode.first;
#ifdef ENTROPY_STATS
        ++intra_mode_stats[A][L][bm];
#endif
830
        write_intra_mode(bc, bm, c->kf_y_mode_prob[A][L]);
831
832
      }
    }
833
834
  }

835
  write_intra_mode(bc, m->mbmi.uv_mode, c->kf_uv_mode_prob[ym]);
836
837
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
838
839
static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
                          TOKENEXTRA **tok, TOKENEXTRA *tok_end,
840
                          int mi_row, int mi_col) {
841
  VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
842
843
  MACROBLOCKD *const xd = &cpi->mb.e_mbd;

844
845
846
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
847
  xd->mode_info_context = m;
848
849
850
  set_mi_row_col(&cpi->common, xd, mi_row,
                 1 << mi_height_log2(m->mbmi.sb_type),
                 mi_col, 1 << mi_width_log2(m->mbmi.sb_type));
851
  if (cm->frame_type == KEY_FRAME) {
852
    write_mb_modes_kf(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
853
854
855
856
#ifdef ENTROPY_STATS
    active_section = 8;
#endif
  } else {
857
    pack_inter_mode_mvs(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
858
859
860
861
862
863
864
865
866
#ifdef ENTROPY_STATS
    active_section = 1;
#endif
  }

  assert(*tok < tok_end);
  pack_mb_tokens(bc, tok, tok_end);
}

867
868
static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
                           TOKENEXTRA **tok, TOKENEXTRA *tok_end,
869
                           int mi_row, int mi_col,
870
871
                           BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON *const cm = &cpi->common;
872
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
873
874
  const int mis = cm->mode_info_stride;
  int bwl, bhl;
875
876
  int bsl = b_width_log2(bsize);
  int bs = (1 << bsl) / 4;  // mode_info step for subsize
877
878
879
880
  int n;
  PARTITION_TYPE partition;
  BLOCK_SIZE_TYPE subsize;

881
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
882
883
    return;

884
885
  bwl = b_width_log2(m->mbmi.sb_type);
  bhl = b_height_log2(m->mbmi.sb_type);
886
887
888
889
890
891
892
893
894
895
896
897
898

  // parse the partition type
  if ((bwl == bsl) && (bhl == bsl))
    partition = PARTITION_NONE;
  else if ((bwl == bsl) && (bhl < bsl))
    partition = PARTITION_HORZ;
  else if ((bwl < bsl) && (bhl == bsl))
    partition = PARTITION_VERT;
  else if ((bwl < bsl) && (bhl < bsl))
    partition = PARTITION_SPLIT;
  else
    assert(0);

899
  if (bsize < BLOCK_SIZE_SB8X8)
900
    if (xd->ab_index > 0)
901
902
903
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
904
    int pl;
905
906
    xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = cm->above_seg_context + mi_col;
907
    pl = partition_plane_context(xd, bsize);
908
    // encode the partition information
909
910
    write_token(bc, vp9_partition_tree,
                cm->fc.partition_prob[cm->frame_type][pl],
911
                vp9_partition_encodings + partition);
912
  }
913

914
  subsize = get_subsize(bsize, partition);
915
  *(get_sb_index(xd, subsize)) = 0;
916

917
918
  switch (partition) {
    case PARTITION_NONE:
919
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
920
921
      break;
    case PARTITION_HORZ:
922
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
923
      *(get_sb_index(xd, subsize)) = 1;
924
925
      if ((mi_row + bs) < cm->mi_rows)
        write_modes_b(cpi, m + bs * mis, bc, tok, tok_end, mi_row + bs, mi_col);
926
927
      break;
    case PARTITION_VERT:
928
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
929
      *(get_sb_index(xd, subsize)) = 1;
930
931
      if ((mi_col + bs) < cm->mi_cols)
        write_modes_b(cpi, m + bs, bc, tok, tok_end, mi_row, mi_col + bs);
932
933
934
935
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
936
        *(get_sb_index(xd, subsize)) = n;
937
        write_modes_sb(cpi, m + j * bs * mis + i * bs, bc, tok, tok_end,
938
                       mi_row + j * bs, mi_col + i * bs, subsize);
939
940
941
942
943
      }
      break;
    default:
      assert(0);
  }
944
945

  // update partition context
946
947
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
948
949
950
    set_partition_seg_context(cm, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
951
952
}

953
static void write_modes(VP9_COMP *cpi, vp9_writer* const bc,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
954
                        TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
955
  VP9_COMMON *const c = &cpi->common;
John Koleszar's avatar
John Koleszar committed
956
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
957
  MODE_INFO *m, *m_ptr = c->mi;
958
  int mi_row, mi_col;
John Koleszar's avatar
John Koleszar committed
959

960
  m_ptr += c->cur_tile_mi_col_start + c->cur_tile_mi_row_start * mis;
961
  vpx_memset(c->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
962
             mi_cols_aligned_to_sb(c));
963

964
965
  for (mi_row = c->cur_tile_mi_row_start;
       mi_row < c->cur_tile_mi_row_end;
Jingning Han's avatar
Jingning Han committed
966
       mi_row += 8, m_ptr += 8 * mis) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
967
    m = m_ptr;
968
    vpx_memset(c->left_seg_context, 0, sizeof(c->left_seg_context));
969
970
    for (mi_col = c->cur_tile_mi_col_start;
         mi_col < c->cur_tile_mi_col_end;
971
         mi_col += 64 / MI_SIZE, m += 64 / MI_SIZE)
972
      write_modes_sb(cpi, m, bc, tok, tok_end, mi_row, mi_col,
973
                     BLOCK_SIZE_SB64X64);
John Koleszar's avatar
John Koleszar committed
974
  }
John Koleszar's avatar
John Koleszar committed
975
}
976

977
/* This function is used for debugging probability trees. */
978
static void print_prob_tree(vp9_coeff_probs *coef_probs, int block_types) {
John Koleszar's avatar
John Koleszar committed
979
  /* print coef probability tree */
980
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
981
982
  FILE *f = fopen("enc_tree_probs.txt", "a");
  fprintf(f, "{\n");
983
  for (i = 0; i < block_types; i++) {
John Koleszar's avatar
John Koleszar committed
984
    fprintf(f, "  {\n");
985
986
987
988
989
990
991
992
993
994
    for (j = 0; j < REF_TYPES; ++j) {
      fprintf(f, "  {\n");
      for (k = 0; k < COEF_BANDS; k++) {
        fprintf(f, "    {\n");
        for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
          fprintf(f, "      {");
          for (m = 0; m < ENTROPY_NODES; m++) {
            fprintf(f, "%3u, ",
                    (unsigned int)(coef_probs[i][j][k][l][m]));
          }
995
        }
John Koleszar's avatar
John Koleszar committed
996
997
998
        fprintf(f, " }\n");
      }
      fprintf(f, "    }\n");
999
    }
John Koleszar's avatar
John Koleszar committed
1000
1001
1002
1003
    fprintf(f, "  }\n");
  }
  fprintf(f, "}\n");
  fclose(f);
1004
1005
}

1006
1007
1008
1009
1010
1011
static void build_tree_distribution(VP9_COMP *cpi, TX_SIZE txfm_size) {
  vp9_coeff_probs_model *coef_probs = cpi->frame_coef_probs[txfm_size];
  vp9_coeff_count *coef_counts = cpi->coef_counts[txfm_size];
  unsigned int (*eob_branch_ct)[REF_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS] =
      cpi->common.fc.eob_branch_counts[txfm_size];
  vp9_coeff_stats *coef_branch_ct = cpi->frame_branch_ct[txfm_size];
1012
  vp9_prob full_probs[ENTROPY_NODES];
1013
  int i, j, k, l;
1014

1015
  for (i = 0; i < BLOCK_TYPES; ++i) {
1016
1017
1018
1019
1020
    for (j = 0; j < REF_TYPES; ++j) {
      for (k = 0; k < COEF_BANDS; ++k) {
        for (l = 0; l < PREV_COEF_CONTEXTS; ++l) {
          if (l >= 3 && k == 0)
            continue;
1021
1022
          vp9_tree_probs_from_distribution(vp9_coef_tree,
                                           full_probs,
1023
                                           coef_branch_ct[i][j][k][l],
1024
1025
1026
                                           coef_counts[i][j][k][l], 0);
          vpx_memcpy(coef_probs[i][j][k][l], full_probs,
                     sizeof(vp9_prob) * UNCONSTRAINED_NODES);
1027
1028
1029
1030
1031
1032
1033
#if CONFIG_BALANCED_COEFTREE
          coef_branch_ct[i][j][k][l][1][1] = eob_branch_ct[i][j][k][l] -
                                             coef_branch_ct[i][j][k][l][1][0];
          coef_probs[i][j][k][l][1] =
              get_binary_prob(coef_branch_ct[i][j][k][l][1][0],
                              coef_branch_ct[i][j][k][l][1][1]);
#else
1034
1035
1036
1037
1038
          coef_branch_ct[i][j][k][l][0][1] = eob_branch_ct[i][j][k][l] -
                                             coef_branch_ct[i][j][k][l][0][0];
          coef_probs[i][j][k][l][0] =
              get_binary_prob(coef_branch_ct[i][j][k][l][0][0],
                              coef_branch_ct[i][j][k][l][0][1]);
1039
#endif
1040
#ifdef ENTROPY_STATS
1041
          if (!cpi->dummy_packing) {
1042
            int t;