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

11
#include <assert.h>
12
#include <stdlib.h>  // qsort()
John Koleszar's avatar
John Koleszar committed
13

14
#include "./vp9_rtcd.h"
15 16
#include "./vpx_scale_rtcd.h"

17
#include "vpx_mem/vpx_mem.h"
18
#include "vpx_ports/mem_ops.h"
19 20
#include "vpx_scale/vpx_scale.h"

Dmitry Kovalev's avatar
Dmitry Kovalev committed
21
#include "vp9/common/vp9_alloccommon.h"
22
#include "vp9/common/vp9_common.h"
23
#include "vp9/common/vp9_entropy.h"
24
#include "vp9/common/vp9_entropymode.h"
25
#include "vp9/common/vp9_idct.h"
26
#include "vp9/common/vp9_thread_common.h"
Dmitry Kovalev's avatar
Dmitry Kovalev committed
27
#include "vp9/common/vp9_pred_common.h"
28
#include "vp9/common/vp9_quant_common.h"
Dmitry Kovalev's avatar
Dmitry Kovalev committed
29 30
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
31
#include "vp9/common/vp9_seg_common.h"
hkuang's avatar
hkuang committed
32
#include "vp9/common/vp9_thread.h"
33
#include "vp9/common/vp9_tile_common.h"
34

Yaowu Xu's avatar
Yaowu Xu committed
35
#include "vp9/decoder/vp9_decodeframe.h"
36 37
#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
38
#include "vp9/decoder/vp9_decoder.h"
39
#include "vp9/decoder/vp9_dsubexp.h"
40
#include "vp9/decoder/vp9_read_bit_buffer.h"
41
#include "vp9/decoder/vp9_reader.h"
42

43 44
#define MAX_VP9_HEADER_SIZE 80

45
static int is_compound_reference_allowed(const VP9_COMMON *cm) {
46
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
47
  for (i = 1; i < REFS_PER_FRAME; ++i)
48
    if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1])
49 50 51 52 53
      return 1;

  return 0;
}

54
static void setup_compound_reference_mode(VP9_COMMON *cm) {
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
  if (cm->ref_frame_sign_bias[LAST_FRAME] ==
          cm->ref_frame_sign_bias[GOLDEN_FRAME]) {
    cm->comp_fixed_ref = ALTREF_FRAME;
    cm->comp_var_ref[0] = LAST_FRAME;
    cm->comp_var_ref[1] = GOLDEN_FRAME;
  } else if (cm->ref_frame_sign_bias[LAST_FRAME] ==
                 cm->ref_frame_sign_bias[ALTREF_FRAME]) {
    cm->comp_fixed_ref = GOLDEN_FRAME;
    cm->comp_var_ref[0] = LAST_FRAME;
    cm->comp_var_ref[1] = ALTREF_FRAME;
  } else {
    cm->comp_fixed_ref = LAST_FRAME;
    cm->comp_var_ref[0] = GOLDEN_FRAME;
    cm->comp_var_ref[1] = ALTREF_FRAME;
  }
}

72
static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
Johann's avatar
Johann committed
73
  return len != 0 && len <= (size_t)(end - start);
74 75
}

76 77 78 79 80
static int decode_unsigned_max(struct vp9_read_bit_buffer *rb, int max) {
  const int data = vp9_rb_read_literal(rb, get_unsigned_bits(max));
  return data > max ? max : data;
}

81 82 83 84 85
static TX_MODE read_tx_mode(vp9_reader *r) {
  TX_MODE tx_mode = vp9_read_literal(r, 2);
  if (tx_mode == ALLOW_32X32)
    tx_mode += vp9_read_bit(r);
  return tx_mode;
86 87
}

88
static void read_tx_mode_probs(struct tx_probs *tx_probs, vp9_reader *r) {
89 90 91
  int i, j;

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
92
    for (j = 0; j < TX_SIZES - 3; ++j)
93
      vp9_diff_update_prob(r, &tx_probs->p8x8[i][j]);
94 95

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
96
    for (j = 0; j < TX_SIZES - 2; ++j)
97
      vp9_diff_update_prob(r, &tx_probs->p16x16[i][j]);
98 99

  for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
100
    for (j = 0; j < TX_SIZES - 1; ++j)
101
      vp9_diff_update_prob(r, &tx_probs->p32x32[i][j]);
John Koleszar's avatar
John Koleszar committed
102 103
}

104 105
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
  int i, j;
106
  for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
107 108 109 110 111 112 113 114 115 116 117
    for (i = 0; i < SWITCHABLE_FILTERS - 1; ++i)
      vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
}

static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
  int i, j;
  for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
    for (j = 0; j < INTER_MODES - 1; ++j)
      vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
}

118 119
static REFERENCE_MODE read_frame_reference_mode(const VP9_COMMON *cm,
                                                vp9_reader *r) {
120
  if (is_compound_reference_allowed(cm)) {
121 122 123
    return vp9_read_bit(r) ? (vp9_read_bit(r) ? REFERENCE_MODE_SELECT
                                              : COMPOUND_REFERENCE)
                           : SINGLE_REFERENCE;
124 125 126
  } else {
    return SINGLE_REFERENCE;
  }
127 128
}

129
static void read_frame_reference_mode_probs(VP9_COMMON *cm, vp9_reader *r) {
130
  FRAME_CONTEXT *const fc = cm->fc;
131
  int i;
132

133
  if (cm->reference_mode == REFERENCE_MODE_SELECT)
134 135
    for (i = 0; i < COMP_INTER_CONTEXTS; ++i)
      vp9_diff_update_prob(r, &fc->comp_inter_prob[i]);
136

137
  if (cm->reference_mode != COMPOUND_REFERENCE)
138 139 140
    for (i = 0; i < REF_CONTEXTS; ++i) {
      vp9_diff_update_prob(r, &fc->single_ref_prob[i][0]);
      vp9_diff_update_prob(r, &fc->single_ref_prob[i][1]);
141 142
    }

143
  if (cm->reference_mode != SINGLE_REFERENCE)
144 145
    for (i = 0; i < REF_CONTEXTS; ++i)
      vp9_diff_update_prob(r, &fc->comp_ref_prob[i]);
146 147
}

