vp9_bitstream.c 44.2 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_tile_common.h"
21
22
23
24
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_entropy.h"
#include "vp9/common/vp9_mvref_common.h"
25
26
27
28
29
30
31
#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"
32
#include "vp9/encoder/vp9_subexp.h"
33
#include "vp9/encoder/vp9_tokenize.h"
34
35
#include "vp9/encoder/vp9_write_bit_buffer.h"

Paul Wilkins's avatar
Paul Wilkins committed
36

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

#ifdef ENTROPY_STATS
42
vp9_coeff_stats tree_update_hist[TX_SIZES][PLANE_TYPES];
John Koleszar's avatar
John Koleszar committed
43
44
45
extern unsigned int active_section;
#endif

46
47
48
49
50
51
52
53
54
55
56
57
58
59
static struct vp9_token intra_mode_encodings[INTRA_MODES];
static struct vp9_token switchable_interp_encodings[SWITCHABLE_FILTERS];
static struct vp9_token partition_encodings[PARTITION_TYPES];
static struct vp9_token inter_mode_encodings[INTER_MODES];

void vp9_entropy_mode_init() {
  vp9_tokens_from_tree(intra_mode_encodings, vp9_intra_mode_tree);
  vp9_tokens_from_tree(switchable_interp_encodings, vp9_switchable_interp_tree);
  vp9_tokens_from_tree(partition_encodings, vp9_partition_tree);
  vp9_tokens_from_tree(inter_mode_encodings, vp9_inter_mode_tree);
}

static void write_intra_mode(vp9_writer *w, MB_PREDICTION_MODE mode,
                             const vp9_prob *probs) {
60
  vp9_write_token(w, vp9_intra_mode_tree, probs, &intra_mode_encodings[mode]);
61
62
63
64
65
}

static void write_inter_mode(vp9_writer *w, MB_PREDICTION_MODE mode,
                             const vp9_prob *probs) {
  assert(is_inter_mode(mode));
66
67
  vp9_write_token(w, vp9_inter_mode_tree, probs,
                  &inter_mode_encodings[INTER_OFFSET(mode)]);
68
69
}

70
71
72
73
74
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;
75
76
}

77
78
79
80
81
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));
}

82
83
84
85
86
87
static void prob_diff_update(const vp9_tree_index *tree,
                             vp9_prob probs[/*n - 1*/],
                             const unsigned int counts[/*n - 1*/],
                             int n, vp9_writer *w) {
  int i;
  unsigned int branch_ct[32][2];
88
89

  // Assuming max number of probabilities <= 32
90
  assert(n <= 32);
91

92
  vp9_tree_probs_from_distribution(tree, branch_ct, counts);
93
  for (i = 0; i < n - 1; ++i)
94
    vp9_cond_prob_diff_update(w, &probs[i], branch_ct[i]);
95
96
}

97
98
99
static void write_selected_tx_size(const VP9_COMP *cpi, MODE_INFO *m,
                                   TX_SIZE tx_size, BLOCK_SIZE bsize,
                                   vp9_writer *w) {
100
  const TX_SIZE max_tx_size = max_txsize_lookup[bsize];
101
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
102
103
  const vp9_prob *const tx_probs = get_tx_probs2(max_tx_size, xd,
                                                 &cpi->common.fc.tx_probs);
104
  vp9_write(w, tx_size != TX_4X4, tx_probs[0]);
105
  if (tx_size != TX_4X4 && max_tx_size >= TX_16X16) {
106
    vp9_write(w, tx_size != TX_8X8, tx_probs[1]);
107
    if (tx_size != TX_8X8 && max_tx_size >= TX_32X32)
108
109
110
111
      vp9_write(w, tx_size != TX_16X16, tx_probs[2]);
  }
}

112
113
114
static int write_skip_coeff(const VP9_COMP *cpi, int segment_id, MODE_INFO *m,
                            vp9_writer *w) {
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
115
  if (vp9_segfeature_active(&cpi->common.seg, segment_id, SEG_LVL_SKIP)) {
116
117
    return 1;
  } else {
118
119
120
    const int skip = m->mbmi.skip_coeff;
    vp9_write(w, skip, vp9_get_skip_prob(&cpi->common, xd));
    return skip;
121
122
123
  }
}

124
void vp9_update_skip_probs(VP9_COMMON *cm, vp9_writer *w) {
125
126
  int k;

127
  for (k = 0; k < MBSKIP_CONTEXTS; ++k)
128
    vp9_cond_prob_diff_update(w, &cm->fc.mbskip_probs[k], cm->counts.mbskip[k]);
129
130
}

