decodemv.c 87 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
  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) {
192
    if (counts) ++counts->newmv_mode[mode_ctx][0];
193
    return NEWMV;
194
  }
195
  if (counts) ++counts->newmv_mode[mode_ctx][1];
Sarah Parker's avatar
Sarah Parker committed
196 197
  if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return GLOBALMV;
  mode_ctx = (ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
198 199 200
  is_zeromv =
      aom_read_symbol(r, ec_ctx->zeromv_cdf[mode_ctx], 2, ACCT_STR) == 0;
  if (is_zeromv) {
201
    if (counts) ++counts->zeromv_mode[mode_ctx][0];
Sarah Parker's avatar
Sarah Parker committed
202
    return GLOBALMV;
203
  }
204
  if (counts) ++counts->zeromv_mode[mode_ctx][1];
205
  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
206 207 208
  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;
209 210
  is_refmv = aom_read_symbol(r, ec_ctx->refmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
  if (is_refmv) {
211
    if (counts) ++counts->refmv_mode[mode_ctx][0];
212 213
    return NEARESTMV;
  } else {
214
    if (counts) ++counts->refmv_mode[mode_ctx][1];
215 216
    return NEARMV;
  }
Jingning Han's avatar
Jingning Han committed
217 218
}

219
static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
220 221
                         MB_MODE_INFO *mbmi, aom_reader *r) {
  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
222
  mbmi->ref_mv_idx = 0;
223
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
224 225 226
    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
227
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
228 229 230 231
        int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
        mbmi->ref_mv_idx = idx + drl_idx;
        if (xd->counts) ++xd->counts->drl_mode[drl_ctx][drl_idx];
        if (!drl_idx) return;
232 233 234
      }
    }
  }
David Barker's avatar
David Barker committed
235
  if (have_nearmv_in_inter_mode(mbmi->mode)) {
236 237 238 239 240 241
    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
242
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
243 244 245 246
        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 (xd->counts) ++xd->counts->drl_mode[drl_ctx][drl_idx];
        if (!drl_idx) return;
247 248 249 250 251
      }
    }
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
252
static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
253 254
                                    MODE_INFO *mi, aom_reader *r) {
  MB_MODE_INFO *mbmi = &mi->mbmi;
Thomas Davies's avatar
Thomas Davies committed
255 256
  (void)cm;

Zoe Liu's avatar
Zoe Liu committed
257 258 259 260
#if CONFIG_EXT_SKIP
  if (mbmi->skip_mode) return SIMPLE_TRANSLATION;
#endif  // CONFIG_EXT_SKIP

261
  const MOTION_MODE last_motion_mode_allowed =
262
      motion_mode_allowed(0, xd->global_motion, xd, mi);
Yue Chen's avatar
Yue Chen committed
263 264
  int motion_mode;
  FRAME_COUNTS *counts = xd->counts;
Yaowu Xu's avatar
Yaowu Xu committed
265

Yue Chen's avatar
Yue Chen committed
266
  if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
Yue Chen's avatar
Yue Chen committed
267

Yue Chen's avatar
Yue Chen committed
268
  if (last_motion_mode_allowed == OBMC_CAUSAL) {
269 270
    motion_mode =
        aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2, ACCT_STR);
Yue Chen's avatar
Yue Chen committed
271 272 273
    if (counts) ++counts->obmc[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
274
    motion_mode =
Thomas Davies's avatar
Thomas Davies committed
275 276
        aom_read_symbol(r, xd->tile_ctx->motion_mode_cdf[mbmi->sb_type],
                        MOTION_MODES, ACCT_STR);
Yaowu Xu's avatar
Yaowu Xu committed
277 278 279 280
    if (counts) ++counts->motion_mode[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
  }
}
281

Yaowu Xu's avatar
Yaowu Xu committed
282 283
static PREDICTION_MODE read_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
                                                aom_reader *r, int16_t ctx) {
284 285 286 287
  (void)cm;
  const int mode =
      aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
                      INTER_COMPOUND_MODES, ACCT_STR);
