vp9_decodframe.c 50.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
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"
27
#include "vp9/common/vp9_setupintrarecon.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
28

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

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

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

44
45
46
47
48
49
50
51
52
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
53
54
static int read_is_valid(const uint8_t *start, size_t len,
                         const uint8_t *end) {
55
56
57
  return start + len > start && start + len <= end;
}

58
59
60
61
62
63
64
65
66
67
68
69
70
71
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);
    }
  }
72
73
}

74
75
76
77
78
79
80
81
82
83
84
85
86
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) {
87
  if (v > 2 * m)
88
    return v;
89
90

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

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

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

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

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

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

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

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

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

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

166
void vp9_init_de_quantizer(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
167
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
168
  int q;
169
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
170

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

176
    // AC values
John Koleszar's avatar
John Koleszar committed
177
    for (i = 1; i < 16; i++) {
178
      const int rc = vp9_default_zig_zag1d_4x4[i];
John Koleszar's avatar
John Koleszar committed
179

Dmitry Kovalev's avatar
Dmitry Kovalev committed
180
      pc->y_dequant[q][rc] = (int16_t)vp9_ac_yquant(q);
181
      pc->uv_dequant[q][rc] = (int16_t)vp9_ac_uv_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
182
    }
John Koleszar's avatar
John Koleszar committed
183
  }
John Koleszar's avatar
John Koleszar committed
184
185
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
186
187
188
static int get_qindex(MACROBLOCKD *mb, int segment_id, int base_qindex) {
  // Set the Q baseline allowing for any segment level adjustment
  if (vp9_segfeature_active(mb, segment_id, SEG_LVL_ALT_Q)) {
189
190
191
192
    const int data = vp9_get_segdata(mb, segment_id, SEG_LVL_ALT_Q);
    return mb->mb_segment_abs_delta == SEGMENT_ABSDATA ?
               data :  // Abs value
               clamp(base_qindex + data, 0, MAXQ);  // Delta value
Dmitry Kovalev's avatar
Dmitry Kovalev committed
193
194
195
196
197
  } else {
    return base_qindex;
  }
}

198
static void mb_init_dequantizer(VP9_COMMON *pc, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
199
  int i;
200
201
  const int segment_id = xd->mode_info_context->mbmi.segment_id;
  xd->q_index = get_qindex(xd, segment_id, pc->base_qindex);
John Koleszar's avatar
John Koleszar committed
202

203
  xd->plane[0].dequant = pc->y_dequant[xd->q_index];
204
  for (i = 1; i < MAX_MB_PLANE; i++)
205
    xd->plane[i].dequant = pc->uv_dequant[xd->q_index];
John Koleszar's avatar
John Koleszar committed
206
207
}

208
static void decode_16x16(MACROBLOCKD *xd) {
209
  const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
210

211
212
  vp9_iht_add_16x16_c(tx_type, xd->plane[0].qcoeff, xd->plane[0].dst.buf,
                      xd->plane[0].dst.stride, xd->plane[0].eobs[0]);
213

214
215
  vp9_idct_add_8x8(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                   xd->plane[1].dst.stride, xd->plane[1].eobs[0]);
216

217
218
  vp9_idct_add_8x8(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
                   xd->plane[1].dst.stride, xd->plane[2].eobs[0]);
219
220
}

221
static void decode_8x8(MACROBLOCKD *xd) {
222
223
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  // luma
224
  // if the first one is DCT_DCT assume all the rest are as well
225
  TX_TYPE tx_type = get_tx_type_8x8(xd, 0);
226
  if (tx_type != DCT_DCT || mode == I8X8_PRED) {
227
228
229
230
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      int idx = (ib & 0x02) ? (ib + 2) : ib;
231
      int16_t *q  = BLOCK_OFFSET(xd->plane[0].qcoeff, idx, 16);
232
233
234
235
      uint8_t* const dst =
          raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
                                    xd->plane[0].dst.buf,
                                    xd->plane[0].dst.stride);
236
      int stride = xd->plane[0].dst.stride;
237
      if (mode == I8X8_PRED) {
Scott LaVarnway's avatar
Scott LaVarnway committed
238
        int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
239
        vp9_intra8x8_predict(xd, ib, i8x8mode, dst, stride);
240
      }
241
      tx_type = get_tx_type_8x8(xd, ib);
242
      vp9_iht_add_8x8_c(tx_type, q, dst, stride, xd->plane[0].eobs[idx]);
243
    }
244
  } else {
245
246
    vp9_idct_add_y_block_8x8(xd->plane[0].qcoeff, xd->plane[0].dst.buf,
                             xd->plane[0].dst.stride, xd);
247
248
  }