148 149 150
static void update_mv_probs(vp9_prob *p, int n, vp9_reader *r) {
  int i;
  for (i = 0; i < n; ++i)
151
    if (vp9_read(r, MV_UPDATE_PROB))
152
      p[i] = (vp9_read_literal(r, 7) << 1) | 1;
153 154
}

155 156
static void read_mv_probs(nmv_context *ctx, int allow_hp, vp9_reader *r) {
  int i, j;
157

158
  update_mv_probs(ctx->joints, MV_JOINTS - 1, r);
159 160

  for (i = 0; i < 2; ++i) {
161 162 163 164 165
    nmv_component *const comp_ctx = &ctx->comps[i];
    update_mv_probs(&comp_ctx->sign, 1, r);
    update_mv_probs(comp_ctx->classes, MV_CLASSES - 1, r);
    update_mv_probs(comp_ctx->class0, CLASS0_SIZE - 1, r);
    update_mv_probs(comp_ctx->bits, MV_OFFSET_BITS, r);
166 167 168
  }

  for (i = 0; i < 2; ++i) {
169
    nmv_component *const comp_ctx = &ctx->comps[i];
170
    for (j = 0; j < CLASS0_SIZE; ++j)
171
      update_mv_probs(comp_ctx->class0_fp[j], MV_FP_SIZE - 1, r);
172
    update_mv_probs(comp_ctx->fp, 3, r);
173 174 175 176
  }

  if (allow_hp) {
    for (i = 0; i < 2; ++i) {
177 178 179
      nmv_component *const comp_ctx = &ctx->comps[i];
      update_mv_probs(&comp_ctx->class0_hp, 1, r);
      update_mv_probs(&comp_ctx->hp, 1, r);
180 181 182 183
    }
  }
}

184
static void setup_plane_dequants(VP9_COMMON *cm, MACROBLOCKD *xd, int q_index) {
John Koleszar's avatar
John Koleszar committed
185
  int i;
186
  xd->plane[0].dequant = cm->y_dequant[q_index];
187

188
  for (i = 1; i < MAX_MB_PLANE; i++)
189
    xd->plane[i].dequant = cm->uv_dequant[q_index];
John Koleszar's avatar
John Koleszar committed
190 191
}

192
static void inverse_transform_block(MACROBLOCKD* xd, int plane, int block,
193 194
                                    TX_SIZE tx_size, uint8_t *dst, int stride,
                                    int eob) {
195
  struct macroblockd_plane *const pd = &xd->plane[plane];
196
  if (eob > 0) {
197
    TX_TYPE tx_type = DCT_DCT;
198
    tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
199 200 201 202
#if CONFIG_VP9_HIGHBITDEPTH
    if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
      if (xd->lossless) {
        tx_type = DCT_DCT;
203
        vp9_highbd_iwht4x4_add(dqcoeff, dst, stride, eob, xd->bd);
204 205 206 207 208
      } else {
        const PLANE_TYPE plane_type = pd->plane_type;
        switch (tx_size) {
          case TX_4X4:
            tx_type = get_tx_type_4x4(plane_type, xd, block);
209
            vp9_highbd_iht4x4_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
210 211 212
            break;
          case TX_8X8:
            tx_type = get_tx_type(plane_type, xd);
213
            vp9_highbd_iht8x8_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
214 215 216
            break;
          case TX_16X16:
            tx_type = get_tx_type(plane_type, xd);
217
            vp9_highbd_iht16x16_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
218 219 220
            break;
          case TX_32X32:
            tx_type = DCT_DCT;
221
            vp9_highbd_idct32x32_add(dqcoeff, dst, stride, eob, xd->bd);
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
            break;
          default:
            assert(0 && "Invalid transform size");
        }
      }
    } else {
      if (xd->lossless) {
        tx_type = DCT_DCT;
        vp9_iwht4x4_add(dqcoeff, dst, stride, eob);
      } else {
        const PLANE_TYPE plane_type = pd->plane_type;
        switch (tx_size) {
          case TX_4X4:
            tx_type = get_tx_type_4x4(plane_type, xd, block);
            vp9_iht4x4_add(tx_type, dqcoeff, dst, stride, eob);
            break;
          case TX_8X8:
            tx_type = get_tx_type(plane_type, xd);
            vp9_iht8x8_add(tx_type, dqcoeff, dst, stride, eob);
            break;
          case TX_16X16:
            tx_type = get_tx_type(plane_type, xd);
            vp9_iht16x16_add(tx_type, dqcoeff, dst, stride, eob);
            break;
          case TX_32X32:
            tx_type = DCT_DCT;
            vp9_idct32x32_add(dqcoeff, dst, stride, eob);
            break;
          default:
            assert(0 && "Invalid transform size");
            return;
        }
      }
    }
#else
257 258 259 260 261 262 263 264
    if (xd->lossless) {
      tx_type = DCT_DCT;
      vp9_iwht4x4_add(dqcoeff, dst, stride, eob);
    } else {
      const PLANE_TYPE plane_type = pd->plane_type;
      switch (tx_size) {
        case TX_4X4:
          tx_type = get_tx_type_4x4(plane_type, xd, block);
265
          vp9_iht4x4_add(tx_type, dqcoeff, dst, stride, eob);
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
          break;
        case TX_8X8:
          tx_type = get_tx_type(plane_type, xd);
          vp9_iht8x8_add(tx_type, dqcoeff, dst, stride, eob);
          break;
        case TX_16X16:
          tx_type = get_tx_type(plane_type, xd);
          vp9_iht16x16_add(tx_type, dqcoeff, dst, stride, eob);
          break;
        case TX_32X32:
          tx_type = DCT_DCT;
          vp9_idct32x32_add(dqcoeff, dst, stride, eob);
          break;
        default:
          assert(0 && "Invalid transform size");
281
          return;
282
      }
283
    }
284
#endif  // CONFIG_VP9_HIGHBITDEPTH
285 286

    if (eob == 1) {
287
      vpx_memset(dqcoeff, 0, 2 * sizeof(dqcoeff[0]));
288
    } else {
289
      if (tx_type == DCT_DCT && tx_size <= TX_16X16 && eob <= 10)
290
        vpx_memset(dqcoeff, 0, 4 * (4 << tx_size) * sizeof(dqcoeff[0]));
291
      else if (tx_size == TX_32X32 && eob <= 34)
292
        vpx_memset(dqcoeff, 0, 256 * sizeof(dqcoeff[0]));
293
      else
294
        vpx_memset(dqcoeff, 0, (16 << (tx_size << 1)) * sizeof(dqcoeff[0]));
295
    }
296 297 298
  }
}

