vp9_decodframe.c 49.6 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
  }
}


304
static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd, vp9_reader *r) {
305
  TX_TYPE tx_type;
306
  int i = 0;
307
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
308
309
310
311
312
  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;
313
      uint8_t* dst;
Scott LaVarnway's avatar
Scott LaVarnway committed
314
      int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
315
316
317
318
319

      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);
320
      for (j = 0; j < 4; j++) {
321
        tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
322
        dequant_add_y(xd, tx_type, ib + iblock[j]);
323
      }
324
325
326
327
328
      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);
329
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
330
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
331
                   xd->plane[1].eobs[i]);
332
333
334
335
336
      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);
337
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
338
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
339
                   xd->plane[2].eobs[i]);
340
    }
Yaowu Xu's avatar
Yaowu Xu committed
341
  } else if (mode == I4X4_PRED) {
342
    for (i = 0; i < 16; i++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
343
      int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
344
345
346
347
      uint8_t* dst;
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, i,
                                      xd->plane[0].dst.buf,
                                      xd->plane[0].dst.stride);
348
#if CONFIG_NEWBINTRAMODES
Scott LaVarnway's avatar
Scott LaVarnway committed
349
      xd->mode_info_context->bmi[i].as_mode.context =
350
          vp9_find_bpred_context(xd, i, dst, xd->plane[0].dst.stride);
351
      if (!xd->mode_info_context->mbmi.mb_skip_coeff)
352
        vp9_decode_coefs_4x4(pbi, xd, r, PLANE_TYPE_Y_WITH_DC, i);
353
#endif
John Koleszar's avatar
John Koleszar committed
354
      vp9_intra4x4_predict(xd, i, b_mode, dst, xd->plane[0].dst.stride);
355
      tx_type = get_tx_type_4x4(xd, i);
356
      dequant_add_y(xd, tx_type, i);
357
    }
358
359
#if CONFIG_NEWBINTRAMODES
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
360
      vp9_decode_mb_tokens_4x4_uv(pbi, xd, r);
361
#endif
362
    vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
363
364
365
366
    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);
367
  } else if (mode == SPLITMV || get_tx_type_4x4(xd, 0) == DCT_DCT) {
368
369
370
371
372
373
    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);
374
  } else {
375
    for (i = 0; i < 16; i++) {
376
      tx_type = get_tx_type_4x4(xd, i);
377
      dequant_add_y(xd, tx_type, i);
378
    }
379
380
381
382
    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);
383
384
385
  }
}

386
387
388
389
390
391
392
393
394
395
396
397
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);
398
399
}

400

401
402
403
404
405
406
407
408
409
410
411
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);
412

413
  TX_TYPE tx_type;
414

415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
  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;
437
438
439
  }
}

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

450
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
451
452

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

455
  // generate prediction
456
  if (mbmi->ref_frame == INTRA_FRAME) {
457
458
    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
459
  } else {
460
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
461
462
  }

463
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
464
    vp9_reset_sb_tokens_context(xd, bsize);
465
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
466
467
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
468
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
469
470

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

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

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

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

Deb Mukherjee's avatar
Deb Mukherjee committed
497
  //mode = xd->mode_info_context->mbmi.mode;
498
  if (pbi->common.frame_type != KEY_FRAME)
499
    vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
500

501
  // do prediction
502
  if (mbmi->ref_frame == INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
503
    if (mode != I8X8_PRED) {
504
      vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
Yaowu Xu's avatar
Yaowu Xu committed
505
      if (mode != I4X4_PRED)
506
        vp9_build_intra_predictors_sby_s(xd, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
507
    }
John Koleszar's avatar
John Koleszar committed
508
  } else {
509
#if 0  // def DEC_DEBUG
510
511
512
513
514
  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
515
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
516
517
  }

518
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
519
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
520
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
521
522
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
523
      mb_init_dequantizer(&pbi->common, xd);
Yunqing Wang's avatar
Yunqing Wang committed
524

525
    if (!vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
526
527
528
#if CONFIG_NEWBINTRAMODES
    if (mode != I4X4_PRED)
#endif
529
      eobtotal = vp9_decode_tokens(pbi, xd, r, BLOCK_SIZE_MB16X16);
Yunqing Wang's avatar
Yunqing Wang committed
530
531
532
533
    }
  }

  if (eobtotal == 0 &&
534
      mode != I4X4_PRED && mode != I8X8_PRED && mode != SPLITMV &&
535
      !vp9_reader_has_error(r)) {
536
    mbmi->mb_skip_coeff = 1;
Yunqing Wang's avatar
Yunqing Wang committed
537
538
539
540
541
542
543
  } 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) {
544
      decode_16x16(xd);
Yunqing Wang's avatar
Yunqing Wang committed
545
    } else if (tx_size == TX_8X8) {
546
      decode_8x8(xd);
Yunqing Wang's avatar
Yunqing Wang committed
547
    } else {
548
      decode_4x4(pbi, xd, r);
Yunqing Wang's avatar
Yunqing Wang committed
549
    }
550
  }
Yunqing Wang's avatar
Yunqing Wang committed
551

