vp9_bitstream.c 57.4 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
#ifdef MODE_STATS
55
56
57
int64_t tx_count_32x32p_stats[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB];
int64_t tx_count_16x16p_stats[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB - 1];
int64_t tx_count_8x8p_stats[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB - 2];
58
59
60
61
62
63
64
65
66

void init_tx_count_stats() {
  vp9_zero(tx_count_32x32p_stats);
  vp9_zero(tx_count_16x16p_stats);
  vp9_zero(tx_count_8x8p_stats);
}

static void update_tx_count_stats(VP9_COMMON *cm) {
  int i, j;
67
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
68
69
70
71
    for (j = 0; j < TX_SIZE_MAX_SB; j++) {
      tx_count_32x32p_stats[i][j] += cm->fc.tx_count_32x32p[i][j];
    }
  }
72
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
73
74
75
76
    for (j = 0; j < TX_SIZE_MAX_SB - 1; j++) {
      tx_count_16x16p_stats[i][j] += cm->fc.tx_count_16x16p[i][j];
    }
  }
77
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
78
79
80
81
82
83
84
85
86
87
88
89
90
91
    for (j = 0; j < TX_SIZE_MAX_SB - 2; j++) {
      tx_count_8x8p_stats[i][j] += cm->fc.tx_count_8x8p[i][j];
    }
  }
}

void write_tx_count_stats() {
  int i, j;
  FILE *fp = fopen("tx_count.bin", "wb");
  fwrite(tx_count_32x32p_stats, sizeof(tx_count_32x32p_stats), 1, fp);
  fwrite(tx_count_16x16p_stats, sizeof(tx_count_16x16p_stats), 1, fp);
  fwrite(tx_count_8x8p_stats, sizeof(tx_count_8x8p_stats), 1, fp);
  fclose(fp);

92
93
94
95
  printf(
      "vp9_default_tx_count_32x32p[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB] = {\n");
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
    printf("  { ");
96
97
98
99
100
101
    for (j = 0; j < TX_SIZE_MAX_SB; j++) {
      printf("%"PRId64", ", tx_count_32x32p_stats[i][j]);
    }
    printf("},\n");
  }
  printf("};\n");
102
103
104
105
  printf(
      "vp9_default_tx_count_16x16p[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB-1] = {\n");
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
    printf("  { ");
106
107
108
109
110
111
    for (j = 0; j < TX_SIZE_MAX_SB - 1; j++) {
      printf("%"PRId64", ", tx_count_16x16p_stats[i][j]);
    }
    printf("},\n");
  }
  printf("};\n");
112
113
114
115
  printf(
      "vp9_default_tx_count_8x8p[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB-2] = {\n");
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
    printf("  { ");
116
117
118
119
120
121
122
123
124
    for (j = 0; j < TX_SIZE_MAX_SB - 2; j++) {
      printf("%"PRId64", ", tx_count_8x8p_stats[i][j]);
    }
    printf("},\n");
  }
  printf("};\n");
}
#endif

125
126
static int update_bits[255];

127
128
129
130
131
static INLINE void write_be32(uint8_t *p, int value) {
  p[0] = value >> 24;
  p[1] = value >> 16;
  p[2] = value >> 8;
  p[3] = value;
132
133
}

134

135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

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

155
156
157
158
159
void vp9_encode_unsigned_max(struct vp9_write_bit_buffer *wb,
                             int data, int max) {
  vp9_wb_write_literal(wb, data, get_unsigned_bits(max));
}

160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
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
233
234
235
static void compute_update_table() {
  int i;
  for (i = 0; i < 255; i++)
236
    update_bits[i] = count_term_subexp(i, SUBEXP_PARAM, 255);
237
238
}

John Koleszar's avatar
John Koleszar committed
239
240
241
242
243
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;
244
245
}

John Koleszar's avatar
John Koleszar committed
246
247
248
249
250
static int remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
  int i;
  if ((m << 1) <= n)
251
    i = recenter_nonneg(v, m) - 1;