299 300 301
struct intra_args {
  VP9_COMMON *cm;
  MACROBLOCKD *xd;
302
  FRAME_COUNTS *counts;
303 304 305 306 307 308
  vp9_reader *r;
};

static void predict_and_reconstruct_intra_block(int plane, int block,
                                                BLOCK_SIZE plane_bsize,
                                                TX_SIZE tx_size, void *arg) {
309
  struct intra_args *const args = (struct intra_args *)arg;
310 311
  VP9_COMMON *const cm = args->cm;
  MACROBLOCKD *const xd = args->xd;
312
  struct macroblockd_plane *const pd = &xd->plane[plane];
hkuang's avatar
hkuang committed
313
  MODE_INFO *const mi = xd->mi[0].src_mi;
314 315
  const PREDICTION_MODE mode = (plane == 0) ? get_y_mode(mi, block)
                                            : mi->mbmi.uv_mode;
316 317 318 319
  int x, y;
  uint8_t *dst;
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x, &y);
  dst = &pd->dst.buf[4 * y * pd->dst.stride + 4 * x];
320

321
  vp9_predict_intra_block(xd, block >> (tx_size << 1),
322
                          b_width_log2_lookup[plane_bsize], tx_size, mode,
323 324
                          dst, pd->dst.stride, dst, pd->dst.stride,
                          x, y, plane);
325

326
  if (!mi->mbmi.skip) {
327
    const int eob = vp9_decode_block_tokens(cm, xd, args->counts, plane, block,
328 329 330 331
                                            plane_bsize, x, y, tx_size,
                                            args->r);
    inverse_transform_block(xd, plane, block, tx_size, dst, pd->dst.stride,
                            eob);
332
  }
333 334
}

335 336 337 338
struct inter_args {
  VP9_COMMON *cm;
  MACROBLOCKD *xd;
  vp9_reader *r;
339
  FRAME_COUNTS *counts;
340 341 342 343 344 345
  int *eobtotal;
};

static void reconstruct_inter_block(int plane, int block,
                                    BLOCK_SIZE plane_bsize,
                                    TX_SIZE tx_size, void *arg) {
346
  struct inter_args *args = (struct inter_args *)arg;
347 348
  VP9_COMMON *const cm = args->cm;
  MACROBLOCKD *const xd = args->xd;
349
  struct macroblockd_plane *const pd = &xd->plane[plane];
350
  int x, y, eob;
351
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x, &y);
352 353
  eob = vp9_decode_block_tokens(cm, xd, args->counts, plane, block, plane_bsize,
                                x, y, tx_size, args->r);
354 355
  inverse_transform_block(xd, plane, block, tx_size,
                          &pd->dst.buf[4 * y * pd->dst.stride + 4 * x],
356 357
                          pd->dst.stride, eob);
  *args->eobtotal += eob;
358 359
}

360 361 362
static MB_MODE_INFO *set_offsets(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                                 const TileInfo *const tile,
                                 BLOCK_SIZE bsize, int mi_row, int mi_col) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
363
  const int bw = num_8x8_blocks_wide_lookup[bsize];
364 365 366
  const int bh = num_8x8_blocks_high_lookup[bsize];
  const int x_mis = MIN(bw, cm->mi_cols - mi_col);
  const int y_mis = MIN(bh, cm->mi_rows - mi_row);
367
  const int offset = mi_row * cm->mi_stride + mi_col;
368
  int x, y;
369

hkuang's avatar
hkuang committed
370 371 372 373
  xd->mi = cm->mi + offset;
  xd->mi[0].src_mi = &xd->mi[0];  // Point to self.
  xd->mi[0].mbmi.sb_type = bsize;

374
  for (y = 0; y < y_mis; ++y)
hkuang's avatar
hkuang committed
375 376 377
    for (x = !y; x < x_mis; ++x) {
      xd->mi[y * cm->mi_stride + x].src_mi = &xd->mi[0];
    }
378

379
  set_skip_context(xd, mi_row, mi_col);
380

381 382
  // 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
James Zern's avatar
James Zern committed
383
  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);
384

385
  vp9_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col);
hkuang's avatar
hkuang committed
386
  return &xd->mi[0].mbmi;
387
}
John Koleszar's avatar
John Koleszar committed
388

389
static void decode_block(VP9Decoder *const pbi, MACROBLOCKD *const xd,
390
                         FRAME_COUNTS *counts,
391 392 393
                         const TileInfo *const tile,
                         int mi_row, int mi_col,
                         vp9_reader *r, BLOCK_SIZE bsize) {
394
  VP9_COMMON *const cm = &pbi->common;
395
  const int less8x8 = bsize < BLOCK_8X8;
396
  MB_MODE_INFO *mbmi = set_offsets(cm, xd, tile, bsize, mi_row, mi_col);
397
  vp9_read_mode_info(pbi, xd, counts, tile, mi_row, mi_col, r);
398

399
  if (less8x8)
400
    bsize = BLOCK_8X8;
401

402
  if (mbmi->skip) {
403
    reset_skip_context(xd, bsize);
404
  } else {
405 406 407 408
    if (cm->seg.enabled)
      setup_plane_dequants(cm, xd, vp9_get_qindex(&cm->seg, mbmi->segment_id,
                                                  cm->base_qindex));
  }
409

410
  if (!is_inter_block(mbmi)) {
411
    struct intra_args arg = { cm, xd, counts, r };
412 413
    vp9_foreach_transformed_block(xd, bsize,
                                  predict_and_reconstruct_intra_block, &arg);
414 415
  } else {
    // Prediction
416
    vp9_dec_build_inter_predictors_sb(pbi, xd, mi_row, mi_col, bsize);
417

418
    // Reconstruction
419
    if (!mbmi->skip) {
420
      int eobtotal = 0;
421
      struct inter_args arg = { cm, xd, r, counts, &eobtotal };
422
      vp9_foreach_transformed_block(xd, bsize, reconstruct_inter_block, &arg);
423
      if (!less8x8 && eobtotal == 0)
424
        mbmi->skip = 1;  // skip loopfilter
425
    }
426
  }
427

428
  xd->corrupted |= vp9_reader_has_error(r);
429 430
}

