decodemv.c 99.4 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
Yaowu Xu's avatar
Yaowu Xu committed
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
Yaowu Xu's avatar
Yaowu Xu committed
4 5 6 7 8 9
 * 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.
Jingning Han's avatar
Jingning Han committed
10 11 12 13
 */

#include <assert.h>

14 15 16 17 18 19 20
#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"
hui su's avatar
hui su committed
21 22 23
#if CONFIG_EXT_INTRA
#include "av1/common/reconintra.h"
#endif  // CONFIG_EXT_INTRA
24
#include "av1/common/seg_common.h"
Yue Chen's avatar
Yue Chen committed
25
#include "av1/common/warped_motion.h"
26 27

#include "av1/decoder/decodeframe.h"
Jingning Han's avatar
Jingning Han committed
28
#include "av1/decoder/decodemv.h"
29

Yaowu Xu's avatar
Yaowu Xu committed
30
#include "aom_dsp/aom_dsp_common.h"
31

Michael Bebenita's avatar
Michael Bebenita committed
32
#define ACCT_STR __func__
33

34
#define DEC_MISMATCH_DEBUG 0
35

36
static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
Hui Su's avatar
Hui Su committed
37
  return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR);
38
}
Jingning Han's avatar
Jingning Han committed
39

40 41 42 43 44
static int read_delta_qindex(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r,
                             MB_MODE_INFO *const mbmi, int mi_col, int mi_row) {
  FRAME_COUNTS *counts = xd->counts;
  int sign, abs, reduced_delta_qindex = 0;
  BLOCK_SIZE bsize = mbmi->sb_type;
45 46
  const int b_col = mi_col & (cm->mib_size - 1);
  const int b_row = mi_row & (cm->mib_size - 1);
47
  const int read_delta_q_flag = (b_col == 0 && b_row == 0);
Thomas Davies's avatar
Thomas Davies committed
48 49 50 51
  int rem_bits, thr;
  int i, smallval;
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
52

Pavel Frolov's avatar
Pavel Frolov committed
53
  if ((bsize != cm->sb_size || mbmi->skip == 0) && read_delta_q_flag) {
Thomas Davies's avatar
Thomas Davies committed
54 55 56 57 58 59 60 61
    abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
    smallval = (abs < DELTA_Q_SMALL);
    if (counts) {
      for (i = 0; i < abs; ++i) counts->delta_q[i][1]++;
      if (smallval) counts->delta_q[abs][0]++;
    }

    if (!smallval) {
62
      rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
63 64 65 66 67 68 69 70 71 72 73 74 75 76
      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;
}
Fangwen Fu's avatar
Fangwen Fu committed
77 78
#if CONFIG_EXT_DELTA_Q
static int read_delta_lflevel(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r,
79 80 81
#if CONFIG_LOOPFILTER_LEVEL
                              int lf_id,
#endif
Fangwen Fu's avatar
Fangwen Fu committed
82 83 84 85 86
                              MB_MODE_INFO *const mbmi, int mi_col,
                              int mi_row) {
  FRAME_COUNTS *counts = xd->counts;
  int sign, abs, reduced_delta_lflevel = 0;
  BLOCK_SIZE bsize = mbmi->sb_type;
87 88
  const int b_col = mi_col & (cm->mib_size - 1);
  const int b_row = mi_row & (cm->mib_size - 1);
Fangwen Fu's avatar
Fangwen Fu committed
89 90 91 92 93 94
  const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
  int rem_bits, thr;
  int i, smallval;
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;

95
  if ((bsize != cm->sb_size || mbmi->skip == 0) && read_delta_lf_flag) {
96
#if CONFIG_LOOPFILTER_LEVEL
97 98 99 100 101 102 103 104
    if (cm->delta_lf_multi) {
      assert(lf_id >= 0 && lf_id < FRAME_LF_COUNT);
      abs = aom_read_symbol(r, ec_ctx->delta_lf_multi_cdf[lf_id],
                            DELTA_LF_PROBS + 1, ACCT_STR);
    } else {
      abs = aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1,
                            ACCT_STR);
    }
105
#else
Fangwen Fu's avatar
Fangwen Fu committed
106 107
    abs =
        aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1, ACCT_STR);
108
#endif  // CONFIG_LOOPFILTER_LEVEL
Fangwen Fu's avatar
Fangwen Fu committed
109 110
    smallval = (abs < DELTA_LF_SMALL);
    if (counts) {
111
#if CONFIG_LOOPFILTER_LEVEL
112 113 114 115 116 117 118
      if (cm->delta_lf_multi) {
        for (i = 0; i < abs; ++i) counts->delta_lf_multi[lf_id][i][1]++;
        if (smallval) counts->delta_lf_multi[lf_id][abs][0]++;
      } else {
        for (i = 0; i < abs; ++i) counts->delta_lf[i][1]++;
        if (smallval) counts->delta_lf[abs][0]++;
      }
119
#else
Fangwen Fu's avatar
Fangwen Fu committed
120 121
      for (i = 0; i < abs; ++i) counts->delta_lf[i][1]++;
      if (smallval) counts->delta_lf[abs][0]++;
122
#endif  // CONFIG_LOOPFILTER_LEVEL
Fangwen Fu's avatar
Fangwen Fu committed
123 124
    }
    if (!smallval) {
125
      rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
Fangwen Fu's avatar
Fangwen Fu committed
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
      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_lflevel = sign ? -abs : abs;
  }
  return reduced_delta_lflevel;
}
#endif
141

Luc Trudeau's avatar
Luc Trudeau committed
142
static UV_PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx,
143
                                             aom_reader *r,
Luc Trudeau's avatar
Luc Trudeau committed
144 145
                                             PREDICTION_MODE y_mode) {
  const UV_PREDICTION_MODE uv_mode =
146 147 148
#if CONFIG_CFL
      aom_read_symbol(r, ec_ctx->uv_mode_cdf[y_mode], UV_INTRA_MODES, ACCT_STR);
#else
149
      read_intra_mode(r, ec_ctx->uv_mode_cdf[y_mode]);
150
#endif  // CONFIG_CFL
Jingning Han's avatar
Jingning Han committed
151 152 153
  return uv_mode;
}