131
static void update_switchable_interp_probs(VP9_COMP *cpi, vp9_writer *w) {
132
  VP9_COMMON *const cm = &cpi->common;
133
134
135
136
137
  int j;
  for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
    prob_diff_update(vp9_switchable_interp_tree,
                     cm->fc.switchable_interp_prob[j],
                     cm->counts.switchable_interp[j], SWITCHABLE_FILTERS, w);
138

139
140
#ifdef MODE_STATS
  if (!cpi->dummy_packing)
141
    update_switchable_interp_stats(cm);
142
#endif
143
144
}

145
static void pack_mb_tokens(vp9_writer* const w,
146
147
148
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
149

150
  while (p < stop && p->token != EOSB_TOKEN) {
151
    const int t = p->token;
152
153
    const struct vp9_token *const a = &vp9_coef_encodings[t];
    const vp9_extra_bit *const b = &vp9_extra_bits[t];
John Koleszar's avatar
John Koleszar committed
154
155
    int i = 0;
    int v = a->value;
156
    int n = a->len;
157

John Koleszar's avatar
John Koleszar committed
158
159
160
161
162
    /* skip one or two nodes */
    if (p->skip_eob_node) {
      n -= p->skip_eob_node;
      i = 2 * p->skip_eob_node;
    }
John Koleszar's avatar
John Koleszar committed
163

164
165
166
167
168
169
170
171
    // TODO(jbb): expanding this can lead to big gains.  It allows
    // much better branch prediction and would enable us to avoid numerous
    // lookups and compares.

    // If we have a token that's in the constrained set, the coefficient tree
    // is split into two treed writes.  The first treed write takes care of the
    // unconstrained nodes.  The second treed write takes care of the
    // constrained nodes.
172
    if (t >= TWO_TOKEN && t < EOB_TOKEN) {
173
174
      int len = UNCONSTRAINED_NODES - p->skip_eob_node;
      int bits = v >> (n - len);
175
176
177
178
      vp9_write_tree(w, vp9_coef_tree, p->context_tree, bits, len, i);
      vp9_write_tree(w, vp9_coef_con_tree,
                     vp9_pareto8_full[p->context_tree[PIVOT_NODE] - 1],
                     v, n - len, 0);
179
    } else {
180
      vp9_write_tree(w, vp9_coef_tree, p->context_tree, v, n, i);
181
    }
John Koleszar's avatar
John Koleszar committed
182

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

186
      if (l) {
187
        const unsigned char *pb = b->prob;
John Koleszar's avatar
John Koleszar committed
188
        int v = e >> 1;
189
        int n = l;              /* number of bits in v, assumed nonzero */
John Koleszar's avatar
John Koleszar committed
190
        int i = 0;
John Koleszar's avatar
John Koleszar committed
191

John Koleszar's avatar
John Koleszar committed
192
193
        do {
          const int bb = (v >> --n) & 1;
194
          vp9_write(w, bb, pb[i >> 1]);
John Koleszar's avatar
John Koleszar committed
195
196
197
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
198

199
      vp9_write_bit(w, e & 1);
John Koleszar's avatar
John Koleszar committed
200
    }
John Koleszar's avatar
John Koleszar committed
201
202
203
    ++p;
  }

204
  *tp = p + (p->token == EOSB_TOKEN);
John Koleszar's avatar
John Koleszar committed
205
206
}

207
static void write_segment_id(vp9_writer *w, const struct segmentation *seg,
208
                             int segment_id) {
209
  if (seg->enabled && seg->update_map)
210
    vp9_write_tree(w, vp9_segment_tree, seg->tree_probs, segment_id, 3, 0);
John Koleszar's avatar
John Koleszar committed
211
212
}

Paul Wilkins's avatar
Paul Wilkins committed
213
// This function encodes the reference frame
Ronald S. Bultje's avatar
Ronald S. Bultje committed
214
static void encode_ref_frame(VP9_COMP *cpi, vp9_writer *bc) {
215
  VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
216
217
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
218
  MB_MODE_INFO *mi = &xd->mi_8x8[0]->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
219
  const int segment_id = mi->segment_id;
220
  int seg_ref_active = vp9_segfeature_active(&cm->seg, segment_id,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
221
                                             SEG_LVL_REF_FRAME);
John Koleszar's avatar
John Koleszar committed
222
223
  // If segment level coding of this signal is disabled...
  // or the segment allows multiple reference frame options
224
  if (!seg_ref_active) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
225
226
    // does the feature use compound prediction or not
    // (if not specified at the frame/segment level)
227
    if (cm->reference_mode == REFERENCE_MODE_SELECT) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
228
      vp9_write(bc, mi->ref_frame[1] > INTRA_FRAME,
229
                vp9_get_reference_mode_prob(cm, xd));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
230
231
    } else {
      assert((mi->ref_frame[1] <= INTRA_FRAME) ==
232
             (cm->reference_mode == SINGLE_REFERENCE));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
233
    }
234

Ronald S. Bultje's avatar
Ronald S. Bultje committed
235
236
    if (mi->ref_frame[1] > INTRA_FRAME) {
      vp9_write(bc, mi->ref_frame[0] == GOLDEN_FRAME,
237
                vp9_get_pred_prob_comp_ref_p(cm, xd));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
238
239
    } else {
      vp9_write(bc, mi->ref_frame[0] != LAST_FRAME,
240
                vp9_get_pred_prob_single_ref_p1(cm, xd));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
241
242
      if (mi->ref_frame[0] != LAST_FRAME)
        vp9_write(bc, mi->ref_frame[0] != GOLDEN_FRAME,
243
                  vp9_get_pred_prob_single_ref_p2(cm, xd));
Paul Wilkins's avatar
Paul Wilkins committed
244
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
245
246
  } else {
    assert(mi->ref_frame[1] <= INTRA_FRAME);
247
    assert(vp9_get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME) ==
248
           mi->ref_frame[0]);
John Koleszar's avatar
John Koleszar committed
249
  }