552
553
554
555
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
556
557
558
559
560
561
562
    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");
563
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
564
    for (i = 0; i < 16; i++) {
565
      for (j = 0; j < 16; j++)
566
        printf("%3d ", xd->plane[0].dst.buf[i * xd->plane[0].dst.stride + j]);
567
      printf("\n");
John Koleszar's avatar
John Koleszar committed
568
    }
569
570
571
572
    printf("\n");
    printf("final u\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
573
        printf("%3d ", xd->plane[1].dst.buf[i * xd->plane[1].dst.stride + j]);
574
      printf("\n");
575
    }
576
577
578
579
    printf("\n");
    printf("final v\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
580
        printf("%3d ", xd->plane[2].dst.buf[i * xd->plane[1].dst.stride + j]);
581
      printf("\n");
582
    }
583
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
584
  }
585
#endif
Yaowu Xu's avatar
Yaowu Xu committed
586
}
John Koleszar's avatar
John Koleszar committed
587

588
589
590
591
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
592
593
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
594
  }
John Koleszar's avatar
John Koleszar committed
595

596
  // Trigger a quantizer update if the delta-q value has changed
597
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
598
599
}

600
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
601
602
603
                        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
604
605
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
606

607
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
608
  const YV12_BUFFER_CONFIG *dst_fb = &cm->yv12_fb[cm->new_fb_idx];
609
610
611
612
  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);
613

614
  xd->mode_info_context = cm->mi + mi_idx;
615
  xd->mode_info_context->mbmi.sb_type = bsize;
616
617
618
619
620
621
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

  xd->above_context = cm->above_context + (mi_col >> CONFIG_SB8X8);
  xd->left_context = cm->left_context + ((mi_row >> CONFIG_SB8X8) & 3);
  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
622

623
624
  // 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
625
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
626

627
628
629
  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
630
}
John Koleszar's avatar
John Koleszar committed
631

632
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
633
634
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
635
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
636
637

  if (mbmi->ref_frame > INTRA_FRAME) {
638
    // Select the appropriate reference frame for this MB
639
640
641
    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];
642
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
643
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
644
                     xd->scale_factor, xd->scale_factor_uv);
645
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
646

Ronald S. Bultje's avatar
Ronald S. Bultje committed
647
    if (mbmi->second_ref_frame > INTRA_FRAME) {
648
      // Select the appropriate reference frame for this MB
649
650
      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
651
652
      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];
653
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
654
                       xd->scale_factor, xd->scale_factor_uv);
655
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
656
657
658
    }
  }
}
John Koleszar's avatar
John Koleszar committed
659

660
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
661
662
663
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

664
665
666
  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);
667
668
669

  // TODO(jingning): merge decode_sb_ and decode_mb_
  if (bsize > BLOCK_SIZE_MB16X16)
670
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
671
  else
672
    decode_mb(pbi, xd, mi_row, mi_col, r);
673

674
  xd->corrupted |= vp9_reader_has_error(r);
675
676
}

677
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
678
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
679
680
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
681
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
682
683
684
685
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

686
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
687
688
689
    return;

  if (bsize > BLOCK_SIZE_MB16X16) {
690
    int pl;
691
    // read the partition information
692
693
694
    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);
695
    pl = partition_plane_context(xd, bsize);
696
    partition = treed_read(r, vp9_partition_tree,
697
698
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
699
700
701
702
703
  }

  switch (partition) {
    case PARTITION_NONE:
      subsize = bsize;
704
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
705
706
707
708
      break;
    case PARTITION_HORZ:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB64X32 :
                                                BLOCK_SIZE_SB32X16;
709
710
711
      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);
712
713
714
715
      break;
    case PARTITION_VERT:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB32X64 :
                                                BLOCK_SIZE_SB16X32;
716
717
718
      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);
719
720
721
722
723
724
725
726
727
728
      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;
729
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
730
731
732
733
734
      }
      break;
    default:
      assert(0);
  }
735
736
737
738
  // update partition context
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_SB32X32))
    return;

739
740
  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);
741
  update_partition_context(xd, subsize, bsize);
742
743
}

744
static void setup_token_decoder(VP9D_COMP *pbi,
745
746
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
747
  VP9_COMMON *pc = &pbi->common;
748
749
  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
750

Dmitry Kovalev's avatar
Dmitry Kovalev committed
751
752
753
  // 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.
754
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
755
756
757
758
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

759
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
760
761
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
762
763
}

764
765
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
766
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
767

John Koleszar's avatar
John Koleszar committed
768
  if (pc->frame_type == KEY_FRAME) {
769
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
770
    // All buffers are implicitly updated on key frames.
771
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
772
773
774
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
775

John Koleszar's avatar
John Koleszar committed
776
  xd->mode_info_context = pc->mi;
777
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
778
779
780
  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
781
782
}

783
784
785
786
787
788
789
790
791
792
793
794
795
796
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
#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);
822
  if (cm->txfm_mode > ONLY_4X4)
823
824
825
826
827
828
829
830
    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

831
832
833
static void read_coef_probs_common