Luc Trudeau's avatar
Luc Trudeau committed
154
#if CONFIG_CFL
155
static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r,
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
                           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;
Luc Trudeau's avatar
Luc Trudeau committed
172 173 174
}
#endif

Yue Chen's avatar
Yue Chen committed
175 176
static INTERINTRA_MODE read_interintra_mode(MACROBLOCKD *xd, aom_reader *r,
                                            int size_group) {
177 178 179
  const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_symbol(
      r, xd->tile_ctx->interintra_mode_cdf[size_group], INTERINTRA_MODES,
      ACCT_STR);
180
  FRAME_COUNTS *counts = xd->counts;
181
  if (counts) ++counts->interintra_mode[size_group][ii_mode];
182 183 184
  return ii_mode;
}

185
static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
186
                                       aom_reader *r, int16_t ctx) {
187
  FRAME_COUNTS *counts = xd->counts;
188
  int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
189 190 191 192 193 194 195
  int is_newmv, is_zeromv, is_refmv;
#if CONFIG_NEW_MULTISYMBOL
  is_newmv = aom_read_symbol(r, ec_ctx->newmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
#else
  is_newmv = aom_read(r, ec_ctx->newmv_prob[mode_ctx], ACCT_STR) == 0;
#endif
  if (is_newmv) {
196
    if (counts) ++counts->newmv_mode[mode_ctx][0];
197
    return NEWMV;
198
  }
199
  if (counts) ++counts->newmv_mode[mode_ctx][1];
Sarah Parker's avatar
Sarah Parker committed
200 201
  if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return GLOBALMV;
  mode_ctx = (ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
202 203 204 205 206 207 208
#if CONFIG_NEW_MULTISYMBOL
  is_zeromv =
      aom_read_symbol(r, ec_ctx->zeromv_cdf[mode_ctx], 2, ACCT_STR) == 0;
#else
  is_zeromv = aom_read(r, ec_ctx->zeromv_prob[mode_ctx], ACCT_STR) == 0;
#endif
  if (is_zeromv) {
209
    if (counts) ++counts->zeromv_mode[mode_ctx][0];
Sarah Parker's avatar
Sarah Parker committed
210
    return GLOBALMV;
211
  }
212
  if (counts) ++counts->zeromv_mode[mode_ctx][1];
213
  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
214 215 216
  if (ctx & (1 << SKIP_NEARESTMV_OFFSET)) mode_ctx = 6;
  if (ctx & (1 << SKIP_NEARMV_OFFSET)) mode_ctx = 7;
  if (ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) mode_ctx = 8;
217 218 219 220 221 222
#if CONFIG_NEW_MULTISYMBOL
  is_refmv = aom_read_symbol(r, ec_ctx->refmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
#else
  is_refmv = aom_read(r, ec_ctx->refmv_prob[mode_ctx], ACCT_STR) == 0;
#endif
  if (is_refmv) {
223
    if (counts) ++counts->refmv_mode[mode_ctx][0];
224 225
    return NEARESTMV;
  } else {
226
    if (counts) ++counts->refmv_mode[mode_ctx][1];
227 228
    return NEARMV;
  }
Jingning Han's avatar
Jingning Han committed
229 230
}

231
static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
232 233
                         MB_MODE_INFO *mbmi, aom_reader *r) {
  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
234
  mbmi->ref_mv_idx = 0;
235
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV
236
#if CONFIG_COMPOUND_SINGLEREF
237
      || mbmi->mode == SR_NEW_NEWMV
238
#endif  // CONFIG_COMPOUND_SINGLEREF
239
      ) {
240 241 242
    int idx;
    for (idx = 0; idx < 2; ++idx) {
      if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
Yaowu Xu's avatar
Yaowu Xu committed
243
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
244 245 246 247 248 249 250 251
#if CONFIG_NEW_MULTISYMBOL
        int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
#else
        int drl_idx = aom_read(r, ec_ctx->drl_prob[drl_ctx], ACCT_STR);
#endif
        mbmi->ref_mv_idx = idx + drl_idx;
        if (xd->counts) ++xd->counts->drl_mode[drl_ctx][drl_idx];
        if (!drl_idx) return;
252 253 254
      }
    }
  }
David Barker's avatar
David Barker committed
255
  if (have_nearmv_in_inter_mode(mbmi->mode)) {
256 257 258 259 260 261
    int idx;
    // Offset the NEARESTMV mode.
    // TODO(jingning): Unify the two syntax decoding loops after the NEARESTMV
    // mode is factored in.
    for (idx = 1; idx < 3; ++idx) {
      if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
Yaowu Xu's avatar
Yaowu Xu committed
262
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
263 264 265 266 267 268 269 270
#if CONFIG_NEW_MULTISYMBOL
        int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
#else
        int drl_idx = aom_read(r, ec_ctx->drl_prob[drl_ctx], ACCT_STR);
#endif
        mbmi->ref_mv_idx = idx + drl_idx - 1;
        if (xd->counts) ++xd->counts->drl_mode[drl_ctx][drl_idx];
        if (!drl_idx) return;
271 272 273 274 275
      }
    }
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
276
static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
277 278
                                    MODE_INFO *mi, aom_reader *r) {
  MB_MODE_INFO *mbmi = &mi->mbmi;
Yue Chen's avatar
Yue Chen committed
279
#if CONFIG_NEW_MULTISYMBOL
Thomas Davies's avatar
Thomas Davies committed
280 281 282
  (void)cm;
#endif

283
  const MOTION_MODE last_motion_mode_allowed =
284
      motion_mode_allowed(0, xd->global_motion, xd, mi);
Yue Chen's avatar
Yue Chen committed
285 286
  int motion_mode;
  FRAME_COUNTS *counts = xd->counts;
Yaowu Xu's avatar
Yaowu Xu committed
287

Yue Chen's avatar
Yue Chen committed
288
  if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
Yue Chen's avatar
Yue Chen committed
289

Yue Chen's avatar
Yue Chen committed
290
  if (last_motion_mode_allowed == OBMC_CAUSAL) {
291 292 293 294
#if CONFIG_NEW_MULTISYMBOL
    motion_mode =
        aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2, ACCT_STR);
#else
Yue Chen's avatar
Yue Chen committed
295
    motion_mode = aom_read(r, cm->fc->obmc_prob[mbmi->sb_type], ACCT_STR);
296
#endif
Yue Chen's avatar
Yue Chen committed
297 298 299
    if (counts) ++counts->obmc[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
300
    motion_mode =
Thomas Davies's avatar
Thomas Davies committed
301 302
        aom_read_symbol(r, xd->tile_ctx->motion_mode_cdf[mbmi->sb_type],
                        MOTION_MODES, ACCT_STR);
Yaowu Xu's avatar
Yaowu Xu committed
303 304 305 306
    if (counts) ++counts->motion_mode[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
  }
}
307

Yaowu Xu's avatar
Yaowu Xu committed
308 309
static PREDICTION_MODE read_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
                                                aom_reader *r, int16_t ctx) {
310
  (void)cm;
Zoe Liu's avatar
Zoe Liu committed
311 312 313 314 315 316 317
#if CONFIG_EXT_SKIP
  FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
  const int mode =
      xd->mi[0]->mbmi.skip_mode
          ? (NEAREST_NEARESTMV - NEAREST_NEARESTMV)
          : aom_read_symbol(r, ec_ctx->inter_compound_mode_cdf[ctx],
                            INTER_COMPOUND_MODES, ACCT_STR);
318
  if (xd->mi[0]->mbmi.skip_mode && r->allow_update_cdf)
Zoe Liu's avatar
Zoe Liu committed
319 320 321
    update_cdf(ec_ctx->inter_compound_mode_cdf[ctx], mode,
               INTER_COMPOUND_MODES);
#else
322 323 324
  const int mode =
      aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
                      INTER_COMPOUND_MODES, ACCT_STR);
