vp9_decodframe.c 39.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
12
#include <assert.h>
#include <stdio.h>
John Koleszar's avatar
John Koleszar committed
13

14
#include "vp9/decoder/vp9_onyxd_int.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
15
#include "vp9/common/vp9_common.h"
16
17
18
#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
19
#include "vp9/common/vp9_entropy.h"
20
#include "vp9/decoder/vp9_decodframe.h"
21
#include "vp9/decoder/vp9_detokenize.h"
22
23
24
25
#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
26
#include "vpx_scale/vpx_scale.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
27

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

216
  TX_TYPE tx_type;
217

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

243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
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;
    uint8_t* dst;
    dst = raster_block_offset_uint8(xd, bsize, 0, i,
                                    xd->plane[0].dst.buf,
                                    xd->plane[0].dst.stride);
#if CONFIG_NEWBINTRAMODES
    xd->mode_info_context->bmi[i].as_mode.context =
        vp9_find_bpred_context(xd, i, dst, xd->plane[0].dst.stride);
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
      vp9_decode_coefs_4x4(pbi, xd, r, PLANE_TYPE_Y_WITH_DC, i);
#endif
263
    vp9_intra4x4_predict(xd, i, bsize, b_mode, dst, xd->plane[0].dst.stride);
264
265
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
266
    dequant_add_y(xd, tx_type, i, bsize);
267
268
269
270
271
272
273
274
  }
#if CONFIG_NEWBINTRAMODES
  if (!xd->mode_info_context->mbmi.mb_skip_coeff)
    vp9_decode_mb_tokens_4x4_uv(pbi, xd, r);
#endif
  foreach_transformed_block_uv(xd, bsize, decode_block, xd);
}

275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
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)) {
#if CONFIG_NEWBINTRAMODES
    if (mbmi->mode != I4X4_PRED)
#endif
      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);
}

310
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
311
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
312
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
313
  const int bw = 1 << bwl, bh = 1 << bhl;
314
  int n, eobtotal;
315
  VP9_COMMON *const pc = &pbi->common;
316
317
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
318
  const int mis = pc->mode_info_stride;
319

320
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
321
322

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

325
  // generate prediction
326
  if (mbmi->ref_frame == INTRA_FRAME) {
327
328
    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
329
  } else {
330
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
331
332
  }

333
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
334
    vp9_reset_sb_tokens_context(xd, bsize);
335
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
336
337
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
338
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
339
340

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

346
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
347
348
349
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
350
      foreach_transformed_block(xd, bsize, decode_block, xd);
351
    }
352
  }
353
354
}

355
356
357
358
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
359
360
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
361
  }
John Koleszar's avatar
John Koleszar committed
362

363
  // Trigger a quantizer update if the delta-q value has changed
364
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
365
366
}

367
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
368
369
370
                        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
371
372
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
373
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
374
  int i;
375

376
  xd->mode_info_context = cm->mi + mi_idx;
377
  xd->mode_info_context->mbmi.sb_type = bsize;
378
379
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

380
381
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
382
        (mi_col * 2 >> xd->plane[i].subsampling_x);
383
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
384
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
385
  }
Jingning Han's avatar
Jingning Han committed
386
387
  xd->above_seg_context = cm->above_seg_context + (mi_col >> 1);
  xd->left_seg_context  = cm->left_seg_context + ((mi_row >> 1) & 3);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
388

389
390
  // 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
391
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
392

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

396
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
397
398
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
399
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
400
401

  if (mbmi->ref_frame > INTRA_FRAME) {
402
    // Select the appropriate reference frame for this MB
403
404
405
    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];
406
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
407
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
408
                     xd->scale_factor, xd->scale_factor_uv);
409
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
410

Ronald S. Bultje's avatar
Ronald S. Bultje committed
411
    if (mbmi->second_ref_frame > INTRA_FRAME) {
412
      // Select the appropriate reference frame for this MB
413
414
      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
415
416
      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];
417
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
418
                       xd->scale_factor, xd->scale_factor_uv);
419
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
420
421
422
    }
  }
}
John Koleszar's avatar
John Koleszar committed
423

424
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
425
426
427
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

428
429
430
  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);
431

432
433
434
435
  if (bsize == BLOCK_SIZE_SB8X8 &&
      (xd->mode_info_context->mbmi.mode == SPLITMV ||
       xd->mode_info_context->mbmi.mode == I4X4_PRED))
    decode_atom(pbi, xd, mi_row, mi_col, r, bsize);
436
  else
437
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
438

439
  xd->corrupted |= vp9_reader_has_error(r);
440
441
}

442
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
443
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
444
445
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
446
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
447
448
449
450
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

451
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
452
453
    return;

