vp9_decodframe.c 33.8 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
#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_pred_common.h"
23
#include "vp9/common/vp9_quant_common.h"
Dmitry Kovalev's avatar
Dmitry Kovalev committed
24
25
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
26
27
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_tile_common.h"
28
29

#include "vp9/decoder/vp9_dboolhuff.h"
30
31
32
#include "vp9/decoder/vp9_decodframe.h"
#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
33
#include "vp9/decoder/vp9_dsubexp.h"
34
35
#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
static int read_be32(const uint8_t *p) {
  return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
45
46
47
}

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

53
54
55
56
57
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;
}

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
static TXFM_MODE read_tx_mode(vp9_reader *r) {
  TXFM_MODE txfm_mode = vp9_read_literal(r, 2);
  if (txfm_mode == ALLOW_32X32)
    txfm_mode += vp9_read_bit(r);
  return txfm_mode;
}

static void read_tx_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
  int i, j;

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
    for (j = 0; j < TX_SIZE_MAX_SB - 3; ++j)
      if (vp9_read(r, VP9_MODE_UPDATE_PROB))
        vp9_diff_update_prob(r, &fc->tx_probs_8x8p[i][j]);

  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, &fc->tx_probs_16x16p[i][j]);

  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, &fc->tx_probs_32x32p[i][j]);
John Koleszar's avatar
John Koleszar committed
82
83
}

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

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

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

106
  TX_TYPE tx_type;
107

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

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

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

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

155
  if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0)
156
157
    extend_for_intra(xd, plane, block, bsize, ss_txfrm_size);

158
159
  plane_b_size = b_width_log2(bsize) - pd->subsampling_x;
  vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size, b_mode,
160
                          dst, pd->dst.stride,
161
                          dst, pd->dst.stride);
162

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

167
  decode_block(plane, block, bsize, ss_txfrm_size, arg);
168
169
}

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
173
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
174
    vp9_reset_sb_tokens_context(xd, bsize);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
175
    return -1;
176
  } else {
177
    if (xd->seg.enabled)
178
179
      mb_init_dequantizer(&pbi->common, xd);

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

185
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
186
                        int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
187
188
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
189
190
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
191
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
192
  int i;
193

194
  xd->mode_info_context = cm->mi + mi_idx;
195
  xd->mode_info_context->mbmi.sb_type = bsize;
196
197
  // Special case: if prev_mi is NULL, the previous mode info context
  // cannot be used.
198
  xd->prev_mode_info_context = cm->prev_mi ? cm->prev_mi + mi_idx : NULL;
199

200
  for (i = 0; i < MAX_MB_PLANE; i++) {
201
202
203
204
205
    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);
206
  }
207
208

  set_partition_seg_context(cm, xd, mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
209

210
211
  // 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
212
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
213

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

217
static void set_ref(VP9D_COMP *pbi, int i, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
218
219
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
220
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
221
  const int ref = mbmi->ref_frame[i] - 1;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
222

223
224
225
226
227
  const YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[cm->active_ref_idx[ref]];
  xd->scale_factor[i] = cm->active_ref_scale[ref];
  xd->scale_factor_uv[i] = cm->active_ref_scale[ref];
  setup_pre_planes(xd, i, cfg, mi_row, mi_col,
                   &xd->scale_factor[i], &xd->scale_factor_uv[i]);
228
  xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
229
}
John Koleszar's avatar
John Koleszar committed
230

231
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
232
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
233
  VP9_COMMON *const cm = &pbi->common;
234
  MACROBLOCKD *const xd = &pbi->mb;
235
236
  const int less8x8 = bsize < BLOCK_SIZE_SB8X8;
  MB_MODE_INFO *mbmi;
237

238
  if (less8x8)
239
240
    if (xd->ab_index > 0)
      return;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
241

242
  set_offsets(pbi, bsize, mi_row, mi_col);
243
  vp9_read_mode_info(pbi, mi_row, mi_col, r);
244

245
246
247
248
249
250
251
252
253
254
  if (less8x8)
    bsize = BLOCK_SIZE_SB8X8;

  // Has to be called after set_offsets
  mbmi = &xd->mode_info_context->mbmi;

  if (mbmi->ref_frame[0] == INTRA_FRAME) {
    // Intra reconstruction
    decode_tokens(pbi, bsize, r);
    foreach_transformed_block(xd, bsize, decode_block_intra, xd);
255
  } else {
256
257
    // Inter reconstruction
    int eobtotal;
258
259
260
261
262

    set_ref(pbi, 0, mi_row, mi_col);
    if (mbmi->ref_frame[1] > INTRA_FRAME)
      set_ref(pbi, 1, mi_row, mi_col);

263
264
265
266
267
268
269
270
271
    vp9_setup_interp_filters(xd, mbmi->interp_filter, cm);
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
    eobtotal = decode_tokens(pbi, bsize, r);
    if (less8x8) {
      if (eobtotal >= 0)
        foreach_transformed_block(xd, bsize, decode_block, xd);
    } else {
      assert(mbmi->sb_type == bsize);
      if (eobtotal == 0)
272
        vp9_set_pred_flag_mbskip(xd, bsize, 1);  // skip loopfilter
273
274
275
      else if (eobtotal > 0)
        foreach_transformed_block(xd, bsize, decode_block, xd);
    }
276
  }
277
  xd->corrupted |= vp9_reader_has_error(r);
278
279
}