288
  FRAME_COUNTS *counts = xd->counts;
289
  if (counts) ++counts->inter_compound_mode[ctx][mode];
290 291 292
  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
  return NEAREST_NEARESTMV + mode;
}
293

294
static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) {
Michael Bebenita's avatar
Michael Bebenita committed
295
  return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
Jingning Han's avatar
Jingning Han committed
296 297
}

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
#if CONFIG_Q_SEGMENTATION
static int 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_q_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                             int mi_row, int mi_col, aom_reader *r) {
  struct segmentation *const seg = &cm->seg;
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  struct segmentation_probs *const segp = &ec_ctx->seg;
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
  int prev_ul = 0; /* Top left segment_id */
  int prev_l = 0;  /* Current left segment_id */
  int prev_u = 0;  /* Current top segment_id */

  if (!seg->q_lvls) return 0;

  MODE_INFO *const mi = cm->mi + mi_row * cm->mi_stride + mi_col;
  int tinfo = mi->mbmi.boundary_info;
  int above = (!(tinfo & TILE_ABOVE_BOUNDARY)) && ((mi_row - 1) >= 0);
  int left = (!(tinfo & TILE_LEFT_BOUNDARY)) && ((mi_col - 1) >= 0);

  if (above && left)
    prev_ul =
        get_segment_id(cm, cm->q_seg_map, BLOCK_4X4, mi_row - 1, mi_col - 1);

  if (above)
    prev_u = get_segment_id(cm, cm->q_seg_map, BLOCK_4X4, mi_row - 1, mi_col);

  if (left)
    prev_l = get_segment_id(cm, cm->q_seg_map, BLOCK_4X4, mi_row, mi_col - 1);

  int cdf_num = pick_q_seg_cdf(prev_ul, prev_u, prev_l);
  int pred = pick_q_seg_pred(prev_ul, prev_u, prev_l);

  if (mbmi->skip) {
    set_q_segment_id(cm, cm->q_seg_map, mbmi->sb_type, mi_row, mi_col, pred);
    return 0;
  }

  aom_cdf_prob *pred_cdf = segp->q_seg_cdf[cdf_num];
  int coded_id = aom_read_symbol(r, pred_cdf, 8, ACCT_STR);

  int segment_id = neg_deinterleave(coded_id, pred, seg->q_lvls);

  assert(segment_id >= 0 && segment_id < seg->q_lvls);
  set_q_segment_id(cm, cm->q_seg_map, mbmi->sb_type, mi_row, mi_col,
                   segment_id);

  return segment_id;
}
#endif

Yaowu Xu's avatar
Yaowu Xu committed
369
static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
370
                               MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
371 372
                               TX_SIZE tx_size, int depth, int blk_row,
                               int blk_col, aom_reader *r) {
373 374
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
375
  int is_split = 0;
376 377
  const int tx_row = blk_row >> 1;
  const int tx_col = blk_col >> 1;
378 379
  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);
380 381
  int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
                                   xd->left_txfm_context + blk_row,
382
                                   mbmi->sb_type, tx_size);
clang-format's avatar
clang-format committed
383
  TX_SIZE(*const inter_tx_size)
384 385 386
  [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
387
  assert(tx_size > TX_4X4);
388

Jingning Han's avatar
Jingning Han committed
389
  if (depth == MAX_VARTX_DEPTH) {
390 391
    int idx, idy;
    inter_tx_size[0][0] = tx_size;
392 393
    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)
394 395
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
396
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
397 398
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
399 400 401
    return;
  }

402
  is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR);
