vp9_decodframe.c 35.5 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
#include "./vp9_rtcd.h"
#include "vpx_mem/vpx_mem.h"
#include "vpx_scale/vpx_scale.h"

Dmitry Kovalev's avatar
Dmitry Kovalev committed
17
#include "vp9/common/vp9_alloccommon.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
18
#include "vp9/common/vp9_common.h"
Yaowu Xu's avatar
Yaowu Xu committed
19
#include "vp9/common/vp9_entropy.h"
20
#include "vp9/common/vp9_entropymode.h"
Dmitry Kovalev's avatar
Dmitry Kovalev committed
21
22
23
#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
#include "vp9/common/vp9_pred_common.h"
24
#include "vp9/common/vp9_quant_common.h"
Dmitry Kovalev's avatar
Dmitry Kovalev committed
25
26
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.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
#include "vp9/decoder/vp9_decodframe.h"
#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
34
#include "vp9/decoder/vp9_dsubexp.h"
35
36
#include "vp9/decoder/vp9_onyxd_int.h"
#include "vp9/decoder/vp9_read_bit_buffer.h"
37

38

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

44
45
static int read_be32(const uint8_t *p) {
  return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
46
47
48
}

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

54
55
56
57
58
static int decode_unsigned_max(struct vp9_read_bit_buffer *rb, int max) {
  const int data = vp9_rb_read_literal(rb, get_unsigned_bits(max));
  return data > max ? max : data;
}

59
60
61
62
63
64
65
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);
66

67
    if (pc->txfm_mode == TX_MODE_SELECT) {
68
      int i, j;
69
70
      for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
        for (j = 0; j < TX_SIZE_MAX_SB - 3; ++j)
71
          if (vp9_read(r, VP9_MODE_UPDATE_PROB))
72
            vp9_diff_update_prob(r, &pc->fc.tx_probs_8x8p[i][j]);
73

74
75
76
77
      for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
        for (j = 0; j < TX_SIZE_MAX_SB - 2; ++j)
          if (vp9_read(r, VP9_MODE_UPDATE_PROB))
            vp9_diff_update_prob(r, &pc->fc.tx_probs_16x16p[i][j]);
78

79
80
81
82
      for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
        for (j = 0; j < TX_SIZE_MAX_SB - 1; ++j)
          if (vp9_read(r, VP9_MODE_UPDATE_PROB))
            vp9_diff_update_prob(r, &pc->fc.tx_probs_32x32p[i][j]);
83
84
    }
  }
John Koleszar's avatar
John Koleszar committed
85
86
}

87
static void mb_init_dequantizer(VP9_COMMON *pc, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
88
  int i;
89
  const int segment_id = xd->mode_info_context->mbmi.segment_id;
90
  xd->q_index = vp9_get_qindex(xd, segment_id, pc->base_qindex);
John Koleszar's avatar
John Koleszar committed
91

92
  xd->plane[0].dequant = pc->y_dequant[xd->q_index];
93
  for (i = 1; i < MAX_MB_PLANE; i++)
94
    xd->plane[i].dequant = pc->uv_dequant[xd->q_index];
John Koleszar's avatar
John Koleszar committed
95
96
}

97
98
99
static void decode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
                         int ss_txfrm_size, void *arg) {
  MACROBLOCKD* const xd = arg;
100
101
102
  struct macroblockd_plane *pd = &xd->plane[plane];
  int16_t* const qcoeff = BLOCK_OFFSET(pd->qcoeff, block, 16);
  const int stride = pd->dst.stride;
103
104
105
106
  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,
107
                                                 pd->dst.buf, stride);
108

109
  TX_TYPE tx_type;
110

111
112
113
114
  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)
115
        xd->itxm_add(qcoeff, dst, stride, pd->eobs[block]);
116
      else
117
        vp9_iht_add_c(tx_type, qcoeff, dst, stride, pd->eobs[block]);