454
  if (bsize > BLOCK_SIZE_SB8X8) {
455
    int pl;
456
    // read the partition information
457
    xd->left_seg_context =
Jingning Han's avatar
Jingning Han committed
458
459
        pc->left_seg_context + ((mi_row >> 1) & 3);
    xd->above_seg_context = pc->above_seg_context + (mi_col >> 1);
460
    pl = partition_plane_context(xd, bsize);
461
    partition = treed_read(r, vp9_partition_tree,
462
463
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
464
465
  }

466
  subsize = get_subsize(bsize, partition);
467
468
  switch (partition) {
    case PARTITION_NONE:
469
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
470
471
      break;
    case PARTITION_HORZ:
472
473
474
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
      if ((mi_row + bs) < pc->mi_rows)
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
475
476
      break;
    case PARTITION_VERT:
477
478
479
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
      if ((mi_col + bs) < pc->mi_cols)
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
480
481
482
483
484
485
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
        if (subsize == BLOCK_SIZE_SB32X32)
          xd->sb_index = n;
486
487
488
489
        else if (subsize == BLOCK_SIZE_MB16X16)
          xd->mb_index = n;
        else
          xd->b_index = n;
490
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
491
492
493
494
495
      }
      break;
    default:
      assert(0);
  }
496
  // update partition context
497
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_MB16X16))
498
499
    return;

Jingning Han's avatar
Jingning Han committed
500
501
  xd->left_seg_context = pc->left_seg_context + ((mi_row >> 1) & 3);
  xd->above_seg_context = pc->above_seg_context + (mi_col >> 1);
502
  update_partition_context(xd, subsize, bsize);
503
504
}

505
static void setup_token_decoder(VP9D_COMP *pbi,
506
507
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
508
  VP9_COMMON *pc = &pbi->common;
509
510
  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
511

Dmitry Kovalev's avatar
Dmitry Kovalev committed
512
513
514
  // 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.
515
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
516
517
518
519
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

520
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
521
522
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
523
524
}

525
526
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
527
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
528

John Koleszar's avatar
John Koleszar committed
529
  if (pc->frame_type == KEY_FRAME) {
530
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
531
    // All buffers are implicitly updated on key frames.
532
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
533
534
535
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
536

John Koleszar's avatar
John Koleszar committed
537
  xd->mode_info_context = pc->mi;
538
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
539
540
541
  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
542
543
}

544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
#if CONFIG_CODE_ZEROGROUP
static void read_zpc_probs_common(VP9_COMMON *cm,
                                  vp9_reader* bc,
                                  TX_SIZE tx_size) {
  int r, b, p, n;
  vp9_zpc_probs *zpc_probs;
  vp9_prob upd = ZPC_UPDATE_PROB;
  if (!get_zpc_used(tx_size)) return;
  if (!vp9_read_bit(bc)) return;

  if (tx_size == TX_32X32) {
    zpc_probs = &cm->fc.zpc_probs_32x32;
  } else if (tx_size == TX_16X16) {
    zpc_probs = &cm->fc.zpc_probs_16x16;
  } else if (tx_size == TX_8X8) {
    zpc_probs = &cm->fc.zpc_probs_8x8;
  } else {
    zpc_probs = &cm->fc.zpc_probs_4x4;
  }
  for (r = 0; r < REF_TYPES; ++r) {
    for (b = 0; b < ZPC_BANDS; ++b) {
      for (p = 0; p < ZPC_PTOKS; ++p) {
        for (n = 0; n < ZPC_NODES; ++n) {
          vp9_prob *q = &(*zpc_probs)[r][b][p][n];
#if USE_ZPC_EXTRA == 0
          if (n == 1) continue;
#endif
          if (vp9_read(bc, upd)) {
            *q = read_prob_diff_update(bc, *q);
          }
        }
      }
    }
  }
}

static void read_zpc_probs(VP9_COMMON *cm,
                           vp9_reader* bc) {
  read_zpc_probs_common(cm, bc, TX_4X4);
583
  if (cm->txfm_mode > ONLY_4X4)
584
585
586
587
588
589
590
591
    read_zpc_probs_common(cm, bc, TX_8X8);
  if (cm->txfm_mode > ALLOW_8X8)
    read_zpc_probs_common(cm, bc, TX_16X16);
  if (cm->txfm_mode > ALLOW_16X16)
    read_zpc_probs_common(cm, bc, TX_32X32);
}
#endif  // CONFIG_CODE_ZEROGROUP

592
593
594
static void read_coef_probs_common(vp9_coeff_probs *coef_probs,
                                   TX_SIZE tx_size,
                                   vp9_reader *r) {
595
596
597
598
599
600
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
  const int entropy_nodes_update = UNCONSTRAINED_UPDATE_NODES;
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

601
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
602

603
  if (vp9_read_bit(r)) {
604
    for (i = 0; i < BLOCK_TYPES; i++) {
605
606
607
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
608
            const int mstart = 0;
609
610
            if (l >= 3 && k == 0)
              continue;
611
612

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

615
616
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
617
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
618
                if (m == UNCONSTRAINED_NODES - 1)
619
620
                  vp9_get_model_distribution(*p, coef_probs[i][j][k][l], i, j);
#endif
621
              }
622
623
624
            }
          }
        }
