vp9_decodframe.c 36.7 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
#include <assert.h>
John Koleszar's avatar
John Koleszar committed
12

13
#include "vp9/decoder/vp9_onyxd_int.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
14
#include "vp9/common/vp9_common.h"
15
16
17
#include "vp9/common/vp9_header.h"
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
Yaowu Xu's avatar
Yaowu Xu committed
18
#include "vp9/common/vp9_entropy.h"
19
#include "vp9/decoder/vp9_decodframe.h"
20
#include "vp9/decoder/vp9_detokenize.h"
21
22
23
24
#include "vp9/common/vp9_invtrans.h"
#include "vp9/common/vp9_alloccommon.h"
#include "vp9/common/vp9_entropymode.h"
#include "vp9/common/vp9_quant_common.h"
Johann's avatar
Johann committed
25
#include "vpx_scale/vpx_scale.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
26

27
#include "vp9/decoder/vp9_decodemv.h"
28
29
#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
John Koleszar's avatar
John Koleszar committed
30
#include "vpx_mem/vpx_mem.h"
31
#include "vp9/decoder/vp9_dboolhuff.h"
John Koleszar's avatar
John Koleszar committed
32

33
#include "vp9/common/vp9_seg_common.h"
34
#include "vp9/common/vp9_tile_common.h"
35
#include "vp9_rtcd.h"
36

37
// #define DEC_DEBUG
38
39
40
41
#ifdef DEC_DEBUG
int dec_debug = 0;
#endif

42
43
44
45
46
47
48
49
50
static int read_le16(const uint8_t *p) {
  return (p[1] << 8) | p[0];
}

static int read_le32(const uint8_t *p) {
  return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
}

// len == 0 is not allowed
51
52
static int read_is_valid(const uint8_t *start, size_t len,
                         const uint8_t *end) {
53
54
55
  return start + len > start && start + len <= end;
}

56
57
58
59
60
61
62
63
64
65
66
67
68
69
static void setup_txfm_mode(VP9_COMMON *pc, int lossless, vp9_reader *r) {
  if (lossless) {
    pc->txfm_mode = ONLY_4X4;
  } else {
    pc->txfm_mode = vp9_read_literal(r, 2);
    if (pc->txfm_mode == ALLOW_32X32)
      pc->txfm_mode += vp9_read_bit(r);

    if (pc->txfm_mode == TX_MODE_SELECT) {
      pc->prob_tx[0] = vp9_read_prob(r);
      pc->prob_tx[1] = vp9_read_prob(r);
      pc->prob_tx[2] = vp9_read_prob(r);
    }
  }
70
71
}

72
73
74
75
76
77
78
79
80
81
82
83
84
static int get_unsigned_bits(unsigned int num_values) {
  int cat = 0;
  if (num_values <= 1)
    return 0;
  num_values--;
  while (num_values > 0) {
    cat++;
    num_values >>= 1;
  }
  return cat;
}

static int inv_recenter_nonneg(int v, int m) {
85
  if (v > 2 * m)
86
    return v;
87
88

  return v % 2 ? m - (v + 1) / 2 : m + v / 2;
89
90
}

91
static int decode_uniform(vp9_reader *r, int n) {
92
93
94
95
96
97
  int v;
  const int l = get_unsigned_bits(n);
  const int m = (1 << l) - n;
  if (!l)
    return 0;

98
99
  v = vp9_read_literal(r, l - 1);
  return v < m ?  v : (v << 1) - m + vp9_read_bit(r);
100
101
}

102
static int decode_term_subexp(vp9_reader *r, int k, int num_syms) {
103
104
105
106
107
  int i = 0, mk = 0, word;
  while (1) {
    const int b = i ? k + i - 1 : k;
    const int a = 1 << b;
    if (num_syms <= mk + 3 * a) {
108
      word = decode_uniform(r, num_syms - mk) + mk;
109
110
      break;
    } else {
111
      if (vp9_read_bit(r)) {
112
113
114
        i++;
        mk += a;
      } else {
115
        word = vp9_read_literal(r, b) + mk;
116
117
118
119
120
121
122
        break;
      }
    }
  }
  return word;
}

