vp9_decodeframe.c 48.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>
12
#include <stdlib.h>  // qsort()
John Koleszar's avatar
John Koleszar committed
13

14
#include "./vp9_rtcd.h"
15
16
#include "./vpx_scale_rtcd.h"

17
#include "vpx_mem/vpx_mem.h"
18
#include "vpx_ports/mem_ops.h"
19
20
#include "vpx_scale/vpx_scale.h"

Dmitry Kovalev's avatar
Dmitry Kovalev committed
21
#include "vp9/common/vp9_alloccommon.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
22
#include "vp9/common/vp9_common.h"
Yaowu Xu's avatar
Yaowu Xu committed
23
#include "vp9/common/vp9_entropy.h"
24
#include "vp9/common/vp9_entropymode.h"
25
#include "vp9/common/vp9_idct.h"
Dmitry Kovalev's avatar
Dmitry Kovalev committed
26
#include "vp9/common/vp9_pred_common.h"
27
#include "vp9/common/vp9_quant_common.h"
Dmitry Kovalev's avatar
Dmitry Kovalev committed
28
29
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
30
31
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_tile_common.h"
32

Yaowu Xu's avatar
Yaowu Xu committed
33
#include "vp9/decoder/vp9_decodeframe.h"
34
35
#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
36
#include "vp9/decoder/vp9_decoder.h"
37
#include "vp9/decoder/vp9_dsubexp.h"
38
#include "vp9/decoder/vp9_dthread.h"
39
#include "vp9/decoder/vp9_read_bit_buffer.h"
40
#include "vp9/decoder/vp9_reader.h"
41
#include "vp9/decoder/vp9_thread.h"
42

43
44
#define MAX_VP9_HEADER_SIZE 80

45
static int is_compound_reference_allowed(const VP9_COMMON *cm) {
46
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
47
  for (i = 1; i < REFS_PER_FRAME; ++i)
48
    if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1])
49
50
51
52
53
      return 1;

  return 0;
}

54
static void setup_compound_reference_mode(VP9_COMMON *cm) {
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
  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;
  }
}

72
static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
Johann's avatar
Johann committed
73
  return len != 0 && len <= (size_t)(end - start);
74
75
}

76
77
78
79
80
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;
}

81
82
83
84
85
static TX_MODE read_tx_mode(vp9_reader *r) {
  TX_MODE tx_mode = vp9_read_literal(r, 2);
  if (tx_mode == ALLOW_32X32)
    tx_mode += vp9_read_bit(r);
  return tx_mode;
86
87
}

88
static void read_tx_mode_probs(struct tx_probs *tx_probs, vp9_reader *r) {
89
90
91
  int i, j;

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
92
    for (j = 0; j < TX_SIZES - 3; ++j)
93
      vp9_diff_update_prob(r, &tx_probs->p8x8[i][j]);
94
95

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
96
    for (j = 0; j < TX_SIZES - 2; ++j)
97
      vp9_diff_update_prob(r, &tx_probs->p16x16[i][j]);
98
99

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
100
    for (j = 0; j < TX_SIZES - 1; ++j)
101
      vp9_diff_update_prob(r, &tx_probs->p32x32[i][j]);
John Koleszar's avatar
John Koleszar committed
102
103
}

104
105
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
  int i, j;
106
  for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
107
108
109
110
111
112
113
114
115
116
117
    for (i = 0; i < SWITCHABLE_FILTERS - 1; ++i)
      vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
}

static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
    for (j = 0; j < INTER_MODES - 1; ++j)
      vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
}

118
119
static REFERENCE_MODE read_frame_reference_mode(const VP9_COMMON *cm,
                                                vp9_reader *r) {
120
  if (is_compound_reference_allowed(cm)) {
121
122
123
    return vp9_read_bit(r) ? (vp9_read_bit(r) ? REFERENCE_MODE_SELECT
                                              : COMPOUND_REFERENCE)
                           : SINGLE_REFERENCE;
124
125
126
  } else {
    return SINGLE_REFERENCE;
  }
127
128
}