280
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
281
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
282
283
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
284
  int bs = (1 << mi_width_log2(bsize)) / 2, n;
285
286
287
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

288
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
289
290
    return;

291
292
293
294
295
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
296
    int pl;
297
298
    const int idx = check_bsize_coverage(pc, xd, mi_row, mi_col, bsize);
    set_partition_seg_context(pc, xd, mi_row, mi_col);
299
    pl = partition_plane_context(xd, bsize);
300
301
302
303
304
305
306
307
308
309

    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;

310
    pc->fc.partition_counts[pl][partition]++;
311
312
  }

313
  subsize = get_subsize(bsize, partition);
314
  *(get_sb_index(xd, subsize)) = 0;
315

316
317
  switch (partition) {
    case PARTITION_NONE:
318
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
319
320
      break;
    case PARTITION_HORZ:
321
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
322
      *(get_sb_index(xd, subsize)) = 1;
323
      if (mi_row + bs < pc->mi_rows)
324
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
325
326
      break;
    case PARTITION_VERT:
327
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
328
      *(get_sb_index(xd, subsize)) = 1;
329
      if (mi_col + bs < pc->mi_cols)
330
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
331
332
333
334
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
335
        *(get_sb_index(xd, subsize)) = n;
336
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
337
338
339
340
341
      }
      break;
    default:
      assert(0);
  }
342
  // update partition context
343
344
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
345
346
347
    set_partition_seg_context(pc, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
348
349
}

350
static void setup_token_decoder(VP9D_COMP *pbi,
351
                                const uint8_t *data, size_t read_size,
352
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
353
  VP9_COMMON *pc = &pbi->common;
354
  const uint8_t *data_end = pbi->source + pbi->source_sz;
John Koleszar's avatar
John Koleszar committed
355

Dmitry Kovalev's avatar
Dmitry Kovalev committed
356
357
358
  // 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.
359
  if (!read_is_valid(data, read_size, data_end))
John Koleszar's avatar
John Koleszar committed
360
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
361
                       "Truncated packet or corrupt tile length");
John Koleszar's avatar
John Koleszar committed
362

363
  if (vp9_reader_init(r, data, read_size))
John Koleszar's avatar
John Koleszar committed
364
365
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
366
367
}

368
369
370
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];
371
372
373
374
375
376
377
378
379
380
381
  int i, j, k, l, m;

  if (vp9_read_bit(r))
    for (i = 0; i < BLOCK_TYPES; i++)
      for (j = 0; j < REF_TYPES; j++)
        for (k = 0; k < COEF_BANDS; k++)
          for (l = 0; l < PREV_COEF_CONTEXTS; l++)
            if (k > 0 || l < 3)
              for (m = 0; m < UNCONSTRAINED_NODES; m++)
                if (vp9_read(r, VP9_COEF_UPDATE_PROB))
                  vp9_diff_update_prob(r, &coef_probs[i][j][k][l][m]);
382
}
383