Paul Wilkins's avatar
Paul Wilkins committed
250

Jingning Han's avatar
Jingning Han committed
251
252
  // If using the prediction model we have nothing further to do because
  // the reference frame is fully coded by the segment.
Paul Wilkins's avatar
Paul Wilkins committed
253
}
John Koleszar's avatar
John Koleszar committed
254

255
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc) {
256
257
  VP9_COMMON *const cm = &cpi->common;
  const nmv_context *nmvc = &cm->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
258
259
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
260
  struct segmentation *seg = &cm->seg;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
261
  MB_MODE_INFO *const mi = &m->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
262
  const MV_REFERENCE_FRAME rf = mi->ref_frame[0];
Jingning Han's avatar
Jingning Han committed
263
  const MV_REFERENCE_FRAME sec_rf = mi->ref_frame[1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
264
265
266
  const MB_PREDICTION_MODE mode = mi->mode;
  const int segment_id = mi->segment_id;
  int skip_coeff;
267
  const BLOCK_SIZE bsize = mi->sb_type;
268
  const int allow_hp = cm->allow_high_precision_mv;
Adrian Grange's avatar
Adrian Grange committed
269

Ronald S. Bultje's avatar
Ronald S. Bultje committed
270
271
#ifdef ENTROPY_STATS
  active_section = 9;
272
#endif
273

274
275
  if (seg->update_map) {
    if (seg->temporal_update) {
Scott LaVarnway's avatar
Scott LaVarnway committed
276
      const int pred_flag = mi->seg_id_predicted;
277
      vp9_prob pred_prob = vp9_get_pred_prob_seg_id(seg, xd);
278
279
280
      vp9_write(bc, pred_flag, pred_prob);
      if (!pred_flag)
        write_segment_id(bc, seg, segment_id);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
281
    } else {
282
      write_segment_id(bc, seg, segment_id);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
283
284
    }
  }
285

286
  skip_coeff = write_skip_coeff(cpi, segment_id, m, bc);
John Koleszar's avatar
John Koleszar committed
287

288
  if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME))
289
    vp9_write(bc, rf != INTRA_FRAME, vp9_get_intra_inter_prob(cm, xd));
Paul Wilkins's avatar
Paul Wilkins committed
290

291
  if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT &&
292
      !(rf != INTRA_FRAME &&
293
        (skip_coeff || vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP)))) {
294
    write_selected_tx_size(cpi, m, mi->tx_size, bsize, bc);
295
296
  }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