118
119
      break;
    case TX_8X8:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
120
      tx_type = plane == 0 ? get_tx_type_8x8(xd) : DCT_DCT;
121
      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride, pd->eobs[block]);
122
123
      break;
    case TX_16X16:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
124
      tx_type = plane == 0 ? get_tx_type_16x16(xd) : DCT_DCT;
125
      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride, pd->eobs[block]);
126
127
      break;
    case TX_32X32:
128
      vp9_idct_add_32x32(qcoeff, dst, stride, pd->eobs[block]);
129
      break;
130
131
132
  }
}

133
134
135
static void decode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
                               int ss_txfrm_size, void *arg) {
  MACROBLOCKD* const xd = arg;
136
  struct macroblockd_plane *pd = &xd->plane[plane];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
137
  MODE_INFO *const mi = xd->mode_info_context;
138

139
140
141
142
  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,
143
                                                 pd->dst.buf, pd->dst.stride);
144
  const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
145
  int b_mode;
146
  int plane_b_size;
147
  const int tx_ib = raster_block >> tx_size;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
148
149
  const int mode = plane == 0 ? mi->mbmi.mode
                              : mi->mbmi.uv_mode;
150

Dmitry Kovalev's avatar
Dmitry Kovalev committed
151
  if (plane == 0 && mi->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
152
    assert(bsize == BLOCK_SIZE_SB8X8);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
153
    b_mode = mi->bmi[raster_block].as_mode.first;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
154
  } else {
155
    b_mode = mode;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
156
  }
157

158
  if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0)
159
160
    extend_for_intra(xd, plane, block, bsize, ss_txfrm_size);

161
162
  plane_b_size = b_width_log2(bsize) - pd->subsampling_x;
  vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size, b_mode,
163
                          dst, pd->dst.stride,
164
                          dst, pd->dst.stride);
165

166
  // Early exit if there are no coefficients
Dmitry Kovalev's avatar
Dmitry Kovalev committed
167
  if (mi->mbmi.mb_skip_coeff)
168
169
    return;

170
  decode_block(plane, block, bsize, ss_txfrm_size, arg);
171
172
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
173
174
static int decode_tokens(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize, vp9_reader *r) {
  MACROBLOCKD *const xd = &pbi->mb;
175

Dmitry Kovalev's avatar
Dmitry Kovalev committed
176
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
177
    vp9_reset_sb_tokens_context(xd, bsize);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
178
    return -1;
179
180
181
182
  } else {
    if (xd->segmentation_enabled)
      mb_init_dequantizer(&pbi->common, xd);

Dmitry Kovalev's avatar
Dmitry Kovalev committed
183
184
    // TODO(dkovalev) if (!vp9_reader_has_error(r))
    return vp9_decode_tokens(pbi, r, bsize);
185
186
187
  }
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
188
189
190
191
static void decode_atom(VP9D_COMP *pbi, int mi_row, int mi_col,
                        vp9_reader *r) {
  BLOCK_SIZE_TYPE bsize = BLOCK_SIZE_SB8X8;
  MACROBLOCKD *const xd = &pbi->mb;
192
193
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
194
195
196
197
198
199
  assert(mbmi->ref_frame[0] != INTRA_FRAME);
  vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
  if (decode_tokens(pbi, bsize, r) >= 0)
    foreach_transformed_block(xd, bsize, decode_block, xd);
}
200