384
385
static void read_coef_probs(FRAME_CONTEXT *fc, TXFM_MODE txfm_mode,
                            vp9_reader *r) {
386
  read_coef_probs_common(fc, TX_4X4, r);
387

388
  if (txfm_mode > ONLY_4X4)
389
    read_coef_probs_common(fc, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
390

391
  if (txfm_mode > ALLOW_8X8)
392
    read_coef_probs_common(fc, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
393

394
  if (txfm_mode > ALLOW_16X16)
395
    read_coef_probs_common(fc, TX_32X32, r);
396
397
}

398
399
static void setup_segmentation(struct segmentation *seg,
                               struct vp9_read_bit_buffer *rb) {
400
401
  int i, j;

402
403
  seg->update_map = 0;
  seg->update_data = 0;
404

405
406
  seg->enabled = vp9_rb_read_bit(rb);
  if (!seg->enabled)
407
408
409
    return;

  // Segmentation map update
410
411
  seg->update_map = vp9_rb_read_bit(rb);
  if (seg->update_map) {
412
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
413
414
      seg->tree_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
                                               : MAX_PROB;
415

416
417
    seg->temporal_update = vp9_rb_read_bit(rb);
    if (seg->temporal_update) {
418
      for (i = 0; i < PREDICTION_PROBS; i++)
419
420
        seg->pred_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
                                                 : MAX_PROB;
421
422
    } else {
      for (i = 0; i < PREDICTION_PROBS; i++)
423
        seg->pred_probs[i] = MAX_PROB;
424
    }
425
  }
426

427
  // Segmentation data update
428
429
430
  seg->update_data = vp9_rb_read_bit(rb);
  if (seg->update_data) {
    seg->abs_delta = vp9_rb_read_bit(rb);
431

432
    vp9_clearall_segfeatures(seg);
433
434
435
436

    for (i = 0; i < MAX_MB_SEGMENTS; i++) {
      for (j = 0; j < SEG_LVL_MAX; j++) {
        int data = 0;
437
        const int feature_enabled = vp9_rb_read_bit(rb);
438
        if (feature_enabled) {
439
          vp9_enable_segfeature(seg, i, j);
440
          data = decode_unsigned_max(rb, vp9_seg_feature_data_max(j));
441
          if (vp9_is_segfeature_signed(j))
442
            data = vp9_rb_read_bit(rb) ? -data : data;
443
        }
444
        vp9_set_segdata(seg, i, j, data);
445
446
447
448
449
      }
    }
  }
}

450
451
452
453
454
455
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);
456
457
458
459
460

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

461
  xd->mode_ref_lf_delta_enabled = vp9_rb_read_bit(rb);
462
  if (xd->mode_ref_lf_delta_enabled) {
463
    xd->mode_ref_lf_delta_update = vp9_rb_read_bit(rb);
464
    if (xd->mode_ref_lf_delta_update) {
465
466
      int i;

467
468
469
      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);
470

471
472
473
      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);
474
475
476
477
    }
  }
}

478
479
static int read_delta_q(struct vp9_read_bit_buffer *rb, int *delta_q) {
  const int old = *delta_q;
480
481
  if (vp9_rb_read_bit(rb))
    *delta_q = vp9_rb_read_signed_literal(rb, 4);
482
483
  return old != *delta_q;
}
484

485
static void setup_quantization(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
486
  MACROBLOCKD *const xd = &pbi->mb;
487
488
  VP9_COMMON *const cm = &pbi->common;
  int update = 0;
489

490
491
492
493
494
495
  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);
496
497
498
499
500

  xd->lossless = cm->base_qindex == 0 &&
                 cm->y_dc_delta_q == 0 &&
                 cm->uv_dc_delta_q == 0 &&
                 cm->uv_ac_delta_q == 0;
501
502
503

  xd->itxm_add = xd->lossless ? vp9_idct_add_lossless_c
                              : vp9_idct_add;
504
505
}

506
507
508
509
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);
510
511
}

512
static void read_frame_size(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb,
513
                            int *width, int *height) {
514
515
  const int w = vp9_rb_read_literal(rb, 16) + 1;
  const int h = vp9_rb_read_literal(rb, 16) + 1;
516
517
  *width = w;
  *height = h;
518
519
}

520
static void setup_display_size(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
521
  VP9_COMMON *const cm = &pbi->common;
522
523
524
525
  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);
526
}
527

528
529
static void apply_frame_size(VP9D_COMP *pbi, int width, int height) {
  VP9_COMMON *cm = &pbi->common;
530

531
  if (cm->width != width || cm->height != height) {
532
    if (!pbi->initial_width || !pbi->initial_height) {
533
534
      if (vp9_alloc_frame_buffers(cm, width, height))
        vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
535
                           "Failed to allocate frame buffers");
536
537
      pbi->initial_width = width;
      pbi->initial_height = height;
538
539
    } else {
      if (width > pbi->initial_width)
540
        vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
541
                           "Frame width too large");
542

543
      if (height > pbi->initial_height)
544
        vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
545
                           "Frame height too large");
546
547
    }

548
549
    cm->width = width;
    cm->height = height;