Zoe Liu's avatar
Zoe Liu committed
325 326
#endif  // CONFIG_EXT_SKIP

327
  FRAME_COUNTS *counts = xd->counts;
328
  if (counts) ++counts->inter_compound_mode[ctx][mode];
329 330 331
  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
  return NEAREST_NEARESTMV + mode;
}
332 333

#if CONFIG_COMPOUND_SINGLEREF
334
static PREDICTION_MODE read_inter_singleref_comp_mode(MACROBLOCKD *xd,
335 336 337
                                                      aom_reader *r,
                                                      int16_t ctx) {
  const int mode =
338 339
      aom_read_symbol(r, xd->tile_ctx->inter_singleref_comp_mode_cdf[ctx],
                      INTER_SINGLEREF_COMP_MODES, ACCT_STR);
340 341 342 343 344 345 346 347
  FRAME_COUNTS *counts = xd->counts;

  if (counts) ++counts->inter_singleref_comp_mode[ctx][mode];

  assert(is_inter_singleref_comp_mode(SR_NEAREST_NEARMV + mode));
  return SR_NEAREST_NEARMV + mode;
}
#endif  // CONFIG_COMPOUND_SINGLEREF
348

349
static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) {
Michael Bebenita's avatar
Michael Bebenita committed
350
  return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
Jingning Han's avatar
Jingning Han committed
351 352
}

