vp9_decodframe.c 37.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
#include "vp9/common/vp9_header.h"
16
17
#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
20
#include "vp9/decoder/vp9_decodframe.h"
#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"
25
#include "vpx_scale/vpx_scale.h"
26
27

#include "vp9/decoder/vp9_decodemv.h"
28
29
30
#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
#include "vpx_mem/vpx_mem.h"
31
32
#include "vp9/decoder/vp9_dboolhuff.h"

33
34
35
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_tile_common.h"
#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
252
253
254
255
256
257
258
259
260
261
262
263
264
265
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
static void decode_block_intra(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);
  const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
  TX_TYPE tx_type;
  int mode, b_mode;
  int plane_b_size;
  int tx_ib = raster_block >> tx_size;
  mode = plane == 0? xd->mode_info_context->mbmi.mode:
                     xd->mode_info_context->mbmi.uv_mode;

  if (bsize <= BLOCK_SIZE_SB8X8 && mode == I4X4_PRED && plane == 0)
    b_mode = xd->mode_info_context->bmi[raster_block].as_mode.first;
  else
    b_mode = mode;

  plane_b_size = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
  vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size,
                          b_mode, dst, xd->plane[plane].dst.stride);

  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;
  }
}

295
296
297
298
299
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;

Yaowu Xu's avatar
Yaowu Xu committed
300
301
  assert(mbmi->ref_frame != INTRA_FRAME);

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

  // prediction
Yaowu Xu's avatar
Yaowu Xu committed
306
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
307
308
309
310
311
312
313
314
315
316
317
318

  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);
    }
  }
Yaowu Xu's avatar
Yaowu Xu committed
319
  foreach_transformed_block(xd, bsize, decode_block, xd);
320
321
}

322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
static void decode_sb_intra(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 (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);
    }
  }

  foreach_transformed_block(xd, bsize, decode_block_intra, xd);
}


342
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
343
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
344
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
345
  const int bw = 1 << bwl, bh = 1 << bhl;
346
  int n, eobtotal;
347
  VP9_COMMON *const pc = &pbi->common;
348
349
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
350
  const int mis = pc->mode_info_stride;
351

352
  assert(mbmi->sb_type == bsize);
Yaowu Xu's avatar
Yaowu Xu committed
353
  assert(mbmi->ref_frame != INTRA_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
354
355

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

358
  // generate prediction
Yaowu Xu's avatar
Yaowu Xu committed
359
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
360

361
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
362
    vp9_reset_sb_tokens_context(xd, bsize);
363
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
364
365
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
366
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
367
368

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

374
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
375
376
377
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
378
      foreach_transformed_block(xd, bsize, decode_block, xd);
379
    }
380
  }
381
382
}

383
384
385
386
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
387
388
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
389
  }
John Koleszar's avatar
John Koleszar committed
390

391
  // Trigger a quantizer update if the delta-q value has changed
392
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
393
394
}

395
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
396
397
398
                        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
399
400
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
401
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
402
  int i;
403

404
  xd->mode_info_context = cm->mi + mi_idx;
405
  xd->mode_info_context->mbmi.sb_type = bsize;
406
407
408
409
  // Special case: if prev_mi is NULL, the previous mode info context
  // cannot be used.
  xd->prev_mode_info_context = cm->prev_mi ?
                                 cm->prev_mi + mi_idx : NULL;
410

411
412
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
413
        (mi_col * 2 >> xd->plane[i].subsampling_x);
414
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
415
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
416
  }
417
418
  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
419

420
421
  // 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
422
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
423

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

427
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
428
429
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
430
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
431
432

  if (mbmi->ref_frame > INTRA_FRAME) {
433
    // Select the appropriate reference frame for this MB
434
435
436
    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];
437
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
438
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
439
                     xd->scale_factor, xd->scale_factor_uv);
440
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
441

Ronald S. Bultje's avatar
Ronald S. Bultje committed
442
    if (mbmi->second_ref_frame > INTRA_FRAME) {
443
      // Select the appropriate reference frame for this MB
444
445
      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
446
447
      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];
448
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
449
                       xd->scale_factor, xd->scale_factor_uv);
450
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
451
452
453
    }
  }
}
John Koleszar's avatar
John Koleszar committed
454

455
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
456
457
458
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

459
460
461
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
462
463
464
  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);
465

466
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
467
468
    decode_sb_intra(pbi, xd, mi_row, mi_col, r, (bsize < BLOCK_SIZE_SB8X8) ?
                                     BLOCK_SIZE_SB8X8 : bsize);
469
  else if (bsize < BLOCK_SIZE_SB8X8)
470
    decode_atom(pbi, xd, mi_row, mi_col, r, BLOCK_SIZE_SB8X8);
471
  else
472
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
473

474
  xd->corrupted |= vp9_reader_has_error(r);
475
476
}

477
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
478
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
479
480
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
481
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
482
483
484
485
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

486
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
487
488
    return;

489
490
491
492
493
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
494
    int pl;
495
    // read the partition information
496
497
    xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = pc->above_seg_context + mi_col;
498
    pl = partition_plane_context(xd, bsize);
499
    partition = treed_read(r, vp9_partition_tree,
500
501
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
502
503
  }

504
  subsize = get_subsize(bsize, partition);
505
  *(get_sb_index(xd, subsize)) = 0;
506

507
508
  switch (partition) {
    case PARTITION_NONE:
509
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
510
511
      break;
    case PARTITION_HORZ:
512
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
513
      *(get_sb_index(xd, subsize)) = 1;
514
      if (mi_row + bs < pc->mi_rows)
515
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
516
517
      break;
    case PARTITION_VERT:
518
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
519
      *(get_sb_index(xd, subsize)) = 1;
520
      if (mi_col + bs < pc->mi_cols)
521
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
522
523
524
525
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
526
        *(get_sb_index(xd, subsize)) = n;
527
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
528
529
530
531
532
      }
      break;
    default:
      assert(0);
  }