123
static int decode_unsigned_max(vp9_reader *r, int max) {
124
125
126
  int data = 0, bit = 0, lmax = max;

  while (lmax) {
127
    data |= vp9_read_bit(r) << bit++;
128
129
130
131
132
    lmax >>= 1;
  }
  return data > max ? max : data;
}

John Koleszar's avatar
John Koleszar committed
133
134
static int merge_index(int v, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
135
136
137
  if (v < max1) {
    v = v * modulus + modulus / 2;
  } else {
John Koleszar's avatar
John Koleszar committed
138
139
140
141
142
143
144
145
    int w;
    v -= max1;
    w = v;
    v += (v + modulus - modulus / 2) / modulus;
    while (v % modulus == modulus / 2 ||
           w != v - (v + modulus - modulus / 2) / modulus) v++;
  }
  return v;
146
147
}

John Koleszar's avatar
John Koleszar committed
148
149
static int inv_remap_prob(int v, int m) {
  const int n = 256;
150

151
  v = merge_index(v, n - 1, MODULUS_PARAM);
John Koleszar's avatar
John Koleszar committed
152
  if ((m << 1) <= n) {
153
    return inv_recenter_nonneg(v + 1, m);
John Koleszar's avatar
John Koleszar committed
154
  } else {
155
    return n - 1 - inv_recenter_nonneg(v + 1, n - 1 - m);
John Koleszar's avatar
John Koleszar committed
156
  }
157
}
158

159
160
static vp9_prob read_prob_diff_update(vp9_reader *r, int oldp) {
  int delp = decode_term_subexp(r, SUBEXP_PARAM, 255);
161
  return (vp9_prob)inv_remap_prob(delp, oldp);
162
}
163

164
void vp9_init_dequantizer(VP9_COMMON *pc) {
165
  int q;
John Koleszar's avatar
John Koleszar committed
166

Dmitry Kovalev's avatar
Dmitry Kovalev committed
167
  for (q = 0; q < QINDEX_RANGE; q++) {
168
    // DC value
169
170
    pc->y_dequant[q][0] = vp9_dc_quant(q, pc->y_dc_delta_q);
    pc->uv_dequant[q][0] = vp9_dc_quant(q, pc->uv_dc_delta_q);
John Koleszar's avatar
John Koleszar committed
171

172
    // AC values
173
174
    pc->y_dequant[q][1] = vp9_ac_quant(q, 0);
    pc->uv_dequant[q][1] = vp9_ac_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
175
  }
John Koleszar's avatar
John Koleszar committed
176
177
}

178
static void mb_init_dequantizer(VP9_COMMON *pc, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
179
  int i;
180
  const int segment_id = xd->mode_info_context->mbmi.segment_id;
181
  xd->q_index = vp9_get_qindex(xd, segment_id, pc->base_qindex);
John Koleszar's avatar
John Koleszar committed
182

183
  xd->plane[0].dequant = pc->y_dequant[xd->q_index];
184
  for (i = 1; i < MAX_MB_PLANE; i++)
185
    xd->plane[i].dequant = pc->uv_dequant[xd->q_index];
John Koleszar's avatar
John Koleszar committed
186
187
}

188
189
static INLINE void dequant_add_y(MACROBLOCKD *xd, TX_TYPE tx_type, int idx,
                                 BLOCK_SIZE_TYPE bsize) {
190
  struct macroblockd_plane *const y = &xd->plane[0];
191
  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, 0, idx,
192
193
                                                 xd->plane[0].dst.buf,
                                                 xd->plane[0].dst.stride);
