vp9_decodframe.c 38.9 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9
10
 */

11
#include <assert.h>
John Koleszar's avatar
John Koleszar committed
12

13
#include "vp9/decoder/vp9_onyxd_int.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
14
#include "vp9/common/vp9_common.h"
15
16
17
#include "vp9/common/vp9_header.h"
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
Yaowu Xu's avatar
Yaowu Xu committed
18
#include "vp9/common/vp9_entropy.h"
19
#include "vp9/decoder/vp9_decodframe.h"
20
#include "vp9/decoder/vp9_detokenize.h"
21
22
23
24
#include "vp9/common/vp9_invtrans.h"
#include "vp9/common/vp9_alloccommon.h"
#include "vp9/common/vp9_entropymode.h"
#include "vp9/common/vp9_quant_common.h"
Johann's avatar
Johann committed
25
#include "vpx_scale/vpx_scale.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
26

27
#include "vp9/decoder/vp9_decodemv.h"
28
29
#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
John Koleszar's avatar
John Koleszar committed
30
#include "vpx_mem/vpx_mem.h"
31
#include "vp9/decoder/vp9_dboolhuff.h"
John Koleszar's avatar
John Koleszar committed
32

33
#include "vp9/common/vp9_seg_common.h"
34
#include "vp9/common/vp9_tile_common.h"
35
#include "vp9_rtcd.h"
36

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

42
43
44
45
46
47
48
49
50
static int read_le16(const uint8_t *p) {
  return (p[1] << 8) | p[0];
}

static int read_le32(const uint8_t *p) {
  return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
}

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

56
57
58
59
60
61
62
63
64
65
66
67
68
69
static void setup_txfm_mode(VP9_COMMON *pc, int lossless, vp9_reader *r) {
  if (lossless) {
    pc->txfm_mode = ONLY_4X4;
  } else {
    pc->txfm_mode = vp9_read_literal(r, 2);
    if (pc->txfm_mode == ALLOW_32X32)
      pc->txfm_mode += vp9_read_bit(r);

    if (pc->txfm_mode == TX_MODE_SELECT) {
      pc->prob_tx[0] = vp9_read_prob(r);
      pc->prob_tx[1] = vp9_read_prob(r);
      pc->prob_tx[2] = vp9_read_prob(r);
    }
  }
70
71
}

72
73
74
75
76
77
78
79
80
81
82
83
84
static int get_unsigned_bits(unsigned int num_values) {
  int cat = 0;
  if (num_values <= 1)
    return 0;
  num_values--;
  while (num_values > 0) {
    cat++;
    num_values >>= 1;
  }
  return cat;
}

static int inv_recenter_nonneg(int v, int m) {
85
  if (v > 2 * m)
86
    return v;
87
88

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

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

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

102
static int decode_term_subexp(vp9_reader *r, int k, int num_syms) {
103
104
105
106
107
  int i = 0, mk = 0, word;
  while (1) {
    const int b = i ? k + i - 1 : k;
    const int a = 1 << b;
    if (num_syms <= mk + 3 * a) {
108
      word = decode_uniform(r, num_syms - mk) + mk;
109
110
      break;
    } else {
111
      if (vp9_read_bit(r)) {
112
113
114
        i++;
        mk += a;
      } else {
115
        word = vp9_read_literal(r, b) + mk;
116
117
118
119
120
121
122
        break;
      }
    }
  }
  return word;
}

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

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

John Koleszar's avatar
John Koleszar committed
133
134
static int merge_index(int v, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
135
136
137
  if (v < max1) {
    v = v * modulus + modulus / 2;
  } else {
John Koleszar's avatar
John Koleszar committed
138
139
140
141
142
143
144
145
    int w;
    v -= max1;
    w = v;
    v += (v + modulus - modulus / 2) / modulus;
    while (v % modulus == modulus / 2 ||
           w != v - (v + modulus - modulus / 2) / modulus) v++;
  }
  return v;
146
147
}

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

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

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
167
  for (q = 0; q < QINDEX_RANGE; q++) {
168
    // DC value
169
170
    pc->y_dequant[q][0] = vp9_dc_quant(q, pc->y_dc_delta_q);
    pc->uv_dequant[q][0] = vp9_dc_quant(q, pc->uv_dc_delta_q);
John Koleszar's avatar
John Koleszar committed
171

172
    // AC values
173
174
    pc->y_dequant[q][1] = vp9_ac_quant(q, 0);
    pc->uv_dequant[q][1] = vp9_ac_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
175
  }
John Koleszar's avatar
John Koleszar committed
176
177
}

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

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

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

