vp9_bitstream.c 42.8 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"

John Koleszar's avatar
John Koleszar committed
36
37
38
39
#ifdef ENTROPY_STATS
extern unsigned int active_section;
#endif

40
41
42
43
44
45
46
47
48
49
50
51
52
53
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) {
54
  vp9_write_token(w, vp9_intra_mode_tree, probs, &intra_mode_encodings[mode]);
55
56
57
58
59
}

static void write_inter_mode(vp9_writer *w, MB_PREDICTION_MODE mode,
                             const vp9_prob *probs) {
  assert(is_inter_mode(mode));
60
61
  vp9_write_token(w, vp9_inter_mode_tree, probs,
                  &inter_mode_encodings[INTER_OFFSET(mode)]);
62
63
}

64
65
66
67
68
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;
69
70
}

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

76
77
78
79
80
81
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];
82
83

  // Assuming max number of probabilities <= 32
84
  assert(n <= 32);
85

86
  vp9_tree_probs_from_distribution(tree, branch_ct, counts);
87
  for (i = 0; i < n - 1; ++i)
88
    vp9_cond_prob_diff_update(w, &probs[i], branch_ct[i]);
89
90
}

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

106
107
static int write_skip(const VP9_COMP *cpi, int segment_id, MODE_INFO *m,
                      vp9_writer *w) {
108
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
109
  if (vp9_segfeature_active(&cpi->common.seg, segment_id, SEG_LVL_SKIP)) {
110
111
    return 1;
  } else {
112
    const int skip = m->mbmi.skip;
113
114
    vp9_write(w, skip, vp9_get_skip_prob(&cpi->common, xd));
    return skip;
115
116
117
  }
}

118
void vp9_update_skip_probs(VP9_COMMON *cm, vp9_writer *w) {
119
120
  int k;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
121
122
  for (k = 0; k < SKIP_CONTEXTS; ++k)
    vp9_cond_prob_diff_update(w, &cm->fc.skip_probs[k], cm->counts.skip[k]);
123
124
}

125
static void update_switchable_interp_probs(VP9_COMP *cpi, vp9_writer *w) {
126
  VP9_COMMON *const cm = &cpi->common;
127
128
129
130
131
  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);
132
133
}

134
static void pack_mb_tokens(vp9_writer* const w,
135
136
137
                           TOKENEXTRA **tp,
                           const TOKENEXTRA *const stop) {
  TOKENEXTRA *p = *tp;
John Koleszar's avatar
John Koleszar committed
138

139
  while (p < stop && p->token != EOSB_TOKEN) {
140
    const int t = p->token;
141
142
    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
143
144
    int i = 0;
    int v = a->value;
145
    int n = a->len;
146

John Koleszar's avatar
John Koleszar committed
147
148
149
150
151
    /* 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
152

153
154
155
156
157
158
159
160
    // 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.
161
    if (t >= TWO_TOKEN && t < EOB_TOKEN) {
162
163
      int len = UNCONSTRAINED_NODES - p->skip_eob_node;
      int bits = v >> (n - len);
164
165
166
167
      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);
168
    } else {
169
      vp9_write_tree(w, vp9_coef_tree, p->context_tree, v, n, i);
170
    }
John Koleszar's avatar
John Koleszar committed
171

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

175
      if (l) {
176
        const unsigned char *pb = b->prob;
John Koleszar's avatar
John Koleszar committed
177
        int v = e >> 1;
178
        int n = l;              /* number of bits in v, assumed nonzero */
John Koleszar's avatar
John Koleszar committed
179
        int i = 0;
John Koleszar's avatar
John Koleszar committed
180

John Koleszar's avatar
John Koleszar committed
181
182
        do {
          const int bb = (v >> --n) & 1;
183
          vp9_write(w, bb, pb[i >> 1]);
John Koleszar's avatar
John Koleszar committed
184
185
186
          i = b->tree[i + bb];
        } while (n);
      }
John Koleszar's avatar
John Koleszar committed
187

188
      vp9_write_bit(w, e & 1);
John Koleszar's avatar
John Koleszar committed
189
    }
John Koleszar's avatar
John Koleszar committed
190
191
192
    ++p;
  }

