vp9_bitstream.c 57.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
#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
int64_t switchable_interp_stats[VP9_SWITCHABLE_FILTERS+1]
                               [VP9_SWITCHABLE_FILTERS];
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);
}

67
68
69
70
void init_switchable_interp_stats() {
  vp9_zero(switchable_interp_stats);
}

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

90
91
92
93
94
95
96
97
static void update_switchable_interp_stats(VP9_COMMON *cm) {
  int i, j;
  for (i = 0; i < VP9_SWITCHABLE_FILTERS+1; ++i)
    for (j = 0; j < VP9_SWITCHABLE_FILTERS; ++j) {
      switchable_interp_stats[i][j] += cm->fc.switchable_interp_count[i][j];
    }
}

98
99
100
101
102
103
104
105
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);

106
107
108
109
  printf(
      "vp9_default_tx_count_32x32p[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB] = {\n");
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
    printf("  { ");
110
111
112
113
114
115
    for (j = 0; j < TX_SIZE_MAX_SB; j++) {
      printf("%"PRId64", ", tx_count_32x32p_stats[i][j]);
    }
    printf("},\n");
  }
  printf("};\n");
116
117
118
119
  printf(
      "vp9_default_tx_count_16x16p[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB-1] = {\n");
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
    printf("  { ");
120
121
122
123
124
125
    for (j = 0; j < TX_SIZE_MAX_SB - 1; j++) {
      printf("%"PRId64", ", tx_count_16x16p_stats[i][j]);
    }
    printf("},\n");
  }
  printf("};\n");
126
127
128
129
  printf(
      "vp9_default_tx_count_8x8p[TX_SIZE_CONTEXTS][TX_SIZE_MAX_SB-2] = {\n");
  for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
    printf("  { ");
130
131
132
133
134
135
136
    for (j = 0; j < TX_SIZE_MAX_SB - 2; j++) {
      printf("%"PRId64", ", tx_count_8x8p_stats[i][j]);
    }
    printf("},\n");
  }
  printf("};\n");
}
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

void write_switchable_interp_stats() {
  int i, j;
  FILE *fp = fopen("switchable_interp.bin", "wb");
  fwrite(switchable_interp_stats, sizeof(switchable_interp_stats), 1, fp);
  fclose(fp);

  printf(
      "vp9_default_switchable_filter_count[VP9_SWITCHABLE_FILTERS+1]"
      "[VP9_SWITCHABLE_FILTERS] = {\n");
  for (i = 0; i < VP9_SWITCHABLE_FILTERS+1; i++) {
    printf("  { ");
    for (j = 0; j < VP9_SWITCHABLE_FILTERS; j++) {
      printf("%"PRId64", ", switchable_interp_stats[i][j]);
    }
    printf("},\n");
  }
  printf("};\n");
}
156
157
#endif

158
159
static int update_bits[255];

160
161
162
163
164
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;
165
166
}

167

168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

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

188
189
190
191
192
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));
}

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
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
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
266
267
static void compute_update_table() {
  int i;
268
  for (i = 0; i < 254; i++)
269
    update_bits[i] = count_term_subexp(i, SUBEXP_PARAM, 255);
270
271
}

John Koleszar's avatar
John Koleszar committed
272
273
274
275
276
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;
277
278
}

John Koleszar's avatar
John Koleszar committed
279
static int remap_prob(int v, int m) {
280
  const int n = 255;
John Koleszar's avatar
John Koleszar committed
281
282
  const int modulus = MODULUS_PARAM;
  int i;
283
284
  v--;
  m--;
John Koleszar's avatar
John Koleszar committed
285
  if ((m << 1) <= n)
286
    i = recenter_nonneg(v, m) - 1;
John Koleszar's avatar
John Koleszar committed
287
  else
288
    i = recenter_nonneg(n - 1 - v, n - 1 - m) - 1;
John Koleszar's avatar
John Koleszar committed
289
290
291

  i = split_index(i, n - 1, modulus);
  return i;
292
}
293

294
static void write_prob_diff_update(vp9_writer *w,
295
                                   vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
296
  int delp = remap_prob(newp, oldp);
297
  encode_term_subexp(w, delp, SUBEXP_PARAM, 255);
298
299
}

300
static int prob_diff_update_cost(vp9_prob newp, vp9_prob oldp) {
John Koleszar's avatar
John Koleszar committed
301
302
  int delp = remap_prob(newp, oldp);
  return update_bits[delp] * 256;
303
}
304

305
static int prob_update_savings(const unsigned int *ct,
306
307
308
309
310
                               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;
311
  return old_b - new_b - update_b;
312
313
314
}