297
  if (rf == INTRA_FRAME) {
298
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
299
    active_section = 6;
300
#endif
Paul Wilkins's avatar
Paul Wilkins committed
301

302
    if (bsize >= BLOCK_8X8) {
303
      write_intra_mode(bc, mode, cm->fc.y_mode_prob[size_group_lookup[bsize]]);
304
    } else {
305
      int idx, idy;
Jim Bankoski's avatar
Jim Bankoski committed
306
307
308
      const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
      const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
      for (idy = 0; idy < 2; idy += num_4x4_blocks_high) {
Jim Bankoski's avatar
Jim Bankoski committed
309
        for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
310
          const MB_PREDICTION_MODE bm = m->bmi[idy * 2 + idx].as_mode;
311
          write_intra_mode(bc, bm, cm->fc.y_mode_prob[0]);
312
        }
Jim Bankoski's avatar
Jim Bankoski committed
313
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
314
    }
315
    write_intra_mode(bc, mi->uv_mode, cm->fc.uv_mode_prob[mode]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
316
  } else {
317
    vp9_prob *mv_ref_p;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
318
    encode_ref_frame(cpi, bc);
Paul Wilkins's avatar
Paul Wilkins committed
319
    mv_ref_p = cpi->common.fc.inter_mode_probs[mi->mode_context[rf]];
Yaowu Xu's avatar
Yaowu Xu committed
320

John Koleszar's avatar
John Koleszar committed
321
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
322
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
323
324
#endif

325
    // If segment skip is not enabled code the mode.
326
    if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP)) {
327
      if (bsize >= BLOCK_8X8) {
328
        write_inter_mode(bc, mode, mv_ref_p);
329
        ++cm->counts.inter_mode[mi->mode_context[rf]][INTER_OFFSET(mode)];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
330
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
331
    }
332

333
    if (cm->mcomp_filter_type == SWITCHABLE) {
334
      const int ctx = vp9_get_pred_context_switchable_interp(xd);
335
336
337
      vp9_write_token(bc, vp9_switchable_interp_tree,
                      cm->fc.switchable_interp_prob[ctx],
                      &switchable_interp_encodings[mi->interp_filter]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
338
    } else {
339
      assert(mi->interp_filter == cm->mcomp_filter_type);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
340
    }
341

342
    if (bsize < BLOCK_8X8) {
Jim Bankoski's avatar
Jim Bankoski committed
343
344
      const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
      const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
345
      int idx, idy;
Jim Bankoski's avatar
Jim Bankoski committed
346
347
      for (idy = 0; idy < 2; idy += num_4x4_blocks_high) {
        for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
348
          const int j = idy * 2 + idx;
349
          const MB_PREDICTION_MODE blockmode = m->bmi[j].as_mode;
350
          write_inter_mode(bc, blockmode, mv_ref_p);
351
          ++cm->counts.inter_mode[mi->mode_context[rf]]
352
                                 [INTER_OFFSET(blockmode)];
353

Ronald S. Bultje's avatar
Ronald S. Bultje committed
354
          if (blockmode == NEWMV) {
355
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
356
            active_section = 11;
357
#endif
358
            vp9_encode_mv(cpi, bc, &m->bmi[j].as_mv[0].as_mv,
Jingning Han's avatar
Jingning Han committed
359
                          &mi->ref_mvs[rf][0].as_mv, nmvc, allow_hp);
360
361
362

            if (has_second_ref(mi))
              vp9_encode_mv(cpi, bc, &m->bmi[j].as_mv[1].as_mv,
Jingning Han's avatar
Jingning Han committed
363
                            &mi->ref_mvs[sec_rf][0].as_mv, nmvc, allow_hp);
John Koleszar's avatar
John Koleszar committed
364
          }
365
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
366
367
368
369
370
      }
    } else if (mode == NEWMV) {
#ifdef ENTROPY_STATS
      active_section = 5;
#endif
371
      vp9_encode_mv(cpi, bc, &mi->mv[0].as_mv,
Jingning Han's avatar
Jingning Han committed
372
                    &mi->ref_mvs[rf][0].as_mv, nmvc, allow_hp);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
373

374
375
      if (has_second_ref(mi))
        vp9_encode_mv(cpi, bc, &mi->mv[1].as_mv,
Jingning Han's avatar
Jingning Han committed
376
                      &mi->ref_mvs[sec_rf][0].as_mv, nmvc, allow_hp);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
377
378
    }
  }
John Koleszar's avatar
John Koleszar committed
379
}
380

381
static void write_mb_modes_kf(const VP9_COMP *cpi, MODE_INFO **mi_8x8,
382
                              vp9_writer *bc) {
383
  const VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
384
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
385
  const struct segmentation *const seg = &cm->seg;
386
  MODE_INFO *m = mi_8x8[0];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
387
388
  const int ym = m->mbmi.mode;
  const int segment_id = m->mbmi.segment_id;
389
  MODE_INFO *above_mi = mi_8x8[-xd->mode_info_stride];
390
  MODE_INFO *left_mi = xd->left_available ? mi_8x8[-1] : NULL;
391

392
393
  if (seg->update_map)
    write_segment_id(bc, seg, m->mbmi.segment_id);
394

395
  write_skip_coeff(cpi, segment_id, m, bc);
396

397
  if (m->mbmi.sb_type >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT)
398
    write_selected_tx_size(cpi, m, m->mbmi.tx_size, m->mbmi.sb_type, bc);
399

400
  if (m->mbmi.sb_type >= BLOCK_8X8) {
401
    const MB_PREDICTION_MODE A = above_block_mode(m, above_mi, 0);
402
    const MB_PREDICTION_MODE L = left_block_mode(m, left_mi, 0);
403
    write_intra_mode(bc, ym, vp9_kf_y_mode_prob[A][L]);
404
  } else {
405
    int idx, idy;
Jim Bankoski's avatar
Jim Bankoski committed
406
407
    const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[m->mbmi.sb_type];
    const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[m->mbmi.sb_type];
Jim Bankoski's avatar
Jim Bankoski committed
408
409
    for (idy = 0; idy < 2; idy += num_4x4_blocks_high) {
      for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
410
411
        int i = idy * 2 + idx;
        const MB_PREDICTION_MODE A = above_block_mode(m, above_mi, i);
412
        const MB_PREDICTION_MODE L = left_block_mode(m, left_mi, i);
413
        const int bm = m->bmi[i].as_mode;
414
        write_intra_mode(bc, bm, vp9_kf_y_mode_prob[A][L]);
415
416
      }
    }
417
418
  }