403 404

  if (is_split) {
405
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
406 407
    const int bsw = tx_size_wide_unit[sub_txs];
    const int bsh = tx_size_high_unit[sub_txs];
408

409
    if (counts) ++counts->txfm_partition[ctx][1];
410

David Barker's avatar
David Barker committed
411
    if (sub_txs == TX_4X4) {
412
      int idx, idy;
413
      inter_tx_size[0][0] = sub_txs;
414 415
      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)
416
          inter_tx_size[idy][idx] = inter_tx_size[0][0];
417
      mbmi->tx_size = sub_txs;
418
      mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
419 420
      txfm_partition_update(xd->above_txfm_context + blk_col,
                            xd->left_txfm_context + blk_row, sub_txs, tx_size);
421 422 423
      return;
    }

424 425 426 427 428 429 430 431
    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(cm, xd, mbmi, counts, sub_txs, depth + 1, offsetr,
                           offsetc, r);
      }
432 433
    }
  } else {
434
    int idx, idy;
435
    inter_tx_size[0][0] = tx_size;
436 437
    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)
438 439
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
440
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
441
    if (counts) ++counts->txfm_partition[ctx][0];
442 443
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
444 445 446
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
447
static TX_SIZE read_selected_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd,
448
                                     int32_t tx_size_cat, aom_reader *r) {
449
  const int max_depths = tx_size_cat_to_max_depth(tx_size_cat);
Jingning Han's avatar
Jingning Han committed
450
  const int ctx = get_tx_size_context(xd);
451 452 453
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;

454
  const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
455 456 457
                                    max_depths + 1, ACCT_STR);
  assert(depth >= 0 && depth <= max_depths);
  const TX_SIZE tx_size = depth_to_tx_size(depth, tx_size_cat);
458
  assert(!is_rect_tx(tx_size));
459
  return tx_size;
Jingning Han's avatar
Jingning Han committed
460 461
}

462 463 464 465
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;
466
  if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4;
467 468

  if (block_signals_txsize(bsize)) {
469 470 471
    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];
472
      const TX_SIZE coded_tx_size =
473
          read_selected_tx_size(cm, xd, tx_size_cat, r);
474 475
      if (coded_tx_size > max_txsize_lookup[bsize]) {
        assert(coded_tx_size == max_txsize_lookup[bsize] + 1);
476
        return get_max_rect_tx_size(bsize, is_inter);
477 478
      }
      return coded_tx_size;
479
    } else {
480
      return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
481 482
    }
  } else {
Debargha Mukherjee's avatar
Debargha Mukherjee committed
483
    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
484
    return get_max_rect_tx_size(bsize, is_inter);
485
  }
Jingning Han's avatar
Jingning Han committed
486 487
}

Yaowu Xu's avatar
Yaowu Xu committed
488
static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
Jingning Han's avatar
Jingning Han committed
489 490 491 492 493
                              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++)
494
      segment_id =
Yaowu Xu's avatar
Yaowu Xu committed
495
          AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
Jingning Han's avatar
Jingning Han committed
496 497 498 499 500

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

Yaowu Xu's avatar
Yaowu Xu committed
501
static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
502
                           int segment_id) {
Jingning Han's avatar
Jingning Han committed
503 504 505 506 507 508 509 510 511
  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
512
static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
513
                                 int mi_offset, int x_mis, int y_mis,
Yaowu Xu's avatar
Yaowu Xu committed
514
                                 aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
515
  struct segmentation *const seg = &cm->seg;
516
  FRAME_COUNTS *counts = xd->counts;
517 518
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  struct segmentation_probs *const segp = &ec_ctx->seg;
Jingning Han's avatar
Jingning Han committed
519 520
  int segment_id;

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

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

525
  segment_id = read_segment_id(r, segp);
526
  if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
527 528 529 530
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
531
static void copy_segment_id(const AV1_COMMON *cm,
532 533 534
                            const uint8_t *last_segment_ids,
                            uint8_t *current_segment_ids, int mi_offset,
                            int x_mis, int y_mis) {
535 536 537 538
  int x, y;

  for (y = 0; y < y_mis; y++)
    for (x = 0; x < x_mis; x++)
539 540 541
      current_segment_ids[mi_offset + y * cm->mi_cols + x] =
          last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
                           : 0;
542 543
}

Yaowu Xu's avatar
Yaowu Xu committed
544 545
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
546
  struct segmentation *const seg = &cm->seg;
547
  FRAME_COUNTS *counts = xd->counts;
548 549 550
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  struct segmentation_probs *const segp = &ec_ctx->seg;

Jingning Han's avatar
Jingning Han committed
551 552 553
  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;
554 555
  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
556 557

  // TODO(slavarnway): move x_mis, y_mis into xd ?????
Yaowu Xu's avatar
Yaowu Xu committed
558 559
  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
560

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

563 564 565 566
  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
567 568 569 570 571 572 573 574

  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
575
    const int ctx = av1_get_pred_context_seg_id(xd);
576 577
    aom_cdf_prob *pred_cdf = segp->pred_cdf[ctx];
    mbmi->seg_id_predicted = aom_read_symbol(r, pred_cdf, 2, ACCT_STR);
578
    if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted];