static int prob_diff_update_savings_search(const unsigned int *ct,
315
316
317
                                           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
318
  int new_b, update_b, savings, bestsavings, step;
319
  vp9_prob newp, bestnewp;
John Koleszar's avatar
John Koleszar committed
320
321
322
323
324
325

  bestsavings = 0;
  bestnewp = oldp;

  step = (*bestp > oldp ? -1 : 1);
  for (newp = *bestp; newp != oldp; newp += step) {
326
327
    new_b = cost_branch256(ct, newp);
    update_b = prob_diff_update_cost(newp, oldp) + vp9_cost_upd256;
John Koleszar's avatar
John Koleszar committed
328
329
330
331
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
332
    }
John Koleszar's avatar
John Koleszar committed
333
334
335
  }
  *bestp = bestnewp;
  return bestsavings;
336
337
}

338
339
340
341
static int prob_diff_update_savings_search_model(const unsigned int *ct,
                                                 const vp9_prob *oldp,
                                                 vp9_prob *bestp,
                                                 const vp9_prob upd,
342
                                                 int b, int r) {
343
344
  int i, old_b, new_b, update_b, savings, bestsavings, step;
  int newp;
345
  vp9_prob bestnewp, newplist[ENTROPY_NODES], oldplist[ENTROPY_NODES];
346
347
  vp9_model_to_full_probs(oldp, oldplist);
  vpx_memcpy(newplist, oldp, sizeof(vp9_prob) * UNCONSTRAINED_NODES);
348
349
350
  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]);
351
352

  bestsavings = 0;
353
  bestnewp = oldp[PIVOT_NODE];
354

355
  step = (*bestp > oldp[PIVOT_NODE] ? -1 : 1);
356
  newp = *bestp;
357
  for (; newp != oldp[PIVOT_NODE]; newp += step) {
358
    if (newp < 1 || newp > 255) continue;
359
    newplist[PIVOT_NODE] = newp;
360
    vp9_model_to_full_probs(newplist, newplist);
361
    for (i = UNCONSTRAINED_NODES, new_b = 0; i < ENTROPY_NODES; ++i)
362
      new_b += cost_branch256(ct + 2 * i, newplist[i]);
363
364
    new_b += cost_branch256(ct + 2 * PIVOT_NODE, newplist[PIVOT_NODE]);
    update_b = prob_diff_update_cost(newp, oldp[PIVOT_NODE]) +
365
366
367
368
369
370
371
372
373
374
375
        vp9_cost_upd256;
    savings = old_b - new_b - update_b;
    if (savings > bestsavings) {
      bestsavings = savings;
      bestnewp = newp;
    }
  }
  *bestp = bestnewp;
  return bestsavings;
}

376
377
378
379
380
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]);
381
  assert(newp >= 1);
382
383
384
  savings = prob_update_savings(ct, *oldp, newp, upd);
  if (savings > 0) {
    vp9_write(bc, 1, upd);
385
    vp9_write_prob(bc, newp);
386
387
388
389
390
391
    *oldp = newp;
  } else {
    vp9_write(bc, 0, upd);
  }
}

392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
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);
  }
}

409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
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) {
425
    vp9_cond_prob_diff_update(w, &Pcur[i], VP9_MODE_UPDATE_PROB, bct[i]);
426
427
428
429
430
431
  }
}

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

436
437
438
439
440
  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]);
441
442
}

Deb Mukherjee's avatar
Deb Mukherjee committed
443
void vp9_update_skip_probs(VP9_COMP *cpi, vp9_writer *bc) {
444
445
446
  VP9_COMMON *const pc = &cpi->common;
  int k;

Deb Mukherjee's avatar
Deb Mukherjee committed
447
448
  for (k = 0; k < MBSKIP_CONTEXTS; ++k) {
    vp9_cond_prob_diff_update(bc, &pc->fc.mbskip_probs[k],
449
                              VP9_MODE_UPDATE_PROB, pc->fc.mbskip_count[k]);
Deb Mukherjee's avatar
Deb Mukherjee committed
450
  }
451
452
453
454
455
456
}

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

457
static void update_switchable_interp_probs(VP9_COMP *const cpi,
458
                                           vp9_writer* const bc) {
459
  VP9_COMMON *const pc = &cpi->common;
460
461
462
463
464
465
466
467
468
469
470
471
472
  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_diff_update(bc, &pc->fc.switchable_interp_prob[j][i],
473
                                VP9_MODE_UPDATE_PROB, branch_ct[j][i]);
474
475
    }
  }
476
477
478
479
#ifdef MODE_STATS
  if (!cpi->dummy_packing)
    update_switchable_interp_stats(pc);