John Koleszar's avatar
John Koleszar committed
252
  else
253
    i = recenter_nonneg(n - 1 - v, n - 1 - m) - 1;
John Koleszar's avatar
John Koleszar committed
254
255
256

  i = split_index(i, n - 1, modulus);
  return i;
257
}
258

259
static void write_prob_diff_update(vp9_writer *w,
260
                                   vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
261
  int delp = remap_prob(newp, oldp);
262
  encode_term_subexp(w, delp, SUBEXP_PARAM, 255);
263
264
}

265
static int prob_diff_update_cost(vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
266
267
  int delp = remap_prob(newp, oldp);
  return update_bits[delp] * 256;
268
}
269

270
static int prob_update_savings(const unsigned int *ct,
271
272
273
274
275
                               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;
276
  return old_b - new_b - update_b;
277
278
279
}

static int prob_diff_update_savings_search(const unsigned int *ct,
280
281
282
                                           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
283
  int new_b, update_b, savings, bestsavings, step;
284
  vp9_prob newp, bestnewp;
John Koleszar's avatar
John Koleszar committed
285
286
287
288
289
290

  bestsavings = 0;
  bestnewp = oldp;

  step = (*bestp > oldp ? -1 : 1);
  for (newp = *bestp; newp != oldp; newp += step) {
291
292
    new_b = cost_branch256(ct, newp);
    update_b = prob_diff_update_cost(newp, oldp) + vp9_cost_upd256;
John Koleszar's avatar
John Koleszar committed
293
294
295
296
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
297
    }
John Koleszar's avatar
John Koleszar committed
298
299
300
  }
  *bestp = bestnewp;
  return bestsavings;
301
302
}

303
304
305
306
static int prob_diff_update_savings_search_model(const unsigned int *ct,
                                                 const vp9_prob *oldp,
                                                 vp9_prob *bestp,
                                                 const vp9_prob upd,
307
                                                 int b, int r) {
308
309
  int i, old_b, new_b, update_b, savings, bestsavings, step;
  int newp;
310
  vp9_prob bestnewp, newplist[ENTROPY_NODES], oldplist[ENTROPY_NODES];
311
312
  vp9_model_to_full_probs(oldp, oldplist);
  vpx_memcpy(newplist, oldp, sizeof(vp9_prob) * UNCONSTRAINED_NODES);
313
314
315
  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]);
316
317

  bestsavings = 0;
318
  bestnewp = oldp[PIVOT_NODE];
319

320
  step = (*bestp > oldp[PIVOT_NODE] ? -1 : 1);
321
  newp = *bestp;
322
  for (; newp != oldp[PIVOT_NODE]; newp += step) {
323
    if (newp < 1 || newp > 255) continue;
324
    newplist[PIVOT_NODE] = newp;
325
    vp9_model_to_full_probs(newplist, newplist);
326
    for (i = UNCONSTRAINED_NODES, new_b = 0; i < ENTROPY_NODES; ++i)
327
      new_b += cost_branch256(ct + 2 * i, newplist[i]);
328
329
    new_b += cost_branch256(ct + 2 * PIVOT_NODE, newplist[PIVOT_NODE]);
    update_b = prob_diff_update_cost(newp, oldp[PIVOT_NODE]) +
330
331
332
333
334
335
336
337
338
339
340
        vp9_cost_upd256;
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
    }
  }
  *bestp = bestnewp;
  return bestsavings;
}

341
342
343
344
345
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]);
346
  assert(newp >= 1);
347
348
349
  savings = prob_update_savings(ct, *oldp, newp, upd);
  if (savings > 0) {
    vp9_write(bc, 1, upd);
350
    vp9_write_prob(bc, newp);
351
352
353
354
355
356
    *oldp = newp;
  } else {
    vp9_write(bc, 0, upd);
  }
}

357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
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);
  }
}

374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
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;
397
  int j;
398
399
400
  vp9_prob pnew[VP9_INTRA_MODES - 1];
  unsigned int bct[VP9_INTRA_MODES - 1][2];