431 432
static PARTITION_TYPE read_partition(VP9_COMMON *cm, MACROBLOCKD *xd,
                                     FRAME_COUNTS *counts, int hbs,
433
                                     int mi_row, int mi_col, BLOCK_SIZE bsize,
434
                                     vp9_reader *r) {
435
  const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
436 437 438 439
  const vp9_prob *const probs = get_partition_probs(cm, ctx);
  const int has_rows = (mi_row + hbs) < cm->mi_rows;
  const int has_cols = (mi_col + hbs) < cm->mi_cols;
  PARTITION_TYPE p;
440 441

  if (has_rows && has_cols)
442
    p = (PARTITION_TYPE)vp9_read_tree(r, vp9_partition_tree, probs);
443
  else if (!has_rows && has_cols)
444
    p = vp9_read(r, probs[1]) ? PARTITION_SPLIT : PARTITION_HORZ;
445
  else if (has_rows && !has_cols)
446
    p = vp9_read(r, probs[2]) ? PARTITION_SPLIT : PARTITION_VERT;
447
  else
448 449 450
    p = PARTITION_SPLIT;

  if (!cm->frame_parallel_decoding_mode)
451
    ++counts->partition[ctx][p];
452 453

  return p;
454 455
}

456
static void decode_partition(VP9Decoder *const pbi, MACROBLOCKD *const xd,
457
                             FRAME_COUNTS *counts,
458 459 460
                             const TileInfo *const tile,
                             int mi_row, int mi_col,
                             vp9_reader* r, BLOCK_SIZE bsize) {
461
  VP9_COMMON *const cm = &pbi->common;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
462
  const int hbs = num_8x8_blocks_wide_lookup[bsize] / 2;
463
  PARTITION_TYPE partition;
464
  BLOCK_SIZE subsize, uv_subsize;
465

466
  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
467 468
    return;

469
  partition = read_partition(cm, xd, counts, hbs, mi_row, mi_col, bsize, r);
470
  subsize = get_subsize(bsize, partition);
471 472
  uv_subsize = ss_size_lookup[subsize][cm->subsampling_x][cm->subsampling_y];
  if (subsize >= BLOCK_8X8 && uv_subsize == BLOCK_INVALID)
473 474
    vpx_internal_error(xd->error_info,
                       VPX_CODEC_CORRUPT_FRAME, "Invalid block size.");
475
  if (subsize < BLOCK_8X8) {
476
    decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
477 478 479
  } else {
    switch (partition) {
      case PARTITION_NONE:
480
        decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
481 482
        break;
      case PARTITION_HORZ:
483
        decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
484
        if (mi_row + hbs < cm->mi_rows)
485
          decode_block(pbi, xd, counts, tile, mi_row + hbs, mi_col, r, subsize);
486 487
        break;
      case PARTITION_VERT:
488
        decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
489
        if (mi_col + hbs < cm->mi_cols)
490
          decode_block(pbi, xd, counts, tile, mi_row, mi_col + hbs, r, subsize);
491 492
        break;
      case PARTITION_SPLIT:
493 494 495 496 497 498 499
        decode_partition(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
        decode_partition(pbi, xd, counts, tile, mi_row, mi_col + hbs, r,
                         subsize);
        decode_partition(pbi, xd, counts, tile, mi_row + hbs, mi_col, r,
                         subsize);
        decode_partition(pbi, xd, counts, tile, mi_row + hbs, mi_col + hbs, r,
                         subsize);
500 501
        break;
      default:
502
        assert(0 && "Invalid partition type");
503
    }
504
  }
505

506
  // update partition context
507
  if (bsize >= BLOCK_8X8 &&
508
      (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
509
    update_partition_context(xd, mi_row, mi_col, subsize, bsize);
510 511
}

512 513 514 515
static void setup_token_decoder(const uint8_t *data,
                                const uint8_t *data_end,
                                size_t read_size,
                                struct vpx_internal_error_info *error_info,
516 517 518
                                vp9_reader *r,
                                vpx_decrypt_cb decrypt_cb,
                                void *decrypt_state) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
519 520 521
  // 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.
522
  if (!read_is_valid(data, read_size, data_end))
523
    vpx_internal_error(error_info, VPX_CODEC_CORRUPT_FRAME,
524
                       "Truncated packet or corrupt tile length");
John Koleszar's avatar
John Koleszar committed
525

526
  if (vp9_reader_init(r, data, read_size, decrypt_cb, decrypt_state))
527
    vpx_internal_error(error_info, VPX_CODEC_MEM_ERROR,
John Koleszar's avatar
John Koleszar committed
528
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
529 530
}

531
static void read_coef_probs_common(vp9_coeff_probs_model *coef_probs,
532
                                   vp9_reader *r) {
533 534 535
  int i, j, k, l, m;

  if (vp9_read_bit(r))
536
    for (i = 0; i < PLANE_TYPES; ++i)
537 538 539 540 541
      for (j = 0; j < REF_TYPES; ++j)
        for (k = 0; k < COEF_BANDS; ++k)
          for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l)
            for (m = 0; m < UNCONSTRAINED_NODES; ++m)
              vp9_diff_update_prob(r, &coef_probs[i][j][k][l][m]);
542
}
543

544
static void read_coef_probs(FRAME_CONTEXT *fc, TX_MODE tx_mode,
545
                            vp9_reader *r) {
Yaowu Xu's avatar
Yaowu Xu committed
546 547 548 549
    const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
    TX_SIZE tx_size;
    for (tx_size = TX_4X4; tx_size <= max_tx_size; ++tx_size)
      read_coef_probs_common(fc->coef_probs[tx_size], r);
550 551
}

552 553
static void setup_segmentation(struct segmentation *seg,
                               struct vp9_read_bit_buffer *rb) {
554 555
  int i, j;

556 557
  seg->update_map = 0;
  seg->update_data = 0;
558

559 560
  seg->enabled = vp9_rb_read_bit(rb);
  if (!seg->enabled)
561 562 563
    return;

  // Segmentation map update
564 565
  seg->update_map = vp9_rb_read_bit(rb);
  if (seg->update_map) {
566
    for (i = 0; i < SEG_TREE_PROBS; i++)
567 568
      seg->tree_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
                                               : MAX_PROB;
569

570 571
    seg->temporal_update = vp9_rb_read_bit(rb);
    if (seg->temporal_update) {
572
      for (i = 0; i < PREDICTION_PROBS; i++)
573 574
        seg->pred_probs[i] = vp9_rb_read_bit(rb) ? vp9_rb_read_literal(rb, 8)
                                                 : MAX_PROB;
575 576
    } else {
      for (i = 0; i < PREDICTION_PROBS; i++)
577
        seg->pred_probs[i] = MAX_PROB;
578
    }
579
  }
580

581
  // Segmentation data update
582 583 584
  seg->update_data = vp9_rb_read_bit(rb);
  if (seg->update_data) {
    seg->abs_delta = vp9_rb_read_bit(rb);
585

586
    vp9_clearall_segfeatures(seg);
587

588
    for (i = 0; i < MAX_SEGMENTS; i++) {
589 590
      for (j = 0; j < SEG_LVL_MAX; j++) {
        int data = 0;
591
        const int feature_enabled = vp9_rb_read_bit(rb);
592
        if (feature_enabled) {
593
          vp9_enable_segfeature(seg, i, j);
594
          data = decode_unsigned_max(rb, vp9_seg_feature_data_max(j));
595
          if (vp9_is_segfeature_signed(j))
596
            data = vp9_rb_read_bit(rb) ? -data : data;
597
        }
598
        vp9_set_segdata(seg, i, j, data);
599 600 601 602 603
      }
    }
  }
}

604 605 606 607
static void setup_loopfilter(struct loopfilter *lf,
                             struct vp9_read_bit_buffer *rb) {
  lf->filter_level = vp9_rb_read_literal(rb, 6);
  lf->sharpness_level = vp9_rb_read_literal(rb, 3);
608 609 610

  // Read in loop filter deltas applied at the MB level based on mode or ref
  // frame.
611
  lf->mode_ref_delta_update = 0;
612

613 614 615 616
  lf->mode_ref_delta_enabled = vp9_rb_read_bit(rb);
  if (lf->mode_ref_delta_enabled) {
    lf->mode_ref_delta_update = vp9_rb_read_bit(rb);
    if (lf->mode_ref_delta_update) {
617 618
      int i;

619 620
      for (i = 0; i < MAX_REF_LF_DELTAS; i++)
        if (vp9_rb_read_bit(rb))
621
          lf->ref_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
622

623 624
      for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
        if (vp9_rb_read_bit(rb))
625
          lf->mode_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
626 627 628 629
    }
  }
}

630 631
static int read_delta_q(struct vp9_read_bit_buffer *rb, int *delta_q) {
  const int old = *delta_q;
632
  *delta_q = vp9_rb_read_bit(rb) ? vp9_rb_read_signed_literal(rb, 4) : 0;
633 634
  return old != *delta_q;
}
635

636 637
static void setup_quantization(VP9_COMMON *const cm, MACROBLOCKD *const xd,
                               struct vp9_read_bit_buffer *rb) {
638
  int update = 0;
639

640 641 642 643
  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);
644
  if (update || cm->bit_depth != cm->dequant_bit_depth) {
645
    vp9_init_dequantizer(cm);
646 647
    cm->dequant_bit_depth = cm->bit_depth;
  }
648 649 650 651 652

  xd->lossless = cm->base_qindex == 0 &&
                 cm->y_dc_delta_q == 0 &&
                 cm->uv_dc_delta_q == 0 &&
                 cm->uv_ac_delta_q == 0;
653 654 655
#if CONFIG_VP9_HIGHBITDEPTH
  xd->bd = (int)cm->bit_depth;
#endif
656 657
}

658 659 660 661 662
static INTERP_FILTER read_interp_filter(struct vp9_read_bit_buffer *rb) {
  const INTERP_FILTER literal_to_filter[] = { EIGHTTAP_SMOOTH,
                                              EIGHTTAP,
                                              EIGHTTAP_SHARP,
                                              BILINEAR };
663
  return vp9_rb_read_bit(rb) ? SWITCHABLE
664
                             : literal_to_filter[vp9_rb_read_literal(rb, 2)];
665 666
}

667 668
void vp9_read_frame_size(struct vp9_read_bit_buffer *rb,
                         int *width, int *height) {
669 670
  *width = vp9_rb_read_literal(rb, 16) + 1;
  *height = vp9_rb_read_literal(rb, 16) + 1;
671 672
}

673
static void setup_display_size(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
674 675 676
  cm->display_width = cm->width;
  cm->display_height = cm->height;
  if (vp9_rb_read_bit(rb))
677
    vp9_read_frame_size(rb, &cm->display_width, &cm->display_height);
678
}
679

680 681 682 683 684 685 686 687
static void resize_mv_buffer(VP9_COMMON *cm) {
  vpx_free(cm->cur_frame->mvs);
  cm->cur_frame->mi_rows = cm->mi_rows;
  cm->cur_frame->mi_cols = cm->mi_cols;
  cm->cur_frame->mvs = (MV_REF *)vpx_calloc(cm->mi_rows * cm->mi_cols,
                                            sizeof(*cm->cur_frame->mvs));
}

688
static void resize_context_buffers(VP9_COMMON *cm, int width, int height) {
689 690 691 692 693
#if CONFIG_SIZE_LIMIT
  if (width > DECODE_WIDTH_LIMIT || height > DECODE_HEIGHT_LIMIT)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Width and height beyond allowed size.");
#endif
694
  if (cm->width != width || cm->height != height) {
695
    const int new_mi_rows =
696
        ALIGN_POWER_OF_TWO(height, MI_SIZE_LOG2) >> MI_SIZE_LOG2;
697
    const int new_mi_cols =
698 699 700 701 702
        ALIGN_POWER_OF_TWO(width,  MI_SIZE_LOG2) >> MI_SIZE_LOG2;

    // Allocations in vp9_alloc_context_buffers() depend on individual
    // dimensions as well as the overall size.
    if (new_mi_cols > cm->mi_cols || new_mi_rows > cm->mi_rows) {
703
      if (vp9_alloc_context_buffers(cm, width, height))
704
        vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
705
                           "Failed to allocate context buffers");
706 707
    } else {
      vp9_set_mb_mi(cm, width, height);
708
    }
709
    vp9_init_context_buffers(cm);
710 711
    cm->width = width;
    cm->height = height;
712
  }
713 714 715 716
  if (cm->cur_frame->mvs == NULL || cm->mi_rows > cm->cur_frame->mi_rows ||
      cm->mi_cols > cm->cur_frame->mi_cols) {
    resize_mv_buffer(cm);
  }
717 718 719 720
}