193
  *tp = p + (p->token == EOSB_TOKEN);
John Koleszar's avatar
John Koleszar committed
194
195
}

196
static void write_segment_id(vp9_writer *w, const struct segmentation *seg,
197
                             int segment_id) {
198
  if (seg->enabled && seg->update_map)
199
    vp9_write_tree(w, vp9_segment_tree, seg->tree_probs, segment_id, 3, 0);
John Koleszar's avatar
John Koleszar committed
200
201
}

Paul Wilkins's avatar
Paul Wilkins committed
202
// This function encodes the reference frame
203
204
205
206
207
208
209
static void write_ref_frames(const VP9_COMP *cpi, vp9_writer *w) {
  const VP9_COMMON *const cm = &cpi->common;
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
  const MB_MODE_INFO *const mbmi = &xd->mi_8x8[0]->mbmi;
  const int is_compound = has_second_ref(mbmi);
  const int segment_id = mbmi->segment_id;

John Koleszar's avatar
John Koleszar committed
210
211
  // If segment level coding of this signal is disabled...
  // or the segment allows multiple reference frame options
212
213
214
215
216
  if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
    assert(!is_compound);
    assert(mbmi->ref_frame[0] ==
               vp9_get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME));
  } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
217
218
    // does the feature use compound prediction or not
    // (if not specified at the frame/segment level)
219
    if (cm->reference_mode == REFERENCE_MODE_SELECT) {
220
      vp9_write(w, is_compound, vp9_get_reference_mode_prob(cm, xd));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
221
    } else {
222
      assert(!is_compound == (cm->reference_mode == SINGLE_REFERENCE));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
223
    }
224

225
226
    if (is_compound) {
      vp9_write(w, mbmi->ref_frame[0] == GOLDEN_FRAME,
227
                vp9_get_pred_prob_comp_ref_p(cm, xd));
Ronald S. Bultje's avatar
Ronald S. Bultje committed
228
    } else {
229
230
231
232
233
234
      const int bit0 = mbmi->ref_frame[0] != LAST_FRAME;
      vp9_write(w, bit0, vp9_get_pred_prob_single_ref_p1(cm, xd));
      if (bit0) {
        const int bit1 = mbmi->ref_frame[0] != GOLDEN_FRAME;
        vp9_write(w, bit1, vp9_get_pred_prob_single_ref_p2(cm, xd));
      }
Paul Wilkins's avatar
Paul Wilkins committed
235
    }
John Koleszar's avatar
John Koleszar committed
236
  }
Paul Wilkins's avatar
Paul Wilkins committed
237
}
John Koleszar's avatar
John Koleszar committed
238

239
static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc) {
240
241
  VP9_COMMON *const cm = &cpi->common;
  const nmv_context *nmvc = &cm->fc.nmvc;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
242
243
  MACROBLOCK *const x = &cpi->mb;
  MACROBLOCKD *const xd = &x->e_mbd;
244
  const struct segmentation *const seg = &cm->seg;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
245
  MB_MODE_INFO *const mi = &m->mbmi;
246
247
  const MV_REFERENCE_FRAME ref0 = mi->ref_frame[0];
  const MV_REFERENCE_FRAME ref1 = mi->ref_frame[1];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
248
249
  const MB_PREDICTION_MODE mode = mi->mode;
  const int segment_id = mi->segment_id;
250
  const BLOCK_SIZE bsize = mi->sb_type;
251
  const int allow_hp = cm->allow_high_precision_mv;
252
  int skip;
Adrian Grange's avatar
Adrian Grange committed
253

Ronald S. Bultje's avatar
Ronald S. Bultje committed
254
255
#ifdef ENTROPY_STATS
  active_section = 9;
256
#endif
257

258
259
  if (seg->update_map) {
    if (seg->temporal_update) {
Scott LaVarnway's avatar
Scott LaVarnway committed
260
      const int pred_flag = mi->seg_id_predicted;
261
      vp9_prob pred_prob = vp9_get_pred_prob_seg_id(seg, xd);
262
263
264
      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
265
    } else {
266
      write_segment_id(bc, seg, segment_id);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
267
268
    }
  }
269

270
  skip = write_skip(cpi, segment_id, m, bc);
John Koleszar's avatar
John Koleszar committed
271

272
  if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME))