419
  write_intra_mode(bc, m->mbmi.uv_mode, vp9_kf_uv_mode_prob[ym]);
420
421
}

James Zern's avatar
James Zern committed
422
static void write_modes_b(VP9_COMP *cpi, const TileInfo *const tile,
423
424
                          vp9_writer *w, TOKENEXTRA **tok, TOKENEXTRA *tok_end,
                          int mi_row, int mi_col) {
425
  VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
426
  MACROBLOCKD *const xd = &cpi->mb.e_mbd;
427
  MODE_INFO *m;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
428

429
430
  xd->mi_8x8 = cm->mi_grid_visible + (mi_row * cm->mode_info_stride + mi_col);
  m = xd->mi_8x8[0];
431

James Zern's avatar
James Zern committed
432
  set_mi_row_col(xd, tile,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
433
                 mi_row, num_8x8_blocks_high_lookup[m->mbmi.sb_type],
James Zern's avatar
James Zern committed
434
435
                 mi_col, num_8x8_blocks_wide_lookup[m->mbmi.sb_type],
                 cm->mi_rows, cm->mi_cols);
436
  if (frame_is_intra_only(cm)) {
437
    write_mb_modes_kf(cpi, xd->mi_8x8, w);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
438
439
440
441
#ifdef ENTROPY_STATS
    active_section = 8;
#endif
  } else {
442
    pack_inter_mode_mvs(cpi, m, w);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
443
444
445
446
447
448
#ifdef ENTROPY_STATS
    active_section = 1;
#endif
  }

  assert(*tok < tok_end);
449
  pack_mb_tokens(w, tok, tok_end);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
450
451
}

452
453
454
455
456
457
458
459
460
static void write_partition(VP9_COMP *cpi, int hbs, int mi_row, int mi_col,
                            PARTITION_TYPE p, BLOCK_SIZE bsize, vp9_writer *w) {
  VP9_COMMON *const cm = &cpi->common;
  const int ctx = partition_plane_context(cpi->above_seg_context,
                                          cpi->left_seg_context,
                                          mi_row, mi_col, bsize);
  const vp9_prob *const probs = get_partition_probs(cm, ctx);
  const int has_rows = (mi_row + hbs) < cm->mi_rows;
  const int has_cols = (mi_col + hbs) < cm->mi_cols;
461
462

  if (has_rows && has_cols) {
463
    vp9_write_token(w, vp9_partition_tree, probs, &partition_encodings[p]);
464
  } else if (!has_rows && has_cols) {
465
466
    assert(p == PARTITION_SPLIT || p == PARTITION_HORZ);
    vp9_write(w, p == PARTITION_SPLIT, probs[1]);
467
  } else if (has_rows && !has_cols) {
468
469
    assert(p == PARTITION_SPLIT || p == PARTITION_VERT);
    vp9_write(w, p == PARTITION_SPLIT, probs[2]);
470
  } else {
471
    assert(p == PARTITION_SPLIT);
472
473
474
  }
}

James Zern's avatar
James Zern committed
475
static void write_modes_sb(VP9_COMP *cpi, const TileInfo *const tile,
476
477
                           vp9_writer *w, TOKENEXTRA **tok, TOKENEXTRA *tok_end,
                           int mi_row, int mi_col, BLOCK_SIZE bsize) {
478
  VP9_COMMON *const cm = &cpi->common;
479
480
481
  const int bsl = b_width_log2(bsize);
  const int bs = (1 << bsl) / 4;
  PARTITION_TYPE partition;
482
  BLOCK_SIZE subsize;
483
  MODE_INFO *m = cm->mi_grid_visible[mi_row * cm->mode_info_stride + mi_col];
484

485
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
486
487
    return;

Jim Bankoski's avatar
Jim Bankoski committed
488
  partition = partition_lookup[bsl][m->mbmi.sb_type];
489
  write_partition(cpi, bs, mi_row, mi_col, partition, bsize, w);
490
  subsize = get_subsize(bsize, partition);
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
  if (subsize < BLOCK_8X8) {
    write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
  } else {
    switch (partition) {
      case PARTITION_NONE:
        write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
        break;
      case PARTITION_HORZ:
        write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
        if (mi_row + bs < cm->mi_rows)
          write_modes_b(cpi, tile, w, tok, tok_end, mi_row + bs, mi_col);
        break;
      case PARTITION_VERT:
        write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
        if (mi_col + bs < cm->mi_cols)
          write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + bs);
        break;
      case PARTITION_SPLIT:
        write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, subsize);
        write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col + bs,
                       subsize);
        write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + bs, mi_col,
                       subsize);
        write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + bs, mi_col + bs,
                       subsize);
        break;
      default:
        assert(0);
    }