249
250
  // chroma
  if (mode == I8X8_PRED) {
251
252
253
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
Scott LaVarnway's avatar
Scott LaVarnway committed
254
      int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
255
      uint8_t* dst;
256

257
258
259
260
261
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 1, i,
                                      xd->plane[1].dst.buf,
                                      xd->plane[1].dst.stride);
      vp9_intra_uv4x4_predict(xd, 16 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
262
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
263
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
264
                   xd->plane[1].eobs[i]);
265

266
267
268
269
270
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 2, i,
                                      xd->plane[2].dst.buf,
                                      xd->plane[1].dst.stride);
      vp9_intra_uv4x4_predict(xd, 20 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
271
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
272
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
273
                   xd->plane[2].eobs[i]);
274
    }
275
  } else if (mode == SPLITMV) {
276
277
278
279
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
        xd->plane[1].dst.stride, xd->plane[1].eobs);
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
        xd->plane[1].dst.stride, xd->plane[2].eobs);
280
  } else {
281
282
    vp9_idct_add_8x8(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                     xd->plane[1].dst.stride, xd->plane[1].eobs[0]);
283

284
285
    vp9_idct_add_8x8(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
                     xd->plane[1].dst.stride, xd->plane[2].eobs[0]);
286
287
288
  }
}

289
static INLINE void dequant_add_y(MACROBLOCKD *xd, TX_TYPE tx_type, int idx) {
290
  struct macroblockd_plane *const y = &xd->plane[0];
291
292
293
  uint8_t* const dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, idx,
                                                 xd->plane[0].dst.buf,
                                                 xd->plane[0].dst.stride);
294
  if (tx_type != DCT_DCT) {
295
    vp9_iht_add_c(tx_type, BLOCK_OFFSET(y->qcoeff, idx, 16),
296
                  dst, xd->plane[0].dst.stride, y->eobs[idx]);
297
  } else {
298
299
    xd->itxm_add(BLOCK_OFFSET(y->qcoeff, idx, 16),
                 dst, xd->plane[0].dst.stride, y->eobs[idx]);
300
301
302
  }
}

303
static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd, vp9_reader *r) {
304
  TX_TYPE tx_type;
305
  int i = 0;
306
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
307
308
309
310
311
  if (mode == I8X8_PRED) {
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      const int iblock[4] = {0, 1, 4, 5};
      int j;
312
      uint8_t* dst;
Scott LaVarnway's avatar
Scott LaVarnway committed
313
      int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
314
315
316
317
318

      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
                                      xd->plane[0].dst.buf,
                                      xd->plane[0].dst.stride);
      vp9_intra8x8_predict(xd, ib, i8x8mode, dst, xd->plane[0].dst.stride);
319
      for (j = 0; j < 4; j++) {
320
        tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
321
        dequant_add_y(xd, tx_type, ib + iblock[j]);
322
      }
323
324
325
326
327
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 1, i,
                                      xd->plane[1].dst.buf,
                                      xd->plane[1].dst.stride);
      vp9_intra_uv4x4_predict(xd, 16 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
328
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
329
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
330
                   xd->plane[1].eobs[i]);
331
332
333
334
335
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 2, i,
                                      xd->plane[2].dst.buf,
                                      xd->plane[2].dst.stride);
      vp9_intra_uv4x4_predict(xd, 20 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
336
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
337
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
338
                   xd->plane[2].eobs[i]);
339
    }
340
  } else if (mode == SPLITMV || get_tx_type_4x4(xd, 0) == DCT_DCT) {
341
342
343
344
345
346
    xd->itxm_add_y_block(xd->plane[0].qcoeff, xd->plane[0].dst.buf,
        xd->plane[0].dst.stride, xd);
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
        xd->plane[1].dst.stride, xd->plane[1].eobs);
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
        xd->plane[1].dst.stride, xd->plane[2].eobs);