Dmitry Kovalev's avatar
Dmitry Kovalev committed
201
202
203
204
static void decode_sb_intra(VP9D_COMP *pbi, int mi_row, int mi_col,
                            vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;
  decode_tokens(pbi, bsize, r);
205
206
207
  foreach_transformed_block(xd, bsize, decode_block_intra, xd);
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
208
209
210
211
static void decode_sb(VP9D_COMP *pbi, int mi_row, int mi_col, vp9_reader *r,
                      BLOCK_SIZE_TYPE bsize) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
212
213
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
214
  int  eobtotal;
215

216
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
217
  assert(mbmi->ref_frame[0] != INTRA_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
218

Dmitry Kovalev's avatar
Dmitry Kovalev committed
219
  vp9_setup_interp_filters(xd, mbmi->interp_filter, cm);
Yaowu Xu's avatar
Yaowu Xu committed
220
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
221

Dmitry Kovalev's avatar
Dmitry Kovalev committed
222
223
224
225
226
  eobtotal = decode_tokens(pbi, bsize, r);
  if (eobtotal == 0) {
    vp9_set_pred_flag(xd, bsize, PRED_MBSKIP, 1);  //  skip loopfilter
  } else if (eobtotal > 0) {
    foreach_transformed_block(xd, bsize, decode_block, xd);
227
  }
228
229
}

230
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
231
                        int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
232
233
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
234
235
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
236
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
237
  int i;
238

239
  xd->mode_info_context = cm->mi + mi_idx;
240
  xd->mode_info_context->mbmi.sb_type = bsize;
241
242
  // Special case: if prev_mi is NULL, the previous mode info context
  // cannot be used.
243
  xd->prev_mode_info_context = cm->prev_mi ? cm->prev_mi + mi_idx : NULL;
244

245
  for (i = 0; i < MAX_MB_PLANE; i++) {
246
247
248
249
250
    struct macroblockd_plane *pd = &xd->plane[i];
    pd->above_context = cm->above_context[i] +
                            (mi_col * 2 >> pd->subsampling_x);
    pd->left_context = cm->left_context[i] +
                           (((mi_row * 2) & 15) >> pd->subsampling_y);
251
  }
252
253
  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
254

255
256
  // 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
257
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
258

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

262
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
263
264
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
265
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
266

267
268
269
270
271
272
273
274
275
276
  // Select the appropriate reference frame for this MB
  const int fb_idx = cm->active_ref_idx[mbmi->ref_frame[0] - 1];
  const YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[fb_idx];
  xd->scale_factor[0] = cm->active_ref_scale[mbmi->ref_frame[0] - 1];
  xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame[0] - 1];
  setup_pre_planes(xd, cfg, NULL, mi_row, mi_col, xd->scale_factor,
                   xd->scale_factor_uv);
  xd->corrupted |= cfg->corrupted;

  if (mbmi->ref_frame[1] > INTRA_FRAME) {
277
    // Select the appropriate reference frame for this MB
278
279
280
281
282
283
284
    const int second_fb_idx = cm->active_ref_idx[mbmi->ref_frame[1] - 1];
    const YV12_BUFFER_CONFIG *second_cfg = &cm->yv12_fb[second_fb_idx];
    xd->scale_factor[1] = cm->active_ref_scale[mbmi->ref_frame[1] - 1];
    xd->scale_factor_uv[1] = cm->active_ref_scale[mbmi->ref_frame[1] - 1];
    setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col, xd->scale_factor,
                     xd->scale_factor_uv);
    xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
285
286
  }
}
John Koleszar's avatar
John Koleszar committed
287

288
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
289
290
291
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

292
293
294
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
295

296
297
  set_offsets(pbi, bsize, mi_row, mi_col);
  vp9_decode_mb_mode_mv(pbi, xd, mi_row, mi_col, r);
298

299
  if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
300
301
    decode_sb_intra(pbi, mi_row, mi_col, r,
                    (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
302
303
304
  } else {
    set_refs(pbi, mi_row, mi_col);
    if (bsize < BLOCK_SIZE_SB8X8)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
305
      decode_atom(pbi, mi_row, mi_col, r);
306
    else
Dmitry Kovalev's avatar
Dmitry Kovalev committed
307
      decode_sb(pbi, mi_row, mi_col, r, bsize);
308
  }
309
  xd->corrupted |= vp9_reader_has_error(r);
310
311
}

