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

#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
19
#include "vp9/common/vp9_common.h"
20
21
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
Yaowu Xu's avatar
Yaowu Xu committed
22
#include "vp9/common/vp9_entropy.h"
23
24
25
26
#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"
27
28
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_tile_common.h"
29
30

#include "vp9/decoder/vp9_dboolhuff.h"
31
32
33
34
35
#include "vp9/decoder/vp9_decodframe.h"
#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
#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
45
46
47
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
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
58
59
60
61
62
63
64
65
66
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);
    }
  }
67
68
}

69
70
71
72
73
74
75
76
77
78
79
80
81
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) {
82
  if (v > 2 * m)
83
    return v;
84
85

  return v % 2 ? m - (v + 1) / 2 : m + v / 2;
86
87
}

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

95
96
  v = vp9_read_literal(r, l - 1);
  return v < m ?  v : (v << 1) - m + vp9_read_bit(r);
97
98
}

99
static int decode_term_subexp(vp9_reader *r, int k, int num_syms) {
100
101
102
103
104
  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) {
105
      word = decode_uniform(r, num_syms - mk) + mk;
106
107
      break;
    } else {
108
      if (vp9_read_bit(r)) {
109
110
111
        i++;
        mk += a;
      } else {
112
        word = vp9_read_literal(r, b) + mk;
113
114
115
116
117
118
119
        break;
      }
    }
  }
  return word;
}

120
static int decode_unsigned_max(vp9_reader *r, int max) {
121
122
123
  int data = 0, bit = 0, lmax = max;

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

John Koleszar's avatar
John Koleszar committed
130
131
static int merge_index(int v, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
132
133
134
  if (v < max1) {
    v = v * modulus + modulus / 2;
  } else {
John Koleszar's avatar
John Koleszar committed
135
136
137
138
139
140
141
142
    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;
143
144
}

John Koleszar's avatar
John Koleszar committed
145
146
static int inv_remap_prob(int v, int m) {
  const int n = 256;
147

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

156
vp9_prob vp9_read_prob_diff_update(vp9_reader *r, int oldp) {
157
  int delp = decode_term_subexp(r, SUBEXP_PARAM, 255);
158
  return (vp9_prob)inv_remap_prob(delp, oldp);
159
}
160

161
void vp9_init_dequantizer(VP9_COMMON *pc) {
162
  int q;
John Koleszar's avatar
John Koleszar committed
163

Dmitry Kovalev's avatar
Dmitry Kovalev committed
164
  for (q = 0; q < QINDEX_RANGE; q++) {
165
    // DC value
166
167
    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
168

169
    // AC values
170
171
    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
172
  }
John Koleszar's avatar
John Koleszar committed
173
174
}

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

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

185
186
187
188
189
190
191
192
193
194
195
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);
196

197
  TX_TYPE tx_type;
198

199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
  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;
221
222
223
  }
}

224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
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;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
243
244
  if (xd->mode_info_context->mbmi.sb_type < BLOCK_SIZE_SB8X8 && plane == 0) {
    assert(bsize == BLOCK_SIZE_SB8X8);
245
    b_mode = xd->mode_info_context->bmi[raster_block].as_mode.first;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
246
  } else {
247
    b_mode = mode;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
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

  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;
  }
}

279
280
281
282
283
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;

Yaowu Xu's avatar
Yaowu Xu committed
284
285
  assert(mbmi->ref_frame != INTRA_FRAME);

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

  // prediction
Yaowu Xu's avatar
Yaowu Xu committed
290
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
291
292
293
294
295
296
297
298
299
300
301
302

  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);
    }
  }
Yaowu Xu's avatar
Yaowu Xu committed
303
  foreach_transformed_block(xd, bsize, decode_block, xd);
304
305
}

306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
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);
}


326
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
327
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
328
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
329
  const int bw = 1 << bwl, bh = 1 << bhl;
330
  int n, eobtotal;
331
  VP9_COMMON *const pc = &pbi->common;
332
333
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
334
  const int mis = pc->mode_info_stride;
335

336
  assert(mbmi->sb_type == bsize);