194
  if (tx_type != DCT_DCT) {
195
    vp9_iht_add_c(tx_type, BLOCK_OFFSET(y->qcoeff, idx, 16),
196
                  dst, xd->plane[0].dst.stride, y->eobs[idx]);
197
  } else {
198
199
    xd->itxm_add(BLOCK_OFFSET(y->qcoeff, idx, 16),
                 dst, xd->plane[0].dst.stride, y->eobs[idx]);
200
201
202
  }
}

203
204
205
206
207
208
209
210
211
212
213
static void decode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
                         int ss_txfrm_size, void *arg) {
  MACROBLOCKD* const xd = arg;
  int16_t* const qcoeff = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16);
  const int stride = xd->plane[plane].dst.stride;
  const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
                                                       block, ss_txfrm_size);
  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
                                                 raster_block,
                                                 xd->plane[plane].dst.buf,
                                                 stride);
214

215
  TX_TYPE tx_type;
216

217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
  switch (ss_txfrm_size / 2) {
    case TX_4X4:
      tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
      if (tx_type == DCT_DCT)
        xd->itxm_add(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      else
        vp9_iht_add_c(tx_type, qcoeff, dst, stride,
                      xd->plane[plane].eobs[block]);
      break;
    case TX_8X8:
      tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride,
                        xd->plane[plane].eobs[block]);
      break;
    case TX_16X16:
      tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride,
                          xd->plane[plane].eobs[block]);
      break;
    case TX_32X32:
      vp9_idct_add_32x32(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      break;
239
240
241
  }
}

242
243
244
245
246
247
248
249
250
251
static void decode_atom_intra(VP9D_COMP *pbi, MACROBLOCKD *xd,
                              vp9_reader *r,
                              BLOCK_SIZE_TYPE bsize) {
  int i = 0;
  int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
  int bc = 1 << (bwl + bhl);
  int tx_type;

  for (i = 0; i < bc; i++) {
    int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
252
253
254
255

    uint8_t* dst = raster_block_offset_uint8(xd, bsize, 0, i,
                                             xd->plane[0].dst.buf,
                                             xd->plane[0].dst.stride);
256

257
    vp9_intra4x4_predict(xd, i, bsize, b_mode, dst, xd->plane[0].dst.stride);
258
259
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
260
    dequant_add_y(xd, tx_type, i, bsize);
261
  }
262

263
264
265
  foreach_transformed_block_uv(xd, bsize, decode_block, xd);
}

266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
static void decode_atom(VP9D_COMP *pbi, MACROBLOCKD *xd,
                        int mi_row, int mi_col,
                        vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;

  if (pbi->common.frame_type != KEY_FRAME)
    vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);

  // prediction
  if (mbmi->ref_frame == INTRA_FRAME)
    vp9_build_intra_predictors_sbuv_s(xd, bsize);
  else
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);

  if (mbmi->mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
  } else {
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(&pbi->common, xd);

    if (!vp9_reader_has_error(r)) {
      vp9_decode_tokens(pbi, xd, r, bsize);
    }
  }

  if (mbmi->ref_frame == INTRA_FRAME)
    decode_atom_intra(pbi, xd, r, bsize);
  else
    foreach_transformed_block(xd, bsize, decode_block, xd);
}

298
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
299
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
300
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
301
  const int bw = 1 << bwl, bh = 1 << bhl;
302
  int n, eobtotal;
303
  VP9_COMMON *const pc = &pbi->common;
304
305
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
306
  const int mis = pc->mode_info_stride;
307

308
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
309
310

  if (pbi->common.frame_type != KEY_FRAME)
311
    vp9_setup_interp_filters(xd, mbmi->interp_filter, pc);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
312

313
  // generate prediction