312
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
313
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
314
315
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
316
  int bs = (1 << mi_width_log2(bsize)) / 2, n;
317
318
319
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

320
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
321
322
    return;

323
324
325
326
327
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
328
    int pl;
329
    int idx = check_bsize_coverage(pc, xd, mi_row, mi_col, bsize);
330
    // read the partition information
331
332
    xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = pc->above_seg_context + mi_col;
333
    pl = partition_plane_context(xd, bsize);
334
335
336
337
338
339
340
341
342
343

    if (idx == 0)
      partition = treed_read(r, vp9_partition_tree,
                             pc->fc.partition_prob[pc->frame_type][pl]);
    else if (idx > 0 &&
        !vp9_read(r, pc->fc.partition_prob[pc->frame_type][pl][idx]))
      partition = (idx == 1) ? PARTITION_HORZ : PARTITION_VERT;
    else
      partition = PARTITION_SPLIT;

344
    pc->fc.partition_counts[pl][partition]++;
345
346
  }

347
  subsize = get_subsize(bsize, partition);
348
  *(get_sb_index(xd, subsize)) = 0;
349

350
351
  switch (partition) {
    case PARTITION_NONE:
352
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
353
354
      break;
    case PARTITION_HORZ:
355
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
356
      *(get_sb_index(xd, subsize)) = 1;
357
      if (mi_row + bs < pc->mi_rows)
358
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
359
360
      break;
    case PARTITION_VERT:
361
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
362
      *(get_sb_index(xd, subsize)) = 1;
363
      if (mi_col + bs < pc->mi_cols)
364
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
365
366
367
368
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
369
        *(get_sb_index(xd, subsize)) = n;
370
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
371
372
373
374
375
      }
      break;
    default:
      assert(0);
  }
376
  // update partition context
377
378
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
379
380
381
    set_partition_seg_context(pc, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
382
383
}

384
static void setup_token_decoder(VP9D_COMP *pbi,
385
                                const uint8_t *data, size_t read_size,
386
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
387
  VP9_COMMON *pc = &pbi->common;
388
  const uint8_t *data_end = pbi->source + pbi->source_sz;
John Koleszar's avatar
John Koleszar committed
389

Dmitry Kovalev's avatar
Dmitry Kovalev committed
390
391
392
  // 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.
393
  if (!read_is_valid(data, read_size, data_end))
John Koleszar's avatar
John Koleszar committed
394
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
395
                       "Truncated packet or corrupt tile length");
John Koleszar's avatar
John Koleszar committed
396

397
  if (vp9_reader_init(r, data, read_size))
John Koleszar's avatar
John Koleszar committed
398
399
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
400
401
}

402
403
404
static void read_coef_probs_common(FRAME_CONTEXT *fc, TX_SIZE tx_size,
                                   vp9_reader *r) {
  vp9_coeff_probs_model *coef_probs = fc->coef_probs[tx_size];
405

406
  if (vp9_read_bit(r)) {
407
    int i, j, k, l, m;
408
    for (i = 0; i < BLOCK_TYPES; i++) {
409
410
411
412
413
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
            if (l >= 3 && k == 0)
              continue;
414

415
            for (m = 0; m < UNCONSTRAINED_NODES; m++) {
416
417
              vp9_prob *const p = coef_probs[i][j][k][l] + m;

418
              if (vp9_read(r, VP9_COEF_UPDATE_PROB))
419
                vp9_diff_update_prob(r, p);
420
421
422
            }
          }
        }
423
424
      }
    }
425
  }
426
}
427