347
  } else {
348
    for (i = 0; i < 16; i++) {
349
      tx_type = get_tx_type_4x4(xd, i);
350
      dequant_add_y(xd, tx_type, i);
351
    }
352
353
354
355
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                          xd->plane[1].dst.stride, xd->plane[1].eobs);
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
                          xd->plane[1].dst.stride, xd->plane[2].eobs);
356
357
358
  }
}

359
360
361
362
363
364
365
366
367
368
369
370
static int txfrm_block_to_raster_block(MACROBLOCKD *xd,
                                       BLOCK_SIZE_TYPE bsize,
                                       int plane, int block,
                                       int ss_txfrm_size) {
  const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
  const int txwl = ss_txfrm_size / 2;
  const int tx_cols_lg2 = bwl - txwl;
  const int tx_cols = 1 << tx_cols_lg2;
  const int raster_mb = block >> ss_txfrm_size;
  const int x = (raster_mb & (tx_cols - 1)) << (txwl);
  const int y = raster_mb >> tx_cols_lg2 << (txwl);
  return x + (y << bwl);
371
372
}

373

374
375
376
377
378
379
380
381
382
383
384
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);
385

386
  TX_TYPE tx_type;
387

388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
  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;
410
411
412
  }
}

413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
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
    vp9_intra4x4_predict(xd, i, b_mode, dst, xd->plane[0].dst.stride);
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
    dequant_add_y(xd, tx_type, i);
  }
#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);
}

445
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
446
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
447
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
448
  const int bw = 1 << bwl, bh = 1 << bhl;
449
  int n, eobtotal;
450
  VP9_COMMON *const pc = &pbi->common;
451
452
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
453
  const int mis = pc->mode_info_stride;
454

455
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
456
457

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

460
  // generate prediction
461
  if (mbmi->ref_frame == INTRA_FRAME) {
462
463
    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
464
  } else {
465
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
466
467
  }

468
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
469
    vp9_reset_sb_tokens_context(xd, bsize);
470
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
471
472
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
473
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
474
475

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

481
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
482
483
484
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
485
      foreach_transformed_block(xd, bsize, decode_block, xd);
486
    }
487
  }
488
489
}

490
491
// TODO(jingning): Need to merge SB and MB decoding. The MB decoding currently
// couples special handles on I8x8, B_PRED, and splitmv modes.
492
static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
493
                     int mi_row, int mi_col,