533
  // update partition context
534
535
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
536
537
538
    set_partition_seg_context(pc, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
539
540
}

541
static void setup_token_decoder(VP9D_COMP *pbi,
542
543
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
544
  VP9_COMMON *pc = &pbi->common;
545
546
  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
547

Dmitry Kovalev's avatar
Dmitry Kovalev committed
548
549
550
  // 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.
551
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
552
553
554
555
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

556
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
557
558
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
559
560
}

561
562
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
563
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
564

John Koleszar's avatar
John Koleszar committed
565
  if (pc->frame_type == KEY_FRAME) {
566
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
567
    // All buffers are implicitly updated on key frames.
568
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
569
570
571
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
572

John Koleszar's avatar
John Koleszar committed
573
  xd->mode_info_context = pc->mi;
574
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
575
576
577
  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
578
579
}

580
581
582
583
584
static void read_coef_probs_common(
    vp9_coeff_probs_model *coef_probs,
    TX_SIZE tx_size,
    vp9_reader *r) {
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
585

586
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
587

588
  if (vp9_read_bit(r)) {
589
    for (i = 0; i < BLOCK_TYPES; i++) {
590
591
592
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
593
            const int mstart = 0;
594
595
            if (l >= 3 && k == 0)
              continue;
596
597

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

600
601
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
602
              }
603
604
605
            }
          }
        }
606
607
      }
    }
608
  }
609
}
610

611
612
613
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
614

615
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
616

617
  if (mode > ONLY_4X4)
618
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
619

620
  if (mode > ALLOW_8X8)
621
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
622

623
  if (mode > ALLOW_16X16)
624
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
625
626
}

627
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
628
629
  int i, j;

630
631
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
632
633
634
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
635

636
  xd->segmentation_enabled = vp9_read_bit(r);
637
638
639
640
641
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
642
643
644
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
645
  if (xd->update_mb_segmentation_map) {
646
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
647
648
649
650
651
652
653
654
655
656
657
      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;
658
    }
659
  }
660

661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
  // 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);
677
        }
678
        vp9_set_segdata(xd, i, j, data);
679
680
681
682
683
      }
    }
  }
}

684
685
686
687
688
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
689
690
691
    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;
692
693
694
695
696
697
698
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
699

700
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
701
702
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
703
704
705
706
707

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

708
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
709
  if (xd->mode_ref_lf_delta_enabled) {
710
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
711
    if (xd->mode_ref_lf_delta_update) {
712
713
      int i;

714
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
715
        if (vp9_read_bit(r)) {
716
717
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
718
719
720
721
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
722
        if (vp9_read_bit(r)) {
723
724
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
725
726
727
728
729
730
        }
      }
    }
  }
}

731
732
733
734
735
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);
736
737
738
  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))
739
    vp9_init_dequantizer(pc);
740

741
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
742
743
}

744
745
746
747
748
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

749
750
751
752
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) {
753
754
755
756
757
758
759
760
761
762
763
    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;
764
765
766
767
768
769
770
771
    data += 4;
  } else {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Failed to read frame size");
  }
  return data;
}

772
static const uint8_t *setup_frame_size(VP9D_COMP *pbi, int scaling_active,
773
774
                                       const uint8_t *data,
                                       const uint8_t *data_end) {
775
776
  // 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.
777
778
779
780
781
  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;
782

783
784
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
785

786
  data = read_frame_size(pc, data, data_end, &width, &height);
787

788
  if (pc->width != width || pc->height != height) {
789
    if (!pbi->initial_width || !pbi->initial_height) {
790
      if (vp9_alloc_frame_buffers(pc, width, height))
791
792
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
793
794
795
796
797
798
        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");
799

800
801
802
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
803
804
    }

805
806
807
808
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
809

810
    vp9_update_frame_size(pc);
811
812
813
814
815
  }

  return data;
}

816
static void update_frame_context(FRAME_CONTEXT *fc) {
817
818
819
820
821
822
823
824
  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);
825
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
826
827
828
829
830
831
832
833
834
835
836
837
838
  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->NMVcount);
  vp9_zero(fc->mv_ref_ct);
839
  vp9_zero(fc->partition_counts);
840
}
841

842
843
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
844
  int mi_row, mi_col;
845

846
  for (mi_row = pc->cur_tile_mi_row_start;
847
       mi_row < pc->cur_tile_mi_row_end; mi_row += 64 / MI_SIZE) {
848
    // For a SB there are 2 left contexts, each pertaining to a MB row within
849
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
850
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
851
    for (mi_col = pc->cur_tile_mi_col_start;
852
         mi_col < pc->cur_tile_mi_col_end; mi_col += 64 / MI_SIZE)
853
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
854
855
856
  }
}

857
858
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
859
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
  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;

879
880
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
881
882
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
                                      MAX_MB_PLANE * mi_cols_aligned_to_sb(pc));
883
884

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
885
                                       mi_cols_aligned_to_sb(pc));
886
887
888
889

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
890
    vp9_reader bc_bak = {0};
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913

    // 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);
914
        decode_tile(pbi, residual_bc);
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
        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);
932
        decode_tile(pbi, residual_bc);
933
934
935
936
937
938
939
940
941
942

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

943
int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) {
944
  vp9_reader header_bc, residual_bc;
945
  VP9_COMMON *const pc = &pbi->common;
946
  MACROBLOCKD *const xd  = &pbi->mb;
947
  const uint8_t *data = pbi->source;
948
  const uint8_t *data_end = data + pbi->source_sz;
949
  size_t first_partition_size = 0;