520
  }
521
522

  // update partition context
523
  if (bsize >= BLOCK_8X8 &&
524
      (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
525
    update_partition_context(cpi->above_seg_context, cpi->left_seg_context,
526
                             mi_row, mi_col, subsize, bsize);
527
528
}

James Zern's avatar
James Zern committed
529
static void write_modes(VP9_COMP *cpi, const TileInfo *const tile,
530
                        vp9_writer *w, TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
531
  int mi_row, mi_col;
532

James Zern's avatar
James Zern committed
533
  for (mi_row = tile->mi_row_start; mi_row < tile->mi_row_end;
534
535
       mi_row += MI_BLOCK_SIZE) {
      vp9_zero(cpi->left_seg_context);
James Zern's avatar
James Zern committed
536
    for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
537
538
         mi_col += MI_BLOCK_SIZE)
      write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, BLOCK_64X64);
John Koleszar's avatar
John Koleszar committed
539
  }
John Koleszar's avatar
John Koleszar committed
540
}
541

542
543
544
static void build_tree_distribution(VP9_COMP *cpi, TX_SIZE tx_size) {
  vp9_coeff_probs_model *coef_probs = cpi->frame_coef_probs[tx_size];
  vp9_coeff_count *coef_counts = cpi->coef_counts[tx_size];
545
  unsigned int (*eob_branch_ct)[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS] =
546
547
      cpi->common.counts.eob_branch[tx_size];
  vp9_coeff_stats *coef_branch_ct = cpi->frame_branch_ct[tx_size];
548
  int i, j, k, l, m;
549

550
  for (i = 0; i < PLANE_TYPES; ++i) {
551
552
    for (j = 0; j < REF_TYPES; ++j) {
      for (k = 0; k < COEF_BANDS; ++k) {
553
        for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
554
          vp9_tree_probs_from_distribution(vp9_coef_tree,
555
                                           coef_branch_ct[i][j][k][l],
556
                                           coef_counts[i][j][k][l]);
557
558
          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];
559
560
561
562
          for (m = 0; m < UNCONSTRAINED_NODES; ++m)
            coef_probs[i][j][k][l][m] = get_binary_prob(
                                            coef_branch_ct[i][j][k][l][m][0],
                                            coef_branch_ct[i][j][k][l][m][1]);
563
#ifdef ENTROPY_STATS
564
          if (!cpi->dummy_packing) {
565
            int t;
566
            for (t = 0; t < ENTROPY_TOKENS; ++t)
567
              context_counters[tx_size][i][j][k][l][t] +=
568
                  coef_counts[i][j][k][l][t];
569
            context_counters[tx_size][i][j][k][l][ENTROPY_TOKENS] +=
570
571
                eob_branch_ct[i][j][k][l];
          }
John Koleszar's avatar
John Koleszar committed
572
#endif
573
        }
Daniel Kang's avatar
Daniel Kang committed
574
575
576
      }
    }
  }
577
578
}

579
580
581
582
583
584
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];
585
  const vp9_prob upd = DIFF_UPDATE_PROB;
586
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
587
588
589
590
591
592
  int i, j, k, l, t;
  switch (cpi->sf.use_fast_coef_updates) {
    case 0: {
      /* dry run to see if there is any udpate at all needed */
      int savings = 0;
      int update[2] = {0, 0};
593
      for (i = 0; i < PLANE_TYPES; ++i) {
594
595
        for (j = 0; j < REF_TYPES; ++j) {
          for (k = 0; k < COEF_BANDS; ++k) {
596
            for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
              for (t = 0; t < entropy_nodes_update; ++t) {
                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];
                int s;
                int u = 0;
                if (t == PIVOT_NODE)
                  s = vp9_prob_diff_update_savings_search_model(
                      frame_branch_ct[i][j][k][l][0],
                      old_frame_coef_probs[i][j][k][l], &newp, upd, i, j);
                else
                  s = vp9_prob_diff_update_savings_search(
                      frame_branch_ct[i][j][k][l][t], oldp, &newp, upd);
                if (s > 0 && newp != oldp)
                  u = 1;
                if (u)
                  savings += s - (int)(vp9_cost_zero(upd));
                else
                  savings -= (int)(vp9_cost_zero(upd));
                update[u]++;
              }
            }
          }
        }
      }
621

622
623
624
625
626
627
628
      // printf("Update %d %d, savings %d\n", update[0], update[1], savings);
      /* Is coef updated at all */
      if (update[1] == 0 || savings < 0) {
        vp9_write_bit(bc, 0);
        return;
      }
      vp9_write_bit(bc, 1);