550

551
    vp9_update_frame_size(cm);
552
  }
553

554
555
  vp9_realloc_frame_buffer(&cm->yv12_fb[cm->new_fb_idx], cm->width, cm->height,
                           cm->subsampling_x, cm->subsampling_y,
556
                           VP9BORDERINPIXELS);
557
558
}

559
560
561
562
563
564
565
566
567
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);
}

568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
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);

587
588
589
590
  if (!width || !height)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Referenced frame with invalid size");

591
592
593
594
  setup_display_size(pbi, rb);
  apply_frame_size(pbi, width, height);
}

595
static void update_frame_context(FRAME_CONTEXT *fc) {
596
  vp9_copy(fc->pre_coef_probs, fc->coef_probs);
597
  vp9_copy(fc->pre_y_mode_prob, fc->y_mode_prob);
598
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
599
  vp9_copy(fc->pre_partition_prob, fc->partition_prob[1]);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
600
601
602
603
  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);
604
  fc->pre_nmvc = fc->nmvc;
605
606
  vp9_copy(fc->pre_switchable_interp_prob, fc->switchable_interp_prob);
  vp9_copy(fc->pre_inter_mode_probs, fc->inter_mode_probs);
607
608
609
  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
610
  vp9_copy(fc->pre_mbskip_probs, fc->mbskip_probs);
611

612
  vp9_zero(fc->coef_counts);
613
  vp9_zero(fc->eob_branch_counts);
614
  vp9_zero(fc->y_mode_counts);
615
616
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->NMVcount);
617
  vp9_zero(fc->inter_mode_counts);
618
  vp9_zero(fc->partition_counts);
619
  vp9_zero(fc->switchable_interp_count);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
620
621
622
623
  vp9_zero(fc->intra_inter_count);
  vp9_zero(fc->comp_inter_count);
  vp9_zero(fc->single_ref_count);
  vp9_zero(fc->comp_ref_count);
624
625
626
  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
627
  vp9_zero(fc->mbskip_count);
628
}
629

630
631
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
632
  int mi_row, mi_col;
633

634
635
  for (mi_row = pc->cur_tile_mi_row_start; mi_row < pc->cur_tile_mi_row_end;
       mi_row += MI_BLOCK_SIZE) {
636
    // For a SB there are 2 left contexts, each pertaining to a MB row within
637
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
638
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
639
640
    for (mi_col = pc->cur_tile_mi_col_start; mi_col < pc->cur_tile_mi_col_end;
         mi_col += MI_BLOCK_SIZE)
641
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
642
643
644
  }
}

645
646
static void setup_tile_info(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
  int delta_log2_tiles;
647

648
  vp9_get_tile_n_bits(cm, &cm->log2_tile_columns, &delta_log2_tiles);
649
  while (delta_log2_tiles--) {
650
651
    if (vp9_rb_read_bit(rb)) {
      cm->log2_tile_columns++;
652
653
654
655
    } else {
      break;
    }
  }
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670

  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;
671
672
  const uint8_t *const data_end = pbi->source + pbi->source_sz;
  const int aligned_mi_cols = mi_cols_aligned_to_sb(pc->mi_cols);
673
  int tile_row, tile_col;
674

675
676
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
677
678
  vpx_memset(pc->above_context[0], 0,
             sizeof(ENTROPY_CONTEXT) * 2 * MAX_MB_PLANE * aligned_mi_cols);
679

680
681
  vpx_memset(pc->above_seg_context, 0,
             sizeof(PARTITION_CONTEXT) * aligned_mi_cols);
682
683
684
685

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
686
    vp9_reader bc_bak = {0};
687
688
689
690
691

    // 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) {
692
        const int size = read_be32(data_ptr2[tile_row - 1][n_cols - 1]);
693
694
695
696
697
        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++) {
698
        const int size = read_be32(data_ptr2[tile_row][tile_col - 1]);
699
700
701
702
703
704
705
706
707
708
        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);
709
710
711
        setup_token_decoder(pbi, data_ptr2[tile_row][tile_col],
                            data_end - data_ptr2[tile_row][tile_col],
                            residual_bc);
712
        decode_tile(pbi, residual_bc);
713
714
715
716
717
718
719
720
721
722
723
        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++) {
724
725
        size_t size;

726
727
728
729
730
        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) {
731
732
733
734
735
736
737
738
          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;
739
        }
740
741
742
743

        setup_token_decoder(pbi, data_ptr, size, residual_bc);
        decode_tile(pbi, residual_bc);
        data_ptr += size;