428
static void read_coef_probs(VP9D_COMP *pbi, vp9_reader *r) {
429
  const TXFM_MODE txfm_mode = pbi->common.txfm_mode;
430
  FRAME_CONTEXT *const fc = &pbi->common.fc;
Daniel Kang's avatar
Daniel Kang committed
431

432
  read_coef_probs_common(fc, TX_4X4, r);
433

434
  if (txfm_mode > ONLY_4X4)
435
    read_coef_probs_common(fc, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
436

437
  if (txfm_mode > ALLOW_8X8)
438
    read_coef_probs_common(fc, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
439

440
  if (txfm_mode > ALLOW_16X16)
441
    read_coef_probs_common(fc, TX_32X32, r);
442
443
}

444
static void setup_segmentation(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
445
446
  int i, j;

447
448
449
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

450
451
452
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;

453
  xd->segmentation_enabled = vp9_rb_read_bit(rb);
454
455
456
457
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
458
  xd->update_mb_segmentation_map = vp9_rb_read_bit(rb);
459
  if (xd->update_mb_segmentation_map) {
460
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
461
462
      xd->mb_segment_tree_probs[i] = vp9_rb_read_bit(rb) ?
                                         vp9_rb_read_literal(rb, 8) : MAX_PROB;
463

464
465
    cm->temporal_update = vp9_rb_read_bit(rb);
    if (cm->temporal_update) {
466
      for (i = 0; i < PREDICTION_PROBS; i++)
467
468
        cm->segment_pred_probs[i] = vp9_rb_read_bit(rb) ?
                                        vp9_rb_read_literal(rb, 8) : MAX_PROB;
469
470
    } else {
      for (i = 0; i < PREDICTION_PROBS; i++)
471
        cm->segment_pred_probs[i] = MAX_PROB;
472
    }
473
  }
474

475
  // Segmentation data update
476
  xd->update_mb_segmentation_data = vp9_rb_read_bit(rb);
477
  if (xd->update_mb_segmentation_data) {
478
    xd->mb_segment_abs_delta = vp9_rb_read_bit(rb);
479
480
481
482
483
484

    vp9_clearall_segfeatures(xd);

    for (i = 0; i < MAX_MB_SEGMENTS; i++) {
      for (j = 0; j < SEG_LVL_MAX; j++) {
        int data = 0;
485
        const int feature_enabled = vp9_rb_read_bit(rb);
486
487
        if (feature_enabled) {
          vp9_enable_segfeature(xd, i, j);
488
          data = decode_unsigned_max(rb, vp9_seg_feature_data_max(j));
489
          if (vp9_is_segfeature_signed(j))
490
            data = vp9_rb_read_bit(rb) ? -data : data;
491
        }
492
        vp9_set_segdata(xd, i, j, data);
493
494
495
496
497
      }
    }
  }
}

498
499
500
501
502
503
static void setup_loopfilter(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;

  cm->filter_level = vp9_rb_read_literal(rb, 6);
  cm->sharpness_level = vp9_rb_read_literal(rb, 3);
504
505
506
507
508

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

509
  xd->mode_ref_lf_delta_enabled = vp9_rb_read_bit(rb);
510
  if (xd->mode_ref_lf_delta_enabled) {
511
    xd->mode_ref_lf_delta_update = vp9_rb_read_bit(rb);
512
    if (xd->mode_ref_lf_delta_update) {
513
514
      int i;

515
516
517
      for (i = 0; i < MAX_REF_LF_DELTAS; i++)
        if (vp9_rb_read_bit(rb))
          xd->ref_lf_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
518

519
520
521
      for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
        if (vp9_rb_read_bit(rb))
          xd->mode_lf_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
522
523
524
525
    }
  }
}

526
527
static int read_delta_q(struct vp9_read_bit_buffer *rb, int *delta_q) {
  const int old = *delta_q;
528
529
  if (vp9_rb_read_bit(rb))
    *delta_q = vp9_rb_read_signed_literal(rb, 4);
530
531
  return old != *delta_q;
}
532

533
static void setup_quantization(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
534
  MACROBLOCKD *const xd = &pbi->mb;
535
536
  VP9_COMMON *const cm = &pbi->common;
  int update = 0;
537

538
539
540
541
542
543
  cm->base_qindex = vp9_rb_read_literal(rb, QINDEX_BITS);
  update |= read_delta_q(rb, &cm->y_dc_delta_q);
  update |= read_delta_q(rb, &cm->uv_dc_delta_q);
  update |= read_delta_q(rb, &cm->uv_ac_delta_q);
  if (update)
    vp9_init_dequantizer(cm);
544
545
546
547
548

  xd->lossless = cm->base_qindex == 0 &&
                 cm->y_dc_delta_q == 0 &&
                 cm->uv_dc_delta_q == 0 &&
                 cm->uv_ac_delta_q == 0;
549
550
551

  xd->itxm_add = xd->lossless ? vp9_idct_add_lossless_c
                              : vp9_idct_add;
552
553
}

554
555
556
557
static INTERPOLATIONFILTERTYPE read_interp_filter_type(
    struct vp9_read_bit_buffer *rb) {
  return vp9_rb_read_bit(rb) ? SWITCHABLE
                             : vp9_rb_read_literal(rb, 2);
558
559
}

560
static void read_frame_size(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb,
561
                            int *width, int *height) {
562
563
  const int w = vp9_rb_read_literal(rb, 16) + 1;
  const int h = vp9_rb_read_literal(rb, 16) + 1;
564
565
  *width = w;
  *height = h;
566
567
}

568
static void setup_display_size(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
569
  VP9_COMMON *const cm = &pbi->common;
570
571
572
573
  cm->display_width = cm->width;
  cm->display_height = cm->height;
  if (vp9_rb_read_bit(rb))
    read_frame_size(cm, rb, &cm->display_width, &cm->display_height);
574
}
575

576
577
static void apply_frame_size(VP9D_COMP *pbi, int width, int height) {
  VP9_COMMON *cm = &pbi->common;
578

579
  if (cm->width != width || cm->height != height) {
580
    if (!pbi->initial_width || !pbi->initial_height) {
581
582
      if (vp9_alloc_frame_buffers(cm, width, height))
        vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
583
                           "Failed to allocate frame buffers");
584
585
      pbi->initial_width = width;
      pbi->initial_height = height;
586
587
    } else {
      if (width > pbi->initial_width)
588
        vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
589
                           "Frame width too large");
590

591
      if (height > pbi->initial_height)
592
        vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
593
                           "Frame height too large");
594
595
    }

596
597
    cm->width = width;
    cm->height = height;
598

599
    vp9_update_frame_size(cm);
600
  }