203
204
205
206
207
208
209
210
211
212
213
static void decode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
                         int ss_txfrm_size, void *arg) {
  MACROBLOCKD* const xd = arg;
  int16_t* const qcoeff = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16);
  const int stride = xd->plane[plane].dst.stride;
  const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
                                                       block, ss_txfrm_size);
  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
                                                 raster_block,
                                                 xd->plane[plane].dst.buf,
                                                 stride);
214

215
  TX_TYPE tx_type;
216

217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
  switch (ss_txfrm_size / 2) {
    case TX_4X4:
      tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
      if (tx_type == DCT_DCT)
        xd->itxm_add(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      else
        vp9_iht_add_c(tx_type, qcoeff, dst, stride,
                      xd->plane[plane].eobs[block]);
      break;
    case TX_8X8:
      tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride,
                        xd->plane[plane].eobs[block]);
      break;
    case TX_16X16:
      tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride,
                          xd->plane[plane].eobs[block]);
      break;
    case TX_32X32:
      vp9_idct_add_32x32(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      break;
239
240
241
  }
}

242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
static void decode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
                               int ss_txfrm_size, void *arg) {
  MACROBLOCKD* const xd = arg;
  int16_t* const qcoeff = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16);
  const int stride = xd->plane[plane].dst.stride;
  const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
                                                       block, ss_txfrm_size);
  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
                                                 raster_block,
                                                 xd->plane[plane].dst.buf,
                                                 stride);
  const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
  TX_TYPE tx_type;
  int mode, b_mode;
  int plane_b_size;
  int tx_ib = raster_block >> tx_size;
  mode = plane == 0? xd->mode_info_context->mbmi.mode:
                     xd->mode_info_context->mbmi.uv_mode;

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

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

  switch (ss_txfrm_size / 2) {
    case TX_4X4:
      tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
      if (tx_type == DCT_DCT)
        xd->itxm_add(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      else
        vp9_iht_add_c(tx_type, qcoeff, dst, stride,
                      xd->plane[plane].eobs[block]);
      break;
    case TX_8X8:
      tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride,
                        xd->plane[plane].eobs[block]);
      break;
    case TX_16X16:
      tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride,
                          xd->plane[plane].eobs[block]);
      break;
    case TX_32X32:
      vp9_idct_add_32x32(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      break;
  }
}

295
296
297
298
299
300
301
302
303
304
static void decode_atom_intra(VP9D_COMP *pbi, MACROBLOCKD *xd,
                              vp9_reader *r,
                              BLOCK_SIZE_TYPE bsize) {
  int i = 0;
  int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
  int bc = 1 << (bwl + bhl);
  int tx_type;

  for (i = 0; i < bc; i++) {
    int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
305
306
307
308

    uint8_t* dst = raster_block_offset_uint8(xd, bsize, 0, i,
                                             xd->plane[0].dst.buf,
                                             xd->plane[0].dst.stride);
309

310
    vp9_intra4x4_predict(xd, i, bsize, b_mode, dst, xd->plane[0].dst.stride);
311
312
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
313
    dequant_add_y(xd, tx_type, i, bsize);
314
  }
315

316
317
318
  foreach_transformed_block_uv(xd, bsize, decode_block, xd);
}

319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
static void decode_atom(VP9D_COMP *pbi, MACROBLOCKD *xd,
                        int mi_row, int mi_col,
                        vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;

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

  // prediction
  if (mbmi->ref_frame == INTRA_FRAME)
    vp9_build_intra_predictors_sbuv_s(xd, bsize);
  else
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);

  if (mbmi->mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
  } else {
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(&pbi->common, xd);

    if (!vp9_reader_has_error(r)) {
      vp9_decode_tokens(pbi, xd, r, bsize);
    }
  }

  if (mbmi->ref_frame == INTRA_FRAME)
    decode_atom_intra(pbi, xd, r, bsize);
  else
    foreach_transformed_block(xd, bsize, decode_block, xd);
}

