src/third_party/libvpx/source/libvpx/vp9/encoder/vp9_bitstream.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  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.
   9  */
  10
  11 #include <assert.h>
  12 #include <stdio.h>
  13 #include <limits.h>
  14
  15 #include "vpx/vpx_encoder.h"
  16 #include "vpx_mem/vpx_mem.h"
  17 #include "vpx_ports/mem_ops.h"
  18
  19 #include "vp9/common/vp9_entropy.h"
  20 #include "vp9/common/vp9_entropymode.h"
  21 #include "vp9/common/vp9_entropymv.h"
  22 #include "vp9/common/vp9_mvref_common.h"
  23 #include "vp9/common/vp9_pred_common.h"
  24 #include "vp9/common/vp9_seg_common.h"
  25 #include "vp9/common/vp9_systemdependent.h"
  26 #include "vp9/common/vp9_tile_common.h"
  27
  28 #include "vp9/encoder/vp9_cost.h"
  29 #include "vp9/encoder/vp9_bitstream.h"
  30 #include "vp9/encoder/vp9_encodemv.h"
  31 #include "vp9/encoder/vp9_mcomp.h"
  32 #include "vp9/encoder/vp9_segmentation.h"
  33 #include "vp9/encoder/vp9_subexp.h"
  34 #include "vp9/encoder/vp9_tokenize.h"
  35 #include "vp9/encoder/vp9_write_bit_buffer.h"
  36
  37 static struct vp9_token intra_mode_encodings[INTRA_MODES];
  38 static struct vp9_token switchable_interp_encodings[SWITCHABLE_FILTERS];
  39 static struct vp9_token partition_encodings[PARTITION_TYPES];
  40 static struct vp9_token inter_mode_encodings[INTER_MODES];
  41
  42 void vp9_entropy_mode_init() {
  43   vp9_tokens_from_tree(intra_mode_encodings, vp9_intra_mode_tree);
  44   vp9_tokens_from_tree(switchable_interp_encodings, vp9_switchable_interp_tree);
  45   vp9_tokens_from_tree(partition_encodings, vp9_partition_tree);
  46   vp9_tokens_from_tree(inter_mode_encodings, vp9_inter_mode_tree);
  47 }
  48
  49 static void write_intra_mode(vp9_writer *w, PREDICTION_MODE mode,
  50                              const vp9_prob *probs) {
  51   vp9_write_token(w, vp9_intra_mode_tree, probs, &intra_mode_encodings[mode]);
  52 }
  53
  54 static void write_inter_mode(vp9_writer *w, PREDICTION_MODE mode,
  55                              const vp9_prob *probs) {
  56   assert(is_inter_mode(mode));
  57   vp9_write_token(w, vp9_inter_mode_tree, probs,
  58                   &inter_mode_encodings[INTER_OFFSET(mode)]);
  59 }
  60
  61 static void encode_unsigned_max(struct vp9_write_bit_buffer *wb,
  62                                 int data, int max) {
  63   vp9_wb_write_literal(wb, data, get_unsigned_bits(max));
  64 }
  65
  66 static void prob_diff_update(const vp9_tree_index *tree,
  67                              vp9_prob probs[/*n - 1*/],
  68                              const unsigned int counts[/*n - 1*/],
  69                              int n, vp9_writer *w) {
  70   int i;
  71   unsigned int branch_ct[32][2];
  72
  73   // Assuming max number of probabilities <= 32
  74   assert(n <= 32);
  75
  76   vp9_tree_probs_from_distribution(tree, branch_ct, counts);
  77   for (i = 0; i < n - 1; ++i)
  78     vp9_cond_prob_diff_update(w, &probs[i], branch_ct[i]);
  79 }
  80
  81 static void write_selected_tx_size(const VP9_COMMON *cm,
  82                                    const MACROBLOCKD *xd,
  83                                    TX_SIZE tx_size, BLOCK_SIZE bsize,
  84                                    vp9_writer *w) {
  85   const TX_SIZE max_tx_size = max_txsize_lookup[bsize];
  86   const vp9_prob *const tx_probs = get_tx_probs2(max_tx_size, xd,
  87                                                  &cm->fc.tx_probs);
  88   vp9_write(w, tx_size != TX_4X4, tx_probs[0]);
  89   if (tx_size != TX_4X4 && max_tx_size >= TX_16X16) {
  90     vp9_write(w, tx_size != TX_8X8, tx_probs[1]);
  91     if (tx_size != TX_8X8 && max_tx_size >= TX_32X32)
  92       vp9_write(w, tx_size != TX_16X16, tx_probs[2]);
  93   }
  94 }
  95
  96 static int write_skip(const VP9_COMMON *cm, const MACROBLOCKD *xd,
  97                       int segment_id, const MODE_INFO *mi, vp9_writer *w) {
  98   if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
  99     return 1;
 100   } else {
 101     const int skip = mi->mbmi.skip;
 102     vp9_write(w, skip, vp9_get_skip_prob(cm, xd));
 103     return skip;
 104   }
 105 }
 106
 107 static void update_skip_probs(VP9_COMMON *cm, vp9_writer *w) {
 108   int k;
 109
 110   for (k = 0; k < SKIP_CONTEXTS; ++k)
 111     vp9_cond_prob_diff_update(w, &cm->fc.skip_probs[k], cm->counts.skip[k]);
 112 }
 113
 114 static void update_switchable_interp_probs(VP9_COMMON *cm, vp9_writer *w) {
 115   int j;
 116   for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
 117     prob_diff_update(vp9_switchable_interp_tree,
 118                      cm->fc.switchable_interp_prob[j],
 119                      cm->counts.switchable_interp[j], SWITCHABLE_FILTERS, w);
 120 }
 121
 122 static void pack_mb_tokens(vp9_writer *w,
 123                            TOKENEXTRA **tp, const TOKENEXTRA *const stop,
 124                            vpx_bit_depth_t bit_depth) {
 125   TOKENEXTRA *p = *tp;
 126
 127   while (p < stop && p->token != EOSB_TOKEN) {
 128     const int t = p->token;
 129     const struct vp9_token *const a = &vp9_coef_encodings[t];
 130     int i = 0;
 131     int v = a->value;
 132     int n = a->len;
 133 #if CONFIG_VP9_HIGHBITDEPTH
 134     const vp9_extra_bit *b;
 135     if (bit_depth == VPX_BITS_12)
 136       b = &vp9_extra_bits_high12[t];
 137     else if (bit_depth == VPX_BITS_10)
 138       b = &vp9_extra_bits_high10[t];
 139     else
 140       b = &vp9_extra_bits[t];
 141 #else
 142     const vp9_extra_bit *const b = &vp9_extra_bits[t];
 143     (void) bit_depth;
 144 #endif  // CONFIG_VP9_HIGHBITDEPTH
 145
 146     /* skip one or two nodes */
 147     if (p->skip_eob_node) {
 148       n -= p->skip_eob_node;
 149       i = 2 * p->skip_eob_node;
 150     }
 151
 152     // TODO(jbb): expanding this can lead to big gains.  It allows
 153     // much better branch prediction and would enable us to avoid numerous
 154     // lookups and compares.
 155
 156     // If we have a token that's in the constrained set, the coefficient tree
 157     // is split into two treed writes.  The first treed write takes care of the
 158     // unconstrained nodes.  The second treed write takes care of the
 159     // constrained nodes.
 160     if (t >= TWO_TOKEN && t < EOB_TOKEN) {
 161       int len = UNCONSTRAINED_NODES - p->skip_eob_node;
 162       int bits = v >> (n - len);
 163       vp9_write_tree(w, vp9_coef_tree, p->context_tree, bits, len, i);
 164       vp9_write_tree(w, vp9_coef_con_tree,
 165                      vp9_pareto8_full[p->context_tree[PIVOT_NODE] - 1],
 166                      v, n - len, 0);
 167     } else {
 168       vp9_write_tree(w, vp9_coef_tree, p->context_tree, v, n, i);
 169     }
 170
 171     if (b->base_val) {
 172       const int e = p->extra, l = b->len;
 173
 174       if (l) {
 175         const unsigned char *pb = b->prob;
 176         int v = e >> 1;
 177         int n = l;              /* number of bits in v, assumed nonzero */
 178         int i = 0;
 179
 180         do {
 181           const int bb = (v >> --n) & 1;
 182           vp9_write(w, bb, pb[i >> 1]);
 183           i = b->tree[i + bb];
 184         } while (n);
 185       }
 186
 187       vp9_write_bit(w, e & 1);
 188     }
 189     ++p;
 190   }
 191
 192   *tp = p + (p->token == EOSB_TOKEN);
 193 }
 194
 195 static void write_segment_id(vp9_writer *w, const struct segmentation *seg,
 196                              int segment_id) {
 197   if (seg->enabled && seg->update_map)
 198     vp9_write_tree(w, vp9_segment_tree, seg->tree_probs, segment_id, 3, 0);
 199 }
 200
 201 // This function encodes the reference frame
 202 static void write_ref_frames(const VP9_COMMON *cm, const MACROBLOCKD *xd,
 203                              vp9_writer *w) {
 204   const MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
 205   const int is_compound = has_second_ref(mbmi);
 206   const int segment_id = mbmi->segment_id;
 207
 208   // If segment level coding of this signal is disabled...
 209   // or the segment allows multiple reference frame options
 210   if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
 211     assert(!is_compound);
 212     assert(mbmi->ref_frame[0] ==
 213                vp9_get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME));
 214   } else {
 215     // does the feature use compound prediction or not
 216     // (if not specified at the frame/segment level)
 217     if (cm->reference_mode == REFERENCE_MODE_SELECT) {
 218       vp9_write(w, is_compound, vp9_get_reference_mode_prob(cm, xd));
 219     } else {
 220       assert(!is_compound == (cm->reference_mode == SINGLE_REFERENCE));
 221     }
 222
 223     if (is_compound) {
 224       vp9_write(w, mbmi->ref_frame[0] == GOLDEN_FRAME,
 225                 vp9_get_pred_prob_comp_ref_p(cm, xd));
 226     } else {
 227       const int bit0 = mbmi->ref_frame[0] != LAST_FRAME;
 228       vp9_write(w, bit0, vp9_get_pred_prob_single_ref_p1(cm, xd));
 229       if (bit0) {
 230         const int bit1 = mbmi->ref_frame[0] != GOLDEN_FRAME;
 231         vp9_write(w, bit1, vp9_get_pred_prob_single_ref_p2(cm, xd));
 232       }
 233     }
 234   }
 235 }
 236
 237 static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
 238                                 vp9_writer *w) {
 239   VP9_COMMON *const cm = &cpi->common;
 240   const nmv_context *nmvc = &cm->fc.nmvc;
 241   const MACROBLOCK *const x = &cpi->mb;
 242   const MACROBLOCKD *const xd = &x->e_mbd;
 243   const struct segmentation *const seg = &cm->seg;
 244   const MB_MODE_INFO *const mbmi = &mi->mbmi;
 245   const PREDICTION_MODE mode = mbmi->mode;
 246   const int segment_id = mbmi->segment_id;
 247   const BLOCK_SIZE bsize = mbmi->sb_type;
 248   const int allow_hp = cm->allow_high_precision_mv;
 249   const int is_inter = is_inter_block(mbmi);
 250   const int is_compound = has_second_ref(mbmi);
 251   int skip, ref;
 252
 253   if (seg->update_map) {
 254     if (seg->temporal_update) {
 255       const int pred_flag = mbmi->seg_id_predicted;
 256       vp9_prob pred_prob = vp9_get_pred_prob_seg_id(seg, xd);
 257       vp9_write(w, pred_flag, pred_prob);
 258       if (!pred_flag)
 259         write_segment_id(w, seg, segment_id);
 260     } else {
 261       write_segment_id(w, seg, segment_id);
 262     }
 263   }
 264
 265   skip = write_skip(cm, xd, segment_id, mi, w);
 266
 267   if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME))
 268     vp9_write(w, is_inter, vp9_get_intra_inter_prob(cm, xd));
 269
 270   if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT &&
 271       !(is_inter &&
 272         (skip || vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP)))) {
 273     write_selected_tx_size(cm, xd, mbmi->tx_size, bsize, w);
 274   }
 275
 276   if (!is_inter) {
 277     if (bsize >= BLOCK_8X8) {
 278       write_intra_mode(w, mode, cm->fc.y_mode_prob[size_group_lookup[bsize]]);
 279     } else {
 280       int idx, idy;
 281       const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
 282       const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
 283       for (idy = 0; idy < 2; idy += num_4x4_h) {
 284         for (idx = 0; idx < 2; idx += num_4x4_w) {
 285           const PREDICTION_MODE b_mode = mi->bmi[idy * 2 + idx].as_mode;
 286           write_intra_mode(w, b_mode, cm->fc.y_mode_prob[0]);
 287         }
 288       }
 289     }
 290     write_intra_mode(w, mbmi->uv_mode, cm->fc.uv_mode_prob[mode]);
 291   } else {
 292     const int mode_ctx = mbmi->mode_context[mbmi->ref_frame[0]];
 293     const vp9_prob *const inter_probs = cm->fc.inter_mode_probs[mode_ctx];
 294     write_ref_frames(cm, xd, w);
 295
 296     // If segment skip is not enabled code the mode.
 297     if (!vp9_segfeature_active(seg, segment_id, SEG_LVL_SKIP)) {
 298       if (bsize >= BLOCK_8X8) {
 299         write_inter_mode(w, mode, inter_probs);
 300         ++cm->counts.inter_mode[mode_ctx][INTER_OFFSET(mode)];
 301       }
 302     }
 303
 304     if (cm->interp_filter == SWITCHABLE) {
 305       const int ctx = vp9_get_pred_context_switchable_interp(xd);
 306       vp9_write_token(w, vp9_switchable_interp_tree,
 307                       cm->fc.switchable_interp_prob[ctx],
 308                       &switchable_interp_encodings[mbmi->interp_filter]);
 309       ++cpi->interp_filter_selected[0][mbmi->interp_filter];
 310     } else {
 311       assert(mbmi->interp_filter == cm->interp_filter);
 312     }
 313
 314     if (bsize < BLOCK_8X8) {
 315       const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
 316       const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
 317       int idx, idy;
 318       for (idy = 0; idy < 2; idy += num_4x4_h) {
 319         for (idx = 0; idx < 2; idx += num_4x4_w) {
 320           const int j = idy * 2 + idx;
 321           const PREDICTION_MODE b_mode = mi->bmi[j].as_mode;
 322           write_inter_mode(w, b_mode, inter_probs);
 323           ++cm->counts.inter_mode[mode_ctx][INTER_OFFSET(b_mode)];
 324           if (b_mode == NEWMV) {
 325             for (ref = 0; ref < 1 + is_compound; ++ref)
 326               vp9_encode_mv(cpi, w, &mi->bmi[j].as_mv[ref].as_mv,
 327                             &mbmi->ref_mvs[mbmi->ref_frame[ref]][0].as_mv,
 328                             nmvc, allow_hp);
 329           }
 330         }
 331       }
 332     } else {
 333       if (mode == NEWMV) {
 334         for (ref = 0; ref < 1 + is_compound; ++ref)
 335           vp9_encode_mv(cpi, w, &mbmi->mv[ref].as_mv,
 336                         &mbmi->ref_mvs[mbmi->ref_frame[ref]][0].as_mv, nmvc,
 337                         allow_hp);
 338       }
 339     }
 340   }
 341 }
 342
 343 static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
 344                               MODE_INFO *mi_8x8, vp9_writer *w) {
 345   const struct segmentation *const seg = &cm->seg;
 346   const MODE_INFO *const mi = mi_8x8;
 347   const MODE_INFO *const above_mi = mi_8x8[-xd->mi_stride].src_mi;
 348   const MODE_INFO *const left_mi =
 349       xd->left_available ? mi_8x8[-1].src_mi : NULL;
 350   const MB_MODE_INFO *const mbmi = &mi->mbmi;
 351   const BLOCK_SIZE bsize = mbmi->sb_type;
 352
 353   if (seg->update_map)
 354     write_segment_id(w, seg, mbmi->segment_id);
 355
 356   write_skip(cm, xd, mbmi->segment_id, mi, w);
 357
 358   if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT)
 359     write_selected_tx_size(cm, xd, mbmi->tx_size, bsize, w);
 360
 361   if (bsize >= BLOCK_8X8) {
 362     write_intra_mode(w, mbmi->mode, get_y_mode_probs(mi, above_mi, left_mi, 0));
 363   } else {
 364     const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
 365     const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
 366     int idx, idy;
 367
 368     for (idy = 0; idy < 2; idy += num_4x4_h) {
 369       for (idx = 0; idx < 2; idx += num_4x4_w) {
 370         const int block = idy * 2 + idx;
 371         write_intra_mode(w, mi->bmi[block].as_mode,
 372                          get_y_mode_probs(mi, above_mi, left_mi, block));
 373       }
 374     }
 375   }
 376
 377   write_intra_mode(w, mbmi->uv_mode, vp9_kf_uv_mode_prob[mbmi->mode]);
 378 }
 379
 380 static void write_modes_b(VP9_COMP *cpi, const TileInfo *const tile,
 381                           vp9_writer *w, TOKENEXTRA **tok,
 382                           const TOKENEXTRA *const tok_end,
 383                           int mi_row, int mi_col) {
 384   const VP9_COMMON *const cm = &cpi->common;
 385   MACROBLOCKD *const xd = &cpi->mb.e_mbd;
 386   MODE_INFO *m;
 387
 388   xd->mi = cm->mi + (mi_row * cm->mi_stride + mi_col);
 389   m = xd->mi;
 390
 391   set_mi_row_col(xd, tile,
 392                  mi_row, num_8x8_blocks_high_lookup[m->mbmi.sb_type],
 393                  mi_col, num_8x8_blocks_wide_lookup[m->mbmi.sb_type],
 394                  cm->mi_rows, cm->mi_cols);
 395   if (frame_is_intra_only(cm)) {
 396     write_mb_modes_kf(cm, xd, xd->mi, w);
 397   } else {
 398     pack_inter_mode_mvs(cpi, m, w);
 399   }
 400
 401   assert(*tok < tok_end);
 402   pack_mb_tokens(w, tok, tok_end, cm->bit_depth);
 403 }
 404
 405 static void write_partition(const VP9_COMMON *const cm,
 406                             const MACROBLOCKD *const xd,
 407                             int hbs, int mi_row, int mi_col,
 408                             PARTITION_TYPE p, BLOCK_SIZE bsize, vp9_writer *w) {
 409   const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
 410   const vp9_prob *const probs = get_partition_probs(cm, ctx);
 411   const int has_rows = (mi_row + hbs) < cm->mi_rows;
 412   const int has_cols = (mi_col + hbs) < cm->mi_cols;
 413
 414   if (has_rows && has_cols) {
 415     vp9_write_token(w, vp9_partition_tree, probs, &partition_encodings[p]);
 416   } else if (!has_rows && has_cols) {
 417     assert(p == PARTITION_SPLIT || p == PARTITION_HORZ);
 418     vp9_write(w, p == PARTITION_SPLIT, probs[1]);
 419   } else if (has_rows && !has_cols) {
 420     assert(p == PARTITION_SPLIT || p == PARTITION_VERT);
 421     vp9_write(w, p == PARTITION_SPLIT, probs[2]);
 422   } else {
 423     assert(p == PARTITION_SPLIT);
 424   }
 425 }
 426
 427 static void write_modes_sb(VP9_COMP *cpi,
 428                            const TileInfo *const tile, vp9_writer *w,
 429                            TOKENEXTRA **tok, const TOKENEXTRA *const tok_end,
 430                            int mi_row, int mi_col, BLOCK_SIZE bsize) {
 431   const VP9_COMMON *const cm = &cpi->common;
 432   MACROBLOCKD *const xd = &cpi->mb.e_mbd;
 433
 434   const int bsl = b_width_log2_lookup[bsize];
 435   const int bs = (1 << bsl) / 4;
 436   PARTITION_TYPE partition;
 437   BLOCK_SIZE subsize;
 438   const MODE_INFO *m = NULL;
 439
 440   if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
 441     return;
 442
 443   m = cm->mi[mi_row * cm->mi_stride + mi_col].src_mi;
 444
 445   partition = partition_lookup[bsl][m->mbmi.sb_type];
 446   write_partition(cm, xd, bs, mi_row, mi_col, partition, bsize, w);
 447   subsize = get_subsize(bsize, partition);
 448   if (subsize < BLOCK_8X8) {
 449     write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
 450   } else {
 451     switch (partition) {
 452       case PARTITION_NONE:
 453         write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
 454         break;
 455       case PARTITION_HORZ:
 456         write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
 457         if (mi_row + bs < cm->mi_rows)
 458           write_modes_b(cpi, tile, w, tok, tok_end, mi_row + bs, mi_col);
 459         break;
 460       case PARTITION_VERT:
 461         write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
 462         if (mi_col + bs < cm->mi_cols)
 463           write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + bs);
 464         break;
 465       case PARTITION_SPLIT:
 466         write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, subsize);
 467         write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col + bs,
 468                        subsize);
 469         write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + bs, mi_col,
 470                        subsize);
 471         write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + bs, mi_col + bs,
 472                        subsize);
 473         break;
 474       default:
 475         assert(0);
 476     }
 477   }
 478
 479   // update partition context
 480   if (bsize >= BLOCK_8X8 &&
 481       (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
 482     update_partition_context(xd, mi_row, mi_col, subsize, bsize);
 483 }
 484
 485 static void write_modes(VP9_COMP *cpi,
 486                         const TileInfo *const tile, vp9_writer *w,
 487                         TOKENEXTRA **tok, const TOKENEXTRA *const tok_end) {
 488   int mi_row, mi_col;
 489
 490   for (mi_row = tile->mi_row_start; mi_row < tile->mi_row_end;
 491        mi_row += MI_BLOCK_SIZE) {
 492     vp9_zero(cpi->mb.e_mbd.left_seg_context);
 493     for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
 494          mi_col += MI_BLOCK_SIZE)
 495       write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col,
 496                      BLOCK_64X64);
 497   }
 498 }
 499
 500 static void build_tree_distribution(VP9_COMP *cpi, TX_SIZE tx_size,
 501                                     vp9_coeff_stats *coef_branch_ct,
 502                                     vp9_coeff_probs_model *coef_probs) {
 503   vp9_coeff_count *coef_counts = cpi->coef_counts[tx_size];
 504   unsigned int (*eob_branch_ct)[REF_TYPES][COEF_BANDS][COEFF_CONTEXTS] =
 505       cpi->common.counts.eob_branch[tx_size];
 506   int i, j, k, l, m;
 507
 508   for (i = 0; i < PLANE_TYPES; ++i) {
 509     for (j = 0; j < REF_TYPES; ++j) {
 510       for (k = 0; k < COEF_BANDS; ++k) {
 511         for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
 512           vp9_tree_probs_from_distribution(vp9_coef_tree,
 513                                            coef_branch_ct[i][j][k][l],
 514                                            coef_counts[i][j][k][l]);
 515           coef_branch_ct[i][j][k][l][0][1] = eob_branch_ct[i][j][k][l] -
 516                                              coef_branch_ct[i][j][k][l][0][0];
 517           for (m = 0; m < UNCONSTRAINED_NODES; ++m)
 518             coef_probs[i][j][k][l][m] = get_binary_prob(
 519                                             coef_branch_ct[i][j][k][l][m][0],
 520                                             coef_branch_ct[i][j][k][l][m][1]);
 521         }
 522       }
 523     }
 524   }
 525 }
 526
 527 static void update_coef_probs_common(vp9_writer* const bc, VP9_COMP *cpi,
 528                                      TX_SIZE tx_size,
 529                                      vp9_coeff_stats *frame_branch_ct,
 530                                      vp9_coeff_probs_model *new_coef_probs) {
 531   vp9_coeff_probs_model *old_coef_probs = cpi->common.fc.coef_probs[tx_size];
 532   const vp9_prob upd = DIFF_UPDATE_PROB;
 533   const int entropy_nodes_update = UNCONSTRAINED_NODES;
 534   int i, j, k, l, t;
 535   switch (cpi->sf.use_fast_coef_updates) {
 536     case TWO_LOOP: {
 537       /* dry run to see if there is any update at all needed */
 538       int savings = 0;
 539       int update[2] = {0, 0};
 540       for (i = 0; i < PLANE_TYPES; ++i) {
 541         for (j = 0; j < REF_TYPES; ++j) {
 542           for (k = 0; k < COEF_BANDS; ++k) {
 543             for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
 544               for (t = 0; t < entropy_nodes_update; ++t) {
 545                 vp9_prob newp = new_coef_probs[i][j][k][l][t];
 546                 const vp9_prob oldp = old_coef_probs[i][j][k][l][t];
 547                 int s;
 548                 int u = 0;
 549                 if (t == PIVOT_NODE)
 550                   s = vp9_prob_diff_update_savings_search_model(
 551                       frame_branch_ct[i][j][k][l][0],
 552                       old_coef_probs[i][j][k][l], &newp, upd);
 553                 else
 554                   s = vp9_prob_diff_update_savings_search(
 555                       frame_branch_ct[i][j][k][l][t], oldp, &newp, upd);
 556                 if (s > 0 && newp != oldp)
 557                   u = 1;
 558                 if (u)
 559                   savings += s - (int)(vp9_cost_zero(upd));
 560                 else
 561                   savings -= (int)(vp9_cost_zero(upd));
 562                 update[u]++;
 563               }
 564             }
 565           }
 566         }
 567       }
 568
 569       // printf("Update %d %d, savings %d\n", update[0], update[1], savings);
 570       /* Is coef updated at all */
 571       if (update[1] == 0 || savings < 0) {
 572         vp9_write_bit(bc, 0);
 573         return;
 574       }
 575       vp9_write_bit(bc, 1);
 576       for (i = 0; i < PLANE_TYPES; ++i) {
 577         for (j = 0; j < REF_TYPES; ++j) {
 578           for (k = 0; k < COEF_BANDS; ++k) {
 579             for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
 580               // calc probs and branch cts for this frame only
 581               for (t = 0; t < entropy_nodes_update; ++t) {
 582                 vp9_prob newp = new_coef_probs[i][j][k][l][t];
 583                 vp9_prob *oldp = old_coef_probs[i][j][k][l] + t;
 584                 const vp9_prob upd = DIFF_UPDATE_PROB;
 585                 int s;
 586                 int u = 0;
 587                 if (t == PIVOT_NODE)
 588                   s = vp9_prob_diff_update_savings_search_model(
 589                       frame_branch_ct[i][j][k][l][0],
 590                       old_coef_probs[i][j][k][l], &newp, upd);
 591                 else
 592                   s = vp9_prob_diff_update_savings_search(
 593                       frame_branch_ct[i][j][k][l][t],
 594                       *oldp, &newp, upd);
 595                 if (s > 0 && newp != *oldp)
 596                   u = 1;
 597                 vp9_write(bc, u, upd);
 598                 if (u) {
 599                   /* send/use new probability */
 600                   vp9_write_prob_diff_update(bc, newp, *oldp);
 601                   *oldp = newp;
 602                 }
 603               }
 604             }
 605           }
 606         }
 607       }
 608       return;
 609     }
 610
 611     case ONE_LOOP:
 612     case ONE_LOOP_REDUCED: {
 613       const int prev_coef_contexts_to_update =
 614           cpi->sf.use_fast_coef_updates == ONE_LOOP_REDUCED ?
 615               COEFF_CONTEXTS >> 1 : COEFF_CONTEXTS;
 616       const int coef_band_to_update =
 617           cpi->sf.use_fast_coef_updates == ONE_LOOP_REDUCED ?
 618               COEF_BANDS >> 1 : COEF_BANDS;
 619       int updates = 0;
 620       int noupdates_before_first = 0;
 621       for (i = 0; i < PLANE_TYPES; ++i) {
 622         for (j = 0; j < REF_TYPES; ++j) {
 623           for (k = 0; k < COEF_BANDS; ++k) {
 624             for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
 625               // calc probs and branch cts for this frame only
 626               for (t = 0; t < entropy_nodes_update; ++t) {
 627                 vp9_prob newp = new_coef_probs[i][j][k][l][t];
 628                 vp9_prob *oldp = old_coef_probs[i][j][k][l] + t;
 629                 int s;
 630                 int u = 0;
 631                 if (l >= prev_coef_contexts_to_update ||
 632                     k >= coef_band_to_update) {
 633                   u = 0;
 634                 } else {
 635                   if (t == PIVOT_NODE)
 636                     s = vp9_prob_diff_update_savings_search_model(
 637                         frame_branch_ct[i][j][k][l][0],
 638                         old_coef_probs[i][j][k][l], &newp, upd);
 639                   else
 640                     s = vp9_prob_diff_update_savings_search(
 641                         frame_branch_ct[i][j][k][l][t],
 642                         *oldp, &newp, upd);
 643                   if (s > 0 && newp != *oldp)
 644                     u = 1;
 645                 }
 646                 updates += u;
 647                 if (u == 0 && updates == 0) {
 648                   noupdates_before_first++;
 649                   continue;
 650                 }
 651                 if (u == 1 && updates == 1) {
 652                   int v;
 653                   // first update
 654                   vp9_write_bit(bc, 1);
 655                   for (v = 0; v < noupdates_before_first; ++v)
 656                     vp9_write(bc, 0, upd);
 657                 }
 658                 vp9_write(bc, u, upd);
 659                 if (u) {
 660                   /* send/use new probability */
 661                   vp9_write_prob_diff_update(bc, newp, *oldp);
 662                   *oldp = newp;
 663                 }
 664               }
 665             }
 666           }
 667         }
 668       }
 669       if (updates == 0) {
 670         vp9_write_bit(bc, 0);  // no updates
 671       }
 672       return;
 673     }
 674
 675     default:
 676       assert(0);
 677   }
 678 }
 679
 680 static void update_coef_probs(VP9_COMP *cpi, vp9_writer* w) {
 681   const TX_MODE tx_mode = cpi->common.tx_mode;
 682   const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
 683   TX_SIZE tx_size;
 684   vp9_coeff_stats frame_branch_ct[TX_SIZES][PLANE_TYPES];
 685   vp9_coeff_probs_model frame_coef_probs[TX_SIZES][PLANE_TYPES];
 686
 687   for (tx_size = TX_4X4; tx_size <= TX_32X32; ++tx_size)
 688     build_tree_distribution(cpi, tx_size, frame_branch_ct[tx_size],
 689                             frame_coef_probs[tx_size]);
 690
 691   for (tx_size = TX_4X4; tx_size <= max_tx_size; ++tx_size)
 692     update_coef_probs_common(w, cpi, tx_size, frame_branch_ct[tx_size],
 693                              frame_coef_probs[tx_size]);
 694 }
 695
 696 static void encode_loopfilter(struct loopfilter *lf,
 697                               struct vp9_write_bit_buffer *wb) {
 698   int i;
 699
 700   // Encode the loop filter level and type
 701   vp9_wb_write_literal(wb, lf->filter_level, 6);
 702   vp9_wb_write_literal(wb, lf->sharpness_level, 3);
 703
 704   // Write out loop filter deltas applied at the MB level based on mode or
 705   // ref frame (if they are enabled).
 706   vp9_wb_write_bit(wb, lf->mode_ref_delta_enabled);
 707
 708   if (lf->mode_ref_delta_enabled) {
 709     vp9_wb_write_bit(wb, lf->mode_ref_delta_update);
 710     if (lf->mode_ref_delta_update) {
 711       for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
 712         const int delta = lf->ref_deltas[i];
 713         const int changed = delta != lf->last_ref_deltas[i];
 714         vp9_wb_write_bit(wb, changed);
 715         if (changed) {
 716           lf->last_ref_deltas[i] = delta;
 717           vp9_wb_write_literal(wb, abs(delta) & 0x3F, 6);
 718           vp9_wb_write_bit(wb, delta < 0);
 719         }
 720       }
 721
 722       for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
 723         const int delta = lf->mode_deltas[i];
 724         const int changed = delta != lf->last_mode_deltas[i];
 725         vp9_wb_write_bit(wb, changed);
 726         if (changed) {
 727           lf->last_mode_deltas[i] = delta;
 728           vp9_wb_write_literal(wb, abs(delta) & 0x3F, 6);
 729           vp9_wb_write_bit(wb, delta < 0);
 730         }
 731       }
 732     }
 733   }
 734 }
 735
 736 static void write_delta_q(struct vp9_write_bit_buffer *wb, int delta_q) {
 737   if (delta_q != 0) {
 738     vp9_wb_write_bit(wb, 1);
 739     vp9_wb_write_literal(wb, abs(delta_q), 4);
 740     vp9_wb_write_bit(wb, delta_q < 0);
 741   } else {
 742     vp9_wb_write_bit(wb, 0);
 743   }
 744 }
 745
 746 static void encode_quantization(const VP9_COMMON *const cm,
 747                                 struct vp9_write_bit_buffer *wb) {
 748   vp9_wb_write_literal(wb, cm->base_qindex, QINDEX_BITS);
 749   write_delta_q(wb, cm->y_dc_delta_q);
 750   write_delta_q(wb, cm->uv_dc_delta_q);
 751   write_delta_q(wb, cm->uv_ac_delta_q);
 752 }
 753
 754 static void encode_segmentation(VP9_COMMON *cm, MACROBLOCKD *xd,
 755                                 struct vp9_write_bit_buffer *wb) {
 756   int i, j;
 757
 758   const struct segmentation *seg = &cm->seg;
 759
 760   vp9_wb_write_bit(wb, seg->enabled);
 761   if (!seg->enabled)
 762     return;
 763
 764   // Segmentation map
 765   vp9_wb_write_bit(wb, seg->update_map);
 766   if (seg->update_map) {
 767     // Select the coding strategy (temporal or spatial)
 768     vp9_choose_segmap_coding_method(cm, xd);
 769     // Write out probabilities used to decode unpredicted  macro-block segments
 770     for (i = 0; i < SEG_TREE_PROBS; i++) {
 771       const int prob = seg->tree_probs[i];
 772       const int update = prob != MAX_PROB;
 773       vp9_wb_write_bit(wb, update);
 774       if (update)
 775         vp9_wb_write_literal(wb, prob, 8);
 776     }
 777
 778     // Write out the chosen coding method.
 779     vp9_wb_write_bit(wb, seg->temporal_update);
 780     if (seg->temporal_update) {
 781       for (i = 0; i < PREDICTION_PROBS; i++) {
 782         const int prob = seg->pred_probs[i];
 783         const int update = prob != MAX_PROB;
 784         vp9_wb_write_bit(wb, update);
 785         if (update)
 786           vp9_wb_write_literal(wb, prob, 8);
 787       }
 788     }
 789   }
 790
 791   // Segmentation data
 792   vp9_wb_write_bit(wb, seg->update_data);
 793   if (seg->update_data) {
 794     vp9_wb_write_bit(wb, seg->abs_delta);
 795
 796     for (i = 0; i < MAX_SEGMENTS; i++) {
 797       for (j = 0; j < SEG_LVL_MAX; j++) {
 798         const int active = vp9_segfeature_active(seg, i, j);
 799         vp9_wb_write_bit(wb, active);
 800         if (active) {
 801           const int data = vp9_get_segdata(seg, i, j);
 802           const int data_max = vp9_seg_feature_data_max(j);
 803
 804           if (vp9_is_segfeature_signed(j)) {
 805             encode_unsigned_max(wb, abs(data), data_max);
 806             vp9_wb_write_bit(wb, data < 0);
 807           } else {
 808             encode_unsigned_max(wb, data, data_max);
 809           }
 810         }
 811       }
 812     }
 813   }
 814 }
 815
 816 static void encode_txfm_probs(VP9_COMMON *cm, vp9_writer *w) {
 817   // Mode
 818   vp9_write_literal(w, MIN(cm->tx_mode, ALLOW_32X32), 2);
 819   if (cm->tx_mode >= ALLOW_32X32)
 820     vp9_write_bit(w, cm->tx_mode == TX_MODE_SELECT);
 821
 822   // Probabilities
 823   if (cm->tx_mode == TX_MODE_SELECT) {
 824     int i, j;
 825     unsigned int ct_8x8p[TX_SIZES - 3][2];
 826     unsigned int ct_16x16p[TX_SIZES - 2][2];
 827     unsigned int ct_32x32p[TX_SIZES - 1][2];
 828
 829
 830     for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
 831       tx_counts_to_branch_counts_8x8(cm->counts.tx.p8x8[i], ct_8x8p);
 832       for (j = 0; j < TX_SIZES - 3; j++)
 833         vp9_cond_prob_diff_update(w, &cm->fc.tx_probs.p8x8[i][j], ct_8x8p[j]);
 834     }
 835
 836     for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
 837       tx_counts_to_branch_counts_16x16(cm->counts.tx.p16x16[i], ct_16x16p);
 838       for (j = 0; j < TX_SIZES - 2; j++)
 839         vp9_cond_prob_diff_update(w, &cm->fc.tx_probs.p16x16[i][j],
 840                                   ct_16x16p[j]);
 841     }
 842
 843     for (i = 0; i < TX_SIZE_CONTEXTS; i++) {
 844       tx_counts_to_branch_counts_32x32(cm->counts.tx.p32x32[i], ct_32x32p);
 845       for (j = 0; j < TX_SIZES - 1; j++)
 846         vp9_cond_prob_diff_update(w, &cm->fc.tx_probs.p32x32[i][j],
 847                                   ct_32x32p[j]);
 848     }
 849   }
 850 }
 851
 852 static void write_interp_filter(INTERP_FILTER filter,
 853                                 struct vp9_write_bit_buffer *wb) {
 854   const int filter_to_literal[] = { 1, 0, 2, 3 };
 855
 856   vp9_wb_write_bit(wb, filter == SWITCHABLE);
 857   if (filter != SWITCHABLE)
 858     vp9_wb_write_literal(wb, filter_to_literal[filter], 2);
 859 }
 860
 861 static void fix_interp_filter(VP9_COMMON *cm) {
 862   if (cm->interp_filter == SWITCHABLE) {
 863     // Check to see if only one of the filters is actually used
 864     int count[SWITCHABLE_FILTERS];
 865     int i, j, c = 0;
 866     for (i = 0; i < SWITCHABLE_FILTERS; ++i) {
 867       count[i] = 0;
 868       for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
 869         count[i] += cm->counts.switchable_interp[j][i];
 870       c += (count[i] > 0);
 871     }
 872     if (c == 1) {
 873       // Only one filter is used. So set the filter at frame level
 874       for (i = 0; i < SWITCHABLE_FILTERS; ++i) {
 875         if (count[i]) {
 876           cm->interp_filter = i;
 877           break;
 878         }
 879       }
 880     }
 881   }
 882 }
 883
 884 static void write_tile_info(const VP9_COMMON *const cm,
 885                             struct vp9_write_bit_buffer *wb) {
 886   int min_log2_tile_cols, max_log2_tile_cols, ones;
 887   vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
 888
 889   // columns
 890   ones = cm->log2_tile_cols - min_log2_tile_cols;
 891   while (ones--)
 892     vp9_wb_write_bit(wb, 1);
 893
 894   if (cm->log2_tile_cols < max_log2_tile_cols)
 895     vp9_wb_write_bit(wb, 0);
 896
 897   // rows
 898   vp9_wb_write_bit(wb, cm->log2_tile_rows != 0);
 899   if (cm->log2_tile_rows != 0)
 900     vp9_wb_write_bit(wb, cm->log2_tile_rows != 1);
 901 }
 902
 903 static int get_refresh_mask(VP9_COMP *cpi) {
 904   if (vp9_preserve_existing_gf(cpi)) {
 905     // We have decided to preserve the previously existing golden frame as our
 906     // new ARF frame. However, in the short term we leave it in the GF slot and,
 907     // if we're updating the GF with the current decoded frame, we save it
 908     // instead to the ARF slot.
 909     // Later, in the function vp9_encoder.c:vp9_update_reference_frames() we
 910     // will swap gld_fb_idx and alt_fb_idx to achieve our objective. We do it
 911     // there so that it can be done outside of the recode loop.
 912     // Note: This is highly specific to the use of ARF as a forward reference,
 913     // and this needs to be generalized as other uses are implemented
 914     // (like RTC/temporal scalability).
 915     return (cpi->refresh_last_frame << cpi->lst_fb_idx) |
 916            (cpi->refresh_golden_frame << cpi->alt_fb_idx);
 917   } else {
 918     int arf_idx = cpi->alt_fb_idx;
 919     if ((cpi->oxcf.pass == 2) && cpi->multi_arf_allowed) {
 920       const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
 921       arf_idx = gf_group->arf_update_idx[gf_group->index];
 922     }
 923     return (cpi->refresh_last_frame << cpi->lst_fb_idx) |
 924            (cpi->refresh_golden_frame << cpi->gld_fb_idx) |
 925            (cpi->refresh_alt_ref_frame << arf_idx);
 926   }
 927 }
 928
 929 static size_t encode_tiles(VP9_COMP *cpi, uint8_t *data_ptr) {
 930   VP9_COMMON *const cm = &cpi->common;
 931   vp9_writer residual_bc;
 932
 933   int tile_row, tile_col;
 934   TOKENEXTRA *tok[4][1 << 6], *tok_end;
 935   size_t total_size = 0;
 936   const int tile_cols = 1 << cm->log2_tile_cols;
 937   const int tile_rows = 1 << cm->log2_tile_rows;
 938   TileInfo tile[4][1 << 6];
 939   TOKENEXTRA *pre_tok = cpi->tok;
 940   int tile_tok = 0;
 941
 942   vpx_memset(cm->above_seg_context, 0, sizeof(*cm->above_seg_context) *
 943              mi_cols_aligned_to_sb(cm->mi_cols));
 944
 945   for (tile_row = 0; tile_row < tile_rows; ++tile_row) {
 946     for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
 947       vp9_tile_init(&tile[tile_row][tile_col], cm, tile_row, tile_col);
 948
 949       tok[tile_row][tile_col] = pre_tok + tile_tok;
 950       pre_tok = tok[tile_row][tile_col];
 951       tile_tok = allocated_tokens(tile[tile_row][tile_col]);
 952     }
 953   }
 954
 955   for (tile_row = 0; tile_row < tile_rows; tile_row++) {
 956     for (tile_col = 0; tile_col < tile_cols; tile_col++) {
 957       const TileInfo * const ptile = &tile[tile_row][tile_col];
 958
 959       tok_end = tok[tile_row][tile_col] + cpi->tok_count[tile_row][tile_col];
 960
 961       if (tile_col < tile_cols - 1 || tile_row < tile_rows - 1)
 962         vp9_start_encode(&residual_bc, data_ptr + total_size + 4);
 963       else
 964         vp9_start_encode(&residual_bc, data_ptr + total_size);
 965
 966       write_modes(cpi, ptile, &residual_bc, &tok[tile_row][tile_col], tok_end);
 967       assert(tok[tile_row][tile_col] == tok_end);
 968       vp9_stop_encode(&residual_bc);
 969       if (tile_col < tile_cols - 1 || tile_row < tile_rows - 1) {
 970         // size of this tile
 971         mem_put_be32(data_ptr + total_size, residual_bc.pos);
 972         total_size += 4;
 973       }
 974
 975       total_size += residual_bc.pos;
 976     }
 977   }
 978
 979   return total_size;
 980 }
 981
 982 static void write_display_size(const VP9_COMMON *cm,
 983                                struct vp9_write_bit_buffer *wb) {
 984   const int scaling_active = cm->width != cm->display_width ||
 985                              cm->height != cm->display_height;
 986   vp9_wb_write_bit(wb, scaling_active);
 987   if (scaling_active) {
 988     vp9_wb_write_literal(wb, cm->display_width - 1, 16);
 989     vp9_wb_write_literal(wb, cm->display_height - 1, 16);
 990   }
 991 }
 992
 993 static void write_frame_size(const VP9_COMMON *cm,
 994                              struct vp9_write_bit_buffer *wb) {
 995   vp9_wb_write_literal(wb, cm->width - 1, 16);
 996   vp9_wb_write_literal(wb, cm->height - 1, 16);
 997
 998   write_display_size(cm, wb);
 999 }