273
    vp9_write(bc, ref0 != INTRA_FRAME, vp9_get_intra_inter_prob(cm, xd));
Paul Wilkins's avatar
Paul Wilkins committed
274

275
  if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT &&
276
      !(ref0 != INTRA_FRAME &&
277
        (skip || vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP)))) {
278
    write_selected_tx_size(cpi, m, mi->tx_size, bsize, bc);
279
280
  }

281
  if (ref0 == INTRA_FRAME) {
282
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
283
    active_section = 6;
284
#endif
Paul Wilkins's avatar
Paul Wilkins committed
285

286
    if (bsize >= BLOCK_8X8) {
287
      write_intra_mode(bc, mode, cm->fc.y_mode_prob[size_group_lookup[bsize]]);
288
    } else {
289
      int idx, idy;
Jim Bankoski's avatar
Jim Bankoski committed
290
291
292
      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
293
        for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
294
          const MB_PREDICTION_MODE bm = m->bmi[idy * 2 + idx].as_mode;
295
          write_intra_mode(bc, bm, cm->fc.y_mode_prob[0]);
296
        }
Jim Bankoski's avatar
Jim Bankoski committed
297
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
298
    }
299
    write_intra_mode(bc, mi->uv_mode, cm->fc.uv_mode_prob[mode]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
300
  } else {
301
    vp9_prob *mv_ref_p;
302
    write_ref_frames(cpi, bc);
303
    mv_ref_p = cm->fc.inter_mode_probs[mi->mode_context[ref0]];
Yaowu Xu's avatar
Yaowu Xu committed
304

John Koleszar's avatar
John Koleszar committed
305
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
306
    active_section = 3;
John Koleszar's avatar
John Koleszar committed
307
308
#endif

309
    // If segment skip is not enabled code the mode.
310
    if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP)) {
311
      if (bsize >= BLOCK_8X8) {
312
        write_inter_mode(bc, mode, mv_ref_p);
313
        ++cm->counts.inter_mode[mi->mode_context[ref0]][INTER_OFFSET(mode)];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
314
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
315
    }
316

317
    if (cm->interp_filter == SWITCHABLE) {
318
      const int ctx = vp9_get_pred_context_switchable_interp(xd);
319
320
321
      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
322
    } else {
323
      assert(mi->interp_filter == cm->interp_filter);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
324
    }
325

326
    if (bsize < BLOCK_8X8) {
Jim Bankoski's avatar
Jim Bankoski committed
327
328
      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
329
      int idx, idy;
Jim Bankoski's avatar
Jim Bankoski committed
330
331
      for (idy = 0; idy < 2; idy += num_4x4_blocks_high) {
        for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
332
          const int j = idy * 2 + idx;
333
334
335
336
          const MB_PREDICTION_MODE b_mode = m->bmi[j].as_mode;
          write_inter_mode(bc, b_mode, mv_ref_p);
          ++cm->counts.inter_mode[mi->mode_context[ref0]][INTER_OFFSET(b_mode)];
          if (b_mode == NEWMV) {
337
#ifdef ENTROPY_STATS
Ronald S. Bultje's avatar
Ronald S. Bultje committed
338
            active_section = 11;
339
#endif
340
            vp9_encode_mv(cpi, bc, &m->bmi[j].as_mv[0].as_mv,
341
                          &mi->ref_mvs[ref0][0].as_mv, nmvc, allow_hp);
342
343
344

            if (has_second_ref(mi))
              vp9_encode_mv(cpi, bc, &m->bmi[j].as_mv[1].as_mv,
345
                            &mi->ref_mvs[ref1][0].as_mv, nmvc, allow_hp);
John Koleszar's avatar
John Koleszar committed
346
          }
347
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
348
349
350
351
352
      }
    } else if (mode == NEWMV) {
#ifdef ENTROPY_STATS
      active_section = 5;
#endif
353
      vp9_encode_mv(cpi, bc, &mi->mv[0].as_mv,
354
                    &mi->ref_mvs[ref0][0].as_mv, nmvc, allow_hp);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
355

356
357
      if (has_second_ref(mi))
        vp9_encode_mv(cpi, bc, &mi->mv[1].as_mv,
358
                      &mi->ref_mvs[ref1][0].as_mv, nmvc, allow_hp);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
359
360
    }
  }