579 580 581 582
    if (mbmi->seg_id_predicted) {
      segment_id = predicted_segment_id;
    } else {
      segment_id = read_segment_id(r, segp);
583
      if (counts) ++counts->seg.tree_mispred[segment_id];
584
    }
Jingning Han's avatar
Jingning Han committed
585
  } else {
586
    segment_id = read_segment_id(r, segp);
587
    if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
588 589 590 591 592
  }
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Zoe Liu's avatar
Zoe Liu committed
593 594 595
#if CONFIG_EXT_SKIP
static int read_skip_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
                          aom_reader *r) {
Zoe Liu's avatar
Zoe Liu committed
596
  if (!cm->skip_mode_flag) return 0;
Zoe Liu's avatar
Zoe Liu committed
597 598 599 600 601

  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
    // TODO(zoeliu): To revisit the handling of this scenario.
    return 0;
  }
Zoe Liu's avatar
Zoe Liu committed
602 603 604 605 606 607 608 609 610 611 612

  if (!is_comp_ref_allowed(xd->mi[0]->mbmi.sb_type)) 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);
  FRAME_COUNTS *counts = xd->counts;
  if (counts) ++counts->skip_mode[ctx][skip_mode];

  return skip_mode;
Zoe Liu's avatar
Zoe Liu committed
613 614 615
}
#endif  // CONFIG_EXT_SKIP

Yaowu Xu's avatar
Yaowu Xu committed
616 617
static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
                     aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
618 619 620
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
    return 1;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
621
    const int ctx = av1_get_skip_context(xd);
622 623
    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
    const int skip = aom_read_symbol(r, ec_ctx->skip_cdfs[ctx], 2, ACCT_STR);
Jingning Han's avatar
Jingning Han committed
624
    FRAME_COUNTS *counts = xd->counts;
625
    if (counts) ++counts->skip[ctx][skip];
Jingning Han's avatar
Jingning Han committed
626 627 628 629
    return skip;
  }
}

630
#if CONFIG_PALETTE_DELTA_ENCODING
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
// 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++];
    }
  }
648 649 650 651 652
}

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];
653
  uint16_t cached_colors[PALETTE_MAX_SIZE];
654
  const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
655 656 657
  const int n = pmi->palette_size[0];
  int idx = 0;
  for (int i = 0; i < n_cache && idx < n; ++i)
658
    if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
659
  if (idx < n) {
660
    const int n_cached_colors = idx;
661 662 663 664 665 666
    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) {
667
        assert(range >= 0);
668
        const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
669 670 671
        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]);
672 673 674
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
675 676 677
    merge_colors(pmi->palette_colors, cached_colors, n, n_cached_colors);
  } else {
    memcpy(pmi->palette_colors, cached_colors, n * sizeof(cached_colors[0]));
678 679 680 681 682 683 684 685 686
  }
}

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];
687
  uint16_t cached_colors[PALETTE_MAX_SIZE];
688
  const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
689 690 691 692 693 694
  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;
695 696 697 698 699 700
    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) {
701
        assert(range >= 0);
702
        const int delta = aom_read_literal(r, bits, ACCT_STR);
703 704 705
        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]);