601

602
603
  vp9_realloc_frame_buffer(&cm->yv12_fb[cm->new_fb_idx], cm->width, cm->height,
                           cm->subsampling_x, cm->subsampling_y,
604
                           VP9BORDERINPIXELS);
605
606
}

607
608
609
610
611
612
613
614
615
static void setup_frame_size(VP9D_COMP *pbi,
                             struct vp9_read_bit_buffer *rb) {
  VP9_COMMON *const cm = &pbi->common;
  int width, height;
  read_frame_size(cm, rb, &width, &height);
  setup_display_size(pbi, rb);
  apply_frame_size(pbi, width, height);
}

616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
static void setup_frame_size_with_refs(VP9D_COMP *pbi,
                                       struct vp9_read_bit_buffer *rb) {
  VP9_COMMON *const cm = &pbi->common;

  int width, height;
  int found = 0, i;
  for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) {
    if (vp9_rb_read_bit(rb)) {
      YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[cm->active_ref_idx[i]];
      width = cfg->y_crop_width;
      height = cfg->y_crop_height;
      found = 1;
      break;
    }
  }

  if (!found)
    read_frame_size(cm, rb, &width, &height);

635
636
637
638
  if (!width || !height)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Referenced frame with invalid size");

639
640
641
642
  setup_display_size(pbi, rb);
  apply_frame_size(pbi, width, height);
}