129
130
static void read_frame_reference_mode_probs(VP9_COMMON *cm, vp9_reader *r) {
  FRAME_CONTEXT *const fc = &cm->fc;
131
  int i;
132

133
  if (cm->reference_mode == REFERENCE_MODE_SELECT)
134
135
    for (i = 0; i < COMP_INTER_CONTEXTS; ++i)
      vp9_diff_update_prob(r, &fc->comp_inter_prob[i]);
136

137
  if (cm->reference_mode != COMPOUND_REFERENCE)
138
139
140
    for (i = 0; i < REF_CONTEXTS; ++i) {
      vp9_diff_update_prob(r, &fc->single_ref_prob[i][0]);
      vp9_diff_update_prob(r, &fc->single_ref_prob[i][1]);
141
142
    }

143
  if (cm->reference_mode != SINGLE_REFERENCE)
144
145
    for (i = 0; i < REF_CONTEXTS; ++i)
      vp9_diff_update_prob(r, &fc->comp_ref_prob[i]);
146
147
}

148
149
150
static void update_mv_probs(vp9_prob *p, int n, vp9_reader *r) {
  int i;
  for (i = 0; i < n; ++i)
151
    if (vp9_read(r, MV_UPDATE_PROB))
Dmitry Kovalev's avatar
Dmitry Kovalev committed
152
      p[i] = (vp9_read_literal(r, 7) << 1) | 1;
153
154
}

155
156
static void read_mv_probs(nmv_context *ctx, int allow_hp, vp9_reader *r) {
  int i, j;
157

158
  update_mv_probs(ctx->joints, MV_JOINTS - 1, r);
159
160

  for (i = 0; i < 2; ++i) {
161
162
163
164
165
    nmv_component *const comp_ctx = &ctx->comps[i];
    update_mv_probs(&comp_ctx->sign, 1, r);
    update_mv_probs(comp_ctx->classes, MV_CLASSES - 1, r);
    update_mv_probs(comp_ctx->class0, CLASS0_SIZE - 1, r);
    update_mv_probs(comp_ctx->bits, MV_OFFSET_BITS, r);
166
167
168
  }

  for (i = 0; i < 2; ++i) {
169
    nmv_component *const comp_ctx = &ctx->comps[i];
170
    for (j = 0; j < CLASS0_SIZE; ++j)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
171
      update_mv_probs(comp_ctx->class0_fp[j], MV_FP_SIZE - 1, r);
172
    update_mv_probs(comp_ctx->fp, 3, r);
173
174
175
176
  }

  if (allow_hp) {
    for (i = 0; i < 2; ++i) {
177
178
179
      nmv_component *const comp_ctx = &ctx->comps[i];
      update_mv_probs(&comp_ctx->class0_hp, 1, r);
      update_mv_probs(&comp_ctx->hp, 1, r);
180
181
182
183
    }
  }
}

184
static void setup_plane_dequants(VP9_COMMON *cm, MACROBLOCKD *xd, int q_index) {
John Koleszar's avatar
John Koleszar committed
185
  int i;
186
  xd->plane[0].dequant = cm->y_dequant[q_index];
187

188
  for (i = 1; i < MAX_MB_PLANE; i++)
189
    xd->plane[i].dequant = cm->uv_dequant[q_index];
John Koleszar's avatar
John Koleszar committed
190
191
}

192
static void inverse_transform_block(MACROBLOCKD* xd, int plane, int block,
193
194
                                    TX_SIZE tx_size, uint8_t *dst, int stride,
                                    int eob) {
195
  struct macroblockd_plane *const pd = &xd->plane[plane];
196
197
  if (eob > 0) {
    TX_TYPE tx_type;
198
    int16_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
199
200
201
202
203
204
205
206
    if (xd->lossless) {
      tx_type = DCT_DCT;
      vp9_iwht4x4_add(dqcoeff, dst, stride, eob);
    } else {
      const PLANE_TYPE plane_type = pd->plane_type;
      switch (tx_size) {
        case TX_4X4:
          tx_type = get_tx_type_4x4(plane_type, xd, block);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
207
          vp9_iht4x4_add(tx_type, dqcoeff, dst, stride, eob);
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
          break;
        case TX_8X8:
          tx_type = get_tx_type(plane_type, xd);
          vp9_iht8x8_add(tx_type, dqcoeff, dst, stride, eob);
          break;
        case TX_16X16:
          tx_type = get_tx_type(plane_type, xd);
          vp9_iht16x16_add(tx_type, dqcoeff, dst, stride, eob);
          break;
        case TX_32X32:
          tx_type = DCT_DCT;
          vp9_idct32x32_add(dqcoeff, dst, stride, eob);
          break;
        default:
          assert(0 && "Invalid transform size");
      }
224
225
226
    }

    if (eob == 1) {
227
      vpx_memset(dqcoeff, 0, 2 * sizeof(dqcoeff[0]));
228
    } else {
229
      if (tx_type == DCT_DCT && tx_size <= TX_16X16 && eob <= 10)
230
        vpx_memset(dqcoeff, 0, 4 * (4 << tx_size) * sizeof(dqcoeff[0]));
231
      else if (tx_size == TX_32X32 && eob <= 34)
232
        vpx_memset(dqcoeff, 0, 256 * sizeof(dqcoeff[0]));
233
      else
234
        vpx_memset(dqcoeff, 0, (16 << (tx_size << 1)) * sizeof(dqcoeff[0]));
235
    }
236
237
238
  }
}