314
  if (mbmi->ref_frame == INTRA_FRAME) {
315
316
    vp9_build_intra_predictors_sby_s(xd, bsize);
    vp9_build_intra_predictors_sbuv_s(xd, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
317
  } else {
318
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
319
320
  }

321
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
322
    vp9_reset_sb_tokens_context(xd, bsize);
323
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
324
325
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
326
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
327
328

    // dequantization and idct
329
    eobtotal = vp9_decode_tokens(pbi, xd, r, bsize);
Yunqing Wang's avatar
Yunqing Wang committed
330
331
332
333
    if (eobtotal == 0) {  // skip loopfilter
      for (n = 0; n < bw * bh; n++) {
        const int x_idx = n & (bw - 1), y_idx = n >> bwl;

334
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
335
336
337
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
338
      foreach_transformed_block(xd, bsize, decode_block, xd);
339
    }
340
  }
341
342
}

343
344
345
346
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
347
348
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
349
  }
John Koleszar's avatar
John Koleszar committed
350

351
  // Trigger a quantizer update if the delta-q value has changed
352
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
353
354
}

355
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
356
357
358
                        int mi_row, int mi_col) {
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
359
360
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
361
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
362
  int i;
363

364
  xd->mode_info_context = cm->mi + mi_idx;
365
  xd->mode_info_context->mbmi.sb_type = bsize;
366
367
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

368
369
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
370
        (mi_col * 2 >> xd->plane[i].subsampling_x);
371
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
372
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
373
  }
374
375
  xd->above_seg_context = cm->above_seg_context + mi_col;
  xd->left_seg_context  = cm->left_seg_context + (mi_row & MI_MASK);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
376

377
378
  // Distance of Mb to the various image edges. These are specified to 8th pel
  // as they are always compared to values that are in 1/8th pel units
379
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
380

381
  setup_dst_planes(xd, &cm->yv12_fb[cm->new_fb_idx], mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
382
}
John Koleszar's avatar
John Koleszar committed
383

384
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
385
386
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
387
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
388
389

  if (mbmi->ref_frame > INTRA_FRAME) {
390
    // Select the appropriate reference frame for this MB
391
392
393
    const int fb_idx = cm->active_ref_idx[mbmi->ref_frame - 1];
    const YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[fb_idx];
    xd->scale_factor[0]    = cm->active_ref_scale[mbmi->ref_frame - 1];
394
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
395
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
396
                     xd->scale_factor, xd->scale_factor_uv);
397
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
398

Ronald S. Bultje's avatar
Ronald S. Bultje committed
399
    if (mbmi->second_ref_frame > INTRA_FRAME) {
400
      // Select the appropriate reference frame for this MB
401
402
      const int second_fb_idx = cm->active_ref_idx[mbmi->second_ref_frame - 1];
      const YV12_BUFFER_CONFIG *second_cfg = &cm->yv12_fb[second_fb_idx];
Yunqing Wang's avatar
Yunqing Wang committed
403
404
      xd->scale_factor[1]    = cm->active_ref_scale[mbmi->second_ref_frame - 1];
      xd->scale_factor_uv[1] = cm->active_ref_scale[mbmi->second_ref_frame - 1];
405
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
406
                       xd->scale_factor, xd->scale_factor_uv);
407
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
408
409
410
    }
  }
}
John Koleszar's avatar
John Koleszar committed
411

412
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
413
414
415
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

416
417
418
419
420
#if CONFIG_AB4X4
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
#endif
421
422
423
  set_offsets(pbi, bsize, mi_row, mi_col);
  vp9_decode_mb_mode_mv(pbi, xd, mi_row, mi_col, r);
  set_refs(pbi, mi_row, mi_col);
424

425
426
427
#if CONFIG_AB4X4
  if (bsize < BLOCK_SIZE_SB8X8)
#else
428
429
430
  if (bsize == BLOCK_SIZE_SB8X8 &&
      (xd->mode_info_context->mbmi.mode == SPLITMV ||
       xd->mode_info_context->mbmi.mode == I4X4_PRED))