Yaowu Xu's avatar
Yaowu Xu committed
353
static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
354
                               MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
355 356
                               TX_SIZE tx_size, int depth, int blk_row,
                               int blk_col, aom_reader *r) {
357 358 359 360
#if CONFIG_NEW_MULTISYMBOL
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
#endif
361
  int is_split = 0;
362 363
  const int tx_row = blk_row >> 1;
  const int tx_col = blk_col >> 1;
364 365
  const int max_blocks_high = max_block_high(xd, mbmi->sb_type, 0);
  const int max_blocks_wide = max_block_wide(xd, mbmi->sb_type, 0);
366 367
  int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
                                   xd->left_txfm_context + blk_row,
368
                                   mbmi->sb_type, tx_size);
clang-format's avatar
clang-format committed
369
  TX_SIZE(*const inter_tx_size)
370 371 372
  [MAX_MIB_SIZE] =
      (TX_SIZE(*)[MAX_MIB_SIZE]) & mbmi->inter_tx_size[tx_row][tx_col];
  if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
David Barker's avatar
David Barker committed
373
  assert(tx_size > TX_4X4);
374

Jingning Han's avatar
Jingning Han committed
375
  if (depth == MAX_VARTX_DEPTH) {
376 377
    int idx, idy;
    inter_tx_size[0][0] = tx_size;
378 379
    for (idy = 0; idy < AOMMAX(1, tx_size_high_unit[tx_size] / 2); ++idy)
      for (idx = 0; idx < AOMMAX(1, tx_size_wide_unit[tx_size] / 2); ++idx)
380 381
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
382
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
383 384
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
385 386 387
    return;
  }