494
                     vp9_reader *r) {
John Koleszar's avatar
John Koleszar committed
495
  int eobtotal = 0;
496
497
498
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
  const MB_PREDICTION_MODE mode = mbmi->mode;
  const int tx_size = mbmi->txfm_size;
499

500
  assert(mbmi->sb_type == BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
501

Deb Mukherjee's avatar
Deb Mukherjee committed
502
  //mode = xd->mode_info_context->mbmi.mode;
503
  if (pbi->common.frame_type != KEY_FRAME)
504
    vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
505

506
  // do prediction
507
  if (mbmi->ref_frame == INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
508
    if (mode != I8X8_PRED) {
509
      vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
Yaowu Xu's avatar
Yaowu Xu committed
510
      if (mode != I4X4_PRED)
511
        vp9_build_intra_predictors_sby_s(xd, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
512
    }
John Koleszar's avatar
John Koleszar committed
513
  } else {
514
#if 0  // def DEC_DEBUG
515
516
517
518
519
  if (dec_debug)
    printf("Decoding mb:  %d %d interp %d\n",
           xd->mode_info_context->mbmi.mode, tx_size,
           xd->mode_info_context->mbmi.interp_filter);
#endif
520
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
521
522
  }

523
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
524
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
525
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
526
527
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
528
      mb_init_dequantizer(&pbi->common, xd);
Yunqing Wang's avatar
Yunqing Wang committed
529

530
    if (!vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
531
532
533
#if CONFIG_NEWBINTRAMODES
    if (mode != I4X4_PRED)
#endif
534
      eobtotal = vp9_decode_tokens(pbi, xd, r, BLOCK_SIZE_MB16X16);
Yunqing Wang's avatar
Yunqing Wang committed
535
536
537
538
    }
  }

  if (eobtotal == 0 &&
539
      mode != I4X4_PRED && mode != I8X8_PRED && mode != SPLITMV &&
540
      !vp9_reader_has_error(r)) {
541
    mbmi->mb_skip_coeff = 1;
Yunqing Wang's avatar
Yunqing Wang committed
542
543
544
545
546
547
548
  } else {
#if 0  // def DEC_DEBUG
  if (dec_debug)
    printf("Decoding mb:  %d %d\n", xd->mode_info_context->mbmi.mode, tx_size);
#endif

    if (tx_size == TX_16X16) {
549
      decode_16x16(xd);
Yunqing Wang's avatar
Yunqing Wang committed
550
    } else if (tx_size == TX_8X8) {
551
      decode_8x8(xd);
Yunqing Wang's avatar
Yunqing Wang committed
552
    } else {
553
554
555
556
557
558
      if (mbmi->mode == I4X4_PRED)
        // TODO(jingning): we need to move this to decode_atom later and
        // deprecate decode_mb, when SB8X8 is on.
        decode_atom_intra(pbi, xd, r, BLOCK_SIZE_MB16X16);
      else
        decode_4x4(pbi, xd, r);
Yunqing Wang's avatar
Yunqing Wang committed
559
    }
560
  }
Yunqing Wang's avatar
Yunqing Wang committed
561

562
563
564
565
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
566
567
568
569
570
571
572
    printf("predictor y\n");
    for (i = 0; i < 16; i++) {
      for (j = 0; j < 16; j++)
        printf("%3d ", xd->predictor[i * 16 + j]);
      printf("\n");
    }
    printf("\n");
573
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
574
    for (i = 0; i < 16; i++) {
575
      for (j = 0; j < 16; j++)
576
        printf("%3d ", xd->plane[0].dst.buf[i * xd->plane[0].dst.stride + j]);
577
      printf("\n");
John Koleszar's avatar
John Koleszar committed
578
    }
579
580
581
582
    printf("\n");
    printf("final u\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
583
        printf("%3d ", xd->plane[1].dst.buf[i * xd->plane[1].dst.stride + j]);
584
      printf("\n");
585
    }
586
587
588
589
    printf("\n");
    printf("final v\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
590
        printf("%3d ", xd->plane[2].dst.buf[i * xd->plane[1].dst.stride + j]);
591
      printf("\n");
592
    }
593
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
594
  }
595
#endif
Yaowu Xu's avatar
Yaowu Xu committed
596
}
John Koleszar's avatar
John Koleszar committed
597

598
599
600
601
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
602
603
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
604
  }
John Koleszar's avatar
John Koleszar committed
605

606
  // Trigger a quantizer update if the delta-q value has changed
607
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
608
609
}

610
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
611
612
613
                        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
614
615
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
616
  int i;
John Koleszar's avatar
John Koleszar committed
617

618
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
619
  const YV12_BUFFER_CONFIG *dst_fb = &cm->yv12_fb[cm->new_fb_idx];
620
621
622
623
  const int recon_yoffset =
      (MI_SIZE * mi_row) * dst_fb->y_stride + (MI_SIZE * mi_col);
  const int recon_uvoffset =
      (MI_UV_SIZE * mi_row) * dst_fb->uv_stride + (MI_UV_SIZE * mi_col);
624

625
  xd->mode_info_context = cm->mi + mi_idx;
626
  xd->mode_info_context->mbmi.sb_type = bsize;
627
628
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

629
630
631
632
633
634
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
        (mi_col * 4 >> (xd->plane[i].subsampling_x + CONFIG_SB8X8));
    xd->plane[i].left_context = cm->left_context[i] +
        (((mi_row * 4 >> CONFIG_SB8X8) & 15) >> xd->plane[i].subsampling_y);
  }
635
636
  xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8);
  xd->left_seg_context  = cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
637

638
639
  // 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
640
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
641

642
643
644
  xd->plane[0].dst.buf = dst_fb->y_buffer + recon_yoffset;
  xd->plane[1].dst.buf = dst_fb->u_buffer + recon_uvoffset;
  xd->plane[2].dst.buf = dst_fb->v_buffer + recon_uvoffset;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