431
432
#endif
    decode_atom(pbi, xd, mi_row, mi_col, r, BLOCK_SIZE_SB8X8);
433
  else
434
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
435

436
  xd->corrupted |= vp9_reader_has_error(r);
437
438
}

439
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
440
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
441
442
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
443
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
444
445
446
447
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

448
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
449
450
    return;

451
452
453
454
455
456
457
458
459
#if CONFIG_AB4X4
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;
#endif

#if CONFIG_AB4X4
  if (bsize >= BLOCK_SIZE_SB8X8) {
#else
460
  if (bsize > BLOCK_SIZE_SB8X8) {
461
#endif
462
    int pl;
463
    // read the partition information
464
465
    xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = pc->above_seg_context + mi_col;
466
    pl = partition_plane_context(xd, bsize);
467
    partition = treed_read(r, vp9_partition_tree,
468
469
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
470
471
  }

472
  subsize = get_subsize(bsize, partition);
473
  *(get_sb_index(xd, subsize)) = 0;
474

475
476
  switch (partition) {
    case PARTITION_NONE:
477
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
478
479
      break;
    case PARTITION_HORZ:
480
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
481
      *(get_sb_index(xd, subsize)) = 1;
482
      if (mi_row + bs < pc->mi_rows)
483
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
484
485
      break;
    case PARTITION_VERT:
486
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
487
      *(get_sb_index(xd, subsize)) = 1;
488
      if (mi_col + bs < pc->mi_cols)
489
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
490
491
492
493
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
494
        *(get_sb_index(xd, subsize)) = n;
495
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
496
497
498
499
500
      }
      break;
    default:
      assert(0);
  }
501
  // update partition context
502
503
504
505
#if CONFIG_AB4X4
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
#else
506
507
  if (bsize > BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_MB16X16 || partition != PARTITION_SPLIT)) {
508
#endif
509
510
511
    set_partition_seg_context(pc, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
512
513
}

514
static void setup_token_decoder(VP9D_COMP *pbi,
515
516
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
517
  VP9_COMMON *pc = &pbi->common;
518
519
  const uint8_t *data_end = pbi->source + pbi->source_sz;
  const size_t partition_size = data_end - data;
John Koleszar's avatar
John Koleszar committed
520

Dmitry Kovalev's avatar
Dmitry Kovalev committed
521
522
523
  // Validate the calculated partition length. If the buffer
  // described by the partition can't be fully read, then restrict
  // it to the portion that can be (for EC mode) or throw an error.
524
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
525
526
527
528
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

529
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
530
531
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
532
533
}

534
535
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
536
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
537

John Koleszar's avatar
John Koleszar committed
538
  if (pc->frame_type == KEY_FRAME) {
539
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
540
    // All buffers are implicitly updated on key frames.
541
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
542
543
544
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
545

John Koleszar's avatar
John Koleszar committed
546
  xd->mode_info_context = pc->mi;
547
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
548
549
550
  xd->frame_type = pc->frame_type;
  xd->mode_info_context->mbmi.mode = DC_PRED;
  xd->mode_info_stride = pc->mode_info_stride;
John Koleszar's avatar
John Koleszar committed
551
552
}

553
554
555
556
557
558
559
560
561
562
static void read_coef_probs_common(
#if CONFIG_MODELCOEFPROB
    vp9_coeff_probs_model *coef_probs,
#else
    vp9_coeff_probs *coef_probs,
#endif
    TX_SIZE tx_size,
    vp9_reader *r) {
#if CONFIG_MODELCOEFPROB
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
563
564
565
566
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

567
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
568

569
  if (vp9_read_bit(r)) {
570
    for (i = 0; i < BLOCK_TYPES; i++) {
571
572
573
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
574
            const int mstart = 0;
575
576
            if (l >= 3 && k == 0)
              continue;
577
578

            for (m = mstart; m < entropy_nodes_update; m++) {
579
580
              vp9_prob *const p = coef_probs[i][j][k][l] + m;

581
582
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
583
              }
584
585
586
            }
          }
        }
587
588
      }
    }