388 389 390
#if CONFIG_NEW_MULTISYMBOL
  is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR);
#else
Michael Bebenita's avatar
Michael Bebenita committed
391
  is_split = aom_read(r, cm->fc->txfm_partition_prob[ctx], ACCT_STR);
392
#endif
393 394

  if (is_split) {
395 396
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
    const int bsl = tx_size_wide_unit[sub_txs];
397
    int i;
398

399
    if (counts) ++counts->txfm_partition[ctx][1];
400

David Barker's avatar
David Barker committed
401
    if (sub_txs == TX_4X4) {
402
      int idx, idy;
403
      inter_tx_size[0][0] = sub_txs;
404 405
      for (idy = 0; idy < AOMMAX(1, tx_size_high_unit[tx_size] / 2); ++idy)
        for (idx = 0; idx < AOMMAX(1, tx_size_wide_unit[tx_size] / 2); ++idx)
406
          inter_tx_size[idy][idx] = inter_tx_size[0][0];
407
      mbmi->tx_size = sub_txs;
408
      mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
409 410
      txfm_partition_update(xd->above_txfm_context + blk_col,
                            xd->left_txfm_context + blk_row, sub_txs, tx_size);
411 412 413 414 415
      return;
    }

    assert(bsl > 0);
    for (i = 0; i < 4; ++i) {
416 417 418
      int offsetr = blk_row + (i >> 1) * bsl;
      int offsetc = blk_col + (i & 0x01) * bsl;
      read_tx_size_vartx(cm, xd, mbmi, counts, sub_txs, depth + 1, offsetr,
419
                         offsetc, r);
420 421
    }
  } else {
422
    int idx, idy;
423
    inter_tx_size[0][0] = tx_size;
424 425
    for (idy = 0; idy < AOMMAX(1, tx_size_high_unit[tx_size] / 2); ++idy)
      for (idx = 0; idx < AOMMAX(1, tx_size_wide_unit[tx_size] / 2); ++idx)
426 427
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
428
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
429
    if (counts) ++counts->txfm_partition[ctx][0];
430 431
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
432 433 434
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
435
static TX_SIZE read_selected_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd,
436
                                     int32_t tx_size_cat, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
437
  const int ctx = get_tx_size_context(xd);
438 439 440
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;

441 442
  const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
                                    tx_size_cat + 2, ACCT_STR);
443 444
  const TX_SIZE tx_size = depth_to_tx_size(depth);
  assert(!is_rect_tx(tx_size));
445
  return tx_size;
Jingning Han's avatar
Jingning Han committed
446 447
}

448 449 450 451
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]->mbmi.sb_type;
452
  if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4;
453 454

  if (block_signals_txsize(bsize)) {
455 456 457
    if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) {
      const int32_t tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize]
                                           : intra_tx_size_cat_lookup[bsize];
458
      const TX_SIZE coded_tx_size =
459
          read_selected_tx_size(cm, xd, tx_size_cat, r);
460 461
      if (coded_tx_size > max_txsize_lookup[bsize]) {
        assert(coded_tx_size == max_txsize_lookup[bsize] + 1);
Yue Chen's avatar
Yue Chen committed
462
#if CONFIG_RECT_TX_EXT
463
        if (is_quarter_tx_allowed(xd, &xd->mi[0]->mbmi, is_inter)) {
Yue Chen's avatar
Yue Chen committed
464
          int quarter_tx;
465

Yue Chen's avatar
Yue Chen committed
466
          if (quarter_txsize_lookup[bsize] != max_txsize_lookup[bsize]) {
467 468 469 470
#if CONFIG_NEW_MULTISYMBOL
            quarter_tx =
                aom_read_symbol(r, cm->fc->quarter_tx_size_cdf, 2, ACCT_STR);
#else
Yue Chen's avatar
Yue Chen committed
471 472 473
            quarter_tx = aom_read(r, cm->fc->quarter_tx_size_prob, ACCT_STR);
            FRAME_COUNTS *counts = xd->counts;
            if (counts) ++counts->quarter_tx_size[quarter_tx];
474
#endif
Yue Chen's avatar
Yue Chen committed
475 476 477
          } else {
            quarter_tx = 1;
          }
478 479 480
          return quarter_tx ? quarter_txsize_lookup[bsize]
                            : max_txsize_rect_lookup[bsize];
        }
Yue Chen's avatar
Yue Chen committed
481
#endif  // CONFIG_RECT_TX_EXT
482

483 484 485
        return max_txsize_rect_lookup[bsize];
      }
      return coded_tx_size;