401
402
403
404
405
  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]);
406
407
}

Deb Mukherjee's avatar
Deb Mukherjee committed
408
void vp9_update_skip_probs(VP9_COMP *cpi, vp9_writer *bc) {
409
410
411
  VP9_COMMON *const pc = &cpi->common;
  int k;

Deb Mukherjee's avatar
Deb Mukherjee committed
412
413
414
415
416
417
418
419
  for (k = 0; k < MBSKIP_CONTEXTS; ++k) {
    vp9_cond_prob_diff_update(bc, &pc->fc.mbskip_probs[k],
                              VP9_DEF_UPDATE_PROB, pc->fc.mbskip_count[k]);
    /*
    pc->fc.mbskip_probs[k] = get_binary_prob(pc->fc.mbskip_count[k][0],
                                                  pc->fc.mbskip_count[k][1]);
                                                  */
  }
420
421
422
423
424
425
}

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

426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
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++) {
452
    for (j = 0; j < VP9_INTER_MODES - 1; j++) {
453
454
455
456
457
458
459
460
461
462
      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]);
    }
  }
}

463
static void pack_mb_tokens(vp9_writer* const bc,
464
465
466
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
467

John Koleszar's avatar
John Koleszar committed
468
  while (p < stop) {
469
    const int t = p->token;
470
    const struct vp9_token *const a = vp9_coef_encodings + t;
471
    const vp9_extra_bit *const b = vp9_extra_bits + t;
John Koleszar's avatar
John Koleszar committed
472
    int i = 0;
473
    const vp9_prob *pp;
John Koleszar's avatar
John Koleszar committed
474
    int v = a->value;
475
    int n = a->len;
476
    vp9_prob probs[ENTROPY_NODES];
John Koleszar's avatar
John Koleszar committed
477

478
    if (t == EOSB_TOKEN) {
479
480
481
      ++p;
      break;
    }
482
    if (t >= TWO_TOKEN) {
483
      vp9_model_to_full_probs(p->context_tree, probs);
484
485
486
487
      pp = probs;
    } else {
      pp = p->context_tree;
    }
488
    assert(pp != 0);
489

John Koleszar's avatar
John Koleszar committed
490
    /* skip one or two nodes */
491
#if !CONFIG_BALANCED_COEFTREE
John Koleszar's avatar
John Koleszar committed
492
493
494
495
    if (p->skip_eob_node) {
      n -= p->skip_eob_node;
      i = 2 * p->skip_eob_node;
    }
496
#endif
John Koleszar's avatar
John Koleszar committed
497

John Koleszar's avatar
John Koleszar committed
498
499
    do {
      const int bb = (v >> --n) & 1;
500
501
502
503
504
505
506
#if CONFIG_BALANCED_COEFTREE
      if (i == 2 && p->skip_eob_node) {
        i += 2;
        assert(bb == 1);
        continue;
      }
#endif
507
      vp9_write(bc, bb, pp[i >> 1]);
508
      i = vp9_coef_tree[i + bb];
509
    } while (n);
John Koleszar's avatar
John Koleszar committed
510

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

514
      if (l) {
515
        const unsigned char *pb = b->prob;
John Koleszar's avatar
John Koleszar committed
516
        int v = e >> 1;
517
        int n = l;              /* number of bits in v, assumed nonzero */
John Koleszar's avatar
John Koleszar committed
518
        int i = 0;
John Koleszar's avatar
John Koleszar committed
519

John Koleszar's avatar
John Koleszar committed
520
521
        do {
          const int bb = (v >> --n) & 1;
522
          vp9_write(bc, bb, pb[i >> 1]);
John Koleszar's avatar
John Koleszar committed
523
524
525
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
526

527
      vp9_write_bit(bc, e & 1);
John Koleszar's avatar
John Koleszar committed
528
    }
John Koleszar's avatar
John Koleszar committed
529
530
531
    ++p;
  }

532
  *tp = p;
John Koleszar's avatar
John Koleszar committed
533
534
}

535
536
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
537
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
538
  assert(NEARESTMV <= m && m <= NEWMV);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
539
#endif
540
541
  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
542
543
}

