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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
564
  vp9_write(bc, rf != INTRA_FRAME, vp9_get_pred_prob(pc, xd, PRED_INTRA_INTER));
Paul Wilkins's avatar
Paul Wilkins committed
565

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

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

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
604
605
    encode_ref_frame(cpi, bc);

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

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

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

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

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

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

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

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

689
  if (xd->update_mb_segmentation_map)
690
691
    write_mb_segid(bc, &m->mbmi, xd);

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

699
700
  if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8 && c->txfm_mode == TX_MODE_SELECT) {
    TX_SIZE sz = m->mbmi.txfm_size;
701
702
    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]);
703
    if (m->mbmi.sb_type >= BLOCK_SIZE_MB16X16 && sz != TX_4X4) {
704
      vp9_write(bc, sz != TX_8X8, c->fc.tx_probs[tx_probs_offset + 1]);
705
      if (m->mbmi.sb_type >= BLOCK_SIZE_SB32X32 && sz != TX_8X8)
706
        vp9_write(bc, sz != TX_16X16, c->fc.tx_probs[tx_probs_offset + 2]);
707
708
709
    }
  }

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

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

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

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

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

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

780
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
781
782
    return;

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

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

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

  if (bsize >= BLOCK_SIZE_SB8X8) {
803
    int pl;
804
805
    xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = cm->above_seg_context + mi_col;
806
    pl = partition_plane_context(xd, bsize);
807
    // encode the partition information
808
809
    write_token(bc, vp9_partition_tree,
                cm->fc.partition_prob[cm->frame_type][pl],
810
                vp9_partition_encodings + partition);
811
  }
812

813
  subsize = get_subsize(bsize, partition);
814
  *(get_sb_index(xd, subsize)) = 0;
815

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

  // update partition context
845
846
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
847
848
849
    set_partition_seg_context(cm, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
850
851
}

852
static void write_modes(VP9_COMP *cpi, vp9_writer* const bc,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
853
                        TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
854
  VP9_COMMON *const c = &cpi->common;
John Koleszar's avatar
John Koleszar committed
855
  const int mis = c->mode_info_stride;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
856
  MODE_INFO *m, *m_ptr = c->mi;
857
  int mi_row, mi_col;
John Koleszar's avatar
John Koleszar committed
858

859
  m_ptr += c->cur_tile_mi_col_start + c->cur_tile_mi_row_start * mis;
860
  vpx_memset(c->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
861
             mi_cols_aligned_to_sb(c));
862

863
864
  for (mi_row = c->cur_tile_mi_row_start;
       mi_row < c->cur_tile_mi_row_end;
Jingning Han's avatar
Jingning Han committed
865
       mi_row += 8, m_ptr += 8 * mis) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
866
    m = m_ptr;
867
    vpx_memset(c->left_seg_context, 0, sizeof(c->left_seg_context));
868
869
    for (mi_col = c->cur_tile_mi_col_start;
         mi_col < c->cur_tile_mi_col_end;
870
         mi_col += 64 / MI_SIZE, m += 64 / MI_SIZE)
871
      write_modes_sb(cpi, m, bc, tok, tok_end, mi_row, mi_col,
872
                     BLOCK_SIZE_SB64X64);
John Koleszar's avatar
John Koleszar committed
873
  }
John Koleszar's avatar
John Koleszar committed
874
}
875

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

905
906
907
908
909
910
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];
911
  vp9_prob full_probs[ENTROPY_NODES];
912
  int i, j, k, l;
913

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

static void build_coeff_contexts(VP9_COMP *cpi) {
956
957
958
  TX_SIZE t;
  for (t = TX_4X4; t <= TX_32X32; t++)
    build_tree_distribution(cpi, t);
John Koleszar's avatar
John Koleszar committed
959
960
}

961
962
963
964
965
966
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];
967
  int i, j, k, l, t;
John Koleszar's avatar
John Koleszar committed
968
969
  int update[2] = {0, 0};
  int savings;
970
971

  const int entropy_nodes_update = UNCONSTRAINED_NODES;
972

973
  const int tstart = 0;
John Koleszar's avatar
John Koleszar committed
974
975
  /* dry run to see if there is any udpate at all needed */
  savings = 0;
976
  for (i = 0; i < BLOCK_TYPES; ++i) {
977
978
    for (j = 0; j < REF_TYPES; ++j) {
      for (k = 0; k < COEF_BANDS; ++k) {
979
        // int prev_coef_savings[ENTROPY_NODES] = {0};
980
        for (l = 0; l < PREV_COEF_CONTEXTS; ++l) {
981
          for (t = tstart; t < entropy_nodes_update; ++t) {
982
983
            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];
984
            const vp9_prob upd = vp9_coef_update_prob[t];
985
            int s;
986
987
988
989
            int u = 0;

            if (l >= 3 && k == 0)
              continue;
990
            if (t == PIVOT_NODE)