vp9_bitstream.c 52.6 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

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

84
85
86
87
88
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));
}

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
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
162
163
164
static void compute_update_table() {
  int i;
  for (i = 0; i < 255; i++)
165
    update_bits[i] = count_term_subexp(i, SUBEXP_PARAM, 255);
166
167
}

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

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

  i = split_index(i, n - 1, modulus);
  return i;
186
}
187

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

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

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

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

  bestsavings = 0;
  bestnewp = oldp;

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

232
233
234
235
static int prob_diff_update_savings_search_model(const unsigned int *ct,
                                                 const vp9_prob *oldp,
                                                 vp9_prob *bestp,
                                                 const vp9_prob upd,
236
                                                 int b, int r) {
237
238
  int i, old_b, new_b, update_b, savings, bestsavings, step;
  int newp;
239
  vp9_prob bestnewp, newplist[ENTROPY_NODES], oldplist[ENTROPY_NODES];
240
241
  vp9_model_to_full_probs(oldp, oldplist);
  vpx_memcpy(newplist, oldp, sizeof(vp9_prob) * UNCONSTRAINED_NODES);
242
243
244
  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]);
245
246

  bestsavings = 0;
247
  bestnewp = oldp[PIVOT_NODE];
248

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

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

286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
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);
  }
}

303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
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;
326
  int j;
327
328
329
  vp9_prob pnew[VP9_INTRA_MODES - 1];
  unsigned int bct[VP9_INTRA_MODES - 1][2];

330
331
332
333
334
  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]);
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
}

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

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

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
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++) {
376
    for (j = 0; j < VP9_INTER_MODES - 1; j++) {
377
378
379
380
381
382
383
384
385
386
      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]);
    }
  }
}

387
static void pack_mb_tokens(vp9_writer* const bc,
388
389
390
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
391

John Koleszar's avatar
John Koleszar committed
392
  while (p < stop) {
393
    const int t = p->token;
394
    const struct vp9_token *const a = vp9_coef_encodings + t;
395
    const vp9_extra_bit *const b = vp9_extra_bits + t;
John Koleszar's avatar
John Koleszar committed
396
    int i = 0;
397
    const vp9_prob *pp;
John Koleszar's avatar
John Koleszar committed
398
    int v = a->value;
399
    int n = a->len;
400
    vp9_prob probs[ENTROPY_NODES];
John Koleszar's avatar
John Koleszar committed
401

402
    if (t == EOSB_TOKEN) {
403
404
405
      ++p;
      break;
    }
406
    if (t >= TWO_TOKEN) {
407
      vp9_model_to_full_probs(p->context_tree, probs);
408
409
410
411
      pp = probs;
    } else {
      pp = p->context_tree;
    }
412
    assert(pp != 0);
413

John Koleszar's avatar
John Koleszar committed
414
    /* skip one or two nodes */
415
#if !CONFIG_BALANCED_COEFTREE
John Koleszar's avatar
John Koleszar committed
416
417
418
419
    if (p->skip_eob_node) {
      n -= p->skip_eob_node;
      i = 2 * p->skip_eob_node;
    }
420
#endif
John Koleszar's avatar
John Koleszar committed
421

John Koleszar's avatar
John Koleszar committed
422
423
    do {
      const int bb = (v >> --n) & 1;
424
425
426
427
428
429
430
#if CONFIG_BALANCED_COEFTREE
      if (i == 2 && p->skip_eob_node) {
        i += 2;
        assert(bb == 1);
        continue;
      }
#endif
431
      vp9_write(bc, bb, pp[i >> 1]);
432
      i = vp9_coef_tree[i + bb];
433
    } while (n);
John Koleszar's avatar
John Koleszar committed
434

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

438
      if (l) {
439
        const unsigned char *pb = b->prob;
John Koleszar's avatar
John Koleszar committed
440
        int v = e >> 1;
441
        int n = l;              /* number of bits in v, assumed nonzero */
John Koleszar's avatar
John Koleszar committed
442
        int i = 0;
John Koleszar's avatar
John Koleszar committed
443

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

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

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

459
460
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
461
#if CONFIG_DEBUG
Ronald S. Bultje's avatar
Ronald S. Bultje committed
462
  assert(NEARESTMV <= m && m <= NEWMV);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
463
#endif
464
465
  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
466
467
}

Paul Wilkins's avatar
Paul Wilkins committed
468
469
// 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.
470
static void write_mb_segid(vp9_writer *bc,
Paul Wilkins's avatar
Paul Wilkins committed
471
                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
472
473
474
  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
475
476
}

Paul Wilkins's avatar
Paul Wilkins committed
477
// This function encodes the reference frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
478
479
480
481
482
483
484
485
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
486
487
  // If segment level coding of this signal is disabled...
  // or the segment allows multiple reference frame options
488
  if (!seg_ref_active) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
489
490
491
492
493
494
495
496
497
    // 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));
    }
498

Ronald S. Bultje's avatar
Ronald S. Bultje committed
499
500
501
502
503
504
505
506
507
    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
508
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
509
510
  } else {
    assert(mi->ref_frame[1] <= INTRA_FRAME);
511
512
    assert(vp9_get_segdata(xd, segment_id, SEG_LVL_REF_FRAME) ==
           mi->ref_frame[0]);
John Koleszar's avatar
John Koleszar committed
513
  }