Paul Wilkins's avatar
Paul Wilkins committed
544
545
// 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.
546
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
547
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
548
549
550
  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
551
552
}

Paul Wilkins's avatar
Paul Wilkins committed
553
// This function encodes the reference frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
554
555
556
557
558
559
560
561
static void encode_ref_frame(VP9_COMP *cpi, vp9_writer *bc) {
  VP9_COMMON *const pc = &cpi->common;
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
  MB_MODE_INFO *mi = &xd->mode_info_context->mbmi;
  const int segment_id = mi->segment_id;
  int seg_ref_active = vp9_segfeature_active(xd, segment_id,
                                             SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
562
563
  // If segment level coding of this signal is disabled...
  // or the segment allows multiple reference frame options
564
  if (!seg_ref_active) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
565
566
567
568
569
570
571
572
573
    // does the feature use compound prediction or not
    // (if not specified at the frame/segment level)
    if (pc->comp_pred_mode == HYBRID_PREDICTION) {
      vp9_write(bc, mi->ref_frame[1] > INTRA_FRAME,
                vp9_get_pred_prob(pc, xd, PRED_COMP_INTER_INTER));
    } else {
      assert((mi->ref_frame[1] <= INTRA_FRAME) ==
                 (pc->comp_pred_mode == SINGLE_PREDICTION_ONLY));
    }
574

Ronald S. Bultje's avatar
Ronald S. Bultje committed
575
576
577
578
579
580
581
582
583
    if (mi->ref_frame[1] > INTRA_FRAME) {
      vp9_write(bc, mi->ref_frame[0] == GOLDEN_FRAME,
                vp9_get_pred_prob(pc, xd, PRED_COMP_REF_P));
    } else {
      vp9_write(bc, mi->ref_frame[0] != LAST_FRAME,
                vp9_get_pred_prob(pc, xd, PRED_SINGLE_REF_P1));
      if (mi->ref_frame[0] != LAST_FRAME)
        vp9_write(bc, mi->ref_frame[0] != GOLDEN_FRAME,
                  vp9_get_pred_prob(pc, xd, PRED_SINGLE_REF_P2));
Paul Wilkins's avatar
Paul Wilkins committed
584
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
585
586
  } else {
    assert(mi->ref_frame[1] <= INTRA_FRAME);
587
588
    assert(vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME) ==
           mi->ref_frame[0]);
John Koleszar's avatar
John Koleszar committed
589
  }
Paul Wilkins's avatar
Paul Wilkins committed
590

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
595
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
596
                                vp9_writer *bc, int mi_row, int mi_col) {
597
  VP9_COMMON *const pc = &cpi->common;
598
  const nmv_context *nmvc = &pc->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
599
600
601
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
  MB_MODE_INFO *const mi = &m->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
602
  const MV_REFERENCE_FRAME rf = mi->ref_frame[0];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
603
604
605
  const MB_PREDICTION_MODE mode = mi->mode;
  const int segment_id = mi->segment_id;
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
606

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
610
611
#ifdef ENTROPY_STATS
  active_section = 9;
612
#endif
613

Ronald S. Bultje's avatar
Ronald S. Bultje committed
614
615
616
617
618
  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
619

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
623
624
      // If the mb segment id wasn't predicted code explicitly
      if (!prediction_flag)
Paul Wilkins's avatar
Paul Wilkins committed
625
        write_mb_segid(bc, mi, &cpi->mb.e_mbd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
626
627
628
629
630
    } else {
      // Normal unpredicted coding
      write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    }
  }
631

632
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
633
634
    skip_coeff = 1;
  } else {
635
    skip_coeff = m->mbmi.mb_skip_coeff;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
636
637
638
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
639

640
641
642
  if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME))
    vp9_write(bc, rf != INTRA_FRAME,
              vp9_get_pred_prob(pc, xd, PRED_INTRA_INTER));