static void setup_frame_size(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
  int width, height;
721
  BufferPool *const pool = cm->buffer_pool;
722 723 724
  vp9_read_frame_size(rb, &width, &height);
  resize_context_buffers(cm, width, height);
  setup_display_size(cm, rb);
725

726
  lock_buffer_pool(pool);
727 728
  if (vp9_realloc_frame_buffer(
          get_frame_new_buffer(cm), cm->width, cm->height,
729 730 731 732 733
          cm->subsampling_x, cm->subsampling_y,
#if CONFIG_VP9_HIGHBITDEPTH
          cm->use_highbitdepth,
#endif
          VP9_DEC_BORDER_IN_PIXELS,
734
          cm->byte_alignment,
735 736 737
          &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb,
          pool->cb_priv)) {
    unlock_buffer_pool(pool);
738 739 740
    vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate frame buffer");
  }
741 742 743 744 745
  unlock_buffer_pool(pool);

  pool->frame_bufs[cm->new_fb_idx].buf.subsampling_x = cm->subsampling_x;
  pool->frame_bufs[cm->new_fb_idx].buf.subsampling_y = cm->subsampling_y;
  pool->frame_bufs[cm->new_fb_idx].buf.bit_depth = (unsigned int)cm->bit_depth;
746 747 748 749 750 751 752 753
}