John Koleszar's avatar
John Koleszar committed
361
}
362

363
static void write_mb_modes_kf(const VP9_COMP *cpi, MODE_INFO **mi_8x8,
364
                              vp9_writer *bc) {
365
  const VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
366
  const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
367
  const struct segmentation *const seg = &cm->seg;
368
  MODE_INFO *m = mi_8x8[0];
Ronald S. Bultje's avatar
Ronald S. Bultje committed
369
370
  const int ym = m->mbmi.mode;
  const int segment_id = m->mbmi.segment_id;
371
  MODE_INFO *above_mi = mi_8x8[-xd->mode_info_stride];
372
  MODE_INFO *left_mi = xd->left_available ? mi_8x8[-1] : NULL;
373

374
375
  if (seg->update_map)
    write_segment_id(bc, seg, m->mbmi.segment_id);
376

377
  write_skip(cpi, segment_id, m, bc);
378

379
  if (m->mbmi.sb_type >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT)
380
    write_selected_tx_size(cpi, m, m->mbmi.tx_size, m->mbmi.sb_type, bc);
381

382
  if (m->mbmi.sb_type >= BLOCK_8X8) {
383
384
    const MB_PREDICTION_MODE A = vp9_above_block_mode(m, above_mi, 0);
    const MB_PREDICTION_MODE L = vp9_left_block_mode(m, left_mi, 0);
385
    write_intra_mode(bc, ym, vp9_kf_y_mode_prob[A][L]);
386
  } else {
387
    int idx, idy;
Jim Bankoski's avatar
Jim Bankoski committed
388
389
    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
390
391
    for (idy = 0; idy < 2; idy += num_4x4_blocks_high) {
      for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
392
        int i = idy * 2 + idx;
393
394
        const MB_PREDICTION_MODE A = vp9_above_block_mode(m, above_mi, i);
        const MB_PREDICTION_MODE L = vp9_left_block_mode(m, left_mi, i);
395
        const int bm = m->bmi[i].as_mode;
396
        write_intra_mode(bc, bm, vp9_kf_y_mode_prob[A][L]);
397
398
      }
    }
399
400
  }

401
  write_intra_mode(bc, m->mbmi.uv_mode, vp9_kf_uv_mode_prob[ym]);
402
403
}

James Zern's avatar
James Zern committed
404
static void write_modes_b(VP9_COMP *cpi, const TileInfo *const tile,
405
406
                          vp9_writer *w, TOKENEXTRA **tok, TOKENEXTRA *tok_end,
                          int mi_row, int mi_col) {
407
  VP9_COMMON *const cm = &cpi->common;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
408
  MACROBLOCKD *const xd = &cpi->mb.e_mbd;
409
  MODE_INFO *m;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
410

411
412
  xd->mi_8x8 = cm->mi_grid_visible + (mi_row * cm->mode_info_stride + mi_col);
  m = xd->mi_8x8[0];
413

James Zern's avatar
James Zern committed
414
  set_mi_row_col(xd, tile,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
415
                 mi_row, num_8x8_blocks_high_lookup[m->mbmi.sb_type],
James Zern's avatar
James Zern committed
416
417
                 mi_col, num_8x8_blocks_wide_lookup[m->mbmi.sb_type],
                 cm->mi_rows, cm->mi_cols);
418
  if (frame_is_intra_only(cm)) {
419
    write_mb_modes_kf(cpi, xd->mi_8x8, w);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
420
421
422
423
#ifdef ENTROPY_STATS
    active_section = 8;
#endif
  } else {
424
    pack_inter_mode_mvs(cpi, m, w);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
425
426
427
428
429
430
#ifdef ENTROPY_STATS
    active_section = 1;
#endif
  }

  assert(*tok < tok_end);
431
  pack_mb_tokens(w, tok, tok_end);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
432
433
}