Paul Wilkins's avatar
Paul Wilkins committed
643

644
645
646
647
  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;
648
649
    const vp9_prob *tx_probs = vp9_get_pred_probs(pc, xd, PRED_TX_SIZE);
    vp9_write(bc, sz != TX_4X4, tx_probs[0]);
650
    if (mi->sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
651
      vp9_write(bc, sz != TX_8X8, tx_probs[1]);
652
      if (mi->sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
653
        vp9_write(bc, sz != TX_16X16, tx_probs[2]);
654
655
656
    }
  }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
657
  if (rf == INTRA_FRAME) {
658
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
659
    active_section = 6;
660
#endif
Paul Wilkins's avatar
Paul Wilkins committed
661

662
    if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
663
664
665
666
      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)]);
667
    } else {
668
669
670
671
      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)
672
673
674
675
        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
676
    }
677
678
    write_intra_mode(bc, mi->uv_mode,
                     pc->fc.uv_mode_prob[mode]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
679
  } else {
680
    vp9_prob mv_ref_p[VP9_INTER_MODES - 1];
681

Ronald S. Bultje's avatar
Ronald S. Bultje committed
682
683
    encode_ref_frame(cpi, bc);

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

John Koleszar's avatar
John Koleszar committed
686
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
687
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
688
689
#endif

690
    // If segment skip is not enabled code the mode.
Paul Wilkins's avatar
Paul Wilkins committed
691
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
692
      if (mi->sb_type >= BLOCK_SIZE_SB8X8) {
693
        write_sb_mv_ref(bc, mode, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
694
695
        vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
696
    }
697

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
    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) {
723
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
724
            active_section = 11;
725
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
726
727
            vp9_encode_mv(bc, &blockmv.as_mv, &mi->best_mv.as_mv,
                          nmvc, xd->allow_high_precision_mv);
728

Ronald S. Bultje's avatar
Ronald S. Bultje committed
729
            if (mi->ref_frame[1] > INTRA_FRAME)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
730
731
732
              vp9_encode_mv(bc,
                            &cpi->mb.partition_info->bmi[j].second_mv.as_mv,
                            &mi->best_second_mv.as_mv,
733
                            nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
734
          }
735
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
736
737
738
739
740
741
742
743
744
      }
    } 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);

Ronald S. Bultje's avatar
Ronald S. Bultje committed
745
      if (mi->ref_frame[1] > INTRA_FRAME)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
746
747
748
        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
749
750
    }
  }
John Koleszar's avatar
John Koleszar committed
751
}
752

Ronald S. Bultje's avatar
Ronald S. Bultje committed
753
static void write_mb_modes_kf(const VP9_COMP *cpi,
754
                              MODE_INFO *m,
755
                              vp9_writer *bc, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
756
757
758
  const VP9_COMMON *const c = &cpi->common;
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
  const int ym = m->mbmi.mode;
759
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
760
761
  const int segment_id = m->mbmi.segment_id;
  int skip_coeff;
762

763
  if (xd->update_mb_segmentation_map)
764
765
    write_mb_segid(bc, &m->mbmi, xd);

766
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
767
768
    skip_coeff = 1;
  } else {
769
    skip_coeff = m->mbmi.mb_skip_coeff;
770
    vp9_write(bc, skip_coeff, vp9_get_pred_prob(c, xd, PRED_MBSKIP));
771
772
  }

