vp9_decodframe.c 37.1 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
14
15
16
17
18
#include "./vp9_rtcd.h"
#include "vpx_mem/vpx_mem.h"
#include "vpx_scale/vpx_scale.h"

#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
19
#include "vp9/common/vp9_common.h"
20
21
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
Yaowu Xu's avatar
Yaowu Xu committed
22
#include "vp9/common/vp9_entropy.h"
23
24
25
26
#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"
27
28
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_tile_common.h"
29
30

#include "vp9/decoder/vp9_dboolhuff.h"
31
32
33
34
35
#include "vp9/decoder/vp9_decodframe.h"
#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
#include "vp9/decoder/vp9_onyxd_int.h"
#include "vp9/decoder/vp9_read_bit_buffer.h"
36

37

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

43
44
45
46
47
48
49
50
51
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
52
53
static int read_is_valid(const uint8_t *start, size_t len,
                         const uint8_t *end) {
54
55
56
  return start + len > start && start + len <= end;
}

57
58
59
60
61
62
63
64
65
66
67
68
69
70
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);
    }
  }
71
72
}

73
74
75
76
77
78
79
80
81
82
83
84
85
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) {
86
  if (v > 2 * m)
87
    return v;
88
89

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

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

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

103
static int decode_term_subexp(vp9_reader *r, int k, int num_syms) {
104
105
106
107
108
  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) {
109
      word = decode_uniform(r, num_syms - mk) + mk;
110
111
      break;
    } else {
112
      if (vp9_read_bit(r)) {
113
114
115
        i++;
        mk += a;
      } else {
116
        word = vp9_read_literal(r, b) + mk;
117
118
119
120
121
122
123
        break;
      }
    }
  }
  return word;
}

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

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

John Koleszar's avatar
John Koleszar committed
134
135
static int merge_index(int v, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
136
137
138
  if (v < max1) {
    v = v * modulus + modulus / 2;
  } else {
John Koleszar's avatar
John Koleszar committed
139
140
141
142
143
144
145
146
    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;
147
148
}

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

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

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
168
  for (q = 0; q < QINDEX_RANGE; q++) {
169
    // DC value
170
171
    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
172

173
    // AC values
174
175
    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
176
  }
John Koleszar's avatar
John Koleszar committed
177
178
}

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

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

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

204
205
206
207
208
209
210
211
212
213
214
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);
215

216
  TX_TYPE tx_type;
217

218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
  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;
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
295
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;
  }
}

296
297
298
299
300
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
301
302
  assert(mbmi->ref_frame != INTRA_FRAME);

303
304
305
306
  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
307
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
308
309
310
311
312
313
314
315
316
317
318
319

  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
320
  foreach_transformed_block(xd, bsize, decode_block, xd);
321
322
}

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


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

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

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

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

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

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

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

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

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

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

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

405
  xd->mode_info_context = cm->mi + mi_idx;
406
  xd->mode_info_context->mbmi.sb_type = bsize;
407
408
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

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

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

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

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

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

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

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

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

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

472
  xd->corrupted |= vp9_reader_has_error(r);
473
474
}

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

484
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
485
486
    return;

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

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

502
  subsize = get_subsize(bsize, partition);
503
  *(get_sb_index(xd, subsize)) = 0;
504

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

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

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

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

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

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

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

578
579
580
581
582
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;
583

584
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
585

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

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

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

609
610
611
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
612

613
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
614

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

747
748
749
750
751
752
753
754
755
756
757
758
759
760
static void read_frame_size(VP9_COMMON *cm,
                            struct vp9_read_bit_buffer *rb,
                            int *width, int *height) {
  const int w = vp9_rb_read_literal(rb, 16);
  const int h = vp9_rb_read_literal(rb, 16);
  if (w <= 0)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid frame width");

  if (h <= 0)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid frame height");
  *width = w;
  *height = h;
761
762
}

763
764
static void setup_frame_size(VP9D_COMP *pbi, int scaling_active,
                             struct vp9_read_bit_buffer *rb) {
765
766
  // 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.
767
768
769
770
771
  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;
772

773
  if (scaling_active)
774
    read_frame_size(pc, rb, &display_width, &display_height);
775

776
  read_frame_size(pc, rb, &width, &height);
777

778
  if (pc->width != width || pc->height != height) {
779
    if (!pbi->initial_width || !pbi->initial_height) {
780
      if (vp9_alloc_frame_buffers(pc, width, height))
781
782
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
783
784
785
786
787
788
        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");
789

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

795
796
797
798
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
799

800
    vp9_update_frame_size(pc);
801
802
803
  }
}

804
static void update_frame_context(FRAME_CONTEXT *fc) {
805
806
807
808
  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);
809
  vp9_copy(fc->pre_y_mode_prob, fc->y_mode_prob);
810
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
811
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
812
813
814
815
816
817
818
  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);
819
  vp9_zero(fc->y_mode_counts);
820
821
822
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->NMVcount);
  vp9_zero(fc->mv_ref_ct);
823
  vp9_zero(fc->partition_counts);
824
}
825

826
827
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
828
  int mi_row, mi_col;
829

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

841
842
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
843
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
  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;

863
864
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
865
866
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
                                      MAX_MB_PLANE * mi_cols_aligned_to_sb(pc));
867
868

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
869
                                       mi_cols_aligned_to_sb(pc));
870
871
872
873

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

    // 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);
898
        decode_tile(pbi, residual_bc);
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
        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);
916
        decode_tile(pbi, residual_bc);
917
918
919
920
921
922
923
924
925
926

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

John Koleszar's avatar
John Koleszar committed
927

928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
static void error_handler(void *data, int bit_offset) {
  VP9_COMMON *const cm = (VP9_COMMON *)data;
  vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet");
}

size_t read_uncompressed_header(VP9D_COMP *pbi,
                                struct vp9_read_bit_buffer *rb) {
  VP9_COMMON *const cm = &pbi->common;

  int scaling_active;
  cm->last_frame_type = cm->frame_type;
  cm->frame_type = (FRAME_TYPE) vp9_rb_read_bit(rb);
  cm->version = vp9_rb_read_literal(rb, 3);
  cm->show_frame = vp9_rb_read_bit(rb);
  scaling_active = vp9_rb_read_bit(rb);
  cm->subsampling_x = vp9_rb_read_bit(rb);
  cm->subsampling_y = vp9_rb_read_bit(rb);

  if (cm->frame_type == KEY_FRAME) {
    if (vp9_rb_read_literal(rb, 8) != SYNC_CODE_0 ||
        vp9_rb_read_literal(rb, 8) != SYNC_CODE_1 ||
        vp9_rb_read_literal(rb, 8) != SYNC_CODE_2) {
        vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM,
                           "Invalid frame sync code");
    }
  }
  setup_frame_size(pbi, scaling_active, rb);
John Koleszar's avatar
John Koleszar committed
955

956
957
958
959
960
961
962
  cm->frame_context_idx = vp9_rb_read_literal(rb, NUM_FRAME_CONTEXTS_LG2);
  cm->clr_type = (YUV_TYPE)vp9_rb_read_bit(rb);

  cm->error_resilient_mode = vp9_rb_read_bit(rb);
  if (!cm->error_resilient_mode) {
    cm->refresh_frame_context = vp9_rb_read_bit(rb);
    cm->frame_parallel_decoding_mode = vp9_rb_read_bit(rb);
John Koleszar's avatar
John Koleszar committed
963
  } else {
964
965
966
    cm