629
      for (i = 0; i < PLANE_TYPES; ++i) {
630
631
        for (j = 0; j < REF_TYPES; ++j) {
          for (k = 0; k < COEF_BANDS; ++k) {
632
            for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
633
634
635
636
              // calc probs and branch cts for this frame only
              for (t = 0; t < entropy_nodes_update; ++t) {
                vp9_prob newp = new_frame_coef_probs[i][j][k][l][t];
                vp9_prob *oldp = old_frame_coef_probs[i][j][k][l] + t;
637
                const vp9_prob upd = DIFF_UPDATE_PROB;
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
                int s;
                int u = 0;
                if (t == PIVOT_NODE)
                  s = vp9_prob_diff_update_savings_search_model(
                      frame_branch_ct[i][j][k][l][0],
                      old_frame_coef_probs[i][j][k][l], &newp, upd, i, j);
                else
                  s = vp9_prob_diff_update_savings_search(
                      frame_branch_ct[i][j][k][l][t],
                      *oldp, &newp, upd);
                if (s > 0 && newp != *oldp)
                  u = 1;
                vp9_write(bc, u, upd);
#ifdef ENTROPY_STATS
                if (!cpi->dummy_packing)
                  ++tree_update_hist[tx_size][i][j][k][l][t][u];
#endif
                if (u) {
                  /* send/use new probability */
                  vp9_write_prob_diff_update(bc, newp, *oldp);
                  *oldp = newp;
                }
              }
            }
662
          }
Daniel Kang's avatar
Daniel Kang committed
663
664
        }
      }
665
      return;
Daniel Kang's avatar
Daniel Kang committed
666
    }
John Koleszar's avatar
John Koleszar committed
667

668
669
670
    case 1:
    case 2: {
      const int prev_coef_contexts_to_update =
671
672
          cpi->sf.use_fast_coef_updates == 2 ? COEFF_CONTEXTS >> 1
                                             : COEFF_CONTEXTS;
673
      const int coef_band_to_update =
674
675
          cpi->sf.use_fast_coef_updates == 2 ? COEF_BANDS >> 1
                                             : COEF_BANDS;
676
677
      int updates = 0;
      int noupdates_before_first = 0;
678
      for (i = 0; i < PLANE_TYPES; ++i) {
679
680
        for (j = 0; j < REF_TYPES; ++j) {
          for (k = 0; k < COEF_BANDS; ++k) {
681
            for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
              // calc probs and branch cts for this frame only
              for (t = 0; t < entropy_nodes_update; ++t) {
                vp9_prob newp = new_frame_coef_probs[i][j][k][l][t];
                vp9_prob *oldp = old_frame_coef_probs[i][j][k][l] + t;
                int s;
                int u = 0;
                if (l >= prev_coef_contexts_to_update ||
                    k >= coef_band_to_update) {
                  u = 0;
                } else {
                  if (t == PIVOT_NODE)
                    s = vp9_prob_diff_update_savings_search_model(
                        frame_branch_ct[i][j][k][l][0],
                        old_frame_coef_probs[i][j][k][l], &newp, upd, i, j);
                  else
                    s = vp9_prob_diff_update_savings_search(
                        frame_branch_ct[i][j][k][l][t],
                        *oldp, &newp, upd);
                  if (s > 0 && newp != *oldp)
                    u = 1;
                }
                updates += u;
                if (u == 0 && updates == 0) {
                  noupdates_before_first++;
706
#ifdef ENTROPY_STATS
707
708
                  if (!cpi->dummy_packing)
                    ++tree_update_hist[tx_size][i][j][k][l][t][u];
709
#endif
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
                  continue;
                }
                if (u == 1 && updates == 1) {
                  int v;
                  // first update
                  vp9_write_bit(bc, 1);
                  for (v = 0; v < noupdates_before_first; ++v)
                    vp9_write(bc, 0, upd);
                }
                vp9_write(bc, u, upd);
#ifdef ENTROPY_STATS
                if (!cpi->dummy_packing)
                  ++tree_update_hist[tx_size][i][j][k][l][t][u];
#endif
                if (u) {
                  /* send/use new probability */
                  vp9_write_prob_diff_update(bc, newp, *oldp);
                  *oldp = newp;
                }
              }
John Koleszar's avatar
John Koleszar committed
730
            }
Daniel Kang's avatar
Daniel Kang committed
731
732
733
          }
        }
      }
734
735
736
737
      if (updates == 0) {
        vp9_write_bit(bc, 0);  // no updates
      }
      return;
Daniel Kang's avatar
Daniel Kang committed
738
    }
739
740
741

    default:
      assert(0);
John Koleszar's avatar
John Koleszar committed
742
  }
743
}
John Koleszar's avatar
John Koleszar committed
744