773
774
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8 && c->txfm_mode == TX_MODE_SELECT) {
    TX_SIZE sz = m->mbmi.txfm_size;
775
776
    const vp9_prob *tx_probs = vp9_get_pred_probs(c, xd, PRED_TX_SIZE);
    vp9_write(bc, sz != TX_4X4, tx_probs[0]);
777
    if (m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
778
      vp9_write(bc, sz != TX_8X8, tx_probs[1]);
779
      if (m->mbmi.sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
780
        vp9_write(bc, sz != TX_16X16, tx_probs[2]);
781
782
783
    }
  }

784
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
Yaowu Xu's avatar
Yaowu Xu committed
785
786
    const MB_PREDICTION_MODE A = above_block_mode(m, 0, mis);
    const MB_PREDICTION_MODE L = xd->left_available ?
787
                                 left_block_mode(m, 0) : DC_PRED;
788
789
    write_intra_mode(bc, ym, c->kf_y_mode_prob[A][L]);
  } else {
790
791
792
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
793
794
795
    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
796
797
        const MB_PREDICTION_MODE A = above_block_mode(m, i, mis);
        const MB_PREDICTION_MODE L = (xd->left_available || idx) ?
798
                                     left_block_mode(m, i) : DC_PRED;
799
800
801
802
        const int bm = m->bmi[i].as_mode.first;
#ifdef ENTROPY_STATS
        ++intra_mode_stats[A][L][bm];
#endif
803
        write_intra_mode(bc, bm, c->kf_y_mode_prob[A][L]);
804
805
      }
    }
806
807
  }

808
  write_intra_mode(bc, m->mbmi.uv_mode, c->kf_uv_mode_prob[ym]);
809
810
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
811
812
static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
                          TOKENEXTRA **tok, TOKENEXTRA *tok_end,
813
                          int mi_row, int mi_col) {
814
  VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
815
816
  MACROBLOCKD *const xd = &cpi->mb.e_mbd;

817
818
819
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
820
  xd->mode_info_context = m;
821
822
823
  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));
Adrian Grange's avatar
Adrian Grange committed
824
  if ((cm->frame_type == KEY_FRAME) || cm->intra_only) {
825
    write_mb_modes_kf(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
826
827
828
829
#ifdef ENTROPY_STATS
    active_section = 8;
#endif
  } else {
830
    pack_inter_mode_mvs(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
831
832
833
834
835
836
837
838
839
#ifdef ENTROPY_STATS
    active_section = 1;
#endif
  }

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

840
841
static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
                           TOKENEXTRA **tok, TOKENEXTRA *tok_end,
842
                           int mi_row, int mi_col,
843
844
                           BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON *const cm = &cpi->common;
845
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
846
847
  const int mis = cm->mode_info_stride;
  int bwl, bhl;
848
849
  int bsl = b_width_log2(bsize);
  int bs = (1 << bsl) / 4;  // mode_info step for subsize
850
851
852
853
  int n;
  PARTITION_TYPE partition;
  BLOCK_SIZE_TYPE subsize;

854
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
855
856
    return;

857
858
  bwl = b_width_log2(m->mbmi.sb_type);
  bhl = b_height_log2(m->mbmi.sb_type);
859
860
861
862
863
864
865
866
867
868
869
870
871

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

872
  if (bsize < BLOCK_SIZE_SB8X8)
873
    if (xd->ab_index > 0)
874
875
876
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
877
    int pl;
878
    int idx = check_bsize_coverage(cm, xd, mi_row, mi_col, bsize);
879
880
    xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = cm->above_seg_context + mi_col;
881
    pl = partition_plane_context(xd, bsize);
882
    // encode the partition information
883
884
885
886
887
888
889
    if (idx == 0)
      write_token(bc, vp9_partition_tree,
                  cm->fc.partition_prob[cm->frame_type][pl],
                  vp9_partition_encodings + partition);
    else if (idx > 0)
      vp9_write(bc, partition == PARTITION_SPLIT,
                cm->fc.partition_prob[cm->frame_type][pl][idx]);
890
  }
891

892
  subsize = get_subsize(bsize, partition);
893
  *(get_sb_index(xd, subsize)) = 0;
894

895
896
  switch (partition) {
    case PARTITION_NONE:
897
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
898
899
      break;
    case PARTITION_HORZ:
900
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
901
      *(get_sb_index(xd, subsize)) = 1;
902
903
      if ((mi_row + bs) < cm->mi_rows)
        write_modes_b(cpi, m + bs * mis, bc, tok, tok_end, mi_row + bs, mi_col);
904
905
      break;
    case PARTITION_VERT:
906
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
907
      *(get_sb_index(xd, subsize)) = 1;
908
909
      if ((mi_col + bs) < cm->mi_cols)
        write_modes_b(cpi, m + bs, bc, tok, tok_end, mi_row, mi_col + bs);
910
911
912
913
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
914
        *(get_sb_index(xd, subsize)) = n;
915
        write_modes_sb(cpi, m + j * bs * mis + i * bs, bc, tok, tok_end,
916
                       mi_row + j * bs, mi_col + i * bs, subsize);
917
918
919
920
921
      }
      break;
    default:
      assert(0);
  }