239
240
241
242
243
244
245
246
247
struct intra_args {
  VP9_COMMON *cm;
  MACROBLOCKD *xd;
  vp9_reader *r;
};

static void predict_and_reconstruct_intra_block(int plane, int block,
                                                BLOCK_SIZE plane_bsize,
                                                TX_SIZE tx_size, void *arg) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
248
  struct intra_args *const args = (struct intra_args *)arg;
249
250
  VP9_COMMON *const cm = args->cm;
  MACROBLOCKD *const xd = args->xd;
251
  struct macroblockd_plane *const pd = &xd->plane[plane];
252
  MODE_INFO *const mi = xd->mi[0];
253
254
  const PREDICTION_MODE mode = (plane == 0) ? get_y_mode(mi, block)
                                            : mi->mbmi.uv_mode;
255
256
257
258
  int x, y;
  uint8_t *dst;
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x, &y);
  dst = &pd->dst.buf[4 * y * pd->dst.stride + 4 * x];
259

260
  vp9_predict_intra_block(xd, block >> (tx_size << 1),
261
                          b_width_log2(plane_bsize), tx_size, mode,
262
263
                          dst, pd->dst.stride, dst, pd->dst.stride,
                          x, y, plane);
264

265
  if (!mi->mbmi.skip) {
266
267
268
269
270
    const int eob = vp9_decode_block_tokens(cm, xd, plane, block,
                                            plane_bsize, x, y, tx_size,
                                            args->r);
    inverse_transform_block(xd, plane, block, tx_size, dst, pd->dst.stride,
                            eob);
271
  }
272
273
}

274
275
276
277
278
279
280
281
282
283
struct inter_args {
  VP9_COMMON *cm;
  MACROBLOCKD *xd;
  vp9_reader *r;
  int *eobtotal;
};

static void reconstruct_inter_block(int plane, int block,
                                    BLOCK_SIZE plane_bsize,
                                    TX_SIZE tx_size, void *arg) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
284
  struct inter_args *args = (struct inter_args *)arg;
285
286
  VP9_COMMON *const cm = args->cm;
  MACROBLOCKD *const xd = args->xd;
287
  struct macroblockd_plane *const pd = &xd->plane[plane];
288
  int x, y, eob;
289
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x, &y);
290
291
  eob = vp9_decode_block_tokens(cm, xd, plane, block, plane_bsize, x, y,
                                tx_size, args->r);
292
293
  inverse_transform_block(xd, plane, block, tx_size,
                          &pd->dst.buf[4 * y * pd->dst.stride + 4 * x],
294
295
                          pd->dst.stride, eob);
  *args->eobtotal += eob;
296
297
}

298
299
300
static MB_MODE_INFO *set_offsets(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                                 const TileInfo *const tile,
                                 BLOCK_SIZE bsize, int mi_row, int mi_col) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
301
  const int bw = num_8x8_blocks_wide_lookup[bsize];
302
303
304
  const int bh = num_8x8_blocks_high_lookup[bsize];
  const int x_mis = MIN(bw, cm->mi_cols - mi_col);
  const int y_mis = MIN(bh, cm->mi_rows - mi_row);
305
  const int offset = mi_row * cm->mi_stride + mi_col;
306
  int x, y;
307

308
309
310
  xd->mi = cm->mi_grid_visible + offset;
  xd->mi[0] = &cm->mi[offset];
  xd->mi[0]->mbmi.sb_type = bsize;
311
312
  for (y = 0; y < y_mis; ++y)
    for (x = !y; x < x_mis; ++x)
313
      xd->mi[y * cm->mi_stride + x] = xd->mi[0];
314

315
  set_skip_context(xd, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
316

317
318
  // 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
James Zern's avatar
James Zern committed
319
  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
320

321
  vp9_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col);
322
  return &xd->mi[0]->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
323
}
John Koleszar's avatar
John Koleszar committed
324

325
326
static void set_ref(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                    int idx, int mi_row, int mi_col) {
327
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
328
329
330
  RefBuffer *ref_buffer = &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME];
  xd->block_refs[idx] = ref_buffer;
  if (!vp9_is_valid_scale(&ref_buffer->sf))