static INLINE int valid_ref_frame_img_fmt(vpx_bit_depth_t ref_bit_depth,
                                          int ref_xss, int ref_yss,
                                          vpx_bit_depth_t this_bit_depth,
                                          int this_xss, int this_yss) {
  return ref_bit_depth == this_bit_depth && ref_xss == this_xss &&
         ref_yss == this_yss;
754 755
}

756
static void setup_frame_size_with_refs(VP9_COMMON *cm,
757 758 759
                                       struct vp9_read_bit_buffer *rb) {
  int width, height;
  int found = 0, i;
760
  int has_valid_ref_frame = 0;
761
  BufferPool *const pool = cm->buffer_pool;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
762
  for (i = 0; i < REFS_PER_FRAME; ++i) {
763
    if (vp9_rb_read_bit(rb)) {
764 765 766
      YV12_BUFFER_CONFIG *const buf = cm->frame_refs[i].buf;
      width = buf->y_crop_width;
      height = buf->y_crop_height;
767 768 769 770 771 772
      found = 1;
      break;
    }
  }

  if (!found)
773
    vp9_read_frame_size(rb, &width, &height);
774

hkuang's avatar
hkuang committed
775
  if (width <= 0 || height <= 0)
776 777 778 779 780
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid frame size");

  // Check to make sure at least one of frames that this frame references
  // has valid dimensions.
781 782
  for (i = 0; i < REFS_PER_FRAME; ++i) {
    RefBuffer *const ref_frame = &cm->frame_refs[i];
783 784
    has_valid_ref_frame |= valid_ref_frame_size(ref_frame->buf->y_crop_width,
                                                ref_frame->buf->y_crop_height,
785
                                                width, height);
786
  }
787 788 789
  if (!has_valid_ref_frame)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Referenced frame has invalid size");
790 791 792 793
  for (i = 0; i < REFS_PER_FRAME; ++i) {
    RefBuffer *const ref_frame = &cm->frame_refs[i];
    if (!valid_ref_frame_img_fmt(
            ref_frame->buf->bit_depth,
794 795
            ref_frame->buf->subsampling_x,
            ref_frame->buf->subsampling_y,
796 797 798 799
            cm->bit_depth,
            cm->subsampling_x,
            cm->subsampling_y))
      vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
Yaowu Xu's avatar
Yaowu Xu committed
800
                         "Referenced frame has incompatible color format");
801
  }
802

803
  resize_context_buffers(cm, width, height);
804
  setup_display_size(cm, rb);
805

806
  lock_buffer_pool(pool);
807 808
  if (vp9_realloc_frame_buffer(
          get_frame_new_buffer(cm), cm->width, cm->height,
809 810 811 812 813
          cm->subsampling_x, cm->subsampling_y,
#if CONFIG_VP9_HIGHBITDEPTH
          cm->use_highbitdepth,
#endif
          VP9_DEC_BORDER_IN_PIXELS,
814
          cm->byte_alignment,
815 816 817
          &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb,
          pool->cb_priv)) {
    unlock_buffer_pool(pool);
818 819 820
    vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate frame buffer");
  }