Yaowu Xu's avatar
Yaowu Xu committed
337
  assert(mbmi->ref_frame != INTRA_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
338
339

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

342
  // generate prediction
Yaowu Xu's avatar
Yaowu Xu committed
343
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
344

345
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
346
    vp9_reset_sb_tokens_context(xd, bsize);
347
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
348
349
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
350
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
351
352

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

358
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
359
360
361
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
362
      foreach_transformed_block(xd, bsize, decode_block, xd);
363
    }
364
  }
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
380
381
  // Special case: if prev_mi is NULL, the previous mode info context
  // cannot be used.
  xd->prev_mode_info_context = cm->prev_mi ?
                                 cm->prev_mi + mi_idx : NULL;
382

383
384
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
385
        (mi_col * 2 >> xd->plane[i].subsampling_x);
386
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
387
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
388
  }
389
390
  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
391

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

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

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

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

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

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

431
432
433
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
434
435
436
  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);
437

438
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
439
440
    decode_sb_intra(pbi, xd, mi_row, mi_col, r, (bsize < BLOCK_SIZE_SB8X8) ?
                                     BLOCK_SIZE_SB8X8 : bsize);
441
  else if (bsize < BLOCK_SIZE_SB8X8)
442
    decode_atom(pbi, xd, mi_row, mi_col, r, BLOCK_SIZE_SB8X8);
443
  else
444
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
445

446
  xd->corrupted |= vp9_reader_has_error(r);
447
448
}

449
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
450
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
451
452
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
453
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
454
455
456
457
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

458
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
459
460
    return;

461
462
463
464
465
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
466
    int pl;
467
    // read the partition information
468
469
    xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = pc->above_seg_context + mi_col;
470
    pl = partition_plane_context(xd, bsize);
471
    partition = treed_read(r, vp9_partition_tree,
472
473
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
474
475
  }

476
  subsize = get_subsize(bsize, partition);
477
  *(get_sb_index(xd, subsize)) = 0;
478

479
480
  switch (partition) {
    case PARTITION_NONE:
481
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
482
483
      break;
    case PARTITION_HORZ:
484
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
485
      *(get_sb_index(xd, subsize)) = 1;
486
      if (mi_row + bs < pc->mi_rows)
487
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
488
489
      break;
    case PARTITION_VERT:
490
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
491
      *(get_sb_index(xd, subsize)) = 1;
492
      if (mi_col + bs < pc->mi_cols)
493
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
494
495
496
497
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
498
        *(get_sb_index(xd, subsize)) = n;
499
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
500
501
502
503
504
      }
      break;
    default:
      assert(0);
  }
505
  // update partition context
506
507
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
508
509
510
    set_partition_seg_context(pc, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
511
512
}

513
static void setup_token_decoder(VP9D_COMP *pbi,
514
515
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
516
  VP9_COMMON *pc = &pbi->common;
517
518
  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
519

Dmitry Kovalev's avatar
Dmitry Kovalev committed
520
521
522
  // 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.
523
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
524
525
526
527
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

528
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
529
530
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
531
532
}

533
534
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
535
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
536

John Koleszar's avatar
John Koleszar committed
537
  if (pc->frame_type == KEY_FRAME) {
538
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
539
    // All buffers are implicitly updated on key frames.
540
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
541
542
543
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
544

John Koleszar's avatar
John Koleszar committed
545
  xd->mode_info_context = pc->mi;
546
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
547
548
549
  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
550
551
}

552
553
static void read_coef_probs_common(FRAME_CONTEXT *fc, TX_SIZE tx_size,
                                   vp9_reader *r) {
554
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
555
  vp9_coeff_probs_model *coef_probs = fc->coef_probs[tx_size];
556

557
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
558

559
  if (vp9_read_bit(r)) {
560
    for (i = 0; i < BLOCK_TYPES; i++) {
561
562
563
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
564
            const int mstart = 0;
565
566
            if (l >= 3 && k == 0)
              continue;
567
568

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

571
              if (vp9_read(r, vp9_coef_update_prob[m])) {
572
                *p = vp9_read_prob_diff_update(r, *p);
573
              }
574
575
576
            }
          }
        }