331
332
    vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM,
                       "Invalid scale factors");
333
334
  vp9_setup_pre_planes(xd, idx, ref_buffer->buf, mi_row, mi_col,
                       &ref_buffer->sf);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
335
  xd->corrupted |= ref_buffer->buf->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
336
}
John Koleszar's avatar
John Koleszar committed
337

338
339
340
341
static void decode_block(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                         const TileInfo *const tile,
                         int mi_row, int mi_col,
                         vp9_reader *r, BLOCK_SIZE bsize) {
342
  const int less8x8 = bsize < BLOCK_8X8;
343
  MB_MODE_INFO *mbmi = set_offsets(cm, xd, tile, bsize, mi_row, mi_col);
James Zern's avatar
James Zern committed
344
  vp9_read_mode_info(cm, xd, tile, mi_row, mi_col, r);
345

346
  if (less8x8)
347
    bsize = BLOCK_8X8;
348

349
  if (mbmi->skip) {
350
    reset_skip_context(xd, bsize);
351
  } else {
352
353
354
355
    if (cm->seg.enabled)
      setup_plane_dequants(cm, xd, vp9_get_qindex(&cm->seg, mbmi->segment_id,
                                                  cm->base_qindex));
  }
356

357
  if (!is_inter_block(mbmi)) {
358
    struct intra_args arg = { cm, xd, r };
359
360
    vp9_foreach_transformed_block(xd, bsize,
                                  predict_and_reconstruct_intra_block, &arg);
361
362
  } else {
    // Setup
363
    set_ref(cm, xd, 0, mi_row, mi_col);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
364
    if (has_second_ref(mbmi))
365
      set_ref(cm, xd, 1, mi_row, mi_col);
366

367
    // Prediction
368
    vp9_dec_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
369

370
    // Reconstruction
371
    if (!mbmi->skip) {
372
      int eobtotal = 0;
373
      struct inter_args arg = { cm, xd, r, &eobtotal };
374
      vp9_foreach_transformed_block(xd, bsize, reconstruct_inter_block, &arg);
375
      if (!less8x8 && eobtotal == 0)
376
        mbmi->skip = 1;  // skip loopfilter
377
    }
378
  }
379

380
  xd->corrupted |= vp9_reader_has_error(r);
381
382
}

383
384
static PARTITION_TYPE read_partition(VP9_COMMON *cm, MACROBLOCKD *xd, int hbs,
                                     int mi_row, int mi_col, BLOCK_SIZE bsize,
385
                                     vp9_reader *r) {
386
  const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
387
388
389
390
  const vp9_prob *const probs = get_partition_probs(cm, ctx);
  const int has_rows = (mi_row + hbs) < cm->mi_rows;
  const int has_cols = (mi_col + hbs) < cm->mi_cols;
  PARTITION_TYPE p;
391
392

  if (has_rows && has_cols)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
393
    p = (PARTITION_TYPE)vp9_read_tree(r, vp9_partition_tree, probs);
394
  else if (!has_rows && has_cols)
395
    p = vp9_read(r, probs[1]) ? PARTITION_SPLIT : PARTITION_HORZ;
396
  else if (has_rows && !has_cols)
397
    p = vp9_read(r, probs[2]) ? PARTITION_SPLIT : PARTITION_VERT;
398
  else
399
400
401
402
403
404
    p = PARTITION_SPLIT;

  if (!cm->frame_parallel_decoding_mode)
    ++cm->counts.partition[ctx][p];

  return p;
405
406
}

407
408
409
410
static void decode_partition(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                             const TileInfo *const tile,
                             int mi_row, int mi_col,
                             vp9_reader* r, BLOCK_SIZE bsize) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
411
  const int hbs = num_8x8_blocks_wide_lookup[bsize] / 2;
412
  PARTITION_TYPE partition;
413
  BLOCK_SIZE subsize;
414

415
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
416
417
    return;

418
  partition = read_partition(cm, xd, hbs, mi_row, mi_col, bsize, r);