922
923

  // update partition context
924
925
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
926
927
928
    set_partition_seg_context(cm, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
929
930
}

931
static void write_modes(VP9_COMP *cpi, vp9_writer* const bc,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
932
                        TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
933
  VP9_COMMON *const c = &cpi->common;
John Koleszar's avatar
John Koleszar committed
934
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
935
  MODE_INFO *m, *m_ptr = c->mi;
936
  int mi_row, mi_col;
John Koleszar's avatar
John Koleszar committed
937

938
  m_ptr += c->cur_tile_mi_col_start + c->cur_tile_mi_row_start * mis;
939
  vpx_memset(c->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
940
             mi_cols_aligned_to_sb(c));
941

942
943
  for (mi_row = c->cur_tile_mi_row_start;
       mi_row < c->cur_tile_mi_row_end;
Jingning Han's avatar
Jingning Han committed
944
       mi_row += 8, m_ptr += 8 * mis) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
945
    m = m_ptr;
946
    vpx_memset(c->left_seg_context, 0, sizeof(c->left_seg_context));
947
948
    for (mi_col = c->cur_tile_mi_col_start;
         mi_col < c->cur_tile_mi_col_end;
949
         mi_col += 64 / MI_SIZE, m += 64 / MI_SIZE)
950
      write_modes_sb(cpi, m, bc, tok, tok_end, mi_row, mi_col,
951
                     BLOCK_SIZE_SB64X64);
John Koleszar's avatar
John Koleszar committed
952
  }
John Koleszar's avatar
John Koleszar committed
953
}
954

955
/* This function is used for debugging probability trees. */
956
static void print_prob_tree(vp9_coeff_probs *coef_probs, int block_types) {
John Koleszar's avatar
John Koleszar committed
957
  /* print coef probability tree */
958
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
959
960
  FILE *f = fopen("enc_tree_probs.txt", "a");
  fprintf(f, "{\n");
961
  for (i = 0; i < block_types; i++) {
John Koleszar's avatar
John Koleszar committed
962
    fprintf(f, "  {\n");
963
964
965
966
967
968
969
970
971
972
    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]));
          }
973
        }
John Koleszar's avatar
John Koleszar committed
974
975
976
        fprintf(f, " }\n");
      }
      fprintf(f, "    }\n");
977
    }
John Koleszar's avatar
John Koleszar committed
978
979
980
981
    fprintf(f, "  }\n");
  }
  fprintf(f, "}\n");
  fclose(f);
982
983
}

984
985
986
987
988
989
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];
990
  vp9_prob full_probs[ENTROPY_NODES];
991
  int i, j, k, l;
992

993
  for (i = 0; i < BLOCK_TYPES; ++i) {
994
995
996
997
998
    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;
999
1000
          vp9_tree_probs_from_distribution(vp9_coef_tree,
                                           full_probs,
1001
                                           coef_branch_ct[i][j][k][l],
1002
1003
1004
                                           coef_counts[i][j][k][l], 0);
          vpx_memcpy(coef_probs[i][j][k][l], full_probs,
                     sizeof(vp9_prob) * UNCONSTRAINED_NODES);
1005
1006
1007
1008
1009
1010
1011
#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
1012
1013
1014
1015
1016
          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]);
1017
#endif
1018
#ifdef ENTROPY_STATS
1019
          if (!cpi->dummy_packing) {
1020
            int t;
1021
            for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)