351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
static void decode_sb_intra(VP9D_COMP *pbi, MACROBLOCKD *xd,
                          int mi_row, int mi_col,
                          vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
  if (mbmi->mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
  } else {
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(&pbi->common, xd);

    if (!vp9_reader_has_error(r)) {
      vp9_decode_tokens(pbi, xd, r, bsize);
    }
  }

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


371
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
372
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
373
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
374
  const int bw = 1 << bwl, bh = 1 << bhl;
375
  int n, eobtotal;
376
  VP9_COMMON *const pc = &pbi->common;
377
378
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
379
  const int mis = pc->mode_info_stride;
380

381
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
382
383

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

386
  // generate prediction
387
  if (mbmi->ref_frame == INTRA_FRAME) {
388
389
    vp9_build_intra_predictors_sby_s(xd, bsize);
    vp9_build_intra_predictors_sbuv_s(xd, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
390
  } else {
391
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
392
393
  }

394
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
395
    vp9_reset_sb_tokens_context(xd, bsize);
396
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
397
398
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
399
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
400
401

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

407
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
408
409
410
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
411
      foreach_transformed_block(xd, bsize, decode_block, xd);
412
    }
413
  }
414
415
}

416
417
418
419
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
420
421
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
422
  }
John Koleszar's avatar
John Koleszar committed
423

424
  // Trigger a quantizer update if the delta-q value has changed
425
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
426
427
}

428
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
429
430
431
                        int mi_row, int mi_col) {
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
432
433
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
434
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
435
  int i;
436

437
  xd->mode_info_context = cm->mi + mi_idx;
438
  xd->mode_info_context->mbmi.sb_type = bsize;
439
440
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

441
442
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
443
        (mi_col * 2 >> xd->plane[i].subsampling_x);
444
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
445
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
446
  }
447
448
  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
449

450
451
  // 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
452
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
453

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

457
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
458
459
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
460
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
461
462

  if (mbmi->ref_frame > INTRA_FRAME) {
463
    // Select the appropriate reference frame for this MB
464
465
466
    const int fb_idx = cm->active_ref_idx[mbmi->ref_frame - 1];
    const YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[fb_idx];
    xd->scale_factor[0]    = cm->active_ref_scale[mbmi->ref_frame - 1];
467
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
468
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
469
                     xd->scale_factor, xd->scale_factor_uv);
470
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
471

Ronald S. Bultje's avatar
Ronald S. Bultje committed
472
    if (mbmi->second_ref_frame > INTRA_FRAME) {
473
      // Select the appropriate reference frame for this MB
474
475
      const int second_fb_idx = cm->active_ref_idx[mbmi->second_ref_frame - 1];
      const YV12_BUFFER_CONFIG *second_cfg = &cm->yv12_fb[second_fb_idx];
Yunqing Wang's avatar
Yunqing Wang committed
476
477
      xd->scale_factor[1]    = cm->active_ref_scale[mbmi->second_ref_frame - 1];
      xd->scale_factor_uv[1] = cm->active_ref_scale[mbmi->second_ref_frame - 1];
478
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
479
                       xd->scale_factor, xd->scale_factor_uv);
480
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
481
482
483
    }
  }
}
John Koleszar's avatar
John Koleszar committed
484

485
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
486
487
488
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

489
490
491
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
492
493
494
  set_offsets(pbi, bsize, mi_row, mi_col);
  vp9_decode_mb_mode_mv(pbi, xd, mi_row, mi_col, r);
  set_refs(pbi, mi_row, mi_col);
495

496
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
497
498
    decode_sb_intra(pbi, xd, mi_row, mi_col, r, (bsize < BLOCK_SIZE_SB8X8) ?
                                     BLOCK_SIZE_SB8X8 : bsize);
499
  else if (bsize < BLOCK_SIZE_SB8X8)
500
    decode_atom(pbi, xd, mi_row, mi_col, r, BLOCK_SIZE_SB8X8);
501
  else
502
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
503

504
  xd->corrupted |= vp9_reader_has_error(r);
505
506
}

507
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
508
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
509
510
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
511
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
512
513
514
515
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

516
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
517
518
    return;

519
520
521
522
523
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
524
    int pl;
525
    // read the partition information
526
527
    xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = pc->above_seg_context + mi_col;
528
    pl = partition_plane_context(xd, bsize);
529
    partition = treed_read(r, vp9_partition_tree,
530
531
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
532
533
  }

534
  subsize = get_subsize(bsize, partition);
535
  *(get_sb_index(xd, subsize)) = 0;
536

537
538
  switch (partition) {
    case PARTITION_NONE:
539
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
540
541
      break;
    case PARTITION_HORZ:
542
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
543
      *(get_sb_index(xd, subsize)) = 1;
544
      if (mi_row + bs < pc->mi_rows)
545
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
546
547
      break;
    case PARTITION_VERT:
548
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
549
      *(get_sb_index(xd, subsize)) = 1;
550
      if (mi_col + bs < pc->mi_cols)
551
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
552
553
554
555
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
556
        *(get_sb_index(xd, subsize)) = n;
557
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
558
559
560
561
562
      }
      break;
    default:
      assert(0);
  }