#endif
480
481
482
483
484
485
}

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

  for (i = 0; i < INTER_MODE_CONTEXTS; i++) {
486
    for (j = 0; j < VP9_INTER_MODES - 1; j++) {
487
      vp9_cond_prob_diff_update(bc, &pc->fc.inter_mode_probs[i][j],
488
                                VP9_MODE_UPDATE_PROB,
489
490
491
492
493
                                pc->fc.inter_mode_counts[i][j]);
    }
  }
}

494
static void pack_mb_tokens(vp9_writer* const bc,
495
496
497
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
498

John Koleszar's avatar
John Koleszar committed
499
  while (p < stop) {
500
    const int t = p->token;
501
    const struct vp9_token *const a = vp9_coef_encodings + t;
502
    const vp9_extra_bit *const b = vp9_extra_bits + t;
John Koleszar's avatar
John Koleszar committed
503
    int i = 0;
504
    const vp9_prob *pp;
John Koleszar's avatar
John Koleszar committed
505
    int v = a->value;
506
    int n = a->len;
507
    vp9_prob probs[ENTROPY_NODES];
John Koleszar's avatar
John Koleszar committed
508

509
    if (t == EOSB_TOKEN) {
510
511
512
      ++p;
      break;
    }
513
    if (t >= TWO_TOKEN) {
514
      vp9_model_to_full_probs(p->context_tree, probs);
515
516
517
518
      pp = probs;
    } else {
      pp = p->context_tree;
    }
519
    assert(pp != 0);
520

John Koleszar's avatar
John Koleszar committed
521
    /* skip one or two nodes */
522
#if !CONFIG_BALANCED_COEFTREE
John Koleszar's avatar
John Koleszar committed
523
524
525
526
    if (p->skip_eob_node) {
      n -= p->skip_eob_node;
      i = 2 * p->skip_eob_node;
    }
527
#endif
John Koleszar's avatar
John Koleszar committed
528

John Koleszar's avatar
John Koleszar committed
529
530
    do {
      const int bb = (v >> --n) & 1;
531
532
533
534
535
536
537
#if CONFIG_BALANCED_COEFTREE
      if (i == 2 && p->skip_eob_node) {
        i += 2;
        assert(bb == 1);
        continue;
      }
#endif
538
      vp9_write(bc, bb, pp[i >> 1]);
539
      i = vp9_coef_tree[i + bb];
540
    } while (n);
John Koleszar's avatar
John Koleszar committed
541

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

545
      if (l) {
546
        const unsigned char *pb = b->prob;
John Koleszar's avatar
John Koleszar committed
547
        int v = e >> 1;
548
        int n = l;              /* number of bits in v, assumed nonzero */
John Koleszar's avatar
John Koleszar committed
549
        int i = 0;
John Koleszar's avatar
John Koleszar committed
550

John Koleszar's avatar
John Koleszar committed
551
552
        do {
          const int bb = (v >> --n) & 1;
553
          vp9_write(bc, bb, pb[i >> 1]);
John Koleszar's avatar
John Koleszar committed
554
555
556
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
557

558
      vp9_write_bit(bc, e & 1);
John Koleszar's avatar
John Koleszar committed
559
    }
John Koleszar's avatar
John Koleszar committed
560
561
562
    ++p;
  }

563
  *tp = p;
John Koleszar's avatar
John Koleszar committed
564
565
}

566
567
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
568
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
569
  assert(NEARESTMV <= m && m <= NEWMV);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
570
#endif
571
572
  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
573
574
}

Paul Wilkins's avatar
Paul Wilkins committed
575
576
// 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.
577
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
578
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
579
580
581
  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
582
583
}

Paul Wilkins's avatar
Paul Wilkins committed
584
// This function encodes the reference frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
585
586
587
588
589
590
591
592
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
593
594
  // If segment level coding of this signal is disabled...
  // or the segment allows multiple reference frame options
595
  if (!seg_ref_active) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
596
597
598
599
600
601
602
603
604
    // 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));
    }
605

Ronald S. Bultje's avatar
Ronald S. Bultje committed
606
607
608
609
610
611
612
613
614
    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
615
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
616
617
  } else {
    assert(mi->ref_frame[1] <= INTRA_FRAME);
618
619
    assert(vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME) ==
           mi->ref_frame[0]);
John Koleszar's avatar
John Koleszar committed
620
  }
Paul Wilkins's avatar
Paul Wilkins committed
621

John Koleszar's avatar
John Koleszar committed
622
623
  // 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
624
}
John Koleszar's avatar
John Koleszar committed
625