434
435
436
437
438
439
440
441
442
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;
443
444

  if (has_rows && has_cols) {
445
    vp9_write_token(w, vp9_partition_tree, probs, &partition_encodings[p]);
446
  } else if (!has_rows && has_cols) {
447
448
    assert(p == PARTITION_SPLIT || p == PARTITION_HORZ);
    vp9_write(w, p == PARTITION_SPLIT, probs[1]);
449
  } else if (has_rows && !has_cols) {
450
451
    assert(p == PARTITION_SPLIT || p == PARTITION_VERT);
    vp9_write(w, p == PARTITION_SPLIT, probs[2]);
452
  } else {
453
    assert(p == PARTITION_SPLIT);
454
455
456
  }
}

James Zern's avatar
James Zern committed
457
static void write_modes_sb(VP9_COMP *cpi, const TileInfo *const tile,
458
459
                           vp9_writer *w, TOKENEXTRA **tok, TOKENEXTRA *tok_end,
                           int mi_row, int mi_col, BLOCK_SIZE bsize) {
460
  VP9_COMMON *const cm = &cpi->common;
461
462
463
  const int bsl = b_width_log2(bsize);
  const int bs = (1 << bsl) / 4;
  PARTITION_TYPE partition;
464
  BLOCK_SIZE subsize;
465
  MODE_INFO *m = cm->mi_grid_visible[mi_row * cm->mode_info_stride + mi_col];
466

467
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
468
469
    return;

Jim Bankoski's avatar
Jim Bankoski committed
470
  partition = partition_lookup[bsl][m->mbmi.sb_type];
471
  write_partition(cpi, bs, mi_row, mi_col, partition, bsize, w);
472
  subsize = get_subsize(bsize, partition);
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
  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);
    }
502
  }
503
504

  // update partition context
505
  if (bsize >= BLOCK_8X8 &&
506
      (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
507
    update_partition_context(cpi->above_seg_context, cpi->left_seg_context,
508
                             mi_row, mi_col, subsize, bsize);
509
510
}

James Zern's avatar
James Zern committed
511
static void write_modes(VP9_COMP *cpi, const TileInfo *const tile,
512
                        vp9_writer *w, TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
513
  int mi_row, mi_col;
514

James Zern's avatar
James Zern committed
515
  for (mi_row = tile->mi_row_start; mi_row < tile->mi_row_end;
516
517
       mi_row += MI_BLOCK_SIZE) {
      vp9_zero(cpi->left_seg_context);
James Zern's avatar
James Zern committed
518
    for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
519
520
         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
521
  }
John Koleszar's avatar
John Koleszar committed
522
}
523

524
525
526
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];
527
  unsigned int (*eob_branch_ct)[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS] =
528
529
      cpi->common.counts.eob_branch[tx_size];
  vp9_coeff_stats *coef_branch_ct = cpi->frame_branch_ct[tx_size];
530
  int i, j, k, l, m;
531

532
  for (i = 0; i < PLANE_TYPES; ++i) {
533
534
    for (j = 0; j < REF_TYPES; ++j) {
      for (k = 0; k < COEF_BANDS; ++k) {
535
        for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
536
          vp9_tree_probs_from_distribution(vp9_coef_tree,
537
                                           coef_branch_ct[i][j][k][l],
538
                                           coef_counts[i][j][k][l]);
539
540
          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];
541
542
543
544
          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]);
545
        }
Daniel Kang's avatar
Daniel Kang committed
546
547
548
      }
    }
  }
549
550
}

551
552
553
554
555
556
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];
557
  const vp9_prob upd = DIFF_UPDATE_PROB;
558
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
559
560
561
562
563
564
  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};
565
      for (i = 0; i < PLANE_TYPES; ++i) {
566
567
        for (j = 0; j < REF_TYPES; ++j) {
          for (k = 0; k < COEF_BANDS; ++k) {
568
            for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
              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]++;
              }
            }
          }
        }
      }
593

594
595
596
597
598
599
600
      // 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);