Paul Wilkins's avatar
Paul Wilkins committed
514

John Koleszar's avatar
John Koleszar committed
515
516
  // 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
517
}
John Koleszar's avatar
John Koleszar committed
518

Ronald S. Bultje's avatar
Ronald S. Bultje committed
519
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
520
                                vp9_writer *bc, int mi_row, int mi_col) {
521
  VP9_COMMON *const pc = &cpi->common;
522
  const nmv_context *nmvc = &pc->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
523
524
525
  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
526
  const MV_REFERENCE_FRAME rf = mi->ref_frame[0];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
527
528
529
  const MB_PREDICTION_MODE mode = mi->mode;
  const int segment_id = mi->segment_id;
  int skip_coeff;
Adrian Grange's avatar
Adrian Grange committed
530

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
534
535
#ifdef ENTROPY_STATS
  active_section = 9;
536
#endif
537

Ronald S. Bultje's avatar
Ronald S. Bultje committed
538
539
540
541
542
  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
543

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
547
548
      // If the mb segment id wasn't predicted code explicitly
      if (!prediction_flag)
Paul Wilkins's avatar
Paul Wilkins committed
549
        write_mb_segid(bc, mi, &cpi->mb.e_mbd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
550
551
552
553
554
    } else {
      // Normal unpredicted coding
      write_mb_segid(bc, mi, &cpi->mb.e_mbd);
    }
  }
555

556
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
557
558
    skip_coeff = 1;
  } else {
559
    skip_coeff = m->mbmi.mb_skip_coeff;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
560
561
562
    vp9_write(bc, skip_coeff,
              vp9_get_pred_prob(pc, xd, PRED_MBSKIP));
  }
John Koleszar's avatar
John Koleszar committed
563

564
565
566
  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
567

568
569
570
571
  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;
572
573
    int tx_probs_offset = get_tx_probs_offset(mi->sb_type);
    vp9_write(bc, sz != TX_4X4, pc->fc.tx_probs[tx_probs_offset]);
574
    if (mi->sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
575
      vp9_write(bc, sz != TX_8X8, pc->fc.tx_probs[tx_probs_offset + 1]);
576
      if (mi->sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
577
        vp9_write(bc, sz != TX_16X16, pc->fc.tx_probs[tx_probs_offset + 2]);
578
579
580
    }
  }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
581
  if (rf == INTRA_FRAME) {
582
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
583
    active_section = 6;
584
#endif
Paul Wilkins's avatar
Paul Wilkins committed
585

586
    if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
587
588
589
590
      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)]);
591
    } else {
592
593
594
595
      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)
596
597
598
599
        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
600
    }
601
602
    write_intra_mode(bc, mi->uv_mode,
                     pc->fc.uv_mode_prob[mode]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
603
  } else {
604
    vp9_prob mv_ref_p[VP9_INTER_MODES - 1];
605

Ronald S. Bultje's avatar
Ronald S. Bultje committed
606
607
    encode_ref_frame(cpi, bc);

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

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

614
    // If segment skip is not enabled code the mode.
Paul Wilkins's avatar
Paul Wilkins committed
615
    if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
616
      if (mi->sb_type >= BLOCK_SIZE_SB8X8) {
617
        write_sb_mv_ref(bc, mode, mv_ref_p);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
618
619
        vp9_accum_mv_refs(&cpi->common, mode, mi->mb_mode_context[rf]);
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
620
    }
621

Ronald S. Bultje's avatar
Ronald S. Bultje committed
622
623
624
625
626
627
628
629
    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
630
    }