744
745
746
747
748
      }
    }
  }
}

749
750
751
752
753
754
755
756
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
757

Frank Galligan's avatar
Frank Galligan committed
758
static void error_handler(void *data, size_t bit_offset) {
759
760
761
762
  VP9_COMMON *const cm = (VP9_COMMON *)data;
  vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet");
}

763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
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;
    }
  }
}

792
793
794
795
796
#define RESERVED \
  if (vp9_rb_read_bit(rb)) \
      vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM, \
                         "Reserved bit must be unset")

797
798
static size_t read_uncompressed_header(VP9D_COMP *pbi,
                                       struct vp9_read_bit_buffer *rb) {
799
  VP9_COMMON *const cm = &pbi->common;
800
  MACROBLOCKD *const xd = &pbi->mb;
801
  int i;
802
803

  cm->last_frame_type = cm->frame_type;
804

805
806
807
808
809
810
811
  if (vp9_rb_read_literal(rb, 2) != 0x2)
      vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM,
                         "Invalid frame marker");

  cm->version = vp9_rb_read_bit(rb);
  RESERVED;

812
813
814
815
816
817
818
819
  if (vp9_rb_read_bit(rb)) {
    // show an existing frame directly
    int frame_to_show = cm->ref_frame_map[vp9_rb_read_literal(rb, 3)];
    ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->new_fb_idx, frame_to_show);
    pbi->refresh_frame_flags = 0;
    cm->filter_level = 0;
    return 0;
  }
820

821
822
  cm->frame_type = (FRAME_TYPE) vp9_rb_read_bit(rb);
  cm->show_frame = vp9_rb_read_bit(rb);
823
  cm->error_resilient_mode = vp9_rb_read_bit(rb);
824
825

  if (cm->frame_type == KEY_FRAME) {
826
827
    int csp;

828
    check_sync_code(cm, rb);
829

830
831
832
833
834
835
836
837
838
839
    csp = vp9_rb_read_literal(rb, 3);  // colorspace
    if (csp != 7) {  // != sRGB
      vp9_rb_read_bit(rb);  // [16,235] (including xvycc) vs [0,255] range
      if (cm->version == 1) {
        cm->subsampling_x = vp9_rb_read_bit(rb);
        cm->subsampling_y = vp9_rb_read_bit(rb);
        vp9_rb_read_bit(rb);  // has extra plane
      } else {
        cm->subsampling_y = cm->subsampling_x = 1;
      }
840
    } else {
841
842
843
844
845
846
847
      if (cm->version == 1) {
        cm->subsampling_y = cm->subsampling_x = 0;
        vp9_rb_read_bit(rb);  // has extra plane
      } else {
        vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM,
                           "RGB not supported in profile 0");
      }
848
    }
John Koleszar's avatar
John Koleszar committed
849

850
851
852
853
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;

    for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i)
      cm->active_ref_idx[i] = cm->new_fb_idx;
854
855

    setup_frame_size(pbi, rb);
856
  } else {
857
858
    cm->intra_only = cm->show_frame ? 0 : vp9_rb_read_bit(rb);

Adrian Grange's avatar
Adrian Grange committed
859
860
    cm->reset_frame_context = cm->error_resilient_mode ?
        0 : vp9_rb_read_literal(rb, 2);
861

862
    if (cm->intra_only) {
863
      check_sync_code(cm, rb);
Adrian Grange's avatar
Adrian Grange committed
864

865
866
      pbi->refresh_frame_flags = vp9_rb_read_literal(rb, NUM_REF_FRAMES);
      setup_frame_size(pbi, rb);
867
868
    } else {
       pbi->refresh_frame_flags = vp9_rb_read_literal(rb, NUM_REF_FRAMES);
869

870
871
872
873
874
      for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) {
        const int ref = vp9_rb_read_literal(rb, NUM_REF_FRAMES_LG2);
        cm->active_ref_idx[i] = cm->ref_frame_map[ref];
        cm->ref_frame_sign_bias[LAST_FRAME + i] = vp9_rb_read_bit(rb);
      }
875

876
      setup_frame_size_with_refs(pbi, rb);
877

878
879
      xd->allow_high_precision_mv = vp9_rb_read_bit(rb);
      cm->mcomp_filter_type = read_interp_filter_type(rb);
880
881
882
883
884

      for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i)
        vp9_setup_scale_factors(cm, i);

      setup_inter_inter(cm);
885
    }
886
887
  }