601
      for (i = 0; i < PLANE_TYPES; ++i) {
602
603
        for (j = 0; j < REF_TYPES; ++j) {
          for (k = 0; k < COEF_BANDS; ++k) {
604
            for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
605
606
607
608
              // 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;
609
                const vp9_prob upd = DIFF_UPDATE_PROB;
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
                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);
                if (u) {
                  /* send/use new probability */
                  vp9_write_prob_diff_update(bc, newp, *oldp);
                  *oldp = newp;
                }
              }
            }
630
          }
Daniel Kang's avatar
Daniel Kang committed
631
632
        }
      }
633
      return;
Daniel Kang's avatar
Daniel Kang committed
634
    }
John Koleszar's avatar
John Koleszar committed
635

636
637
638
    case 1:
    case 2: {
      const int prev_coef_contexts_to_update =
639
640
          cpi->sf.use_fast_coef_updates == 2 ? COEFF_CONTEXTS >> 1
                                             : COEFF_CONTEXTS;
641
      const int coef_band_to_update =
642
643
          cpi->sf.use_fast_coef_updates == 2 ? COEF_BANDS >> 1
                                             : COEF_BANDS;
644
645
      int updates = 0;
      int noupdates_before_first = 0;
646
      for (i = 0; i < PLANE_TYPES; ++i) {
647
648
        for (j = 0; j < REF_TYPES; ++j) {
          for (k = 0; k < COEF_BANDS; ++k) {
649
            for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
              // 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++;
                  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);
                if (u) {
                  /* send/use new probability */
                  vp9_write_prob_diff_update(bc, newp, *oldp);
                  *oldp = newp;
                }
              }
John Koleszar's avatar
John Koleszar committed
690
            }
Daniel Kang's avatar
Daniel Kang committed
691
692
693
          }
        }
      }
694
695
696
697
      if (updates == 0) {
        vp9_write_bit(bc, 0);  // no updates
      }
      return;
Daniel Kang's avatar
Daniel Kang committed
698
    }
699
700
701

    default:
      assert(0);
John Koleszar's avatar
John Koleszar committed
702
  }
703
}
John Koleszar's avatar
John Koleszar committed
704

705
static void update_coef_probs(VP9_COMP* cpi, vp9_writer* w) {
706
  const TX_MODE tx_mode = cpi->common.tx_mode;
707
708
  const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
  TX_SIZE tx_size;
709
  vp9_clear_system_state();
710

711
712
  for (tx_size = TX_4X4; tx_size <= TX_32X32; ++tx_size)
    build_tree_distribution(cpi, tx_size);
713

714
715
  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
716
}
717

718
static void encode_loopfilter(struct loopfilter *lf,
719
                              struct vp9_write_bit_buffer *wb) {
720
721
  int i;

722
  // Encode the loop filter level and type
723
724
  vp9_wb_write_literal(wb, lf->filter_level, 6);
  vp9_wb_write_literal(wb, lf->sharpness_level, 3);
725

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

730
731
732
  if (lf->mode_ref_delta_enabled) {
    vp9_wb_write_bit(wb, lf->mode_ref_delta_update);
    if (lf->mode_ref_delta_update) {
733
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
734
        const int delta = lf->ref_deltas[i];
735
736
737
        const int changed = delta != lf->last_ref_deltas[i];
        vp9_wb_write_bit(wb, changed);
        if (changed) {
738
          lf->last_ref_deltas[i] = delta;
739
740
          vp9_wb_write_literal(wb, abs(delta) & 0x3F, 6);
          vp9_wb_write_bit(wb, delta < 0);
741
742
743
744
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
745
        const int delta = lf->mode_deltas[i];
746
747
748
        const int changed = delta != lf->last_mode_deltas[i];
        vp9_wb_write_bit(wb, changed);
        if (changed) {
749
          lf->last_mode_deltas[i] = delta;
750
751
          vp9_wb_write_literal(wb, abs(delta) & 0x3F, 6);
          vp9_wb_write_bit(wb, delta < 0);
752
753
754
755
756
757
        }
      }
    }
  }
}

758
static void write_delta_q(struct vp9_write_bit_buffer *wb, int delta_q) {
759
  if (delta_q != 0) {
760
761
762
    vp9_wb_write_bit(wb, 1);
    vp9_wb_write_literal(wb, abs(delta_q), 4);
    vp9_wb_write_bit(wb, delta_q < 0);
763
  } else {
764
    vp9_wb_write_bit(wb, 0);
765
766
767
  }
}