419
420
  subsize = get_subsize(bsize, partition);
  if (subsize < BLOCK_8X8) {
421
    decode_block(cm, xd, tile, mi_row, mi_col, r, subsize);
422
423
424
  } else {
    switch (partition) {
      case PARTITION_NONE:
425
        decode_block(cm, xd, tile, mi_row, mi_col, r, subsize);
426
427
        break;
      case PARTITION_HORZ:
428
        decode_block(cm, xd, tile, mi_row, mi_col, r, subsize);
429
        if (mi_row + hbs < cm->mi_rows)
430
          decode_block(cm, xd, tile, mi_row + hbs, mi_col, r, subsize);
431
432
        break;
      case PARTITION_VERT:
433
        decode_block(cm, xd, tile, mi_row, mi_col, r, subsize);
434
        if (mi_col + hbs < cm->mi_cols)
435
          decode_block(cm, xd, tile, mi_row, mi_col + hbs, r, subsize);
436
437
        break;
      case PARTITION_SPLIT:
438
439
440
441
        decode_partition(cm, xd, tile, mi_row,       mi_col,       r, subsize);
        decode_partition(cm, xd, tile, mi_row,       mi_col + hbs, r, subsize);
        decode_partition(cm, xd, tile, mi_row + hbs, mi_col,       r, subsize);
        decode_partition(cm, xd, tile, mi_row + hbs, mi_col + hbs, r, subsize);
442
443
        break;
      default:
James Zern's avatar
James Zern committed
444
        assert(0 && "Invalid partition type");
445
    }
446
  }
447

448
  // update partition context
449
  if (bsize >= BLOCK_8X8 &&
450
      (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
451
    update_partition_context(xd, mi_row, mi_col, subsize, bsize);
452
453
}

454
455
456
457
static void setup_token_decoder(const uint8_t *data,
                                const uint8_t *data_end,
                                size_t read_size,
                                struct vpx_internal_error_info *error_info,
458
459
460
                                vp9_reader *r,
                                vpx_decrypt_cb decrypt_cb,
                                void *decrypt_state) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
461
462
463
  // 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.
464
  if (!read_is_valid(data, read_size, data_end))
465
    vpx_internal_error(error_info, VPX_CODEC_CORRUPT_FRAME,
466
                       "Truncated packet or corrupt tile length");
John Koleszar's avatar
John Koleszar committed
467

468
  if (vp9_reader_init(r, data, read_size, decrypt_cb, decrypt_state))
469
    vpx_internal_error(error_info, VPX_CODEC_MEM_ERROR,
John Koleszar's avatar
John Koleszar committed
470
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
471
472
}

473
static void read_coef_probs_common(vp9_coeff_probs_model *coef_probs,
474
                                   vp9_reader *r) {
475
476
477
  int i, j, k, l, m;

  if (vp9_read_bit(r))
478
    for (i = 0; i < PLANE_TYPES; ++i)
479
480
481
482
483
      for (j = 0; j < REF_TYPES; ++j)
        for (k = 0; k < COEF_BANDS; ++k)
          for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
            for (m = 0; m < UNCONSTRAINED_NODES; ++m)
              vp9_diff_update_prob(r, &coef_probs[i][j][k][l][m]);
484
}
485

486
static void read_coef_probs(FRAME_CONTEXT *fc, TX_MODE tx_mode,
487
                            vp9_reader *r) {
Yaowu Xu's avatar
Yaowu Xu committed
488
489
490
491
    const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
    TX_SIZE tx_size;
    for (tx_size = TX_4X4; tx_size <= max_tx_size; ++tx_size)
      read_coef_probs_common(fc->coef_probs[tx_size], r);
492
493
}

494
495
static void setup_segmentation(struct segmentation *seg,
                               struct vp9_read_bit_buffer *rb) {
496
497
  int i, j;

498
499
  seg->update_map = 0;
  seg->update_data = 0;
500

501
502
  seg->enabled = vp9_rb_read_bit(rb);
  if (!seg->enabled)
503
504
505
    return;

  // Segmentation map update
506
507
  seg->update_map = vp9_rb_read_bit(rb);
  if (seg->update_map) {
Paul Wilkins's avatar
Paul Wilkins committed
508
    for (i = 0; i < SEG_TREE_PROBS; i++)
509
510
      seg->tree_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
                                               : MAX_PROB;
511

512
513
    seg->temporal_update = vp9_rb_read_bit(rb);
    if (seg->temporal_update) {
514
      for (i = 0; i < PREDICTION_PROBS; i++)
515
516
        seg->pred_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
                                                 : MAX_PROB;
517
518
    } else {
      for (i = 0; i < PREDICTION_PROBS; i++)
519
        seg->pred_probs[i] = MAX_PROB;
520
    }
521
  }
522

523
  // Segmentation data update
524
525
526
  seg->update_data = vp9_rb_read_bit(rb);
  if (seg->update_data) {
    seg->abs_delta = vp9_rb_read_bit(rb);
527

528
    vp9_clearall_segfeatures(seg);
529

Paul Wilkins's avatar
Paul Wilkins committed
530
    for (i = 0; i < MAX_SEGMENTS; i++) {
531
532
      for (j = 0; j < SEG_LVL_MAX; j++) {
        int data = 0;
533
        const int feature_enabled = vp9_rb_read_bit(rb);
534
        if (feature_enabled) {
535
          vp9_enable_segfeature(seg, i, j);
536
          data = decode_unsigned_max(rb, vp9_seg_feature_data_max(j));
537
          if (vp9_is_segfeature_signed(j))
538
            data = vp9_rb_read_bit(rb) ? -data : data;
539
        }
540
        vp9_set_segdata(seg, i, j, data);
541
542
543
544
545
      }
    }
  }
}

546
547
548
549
static void setup_loopfilter(struct loopfilter *lf,
                             struct vp9_read_bit_buffer *rb) {
  lf->filter_level = vp9_rb_read_literal(rb, 6);
  lf->sharpness_level = vp9_rb_read_literal(rb, 3);
550
551
552

  // Read in loop filter deltas applied at the MB level based on mode or ref
  // frame.
553
  lf->mode_ref_delta_update = 0;
554

555
556
557
558
  lf->mode_ref_delta_enabled = vp9_rb_read_bit(rb);
  if (lf->mode_ref_delta_enabled) {
    lf->mode_ref_delta_update = vp9_rb_read_bit(rb);
    if (lf->mode_ref_delta_update) {
559
560
      int i;

561
562
      for (i = 0; i < MAX_REF_LF_DELTAS; i++)
        if (vp9_rb_read_bit(rb))
563
          lf->ref_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
564

565
566
      for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
        if (vp9_rb_read_bit(rb))
567
          lf->mode_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
568
569
570
571
    }
  }
}

572
573
static int read_delta_q(struct vp9_read_bit_buffer *rb, int *delta_q) {
  const int old = *delta_q;
574
  *delta_q = vp9_rb_read_bit(rb) ? vp9_rb_read_signed_literal(rb, 4) : 0;
575
576
  return old != *delta_q;
}
577

578
579
static void setup_quantization(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                               struct vp9_read_bit_buffer *rb) {
580
  int update = 0;
581

582
583
584
585
586
587
  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);
588
589
590
591
592

  xd->lossless = cm->base_qindex == 0 &&
                 cm->y_dc_delta_q == 0 &&
                 cm->uv_dc_delta_q == 0 &&
                 cm->uv_ac_delta_q == 0;
593
594
}