563
  // update partition context
564
565
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
566
567
568
    set_partition_seg_context(pc, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
569
570
}

571
static void setup_token_decoder(VP9D_COMP *pbi,
572
573
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
574
  VP9_COMMON *pc = &pbi->common;
575
576
  const uint8_t *data_end = pbi->source + pbi->source_sz;
  const size_t partition_size = data_end - data;
John Koleszar's avatar
John Koleszar committed
577

Dmitry Kovalev's avatar
Dmitry Kovalev committed
578
579
580
  // 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.
581
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
582
583
584
585
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

586
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
587
588
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
589
590
}

591
592
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
593
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
594

John Koleszar's avatar
John Koleszar committed
595
  if (pc->frame_type == KEY_FRAME) {
596
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
597
    // All buffers are implicitly updated on key frames.
598
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
599
600
601
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
602

John Koleszar's avatar
John Koleszar committed
603
  xd->mode_info_context = pc->mi;
604
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
605
606
607
  xd->frame_type = pc->frame_type;
  xd->mode_info_context->mbmi.mode = DC_PRED;
  xd->mode_info_stride = pc->mode_info_stride;
John Koleszar's avatar
John Koleszar committed
608
609
}

610
611
612
613
614
static void read_coef_probs_common(
    vp9_coeff_probs_model *coef_probs,
    TX_SIZE tx_size,
    vp9_reader *r) {
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
615

616
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
617

618
  if (vp9_read_bit(r)) {
619
    for (i = 0; i < BLOCK_TYPES; i++) {
620
621
622
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
623
            const int mstart = 0;
624
625
            if (l >= 3 && k == 0)
              continue;
626
627

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

630
631
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
632
              }
633
634
635
            }
          }
        }
636
637
      }
    }
638
  }
639
}
640

641
642
643
static void read_coef_probs(VP9D_COMP *pbi, vp9_reader *r) {
  const TXFM_MODE mode = pbi->common.txfm_mode;
  FRAME_CONTEXT *const fc = &pbi->common.fc;
Daniel Kang's avatar
Daniel Kang committed
644

645
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
646

647
  if (mode > ONLY_4X4)
648
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
649

650
  if (mode > ALLOW_8X8)
651
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
652

653
  if (mode > ALLOW_16X16)
654
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
655
656
}

657
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
658
659
  int i, j;

660
661
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
662
663
664
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
665

666
  xd->segmentation_enabled = vp9_read_bit(r);
667
668
669
670
671
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
672
673
674
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
675
  if (xd->update_mb_segmentation_map) {
676
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
677
678
679
680
681
682
683
684
685
686
687
      xd->mb_segment_tree_probs[i] = vp9_read_bit(r) ? vp9_read_prob(r)
                                                     : MAX_PROB;

    pc->temporal_update = vp9_read_bit(r);
    if (pc->temporal_update) {
      for (i = 0; i < PREDICTION_PROBS; i++)
        pc->segment_pred_probs[i] = vp9_read_bit(r) ? vp9_read_prob(r)
                                                    : MAX_PROB;
    } else {
      for (i = 0; i < PREDICTION_PROBS; i++)
        pc->segment_pred_probs[i] = MAX_PROB;
688
    }
689
  }
690

691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
  // Segmentation data update
  xd->update_mb_segmentation_data = vp9_read_bit(r);
  if (xd->update_mb_segmentation_data) {
    xd->mb_segment_abs_delta = vp9_read_bit(r);

    vp9_clearall_segfeatures(xd);

    for (i = 0; i < MAX_MB_SEGMENTS; i++) {
      for (j = 0; j < SEG_LVL_MAX; j++) {
        int data = 0;
        const int feature_enabled = vp9_read_bit(r);
        if (feature_enabled) {
          vp9_enable_segfeature(xd, i, j);
          data = decode_unsigned_max(r, vp9_seg_feature_data_max(j));
          if (vp9_is_segfeature_signed(j))
            data = vp9_read_and_apply_sign(r, data);
707
        }
708
        vp9_set_segdata(xd, i, j, data);
709
710
711
712
713
      }
    }
  }
}