768
769
770
771
772
773
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);
774
775
776
}


777
static void encode_segmentation(VP9_COMP *cpi,
778
                                struct vp9_write_bit_buffer *wb) {
John Koleszar's avatar
John Koleszar committed
779
  int i, j;
780

781
  struct segmentation *seg = &cpi->common.seg;
782
783
784

  vp9_wb_write_bit(wb, seg->enabled);
  if (!seg->enabled)
785
786
787
    return;

  // Segmentation map
788
789
  vp9_wb_write_bit(wb, seg->update_map);
  if (seg->update_map) {
790
791
792
    // 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
793
    for (i = 0; i < SEG_TREE_PROBS; i++) {
794
      const int prob = seg->tree_probs[i];
795
796
797
798
      const int update = prob != MAX_PROB;
      vp9_wb_write_bit(wb, update);
      if (update)
        vp9_wb_write_literal(wb, prob, 8);
799
800
801
    }

    // Write out the chosen coding method.
802
803
    vp9_wb_write_bit(wb, seg->temporal_update);
    if (seg->temporal_update) {
804
      for (i = 0; i < PREDICTION_PROBS; i++) {
805
        const int prob = seg->pred_probs[i];
806
807
808
809
        const int update = prob != MAX_PROB;
        vp9_wb_write_bit(wb, update);
        if (update)
          vp9_wb_write_literal(wb, prob, 8);
810
811
812
813
814
      }
    }
  }

  // Segmentation data
815
816
817
  vp9_wb_write_bit(wb, seg->update_data);
  if (seg->update_data) {
    vp9_wb_write_bit(wb, seg->abs_delta);
818

Paul Wilkins's avatar
Paul Wilkins committed
819
    for (i = 0; i < MAX_SEGMENTS; i++) {
820
      for (j = 0; j < SEG_LVL_MAX; j++) {
821
        const int active = vp9_segfeature_active(seg, i, j);
822
823
        vp9_wb_write_bit(wb, active);
        if (active) {
824
          const int data = vp9_get_segdata(seg, i, j);
825
          const int data_max = vp9_seg_feature_data_max(j);
826
827

          if (vp9_is_segfeature_signed(j)) {
828
829
            vp9_encode_unsigned_max(wb, abs(data), data_max);
            vp9_wb_write_bit(wb, data < 0);
830
          } else {
831
            vp9_encode_unsigned_max(wb, data, data_max);
832
833
834
835
836
837
838
          }
        }
      }
    }
  }
}

839

840
static void encode_txfm_probs(VP9_COMP *cpi, vp9_writer *w) {
841
842
843
  VP9_COMMON *const cm = &cpi->common;

  // Mode
844
845
846
  vp9_write_literal(w, MIN(cm->tx_mode, ALLOW_32X32), 2);
  if (cm->tx_mode >= ALLOW_32X32)
    vp9_write_bit(w, cm->tx_mode == TX_MODE_SELECT);
847
848

  // Probabilities
849
  if (cm->tx_mode == TX_MODE_SELECT) {
850
    int i, j;
851
852
853
    unsigned int ct_8x8p[TX_SIZES - 3][2];
    unsigned int ct_16x16p[TX_SIZES - 2][2];
    unsigned int ct_32x32p[TX_SIZES - 1][2];
854
855


856
    for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
857
      tx_counts_to_branch_counts_8x8(cm->counts.tx.p8x8[i], ct_8x8p);
858
      for (j = 0; j < TX_SIZES - 3; j++)
859
        vp9_cond_prob_diff_update(w, &cm->fc.tx_probs.p8x8[i][j], ct_8x8p[j]);
860
    }
861

862
    for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
863
      tx_counts_to_branch_counts_16x16(cm->counts.tx.p16x16[i], ct_16x16p);
864
      for (j = 0; j < TX_SIZES - 2; j++)
865
        vp9_cond_prob_diff_update(w, &cm->fc.tx_probs.p16x16[i][j],
866
                                  ct_16x16p[j]);
Deb Mukherjee's avatar