595
596
597
598
599
static INTERP_FILTER read_interp_filter(struct vp9_read_bit_buffer *rb) {
  const INTERP_FILTER literal_to_filter[] = { EIGHTTAP_SMOOTH,
                                              EIGHTTAP,
                                              EIGHTTAP_SHARP,
                                              BILINEAR };
600
  return vp9_rb_read_bit(rb) ? SWITCHABLE
601
                             : literal_to_filter[vp9_rb_read_literal(rb, 2)];
602
603
}

604
static void read_frame_size(struct vp9_read_bit_buffer *rb,
605
                            int *width, int *height) {
606
607
  const int w = vp9_rb_read_literal(rb, 16) + 1;
  const int h = vp9_rb_read_literal(rb, 16) + 1;
608
609
  *width = w;
  *height = h;
610
611
}

612
static void setup_display_size(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
613
614
615
  cm->display_width = cm->width;
  cm->display_height = cm->height;
  if (vp9_rb_read_bit(rb))
616
    read_frame_size(rb, &cm->display_width, &cm->display_height);
617
}
618

619
static void apply_frame_size(VP9_COMMON *cm, int width, int height) {
620
  if (cm->width != width || cm->height != height) {
621
622
623
624
625
    // Change in frame size.
    // TODO(agrange) Don't test width/height, check overall size.
    if (width > cm->width || height > cm->height) {
      // Rescale frame buffers only if they're not big enough already.
      if (vp9_resize_frame_buffers(cm, width, height))
626
        vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
627
628
629
                           "Failed to allocate frame buffers");
    }

630
631
    cm->width = width;
    cm->height = height;
632

633
    vp9_update_frame_size(cm);
634
  }
635

636
637
638
639
640
641
642
643
  if (vp9_realloc_frame_buffer(
          get_frame_new_buffer(cm), cm->width, cm->height,
          cm->subsampling_x, cm->subsampling_y, VP9_DEC_BORDER_IN_PIXELS,
          &cm->frame_bufs[cm->new_fb_idx].raw_frame_buffer, cm->get_fb_cb,
          cm->cb_priv)) {
    vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate frame buffer");
  }