Ronald S. Bultje's avatar
Ronald S. Bultje committed
626
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
627
                                vp9_writer *bc, int mi_row, int mi_col) {
628
  VP9_COMMON *const pc = &cpi->common;
629
  const nmv_context *nmvc = &pc->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
630
631
632
  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
633
  const MV_REFERENCE_FRAME rf = mi->ref_frame[0];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
634
635
636
  const MB_PREDICTION_MODE mode = mi->mode;
  const int segment_id = mi->segment_id;
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
637

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
641
642
#ifdef ENTROPY_STATS
  active_section = 9;
643
#endif
644

Ronald S. Bultje's avatar
Ronald S. Bultje committed
645
646
647
648
649
  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
650

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
654
655
      // If the mb segment id wasn't predicted code explicitly
      if (!prediction_flag)
Paul Wilkins's avatar
Paul Wilkins committed
656
        write_mb_segid(bc, mi, &cpi->mb.e_mbd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
657
658
659
660
661
    } else {
      // Normal unpredicted coding
      write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    }
  }
662

663
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
664
665
    skip_coeff = 1;
  } else {
666
    skip_coeff = m->mbmi.mb_skip_coeff;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
667
668
669
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
670

671
672
673
  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
674

675
676
677
678
  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;
679
680
    const vp9_prob *tx_probs = vp9_get_pred_probs(pc, xd, PRED_TX_SIZE);
    vp9_write(bc, sz != TX_4X4, tx_probs[0]);
681
    if (mi->sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
682
      vp9_write(bc, sz != TX_8X8, tx_probs[1]);
683
      if (mi->sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
684
        vp9_write(bc, sz != TX_16X16, tx_probs[2]);
685
686
687
    }
  }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
688
  if (rf == INTRA_FRAME) {
689
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
690
    active_section = 6;
691
#endif
Paul Wilkins's avatar
Paul Wilkins committed
692

693
    if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
694
695
696
697
      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)]);
698
    } else {
699
700
701
702
      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)
703
704
705
706
        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
707
    }
708
709
    write_intra_mode(bc, mi->uv_mode,
                     pc->fc.uv_mode_prob[mode]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
710
  } else {
711
    vp9_prob mv_ref_p[VP9_INTER_MODES - 1];
712

Ronald S. Bultje's avatar
Ronald S. Bultje committed
713
714
    encode_ref_frame(cpi, bc);

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

John Koleszar's avatar
John Koleszar committed
717
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
718
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
719
720
#endif

721
    // If segment skip is not enabled code the mode.
Paul Wilkins's avatar
Paul Wilkins committed
722
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
723
      if (mi->sb_type >= BLOCK_SIZE_SB8X8) {
724
        write_sb_mv_ref(bc, mode, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
725
726
        vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
727
    }
728

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
    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) {
754
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
755
            active_section = 11;
756
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
757
758
            vp9_encode_mv(bc, &blockmv.as_mv, &mi->best_mv.as_mv,
                          nmvc, xd->allow_high_precision_mv);
759

Ronald S. Bultje's avatar
Ronald S. Bultje committed
760
            if (mi->ref_frame[1] > INTRA_FRAME)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
761
762
763
              vp9_encode_mv(bc,
                            &cpi->mb.partition_info->bmi[j].second_mv.as_mv,
                            &mi->best_second_mv.as_mv,
764
                            nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
765
          }
766
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
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);

Ronald S. Bultje's avatar
Ronald S. Bultje committed
776
      if (mi->ref_frame[1] > INTRA_FRAME)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
777
778
779
        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
780
781
    }
  }
John Koleszar's avatar
John Koleszar committed
782
}
783

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

794
  if (xd->update_mb_segmentation_map)
795
796
    write_mb_segid(bc, &m->mbmi, xd);

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

804
805
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8 && c->txfm_mode == TX_MODE_SELECT) {
    TX_SIZE sz = m->mbmi.txfm_size;
806
807
    const vp9_prob *tx_probs = vp9_get_pred_probs(c, xd, PRED_TX_SIZE);
    vp9_write(bc, sz != TX_4X4, tx_probs[0]);
808
    if (m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
809
      vp9_write(bc, sz != TX_8X8, tx_probs[1]);
810
      if (m->mbmi.sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
811
        vp9_write(bc, sz != TX_16X16, tx_probs[2]);
812
813
814
    }
  }

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

839
  write_intra_mode(bc, m->mbmi.uv_mode, c->kf_uv_mode_prob[ym]);
840
841
}

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

848
849
850
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
851
  xd->mode_info_context = m;
852
853
854
  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