1000
1001 static void write_frame_size_with_refs(VP9_COMP *cpi,
1002                                        struct vp9_write_bit_buffer *wb) {
1003   VP9_COMMON *const cm = &cpi->common;
1004   int found = 0;
1005
1006   MV_REFERENCE_FRAME ref_frame;
1007   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
1008     YV12_BUFFER_CONFIG *cfg = get_ref_frame_buffer(cpi, ref_frame);
1009     found = cm->width == cfg->y_crop_width &&
1010             cm->height == cfg->y_crop_height;
1011
1012     // Set "found" to 0 for temporal svc and for spatial svc key frame
1013     if (cpi->use_svc &&
1014         ((cpi->svc.number_temporal_layers > 1 &&
1015          cpi->oxcf.rc_mode == VPX_CBR) ||
1016         (cpi->svc.number_spatial_layers > 1 &&
1017          cpi->svc.layer_context[cpi->svc.spatial_layer_id].is_key_frame) ||
1018         (is_two_pass_svc(cpi) &&
1019          cpi->svc.encode_empty_frame_state == ENCODING &&
1020          cpi->svc.layer_context[0].frames_from_key_frame <
1021          cpi->svc.number_temporal_layers + 1))) {
1022       found = 0;
1023     }
1024     vp9_wb_write_bit(wb, found);
1025     if (found) {
1026       break;
1027     }
1028   }
1029
1030   if (!found) {
1031     vp9_wb_write_literal(wb, cm->width - 1, 16);
1032     vp9_wb_write_literal(wb, cm->height - 1, 16);
1033   }
1034
1035   write_display_size(cm, wb);
1036 }
1037
1038 static void write_sync_code(struct vp9_write_bit_buffer *wb) {
1039   vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
1040   vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
1041   vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);
1042 }
1043
1044 static void write_profile(BITSTREAM_PROFILE profile,
1045                           struct vp9_write_bit_buffer *wb) {
1046   switch (profile) {
1047     case PROFILE_0:
1048       vp9_wb_write_literal(wb, 0, 2);
1049       break;
1050     case PROFILE_1:
1051       vp9_wb_write_literal(wb, 2, 2);
1052       break;
1053     case PROFILE_2:
1054       vp9_wb_write_literal(wb, 1, 2);
1055       break;
1056     case PROFILE_3:
1057       vp9_wb_write_literal(wb, 6, 3);
1058       break;
1059     default:
1060       assert(0);
1061   }
1062 }
1063
1064 static void write_bitdepth_colorspace_sampling(
1065     VP9_COMMON *const cm, struct vp9_write_bit_buffer *wb) {
1066   if (cm->profile >= PROFILE_2) {
1067     assert(cm->bit_depth > VPX_BITS_8);
1068     vp9_wb_write_bit(wb, cm->bit_depth == VPX_BITS_10 ? 0 : 1);
1069   }
1070   vp9_wb_write_literal(wb, cm->color_space, 3);
1071   if (cm->color_space != SRGB) {
1072     vp9_wb_write_bit(wb, 0);  // 0: [16, 235] (i.e. xvYCC), 1: [0, 255]
1073     if (cm->profile == PROFILE_1 || cm->profile == PROFILE_3) {
1074       assert(cm->subsampling_x != 1 || cm->subsampling_y != 1);
1075       vp9_wb_write_bit(wb, cm->subsampling_x);
1076       vp9_wb_write_bit(wb, cm->subsampling_y);
1077       vp9_wb_write_bit(wb, 0);  // unused
1078     } else {
1079       assert(cm->subsampling_x == 1 && cm->subsampling_y == 1);
1080     }
1081   } else {
1082     assert(cm->profile == PROFILE_1 || cm->profile == PROFILE_3);
1083     vp9_wb_write_bit(wb, 0);  // unused
1084   }
1085 }
1086
1087 static void write_uncompressed_header(VP9_COMP *cpi,
1088                                       struct vp9_write_bit_buffer *wb) {
1089   VP9_COMMON *const cm = &cpi->common;
1090
1091   vp9_wb_write_literal(wb, VP9_FRAME_MARKER, 2);
1092
1093   write_profile(cm->profile, wb);
1094
1095   vp9_wb_write_bit(wb, 0);  // show_existing_frame
1096   vp9_wb_write_bit(wb, cm->frame_type);
1097   vp9_wb_write_bit(wb, cm->show_frame);
1098   vp9_wb_write_bit(wb, cm->error_resilient_mode);
1099
1100   if (cm->frame_type == KEY_FRAME) {
1101     write_sync_code(wb);
1102     write_bitdepth_colorspace_sampling(cm, wb);
1103     write_frame_size(cm, wb);
1104   } else {
1105     // In spatial svc if it's not error_resilient_mode then we need to code all
1106     // visible frames as invisible. But we need to keep the show_frame flag so
1107     // that the publisher could know whether it is supposed to be visible.
1108     // So we will code the show_frame flag as it is. Then code the intra_only
1109     // bit here. This will make the bitstream incompatible. In the player we
1110     // will change to show_frame flag to 0, then add an one byte frame with
1111     // show_existing_frame flag which tells the decoder which frame we want to
1112     // show.
1113     if (!cm->show_frame)
1114       vp9_wb_write_bit(wb, cm->intra_only);
1115
1116     if (!cm->error_resilient_mode)
1117       vp9_wb_write_literal(wb, cm->reset_frame_context, 2);
1118
1119     if (cm->intra_only) {
1120       write_sync_code(wb);
1121
1122       // Note for profile 0, 420 8bpp is assumed.
1123       if (cm->profile > PROFILE_0) {
1124         write_bitdepth_colorspace_sampling(cm, wb);
1125       }
1126
1127       vp9_wb_write_literal(wb, get_refresh_mask(cpi), REF_FRAMES);
1128       write_frame_size(cm, wb);
1129     } else {
1130       MV_REFERENCE_FRAME ref_frame;
1131       vp9_wb_write_literal(wb, get_refresh_mask(cpi), REF_FRAMES);
1132       for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
1133         vp9_wb_write_literal(wb, get_ref_frame_idx(cpi, ref_frame),
1134                              REF_FRAMES_LOG2);
1135         vp9_wb_write_bit(wb, cm->ref_frame_sign_bias[ref_frame]);
1136       }
1137
1138       write_frame_size_with_refs(cpi, wb);
1139
1140       vp9_wb_write_bit(wb, cm->allow_high_precision_mv);
1141
1142       fix_interp_filter(cm);
1143       write_interp_filter(cm->interp_filter, wb);
1144     }
1145   }
1146
1147   if (!cm->error_resilient_mode) {
1148     vp9_wb_write_bit(wb, cm->refresh_frame_context);
1149     vp9_wb_write_bit(wb, cm->frame_parallel_decoding_mode);
1150   }
1151
1152   vp9_wb_write_literal(wb, cm->frame_context_idx, FRAME_CONTEXTS_LOG2);
1153
1154   encode_loopfilter(&cm->lf, wb);
1155   encode_quantization(cm, wb);
1156   encode_segmentation(cm, &cpi->mb.e_mbd, wb);
1157
1158   write_tile_info(cm, wb);
1159 }
1160
1161 static size_t write_compressed_header(VP9_COMP *cpi, uint8_t *data) {
1162   VP9_COMMON *const cm = &cpi->common;
1163   MACROBLOCKD *const xd = &cpi->mb.e_mbd;
1164   FRAME_CONTEXT *const fc = &cm->fc;
1165   vp9_writer header_bc;
1166
1167   vp9_start_encode(&header_bc, data);
1168
1169   if (xd->lossless)
1170     cm->tx_mode = ONLY_4X4;
1171   else
1172     encode_txfm_probs(cm, &header_bc);
1173
1174   update_coef_probs(cpi, &header_bc);
1175   update_skip_probs(cm, &header_bc);
1176
1177   if (!frame_is_intra_only(cm)) {
1178     int i;
1179
1180     for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
1181       prob_diff_update(vp9_inter_mode_tree, cm->fc.inter_mode_probs[i],
1182                        cm->counts.inter_mode[i], INTER_MODES, &header_bc);
1183
1184     vp9_zero(cm->counts.inter_mode);
1185
1186     if (cm->interp_filter == SWITCHABLE)
1187       update_switchable_interp_probs(cm, &header_bc);
1188
1189     for (i = 0; i < INTRA_INTER_CONTEXTS; i++)
1190       vp9_cond_prob_diff_update(&header_bc, &fc->intra_inter_prob[i],
1191                                 cm->counts.intra_inter[i]);
1192
1193     if (cm->allow_comp_inter_inter) {
1194       const int use_compound_pred = cm->reference_mode != SINGLE_REFERENCE;
1195       const int use_hybrid_pred = cm->reference_mode == REFERENCE_MODE_SELECT;
1196
1197       vp9_write_bit(&header_bc, use_compound_pred);
1198       if (use_compound_pred) {
1199         vp9_write_bit(&header_bc, use_hybrid_pred);
1200         if (use_hybrid_pred)
1201           for (i = 0; i < COMP_INTER_CONTEXTS; i++)
1202             vp9_cond_prob_diff_update(&header_bc, &fc->comp_inter_prob[i],
1203                                       cm->counts.comp_inter[i]);
1204       }
1205     }
1206
1207     if (cm->reference_mode != COMPOUND_REFERENCE) {
1208       for (i = 0; i < REF_CONTEXTS; i++) {
1209         vp9_cond_prob_diff_update(&header_bc, &fc->single_ref_prob[i][0],
1210                                   cm->counts.single_ref[i][0]);
1211         vp9_cond_prob_diff_update(&header_bc, &fc->single_ref_prob[i][1],
1212                                   cm->counts.single_ref[i][1]);
1213       }
1214     }
1215
1216     if (cm->reference_mode != SINGLE_REFERENCE)
1217       for (i = 0; i < REF_CONTEXTS; i++)
1218         vp9_cond_prob_diff_update(&header_bc, &fc->comp_ref_prob[i],
1219                                   cm->counts.comp_ref[i]);
1220
1221     for (i = 0; i < BLOCK_SIZE_GROUPS; ++i)
1222       prob_diff_update(vp9_intra_mode_tree, cm->fc.y_mode_prob[i],
1223                        cm->counts.y_mode[i], INTRA_MODES, &header_bc);
1224
1225     for (i = 0; i < PARTITION_CONTEXTS; ++i)
1226       prob_diff_update(vp9_partition_tree, fc->partition_prob[i],
1227                        cm->counts.partition[i], PARTITION_TYPES, &header_bc);
1228
1229     vp9_write_nmv_probs(cm, cm->allow_high_precision_mv, &header_bc);
1230   }
1231
1232   vp9_stop_encode(&header_bc);
1233   assert(header_bc.pos <= 0xffff);
1234
1235   return header_bc.pos;
1236 }
1237
1238 void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, size_t *size) {
1239   uint8_t *data = dest;
1240   size_t first_part_size, uncompressed_hdr_size;
1241   struct vp9_write_bit_buffer wb = {data, 0};
1242   struct vp9_write_bit_buffer saved_wb;
1243
1244   write_uncompressed_header(cpi, &wb);
1245   saved_wb = wb;
1246   vp9_wb_write_literal(&wb, 0, 16);  // don't know in advance first part. size
1247
1248   uncompressed_hdr_size = vp9_wb_bytes_written(&wb);
1249   data += uncompressed_hdr_size;
1250
1251   vp9_clear_system_state();
1252
1253   first_part_size = write_compressed_header(cpi, data);
1254   data += first_part_size;
1255   // TODO(jbb): Figure out what to do if first_part_size > 16 bits.
1256   vp9_wb_write_literal(&saved_wb, (int)first_part_size, 16);
1257
1258   data += encode_tiles(cpi, data);
1259
1260   *size = data - dest;
1261 }