644
645
}

646
static void setup_frame_size(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
647
  int width, height;
648
  read_frame_size(rb, &width, &height);
649
650
  apply_frame_size(cm, width, height);
  setup_display_size(cm, rb);
651
652
}

653
static void setup_frame_size_with_refs(VP9_COMMON *cm,
654
655
656
                                       struct vp9_read_bit_buffer *rb) {
  int width, height;
  int found = 0, i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
657
  for (i = 0; i < REFS_PER_FRAME; ++i) {
658
    if (vp9_rb_read_bit(rb)) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
659
660
661
      YV12_BUFFER_CONFIG *const buf = cm->frame_refs[i].buf;
      width = buf->y_crop_width;
      height = buf->y_crop_height;
662
663
664
665
666
667
      found = 1;
      break;
    }
  }

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

670
671
672
673
674
675
676
677
678
679
680
  // Check that each of the frames that this frame references has valid
  // dimensions.
  for (i = 0; i < REFS_PER_FRAME; ++i) {
    RefBuffer *const ref_frame = &cm->frame_refs[i];
    const int ref_width = ref_frame->buf->y_width;
    const int ref_height = ref_frame->buf->y_height;

    if (!valid_ref_frame_size(ref_width, ref_height, width, height))
      vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                         "Referenced frame has invalid size");
  }
681

682
  apply_frame_size(cm, width, height);
683
  setup_display_size(cm, rb);
684
685
}

686
static void setup_tile_info(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
687
688
  int min_log2_tile_cols, max_log2_tile_cols, max_ones;
  vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
689

Dmitry Kovalev's avatar
Dmitry Kovalev committed
690
691
692
693
694
  // columns
  max_ones = max_log2_tile_cols - min_log2_tile_cols;
  cm->log2_tile_cols = min_log2_tile_cols;
  while (max_ones-- && vp9_rb_read_bit(rb))
    cm->log2_tile_cols++;
695

James Zern's avatar
James Zern committed
696
697
698
699
  if (cm->log2_tile_cols > 6)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid number of tile columns");

Dmitry Kovalev's avatar
Dmitry Kovalev committed
700
  // rows
701
702
703
704
705
  cm->log2_tile_rows = vp9_rb_read_bit(rb);
  if (cm->log2_tile_rows)
    cm->log2_tile_rows += vp9_rb_read_bit(rb);
}

706
707
708
709
710
711
typedef struct TileBuffer {
  const uint8_t *data;
  size_t size;
  int col;  // only used with multi-threaded decoding
} TileBuffer;

James Zern's avatar
James Zern committed
712
713
// Reads the next tile returning its size and adjusting '*data' accordingly
// based on 'is_last'.
714
715
716
717
718
719
static void get_tile_buffer(const uint8_t *const data_end,
                            int is_last,
                            struct vpx_internal_error_info *error_info,
                            const uint8_t **data,
                            vpx_decrypt_cb decrypt_cb, void *decrypt_state,
                            TileBuffer *buf) {
James Zern's avatar
James Zern committed
720
721
722
723
724
  size_t size;

  if (!is_last) {
    if (!read_is_valid(*data, 4, data_end))
      vpx_internal_error(error_info, VPX_CODEC_CORRUPT_FRAME,
Johann's avatar
Johann committed
725
                         "Truncated packet or corrupt tile length");
James Zern's avatar
James Zern committed
726

727
728
729
730
731
732
733
    if (decrypt_cb) {
      uint8_t be_data[4];
      decrypt_cb(decrypt_state, *data, be_data, 4);
      size = mem_get_be32(be_data);
    } else {
      size = mem_get_be32(*data);
    }
James Zern's avatar
James Zern committed
734
    *data += 4;
Johann's avatar
Johann committed
735

Johann's avatar
Johann committed
736
    if (size > (size_t)(data_end - *data))
Johann's avatar
Johann committed
737
738
      vpx_internal_error(error_info, VPX_CODEC_CORRUPT_FRAME,
                         "Truncated packet or corrupt tile size");
James Zern's avatar
James Zern committed
739
740
741
  } else {
    size = data_end - *data;
  }
742
743
744
745
746

  buf->data = *data;
  buf->size = size;

  *data += size;
James Zern's avatar
James Zern committed
747
748
}

