Move aom source to a sub-directory under media/libaom

There is no damned reason to treat this differently than any other media lib given its license and there never was.

18 files changed, 0 insertions, 10205 deletions

diff --git a/third_party/aom/av1/decoder/accounting.c b/third_party/aom/av1/decoder/accounting.c
deleted file mode 100644
index 8d8f3dfdb..000000000
--- a/third_party/aom/av1/decoder/accounting.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "aom/aom_integer.h"
-#include "av1/decoder/accounting.h"
-
-static int aom_accounting_hash(const char *str) {
-  uint32_t val;
-  const unsigned char *ustr;
-  val = 0;
-  ustr = (const unsigned char *)str;
-  /* This is about the worst hash one can design, but it should be good enough
-     here. */
-  while (*ustr) val += *ustr++;
-  return val % AOM_ACCOUNTING_HASH_SIZE;
-}
-
-/* Dictionary lookup based on an open-addressing hash table. */
-int aom_accounting_dictionary_lookup(Accounting *accounting, const char *str) {
-  int hash;
-  size_t len;
-  AccountingDictionary *dictionary;
-  dictionary = &accounting->syms.dictionary;
-  hash = aom_accounting_hash(str);
-  while (accounting->hash_dictionary[hash] != -1) {
-    if (strcmp(dictionary->strs[accounting->hash_dictionary[hash]], str) == 0) {
-      return accounting->hash_dictionary[hash];
-    }
-    hash++;
-    if (hash == AOM_ACCOUNTING_HASH_SIZE) hash = 0;
-  }
-  /* No match found. */
-  assert(dictionary->num_strs + 1 < MAX_SYMBOL_TYPES);
-  accounting->hash_dictionary[hash] = dictionary->num_strs;
-  len = strlen(str);
-  dictionary->strs[dictionary->num_strs] = malloc(len + 1);
-  snprintf(dictionary->strs[dictionary->num_strs], len + 1, "%s", str);
-  dictionary->num_strs++;
-  return dictionary->num_strs - 1;
-}
-
-void aom_accounting_init(Accounting *accounting) {
-  int i;
-  accounting->num_syms_allocated = 1000;
-  accounting->syms.syms =
-      malloc(sizeof(AccountingSymbol) * accounting->num_syms_allocated);
-  accounting->syms.dictionary.num_strs = 0;
-  assert(AOM_ACCOUNTING_HASH_SIZE > 2 * MAX_SYMBOL_TYPES);
-  for (i = 0; i < AOM_ACCOUNTING_HASH_SIZE; i++)
-    accounting->hash_dictionary[i] = -1;
-  aom_accounting_reset(accounting);
-}
-
-void aom_accounting_reset(Accounting *accounting) {
-  accounting->syms.num_syms = 0;
-  accounting->syms.num_binary_syms = 0;
-  accounting->syms.num_multi_syms = 0;
-  accounting->context.x = -1;
-  accounting->context.y = -1;
-  accounting->last_tell_frac = 0;
-}
-
-void aom_accounting_clear(Accounting *accounting) {
-  int i;
-  AccountingDictionary *dictionary;
-  free(accounting->syms.syms);
-  dictionary = &accounting->syms.dictionary;
-  for (i = 0; i < dictionary->num_strs; i++) {
-    free(dictionary->strs[i]);
-  }
-}
-
-void aom_accounting_set_context(Accounting *accounting, int16_t x, int16_t y) {
-  accounting->context.x = x;
-  accounting->context.y = y;
-}
-
-void aom_accounting_record(Accounting *accounting, const char *str,
-                           uint32_t bits) {
-  AccountingSymbol sym;
-  // Reuse previous symbol if it has the same context and symbol id.
-  if (accounting->syms.num_syms) {
-    AccountingSymbol *last_sym;
-    last_sym = &accounting->syms.syms[accounting->syms.num_syms - 1];
-    if (memcmp(&last_sym->context, &accounting->context,
-               sizeof(AccountingSymbolContext)) == 0) {
-      uint32_t id;
-      id = aom_accounting_dictionary_lookup(accounting, str);
-      if (id == last_sym->id) {
-        last_sym->bits += bits;
-        last_sym->samples++;
-        return;
-      }
-    }
-  }
-  sym.context = accounting->context;
-  sym.samples = 1;
-  sym.bits = bits;
-  sym.id = aom_accounting_dictionary_lookup(accounting, str);
-  assert(sym.id <= 255);
-  if (accounting->syms.num_syms == accounting->num_syms_allocated) {
-    accounting->num_syms_allocated *= 2;
-    accounting->syms.syms =
-        realloc(accounting->syms.syms,
-                sizeof(AccountingSymbol) * accounting->num_syms_allocated);
-    assert(accounting->syms.syms != NULL);
-  }
-  accounting->syms.syms[accounting->syms.num_syms++] = sym;
-}
-
-void aom_accounting_dump(Accounting *accounting) {
-  int i;
-  AccountingSymbol *sym;
-  printf("\n----- Number of recorded syntax elements = %d -----\n",
-         accounting->syms.num_syms);
-  printf("----- Total number of symbol calls = %d (%d binary) -----\n",
-         accounting->syms.num_multi_syms + accounting->syms.num_binary_syms,
-         accounting->syms.num_binary_syms);
-  for (i = 0; i < accounting->syms.num_syms; i++) {
-    sym = &accounting->syms.syms[i];
-    printf("%s x: %d, y: %d bits: %f samples: %d\n",
-           accounting->syms.dictionary.strs[sym->id], sym->context.x,
-           sym->context.y, (float)sym->bits / 8.0, sym->samples);
-  }
-}
diff --git a/third_party/aom/av1/decoder/accounting.h b/third_party/aom/av1/decoder/accounting.h
deleted file mode 100644
index 288e5e63e..000000000
--- a/third_party/aom/av1/decoder/accounting.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-#ifndef AOM_AV1_DECODER_ACCOUNTING_H_
-#define AOM_AV1_DECODER_ACCOUNTING_H_
-#include <stdlib.h>
-#include "aom/aomdx.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif  // __cplusplus
-
-#define AOM_ACCOUNTING_HASH_SIZE (1021)
-
-/* Max number of entries for symbol types in the dictionary (increase as
-   necessary). */
-#define MAX_SYMBOL_TYPES (256)
-
-/*The resolution of fractional-precision bit usage measurements, i.e.,
-   3 => 1/8th bits.*/
-#define AOM_ACCT_BITRES (3)
-
-typedef struct {
-  int16_t x;
-  int16_t y;
-} AccountingSymbolContext;
-
-typedef struct {
-  AccountingSymbolContext context;
-  uint32_t id;
-  /** Number of bits in units of 1/8 bit. */
-  uint32_t bits;
-  uint32_t samples;
-} AccountingSymbol;
-
-/** Dictionary for translating strings into id. */
-typedef struct {
-  char *(strs[MAX_SYMBOL_TYPES]);
-  int num_strs;
-} AccountingDictionary;
-
-typedef struct {
-  /** All recorded symbols decoded. */
-  AccountingSymbol *syms;
-  /** Number of syntax actually recorded. */
-  int num_syms;
-  /** Raw symbol decoding calls for non-binary values. */
-  int num_multi_syms;
-  /** Raw binary symbol decoding calls. */
-  int num_binary_syms;
-  /** Dictionary for translating strings into id. */
-  AccountingDictionary dictionary;
-} AccountingSymbols;
-
-struct Accounting {
-  AccountingSymbols syms;
-  /** Size allocated for symbols (not all may be used). */
-  int num_syms_allocated;
-  int16_t hash_dictionary[AOM_ACCOUNTING_HASH_SIZE];
-  AccountingSymbolContext context;
-  uint32_t last_tell_frac;
-};
-
-void aom_accounting_init(Accounting *accounting);
-void aom_accounting_reset(Accounting *accounting);
-void aom_accounting_clear(Accounting *accounting);
-void aom_accounting_set_context(Accounting *accounting, int16_t x, int16_t y);
-int aom_accounting_dictionary_lookup(Accounting *accounting, const char *str);
-void aom_accounting_record(Accounting *accounting, const char *str,
-                           uint32_t bits);
-void aom_accounting_dump(Accounting *accounting);
-#ifdef __cplusplus
-}  // extern "C"
-#endif  // __cplusplus
-#endif  // AOM_AV1_DECODER_ACCOUNTING_H_
diff --git a/third_party/aom/av1/decoder/decodeframe.c b/third_party/aom/av1/decoder/decodeframe.c
deleted file mode 100644
index 31f14b531..000000000
--- a/third_party/aom/av1/decoder/decodeframe.c
+++ /dev/null
@@ -1,5567 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include <assert.h>
-#include <stddef.h>
-
-#include "config/aom_config.h"
-#include "config/aom_dsp_rtcd.h"
-#include "config/aom_scale_rtcd.h"
-#include "config/av1_rtcd.h"
-
-#include "aom/aom_codec.h"
-#include "aom_dsp/aom_dsp_common.h"
-#include "aom_dsp/binary_codes_reader.h"
-#include "aom_dsp/bitreader.h"
-#include "aom_dsp/bitreader_buffer.h"
-#include "aom_mem/aom_mem.h"
-#include "aom_ports/aom_timer.h"
-#include "aom_ports/mem.h"
-#include "aom_ports/mem_ops.h"
-#include "aom_scale/aom_scale.h"
-#include "aom_util/aom_thread.h"
-
-#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
-#include "aom_util/debug_util.h"
-#endif  // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
-
-#include "av1/common/alloccommon.h"
-#include "av1/common/cdef.h"
-#include "av1/common/cfl.h"
-#if CONFIG_INSPECTION
-#include "av1/decoder/inspection.h"
-#endif
-#include "av1/common/common.h"
-#include "av1/common/entropy.h"
-#include "av1/common/entropymode.h"
-#include "av1/common/entropymv.h"
-#include "av1/common/frame_buffers.h"
-#include "av1/common/idct.h"
-#include "av1/common/mvref_common.h"
-#include "av1/common/pred_common.h"
-#include "av1/common/quant_common.h"
-#include "av1/common/reconinter.h"
-#include "av1/common/reconintra.h"
-#include "av1/common/resize.h"
-#include "av1/common/seg_common.h"
-#include "av1/common/thread_common.h"
-#include "av1/common/tile_common.h"
-#include "av1/common/warped_motion.h"
-#include "av1/common/obmc.h"
-#include "av1/decoder/decodeframe.h"
-#include "av1/decoder/decodemv.h"
-#include "av1/decoder/decoder.h"
-#include "av1/decoder/decodetxb.h"
-#include "av1/decoder/detokenize.h"
-
-#define ACCT_STR __func__
-
-// This is needed by ext_tile related unit tests.
-#define EXT_TILE_DEBUG 1
-#define MC_TEMP_BUF_PELS                       \
-  (((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2) * \
-   ((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2))
-
-// Checks that the remaining bits start with a 1 and ends with 0s.
-// It consumes an additional byte, if already byte aligned before the check.
-int av1_check_trailing_bits(AV1Decoder *pbi, struct aom_read_bit_buffer *rb) {
-  AV1_COMMON *const cm = &pbi->common;
-  // bit_offset is set to 0 (mod 8) when the reader is already byte aligned
-  int bits_before_alignment = 8 - rb->bit_offset % 8;
-  int trailing = aom_rb_read_literal(rb, bits_before_alignment);
-  if (trailing != (1 << (bits_before_alignment - 1))) {
-    cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-    return -1;
-  }
-  return 0;
-}
-
-// Use only_chroma = 1 to only set the chroma planes
-static void set_planes_to_neutral_grey(const SequenceHeader *const seq_params,
-                                       const YV12_BUFFER_CONFIG *const buf,
-                                       int only_chroma) {
-  if (seq_params->use_highbitdepth) {
-    const int val = 1 << (seq_params->bit_depth - 1);
-    for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {
-      const int is_uv = plane > 0;
-      uint16_t *const base = CONVERT_TO_SHORTPTR(buf->buffers[plane]);
-      // Set the first row to neutral grey. Then copy the first row to all
-      // subsequent rows.
-      if (buf->crop_heights[is_uv] > 0) {
-        aom_memset16(base, val, buf->crop_widths[is_uv]);
-        for (int row_idx = 1; row_idx < buf->crop_heights[is_uv]; row_idx++) {
-          memcpy(&base[row_idx * buf->strides[is_uv]], base,
-                 sizeof(*base) * buf->crop_widths[is_uv]);
-        }
-      }
-    }
-  } else {
-    for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {
-      const int is_uv = plane > 0;
-      for (int row_idx = 0; row_idx < buf->crop_heights[is_uv]; row_idx++) {
-        memset(&buf->buffers[plane][row_idx * buf->uv_stride], 1 << 7,
-               buf->crop_widths[is_uv]);
-      }
-    }
-  }
-}
-
-static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
-                                            MACROBLOCKD *xd,
-                                            aom_reader *const r, int plane,
-                                            int runit_idx);
-
-static void setup_compound_reference_mode(AV1_COMMON *cm) {
-  cm->comp_fwd_ref[0] = LAST_FRAME;
-  cm->comp_fwd_ref[1] = LAST2_FRAME;
-  cm->comp_fwd_ref[2] = LAST3_FRAME;
-  cm->comp_fwd_ref[3] = GOLDEN_FRAME;
-
-  cm->comp_bwd_ref[0] = BWDREF_FRAME;
-  cm->comp_bwd_ref[1] = ALTREF2_FRAME;
-  cm->comp_bwd_ref[2] = ALTREF_FRAME;
-}
-
-static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
-  return len != 0 && len <= (size_t)(end - start);
-}
-
-static TX_MODE read_tx_mode(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-  if (cm->coded_lossless) return ONLY_4X4;
-  return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST;
-}
-
-static REFERENCE_MODE read_frame_reference_mode(
-    const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-  if (frame_is_intra_only(cm)) {
-    return SINGLE_REFERENCE;
-  } else {
-    return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
-  }
-}
-
-static void inverse_transform_block(MACROBLOCKD *xd, int plane,
-                                    const TX_TYPE tx_type,
-                                    const TX_SIZE tx_size, uint8_t *dst,
-                                    int stride, int reduced_tx_set) {
-  struct macroblockd_plane *const pd = &xd->plane[plane];
-  tran_low_t *const dqcoeff = pd->dqcoeff;
-  eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
-  uint16_t scan_line = eob_data->max_scan_line;
-  uint16_t eob = eob_data->eob;
-
-  memcpy(dqcoeff, pd->dqcoeff_block + xd->cb_offset[plane],
-         (scan_line + 1) * sizeof(dqcoeff[0]));
-  av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst, stride,
-                              eob, reduced_tx_set);
-  memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));
-}
-
-static void read_coeffs_tx_intra_block(const AV1_COMMON *const cm,
-                                       MACROBLOCKD *const xd,
-                                       aom_reader *const r, const int plane,
-                                       const int row, const int col,
-                                       const TX_SIZE tx_size) {
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  if (!mbmi->skip) {
-#if TXCOEFF_TIMER
-    struct aom_usec_timer timer;
-    aom_usec_timer_start(&timer);
-#endif
-    av1_read_coeffs_txb_facade(cm, xd, r, plane, row, col, tx_size);
-#if TXCOEFF_TIMER
-    aom_usec_timer_mark(&timer);
-    const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);
-    cm->txcoeff_timer += elapsed_time;
-    ++cm->txb_count;
-#endif
-  }
-}
-
-static void decode_block_void(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                              aom_reader *const r, const int plane,
-                              const int row, const int col,
-                              const TX_SIZE tx_size) {
-  (void)cm;
-  (void)xd;
-  (void)r;
-  (void)plane;
-  (void)row;
-  (void)col;
-  (void)tx_size;
-}
-
-static void predict_inter_block_void(AV1_COMMON *const cm,
-                                     MACROBLOCKD *const xd, int mi_row,
-                                     int mi_col, BLOCK_SIZE bsize) {
-  (void)cm;
-  (void)xd;
-  (void)mi_row;
-  (void)mi_col;
-  (void)bsize;
-}
-
-static void cfl_store_inter_block_void(AV1_COMMON *const cm,
-                                       MACROBLOCKD *const xd) {
-  (void)cm;
-  (void)xd;
-}
-
-static void predict_and_reconstruct_intra_block(
-    const AV1_COMMON *const cm, MACROBLOCKD *const xd, aom_reader *const r,
-    const int plane, const int row, const int col, const TX_SIZE tx_size) {
-  (void)r;
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  PLANE_TYPE plane_type = get_plane_type(plane);
-
-  av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size);
-
-  if (!mbmi->skip) {
-    struct macroblockd_plane *const pd = &xd->plane[plane];
-
-    // tx_type will be read out in av1_read_coeffs_txb_facade
-    const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, tx_size,
-                                            cm->reduced_tx_set_used);
-    eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
-    if (eob_data->eob) {
-      uint8_t *dst =
-          &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
-      inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
-                              cm->reduced_tx_set_used);
-    }
-  }
-  if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) {
-    cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type);
-  }
-}
-
-static void inverse_transform_inter_block(const AV1_COMMON *const cm,
-                                          MACROBLOCKD *const xd,
-                                          aom_reader *const r, const int plane,
-                                          const int blk_row, const int blk_col,
-                                          const TX_SIZE tx_size) {
-  (void)r;
-  PLANE_TYPE plane_type = get_plane_type(plane);
-  const struct macroblockd_plane *const pd = &xd->plane[plane];
-
-  // tx_type will be read out in av1_read_coeffs_txb_facade
-  const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, blk_row, blk_col,
-                                          tx_size, cm->reduced_tx_set_used);
-
-  uint8_t *dst =
-      &pd->dst
-           .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]];
-  inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
-                          cm->reduced_tx_set_used);
-#if CONFIG_MISMATCH_DEBUG
-  int pixel_c, pixel_r;
-  BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
-  int blk_w = block_size_wide[bsize];
-  int blk_h = block_size_high[bsize];
-  mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row,
-                  pd->subsampling_x, pd->subsampling_y);
-  mismatch_check_block_tx(dst, pd->dst.stride, cm->frame_offset, plane, pixel_c,
-                          pixel_r, blk_w, blk_h,
-                          xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);
-#endif
-}
-
-static void set_cb_buffer_offsets(MACROBLOCKD *const xd, TX_SIZE tx_size,
-                                  int plane) {
-  xd->cb_offset[plane] += tx_size_wide[tx_size] * tx_size_high[tx_size];
-  xd->txb_offset[plane] =
-      xd->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
-}
-
-static void decode_reconstruct_tx(AV1_COMMON *cm, ThreadData *const td,
-                                  aom_reader *r, MB_MODE_INFO *const mbmi,
-                                  int plane, BLOCK_SIZE plane_bsize,
-                                  int blk_row, int blk_col, int block,
-                                  TX_SIZE tx_size, int *eob_total) {
-  MACROBLOCKD *const xd = &td->xd;
-  const struct macroblockd_plane *const pd = &xd->plane[plane];
-  const TX_SIZE plane_tx_size =
-      plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x,
-                                    pd->subsampling_y)
-            : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
-                                                         blk_col)];
-  // Scale to match transform block unit.
-  const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
-  const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
-
-  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
-
-  if (tx_size == plane_tx_size || plane) {
-    td->read_coeffs_tx_inter_block_visit(cm, xd, r, plane, blk_row, blk_col,
-                                         tx_size);
-
-    td->inverse_tx_inter_block_visit(cm, xd, r, plane, blk_row, blk_col,
-                                     tx_size);
-    eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
-    *eob_total += eob_data->eob;
-    set_cb_buffer_offsets(xd, tx_size, plane);
-  } else {
-    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
-    assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size));
-    assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size));
-    const int bsw = tx_size_wide_unit[sub_txs];
-    const int bsh = tx_size_high_unit[sub_txs];
-    const int sub_step = bsw * bsh;
-
-    assert(bsw > 0 && bsh > 0);
-
-    for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) {
-      for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) {
-        const int offsetr = blk_row + row;
-        const int offsetc = blk_col + col;
-
-        if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
-
-        decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize, offsetr,
-                              offsetc, block, sub_txs, eob_total);
-        block += sub_step;
-      }
-    }
-  }
-}
-
-static void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                        BLOCK_SIZE bsize, int mi_row, int mi_col, int bw,
-                        int bh, int x_mis, int y_mis) {
-  const int num_planes = av1_num_planes(cm);
-
-  const int offset = mi_row * cm->mi_stride + mi_col;
-  const TileInfo *const tile = &xd->tile;
-
-  xd->mi = cm->mi_grid_visible + offset;
-  xd->mi[0] = &cm->mi[offset];
-  // TODO(slavarnway): Generate sb_type based on bwl and bhl, instead of
-  // passing bsize from decode_partition().
-  xd->mi[0]->sb_type = bsize;
-#if CONFIG_RD_DEBUG
-  xd->mi[0]->mi_row = mi_row;
-  xd->mi[0]->mi_col = mi_col;
-#endif
-  xd->cfl.mi_row = mi_row;
-  xd->cfl.mi_col = mi_col;
-
-  assert(x_mis && y_mis);
-  for (int x = 1; x < x_mis; ++x) xd->mi[x] = xd->mi[0];
-  int idx = cm->mi_stride;
-  for (int y = 1; y < y_mis; ++y) {
-    memcpy(&xd->mi[idx], &xd->mi[0], x_mis * sizeof(xd->mi[0]));
-    idx += cm->mi_stride;
-  }
-
-  set_plane_n4(xd, bw, bh, num_planes);
-  set_skip_context(xd, mi_row, mi_col, num_planes);
-
-  // 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
-  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);
-
-  av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row,
-                       mi_col, 0, num_planes);
-}
-
-static void decode_mbmi_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
-                              int mi_row, int mi_col, aom_reader *r,
-                              PARTITION_TYPE partition, BLOCK_SIZE bsize) {
-  AV1_COMMON *const cm = &pbi->common;
-  const SequenceHeader *const seq_params = &cm->seq_params;
-  const int bw = mi_size_wide[bsize];
-  const int bh = mi_size_high[bsize];
-  const int x_mis = AOMMIN(bw, cm->mi_cols - mi_col);
-  const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row);
-
-#if CONFIG_ACCOUNTING
-  aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
-#endif
-  set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
-  xd->mi[0]->partition = partition;
-  av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis);
-  if (bsize >= BLOCK_8X8 &&
-      (seq_params->subsampling_x || seq_params->subsampling_y)) {
-    const BLOCK_SIZE uv_subsize =
-        ss_size_lookup[bsize][seq_params->subsampling_x]
-                      [seq_params->subsampling_y];
-    if (uv_subsize == BLOCK_INVALID)
-      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
-                         "Invalid block size.");
-  }
-
-  int reader_corrupted_flag = aom_reader_has_error(r);
-  aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag);
-}
-
-typedef struct PadBlock {
-  int x0;
-  int x1;
-  int y0;
-  int y1;
-} PadBlock;
-
-static void highbd_build_mc_border(const uint8_t *src8, int src_stride,
-                                   uint8_t *dst8, int dst_stride, int x, int y,
-                                   int b_w, int b_h, int w, int h) {
-  // Get a pointer to the start of the real data for this row.
-  const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
-  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
-  const uint16_t *ref_row = src - x - y * src_stride;
-
-  if (y >= h)
-    ref_row += (h - 1) * src_stride;
-  else if (y > 0)
-    ref_row += y * src_stride;
-
-  do {
-    int right = 0, copy;
-    int left = x < 0 ? -x : 0;
-
-    if (left > b_w) left = b_w;
-
-    if (x + b_w > w) right = x + b_w - w;
-
-    if (right > b_w) right = b_w;
-
-    copy = b_w - left - right;
-
-    if (left) aom_memset16(dst, ref_row[0], left);
-
-    if (copy) memcpy(dst + left, ref_row + x + left, copy * sizeof(uint16_t));
-
-    if (right) aom_memset16(dst + left + copy, ref_row[w - 1], right);
-
-    dst += dst_stride;
-    ++y;
-
-    if (y > 0 && y < h) ref_row += src_stride;
-  } while (--b_h);
-}
-
-static void build_mc_border(const uint8_t *src, int src_stride, uint8_t *dst,
-                            int dst_stride, int x, int y, int b_w, int b_h,
-                            int w, int h) {
-  // Get a pointer to the start of the real data for this row.
-  const uint8_t *ref_row = src - x - y * src_stride;
-
-  if (y >= h)
-    ref_row += (h - 1) * src_stride;
-  else if (y > 0)
-    ref_row += y * src_stride;
-
-  do {
-    int right = 0, copy;
-    int left = x < 0 ? -x : 0;
-
-    if (left > b_w) left = b_w;
-
-    if (x + b_w > w) right = x + b_w - w;
-
-    if (right > b_w) right = b_w;
-
-    copy = b_w - left - right;
-
-    if (left) memset(dst, ref_row[0], left);
-
-    if (copy) memcpy(dst + left, ref_row + x + left, copy);
-
-    if (right) memset(dst + left + copy, ref_row[w - 1], right);
-
-    dst += dst_stride;
-    ++y;
-
-    if (y > 0 && y < h) ref_row += src_stride;
-  } while (--b_h);
-}
-
-static INLINE int update_extend_mc_border_params(
-    const struct scale_factors *const sf, struct buf_2d *const pre_buf,
-    MV32 scaled_mv, PadBlock *block, int subpel_x_mv, int subpel_y_mv,
-    int do_warp, int is_intrabc, int *x_pad, int *y_pad) {
-  const int is_scaled = av1_is_scaled(sf);
-  // Get reference width and height.
-  int frame_width = pre_buf->width;
-  int frame_height = pre_buf->height;
-
-  // Do border extension if there is motion or
-  // width/height is not a multiple of 8 pixels.
-  if ((!is_intrabc) && (!do_warp) &&
-      (is_scaled || scaled_mv.col || scaled_mv.row || (frame_width & 0x7) ||
-       (frame_height & 0x7))) {
-    if (subpel_x_mv || (sf->x_step_q4 != SUBPEL_SHIFTS)) {
-      block->x0 -= AOM_INTERP_EXTEND - 1;
-      block->x1 += AOM_INTERP_EXTEND;
-      *x_pad = 1;
-    }
-
-    if (subpel_y_mv || (sf->y_step_q4 != SUBPEL_SHIFTS)) {
-      block->y0 -= AOM_INTERP_EXTEND - 1;
-      block->y1 += AOM_INTERP_EXTEND;
-      *y_pad = 1;
-    }
-
-    // Skip border extension if block is inside the frame.
-    if (block->x0 < 0 || block->x1 > frame_width - 1 || block->y0 < 0 ||
-        block->y1 > frame_height - 1) {
-      return 1;
-    }
-  }
-  return 0;
-}
-
-static INLINE void extend_mc_border(const struct scale_factors *const sf,
-                                    struct buf_2d *const pre_buf,
-                                    MV32 scaled_mv, PadBlock block,
-                                    int subpel_x_mv, int subpel_y_mv,
-                                    int do_warp, int is_intrabc, int highbd,
-                                    uint8_t *mc_buf, uint8_t **pre,
-                                    int *src_stride) {
-  int x_pad = 0, y_pad = 0;
-  if (update_extend_mc_border_params(sf, pre_buf, scaled_mv, &block,
-                                     subpel_x_mv, subpel_y_mv, do_warp,
-                                     is_intrabc, &x_pad, &y_pad)) {
-    // Get reference block pointer.
-    const uint8_t *const buf_ptr =
-        pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
-    int buf_stride = pre_buf->stride;
-    const int b_w = block.x1 - block.x0;
-    const int b_h = block.y1 - block.y0;
-
-    // Extend the border.
-    if (highbd) {
-      highbd_build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0,
-                             block.y0, b_w, b_h, pre_buf->width,
-                             pre_buf->height);
-    } else {
-      build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0, block.y0, b_w,
-                      b_h, pre_buf->width, pre_buf->height);
-    }
-    *src_stride = b_w;
-    *pre = mc_buf + y_pad * (AOM_INTERP_EXTEND - 1) * b_w +
-           x_pad * (AOM_INTERP_EXTEND - 1);
-  }
-}
-
-static INLINE void dec_calc_subpel_params(
-    MACROBLOCKD *xd, const struct scale_factors *const sf, const MV mv,
-    int plane, const int pre_x, const int pre_y, int x, int y,
-    struct buf_2d *const pre_buf, SubpelParams *subpel_params, int bw, int bh,
-    PadBlock *block, int mi_x, int mi_y, MV32 *scaled_mv, int *subpel_x_mv,
-    int *subpel_y_mv) {
-  struct macroblockd_plane *const pd = &xd->plane[plane];
-  const int is_scaled = av1_is_scaled(sf);
-  if (is_scaled) {
-    int ssx = pd->subsampling_x;
-    int ssy = pd->subsampling_y;
-    int orig_pos_y = (pre_y + y) << SUBPEL_BITS;
-    orig_pos_y += mv.row * (1 << (1 - ssy));
-    int orig_pos_x = (pre_x + x) << SUBPEL_BITS;
-    orig_pos_x += mv.col * (1 << (1 - ssx));
-    int pos_y = sf->scale_value_y(orig_pos_y, sf);
-    int pos_x = sf->scale_value_x(orig_pos_x, sf);
-    pos_x += SCALE_EXTRA_OFF;
-    pos_y += SCALE_EXTRA_OFF;
-
-    const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy);
-    const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx);
-    const int bottom = (pre_buf->height + AOM_INTERP_EXTEND)
-                       << SCALE_SUBPEL_BITS;
-    const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;
-    pos_y = clamp(pos_y, top, bottom);
-    pos_x = clamp(pos_x, left, right);
-
-    subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK;
-    subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
-    subpel_params->xs = sf->x_step_q4;
-    subpel_params->ys = sf->y_step_q4;
-
-    // Get reference block top left coordinate.
-    block->x0 = pos_x >> SCALE_SUBPEL_BITS;
-    block->y0 = pos_y >> SCALE_SUBPEL_BITS;
-
-    // Get reference block bottom right coordinate.
-    block->x1 =
-        ((pos_x + (bw - 1) * subpel_params->xs) >> SCALE_SUBPEL_BITS) + 1;
-    block->y1 =
-        ((pos_y + (bh - 1) * subpel_params->ys) >> SCALE_SUBPEL_BITS) + 1;
-
-    MV temp_mv;
-    temp_mv = clamp_mv_to_umv_border_sb(xd, &mv, bw, bh, pd->subsampling_x,
-                                        pd->subsampling_y);
-    *scaled_mv = av1_scale_mv(&temp_mv, (mi_x + x), (mi_y + y), sf);
-    scaled_mv->row += SCALE_EXTRA_OFF;
-    scaled_mv->col += SCALE_EXTRA_OFF;
-
-    *subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK;
-    *subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK;
-  } else {
-    // Get block position in current frame.
-    int pos_x = (pre_x + x) << SUBPEL_BITS;
-    int pos_y = (pre_y + y) << SUBPEL_BITS;
-
-    const MV mv_q4 = clamp_mv_to_umv_border_sb(
-        xd, &mv, bw, bh, pd->subsampling_x, pd->subsampling_y);
-    subpel_params->xs = subpel_params->ys = SCALE_SUBPEL_SHIFTS;
-    subpel_params->subpel_x = (mv_q4.col & SUBPEL_MASK) << SCALE_EXTRA_BITS;
-    subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS;
-
-    // Get reference block top left coordinate.
-    pos_x += mv_q4.col;
-    pos_y += mv_q4.row;
-    block->x0 = pos_x >> SUBPEL_BITS;
-    block->y0 = pos_y >> SUBPEL_BITS;
-
-    // Get reference block bottom right coordinate.
-    block->x1 = (pos_x >> SUBPEL_BITS) + (bw - 1) + 1;
-    block->y1 = (pos_y >> SUBPEL_BITS) + (bh - 1) + 1;
-
-    scaled_mv->row = mv_q4.row;
-    scaled_mv->col = mv_q4.col;
-    *subpel_x_mv = scaled_mv->col & SUBPEL_MASK;
-    *subpel_y_mv = scaled_mv->row & SUBPEL_MASK;
-  }
-}
-
-static INLINE void dec_build_inter_predictors(const AV1_COMMON *cm,
-                                              MACROBLOCKD *xd, int plane,
-                                              const MB_MODE_INFO *mi,
-                                              int build_for_obmc, int bw,
-                                              int bh, int mi_x, int mi_y) {
-  struct macroblockd_plane *const pd = &xd->plane[plane];
-  int is_compound = has_second_ref(mi);
-  int ref;
-  const int is_intrabc = is_intrabc_block(mi);
-  assert(IMPLIES(is_intrabc, !is_compound));
-  int is_global[2] = { 0, 0 };
-  for (ref = 0; ref < 1 + is_compound; ++ref) {
-    const WarpedMotionParams *const wm = &xd->global_motion[mi->ref_frame[ref]];
-    is_global[ref] = is_global_mv_block(mi, wm->wmtype);
-  }
-
-  const BLOCK_SIZE bsize = mi->sb_type;
-  const int ss_x = pd->subsampling_x;
-  const int ss_y = pd->subsampling_y;
-  int sub8x8_inter = (block_size_wide[bsize] < 8 && ss_x) ||
-                     (block_size_high[bsize] < 8 && ss_y);
-
-  if (is_intrabc) sub8x8_inter = 0;
-
-  // For sub8x8 chroma blocks, we may be covering more than one luma block's
-  // worth of pixels. Thus (mi_x, mi_y) may not be the correct coordinates for
-  // the top-left corner of the prediction source - the correct top-left corner
-  // is at (pre_x, pre_y).
-  const int row_start =
-      (block_size_high[bsize] == 4) && ss_y && !build_for_obmc ? -1 : 0;
-  const int col_start =
-      (block_size_wide[bsize] == 4) && ss_x && !build_for_obmc ? -1 : 0;
-  const int pre_x = (mi_x + MI_SIZE * col_start) >> ss_x;
-  const int pre_y = (mi_y + MI_SIZE * row_start) >> ss_y;
-
-  sub8x8_inter = sub8x8_inter && !build_for_obmc;
-  if (sub8x8_inter) {
-    for (int row = row_start; row <= 0 && sub8x8_inter; ++row) {
-      for (int col = col_start; col <= 0; ++col) {
-        const MB_MODE_INFO *this_mbmi = xd->mi[row * xd->mi_stride + col];
-        if (!is_inter_block(this_mbmi)) sub8x8_inter = 0;
-        if (is_intrabc_block(this_mbmi)) sub8x8_inter = 0;
-      }
-    }
-  }
-
-  if (sub8x8_inter) {
-    // block size
-    const int b4_w = block_size_wide[bsize] >> ss_x;
-    const int b4_h = block_size_high[bsize] >> ss_y;
-    const BLOCK_SIZE plane_bsize = scale_chroma_bsize(bsize, ss_x, ss_y);
-    const int b8_w = block_size_wide[plane_bsize] >> ss_x;
-    const int b8_h = block_size_high[plane_bsize] >> ss_y;
-    assert(!is_compound);
-
-    const struct buf_2d orig_pred_buf[2] = { pd->pre[0], pd->pre[1] };
-
-    int row = row_start;
-    int src_stride;
-    for (int y = 0; y < b8_h; y += b4_h) {
-      int col = col_start;
-      for (int x = 0; x < b8_w; x += b4_w) {
-        MB_MODE_INFO *this_mbmi = xd->mi[row * xd->mi_stride + col];
-        is_compound = has_second_ref(this_mbmi);
-        int tmp_dst_stride = 8;
-        assert(bw < 8 || bh < 8);
-        ConvolveParams conv_params = get_conv_params_no_round(
-            0, plane, xd->tmp_conv_dst, tmp_dst_stride, is_compound, xd->bd);
-        conv_params.use_jnt_comp_avg = 0;
-        struct buf_2d *const dst_buf = &pd->dst;
-        uint8_t *dst = dst_buf->buf + dst_buf->stride * y + x;
-
-        ref = 0;
-        const RefBuffer *ref_buf =
-            &cm->frame_refs[this_mbmi->ref_frame[ref] - LAST_FRAME];
-
-        pd->pre[ref].buf0 =
-            (plane == 1) ? ref_buf->buf->u_buffer : ref_buf->buf->v_buffer;
-        pd->pre[ref].buf =
-            pd->pre[ref].buf0 + scaled_buffer_offset(pre_x, pre_y,
-                                                     ref_buf->buf->uv_stride,
-                                                     &ref_buf->sf);
-        pd->pre[ref].width = ref_buf->buf->uv_crop_width;
-        pd->pre[ref].height = ref_buf->buf->uv_crop_height;
-        pd->pre[ref].stride = ref_buf->buf->uv_stride;
-
-        const struct scale_factors *const sf =
-            is_intrabc ? &cm->sf_identity : &ref_buf->sf;
-        struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref];
-
-        const MV mv = this_mbmi->mv[ref].as_mv;
-
-        uint8_t *pre;
-        SubpelParams subpel_params;
-        PadBlock block;
-        MV32 scaled_mv;
-        int subpel_x_mv, subpel_y_mv;
-        int highbd;
-        WarpTypesAllowed warp_types;
-        warp_types.global_warp_allowed = is_global[ref];
-        warp_types.local_warp_allowed = this_mbmi->motion_mode == WARPED_CAUSAL;
-
-        dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, x, y, pre_buf,
-                               &subpel_params, bw, bh, &block, mi_x, mi_y,
-                               &scaled_mv, &subpel_x_mv, &subpel_y_mv);
-        pre = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
-        src_stride = pre_buf->stride;
-        highbd = xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH;
-        extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv,
-                         subpel_y_mv, 0, is_intrabc, highbd, xd->mc_buf[ref],
-                         &pre, &src_stride);
-        conv_params.do_average = ref;
-        if (is_masked_compound_type(mi->interinter_comp.type)) {
-          // masked compound type has its own average mechanism
-          conv_params.do_average = 0;
-        }
-
-        av1_make_inter_predictor(
-            pre, src_stride, dst, dst_buf->stride, &subpel_params, sf, b4_w,
-            b4_h, &conv_params, this_mbmi->interp_filters, &warp_types,
-            (mi_x >> pd->subsampling_x) + x, (mi_y >> pd->subsampling_y) + y,
-            plane, ref, mi, build_for_obmc, xd, cm->allow_warped_motion);
-
-        ++col;
-      }
-      ++row;
-    }
-
-    for (ref = 0; ref < 2; ++ref) pd->pre[ref] = orig_pred_buf[ref];
-    return;
-  }
-
-  {
-    struct buf_2d *const dst_buf = &pd->dst;
-    uint8_t *const dst = dst_buf->buf;
-    uint8_t *pre[2];
-    SubpelParams subpel_params[2];
-    int src_stride[2];
-    for (ref = 0; ref < 1 + is_compound; ++ref) {
-      const struct scale_factors *const sf =
-          is_intrabc ? &cm->sf_identity : &xd->block_refs[ref]->sf;
-      struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref];
-      const MV mv = mi->mv[ref].as_mv;
-      PadBlock block;
-      MV32 scaled_mv;
-      int subpel_x_mv, subpel_y_mv;
-      int highbd;
-
-      dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, 0, 0, pre_buf,
-                             &subpel_params[ref], bw, bh, &block, mi_x, mi_y,
-                             &scaled_mv, &subpel_x_mv, &subpel_y_mv);
-      pre[ref] = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
-      src_stride[ref] = pre_buf->stride;
-      highbd = xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH;
-
-      WarpTypesAllowed warp_types;
-      warp_types.global_warp_allowed = is_global[ref];
-      warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL;
-      int do_warp = (bw >= 8 && bh >= 8 &&
-                     av1_allow_warp(mi, &warp_types,
-                                    &xd->global_motion[mi->ref_frame[ref]],
-                                    build_for_obmc, subpel_params[ref].xs,
-                                    subpel_params[ref].ys, NULL));
-      do_warp = (do_warp && xd->cur_frame_force_integer_mv == 0);
-
-      extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv, subpel_y_mv,
-                       do_warp, is_intrabc, highbd, xd->mc_buf[ref], &pre[ref],
-                       &src_stride[ref]);
-    }
-
-    ConvolveParams conv_params = get_conv_params_no_round(
-        0, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
-    av1_jnt_comp_weight_assign(cm, mi, 0, &conv_params.fwd_offset,
-                               &conv_params.bck_offset,
-                               &conv_params.use_jnt_comp_avg, is_compound);
-
-    for (ref = 0; ref < 1 + is_compound; ++ref) {
-      const struct scale_factors *const sf =
-          is_intrabc ? &cm->sf_identity : &xd->block_refs[ref]->sf;
-      WarpTypesAllowed warp_types;
-      warp_types.global_warp_allowed = is_global[ref];
-      warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL;
-      conv_params.do_average = ref;
-      if (is_masked_compound_type(mi->interinter_comp.type)) {
-        // masked compound type has its own average mechanism
-        conv_params.do_average = 0;
-      }
-
-      if (ref && is_masked_compound_type(mi->interinter_comp.type))
-        av1_make_masked_inter_predictor(
-            pre[ref], src_stride[ref], dst, dst_buf->stride,
-            &subpel_params[ref], sf, bw, bh, &conv_params, mi->interp_filters,
-            plane, &warp_types, mi_x >> pd->subsampling_x,
-            mi_y >> pd->subsampling_y, ref, xd, cm->allow_warped_motion);
-      else
-        av1_make_inter_predictor(
-            pre[ref], src_stride[ref], dst, dst_buf->stride,
-            &subpel_params[ref], sf, bw, bh, &conv_params, mi->interp_filters,
-            &warp_types, mi_x >> pd->subsampling_x, mi_y >> pd->subsampling_y,
-            plane, ref, mi, build_for_obmc, xd, cm->allow_warped_motion);
-    }
-  }
-}
-
-static void dec_build_inter_predictors_for_planes(const AV1_COMMON *cm,
-                                                  MACROBLOCKD *xd,
-                                                  BLOCK_SIZE bsize, int mi_row,
-                                                  int mi_col, int plane_from,
-                                                  int plane_to) {
-  int plane;
-  const int mi_x = mi_col * MI_SIZE;
-  const int mi_y = mi_row * MI_SIZE;
-  for (plane = plane_from; plane <= plane_to; ++plane) {
-    const struct macroblockd_plane *pd = &xd->plane[plane];
-    const int bw = pd->width;
-    const int bh = pd->height;
-
-    if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
-                             pd->subsampling_y))
-      continue;
-
-    dec_build_inter_predictors(cm, xd, plane, xd->mi[0], 0, bw, bh, mi_x, mi_y);
-  }
-}
-
-static void dec_build_inter_predictors_sby(const AV1_COMMON *cm,
-                                           MACROBLOCKD *xd, int mi_row,
-                                           int mi_col, BUFFER_SET *ctx,
-                                           BLOCK_SIZE bsize) {
-  dec_build_inter_predictors_for_planes(cm, xd, bsize, mi_row, mi_col, 0, 0);
-
-  if (is_interintra_pred(xd->mi[0])) {
-    BUFFER_SET default_ctx = { { xd->plane[0].dst.buf, NULL, NULL },
-                               { xd->plane[0].dst.stride, 0, 0 } };
-    if (!ctx) ctx = &default_ctx;
-    av1_build_interintra_predictors_sbp(cm, xd, xd->plane[0].dst.buf,
-                                        xd->plane[0].dst.stride, ctx, 0, bsize);
-  }
-}
-
-static void dec_build_inter_predictors_sbuv(const AV1_COMMON *cm,
-                                            MACROBLOCKD *xd, int mi_row,
-                                            int mi_col, BUFFER_SET *ctx,
-                                            BLOCK_SIZE bsize) {
-  dec_build_inter_predictors_for_planes(cm, xd, bsize, mi_row, mi_col, 1,
-                                        MAX_MB_PLANE - 1);
-
-  if (is_interintra_pred(xd->mi[0])) {
-    BUFFER_SET default_ctx = {
-      { NULL, xd->plane[1].dst.buf, xd->plane[2].dst.buf },
-      { 0, xd->plane[1].dst.stride, xd->plane[2].dst.stride }
-    };
-    if (!ctx) ctx = &default_ctx;
-    av1_build_interintra_predictors_sbuv(
-        cm, xd, xd->plane[1].dst.buf, xd->plane[2].dst.buf,
-        xd->plane[1].dst.stride, xd->plane[2].dst.stride, ctx, bsize);
-  }
-}
-
-static void dec_build_inter_predictors_sb(const AV1_COMMON *cm, MACROBLOCKD *xd,
-                                          int mi_row, int mi_col,
-                                          BUFFER_SET *ctx, BLOCK_SIZE bsize) {
-  const int num_planes = av1_num_planes(cm);
-  dec_build_inter_predictors_sby(cm, xd, mi_row, mi_col, ctx, bsize);
-  if (num_planes > 1)
-    dec_build_inter_predictors_sbuv(cm, xd, mi_row, mi_col, ctx, bsize);
-}
-
-static INLINE void dec_build_prediction_by_above_pred(
-    MACROBLOCKD *xd, int rel_mi_col, uint8_t above_mi_width,
-    MB_MODE_INFO *above_mbmi, void *fun_ctxt, const int num_planes) {
-  struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;
-  const int above_mi_col = ctxt->mi_col + rel_mi_col;
-  int mi_x, mi_y;
-  MB_MODE_INFO backup_mbmi = *above_mbmi;
-
-  av1_setup_build_prediction_by_above_pred(xd, rel_mi_col, above_mi_width,
-                                           &backup_mbmi, ctxt, num_planes);
-  mi_x = above_mi_col << MI_SIZE_LOG2;
-  mi_y = ctxt->mi_row << MI_SIZE_LOG2;
-
-  const BLOCK_SIZE bsize = xd->mi[0]->sb_type;
-
-  for (int j = 0; j < num_planes; ++j) {
-    const struct macroblockd_plane *pd = &xd->plane[j];
-    int bw = (above_mi_width * MI_SIZE) >> pd->subsampling_x;
-    int bh = clamp(block_size_high[bsize] >> (pd->subsampling_y + 1), 4,
-                   block_size_high[BLOCK_64X64] >> (pd->subsampling_y + 1));
-
-    if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 0)) continue;
-    dec_build_inter_predictors(ctxt->cm, xd, j, &backup_mbmi, 1, bw, bh, mi_x,
-                               mi_y);
-  }
-}
-
-static void dec_build_prediction_by_above_preds(
-    const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
-    uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],
-    int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {
-  if (!xd->up_available) return;
-
-  // Adjust mb_to_bottom_edge to have the correct value for the OBMC
-  // prediction block. This is half the height of the original block,
-  // except for 128-wide blocks, where we only use a height of 32.
-  int this_height = xd->n4_h * MI_SIZE;
-  int pred_height = AOMMIN(this_height / 2, 32);
-  xd->mb_to_bottom_edge += (this_height - pred_height) * 8;
-
-  struct build_prediction_ctxt ctxt = { cm,         mi_row,
-                                        mi_col,     tmp_buf,
-                                        tmp_width,  tmp_height,
-                                        tmp_stride, xd->mb_to_right_edge };
-  BLOCK_SIZE bsize = xd->mi[0]->sb_type;
-  foreach_overlappable_nb_above(cm, xd, mi_col,
-                                max_neighbor_obmc[mi_size_wide_log2[bsize]],
-                                dec_build_prediction_by_above_pred, &ctxt);
-
-  xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8);
-  xd->mb_to_right_edge = ctxt.mb_to_far_edge;
-  xd->mb_to_bottom_edge -= (this_height - pred_height) * 8;
-}
-
-static INLINE void dec_build_prediction_by_left_pred(
-    MACROBLOCKD *xd, int rel_mi_row, uint8_t left_mi_height,
-    MB_MODE_INFO *left_mbmi, void *fun_ctxt, const int num_planes) {
-  struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;
-  const int left_mi_row = ctxt->mi_row + rel_mi_row;
-  int mi_x, mi_y;
-  MB_MODE_INFO backup_mbmi = *left_mbmi;
-
-  av1_setup_build_prediction_by_left_pred(xd, rel_mi_row, left_mi_height,
-                                          &backup_mbmi, ctxt, num_planes);
-  mi_x = ctxt->mi_col << MI_SIZE_LOG2;
-  mi_y = left_mi_row << MI_SIZE_LOG2;
-  const BLOCK_SIZE bsize = xd->mi[0]->sb_type;
-
-  for (int j = 0; j < num_planes; ++j) {
-    const struct macroblockd_plane *pd = &xd->plane[j];
-    int bw = clamp(block_size_wide[bsize] >> (pd->subsampling_x + 1), 4,
-                   block_size_wide[BLOCK_64X64] >> (pd->subsampling_x + 1));
-    int bh = (left_mi_height << MI_SIZE_LOG2) >> pd->subsampling_y;
-
-    if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 1)) continue;
-    dec_build_inter_predictors(ctxt->cm, xd, j, &backup_mbmi, 1, bw, bh, mi_x,
-                               mi_y);
-  }
-}
-
-static void dec_build_prediction_by_left_preds(
-    const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
-    uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],
-    int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {
-  if (!xd->left_available) return;
-
-  // Adjust mb_to_right_edge to have the correct value for the OBMC
-  // prediction block. This is half the width of the original block,
-  // except for 128-wide blocks, where we only use a width of 32.
-  int this_width = xd->n4_w * MI_SIZE;
-  int pred_width = AOMMIN(this_width / 2, 32);
-  xd->mb_to_right_edge += (this_width - pred_width) * 8;
-
-  struct build_prediction_ctxt ctxt = { cm,         mi_row,
-                                        mi_col,     tmp_buf,
-                                        tmp_width,  tmp_height,
-                                        tmp_stride, xd->mb_to_bottom_edge };
-  BLOCK_SIZE bsize = xd->mi[0]->sb_type;
-  foreach_overlappable_nb_left(cm, xd, mi_row,
-                               max_neighbor_obmc[mi_size_high_log2[bsize]],
-                               dec_build_prediction_by_left_pred, &ctxt);
-
-  xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8);
-  xd->mb_to_right_edge -= (this_width - pred_width) * 8;
-  xd->mb_to_bottom_edge = ctxt.mb_to_far_edge;
-}
-
-static void dec_build_obmc_inter_predictors_sb(const AV1_COMMON *cm,
-                                               MACROBLOCKD *xd, int mi_row,
-                                               int mi_col) {
-  const int num_planes = av1_num_planes(cm);
-  uint8_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE];
-  int dst_stride1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
-  int dst_stride2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
-  int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
-  int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
-  int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
-  int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
-
-  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
-    int len = sizeof(uint16_t);
-    dst_buf1[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0]);
-    dst_buf1[1] =
-        CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * len);
-    dst_buf1[2] =
-        CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2 * len);
-    dst_buf2[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1]);
-    dst_buf2[1] =
-        CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * len);
-    dst_buf2[2] =
-        CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2 * len);
-  } else {
-    dst_buf1[0] = xd->tmp_obmc_bufs[0];
-    dst_buf1[1] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE;
-    dst_buf1[2] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2;
-    dst_buf2[0] = xd->tmp_obmc_bufs[1];
-    dst_buf2[1] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE;
-    dst_buf2[2] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2;
-  }
-  dec_build_prediction_by_above_preds(cm, xd, mi_row, mi_col, dst_buf1,
-                                      dst_width1, dst_height1, dst_stride1);
-  dec_build_prediction_by_left_preds(cm, xd, mi_row, mi_col, dst_buf2,
-                                     dst_width2, dst_height2, dst_stride2);
-  av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type, get_frame_new_buffer(cm),
-                       mi_row, mi_col, 0, num_planes);
-  av1_build_obmc_inter_prediction(cm, xd, mi_row, mi_col, dst_buf1, dst_stride1,
-                                  dst_buf2, dst_stride2);
-}
-
-static void cfl_store_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd) {
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  if (store_cfl_required(cm, xd)) {
-    cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
-  }
-}
-
-static void predict_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                                int mi_row, int mi_col, BLOCK_SIZE bsize) {
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  const int num_planes = av1_num_planes(cm);
-  for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
-    const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
-    if (frame < LAST_FRAME) {
-      assert(is_intrabc_block(mbmi));
-      assert(frame == INTRA_FRAME);
-      assert(ref == 0);
-    } else {
-      RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];
-
-      xd->block_refs[ref] = ref_buf;
-      av1_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col, &ref_buf->sf,
-                           num_planes);
-    }
-  }
-
-  dec_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, bsize);
-  if (mbmi->motion_mode == OBMC_CAUSAL) {
-    dec_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col);
-  }
-#if CONFIG_MISMATCH_DEBUG
-  for (int plane = 0; plane < num_planes; ++plane) {
-    const struct macroblockd_plane *pd = &xd->plane[plane];
-    int pixel_c, pixel_r;
-    mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, pd->subsampling_x,
-                    pd->subsampling_y);
-    if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
-                             pd->subsampling_y))
-      continue;
-    mismatch_check_block_pre(pd->dst.buf, pd->dst.stride, cm->frame_offset,
-                             plane, pixel_c, pixel_r, pd->width, pd->height,
-                             xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);
-  }
-#endif
-}
-
-static void set_color_index_map_offset(MACROBLOCKD *const xd, int plane,
-                                       aom_reader *r) {
-  (void)r;
-  Av1ColorMapParam params;
-  const MB_MODE_INFO *const mbmi = xd->mi[0];
-  av1_get_block_dimensions(mbmi->sb_type, plane, xd, &params.plane_width,
-                           &params.plane_height, NULL, NULL);
-  xd->color_index_map_offset[plane] += params.plane_width * params.plane_height;
-}
-
-static void decode_token_recon_block(AV1Decoder *const pbi,
-                                     ThreadData *const td, int mi_row,
-                                     int mi_col, aom_reader *r,
-                                     BLOCK_SIZE bsize) {
-  AV1_COMMON *const cm = &pbi->common;
-  MACROBLOCKD *const xd = &td->xd;
-  const int num_planes = av1_num_planes(cm);
-
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  CFL_CTX *const cfl = &xd->cfl;
-  cfl->is_chroma_reference = is_chroma_reference(
-      mi_row, mi_col, bsize, cfl->subsampling_x, cfl->subsampling_y);
-
-  if (!is_inter_block(mbmi)) {
-    int row, col;
-    assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x,
-                                         xd->plane[0].subsampling_y));
-    const int max_blocks_wide = max_block_wide(xd, bsize, 0);
-    const int max_blocks_high = max_block_high(xd, bsize, 0);
-    const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
-    int mu_blocks_wide =
-        block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
-    int mu_blocks_high =
-        block_size_high[max_unit_bsize] >> tx_size_high_log2[0];
-    mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
-    mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
-
-    for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
-      for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
-        for (int plane = 0; plane < num_planes; ++plane) {
-          const struct macroblockd_plane *const pd = &xd->plane[plane];
-          if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
-                                   pd->subsampling_y))
-            continue;
-
-          const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
-          const int stepr = tx_size_high_unit[tx_size];
-          const int stepc = tx_size_wide_unit[tx_size];
-
-          const int unit_height = ROUND_POWER_OF_TWO(
-              AOMMIN(mu_blocks_high + row, max_blocks_high), pd->subsampling_y);
-          const int unit_width = ROUND_POWER_OF_TWO(
-              AOMMIN(mu_blocks_wide + col, max_blocks_wide), pd->subsampling_x);
-
-          for (int blk_row = row >> pd->subsampling_y; blk_row < unit_height;
-               blk_row += stepr) {
-            for (int blk_col = col >> pd->subsampling_x; blk_col < unit_width;
-                 blk_col += stepc) {
-              td->read_coeffs_tx_intra_block_visit(cm, xd, r, plane, blk_row,
-                                                   blk_col, tx_size);
-              td->predict_and_recon_intra_block_visit(cm, xd, r, plane, blk_row,
-                                                      blk_col, tx_size);
-              set_cb_buffer_offsets(xd, tx_size, plane);
-            }
-          }
-        }
-      }
-    }
-  } else {
-    td->predict_inter_block_visit(cm, xd, mi_row, mi_col, bsize);
-    // Reconstruction
-    if (!mbmi->skip) {
-      int eobtotal = 0;
-
-      const int max_blocks_wide = max_block_wide(xd, bsize, 0);
-      const int max_blocks_high = max_block_high(xd, bsize, 0);
-      int row, col;
-
-      const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
-      assert(max_unit_bsize ==
-             get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x,
-                                  xd->plane[0].subsampling_y));
-      int mu_blocks_wide =
-          block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
-      int mu_blocks_high =
-          block_size_high[max_unit_bsize] >> tx_size_high_log2[0];
-
-      mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
-      mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
-
-      for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
-        for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
-          for (int plane = 0; plane < num_planes; ++plane) {
-            const struct macroblockd_plane *const pd = &xd->plane[plane];
-            if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
-                                     pd->subsampling_y))
-              continue;
-            const BLOCK_SIZE bsizec =
-                scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y);
-            const BLOCK_SIZE plane_bsize = get_plane_block_size(
-                bsizec, pd->subsampling_x, pd->subsampling_y);
-
-            const TX_SIZE max_tx_size =
-                get_vartx_max_txsize(xd, plane_bsize, plane);
-            const int bh_var_tx = tx_size_high_unit[max_tx_size];
-            const int bw_var_tx = tx_size_wide_unit[max_tx_size];
-            int block = 0;
-            int step =
-                tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
-            int blk_row, blk_col;
-            const int unit_height = ROUND_POWER_OF_TWO(
-                AOMMIN(mu_blocks_high + row, max_blocks_high),
-                pd->subsampling_y);
-            const int unit_width = ROUND_POWER_OF_TWO(
-                AOMMIN(mu_blocks_wide + col, max_blocks_wide),
-                pd->subsampling_x);
-
-            for (blk_row = row >> pd->subsampling_y; blk_row < unit_height;
-                 blk_row += bh_var_tx) {
-              for (blk_col = col >> pd->subsampling_x; blk_col < unit_width;
-                   blk_col += bw_var_tx) {
-                decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize,
-                                      blk_row, blk_col, block, max_tx_size,
-                                      &eobtotal);
-                block += step;
-              }
-            }
-          }
-        }
-      }
-    }
-    td->cfl_store_inter_block_visit(cm, xd);
-  }
-
-  av1_visit_palette(pbi, xd, mi_row, mi_col, r, bsize,
-                    set_color_index_map_offset);
-}
-
-#if LOOP_FILTER_BITMASK
-static void store_bitmask_vartx(AV1_COMMON *cm, int mi_row, int mi_col,
-                                BLOCK_SIZE bsize, TX_SIZE tx_size,
-                                MB_MODE_INFO *mbmi);
-#endif
-
-static void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi,
-                               TX_SIZE tx_size, int depth,
-#if LOOP_FILTER_BITMASK
-                               AV1_COMMON *cm, int mi_row, int mi_col,
-#endif
-                               int blk_row, int blk_col, aom_reader *r) {
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  int is_split = 0;
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  const int max_blocks_high = max_block_high(xd, bsize, 0);
-  const int max_blocks_wide = max_block_wide(xd, bsize, 0);
-  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
-  assert(tx_size > TX_4X4);
-
-  if (depth == MAX_VARTX_DEPTH) {
-    for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) {
-      for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) {
-        const int index =
-            av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx);
-        mbmi->inter_tx_size[index] = tx_size;
-      }
-    }
-    mbmi->tx_size = tx_size;
-    txfm_partition_update(xd->above_txfm_context + blk_col,
-                          xd->left_txfm_context + blk_row, tx_size, tx_size);
-    return;
-  }
-
-  const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
-                                         xd->left_txfm_context + blk_row,
-                                         mbmi->sb_type, tx_size);
-  is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR);
-
-  if (is_split) {
-    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
-    const int bsw = tx_size_wide_unit[sub_txs];
-    const int bsh = tx_size_high_unit[sub_txs];
-
-    if (sub_txs == TX_4X4) {
-      for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) {
-        for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) {
-          const int index =
-              av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx);
-          mbmi->inter_tx_size[index] = sub_txs;
-        }
-      }
-      mbmi->tx_size = sub_txs;
-      txfm_partition_update(xd->above_txfm_context + blk_col,
-                            xd->left_txfm_context + blk_row, sub_txs, tx_size);
-#if LOOP_FILTER_BITMASK
-      store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, BLOCK_8X8,
-                          TX_4X4, mbmi);
-#endif
-      return;
-    }
-#if LOOP_FILTER_BITMASK
-    if (depth + 1 == MAX_VARTX_DEPTH) {
-      store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
-                          txsize_to_bsize[tx_size], sub_txs, mbmi);
-    }
-#endif
-
-    assert(bsw > 0 && bsh > 0);
-    for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) {
-      for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) {
-        int offsetr = blk_row + row;
-        int offsetc = blk_col + col;
-        read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1,
-#if LOOP_FILTER_BITMASK
-                           cm, mi_row, mi_col,
-#endif
-                           offsetr, offsetc, r);
-      }
-    }
-  } else {
-    for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) {
-      for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) {
-        const int index =
-            av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx);
-        mbmi->inter_tx_size[index] = tx_size;
-      }
-    }
-    mbmi->tx_size = tx_size;
-    txfm_partition_update(xd->above_txfm_context + blk_col,
-                          xd->left_txfm_context + blk_row, tx_size, tx_size);
-#if LOOP_FILTER_BITMASK
-    store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
-                        txsize_to_bsize[tx_size], tx_size, mbmi);
-#endif
-  }
-}
-
-static TX_SIZE read_selected_tx_size(MACROBLOCKD *xd, aom_reader *r) {
-  // TODO(debargha): Clean up the logic here. This function should only
-  // be called for intra.
-  const BLOCK_SIZE bsize = xd->mi[0]->sb_type;
-  const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize);
-  const int max_depths = bsize_to_max_depth(bsize);
-  const int ctx = get_tx_size_context(xd);
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
-                                    max_depths + 1, ACCT_STR);
-  assert(depth >= 0 && depth <= max_depths);
-  const TX_SIZE tx_size = depth_to_tx_size(depth, bsize);
-  return tx_size;
-}
-
-static TX_SIZE read_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd, int is_inter,
-                            int allow_select_inter, aom_reader *r) {
-  const TX_MODE tx_mode = cm->tx_mode;
-  const BLOCK_SIZE bsize = xd->mi[0]->sb_type;
-  if (xd->lossless[xd->mi[0]->segment_id]) return TX_4X4;
-
-  if (block_signals_txsize(bsize)) {
-    if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) {
-      const TX_SIZE coded_tx_size = read_selected_tx_size(xd, r);
-      return coded_tx_size;
-    } else {
-      return tx_size_from_tx_mode(bsize, tx_mode);
-    }
-  } else {
-    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
-    return max_txsize_rect_lookup[bsize];
-  }
-}
-
-#if LOOP_FILTER_BITMASK
-static void store_bitmask_vartx(AV1_COMMON *cm, int mi_row, int mi_col,
-                                BLOCK_SIZE bsize, TX_SIZE tx_size,
-                                MB_MODE_INFO *mbmi) {
-  LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col);
-  const TX_SIZE tx_size_y_vert = txsize_vert_map[tx_size];
-  const TX_SIZE tx_size_y_horz = txsize_horz_map[tx_size];
-  const TX_SIZE tx_size_uv_vert = txsize_vert_map[av1_get_max_uv_txsize(
-      mbmi->sb_type, cm->seq_params.subsampling_x,
-      cm->seq_params.subsampling_y)];
-  const TX_SIZE tx_size_uv_horz = txsize_horz_map[av1_get_max_uv_txsize(
-      mbmi->sb_type, cm->seq_params.subsampling_x,
-      cm->seq_params.subsampling_y)];
-  const int is_square_transform_size = tx_size <= TX_64X64;
-  int mask_id = 0;
-  int offset = 0;
-  const int half_ratio_tx_size_max32 =
-      (tx_size > TX_64X64) & (tx_size <= TX_32X16);
-  if (is_square_transform_size) {
-    switch (tx_size) {
-      case TX_4X4: mask_id = mask_id_table_tx_4x4[bsize]; break;
-      case TX_8X8:
-        mask_id = mask_id_table_tx_8x8[bsize];
-        offset = 19;
-        break;
-      case TX_16X16:
-        mask_id = mask_id_table_tx_16x16[bsize];
-        offset = 33;
-        break;
-      case TX_32X32:
-        mask_id = mask_id_table_tx_32x32[bsize];
-        offset = 42;
-        break;
-      case TX_64X64: mask_id = 46; break;
-      default: assert(!is_square_transform_size); return;
-    }
-    mask_id += offset;
-  } else if (half_ratio_tx_size_max32) {
-    int tx_size_equal_block_size = bsize == txsize_to_bsize[tx_size];
-    mask_id = 47 + 2 * (tx_size - TX_4X8) + (tx_size_equal_block_size ? 0 : 1);
-  } else if (tx_size == TX_32X64) {
-    mask_id = 59;
-  } else if (tx_size == TX_64X32) {
-    mask_id = 60;
-  } else {  // quarter ratio tx size
-    mask_id = 61 + (tx_size - TX_4X16);
-  }
-  int index = 0;
-  const int row = mi_row % MI_SIZE_64X64;
-  const int col = mi_col % MI_SIZE_64X64;
-  const int shift = get_index_shift(col, row, &index);
-  const int vert_shift = tx_size_y_vert <= TX_8X8 ? shift : col;
-  for (int i = 0; i + index < 4; ++i) {
-    // y vertical.
-    lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |=
-        (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift);
-    // y horizontal.
-    lfm->tx_size_hor[0][tx_size_y_vert].bits[i + index] |=
-        (above_mask_univariant_reordered[mask_id].bits[i] << shift);
-    // u/v vertical.
-    lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |=
-        (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift);
-    // u/v horizontal.
-    lfm->tx_size_hor[1][tx_size_uv_vert].bits[i + index] |=
-        (above_mask_univariant_reordered[mask_id].bits[i] << shift);
-  }
-}
-
-static void store_bitmask_univariant_tx(AV1_COMMON *cm, int mi_row, int mi_col,
-                                        BLOCK_SIZE bsize, MB_MODE_INFO *mbmi) {
-  // Use a lookup table that provides one bitmask for a given block size and
-  // a univariant transform size.
-  int index;
-  int shift;
-  int row;
-  int col;
-  LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col);
-  const TX_SIZE tx_size_y_vert = txsize_vert_map[mbmi->tx_size];
-  const TX_SIZE tx_size_y_horz = txsize_horz_map[mbmi->tx_size];
-  const TX_SIZE tx_size_uv_vert = txsize_vert_map[av1_get_max_uv_txsize(
-      mbmi->sb_type, cm->seq_params.subsampling_x,
-      cm->seq_params.subsampling_y)];
-  const TX_SIZE tx_size_uv_horz = txsize_horz_map[av1_get_max_uv_txsize(
-      mbmi->sb_type, cm->seq_params.subsampling_x,
-      cm->seq_params.subsampling_y)];
-  const int is_square_transform_size = mbmi->tx_size <= TX_64X64;
-  int mask_id = 0;
-  int offset = 0;
-  const int half_ratio_tx_size_max32 =
-      (mbmi->tx_size > TX_64X64) & (mbmi->tx_size <= TX_32X16);
-  if (is_square_transform_size) {
-    switch (mbmi->tx_size) {
-      case TX_4X4: mask_id = mask_id_table_tx_4x4[bsize]; break;
-      case TX_8X8:
-        mask_id = mask_id_table_tx_8x8[bsize];
-        offset = 19;
-        break;
-      case TX_16X16:
-        mask_id = mask_id_table_tx_16x16[bsize];
-        offset = 33;
-        break;
-      case TX_32X32:
-        mask_id = mask_id_table_tx_32x32[bsize];
-        offset = 42;
-        break;
-      case TX_64X64: mask_id = 46; break;
-      default: assert(!is_square_transform_size); return;
-    }
-    mask_id += offset;
-  } else if (half_ratio_tx_size_max32) {
-    int tx_size_equal_block_size = bsize == txsize_to_bsize[mbmi->tx_size];
-    mask_id =
-        47 + 2 * (mbmi->tx_size - TX_4X8) + (tx_size_equal_block_size ? 0 : 1);
-  } else if (mbmi->tx_size == TX_32X64) {
-    mask_id = 59;
-  } else if (mbmi->tx_size == TX_64X32) {
-    mask_id = 60;
-  } else {  // quarter ratio tx size
-    mask_id = 61 + (mbmi->tx_size - TX_4X16);
-  }
-  row = mi_row % MI_SIZE_64X64;
-  col = mi_col % MI_SIZE_64X64;
-  shift = get_index_shift(col, row, &index);
-  const int vert_shift = tx_size_y_vert <= TX_8X8 ? shift : col;
-  for (int i = 0; i + index < 4; ++i) {
-    // y vertical.
-    lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |=
-        (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift);
-    // y horizontal.
-    lfm->tx_size_hor[0][tx_size_y_vert].bits[i + index] |=
-        (above_mask_univariant_reordered[mask_id].bits[i] << shift);
-    // u/v vertical.
-    lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |=
-        (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift);
-    // u/v horizontal.
-    lfm->tx_size_hor[1][tx_size_uv_vert].bits[i + index] |=
-        (above_mask_univariant_reordered[mask_id].bits[i] << shift);
-  }
-}
-
-static void store_bitmask_other_info(AV1_COMMON *cm, int mi_row, int mi_col,
-                                     BLOCK_SIZE bsize, MB_MODE_INFO *mbmi) {
-  int index;
-  int shift;
-  int row;
-  LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col);
-  const int row_start = mi_row % MI_SIZE_64X64;
-  const int col_start = mi_col % MI_SIZE_64X64;
-  shift = get_index_shift(col_start, row_start, &index);
-  const uint64_t top_edge_mask =
-      ((uint64_t)1 << (shift + mi_size_wide[bsize])) - ((uint64_t)1 << shift);
-  lfm->is_horz_border.bits[index] |= top_edge_mask;
-  const int is_vert_border = mask_id_table_vert_border[bsize];
-  const int vert_shift = block_size_high[bsize] <= 8 ? shift : col_start;
-  for (int i = 0; i + index < 4; ++i) {
-    lfm->is_vert_border.bits[i + index] |=
-        (left_mask_univariant_reordered[is_vert_border].bits[i] << vert_shift);
-  }
-  const int is_skip = mbmi->skip && is_inter_block(mbmi);
-  if (is_skip) {
-    const int is_skip_mask = mask_id_table_tx_4x4[bsize];
-    for (int i = 0; i + index < 4; ++i) {
-      lfm->skip.bits[i + index] |=
-          (above_mask_univariant_reordered[is_skip_mask].bits[i] << shift);
-    }
-  }
-  const uint8_t level_vert_y = get_filter_level(cm, &cm->lf_info, 0, 0, mbmi);
-  const uint8_t level_horz_y = get_filter_level(cm, &cm->lf_info, 1, 0, mbmi);
-  const uint8_t level_u = get_filter_level(cm, &cm->lf_info, 0, 1, mbmi);
-  const uint8_t level_v = get_filter_level(cm, &cm->lf_info, 0, 2, mbmi);
-  for (int r = mi_row; r < mi_row + mi_size_high[bsize]; r++) {
-    index = 0;
-    row = r % MI_SIZE_64X64;
-    memset(&lfm->lfl_y_ver[row][col_start], level_vert_y,
-           sizeof(uint8_t) * mi_size_wide[bsize]);
-    memset(&lfm->lfl_y_hor[row][col_start], level_horz_y,
-           sizeof(uint8_t) * mi_size_wide[bsize]);
-    memset(&lfm->lfl_u[row][col_start], level_u,
-           sizeof(uint8_t) * mi_size_wide[bsize]);
-    memset(&lfm->lfl_v[row][col_start], level_v,
-           sizeof(uint8_t) * mi_size_wide[bsize]);
-  }
-}
-#endif
-
-static void parse_decode_block(AV1Decoder *const pbi, ThreadData *const td,
-                               int mi_row, int mi_col, aom_reader *r,
-                               PARTITION_TYPE partition, BLOCK_SIZE bsize) {
-  MACROBLOCKD *const xd = &td->xd;
-  decode_mbmi_block(pbi, xd, mi_row, mi_col, r, partition, bsize);
-
-  av1_visit_palette(pbi, xd, mi_row, mi_col, r, bsize,
-                    av1_decode_palette_tokens);
-
-  AV1_COMMON *cm = &pbi->common;
-  const int num_planes = av1_num_planes(cm);
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  int inter_block_tx = is_inter_block(mbmi) || is_intrabc_block(mbmi);
-  if (cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) &&
-      !mbmi->skip && inter_block_tx && !xd->lossless[mbmi->segment_id]) {
-    const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
-    const int bh = tx_size_high_unit[max_tx_size];
-    const int bw = tx_size_wide_unit[max_tx_size];
-    const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
-    const int height = block_size_high[bsize] >> tx_size_high_log2[0];
-
-    for (int idy = 0; idy < height; idy += bh)
-      for (int idx = 0; idx < width; idx += bw)
-        read_tx_size_vartx(xd, mbmi, max_tx_size, 0,
-#if LOOP_FILTER_BITMASK
-                           cm, mi_row, mi_col,
-#endif
-                           idy, idx, r);
-  } else {
-    mbmi->tx_size = read_tx_size(cm, xd, inter_block_tx, !mbmi->skip, r);
-    if (inter_block_tx)
-      memset(mbmi->inter_tx_size, mbmi->tx_size, sizeof(mbmi->inter_tx_size));
-    set_txfm_ctxs(mbmi->tx_size, xd->n4_w, xd->n4_h,
-                  mbmi->skip && is_inter_block(mbmi), xd);
-#if LOOP_FILTER_BITMASK
-    const int w = mi_size_wide[bsize];
-    const int h = mi_size_high[bsize];
-    if (w <= mi_size_wide[BLOCK_64X64] && h <= mi_size_high[BLOCK_64X64]) {
-      store_bitmask_univariant_tx(cm, mi_row, mi_col, bsize, mbmi);
-    } else {
-      for (int row = 0; row < h; row += mi_size_high[BLOCK_64X64]) {
-        for (int col = 0; col < w; col += mi_size_wide[BLOCK_64X64]) {
-          store_bitmask_univariant_tx(cm, mi_row + row, mi_col + col,
-                                      BLOCK_64X64, mbmi);
-        }
-      }
-    }
-#endif
-  }
-#if LOOP_FILTER_BITMASK
-  const int w = mi_size_wide[bsize];
-  const int h = mi_size_high[bsize];
-  if (w <= mi_size_wide[BLOCK_64X64] && h <= mi_size_high[BLOCK_64X64]) {
-    store_bitmask_other_info(cm, mi_row, mi_col, bsize, mbmi);
-  } else {
-    for (int row = 0; row < h; row += mi_size_high[BLOCK_64X64]) {
-      for (int col = 0; col < w; col += mi_size_wide[BLOCK_64X64]) {
-        store_bitmask_other_info(cm, mi_row + row, mi_col + col, BLOCK_64X64,
-                                 mbmi);
-      }
-    }
-  }
-#endif
-
-  if (cm->delta_q_present_flag) {
-    for (int i = 0; i < MAX_SEGMENTS; i++) {
-      const int current_qindex =
-          av1_get_qindex(&cm->seg, i, xd->current_qindex);
-      for (int j = 0; j < num_planes; ++j) {
-        const int dc_delta_q =
-            j == 0 ? cm->y_dc_delta_q
-                   : (j == 1 ? cm->u_dc_delta_q : cm->v_dc_delta_q);
-        const int ac_delta_q =
-            j == 0 ? 0 : (j == 1 ? cm->u_ac_delta_q : cm->v_ac_delta_q);
-        xd->plane[j].seg_dequant_QTX[i][0] = av1_dc_quant_QTX(
-            current_qindex, dc_delta_q, cm->seq_params.bit_depth);
-        xd->plane[j].seg_dequant_QTX[i][1] = av1_ac_quant_QTX(
-            current_qindex, ac_delta_q, cm->seq_params.bit_depth);
-      }
-    }
-  }
-  if (mbmi->skip) av1_reset_skip_context(xd, mi_row, mi_col, bsize, num_planes);
-
-  decode_token_recon_block(pbi, td, mi_row, mi_col, r, bsize);
-
-  int reader_corrupted_flag = aom_reader_has_error(r);
-  aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag);
-}
-
-static void set_offsets_for_pred_and_recon(AV1Decoder *const pbi,
-                                           ThreadData *const td, int mi_row,
-                                           int mi_col, BLOCK_SIZE bsize) {
-  AV1_COMMON *const cm = &pbi->common;
-  MACROBLOCKD *const xd = &td->xd;
-  const int bw = mi_size_wide[bsize];
-  const int bh = mi_size_high[bsize];
-  const int num_planes = av1_num_planes(cm);
-
-  const int offset = mi_row * cm->mi_stride + mi_col;
-  const TileInfo *const tile = &xd->tile;
-
-  xd->mi = cm->mi_grid_visible + offset;
-  xd->cfl.mi_row = mi_row;
-  xd->cfl.mi_col = mi_col;
-
-  set_plane_n4(xd, bw, bh, num_planes);
-
-  // 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
-  set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);
-
-  av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row,
-                       mi_col, 0, num_planes);
-}
-
-static void decode_block(AV1Decoder *const pbi, ThreadData *const td,
-                         int mi_row, int mi_col, aom_reader *r,
-                         PARTITION_TYPE partition, BLOCK_SIZE bsize) {
-  (void)partition;
-  set_offsets_for_pred_and_recon(pbi, td, mi_row, mi_col, bsize);
-  decode_token_recon_block(pbi, td, mi_row, mi_col, r, bsize);
-}
-
-static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col,
-                                     aom_reader *r, int has_rows, int has_cols,
-                                     BLOCK_SIZE bsize) {
-  const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-
-  if (!has_rows && !has_cols) return PARTITION_SPLIT;
-
-  assert(ctx >= 0);
-  aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[ctx];
-  if (has_rows && has_cols) {
-    return (PARTITION_TYPE)aom_read_symbol(
-        r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
-  } else if (!has_rows && has_cols) {
-    assert(bsize > BLOCK_8X8);
-    aom_cdf_prob cdf[2];
-    partition_gather_vert_alike(cdf, partition_cdf, bsize);
-    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
-    return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ;
-  } else {
-    assert(has_rows && !has_cols);
-    assert(bsize > BLOCK_8X8);
-    aom_cdf_prob cdf[2];
-    partition_gather_horz_alike(cdf, partition_cdf, bsize);
-    assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
-    return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT;
-  }
-}
-
-// TODO(slavarnway): eliminate bsize and subsize in future commits
-static void decode_partition(AV1Decoder *const pbi, ThreadData *const td,
-                             int mi_row, int mi_col, aom_reader *r,
-                             BLOCK_SIZE bsize, int parse_decode_flag) {
-  AV1_COMMON *const cm = &pbi->common;
-  MACROBLOCKD *const xd = &td->xd;
-  const int bw = mi_size_wide[bsize];
-  const int hbs = bw >> 1;
-  PARTITION_TYPE partition;
-  BLOCK_SIZE subsize;
-  const int quarter_step = bw / 4;
-  BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
-  const int has_rows = (mi_row + hbs) < cm->mi_rows;
-  const int has_cols = (mi_col + hbs) < cm->mi_cols;
-
-  if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return;
-
-  // parse_decode_flag takes the following values :
-  // 01 - do parse only
-  // 10 - do decode only
-  // 11 - do parse and decode
-  static const block_visitor_fn_t block_visit[4] = {
-    NULL, parse_decode_block, decode_block, parse_decode_block
-  };
-
-  if (parse_decode_flag & 1) {
-    const int num_planes = av1_num_planes(cm);
-    for (int plane = 0; plane < num_planes; ++plane) {
-      int rcol0, rcol1, rrow0, rrow1;
-      if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
-                                             &rcol0, &rcol1, &rrow0, &rrow1)) {
-        const int rstride = cm->rst_info[plane].horz_units_per_tile;
-        for (int rrow = rrow0; rrow < rrow1; ++rrow) {
-          for (int rcol = rcol0; rcol < rcol1; ++rcol) {
-            const int runit_idx = rcol + rrow * rstride;
-            loop_restoration_read_sb_coeffs(cm, xd, r, plane, runit_idx);
-          }
-        }
-      }
-    }
-
-    partition = (bsize < BLOCK_8X8) ? PARTITION_NONE
-                                    : read_partition(xd, mi_row, mi_col, r,
-                                                     has_rows, has_cols, bsize);
-  } else {
-    partition = get_partition(cm, mi_row, mi_col, bsize);
-  }
-  subsize = get_partition_subsize(bsize, partition);
-
-  // Check the bitstream is conformant: if there is subsampling on the
-  // chroma planes, subsize must subsample to a valid block size.
-  const struct macroblockd_plane *const pd_u = &xd->plane[1];
-  if (get_plane_block_size(subsize, pd_u->subsampling_x, pd_u->subsampling_y) ==
-      BLOCK_INVALID) {
-    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
-                       "Block size %dx%d invalid with this subsampling mode",
-                       block_size_wide[subsize], block_size_high[subsize]);
-  }
-
-#define DEC_BLOCK_STX_ARG
-#define DEC_BLOCK_EPT_ARG partition,
-#define DEC_BLOCK(db_r, db_c, db_subsize)                                     \
-  block_visit[parse_decode_flag](pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), r, \
-                                 DEC_BLOCK_EPT_ARG(db_subsize))
-#define DEC_PARTITION(db_r, db_c, db_subsize)                                 \
-  decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), r, (db_subsize), \
-                   parse_decode_flag)
-
-  switch (partition) {
-    case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize); break;
-    case PARTITION_HORZ:
-      DEC_BLOCK(mi_row, mi_col, subsize);
-      if (has_rows) DEC_BLOCK(mi_row + hbs, mi_col, subsize);
-      break;
-    case PARTITION_VERT:
-      DEC_BLOCK(mi_row, mi_col, subsize);
-      if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs, subsize);
-      break;
-    case PARTITION_SPLIT:
-      DEC_PARTITION(mi_row, mi_col, subsize);
-      DEC_PARTITION(mi_row, mi_col + hbs, subsize);
-      DEC_PARTITION(mi_row + hbs, mi_col, subsize);
-      DEC_PARTITION(mi_row + hbs, mi_col + hbs, subsize);
-      break;
-    case PARTITION_HORZ_A:
-      DEC_BLOCK(mi_row, mi_col, bsize2);
-      DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
-      DEC_BLOCK(mi_row + hbs, mi_col, subsize);
-      break;
-    case PARTITION_HORZ_B:
-      DEC_BLOCK(mi_row, mi_col, subsize);
-      DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
-      DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
-      break;
-    case PARTITION_VERT_A:
-      DEC_BLOCK(mi_row, mi_col, bsize2);
-      DEC_BLOCK(mi_row + hbs, mi_col, bsize2);
-      DEC_BLOCK(mi_row, mi_col + hbs, subsize);
-      break;
-    case PARTITION_VERT_B:
-      DEC_BLOCK(mi_row, mi_col, subsize);
-      DEC_BLOCK(mi_row, mi_col + hbs, bsize2);
-      DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2);
-      break;
-    case PARTITION_HORZ_4:
-      for (int i = 0; i < 4; ++i) {
-        int this_mi_row = mi_row + i * quarter_step;
-        if (i > 0 && this_mi_row >= cm->mi_rows) break;
-        DEC_BLOCK(this_mi_row, mi_col, subsize);
-      }
-      break;
-    case PARTITION_VERT_4:
-      for (int i = 0; i < 4; ++i) {
-        int this_mi_col = mi_col + i * quarter_step;
-        if (i > 0 && this_mi_col >= cm->mi_cols) break;
-        DEC_BLOCK(mi_row, this_mi_col, subsize);
-      }
-      break;
-    default: assert(0 && "Invalid partition type");
-  }
-
-#undef DEC_PARTITION
-#undef DEC_BLOCK
-#undef DEC_BLOCK_EPT_ARG
-#undef DEC_BLOCK_STX_ARG
-
-  if (parse_decode_flag & 1)
-    update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
-}
-
-static void setup_bool_decoder(const uint8_t *data, const uint8_t *data_end,
-                               const size_t read_size,
-                               struct aom_internal_error_info *error_info,
-                               aom_reader *r, uint8_t allow_update_cdf) {
-  // 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.
-  if (!read_is_valid(data, read_size, data_end))
-    aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
-                       "Truncated packet or corrupt tile length");
-
-  if (aom_reader_init(r, data, read_size))
-    aom_internal_error(error_info, AOM_CODEC_MEM_ERROR,
-                       "Failed to allocate bool decoder %d", 1);
-
-  r->allow_update_cdf = allow_update_cdf;
-}
-
-static void setup_segmentation(AV1_COMMON *const cm,
-                               struct aom_read_bit_buffer *rb) {
-  struct segmentation *const seg = &cm->seg;
-
-  seg->update_map = 0;
-  seg->update_data = 0;
-  seg->temporal_update = 0;
-
-  seg->enabled = aom_rb_read_bit(rb);
-  if (!seg->enabled) {
-    if (cm->cur_frame->seg_map)
-      memset(cm->cur_frame->seg_map, 0, (cm->mi_rows * cm->mi_cols));
-
-    memset(seg, 0, sizeof(*seg));
-    segfeatures_copy(&cm->cur_frame->seg, seg);
-    return;
-  }
-  if (cm->seg.enabled && cm->prev_frame &&
-      (cm->mi_rows == cm->prev_frame->mi_rows) &&
-      (cm->mi_cols == cm->prev_frame->mi_cols)) {
-    cm->last_frame_seg_map = cm->prev_frame->seg_map;
-  } else {
-    cm->last_frame_seg_map = NULL;
-  }
-  // Read update flags
-  if (cm->primary_ref_frame == PRIMARY_REF_NONE) {
-    // These frames can't use previous frames, so must signal map + features
-    seg->update_map = 1;
-    seg->temporal_update = 0;
-    seg->update_data = 1;
-  } else {
-    seg->update_map = aom_rb_read_bit(rb);
-    if (seg->update_map) {
-      seg->temporal_update = aom_rb_read_bit(rb);
-    } else {
-      seg->temporal_update = 0;
-    }
-    seg->update_data = aom_rb_read_bit(rb);
-  }
-
-  // Segmentation data update
-  if (seg->update_data) {
-    av1_clearall_segfeatures(seg);
-
-    for (int i = 0; i < MAX_SEGMENTS; i++) {
-      for (int j = 0; j < SEG_LVL_MAX; j++) {
-        int data = 0;
-        const int feature_enabled = aom_rb_read_bit(rb);
-        if (feature_enabled) {
-          av1_enable_segfeature(seg, i, j);
-
-          const int data_max = av1_seg_feature_data_max(j);
-          const int data_min = -data_max;
-          const int ubits = get_unsigned_bits(data_max);
-
-          if (av1_is_segfeature_signed(j)) {
-            data = aom_rb_read_inv_signed_literal(rb, ubits);
-          } else {
-            data = aom_rb_read_literal(rb, ubits);
-          }
-
-          data = clamp(data, data_min, data_max);
-        }
-        av1_set_segdata(seg, i, j, data);
-      }
-    }
-    calculate_segdata(seg);
-  } else if (cm->prev_frame) {
-    segfeatures_copy(seg, &cm->prev_frame->seg);
-  }
-  segfeatures_copy(&cm->cur_frame->seg, seg);
-}
-
-static void decode_restoration_mode(AV1_COMMON *cm,
-                                    struct aom_read_bit_buffer *rb) {
-  assert(!cm->all_lossless);
-  const int num_planes = av1_num_planes(cm);
-  if (cm->allow_intrabc) return;
-  int all_none = 1, chroma_none = 1;
-  for (int p = 0; p < num_planes; ++p) {
-    RestorationInfo *rsi = &cm->rst_info[p];
-    if (aom_rb_read_bit(rb)) {
-      rsi->frame_restoration_type =
-          aom_rb_read_bit(rb) ? RESTORE_SGRPROJ : RESTORE_WIENER;
-    } else {
-      rsi->frame_restoration_type =
-          aom_rb_read_bit(rb) ? RESTORE_SWITCHABLE : RESTORE_NONE;
-    }
-    if (rsi->frame_restoration_type != RESTORE_NONE) {
-      all_none = 0;
-      chroma_none &= p == 0;
-    }
-  }
-  if (!all_none) {
-    assert(cm->seq_params.sb_size == BLOCK_64X64 ||
-           cm->seq_params.sb_size == BLOCK_128X128);
-    const int sb_size = cm->seq_params.sb_size == BLOCK_128X128 ? 128 : 64;
-
-    for (int p = 0; p < num_planes; ++p)
-      cm->rst_info[p].restoration_unit_size = sb_size;
-
-    RestorationInfo *rsi = &cm->rst_info[0];
-
-    if (sb_size == 64) {
-      rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
-    }
-    if (rsi->restoration_unit_size > 64) {
-      rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
-    }
-  } else {
-    const int size = RESTORATION_UNITSIZE_MAX;
-    for (int p = 0; p < num_planes; ++p)
-      cm->rst_info[p].restoration_unit_size = size;
-  }
-
-  if (num_planes > 1) {
-    int s = AOMMIN(cm->seq_params.subsampling_x, cm->seq_params.subsampling_y);
-    if (s && !chroma_none) {
-      cm->rst_info[1].restoration_unit_size =
-          cm->rst_info[0].restoration_unit_size >> (aom_rb_read_bit(rb) * s);
-    } else {
-      cm->rst_info[1].restoration_unit_size =
-          cm->rst_info[0].restoration_unit_size;
-    }
-    cm->rst_info[2].restoration_unit_size =
-        cm->rst_info[1].restoration_unit_size;
-  }
-}
-
-static void read_wiener_filter(int wiener_win, WienerInfo *wiener_info,
-                               WienerInfo *ref_wiener_info, aom_reader *rb) {
-  memset(wiener_info->vfilter, 0, sizeof(wiener_info->vfilter));
-  memset(wiener_info->hfilter, 0, sizeof(wiener_info->hfilter));
-
-  if (wiener_win == WIENER_WIN)
-    wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] =
-        aom_read_primitive_refsubexpfin(
-            rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
-            WIENER_FILT_TAP0_SUBEXP_K,
-            ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
-        WIENER_FILT_TAP0_MINV;
-  else
-    wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] = 0;
-  wiener_info->vfilter[1] = wiener_info->vfilter[WIENER_WIN - 2] =
-      aom_read_primitive_refsubexpfin(
-          rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
-          WIENER_FILT_TAP1_SUBEXP_K,
-          ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
-      WIENER_FILT_TAP1_MINV;
-  wiener_info->vfilter[2] = wiener_info->vfilter[WIENER_WIN - 3] =
-      aom_read_primitive_refsubexpfin(
-          rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
-          WIENER_FILT_TAP2_SUBEXP_K,
-          ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
-      WIENER_FILT_TAP2_MINV;
-  // The central element has an implicit +WIENER_FILT_STEP
-  wiener_info->vfilter[WIENER_HALFWIN] =
-      -2 * (wiener_info->vfilter[0] + wiener_info->vfilter[1] +
-            wiener_info->vfilter[2]);
-
-  if (wiener_win == WIENER_WIN)
-    wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] =
-        aom_read_primitive_refsubexpfin(
-            rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
-            WIENER_FILT_TAP0_SUBEXP_K,
-            ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
-        WIENER_FILT_TAP0_MINV;
-  else
-    wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] = 0;
-  wiener_info->hfilter[1] = wiener_info->hfilter[WIENER_WIN - 2] =
-      aom_read_primitive_refsubexpfin(
-          rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
-          WIENER_FILT_TAP1_SUBEXP_K,
-          ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
-      WIENER_FILT_TAP1_MINV;
-  wiener_info->hfilter[2] = wiener_info->hfilter[WIENER_WIN - 3] =
-      aom_read_primitive_refsubexpfin(
-          rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
-          WIENER_FILT_TAP2_SUBEXP_K,
-          ref_wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
-      WIENER_FILT_TAP2_MINV;
-  // The central element has an implicit +WIENER_FILT_STEP
-  wiener_info->hfilter[WIENER_HALFWIN] =
-      -2 * (wiener_info->hfilter[0] + wiener_info->hfilter[1] +
-            wiener_info->hfilter[2]);
-  memcpy(ref_wiener_info, wiener_info, sizeof(*wiener_info));
-}
-
-static void read_sgrproj_filter(SgrprojInfo *sgrproj_info,
-                                SgrprojInfo *ref_sgrproj_info, aom_reader *rb) {
-  sgrproj_info->ep = aom_read_literal(rb, SGRPROJ_PARAMS_BITS, ACCT_STR);
-  const sgr_params_type *params = &sgr_params[sgrproj_info->ep];
-
-  if (params->r[0] == 0) {
-    sgrproj_info->xqd[0] = 0;
-    sgrproj_info->xqd[1] =
-        aom_read_primitive_refsubexpfin(
-            rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
-            ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
-        SGRPROJ_PRJ_MIN1;
-  } else if (params->r[1] == 0) {
-    sgrproj_info->xqd[0] =
-        aom_read_primitive_refsubexpfin(
-            rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
-            ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
-        SGRPROJ_PRJ_MIN0;
-    sgrproj_info->xqd[1] = clamp((1 << SGRPROJ_PRJ_BITS) - sgrproj_info->xqd[0],
-                                 SGRPROJ_PRJ_MIN1, SGRPROJ_PRJ_MAX1);
-  } else {
-    sgrproj_info->xqd[0] =
-        aom_read_primitive_refsubexpfin(
-            rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
-            ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
-        SGRPROJ_PRJ_MIN0;
-    sgrproj_info->xqd[1] =
-        aom_read_primitive_refsubexpfin(
-            rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
-            ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
-        SGRPROJ_PRJ_MIN1;
-  }
-
-  memcpy(ref_sgrproj_info, sgrproj_info, sizeof(*sgrproj_info));
-}
-
-static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
-                                            MACROBLOCKD *xd,
-                                            aom_reader *const r, int plane,
-                                            int runit_idx) {
-  const RestorationInfo *rsi = &cm->rst_info[plane];
-  RestorationUnitInfo *rui = &rsi->unit_info[runit_idx];
-  if (rsi->frame_restoration_type == RESTORE_NONE) return;
-
-  assert(!cm->all_lossless);
-
-  const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN;
-  WienerInfo *wiener_info = xd->wiener_info + plane;
-  SgrprojInfo *sgrproj_info = xd->sgrproj_info + plane;
-
-  if (rsi->frame_restoration_type == RESTORE_SWITCHABLE) {
-    rui->restoration_type =
-        aom_read_symbol(r, xd->tile_ctx->switchable_restore_cdf,
-                        RESTORE_SWITCHABLE_TYPES, ACCT_STR);
-    switch (rui->restoration_type) {
-      case RESTORE_WIENER:
-        read_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, r);
-        break;
-      case RESTORE_SGRPROJ:
-        read_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, r);
-        break;
-      default: assert(rui->restoration_type == RESTORE_NONE); break;
-    }
-  } else if (rsi->frame_restoration_type == RESTORE_WIENER) {
-    if (aom_read_symbol(r, xd->tile_ctx->wiener_restore_cdf, 2, ACCT_STR)) {
-      rui->restoration_type = RESTORE_WIENER;
-      read_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, r);
-    } else {
-      rui->restoration_type = RESTORE_NONE;
-    }
-  } else if (rsi->frame_restoration_type == RESTORE_SGRPROJ) {
-    if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2, ACCT_STR)) {
-      rui->restoration_type = RESTORE_SGRPROJ;
-      read_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, r);
-    } else {
-      rui->restoration_type = RESTORE_NONE;
-    }
-  }
-}
-
-static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-  const int num_planes = av1_num_planes(cm);
-  struct loopfilter *lf = &cm->lf;
-  if (cm->allow_intrabc || cm->coded_lossless) {
-    // write default deltas to frame buffer
-    av1_set_default_ref_deltas(cm->cur_frame->ref_deltas);
-    av1_set_default_mode_deltas(cm->cur_frame->mode_deltas);
-    return;
-  }
-  assert(!cm->coded_lossless);
-  if (cm->prev_frame) {
-    // write deltas to frame buffer
-    memcpy(lf->ref_deltas, cm->prev_frame->ref_deltas, REF_FRAMES);
-    memcpy(lf->mode_deltas, cm->prev_frame->mode_deltas, MAX_MODE_LF_DELTAS);
-  } else {
-    av1_set_default_ref_deltas(lf->ref_deltas);
-    av1_set_default_mode_deltas(lf->mode_deltas);
-  }
-  lf->filter_level[0] = aom_rb_read_literal(rb, 6);
-  lf->filter_level[1] = aom_rb_read_literal(rb, 6);
-  if (num_planes > 1) {
-    if (lf->filter_level[0] || lf->filter_level[1]) {
-      lf->filter_level_u = aom_rb_read_literal(rb, 6);
-      lf->filter_level_v = aom_rb_read_literal(rb, 6);
-    }
-  }
-  lf->sharpness_level = aom_rb_read_literal(rb, 3);
-
-  // Read in loop filter deltas applied at the MB level based on mode or ref
-  // frame.
-  lf->mode_ref_delta_update = 0;
-
-  lf->mode_ref_delta_enabled = aom_rb_read_bit(rb);
-  if (lf->mode_ref_delta_enabled) {
-    lf->mode_ref_delta_update = aom_rb_read_bit(rb);
-    if (lf->mode_ref_delta_update) {
-      for (int i = 0; i < REF_FRAMES; i++)
-        if (aom_rb_read_bit(rb))
-          lf->ref_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6);
-
-      for (int i = 0; i < MAX_MODE_LF_DELTAS; i++)
-        if (aom_rb_read_bit(rb))
-          lf->mode_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6);
-    }
-  }
-
-  // write deltas to frame buffer
-  memcpy(cm->cur_frame->ref_deltas, lf->ref_deltas, REF_FRAMES);
-  memcpy(cm->cur_frame->mode_deltas, lf->mode_deltas, MAX_MODE_LF_DELTAS);
-}
-
-static void setup_cdef(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-  const int num_planes = av1_num_planes(cm);
-  if (cm->allow_intrabc) return;
-  cm->cdef_pri_damping = cm->cdef_sec_damping = aom_rb_read_literal(rb, 2) + 3;
-  cm->cdef_bits = aom_rb_read_literal(rb, 2);
-  cm->nb_cdef_strengths = 1 << cm->cdef_bits;
-  for (int i = 0; i < cm->nb_cdef_strengths; i++) {
-    cm->cdef_strengths[i] = aom_rb_read_literal(rb, CDEF_STRENGTH_BITS);
-    cm->cdef_uv_strengths[i] =
-        num_planes > 1 ? aom_rb_read_literal(rb, CDEF_STRENGTH_BITS) : 0;
-  }
-}
-
-static INLINE int read_delta_q(struct aom_read_bit_buffer *rb) {
-  return aom_rb_read_bit(rb) ? aom_rb_read_inv_signed_literal(rb, 6) : 0;
-}
-
-static void setup_quantization(AV1_COMMON *const cm,
-                               struct aom_read_bit_buffer *rb) {
-  const SequenceHeader *const seq_params = &cm->seq_params;
-  const int num_planes = av1_num_planes(cm);
-  cm->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS);
-  cm->y_dc_delta_q = read_delta_q(rb);
-  if (num_planes > 1) {
-    int diff_uv_delta = 0;
-    if (seq_params->separate_uv_delta_q) diff_uv_delta = aom_rb_read_bit(rb);
-    cm->u_dc_delta_q = read_delta_q(rb);
-    cm->u_ac_delta_q = read_delta_q(rb);
-    if (diff_uv_delta) {
-      cm->v_dc_delta_q = read_delta_q(rb);
-      cm->v_ac_delta_q = read_delta_q(rb);
-    } else {
-      cm->v_dc_delta_q = cm->u_dc_delta_q;
-      cm->v_ac_delta_q = cm->u_ac_delta_q;
-    }
-  } else {
-    cm->u_dc_delta_q = 0;
-    cm->u_ac_delta_q = 0;
-    cm->v_dc_delta_q = 0;
-    cm->v_ac_delta_q = 0;
-  }
-  cm->dequant_bit_depth = seq_params->bit_depth;
-  cm->using_qmatrix = aom_rb_read_bit(rb);
-  if (cm->using_qmatrix) {
-    cm->qm_y = aom_rb_read_literal(rb, QM_LEVEL_BITS);
-    cm->qm_u = aom_rb_read_literal(rb, QM_LEVEL_BITS);
-    if (!seq_params->separate_uv_delta_q)
-      cm->qm_v = cm->qm_u;
-    else
-      cm->qm_v = aom_rb_read_literal(rb, QM_LEVEL_BITS);
-  } else {
-    cm->qm_y = 0;
-    cm->qm_u = 0;
-    cm->qm_v = 0;
-  }
-}
-
-// Build y/uv dequant values based on segmentation.
-static void setup_segmentation_dequant(AV1_COMMON *const cm) {
-  const int bit_depth = cm->seq_params.bit_depth;
-  const int using_qm = cm->using_qmatrix;
-  // When segmentation is disabled, only the first value is used.  The
-  // remaining are don't cares.
-  const int max_segments = cm->seg.enabled ? MAX_SEGMENTS : 1;
-  for (int i = 0; i < max_segments; ++i) {
-    const int qindex = av1_get_qindex(&cm->seg, i, cm->base_qindex);
-    cm->y_dequant_QTX[i][0] =
-        av1_dc_quant_QTX(qindex, cm->y_dc_delta_q, bit_depth);
-    cm->y_dequant_QTX[i][1] = av1_ac_quant_QTX(qindex, 0, bit_depth);
-    cm->u_dequant_QTX[i][0] =
-        av1_dc_quant_QTX(qindex, cm->u_dc_delta_q, bit_depth);
-    cm->u_dequant_QTX[i][1] =
-        av1_ac_quant_QTX(qindex, cm->u_ac_delta_q, bit_depth);
-    cm->v_dequant_QTX[i][0] =
-        av1_dc_quant_QTX(qindex, cm->v_dc_delta_q, bit_depth);
-    cm->v_dequant_QTX[i][1] =
-        av1_ac_quant_QTX(qindex, cm->v_ac_delta_q, bit_depth);
-    const int lossless = qindex == 0 && cm->y_dc_delta_q == 0 &&
-                         cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 &&
-                         cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0;
-    // NB: depends on base index so there is only 1 set per frame
-    // No quant weighting when lossless or signalled not using QM
-    int qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_y;
-    for (int j = 0; j < TX_SIZES_ALL; ++j) {
-      cm->y_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_Y, j);
-    }
-    qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_u;
-    for (int j = 0; j < TX_SIZES_ALL; ++j) {
-      cm->u_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_U, j);
-    }
-    qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_v;
-    for (int j = 0; j < TX_SIZES_ALL; ++j) {
-      cm->v_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_V, j);
-    }
-  }
-}
-
-static InterpFilter read_frame_interp_filter(struct aom_read_bit_buffer *rb) {
-  return aom_rb_read_bit(rb) ? SWITCHABLE
-                             : aom_rb_read_literal(rb, LOG_SWITCHABLE_FILTERS);
-}
-
-static void setup_render_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-  cm->render_width = cm->superres_upscaled_width;
-  cm->render_height = cm->superres_upscaled_height;
-  if (aom_rb_read_bit(rb))
-    av1_read_frame_size(rb, 16, 16, &cm->render_width, &cm->render_height);
-}
-
-// TODO(afergs): make "struct aom_read_bit_buffer *const rb"?
-static void setup_superres(AV1_COMMON *const cm, struct aom_read_bit_buffer *rb,
-                           int *width, int *height) {
-  cm->superres_upscaled_width = *width;
-  cm->superres_upscaled_height = *height;
-
-  const SequenceHeader *const seq_params = &cm->seq_params;
-  if (!seq_params->enable_superres) return;
-
-  if (aom_rb_read_bit(rb)) {
-    cm->superres_scale_denominator =
-        (uint8_t)aom_rb_read_literal(rb, SUPERRES_SCALE_BITS);
-    cm->superres_scale_denominator += SUPERRES_SCALE_DENOMINATOR_MIN;
-    // Don't edit cm->width or cm->height directly, or the buffers won't get
-    // resized correctly
-    av1_calculate_scaled_superres_size(width, height,
-                                       cm->superres_scale_denominator);
-  } else {
-    // 1:1 scaling - ie. no scaling, scale not provided
-    cm->superres_scale_denominator = SCALE_NUMERATOR;
-  }
-}
-
-static void resize_context_buffers(AV1_COMMON *cm, int width, int height) {
-#if CONFIG_SIZE_LIMIT
-  if (width > DECODE_WIDTH_LIMIT || height > DECODE_HEIGHT_LIMIT)
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Dimensions of %dx%d beyond allowed size of %dx%d.",
-                       width, height, DECODE_WIDTH_LIMIT, DECODE_HEIGHT_LIMIT);
-#endif
-  if (cm->width != width || cm->height != height) {
-    const int new_mi_rows =
-        ALIGN_POWER_OF_TWO(height, MI_SIZE_LOG2) >> MI_SIZE_LOG2;
-    const int new_mi_cols =
-        ALIGN_POWER_OF_TWO(width, MI_SIZE_LOG2) >> MI_SIZE_LOG2;
-
-    // Allocations in av1_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) {
-      if (av1_alloc_context_buffers(cm, width, height)) {
-        // The cm->mi_* values have been cleared and any existing context
-        // buffers have been freed. Clear cm->width and cm->height to be
-        // consistent and to force a realloc next time.
-        cm->width = 0;
-        cm->height = 0;
-        aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
-                           "Failed to allocate context buffers");
-      }
-    } else {
-      av1_set_mb_mi(cm, width, height);
-    }
-    av1_init_context_buffers(cm);
-    cm->width = width;
-    cm->height = height;
-  }
-
-  ensure_mv_buffer(cm->cur_frame, cm);
-  cm->cur_frame->width = cm->width;
-  cm->cur_frame->height = cm->height;
-}
-
-static void setup_buffer_pool(AV1_COMMON *cm) {
-  BufferPool *const pool = cm->buffer_pool;
-  const SequenceHeader *const seq_params = &cm->seq_params;
-
-  lock_buffer_pool(pool);
-  if (aom_realloc_frame_buffer(
-          get_frame_new_buffer(cm), cm->width, cm->height,
-          seq_params->subsampling_x, seq_params->subsampling_y,
-          seq_params->use_highbitdepth, AOM_BORDER_IN_PIXELS,
-          cm->byte_alignment,
-          &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb,
-          pool->cb_priv)) {
-    unlock_buffer_pool(pool);
-    aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
-                       "Failed to allocate frame buffer");
-  }
-  unlock_buffer_pool(pool);
-
-  pool->frame_bufs[cm->new_fb_idx].buf.subsampling_x =
-      seq_params->subsampling_x;
-  pool->frame_bufs[cm->new_fb_idx].buf.subsampling_y =
-      seq_params->subsampling_y;
-  pool->frame_bufs[cm->new_fb_idx].buf.bit_depth =
-      (unsigned int)seq_params->bit_depth;
-  pool->frame_bufs[cm->new_fb_idx].buf.color_primaries =
-      seq_params->color_primaries;
-  pool->frame_bufs[cm->new_fb_idx].buf.transfer_characteristics =
-      seq_params->transfer_characteristics;
-  pool->frame_bufs[cm->new_fb_idx].buf.matrix_coefficients =
-      seq_params->matrix_coefficients;
-  pool->frame_bufs[cm->new_fb_idx].buf.monochrome = seq_params->monochrome;
-  pool->frame_bufs[cm->new_fb_idx].buf.chroma_sample_position =
-      seq_params->chroma_sample_position;
-  pool->frame_bufs[cm->new_fb_idx].buf.color_range = seq_params->color_range;
-  pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width;
-  pool->frame_bufs[cm->new_fb_idx].buf.render_height = cm->render_height;
-}
-
-static void setup_frame_size(AV1_COMMON *cm, int frame_size_override_flag,
-                             struct aom_read_bit_buffer *rb) {
-  const SequenceHeader *const seq_params = &cm->seq_params;
-  int width, height;
-
-  if (frame_size_override_flag) {
-    int num_bits_width = seq_params->num_bits_width;
-    int num_bits_height = seq_params->num_bits_height;
-    av1_read_frame_size(rb, num_bits_width, num_bits_height, &width, &height);
-    if (width > seq_params->max_frame_width ||
-        height > seq_params->max_frame_height) {
-      aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                         "Frame dimensions are larger than the maximum values");
-    }
-  } else {
-    width = seq_params->max_frame_width;
-    height = seq_params->max_frame_height;
-  }
-
-  setup_superres(cm, rb, &width, &height);
-  resize_context_buffers(cm, width, height);
-  setup_render_size(cm, rb);
-  setup_buffer_pool(cm);
-}
-
-static void setup_sb_size(SequenceHeader *seq_params,
-                          struct aom_read_bit_buffer *rb) {
-  set_sb_size(seq_params, aom_rb_read_bit(rb) ? BLOCK_128X128 : BLOCK_64X64);
-}
-
-static INLINE int valid_ref_frame_img_fmt(aom_bit_depth_t ref_bit_depth,
-                                          int ref_xss, int ref_yss,
-                                          aom_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;
-}
-
-static void setup_frame_size_with_refs(AV1_COMMON *cm,
-                                       struct aom_read_bit_buffer *rb) {
-  int width, height;
-  int found = 0;
-  int has_valid_ref_frame = 0;
-  for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    if (aom_rb_read_bit(rb)) {
-      YV12_BUFFER_CONFIG *const buf = cm->frame_refs[i].buf;
-      width = buf->y_crop_width;
-      height = buf->y_crop_height;
-      cm->render_width = buf->render_width;
-      cm->render_height = buf->render_height;
-      setup_superres(cm, rb, &width, &height);
-      resize_context_buffers(cm, width, height);
-      found = 1;
-      break;
-    }
-  }
-
-  const SequenceHeader *const seq_params = &cm->seq_params;
-  if (!found) {
-    int num_bits_width = seq_params->num_bits_width;
-    int num_bits_height = seq_params->num_bits_height;
-
-    av1_read_frame_size(rb, num_bits_width, num_bits_height, &width, &height);
-    setup_superres(cm, rb, &width, &height);
-    resize_context_buffers(cm, width, height);
-    setup_render_size(cm, rb);
-  }
-
-  if (width <= 0 || height <= 0)
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Invalid frame size");
-
-  // Check to make sure at least one of frames that this frame references
-  // has valid dimensions.
-  for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    RefBuffer *const ref_frame = &cm->frame_refs[i];
-    has_valid_ref_frame |=
-        valid_ref_frame_size(ref_frame->buf->y_crop_width,
-                             ref_frame->buf->y_crop_height, width, height);
-  }
-  if (!has_valid_ref_frame)
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Referenced frame has invalid size");
-  for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    RefBuffer *const ref_frame = &cm->frame_refs[i];
-    if (!valid_ref_frame_img_fmt(
-            ref_frame->buf->bit_depth, ref_frame->buf->subsampling_x,
-            ref_frame->buf->subsampling_y, seq_params->bit_depth,
-            seq_params->subsampling_x, seq_params->subsampling_y))
-      aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                         "Referenced frame has incompatible color format");
-  }
-  setup_buffer_pool(cm);
-}
-
-// Same function as av1_read_uniform but reading from uncompresses header wb
-static int rb_read_uniform(struct aom_read_bit_buffer *const rb, int n) {
-  const int l = get_unsigned_bits(n);
-  const int m = (1 << l) - n;
-  const int v = aom_rb_read_literal(rb, l - 1);
-  assert(l != 0);
-  if (v < m)
-    return v;
-  else
-    return (v << 1) - m + aom_rb_read_bit(rb);
-}
-
-static void read_tile_info_max_tile(AV1_COMMON *const cm,
-                                    struct aom_read_bit_buffer *const rb) {
-  int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2);
-  int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
-  int width_sb = width_mi >> cm->seq_params.mib_size_log2;
-  int height_sb = height_mi >> cm->seq_params.mib_size_log2;
-
-  av1_get_tile_limits(cm);
-  cm->uniform_tile_spacing_flag = aom_rb_read_bit(rb);
-
-  // Read tile columns
-  if (cm->uniform_tile_spacing_flag) {
-    cm->log2_tile_cols = cm->min_log2_tile_cols;
-    while (cm->log2_tile_cols < cm->max_log2_tile_cols) {
-      if (!aom_rb_read_bit(rb)) {
-        break;
-      }
-      cm->log2_tile_cols++;
-    }
-  } else {
-    int i;
-    int start_sb;
-    for (i = 0, start_sb = 0; width_sb > 0 && i < MAX_TILE_COLS; i++) {
-      const int size_sb =
-          1 + rb_read_uniform(rb, AOMMIN(width_sb, cm->max_tile_width_sb));
-      cm->tile_col_start_sb[i] = start_sb;
-      start_sb += size_sb;
-      width_sb -= size_sb;
-    }
-    cm->tile_cols = i;
-    cm->tile_col_start_sb[i] = start_sb + width_sb;
-  }
-  av1_calculate_tile_cols(cm);
-
-  // Read tile rows
-  if (cm->uniform_tile_spacing_flag) {
-    cm->log2_tile_rows = cm->min_log2_tile_rows;
-    while (cm->log2_tile_rows < cm->max_log2_tile_rows) {
-      if (!aom_rb_read_bit(rb)) {
-        break;
-      }
-      cm->log2_tile_rows++;
-    }
-  } else {
-    int i;
-    int start_sb;
-    for (i = 0, start_sb = 0; height_sb > 0 && i < MAX_TILE_ROWS; i++) {
-      const int size_sb =
-          1 + rb_read_uniform(rb, AOMMIN(height_sb, cm->max_tile_height_sb));
-      cm->tile_row_start_sb[i] = start_sb;
-      start_sb += size_sb;
-      height_sb -= size_sb;
-    }
-    cm->tile_rows = i;
-    cm->tile_row_start_sb[i] = start_sb + height_sb;
-  }
-  av1_calculate_tile_rows(cm);
-}
-
-void av1_set_single_tile_decoding_mode(AV1_COMMON *const cm) {
-  cm->single_tile_decoding = 0;
-  if (cm->large_scale_tile) {
-    struct loopfilter *lf = &cm->lf;
-
-    // Figure out single_tile_decoding by loopfilter_level.
-    const int no_loopfilter = !(lf->filter_level[0] || lf->filter_level[1]);
-    const int no_cdef = cm->cdef_bits == 0 && cm->cdef_strengths[0] == 0 &&
-                        cm->cdef_uv_strengths[0] == 0;
-    const int no_restoration =
-        cm->rst_info[0].frame_restoration_type == RESTORE_NONE &&
-        cm->rst_info[1].frame_restoration_type == RESTORE_NONE &&
-        cm->rst_info[2].frame_restoration_type == RESTORE_NONE;
-    assert(IMPLIES(cm->coded_lossless, no_loopfilter && no_cdef));
-    assert(IMPLIES(cm->all_lossless, no_restoration));
-    cm->single_tile_decoding = no_loopfilter && no_cdef && no_restoration;
-  }
-}
-
-static void read_tile_info(AV1Decoder *const pbi,
-                           struct aom_read_bit_buffer *const rb) {
-  AV1_COMMON *const cm = &pbi->common;
-
-  read_tile_info_max_tile(cm, rb);
-
-  cm->context_update_tile_id = 0;
-  if (cm->tile_rows * cm->tile_cols > 1) {
-    // tile to use for cdf update
-    cm->context_update_tile_id =
-        aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols);
-    if (cm->context_update_tile_id >= cm->tile_rows * cm->tile_cols) {
-      aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                         "Invalid context_update_tile_id");
-    }
-    // tile size magnitude
-    pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1;
-  }
-}
-
-#if EXT_TILE_DEBUG
-static void read_ext_tile_info(AV1Decoder *const pbi,
-                               struct aom_read_bit_buffer *const rb) {
-  AV1_COMMON *const cm = &pbi->common;
-
-  // This information is stored as a separate byte.
-  int mod = rb->bit_offset % CHAR_BIT;
-  if (mod > 0) aom_rb_read_literal(rb, CHAR_BIT - mod);
-  assert(rb->bit_offset % CHAR_BIT == 0);
-
-  if (cm->tile_cols * cm->tile_rows > 1) {
-    // Read the number of bytes used to store tile size
-    pbi->tile_col_size_bytes = aom_rb_read_literal(rb, 2) + 1;
-    pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1;
-  }
-}
-#endif  // EXT_TILE_DEBUG
-
-static size_t mem_get_varsize(const uint8_t *src, int sz) {
-  switch (sz) {
-    case 1: return src[0];
-    case 2: return mem_get_le16(src);
-    case 3: return mem_get_le24(src);
-    case 4: return mem_get_le32(src);
-    default: assert(0 && "Invalid size"); return -1;
-  }
-}
-
-#if EXT_TILE_DEBUG
-// Reads the next tile returning its size and adjusting '*data' accordingly
-// based on 'is_last'. On return, '*data' is updated to point to the end of the
-// raw tile buffer in the bit stream.
-static void get_ls_tile_buffer(
-    const uint8_t *const data_end, struct aom_internal_error_info *error_info,
-    const uint8_t **data, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS],
-    int tile_size_bytes, int col, int row, int tile_copy_mode) {
-  size_t size;
-
-  size_t copy_size = 0;
-  const uint8_t *copy_data = NULL;
-
-  if (!read_is_valid(*data, tile_size_bytes, data_end))
-    aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
-                       "Truncated packet or corrupt tile length");
-  size = mem_get_varsize(*data, tile_size_bytes);
-
-  // If tile_copy_mode = 1, then the top bit of the tile header indicates copy
-  // mode.
-  if (tile_copy_mode && (size >> (tile_size_bytes * 8 - 1)) == 1) {
-    // The remaining bits in the top byte signal the row offset
-    int offset = (size >> (tile_size_bytes - 1) * 8) & 0x7f;
-
-    // Currently, only use tiles in same column as reference tiles.
-    copy_data = tile_buffers[row - offset][col].data;
-    copy_size = tile_buffers[row - offset][col].size;
-    size = 0;
-  } else {
-    size += AV1_MIN_TILE_SIZE_BYTES;
-  }
-
-  *data += tile_size_bytes;
-
-  if (size > (size_t)(data_end - *data))
-    aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
-                       "Truncated packet or corrupt tile size");
-
-  if (size > 0) {
-    tile_buffers[row][col].data = *data;
-    tile_buffers[row][col].size = size;
-  } else {
-    tile_buffers[row][col].data = copy_data;
-    tile_buffers[row][col].size = copy_size;
-  }
-
-  *data += size;
-}
-
-// Returns the end of the last tile buffer
-// (tile_buffers[cm->tile_rows - 1][cm->tile_cols - 1]).
-static const uint8_t *get_ls_tile_buffers(
-    AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end,
-    TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) {
-  AV1_COMMON *const cm = &pbi->common;
-  const int tile_cols = cm->tile_cols;
-  const int tile_rows = cm->tile_rows;
-  const int have_tiles = tile_cols * tile_rows > 1;
-  const uint8_t *raw_data_end;  // The end of the last tile buffer
-
-  if (!have_tiles) {
-    const size_t tile_size = data_end - data;
-    tile_buffers[0][0].data = data;
-    tile_buffers[0][0].size = tile_size;
-    raw_data_end = NULL;
-  } else {
-    // We locate only the tile buffers that are required, which are the ones
-    // specified by pbi->dec_tile_col and pbi->dec_tile_row. Also, we always
-    // need the last (bottom right) tile buffer, as we need to know where the
-    // end of the compressed frame buffer is for proper superframe decoding.
-
-    const uint8_t *tile_col_data_end[MAX_TILE_COLS] = { NULL };
-    const uint8_t *const data_start = data;
-
-    const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
-    const int single_row = pbi->dec_tile_row >= 0;
-    const int tile_rows_start = single_row ? dec_tile_row : 0;
-    const int tile_rows_end = single_row ? tile_rows_start + 1 : tile_rows;
-    const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
-    const int single_col = pbi->dec_tile_col >= 0;
-    const int tile_cols_start = single_col ? dec_tile_col : 0;
-    const int tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
-
-    const int tile_col_size_bytes = pbi->tile_col_size_bytes;
-    const int tile_size_bytes = pbi->tile_size_bytes;
-    const int tile_copy_mode =
-        ((AOMMAX(cm->tile_width, cm->tile_height) << MI_SIZE_LOG2) <= 256) ? 1
-                                                                           : 0;
-    // Read tile column sizes for all columns (we need the last tile buffer)
-    for (int c = 0; c < tile_cols; ++c) {
-      const int is_last = c == tile_cols - 1;
-      size_t tile_col_size;
-
-      if (!is_last) {
-        tile_col_size = mem_get_varsize(data, tile_col_size_bytes);
-        data += tile_col_size_bytes;
-        tile_col_data_end[c] = data + tile_col_size;
-      } else {
-        tile_col_size = data_end - data;
-        tile_col_data_end[c] = data_end;
-      }
-      data += tile_col_size;
-    }
-
-    data = data_start;
-
-    // Read the required tile sizes.
-    for (int c = tile_cols_start; c < tile_cols_end; ++c) {
-      const int is_last = c == tile_cols - 1;
-
-      if (c > 0) data = tile_col_data_end[c - 1];
-
-      if (!is_last) data += tile_col_size_bytes;
-
-      // Get the whole of the last column, otherwise stop at the required tile.
-      for (int r = 0; r < (is_last ? tile_rows : tile_rows_end); ++r) {
-        get_ls_tile_buffer(tile_col_data_end[c], &pbi->common.error, &data,
-                           tile_buffers, tile_size_bytes, c, r, tile_copy_mode);
-      }
-    }
-
-    // If we have not read the last column, then read it to get the last tile.
-    if (tile_cols_end != tile_cols) {
-      const int c = tile_cols - 1;
-
-      data = tile_col_data_end[c - 1];
-
-      for (int r = 0; r < tile_rows; ++r) {
-        get_ls_tile_buffer(tile_col_data_end[c], &pbi->common.error, &data,
-                           tile_buffers, tile_size_bytes, c, r, tile_copy_mode);
-      }
-    }
-    raw_data_end = data;
-  }
-  return raw_data_end;
-}
-#endif  // EXT_TILE_DEBUG
-
-static const uint8_t *get_ls_single_tile_buffer(
-    AV1Decoder *pbi, const uint8_t *data,
-    TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) {
-  assert(pbi->dec_tile_row >= 0 && pbi->dec_tile_col >= 0);
-  tile_buffers[pbi->dec_tile_row][pbi->dec_tile_col].data = data;
-  tile_buffers[pbi->dec_tile_row][pbi->dec_tile_col].size =
-      (size_t)pbi->coded_tile_data_size;
-  return data + pbi->coded_tile_data_size;
-}
-
-// Reads the next tile returning its size and adjusting '*data' accordingly
-// based on 'is_last'.
-static void get_tile_buffer(const uint8_t *const data_end,
-                            const int tile_size_bytes, int is_last,
-                            struct aom_internal_error_info *error_info,
-                            const uint8_t **data, TileBufferDec *const buf) {
-  size_t size;
-
-  if (!is_last) {
-    if (!read_is_valid(*data, tile_size_bytes, data_end))
-      aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
-                         "Truncated packet or corrupt tile length");
-
-    size = mem_get_varsize(*data, tile_size_bytes) + AV1_MIN_TILE_SIZE_BYTES;
-    *data += tile_size_bytes;
-
-    if (size > (size_t)(data_end - *data))
-      aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
-                         "Truncated packet or corrupt tile size");
-  } else {
-    size = data_end - *data;
-  }
-
-  buf->data = *data;
-  buf->size = size;
-
-  *data += size;
-}
-
-static void get_tile_buffers(AV1Decoder *pbi, const uint8_t *data,
-                             const uint8_t *data_end,
-                             TileBufferDec (*const tile_buffers)[MAX_TILE_COLS],
-                             int start_tile, int end_tile) {
-  AV1_COMMON *const cm = &pbi->common;
-  const int tile_cols = cm->tile_cols;
-  const int tile_rows = cm->tile_rows;
-  int tc = 0;
-  int first_tile_in_tg = 0;
-
-  for (int r = 0; r < tile_rows; ++r) {
-    for (int c = 0; c < tile_cols; ++c, ++tc) {
-      TileBufferDec *const buf = &tile_buffers[r][c];
-
-      const int is_last = (tc == end_tile);
-      const size_t hdr_offset = 0;
-
-      if (tc < start_tile || tc > end_tile) continue;
-
-      if (data + hdr_offset >= data_end)
-        aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                           "Data ended before all tiles were read.");
-      first_tile_in_tg += tc == first_tile_in_tg ? pbi->tg_size : 0;
-      data += hdr_offset;
-      get_tile_buffer(data_end, pbi->tile_size_bytes, is_last,
-                      &pbi->common.error, &data, buf);
-    }
-  }
-}
-
-static void set_cb_buffer(AV1Decoder *pbi, MACROBLOCKD *const xd,
-                          CB_BUFFER *cb_buffer_base, const int num_planes,
-                          int mi_row, int mi_col) {
-  AV1_COMMON *const cm = &pbi->common;
-  int mib_size_log2 = cm->seq_params.mib_size_log2;
-  int stride = (cm->mi_cols >> mib_size_log2) + 1;
-  int offset = (mi_row >> mib_size_log2) * stride + (mi_col >> mib_size_log2);
-  CB_BUFFER *cb_buffer = cb_buffer_base + offset;
-
-  for (int plane = 0; plane < num_planes; ++plane) {
-    xd->plane[plane].dqcoeff_block = cb_buffer->dqcoeff[plane];
-    xd->plane[plane].eob_data = cb_buffer->eob_data[plane];
-    xd->cb_offset[plane] = 0;
-    xd->txb_offset[plane] = 0;
-  }
-  xd->plane[0].color_index_map = cb_buffer->color_index_map[0];
-  xd->plane[1].color_index_map = cb_buffer->color_index_map[1];
-  xd->color_index_map_offset[0] = 0;
-  xd->color_index_map_offset[1] = 0;
-}
-
-static void decoder_alloc_tile_data(AV1Decoder *pbi, const int n_tiles) {
-  AV1_COMMON *const cm = &pbi->common;
-  aom_free(pbi->tile_data);
-  CHECK_MEM_ERROR(cm, pbi->tile_data,
-                  aom_memalign(32, n_tiles * sizeof(*pbi->tile_data)));
-  pbi->allocated_tiles = n_tiles;
-  for (int i = 0; i < n_tiles; i++) {
-    TileDataDec *const tile_data = pbi->tile_data + i;
-    av1_zero(tile_data->dec_row_mt_sync);
-  }
-  pbi->allocated_row_mt_sync_rows = 0;
-}
-
-// Set up nsync by width.
-static INLINE int get_sync_range(int width) {
-// nsync numbers are picked by testing.
-#if 0
-  if (width < 640)
-    return 1;
-  else if (width <= 1280)
-    return 2;
-  else if (width <= 4096)
-    return 4;
-  else
-    return 8;
-#else
-  (void)width;
-#endif
-  return 1;
-}
-
-// Allocate memory for decoder row synchronization
-static void dec_row_mt_alloc(AV1DecRowMTSync *dec_row_mt_sync, AV1_COMMON *cm,
-                             int rows) {
-  dec_row_mt_sync->allocated_sb_rows = rows;
-#if CONFIG_MULTITHREAD
-  {
-    int i;
-
-    CHECK_MEM_ERROR(cm, dec_row_mt_sync->mutex_,
-                    aom_malloc(sizeof(*(dec_row_mt_sync->mutex_)) * rows));
-    if (dec_row_mt_sync->mutex_) {
-      for (i = 0; i < rows; ++i) {
-        pthread_mutex_init(&dec_row_mt_sync->mutex_[i], NULL);
-      }
-    }
-
-    CHECK_MEM_ERROR(cm, dec_row_mt_sync->cond_,
-                    aom_malloc(sizeof(*(dec_row_mt_sync->cond_)) * rows));
-    if (dec_row_mt_sync->cond_) {
-      for (i = 0; i < rows; ++i) {
-        pthread_cond_init(&dec_row_mt_sync->cond_[i], NULL);
-      }
-    }
-  }
-#endif  // CONFIG_MULTITHREAD
-
-  CHECK_MEM_ERROR(cm, dec_row_mt_sync->cur_sb_col,
-                  aom_malloc(sizeof(*(dec_row_mt_sync->cur_sb_col)) * rows));
-
-  // Set up nsync.
-  dec_row_mt_sync->sync_range = get_sync_range(cm->width);
-}
-
-// Deallocate decoder row synchronization related mutex and data
-void av1_dec_row_mt_dealloc(AV1DecRowMTSync *dec_row_mt_sync) {
-  if (dec_row_mt_sync != NULL) {
-#if CONFIG_MULTITHREAD
-    int i;
-    if (dec_row_mt_sync->mutex_ != NULL) {
-      for (i = 0; i < dec_row_mt_sync->allocated_sb_rows; ++i) {
-        pthread_mutex_destroy(&dec_row_mt_sync->mutex_[i]);
-      }
-      aom_free(dec_row_mt_sync->mutex_);
-    }
-    if (dec_row_mt_sync->cond_ != NULL) {
-      for (i = 0; i < dec_row_mt_sync->allocated_sb_rows; ++i) {
-        pthread_cond_destroy(&dec_row_mt_sync->cond_[i]);
-      }
-      aom_free(dec_row_mt_sync->cond_);
-    }
-#endif  // CONFIG_MULTITHREAD
-    aom_free(dec_row_mt_sync->cur_sb_col);
-
-    // clear the structure as the source of this call may be a resize in which
-    // case this call will be followed by an _alloc() which may fail.
-    av1_zero(*dec_row_mt_sync);
-  }
-}
-
-static INLINE void sync_read(AV1DecRowMTSync *const dec_row_mt_sync, int r,
-                             int c) {
-#if CONFIG_MULTITHREAD
-  const int nsync = dec_row_mt_sync->sync_range;
-
-  if (r && !(c & (nsync - 1))) {
-    pthread_mutex_t *const mutex = &dec_row_mt_sync->mutex_[r - 1];
-    pthread_mutex_lock(mutex);
-
-    while (c > dec_row_mt_sync->cur_sb_col[r - 1] - nsync) {
-      pthread_cond_wait(&dec_row_mt_sync->cond_[r - 1], mutex);
-    }
-    pthread_mutex_unlock(mutex);
-  }
-#else
-  (void)dec_row_mt_sync;
-  (void)r;
-  (void)c;
-#endif  // CONFIG_MULTITHREAD
-}
-
-static INLINE void sync_write(AV1DecRowMTSync *const dec_row_mt_sync, int r,
-                              int c, const int sb_cols) {
-#if CONFIG_MULTITHREAD
-  const int nsync = dec_row_mt_sync->sync_range;
-  int cur;
-  int sig = 1;
-
-  if (c < sb_cols - 1) {
-    cur = c;
-    if (c % nsync) sig = 0;
-  } else {
-    cur = sb_cols + nsync;
-  }
-
-  if (sig) {
-    pthread_mutex_lock(&dec_row_mt_sync->mutex_[r]);
-
-    dec_row_mt_sync->cur_sb_col[r] = cur;
-
-    pthread_cond_signal(&dec_row_mt_sync->cond_[r]);
-    pthread_mutex_unlock(&dec_row_mt_sync->mutex_[r]);
-  }
-#else
-  (void)dec_row_mt_sync;
-  (void)r;
-  (void)c;
-  (void)sb_cols;
-#endif  // CONFIG_MULTITHREAD
-}
-
-static void decode_tile_sb_row(AV1Decoder *pbi, ThreadData *const td,
-                               TileInfo tile_info, const int mi_row) {
-  AV1_COMMON *const cm = &pbi->common;
-  const int num_planes = av1_num_planes(cm);
-  TileDataDec *const tile_data =
-      pbi->tile_data + tile_info.tile_row * cm->tile_cols + tile_info.tile_col;
-  const int sb_cols_in_tile = av1_get_sb_cols_in_tile(cm, tile_info);
-  const int sb_row_in_tile =
-      (mi_row - tile_info.mi_row_start) >> cm->seq_params.mib_size_log2;
-  int sb_col_in_tile = 0;
-
-  for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
-       mi_col += cm->seq_params.mib_size, sb_col_in_tile++) {
-    set_cb_buffer(pbi, &td->xd, pbi->cb_buffer_base, num_planes, mi_row,
-                  mi_col);
-
-    sync_read(&tile_data->dec_row_mt_sync, sb_row_in_tile, sb_col_in_tile);
-
-    // Decoding of the super-block
-    decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
-                     cm->seq_params.sb_size, 0x2);
-
-    sync_write(&tile_data->dec_row_mt_sync, sb_row_in_tile, sb_col_in_tile,
-               sb_cols_in_tile);
-  }
-}
-
-static int check_trailing_bits_after_symbol_coder(aom_reader *r) {
-  if (aom_reader_has_overflowed(r)) return -1;
-
-  uint32_t nb_bits = aom_reader_tell(r);
-  uint32_t nb_bytes = (nb_bits + 7) >> 3;
-  const uint8_t *p = aom_reader_find_begin(r) + nb_bytes;
-
-  // aom_reader_tell() returns 1 for a newly initialized decoder, and the
-  // return value only increases as values are decoded. So nb_bits > 0, and
-  // thus p > p_begin. Therefore accessing p[-1] is safe.
-  uint8_t last_byte = p[-1];
-  uint8_t pattern = 128 >> ((nb_bits - 1) & 7);
-  if ((last_byte & (2 * pattern - 1)) != pattern) return -1;
-
-  // Make sure that all padding bytes are zero as required by the spec.
-  const uint8_t *p_end = aom_reader_find_end(r);
-  while (p < p_end) {
-    if (*p != 0) return -1;
-    p++;
-  }
-  return 0;
-}
-
-static void set_decode_func_pointers(ThreadData *td, int parse_decode_flag) {
-  td->read_coeffs_tx_intra_block_visit = decode_block_void;
-  td->predict_and_recon_intra_block_visit = decode_block_void;
-  td->read_coeffs_tx_inter_block_visit = decode_block_void;
-  td->inverse_tx_inter_block_visit = decode_block_void;
-  td->predict_inter_block_visit = predict_inter_block_void;
-  td->cfl_store_inter_block_visit = cfl_store_inter_block_void;
-
-  if (parse_decode_flag & 0x1) {
-    td->read_coeffs_tx_intra_block_visit = read_coeffs_tx_intra_block;
-    td->read_coeffs_tx_inter_block_visit = av1_read_coeffs_txb_facade;
-  }
-  if (parse_decode_flag & 0x2) {
-    td->predict_and_recon_intra_block_visit =
-        predict_and_reconstruct_intra_block;
-    td->inverse_tx_inter_block_visit = inverse_transform_inter_block;
-    td->predict_inter_block_visit = predict_inter_block;
-    td->cfl_store_inter_block_visit = cfl_store_inter_block;
-  }
-}
-
-static void decode_tile(AV1Decoder *pbi, ThreadData *const td, int tile_row,
-                        int tile_col) {
-  TileInfo tile_info;
-
-  AV1_COMMON *const cm = &pbi->common;
-  const int num_planes = av1_num_planes(cm);
-
-  av1_tile_set_row(&tile_info, cm, tile_row);
-  av1_tile_set_col(&tile_info, cm, tile_col);
-  av1_zero_above_context(cm, &td->xd, tile_info.mi_col_start,
-                         tile_info.mi_col_end, tile_row);
-  av1_reset_loop_filter_delta(&td->xd, num_planes);
-  av1_reset_loop_restoration(&td->xd, num_planes);
-
-  for (int mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end;
-       mi_row += cm->seq_params.mib_size) {
-    av1_zero_left_context(&td->xd);
-
-    for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
-         mi_col += cm->seq_params.mib_size) {
-      set_cb_buffer(pbi, &td->xd, &td->cb_buffer_base, num_planes, 0, 0);
-
-      // Bit-stream parsing and decoding of the superblock
-      decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
-                       cm->seq_params.sb_size, 0x3);
-
-      if (aom_reader_has_overflowed(td->bit_reader)) {
-        aom_merge_corrupted_flag(&td->xd.corrupted, 1);
-        return;
-      }
-    }
-  }
-
-  int corrupted =
-      (check_trailing_bits_after_symbol_coder(td->bit_reader)) ? 1 : 0;
-  aom_merge_corrupted_flag(&td->xd.corrupted, corrupted);
-}
-
-static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
-                                   const uint8_t *data_end, int start_tile,
-                                   int end_tile) {
-  AV1_COMMON *const cm = &pbi->common;
-  ThreadData *const td = &pbi->td;
-  const int tile_cols = cm->tile_cols;
-  const int tile_rows = cm->tile_rows;
-  const int n_tiles = tile_cols * tile_rows;
-  TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers;
-  const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
-  const int single_row = pbi->dec_tile_row >= 0;
-  const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
-  const int single_col = pbi->dec_tile_col >= 0;
-  int tile_rows_start;
-  int tile_rows_end;
-  int tile_cols_start;
-  int tile_cols_end;
-  int inv_col_order;
-  int inv_row_order;
-  int tile_row, tile_col;
-  uint8_t allow_update_cdf;
-  const uint8_t *raw_data_end = NULL;
-
-  if (cm->large_scale_tile) {
-    tile_rows_start = single_row ? dec_tile_row : 0;
-    tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows;
-    tile_cols_start = single_col ? dec_tile_col : 0;
-    tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
-    inv_col_order = pbi->inv_tile_order && !single_col;
-    inv_row_order = pbi->inv_tile_order && !single_row;
-    allow_update_cdf = 0;
-  } else {
-    tile_rows_start = 0;
-    tile_rows_end = tile_rows;
-    tile_cols_start = 0;
-    tile_cols_end = tile_cols;
-    inv_col_order = pbi->inv_tile_order;
-    inv_row_order = pbi->inv_tile_order;
-    allow_update_cdf = 1;
-  }
-
-  // No tiles to decode.
-  if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start ||
-      // First tile is larger than end_tile.
-      tile_rows_start * cm->tile_cols + tile_cols_start > end_tile ||
-      // Last tile is smaller than start_tile.
-      (tile_rows_end - 1) * cm->tile_cols + tile_cols_end - 1 < start_tile)
-    return data;
-
-  allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update;
-
-  assert(tile_rows <= MAX_TILE_ROWS);
-  assert(tile_cols <= MAX_TILE_COLS);
-
-#if EXT_TILE_DEBUG
-  if (cm->large_scale_tile && !pbi->ext_tile_debug)
-    raw_data_end = get_ls_single_tile_buffer(pbi, data, tile_buffers);
-  else if (cm->large_scale_tile && pbi->ext_tile_debug)
-    raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers);
-  else
-#endif  // EXT_TILE_DEBUG
-    get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile);
-
-  if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) {
-    decoder_alloc_tile_data(pbi, n_tiles);
-  }
-#if CONFIG_ACCOUNTING
-  if (pbi->acct_enabled) {
-    aom_accounting_reset(&pbi->accounting);
-  }
-#endif
-
-  set_decode_func_pointers(&pbi->td, 0x3);
-
-  // Load all tile information into thread_data.
-  td->xd = pbi->mb;
-  td->xd.corrupted = 0;
-  td->xd.mc_buf[0] = td->mc_buf[0];
-  td->xd.mc_buf[1] = td->mc_buf[1];
-  td->xd.tmp_conv_dst = td->tmp_conv_dst;
-  for (int j = 0; j < 2; ++j) {
-    td->xd.tmp_obmc_bufs[j] = td->tmp_obmc_bufs[j];
-  }
-
-  for (tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) {
-    const int row = inv_row_order ? tile_rows - 1 - tile_row : tile_row;
-
-    for (tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) {
-      const int col = inv_col_order ? tile_cols - 1 - tile_col : tile_col;
-      TileDataDec *const tile_data = pbi->tile_data + row * cm->tile_cols + col;
-      const TileBufferDec *const tile_bs_buf = &tile_buffers[row][col];
-
-      if (row * cm->tile_cols + col < start_tile ||
-          row * cm->tile_cols + col > end_tile)
-        continue;
-
-      td->bit_reader = &tile_data->bit_reader;
-      av1_zero(td->dqcoeff);
-      av1_tile_init(&td->xd.tile, cm, row, col);
-      td->xd.current_qindex = cm->base_qindex;
-      setup_bool_decoder(tile_bs_buf->data, data_end, tile_bs_buf->size,
-                         &cm->error, td->bit_reader, allow_update_cdf);
-#if CONFIG_ACCOUNTING
-      if (pbi->acct_enabled) {
-        td->bit_reader->accounting = &pbi->accounting;
-        td->bit_reader->accounting->last_tell_frac =
-            aom_reader_tell_frac(td->bit_reader);
-      } else {
-        td->bit_reader->accounting = NULL;
-      }
-#endif
-      av1_init_macroblockd(cm, &td->xd, td->dqcoeff);
-      av1_init_above_context(cm, &td->xd, row);
-
-      // Initialise the tile context from the frame context
-      tile_data->tctx = *cm->fc;
-      td->xd.tile_ctx = &tile_data->tctx;
-
-      // decode tile
-      decode_tile(pbi, td, row, col);
-      aom_merge_corrupted_flag(&pbi->mb.corrupted, td->xd.corrupted);
-      if (pbi->mb.corrupted)
-        aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                           "Failed to decode tile data");
-    }
-  }
-
-  if (cm->large_scale_tile) {
-    if (n_tiles == 1) {
-      // Find the end of the single tile buffer
-      return aom_reader_find_end(&pbi->tile_data->bit_reader);
-    }
-    // Return the end of the last tile buffer
-    return raw_data_end;
-  }
-  TileDataDec *const tile_data = pbi->tile_data + end_tile;
-
-  return aom_reader_find_end(&tile_data->bit_reader);
-}
-
-static TileJobsDec *get_dec_job_info(AV1DecTileMT *tile_mt_info) {
-  TileJobsDec *cur_job_info = NULL;
-#if CONFIG_MULTITHREAD
-  pthread_mutex_lock(tile_mt_info->job_mutex);
-
-  if (tile_mt_info->jobs_dequeued < tile_mt_info->jobs_enqueued) {
-    cur_job_info = tile_mt_info->job_queue + tile_mt_info->jobs_dequeued;
-    tile_mt_info->jobs_dequeued++;
-  }
-
-  pthread_mutex_unlock(tile_mt_info->job_mutex);
-#else
-  (void)tile_mt_info;
-#endif
-  return cur_job_info;
-}
-
-static void tile_worker_hook_init(AV1Decoder *const pbi,
-                                  DecWorkerData *const thread_data,
-                                  const TileBufferDec *const tile_buffer,
-                                  TileDataDec *const tile_data,
-                                  uint8_t allow_update_cdf) {
-  AV1_COMMON *cm = &pbi->common;
-  ThreadData *const td = thread_data->td;
-  int tile_row = tile_data->tile_info.tile_row;
-  int tile_col = tile_data->tile_info.tile_col;
-
-  td->bit_reader = &tile_data->bit_reader;
-  av1_zero(td->dqcoeff);
-  av1_tile_init(&td->xd.tile, cm, tile_row, tile_col);
-  td->xd.current_qindex = cm->base_qindex;
-  setup_bool_decoder(tile_buffer->data, thread_data->data_end,
-                     tile_buffer->size, &thread_data->error_info,
-                     td->bit_reader, allow_update_cdf);
-#if CONFIG_ACCOUNTING
-  if (pbi->acct_enabled) {
-    td->bit_reader->accounting = &pbi->accounting;
-    td->bit_reader->accounting->last_tell_frac =
-        aom_reader_tell_frac(td->bit_reader);
-  } else {
-    td->bit_reader->accounting = NULL;
-  }
-#endif
-  av1_init_macroblockd(cm, &td->xd, td->dqcoeff);
-  td->xd.error_info = &thread_data->error_info;
-  av1_init_above_context(cm, &td->xd, tile_row);
-
-  // Initialise the tile context from the frame context
-  tile_data->tctx = *cm->fc;
-  td->xd.tile_ctx = &tile_data->tctx;
-#if CONFIG_ACCOUNTING
-  if (pbi->acct_enabled) {
-    tile_data->bit_reader.accounting->last_tell_frac =
-        aom_reader_tell_frac(&tile_data->bit_reader);
-  }
-#endif
-}
-
-static int tile_worker_hook(void *arg1, void *arg2) {
-  DecWorkerData *const thread_data = (DecWorkerData *)arg1;
-  AV1Decoder *const pbi = (AV1Decoder *)arg2;
-  AV1_COMMON *cm = &pbi->common;
-  ThreadData *const td = thread_data->td;
-  uint8_t allow_update_cdf;
-
-  // The jmp_buf is valid only for the duration of the function that calls
-  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
-  // before it returns.
-  if (setjmp(thread_data->error_info.jmp)) {
-    thread_data->error_info.setjmp = 0;
-    thread_data->td->xd.corrupted = 1;
-    return 0;
-  }
-  thread_data->error_info.setjmp = 1;
-
-  allow_update_cdf = cm->large_scale_tile ? 0 : 1;
-  allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update;
-
-  set_decode_func_pointers(td, 0x3);
-
-  assert(cm->tile_cols > 0);
-  while (1) {
-    TileJobsDec *cur_job_info = get_dec_job_info(&pbi->tile_mt_info);
-
-    if (cur_job_info != NULL && !td->xd.corrupted) {
-      const TileBufferDec *const tile_buffer = cur_job_info->tile_buffer;
-      TileDataDec *const tile_data = cur_job_info->tile_data;
-      tile_worker_hook_init(pbi, thread_data, tile_buffer, tile_data,
-                            allow_update_cdf);
-      // decode tile
-      int tile_row = tile_data->tile_info.tile_row;
-      int tile_col = tile_data->tile_info.tile_col;
-      decode_tile(pbi, td, tile_row, tile_col);
-    } else {
-      break;
-    }
-  }
-  thread_data->error_info.setjmp = 0;
-  return !td->xd.corrupted;
-}
-
-static int get_next_job_info(AV1Decoder *const pbi,
-                             AV1DecRowMTJobInfo *next_job_info,
-                             int *end_of_frame) {
-  AV1_COMMON *cm = &pbi->common;
-  TileDataDec *tile_data;
-  AV1DecRowMTSync *dec_row_mt_sync;
-  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
-  TileInfo tile_info;
-  const int tile_rows_start = frame_row_mt_info->tile_rows_start;
-  const int tile_rows_end = frame_row_mt_info->tile_rows_end;
-  const int tile_cols_start = frame_row_mt_info->tile_cols_start;
-  const int tile_cols_end = frame_row_mt_info->tile_cols_end;
-  const int start_tile = frame_row_mt_info->start_tile;
-  const int end_tile = frame_row_mt_info->end_tile;
-  const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
-  int num_mis_to_decode, num_threads_working;
-  int num_mis_waiting_for_decode;
-  int min_threads_working = INT_MAX;
-  int max_mis_to_decode = 0;
-  int tile_row_idx, tile_col_idx;
-  int tile_row = 0;
-  int tile_col = 0;
-
-  memset(next_job_info, 0, sizeof(*next_job_info));
-
-  // Frame decode is completed or error is encountered.
-  *end_of_frame = (frame_row_mt_info->mi_rows_decode_started ==
-                   frame_row_mt_info->mi_rows_to_decode) ||
-                  (frame_row_mt_info->row_mt_exit == 1);
-  if (*end_of_frame) {
-    return 1;
-  }
-
-  // Decoding cannot start as bit-stream parsing is not complete.
-  if (frame_row_mt_info->mi_rows_parse_done -
-          frame_row_mt_info->mi_rows_decode_started ==
-      0)
-    return 0;
-
-  // Choose the tile to decode.
-  for (tile_row_idx = tile_rows_start; tile_row_idx < tile_rows_end;
-       ++tile_row_idx) {
-    for (tile_col_idx = tile_cols_start; tile_col_idx < tile_cols_end;
-         ++tile_col_idx) {
-      if (tile_row_idx * cm->tile_cols + tile_col_idx < start_tile ||
-          tile_row_idx * cm->tile_cols + tile_col_idx > end_tile)
-        continue;
-
-      tile_data = pbi->tile_data + tile_row_idx * cm->tile_cols + tile_col_idx;
-      dec_row_mt_sync = &tile_data->dec_row_mt_sync;
-
-      num_threads_working = dec_row_mt_sync->num_threads_working;
-      num_mis_waiting_for_decode = (dec_row_mt_sync->mi_rows_parse_done -
-                                    dec_row_mt_sync->mi_rows_decode_started) *
-                                   dec_row_mt_sync->mi_cols;
-      num_mis_to_decode =
-          (dec_row_mt_sync->mi_rows - dec_row_mt_sync->mi_rows_decode_started) *
-          dec_row_mt_sync->mi_cols;
-
-      assert(num_mis_to_decode >= num_mis_waiting_for_decode);
-
-      // Pick the tile which has minimum number of threads working on it.
-      if (num_mis_waiting_for_decode > 0) {
-        if (num_threads_working < min_threads_working) {
-          min_threads_working = num_threads_working;
-          max_mis_to_decode = 0;
-        }
-        if (num_threads_working == min_threads_working &&
-            num_mis_to_decode > max_mis_to_decode) {
-          max_mis_to_decode = num_mis_to_decode;
-          tile_row = tile_row_idx;
-          tile_col = tile_col_idx;
-        }
-      }
-    }
-  }
-
-  tile_data = pbi->tile_data + tile_row * cm->tile_cols + tile_col;
-  tile_info = tile_data->tile_info;
-  dec_row_mt_sync = &tile_data->dec_row_mt_sync;
-
-  next_job_info->tile_row = tile_row;
-  next_job_info->tile_col = tile_col;
-  next_job_info->mi_row =
-      dec_row_mt_sync->mi_rows_decode_started + tile_info.mi_row_start;
-
-  dec_row_mt_sync->num_threads_working++;
-  dec_row_mt_sync->mi_rows_decode_started += sb_mi_size;
-  frame_row_mt_info->mi_rows_decode_started += sb_mi_size;
-
-  return 1;
-}
-
-static INLINE void signal_parse_sb_row_done(AV1Decoder *const pbi,
-                                            TileDataDec *const tile_data,
-                                            const int sb_mi_size) {
-  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
-#if CONFIG_MULTITHREAD
-  pthread_mutex_lock(pbi->row_mt_mutex_);
-#endif
-  tile_data->dec_row_mt_sync.mi_rows_parse_done += sb_mi_size;
-  frame_row_mt_info->mi_rows_parse_done += sb_mi_size;
-#if CONFIG_MULTITHREAD
-  pthread_cond_broadcast(pbi->row_mt_cond_);
-  pthread_mutex_unlock(pbi->row_mt_mutex_);
-#endif
-}
-
-static int row_mt_worker_hook(void *arg1, void *arg2) {
-  DecWorkerData *const thread_data = (DecWorkerData *)arg1;
-  AV1Decoder *const pbi = (AV1Decoder *)arg2;
-  AV1_COMMON *cm = &pbi->common;
-  ThreadData *const td = thread_data->td;
-  uint8_t allow_update_cdf;
-  const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
-  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
-  td->xd.corrupted = 0;
-
-  // The jmp_buf is valid only for the duration of the function that calls
-  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
-  // before it returns.
-  if (setjmp(thread_data->error_info.jmp)) {
-    thread_data->error_info.setjmp = 0;
-    thread_data->td->xd.corrupted = 1;
-#if CONFIG_MULTITHREAD
-    pthread_mutex_lock(pbi->row_mt_mutex_);
-#endif
-    frame_row_mt_info->row_mt_exit = 1;
-#if CONFIG_MULTITHREAD
-    pthread_cond_broadcast(pbi->row_mt_cond_);
-    pthread_mutex_unlock(pbi->row_mt_mutex_);
-#endif
-    return 0;
-  }
-  thread_data->error_info.setjmp = 1;
-
-  const int num_planes = av1_num_planes(cm);
-  allow_update_cdf = cm->large_scale_tile ? 0 : 1;
-  allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update;
-
-  assert(cm->tile_cols > 0);
-  while (1) {
-    TileJobsDec *cur_job_info = get_dec_job_info(&pbi->tile_mt_info);
-
-    if (cur_job_info != NULL && !td->xd.corrupted) {
-      const TileBufferDec *const tile_buffer = cur_job_info->tile_buffer;
-      TileDataDec *const tile_data = cur_job_info->tile_data;
-      tile_worker_hook_init(pbi, thread_data, tile_buffer, tile_data,
-                            allow_update_cdf);
-
-      set_decode_func_pointers(td, 0x1);
-
-      // decode tile
-      TileInfo tile_info = tile_data->tile_info;
-      int tile_row = tile_info.tile_row;
-
-      av1_zero_above_context(cm, &td->xd, tile_info.mi_col_start,
-                             tile_info.mi_col_end, tile_row);
-      av1_reset_loop_filter_delta(&td->xd, num_planes);
-      av1_reset_loop_restoration(&td->xd, num_planes);
-
-      for (int mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end;
-           mi_row += cm->seq_params.mib_size) {
-        av1_zero_left_context(&td->xd);
-
-        for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
-             mi_col += cm->seq_params.mib_size) {
-          set_cb_buffer(pbi, &td->xd, pbi->cb_buffer_base, num_planes, mi_row,
-                        mi_col);
-
-          // Bit-stream parsing of the superblock
-          decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
-                           cm->seq_params.sb_size, 0x1);
-        }
-        signal_parse_sb_row_done(pbi, tile_data, sb_mi_size);
-      }
-
-      int corrupted =
-          (check_trailing_bits_after_symbol_coder(td->bit_reader)) ? 1 : 0;
-      aom_merge_corrupted_flag(&td->xd.corrupted, corrupted);
-    } else {
-      break;
-    }
-  }
-
-  set_decode_func_pointers(td, 0x2);
-
-  while (1) {
-    AV1DecRowMTJobInfo next_job_info;
-    int end_of_frame = 0;
-
-#if CONFIG_MULTITHREAD
-    pthread_mutex_lock(pbi->row_mt_mutex_);
-#endif
-    while (!get_next_job_info(pbi, &next_job_info, &end_of_frame)) {
-#if CONFIG_MULTITHREAD
-      pthread_cond_wait(pbi->row_mt_cond_, pbi->row_mt_mutex_);
-#endif
-    }
-#if CONFIG_MULTITHREAD
-    pthread_mutex_unlock(pbi->row_mt_mutex_);
-#endif
-
-    if (end_of_frame) break;
-
-    int tile_row = next_job_info.tile_row;
-    int tile_col = next_job_info.tile_col;
-    int mi_row = next_job_info.mi_row;
-
-    TileDataDec *tile_data =
-        pbi->tile_data + tile_row * cm->tile_cols + tile_col;
-    AV1DecRowMTSync *dec_row_mt_sync = &tile_data->dec_row_mt_sync;
-    TileInfo tile_info = tile_data->tile_info;
-
-    av1_tile_init(&td->xd.tile, cm, tile_row, tile_col);
-    av1_init_macroblockd(cm, &td->xd, td->dqcoeff);
-    td->xd.error_info = &thread_data->error_info;
-
-    decode_tile_sb_row(pbi, td, tile_info, mi_row);
-
-#if CONFIG_MULTITHREAD
-    pthread_mutex_lock(pbi->row_mt_mutex_);
-#endif
-    dec_row_mt_sync->num_threads_working--;
-#if CONFIG_MULTITHREAD
-    pthread_mutex_unlock(pbi->row_mt_mutex_);
-#endif
-  }
-  thread_data->error_info.setjmp = 0;
-  return !td->xd.corrupted;
-}
-
-// sorts in descending order
-static int compare_tile_buffers(const void *a, const void *b) {
-  const TileJobsDec *const buf1 = (const TileJobsDec *)a;
-  const TileJobsDec *const buf2 = (const TileJobsDec *)b;
-  return (((int)buf2->tile_buffer->size) - ((int)buf1->tile_buffer->size));
-}
-
-static void enqueue_tile_jobs(AV1Decoder *pbi, AV1_COMMON *cm,
-                              int tile_rows_start, int tile_rows_end,
-                              int tile_cols_start, int tile_cols_end,
-                              int startTile, int endTile) {
-  AV1DecTileMT *tile_mt_info = &pbi->tile_mt_info;
-  TileJobsDec *tile_job_queue = tile_mt_info->job_queue;
-  tile_mt_info->jobs_enqueued = 0;
-  tile_mt_info->jobs_dequeued = 0;
-
-  for (int row = tile_rows_start; row < tile_rows_end; row++) {
-    for (int col = tile_cols_start; col < tile_cols_end; col++) {
-      if (row * cm->tile_cols + col < startTile ||
-          row * cm->tile_cols + col > endTile)
-        continue;
-      tile_job_queue->tile_buffer = &pbi->tile_buffers[row][col];
-      tile_job_queue->tile_data = pbi->tile_data + row * cm->tile_cols + col;
-      tile_job_queue++;
-      tile_mt_info->jobs_enqueued++;
-    }
-  }
-}
-
-static void alloc_dec_jobs(AV1DecTileMT *tile_mt_info, AV1_COMMON *cm,
-                           int tile_rows, int tile_cols) {
-  tile_mt_info->alloc_tile_rows = tile_rows;
-  tile_mt_info->alloc_tile_cols = tile_cols;
-  int num_tiles = tile_rows * tile_cols;
-#if CONFIG_MULTITHREAD
-  {
-    CHECK_MEM_ERROR(cm, tile_mt_info->job_mutex,
-                    aom_malloc(sizeof(*tile_mt_info->job_mutex) * num_tiles));
-
-    for (int i = 0; i < num_tiles; i++) {
-      pthread_mutex_init(&tile_mt_info->job_mutex[i], NULL);
-    }
-  }
-#endif
-  CHECK_MEM_ERROR(cm, tile_mt_info->job_queue,
-                  aom_malloc(sizeof(*tile_mt_info->job_queue) * num_tiles));
-}
-
-void av1_free_mc_tmp_buf(ThreadData *thread_data) {
-  int ref;
-  for (ref = 0; ref < 2; ref++) {
-    if (thread_data->mc_buf_use_highbd)
-      aom_free(CONVERT_TO_SHORTPTR(thread_data->mc_buf[ref]));
-    else
-      aom_free(thread_data->mc_buf[ref]);
-    thread_data->mc_buf[ref] = NULL;
-  }
-  thread_data->mc_buf_size = 0;
-  thread_data->mc_buf_use_highbd = 0;
-
-  aom_free(thread_data->tmp_conv_dst);
-  thread_data->tmp_conv_dst = NULL;
-  for (int i = 0; i < 2; ++i) {
-    aom_free(thread_data->tmp_obmc_bufs[i]);
-    thread_data->tmp_obmc_bufs[i] = NULL;
-  }
-}
-
-static void allocate_mc_tmp_buf(AV1_COMMON *const cm, ThreadData *thread_data,
-                                int buf_size, int use_highbd) {
-  for (int ref = 0; ref < 2; ref++) {
-    if (use_highbd) {
-      uint16_t *hbd_mc_buf;
-      CHECK_MEM_ERROR(cm, hbd_mc_buf, (uint16_t *)aom_memalign(16, buf_size));
-      thread_data->mc_buf[ref] = CONVERT_TO_BYTEPTR(hbd_mc_buf);
-    } else {
-      CHECK_MEM_ERROR(cm, thread_data->mc_buf[ref],
-                      (uint8_t *)aom_memalign(16, buf_size));
-    }
-  }
-  thread_data->mc_buf_size = buf_size;
-  thread_data->mc_buf_use_highbd = use_highbd;
-
-  CHECK_MEM_ERROR(cm, thread_data->tmp_conv_dst,
-                  aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE *
-                                       sizeof(*thread_data->tmp_conv_dst)));
-  for (int i = 0; i < 2; ++i) {
-    CHECK_MEM_ERROR(
-        cm, thread_data->tmp_obmc_bufs[i],
-        aom_memalign(16, 2 * MAX_MB_PLANE * MAX_SB_SQUARE *
-                             sizeof(*thread_data->tmp_obmc_bufs[i])));
-  }
-}
-
-static void reset_dec_workers(AV1Decoder *pbi, AVxWorkerHook worker_hook,
-                              int num_workers) {
-  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
-
-  // Reset tile decoding hook
-  for (int worker_idx = 0; worker_idx < num_workers; ++worker_idx) {
-    AVxWorker *const worker = &pbi->tile_workers[worker_idx];
-    DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
-    thread_data->td->xd = pbi->mb;
-    thread_data->td->xd.corrupted = 0;
-    thread_data->td->xd.mc_buf[0] = thread_data->td->mc_buf[0];
-    thread_data->td->xd.mc_buf[1] = thread_data->td->mc_buf[1];
-    thread_data->td->xd.tmp_conv_dst = thread_data->td->tmp_conv_dst;
-    for (int j = 0; j < 2; ++j) {
-      thread_data->td->xd.tmp_obmc_bufs[j] = thread_data->td->tmp_obmc_bufs[j];
-    }
-    winterface->sync(worker);
-
-    worker->hook = worker_hook;
-    worker->data1 = thread_data;
-    worker->data2 = pbi;
-  }
-#if CONFIG_ACCOUNTING
-  if (pbi->acct_enabled) {
-    aom_accounting_reset(&pbi->accounting);
-  }
-#endif
-}
-
-static void launch_dec_workers(AV1Decoder *pbi, const uint8_t *data_end,
-                               int num_workers) {
-  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
-
-  for (int worker_idx = 0; worker_idx < num_workers; ++worker_idx) {
-    AVxWorker *const worker = &pbi->tile_workers[worker_idx];
-    DecWorkerData *const thread_data = (DecWorkerData *)worker->data1;
-
-    thread_data->data_end = data_end;
-
-    worker->had_error = 0;
-    if (worker_idx == num_workers - 1) {
-      winterface->execute(worker);
-    } else {
-      winterface->launch(worker);
-    }
-  }
-}
-
-static void sync_dec_workers(AV1Decoder *pbi, int num_workers) {
-  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
-  int corrupted = 0;
-
-  for (int worker_idx = num_workers; worker_idx > 0; --worker_idx) {
-    AVxWorker *const worker = &pbi->tile_workers[worker_idx - 1];
-    aom_merge_corrupted_flag(&corrupted, !winterface->sync(worker));
-  }
-
-  pbi->mb.corrupted = corrupted;
-}
-
-static void decode_mt_init(AV1Decoder *pbi) {
-  AV1_COMMON *const cm = &pbi->common;
-  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
-  int worker_idx;
-
-  // Create workers and thread_data
-  if (pbi->num_workers == 0) {
-    const int num_threads = pbi->max_threads;
-    CHECK_MEM_ERROR(cm, pbi->tile_workers,
-                    aom_malloc(num_threads * sizeof(*pbi->tile_workers)));
-    CHECK_MEM_ERROR(cm, pbi->thread_data,
-                    aom_malloc(num_threads * sizeof(*pbi->thread_data)));
-
-    for (worker_idx = 0; worker_idx < num_threads; ++worker_idx) {
-      AVxWorker *const worker = &pbi->tile_workers[worker_idx];
-      DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
-      ++pbi->num_workers;
-
-      winterface->init(worker);
-      if (worker_idx < num_threads - 1 && !winterface->reset(worker)) {
-        aom_internal_error(&cm->error, AOM_CODEC_ERROR,
-                           "Tile decoder thread creation failed");
-      }
-
-      if (worker_idx < num_threads - 1) {
-        // Allocate thread data.
-        CHECK_MEM_ERROR(cm, thread_data->td,
-                        aom_memalign(32, sizeof(*thread_data->td)));
-        av1_zero(*thread_data->td);
-      } else {
-        // Main thread acts as a worker and uses the thread data in pbi
-        thread_data->td = &pbi->td;
-      }
-      thread_data->error_info.error_code = AOM_CODEC_OK;
-      thread_data->error_info.setjmp = 0;
-    }
-  }
-  const int use_highbd = cm->seq_params.use_highbitdepth ? 1 : 0;
-  const int buf_size = MC_TEMP_BUF_PELS << use_highbd;
-  for (worker_idx = 0; worker_idx < pbi->max_threads - 1; ++worker_idx) {
-    DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
-    if (thread_data->td->mc_buf_size != buf_size) {
-      av1_free_mc_tmp_buf(thread_data->td);
-      allocate_mc_tmp_buf(cm, thread_data->td, buf_size, use_highbd);
-    }
-  }
-}
-
-static void tile_mt_queue(AV1Decoder *pbi, int tile_cols, int tile_rows,
-                          int tile_rows_start, int tile_rows_end,
-                          int tile_cols_start, int tile_cols_end,
-                          int start_tile, int end_tile) {
-  AV1_COMMON *const cm = &pbi->common;
-  if (pbi->tile_mt_info.alloc_tile_cols != tile_cols ||
-      pbi->tile_mt_info.alloc_tile_rows != tile_rows) {
-    av1_dealloc_dec_jobs(&pbi->tile_mt_info);
-    alloc_dec_jobs(&pbi->tile_mt_info, cm, tile_rows, tile_cols);
-  }
-  enqueue_tile_jobs(pbi, cm, tile_rows_start, tile_rows_end, tile_cols_start,
-                    tile_cols_end, start_tile, end_tile);
-  qsort(pbi->tile_mt_info.job_queue, pbi->tile_mt_info.jobs_enqueued,
-        sizeof(pbi->tile_mt_info.job_queue[0]), compare_tile_buffers);
-}
-
-static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data,
-                                      const uint8_t *data_end, int start_tile,
-                                      int end_tile) {
-  AV1_COMMON *const cm = &pbi->common;
-  const int tile_cols = cm->tile_cols;
-  const int tile_rows = cm->tile_rows;
-  const int n_tiles = tile_cols * tile_rows;
-  TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers;
-  const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
-  const int single_row = pbi->dec_tile_row >= 0;
-  const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
-  const int single_col = pbi->dec_tile_col >= 0;
-  int tile_rows_start;
-  int tile_rows_end;
-  int tile_cols_start;
-  int tile_cols_end;
-  int tile_count_tg;
-  int num_workers;
-  const uint8_t *raw_data_end = NULL;
-
-  if (cm->large_scale_tile) {
-    tile_rows_start = single_row ? dec_tile_row : 0;
-    tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows;
-    tile_cols_start = single_col ? dec_tile_col : 0;
-    tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
-  } else {
-    tile_rows_start = 0;
-    tile_rows_end = tile_rows;
-    tile_cols_start = 0;
-    tile_cols_end = tile_cols;
-  }
-  tile_count_tg = end_tile - start_tile + 1;
-  num_workers = AOMMIN(pbi->max_threads, tile_count_tg);
-
-  // No tiles to decode.
-  if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start ||
-      // First tile is larger than end_tile.
-      tile_rows_start * tile_cols + tile_cols_start > end_tile ||
-      // Last tile is smaller than start_tile.
-      (tile_rows_end - 1) * tile_cols + tile_cols_end - 1 < start_tile)
-    return data;
-
-  assert(tile_rows <= MAX_TILE_ROWS);
-  assert(tile_cols <= MAX_TILE_COLS);
-  assert(tile_count_tg > 0);
-  assert(num_workers > 0);
-  assert(start_tile <= end_tile);
-  assert(start_tile >= 0 && end_tile < n_tiles);
-
-  decode_mt_init(pbi);
-
-  // get tile size in tile group
-#if EXT_TILE_DEBUG
-  if (cm->large_scale_tile) assert(pbi->ext_tile_debug == 1);
-  if (cm->large_scale_tile)
-    raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers);
-  else
-#endif  // EXT_TILE_DEBUG
-    get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile);
-
-  if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) {
-    decoder_alloc_tile_data(pbi, n_tiles);
-  }
-
-  for (int row = 0; row < tile_rows; row++) {
-    for (int col = 0; col < tile_cols; col++) {
-      TileDataDec *tile_data = pbi->tile_data + row * cm->tile_cols + col;
-      av1_tile_init(&tile_data->tile_info, cm, row, col);
-    }
-  }
-
-  tile_mt_queue(pbi, tile_cols, tile_rows, tile_rows_start, tile_rows_end,
-                tile_cols_start, tile_cols_end, start_tile, end_tile);
-
-  reset_dec_workers(pbi, tile_worker_hook, num_workers);
-  launch_dec_workers(pbi, data_end, num_workers);
-  sync_dec_workers(pbi, num_workers);
-
-  if (pbi->mb.corrupted)
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Failed to decode tile data");
-
-  if (cm->large_scale_tile) {
-    if (n_tiles == 1) {
-      // Find the end of the single tile buffer
-      return aom_reader_find_end(&pbi->tile_data->bit_reader);
-    }
-    // Return the end of the last tile buffer
-    return raw_data_end;
-  }
-  TileDataDec *const tile_data = pbi->tile_data + end_tile;
-
-  return aom_reader_find_end(&tile_data->bit_reader);
-}
-
-static void dec_alloc_cb_buf(AV1Decoder *pbi) {
-  AV1_COMMON *const cm = &pbi->common;
-  int size = ((cm->mi_rows >> cm->seq_params.mib_size_log2) + 1) *
-             ((cm->mi_cols >> cm->seq_params.mib_size_log2) + 1);
-
-  if (pbi->cb_buffer_alloc_size < size) {
-    av1_dec_free_cb_buf(pbi);
-    CHECK_MEM_ERROR(cm, pbi->cb_buffer_base,
-                    aom_memalign(32, sizeof(*pbi->cb_buffer_base) * size));
-    pbi->cb_buffer_alloc_size = size;
-  }
-}
-
-static void row_mt_frame_init(AV1Decoder *pbi, int tile_rows_start,
-                              int tile_rows_end, int tile_cols_start,
-                              int tile_cols_end, int start_tile, int end_tile,
-                              int max_sb_rows) {
-  AV1_COMMON *const cm = &pbi->common;
-  AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info;
-
-  frame_row_mt_info->tile_rows_start = tile_rows_start;
-  frame_row_mt_info->tile_rows_end = tile_rows_end;
-  frame_row_mt_info->tile_cols_start = tile_cols_start;
-  frame_row_mt_info->tile_cols_end = tile_cols_end;
-  frame_row_mt_info->start_tile = start_tile;
-  frame_row_mt_info->end_tile = end_tile;
-  frame_row_mt_info->mi_rows_to_decode = 0;
-  frame_row_mt_info->mi_rows_parse_done = 0;
-  frame_row_mt_info->mi_rows_decode_started = 0;
-  frame_row_mt_info->row_mt_exit = 0;
-
-  for (int tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) {
-    for (int tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) {
-      if (tile_row * cm->tile_cols + tile_col < start_tile ||
-          tile_row * cm->tile_cols + tile_col > end_tile)
-        continue;
-
-      TileDataDec *const tile_data =
-          pbi->tile_data + tile_row * cm->tile_cols + tile_col;
-      TileInfo tile_info = tile_data->tile_info;
-
-      tile_data->dec_row_mt_sync.mi_rows_parse_done = 0;
-      tile_data->dec_row_mt_sync.mi_rows_decode_started = 0;
-      tile_data->dec_row_mt_sync.num_threads_working = 0;
-      tile_data->dec_row_mt_sync.mi_rows =
-          ALIGN_POWER_OF_TWO(tile_info.mi_row_end - tile_info.mi_row_start,
-                             cm->seq_params.mib_size_log2);
-      tile_data->dec_row_mt_sync.mi_cols =
-          ALIGN_POWER_OF_TWO(tile_info.mi_col_end - tile_info.mi_col_start,
-                             cm->seq_params.mib_size_log2);
-
-      frame_row_mt_info->mi_rows_to_decode +=
-          tile_data->dec_row_mt_sync.mi_rows;
-
-      // Initialize cur_sb_col to -1 for all SB rows.
-      memset(tile_data->dec_row_mt_sync.cur_sb_col, -1,
-             sizeof(*tile_data->dec_row_mt_sync.cur_sb_col) * max_sb_rows);
-    }
-  }
-
-#if CONFIG_MULTITHREAD
-  if (pbi->row_mt_mutex_ == NULL) {
-    CHECK_MEM_ERROR(cm, pbi->row_mt_mutex_,
-                    aom_malloc(sizeof(*(pbi->row_mt_mutex_))));
-    if (pbi->row_mt_mutex_) {
-      pthread_mutex_init(pbi->row_mt_mutex_, NULL);
-    }
-  }
-
-  if (pbi->row_mt_cond_ == NULL) {
-    CHECK_MEM_ERROR(cm, pbi->row_mt_cond_,
-                    aom_malloc(sizeof(*(pbi->row_mt_cond_))));
-    if (pbi->row_mt_cond_) {
-      pthread_cond_init(pbi->row_mt_cond_, NULL);
-    }
-  }
-#endif
-}
-
-static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data,
-                                          const uint8_t *data_end,
-                                          int start_tile, int end_tile) {
-  AV1_COMMON *const cm = &pbi->common;
-  const int tile_cols = cm->tile_cols;
-  const int tile_rows = cm->tile_rows;
-  const int n_tiles = tile_cols * tile_rows;
-  TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers;
-  const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows);
-  const int single_row = pbi->dec_tile_row >= 0;
-  const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols);
-  const int single_col = pbi->dec_tile_col >= 0;
-  int tile_rows_start;
-  int tile_rows_end;
-  int tile_cols_start;
-  int tile_cols_end;
-  int tile_count_tg;
-  int num_workers;
-  const uint8_t *raw_data_end = NULL;
-  int max_sb_rows = 0;
-
-  if (cm->large_scale_tile) {
-    tile_rows_start = single_row ? dec_tile_row : 0;
-    tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows;
-    tile_cols_start = single_col ? dec_tile_col : 0;
-    tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols;
-  } else {
-    tile_rows_start = 0;
-    tile_rows_end = tile_rows;
-    tile_cols_start = 0;
-    tile_cols_end = tile_cols;
-  }
-  tile_count_tg = end_tile - start_tile + 1;
-  num_workers = pbi->max_threads;
-
-  // No tiles to decode.
-  if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start ||
-      // First tile is larger than end_tile.
-      tile_rows_start * tile_cols + tile_cols_start > end_tile ||
-      // Last tile is smaller than start_tile.
-      (tile_rows_end - 1) * tile_cols + tile_cols_end - 1 < start_tile)
-    return data;
-
-  assert(tile_rows <= MAX_TILE_ROWS);
-  assert(tile_cols <= MAX_TILE_COLS);
-  assert(tile_count_tg > 0);
-  assert(num_workers > 0);
-  assert(start_tile <= end_tile);
-  assert(start_tile >= 0 && end_tile < n_tiles);
-
-  (void)tile_count_tg;
-
-  decode_mt_init(pbi);
-
-  // get tile size in tile group
-#if EXT_TILE_DEBUG
-  if (cm->large_scale_tile) assert(pbi->ext_tile_debug == 1);
-  if (cm->large_scale_tile)
-    raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers);
-  else
-#endif  // EXT_TILE_DEBUG
-    get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile);
-
-  if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) {
-    for (int i = 0; i < pbi->allocated_tiles; i++) {
-      TileDataDec *const tile_data = pbi->tile_data + i;
-      av1_dec_row_mt_dealloc(&tile_data->dec_row_mt_sync);
-    }
-    decoder_alloc_tile_data(pbi, n_tiles);
-  }
-
-  for (int row = 0; row < tile_rows; row++) {
-    for (int col = 0; col < tile_cols; col++) {
-      TileDataDec *tile_data = pbi->tile_data + row * cm->tile_cols + col;
-      av1_tile_init(&tile_data->tile_info, cm, row, col);
-
-      max_sb_rows = AOMMAX(max_sb_rows,
-                           av1_get_sb_rows_in_tile(cm, tile_data->tile_info));
-    }
-  }
-
-  if (pbi->allocated_row_mt_sync_rows != max_sb_rows) {
-    for (int i = 0; i < n_tiles; ++i) {
-      TileDataDec *const tile_data = pbi->tile_data + i;
-      av1_dec_row_mt_dealloc(&tile_data->dec_row_mt_sync);
-      dec_row_mt_alloc(&tile_data->dec_row_mt_sync, cm, max_sb_rows);
-    }
-    pbi->allocated_row_mt_sync_rows = max_sb_rows;
-  }
-
-  tile_mt_queue(pbi, tile_cols, tile_rows, tile_rows_start, tile_rows_end,
-                tile_cols_start, tile_cols_end, start_tile, end_tile);
-
-  dec_alloc_cb_buf(pbi);
-
-  row_mt_frame_init(pbi, tile_rows_start, tile_rows_end, tile_cols_start,
-                    tile_cols_end, start_tile, end_tile, max_sb_rows);
-
-  reset_dec_workers(pbi, row_mt_worker_hook, num_workers);
-  launch_dec_workers(pbi, data_end, num_workers);
-  sync_dec_workers(pbi, num_workers);
-
-  if (pbi->mb.corrupted)
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Failed to decode tile data");
-
-  if (cm->large_scale_tile) {
-    if (n_tiles == 1) {
-      // Find the end of the single tile buffer
-      return aom_reader_find_end(&pbi->tile_data->bit_reader);
-    }
-    // Return the end of the last tile buffer
-    return raw_data_end;
-  }
-  TileDataDec *const tile_data = pbi->tile_data + end_tile;
-
-  return aom_reader_find_end(&tile_data->bit_reader);
-}
-
-static void error_handler(void *data) {
-  AV1_COMMON *const cm = (AV1_COMMON *)data;
-  aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Truncated packet");
-}
-
-// Reads the high_bitdepth and twelve_bit fields in color_config() and sets
-// seq_params->bit_depth based on the values of those fields and
-// seq_params->profile. Reports errors by calling rb->error_handler() or
-// aom_internal_error().
-static void read_bitdepth(struct aom_read_bit_buffer *rb,
-                          SequenceHeader *seq_params,
-                          struct aom_internal_error_info *error_info) {
-  const int high_bitdepth = aom_rb_read_bit(rb);
-  if (seq_params->profile == PROFILE_2 && high_bitdepth) {
-    const int twelve_bit = aom_rb_read_bit(rb);
-    seq_params->bit_depth = twelve_bit ? AOM_BITS_12 : AOM_BITS_10;
-  } else if (seq_params->profile <= PROFILE_2) {
-    seq_params->bit_depth = high_bitdepth ? AOM_BITS_10 : AOM_BITS_8;
-  } else {
-    aom_internal_error(error_info, AOM_CODEC_UNSUP_BITSTREAM,
-                       "Unsupported profile/bit-depth combination");
-  }
-}
-
-void av1_read_film_grain_params(AV1_COMMON *cm,
-                                struct aom_read_bit_buffer *rb) {
-  aom_film_grain_t *pars = &cm->film_grain_params;
-  const SequenceHeader *const seq_params = &cm->seq_params;
-
-  pars->apply_grain = aom_rb_read_bit(rb);
-  if (!pars->apply_grain) {
-    memset(pars, 0, sizeof(*pars));
-    return;
-  }
-
-  pars->random_seed = aom_rb_read_literal(rb, 16);
-  if (cm->frame_type == INTER_FRAME)
-    pars->update_parameters = aom_rb_read_bit(rb);
-  else
-    pars->update_parameters = 1;
-
-  pars->bit_depth = seq_params->bit_depth;
-
-  if (!pars->update_parameters) {
-    // inherit parameters from a previous reference frame
-    RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
-    int film_grain_params_ref_idx = aom_rb_read_literal(rb, 3);
-    int buf_idx = cm->ref_frame_map[film_grain_params_ref_idx];
-    if (buf_idx == INVALID_IDX) {
-      aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                         "Invalid Film grain reference idx");
-    }
-    if (!frame_bufs[buf_idx].film_grain_params_present) {
-      aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                         "Film grain reference parameters not available");
-    }
-    uint16_t random_seed = pars->random_seed;
-    *pars = frame_bufs[buf_idx].film_grain_params;  // inherit paramaters
-    pars->random_seed = random_seed;                // with new random seed
-    return;
-  }
-
-  // Scaling functions parameters
-  pars->num_y_points = aom_rb_read_literal(rb, 4);  // max 14
-  if (pars->num_y_points > 14)
-    aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                       "Number of points for film grain luma scaling function "
-                       "exceeds the maximum value.");
-  for (int i = 0; i < pars->num_y_points; i++) {
-    pars->scaling_points_y[i][0] = aom_rb_read_literal(rb, 8);
-    if (i && pars->scaling_points_y[i - 1][0] >= pars->scaling_points_y[i][0])
-      aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                         "First coordinate of the scaling function points "
-                         "shall be increasing.");
-    pars->scaling_points_y[i][1] = aom_rb_read_literal(rb, 8);
-  }
-
-  if (!seq_params->monochrome)
-    pars->chroma_scaling_from_luma = aom_rb_read_bit(rb);
-  else
-    pars->chroma_scaling_from_luma = 0;
-
-  if (seq_params->monochrome || pars->chroma_scaling_from_luma ||
-      ((seq_params->subsampling_x == 1) && (seq_params->subsampling_y == 1) &&
-       (pars->num_y_points == 0))) {
-    pars->num_cb_points = 0;
-    pars->num_cr_points = 0;
-  } else {
-    pars->num_cb_points = aom_rb_read_literal(rb, 4);  // max 10
-    if (pars->num_cb_points > 10)
-      aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                         "Number of points for film grain cb scaling function "
-                         "exceeds the maximum value.");
-    for (int i = 0; i < pars->num_cb_points; i++) {
-      pars->scaling_points_cb[i][0] = aom_rb_read_literal(rb, 8);
-      if (i &&
-          pars->scaling_points_cb[i - 1][0] >= pars->scaling_points_cb[i][0])
-        aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                           "First coordinate of the scaling function points "
-                           "shall be increasing.");
-      pars->scaling_points_cb[i][1] = aom_rb_read_literal(rb, 8);
-    }
-
-    pars->num_cr_points = aom_rb_read_literal(rb, 4);  // max 10
-    if (pars->num_cr_points > 10)
-      aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                         "Number of points for film grain cr scaling function "
-                         "exceeds the maximum value.");
-    for (int i = 0; i < pars->num_cr_points; i++) {
-      pars->scaling_points_cr[i][0] = aom_rb_read_literal(rb, 8);
-      if (i &&
-          pars->scaling_points_cr[i - 1][0] >= pars->scaling_points_cr[i][0])
-        aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                           "First coordinate of the scaling function points "
-                           "shall be increasing.");
-      pars->scaling_points_cr[i][1] = aom_rb_read_literal(rb, 8);
-    }
-
-    if ((seq_params->subsampling_x == 1) && (seq_params->subsampling_y == 1) &&
-        (((pars->num_cb_points == 0) && (pars->num_cr_points != 0)) ||
-         ((pars->num_cb_points != 0) && (pars->num_cr_points == 0))))
-      aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                         "In YCbCr 4:2:0, film grain shall be applied "
-                         "to both chroma components or neither.");
-  }
-
-  pars->scaling_shift = aom_rb_read_literal(rb, 2) + 8;  // 8 + value
-
-  // AR coefficients
-  // Only sent if the corresponsing scaling function has
-  // more than 0 points
-
-  pars->ar_coeff_lag = aom_rb_read_literal(rb, 2);
-
-  int num_pos_luma = 2 * pars->ar_coeff_lag * (pars->ar_coeff_lag + 1);
-  int num_pos_chroma = num_pos_luma;
-  if (pars->num_y_points > 0) ++num_pos_chroma;
-
-  if (pars->num_y_points)
-    for (int i = 0; i < num_pos_luma; i++)
-      pars->ar_coeffs_y[i] = aom_rb_read_literal(rb, 8) - 128;
-
-  if (pars->num_cb_points || pars->chroma_scaling_from_luma)
-    for (int i = 0; i < num_pos_chroma; i++)
-      pars->ar_coeffs_cb[i] = aom_rb_read_literal(rb, 8) - 128;
-
-  if (pars->num_cr_points || pars->chroma_scaling_from_luma)
-    for (int i = 0; i < num_pos_chroma; i++)
-      pars->ar_coeffs_cr[i] = aom_rb_read_literal(rb, 8) - 128;
-
-  pars->ar_coeff_shift = aom_rb_read_literal(rb, 2) + 6;  // 6 + value
-
-  pars->grain_scale_shift = aom_rb_read_literal(rb, 2);
-
-  if (pars->num_cb_points) {
-    pars->cb_mult = aom_rb_read_literal(rb, 8);
-    pars->cb_luma_mult = aom_rb_read_literal(rb, 8);
-    pars->cb_offset = aom_rb_read_literal(rb, 9);
-  }
-
-  if (pars->num_cr_points) {
-    pars->cr_mult = aom_rb_read_literal(rb, 8);
-    pars->cr_luma_mult = aom_rb_read_literal(rb, 8);
-    pars->cr_offset = aom_rb_read_literal(rb, 9);
-  }
-
-  pars->overlap_flag = aom_rb_read_bit(rb);
-
-  pars->clip_to_restricted_range = aom_rb_read_bit(rb);
-}
-
-static void read_film_grain(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-  if (cm->seq_params.film_grain_params_present &&
-      (cm->show_frame || cm->showable_frame)) {
-    av1_read_film_grain_params(cm, rb);
-  } else {
-    memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params));
-  }
-  cm->film_grain_params.bit_depth = cm->seq_params.bit_depth;
-  memcpy(&cm->cur_frame->film_grain_params, &cm->film_grain_params,
-         sizeof(aom_film_grain_t));
-}
-
-void av1_read_color_config(struct aom_read_bit_buffer *rb,
-                           int allow_lowbitdepth, SequenceHeader *seq_params,
-                           struct aom_internal_error_info *error_info) {
-  read_bitdepth(rb, seq_params, error_info);
-
-  seq_params->use_highbitdepth =
-      seq_params->bit_depth > AOM_BITS_8 || !allow_lowbitdepth;
-  // monochrome bit (not needed for PROFILE_1)
-  const int is_monochrome =
-      seq_params->profile != PROFILE_1 ? aom_rb_read_bit(rb) : 0;
-  seq_params->monochrome = is_monochrome;
-  int color_description_present_flag = aom_rb_read_bit(rb);
-  if (color_description_present_flag) {
-    seq_params->color_primaries = aom_rb_read_literal(rb, 8);
-    seq_params->transfer_characteristics = aom_rb_read_literal(rb, 8);
-    seq_params->matrix_coefficients = aom_rb_read_literal(rb, 8);
-  } else {
-    seq_params->color_primaries = AOM_CICP_CP_UNSPECIFIED;
-    seq_params->transfer_characteristics = AOM_CICP_TC_UNSPECIFIED;
-    seq_params->matrix_coefficients = AOM_CICP_MC_UNSPECIFIED;
-  }
-  if (is_monochrome) {
-    // [16,235] (including xvycc) vs [0,255] range
-    seq_params->color_range = aom_rb_read_bit(rb);
-    seq_params->subsampling_y = seq_params->subsampling_x = 1;
-    seq_params->chroma_sample_position = AOM_CSP_UNKNOWN;
-    seq_params->separate_uv_delta_q = 0;
-    return;
-  }
-  if (seq_params->color_primaries == AOM_CICP_CP_BT_709 &&
-      seq_params->transfer_characteristics == AOM_CICP_TC_SRGB &&
-      seq_params->matrix_coefficients == AOM_CICP_MC_IDENTITY) {
-    // It would be good to remove this dependency.
-    seq_params->subsampling_y = seq_params->subsampling_x = 0;
-    seq_params->color_range = 1;  // assume full color-range
-    if (!(seq_params->profile == PROFILE_1 ||
-          (seq_params->profile == PROFILE_2 &&
-           seq_params->bit_depth == AOM_BITS_12))) {
-      aom_internal_error(
-          error_info, AOM_CODEC_UNSUP_BITSTREAM,
-          "sRGB colorspace not compatible with specified profile");
-    }
-  } else {
-    // [16,235] (including xvycc) vs [0,255] range
-    seq_params->color_range = aom_rb_read_bit(rb);
-    if (seq_params->profile == PROFILE_0) {
-      // 420 only
-      seq_params->subsampling_x = seq_params->subsampling_y = 1;
-    } else if (seq_params->profile == PROFILE_1) {
-      // 444 only
-      seq_params->subsampling_x = seq_params->subsampling_y = 0;
-    } else {
-      assert(seq_params->profile == PROFILE_2);
-      if (seq_params->bit_depth == AOM_BITS_12) {
-        seq_params->subsampling_x = aom_rb_read_bit(rb);
-        if (seq_params->subsampling_x)
-          seq_params->subsampling_y = aom_rb_read_bit(rb);  // 422 or 420
-        else
-          seq_params->subsampling_y = 0;  // 444
-      } else {
-        // 422
-        seq_params->subsampling_x = 1;
-        seq_params->subsampling_y = 0;
-      }
-    }
-    if (seq_params->matrix_coefficients == AOM_CICP_MC_IDENTITY &&
-        (seq_params->subsampling_x || seq_params->subsampling_y)) {
-      aom_internal_error(
-          error_info, AOM_CODEC_UNSUP_BITSTREAM,
-          "Identity CICP Matrix incompatible with non 4:4:4 color sampling");
-    }
-    if (seq_params->subsampling_x && seq_params->subsampling_y) {
-      seq_params->chroma_sample_position = aom_rb_read_literal(rb, 2);
-    }
-  }
-  seq_params->separate_uv_delta_q = aom_rb_read_bit(rb);
-}
-
-void av1_read_timing_info_header(AV1_COMMON *cm,
-                                 struct aom_read_bit_buffer *rb) {
-  cm->timing_info.num_units_in_display_tick = aom_rb_read_unsigned_literal(
-      rb, 32);  // Number of units in a display tick
-  cm->timing_info.time_scale =
-      aom_rb_read_unsigned_literal(rb, 32);  // Time scale
-  if (cm->timing_info.num_units_in_display_tick == 0 ||
-      cm->timing_info.time_scale == 0) {
-    aom_internal_error(
-        &cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-        "num_units_in_display_tick and time_scale must be greater than 0.");
-  }
-  cm->timing_info.equal_picture_interval =
-      aom_rb_read_bit(rb);  // Equal picture interval bit
-  if (cm->timing_info.equal_picture_interval) {
-    cm->timing_info.num_ticks_per_picture =
-        aom_rb_read_uvlc(rb) + 1;  // ticks per picture
-    if (cm->timing_info.num_ticks_per_picture == 0) {
-      aom_internal_error(
-          &cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-          "num_ticks_per_picture_minus_1 cannot be (1 << 32) − 1.");
-    }
-  }
-}
-
-void av1_read_decoder_model_info(AV1_COMMON *cm,
-                                 struct aom_read_bit_buffer *rb) {
-  cm->buffer_model.encoder_decoder_buffer_delay_length =
-      aom_rb_read_literal(rb, 5) + 1;
-  cm->buffer_model.num_units_in_decoding_tick = aom_rb_read_unsigned_literal(
-      rb, 32);  // Number of units in a decoding tick
-  cm->buffer_model.buffer_removal_time_length = aom_rb_read_literal(rb, 5) + 1;
-  cm->buffer_model.frame_presentation_time_length =
-      aom_rb_read_literal(rb, 5) + 1;
-}
-
-void av1_read_op_parameters_info(AV1_COMMON *const cm,
-                                 struct aom_read_bit_buffer *rb, int op_num) {
-  // The cm->op_params array has MAX_NUM_OPERATING_POINTS + 1 elements.
-  if (op_num > MAX_NUM_OPERATING_POINTS) {
-    aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                       "AV1 does not support %d decoder model operating points",
-                       op_num + 1);
-  }
-
-  cm->op_params[op_num].decoder_buffer_delay = aom_rb_read_unsigned_literal(
-      rb, cm->buffer_model.encoder_decoder_buffer_delay_length);
-
-  cm->op_params[op_num].encoder_buffer_delay = aom_rb_read_unsigned_literal(
-      rb, cm->buffer_model.encoder_decoder_buffer_delay_length);
-
-  cm->op_params[op_num].low_delay_mode_flag = aom_rb_read_bit(rb);
-}
-
-static void av1_read_temporal_point_info(AV1_COMMON *const cm,
-                                         struct aom_read_bit_buffer *rb) {
-  cm->frame_presentation_time = aom_rb_read_unsigned_literal(
-      rb, cm->buffer_model.frame_presentation_time_length);
-}
-
-void av1_read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb,
-                              SequenceHeader *seq_params) {
-  const int num_bits_width = aom_rb_read_literal(rb, 4) + 1;
-  const int num_bits_height = aom_rb_read_literal(rb, 4) + 1;
-  const int max_frame_width = aom_rb_read_literal(rb, num_bits_width) + 1;
-  const int max_frame_height = aom_rb_read_literal(rb, num_bits_height) + 1;
-
-  seq_params->num_bits_width = num_bits_width;
-  seq_params->num_bits_height = num_bits_height;
-  seq_params->max_frame_width = max_frame_width;
-  seq_params->max_frame_height = max_frame_height;
-
-  if (seq_params->reduced_still_picture_hdr) {
-    seq_params->frame_id_numbers_present_flag = 0;
-  } else {
-    seq_params->frame_id_numbers_present_flag = aom_rb_read_bit(rb);
-  }
-  if (seq_params->frame_id_numbers_present_flag) {
-    // We must always have delta_frame_id_length < frame_id_length,
-    // in order for a frame to be referenced with a unique delta.
-    // Avoid wasting bits by using a coding that enforces this restriction.
-    seq_params->delta_frame_id_length = aom_rb_read_literal(rb, 4) + 2;
-    seq_params->frame_id_length =
-        aom_rb_read_literal(rb, 3) + seq_params->delta_frame_id_length + 1;
-    if (seq_params->frame_id_length > 16)
-      aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                         "Invalid frame_id_length");
-  }
-
-  setup_sb_size(seq_params, rb);
-
-  seq_params->enable_filter_intra = aom_rb_read_bit(rb);
-  seq_params->enable_intra_edge_filter = aom_rb_read_bit(rb);
-
-  if (seq_params->reduced_still_picture_hdr) {
-    seq_params->enable_interintra_compound = 0;
-    seq_params->enable_masked_compound = 0;
-    seq_params->enable_warped_motion = 0;
-    seq_params->enable_dual_filter = 0;
-    seq_params->enable_order_hint = 0;
-    seq_params->enable_jnt_comp = 0;
-    seq_params->enable_ref_frame_mvs = 0;
-    seq_params->force_screen_content_tools = 2;  // SELECT_SCREEN_CONTENT_TOOLS
-    seq_params->force_integer_mv = 2;            // SELECT_INTEGER_MV
-    seq_params->order_hint_bits_minus_1 = -1;
-  } else {
-    seq_params->enable_interintra_compound = aom_rb_read_bit(rb);
-    seq_params->enable_masked_compound = aom_rb_read_bit(rb);
-    seq_params->enable_warped_motion = aom_rb_read_bit(rb);
-    seq_params->enable_dual_filter = aom_rb_read_bit(rb);
-
-    seq_params->enable_order_hint = aom_rb_read_bit(rb);
-    seq_params->enable_jnt_comp =
-        seq_params->enable_order_hint ? aom_rb_read_bit(rb) : 0;
-    seq_params->enable_ref_frame_mvs =
-        seq_params->enable_order_hint ? aom_rb_read_bit(rb) : 0;
-
-    if (aom_rb_read_bit(rb)) {
-      seq_params->force_screen_content_tools =
-          2;  // SELECT_SCREEN_CONTENT_TOOLS
-    } else {
-      seq_params->force_screen_content_tools = aom_rb_read_bit(rb);
-    }
-
-    if (seq_params->force_screen_content_tools > 0) {
-      if (aom_rb_read_bit(rb)) {
-        seq_params->force_integer_mv = 2;  // SELECT_INTEGER_MV
-      } else {
-        seq_params->force_integer_mv = aom_rb_read_bit(rb);
-      }
-    } else {
-      seq_params->force_integer_mv = 2;  // SELECT_INTEGER_MV
-    }
-    seq_params->order_hint_bits_minus_1 =
-        seq_params->enable_order_hint ? aom_rb_read_literal(rb, 3) : -1;
-  }
-
-  seq_params->enable_superres = aom_rb_read_bit(rb);
-  seq_params->enable_cdef = aom_rb_read_bit(rb);
-  seq_params->enable_restoration = aom_rb_read_bit(rb);
-}
-
-static int read_global_motion_params(WarpedMotionParams *params,
-                                     const WarpedMotionParams *ref_params,
-                                     struct aom_read_bit_buffer *rb,
-                                     int allow_hp) {
-  TransformationType type = aom_rb_read_bit(rb);
-  if (type != IDENTITY) {
-    if (aom_rb_read_bit(rb))
-      type = ROTZOOM;
-    else
-      type = aom_rb_read_bit(rb) ? TRANSLATION : AFFINE;
-  }
-
-  *params = default_warp_params;
-  params->wmtype = type;
-
-  if (type >= ROTZOOM) {
-    params->wmmat[2] = aom_rb_read_signed_primitive_refsubexpfin(
-                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
-                           (ref_params->wmmat[2] >> GM_ALPHA_PREC_DIFF) -
-                               (1 << GM_ALPHA_PREC_BITS)) *
-                           GM_ALPHA_DECODE_FACTOR +
-                       (1 << WARPEDMODEL_PREC_BITS);
-    params->wmmat[3] = aom_rb_read_signed_primitive_refsubexpfin(
-                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
-                           (ref_params->wmmat[3] >> GM_ALPHA_PREC_DIFF)) *
-                       GM_ALPHA_DECODE_FACTOR;
-  }
-
-  if (type >= AFFINE) {
-    params->wmmat[4] = aom_rb_read_signed_primitive_refsubexpfin(
-                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
-                           (ref_params->wmmat[4] >> GM_ALPHA_PREC_DIFF)) *
-                       GM_ALPHA_DECODE_FACTOR;
-    params->wmmat[5] = aom_rb_read_signed_primitive_refsubexpfin(
-                           rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K,
-                           (ref_params->wmmat[5] >> GM_ALPHA_PREC_DIFF) -
-                               (1 << GM_ALPHA_PREC_BITS)) *
-                           GM_ALPHA_DECODE_FACTOR +
-                       (1 << WARPEDMODEL_PREC_BITS);
-  } else {
-    params->wmmat[4] = -params->wmmat[3];
-    params->wmmat[5] = params->wmmat[2];
-  }
-
-  if (type >= TRANSLATION) {
-    const int trans_bits = (type == TRANSLATION)
-                               ? GM_ABS_TRANS_ONLY_BITS - !allow_hp
-                               : GM_ABS_TRANS_BITS;
-    const int trans_dec_factor =
-        (type == TRANSLATION) ? GM_TRANS_ONLY_DECODE_FACTOR * (1 << !allow_hp)
-                              : GM_TRANS_DECODE_FACTOR;
-    const int trans_prec_diff = (type == TRANSLATION)
-                                    ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp
-                                    : GM_TRANS_PREC_DIFF;
-    params->wmmat[0] = aom_rb_read_signed_primitive_refsubexpfin(
-                           rb, (1 << trans_bits) + 1, SUBEXPFIN_K,
-                           (ref_params->wmmat[0] >> trans_prec_diff)) *
-                       trans_dec_factor;
-    params->wmmat[1] = aom_rb_read_signed_primitive_refsubexpfin(
-                           rb, (1 << trans_bits) + 1, SUBEXPFIN_K,
-                           (ref_params->wmmat[1] >> trans_prec_diff)) *
-                       trans_dec_factor;
-  }
-
-  if (params->wmtype <= AFFINE) {
-    int good_shear_params = get_shear_params(params);
-    if (!good_shear_params) return 0;
-  }
-
-  return 1;
-}
-
-static void read_global_motion(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
-  for (int frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) {
-    const WarpedMotionParams *ref_params =
-        cm->prev_frame ? &cm->prev_frame->global_motion[frame]
-                       : &default_warp_params;
-    int good_params = read_global_motion_params(
-        &cm->global_motion[frame], ref_params, rb, cm->allow_high_precision_mv);
-    if (!good_params) {
-#if WARPED_MOTION_DEBUG
-      printf("Warning: unexpected global motion shear params from aomenc\n");
-#endif
-      cm->global_motion[frame].invalid = 1;
-    }
-
-    // TODO(sarahparker, debargha): The logic in the commented out code below
-    // does not work currently and causes mismatches when resize is on. Fix it
-    // before turning the optimization back on.
-    /*
-    YV12_BUFFER_CONFIG *ref_buf = get_ref_frame(cm, frame);
-    if (cm->width == ref_buf->y_crop_width &&
-        cm->height == ref_buf->y_crop_height) {
-      read_global_motion_params(&cm->global_motion[frame],
-                                &cm->prev_frame->global_motion[frame], rb,
-                                cm->allow_high_precision_mv);
-    } else {
-      cm->global_motion[frame] = default_warp_params;
-    }
-    */
-    /*
-    printf("Dec Ref %d [%d/%d]: %d %d %d %d\n",
-           frame, cm->current_video_frame, cm->show_frame,
-           cm->global_motion[frame].wmmat[0],
-           cm->global_motion[frame].wmmat[1],
-           cm->global_motion[frame].wmmat[2],
-           cm->global_motion[frame].wmmat[3]);
-           */
-  }
-  memcpy(cm->cur_frame->global_motion, cm->global_motion,
-         REF_FRAMES * sizeof(WarpedMotionParams));
-}
-
-static void show_existing_frame_reset(AV1Decoder *const pbi,
-                                      int existing_frame_idx) {
-  AV1_COMMON *const cm = &pbi->common;
-  BufferPool *const pool = cm->buffer_pool;
-  RefCntBuffer *const frame_bufs = pool->frame_bufs;
-
-  assert(cm->show_existing_frame);
-
-  cm->frame_type = KEY_FRAME;
-
-  pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1;
-
-  for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    cm->frame_refs[i].idx = INVALID_IDX;
-    cm->frame_refs[i].buf = NULL;
-  }
-
-  if (pbi->need_resync) {
-    memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
-    pbi->need_resync = 0;
-  }
-
-  cm->cur_frame->intra_only = 1;
-
-  if (cm->seq_params.frame_id_numbers_present_flag) {
-    /* If bitmask is set, update reference frame id values and
-       mark frames as valid for reference.
-       Note that the displayed frame be valid for referencing
-       in order to have been selected.
-    */
-    int refresh_frame_flags = pbi->refresh_frame_flags;
-    int display_frame_id = cm->ref_frame_id[existing_frame_idx];
-    for (int i = 0; i < REF_FRAMES; i++) {
-      if ((refresh_frame_flags >> i) & 1) {
-        cm->ref_frame_id[i] = display_frame_id;
-        cm->valid_for_referencing[i] = 1;
-      }
-    }
-  }
-
-  cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
-
-  // Generate next_ref_frame_map.
-  lock_buffer_pool(pool);
-  int ref_index = 0;
-  for (int mask = pbi->refresh_frame_flags; mask; mask >>= 1) {
-    if (mask & 1) {
-      cm->next_ref_frame_map[ref_index] = cm->new_fb_idx;
-      ++frame_bufs[cm->new_fb_idx].ref_count;
-    } else {
-      cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index];
-    }
-    // Current thread holds the reference frame.
-    if (cm->ref_frame_map[ref_index] >= 0)
-      ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count;
-    ++ref_index;
-  }
-
-  for (; ref_index < REF_FRAMES; ++ref_index) {
-    cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index];
-
-    // Current thread holds the reference frame.
-    if (cm->ref_frame_map[ref_index] >= 0)
-      ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count;
-  }
-  unlock_buffer_pool(pool);
-  pbi->hold_ref_buf = 1;
-
-  // Reload the adapted CDFs from when we originally coded this keyframe
-  *cm->fc = cm->frame_contexts[existing_frame_idx];
-}
-
-static INLINE void reset_frame_buffers(AV1_COMMON *cm) {
-  RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
-  int i;
-
-  memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
-  memset(&cm->next_ref_frame_map, -1, sizeof(cm->next_ref_frame_map));
-
-  lock_buffer_pool(cm->buffer_pool);
-  for (i = 0; i < FRAME_BUFFERS; ++i) {
-    if (i != cm->new_fb_idx) {
-      frame_bufs[i].ref_count = 0;
-      cm->buffer_pool->release_fb_cb(cm->buffer_pool->cb_priv,
-                                     &frame_bufs[i].raw_frame_buffer);
-    } else {
-      assert(frame_bufs[i].ref_count == 1);
-    }
-    frame_bufs[i].cur_frame_offset = 0;
-    av1_zero(frame_bufs[i].ref_frame_offset);
-  }
-  av1_zero_unused_internal_frame_buffers(&cm->buffer_pool->int_frame_buffers);
-  unlock_buffer_pool(cm->buffer_pool);
-}
-
-// On success, returns 0. On failure, calls aom_internal_error and does not
-// return.
-static int read_uncompressed_header(AV1Decoder *pbi,
-                                    struct aom_read_bit_buffer *rb) {
-  AV1_COMMON *const cm = &pbi->common;
-  const SequenceHeader *const seq_params = &cm->seq_params;
-  MACROBLOCKD *const xd = &pbi->mb;
-  BufferPool *const pool = cm->buffer_pool;
-  RefCntBuffer *const frame_bufs = pool->frame_bufs;
-
-  if (!pbi->sequence_header_ready) {
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "No sequence header");
-  }
-
-  cm->last_frame_type = cm->frame_type;
-  cm->last_intra_only = cm->intra_only;
-
-  // NOTE: By default all coded frames to be used as a reference
-  cm->is_reference_frame = 1;
-
-  if (seq_params->reduced_still_picture_hdr) {
-    cm->show_existing_frame = 0;
-    cm->show_frame = 1;
-    cm->frame_type = KEY_FRAME;
-    cm->error_resilient_mode = 1;
-  } else {
-    cm->show_existing_frame = aom_rb_read_bit(rb);
-    cm->reset_decoder_state = 0;
-
-    if (cm->show_existing_frame) {
-      if (pbi->sequence_header_changed) {
-        aom_internal_error(
-            &cm->error, AOM_CODEC_CORRUPT_FRAME,
-            "New sequence header starts with a show_existing_frame.");
-      }
-      // Show an existing frame directly.
-      const int existing_frame_idx = aom_rb_read_literal(rb, 3);
-      const int frame_to_show = cm->ref_frame_map[existing_frame_idx];
-      if (seq_params->decoder_model_info_present_flag &&
-          cm->timing_info.equal_picture_interval == 0) {
-        av1_read_temporal_point_info(cm, rb);
-      }
-      if (seq_params->frame_id_numbers_present_flag) {
-        int frame_id_length = seq_params->frame_id_length;
-        int display_frame_id = aom_rb_read_literal(rb, frame_id_length);
-        /* Compare display_frame_id with ref_frame_id and check valid for
-         * referencing */
-        if (display_frame_id != cm->ref_frame_id[existing_frame_idx] ||
-            cm->valid_for_referencing[existing_frame_idx] == 0)
-          aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                             "Reference buffer frame ID mismatch");
-      }
-      lock_buffer_pool(pool);
-      if (frame_to_show < 0 || frame_bufs[frame_to_show].ref_count < 1) {
-        unlock_buffer_pool(pool);
-        aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                           "Buffer %d does not contain a decoded frame",
-                           frame_to_show);
-      }
-      ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show);
-      cm->reset_decoder_state =
-          frame_bufs[frame_to_show].frame_type == KEY_FRAME;
-      unlock_buffer_pool(pool);
-
-      cm->lf.filter_level[0] = 0;
-      cm->lf.filter_level[1] = 0;
-      cm->show_frame = 1;
-
-      if (!frame_bufs[frame_to_show].showable_frame) {
-        aom_merge_corrupted_flag(&xd->corrupted, 1);
-      }
-      if (cm->reset_decoder_state) frame_bufs[frame_to_show].showable_frame = 0;
-
-      cm->film_grain_params = frame_bufs[frame_to_show].film_grain_params;
-
-      if (cm->reset_decoder_state) {
-        show_existing_frame_reset(pbi, existing_frame_idx);
-      } else {
-        pbi->refresh_frame_flags = 0;
-      }
-
-      return 0;
-    }
-
-    cm->frame_type = (FRAME_TYPE)aom_rb_read_literal(rb, 2);  // 2 bits
-    if (pbi->sequence_header_changed) {
-      if (pbi->common.frame_type == KEY_FRAME) {
-        // This is the start of a new coded video sequence.
-        pbi->sequence_header_changed = 0;
-        pbi->decoding_first_frame = 1;
-        reset_frame_buffers(&pbi->common);
-      } else {
-        aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                           "Sequence header has changed without a keyframe.");
-      }
-    }
-
-    cm->show_frame = aom_rb_read_bit(rb);
-    if (seq_params->still_picture &&
-        (cm->frame_type != KEY_FRAME || !cm->show_frame)) {
-      aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                         "Still pictures must be coded as shown keyframes");
-    }
-    cm->showable_frame = cm->frame_type != KEY_FRAME;
-    if (cm->show_frame) {
-      if (seq_params->decoder_model_info_present_flag &&
-          cm->timing_info.equal_picture_interval == 0)
-        av1_read_temporal_point_info(cm, rb);
-    } else {
-      // See if this frame can be used as show_existing_frame in future
-      cm->showable_frame = aom_rb_read_bit(rb);
-    }
-    cm->cur_frame->showable_frame = cm->showable_frame;
-    cm->intra_only = cm->frame_type == INTRA_ONLY_FRAME;
-    cm->error_resilient_mode =
-        frame_is_sframe(cm) || (cm->frame_type == KEY_FRAME && cm->show_frame)
-            ? 1
-            : aom_rb_read_bit(rb);
-  }
-
-  cm->disable_cdf_update = aom_rb_read_bit(rb);
-  if (seq_params->force_screen_content_tools == 2) {
-    cm->allow_screen_content_tools = aom_rb_read_bit(rb);
-  } else {
-    cm->allow_screen_content_tools = seq_params->force_screen_content_tools;
-  }
-
-  if (cm->allow_screen_content_tools) {
-    if (seq_params->force_integer_mv == 2) {
-      cm->cur_frame_force_integer_mv = aom_rb_read_bit(rb);
-    } else {
-      cm->cur_frame_force_integer_mv = seq_params->force_integer_mv;
-    }
-  } else {
-    cm->cur_frame_force_integer_mv = 0;
-  }
-
-  cm->frame_refs_short_signaling = 0;
-  int frame_size_override_flag = 0;
-  cm->allow_intrabc = 0;
-  cm->primary_ref_frame = PRIMARY_REF_NONE;
-
-  if (!seq_params->reduced_still_picture_hdr) {
-    if (seq_params->frame_id_numbers_present_flag) {
-      int frame_id_length = seq_params->frame_id_length;
-      int diff_len = seq_params->delta_frame_id_length;
-      int prev_frame_id = 0;
-      int have_prev_frame_id = !pbi->decoding_first_frame &&
-                               !(cm->frame_type == KEY_FRAME && cm->show_frame);
-      if (have_prev_frame_id) {
-        prev_frame_id = cm->current_frame_id;
-      }
-      cm->current_frame_id = aom_rb_read_literal(rb, frame_id_length);
-
-      if (have_prev_frame_id) {
-        int diff_frame_id;
-        if (cm->current_frame_id > prev_frame_id) {
-          diff_frame_id = cm->current_frame_id - prev_frame_id;
-        } else {
-          diff_frame_id =
-              (1 << frame_id_length) + cm->current_frame_id - prev_frame_id;
-        }
-        /* Check current_frame_id for conformance */
-        if (prev_frame_id == cm->current_frame_id ||
-            diff_frame_id >= (1 << (frame_id_length - 1))) {
-          aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                             "Invalid value of current_frame_id");
-        }
-      }
-      /* Check if some frames need to be marked as not valid for referencing */
-      for (int i = 0; i < REF_FRAMES; i++) {
-        if (cm->frame_type == KEY_FRAME && cm->show_frame) {
-          cm->valid_for_referencing[i] = 0;
-        } else if (cm->current_frame_id - (1 << diff_len) > 0) {
-          if (cm->ref_frame_id[i] > cm->current_frame_id ||
-              cm->ref_frame_id[i] < cm->current_frame_id - (1 << diff_len))
-            cm->valid_for_referencing[i] = 0;
-        } else {
-          if (cm->ref_frame_id[i] > cm->current_frame_id &&
-              cm->ref_frame_id[i] < (1 << frame_id_length) +
-                                        cm->current_frame_id - (1 << diff_len))
-            cm->valid_for_referencing[i] = 0;
-        }
-      }
-    }
-
-    frame_size_override_flag = frame_is_sframe(cm) ? 1 : aom_rb_read_bit(rb);
-
-    cm->frame_offset =
-        aom_rb_read_literal(rb, seq_params->order_hint_bits_minus_1 + 1);
-    cm->current_video_frame = cm->frame_offset;
-
-    if (!cm->error_resilient_mode && !frame_is_intra_only(cm)) {
-      cm->primary_ref_frame = aom_rb_read_literal(rb, PRIMARY_REF_BITS);
-    }
-  }
-
-  if (seq_params->decoder_model_info_present_flag) {
-    cm->buffer_removal_time_present = aom_rb_read_bit(rb);
-    if (cm->buffer_removal_time_present) {
-      for (int op_num = 0;
-           op_num < seq_params->operating_points_cnt_minus_1 + 1; op_num++) {
-        if (cm->op_params[op_num].decoder_model_param_present_flag) {
-          if ((((seq_params->operating_point_idc[op_num] >>
-                 cm->temporal_layer_id) &
-                0x1) &&
-               ((seq_params->operating_point_idc[op_num] >>
-                 (cm->spatial_layer_id + 8)) &
-                0x1)) ||
-              seq_params->operating_point_idc[op_num] == 0) {
-            cm->op_frame_timing[op_num].buffer_removal_time =
-                aom_rb_read_unsigned_literal(
-                    rb, cm->buffer_model.buffer_removal_time_length);
-          } else {
-            cm->op_frame_timing[op_num].buffer_removal_time = 0;
-          }
-        } else {
-          cm->op_frame_timing[op_num].buffer_removal_time = 0;
-        }
-      }
-    }
-  }
-  if (cm->frame_type == KEY_FRAME) {
-    if (!cm->show_frame)  // unshown keyframe (forward keyframe)
-      pbi->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES);
-    else  // shown keyframe
-      pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1;
-
-    for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-      cm->frame_refs[i].idx = INVALID_IDX;
-      cm->frame_refs[i].buf = NULL;
-    }
-    if (pbi->need_resync) {
-      memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
-      pbi->need_resync = 0;
-    }
-  } else {
-    if (cm->intra_only) {
-      pbi->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES);
-      if (pbi->refresh_frame_flags == 0xFF) {
-        aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                           "Intra only frames cannot have refresh flags 0xFF");
-      }
-      if (pbi->need_resync) {
-        memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
-        pbi->need_resync = 0;
-      }
-    } else if (pbi->need_resync != 1) { /* Skip if need resync */
-      pbi->refresh_frame_flags =
-          frame_is_sframe(cm) ? 0xFF : aom_rb_read_literal(rb, REF_FRAMES);
-      if (!pbi->refresh_frame_flags) {
-        // NOTE: "pbi->refresh_frame_flags == 0" indicates that the coded frame
-        //       will not be used as a reference
-        cm->is_reference_frame = 0;
-      }
-    }
-  }
-
-  if (!frame_is_intra_only(cm) || pbi->refresh_frame_flags != 0xFF) {
-    // Read all ref frame order hints if error_resilient_mode == 1
-    if (cm->error_resilient_mode && seq_params->enable_order_hint) {
-      for (int ref_idx = 0; ref_idx < REF_FRAMES; ref_idx++) {
-        // Read order hint from bit stream
-        unsigned int frame_offset =
-            aom_rb_read_literal(rb, seq_params->order_hint_bits_minus_1 + 1);
-        // Get buffer index
-        int buf_idx = cm->ref_frame_map[ref_idx];
-        assert(buf_idx < FRAME_BUFFERS);
-        if (buf_idx == -1 ||
-            frame_offset != frame_bufs[buf_idx].cur_frame_offset) {
-          if (buf_idx >= 0) {
-            lock_buffer_pool(pool);
-            decrease_ref_count(buf_idx, frame_bufs, pool);
-            unlock_buffer_pool(pool);
-          }
-          // If no corresponding buffer exists, allocate a new buffer with all
-          // pixels set to neutral grey.
-          buf_idx = get_free_fb(cm);
-          if (buf_idx == INVALID_IDX) {
-            aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
-                               "Unable to find free frame buffer");
-          }
-          lock_buffer_pool(pool);
-          if (aom_realloc_frame_buffer(
-                  &frame_bufs[buf_idx].buf, seq_params->max_frame_width,
-                  seq_params->max_frame_height, seq_params->subsampling_x,
-                  seq_params->subsampling_y, seq_params->use_highbitdepth,
-                  AOM_BORDER_IN_PIXELS, cm->byte_alignment,
-                  &pool->frame_bufs[buf_idx].raw_frame_buffer, pool->get_fb_cb,
-                  pool->cb_priv)) {
-            unlock_buffer_pool(pool);
-            aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
-                               "Failed to allocate frame buffer");
-          }
-          unlock_buffer_pool(pool);
-          set_planes_to_neutral_grey(seq_params, &frame_bufs[buf_idx].buf, 0);
-
-          cm->ref_frame_map[ref_idx] = buf_idx;
-          frame_bufs[buf_idx].cur_frame_offset = frame_offset;
-        }
-      }
-    }
-  }
-
-  if (cm->frame_type == KEY_FRAME) {
-    setup_frame_size(cm, frame_size_override_flag, rb);
-
-    if (cm->allow_screen_content_tools && !av1_superres_scaled(cm))
-      cm->allow_intrabc = aom_rb_read_bit(rb);
-    cm->allow_ref_frame_mvs = 0;
-    cm->prev_frame = NULL;
-  } else {
-    cm->allow_ref_frame_mvs = 0;
-
-    if (cm->intra_only) {
-      cm->cur_frame->film_grain_params_present =
-          seq_params->film_grain_params_present;
-      setup_frame_size(cm, frame_size_override_flag, rb);
-      if (cm->allow_screen_content_tools && !av1_superres_scaled(cm))
-        cm->allow_intrabc = aom_rb_read_bit(rb);
-
-    } else if (pbi->need_resync != 1) { /* Skip if need resync */
-
-      // Frame refs short signaling is off when error resilient mode is on.
-      if (seq_params->enable_order_hint)
-        cm->frame_refs_short_signaling = aom_rb_read_bit(rb);
-
-      if (cm->frame_refs_short_signaling) {
-        // == LAST_FRAME ==
-        const int lst_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2);
-        const int lst_idx = cm->ref_frame_map[lst_ref];
-
-        // == GOLDEN_FRAME ==
-        const int gld_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2);
-        const int gld_idx = cm->ref_frame_map[gld_ref];
-
-        // Most of the time, streams start with a keyframe. In that case,
-        // ref_frame_map will have been filled in at that point and will not
-        // contain any -1's. However, streams are explicitly allowed to start
-        // with an intra-only frame, so long as they don't then signal a
-        // reference to a slot that hasn't been set yet. That's what we are
-        // checking here.
-        if (lst_idx == -1)
-          aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                             "Inter frame requests nonexistent reference");
-        if (gld_idx == -1)
-          aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                             "Inter frame requests nonexistent reference");
-
-        av1_set_frame_refs(cm, lst_ref, gld_ref);
-      }
-
-      for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-        int ref = 0;
-        if (!cm->frame_refs_short_signaling) {
-          ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2);
-          const int idx = cm->ref_frame_map[ref];
-
-          // Most of the time, streams start with a keyframe. In that case,
-          // ref_frame_map will have been filled in at that point and will not
-          // contain any -1's. However, streams are explicitly allowed to start
-          // with an intra-only frame, so long as they don't then signal a
-          // reference to a slot that hasn't been set yet. That's what we are
-          // checking here.
-          if (idx == -1)
-            aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                               "Inter frame requests nonexistent reference");
-
-          RefBuffer *const ref_frame = &cm->frame_refs[i];
-          ref_frame->idx = idx;
-          ref_frame->buf = &frame_bufs[idx].buf;
-          ref_frame->map_idx = ref;
-        } else {
-          ref = cm->frame_refs[i].map_idx;
-        }
-
-        cm->ref_frame_sign_bias[LAST_FRAME + i] = 0;
-
-        if (seq_params->frame_id_numbers_present_flag) {
-          int frame_id_length = seq_params->frame_id_length;
-          int diff_len = seq_params->delta_frame_id_length;
-          int delta_frame_id_minus_1 = aom_rb_read_literal(rb, diff_len);
-          int ref_frame_id =
-              ((cm->current_frame_id - (delta_frame_id_minus_1 + 1) +
-                (1 << frame_id_length)) %
-               (1 << frame_id_length));
-          // Compare values derived from delta_frame_id_minus_1 and
-          // refresh_frame_flags. Also, check valid for referencing
-          if (ref_frame_id != cm->ref_frame_id[ref] ||
-              cm->valid_for_referencing[ref] == 0)
-            aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                               "Reference buffer frame ID mismatch");
-        }
-      }
-
-      if (!cm->error_resilient_mode && frame_size_override_flag) {
-        setup_frame_size_with_refs(cm, rb);
-      } else {
-        setup_frame_size(cm, frame_size_override_flag, rb);
-      }
-
-      if (cm->cur_frame_force_integer_mv) {
-        cm->allow_high_precision_mv = 0;
-      } else {
-        cm->allow_high_precision_mv = aom_rb_read_bit(rb);
-      }
-      cm->interp_filter = read_frame_interp_filter(rb);
-      cm->switchable_motion_mode = aom_rb_read_bit(rb);
-    }
-
-    cm->prev_frame = get_prev_frame(cm);
-    if (cm->primary_ref_frame != PRIMARY_REF_NONE &&
-        cm->frame_refs[cm->primary_ref_frame].idx < 0) {
-      aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                         "Reference frame containing this frame's initial "
-                         "frame context is unavailable.");
-    }
-
-    if (!cm->intra_only && pbi->need_resync != 1) {
-      if (frame_might_allow_ref_frame_mvs(cm))
-        cm->allow_ref_frame_mvs = aom_rb_read_bit(rb);
-      else
-        cm->allow_ref_frame_mvs = 0;
-
-      for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-        RefBuffer *const ref_buf = &cm->frame_refs[i];
-        av1_setup_scale_factors_for_frame(
-            &ref_buf->sf, ref_buf->buf->y_crop_width,
-            ref_buf->buf->y_crop_height, cm->width, cm->height);
-        if ((!av1_is_valid_scale(&ref_buf->sf)))
-          aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                             "Reference frame has invalid dimensions");
-      }
-    }
-  }
-
-  av1_setup_frame_buf_refs(cm);
-
-  av1_setup_frame_sign_bias(cm);
-
-  cm->cur_frame->intra_only = cm->frame_type == KEY_FRAME || cm->intra_only;
-  cm->cur_frame->frame_type = cm->frame_type;
-
-  if (seq_params->frame_id_numbers_present_flag) {
-    /* If bitmask is set, update reference frame id values and
-       mark frames as valid for reference */
-    int refresh_frame_flags = pbi->refresh_frame_flags;
-    for (int i = 0; i < REF_FRAMES; i++) {
-      if ((refresh_frame_flags >> i) & 1) {
-        cm->ref_frame_id[i] = cm->current_frame_id;
-        cm->valid_for_referencing[i] = 1;
-      }
-    }
-  }
-
-  const int might_bwd_adapt =
-      !(seq_params->reduced_still_picture_hdr) && !(cm->disable_cdf_update);
-  if (might_bwd_adapt) {
-    cm->refresh_frame_context = aom_rb_read_bit(rb)
-                                    ? REFRESH_FRAME_CONTEXT_DISABLED
-                                    : REFRESH_FRAME_CONTEXT_BACKWARD;
-  } else {
-    cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED;
-  }
-
-  get_frame_new_buffer(cm)->bit_depth = seq_params->bit_depth;
-  get_frame_new_buffer(cm)->color_primaries = seq_params->color_primaries;
-  get_frame_new_buffer(cm)->transfer_characteristics =
-      seq_params->transfer_characteristics;
-  get_frame_new_buffer(cm)->matrix_coefficients =
-      seq_params->matrix_coefficients;
-  get_frame_new_buffer(cm)->monochrome = seq_params->monochrome;
-  get_frame_new_buffer(cm)->chroma_sample_position =
-      seq_params->chroma_sample_position;
-  get_frame_new_buffer(cm)->color_range = seq_params->color_range;
-  get_frame_new_buffer(cm)->render_width = cm->render_width;
-  get_frame_new_buffer(cm)->render_height = cm->render_height;
-
-  if (pbi->need_resync) {
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Keyframe / intra-only frame required to reset decoder"
-                       " state");
-  }
-
-  // Generate next_ref_frame_map.
-  lock_buffer_pool(pool);
-  int ref_index = 0;
-  for (int mask = pbi->refresh_frame_flags; mask; mask >>= 1) {
-    if (mask & 1) {
-      cm->next_ref_frame_map[ref_index] = cm->new_fb_idx;
-      ++frame_bufs[cm->new_fb_idx].ref_count;
-    } else {
-      cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index];
-    }
-    // Current thread holds the reference frame.
-    if (cm->ref_frame_map[ref_index] >= 0)
-      ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count;
-    ++ref_index;
-  }
-
-  for (; ref_index < REF_FRAMES; ++ref_index) {
-    cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index];
-
-    // Current thread holds the reference frame.
-    if (cm->ref_frame_map[ref_index] >= 0)
-      ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count;
-  }
-  unlock_buffer_pool(pool);
-  pbi->hold_ref_buf = 1;
-
-  if (cm->allow_intrabc) {
-    // Set parameters corresponding to no filtering.
-    struct loopfilter *lf = &cm->lf;
-    lf->filter_level[0] = 0;
-    lf->filter_level[1] = 0;
-    cm->cdef_bits = 0;
-    cm->cdef_strengths[0] = 0;
-    cm->nb_cdef_strengths = 1;
-    cm->cdef_uv_strengths[0] = 0;
-    cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
-    cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
-    cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
-  }
-
-  read_tile_info(pbi, rb);
-  setup_quantization(cm, rb);
-  xd->bd = (int)seq_params->bit_depth;
-
-  if (cm->num_allocated_above_context_planes < av1_num_planes(cm) ||
-      cm->num_allocated_above_context_mi_col < cm->mi_cols ||
-      cm->num_allocated_above_contexts < cm->tile_rows) {
-    av1_free_above_context_buffers(cm, cm->num_allocated_above_contexts);
-    if (av1_alloc_above_context_buffers(cm, cm->tile_rows))
-      aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
-                         "Failed to allocate context buffers");
-  }
-
-  if (cm->primary_ref_frame == PRIMARY_REF_NONE) {
-    av1_setup_past_independence(cm);
-  }
-
-  setup_segmentation(cm, rb);
-
-  cm->delta_q_res = 1;
-  cm->delta_lf_res = 1;
-  cm->delta_lf_present_flag = 0;
-  cm->delta_lf_multi = 0;
-  cm->delta_q_present_flag = cm->base_qindex > 0 ? aom_rb_read_bit(rb) : 0;
-  if (cm->delta_q_present_flag) {
-    xd->current_qindex = cm->base_qindex;
-    cm->delta_q_res = 1 << aom_rb_read_literal(rb, 2);
-    if (!cm->allow_intrabc) cm->delta_lf_present_flag = aom_rb_read_bit(rb);
-    if (cm->delta_lf_present_flag) {
-      cm->delta_lf_res = 1 << aom_rb_read_literal(rb, 2);
-      cm->delta_lf_multi = aom_rb_read_bit(rb);
-      av1_reset_loop_filter_delta(xd, av1_num_planes(cm));
-    }
-  }
-
-  xd->cur_frame_force_integer_mv = cm->cur_frame_force_integer_mv;
-
-  for (int i = 0; i < MAX_SEGMENTS; ++i) {
-    const int qindex = cm->seg.enabled
-                           ? av1_get_qindex(&cm->seg, i, cm->base_qindex)
-                           : cm->base_qindex;
-    xd->lossless[i] = qindex == 0 && cm->y_dc_delta_q == 0 &&
-                      cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 &&
-                      cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0;
-    xd->qindex[i] = qindex;
-  }
-  cm->coded_lossless = is_coded_lossless(cm, xd);
-  cm->all_lossless = cm->coded_lossless && !av1_superres_scaled(cm);
-  setup_segmentation_dequant(cm);
-  if (cm->coded_lossless) {
-    cm->lf.filter_level[0] = 0;
-    cm->lf.filter_level[1] = 0;
-  }
-  if (cm->coded_lossless || !seq_params->enable_cdef) {
-    cm->cdef_bits = 0;
-    cm->cdef_strengths[0] = 0;
-    cm->cdef_uv_strengths[0] = 0;
-  }
-  if (cm->all_lossless || !seq_params->enable_restoration) {
-    cm->rst_info[0].frame_restoration_type = RESTORE_NONE;
-    cm->rst_info[1].frame_restoration_type = RESTORE_NONE;
-    cm->rst_info[2].frame_restoration_type = RESTORE_NONE;
-  }
-  setup_loopfilter(cm, rb);
-
-  if (!cm->coded_lossless && seq_params->enable_cdef) {
-    setup_cdef(cm, rb);
-  }
-  if (!cm->all_lossless && seq_params->enable_restoration) {
-    decode_restoration_mode(cm, rb);
-  }
-
-  cm->tx_mode = read_tx_mode(cm, rb);
-  cm->reference_mode = read_frame_reference_mode(cm, rb);
-  if (cm->reference_mode != SINGLE_REFERENCE) setup_compound_reference_mode(cm);
-
-  av1_setup_skip_mode_allowed(cm);
-  cm->skip_mode_flag = cm->is_skip_mode_allowed ? aom_rb_read_bit(rb) : 0;
-
-  if (frame_might_allow_warped_motion(cm))
-    cm->allow_warped_motion = aom_rb_read_bit(rb);
-  else
-    cm->allow_warped_motion = 0;
-
-  cm->reduced_tx_set_used = aom_rb_read_bit(rb);
-
-  if (cm->allow_ref_frame_mvs && !frame_might_allow_ref_frame_mvs(cm)) {
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Frame wrongly requests reference frame MVs");
-  }
-
-  if (!frame_is_intra_only(cm)) read_global_motion(cm, rb);
-
-  cm->cur_frame->film_grain_params_present =
-      seq_params->film_grain_params_present;
-  read_film_grain(cm, rb);
-
-#if EXT_TILE_DEBUG
-  if (pbi->ext_tile_debug && cm->large_scale_tile) {
-    read_ext_tile_info(pbi, rb);
-    av1_set_single_tile_decoding_mode(cm);
-  }
-#endif  // EXT_TILE_DEBUG
-  return 0;
-}
-
-struct aom_read_bit_buffer *av1_init_read_bit_buffer(
-    AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data,
-    const uint8_t *data_end) {
-  rb->bit_offset = 0;
-  rb->error_handler = error_handler;
-  rb->error_handler_data = &pbi->common;
-  rb->bit_buffer = data;
-  rb->bit_buffer_end = data_end;
-  return rb;
-}
-
-void av1_read_frame_size(struct aom_read_bit_buffer *rb, int num_bits_width,
-                         int num_bits_height, int *width, int *height) {
-  *width = aom_rb_read_literal(rb, num_bits_width) + 1;
-  *height = aom_rb_read_literal(rb, num_bits_height) + 1;
-}
-
-BITSTREAM_PROFILE av1_read_profile(struct aom_read_bit_buffer *rb) {
-  int profile = aom_rb_read_literal(rb, PROFILE_BITS);
-  return (BITSTREAM_PROFILE)profile;
-}
-
-void superres_post_decode(AV1Decoder *pbi) {
-  AV1_COMMON *const cm = &pbi->common;
-  BufferPool *const pool = cm->buffer_pool;
-
-  if (!av1_superres_scaled(cm)) return;
-  assert(!cm->all_lossless);
-
-  lock_buffer_pool(pool);
-  av1_superres_upscale(cm, pool);
-  unlock_buffer_pool(pool);
-}
-
-uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi,
-                                            struct aom_read_bit_buffer *rb,
-                                            const uint8_t *data,
-                                            const uint8_t **p_data_end,
-                                            int trailing_bits_present) {
-  AV1_COMMON *const cm = &pbi->common;
-  const int num_planes = av1_num_planes(cm);
-  MACROBLOCKD *const xd = &pbi->mb;
-
-#if CONFIG_BITSTREAM_DEBUG
-  bitstream_queue_set_frame_read(cm->current_video_frame * 2 + cm->show_frame);
-#endif
-#if CONFIG_MISMATCH_DEBUG
-  mismatch_move_frame_idx_r();
-#endif
-
-  for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
-    cm->global_motion[i] = default_warp_params;
-    cm->cur_frame->global_motion[i] = default_warp_params;
-  }
-  xd->global_motion = cm->global_motion;
-
-  read_uncompressed_header(pbi, rb);
-
-  if (trailing_bits_present) av1_check_trailing_bits(pbi, rb);
-
-  // If cm->single_tile_decoding = 0, the independent decoding of a single tile
-  // or a section of a frame is not allowed.
-  if (!cm->single_tile_decoding &&
-      (pbi->dec_tile_row >= 0 || pbi->dec_tile_col >= 0)) {
-    pbi->dec_tile_row = -1;
-    pbi->dec_tile_col = -1;
-  }
-
-  const uint32_t uncomp_hdr_size =
-      (uint32_t)aom_rb_bytes_read(rb);  // Size of the uncompressed header
-  YV12_BUFFER_CONFIG *new_fb = get_frame_new_buffer(cm);
-  xd->cur_buf = new_fb;
-  if (av1_allow_intrabc(cm)) {
-    av1_setup_scale_factors_for_frame(
-        &cm->sf_identity, xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height,
-        xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height);
-  }
-
-  if (cm->show_existing_frame) {
-    // showing a frame directly
-    *p_data_end = data + uncomp_hdr_size;
-    if (cm->reset_decoder_state) {
-      // Use the default frame context values.
-      *cm->fc = cm->frame_contexts[FRAME_CONTEXT_DEFAULTS];
-      if (!cm->fc->initialized)
-        aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                           "Uninitialized entropy context.");
-    }
-    return uncomp_hdr_size;
-  }
-
-  cm->setup_mi(cm);
-
-  cm->current_frame_seg_map = cm->cur_frame->seg_map;
-
-  av1_setup_motion_field(cm);
-
-  av1_setup_block_planes(xd, cm->seq_params.subsampling_x,
-                         cm->seq_params.subsampling_y, num_planes);
-  if (cm->primary_ref_frame == PRIMARY_REF_NONE) {
-    // use the default frame context values
-    *cm->fc = cm->frame_contexts[FRAME_CONTEXT_DEFAULTS];
-  } else {
-    *cm->fc = cm->frame_contexts[cm->frame_refs[cm->primary_ref_frame].idx];
-  }
-  if (!cm->fc->initialized)
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Uninitialized entropy context.");
-
-  xd->corrupted = 0;
-  return uncomp_hdr_size;
-}
-
-// Once-per-frame initialization
-static void setup_frame_info(AV1Decoder *pbi) {
-  AV1_COMMON *const cm = &pbi->common;
-
-  if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
-      cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
-      cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
-    av1_alloc_restoration_buffers(cm);
-  }
-  const int use_highbd = cm->seq_params.use_highbitdepth ? 1 : 0;
-  const int buf_size = MC_TEMP_BUF_PELS << use_highbd;
-  if (pbi->td.mc_buf_size != buf_size) {
-    av1_free_mc_tmp_buf(&pbi->td);
-    allocate_mc_tmp_buf(cm, &pbi->td, buf_size, use_highbd);
-  }
-}
-
-void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data,
-                                    const uint8_t *data_end,
-                                    const uint8_t **p_data_end, int start_tile,
-                                    int end_tile, int initialize_flag) {
-  AV1_COMMON *const cm = &pbi->common;
-  MACROBLOCKD *const xd = &pbi->mb;
-  const int tile_count_tg = end_tile - start_tile + 1;
-
-  if (initialize_flag) setup_frame_info(pbi);
-  const int num_planes = av1_num_planes(cm);
-#if LOOP_FILTER_BITMASK
-  av1_loop_filter_frame_init(cm, 0, num_planes);
-  av1_zero_array(cm->lf.lfm, cm->lf.lfm_num);
-#endif
-
-  if (pbi->max_threads > 1 && !(cm->large_scale_tile && !pbi->ext_tile_debug) &&
-      pbi->row_mt)
-    *p_data_end =
-        decode_tiles_row_mt(pbi, data, data_end, start_tile, end_tile);
-  else if (pbi->max_threads > 1 && tile_count_tg > 1 &&
-           !(cm->large_scale_tile && !pbi->ext_tile_debug))
-    *p_data_end = decode_tiles_mt(pbi, data, data_end, start_tile, end_tile);
-  else
-    *p_data_end = decode_tiles(pbi, data, data_end, start_tile, end_tile);
-
-  // If the bit stream is monochrome, set the U and V buffers to a constant.
-  if (num_planes < 3) {
-    set_planes_to_neutral_grey(&cm->seq_params, xd->cur_buf, 1);
-  }
-
-  if (end_tile != cm->tile_rows * cm->tile_cols - 1) {
-    return;
-  }
-
-  if (!cm->allow_intrabc && !cm->single_tile_decoding) {
-    if (cm->lf.filter_level[0] || cm->lf.filter_level[1]) {
-#if LOOP_FILTER_BITMASK
-      av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, 1, 0,
-                            num_planes, 0);
-#else
-      if (pbi->num_workers > 1) {
-        av1_loop_filter_frame_mt(get_frame_new_buffer(cm), cm, &pbi->mb, 0,
-                                 num_planes, 0, pbi->tile_workers,
-                                 pbi->num_workers, &pbi->lf_row_sync);
-      } else {
-        av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, 0,
-                              num_planes, 0);
-      }
-#endif
-    }
-
-    const int do_loop_restoration =
-        cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
-        cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
-        cm->rst_info[2].frame_restoration_type != RESTORE_NONE;
-    const int do_cdef =
-        !cm->skip_loop_filter && !cm->coded_lossless &&
-        (cm->cdef_bits || cm->cdef_strengths[0] || cm->cdef_uv_strengths[0]);
-    const int do_superres = av1_superres_scaled(cm);
-    const int optimized_loop_restoration = !do_cdef && !do_superres;
-
-    if (!optimized_loop_restoration) {
-      if (do_loop_restoration)
-        av1_loop_restoration_save_boundary_lines(&pbi->cur_buf->buf, cm, 0);
-
-      if (do_cdef) av1_cdef_frame(&pbi->cur_buf->buf, cm, &pbi->mb);
-
-      superres_post_decode(pbi);
-
-      if (do_loop_restoration) {
-        av1_loop_restoration_save_boundary_lines(&pbi->cur_buf->buf, cm, 1);
-        if (pbi->num_workers > 1) {
-          av1_loop_restoration_filter_frame_mt(
-              (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, optimized_loop_restoration,
-              pbi->tile_workers, pbi->num_workers, &pbi->lr_row_sync,
-              &pbi->lr_ctxt);
-        } else {
-          av1_loop_restoration_filter_frame((YV12_BUFFER_CONFIG *)xd->cur_buf,
-                                            cm, optimized_loop_restoration,
-                                            &pbi->lr_ctxt);
-        }
-      }
-    } else {
-      // In no cdef and no superres case. Provide an optimized version of
-      // loop_restoration_filter.
-      if (do_loop_restoration) {
-        if (pbi->num_workers > 1) {
-          av1_loop_restoration_filter_frame_mt(
-              (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, optimized_loop_restoration,
-              pbi->tile_workers, pbi->num_workers, &pbi->lr_row_sync,
-              &pbi->lr_ctxt);
-        } else {
-          av1_loop_restoration_filter_frame((YV12_BUFFER_CONFIG *)xd->cur_buf,
-                                            cm, optimized_loop_restoration,
-                                            &pbi->lr_ctxt);
-        }
-      }
-    }
-  }
-
-  if (!xd->corrupted) {
-    if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) {
-      assert(cm->context_update_tile_id < pbi->allocated_tiles);
-      *cm->fc = pbi->tile_data[cm->context_update_tile_id].tctx;
-      av1_reset_cdf_symbol_counters(cm->fc);
-    }
-  } else {
-    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
-                       "Decode failed. Frame data is corrupted.");
-  }
-
-#if CONFIG_INSPECTION
-  if (pbi->inspect_cb != NULL) {
-    (*pbi->inspect_cb)(pbi, pbi->inspect_ctx);
-  }
-#endif
-
-  // Non frame parallel update frame context here.
-  if (!cm->large_scale_tile) {
-    cm->frame_contexts[cm->new_fb_idx] = *cm->fc;
-  }
-}
diff --git a/third_party/aom/av1/decoder/decodeframe.h b/third_party/aom/av1/decoder/decodeframe.h
deleted file mode 100644
index ddad273f1..000000000
--- a/third_party/aom/av1/decoder/decodeframe.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#ifndef AOM_AV1_DECODER_DECODEFRAME_H_
-#define AOM_AV1_DECODER_DECODEFRAME_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct AV1Decoder;
-struct aom_read_bit_buffer;
-struct ThreadData;
-
-// Reads the middle part of the sequence header OBU (from
-// frame_width_bits_minus_1 to enable_restoration) into seq_params.
-// Reports errors by calling rb->error_handler() or aom_internal_error().
-void av1_read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb,
-                              SequenceHeader *seq_params);
-
-void av1_read_frame_size(struct aom_read_bit_buffer *rb, int num_bits_width,
-                         int num_bits_height, int *width, int *height);
-BITSTREAM_PROFILE av1_read_profile(struct aom_read_bit_buffer *rb);
-
-// Returns 0 on success. Sets pbi->common.error.error_code and returns -1 on
-// failure.
-int av1_check_trailing_bits(struct AV1Decoder *pbi,
-                            struct aom_read_bit_buffer *rb);
-
-// On success, returns the frame header size. On failure, calls
-// aom_internal_error and does not return.
-// TODO(wtc): Figure out and document the p_data_end parameter.
-uint32_t av1_decode_frame_headers_and_setup(struct AV1Decoder *pbi,
-                                            struct aom_read_bit_buffer *rb,
-                                            const uint8_t *data,
-                                            const uint8_t **p_data_end,
-                                            int trailing_bits_present);
-
-void av1_decode_tg_tiles_and_wrapup(struct AV1Decoder *pbi, const uint8_t *data,
-                                    const uint8_t *data_end,
-                                    const uint8_t **p_data_end, int startTile,
-                                    int endTile, int initialize_flag);
-
-// Implements the color_config() function in the spec. Reports errors by
-// calling rb->error_handler() or aom_internal_error().
-void av1_read_color_config(struct aom_read_bit_buffer *rb,
-                           int allow_lowbitdepth, SequenceHeader *seq_params,
-                           struct aom_internal_error_info *error_info);
-
-// Implements the timing_info() function in the spec. Reports errors by calling
-// rb->error_handler().
-void av1_read_timing_info_header(AV1_COMMON *cm,
-                                 struct aom_read_bit_buffer *rb);
-
-// Implements the decoder_model_info() function in the spec. Reports errors by
-// calling rb->error_handler().
-void av1_read_decoder_model_info(AV1_COMMON *cm,
-                                 struct aom_read_bit_buffer *rb);
-
-// Implements the operating_parameters_info() function in the spec. Reports
-// errors by calling rb->error_handler() or aom_internal_error().
-void av1_read_op_parameters_info(AV1_COMMON *const cm,
-                                 struct aom_read_bit_buffer *rb, int op_num);
-
-struct aom_read_bit_buffer *av1_init_read_bit_buffer(
-    struct AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data,
-    const uint8_t *data_end);
-
-void av1_free_mc_tmp_buf(struct ThreadData *thread_data);
-
-void av1_set_single_tile_decoding_mode(AV1_COMMON *const cm);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#endif  // AOM_AV1_DECODER_DECODEFRAME_H_
diff --git a/third_party/aom/av1/decoder/decodemv.c b/third_party/aom/av1/decoder/decodemv.c
deleted file mode 100644
index 551e4d543..000000000
--- a/third_party/aom/av1/decoder/decodemv.c
+++ /dev/null
@@ -1,1560 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include <assert.h>
-
-#include "av1/common/cfl.h"
-#include "av1/common/common.h"
-#include "av1/common/entropy.h"
-#include "av1/common/entropymode.h"
-#include "av1/common/entropymv.h"
-#include "av1/common/mvref_common.h"
-#include "av1/common/pred_common.h"
-#include "av1/common/reconinter.h"
-#include "av1/common/reconintra.h"
-#include "av1/common/seg_common.h"
-#include "av1/common/warped_motion.h"
-
-#include "av1/decoder/decodeframe.h"
-#include "av1/decoder/decodemv.h"
-
-#include "aom_dsp/aom_dsp_common.h"
-
-#define ACCT_STR __func__
-
-#define DEC_MISMATCH_DEBUG 0
-
-static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
-  return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR);
-}
-
-static void read_cdef(AV1_COMMON *cm, aom_reader *r, MACROBLOCKD *const xd,
-                      int mi_col, int mi_row) {
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  if (cm->coded_lossless) return;
-  if (cm->allow_intrabc) {
-    assert(cm->cdef_bits == 0);
-    return;
-  }
-
-  if (!(mi_col & (cm->seq_params.mib_size - 1)) &&
-      !(mi_row & (cm->seq_params.mib_size - 1))) {  // Top left?
-    xd->cdef_preset[0] = xd->cdef_preset[1] = xd->cdef_preset[2] =
-        xd->cdef_preset[3] = -1;
-  }
-  // Read CDEF param at the first non-skip coding block
-  const int mask = (1 << (6 - MI_SIZE_LOG2));
-  const int m = ~(mask - 1);
-  const int index = cm->seq_params.sb_size == BLOCK_128X128
-                        ? !!(mi_col & mask) + 2 * !!(mi_row & mask)
-                        : 0;
-  cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]
-      ->cdef_strength = xd->cdef_preset[index] =
-      xd->cdef_preset[index] == -1 && !mbmi->skip
-          ? aom_read_literal(r, cm->cdef_bits, ACCT_STR)
-          : xd->cdef_preset[index];
-}
-
-static int read_delta_qindex(AV1_COMMON *cm, const MACROBLOCKD *xd,
-                             aom_reader *r, MB_MODE_INFO *const mbmi,
-                             int mi_col, int mi_row) {
-  int sign, abs, reduced_delta_qindex = 0;
-  BLOCK_SIZE bsize = mbmi->sb_type;
-  const int b_col = mi_col & (cm->seq_params.mib_size - 1);
-  const int b_row = mi_row & (cm->seq_params.mib_size - 1);
-  const int read_delta_q_flag = (b_col == 0 && b_row == 0);
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-
-  if ((bsize != cm->seq_params.sb_size || mbmi->skip == 0) &&
-      read_delta_q_flag) {
-    abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
-    const int smallval = (abs < DELTA_Q_SMALL);
-
-    if (!smallval) {
-      const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
-      const int thr = (1 << rem_bits) + 1;
-      abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
-    }
-
-    if (abs) {
-      sign = aom_read_bit(r, ACCT_STR);
-    } else {
-      sign = 1;
-    }
-
-    reduced_delta_qindex = sign ? -abs : abs;
-  }
-  return reduced_delta_qindex;
-}
-static int read_delta_lflevel(const AV1_COMMON *const cm, aom_reader *r,
-                              aom_cdf_prob *const cdf,
-                              const MB_MODE_INFO *const mbmi, int mi_col,
-                              int mi_row) {
-  int reduced_delta_lflevel = 0;
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  const int b_col = mi_col & (cm->seq_params.mib_size - 1);
-  const int b_row = mi_row & (cm->seq_params.mib_size - 1);
-  const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
-
-  if ((bsize != cm->seq_params.sb_size || mbmi->skip == 0) &&
-      read_delta_lf_flag) {
-    int abs = aom_read_symbol(r, cdf, DELTA_LF_PROBS + 1, ACCT_STR);
-    const int smallval = (abs < DELTA_LF_SMALL);
-    if (!smallval) {
-      const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
-      const int thr = (1 << rem_bits) + 1;
-      abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
-    }
-    const int sign = abs ? aom_read_bit(r, ACCT_STR) : 1;
-    reduced_delta_lflevel = sign ? -abs : abs;
-  }
-  return reduced_delta_lflevel;
-}
-
-static UV_PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx,
-                                             aom_reader *r,
-                                             CFL_ALLOWED_TYPE cfl_allowed,
-                                             PREDICTION_MODE y_mode) {
-  const UV_PREDICTION_MODE uv_mode =
-      aom_read_symbol(r, ec_ctx->uv_mode_cdf[cfl_allowed][y_mode],
-                      UV_INTRA_MODES - !cfl_allowed, ACCT_STR);
-  return uv_mode;
-}
-
-static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r,
-                           int *signs_out) {
-  const int joint_sign =
-      aom_read_symbol(r, ec_ctx->cfl_sign_cdf, CFL_JOINT_SIGNS, "cfl:signs");
-  int idx = 0;
-  // Magnitudes are only coded for nonzero values
-  if (CFL_SIGN_U(joint_sign) != CFL_SIGN_ZERO) {
-    aom_cdf_prob *cdf_u = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_U(joint_sign)];
-    idx = aom_read_symbol(r, cdf_u, CFL_ALPHABET_SIZE, "cfl:alpha_u")
-          << CFL_ALPHABET_SIZE_LOG2;
-  }
-  if (CFL_SIGN_V(joint_sign) != CFL_SIGN_ZERO) {
-    aom_cdf_prob *cdf_v = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_V(joint_sign)];
-    idx += aom_read_symbol(r, cdf_v, CFL_ALPHABET_SIZE, "cfl:alpha_v");
-  }
-  *signs_out = joint_sign;
-  return idx;
-}
-
-static INTERINTRA_MODE read_interintra_mode(MACROBLOCKD *xd, aom_reader *r,
-                                            int size_group) {
-  const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_symbol(
-      r, xd->tile_ctx->interintra_mode_cdf[size_group], INTERINTRA_MODES,
-      ACCT_STR);
-  return ii_mode;
-}
-
-static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, aom_reader *r,
-                                       int16_t ctx) {
-  int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
-  int is_newmv, is_zeromv, is_refmv;
-  is_newmv = aom_read_symbol(r, ec_ctx->newmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
-  if (is_newmv) return NEWMV;
-
-  mode_ctx = (ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
-  is_zeromv =
-      aom_read_symbol(r, ec_ctx->zeromv_cdf[mode_ctx], 2, ACCT_STR) == 0;
-  if (is_zeromv) return GLOBALMV;
-
-  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
-  is_refmv = aom_read_symbol(r, ec_ctx->refmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
-  if (is_refmv)
-    return NEARESTMV;
-  else
-    return NEARMV;
-}
-
-static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
-                         MB_MODE_INFO *mbmi, aom_reader *r) {
-  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
-  mbmi->ref_mv_idx = 0;
-  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
-    for (int idx = 0; idx < 2; ++idx) {
-      if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
-        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
-        int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
-        mbmi->ref_mv_idx = idx + drl_idx;
-        if (!drl_idx) return;
-      }
-    }
-  }
-  if (have_nearmv_in_inter_mode(mbmi->mode)) {
-    // Offset the NEARESTMV mode.
-    // TODO(jingning): Unify the two syntax decoding loops after the NEARESTMV
-    // mode is factored in.
-    for (int idx = 1; idx < 3; ++idx) {
-      if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
-        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
-        int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
-        mbmi->ref_mv_idx = idx + drl_idx - 1;
-        if (!drl_idx) return;
-      }
-    }
-  }
-}
-
-static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
-                                    MB_MODE_INFO *mbmi, aom_reader *r) {
-  if (cm->switchable_motion_mode == 0) return SIMPLE_TRANSLATION;
-  if (mbmi->skip_mode) return SIMPLE_TRANSLATION;
-
-  const MOTION_MODE last_motion_mode_allowed =
-      motion_mode_allowed(xd->global_motion, xd, mbmi, cm->allow_warped_motion);
-  int motion_mode;
-
-  if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
-
-  if (last_motion_mode_allowed == OBMC_CAUSAL) {
-    motion_mode =
-        aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2, ACCT_STR);
-    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
-  } else {
-    motion_mode =
-        aom_read_symbol(r, xd->tile_ctx->motion_mode_cdf[mbmi->sb_type],
-                        MOTION_MODES, ACCT_STR);
-    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
-  }
-}
-
-static PREDICTION_MODE read_inter_compound_mode(MACROBLOCKD *xd, aom_reader *r,
-                                                int16_t ctx) {
-  const int mode =
-      aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
-                      INTER_COMPOUND_MODES, ACCT_STR);
-  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
-  return NEAREST_NEARESTMV + mode;
-}
-
-int av1_neg_deinterleave(int diff, int ref, int max) {
-  if (!ref) return diff;
-  if (ref >= (max - 1)) return max - diff - 1;
-  if (2 * ref < max) {
-    if (diff <= 2 * ref) {
-      if (diff & 1)
-        return ref + ((diff + 1) >> 1);
-      else
-        return ref - (diff >> 1);
-    }
-    return diff;
-  } else {
-    if (diff <= 2 * (max - ref - 1)) {
-      if (diff & 1)
-        return ref + ((diff + 1) >> 1);
-      else
-        return ref - (diff >> 1);
-    }
-    return max - (diff + 1);
-  }
-}
-
-static int read_segment_id(AV1_COMMON *const cm, const MACROBLOCKD *const xd,
-                           int mi_row, int mi_col, aom_reader *r, int skip) {
-  int cdf_num;
-  const int pred = av1_get_spatial_seg_pred(cm, xd, mi_row, mi_col, &cdf_num);
-  if (skip) return pred;
-
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  struct segmentation *const seg = &cm->seg;
-  struct segmentation_probs *const segp = &ec_ctx->seg;
-  aom_cdf_prob *pred_cdf = segp->spatial_pred_seg_cdf[cdf_num];
-  const int coded_id = aom_read_symbol(r, pred_cdf, MAX_SEGMENTS, ACCT_STR);
-  const int segment_id =
-      av1_neg_deinterleave(coded_id, pred, seg->last_active_segid + 1);
-
-  if (segment_id < 0 || segment_id > seg->last_active_segid) {
-    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
-                       "Corrupted segment_ids");
-  }
-  return segment_id;
-}
-
-static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
-                              int mi_offset, int x_mis, int y_mis) {
-  int segment_id = INT_MAX;
-
-  for (int y = 0; y < y_mis; y++)
-    for (int x = 0; x < x_mis; x++)
-      segment_id =
-          AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
-
-  assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
-  return segment_id;
-}
-
-static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
-                           int segment_id) {
-  assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
-
-  for (int y = 0; y < y_mis; y++)
-    for (int x = 0; x < x_mis; x++)
-      cm->current_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id;
-}
-
-static int read_intra_segment_id(AV1_COMMON *const cm,
-                                 const MACROBLOCKD *const xd, int mi_row,
-                                 int mi_col, int bsize, aom_reader *r,
-                                 int skip) {
-  struct segmentation *const seg = &cm->seg;
-  if (!seg->enabled) return 0;  // Default for disabled segmentation
-
-  assert(seg->update_map && !seg->temporal_update);
-
-  const int mi_offset = mi_row * cm->mi_cols + mi_col;
-  const int bw = mi_size_wide[bsize];
-  const int bh = mi_size_high[bsize];
-  const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw);
-  const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh);
-  const int segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, skip);
-  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
-  return segment_id;
-}
-
-static void copy_segment_id(const AV1_COMMON *cm,
-                            const uint8_t *last_segment_ids,
-                            uint8_t *current_segment_ids, int mi_offset,
-                            int x_mis, int y_mis) {
-  for (int y = 0; y < y_mis; y++)
-    for (int x = 0; x < x_mis; x++)
-      current_segment_ids[mi_offset + y * cm->mi_cols + x] =
-          last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
-                           : 0;
-}
-
-static int get_predicted_segment_id(AV1_COMMON *const cm, int mi_offset,
-                                    int x_mis, int y_mis) {
-  return cm->last_frame_seg_map ? dec_get_segment_id(cm, cm->last_frame_seg_map,
-                                                     mi_offset, x_mis, y_mis)
-                                : 0;
-}
-
-static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                                 int mi_row, int mi_col, int preskip,
-                                 aom_reader *r) {
-  struct segmentation *const seg = &cm->seg;
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  const int mi_offset = mi_row * cm->mi_cols + mi_col;
-  const int bw = mi_size_wide[mbmi->sb_type];
-  const int bh = mi_size_high[mbmi->sb_type];
-
-  // TODO(slavarnway): move x_mis, y_mis into xd ?????
-  const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw);
-  const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh);
-
-  if (!seg->enabled) return 0;  // Default for disabled segmentation
-
-  if (!seg->update_map) {
-    copy_segment_id(cm, cm->last_frame_seg_map, cm->current_frame_seg_map,
-                    mi_offset, x_mis, y_mis);
-    return get_predicted_segment_id(cm, mi_offset, x_mis, y_mis);
-  }
-
-  int segment_id;
-  if (preskip) {
-    if (!seg->segid_preskip) return 0;
-  } else {
-    if (seg->segid_preskip) return mbmi->segment_id;
-    if (mbmi->skip) {
-      if (seg->temporal_update) {
-        mbmi->seg_id_predicted = 0;
-      }
-      segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 1);
-      set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
-      return segment_id;
-    }
-  }
-
-  if (seg->temporal_update) {
-    const int ctx = av1_get_pred_context_seg_id(xd);
-    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-    struct segmentation_probs *const segp = &ec_ctx->seg;
-    aom_cdf_prob *pred_cdf = segp->pred_cdf[ctx];
-    mbmi->seg_id_predicted = aom_read_symbol(r, pred_cdf, 2, ACCT_STR);
-    if (mbmi->seg_id_predicted) {
-      segment_id = get_predicted_segment_id(cm, mi_offset, x_mis, y_mis);
-    } else {
-      segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0);
-    }
-  } else {
-    segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0);
-  }
-  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
-  return segment_id;
-}
-
-static int read_skip_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
-                          aom_reader *r) {
-  if (!cm->skip_mode_flag) return 0;
-
-  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
-    return 0;
-  }
-
-  if (!is_comp_ref_allowed(xd->mi[0]->sb_type)) return 0;
-
-  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME) ||
-      segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
-    // These features imply single-reference mode, while skip mode implies
-    // compound reference. Hence, the two are mutually exclusive.
-    // In other words, skip_mode is implicitly 0 here.
-    return 0;
-  }
-
-  const int ctx = av1_get_skip_mode_context(xd);
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  const int skip_mode =
-      aom_read_symbol(r, ec_ctx->skip_mode_cdfs[ctx], 2, ACCT_STR);
-  return skip_mode;
-}
-
-static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
-                     aom_reader *r) {
-  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
-    return 1;
-  } else {
-    const int ctx = av1_get_skip_context(xd);
-    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-    const int skip = aom_read_symbol(r, ec_ctx->skip_cdfs[ctx], 2, ACCT_STR);
-    return skip;
-  }
-}
-
-// Merge the sorted list of cached colors(cached_colors[0...n_cached_colors-1])
-// and the sorted list of transmitted colors(colors[n_cached_colors...n-1]) into
-// one single sorted list(colors[...]).
-static void merge_colors(uint16_t *colors, uint16_t *cached_colors,
-                         int n_colors, int n_cached_colors) {
-  if (n_cached_colors == 0) return;
-  int cache_idx = 0, trans_idx = n_cached_colors;
-  for (int i = 0; i < n_colors; ++i) {
-    if (cache_idx < n_cached_colors &&
-        (trans_idx >= n_colors ||
-         cached_colors[cache_idx] <= colors[trans_idx])) {
-      colors[i] = cached_colors[cache_idx++];
-    } else {
-      assert(trans_idx < n_colors);
-      colors[i] = colors[trans_idx++];
-    }
-  }
-}
-
-static void read_palette_colors_y(MACROBLOCKD *const xd, int bit_depth,
-                                  PALETTE_MODE_INFO *const pmi, aom_reader *r) {
-  uint16_t color_cache[2 * PALETTE_MAX_SIZE];
-  uint16_t cached_colors[PALETTE_MAX_SIZE];
-  const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
-  const int n = pmi->palette_size[0];
-  int idx = 0;
-  for (int i = 0; i < n_cache && idx < n; ++i)
-    if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
-  if (idx < n) {
-    const int n_cached_colors = idx;
-    pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
-    if (idx < n) {
-      const int min_bits = bit_depth - 3;
-      int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
-      int range = (1 << bit_depth) - pmi->palette_colors[idx - 1] - 1;
-      for (; idx < n; ++idx) {
-        assert(range >= 0);
-        const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
-        pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
-                                         0, (1 << bit_depth) - 1);
-        range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
-        bits = AOMMIN(bits, av1_ceil_log2(range));
-      }
-    }
-    merge_colors(pmi->palette_colors, cached_colors, n, n_cached_colors);
-  } else {
-    memcpy(pmi->palette_colors, cached_colors, n * sizeof(cached_colors[0]));
-  }
-}
-
-static void read_palette_colors_uv(MACROBLOCKD *const xd, int bit_depth,
-                                   PALETTE_MODE_INFO *const pmi,
-                                   aom_reader *r) {
-  const int n = pmi->palette_size[1];
-  // U channel colors.
-  uint16_t color_cache[2 * PALETTE_MAX_SIZE];
-  uint16_t cached_colors[PALETTE_MAX_SIZE];
-  const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
-  int idx = 0;
-  for (int i = 0; i < n_cache && idx < n; ++i)
-    if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
-  if (idx < n) {
-    const int n_cached_colors = idx;
-    idx += PALETTE_MAX_SIZE;
-    pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
-    if (idx < PALETTE_MAX_SIZE + n) {
-      const int min_bits = bit_depth - 3;
-      int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
-      int range = (1 << bit_depth) - pmi->palette_colors[idx - 1];
-      for (; idx < PALETTE_MAX_SIZE + n; ++idx) {
-        assert(range >= 0);
-        const int delta = aom_read_literal(r, bits, ACCT_STR);
-        pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
-                                         0, (1 << bit_depth) - 1);
-        range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
-        bits = AOMMIN(bits, av1_ceil_log2(range));
-      }
-    }
-    merge_colors(pmi->palette_colors + PALETTE_MAX_SIZE, cached_colors, n,
-                 n_cached_colors);
-  } else {
-    memcpy(pmi->palette_colors + PALETTE_MAX_SIZE, cached_colors,
-           n * sizeof(cached_colors[0]));
-  }
-
-  // V channel colors.
-  if (aom_read_bit(r, ACCT_STR)) {  // Delta encoding.
-    const int min_bits_v = bit_depth - 4;
-    const int max_val = 1 << bit_depth;
-    int bits = min_bits_v + aom_read_literal(r, 2, ACCT_STR);
-    pmi->palette_colors[2 * PALETTE_MAX_SIZE] =
-        aom_read_literal(r, bit_depth, ACCT_STR);
-    for (int i = 1; i < n; ++i) {
-      int delta = aom_read_literal(r, bits, ACCT_STR);
-      if (delta && aom_read_bit(r, ACCT_STR)) delta = -delta;
-      int val = (int)pmi->palette_colors[2 * PALETTE_MAX_SIZE + i - 1] + delta;
-      if (val < 0) val += max_val;
-      if (val >= max_val) val -= max_val;
-      pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] = val;
-    }
-  } else {
-    for (int i = 0; i < n; ++i) {
-      pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
-          aom_read_literal(r, bit_depth, ACCT_STR);
-    }
-  }
-}
-
-static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                                   int mi_row, int mi_col, aom_reader *r) {
-  const int num_planes = av1_num_planes(cm);
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  assert(av1_allow_palette(cm->allow_screen_content_tools, bsize));
-  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
-  const int bsize_ctx = av1_get_palette_bsize_ctx(bsize);
-
-  if (mbmi->mode == DC_PRED) {
-    const int palette_mode_ctx = av1_get_palette_mode_ctx(xd);
-    const int modev = aom_read_symbol(
-        r, xd->tile_ctx->palette_y_mode_cdf[bsize_ctx][palette_mode_ctx], 2,
-        ACCT_STR);
-    if (modev) {
-      pmi->palette_size[0] =
-          aom_read_symbol(r, xd->tile_ctx->palette_y_size_cdf[bsize_ctx],
-                          PALETTE_SIZES, ACCT_STR) +
-          2;
-      read_palette_colors_y(xd, cm->seq_params.bit_depth, pmi, r);
-    }
-  }
-  if (num_planes > 1 && mbmi->uv_mode == UV_DC_PRED &&
-      is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x,
-                          xd->plane[1].subsampling_y)) {
-    const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
-    const int modev = aom_read_symbol(
-        r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR);
-    if (modev) {
-      pmi->palette_size[1] =
-          aom_read_symbol(r, xd->tile_ctx->palette_uv_size_cdf[bsize_ctx],
-                          PALETTE_SIZES, ACCT_STR) +
-          2;
-      read_palette_colors_uv(xd, cm->seq_params.bit_depth, pmi, r);
-    }
-  }
-}
-
-static int read_angle_delta(aom_reader *r, aom_cdf_prob *cdf) {
-  const int sym = aom_read_symbol(r, cdf, 2 * MAX_ANGLE_DELTA + 1, ACCT_STR);
-  return sym - MAX_ANGLE_DELTA;
-}
-
-static void read_filter_intra_mode_info(const AV1_COMMON *const cm,
-                                        MACROBLOCKD *const xd, aom_reader *r) {
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
-      &mbmi->filter_intra_mode_info;
-
-  if (av1_filter_intra_allowed(cm, mbmi)) {
-    filter_intra_mode_info->use_filter_intra = aom_read_symbol(
-        r, xd->tile_ctx->filter_intra_cdfs[mbmi->sb_type], 2, ACCT_STR);
-    if (filter_intra_mode_info->use_filter_intra) {
-      filter_intra_mode_info->filter_intra_mode = aom_read_symbol(
-          r, xd->tile_ctx->filter_intra_mode_cdf, FILTER_INTRA_MODES, ACCT_STR);
-    }
-  } else {
-    filter_intra_mode_info->use_filter_intra = 0;
-  }
-}
-
-void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row,
-                      int blk_col, TX_SIZE tx_size, aom_reader *r) {
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  const int txk_type_idx =
-      av1_get_txk_type_index(mbmi->sb_type, blk_row, blk_col);
-  TX_TYPE *tx_type = &mbmi->txk_type[txk_type_idx];
-  *tx_type = DCT_DCT;
-
-  // No need to read transform type if block is skipped.
-  if (mbmi->skip || segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP))
-    return;
-
-  // No need to read transform type for lossless mode(qindex==0).
-  const int qindex =
-      cm->seg.enabled ? xd->qindex[mbmi->segment_id] : cm->base_qindex;
-  if (qindex <= 0) return;
-
-  const int inter_block = is_inter_block(mbmi);
-  if (get_ext_tx_types(tx_size, inter_block, cm->reduced_tx_set_used) > 1) {
-    const TxSetType tx_set_type =
-        av1_get_ext_tx_set_type(tx_size, inter_block, cm->reduced_tx_set_used);
-    const int eset =
-        get_ext_tx_set(tx_size, inter_block, cm->reduced_tx_set_used);
-    // eset == 0 should correspond to a set with only DCT_DCT and
-    // there is no need to read the tx_type
-    assert(eset != 0);
-
-    const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
-    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-    if (inter_block) {
-      *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol(
-          r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size],
-          av1_num_ext_tx_set[tx_set_type], ACCT_STR)];
-    } else {
-      const PREDICTION_MODE intra_mode =
-          mbmi->filter_intra_mode_info.use_filter_intra
-              ? fimode_to_intradir[mbmi->filter_intra_mode_info
-                                       .filter_intra_mode]
-              : mbmi->mode;
-      *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol(
-          r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_mode],
-          av1_num_ext_tx_set[tx_set_type], ACCT_STR)];
-    }
-  }
-}
-
-static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref,
-                           nmv_context *ctx, MvSubpelPrecision precision);
-
-static INLINE int is_mv_valid(const MV *mv);
-
-static INLINE int assign_dv(AV1_COMMON *cm, MACROBLOCKD *xd, int_mv *mv,
-                            const int_mv *ref_mv, int mi_row, int mi_col,
-                            BLOCK_SIZE bsize, aom_reader *r) {
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  read_mv(r, &mv->as_mv, &ref_mv->as_mv, &ec_ctx->ndvc, MV_SUBPEL_NONE);
-  // DV should not have sub-pel.
-  assert((mv->as_mv.col & 7) == 0);
-  assert((mv->as_mv.row & 7) == 0);
-  mv->as_mv.col = (mv->as_mv.col >> 3) * 8;
-  mv->as_mv.row = (mv->as_mv.row >> 3) * 8;
-  int valid = is_mv_valid(&mv->as_mv) &&
-              av1_is_dv_valid(mv->as_mv, cm, xd, mi_row, mi_col, bsize,
-                              cm->seq_params.mib_size_log2);
-  return valid;
-}
-
-static void read_intrabc_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                              int mi_row, int mi_col, aom_reader *r) {
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  mbmi->use_intrabc = aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_STR);
-  if (mbmi->use_intrabc) {
-    BLOCK_SIZE bsize = mbmi->sb_type;
-    mbmi->mode = DC_PRED;
-    mbmi->uv_mode = UV_DC_PRED;
-    mbmi->interp_filters = av1_broadcast_interp_filter(BILINEAR);
-    mbmi->motion_mode = SIMPLE_TRANSLATION;
-
-    int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES];
-    int_mv ref_mvs[INTRA_FRAME + 1][MAX_MV_REF_CANDIDATES];
-    int_mv global_mvs[REF_FRAMES];
-
-    av1_find_mv_refs(cm, xd, mbmi, INTRA_FRAME, xd->ref_mv_count,
-                     xd->ref_mv_stack, ref_mvs, global_mvs, mi_row, mi_col,
-                     inter_mode_ctx);
-
-    int_mv nearestmv, nearmv;
-
-    av1_find_best_ref_mvs(0, ref_mvs[INTRA_FRAME], &nearestmv, &nearmv, 0);
-    int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv;
-    if (dv_ref.as_int == 0)
-      av1_find_ref_dv(&dv_ref, &xd->tile, cm->seq_params.mib_size, mi_row,
-                      mi_col);
-    // Ref DV should not have sub-pel.
-    int valid_dv = (dv_ref.as_mv.col & 7) == 0 && (dv_ref.as_mv.row & 7) == 0;
-    dv_ref.as_mv.col = (dv_ref.as_mv.col >> 3) * 8;
-    dv_ref.as_mv.row = (dv_ref.as_mv.row >> 3) * 8;
-    valid_dv = valid_dv && assign_dv(cm, xd, &mbmi->mv[0], &dv_ref, mi_row,
-                                     mi_col, bsize, r);
-    if (!valid_dv) {
-      // Intra bc motion vectors are not valid - signal corrupt frame
-      aom_merge_corrupted_flag(&xd->corrupted, 1);
-    }
-  }
-}
-
-// If delta q is present, reads delta_q index.
-// Also reads delta_q loop filter levels, if present.
-static void read_delta_q_params(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                                const int mi_row, const int mi_col,
-                                aom_reader *r) {
-  if (cm->delta_q_present_flag) {
-    MB_MODE_INFO *const mbmi = xd->mi[0];
-    xd->current_qindex +=
-        read_delta_qindex(cm, xd, r, mbmi, mi_col, mi_row) * cm->delta_q_res;
-    /* Normative: Clamp to [1,MAXQ] to not interfere with lossless mode */
-    xd->current_qindex = clamp(xd->current_qindex, 1, MAXQ);
-    FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
-    if (cm->delta_lf_present_flag) {
-      if (cm->delta_lf_multi) {
-        const int frame_lf_count =
-            av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
-        for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) {
-          const int tmp_lvl =
-              xd->delta_lf[lf_id] +
-              read_delta_lflevel(cm, r, ec_ctx->delta_lf_multi_cdf[lf_id], mbmi,
-                                 mi_col, mi_row) *
-                  cm->delta_lf_res;
-          mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id] =
-              clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER);
-        }
-      } else {
-        const int tmp_lvl = xd->delta_lf_from_base +
-                            read_delta_lflevel(cm, r, ec_ctx->delta_lf_cdf,
-                                               mbmi, mi_col, mi_row) *
-                                cm->delta_lf_res;
-        mbmi->delta_lf_from_base = xd->delta_lf_from_base =
-            clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER);
-      }
-    }
-  }
-}
-
-static void read_intra_frame_mode_info(AV1_COMMON *const cm,
-                                       MACROBLOCKD *const xd, int mi_row,
-                                       int mi_col, aom_reader *r) {
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  const MB_MODE_INFO *above_mi = xd->above_mbmi;
-  const MB_MODE_INFO *left_mi = xd->left_mbmi;
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  struct segmentation *const seg = &cm->seg;
-
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-
-  if (seg->segid_preskip)
-    mbmi->segment_id =
-        read_intra_segment_id(cm, xd, mi_row, mi_col, bsize, r, 0);
-
-  mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
-
-  if (!seg->segid_preskip)
-    mbmi->segment_id =
-        read_intra_segment_id(cm, xd, mi_row, mi_col, bsize, r, mbmi->skip);
-
-  read_cdef(cm, r, xd, mi_col, mi_row);
-
-  read_delta_q_params(cm, xd, mi_row, mi_col, r);
-
-  mbmi->current_qindex = xd->current_qindex;
-
-  mbmi->ref_frame[0] = INTRA_FRAME;
-  mbmi->ref_frame[1] = NONE_FRAME;
-  mbmi->palette_mode_info.palette_size[0] = 0;
-  mbmi->palette_mode_info.palette_size[1] = 0;
-  mbmi->filter_intra_mode_info.use_filter_intra = 0;
-
-  xd->above_txfm_context = cm->above_txfm_context[xd->tile.tile_row] + mi_col;
-  xd->left_txfm_context =
-      xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
-
-  if (av1_allow_intrabc(cm)) {
-    read_intrabc_info(cm, xd, mi_row, mi_col, r);
-    if (is_intrabc_block(mbmi)) return;
-  }
-
-  mbmi->mode = read_intra_mode(r, get_y_mode_cdf(ec_ctx, above_mi, left_mi));
-
-  const int use_angle_delta = av1_use_angle_delta(bsize);
-  mbmi->angle_delta[PLANE_TYPE_Y] =
-      (use_angle_delta && av1_is_directional_mode(mbmi->mode))
-          ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
-          : 0;
-
-  if (!cm->seq_params.monochrome &&
-      is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x,
-                          xd->plane[1].subsampling_y)) {
-    xd->cfl.is_chroma_reference = 1;
-    mbmi->uv_mode =
-        read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode);
-    if (mbmi->uv_mode == UV_CFL_PRED) {
-      mbmi->cfl_alpha_idx = read_cfl_alphas(ec_ctx, r, &mbmi->cfl_alpha_signs);
-    }
-    mbmi->angle_delta[PLANE_TYPE_UV] =
-        (use_angle_delta && av1_is_directional_mode(get_uv_mode(mbmi->uv_mode)))
-            ? read_angle_delta(r,
-                               ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED])
-            : 0;
-  } else {
-    // Avoid decoding angle_info if there is is no chroma prediction
-    mbmi->uv_mode = UV_DC_PRED;
-    xd->cfl.is_chroma_reference = 0;
-  }
-  xd->cfl.store_y = store_cfl_required(cm, xd);
-
-  if (av1_allow_palette(cm->allow_screen_content_tools, bsize))
-    read_palette_mode_info(cm, xd, mi_row, mi_col, r);
-
-  read_filter_intra_mode_info(cm, xd, r);
-}
-
-static int read_mv_component(aom_reader *r, nmv_component *mvcomp,
-                             int use_subpel, int usehp) {
-  int mag, d, fr, hp;
-  const int sign = aom_read_symbol(r, mvcomp->sign_cdf, 2, ACCT_STR);
-  const int mv_class =
-      aom_read_symbol(r, mvcomp->classes_cdf, MV_CLASSES, ACCT_STR);
-  const int class0 = mv_class == MV_CLASS_0;
-
-  // Integer part
-  if (class0) {
-    d = aom_read_symbol(r, mvcomp->class0_cdf, CLASS0_SIZE, ACCT_STR);
-    mag = 0;
-  } else {
-    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
-    d = 0;
-    for (int i = 0; i < n; ++i)
-      d |= aom_read_symbol(r, mvcomp->bits_cdf[i], 2, ACCT_STR) << i;
-    mag = CLASS0_SIZE << (mv_class + 2);
-  }
-
-  if (use_subpel) {
-    // Fractional part
-    fr = aom_read_symbol(r, class0 ? mvcomp->class0_fp_cdf[d] : mvcomp->fp_cdf,
-                         MV_FP_SIZE, ACCT_STR);
-
-    // High precision part (if hp is not used, the default value of the hp is 1)
-    hp = usehp ? aom_read_symbol(
-                     r, class0 ? mvcomp->class0_hp_cdf : mvcomp->hp_cdf, 2,
-                     ACCT_STR)
-               : 1;
-  } else {
-    fr = 3;
-    hp = 1;
-  }
-
-  // Result
-  mag += ((d << 3) | (fr << 1) | hp) + 1;
-  return sign ? -mag : mag;
-}
-
-static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref,
-                           nmv_context *ctx, MvSubpelPrecision precision) {
-  MV diff = kZeroMv;
-  const MV_JOINT_TYPE joint_type =
-      (MV_JOINT_TYPE)aom_read_symbol(r, ctx->joints_cdf, MV_JOINTS, ACCT_STR);
-
-  if (mv_joint_vertical(joint_type))
-    diff.row = read_mv_component(r, &ctx->comps[0], precision > MV_SUBPEL_NONE,
-                                 precision > MV_SUBPEL_LOW_PRECISION);
-
-  if (mv_joint_horizontal(joint_type))
-    diff.col = read_mv_component(r, &ctx->comps[1], precision > MV_SUBPEL_NONE,
-                                 precision > MV_SUBPEL_LOW_PRECISION);
-
-  mv->row = ref->row + diff.row;
-  mv->col = ref->col + diff.col;
-}
-
-static REFERENCE_MODE read_block_reference_mode(AV1_COMMON *cm,
-                                                const MACROBLOCKD *xd,
-                                                aom_reader *r) {
-  if (!is_comp_ref_allowed(xd->mi[0]->sb_type)) return SINGLE_REFERENCE;
-  if (cm->reference_mode == REFERENCE_MODE_SELECT) {
-    const int ctx = av1_get_reference_mode_context(xd);
-    const REFERENCE_MODE mode = (REFERENCE_MODE)aom_read_symbol(
-        r, xd->tile_ctx->comp_inter_cdf[ctx], 2, ACCT_STR);
-    return mode;  // SINGLE_REFERENCE or COMPOUND_REFERENCE
-  } else {
-    assert(cm->reference_mode == SINGLE_REFERENCE);
-    return cm->reference_mode;
-  }
-}
-
-#define READ_REF_BIT(pname) \
-  aom_read_symbol(r, av1_get_pred_cdf_##pname(xd), 2, ACCT_STR)
-
-static COMP_REFERENCE_TYPE read_comp_reference_type(const MACROBLOCKD *xd,
-                                                    aom_reader *r) {
-  const int ctx = av1_get_comp_reference_type_context(xd);
-  const COMP_REFERENCE_TYPE comp_ref_type =
-      (COMP_REFERENCE_TYPE)aom_read_symbol(
-          r, xd->tile_ctx->comp_ref_type_cdf[ctx], 2, ACCT_STR);
-  return comp_ref_type;  // UNIDIR_COMP_REFERENCE or BIDIR_COMP_REFERENCE
-}
-
-static void set_ref_frames_for_skip_mode(AV1_COMMON *const cm,
-                                         MV_REFERENCE_FRAME ref_frame[2]) {
-  ref_frame[0] = LAST_FRAME + cm->ref_frame_idx_0;
-  ref_frame[1] = LAST_FRAME + cm->ref_frame_idx_1;
-}
-
-// Read the referncence frame
-static void read_ref_frames(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                            aom_reader *r, int segment_id,
-                            MV_REFERENCE_FRAME ref_frame[2]) {
-  if (xd->mi[0]->skip_mode) {
-    set_ref_frames_for_skip_mode(cm, ref_frame);
-    return;
-  }
-
-  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
-    ref_frame[0] = (MV_REFERENCE_FRAME)get_segdata(&cm->seg, segment_id,
-                                                   SEG_LVL_REF_FRAME);
-    ref_frame[1] = NONE_FRAME;
-  } else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP) ||
-             segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
-    ref_frame[0] = LAST_FRAME;
-    ref_frame[1] = NONE_FRAME;
-  } else {
-    const REFERENCE_MODE mode = read_block_reference_mode(cm, xd, r);
-
-    if (mode == COMPOUND_REFERENCE) {
-      const COMP_REFERENCE_TYPE comp_ref_type = read_comp_reference_type(xd, r);
-
-      if (comp_ref_type == UNIDIR_COMP_REFERENCE) {
-        const int bit = READ_REF_BIT(uni_comp_ref_p);
-        if (bit) {
-          ref_frame[0] = BWDREF_FRAME;
-          ref_frame[1] = ALTREF_FRAME;
-        } else {
-          const int bit1 = READ_REF_BIT(uni_comp_ref_p1);
-          if (bit1) {
-            const int bit2 = READ_REF_BIT(uni_comp_ref_p2);
-            if (bit2) {
-              ref_frame[0] = LAST_FRAME;
-              ref_frame[1] = GOLDEN_FRAME;
-            } else {
-              ref_frame[0] = LAST_FRAME;
-              ref_frame[1] = LAST3_FRAME;
-            }
-          } else {
-            ref_frame[0] = LAST_FRAME;
-            ref_frame[1] = LAST2_FRAME;
-          }
-        }
-
-        return;
-      }
-
-      assert(comp_ref_type == BIDIR_COMP_REFERENCE);
-
-      const int idx = 1;
-      const int bit = READ_REF_BIT(comp_ref_p);
-      // Decode forward references.
-      if (!bit) {
-        const int bit1 = READ_REF_BIT(comp_ref_p1);
-        ref_frame[!idx] = cm->comp_fwd_ref[bit1 ? 1 : 0];
-      } else {
-        const int bit2 = READ_REF_BIT(comp_ref_p2);
-        ref_frame[!idx] = cm->comp_fwd_ref[bit2 ? 3 : 2];
-      }
-
-      // Decode backward references.
-      const int bit_bwd = READ_REF_BIT(comp_bwdref_p);
-      if (!bit_bwd) {
-        const int bit1_bwd = READ_REF_BIT(comp_bwdref_p1);
-        ref_frame[idx] = cm->comp_bwd_ref[bit1_bwd];
-      } else {
-        ref_frame[idx] = cm->comp_bwd_ref[2];
-      }
-    } else if (mode == SINGLE_REFERENCE) {
-      const int bit0 = READ_REF_BIT(single_ref_p1);
-      if (bit0) {
-        const int bit1 = READ_REF_BIT(single_ref_p2);
-        if (!bit1) {
-          const int bit5 = READ_REF_BIT(single_ref_p6);
-          ref_frame[0] = bit5 ? ALTREF2_FRAME : BWDREF_FRAME;
-        } else {
-          ref_frame[0] = ALTREF_FRAME;
-        }
-      } else {
-        const int bit2 = READ_REF_BIT(single_ref_p3);
-        if (bit2) {
-          const int bit4 = READ_REF_BIT(single_ref_p5);
-          ref_frame[0] = bit4 ? GOLDEN_FRAME : LAST3_FRAME;
-        } else {
-          const int bit3 = READ_REF_BIT(single_ref_p4);
-          ref_frame[0] = bit3 ? LAST2_FRAME : LAST_FRAME;
-        }
-      }
-
-      ref_frame[1] = NONE_FRAME;
-    } else {
-      assert(0 && "Invalid prediction mode.");
-    }
-  }
-}
-
-static INLINE void read_mb_interp_filter(AV1_COMMON *const cm,
-                                         MACROBLOCKD *const xd,
-                                         MB_MODE_INFO *const mbmi,
-                                         aom_reader *r) {
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-
-  if (!av1_is_interp_needed(xd)) {
-    set_default_interp_filters(mbmi, cm->interp_filter);
-    return;
-  }
-
-  if (cm->interp_filter != SWITCHABLE) {
-    mbmi->interp_filters = av1_broadcast_interp_filter(cm->interp_filter);
-  } else {
-    InterpFilter ref0_filter[2] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
-    for (int dir = 0; dir < 2; ++dir) {
-      const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
-      ref0_filter[dir] = (InterpFilter)aom_read_symbol(
-          r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS, ACCT_STR);
-      if (cm->seq_params.enable_dual_filter == 0) {
-        ref0_filter[1] = ref0_filter[0];
-        break;
-      }
-    }
-    // The index system works as: (0, 1) -> (vertical, horizontal) filter types
-    mbmi->interp_filters =
-        av1_make_interp_filters(ref0_filter[0], ref0_filter[1]);
-  }
-}
-
-static void read_intra_block_mode_info(AV1_COMMON *const cm, const int mi_row,
-                                       const int mi_col, MACROBLOCKD *const xd,
-                                       MB_MODE_INFO *const mbmi,
-                                       aom_reader *r) {
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  const int use_angle_delta = av1_use_angle_delta(bsize);
-
-  mbmi->ref_frame[0] = INTRA_FRAME;
-  mbmi->ref_frame[1] = NONE_FRAME;
-
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-
-  mbmi->mode = read_intra_mode(r, ec_ctx->y_mode_cdf[size_group_lookup[bsize]]);
-
-  mbmi->angle_delta[PLANE_TYPE_Y] =
-      use_angle_delta && av1_is_directional_mode(mbmi->mode)
-          ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
-          : 0;
-  const int has_chroma =
-      is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x,
-                          xd->plane[1].subsampling_y);
-  xd->cfl.is_chroma_reference = has_chroma;
-  if (!cm->seq_params.monochrome && has_chroma) {
-    mbmi->uv_mode =
-        read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode);
-    if (mbmi->uv_mode == UV_CFL_PRED) {
-      mbmi->cfl_alpha_idx =
-          read_cfl_alphas(xd->tile_ctx, r, &mbmi->cfl_alpha_signs);
-    }
-    mbmi->angle_delta[PLANE_TYPE_UV] =
-        use_angle_delta && av1_is_directional_mode(get_uv_mode(mbmi->uv_mode))
-            ? read_angle_delta(r,
-                               ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED])
-            : 0;
-  } else {
-    // Avoid decoding angle_info if there is is no chroma prediction
-    mbmi->uv_mode = UV_DC_PRED;
-  }
-  xd->cfl.store_y = store_cfl_required(cm, xd);
-
-  mbmi->palette_mode_info.palette_size[0] = 0;
-  mbmi->palette_mode_info.palette_size[1] = 0;
-  if (av1_allow_palette(cm->allow_screen_content_tools, bsize))
-    read_palette_mode_info(cm, xd, mi_row, mi_col, r);
-
-  read_filter_intra_mode_info(cm, xd, r);
-}
-
-static INLINE int is_mv_valid(const MV *mv) {
-  return mv->row > MV_LOW && mv->row < MV_UPP && mv->col > MV_LOW &&
-         mv->col < MV_UPP;
-}
-
-static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd,
-                            PREDICTION_MODE mode,
-                            MV_REFERENCE_FRAME ref_frame[2], int_mv mv[2],
-                            int_mv ref_mv[2], int_mv nearest_mv[2],
-                            int_mv near_mv[2], int mi_row, int mi_col,
-                            int is_compound, int allow_hp, aom_reader *r) {
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  MB_MODE_INFO *mbmi = xd->mi[0];
-  BLOCK_SIZE bsize = mbmi->sb_type;
-  if (cm->cur_frame_force_integer_mv) {
-    allow_hp = MV_SUBPEL_NONE;
-  }
-  switch (mode) {
-    case NEWMV: {
-      nmv_context *const nmvc = &ec_ctx->nmvc;
-      read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp);
-      break;
-    }
-    case NEARESTMV: {
-      mv[0].as_int = nearest_mv[0].as_int;
-      break;
-    }
-    case NEARMV: {
-      mv[0].as_int = near_mv[0].as_int;
-      break;
-    }
-    case GLOBALMV: {
-      mv[0].as_int =
-          gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
-                               cm->allow_high_precision_mv, bsize, mi_col,
-                               mi_row, cm->cur_frame_force_integer_mv)
-              .as_int;
-      break;
-    }
-    case NEW_NEWMV: {
-      assert(is_compound);
-      for (int i = 0; i < 2; ++i) {
-        nmv_context *const nmvc = &ec_ctx->nmvc;
-        read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, nmvc, allow_hp);
-      }
-      break;
-    }
-    case NEAREST_NEARESTMV: {
-      assert(is_compound);
-      mv[0].as_int = nearest_mv[0].as_int;
-      mv[1].as_int = nearest_mv[1].as_int;
-      break;
-    }
-    case NEAR_NEARMV: {
-      assert(is_compound);
-      mv[0].as_int = near_mv[0].as_int;
-      mv[1].as_int = near_mv[1].as_int;
-      break;
-    }
-    case NEW_NEARESTMV: {
-      nmv_context *const nmvc = &ec_ctx->nmvc;
-      read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp);
-      assert(is_compound);
-      mv[1].as_int = nearest_mv[1].as_int;
-      break;
-    }
-    case NEAREST_NEWMV: {
-      nmv_context *const nmvc = &ec_ctx->nmvc;
-      mv[0].as_int = nearest_mv[0].as_int;
-      read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, allow_hp);
-      assert(is_compound);
-      break;
-    }
-    case NEAR_NEWMV: {
-      nmv_context *const nmvc = &ec_ctx->nmvc;
-      mv[0].as_int = near_mv[0].as_int;
-      read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, allow_hp);
-      assert(is_compound);
-      break;
-    }
-    case NEW_NEARMV: {
-      nmv_context *const nmvc = &ec_ctx->nmvc;
-      read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp);
-      assert(is_compound);
-      mv[1].as_int = near_mv[1].as_int;
-      break;
-    }
-    case GLOBAL_GLOBALMV: {
-      assert(is_compound);
-      mv[0].as_int =
-          gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
-                               cm->allow_high_precision_mv, bsize, mi_col,
-                               mi_row, cm->cur_frame_force_integer_mv)
-              .as_int;
-      mv[1].as_int =
-          gm_get_motion_vector(&cm->global_motion[ref_frame[1]],
-                               cm->allow_high_precision_mv, bsize, mi_col,
-                               mi_row, cm->cur_frame_force_integer_mv)
-              .as_int;
-      break;
-    }
-    default: { return 0; }
-  }
-
-  int ret = is_mv_valid(&mv[0].as_mv);
-  if (is_compound) {
-    ret = ret && is_mv_valid(&mv[1].as_mv);
-  }
-  return ret;
-}
-
-static int read_is_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                               int segment_id, aom_reader *r) {
-  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
-    const int frame = get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME);
-    if (frame < LAST_FRAME) return 0;
-    return frame != INTRA_FRAME;
-  }
-  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
-    return 1;
-  }
-  const int ctx = av1_get_intra_inter_context(xd);
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-  const int is_inter =
-      aom_read_symbol(r, ec_ctx->intra_inter_cdf[ctx], 2, ACCT_STR);
-  return is_inter;
-}
-
-#if DEC_MISMATCH_DEBUG
-static void dec_dump_logs(AV1_COMMON *cm, MB_MODE_INFO *const mbmi, int mi_row,
-                          int mi_col, int16_t mode_ctx) {
-  int_mv mv[2] = { { 0 } };
-  for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref)
-    mv[ref].as_mv = mbmi->mv[ref].as_mv;
-
-  const int16_t newmv_ctx = mode_ctx & NEWMV_CTX_MASK;
-  int16_t zeromv_ctx = -1;
-  int16_t refmv_ctx = -1;
-  if (mbmi->mode != NEWMV) {
-    zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
-    if (mbmi->mode != GLOBALMV)
-      refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
-  }
-
-#define FRAME_TO_CHECK 11
-  if (cm->current_video_frame == FRAME_TO_CHECK && cm->show_frame == 1) {
-    printf(
-        "=== DECODER ===: "
-        "Frame=%d, (mi_row,mi_col)=(%d,%d), skip_mode=%d, mode=%d, bsize=%d, "
-        "show_frame=%d, mv[0]=(%d,%d), mv[1]=(%d,%d), ref[0]=%d, "
-        "ref[1]=%d, motion_mode=%d, mode_ctx=%d, "
-        "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d, tx_size=%d\n",
-        cm->current_video_frame, mi_row, mi_col, mbmi->skip_mode, mbmi->mode,
-        mbmi->sb_type, cm->show_frame, mv[0].as_mv.row, mv[0].as_mv.col,
-        mv[1].as_mv.row, mv[1].as_mv.col, mbmi->ref_frame[0],
-        mbmi->ref_frame[1], mbmi->motion_mode, mode_ctx, newmv_ctx, zeromv_ctx,
-        refmv_ctx, mbmi->tx_size);
-  }
-}
-#endif  // DEC_MISMATCH_DEBUG
-
-static void read_inter_block_mode_info(AV1Decoder *const pbi,
-                                       MACROBLOCKD *const xd,
-                                       MB_MODE_INFO *const mbmi, int mi_row,
-                                       int mi_col, aom_reader *r) {
-  AV1_COMMON *const cm = &pbi->common;
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  const int allow_hp = cm->allow_high_precision_mv;
-  int_mv nearestmv[2], nearmv[2];
-  int_mv ref_mvs[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES] = { { { 0 } } };
-  int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES];
-  int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
-  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
-
-  mbmi->uv_mode = UV_DC_PRED;
-  mbmi->palette_mode_info.palette_size[0] = 0;
-  mbmi->palette_mode_info.palette_size[1] = 0;
-
-  av1_collect_neighbors_ref_counts(xd);
-
-  read_ref_frames(cm, xd, r, mbmi->segment_id, mbmi->ref_frame);
-  const int is_compound = has_second_ref(mbmi);
-
-  MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame);
-  int_mv global_mvs[REF_FRAMES];
-  av1_find_mv_refs(cm, xd, mbmi, ref_frame, xd->ref_mv_count, xd->ref_mv_stack,
-                   ref_mvs, global_mvs, mi_row, mi_col, inter_mode_ctx);
-
-  int mode_ctx = av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame);
-  mbmi->ref_mv_idx = 0;
-
-  if (mbmi->skip_mode) {
-    assert(is_compound);
-    mbmi->mode = NEAREST_NEARESTMV;
-  } else {
-    if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP) ||
-        segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_GLOBALMV)) {
-      mbmi->mode = GLOBALMV;
-    } else {
-      if (is_compound)
-        mbmi->mode = read_inter_compound_mode(xd, r, mode_ctx);
-      else
-        mbmi->mode = read_inter_mode(ec_ctx, r, mode_ctx);
-      if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV ||
-          have_nearmv_in_inter_mode(mbmi->mode))
-        read_drl_idx(ec_ctx, xd, mbmi, r);
-    }
-  }
-
-  if (is_compound != is_inter_compound_mode(mbmi->mode)) {
-    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
-                       "Prediction mode %d invalid with ref frame %d %d",
-                       mbmi->mode, mbmi->ref_frame[0], mbmi->ref_frame[1]);
-  }
-
-  if (!is_compound && mbmi->mode != GLOBALMV) {
-    av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[0]], &nearestmv[0],
-                          &nearmv[0], cm->cur_frame_force_integer_mv);
-  }
-
-  if (is_compound && mbmi->mode != GLOBAL_GLOBALMV) {
-    int ref_mv_idx = mbmi->ref_mv_idx + 1;
-    nearestmv[0] = xd->ref_mv_stack[ref_frame][0].this_mv;
-    nearestmv[1] = xd->ref_mv_stack[ref_frame][0].comp_mv;
-    nearmv[0] = xd->ref_mv_stack[ref_frame][ref_mv_idx].this_mv;
-    nearmv[1] = xd->ref_mv_stack[ref_frame][ref_mv_idx].comp_mv;
-    lower_mv_precision(&nearestmv[0].as_mv, allow_hp,
-                       cm->cur_frame_force_integer_mv);
-    lower_mv_precision(&nearestmv[1].as_mv, allow_hp,
-                       cm->cur_frame_force_integer_mv);
-    lower_mv_precision(&nearmv[0].as_mv, allow_hp,
-                       cm->cur_frame_force_integer_mv);
-    lower_mv_precision(&nearmv[1].as_mv, allow_hp,
-                       cm->cur_frame_force_integer_mv);
-  } else if (mbmi->ref_mv_idx > 0 && mbmi->mode == NEARMV) {
-    int_mv cur_mv =
-        xd->ref_mv_stack[mbmi->ref_frame[0]][1 + mbmi->ref_mv_idx].this_mv;
-    nearmv[0] = cur_mv;
-  }
-
-  int_mv ref_mv[2];
-  ref_mv[0] = nearestmv[0];
-  ref_mv[1] = nearestmv[1];
-
-  if (is_compound) {
-    int ref_mv_idx = mbmi->ref_mv_idx;
-    // Special case: NEAR_NEWMV and NEW_NEARMV modes use
-    // 1 + mbmi->ref_mv_idx (like NEARMV) instead of
-    // mbmi->ref_mv_idx (like NEWMV)
-    if (mbmi->mode == NEAR_NEWMV || mbmi->mode == NEW_NEARMV)
-      ref_mv_idx = 1 + mbmi->ref_mv_idx;
-
-    // TODO(jingning, yunqing): Do we need a lower_mv_precision() call here?
-    if (compound_ref0_mode(mbmi->mode) == NEWMV)
-      ref_mv[0] = xd->ref_mv_stack[ref_frame][ref_mv_idx].this_mv;
-
-    if (compound_ref1_mode(mbmi->mode) == NEWMV)
-      ref_mv[1] = xd->ref_mv_stack[ref_frame][ref_mv_idx].comp_mv;
-  } else {
-    if (mbmi->mode == NEWMV) {
-      if (xd->ref_mv_count[ref_frame] > 1)
-        ref_mv[0] = xd->ref_mv_stack[ref_frame][mbmi->ref_mv_idx].this_mv;
-    }
-  }
-
-  if (mbmi->skip_mode) {
-    assert(mbmi->mode == NEAREST_NEARESTMV);
-    mbmi->mv[0].as_int = nearestmv[0].as_int;
-    mbmi->mv[1].as_int = nearestmv[1].as_int;
-  } else {
-    int mv_corrupted_flag =
-        !assign_mv(cm, xd, mbmi->mode, mbmi->ref_frame, mbmi->mv, ref_mv,
-                   nearestmv, nearmv, mi_row, mi_col, is_compound, allow_hp, r);
-    aom_merge_corrupted_flag(&xd->corrupted, mv_corrupted_flag);
-  }
-
-  mbmi->use_wedge_interintra = 0;
-  if (cm->seq_params.enable_interintra_compound && !mbmi->skip_mode &&
-      is_interintra_allowed(mbmi)) {
-    const int bsize_group = size_group_lookup[bsize];
-    const int interintra =
-        aom_read_symbol(r, ec_ctx->interintra_cdf[bsize_group], 2, ACCT_STR);
-    assert(mbmi->ref_frame[1] == NONE_FRAME);
-    if (interintra) {
-      const INTERINTRA_MODE interintra_mode =
-          read_interintra_mode(xd, r, bsize_group);
-      mbmi->ref_frame[1] = INTRA_FRAME;
-      mbmi->interintra_mode = interintra_mode;
-      mbmi->angle_delta[PLANE_TYPE_Y] = 0;
-      mbmi->angle_delta[PLANE_TYPE_UV] = 0;
-      mbmi->filter_intra_mode_info.use_filter_intra = 0;
-      if (is_interintra_wedge_used(bsize)) {
-        mbmi->use_wedge_interintra = aom_read_symbol(
-            r, ec_ctx->wedge_interintra_cdf[bsize], 2, ACCT_STR);
-        if (mbmi->use_wedge_interintra) {
-          mbmi->interintra_wedge_index =
-              aom_read_symbol(r, ec_ctx->wedge_idx_cdf[bsize], 16, ACCT_STR);
-          mbmi->interintra_wedge_sign = 0;
-        }
-      }
-    }
-  }
-
-  for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
-    const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
-    RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];
-
-    xd->block_refs[ref] = ref_buf;
-  }
-
-  mbmi->motion_mode = SIMPLE_TRANSLATION;
-  if (is_motion_variation_allowed_bsize(mbmi->sb_type) && !mbmi->skip_mode &&
-      !has_second_ref(mbmi))
-    mbmi->num_proj_ref = findSamples(cm, xd, mi_row, mi_col, pts, pts_inref);
-  av1_count_overlappable_neighbors(cm, xd, mi_row, mi_col);
-
-  if (mbmi->ref_frame[1] != INTRA_FRAME)
-    mbmi->motion_mode = read_motion_mode(cm, xd, mbmi, r);
-
-  // init
-  mbmi->comp_group_idx = 0;
-  mbmi->compound_idx = 1;
-  mbmi->interinter_comp.type = COMPOUND_AVERAGE;
-
-  if (has_second_ref(mbmi) && !mbmi->skip_mode) {
-    // Read idx to indicate current compound inter prediction mode group
-    const int masked_compound_used = is_any_masked_compound_used(bsize) &&
-                                     cm->seq_params.enable_masked_compound;
-
-    if (masked_compound_used) {
-      const int ctx_comp_group_idx = get_comp_group_idx_context(xd);
-      mbmi->comp_group_idx = aom_read_symbol(
-          r, ec_ctx->comp_group_idx_cdf[ctx_comp_group_idx], 2, ACCT_STR);
-    }
-
-    if (mbmi->comp_group_idx == 0) {
-      if (cm->seq_params.enable_jnt_comp) {
-        const int comp_index_ctx = get_comp_index_context(cm, xd);
-        mbmi->compound_idx = aom_read_symbol(
-            r, ec_ctx->compound_index_cdf[comp_index_ctx], 2, ACCT_STR);
-      } else {
-        // Distance-weighted compound is disabled, so always use average
-        mbmi->compound_idx = 1;
-      }
-    } else {
-      assert(cm->reference_mode != SINGLE_REFERENCE &&
-             is_inter_compound_mode(mbmi->mode) &&
-             mbmi->motion_mode == SIMPLE_TRANSLATION);
-      assert(masked_compound_used);
-
-      // compound_diffwtd, wedge
-      if (is_interinter_compound_used(COMPOUND_WEDGE, bsize))
-        mbmi->interinter_comp.type =
-            1 + aom_read_symbol(r, ec_ctx->compound_type_cdf[bsize],
-                                COMPOUND_TYPES - 1, ACCT_STR);
-      else
-        mbmi->interinter_comp.type = COMPOUND_DIFFWTD;
-
-      if (mbmi->interinter_comp.type == COMPOUND_WEDGE) {
-        assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize));
-        mbmi->interinter_comp.wedge_index =
-            aom_read_symbol(r, ec_ctx->wedge_idx_cdf[bsize], 16, ACCT_STR);
-        mbmi->interinter_comp.wedge_sign = aom_read_bit(r, ACCT_STR);
-      } else {
-        assert(mbmi->interinter_comp.type == COMPOUND_DIFFWTD);
-        mbmi->interinter_comp.mask_type =
-            aom_read_literal(r, MAX_DIFFWTD_MASK_BITS, ACCT_STR);
-      }
-    }
-  }
-
-  read_mb_interp_filter(cm, xd, mbmi, r);
-
-  if (mbmi->motion_mode == WARPED_CAUSAL) {
-    mbmi->wm_params.wmtype = DEFAULT_WMTYPE;
-    mbmi->wm_params.invalid = 0;
-
-    if (mbmi->num_proj_ref > 1)
-      mbmi->num_proj_ref = selectSamples(&mbmi->mv[0].as_mv, pts, pts_inref,
-                                         mbmi->num_proj_ref, bsize);
-
-    if (find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize,
-                        mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col,
-                        &mbmi->wm_params, mi_row, mi_col)) {
-#if WARPED_MOTION_DEBUG
-      printf("Warning: unexpected warped model from aomenc\n");
-#endif
-      mbmi->wm_params.invalid = 1;
-    }
-  }
-
-  xd->cfl.is_chroma_reference =
-      is_chroma_reference(mi_row, mi_col, bsize, cm->seq_params.subsampling_x,
-                          cm->seq_params.subsampling_y);
-  xd->cfl.store_y = store_cfl_required(cm, xd);
-
-#if DEC_MISMATCH_DEBUG
-  dec_dump_logs(cm, mi, mi_row, mi_col, mode_ctx);
-#endif  // DEC_MISMATCH_DEBUG
-}
-
-static void read_inter_frame_mode_info(AV1Decoder *const pbi,
-                                       MACROBLOCKD *const xd, int mi_row,
-                                       int mi_col, aom_reader *r) {
-  AV1_COMMON *const cm = &pbi->common;
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  int inter_block = 1;
-
-  mbmi->mv[0].as_int = 0;
-  mbmi->mv[1].as_int = 0;
-  mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, 1, r);
-
-  mbmi->skip_mode = read_skip_mode(cm, xd, mbmi->segment_id, r);
-
-  if (mbmi->skip_mode)
-    mbmi->skip = 1;
-  else
-    mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
-
-  mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, 0, r);
-
-  read_cdef(cm, r, xd, mi_col, mi_row);
-
-  read_delta_q_params(cm, xd, mi_row, mi_col, r);
-
-  if (!mbmi->skip_mode)
-    inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
-
-  mbmi->current_qindex = xd->current_qindex;
-
-  xd->above_txfm_context = cm->above_txfm_context[xd->tile.tile_row] + mi_col;
-  xd->left_txfm_context =
-      xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
-
-  if (inter_block)
-    read_inter_block_mode_info(pbi, xd, mbmi, mi_row, mi_col, r);
-  else
-    read_intra_block_mode_info(cm, mi_row, mi_col, xd, mbmi, r);
-}
-
-static void intra_copy_frame_mvs(AV1_COMMON *const cm, int mi_row, int mi_col,
-                                 int x_mis, int y_mis) {
-  const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1);
-  MV_REF *frame_mvs =
-      cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1);
-  x_mis = ROUND_POWER_OF_TWO(x_mis, 1);
-  y_mis = ROUND_POWER_OF_TWO(y_mis, 1);
-
-  for (int h = 0; h < y_mis; h++) {
-    MV_REF *mv = frame_mvs;
-    for (int w = 0; w < x_mis; w++) {
-      mv->ref_frame = NONE_FRAME;
-      mv++;
-    }
-    frame_mvs += frame_mvs_stride;
-  }
-}
-
-void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, int mi_row,
-                        int mi_col, aom_reader *r, int x_mis, int y_mis) {
-  AV1_COMMON *const cm = &pbi->common;
-  MB_MODE_INFO *const mi = xd->mi[0];
-  mi->use_intrabc = 0;
-
-  if (frame_is_intra_only(cm)) {
-    read_intra_frame_mode_info(cm, xd, mi_row, mi_col, r);
-    intra_copy_frame_mvs(cm, mi_row, mi_col, x_mis, y_mis);
-  } else {
-    read_inter_frame_mode_info(pbi, xd, mi_row, mi_col, r);
-    av1_copy_frame_mvs(cm, mi, mi_row, mi_col, x_mis, y_mis);
-  }
-}
diff --git a/third_party/aom/av1/decoder/decodemv.h b/third_party/aom/av1/decoder/decodemv.h
deleted file mode 100644
index 1625e5bd2..000000000
--- a/third_party/aom/av1/decoder/decodemv.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#ifndef AOM_AV1_DECODER_DECODEMV_H_
-#define AOM_AV1_DECODER_DECODEMV_H_
-
-#include "aom_dsp/bitreader.h"
-
-#include "av1/decoder/decoder.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd,
-
-                        int mi_row, int mi_col, aom_reader *r, int x_mis,
-                        int y_mis);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row,
-                      int blk_col, TX_SIZE tx_size, aom_reader *r);
-
-#endif  // AOM_AV1_DECODER_DECODEMV_H_
diff --git a/third_party/aom/av1/decoder/decoder.c b/third_party/aom/av1/decoder/decoder.c
deleted file mode 100644
index a5f4fd67f..000000000
--- a/third_party/aom/av1/decoder/decoder.c
+++ /dev/null
@@ -1,575 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include <assert.h>
-#include <limits.h>
-#include <stdio.h>
-
-#include "config/av1_rtcd.h"
-#include "config/aom_dsp_rtcd.h"
-#include "config/aom_scale_rtcd.h"
-
-#include "aom_mem/aom_mem.h"
-#include "aom_ports/system_state.h"
-#include "aom_ports/aom_once.h"
-#include "aom_ports/aom_timer.h"
-#include "aom_scale/aom_scale.h"
-#include "aom_util/aom_thread.h"
-
-#include "av1/common/alloccommon.h"
-#include "av1/common/av1_loopfilter.h"
-#include "av1/common/onyxc_int.h"
-#include "av1/common/quant_common.h"
-#include "av1/common/reconinter.h"
-#include "av1/common/reconintra.h"
-
-#include "av1/decoder/decodeframe.h"
-#include "av1/decoder/decoder.h"
-#include "av1/decoder/detokenize.h"
-#include "av1/decoder/obu.h"
-
-static void initialize_dec(void) {
-  av1_rtcd();
-  aom_dsp_rtcd();
-  aom_scale_rtcd();
-  av1_init_intra_predictors();
-  av1_init_wedge_masks();
-}
-
-static void dec_setup_mi(AV1_COMMON *cm) {
-  cm->mi = cm->mip;
-  cm->mi_grid_visible = cm->mi_grid_base;
-  memset(cm->mi_grid_base, 0,
-         cm->mi_stride * cm->mi_rows * sizeof(*cm->mi_grid_base));
-}
-
-static int av1_dec_alloc_mi(AV1_COMMON *cm, int mi_size) {
-  cm->mip = aom_calloc(mi_size, sizeof(*cm->mip));
-  if (!cm->mip) return 1;
-  cm->mi_alloc_size = mi_size;
-  cm->mi_grid_base =
-      (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *));
-  if (!cm->mi_grid_base) return 1;
-  return 0;
-}
-
-static void dec_free_mi(AV1_COMMON *cm) {
-  aom_free(cm->mip);
-  cm->mip = NULL;
-  aom_free(cm->mi_grid_base);
-  cm->mi_grid_base = NULL;
-  cm->mi_alloc_size = 0;
-}
-
-AV1Decoder *av1_decoder_create(BufferPool *const pool) {
-  AV1Decoder *volatile const pbi = aom_memalign(32, sizeof(*pbi));
-  AV1_COMMON *volatile const cm = pbi ? &pbi->common : NULL;
-
-  if (!cm) return NULL;
-
-  av1_zero(*pbi);
-
-  // The jmp_buf is valid only for the duration of the function that calls
-  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
-  // before it returns.
-  if (setjmp(cm->error.jmp)) {
-    cm->error.setjmp = 0;
-    av1_decoder_remove(pbi);
-    return NULL;
-  }
-
-  cm->error.setjmp = 1;
-
-  CHECK_MEM_ERROR(cm, cm->fc,
-                  (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->fc)));
-  CHECK_MEM_ERROR(cm, cm->frame_contexts,
-                  (FRAME_CONTEXT *)aom_memalign(
-                      32, FRAME_CONTEXTS * sizeof(*cm->frame_contexts)));
-  memset(cm->fc, 0, sizeof(*cm->fc));
-  memset(cm->frame_contexts, 0, FRAME_CONTEXTS * sizeof(*cm->frame_contexts));
-
-  pbi->need_resync = 1;
-  aom_once(initialize_dec);
-
-  // Initialize the references to not point to any frame buffers.
-  memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
-  memset(&cm->next_ref_frame_map, -1, sizeof(cm->next_ref_frame_map));
-
-  cm->current_video_frame = 0;
-  pbi->decoding_first_frame = 1;
-  pbi->common.buffer_pool = pool;
-
-  cm->seq_params.bit_depth = AOM_BITS_8;
-  cm->dequant_bit_depth = AOM_BITS_8;
-
-  cm->alloc_mi = av1_dec_alloc_mi;
-  cm->free_mi = dec_free_mi;
-  cm->setup_mi = dec_setup_mi;
-
-  av1_loop_filter_init(cm);
-
-  av1_qm_init(cm);
-  av1_loop_restoration_precal();
-#if CONFIG_ACCOUNTING
-  pbi->acct_enabled = 1;
-  aom_accounting_init(&pbi->accounting);
-#endif
-
-  cm->error.setjmp = 0;
-
-  aom_get_worker_interface()->init(&pbi->lf_worker);
-
-  return pbi;
-}
-
-void av1_dealloc_dec_jobs(struct AV1DecTileMTData *tile_mt_info) {
-  if (tile_mt_info != NULL) {
-#if CONFIG_MULTITHREAD
-    if (tile_mt_info->job_mutex != NULL) {
-      pthread_mutex_destroy(tile_mt_info->job_mutex);
-      aom_free(tile_mt_info->job_mutex);
-    }
-#endif
-    aom_free(tile_mt_info->job_queue);
-    // clear the structure as the source of this call may be a resize in which
-    // case this call will be followed by an _alloc() which may fail.
-    av1_zero(*tile_mt_info);
-  }
-}
-
-void av1_dec_free_cb_buf(AV1Decoder *pbi) {
-  aom_free(pbi->cb_buffer_base);
-  pbi->cb_buffer_base = NULL;
-  pbi->cb_buffer_alloc_size = 0;
-}
-
-void av1_decoder_remove(AV1Decoder *pbi) {
-  int i;
-
-  if (!pbi) return;
-
-  // Free the tile list output buffer.
-  if (pbi->tile_list_output != NULL) aom_free(pbi->tile_list_output);
-  pbi->tile_list_output = NULL;
-
-  aom_get_worker_interface()->end(&pbi->lf_worker);
-  aom_free(pbi->lf_worker.data1);
-
-  if (pbi->thread_data) {
-    for (int worker_idx = 0; worker_idx < pbi->max_threads - 1; worker_idx++) {
-      DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
-      av1_free_mc_tmp_buf(thread_data->td);
-      aom_free(thread_data->td);
-    }
-    aom_free(pbi->thread_data);
-  }
-
-  for (i = 0; i < pbi->num_workers; ++i) {
-    AVxWorker *const worker = &pbi->tile_workers[i];
-    aom_get_worker_interface()->end(worker);
-  }
-#if CONFIG_MULTITHREAD
-  if (pbi->row_mt_mutex_ != NULL) {
-    pthread_mutex_destroy(pbi->row_mt_mutex_);
-    aom_free(pbi->row_mt_mutex_);
-  }
-  if (pbi->row_mt_cond_ != NULL) {
-    pthread_cond_destroy(pbi->row_mt_cond_);
-    aom_free(pbi->row_mt_cond_);
-  }
-#endif
-  for (i = 0; i < pbi->allocated_tiles; i++) {
-    TileDataDec *const tile_data = pbi->tile_data + i;
-    av1_dec_row_mt_dealloc(&tile_data->dec_row_mt_sync);
-  }
-  aom_free(pbi->tile_data);
-  aom_free(pbi->tile_workers);
-
-  if (pbi->num_workers > 0) {
-    av1_loop_filter_dealloc(&pbi->lf_row_sync);
-    av1_loop_restoration_dealloc(&pbi->lr_row_sync, pbi->num_workers);
-    av1_dealloc_dec_jobs(&pbi->tile_mt_info);
-  }
-
-  av1_dec_free_cb_buf(pbi);
-#if CONFIG_ACCOUNTING
-  aom_accounting_clear(&pbi->accounting);
-#endif
-  av1_free_mc_tmp_buf(&pbi->td);
-
-  aom_free(pbi);
-}
-
-void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, int mi_row,
-                       int mi_col, aom_reader *r, BLOCK_SIZE bsize,
-                       palette_visitor_fn_t visit) {
-  if (!is_inter_block(xd->mi[0])) {
-    for (int plane = 0; plane < AOMMIN(2, av1_num_planes(&pbi->common));
-         ++plane) {
-      const struct macroblockd_plane *const pd = &xd->plane[plane];
-      if (is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
-                              pd->subsampling_y)) {
-        if (xd->mi[0]->palette_mode_info.palette_size[plane])
-          visit(xd, plane, r);
-      } else {
-        assert(xd->mi[0]->palette_mode_info.palette_size[plane] == 0);
-      }
-    }
-  }
-}
-
-static int equal_dimensions(const YV12_BUFFER_CONFIG *a,
-                            const YV12_BUFFER_CONFIG *b) {
-  return a->y_height == b->y_height && a->y_width == b->y_width &&
-         a->uv_height == b->uv_height && a->uv_width == b->uv_width;
-}
-
-aom_codec_err_t av1_copy_reference_dec(AV1Decoder *pbi, int idx,
-                                       YV12_BUFFER_CONFIG *sd) {
-  AV1_COMMON *cm = &pbi->common;
-  const int num_planes = av1_num_planes(cm);
-
-  const YV12_BUFFER_CONFIG *const cfg = get_ref_frame(cm, idx);
-  if (cfg == NULL) {
-    aom_internal_error(&cm->error, AOM_CODEC_ERROR, "No reference frame");
-    return AOM_CODEC_ERROR;
-  }
-  if (!equal_dimensions(cfg, sd))
-    aom_internal_error(&cm->error, AOM_CODEC_ERROR,
-                       "Incorrect buffer dimensions");
-  else
-    aom_yv12_copy_frame(cfg, sd, num_planes);
-
-  return cm->error.error_code;
-}
-
-static int equal_dimensions_and_border(const YV12_BUFFER_CONFIG *a,
-                                       const YV12_BUFFER_CONFIG *b) {
-  return a->y_height == b->y_height && a->y_width == b->y_width &&
-         a->uv_height == b->uv_height && a->uv_width == b->uv_width &&
-         a->y_stride == b->y_stride && a->uv_stride == b->uv_stride &&
-         a->border == b->border &&
-         (a->flags & YV12_FLAG_HIGHBITDEPTH) ==
-             (b->flags & YV12_FLAG_HIGHBITDEPTH);
-}
-
-aom_codec_err_t av1_set_reference_dec(AV1_COMMON *cm, int idx,
-                                      int use_external_ref,
-                                      YV12_BUFFER_CONFIG *sd) {
-  const int num_planes = av1_num_planes(cm);
-  YV12_BUFFER_CONFIG *ref_buf = NULL;
-
-  // Get the destination reference buffer.
-  ref_buf = get_ref_frame(cm, idx);
-
-  if (ref_buf == NULL) {
-    aom_internal_error(&cm->error, AOM_CODEC_ERROR, "No reference frame");
-    return AOM_CODEC_ERROR;
-  }
-
-  if (!use_external_ref) {
-    if (!equal_dimensions(ref_buf, sd)) {
-      aom_internal_error(&cm->error, AOM_CODEC_ERROR,
-                         "Incorrect buffer dimensions");
-    } else {
-      // Overwrite the reference frame buffer.
-      aom_yv12_copy_frame(sd, ref_buf, num_planes);
-    }
-  } else {
-    if (!equal_dimensions_and_border(ref_buf, sd)) {
-      aom_internal_error(&cm->error, AOM_CODEC_ERROR,
-                         "Incorrect buffer dimensions");
-    } else {
-      // Overwrite the reference frame buffer pointers.
-      // Once we no longer need the external reference buffer, these pointers
-      // are restored.
-      ref_buf->store_buf_adr[0] = ref_buf->y_buffer;
-      ref_buf->store_buf_adr[1] = ref_buf->u_buffer;
-      ref_buf->store_buf_adr[2] = ref_buf->v_buffer;
-      ref_buf->y_buffer = sd->y_buffer;
-      ref_buf->u_buffer = sd->u_buffer;
-      ref_buf->v_buffer = sd->v_buffer;
-      ref_buf->use_external_reference_buffers = 1;
-    }
-  }
-
-  return cm->error.error_code;
-}
-
-aom_codec_err_t av1_copy_new_frame_dec(AV1_COMMON *cm,
-                                       YV12_BUFFER_CONFIG *new_frame,
-                                       YV12_BUFFER_CONFIG *sd) {
-  const int num_planes = av1_num_planes(cm);
-
-  if (!equal_dimensions_and_border(new_frame, sd))
-    aom_internal_error(&cm->error, AOM_CODEC_ERROR,
-                       "Incorrect buffer dimensions");
-  else
-    aom_yv12_copy_frame(new_frame, sd, num_planes);
-
-  return cm->error.error_code;
-}
-
-/* If any buffer updating is signaled it should be done here.
-   Consumes a reference to cm->new_fb_idx.
-*/
-static void swap_frame_buffers(AV1Decoder *pbi, int frame_decoded) {
-  int ref_index = 0, mask;
-  AV1_COMMON *const cm = &pbi->common;
-  BufferPool *const pool = cm->buffer_pool;
-  RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
-
-  if (frame_decoded) {
-    lock_buffer_pool(pool);
-
-    // In ext-tile decoding, the camera frame header is only decoded once. So,
-    // we don't release the references here.
-    if (!pbi->camera_frame_header_ready) {
-      for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) {
-        const int old_idx = cm->ref_frame_map[ref_index];
-        // Current thread releases the holding of reference frame.
-        decrease_ref_count(old_idx, frame_bufs, pool);
-
-        // Release the reference frame holding in the reference map for the
-        // decoding of the next frame.
-        if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool);
-        cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index];
-        ++ref_index;
-      }
-
-      // Current thread releases the holding of reference frame.
-      const int check_on_show_existing_frame =
-          !cm->show_existing_frame || cm->reset_decoder_state;
-      for (; ref_index < REF_FRAMES && check_on_show_existing_frame;
-           ++ref_index) {
-        const int old_idx = cm->ref_frame_map[ref_index];
-        decrease_ref_count(old_idx, frame_bufs, pool);
-        cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index];
-      }
-    }
-
-    YV12_BUFFER_CONFIG *cur_frame = get_frame_new_buffer(cm);
-
-    if (cm->show_existing_frame || cm->show_frame) {
-      if (pbi->output_all_layers) {
-        // Append this frame to the output queue
-        if (pbi->num_output_frames >= MAX_NUM_SPATIAL_LAYERS) {
-          // We can't store the new frame anywhere, so drop it and return an
-          // error
-          decrease_ref_count(cm->new_fb_idx, frame_bufs, pool);
-          cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
-        } else {
-          pbi->output_frames[pbi->num_output_frames] = cur_frame;
-          pbi->output_frame_index[pbi->num_output_frames] = cm->new_fb_idx;
-          pbi->num_output_frames++;
-        }
-      } else {
-        // Replace any existing output frame
-        assert(pbi->num_output_frames == 0 || pbi->num_output_frames == 1);
-        if (pbi->num_output_frames > 0) {
-          decrease_ref_count((int)pbi->output_frame_index[0], frame_bufs, pool);
-        }
-        pbi->output_frames[0] = cur_frame;
-        pbi->output_frame_index[0] = cm->new_fb_idx;
-        pbi->num_output_frames = 1;
-      }
-    } else {
-      decrease_ref_count(cm->new_fb_idx, frame_bufs, pool);
-    }
-
-    unlock_buffer_pool(pool);
-  } else {
-    // Nothing was decoded, so just drop this frame buffer
-    lock_buffer_pool(pool);
-    decrease_ref_count(cm->new_fb_idx, frame_bufs, pool);
-    unlock_buffer_pool(pool);
-  }
-
-  if (!pbi->camera_frame_header_ready) {
-    pbi->hold_ref_buf = 0;
-
-    // Invalidate these references until the next frame starts.
-    for (ref_index = 0; ref_index < INTER_REFS_PER_FRAME; ref_index++) {
-      cm->frame_refs[ref_index].idx = INVALID_IDX;
-      cm->frame_refs[ref_index].buf = NULL;
-    }
-  }
-}
-
-int av1_receive_compressed_data(AV1Decoder *pbi, size_t size,
-                                const uint8_t **psource) {
-  AV1_COMMON *volatile const cm = &pbi->common;
-  BufferPool *volatile const pool = cm->buffer_pool;
-  RefCntBuffer *volatile const frame_bufs = cm->buffer_pool->frame_bufs;
-  const uint8_t *source = *psource;
-  cm->error.error_code = AOM_CODEC_OK;
-
-  if (size == 0) {
-    // This is used to signal that we are missing frames.
-    // We do not know if the missing frame(s) was supposed to update
-    // any of the reference buffers, but we act conservative and
-    // mark only the last buffer as corrupted.
-    //
-    // TODO(jkoleszar): Error concealment is undefined and non-normative
-    // at this point, but if it becomes so, [0] may not always be the correct
-    // thing to do here.
-    if (cm->frame_refs[0].idx > 0) {
-      assert(cm->frame_refs[0].buf != NULL);
-      cm->frame_refs[0].buf->corrupted = 1;
-    }
-  }
-
-  // Find a free buffer for the new frame, releasing the reference previously
-  // held.
-
-  // Find a free frame buffer. Return error if can not find any.
-  cm->new_fb_idx = get_free_fb(cm);
-  if (cm->new_fb_idx == INVALID_IDX) {
-    cm->error.error_code = AOM_CODEC_MEM_ERROR;
-    return 1;
-  }
-
-  // Assign a MV array to the frame buffer.
-  cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx];
-
-  if (!pbi->camera_frame_header_ready) pbi->hold_ref_buf = 0;
-
-  pbi->cur_buf = &frame_bufs[cm->new_fb_idx];
-
-  // The jmp_buf is valid only for the duration of the function that calls
-  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0
-  // before it returns.
-  if (setjmp(cm->error.jmp)) {
-    const AVxWorkerInterface *const winterface = aom_get_worker_interface();
-    int i;
-
-    cm->error.setjmp = 0;
-
-    // Synchronize all threads immediately as a subsequent decode call may
-    // cause a resize invalidating some allocations.
-    winterface->sync(&pbi->lf_worker);
-    for (i = 0; i < pbi->num_workers; ++i) {
-      winterface->sync(&pbi->tile_workers[i]);
-    }
-
-    lock_buffer_pool(pool);
-    // Release all the reference buffers if worker thread is holding them.
-    if (pbi->hold_ref_buf == 1) {
-      int ref_index = 0, mask;
-      for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) {
-        const int old_idx = cm->ref_frame_map[ref_index];
-        // Current thread releases the holding of reference frame.
-        decrease_ref_count(old_idx, frame_bufs, pool);
-
-        // Release the reference frame holding in the reference map for the
-        // decoding of the next frame.
-        if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool);
-        ++ref_index;
-      }
-
-      // Current thread releases the holding of reference frame.
-      const int check_on_show_existing_frame =
-          !cm->show_existing_frame || cm->reset_decoder_state;
-      for (; ref_index < REF_FRAMES && check_on_show_existing_frame;
-           ++ref_index) {
-        const int old_idx = cm->ref_frame_map[ref_index];
-        decrease_ref_count(old_idx, frame_bufs, pool);
-      }
-      pbi->hold_ref_buf = 0;
-    }
-    // Release current frame.
-    decrease_ref_count(cm->new_fb_idx, frame_bufs, pool);
-    unlock_buffer_pool(pool);
-
-    aom_clear_system_state();
-    return -1;
-  }
-
-  cm->error.setjmp = 1;
-
-  int frame_decoded =
-      aom_decode_frame_from_obus(pbi, source, source + size, psource);
-
-  if (cm->error.error_code != AOM_CODEC_OK) {
-    lock_buffer_pool(pool);
-    decrease_ref_count(cm->new_fb_idx, frame_bufs, pool);
-    unlock_buffer_pool(pool);
-    cm->error.setjmp = 0;
-    return 1;
-  }
-
-#if TXCOEFF_TIMER
-  cm->cum_txcoeff_timer += cm->txcoeff_timer;
-  fprintf(stderr,
-          "txb coeff block number: %d, frame time: %ld, cum time %ld in us\n",
-          cm->txb_count, cm->txcoeff_timer, cm->cum_txcoeff_timer);
-  cm->txcoeff_timer = 0;
-  cm->txb_count = 0;
-#endif
-
-  // Note: At this point, this function holds a reference to cm->new_fb_idx
-  // in the buffer pool. This reference is consumed by swap_frame_buffers().
-  swap_frame_buffers(pbi, frame_decoded);
-
-  if (frame_decoded) {
-    pbi->decoding_first_frame = 0;
-  }
-
-  if (cm->error.error_code != AOM_CODEC_OK) {
-    cm->error.setjmp = 0;
-    return 1;
-  }
-
-  aom_clear_system_state();
-
-  if (!cm->show_existing_frame) {
-    cm->last_show_frame = cm->show_frame;
-
-    if (cm->seg.enabled) {
-      if (cm->prev_frame && (cm->mi_rows == cm->prev_frame->mi_rows) &&
-          (cm->mi_cols == cm->prev_frame->mi_cols)) {
-        cm->last_frame_seg_map = cm->prev_frame->seg_map;
-      } else {
-        cm->last_frame_seg_map = NULL;
-      }
-    }
-  }
-
-  // Update progress in frame parallel decode.
-  cm->last_width = cm->width;
-  cm->last_height = cm->height;
-  cm->last_tile_cols = cm->tile_cols;
-  cm->last_tile_rows = cm->tile_rows;
-  cm->error.setjmp = 0;
-
-  return 0;
-}
-
-// Get the frame at a particular index in the output queue
-int av1_get_raw_frame(AV1Decoder *pbi, size_t index, YV12_BUFFER_CONFIG **sd,
-                      aom_film_grain_t **grain_params) {
-  RefCntBuffer *const frame_bufs = pbi->common.buffer_pool->frame_bufs;
-
-  if (index >= pbi->num_output_frames) return -1;
-  *sd = pbi->output_frames[index];
-  *grain_params = &frame_bufs[pbi->output_frame_index[index]].film_grain_params;
-  aom_clear_system_state();
-  return 0;
-}
-
-// Get the highest-spatial-layer output
-// TODO(david.barker): What should this do?
-int av1_get_frame_to_show(AV1Decoder *pbi, YV12_BUFFER_CONFIG *frame) {
-  if (pbi->num_output_frames == 0) return -1;
-
-  *frame = *pbi->output_frames[pbi->num_output_frames - 1];
-  return 0;
-}
diff --git a/third_party/aom/av1/decoder/decoder.h b/third_party/aom/av1/decoder/decoder.h
deleted file mode 100644
index 5ca939c24..000000000
--- a/third_party/aom/av1/decoder/decoder.h
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#ifndef AOM_AV1_DECODER_DECODER_H_
-#define AOM_AV1_DECODER_DECODER_H_
-
-#include "config/aom_config.h"
-
-#include "aom/aom_codec.h"
-#include "aom_dsp/bitreader.h"
-#include "aom_scale/yv12config.h"
-#include "aom_util/aom_thread.h"
-
-#include "av1/common/thread_common.h"
-#include "av1/common/onyxc_int.h"
-#include "av1/decoder/dthread.h"
-#if CONFIG_ACCOUNTING
-#include "av1/decoder/accounting.h"
-#endif
-#if CONFIG_INSPECTION
-#include "av1/decoder/inspection.h"
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void (*decode_block_visitor_fn_t)(const AV1_COMMON *const cm,
-                                          MACROBLOCKD *const xd,
-                                          aom_reader *const r, const int plane,
-                                          const int row, const int col,
-                                          const TX_SIZE tx_size);
-
-typedef void (*predict_inter_block_visitor_fn_t)(AV1_COMMON *const cm,
-                                                 MACROBLOCKD *const xd,
-                                                 int mi_row, int mi_col,
-                                                 BLOCK_SIZE bsize);
-
-typedef void (*cfl_store_inter_block_visitor_fn_t)(AV1_COMMON *const cm,
-                                                   MACROBLOCKD *const xd);
-
-typedef struct ThreadData {
-  aom_reader *bit_reader;
-  DECLARE_ALIGNED(32, MACROBLOCKD, xd);
-  /* dqcoeff are shared by all the planes. So planes must be decoded serially */
-  DECLARE_ALIGNED(32, tran_low_t, dqcoeff[MAX_TX_SQUARE]);
-  CB_BUFFER cb_buffer_base;
-  uint8_t *mc_buf[2];
-  int32_t mc_buf_size;
-  int mc_buf_use_highbd;  // Boolean: whether the byte pointers stored in
-                          // mc_buf were converted from highbd pointers.
-
-  CONV_BUF_TYPE *tmp_conv_dst;
-  uint8_t *tmp_obmc_bufs[2];
-
-  decode_block_visitor_fn_t read_coeffs_tx_intra_block_visit;
-  decode_block_visitor_fn_t predict_and_recon_intra_block_visit;
-  decode_block_visitor_fn_t read_coeffs_tx_inter_block_visit;
-  decode_block_visitor_fn_t inverse_tx_inter_block_visit;
-  predict_inter_block_visitor_fn_t predict_inter_block_visit;
-  cfl_store_inter_block_visitor_fn_t cfl_store_inter_block_visit;
-} ThreadData;
-
-typedef struct AV1DecRowMTJobInfo {
-  int tile_row;
-  int tile_col;
-  int mi_row;
-} AV1DecRowMTJobInfo;
-
-typedef struct AV1DecRowMTSyncData {
-#if CONFIG_MULTITHREAD
-  pthread_mutex_t *mutex_;
-  pthread_cond_t *cond_;
-#endif
-  int allocated_sb_rows;
-  int *cur_sb_col;
-  int sync_range;
-  int mi_rows;
-  int mi_cols;
-  int mi_rows_parse_done;
-  int mi_rows_decode_started;
-  int num_threads_working;
-} AV1DecRowMTSync;
-
-typedef struct AV1DecRowMTInfo {
-  int tile_rows_start;
-  int tile_rows_end;
-  int tile_cols_start;
-  int tile_cols_end;
-  int start_tile;
-  int end_tile;
-  int mi_rows_parse_done;
-  int mi_rows_decode_started;
-  int mi_rows_to_decode;
-  int row_mt_exit;
-} AV1DecRowMTInfo;
-
-typedef struct TileDataDec {
-  TileInfo tile_info;
-  aom_reader bit_reader;
-  DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
-  AV1DecRowMTSync dec_row_mt_sync;
-} TileDataDec;
-
-typedef struct TileBufferDec {
-  const uint8_t *data;
-  size_t size;
-} TileBufferDec;
-
-typedef struct DataBuffer {
-  const uint8_t *data;
-  size_t size;
-} DataBuffer;
-
-typedef struct EXTERNAL_REFERENCES {
-  YV12_BUFFER_CONFIG refs[MAX_EXTERNAL_REFERENCES];
-  int num;
-} EXTERNAL_REFERENCES;
-
-typedef struct TileJobsDec {
-  TileBufferDec *tile_buffer;
-  TileDataDec *tile_data;
-} TileJobsDec;
-
-typedef struct AV1DecTileMTData {
-#if CONFIG_MULTITHREAD
-  pthread_mutex_t *job_mutex;
-#endif
-  TileJobsDec *job_queue;
-  int jobs_enqueued;
-  int jobs_dequeued;
-  int alloc_tile_rows;
-  int alloc_tile_cols;
-} AV1DecTileMT;
-
-typedef struct AV1Decoder {
-  DECLARE_ALIGNED(32, MACROBLOCKD, mb);
-
-  DECLARE_ALIGNED(32, AV1_COMMON, common);
-
-  int refresh_frame_flags;
-
-  // TODO(hkuang): Combine this with cur_buf in macroblockd as they are
-  // the same.
-  RefCntBuffer *cur_buf;  //  Current decoding frame buffer.
-
-  AVxWorker *frame_worker_owner;  // frame_worker that owns this pbi.
-  AVxWorker lf_worker;
-  AV1LfSync lf_row_sync;
-  AV1LrSync lr_row_sync;
-  AV1LrStruct lr_ctxt;
-  AVxWorker *tile_workers;
-  int num_workers;
-  DecWorkerData *thread_data;
-  ThreadData td;
-  TileDataDec *tile_data;
-  int allocated_tiles;
-
-  TileBufferDec tile_buffers[MAX_TILE_ROWS][MAX_TILE_COLS];
-  AV1DecTileMT tile_mt_info;
-
-  // Each time the decoder is called, we expect to receive a full temporal unit.
-  // This can contain up to one shown frame per spatial layer in the current
-  // operating point (note that some layers may be entirely omitted).
-  // If the 'output_all_layers' option is true, we save all of these shown
-  // frames so that they can be returned to the application. If the
-  // 'output_all_layers' option is false, then we only output one image per
-  // temporal unit.
-  //
-  // Note: The saved buffers are released at the start of the next time the
-  // application calls aom_codec_decode().
-  int output_all_layers;
-  YV12_BUFFER_CONFIG *output_frames[MAX_NUM_SPATIAL_LAYERS];
-  size_t output_frame_index[MAX_NUM_SPATIAL_LAYERS];  // Buffer pool indices
-  size_t num_output_frames;  // How many frames are queued up so far?
-
-  // In order to properly support random-access decoding, we need
-  // to behave slightly differently for the very first frame we decode.
-  // So we track whether this is the first frame or not.
-  int decoding_first_frame;
-
-  int allow_lowbitdepth;
-  int max_threads;
-  int inv_tile_order;
-  int need_resync;   // wait for key/intra-only frame.
-  int hold_ref_buf;  // hold the reference buffer.
-
-  int tile_size_bytes;
-  int tile_col_size_bytes;
-  int dec_tile_row, dec_tile_col;  // always -1 for non-VR tile encoding
-#if CONFIG_ACCOUNTING
-  int acct_enabled;
-  Accounting accounting;
-#endif
-  int tg_size;   // Number of tiles in the current tilegroup
-  int tg_start;  // First tile in the current tilegroup
-  int tg_size_bit_offset;
-  int sequence_header_ready;
-  int sequence_header_changed;
-#if CONFIG_INSPECTION
-  aom_inspect_cb inspect_cb;
-  void *inspect_ctx;
-#endif
-  int operating_point;
-  int current_operating_point;
-  int seen_frame_header;
-
-  // State if the camera frame header is already decoded while
-  // large_scale_tile = 1.
-  int camera_frame_header_ready;
-  size_t frame_header_size;
-  DataBuffer obu_size_hdr;
-  int output_frame_width_in_tiles_minus_1;
-  int output_frame_height_in_tiles_minus_1;
-  int tile_count_minus_1;
-  uint32_t coded_tile_data_size;
-  unsigned int ext_tile_debug;  // for ext-tile software debug & testing
-  unsigned int row_mt;
-  EXTERNAL_REFERENCES ext_refs;
-  size_t tile_list_size;
-  uint8_t *tile_list_output;
-  size_t buffer_sz;
-
-  CB_BUFFER *cb_buffer_base;
-  int cb_buffer_alloc_size;
-
-  int allocated_row_mt_sync_rows;
-
-#if CONFIG_MULTITHREAD
-  pthread_mutex_t *row_mt_mutex_;
-  pthread_cond_t *row_mt_cond_;
-#endif
-
-  AV1DecRowMTInfo frame_row_mt_info;
-} AV1Decoder;
-
-// Returns 0 on success. Sets pbi->common.error.error_code to a nonzero error
-// code and returns a nonzero value on failure.
-int av1_receive_compressed_data(struct AV1Decoder *pbi, size_t size,
-                                const uint8_t **dest);
-
-// Get the frame at a particular index in the output queue
-int av1_get_raw_frame(AV1Decoder *pbi, size_t index, YV12_BUFFER_CONFIG **sd,
-                      aom_film_grain_t **grain_params);
-
-int av1_get_frame_to_show(struct AV1Decoder *pbi, YV12_BUFFER_CONFIG *frame);
-
-aom_codec_err_t av1_copy_reference_dec(struct AV1Decoder *pbi, int idx,
-                                       YV12_BUFFER_CONFIG *sd);
-
-aom_codec_err_t av1_set_reference_dec(AV1_COMMON *cm, int idx,
-                                      int use_external_ref,
-                                      YV12_BUFFER_CONFIG *sd);
-aom_codec_err_t av1_copy_new_frame_dec(AV1_COMMON *cm,
-                                       YV12_BUFFER_CONFIG *new_frame,
-                                       YV12_BUFFER_CONFIG *sd);
-
-struct AV1Decoder *av1_decoder_create(BufferPool *const pool);
-
-void av1_decoder_remove(struct AV1Decoder *pbi);
-void av1_dealloc_dec_jobs(struct AV1DecTileMTData *tile_jobs_sync);
-
-void av1_dec_row_mt_dealloc(AV1DecRowMTSync *dec_row_mt_sync);
-
-void av1_dec_free_cb_buf(AV1Decoder *pbi);
-
-static INLINE void decrease_ref_count(int idx, RefCntBuffer *const frame_bufs,
-                                      BufferPool *const pool) {
-  if (idx >= 0) {
-    --frame_bufs[idx].ref_count;
-    // A worker may only get a free framebuffer index when calling get_free_fb.
-    // But the private buffer is not set up until finish decoding header.
-    // So any error happens during decoding header, the frame_bufs will not
-    // have valid priv buffer.
-    if (frame_bufs[idx].ref_count == 0 &&
-        frame_bufs[idx].raw_frame_buffer.priv) {
-      pool->release_fb_cb(pool->cb_priv, &frame_bufs[idx].raw_frame_buffer);
-    }
-  }
-}
-
-#define ACCT_STR __func__
-static INLINE int av1_read_uniform(aom_reader *r, int n) {
-  const int l = get_unsigned_bits(n);
-  const int m = (1 << l) - n;
-  const int v = aom_read_literal(r, l - 1, ACCT_STR);
-  assert(l != 0);
-  if (v < m)
-    return v;
-  else
-    return (v << 1) - m + aom_read_literal(r, 1, ACCT_STR);
-}
-
-typedef void (*palette_visitor_fn_t)(MACROBLOCKD *const xd, int plane,
-                                     aom_reader *r);
-
-void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, int mi_row,
-                       int mi_col, aom_reader *r, BLOCK_SIZE bsize,
-                       palette_visitor_fn_t visit);
-
-typedef void (*block_visitor_fn_t)(AV1Decoder *const pbi, ThreadData *const td,
-                                   int mi_row, int mi_col, aom_reader *r,
-                                   PARTITION_TYPE partition, BLOCK_SIZE bsize);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#endif  // AOM_AV1_DECODER_DECODER_H_
diff --git a/third_party/aom/av1/decoder/decodetxb.c b/third_party/aom/av1/decoder/decodetxb.c
deleted file mode 100644
index f3ef2d55e..000000000
--- a/third_party/aom/av1/decoder/decodetxb.c
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
- * Copyright (c) 2017, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include "av1/decoder/decodetxb.h"
-
-#include "aom_ports/mem.h"
-#include "av1/common/idct.h"
-#include "av1/common/scan.h"
-#include "av1/common/txb_common.h"
-#include "av1/decoder/decodemv.h"
-
-#define ACCT_STR __func__
-
-static int read_golomb(MACROBLOCKD *xd, aom_reader *r) {
-  int x = 1;
-  int length = 0;
-  int i = 0;
-
-  while (!i) {
-    i = aom_read_bit(r, ACCT_STR);
-    ++length;
-    if (length > 20) {
-      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
-                         "Invalid length in read_golomb");
-      break;
-    }
-  }
-
-  for (i = 0; i < length - 1; ++i) {
-    x <<= 1;
-    x += aom_read_bit(r, ACCT_STR);
-  }
-
-  return x - 1;
-}
-
-static INLINE int rec_eob_pos(const int eob_token, const int extra) {
-  int eob = k_eob_group_start[eob_token];
-  if (eob > 2) {
-    eob += extra;
-  }
-  return eob;
-}
-
-static INLINE int get_dqv(const int16_t *dequant, int coeff_idx,
-                          const qm_val_t *iqmatrix) {
-  int dqv = dequant[!!coeff_idx];
-  if (iqmatrix != NULL)
-    dqv =
-        ((iqmatrix[coeff_idx] * dqv) + (1 << (AOM_QM_BITS - 1))) >> AOM_QM_BITS;
-  return dqv;
-}
-
-static INLINE void read_coeffs_reverse_2d(aom_reader *r, TX_SIZE tx_size,
-                                          int start_si, int end_si,
-                                          const int16_t *scan, int bwl,
-                                          uint8_t *levels,
-                                          base_cdf_arr base_cdf,
-                                          br_cdf_arr br_cdf) {
-  for (int c = end_si; c >= start_si; --c) {
-    const int pos = scan[c];
-    const int coeff_ctx = get_lower_levels_ctx_2d(levels, pos, bwl, tx_size);
-    const int nsymbs = 4;
-    int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR);
-    if (level > NUM_BASE_LEVELS) {
-      const int br_ctx = get_br_ctx_2d(levels, pos, bwl);
-      aom_cdf_prob *cdf = br_cdf[br_ctx];
-      for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
-        const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
-        level += k;
-        if (k < BR_CDF_SIZE - 1) break;
-      }
-    }
-    levels[get_padded_idx(pos, bwl)] = level;
-  }
-}
-
-static INLINE void read_coeffs_reverse(aom_reader *r, TX_SIZE tx_size,
-                                       TX_CLASS tx_class, int start_si,
-                                       int end_si, const int16_t *scan, int bwl,
-                                       uint8_t *levels, base_cdf_arr base_cdf,
-                                       br_cdf_arr br_cdf) {
-  for (int c = end_si; c >= start_si; --c) {
-    const int pos = scan[c];
-    const int coeff_ctx =
-        get_lower_levels_ctx(levels, pos, bwl, tx_size, tx_class);
-    const int nsymbs = 4;
-    int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR);
-    if (level > NUM_BASE_LEVELS) {
-      const int br_ctx = get_br_ctx(levels, pos, bwl, tx_class);
-      aom_cdf_prob *cdf = br_cdf[br_ctx];
-      for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
-        const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR);
-        level += k;
-        if (k < BR_CDF_SIZE - 1) break;
-      }
-    }
-    levels[get_padded_idx(pos, bwl)] = level;
-  }
-}
-
-uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                            aom_reader *const r, const int blk_row,
-                            const int blk_col, const int plane,
-                            const TXB_CTX *const txb_ctx,
-                            const TX_SIZE tx_size) {
-  FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
-  const int32_t max_value = (1 << (7 + xd->bd)) - 1;
-  const int32_t min_value = -(1 << (7 + xd->bd));
-  const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
-  const PLANE_TYPE plane_type = get_plane_type(plane);
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  struct macroblockd_plane *const pd = &xd->plane[plane];
-  const int16_t *const dequant = pd->seg_dequant_QTX[mbmi->segment_id];
-  tran_low_t *const tcoeffs = pd->dqcoeff_block + xd->cb_offset[plane];
-  const int shift = av1_get_tx_scale(tx_size);
-  const int bwl = get_txb_bwl(tx_size);
-  const int width = get_txb_wide(tx_size);
-  const int height = get_txb_high(tx_size);
-  int cul_level = 0;
-  int dc_val = 0;
-  uint8_t levels_buf[TX_PAD_2D];
-  uint8_t *const levels = set_levels(levels_buf, width);
-  const int all_zero = aom_read_symbol(
-      r, ec_ctx->txb_skip_cdf[txs_ctx][txb_ctx->txb_skip_ctx], 2, ACCT_STR);
-  eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
-  uint16_t *const eob = &(eob_data->eob);
-  uint16_t *const max_scan_line = &(eob_data->max_scan_line);
-  *max_scan_line = 0;
-  *eob = 0;
-  if (all_zero) {
-    *max_scan_line = 0;
-    if (plane == 0) {
-      const int txk_type_idx =
-          av1_get_txk_type_index(mbmi->sb_type, blk_row, blk_col);
-      mbmi->txk_type[txk_type_idx] = DCT_DCT;
-    }
-    return 0;
-  }
-
-  memset(levels_buf, 0,
-         sizeof(*levels_buf) *
-             ((width + TX_PAD_HOR) * (height + TX_PAD_VER) + TX_PAD_END));
-  if (plane == AOM_PLANE_Y) {
-    // only y plane's tx_type is transmitted
-    av1_read_tx_type(cm, xd, blk_row, blk_col, tx_size, r);
-  }
-  const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, blk_row, blk_col,
-                                          tx_size, cm->reduced_tx_set_used);
-  const TX_CLASS tx_class = tx_type_to_class[tx_type];
-  const TX_SIZE qm_tx_size = av1_get_adjusted_tx_size(tx_size);
-  const qm_val_t *iqmatrix =
-      IS_2D_TRANSFORM(tx_type)
-          ? pd->seg_iqmatrix[mbmi->segment_id][qm_tx_size]
-          : cm->giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size];
-  const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type);
-  const int16_t *const scan = scan_order->scan;
-  int eob_extra = 0;
-  int eob_pt = 1;
-
-  const int eob_multi_size = txsize_log2_minus4[tx_size];
-  const int eob_multi_ctx = (tx_class == TX_CLASS_2D) ? 0 : 1;
-  switch (eob_multi_size) {
-    case 0:
-      eob_pt =
-          aom_read_symbol(r, ec_ctx->eob_flag_cdf16[plane_type][eob_multi_ctx],
-                          5, ACCT_STR) +
-          1;
-      break;
-    case 1:
-      eob_pt =
-          aom_read_symbol(r, ec_ctx->eob_flag_cdf32[plane_type][eob_multi_ctx],
-                          6, ACCT_STR) +
-          1;
-      break;
-    case 2:
-      eob_pt =
-          aom_read_symbol(r, ec_ctx->eob_flag_cdf64[plane_type][eob_multi_ctx],
-                          7, ACCT_STR) +
-          1;
-      break;
-    case 3:
-      eob_pt =
-          aom_read_symbol(r, ec_ctx->eob_flag_cdf128[plane_type][eob_multi_ctx],
-                          8, ACCT_STR) +
-          1;
-      break;
-    case 4:
-      eob_pt =
-          aom_read_symbol(r, ec_ctx->eob_flag_cdf256[plane_type][eob_multi_ctx],
-                          9, ACCT_STR) +
-          1;
-      break;
-    case 5:
-      eob_pt =
-          aom_read_symbol(r, ec_ctx->eob_flag_cdf512[plane_type][eob_multi_ctx],
-                          10, ACCT_STR) +
-          1;
-      break;
-    case 6:
-    default:
-      eob_pt = aom_read_symbol(
-                   r, ec_ctx->eob_flag_cdf1024[plane_type][eob_multi_ctx], 11,
-                   ACCT_STR) +
-               1;
-      break;
-  }
-
-  if (k_eob_offset_bits[eob_pt] > 0) {
-    const int eob_ctx = eob_pt - 3;
-    int bit = aom_read_symbol(
-        r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx], 2, ACCT_STR);
-    if (bit) {
-      eob_extra += (1 << (k_eob_offset_bits[eob_pt] - 1));
-    }
-
-    for (int i = 1; i < k_eob_offset_bits[eob_pt]; i++) {
-      bit = aom_read_bit(r, ACCT_STR);
-      if (bit) {
-        eob_extra += (1 << (k_eob_offset_bits[eob_pt] - 1 - i));
-      }
-    }
-  }
-  *eob = rec_eob_pos(eob_pt, eob_extra);
-
-  {
-    // Read the non-zero coefficient with scan index eob-1
-    // TODO(angiebird): Put this into a function
-    const int c = *eob - 1;
-    const int pos = scan[c];
-    const int coeff_ctx = get_lower_levels_ctx_eob(bwl, height, c);
-    const int nsymbs = 3;
-    aom_cdf_prob *cdf =
-        ec_ctx->coeff_base_eob_cdf[txs_ctx][plane_type][coeff_ctx];
-    int level = aom_read_symbol(r, cdf, nsymbs, ACCT_STR) + 1;
-    if (level > NUM_BASE_LEVELS) {
-      const int br_ctx = get_br_ctx(levels, pos, bwl, tx_class);
-      for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
-        const int k = aom_read_symbol(
-            r,
-            ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][br_ctx],
-            BR_CDF_SIZE, ACCT_STR);
-        level += k;
-        if (k < BR_CDF_SIZE - 1) break;
-      }
-    }
-    levels[get_padded_idx(pos, bwl)] = level;
-  }
-  if (*eob > 1) {
-    base_cdf_arr base_cdf = ec_ctx->coeff_base_cdf[txs_ctx][plane_type];
-    br_cdf_arr br_cdf =
-        ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type];
-    if (tx_class == TX_CLASS_2D) {
-      read_coeffs_reverse_2d(r, tx_size, 1, *eob - 1 - 1, scan, bwl, levels,
-                             base_cdf, br_cdf);
-      read_coeffs_reverse(r, tx_size, tx_class, 0, 0, scan, bwl, levels,
-                          base_cdf, br_cdf);
-    } else {
-      read_coeffs_reverse(r, tx_size, tx_class, 0, *eob - 1 - 1, scan, bwl,
-                          levels, base_cdf, br_cdf);
-    }
-  }
-
-  int16_t num_zero_coeffs = 0;
-  for (int c = 0; c < *eob; ++c) {
-    const int pos = scan[c];
-    num_zero_coeffs = AOMMAX(num_zero_coeffs, pos);
-  }
-  memset(tcoeffs, 0, (num_zero_coeffs + 1) * sizeof(tcoeffs[0]));
-
-  for (int c = 0; c < *eob; ++c) {
-    const int pos = scan[c];
-    uint8_t sign;
-    tran_low_t level = levels[get_padded_idx(pos, bwl)];
-    if (level) {
-      *max_scan_line = AOMMAX(*max_scan_line, pos);
-      if (c == 0) {
-        const int dc_sign_ctx = txb_ctx->dc_sign_ctx;
-        sign = aom_read_symbol(r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx],
-                               2, ACCT_STR);
-      } else {
-        sign = aom_read_bit(r, ACCT_STR);
-      }
-      if (level >= MAX_BASE_BR_RANGE) {
-        level += read_golomb(xd, r);
-      }
-
-      if (c == 0) dc_val = sign ? -level : level;
-
-      // Bitmasking to clamp level to valid range:
-      //   The valid range for 8/10/12 bit vdieo is at most 14/16/18 bit
-      level &= 0xfffff;
-      cul_level += level;
-      tran_low_t dq_coeff;
-      // Bitmasking to clamp dq_coeff to valid range:
-      //   The valid range for 8/10/12 bit video is at most 17/19/21 bit
-      dq_coeff = (tran_low_t)(
-          (int64_t)level * get_dqv(dequant, scan[c], iqmatrix) & 0xffffff);
-      dq_coeff = dq_coeff >> shift;
-      if (sign) {
-        dq_coeff = -dq_coeff;
-      }
-      tcoeffs[pos] = clamp(dq_coeff, min_value, max_value);
-    }
-  }
-
-  cul_level = AOMMIN(COEFF_CONTEXT_MASK, cul_level);
-
-  // DC value
-  set_dc_sign(&cul_level, dc_val);
-
-  return cul_level;
-}
-
-void av1_read_coeffs_txb_facade(const AV1_COMMON *const cm,
-                                MACROBLOCKD *const xd, aom_reader *const r,
-                                const int plane, const int row, const int col,
-                                const TX_SIZE tx_size) {
-#if TXCOEFF_TIMER
-  struct aom_usec_timer timer;
-  aom_usec_timer_start(&timer);
-#endif
-  MB_MODE_INFO *const mbmi = xd->mi[0];
-  struct macroblockd_plane *const pd = &xd->plane[plane];
-
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  const BLOCK_SIZE plane_bsize =
-      get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
-
-  TXB_CTX txb_ctx;
-  get_txb_ctx(plane_bsize, tx_size, plane, pd->above_context + col,
-              pd->left_context + row, &txb_ctx);
-  const uint8_t cul_level =
-      av1_read_coeffs_txb(cm, xd, r, row, col, plane, &txb_ctx, tx_size);
-  av1_set_contexts(xd, pd, plane, plane_bsize, tx_size, cul_level, col, row);
-
-  if (is_inter_block(mbmi)) {
-    PLANE_TYPE plane_type = get_plane_type(plane);
-    // tx_type will be read out in av1_read_coeffs_txb_facade
-    const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, tx_size,
-                                            cm->reduced_tx_set_used);
-
-    if (plane == 0)
-      update_txk_array(mbmi->txk_type, mbmi->sb_type, row, col, tx_size,
-                       tx_type);
-  }
-
-#if TXCOEFF_TIMER
-  aom_usec_timer_mark(&timer);
-  const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);
-  cm->txcoeff_timer += elapsed_time;
-  ++cm->txb_count;
-#endif
-}
diff --git a/third_party/aom/av1/decoder/decodetxb.h b/third_party/aom/av1/decoder/decodetxb.h
deleted file mode 100644
index fe04f6abd..000000000
--- a/third_party/aom/av1/decoder/decodetxb.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2017, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#ifndef AOM_AV1_DECODER_DECODETXB_H_
-#define AOM_AV1_DECODER_DECODETXB_H_
-
-#include "config/aom_config.h"
-
-#include "av1/common/blockd.h"
-#include "av1/common/onyxc_int.h"
-#include "av1/common/txb_common.h"
-#include "aom_dsp/bitreader.h"
-
-uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
-                            aom_reader *const r, const int blk_row,
-                            const int blk_col, const int plane,
-                            const TXB_CTX *const txb_ctx,
-                            const TX_SIZE tx_size);
-
-void av1_read_coeffs_txb_facade(const AV1_COMMON *const cm,
-                                MACROBLOCKD *const xd, aom_reader *const r,
-                                const int plane, const int row, const int col,
-                                const TX_SIZE tx_size);
-#endif  // AOM_AV1_DECODER_DECODETXB_H_
diff --git a/third_party/aom/av1/decoder/detokenize.c b/third_party/aom/av1/decoder/detokenize.c
deleted file mode 100644
index 9d54bd13d..000000000
--- a/third_party/aom/av1/decoder/detokenize.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include "config/aom_config.h"
-
-#include "aom_mem/aom_mem.h"
-#include "aom_ports/mem.h"
-#include "av1/common/blockd.h"
-#include "av1/decoder/detokenize.h"
-
-#define ACCT_STR __func__
-
-#include "av1/common/common.h"
-#include "av1/common/entropy.h"
-#include "av1/common/idct.h"
-
-static void decode_color_map_tokens(Av1ColorMapParam *param, aom_reader *r) {
-  uint8_t color_order[PALETTE_MAX_SIZE];
-  const int n = param->n_colors;
-  uint8_t *const color_map = param->color_map;
-  MapCdf color_map_cdf = param->map_cdf;
-  int plane_block_width = param->plane_width;
-  int plane_block_height = param->plane_height;
-  int rows = param->rows;
-  int cols = param->cols;
-
-  // The first color index.
-  color_map[0] = av1_read_uniform(r, n);
-  assert(color_map[0] < n);
-
-  // Run wavefront on the palette map index decoding.
-  for (int i = 1; i < rows + cols - 1; ++i) {
-    for (int j = AOMMIN(i, cols - 1); j >= AOMMAX(0, i - rows + 1); --j) {
-      const int color_ctx = av1_get_palette_color_index_context(
-          color_map, plane_block_width, (i - j), j, n, color_order, NULL);
-      const int color_idx = aom_read_symbol(
-          r, color_map_cdf[n - PALETTE_MIN_SIZE][color_ctx], n, ACCT_STR);
-      assert(color_idx >= 0 && color_idx < n);
-      color_map[(i - j) * plane_block_width + j] = color_order[color_idx];
-    }
-  }
-  // Copy last column to extra columns.
-  if (cols < plane_block_width) {
-    for (int i = 0; i < rows; ++i) {
-      memset(color_map + i * plane_block_width + cols,
-             color_map[i * plane_block_width + cols - 1],
-             (plane_block_width - cols));
-    }
-  }
-  // Copy last row to extra rows.
-  for (int i = rows; i < plane_block_height; ++i) {
-    memcpy(color_map + i * plane_block_width,
-           color_map + (rows - 1) * plane_block_width, plane_block_width);
-  }
-}
-
-void av1_decode_palette_tokens(MACROBLOCKD *const xd, int plane,
-                               aom_reader *r) {
-  assert(plane == 0 || plane == 1);
-  Av1ColorMapParam params;
-  params.color_map =
-      xd->plane[plane].color_index_map + xd->color_index_map_offset[plane];
-  params.map_cdf = plane ? xd->tile_ctx->palette_uv_color_index_cdf
-                         : xd->tile_ctx->palette_y_color_index_cdf;
-  const MB_MODE_INFO *const mbmi = xd->mi[0];
-  params.n_colors = mbmi->palette_mode_info.palette_size[plane];
-  av1_get_block_dimensions(mbmi->sb_type, plane, xd, &params.plane_width,
-                           &params.plane_height, &params.rows, &params.cols);
-  decode_color_map_tokens(&params, r);
-}
diff --git a/third_party/aom/av1/decoder/detokenize.h b/third_party/aom/av1/decoder/detokenize.h
deleted file mode 100644
index 173b437a9..000000000
--- a/third_party/aom/av1/decoder/detokenize.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#ifndef AOM_AV1_DECODER_DETOKENIZE_H_
-#define AOM_AV1_DECODER_DETOKENIZE_H_
-
-#include "config/aom_config.h"
-
-#include "av1/common/scan.h"
-#include "av1/decoder/decoder.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void av1_decode_palette_tokens(MACROBLOCKD *const xd, int plane, aom_reader *r);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-#endif  // AOM_AV1_DECODER_DETOKENIZE_H_
diff --git a/third_party/aom/av1/decoder/dthread.c b/third_party/aom/av1/decoder/dthread.c
deleted file mode 100644
index 3946c787a..000000000
--- a/third_party/aom/av1/decoder/dthread.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include "config/aom_config.h"
-
-#include "aom_mem/aom_mem.h"
-#include "av1/common/reconinter.h"
-#include "av1/decoder/dthread.h"
-#include "av1/decoder/decoder.h"
-
-// #define DEBUG_THREAD
-
-// TODO(hkuang): Clean up all the #ifdef in this file.
-void av1_frameworker_lock_stats(AVxWorker *const worker) {
-#if CONFIG_MULTITHREAD
-  FrameWorkerData *const worker_data = worker->data1;
-  pthread_mutex_lock(&worker_data->stats_mutex);
-#else
-  (void)worker;
-#endif
-}
-
-void av1_frameworker_unlock_stats(AVxWorker *const worker) {
-#if CONFIG_MULTITHREAD
-  FrameWorkerData *const worker_data = worker->data1;
-  pthread_mutex_unlock(&worker_data->stats_mutex);
-#else
-  (void)worker;
-#endif
-}
-
-void av1_frameworker_signal_stats(AVxWorker *const worker) {
-#if CONFIG_MULTITHREAD
-  FrameWorkerData *const worker_data = worker->data1;
-
-// TODO(hkuang): Fix the pthread_cond_broadcast in windows wrapper.
-#if defined(_WIN32) && !HAVE_PTHREAD_H
-  pthread_cond_signal(&worker_data->stats_cond);
-#else
-  pthread_cond_broadcast(&worker_data->stats_cond);
-#endif
-
-#else
-  (void)worker;
-#endif
-}
-
-// This macro prevents thread_sanitizer from reporting known concurrent writes.
-#if defined(__has_feature)
-#if __has_feature(thread_sanitizer)
-#define BUILDING_WITH_TSAN
-#endif
-#endif
-
-// TODO(hkuang): Remove worker parameter as it is only used in debug code.
-void av1_frameworker_wait(AVxWorker *const worker, RefCntBuffer *const ref_buf,
-                          int row) {
-#if CONFIG_MULTITHREAD
-  if (!ref_buf) return;
-
-#ifndef BUILDING_WITH_TSAN
-  // The following line of code will get harmless tsan error but it is the key
-  // to get best performance.
-  if (ref_buf->row >= row && ref_buf->buf.corrupted != 1) return;
-#endif
-
-  {
-    // Find the worker thread that owns the reference frame. If the reference
-    // frame has been fully decoded, it may not have owner.
-    AVxWorker *const ref_worker = ref_buf->frame_worker_owner;
-    FrameWorkerData *const ref_worker_data =
-        (FrameWorkerData *)ref_worker->data1;
-    const AV1Decoder *const pbi = ref_worker_data->pbi;
-
-#ifdef DEBUG_THREAD
-    {
-      FrameWorkerData *const worker_data = (FrameWorkerData *)worker->data1;
-      printf("%d %p worker is waiting for %d %p worker (%d)  ref %d \r\n",
-             worker_data->worker_id, worker, ref_worker_data->worker_id,
-             ref_buf->frame_worker_owner, row, ref_buf->row);
-    }
-#endif
-
-    av1_frameworker_lock_stats(ref_worker);
-    while (ref_buf->row < row && pbi->cur_buf == ref_buf &&
-           ref_buf->buf.corrupted != 1) {
-      pthread_cond_wait(&ref_worker_data->stats_cond,
-                        &ref_worker_data->stats_mutex);
-    }
-
-    if (ref_buf->buf.corrupted == 1) {
-      FrameWorkerData *const worker_data = (FrameWorkerData *)worker->data1;
-      av1_frameworker_unlock_stats(ref_worker);
-      aom_internal_error(&worker_data->pbi->common.error,
-                         AOM_CODEC_CORRUPT_FRAME,
-                         "Worker %p failed to decode frame", worker);
-    }
-    av1_frameworker_unlock_stats(ref_worker);
-  }
-#else
-  (void)worker;
-  (void)ref_buf;
-  (void)row;
-  (void)ref_buf;
-#endif  // CONFIG_MULTITHREAD
-}
-
-void av1_frameworker_broadcast(RefCntBuffer *const buf, int row) {
-#if CONFIG_MULTITHREAD
-  AVxWorker *worker = buf->frame_worker_owner;
-
-#ifdef DEBUG_THREAD
-  {
-    FrameWorkerData *const worker_data = (FrameWorkerData *)worker->data1;
-    printf("%d %p worker decode to (%d) \r\n", worker_data->worker_id,
-           buf->frame_worker_owner, row);
-  }
-#endif
-
-  av1_frameworker_lock_stats(worker);
-  buf->row = row;
-  av1_frameworker_signal_stats(worker);
-  av1_frameworker_unlock_stats(worker);
-#else
-  (void)buf;
-  (void)row;
-#endif  // CONFIG_MULTITHREAD
-}
-
-void av1_frameworker_copy_context(AVxWorker *const dst_worker,
-                                  AVxWorker *const src_worker) {
-#if CONFIG_MULTITHREAD
-  FrameWorkerData *const src_worker_data = (FrameWorkerData *)src_worker->data1;
-  FrameWorkerData *const dst_worker_data = (FrameWorkerData *)dst_worker->data1;
-  AV1_COMMON *const src_cm = &src_worker_data->pbi->common;
-  AV1_COMMON *const dst_cm = &dst_worker_data->pbi->common;
-  int i;
-
-  // Wait until source frame's context is ready.
-  av1_frameworker_lock_stats(src_worker);
-  while (!src_worker_data->frame_context_ready) {
-    pthread_cond_wait(&src_worker_data->stats_cond,
-                      &src_worker_data->stats_mutex);
-  }
-
-  dst_cm->last_frame_seg_map = src_cm->seg.enabled
-                                   ? src_cm->current_frame_seg_map
-                                   : src_cm->last_frame_seg_map;
-  dst_worker_data->pbi->need_resync = src_worker_data->pbi->need_resync;
-  av1_frameworker_unlock_stats(src_worker);
-
-  dst_cm->seq_params.bit_depth = src_cm->seq_params.bit_depth;
-  dst_cm->seq_params.use_highbitdepth = src_cm->seq_params.use_highbitdepth;
-  // TODO(zoeliu): To handle parallel decoding
-  dst_cm->prev_frame =
-      src_cm->show_existing_frame ? src_cm->prev_frame : src_cm->cur_frame;
-  dst_cm->last_width =
-      !src_cm->show_existing_frame ? src_cm->width : src_cm->last_width;
-  dst_cm->last_height =
-      !src_cm->show_existing_frame ? src_cm->height : src_cm->last_height;
-  dst_cm->seq_params.subsampling_x = src_cm->seq_params.subsampling_x;
-  dst_cm->seq_params.subsampling_y = src_cm->seq_params.subsampling_y;
-  dst_cm->frame_type = src_cm->frame_type;
-  dst_cm->last_show_frame = !src_cm->show_existing_frame
-                                ? src_cm->show_frame
-                                : src_cm->last_show_frame;
-  for (i = 0; i < REF_FRAMES; ++i)
-    dst_cm->ref_frame_map[i] = src_cm->next_ref_frame_map[i];
-
-  memcpy(dst_cm->lf_info.lfthr, src_cm->lf_info.lfthr,
-         (MAX_LOOP_FILTER + 1) * sizeof(loop_filter_thresh));
-  dst_cm->lf.sharpness_level = src_cm->lf.sharpness_level;
-  dst_cm->lf.filter_level[0] = src_cm->lf.filter_level[0];
-  dst_cm->lf.filter_level[1] = src_cm->lf.filter_level[1];
-  memcpy(dst_cm->lf.ref_deltas, src_cm->lf.ref_deltas, REF_FRAMES);
-  memcpy(dst_cm->lf.mode_deltas, src_cm->lf.mode_deltas, MAX_MODE_LF_DELTAS);
-  dst_cm->seg = src_cm->seg;
-  memcpy(dst_cm->frame_contexts, src_cm->frame_contexts,
-         FRAME_CONTEXTS * sizeof(dst_cm->frame_contexts[0]));
-#else
-  (void)dst_worker;
-  (void)src_worker;
-#endif  // CONFIG_MULTITHREAD
-}
diff --git a/third_party/aom/av1/decoder/dthread.h b/third_party/aom/av1/decoder/dthread.h
deleted file mode 100644
index 1d264b07e..000000000
--- a/third_party/aom/av1/decoder/dthread.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2016, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#ifndef AOM_AV1_DECODER_DTHREAD_H_
-#define AOM_AV1_DECODER_DTHREAD_H_
-
-#include "config/aom_config.h"
-
-#include "aom_util/aom_thread.h"
-#include "aom/internal/aom_codec_internal.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct AV1Common;
-struct AV1Decoder;
-struct ThreadData;
-
-typedef struct DecWorkerData {
-  struct ThreadData *td;
-  const uint8_t *data_end;
-  struct aom_internal_error_info error_info;
-} DecWorkerData;
-
-// WorkerData for the FrameWorker thread. It contains all the information of
-// the worker and decode structures for decoding a frame.
-typedef struct FrameWorkerData {
-  struct AV1Decoder *pbi;
-  const uint8_t *data;
-  const uint8_t *data_end;
-  size_t data_size;
-  void *user_priv;
-  int worker_id;
-  int received_frame;
-
-  // scratch_buffer is used in frame parallel mode only.
-  // It is used to make a copy of the compressed data.
-  uint8_t *scratch_buffer;
-  size_t scratch_buffer_size;
-
-#if CONFIG_MULTITHREAD
-  pthread_mutex_t stats_mutex;
-  pthread_cond_t stats_cond;
-#endif
-
-  int frame_context_ready;  // Current frame's context is ready to read.
-  int frame_decoded;        // Finished decoding current frame.
-} FrameWorkerData;
-
-void av1_frameworker_lock_stats(AVxWorker *const worker);
-void av1_frameworker_unlock_stats(AVxWorker *const worker);
-void av1_frameworker_signal_stats(AVxWorker *const worker);
-
-// Wait until ref_buf has been decoded to row in real pixel unit.
-// Note: worker may already finish decoding ref_buf and release it in order to
-// start decoding next frame. So need to check whether worker is still decoding
-// ref_buf.
-void av1_frameworker_wait(AVxWorker *const worker, RefCntBuffer *const ref_buf,
-                          int row);
-
-// FrameWorker broadcasts its decoding progress so other workers that are
-// waiting on it can resume decoding.
-void av1_frameworker_broadcast(RefCntBuffer *const buf, int row);
-
-// Copy necessary decoding context from src worker to dst worker.
-void av1_frameworker_copy_context(AVxWorker *const dst_worker,
-                                  AVxWorker *const src_worker);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#endif  // AOM_AV1_DECODER_DTHREAD_H_
diff --git a/third_party/aom/av1/decoder/inspection.c b/third_party/aom/av1/decoder/inspection.c
deleted file mode 100644
index e6c89298a..000000000
--- a/third_party/aom/av1/decoder/inspection.c
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-#include "av1/decoder/decoder.h"
-#include "av1/decoder/inspection.h"
-#include "av1/common/enums.h"
-#include "av1/common/cdef.h"
-
-static void ifd_init_mi_rc(insp_frame_data *fd, int mi_cols, int mi_rows) {
-  fd->mi_cols = mi_cols;
-  fd->mi_rows = mi_rows;
-  fd->mi_grid = (insp_mi_data *)aom_malloc(sizeof(insp_mi_data) * fd->mi_rows *
-                                           fd->mi_cols);
-}
-
-void ifd_init(insp_frame_data *fd, int frame_width, int frame_height) {
-  int mi_cols = ALIGN_POWER_OF_TWO(frame_width, 3) >> MI_SIZE_LOG2;
-  int mi_rows = ALIGN_POWER_OF_TWO(frame_height, 3) >> MI_SIZE_LOG2;
-  ifd_init_mi_rc(fd, mi_cols, mi_rows);
-}
-
-void ifd_clear(insp_frame_data *fd) {
-  aom_free(fd->mi_grid);
-  fd->mi_grid = NULL;
-}
-
-/* TODO(negge) This function may be called by more than one thread when using
-               a multi-threaded decoder and this may cause a data race. */
-int ifd_inspect(insp_frame_data *fd, void *decoder) {
-  struct AV1Decoder *pbi = (struct AV1Decoder *)decoder;
-  AV1_COMMON *const cm = &pbi->common;
-  if (fd->mi_rows != cm->mi_rows || fd->mi_cols != cm->mi_cols) {
-    ifd_clear(fd);
-    ifd_init_mi_rc(fd, cm->mi_rows, cm->mi_cols);
-  }
-  fd->show_frame = cm->show_frame;
-  fd->frame_type = cm->frame_type;
-  fd->base_qindex = cm->base_qindex;
-  // Set width and height of the first tile until generic support can be added
-  TileInfo tile_info;
-  av1_tile_set_row(&tile_info, cm, 0);
-  av1_tile_set_col(&tile_info, cm, 0);
-  fd->tile_mi_cols = tile_info.mi_col_end - tile_info.mi_col_start;
-  fd->tile_mi_rows = tile_info.mi_row_end - tile_info.mi_row_start;
-  fd->delta_q_present_flag = cm->delta_q_present_flag;
-  fd->delta_q_res = cm->delta_q_res;
-#if CONFIG_ACCOUNTING
-  fd->accounting = &pbi->accounting;
-#endif
-  // TODO(negge): copy per frame CDEF data
-  int i, j;
-  for (i = 0; i < MAX_SEGMENTS; i++) {
-    for (j = 0; j < 2; j++) {
-      fd->y_dequant[i][j] = cm->y_dequant_QTX[i][j];
-      fd->u_dequant[i][j] = cm->u_dequant_QTX[i][j];
-      fd->v_dequant[i][j] = cm->v_dequant_QTX[i][j];
-    }
-  }
-  for (j = 0; j < cm->mi_rows; j++) {
-    for (i = 0; i < cm->mi_cols; i++) {
-      const MB_MODE_INFO *mbmi = cm->mi_grid_visible[j * cm->mi_stride + i];
-      insp_mi_data *mi = &fd->mi_grid[j * cm->mi_cols + i];
-      // Segment
-      mi->segment_id = mbmi->segment_id;
-      // Motion Vectors
-      mi->mv[0].row = mbmi->mv[0].as_mv.row;
-      mi->mv[0].col = mbmi->mv[0].as_mv.col;
-      mi->mv[1].row = mbmi->mv[1].as_mv.row;
-      mi->mv[1].col = mbmi->mv[1].as_mv.col;
-      // Reference Frames
-      mi->ref_frame[0] = mbmi->ref_frame[0];
-      mi->ref_frame[1] = mbmi->ref_frame[1];
-      // Prediction Mode
-      mi->mode = mbmi->mode;
-      // Prediction Mode for Chromatic planes
-      if (mi->mode < INTRA_MODES) {
-        mi->uv_mode = mbmi->uv_mode;
-      } else {
-        mi->uv_mode = UV_MODE_INVALID;
-      }
-      // Block Size
-      mi->sb_type = mbmi->sb_type;
-      // Skip Flag
-      mi->skip = mbmi->skip;
-      mi->filter[0] = av1_extract_interp_filter(mbmi->interp_filters, 0);
-      mi->filter[1] = av1_extract_interp_filter(mbmi->interp_filters, 1);
-      mi->dual_filter_type = mi->filter[0] * 3 + mi->filter[1];
-      // Transform
-      // TODO(anyone): extract tx type info from mbmi->txk_type[].
-      mi->tx_type = DCT_DCT;
-      mi->tx_size = mbmi->tx_size;
-
-      mi->cdef_level =
-          cm->cdef_strengths[mbmi->cdef_strength] / CDEF_SEC_STRENGTHS;
-      mi->cdef_strength =
-          cm->cdef_strengths[mbmi->cdef_strength] % CDEF_SEC_STRENGTHS;
-      mi->cdef_strength += mi->cdef_strength == 3;
-      if (mbmi->uv_mode == UV_CFL_PRED) {
-        mi->cfl_alpha_idx = mbmi->cfl_alpha_idx;
-        mi->cfl_alpha_sign = mbmi->cfl_alpha_signs;
-      } else {
-        mi->cfl_alpha_idx = 0;
-        mi->cfl_alpha_sign = 0;
-      }
-      // delta_q
-      mi->current_qindex = mbmi->current_qindex;
-    }
-  }
-  return 1;
-}
diff --git a/third_party/aom/av1/decoder/inspection.h b/third_party/aom/av1/decoder/inspection.h
deleted file mode 100644
index 7214a9bed..000000000
--- a/third_party/aom/av1/decoder/inspection.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2017, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-#ifndef AOM_AV1_DECODER_INSPECTION_H_
-#define AOM_AV1_DECODER_INSPECTION_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif  // __cplusplus
-
-#include "av1/common/seg_common.h"
-#if CONFIG_ACCOUNTING
-#include "av1/decoder/accounting.h"
-#endif
-
-#ifndef AOM_AOMDX_H_
-typedef void (*aom_inspect_cb)(void *decoder, void *data);
-#endif
-
-typedef struct insp_mv insp_mv;
-
-struct insp_mv {
-  int16_t row;
-  int16_t col;
-};
-
-typedef struct insp_mi_data insp_mi_data;
-
-struct insp_mi_data {
-  insp_mv mv[2];
-  int16_t ref_frame[2];
-  int16_t mode;
-  int16_t uv_mode;
-  int16_t sb_type;
-  int16_t skip;
-  int16_t segment_id;
-  int16_t dual_filter_type;
-  int16_t filter[2];
-  int16_t tx_type;
-  int16_t tx_size;
-  int16_t cdef_level;
-  int16_t cdef_strength;
-  int16_t cfl_alpha_idx;
-  int16_t cfl_alpha_sign;
-  int16_t current_qindex;
-};
-
-typedef struct insp_frame_data insp_frame_data;
-
-struct insp_frame_data {
-#if CONFIG_ACCOUNTING
-  Accounting *accounting;
-#endif
-  insp_mi_data *mi_grid;
-  int show_frame;
-  int frame_type;
-  int base_qindex;
-  int mi_rows;
-  int mi_cols;
-  int tile_mi_rows;
-  int tile_mi_cols;
-  int16_t y_dequant[MAX_SEGMENTS][2];
-  int16_t u_dequant[MAX_SEGMENTS][2];
-  int16_t v_dequant[MAX_SEGMENTS][2];
-  // TODO(negge): add per frame CDEF data
-  int delta_q_present_flag;
-  int delta_q_res;
-};
-
-void ifd_init(insp_frame_data *fd, int frame_width, int frame_height);
-void ifd_clear(insp_frame_data *fd);
-int ifd_inspect(insp_frame_data *fd, void *decoder);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif  // __cplusplus
-#endif  // AOM_AV1_DECODER_INSPECTION_H_
diff --git a/third_party/aom/av1/decoder/obu.c b/third_party/aom/av1/decoder/obu.c
deleted file mode 100644
index 44ecf818e..000000000
--- a/third_party/aom/av1/decoder/obu.c
+++ /dev/null
@@ -1,839 +0,0 @@
-/*
- * Copyright (c) 2017, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include <assert.h>
-
-#include "config/aom_config.h"
-
-#include "aom/aom_codec.h"
-#include "aom_dsp/bitreader_buffer.h"
-#include "aom_ports/mem_ops.h"
-
-#include "av1/common/common.h"
-#include "av1/common/obu_util.h"
-#include "av1/common/timing.h"
-#include "av1/decoder/decoder.h"
-#include "av1/decoder/decodeframe.h"
-#include "av1/decoder/obu.h"
-
-// Picture prediction structures (0-12 are predefined) in scalability metadata.
-typedef enum {
-  SCALABILITY_L1T2 = 0,
-  SCALABILITY_L1T3 = 1,
-  SCALABILITY_L2T1 = 2,
-  SCALABILITY_L2T2 = 3,
-  SCALABILITY_L2T3 = 4,
-  SCALABILITY_S2T1 = 5,
-  SCALABILITY_S2T2 = 6,
-  SCALABILITY_S2T3 = 7,
-  SCALABILITY_L2T1h = 8,
-  SCALABILITY_L2T2h = 9,
-  SCALABILITY_L2T3h = 10,
-  SCALABILITY_S2T1h = 11,
-  SCALABILITY_S2T2h = 12,
-  SCALABILITY_S2T3h = 13,
-  SCALABILITY_SS = 14
-} SCALABILITY_STRUCTURES;
-
-aom_codec_err_t aom_get_num_layers_from_operating_point_idc(
-    int operating_point_idc, unsigned int *number_spatial_layers,
-    unsigned int *number_temporal_layers) {
-  // derive number of spatial/temporal layers from operating_point_idc
-
-  if (!number_spatial_layers || !number_temporal_layers)
-    return AOM_CODEC_INVALID_PARAM;
-
-  if (operating_point_idc == 0) {
-    *number_temporal_layers = 1;
-    *number_spatial_layers = 1;
-  } else {
-    *number_spatial_layers = 0;
-    *number_temporal_layers = 0;
-    for (int j = 0; j < MAX_NUM_SPATIAL_LAYERS; j++) {
-      *number_spatial_layers +=
-          (operating_point_idc >> (j + MAX_NUM_TEMPORAL_LAYERS)) & 0x1;
-    }
-    for (int j = 0; j < MAX_NUM_TEMPORAL_LAYERS; j++) {
-      *number_temporal_layers += (operating_point_idc >> j) & 0x1;
-    }
-  }
-
-  return AOM_CODEC_OK;
-}
-
-static int is_obu_in_current_operating_point(AV1Decoder *pbi,
-                                             ObuHeader obu_header) {
-  if (!pbi->current_operating_point) {
-    return 1;
-  }
-
-  if ((pbi->current_operating_point >> obu_header.temporal_layer_id) & 0x1 &&
-      (pbi->current_operating_point >> (obu_header.spatial_layer_id + 8)) &
-          0x1) {
-    return 1;
-  }
-  return 0;
-}
-
-static int byte_alignment(AV1_COMMON *const cm,
-                          struct aom_read_bit_buffer *const rb) {
-  while (rb->bit_offset & 7) {
-    if (aom_rb_read_bit(rb)) {
-      cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-      return -1;
-    }
-  }
-  return 0;
-}
-
-static uint32_t read_temporal_delimiter_obu() { return 0; }
-
-// Returns a boolean that indicates success.
-static int read_bitstream_level(BitstreamLevel *bl,
-                                struct aom_read_bit_buffer *rb) {
-  const uint8_t seq_level_idx = aom_rb_read_literal(rb, LEVEL_BITS);
-  if (!is_valid_seq_level_idx(seq_level_idx)) return 0;
-  bl->major = (seq_level_idx >> LEVEL_MINOR_BITS) + LEVEL_MAJOR_MIN;
-  bl->minor = seq_level_idx & ((1 << LEVEL_MINOR_BITS) - 1);
-  return 1;
-}
-
-// Returns whether two sequence headers are consistent with each other.
-// TODO(huisu,wtc@google.com): make sure the code matches the spec exactly.
-static int are_seq_headers_consistent(const SequenceHeader *seq_params_old,
-                                      const SequenceHeader *seq_params_new) {
-  return !memcmp(seq_params_old, seq_params_new, sizeof(SequenceHeader));
-}
-
-// On success, sets pbi->sequence_header_ready to 1 and returns the number of
-// bytes read from 'rb'.
-// On failure, sets pbi->common.error.error_code and returns 0.
-static uint32_t read_sequence_header_obu(AV1Decoder *pbi,
-                                         struct aom_read_bit_buffer *rb) {
-  AV1_COMMON *const cm = &pbi->common;
-  const uint32_t saved_bit_offset = rb->bit_offset;
-
-  // Verify rb has been configured to report errors.
-  assert(rb->error_handler);
-
-  // Use a local variable to store the information as we decode. At the end,
-  // if no errors have occurred, cm->seq_params is updated.
-  SequenceHeader sh = cm->seq_params;
-  SequenceHeader *const seq_params = &sh;
-
-  seq_params->profile = av1_read_profile(rb);
-  if (seq_params->profile > CONFIG_MAX_DECODE_PROFILE) {
-    cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
-    return 0;
-  }
-
-  // Still picture or not
-  seq_params->still_picture = aom_rb_read_bit(rb);
-  seq_params->reduced_still_picture_hdr = aom_rb_read_bit(rb);
-  // Video must have reduced_still_picture_hdr = 0
-  if (!seq_params->still_picture && seq_params->reduced_still_picture_hdr) {
-    cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
-    return 0;
-  }
-
-  if (seq_params->reduced_still_picture_hdr) {
-    cm->timing_info_present = 0;
-    seq_params->decoder_model_info_present_flag = 0;
-    seq_params->display_model_info_present_flag = 0;
-    seq_params->operating_points_cnt_minus_1 = 0;
-    seq_params->operating_point_idc[0] = 0;
-    if (!read_bitstream_level(&seq_params->level[0], rb)) {
-      cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
-      return 0;
-    }
-    seq_params->tier[0] = 0;
-    cm->op_params[0].decoder_model_param_present_flag = 0;
-    cm->op_params[0].display_model_param_present_flag = 0;
-  } else {
-    cm->timing_info_present = aom_rb_read_bit(rb);  // timing_info_present_flag
-    if (cm->timing_info_present) {
-      av1_read_timing_info_header(cm, rb);
-
-      seq_params->decoder_model_info_present_flag = aom_rb_read_bit(rb);
-      if (seq_params->decoder_model_info_present_flag)
-        av1_read_decoder_model_info(cm, rb);
-    } else {
-      seq_params->decoder_model_info_present_flag = 0;
-    }
-    seq_params->display_model_info_present_flag = aom_rb_read_bit(rb);
-    seq_params->operating_points_cnt_minus_1 =
-        aom_rb_read_literal(rb, OP_POINTS_CNT_MINUS_1_BITS);
-    for (int i = 0; i < seq_params->operating_points_cnt_minus_1 + 1; i++) {
-      seq_params->operating_point_idc[i] =
-          aom_rb_read_literal(rb, OP_POINTS_IDC_BITS);
-      if (!read_bitstream_level(&seq_params->level[i], rb)) {
-        cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
-        return 0;
-      }
-      // This is the seq_level_idx[i] > 7 check in the spec. seq_level_idx 7
-      // is equivalent to level 3.3.
-      if (seq_params->level[i].major > 3)
-        seq_params->tier[i] = aom_rb_read_bit(rb);
-      else
-        seq_params->tier[i] = 0;
-      if (seq_params->decoder_model_info_present_flag) {
-        cm->op_params[i].decoder_model_param_present_flag = aom_rb_read_bit(rb);
-        if (cm->op_params[i].decoder_model_param_present_flag)
-          av1_read_op_parameters_info(cm, rb, i);
-      } else {
-        cm->op_params[i].decoder_model_param_present_flag = 0;
-      }
-      if (cm->timing_info_present &&
-          (cm->timing_info.equal_picture_interval ||
-           cm->op_params[i].decoder_model_param_present_flag)) {
-        cm->op_params[i].bitrate = max_level_bitrate(
-            seq_params->profile,
-            major_minor_to_seq_level_idx(seq_params->level[i]),
-            seq_params->tier[i]);
-        // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass
-        // the check
-        if (cm->op_params[i].bitrate == 0)
-          aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                             "AV1 does not support this combination of "
-                             "profile, level, and tier.");
-        // Buffer size in bits/s is bitrate in bits/s * 1 s
-        cm->op_params[i].buffer_size = cm->op_params[i].bitrate;
-      }
-      if (cm->timing_info_present && cm->timing_info.equal_picture_interval &&
-          !cm->op_params[i].decoder_model_param_present_flag) {
-        // When the decoder_model_parameters are not sent for this op, set
-        // the default ones that can be used with the resource availability mode
-        cm->op_params[i].decoder_buffer_delay = 70000;
-        cm->op_params[i].encoder_buffer_delay = 20000;
-        cm->op_params[i].low_delay_mode_flag = 0;
-      }
-
-      if (seq_params->display_model_info_present_flag) {
-        cm->op_params[i].display_model_param_present_flag = aom_rb_read_bit(rb);
-        if (cm->op_params[i].display_model_param_present_flag) {
-          cm->op_params[i].initial_display_delay =
-              aom_rb_read_literal(rb, 4) + 1;
-          if (cm->op_params[i].initial_display_delay > 10)
-            aom_internal_error(
-                &cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                "AV1 does not support more than 10 decoded frames delay");
-        } else {
-          cm->op_params[i].initial_display_delay = 10;
-        }
-      } else {
-        cm->op_params[i].display_model_param_present_flag = 0;
-        cm->op_params[i].initial_display_delay = 10;
-      }
-    }
-  }
-  // This decoder supports all levels.  Choose operating point provided by
-  // external means
-  int operating_point = pbi->operating_point;
-  if (operating_point < 0 ||
-      operating_point > seq_params->operating_points_cnt_minus_1)
-    operating_point = 0;
-  pbi->current_operating_point =
-      seq_params->operating_point_idc[operating_point];
-  if (aom_get_num_layers_from_operating_point_idc(
-          pbi->current_operating_point, &cm->number_spatial_layers,
-          &cm->number_temporal_layers) != AOM_CODEC_OK) {
-    cm->error.error_code = AOM_CODEC_ERROR;
-    return 0;
-  }
-
-  av1_read_sequence_header(cm, rb, seq_params);
-
-  av1_read_color_config(rb, pbi->allow_lowbitdepth, seq_params, &cm->error);
-  if (!(seq_params->subsampling_x == 0 && seq_params->subsampling_y == 0) &&
-      !(seq_params->subsampling_x == 1 && seq_params->subsampling_y == 1) &&
-      !(seq_params->subsampling_x == 1 && seq_params->subsampling_y == 0)) {
-    aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-                       "Only 4:4:4, 4:2:2 and 4:2:0 are currently supported, "
-                       "%d %d subsampling is not supported.\n",
-                       seq_params->subsampling_x, seq_params->subsampling_y);
-  }
-
-  seq_params->film_grain_params_present = aom_rb_read_bit(rb);
-
-  if (av1_check_trailing_bits(pbi, rb) != 0) {
-    // cm->error.error_code is already set.
-    return 0;
-  }
-
-  // If a sequence header has been decoded before, we check if the new
-  // one is consistent with the old one.
-  if (pbi->sequence_header_ready) {
-    if (!are_seq_headers_consistent(&cm->seq_params, seq_params))
-      pbi->sequence_header_changed = 1;
-  }
-
-  cm->seq_params = *seq_params;
-  pbi->sequence_header_ready = 1;
-
-  return ((rb->bit_offset - saved_bit_offset + 7) >> 3);
-}
-
-// On success, returns the frame header size. On failure, calls
-// aom_internal_error and does not return.
-static uint32_t read_frame_header_obu(AV1Decoder *pbi,
-                                      struct aom_read_bit_buffer *rb,
-                                      const uint8_t *data,
-                                      const uint8_t **p_data_end,
-                                      int trailing_bits_present) {
-  return av1_decode_frame_headers_and_setup(pbi, rb, data, p_data_end,
-                                            trailing_bits_present);
-}
-
-static int32_t read_tile_group_header(AV1Decoder *pbi,
-                                      struct aom_read_bit_buffer *rb,
-                                      int *start_tile, int *end_tile,
-                                      int tile_start_implicit) {
-  AV1_COMMON *const cm = &pbi->common;
-  uint32_t saved_bit_offset = rb->bit_offset;
-  int tile_start_and_end_present_flag = 0;
-  const int num_tiles = pbi->common.tile_rows * pbi->common.tile_cols;
-
-  if (!pbi->common.large_scale_tile && num_tiles > 1) {
-    tile_start_and_end_present_flag = aom_rb_read_bit(rb);
-  }
-  if (pbi->common.large_scale_tile || num_tiles == 1 ||
-      !tile_start_and_end_present_flag) {
-    *start_tile = 0;
-    *end_tile = num_tiles - 1;
-    return ((rb->bit_offset - saved_bit_offset + 7) >> 3);
-  }
-  if (tile_start_implicit && tile_start_and_end_present_flag) {
-    aom_internal_error(
-        &cm->error, AOM_CODEC_UNSUP_BITSTREAM,
-        "For OBU_FRAME type obu tile_start_and_end_present_flag must be 0");
-    return -1;
-  }
-  *start_tile =
-      aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols);
-  *end_tile = aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols);
-
-  return ((rb->bit_offset - saved_bit_offset + 7) >> 3);
-}
-
-static uint32_t read_one_tile_group_obu(
-    AV1Decoder *pbi, struct aom_read_bit_buffer *rb, int is_first_tg,
-    const uint8_t *data, const uint8_t *data_end, const uint8_t **p_data_end,
-    int *is_last_tg, int tile_start_implicit) {
-  AV1_COMMON *const cm = &pbi->common;
-  int start_tile, end_tile;
-  int32_t header_size, tg_payload_size;
-
-  assert((rb->bit_offset & 7) == 0);
-  assert(rb->bit_buffer + aom_rb_bytes_read(rb) == data);
-
-  header_size = read_tile_group_header(pbi, rb, &start_tile, &end_tile,
-                                       tile_start_implicit);
-  if (header_size == -1 || byte_alignment(cm, rb)) return 0;
-  if (start_tile > end_tile) return header_size;
-  data += header_size;
-  av1_decode_tg_tiles_and_wrapup(pbi, data, data_end, p_data_end, start_tile,
-                                 end_tile, is_first_tg);
-
-  tg_payload_size = (uint32_t)(*p_data_end - data);
-
-  // TODO(shan):  For now, assume all tile groups received in order
-  *is_last_tg = end_tile == cm->tile_rows * cm->tile_cols - 1;
-  return header_size + tg_payload_size;
-}
-
-static void alloc_tile_list_buffer(AV1Decoder *pbi) {
-  // TODO(yunqing): for now, copy each tile's decoded YUV data directly to the
-  // output buffer. This needs to be modified according to the application
-  // requirement.
-  AV1_COMMON *const cm = &pbi->common;
-  const int tile_width_in_pixels = cm->tile_width * MI_SIZE;
-  const int tile_height_in_pixels = cm->tile_height * MI_SIZE;
-  const int ssy = cm->seq_params.subsampling_y;
-  const int ssx = cm->seq_params.subsampling_x;
-  const int num_planes = av1_num_planes(cm);
-  const size_t yplane_tile_size = tile_height_in_pixels * tile_width_in_pixels;
-  const size_t uvplane_tile_size =
-      (num_planes > 1)
-          ? (tile_height_in_pixels >> ssy) * (tile_width_in_pixels >> ssx)
-          : 0;
-  const size_t tile_size = (cm->seq_params.use_highbitdepth ? 2 : 1) *
-                           (yplane_tile_size + 2 * uvplane_tile_size);
-  pbi->tile_list_size = tile_size * (pbi->tile_count_minus_1 + 1);
-
-  if (pbi->tile_list_size > pbi->buffer_sz) {
-    if (pbi->tile_list_output != NULL) aom_free(pbi->tile_list_output);
-    pbi->tile_list_output = NULL;
-
-    pbi->tile_list_output = (uint8_t *)aom_memalign(32, pbi->tile_list_size);
-    if (pbi->tile_list_output == NULL)
-      aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
-                         "Failed to allocate the tile list output buffer");
-    pbi->buffer_sz = pbi->tile_list_size;
-  }
-}
-
-static void copy_decoded_tile_to_tile_list_buffer(AV1Decoder *pbi,
-                                                  uint8_t **output) {
-  AV1_COMMON *const cm = &pbi->common;
-  const int tile_width_in_pixels = cm->tile_width * MI_SIZE;
-  const int tile_height_in_pixels = cm->tile_height * MI_SIZE;
-  const int ssy = cm->seq_params.subsampling_y;
-  const int ssx = cm->seq_params.subsampling_x;
-  const int num_planes = av1_num_planes(cm);
-
-  // Copy decoded tile to the tile list output buffer.
-  YV12_BUFFER_CONFIG *cur_frame = get_frame_new_buffer(cm);
-  const int mi_row = pbi->dec_tile_row * cm->tile_height;
-  const int mi_col = pbi->dec_tile_col * cm->tile_width;
-  const int is_hbd = (cur_frame->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0;
-  uint8_t *bufs[MAX_MB_PLANE] = { NULL, NULL, NULL };
-  int strides[MAX_MB_PLANE] = { 0, 0, 0 };
-  int plane;
-
-  for (plane = 0; plane < num_planes; ++plane) {
-    int shift_x = plane > 0 ? ssx : 0;
-    int shift_y = plane > 0 ? ssy : 0;
-
-    bufs[plane] = cur_frame->buffers[plane];
-    strides[plane] =
-        (plane > 0) ? cur_frame->strides[1] : cur_frame->strides[0];
-
-    bufs[plane] += mi_row * (MI_SIZE >> shift_y) * strides[plane] +
-                   mi_col * (MI_SIZE >> shift_x);
-
-    if (is_hbd) {
-      bufs[plane] = (uint8_t *)CONVERT_TO_SHORTPTR(bufs[plane]);
-      strides[plane] *= 2;
-    }
-
-    int w, h;
-    w = (plane > 0 && shift_x > 0) ? ((tile_width_in_pixels + 1) >> shift_x)
-                                   : tile_width_in_pixels;
-    w *= (1 + is_hbd);
-    h = (plane > 0 && shift_y > 0) ? ((tile_height_in_pixels + 1) >> shift_y)
-                                   : tile_height_in_pixels;
-    int j;
-
-    for (j = 0; j < h; ++j) {
-      memcpy(*output, bufs[plane], w);
-      bufs[plane] += strides[plane];
-      *output += w;
-    }
-  }
-}
-
-// Only called while large_scale_tile = 1.
-static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi,
-                                              struct aom_read_bit_buffer *rb,
-                                              const uint8_t *data,
-                                              const uint8_t *data_end,
-                                              const uint8_t **p_data_end,
-                                              int *frame_decoding_finished) {
-  AV1_COMMON *const cm = &pbi->common;
-  uint32_t tile_list_payload_size = 0;
-  const int num_tiles = cm->tile_cols * cm->tile_rows;
-  const int start_tile = 0;
-  const int end_tile = num_tiles - 1;
-  int i = 0;
-
-  // Process the tile list info.
-  pbi->output_frame_width_in_tiles_minus_1 = aom_rb_read_literal(rb, 8);
-  pbi->output_frame_height_in_tiles_minus_1 = aom_rb_read_literal(rb, 8);
-  pbi->tile_count_minus_1 = aom_rb_read_literal(rb, 16);
-  if (pbi->tile_count_minus_1 > MAX_TILES - 1) {
-    cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-    return 0;
-  }
-
-  // Allocate output frame buffer for the tile list.
-  alloc_tile_list_buffer(pbi);
-
-  uint32_t tile_list_info_bytes = 4;
-  tile_list_payload_size += tile_list_info_bytes;
-  data += tile_list_info_bytes;
-  uint8_t *output = pbi->tile_list_output;
-
-  for (i = 0; i <= pbi->tile_count_minus_1; i++) {
-    // Process 1 tile.
-    // Reset the bit reader.
-    rb->bit_offset = 0;
-    rb->bit_buffer = data;
-
-    // Read out the tile info.
-    uint32_t tile_info_bytes = 5;
-    // Set reference for each tile.
-    int ref_idx = aom_rb_read_literal(rb, 8);
-    if (ref_idx >= MAX_EXTERNAL_REFERENCES) {
-      cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-      return 0;
-    }
-    av1_set_reference_dec(cm, 0, 1, &pbi->ext_refs.refs[ref_idx]);
-
-    pbi->dec_tile_row = aom_rb_read_literal(rb, 8);
-    pbi->dec_tile_col = aom_rb_read_literal(rb, 8);
-    if (pbi->dec_tile_row < 0 || pbi->dec_tile_col < 0 ||
-        pbi->dec_tile_row >= cm->tile_rows ||
-        pbi->dec_tile_col >= cm->tile_cols) {
-      cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-      return 0;
-    }
-
-    pbi->coded_tile_data_size = aom_rb_read_literal(rb, 16) + 1;
-    data += tile_info_bytes;
-    if ((size_t)(data_end - data) < pbi->coded_tile_data_size) {
-      cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-      return 0;
-    }
-
-    av1_decode_tg_tiles_and_wrapup(pbi, data, data + pbi->coded_tile_data_size,
-                                   p_data_end, start_tile, end_tile, 0);
-    uint32_t tile_payload_size = (uint32_t)(*p_data_end - data);
-
-    tile_list_payload_size += tile_info_bytes + tile_payload_size;
-
-    // Update data ptr for next tile decoding.
-    data = *p_data_end;
-    assert(data <= data_end);
-
-    // Copy the decoded tile to the tile list output buffer.
-    copy_decoded_tile_to_tile_list_buffer(pbi, &output);
-  }
-
-  *frame_decoding_finished = 1;
-  return tile_list_payload_size;
-}
-
-static void read_metadata_itut_t35(const uint8_t *data, size_t sz) {
-  struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL };
-  for (size_t i = 0; i < sz; i++) {
-    aom_rb_read_literal(&rb, 8);
-  }
-}
-
-static void read_metadata_hdr_cll(const uint8_t *data, size_t sz) {
-  struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL };
-  aom_rb_read_literal(&rb, 16);  // max_cll
-  aom_rb_read_literal(&rb, 16);  // max_fall
-}
-
-static void read_metadata_hdr_mdcv(const uint8_t *data, size_t sz) {
-  struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL };
-  for (int i = 0; i < 3; i++) {
-    aom_rb_read_literal(&rb, 16);  // primary_i_chromaticity_x
-    aom_rb_read_literal(&rb, 16);  // primary_i_chromaticity_y
-  }
-
-  aom_rb_read_literal(&rb, 16);  // white_point_chromaticity_x
-  aom_rb_read_literal(&rb, 16);  // white_point_chromaticity_y
-
-  aom_rb_read_unsigned_literal(&rb, 32);  // luminance_max
-  aom_rb_read_unsigned_literal(&rb, 32);  // luminance_min
-}
-
-static void scalability_structure(struct aom_read_bit_buffer *rb) {
-  int spatial_layers_cnt = aom_rb_read_literal(rb, 2);
-  int spatial_layer_dimensions_present_flag = aom_rb_read_bit(rb);
-  int spatial_layer_description_present_flag = aom_rb_read_bit(rb);
-  int temporal_group_description_present_flag = aom_rb_read_bit(rb);
-  aom_rb_read_literal(rb, 3);  // reserved
-
-  if (spatial_layer_dimensions_present_flag) {
-    int i;
-    for (i = 0; i < spatial_layers_cnt + 1; i++) {
-      aom_rb_read_literal(rb, 16);
-      aom_rb_read_literal(rb, 16);
-    }
-  }
-  if (spatial_layer_description_present_flag) {
-    int i;
-    for (i = 0; i < spatial_layers_cnt + 1; i++) {
-      aom_rb_read_literal(rb, 8);
-    }
-  }
-  if (temporal_group_description_present_flag) {
-    int i, j, temporal_group_size;
-    temporal_group_size = aom_rb_read_literal(rb, 8);
-    for (i = 0; i < temporal_group_size; i++) {
-      aom_rb_read_literal(rb, 3);
-      aom_rb_read_bit(rb);
-      aom_rb_read_bit(rb);
-      int temporal_group_ref_cnt = aom_rb_read_literal(rb, 3);
-      for (j = 0; j < temporal_group_ref_cnt; j++) {
-        aom_rb_read_literal(rb, 8);
-      }
-    }
-  }
-}
-
-static void read_metadata_scalability(const uint8_t *data, size_t sz) {
-  struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL };
-  int scalability_mode_idc = aom_rb_read_literal(&rb, 8);
-  if (scalability_mode_idc == SCALABILITY_SS) {
-    scalability_structure(&rb);
-  }
-}
-
-static void read_metadata_timecode(const uint8_t *data, size_t sz) {
-  struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL };
-  aom_rb_read_literal(&rb, 5);                     // counting_type f(5)
-  int full_timestamp_flag = aom_rb_read_bit(&rb);  // full_timestamp_flag f(1)
-  aom_rb_read_bit(&rb);                            // discontinuity_flag (f1)
-  aom_rb_read_bit(&rb);                            // cnt_dropped_flag f(1)
-  aom_rb_read_literal(&rb, 9);                     // n_frames f(9)
-  if (full_timestamp_flag) {
-    aom_rb_read_literal(&rb, 6);  // seconds_value f(6)
-    aom_rb_read_literal(&rb, 6);  // minutes_value f(6)
-    aom_rb_read_literal(&rb, 5);  // hours_value f(5)
-  } else {
-    int seconds_flag = aom_rb_read_bit(&rb);  // seconds_flag f(1)
-    if (seconds_flag) {
-      aom_rb_read_literal(&rb, 6);              // seconds_value f(6)
-      int minutes_flag = aom_rb_read_bit(&rb);  // minutes_flag f(1)
-      if (minutes_flag) {
-        aom_rb_read_literal(&rb, 6);            // minutes_value f(6)
-        int hours_flag = aom_rb_read_bit(&rb);  // hours_flag f(1)
-        if (hours_flag) {
-          aom_rb_read_literal(&rb, 5);  // hours_value f(5)
-        }
-      }
-    }
-  }
-  // time_offset_length f(5)
-  int time_offset_length = aom_rb_read_literal(&rb, 5);
-  if (time_offset_length) {
-    aom_rb_read_literal(&rb, time_offset_length);  // f(time_offset_length)
-  }
-}
-
-static size_t read_metadata(const uint8_t *data, size_t sz) {
-  size_t type_length;
-  uint64_t type_value;
-  OBU_METADATA_TYPE metadata_type;
-  if (aom_uleb_decode(data, sz, &type_value, &type_length) < 0) {
-    return sz;
-  }
-  metadata_type = (OBU_METADATA_TYPE)type_value;
-  if (metadata_type == OBU_METADATA_TYPE_ITUT_T35) {
-    read_metadata_itut_t35(data + type_length, sz - type_length);
-  } else if (metadata_type == OBU_METADATA_TYPE_HDR_CLL) {
-    read_metadata_hdr_cll(data + type_length, sz - type_length);
-  } else if (metadata_type == OBU_METADATA_TYPE_HDR_MDCV) {
-    read_metadata_hdr_mdcv(data + type_length, sz - type_length);
-  } else if (metadata_type == OBU_METADATA_TYPE_SCALABILITY) {
-    read_metadata_scalability(data + type_length, sz - type_length);
-  } else if (metadata_type == OBU_METADATA_TYPE_TIMECODE) {
-    read_metadata_timecode(data + type_length, sz - type_length);
-  }
-
-  return sz;
-}
-
-// On success, returns a boolean that indicates whether the decoding of the
-// current frame is finished. On failure, sets cm->error.error_code and
-// returns -1.
-int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data,
-                               const uint8_t *data_end,
-                               const uint8_t **p_data_end) {
-  AV1_COMMON *const cm = &pbi->common;
-  int frame_decoding_finished = 0;
-  int is_first_tg_obu_received = 1;
-  uint32_t frame_header_size = 0;
-  ObuHeader obu_header;
-  memset(&obu_header, 0, sizeof(obu_header));
-  pbi->seen_frame_header = 0;
-
-  if (data_end < data) {
-    cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-    return -1;
-  }
-
-  // Reset pbi->camera_frame_header_ready to 0 if cm->large_scale_tile = 0.
-  if (!cm->large_scale_tile) pbi->camera_frame_header_ready = 0;
-
-  // decode frame as a series of OBUs
-  while (!frame_decoding_finished && !cm->error.error_code) {
-    struct aom_read_bit_buffer rb;
-    size_t payload_size = 0;
-    size_t decoded_payload_size = 0;
-    size_t obu_payload_offset = 0;
-    size_t bytes_read = 0;
-    const size_t bytes_available = data_end - data;
-
-    if (bytes_available == 0 && !pbi->seen_frame_header) {
-      *p_data_end = data;
-      cm->error.error_code = AOM_CODEC_OK;
-      break;
-    }
-
-    aom_codec_err_t status =
-        aom_read_obu_header_and_size(data, bytes_available, cm->is_annexb,
-                                     &obu_header, &payload_size, &bytes_read);
-
-    if (status != AOM_CODEC_OK) {
-      cm->error.error_code = status;
-      return -1;
-    }
-
-    // Record obu size header information.
-    pbi->obu_size_hdr.data = data + obu_header.size;
-    pbi->obu_size_hdr.size = bytes_read - obu_header.size;
-
-    // Note: aom_read_obu_header_and_size() takes care of checking that this
-    // doesn't cause 'data' to advance past 'data_end'.
-    data += bytes_read;
-
-    if ((size_t)(data_end - data) < payload_size) {
-      cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-      return -1;
-    }
-
-    cm->temporal_layer_id = obu_header.temporal_layer_id;
-    cm->spatial_layer_id = obu_header.spatial_layer_id;
-
-    if (obu_header.type != OBU_TEMPORAL_DELIMITER &&
-        obu_header.type != OBU_SEQUENCE_HEADER &&
-        obu_header.type != OBU_PADDING) {
-      // don't decode obu if it's not in current operating mode
-      if (!is_obu_in_current_operating_point(pbi, obu_header)) {
-        data += payload_size;
-        continue;
-      }
-    }
-
-    av1_init_read_bit_buffer(pbi, &rb, data, data + payload_size);
-
-    switch (obu_header.type) {
-      case OBU_TEMPORAL_DELIMITER:
-        decoded_payload_size = read_temporal_delimiter_obu();
-        pbi->seen_frame_header = 0;
-        break;
-      case OBU_SEQUENCE_HEADER:
-        decoded_payload_size = read_sequence_header_obu(pbi, &rb);
-        if (cm->error.error_code != AOM_CODEC_OK) return -1;
-        break;
-      case OBU_FRAME_HEADER:
-      case OBU_REDUNDANT_FRAME_HEADER:
-      case OBU_FRAME:
-        // Only decode first frame header received
-        if (!pbi->seen_frame_header ||
-            (cm->large_scale_tile && !pbi->camera_frame_header_ready)) {
-          frame_header_size = read_frame_header_obu(
-              pbi, &rb, data, p_data_end, obu_header.type != OBU_FRAME);
-          pbi->seen_frame_header = 1;
-          if (!pbi->ext_tile_debug && cm->large_scale_tile)
-            pbi->camera_frame_header_ready = 1;
-        } else {
-          // TODO(wtc): Verify that the frame_header_obu is identical to the
-          // original frame_header_obu. For now just skip frame_header_size
-          // bytes in the bit buffer.
-          if (frame_header_size > payload_size) {
-            cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-            return -1;
-          }
-          assert(rb.bit_offset == 0);
-          rb.bit_offset = 8 * frame_header_size;
-        }
-
-        decoded_payload_size = frame_header_size;
-        pbi->frame_header_size = frame_header_size;
-
-        if (cm->show_existing_frame) {
-          if (obu_header.type == OBU_FRAME) {
-            cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
-            return -1;
-          }
-          frame_decoding_finished = 1;
-          pbi->seen_frame_header = 0;
-          break;
-        }
-
-        // In large scale tile coding, decode the common camera frame header
-        // before any tile list OBU.
-        if (!pbi->ext_tile_debug && pbi->camera_frame_header_ready) {
-          frame_decoding_finished = 1;
-          // Skip the rest of the frame data.
-          decoded_payload_size = payload_size;
-          // Update data_end.
-          *p_data_end = data_end;
-          break;
-        }
-
-        if (obu_header.type != OBU_FRAME) break;
-        obu_payload_offset = frame_header_size;
-        // Byte align the reader before reading the tile group.
-        if (byte_alignment(cm, &rb)) return -1;
-        AOM_FALLTHROUGH_INTENDED;  // fall through to read tile group.
-      case OBU_TILE_GROUP:
-        if (!pbi->seen_frame_header) {
-          cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-          return -1;
-        }
-        if (obu_payload_offset > payload_size) {
-          cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-          return -1;
-        }
-        decoded_payload_size += read_one_tile_group_obu(
-            pbi, &rb, is_first_tg_obu_received, data + obu_payload_offset,
-            data + payload_size, p_data_end, &frame_decoding_finished,
-            obu_header.type == OBU_FRAME);
-        is_first_tg_obu_received = 0;
-        if (frame_decoding_finished) pbi->seen_frame_header = 0;
-        break;
-      case OBU_METADATA:
-        decoded_payload_size = read_metadata(data, payload_size);
-        break;
-      case OBU_TILE_LIST:
-        if (CONFIG_NORMAL_TILE_MODE) {
-          cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM;
-          return -1;
-        }
-
-        // This OBU type is purely for the large scale tile coding mode.
-        // The common camera frame header has to be already decoded.
-        if (!pbi->camera_frame_header_ready) {
-          cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-          return -1;
-        }
-
-        cm->large_scale_tile = 1;
-        av1_set_single_tile_decoding_mode(cm);
-        decoded_payload_size =
-            read_and_decode_one_tile_list(pbi, &rb, data, data + payload_size,
-                                          p_data_end, &frame_decoding_finished);
-        if (cm->error.error_code != AOM_CODEC_OK) return -1;
-        break;
-      case OBU_PADDING:
-      default:
-        // Skip unrecognized OBUs
-        decoded_payload_size = payload_size;
-        break;
-    }
-
-    // Check that the signalled OBU size matches the actual amount of data read
-    if (decoded_payload_size > payload_size) {
-      cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-      return -1;
-    }
-
-    // If there are extra padding bytes, they should all be zero
-    while (decoded_payload_size < payload_size) {
-      uint8_t padding_byte = data[decoded_payload_size++];
-      if (padding_byte != 0) {
-        cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
-        return -1;
-      }
-    }
-
-    data += payload_size;
-  }
-
-  return frame_decoding_finished;
-}
diff --git a/third_party/aom/av1/decoder/obu.h b/third_party/aom/av1/decoder/obu.h
deleted file mode 100644
index 5ab243fc9..000000000
--- a/third_party/aom/av1/decoder/obu.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2017, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#ifndef AOM_AV1_DECODER_OBU_H_
-#define AOM_AV1_DECODER_OBU_H_
-
-#include "aom/aom_codec.h"
-#include "av1/decoder/decoder.h"
-
-// Try to decode one frame from a buffer.
-// Returns 1 if we decoded a frame,
-//         0 if we didn't decode a frame but that's okay
-//           (eg, if there was a frame but we skipped it),
-//     or -1 on error
-int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data,
-                               const uint8_t *data_end,
-                               const uint8_t **p_data_end);
-
-aom_codec_err_t aom_get_num_layers_from_operating_point_idc(
-    int operating_point_idc, unsigned int *num_spatial_layers,
-    unsigned int *num_temporal_layers);
-
-#endif  // AOM_AV1_DECODER_OBU_H_