714
715
716
717
718
static void setup_pred_probs(VP9_COMMON *pc, vp9_reader *r) {
  // Read common prediction model status flag probability updates for the
  // reference frame
  if (pc->frame_type == KEY_FRAME) {
    // Set the prediction probabilities to defaults
719
720
721
    pc->ref_pred_probs[0] = DEFAULT_PRED_PROB_0;
    pc->ref_pred_probs[1] = DEFAULT_PRED_PROB_1;
    pc->ref_pred_probs[2] = DEFAULT_PRED_PROB_2;
722
723
724
725
726
727
728
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
729

730
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
731
732
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
733
734

#if CONFIG_LOOP_DERING
735
736
  if (vp9_read_bit(r))
    pc->dering_enabled = 1 + vp9_read_literal(r, 4);
737
738
739
740
741
742
743
744
  else
    pc->dering_enabled = 0;
#endif

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

745
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
746
  if (xd->mode_ref_lf_delta_enabled) {
747
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
748
    if (xd->mode_ref_lf_delta_update) {
749
750
      int i;

751
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
752
        if (vp9_read_bit(r)) {
753
754
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
755
756
757
758
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
759
        if (vp9_read_bit(r)) {
760
761
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
762
763
764
765
766
767
        }
      }
    }
  }
}

768
769
770
771
772
static void setup_quantization(VP9D_COMP *pbi, vp9_reader *r) {
  // Read the default quantizers
  VP9_COMMON *const pc = &pbi->common;

  pc->base_qindex = vp9_read_literal(r, QINDEX_BITS);
773
774
775
  if (get_delta_q(r, &pc->y_dc_delta_q) |
      get_delta_q(r, &pc->uv_dc_delta_q) |
      get_delta_q(r, &pc->uv_ac_delta_q))
776
    vp9_init_dequantizer(pc);
777

778
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
779
780
}

781
782
783
784
785
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

786
787
788
789
static const uint8_t *read_frame_size(VP9_COMMON *const pc, const uint8_t *data,
                                      const uint8_t *data_end,
                                      int *width, int *height) {
  if (data + 4 < data_end) {
790
791
792
793
794
795
796
797
798
799
800
    const int w = read_le16(data);
    const int h = read_le16(data + 2);
    if (w <= 0)
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Invalid frame width");

    if (h <= 0)
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Invalid frame height");
    *width = w;
    *height = h;
801
802
803
804
805
806
807
808
    data += 4;
  } else {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Failed to read frame size");
  }
  return data;
}

809
static const uint8_t *setup_frame_size(VP9D_COMP *pbi, int scaling_active,
810
811
                                       const uint8_t *data,
                                       const uint8_t *data_end) {
812
813
  // If error concealment is enabled we should only parse the new size
  // if we have enough data. Otherwise we will end up with the wrong size.
814
815
816
817
818
  VP9_COMMON *const pc = &pbi->common;
  int display_width = pc->display_width;
  int display_height = pc->display_height;
  int width = pc->width;
  int height = pc->height;
819

820
821
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
822

823
  data = read_frame_size(pc, data, data_end, &width, &height);
824

825
  if (pc->width != width || pc->height != height) {
826
    if (!pbi->initial_width || !pbi->initial_height) {
827
      if (vp9_alloc_frame_buffers(pc, width, height))
828
829
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
830
831
832
833
834
835
        pbi->initial_width = width;
        pbi->initial_height = height;
    } else {
      if (width > pbi->initial_width)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame width too large");
836

837
838
839
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
840
841
    }

842
843
844
845
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
846

847
    vp9_update_frame_size(pc);
848
849
850
851
852
  }

  return data;
}

853
static void update_frame_context(FRAME_CONTEXT *fc) {
854
855
856
857
858
859
860
861
862
  vp9_copy(fc->pre_coef_probs_4x4, fc->coef_probs_4x4);
  vp9_copy(fc->pre_coef_probs_8x8, fc->coef_probs_8x8);
  vp9_copy(fc->pre_coef_probs_16x16, fc->coef_probs_16x16);
  vp9_copy(fc->pre_coef_probs_32x32, fc->coef_probs_32x32);
  vp9_copy(fc->pre_ymode_prob, fc->ymode_prob);
  vp9_copy(fc->pre_sb_ymode_prob, fc->sb_ymode_prob);
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
  vp9_copy(fc->pre_bmode_prob, fc->bmode_prob);
  vp9_copy(fc->pre_sub_mv_ref_prob, fc->sub_mv_ref_prob);
863
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
864
865
866
867
868
869
870
871
872
873
874
875
876
877
  fc->pre_nmvc = fc->nmvc;

  vp9_zero(fc->coef_counts_4x4);
  vp9_zero(fc->coef_counts_8x8);
  vp9_zero(fc->coef_counts_16x16);
  vp9_zero(fc->coef_counts_32x32);
  vp9_zero(fc->eob_branch_counts);
  vp9_zero(fc->ymode_counts);
  vp9_zero(fc->sb_ymode_counts);
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->bmode_counts);
  vp9_zero(fc->sub_mv_ref_counts);
  vp9_zero(fc->NMVcount);
  vp9_zero(fc->mv_ref_ct);
878
  vp9_zero(fc->partition_counts);
879
}
880