631

Ronald S. Bultje's avatar
Ronald S. Bultje committed
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
    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) {
647
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
648
            active_section = 11;
649
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
650
651
            vp9_encode_mv(bc, &blockmv.as_mv, &mi->best_mv.as_mv,
                          nmvc, xd->allow_high_precision_mv);
652

Ronald S. Bultje's avatar
Ronald S. Bultje committed
653
            if (mi->ref_frame[1] > INTRA_FRAME)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
654
655
656
              vp9_encode_mv(bc,
                            &cpi->mb.partition_info->bmi[j].second_mv.as_mv,
                            &mi->best_second_mv.as_mv,
657
                            nmvc, xd->allow_high_precision_mv);
John Koleszar's avatar
John Koleszar committed
658
          }
659
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
660
      }
661
662

#ifdef MODE_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
663
      ++count_mb_seg[mi->partitioning];
664
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
665
666
667
668
669
670
671
672
    } 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
673
      if (mi->ref_frame[1] > INTRA_FRAME)
Ronald S. Bultje's avatar
Ronald S. Bultje committed
674
675
676
        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
677
678
    }
  }
John Koleszar's avatar
John Koleszar committed
679
}
680

Ronald S. Bultje's avatar
Ronald S. Bultje committed
681
static void write_mb_modes_kf(const VP9_COMP *cpi,
682
                              MODE_INFO *m,
683
                              vp9_writer *bc, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
684
685
686
  const VP9_COMMON *const c = &cpi->common;
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
  const int ym = m->mbmi.mode;
687
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
688
689
  const int segment_id = m->mbmi.segment_id;
  int skip_coeff;
690

691
  if (xd->update_mb_segmentation_map)
692
693
    write_mb_segid(bc, &m->mbmi, xd);

694
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
695
696
    skip_coeff = 1;
  } else {
697
    skip_coeff = m->mbmi.mb_skip_coeff;
698
    vp9_write(bc, skip_coeff, vp9_get_pred_prob(c, xd, PRED_MBSKIP));
699
700
  }

701
702
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8 && c->txfm_mode == TX_MODE_SELECT) {
    TX_SIZE sz = m->mbmi.txfm_size;
703
704
    int tx_probs_offset = get_tx_probs_offset(m->mbmi.sb_type);
    vp9_write(bc, sz != TX_4X4, c->fc.tx_probs[tx_probs_offset]);
705
    if (m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
706
      vp9_write(bc, sz != TX_8X8, c->fc.tx_probs[tx_probs_offset + 1]);
707
      if (m->mbmi.sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
708
        vp9_write(bc, sz != TX_16X16, c->fc.tx_probs[tx_probs_offset + 2]);
709
710
711
    }
  }

712
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
Yaowu Xu's avatar
Yaowu Xu committed
713
714
    const MB_PREDICTION_MODE A = above_block_mode(m, 0, mis);
    const MB_PREDICTION_MODE L = xd->left_available ?
715
                                 left_block_mode(m, 0) : DC_PRED;
716
717
    write_intra_mode(bc, ym, c->kf_y_mode_prob[A][L]);
  } else {
718
719
720
    int idx, idy;
    int bw = 1 << b_width_log2(m->mbmi.sb_type);
    int bh = 1 << b_height_log2(m->mbmi.sb_type);
721
722
723
    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
724
725
        const MB_PREDICTION_MODE A = above_block_mode(m, i, mis);
        const MB_PREDICTION_MODE L = (xd->left_available || idx) ?
726
                                     left_block_mode(m, i) : DC_PRED;
727
728
729
730
        const int bm = m->bmi[i].as_mode.first;
#ifdef ENTROPY_STATS
        ++intra_mode_stats[A][L][bm];
#endif
731
        write_intra_mode(bc, bm, c->kf_y_mode_prob[A][L]);
732
733
      }
    }
734
735
  }

736
  write_intra_mode(bc, m->mbmi.uv_mode, c->kf_uv_mode_prob[ym]);
737
738
}

Ronald S. Bultje's avatar
Ronald S. Bultje committed
739
740
static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
                          TOKENEXTRA **tok, TOKENEXTRA *tok_end,
741
                          int mi_row, int mi_col) {
742
  VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
743
744
  MACROBLOCKD *const xd = &cpi->mb.e_mbd;

745
746
747
  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
748
  xd->mode_info_context = m;
749
750
751
  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));