643
static void update_frame_context(FRAME_CONTEXT *fc) {
644
  vp9_copy(fc->pre_coef_probs, fc->coef_probs);
645
  vp9_copy(fc->pre_y_mode_prob, fc->y_mode_prob);
646
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
647
  vp9_copy(fc->pre_partition_prob, fc->partition_prob[1]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
648
649
650
651
  vp9_copy(fc->pre_intra_inter_prob, fc->intra_inter_prob);
  vp9_copy(fc->pre_comp_inter_prob, fc->comp_inter_prob);
  vp9_copy(fc->pre_single_ref_prob, fc->single_ref_prob);
  vp9_copy(fc->pre_comp_ref_prob, fc->comp_ref_prob);
652
  fc->pre_nmvc = fc->nmvc;
653
654
  vp9_copy(fc->pre_switchable_interp_prob, fc->switchable_interp_prob);
  vp9_copy(fc->pre_inter_mode_probs, fc->inter_mode_probs);
655
656
657
  vp9_copy(fc->pre_tx_probs_8x8p, fc->tx_probs_8x8p);
  vp9_copy(fc->pre_tx_probs_16x16p, fc->tx_probs_16x16p);
  vp9_copy(fc->pre_tx_probs_32x32p, fc->tx_probs_32x32p);
Deb Mukherjee's avatar
Deb Mukherjee committed
658
  vp9_copy(fc->pre_mbskip_probs, fc->mbskip_probs);
659

660
  vp9_zero(fc->coef_counts);
661
  vp9_zero(fc->eob_branch_counts);
662
  vp9_zero(fc->y_mode_counts);
663
664
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->NMVcount);
665
  vp9_zero(fc->inter_mode_counts);
666
  vp9_zero(fc->partition_counts);
667
  vp9_zero(fc->switchable_interp_count);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
668
669
670
671
  vp9_zero(fc->intra_inter_count);
  vp9_zero(fc->comp_inter_count);
  vp9_zero(fc->single_ref_count);
  vp9_zero(fc->comp_ref_count);
672
673
674
  vp9_zero(fc->tx_count_8x8p);
  vp9_zero(fc->tx_count_16x16p);
  vp9_zero(fc->tx_count_32x32p);
Deb Mukherjee's avatar
Deb Mukherjee committed
675
  vp9_zero(fc->mbskip_count);
676
}
677

678
679
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
680
  int mi_row, mi_col;
681

682
  for (mi_row = pc->cur_tile_mi_row_start;
683
       mi_row < pc->cur_tile_mi_row_end; mi_row += 64 / MI_SIZE) {
684
    // For a SB there are 2 left contexts, each pertaining to a MB row within
685
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
686
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
687
    for (mi_col = pc->cur_tile_mi_col_start;
688
         mi_col < pc->cur_tile_mi_col_end; mi_col += 64 / MI_SIZE)
689
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
690
691
692
  }
}

693
694
static void setup_tile_info(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
  int delta_log2_tiles;
695

696
  vp9_get_tile_n_bits(cm, &cm->log2_tile_columns, &delta_log2_tiles);
697
  while (delta_log2_tiles--) {
698
699
    if (vp9_rb_read_bit(rb)) {
      cm->log2_tile_columns++;
700
701
702
703
    } else {
      break;
    }
  }
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718

  cm->log2_tile_rows = vp9_rb_read_bit(rb);
  if (cm->log2_tile_rows)
    cm->log2_tile_rows += vp9_rb_read_bit(rb);

  cm->tile_columns = 1 << cm->log2_tile_columns;
  cm->tile_rows    = 1 << cm->log2_tile_rows;
}