881
882
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
883
  int mi_row, mi_col;
884

885
  for (mi_row = pc->cur_tile_mi_row_start;
886
       mi_row < pc->cur_tile_mi_row_end; mi_row += 64 / MI_SIZE) {
887
    // For a SB there are 2 left contexts, each pertaining to a MB row within
888
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
889
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
890
    for (mi_col = pc->cur_tile_mi_col_start;
891
         mi_col < pc->cur_tile_mi_col_end; mi_col += 64 / MI_SIZE)
892
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
893
894
895
  }
}

896
897
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
898
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
  VP9_COMMON *const pc = &pbi->common;

  const uint8_t *data_ptr = data + first_partition_size;
  int tile_row, tile_col, delta_log2_tiles;

  vp9_get_tile_n_bits(pc, &pc->log2_tile_columns, &delta_log2_tiles);
  while (delta_log2_tiles--) {
    if (vp9_read_bit(header_bc)) {
      pc->log2_tile_columns++;
    } else {
      break;
    }
  }
  pc->log2_tile_rows = vp9_read_bit(header_bc);
  if (pc->log2_tile_rows)
    pc->log2_tile_rows += vp9_read_bit(header_bc);
  pc->tile_columns = 1 << pc->log2_tile_columns;
  pc->tile_rows    = 1 << pc->log2_tile_rows;

918
919
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
920
921
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
                                      MAX_MB_PLANE * mi_cols_aligned_to_sb(pc));
922
923

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
924
                                       mi_cols_aligned_to_sb(pc));
925
926
927
928

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
929
    vp9_reader bc_bak = {0};
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952

    // pre-initialize the offsets, we're going to read in inverse order
    data_ptr2[0][0] = data_ptr;
    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      if (tile_row) {
        const int size = read_le32(data_ptr2[tile_row - 1][n_cols - 1]);
        data_ptr2[tile_row - 1][n_cols - 1] += 4;
        data_ptr2[tile_row][0] = data_ptr2[tile_row - 1][n_cols - 1] + size;
      }

      for (tile_col = 1; tile_col < n_cols; tile_col++) {
        const int size = read_le32(data_ptr2[tile_row][tile_col - 1]);
        data_ptr2[tile_row][tile_col - 1] += 4;
        data_ptr2[tile_row][tile_col] =
            data_ptr2[tile_row][tile_col - 1] + size;
      }
    }

    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      vp9_get_tile_row_offsets(pc, tile_row);
      for (tile_col = n_cols - 1; tile_col >= 0; tile_col--) {
        vp9_get_tile_col_offsets(pc, tile_col);
        setup_token_decoder(pbi, data_ptr2[tile_row][tile_col], residual_bc);
953
        decode_tile(pbi, residual_bc);
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
        if (tile_row == pc->tile_rows - 1 && tile_col == n_cols - 1)
          bc_bak = *residual_bc;
      }
    }
    *residual_bc = bc_bak;
  } else {
    int has_more;

    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      vp9_get_tile_row_offsets(pc, tile_row);
      for (tile_col = 0; tile_col < pc->tile_columns; tile_col++) {
        vp9_get_tile_col_offsets(pc, tile_col);

        has_more = tile_col < pc->tile_columns - 1 ||
                   tile_row < pc->tile_rows - 1;

        setup_token_decoder(pbi, data_ptr + (has_more ? 4 : 0), residual_bc);
971
        decode_tile(pbi, residual_bc);
972
973
974
975
976
977
978
979
980
981

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

982
int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) {
983
  vp9_reader header_bc, residual_bc;
984
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
985
  MACROBLOCKD *const xd  = &pbi->mb;
986
  const uint8_t *data = pbi->source;
987
  const uint8_t *data_end = data + pbi->source_sz;
988
  size_t first_partition_size = 0;
989
  YV12_BUFFER_CONFIG *new_fb = &pc->yv12_fb[pc->new_fb_idx];