589
  }
590
}
591

592
593
594
static void read_coef_probs(VP9D_COMP *pbi, vp9_reader *r) {
  const TXFM_MODE mode = pbi->common.txfm_mode;
  FRAME_CONTEXT *const fc = &pbi->common.fc;
Daniel Kang's avatar
Daniel Kang committed
595

596
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
597

598
  if (mode > ONLY_4X4)
599
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
600

601
  if (mode > ALLOW_8X8)
602
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
603

604
  if (mode > ALLOW_16X16)
605
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
606
607
}

608
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
609
610
  int i, j;

611
612
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
613
614
615
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
616

617
  xd->segmentation_enabled = vp9_read_bit(r);
618
619
620
621
622
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
623
624
625
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
626
  if (xd->update_mb_segmentation_map) {
627
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
628
629
630
631
632
633
634
635
636
637
638
      xd->mb_segment_tree_probs[i] = vp9_read_bit(r) ? vp9_read_prob(r)
                                                     : MAX_PROB;

    pc->temporal_update = vp9_read_bit(r);
    if (pc->temporal_update) {
      for (i = 0; i < PREDICTION_PROBS; i++)
        pc->segment_pred_probs[i] = vp9_read_bit(r) ? vp9_read_prob(r)
                                                    : MAX_PROB;
    } else {
      for (i = 0; i < PREDICTION_PROBS; i++)
        pc->segment_pred_probs[i] = MAX_PROB;
639
    }
640
  }
641

642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
  // Segmentation data update
  xd->update_mb_segmentation_data = vp9_read_bit(r);
  if (xd->update_mb_segmentation_data) {
    xd->mb_segment_abs_delta = vp9_read_bit(r);

    vp9_clearall_segfeatures(xd);

    for (i = 0; i < MAX_MB_SEGMENTS; i++) {
      for (j = 0; j < SEG_LVL_MAX; j++) {
        int data = 0;
        const int feature_enabled = vp9_read_bit(r);
        if (feature_enabled) {
          vp9_enable_segfeature(xd, i, j);
          data = decode_unsigned_max(r, vp9_seg_feature_data_max(j));
          if (vp9_is_segfeature_signed(j))
            data = vp9_read_and_apply_sign(r, data);
658
        }
659
        vp9_set_segdata(xd, i, j, data);
660
661
662
663
664
      }
    }
  }
}