625
626
      }
    }
627
  }
628
}
629

630
631
632
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
633

634
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
635

636
  if (mode > ONLY_4X4)
637
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
638

639
  if (mode > ALLOW_8X8)
640
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
641

642
  if (mode > ALLOW_16X16)
643
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
644
645
}

646
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
647
648
  int i, j;

649
650
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
651
652
653
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
654

655
  xd->segmentation_enabled = vp9_read_bit(r);
656
657
658
659
660
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
661
662
663
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
664
  if (xd->update_mb_segmentation_map) {
665
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
666
667
668
669
670
671
672
673
674
675
676
      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;
677
    }
678
  }
679

680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
  // 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);
696
        }
697
        vp9_set_segdata(xd, i, j, data);
698
699
700
701
702
      }
    }
  }
}

703
704
705
706
707
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
708
709
710
    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;
711
712
713
714
715
716
717
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
718

719
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
720
  pc->filter_type = (LOOPFILTER_TYPE) vp9_read_bit(r);
721
722
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
723
724

#if CONFIG_LOOP_DERING
725
726
  if (vp9_read_bit(r))
    pc->dering_enabled = 1 + vp9_read_literal(r, 4);
727
728
729
730
731
732
733
734
  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;

735
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
736
  if (xd->mode_ref_lf_delta_enabled) {
737
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
738
    if (xd->mode_ref_lf_delta_update) {
739
740
      int i;

741
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
742
        if (vp9_read_bit(r)) {
743
744
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
745
746
747
748
        }
      }

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

758
759
760
761
762
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);
763
764
765
  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))
766
    vp9_init_dequantizer(pc);
767

768
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
769
770
}

771
772
773
774
775
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

776
777
778
779
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) {
780
781
782
783
784
785
786
787
788
789
790
    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;
791
792
793
794
795
796
797
798
    data += 4;
  } else {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Failed to read frame size");
  }
  return data;
}

799
static const uint8_t *setup_frame_size(VP9D_COMP *pbi, int scaling_active,
800
801
                                       const uint8_t *data,
                                       const uint8_t *data_end) {
802
803
  // 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.
804
805
806
807
808
  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;
809

810
811
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
812

813
  data = read_frame_size(pc, data, data_end, &width, &height);
814

815
  if (pc->width != width || pc->height != height) {
816
    if (!pbi->initial_width || !pbi->initial_height) {
817
      if (vp9_alloc_frame_buffers(pc, width, height))
818
819
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
820
821
822
823
824
825
        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");
826

827
828
829
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
830
831
    }

832
833
834
835
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
836

837
    vp9_update_frame_size(pc);
838
839
840
841
842
  }

  return data;
}

843
static void update_frame_context(FRAME_CONTEXT *fc) {
844
845
846
847
848
849
850
851
852
  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);
853
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
854
855
856
857
858
859
860
861
862
863
864
865
866
867
  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);
868
  vp9_zero(fc->partition_counts);
869
870
871
872
873
874

#if CONFIG_COMP_INTERINTRA_PRED
  fc->pre_interintra_prob = fc->interintra_prob;
  vp9_zero(fc->interintra_counts);
#endif

875
876
877
878
879
880
881
882
883
884
885
#if CONFIG_CODE_ZEROGROUP
  vp9_copy(fc->pre_zpc_probs_4x4, fc->zpc_probs_4x4);
  vp9_copy(fc->pre_zpc_probs_8x8, fc->zpc_probs_8x8);
  vp9_copy(fc->pre_zpc_probs_16x16, fc->zpc_probs_16x16);
  vp9_copy(fc->pre_zpc_probs_32x32, fc->zpc_probs_32x32);

  vp9_zero(fc->zpc_counts_4x4);
  vp9_zero(fc->zpc_counts_8x8);
  vp9_zero(fc->zpc_counts_16x16);
  vp9_zero(fc->zpc_counts_32x32);
#endif
886
}
887

888
889
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
890
  int mi_row, mi_col;
891

892
  for (mi_row = pc->cur_tile_mi_row_start;
Jingning Han's avatar
Jingning Han committed
893
       mi_row < pc->cur_tile_mi_row_end; mi_row += 8) {
894
    // For a SB there are 2 left contexts, each pertaining to a MB row within
895
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
896
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
897
    for (mi_col = pc->cur_tile_mi_col_start;
Jingning Han's avatar
Jingning Han committed
898
         mi_col < pc->cur_tile_mi_col_end; mi_col += 8) {
899
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
900
901
902
903
    }
  }
}

904
905
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
906
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
  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;

926
927
928
929
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 4 *
                                      MAX_MB_PLANE * mb_cols_aligned_to_sb(pc));
930
931
932

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
                                       mb_cols_aligned_to_sb(pc));
933
934
935
936

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
937
    vp9_reader bc_bak = {0};
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960

    // 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);
961
        decode_tile(pbi, residual_bc);
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
        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);
979
        decode_tile(pbi, residual_bc);