static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, size_t first_partition_size,
                         vp9_reader *residual_bc) {
  VP9_COMMON *const pc = &pbi->common;

  const uint8_t *data_ptr = data + first_partition_size;
719
  const uint8_t* const data_end = pbi->source + pbi->source_sz;
720
  int tile_row, tile_col;
721

722
723
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
724
725
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
                                      MAX_MB_PLANE * mi_cols_aligned_to_sb(pc));
726
727

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
728
                                       mi_cols_aligned_to_sb(pc));
729
730
731
732

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
733
    vp9_reader bc_bak = {0};
734
735
736
737
738

    // 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) {
739
        const int size = read_be32(data_ptr2[tile_row - 1][n_cols - 1]);
740
741
742
743
744
        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++) {
745
        const int size = read_be32(data_ptr2[tile_row][tile_col - 1]);
746
747
748
749
750
751
752
753
754
755
        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);
756
757
758
        setup_token_decoder(pbi, data_ptr2[tile_row][tile_col],
                            data_end - data_ptr2[tile_row][tile_col],
                            residual_bc);
759
        decode_tile(pbi, residual_bc);
760
761
762
763
764
765
766
767
768
769
770
        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++) {
771
772
        size_t size;

773
774
775
776
777
        vp9_get_tile_col_offsets(pc, tile_col);

        has_more = tile_col < pc->tile_columns - 1 ||
                   tile_row < pc->tile_rows - 1;
        if (has_more) {
778
779
780
781
782
783
784
785
          if (!read_is_valid(data_ptr, 4, data_end))
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Truncated packet or corrupt tile length");

          size = read_be32(data_ptr);
          data_ptr += 4;
        } else {
          size = data_end - data_ptr;
786
        }
787
788
789
790

        setup_token_decoder(pbi, data_ptr, size, residual_bc);
        decode_tile(pbi, residual_bc);
        data_ptr += size;
791
792
793
794
795
      }
    }
  }
}

796
797
798
799
800
801
802
803
static void check_sync_code(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
  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");
  }
}
John Koleszar's avatar
John Koleszar committed
804

Frank Galligan's avatar
Frank Galligan committed
805
static void error_handler(void *data, size_t bit_offset) {
806
807
808
809
  VP9_COMMON *const cm = (VP9_COMMON *)data;
  vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet");
}

810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
static void setup_inter_inter(VP9_COMMON *cm) {
  int i;

  cm->allow_comp_inter_inter = 0;
  for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) {
    cm->allow_comp_inter_inter |= i > 0 &&
        cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1];
  }

  if (cm->allow_comp_inter_inter) {
    // which one is always-on in comp inter-inter?
    if (cm->ref_frame_sign_bias[LAST_FRAME] ==
        cm->ref_frame_sign_bias[GOLDEN_FRAME]) {
      cm->comp_fixed_ref = ALTREF_FRAME;
      cm->comp_var_ref[0] = LAST_FRAME;
      cm->comp_var_ref[1] = GOLDEN_FRAME;
    } else if (cm->ref_frame_sign_bias[LAST_FRAME] ==
               cm->ref_frame_sign_bias[ALTREF_FRAME]) {
      cm->comp_fixed_ref = GOLDEN_FRAME;
      cm->comp_var_ref[0] = LAST_FRAME;
      cm->comp_var_ref[1] = ALTREF_FRAME;
    } else {
      cm->comp_fixed_ref = LAST_FRAME;
      cm->comp_var_ref[0] = GOLDEN_FRAME;
      cm->comp_var_ref[1] = ALTREF_FRAME;
    }
  }
}

839
840
841
842
843
#define RESERVED \
  if (vp9_rb_read_bit(rb)) \
      vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM, \
                         "Reserved bit must be unset")

844
845
static size_t read_uncompressed_header(VP9D_COMP *pbi,
                                       struct vp9_read_bit_buffer *rb) {
846
  VP9_COMMON *const cm = &pbi->common;
847
  MACROBLOCKD *const xd = &pbi->mb;
848
  int i;
849
850

  cm->last_frame_type = cm->frame_type;