645
}
John Koleszar's avatar
John Koleszar committed
646

647
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
648
649
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
650
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
651
652

  if (mbmi->ref_frame > INTRA_FRAME) {
653
    // Select the appropriate reference frame for this MB
654
655
656
    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];
657
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
658
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
659
                     xd->scale_factor, xd->scale_factor_uv);
660
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
661

Ronald S. Bultje's avatar
Ronald S. Bultje committed
662
    if (mbmi->second_ref_frame > INTRA_FRAME) {
663
      // Select the appropriate reference frame for this MB
664
665
      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
666
667
      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];
668
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
669
                       xd->scale_factor, xd->scale_factor_uv);
670
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
671
672
673
    }
  }
}
John Koleszar's avatar
John Koleszar committed
674

675
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
676
677
678
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

679
680
681
  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);
682
683

  // TODO(jingning): merge decode_sb_ and decode_mb_
684
  if (bsize > BLOCK_SIZE_MB16X16) {
685
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
686
  } else {
687
    decode_mb(pbi, xd, mi_row, mi_col, r);
688
  }
689

690
  xd->corrupted |= vp9_reader_has_error(r);
691
692
}

693
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
694
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
695
696
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
697
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
698
699
700
701
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

702
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
703
704
705
    return;

  if (bsize > BLOCK_SIZE_MB16X16) {
706
    int pl;
707
    // read the partition information
708
709
710
    xd->left_seg_context =
        pc->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
    xd->above_seg_context = pc->above_seg_context + (mi_col >> CONFIG_SB8X8);
711
    pl = partition_plane_context(xd, bsize);
712
    partition = treed_read(r, vp9_partition_tree,
713
714
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
715
716
717
718
719
  }

  switch (partition) {
    case PARTITION_NONE:
      subsize = bsize;
720
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
721
722
723
724
      break;
    case PARTITION_HORZ:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB64X32 :
                                                BLOCK_SIZE_SB32X16;
725
726
727
      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);
728
729
730
731
      break;
    case PARTITION_VERT:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB32X64 :
                                                BLOCK_SIZE_SB16X32;
732
733
734
      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);
735
736
737
738
739
740
741
742
743
744
      break;
    case PARTITION_SPLIT:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB32X32 :
                                                BLOCK_SIZE_MB16X16;
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
        if (subsize == BLOCK_SIZE_SB32X32)
          xd->sb_index = n;
        else
          xd->mb_index = n;
745
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
746
747
748
749
750
      }
      break;
    default:
      assert(0);
  }
751
752
753
754
  // update partition context
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_SB32X32))
    return;

755
756
  xd->left_seg_context = pc->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
  xd->above_seg_context = pc->above_seg_context + (mi_col >> CONFIG_SB8X8);
757
  update_partition_context(xd, subsize, bsize);
758
759
}

760
static void setup_token_decoder(VP9D_COMP *pbi,
761
762
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
763
  VP9_COMMON *pc = &pbi->common;
764
765
  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
766

Dmitry Kovalev's avatar
Dmitry Kovalev committed
767
768
769
  // 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.
770
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
771
772
773
774
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

775
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
776
777
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
778
779
}

780
781
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
782
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
783

John Koleszar's avatar
John Koleszar committed
784
  if (pc->frame_type == KEY_FRAME) {
785
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
786
    // All buffers are implicitly updated on key frames.
787
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
788
789
790
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
791

John Koleszar's avatar
John Koleszar committed
792
  xd->mode_info_context = pc->mi;
793
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
794
795
796
  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
797
798
}

799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
#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);
838
  if (cm->txfm_mode > ONLY_4X4)
839
840
841
842
843
844
845
846
    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

847
848
849
static void read_coef_probs_common(vp9_coeff_probs *coef_probs,
                                   TX_SIZE tx_size,
                                   vp9_reader *r) {
850
851
852
853
854
855
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
  const int entropy_nodes_update = UNCONSTRAINED_UPDATE_NODES;
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

856
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
857

858
  if (vp9_read_bit(r)) {
859
    for (i = 0; i < BLOCK_TYPES; i++) {
860
861
862
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l <