706 707 708
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
709 710 711 712 713
    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]));
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
  }

  // 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
740 741
static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                   aom_reader *r) {
hui su's avatar
hui su committed
742 743
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
744
  const MODE_INFO *const above_mi = xd->above_mi;
745
  const MODE_INFO *const left_mi = xd->left_mi;
hui su's avatar
hui su committed
746
  const BLOCK_SIZE bsize = mbmi->sb_type;
747
  assert(av1_allow_palette(cm->allow_screen_content_tools, bsize));
748
  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
749
  const int block_palette_idx = bsize - BLOCK_8X8;
750
  int modev;
751

752
  if (mbmi->mode == DC_PRED) {
753
    int palette_y_mode_ctx = 0;
754
    if (above_mi) {
755 756
      palette_y_mode_ctx +=
          (above_mi->mbmi.palette_mode_info.palette_size[0] > 0);
757 758
    }
    if (left_mi) {
759 760
      palette_y_mode_ctx +=
          (left_mi->mbmi.palette_mode_info.palette_size[0] > 0);
761
    }
762 763 764 765 766
    modev = aom_read_symbol(
        r,
        xd->tile_ctx->palette_y_mode_cdf[block_palette_idx][palette_y_mode_ctx],
        2, ACCT_STR);
    if (modev) {
767
      pmi->palette_size[0] =
768
          aom_read_symbol(r,
769
                          xd->tile_ctx->palette_y_size_cdf[block_palette_idx],
770 771
                          PALETTE_SIZES, ACCT_STR) +
          2;
hui su's avatar
hui su committed
772
#if CONFIG_PALETTE_DELTA_ENCODING
773
      read_palette_colors_y(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
774
#else
775
      for (int i = 0; i < pmi->palette_size[0]; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
776
        pmi->palette_colors[i] = aom_read_literal(r, cm->bit_depth, ACCT_STR);
hui su's avatar
hui su committed
777
#endif  // CONFIG_PALETTE_DELTA_ENCODING
778 779
    }
  }
Luc Trudeau's avatar
Luc Trudeau committed
780
  if (mbmi->uv_mode == UV_DC_PRED) {
781
    const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
782 783 784
    modev = aom_read_symbol(
        r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR);
    if (modev) {
785
      pmi->palette_size[1] =
786
          aom_read_symbol(r,
787
                          xd->tile_ctx->palette_uv_size_cdf[block_palette_idx],
788 789
                          PALETTE_SIZES, ACCT_STR) +
          2;
hui su's avatar
hui su committed
790
#if CONFIG_PALETTE_DELTA_ENCODING
791
      read_palette_colors_uv(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
792
#else
793
      for (int i = 0; i < pmi->palette_size[1]; ++i) {
794
        pmi->palette_colors[PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
795
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
796
        pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
797
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
798
      }
hui su's avatar
hui su committed
799
#endif  // CONFIG_PALETTE_DELTA_ENCODING
800
    }
hui su's avatar
hui su committed
801 802 803
  }
}

804
#if CONFIG_FILTER_INTRA
805
static void read_filter_intra_mode_info(MACROBLOCKD *const xd, aom_reader *r) {
hui su's avatar
hui su committed
806 807
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
808 809
  FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
      &mbmi->filter_intra_mode_info;
hui su's avatar
hui su committed
810

811 812
  if (mbmi->mode == DC_PRED && mbmi->palette_mode_info.palette_size[0] == 0 &&
      av1_filter_intra_allowed_txsize(mbmi->tx_size)) {
813 814
    filter_intra_mode_info->use_filter_intra_mode[0] = aom_read_symbol(
        r, xd->tile_ctx->filter_intra_cdfs[mbmi->tx_size], 2, ACCT_STR);
815 816
    if (filter_intra_mode_info->use_filter_intra_mode[0]) {
      filter_intra_mode_info->filter_intra_mode[0] =
817 818
          aom_read_symbol(r, xd->tile_ctx->filter_intra_mode_cdf[0],
                          FILTER_INTRA_MODES, ACCT_STR);
hui su's avatar
hui su committed
819 820 821
    }
  }
}
822
#endif  // CONFIG_FILTER_INTRA
823

824
#if CONFIG_EXT_INTRA
Joe Young's avatar
Joe Young committed
825 826 827 828 829 830 831
#if CONFIG_EXT_INTRA_MOD
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;
}
#endif  // CONFIG_EXT_INTRA_MOD

Hui Su's avatar
Hui Su committed
832
static void read_intra_angle_info(MACROBLOCKD *const xd, aom_reader *r) {
833 834
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
  const BLOCK_SIZE bsize = mbmi->sb_type;
Joe Young's avatar
Joe Young committed
835 836 837 838
#if CONFIG_EXT_INTRA_MOD
  FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
#endif  // CONFIG_EXT_INTRA_MOD

839 840 841
  mbmi->angle_delta[0] = 0;
  mbmi->angle_delta[1] = 0;
  if (!av1_use_angle_delta(bsize)) return;
842

hui su's avatar
hui su committed
843
  if (av1_is_directional_mode(mbmi->mode, bsize)) {
Joe Young's avatar
Joe Young committed
844 845 846 847
#if CONFIG_EXT_INTRA_MOD
    mbmi->angle_delta[0] =
        read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED]);
#else
848
    mbmi->angle_delta[0] =
849
        av1_read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
Joe Young's avatar
Joe Young committed
850
#endif  // CONFIG_EXT_INTRA_MOD
851 852
  }

Luc Trudeau's avatar
Luc Trudeau committed
853
  if (av1_is_directional_mode(get_uv_mode(mbmi->uv_mode), bsize)) {
Joe Young's avatar
Joe Young committed
854 855 856 857
#if CONFIG_EXT_INTRA_MOD
    mbmi->angle_delta[1] =
        read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED]);
#else
858
    mbmi->angle_delta[1] =
859
        av1_read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
Joe Young's avatar
Joe Young committed
860
#endif  // CONFIG_EXT_INTRA_MOD
861 862
  }
}
hui su's avatar
hui su committed
863 864
#endif  // CONFIG_EXT_INTRA