749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
static void get_tile_buffers(VP9Decoder *pbi,
                             const uint8_t *data, const uint8_t *data_end,
                             int tile_cols, int tile_rows,
                             TileBuffer (*tile_buffers)[1 << 6]) {
  int r, c;

  for (r = 0; r < tile_rows; ++r) {
    for (c = 0; c < tile_cols; ++c) {
      const int is_last = (r == tile_rows - 1) && (c == tile_cols - 1);
      TileBuffer *const buf = &tile_buffers[r][c];
      buf->col = c;
      get_tile_buffer(data_end, is_last, &pbi->common.error, &data,
                      pbi->decrypt_cb, pbi->decrypt_state, buf);
    }
  }
}
765

766
static const uint8_t *decode_tiles(VP9Decoder *pbi,
767
                                   const uint8_t *data,
768
                                   const uint8_t *data_end) {
769
  VP9_COMMON *const cm = &pbi->common;
770
  const int aligned_cols = mi_cols_aligned_to_sb(cm->mi_cols);
771
772
  const int tile_cols = 1 << cm->log2_tile_cols;
  const int tile_rows = 1 << cm->log2_tile_rows;
773
  TileBuffer tile_buffers[4][1 << 6];
774
  int tile_row, tile_col;
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
  int mi_row, mi_col;
  TileData *tile_data = NULL;

  if (cm->lf.filter_level && pbi->lf_worker.data1 == NULL) {
    CHECK_MEM_ERROR(cm, pbi->lf_worker.data1,
                    vpx_memalign(32, sizeof(LFWorkerData)));
    pbi->lf_worker.hook = (VP9WorkerHook)vp9_loop_filter_worker;
    if (pbi->max_threads > 1 && !vp9_worker_reset(&pbi->lf_worker)) {
      vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
                         "Loop filter thread creation failed");
    }
  }

  if (cm->lf.filter_level) {
    LFWorkerData *const lf_data = (LFWorkerData*)pbi->lf_worker.data1;
    lf_data->frame_buffer = get_frame_new_buffer(cm);
    lf_data->cm = cm;
    vp9_copy(lf_data->planes, pbi->mb.plane);
    lf_data->stop = 0;
    lf_data->y_only = 0;
    vp9_loop_filter_frame_init(cm, cm->lf.filter_level);
  }
797

Yaowu Xu's avatar
Yaowu Xu committed
798
799
  assert(tile_rows <= 4);
  assert(tile_cols <= (1 << 6));
800

801
802
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
803
804
  vpx_memset(cm->above_context, 0,
             sizeof(*cm->above_context) * MAX_MB_PLANE * 2 * aligned_cols);
805

806
807
  vpx_memset(cm->above_seg_context, 0,
             sizeof(*cm->above_seg_context) * aligned_cols);
808

809
  get_tile_buffers(pbi, data, data_end, tile_cols, tile_rows, tile_buffers);
810

811
812
813
814
815
816
  if (pbi->tile_data == NULL ||
      (tile_cols * tile_rows) != pbi->total_tiles) {
    vpx_free(pbi->tile_data);
    CHECK_MEM_ERROR(
        cm,
        pbi->tile_data,
817
        vpx_memalign(32, tile_cols * tile_rows * (sizeof(*pbi->tile_data))));
818
819
820
821
    pbi->total_tiles = tile_rows * tile_cols;
  }

  // Load all tile information into tile_data.
822
823
824
  for (tile_row = 0; tile_row < tile_rows; ++tile_row) {
    for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
      TileInfo tile;
825
826
827
828
829
830
831
832
833
834
835
836
837
      const TileBuffer *const buf = &tile_buffers[tile_row][tile_col];
      tile_data = pbi->tile_data + tile_cols * tile_row + tile_col;
      tile_data->cm = cm;
      tile_data->xd = pbi->mb;
      tile_data->xd.corrupted = 0;
      vp9_tile_init(&tile, tile_data->cm, tile_row, tile_col);
      setup_token_decoder(buf->data, data_end, buf->size, &cm->error,
                          &tile_data->bit_reader, pbi->decrypt_cb,
                          pbi->decrypt_state);
      init_macroblockd(cm, &tile_data->xd);
      vp9_zero(tile_data->xd.dqcoeff);
    }
  }
838

839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
  for (tile_row = 0; tile_row < tile_rows; ++tile_row) {
    TileInfo tile;
    vp9_tile_set_row(&tile, cm, tile_row);
    for (mi_row = tile.mi_row_start; mi_row < tile.mi_row_end;
         mi_row += MI_BLOCK_SIZE) {
      for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
        const int col = pbi->i