486
    } else {
487
      return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
488 489
    }
  } else {
Debargha Mukherjee's avatar
Debargha Mukherjee committed
490
    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
491 492
    return max_txsize_rect_lookup[bsize];
  }
Jingning Han's avatar
Jingning Han committed
493 494
}

Yaowu Xu's avatar
Yaowu Xu committed
495
static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
Jingning Han's avatar
Jingning Han committed
496 497 498 499 500
                              int mi_offset, int x_mis, int y_mis) {
  int x, y, segment_id = INT_MAX;

  for (y = 0; y < y_mis; y++)
    for (x = 0; x < x_mis; x++)
501
      segment_id =
Yaowu Xu's avatar
Yaowu Xu committed
502
          AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
Jingning Han's avatar
Jingning Han committed
503 504 505 506 507

  assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
508
static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
509
                           int segment_id) {
Jingning Han's avatar
Jingning Han committed
510 511 512 513 514 515 516 517 518
  int x, y;

  assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);

  for (y = 0; y < y_mis; y++)
    for (x = 0; x < x_mis; x++)
      cm->current_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
519
static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
520
                                 int mi_offset, int x_mis, int y_mis,
Yaowu Xu's avatar
Yaowu Xu committed
521
                                 aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
522
  struct segmentation *const seg = &cm->seg;
523
  FRAME_COUNTS *counts = xd->counts;
524 525
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  struct segmentation_probs *const segp = &ec_ctx->seg;
Jingning Han's avatar
Jingning Han committed
526 527
  int segment_id;

528
  if (!seg->enabled) return 0;  // Default for disabled segmentation
Jingning Han's avatar
Jingning Han committed
529

530
  assert(seg->update_map && !seg->temporal_update);
Jingning Han's avatar
Jingning Han committed
531

532
  segment_id = read_segment_id(r, segp);
533
  if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
534 535 536 537
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
538
static void copy_segment_id(const AV1_COMMON *cm,
539 540 541
                            const uint8_t *last_segment_ids,
                            uint8_t *current_segment_ids, int mi_offset,
                            int x_mis, int y_mis) {
542 543 544 545
  int x, y;

  for (y = 0; y < y_mis; y++)
    for (x = 0; x < x_mis; x++)
546 547 548
      current_segment_ids[mi_offset + y * cm->mi_cols + x] =
          last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
                           : 0;
549 550
}

Yaowu Xu's avatar
Yaowu Xu committed
551 552
static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                 int mi_row, int mi_col, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
553
  struct segmentation *const seg = &cm->seg;
554
  FRAME_COUNTS *counts = xd->counts;
555 556 557
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  struct segmentation_probs *const segp = &ec_ctx->seg;

Jingning Han's avatar
Jingning Han committed
558 559 560
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
  int predicted_segment_id, segment_id;
  const int mi_offset = mi_row * cm->mi_cols + mi_col;
561 562
  const int bw = mi_size_wide[mbmi->sb_type];
  const int bh = mi_size_high[mbmi->sb_type];
Jingning Han's avatar
Jingning Han committed
563 564

  // TODO(slavarnway): move x_mis, y_mis into xd ?????
Yaowu Xu's avatar
Yaowu Xu committed
565 566
  const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw);
  const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh);
Jingning Han's avatar
Jingning Han committed
567

568
  if (!seg->enabled) return 0;  // Default for disabled segmentation
Jingning Han's avatar
Jingning Han committed
569