855
  if ((cm->frame_type == KEY_FRAME) || cm->intra_only) {
856
    write_mb_modes_kf(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
857
858
859
860
#ifdef ENTROPY_STATS
    active_section = 8;
#endif
  } else {
861
    pack_inter_mode_mvs(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
862
863
864
865
866
867
868
869
870
#ifdef ENTROPY_STATS
    active_section = 1;
#endif
  }

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

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

885
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
886
887
    return;

888
889
  bwl = b_width_log2(m->mbmi.sb_type);
  bhl = b_height_log2(m->mbmi.sb_type);
890
891
892
893
894
895
896
897
898
899
900
901
902

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

903
  if (bsize < BLOCK_SIZE_SB8X8)
904
    if (xd->ab_index > 0)
905
906
907
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
908
    int pl;
909
    int idx = check_bsize_coverage(cm, xd, mi_row, mi_col, bsize);
910
911
    xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = cm->above_seg_context + mi_col;
912
    pl = partition_plane_context(xd, bsize);
913
    // encode the partition information
914
915
916
917
918
919
920
    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]);
921
  }
922

923
  subsize = get_subsize(bsize, partition);
924
  *(get_sb_index(xd, subsize)) = 0;
925

926
927
  switch (partition) {
    case PARTITION_NONE:
928
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
929
930
      break;
    case PARTITION_HORZ:
931
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
932
      *(get_sb_index(xd, subsize)) = 1;
933
934
      if ((mi_row + bs) < cm->mi_rows)
        write_modes_b(cpi, m + bs * mis, bc, tok, tok_end, mi_row + bs, mi_col);
935
936
      break;
    case PARTITION_VERT:
937
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
938
      *(get_sb_index(xd, subsize)) = 1;
939
940
      if ((mi_col + bs) < cm->mi_cols)
        write_modes_b(cpi, m + bs, bc, tok, tok_end, mi_row, mi_col + bs);
941
942
943
944
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
945
        *(get_sb_index(xd, subsize)) = n;
946
        write_modes_sb(cpi, m + j * bs * mis + i * bs, bc, tok, tok_end,
947
                       mi_row + j * bs, mi_col + i * bs, subsize);
948
949
950
951
952
      }
      break;
    default:
      assert(0);
  }
953
954

  // update partition context
955
956
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
957
958
959
    set_partition_seg_context(cm, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
960
961
}

962
static void write_modes(VP9_COMP *cpi, vp9_writer* const bc,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
963
                        TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
964
  VP9_COMMON *const c = &cpi->common;
John Koleszar's avatar
John Koleszar committed
965
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
966
  MODE_INFO *m, *m_ptr = c->mi;
967
  int mi_row, mi_col;
John Koleszar's avatar
John Koleszar committed
968

969
  m_ptr += c->cur_tile_mi_col_start + c->cur_tile_mi_row_start * mis;
970

971
972
  for (mi_row = c->cur_tile_mi_row_start;
       mi_row < c->cur_tile_mi_row_end;
Jingning Han's avatar
Jingning Han committed
973
       mi_row += 8, m_ptr += 8 * mis) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
974
    m = m_ptr;
975
    vpx_memset(c->left_seg_context, 0, sizeof(c->left_seg_context));
976
977
    for (mi_col = c->cur_tile_mi_col_start;
         mi_col < c->cur_tile_mi_col_end;
978
         mi_col += 64 / MI_SIZE, m += 64 / MI_SIZE)
979
      write_modes_sb(cpi, m, bc, tok, tok_end, mi_row, mi_col,
980
                     BLOCK_SIZE_SB64X64);
John Koleszar's avatar
John Koleszar committed
981
  }
John Koleszar's avatar
John Koleszar committed
982
}
983

984
/* This function is used for debugging probability trees. */
985
static void print_prob_tree(vp9_coeff_probs *coef_probs, int block_types) {
John Koleszar's avatar
John Koleszar committed
986
  /* print coef probability tree */
987
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
988
989
  FILE *f = fopen("enc_tree_probs.txt", "a");
  fprintf(f, "{\n");
990
  for (i = 0; i < block_types; i++) {
John Koleszar's avatar
John Koleszar committed
991
    fprintf(f, "  {\n");
992
993
994
995
996
997
998
999
1000
1001
    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]));
          }
1002
        }
John Koleszar's avatar
John Koleszar committed
1003
1004
1005
        fprintf(f, " }\n");
      }
      fprintf(f, "    }\n");
1006
    }
John Koleszar's avatar
John Koleszar committed
1007
1008
1009
1010
    fprintf(f, "  }\n");
  }
  fprintf(f, "}\n");
  fclose(f);
Stefan Holmer's avatar