577
578
      }
    }
579
  }
580
}
581

582
583
584
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
585

586
  read_coef_probs_common(fc, TX_4X4, r);
587

588
  if (mode > ONLY_4X4)
589
    read_coef_probs_common(fc, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
590

591
  if (mode > ALLOW_8X8)
592
    read_coef_probs_common(fc, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
593

594
  if (mode > ALLOW_16X16)
595
    read_coef_probs_common(fc, TX_32X32, r);
596
597
}

598
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
599
600
  int i, j;

601
602
603
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;

604
  xd->segmentation_enabled = vp9_read_bit(r);
605
606
607
608
609
610
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
  if (xd->update_mb_segmentation_map) {
611
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
612
613
614
615
616
617
618
619
620
621
622
      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;
623
    }
624
  }
625

626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
  // 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);
642
        }
643
        vp9_set_segdata(xd, i, j, data);
644
645
646
647
648
      }
    }
  }
}

649
650
651
652
653
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
654
655
656
    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;
657
658
659
660
661
662
663
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
664

665
666
667
668
669
670
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);
671
672
673
674
675

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

676
  xd->mode_ref_lf_delta_enabled = vp9_rb_read_bit(rb);
677
  if (xd->mode_ref_lf_delta_enabled) {
678
    xd->mode_ref_lf_delta_update = vp9_rb_read_bit(rb);
679
    if (xd->mode_ref_lf_delta_update) {
680
681
      int i;

682
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
683
684
685
        if (vp9_rb_read_bit(rb)) {
          const int value = vp9_rb_read_literal(rb, 6);
          xd->ref_lf_deltas[i] = vp9_rb_read_bit(rb) ? -value : value;
686
687
688
689
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
690
691
692
        if (vp9_rb_read_bit(rb)) {
          const int value = vp9_rb_read_literal(rb, 6);
          xd->mode_lf_deltas[i] = vp9_rb_read_bit(rb) ? -value : value;
693
694
695
696
697
698
        }
      }
    }
  }
}

699
700
701
702
703
704
705
706
static int read_delta_q(struct vp9_read_bit_buffer *rb, int *delta_q) {
  const int old = *delta_q;
  if (vp9_rb_read_bit(rb)) {
    const int value = vp9_rb_read_literal(rb, 4);
    *delta_q = vp9_rb_read_bit(rb) ? -value : value;
  }
  return old != *delta_q;
}
707

708
709
710
711
712
713
714
715
716
static void setup_quantization(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
  VP9_COMMON *const cm = &pbi->common;
  int update = 0;
  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);
717
718
}

719
720
721
722
723
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

724
725
726
727
728
729
730
731
732
733
734
735
736
737
static void read_frame_size(VP9_COMMON *cm,
                            struct vp9_read_bit_buffer *rb,
                            int *width, int *height) {
  const int w = vp9_rb_read_literal(rb, 16);
  const int h = vp9_rb_read_literal(rb, 16);
  if (w <= 0)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid frame width");

  if (h <= 0)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid frame height");
  *width = w;
  *height = h;
738
739
}

740
741
static void setup_frame_size(VP9D_COMP *pbi, int scaling_active,
                             struct vp9_read_bit_buffer *rb) {
742
743
  // 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.
744
745
746
747
748
  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;
749

750
  if (scaling_active)
751
    read_frame_size(pc, rb, &display_width, &display_height);
752

753
  read_frame_size(pc, rb, &width, &height);
754

755
  if (pc->width != width || pc->height != height) {
756
    if (!pbi->initial_width || !pbi->initial_height) {
757
      if (vp9_alloc_frame_buffers(pc, width, height))
758
759
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
760
761
762
763
764
765
        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");
766

767
768
769
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
770
771
    }

772
773
774
775
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
776

777
    vp9_update_frame_size(pc);
778
779
780
  }
}