570 571 572 573
  predicted_segment_id = cm->last_frame_seg_map
                             ? dec_get_segment_id(cm, cm->last_frame_seg_map,
                                                  mi_offset, x_mis, y_mis)
                             : 0;
Jingning Han's avatar
Jingning Han committed
574 575 576 577 578 579 580 581

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

  if (seg->temporal_update) {
Yaowu Xu's avatar
Yaowu Xu committed
582
    const int ctx = av1_get_pred_context_seg_id(xd);
583 584 585 586
#if CONFIG_NEW_MULTISYMBOL
    aom_cdf_prob *pred_cdf = segp->pred_cdf[ctx];
    mbmi->seg_id_predicted = aom_read_symbol(r, pred_cdf, 2, ACCT_STR);
#else
Yaowu Xu's avatar
Yaowu Xu committed
587
    const aom_prob pred_prob = segp->pred_probs[ctx];
Michael Bebenita's avatar
Michael Bebenita committed
588
    mbmi->seg_id_predicted = aom_read(r, pred_prob, ACCT_STR);
589
#endif
590
    if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted];
591 592 593 594
    if (mbmi->seg_id_predicted) {
      segment_id = predicted_segment_id;
    } else {
      segment_id = read_segment_id(r, segp);
595
      if (counts) ++counts->seg.tree_mispred[segment_id];
596
    }
Jingning Han's avatar
Jingning Han committed
597
  } else {
598
    segment_id = read_segment_id(r, segp);
599
    if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
600 601 602 603 604
  }
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Zoe Liu's avatar
Zoe Liu committed
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
#if CONFIG_EXT_SKIP
static int read_skip_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
                          aom_reader *r) {
  if (!cm->is_skip_mode_allowed) return 0;

  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
    // TODO(zoeliu): To revisit the handling of this scenario.
    return 0;
  } else {
    const int ctx = av1_get_skip_mode_context(xd);
#if CONFIG_NEW_MULTISYMBOL
    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
    const int skip_mode =
        aom_read_symbol(r, ec_ctx->skip_mode_cdfs[ctx], 2, ACCT_STR);
#else
    const int skip_mode = aom_read(r, cm->fc->skip_mode_probs[ctx], ACCT_STR);
#endif  // CONFIG_NEW_MULTISYMBOL
    FRAME_COUNTS *counts = xd->counts;
    if (counts) ++counts->skip_mode[ctx][skip_mode];

    // TODO(zoeliu): To handle:
    //               if (!is_comp_ref_allowed(xd->mi[0]->mbmi.sb_type))
    return skip_mode;
  }
}
#endif  // CONFIG_EXT_SKIP

Yaowu Xu's avatar
Yaowu Xu committed
632 633
static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
                     aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
634 635 636
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
    return 1;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
637
    const int ctx = av1_get_skip_context(xd);
638 639 640 641
#if CONFIG_NEW_MULTISYMBOL
    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
    const int skip = aom_read_symbol(r, ec_ctx->skip_cdfs[ctx], 2, ACCT_STR);
#else
Michael Bebenita's avatar
Michael Bebenita committed
642
    const int skip = aom_read(r, cm->fc->skip_probs[ctx], ACCT_STR);
643
#endif
Jingning Han's avatar
Jingning Han committed
644
    FRAME_COUNTS *counts = xd->counts;
645
    if (counts) ++counts->skip[ctx][skip];
Jingning Han's avatar
Jingning Han committed
646 647 648 649
    return skip;
  }
}

650
#if CONFIG_PALETTE_DELTA_ENCODING
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
// 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++];
    }
  }
668 669 670 671 672
}

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];
673
  uint16_t cached_colors[PALETTE_MAX_SIZE];
674
  const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
675 676 677
  const int n = pmi->palette_size[0];
  int idx = 0;
  for (int i = 0; i < n_cache && idx < n; ++i)
678
    if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
679
  if (idx < n) {
680
    const int n_cached_colors = idx;
681 682 683 684 685 686
    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) {
687
        assert(range >= 0);
688
        const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
689 690 691
        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]);
692 693 694
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
695 696 697
    merge_colors(pmi->palette_colors, cached_colors, n, n_cached_colors);
  } else {
    memcpy(pmi->palette_colors, cached_colors, n * sizeof(cached_colors[0]));
698 699 700 701 702 703 704 705 706
  }
}

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];
707
  uint16_t cached_colors[PALETTE_MAX_SIZE];