752
  if (cm->frame_type == KEY_FRAME) {
753
    write_mb_modes_kf(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
754
755
756
757
#ifdef ENTROPY_STATS
    active_section = 8;
#endif
  } else {
758
    pack_inter_mode_mvs(cpi, m, bc, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
759
760
761
762
763
764
765
766
767
#ifdef ENTROPY_STATS
    active_section = 1;
#endif
  }

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

768
769
static void write_modes_sb(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
                           TOKENEXTRA **tok, TOKENEXTRA *tok_end,
770
                           int mi_row, int mi_col,
771
772
                           BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON *const cm = &cpi->common;
773
  MACROBLOCKD *xd = &cpi->mb.e_mbd;
774
775
  const int mis = cm->mode_info_stride;
  int bwl, bhl;
776
777
  int bsl = b_width_log2(bsize);
  int bs = (1 << bsl) / 4;  // mode_info step for subsize
778
779
780
781
  int n;
  PARTITION_TYPE partition;
  BLOCK_SIZE_TYPE subsize;

782
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
783
784
    return;

785
786
  bwl = b_width_log2(m->mbmi.sb_type);
  bhl = b_height_log2(m->mbmi.sb_type);
787
788
789
790
791
792
793
794
795
796
797
798
799

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

800
  if (bsize < BLOCK_SIZE_SB8X8)
801
    if (xd->ab_index > 0)
802
803
804
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
805
    int pl;
806
    int idx = check_bsize_coverage(cm, xd, mi_row, mi_col, bsize);
807
808
    xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = cm->above_seg_context + mi_col;
809
    pl = partition_plane_context(xd, bsize);
810
    // encode the partition information
811
812
813
814
815
816
817
    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]);
818
  }
819

820
  subsize = get_subsize(bsize, partition);
821
  *(get_sb_index(xd, subsize)) = 0;
822

823
824
  switch (partition) {
    case PARTITION_NONE:
825
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
826
827
      break;
    case PARTITION_HORZ:
828
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
829
      *(get_sb_index(xd, subsize)) = 1;
830
831
      if ((mi_row + bs) < cm->mi_rows)
        write_modes_b(cpi, m + bs * mis, bc, tok, tok_end, mi_row + bs, mi_col);
832
833
      break;
    case PARTITION_VERT:
834
      write_modes_b(cpi, m, bc, tok, tok_end, mi_row, mi_col);
835
      *(get_sb_index(xd, subsize)) = 1;
836
837
      if ((mi_col + bs) < cm->mi_cols)
        write_modes_b(cpi, m + bs, bc, tok, tok_end, mi_row, mi_col + bs);
838
839
840
841
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
842
        *(get_sb_index(xd, subsize)) = n;
843
        write_modes_sb(cpi, m + j * bs * mis + i * bs, bc, tok, tok_end,
844
                       mi_row + j * bs, mi_col + i * bs, subsize);
845
846
847
848
849
      }
      break;
    default:
      assert(0);
  }
850
851

  // update partition context
852
853
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
854
855
856
    set_partition_seg_context(cm, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
857
858
}

859
static void write_modes(VP9_COMP *cpi, vp9_writer* const bc,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
860
                        TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
861
  VP9_COMMON *const c = &cpi->common;
John Koleszar's avatar
John Koleszar committed
862
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
863
  MODE_INFO *m, *m_ptr = c->mi;
864
  int mi_row, mi_col;
John Koleszar's avatar
John Koleszar committed
865

866
  m_ptr += c->cur_tile_mi_col_start + c->cur_tile_mi_row_start * mis;
867
  vpx_memset(c->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
868
             mi_cols_aligned_to_sb(c));
869

870
871
  for (mi_row = c->cur_tile_mi_row_start;
       mi_row < c->cur_tile_mi_row_end;
Jingning Han's avatar
Jingning Han committed
872
       mi_row += 8, m_ptr += 8 * mis) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
873
    m = m_ptr;
874
    vpx_memset(c->left_seg_context, 0, sizeof(c->left_seg_context));
875
876
    for (mi_col = c->cur_tile_mi_col_start;
         mi_col < c->cur_tile_mi_col_end;
877
         mi_col += 64 / MI_SIZE, m += 64 / MI_SIZE)
878
      write_modes_sb(cpi, m, bc, tok, tok_end, mi_row, mi_col,
879
                     BLOCK_SIZE_SB64X64);
John Koleszar's avatar
John Koleszar committed
880
  }