745
static void update_coef_probs(VP9_COMP* cpi, vp9_writer* w) {
746
  const TX_MODE tx_mode = cpi->common.tx_mode;
747
748
  const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
  TX_SIZE tx_size;
749
  vp9_clear_system_state();
750

751
752
  for (tx_size = TX_4X4; tx_size <= TX_32X32; ++tx_size)
    build_tree_distribution(cpi, tx_size);
753

754
755
  for (tx_size = TX_4X4; tx_size <= max_tx_size; ++tx_size)
    update_coef_probs_common(w, cpi, tx_size);
John Koleszar's avatar
John Koleszar committed
756
}
757

758
static void encode_loopfilter(struct loopfilter *lf,
759
                              struct vp9_write_bit_buffer *wb) {
760
761
  int i;

762
  // Encode the loop filter level and type
763
764
  vp9_wb_write_literal(wb, lf->filter_level, 6);
  vp9_wb_write_literal(wb, lf->sharpness_level, 3);
765

766
767
  // Write out loop filter deltas applied at the MB level based on mode or
  // ref frame (if they are enabled).
768
  vp9_wb_write_bit(wb, lf->mode_ref_delta_enabled);
769

770
771
772
  if (lf->mode_ref_delta_enabled) {
    vp9_wb_write_bit(wb, lf->mode_ref_delta_update);
    if (lf->mode_ref_delta_update) {
773
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
774
        const int delta = lf->ref_deltas[i];
775
776
777
        const int changed = delta != lf->last_ref_deltas[i];
        vp9_wb_write_bit(wb, changed);
        if (changed) {
778
          lf->last_ref_deltas[i] = delta;
779
780
          vp9_wb_write_literal(wb, abs(delta) & 0x3F, 6);
          vp9_wb_write_bit(wb, delta < 0);
781
782
783
784
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
785
        const int delta = lf->mode_deltas[i];
786
787
788
        const int changed = delta != lf->last_mode_deltas[i];
        vp9_wb_write_bit(wb, changed);
        if (changed) {
789
          lf->last_mode_deltas[i] = delta;
790
791
          vp9_wb_write_literal(wb, abs(delta) & 0x3F, 6);
          vp9_wb_write_bit(wb, delta < 0);
792
793
794
795
796
797
        }
      }
    }
  }
}

798
static void write_delta_q(struct vp9_write_bit_buffer *wb, int delta_q) {
799
  if (delta_q != 0) {
800
801
802
    vp9_wb_write_bit(wb, 1);
    vp9_wb_write_literal(wb, abs(delta_q), 4);
    vp9_wb_write_bit(wb, delta_q < 0);
803
  } else {
804
    vp9_wb_write_bit(wb, 0);
805
806
807
  }
}

808
809
810
811
812
813
static void encode_quantization(VP9_COMMON *cm,
                                struct vp9_write_bit_buffer *wb) {
  vp9_wb_write_literal(wb, cm->base_qindex, QINDEX_BITS);
  write_delta_q(wb, cm->y_dc_delta_q);
  write_delta_q(wb, cm->uv_dc_delta_q);
  write_delta_q(wb, cm->uv_ac_delta_q);
814
815
816
}


817
static void encode_segmentation(VP9_COMP *cpi,
818
                                struct vp9_write_bit_buffer *wb) {
John Koleszar's avatar
John Koleszar committed
819
  int i, j;
820

821
  struct segmentation *seg = &cpi->common.seg;
822
823
824

  vp9_wb_write_bit(wb, seg->enabled);
  if (!seg->enabled)
825
826
827
    return;

  // Segmentation map
828
829
  vp9_wb_write_bit(wb, seg->update_map);
  if (seg->update_map) {
830
831
832
    // Select the coding strategy (temporal or spatial)
    vp9_choose_segmap_coding_method(cpi);
    // Write out probabilities used to decode unpredicted  macro-block segments
Paul Wilkins's avatar
Paul Wilkins committed
833
    for (i = 0; i < SEG_TREE_PROBS; i++) {
834
      const int prob = seg->tree_probs[i];
835
836
837
838
      const int update = prob != MAX_PROB;
      vp9_wb_write_bit(wb, update);
      if (update)
        vp9_wb_write_literal(wb, prob, 8);
839
840
841
    }

    // Write out the chosen coding method.
842
843
    vp9_wb_write_bit(wb, seg->temporal_update);
    if (seg->temporal_update) {
844
      for (i = 0; i < PREDICTION_PROBS; i++) {
845
        const int prob = seg->pred_probs[i];
846
847
848
849
        const int update = prob != MAX_PROB;
        vp9_wb_write_bit(wb, update);
        if (update)
          vp9_wb_write_literal(wb, prob, 8);
850
851
852
853
854
      }
    }
  }

  // Segmentation data<