781
static void update_frame_context(FRAME_CONTEXT *fc) {
782
  vp9_copy(fc->pre_coef_probs, fc->coef_probs);
783
  vp9_copy(fc->pre_y_mode_prob, fc->y_mode_prob);
784
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
785
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
786
  fc->pre_nmvc = fc->nmvc;
787
788
789
790
  vp9_copy(fc->pre_switchable_interp_prob,
           fc->switchable_interp_prob);
  vp9_copy(fc->pre_inter_mode_probs,
           fc->inter_mode_probs);
791

792
  vp9_zero(fc->coef_counts);
793
  vp9_zero(fc->eob_branch_counts);
794
  vp9_zero(fc->y_mode_counts);
795
796
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->NMVcount);
797
  vp9_zero(fc->inter_mode_counts);
798
  vp9_zero(fc->partition_counts);
799
  vp9_zero(fc->switchable_interp_count);
800
}
801

802
803
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
804
  int mi_row, mi_col;
805

806
  for (mi_row = pc->cur_tile_mi_row_start;
807
       mi_row < pc->cur_tile_mi_row_end; mi_row += 64 / MI_SIZE) {
808
    // For a SB there are 2 left contexts, each pertaining to a MB row within
809
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
810
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
811
    for (mi_col = pc->cur_tile_mi_col_start;
812
         mi_col < pc->cur_tile_mi_col_end; mi_col += 64 / MI_SIZE)
813
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
814
815
816
  }
}

817
818
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
819
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
  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;

839
840
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
841
842
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
                                      MAX_MB_PLANE * mi_cols_aligned_to_sb(pc));
843
844

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
845
                                       mi_cols_aligned_to_sb(pc));
846
847
848
849

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
850
    vp9_reader bc_bak = {0};
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873

    // 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);
874
        decode_tile(pbi, residual_bc);
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
        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);
892
        decode_tile(pbi, residual_bc);
893
894
895
896
897
898
899
900
901
902

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

John Koleszar's avatar
John Koleszar committed
903

904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
static void error_handler(void *data, int bit_offset) {
  VP9_COMMON *const cm = (VP9_COMMON *)data;
  vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet");
}

size_t read_uncompressed_header(VP9D_COMP *pbi,
                                struct vp9_read_bit_buffer *rb) {
  VP9_COMMON *const cm = &pbi->common;

  int scaling_active;
  cm->last_frame_type = cm->frame_type;
  cm->frame_type = (FRAME_TYPE) vp9_rb_read_bit(rb);
  cm->version = vp9_rb_read_literal(rb, 3);
  cm->show_frame = vp9_rb_read_bit(rb);
  scaling_active = vp9_rb_read_bit(rb);
  cm->subsampling_x = vp9_rb_read_bit(rb);
  cm->subsampling_y = vp9_rb_read_bit(rb);

  if (cm->frame_type == KEY_FRAME) {
    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");
    }
  }
930

931
  setup_frame_size(pbi, scaling_active, rb);
John Koleszar's avatar
John Koleszar committed
932

933
934
935
936
937
938
  if (!cm->show_frame) {
    cm->intra_only = vp9_rb_read_bit(rb);
  } else {
    cm->intra_only = 0;
  }

939
940
941
942
943
  cm->frame_context_idx = vp9_rb_read_literal(rb, NUM_FRAME_CONTEXTS_LG2);
  cm->clr_type = (YUV_TYPE)vp9_rb_read_bit(rb);

  cm->error_resilient_mode = vp9_rb_read_bit(rb);
  if (!cm->error_resilient_mode) {
944
    cm->reset_frame_context = vp9_rb_read_bit(rb);
945
946
    cm->refresh_frame_context = vp9_rb_read_bit(rb);
    cm->frame_parallel_decoding_mode = vp9_rb_read_bit(rb);
John Koleszar's avatar
John Koleszar committed
947
  } else {
948
    cm->reset_frame_context = 0;
949
950
951
    cm->refresh_frame_context = 0;
    cm->frame_parallel_decoding_mode = 1;
  }
John Koleszar's avatar
John Koleszar committed
952

953
954
955
  setup_loopfilter(pbi, rb);
  setup_quantization(pbi, rb);

956
957
  return vp9_rb_read_literal(rb, 16);
}
John Koleszar's avatar
John Koleszar committed
958