821 822 823 824 825
  unlock_buffer_pool(pool);

  pool->frame_bufs[cm->new_fb_idx].buf.subsampling_x = cm->subsampling_x;
  pool->frame_bufs[cm->new_fb_idx].buf.subsampling_y = cm->subsampling_y;
  pool->frame_bufs[cm->new_fb_idx].buf.bit_depth = (unsigned int)cm->bit_depth;
826 827
}

828
static void setup_tile_info(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
829 830
  int min_log2_tile_cols, max_log2_tile_cols, max_ones;
  vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
831

Dmitry Kovalev's avatar
Dmitry Kovalev committed
832 833 834 835 836
  // columns
  max_ones = max_log2_tile_cols - min_log2_tile_cols;
  cm->log2_tile_cols = min_log2_tile_cols;
  while (max_ones-- && vp9_rb_read_bit(rb))
    cm->log2_tile_cols++;
837

838 839 840 841
  if (cm->log2_tile_cols > 6)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid number of tile columns");

Dmitry Kovalev's avatar
Dmitry Kovalev committed
842
  // rows
843 844 845 846 847
  cm->log2_tile_rows = vp9_rb_read_bit(rb);
  if (cm->log2_tile_rows)
    cm->log2_tile_rows += vp9_rb_read_bit(rb);
}

848 849 850 851 852 853
typedef struct TileBuffer {
  const uint8_t *data;
  size_t size;
  int col;  // only used with multi-threaded decoding
} TileBuffer;

James Zern's avatar
James Zern committed
854 855
// Reads the next tile returning its size and adjusting '*data' accordingly
// based on 'is_last'.
856 857 858 859 860 861
static void get_tile_buffer(const uint8_t *const data_end,
                            int is_last,
                            struct vpx_internal_error_info *error_info,
                            const uint8_t **data,
                            vpx_decrypt_cb decrypt_cb, void *decrypt_state,
                            TileBuffer *buf) {
James Zern's avatar
James Zern committed
862 863 864 865 866
  size_t size;

  if (!is_last) {
    if (!read_is_valid(*data, 4, data_end))
      vpx_internal_error(error_info, VPX_CODEC_CORRUPT_FRAME,
Johann's avatar
Johann committed
867
                         "Truncated packet or corrupt tile length");
James Zern's avatar
James Zern committed
868

869 870 871 872 873 874 875
    if (decrypt_cb) {
      uint8_t be_data[4];
      decrypt_cb(decrypt_state, *data, be_data, 4);
      size = mem_get_be32(be_data);
    } else {
      size = mem_get_be32(*data);
    }
James Zern's avatar
James Zern committed
876
    *data += 4;
Johann's avatar
Johann committed
877

Johann's avatar
Johann committed
878
    if (size > (size_t)(data_end - *data))
Johann's avatar
Johann committed
879 880
      vpx_internal_error(error_info, VPX_CODEC_CORRUPT_FRAME,
                         "Truncated packet or corrupt tile size");
James Zern's avatar
James Zern committed
881 882 883
  } else {
    size = data_end - *data;
  }
884 885 886 887 888

  buf->data = *data;
  buf->size = size;

  *data += size;
James Zern's avatar
James Zern committed
889 890
}

891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
static void get_tile_buffers(VP9Decoder *pbi,
                             const uint8_t *data, const uint8_t *data_end,
                             int tile_cols, int tile_rows,
                             TileBuffer (*tile_buffers)[1 << 6]) {
  int r, c;

  for (r = 0; r < tile_rows; ++r) {
    for (c = 0; c < tile_cols; ++c) {
      const int is_last = (r == tile_rows - 1) && (c == tile_cols - 1);
      TileBuffer *const buf = &tile_buffers[r][c];
      buf->col = c;
      get_tile_buffer(data_end, is_last, &pbi->common.error, &data,
                      pbi->decrypt_cb, pbi->decrypt_state, buf);
    }
  }
}
907

908
static const uint8_t *decode_tiles(VP9Decoder *pbi,
909
                                   const uint8_t *data,
910
                                   const uint8_t *data_end) {
911
  VP9_COMMON *const cm = &pbi->common;
James Zern's avatar
James Zern committed
912
  const VP9WorkerInterface *const winterface = vp9_get_worker_interface();
913
  const int aligned_cols = mi_cols_aligned_to_sb(cm->mi_cols);
914 915
  const int tile_cols = 1 << cm->log2_tile_cols;
  const int tile_rows = 1 << cm->log2_tile_rows;
916
  TileBuffer tile_buffers[4][1 << 6];
917
  int tile_row, tile_col;
918 919 920 921 922 923 924
  int mi_row, mi_col;
  TileData *tile_data = NULL;

  if (cm->lf.filter_level && pbi->lf_worker.data1 == NULL) {
    CHECK_MEM_ERROR(cm, pbi->lf_worker.data1,
                    vpx_memalign(32, sizeof(LFWorkerData)));
    pbi->lf_worker.hook = (VP9WorkerHook)vp9_loop_filter_worker;
James Zern's avatar
James Zern committed
925
    if (pbi->max_threads > 1 && !winterface->reset(&pbi->lf_worker)) {
926 927 928 929 930 931 932
      vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
                         "Loop filter thread creation failed");
    }
  }

  if (cm->lf.filter_level) {
    LFWorkerData *const lf_data = (LFWorkerData*)pbi->lf_worker.data1;
933 934
    // Be sure to sync as we might be resuming after a failed frame decode.
    winterface->sync(&pbi->lf_worker);
935 936
    vp9_loop_filter_data_reset(lf_data, get_frame_new_buffer(cm), cm,
                               pbi->mb.plane);
937 938
    vp9_loop_filter_frame_init(cm, cm->lf.filter_level);
  }
939

Yaowu Xu's avatar
Yaowu Xu committed
940 941
  assert(tile_rows <= 4);
  assert(tile_cols <= (1 << 6));
942

943 944
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
945 946
  vpx_memset(cm->above_context, 0,
             sizeof(*cm->above_context) * MAX_MB_PLANE * 2 * aligned_cols);
947

948 949
  vpx_memset(cm->above_seg_context, 0,
             sizeof(*cm->above_seg_context) * aligned_cols);
950