708
  const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
709 710 711 712 713 714
  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;
715 716 717 718 719 720
    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) {
721
        assert(range >= 0);
722
        const int delta = aom_read_literal(r, bits, ACCT_STR);
723 724 725
        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]);
726 727 728
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
729 730 731 732 733
    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]));
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
  }

  // 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);
    }
  }
}
#endif  // CONFIG_PALETTE_DELTA_ENCODING

Yaowu Xu's avatar
Yaowu Xu committed
760 761
static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                   aom_reader *r) {
hui su's avatar
hui su committed
762 763
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
764
  const MODE_INFO *const above_mi = xd->above_mi;
765
  const MODE_INFO *const left_mi = xd->left_mi;
hui su's avatar
hui su committed
766
  const BLOCK_SIZE bsize = mbmi->sb_type;
767 768
  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;

769 770
  assert(bsize >= BLOCK_8X8 && bsize <= BLOCK_LARGEST);
  const int block_palette_idx = bsize - BLOCK_8X8;
771
  int modev;
772

773
  if (mbmi->mode == DC_PRED) {
774
    int palette_y_mode_ctx = 0;
775
    if (above_mi) {
776 777
      palette_y_mode_ctx +=
          (above_mi->mbmi.palette_mode_info.palette_size[0] > 0);
778 779
    }
    if (left_mi) {
780 781
      palette_y_mode_ctx +=
          (left_mi->mbmi.palette_mode_info.palette_size[0] > 0);
782
    }
783 784 785 786 787 788 789 790 791 792 793 794
#if CONFIG_NEW_MULTISYMBOL
    modev = aom_read_symbol(
        r,
        xd->tile_ctx->palette_y_mode_cdf[block_palette_idx][palette_y_mode_ctx],
        2, ACCT_STR);
#else
    modev = aom_read(
        r,
        av1_default_palette_y_mode_prob[block_palette_idx][palette_y_mode_ctx],
        ACCT_STR);
#endif
    if (modev) {
795
      pmi->palette_size[0] =
796
          aom_read_symbol(r,
797
                          xd->tile_ctx->palette_y_size_cdf[block_palette_idx],
798 799
                          PALETTE_SIZES, ACCT_STR) +
          2;
hui su's avatar
hui su committed
800
#if CONFIG_PALETTE_DELTA_ENCODING
801
      read_palette_colors_y(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
802
#else
803
      for (int i = 0; i < pmi->palette_size[0]; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
804
        pmi->palette_colors[i] = aom_read_literal(r, cm->bit_depth, ACCT_STR);
hui su's avatar
hui su committed
805
#endif  // CONFIG_PALETTE_DELTA_ENCODING
806 807
    }
  }
Luc Trudeau's avatar
Luc Trudeau committed
808
  if (mbmi->uv_mode == UV_DC_PRED) {
809
    const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
810 811 812 813 814 815 816 817
#if CONFIG_NEW_MULTISYMBOL
    modev = aom_read_symbol(
        r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR);
#else
    modev = aom_read(r, av1_default_palette_uv_mode_prob[palette_uv_mode_ctx],
                     ACCT_STR);
#endif
    if (modev) {
818
      pmi->palette_size[1] =
819
          aom_read_symbol(r,
820
                          xd->tile_ctx->palette_uv_size_cdf[block_palette_idx],
821 822
                          PALETTE_SIZES, ACCT_STR) +
          2;
hui su's avatar
hui su committed
823
#if CONFIG_PALETTE_DELTA_ENCODING
824
      read_palette_colors_uv(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
825
#else
826
      for (int i = 0; i < pmi->palette_size[1]; ++i) {
827
        pmi->palette_colors[PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
828
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
829
        pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
830
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
831
      }
hui su's avatar
hui su committed
832
#endif  // CONFIG_PALETTE_DELTA_ENCODING
833
    }
hui su's avatar
hui su committed
834 835 836
  }
}

837 838
#if CONFIG_FILTER_INTRA
static void read_filter_intra_mode_info(AV1_COMMON *const cm,
Yue Chen's avatar