John Koleszar's avatar
John Koleszar committed
881
}
882

883
/* This function is used for debugging probability trees. */
884
static void print_prob_tree(vp9_coeff_probs *coef_probs, int block_types) {
John Koleszar's avatar
John Koleszar committed
885
  /* print coef probability tree */
886
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
887
888
  FILE *f = fopen("enc_tree_probs.txt", "a");
  fprintf(f, "{\n");
889
  for (i = 0; i < block_types; i++) {
John Koleszar's avatar
John Koleszar committed
890
    fprintf(f, "  {\n");
891
892
893
894
895
896
897
898
899
900
    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]));
          }
901
        }
John Koleszar's avatar
John Koleszar committed
902
903
904
        fprintf(f, " }\n");
      }
      fprintf(f, "    }\n");
905
    }
John Koleszar's avatar
John Koleszar committed
906
907
908
909
    fprintf(f, "  }\n");
  }
  fprintf(f, "}\n");
  fclose(f);
910
911
}

912
913
914
915
916
917
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];
918
  vp9_prob full_probs[ENTROPY_NODES];
919
  int i, j, k, l;
920

921
  for (i = 0; i < BLOCK_TYPES; ++i) {
922
923
924
925
926
    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;
927
928
          vp9_tree_probs_from_distribution(vp9_coef_tree,
                                           full_probs,
929
                                           coef_branch_ct[i][j][k][l],
930
931
932
                                           coef_counts[i][j][k][l], 0);
          vpx_memcpy(coef_probs[i][j][k][l], full_probs,
                     sizeof(vp9_prob) * UNCONSTRAINED_NODES);
933
934
935
936
937
938
939
#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
940
941
942
943
944
          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]);
945
#endif
946
#ifdef ENTROPY_STATS
947
          if (!cpi->dummy_packing) {
948
            int t;
949
            for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
950
951
952
              context_counters[txfm_size][i][j][k][l][t] +=
                  coef_counts[i][j][k][l][t];
            context_counters[txfm_size][i][j][k][l][MAX_ENTROPY_TOKENS] +=
953
954
                eob_branch_ct[i][j][k][l];
          }
John Koleszar's avatar
John Koleszar committed
955
#endif
956
        }
Daniel Kang's avatar
Daniel Kang committed
957
958
959
      }
    }
  }
960
961
962
}

static void build_coeff_contexts(VP9_COMP *cpi) {
963
964
965
  TX_SIZE t;
  for (t = TX_4X4; t <= TX_32X32; t++)
    build_tree_distribution(cpi, t);
John Koleszar's avatar
John Koleszar committed
966
967
}

968
969
970
971
972
973
static void update_coef_probs_common(vp9_writer* const bc, VP9_COMP *cpi,
                                     TX_SIZE tx_size) {
  vp9_coeff_probs_model *new_frame_coef_probs = cpi->frame_coef_probs[tx_size];
  vp9_coeff_probs_model *old_frame_coef_probs =
      cpi->common.fc.coef_probs[tx_size];
  vp9_coeff_stats *frame_branch_ct = cpi->frame_branch_ct[tx_size];
974
  int i, j, k, l, t;
John Koleszar's avatar
John Koleszar committed
975
976
  int update[2] = {0, 0};
  int savings;
977
978

  const int entropy_nodes_update = UNCONSTRAINED_NODES;
979

980
  const int tstart = 0;
John Koleszar's avatar
John Koleszar committed
981
982
  /* dry run to see if there is any udpate at all needed */
  savings = 0;
983
  for (i = 0; i < BLOCK_TYPES; ++i) {
984
985
    for (j = 0; j < REF_TYPES; ++j) {
      for (k = 0; k < COEF_BANDS; ++k) {
986
        // int prev_coef_savings[ENTROPY_NODES] = {0};
987
        for (l = 0; l < PREV_COEF_CONTEXTS; ++l) {
988
          for (t = tstart; t < entropy_nodes_update; ++t) {
989
990
            vp9_prob newp = new_frame_coef_probs[i][j][k][l][t];
            const vp9_prob oldp = old_frame_coef_probs[i][j][k][l][t];
991
            const vp9_prob upd = vp9_coef_update_prob[t];
992
            int s;
993
994
995
996
            int