665
666
667
668
669
static void setup_pred_probs(VP9_COMMON *pc, vp9_reader *r) {
  // Read common prediction model status flag probability updates for the
  // reference frame
  if (pc->frame_type == KEY_FRAME) {
    // Set the prediction probabilities to defaults
670
671
672
    pc->ref_pred_probs[0] = DEFAULT_PRED_PROB_0;
    pc->ref_pred_probs[1] = DEFAULT_PRED_PROB_1;
    pc->ref_pred_probs[2] = DEFAULT_PRED_PROB_2;
673
674
675
676
677
678
679
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
680

681
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
682
683
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
684
685

#if CONFIG_LOOP_DERING
686
687
  if (vp9_read_bit(r))
    pc->dering_enabled = 1 + vp9_read_literal(r, 4);
688
689
690
691
692
693
694
695
  else
    pc->dering_enabled = 0;
#endif

  // Read in loop filter deltas applied at the MB level based on mode or ref
  // frame.
  xd->mode_ref_lf_delta_update = 0;

696
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
697
  if (xd->mode_ref_lf_delta_enabled) {
698
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
699
    if (xd->mode_ref_lf_delta_update) {
700
701
      int i;

702
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
703
        if (vp9_read_bit(r)) {
704
705
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
706
707
708
709
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
710
        if (vp9_read_bit(r)) {
711
712
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
713
714
715
716
717
718
        }
      }
    }
  }
}

719
720
721
722
723
static void setup_quantization(VP9D_COMP *pbi, vp9_reader *r) {
  // Read the default quantizers
  VP9_COMMON *const pc = &pbi->common;

  pc->base_qindex = vp9_read_literal(r, QINDEX_BITS);
724
725
726
  if (get_delta_q(r, &pc->y_dc_delta_q) |
      get_delta_q(r, &pc->uv_dc_delta_q) |
      get_delta_q(r, &pc->uv_ac_delta_q))
727
    vp9_init_dequantizer(pc);
728

729
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
730
731
}

732
733
734
735
736
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

737
738
739
740
static const uint8_t *read_frame_size(VP9_COMMON *const pc, const uint8_t *data,
                                      const uint8_t *data_end,
                                      int *width, int *height) {
  if (data + 4 < data_end) {
741
742
743
744
745
746
747
748
749
750
751
    const int w = read_le16(data);
    const int h = read_le16(data + 2);
    if (w <= 0)
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Invalid frame width");

    if (h <= 0)
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Invalid frame height");
    *width = w;
    *height = h;
752
753
754
755
756
757
758
759
    data += 4;
  } else {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Failed to read frame size");
  }
  return data;
}

760
static const uint8_t *setup_frame_size(VP9D_COMP *pbi, int scaling_active,
761
762
                                       const uint8_t *data,
                                       const uint8_t *data_end) {
763
764
  // If error concealment is enabled we should only parse the new size
  // if we have enough data. Otherwise we will end up with the wrong size.
765
766
767
768
769
  VP9_COMMON *const pc = &pbi->common;
  int display_width = pc->display_width;
  int display_height = pc->display_height;
  int width = pc->width;
  int height = pc->height;
770

771
772
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
773

774
  data = read_frame_size(pc, data, data_end, &width, &height);
775

776
  if (pc->width != width || pc->height != height) {
777
    if (!pbi->initial_width || !pbi->initial_height) {
778
      if (vp9_alloc_frame_buffers(pc, width, height))
779
780
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
781
782
783
784
785
786
        pbi->initial_width = width;
        pbi->initial_height = height;
    } else {
      if (width > pbi->initial_width)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame width too large");
787

788
789
790
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
791
792
    }

793
794
795
796
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
797

798
    vp9_update_frame_size(pc);
799
800
801
802
803
  }

  return data;
}

804
static void update_frame_context(FRAME_CONTEXT *fc) {
805
806
807
808
809
810
811
812
813
  vp9_copy(fc->pre_coef_probs_4x4, fc->coef_probs_4x4);
  vp9_copy(fc->pre_coef_probs_8x8, fc->coef_probs_8x8);
  vp9_copy(fc->pre_coef_probs_16x16, fc->coef_probs_16x16);
  vp9_copy(fc->pre_coef_probs_32x32, fc->coef_probs_32x32);
  vp9_copy(fc->pre_ymode_prob, fc->ymode_prob);
  vp9_copy(fc->pre_sb_ymode_prob, fc->sb_ymode_prob);
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
  vp9_copy(fc->pre_bmode_prob, fc->bmode_prob);
  vp9_copy(fc->pre_sub_mv_ref_prob, fc->sub_mv_ref_prob);
814
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
815
816
817
818
819
820
821
822
823
824
825
826
827
828
  fc->pre_nmvc = fc->nmvc;

  vp9_zero(fc->coef_counts_4x4);
  vp9_zero(fc->coef_counts_8x8);
  vp9_zero(fc->coef_counts_16x16);
  vp9_zero(fc->coef_counts_32x32);
  vp9_zero(fc->eob_branch_counts);
  vp9_zero(fc->ymode_counts);
  vp9_zero(fc->sb_ymode_counts);
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->bmode_counts);
  vp9_zero(fc->sub_mv_ref_counts);
  vp9_zero(fc->NMVcount);
  vp9_zero(fc->mv_ref_ct);
829
  vp9_zero(fc->partition_counts);
830
}
831