865
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd,
Angie Chiang's avatar
Angie Chiang committed
866
#if CONFIG_TXK_SEL
867 868
                      int blk_row, int blk_col, int block, int plane,
                      TX_SIZE tx_size,
869 870 871
#endif
                      aom_reader *r) {
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
Jingning Han's avatar
Jingning Han committed
872
  const int inter_block = is_inter_block(mbmi);
873
#if !CONFIG_TXK_SEL
874 875
  const TX_SIZE mtx_size =
      get_max_rect_tx_size(xd->mi[0]->mbmi.sb_type, inter_block);
876
  const TX_SIZE tx_size =
877
      inter_block ? AOMMAX(sub_tx_size_map[mtx_size], mbmi->min_tx_size)
878
                  : mbmi->tx_size;
879
#endif  // !CONFIG_TXK_SEL
880 881
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;

Angie Chiang's avatar
Angie Chiang committed
882
#if !CONFIG_TXK_SEL
883 884
  TX_TYPE *tx_type = &mbmi->tx_type;
#else
885 886
  // only y plane's tx_type is transmitted
  if (plane > 0) return;
887 888
  (void)block;
  TX_TYPE *tx_type = &mbmi->txk_type[(blk_row << 4) + blk_col];
889 890
#endif

Jingning Han's avatar
Jingning Han committed
891
  if (!FIXED_TX_TYPE) {
892
    const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
893 894
    if (get_ext_tx_types(tx_size, mbmi->sb_type, inter_block,
                         cm->reduced_tx_set_used) > 1 &&
895 896 897
        ((!cm->seg.enabled && cm->base_qindex > 0) ||
         (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
        !mbmi->skip &&