951
  get_tile_buffers(pbi, data, data_end, tile_cols, tile_rows, tile_buffers);
952

953 954 955 956 957 958
  if (pbi->tile_data == NULL ||
      (tile_cols * tile_rows) != pbi->total_tiles) {
    vpx_free(pbi->tile_data);
    CHECK_MEM_ERROR(
        cm,
        pbi->tile_data,
959
        vpx_memalign(32, tile_cols * tile_rows * (sizeof(*pbi->tile_data))));
960 961 962 963
    pbi->total_tiles = tile_rows * tile_cols;
  }

  // Load all tile information into tile_data.
964 965 966
  for (tile_row = 0; tile_row < tile_rows; ++tile_row) {
    for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
      TileInfo tile;
967 968 969 970 971 972 973 974 975 976 977 978
      const TileBuffer *const buf = &tile_buffers[tile_row][tile_col];
      tile_data = pbi->tile_data + tile_cols * tile_row + tile_col;
      tile_data->cm = cm;
      tile_data->xd = pbi->mb;
      tile_data->xd.corrupted = 0;
      vp9_tile_init(&tile, tile_data->cm, tile_row, tile_col);
      setup_token_decoder(buf->data, data_end, buf->size, &cm->error,
                          &tile_data->bit_reader, pbi->decrypt_cb,
                          pbi->decrypt_state);
      init_macroblockd(cm, &tile_data->xd);
    }
  }
979

980 981 982 983 984 985 986 987 988 989 990 991 992 993
  for (tile_row = 0; tile_row < tile_rows; ++tile_row) {
    TileInfo tile;
    vp9_tile_set_row(&tile, cm, tile_row);
    for (mi_row = tile.mi_row_start; mi_row < tile.mi_row_end;
         mi_row += MI_BLOCK_SIZE) {
      for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
        const int col = pbi->inv_tile_order ?
                        tile_cols - tile_col - 1 : tile_col;
        tile_data = pbi->tile_data + tile_cols * tile_row + col;
        vp9_tile_set_col(&tile, tile_data->cm, col);
        vp9_zero(tile_data->xd.left_context);
        vp9_zero(tile_data->xd.left_seg_context);
        for (mi_col = tile.mi_col_start; mi_col < tile.mi_col_end;
             mi_col += MI_BLOCK_SIZE) {
994 995
          decode_partition(pbi, &tile_data->xd, &cm->counts, &tile, mi_row,
                           mi_col, &tile_data->bit_reader, BLOCK_64X64);
996
        }
997
        pbi->mb.corrupted |= tile_data->xd.corrupted;
998 999 1000
        if (pbi->mb.corrupted)
            vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                               "Failed to decode tile data");
1001 1002
      }
      // Loopfilter one row.
1003
      if (cm->lf.filter_level) {
1004 1005 1006 1007 1008 1009 1010 1011 1012
        const int lf_start = mi_row - MI_BLOCK_SIZE;
        LFWorkerData *const lf_data = (LFWorkerData*)pbi->lf_worker.data1;

        // delay the loopfilter by 1 macroblock row.
        if (lf_start < 0) continue;

        // decoding has completed: finish up the loop filter in this thread.
        if (mi_row + MI_BLOCK_SIZE >= cm->mi_rows) continue;

James Zern's avatar
James Zern committed
1013
        winterface->sync(&pbi->lf_worker);
1014 1015 1016
        lf_data->start = lf_start;
        lf_data->stop = mi_row;
        if (pbi->max_threads > 1) {
James Zern's avatar
James Zern committed
1017
          winterface->launch(&pbi->lf_worker);
1018
        } else {
James Zern's avatar
James Zern committed
1019
          winterface->execute(&pbi->lf_worker);
1020 1021
        }
      }
1022 1023 1024 1025 1026 1027
      // After loopfiltering, the last 7 row pixels in each superblock row may
      // still be changed by the longest loopfilter of the next superblock
      // row.
      if (pbi->frame_parallel_decode)
        vp9_frameworker_broadcast(pbi->cur_buf,
                                  mi_row << MI_BLOCK_SIZE_LOG2);
1028 1029
    }
  }
1030

1031
  // Loopfilter remaining rows in the frame.
1032
  if (cm->lf.filter_level) {
1033
    LFWorkerData *const lf_data = (LFWorkerData*)pbi->lf_worker.data1;
James Zern's avatar
James Zern committed
1034
    winterface->sync(&pbi->lf_worker);
1035 1036
    lf_data->start = lf_data->stop;
    lf_data->stop = cm->mi_rows;
James Zern's avatar
James Zern committed
1037
    winterface->execute(&pbi->lf_worker);
1038 1039 1040 1041 1042
  }

  // Get last tile data.
  tile_data = pbi->tile_data + tile_cols * tile_rows - 1;

1043 1044
  if (pbi->frame_parallel_decode)
    vp9_frameworker_broadcast(pbi->cur_buf, INT_MAX);
1045
  return vp9_reader_find_end(&tile_data->bit_reader);
1046 1047
}

1048 1049
static int tile_worker_hook(TileWorkerData *const tile_data,
                            const TileInfo *const tile) {
1050 1051
  int mi_row, mi_col;

1052 1053 1054 1055 1056 1057 1058 1059 1060
  if (setjmp(tile_data->error_info.jmp)) {
    tile_data->error_info.setjmp = 0;
    tile_data->xd.corrupted = 1;
    return 0;
  }

  tile_data->error_info.setjmp = 1;
  tile_data->xd.error_info = &tile_data->error_info;

1061 1062 1063 1064 1065
  for (mi_row = tile->mi_row_start; mi_row < tile->mi_row_end;
       mi_row += MI_BLOCK_SIZE) {
    vp9_zero(tile_data->xd.left_context);
    vp9_zero(tile_data->xd.left_seg_context);
    for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
1066
         mi_col += MI_BLOCK_SIZE) {
1067
      decode_partition(tile_data->pbi, &tile_data->xd, &tile_data->counts,
1068 1069
                       tile, mi_row, mi_col, &tile_data->bit_reader,
                       BLOCK_64X64);
1070
    }