832
833
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
834
  int mi_row, mi_col;
835

836
  for (mi_row = pc->cur_tile_mi_row_start;
837
       mi_row < pc->cur_tile_mi_row_end; mi_row += 64 / MI_SIZE) {
838
    // For a SB there are 2 left contexts, each pertaining to a MB row within
839
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
840
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
841
    for (mi_col = pc->cur_tile_mi_col_start;
842
         mi_col < pc->cur_tile_mi_col_end; mi_col += 64 / MI_SIZE)
843
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
844
845
846
  }
}

847
848
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
849
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
  VP9_COMMON *const pc = &pbi->common;

  const uint8_t *data_ptr = data + first_partition_size;
  int tile_row, tile_col, delta_log2_tiles;

  vp9_get_tile_n_bits(pc, &pc->log2_tile_columns, &delta_log2_tiles);
  while (delta_log2_tiles--) {
    if (vp9_read_bit(header_bc)) {
      pc->log2_tile_columns++;
    } else {
      break;
    }
  }
  pc->log2_tile_rows = vp9_read_bit(header_bc);
  if (pc->log2_tile_rows)
    pc->log2_tile_rows += vp9_read_bit(header_bc);
  pc->tile_columns = 1 << pc->log2_tile_columns;
  pc->tile_rows    = 1 << pc->log2_tile_rows;

869
870
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
871
872
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
                                      MAX_MB_PLANE * mi_cols_aligned_to_sb(pc));
873
874

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
875
                                       mi_cols_aligned_to_sb(pc));
876
877
878
879

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
880
    vp9_reader bc_bak = {0};
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903

    // pre-initialize the offsets, we're going to read in inverse order
    data_ptr2[0][0] = data_ptr;
    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      if (tile_row) {
        const int size = read_le32(data_ptr2[tile_row - 1][n_cols - 1]);
        data_ptr2[tile_row - 1][n_cols - 1] += 4;
        data_ptr2[tile_row][0] = data_ptr2[tile_row - 1][n_cols - 1] + size;
      }

      for (tile_col = 1; tile_col < n_cols; tile_col++) {
        const int size = read_le32(data_ptr2[tile_row][tile_col - 1]);
        data_ptr2[tile_row][tile_col - 1] += 4;
        data_ptr2[tile_row][tile_col] =
            data_ptr2[tile_row][tile_col - 1] + size;
      }
    }

    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      vp9_get_tile_row_offsets(pc, tile_row);
      for (tile_col = n_cols - 1; tile_col >= 0; tile_col--) {
        vp9_get_tile_col_offsets(pc, tile_col);
        setup_token_decoder(pbi, data_ptr2[tile_row][tile_col], residual_bc);
904
        decode_tile(pbi, residual_bc);
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
        if (tile_row == pc->tile_rows - 1 && tile_col == n_cols - 1)
          bc_bak = *residual_bc;
      }
    }
    *residual_bc = bc_bak;
  } else {
    int has_more;

    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      vp9_get_tile_row_offsets(pc, tile_row);
      for (tile_col = 0; tile_col < pc->tile_columns; tile_col++) {
        vp9_get_tile_col_offsets(pc, tile_col);

        has_more = tile_col < pc->tile_columns - 1 ||
                   tile_row < pc->tile_rows - 1;

        setup_token_decoder(pbi, data_ptr + (has_more ? 4 : 0), residual_bc);
922
        decode_tile(pbi, residual_bc);
923
924
925
926
927
928
929
930
931
932

        if (has_more) {
          const int size = read_le32(data_ptr);
          data_ptr += 4 + size;
        }
      }
    }
  }
}

933
int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) {
934
  vp9_reader header_bc, residual_bc;
935
  VP9_COMMON *const pc = &pbi->common;