decodemv.c 85.6 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

Luc Trudeau's avatar
Luc Trudeau committed
32
33
34
35
#if CONFIG_CFL
#include "av1/common/cfl.h"
#endif

Michael Bebenita's avatar
Michael Bebenita committed
36
#define ACCT_STR __func__
37

38
#define DEC_MISMATCH_DEBUG 0
39

40
static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
Hui Su's avatar
Hui Su committed
41
  return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR);
42
}
Jingning Han's avatar
Jingning Han committed
43

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
static void read_cdef(AV1_COMMON *cm, aom_reader *r, MB_MODE_INFO *const mbmi,
                      int mi_col, int mi_row) {
  if (cm->all_lossless) return;

  const int m = ~((1 << (6 - MI_SIZE_LOG2)) - 1);
  if (!(mi_col & (cm->mib_size - 1)) &&
      !(mi_row & (cm->mib_size - 1))) {  // Top left?
#if CONFIG_EXT_PARTITION
    cm->cdef_preset[0] = cm->cdef_preset[1] = cm->cdef_preset[2] =
        cm->cdef_preset[3] = -1;
#else
    cm->cdef_preset = -1;
#endif
  }
// Read CDEF param at first a non-skip coding block
#if CONFIG_EXT_PARTITION
  const int mask = 1 << (6 - MI_SIZE_LOG2);
  const int index = cm->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)]
      ->mbmi.cdef_strength = cm->cdef_preset[index] =
      cm->cdef_preset[index] == -1 && !mbmi->skip
          ? aom_read_literal(r, cm->cdef_bits, ACCT_STR)
          : cm->cdef_preset[index];
#else
  cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]
      ->mbmi.cdef_strength = cm->cdef_preset =
      cm->cdef_preset == -1 && !mbmi->skip
          ? aom_read_literal(r, cm->cdef_bits, ACCT_STR)
          : cm->cdef_preset;
#endif
}

78
79
80
81
82
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;
83
84
  const int b_col = mi_col & (cm->mib_size - 1);
  const int b_row = mi_row & (cm->mib_size - 1);
85
  const int read_delta_q_flag = (b_col == 0 && b_row == 0);
Thomas Davies's avatar
Thomas Davies committed
86
87
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
88

Pavel Frolov's avatar
Pavel Frolov committed
89
  if ((bsize != cm->sb_size || mbmi->skip == 0) && read_delta_q_flag) {
Thomas Davies's avatar
Thomas Davies committed
90
    abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
91
    const int smallval = (abs < DELTA_Q_SMALL);
Thomas Davies's avatar
Thomas Davies committed
92
    if (counts) {
93
      for (int i = 0; i < abs; ++i) counts->delta_q[i][1]++;
Thomas Davies's avatar
Thomas Davies committed
94
95
96
97
      if (smallval) counts->delta_q[abs][0]++;
    }

    if (!smallval) {
98
99
      const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
      const int thr = (1 << rem_bits) + 1;
100
101
102
103
104
105
106
107
108
109
110
111
112
      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
113
114
#if CONFIG_EXT_DELTA_Q
static int read_delta_lflevel(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r,
115
116
117
#if CONFIG_LOOPFILTER_LEVEL
                              int lf_id,
#endif
Fangwen Fu's avatar
Fangwen Fu committed
118
119
120
121
122
                              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;
123
124
  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
125
126
127
128
  const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;

129
  if ((bsize != cm->sb_size || mbmi->skip == 0) && read_delta_lf_flag) {
130
#if CONFIG_LOOPFILTER_LEVEL
131
132
133
134
135
136
137
138
    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);
    }
139
#else
Fangwen Fu's avatar
Fangwen Fu committed
140
141
    abs =
        aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1, ACCT_STR);
142
#endif  // CONFIG_LOOPFILTER_LEVEL
143
    const int smallval = (abs < DELTA_LF_SMALL);
Fangwen Fu's avatar
Fangwen Fu committed
144
    if (counts) {
145
#if CONFIG_LOOPFILTER_LEVEL
146
      if (cm->delta_lf_multi) {
147
        for (int i = 0; i < abs; ++i) counts->delta_lf_multi[lf_id][i][1]++;
148
149
        if (smallval) counts->delta_lf_multi[lf_id][abs][0]++;
      } else {
150
        for (int i = 0; i < abs; ++i) counts->delta_lf[i][1]++;
151
152
        if (smallval) counts->delta_lf[abs][0]++;
      }
153
#else
154
      for (int i = 0; i < abs; ++i) counts->delta_lf[i][1]++;
Fangwen Fu's avatar
Fangwen Fu committed
155
      if (smallval) counts->delta_lf[abs][0]++;
156
#endif  // CONFIG_LOOPFILTER_LEVEL
Fangwen Fu's avatar
Fangwen Fu committed
157
158
    }
    if (!smallval) {
159
160
      const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
      const int thr = (1 << rem_bits) + 1;
Fangwen Fu's avatar
Fangwen Fu committed
161
162
163
164
165
166
167
168
169
170
171
172
173
174
      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
175

Luc Trudeau's avatar
Luc Trudeau committed
176
static UV_PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx,
177
                                             aom_reader *r,
178
179
180
#if CONFIG_CFL
                                             CFL_ALLOWED_TYPE cfl_allowed,
#endif
Luc Trudeau's avatar
Luc Trudeau committed
181
182
                                             PREDICTION_MODE y_mode) {
  const UV_PREDICTION_MODE uv_mode =
183
#if CONFIG_CFL
184
185
      aom_read_symbol(r, ec_ctx->uv_mode_cdf[cfl_allowed][y_mode],
                      UV_INTRA_MODES - !cfl_allowed, ACCT_STR);
186
#else
187
      read_intra_mode(r, ec_ctx->uv_mode_cdf[y_mode]);
188
#endif  // CONFIG_CFL
Jingning Han's avatar
Jingning Han committed
189
190
191
  return uv_mode;
}

Luc Trudeau's avatar
Luc Trudeau committed
192
#if CONFIG_CFL
193
static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r,
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
                           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
210
211
212
}
#endif

Yue Chen's avatar
Yue Chen committed
213
214
static INTERINTRA_MODE read_interintra_mode(MACROBLOCKD *xd, aom_reader *r,
                                            int size_group) {
215
216
217
  const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_symbol(
      r, xd->tile_ctx->interintra_mode_cdf[size_group], INTERINTRA_MODES,
      ACCT_STR);
218
  FRAME_COUNTS *counts = xd->counts;
219
  if (counts) ++counts->interintra_mode[size_group][ii_mode];
220
221
222
  return ii_mode;
}

223
static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
224
                                       aom_reader *r, int16_t ctx) {
225
  FRAME_COUNTS *counts = xd->counts;
226
  int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
227
228
229
  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) {
230
    if (counts) ++counts->newmv_mode[mode_ctx][0];
231
    return NEWMV;
232
  }
233
  if (counts) ++counts->newmv_mode[mode_ctx][1];
Sarah Parker's avatar
Sarah Parker committed
234
  mode_ctx = (ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
235
236
237
  is_zeromv =
      aom_read_symbol(r, ec_ctx->zeromv_cdf[mode_ctx], 2, ACCT_STR) == 0;
  if (is_zeromv) {
238
    if (counts) ++counts->zeromv_mode[mode_ctx][0];
Sarah Parker's avatar
Sarah Parker committed
239
    return GLOBALMV;
240
  }
241
  if (counts) ++counts->zeromv_mode[mode_ctx][1];
242
  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
243
244
245
  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;
246
247
  is_refmv = aom_read_symbol(r, ec_ctx->refmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
  if (is_refmv) {
248
    if (counts) ++counts->refmv_mode[mode_ctx][0];
249
250
    return NEARESTMV;
  } else {
251
    if (counts) ++counts->refmv_mode[mode_ctx][1];
252
253
    return NEARMV;
  }
Jingning Han's avatar
Jingning Han committed
254
255
}

256
static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
257
258
                         MB_MODE_INFO *mbmi, aom_reader *r) {
  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
259
  mbmi->ref_mv_idx = 0;
260
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
261
    for (int idx = 0; idx < 2; ++idx) {
262
      if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
Yaowu Xu's avatar
Yaowu Xu committed
263
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
264
265
266
267
        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;
268
269
270
      }
    }
  }
David Barker's avatar
David Barker committed
271
  if (have_nearmv_in_inter_mode(mbmi->mode)) {
272
273
274
    // Offset the NEARESTMV mode.
    // TODO(jingning): Unify the two syntax decoding loops after the NEARESTMV
    // mode is factored in.
275
    for (int idx = 1; idx < 3; ++idx) {
276
      if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
Yaowu Xu's avatar
Yaowu Xu committed
277
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
278
279
280
281
        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;
282
283
284
285
286
      }
    }
  }
}

287
288
static MOTION_MODE read_motion_mode(MACROBLOCKD *xd, MODE_INFO *mi,
                                    aom_reader *r) {
289
  MB_MODE_INFO *mbmi = &mi->mbmi;
Thomas Davies's avatar
Thomas Davies committed
290

Zoe Liu's avatar
Zoe Liu committed
291
292
293
294
#if CONFIG_EXT_SKIP
  if (mbmi->skip_mode) return SIMPLE_TRANSLATION;
#endif  // CONFIG_EXT_SKIP

295
  const MOTION_MODE last_motion_mode_allowed =
Luc Trudeau's avatar
Luc Trudeau committed
296
      motion_mode_allowed(xd->global_motion, xd, mi);
Yue Chen's avatar
Yue Chen committed
297
298
  int motion_mode;
  FRAME_COUNTS *counts = xd->counts;
Yaowu Xu's avatar
Yaowu Xu committed
299

Yue Chen's avatar
Yue Chen committed
300
  if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
Yue Chen's avatar
Yue Chen committed
301

Yue Chen's avatar
Yue Chen committed
302
  if (last_motion_mode_allowed == OBMC_CAUSAL) {
303
304
    motion_mode =
        aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2, ACCT_STR);
Yue Chen's avatar
Yue Chen committed
305
306
307
    if (counts) ++counts->obmc[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
308
    motion_mode =
Thomas Davies's avatar
Thomas Davies committed
309
310
        aom_read_symbol(r, xd->tile_ctx->motion_mode_cdf[mbmi->sb_type],
                        MOTION_MODES, ACCT_STR);
Yaowu Xu's avatar
Yaowu Xu committed
311
312
313
314
    if (counts) ++counts->motion_mode[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
  }
}
315

Yaowu Xu's avatar
Yaowu Xu committed
316
317
static PREDICTION_MODE read_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
                                                aom_reader *r, int16_t ctx) {
318
319
320
321
  (void)cm;
  const int mode =
      aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
                      INTER_COMPOUND_MODES, ACCT_STR);
322
  FRAME_COUNTS *counts = xd->counts;
323
  if (counts) ++counts->inter_compound_mode[ctx][mode];
324
325
326
  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
  return NEAREST_NEARESTMV + mode;
}
327

328
#if CONFIG_SPATIAL_SEGMENTATION
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
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);
  }
}

351
352
static int read_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                           int mi_row, int mi_col, aom_reader *r, int skip) {
353
354
355
356
357
358
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  struct segmentation_probs *const segp = &ec_ctx->seg;
  int prev_ul = 0; /* Top left segment_id */
  int prev_l = 0;  /* Current left segment_id */
  int prev_u = 0;  /* Current top segment_id */

359
  if ((xd->up_available) && (xd->left_available))
360
361
    prev_ul = get_segment_id(cm, cm->current_frame_seg_map, BLOCK_4X4,
                             mi_row - 1, mi_col - 1);
362

363
  if (xd->up_available)
364
365
    prev_u = get_segment_id(cm, cm->current_frame_seg_map, BLOCK_4X4,
                            mi_row - 1, mi_col - 0);
366

367
  if (xd->left_available)
368
369
    prev_l = get_segment_id(cm, cm->current_frame_seg_map, BLOCK_4X4,
                            mi_row - 0, mi_col - 1);
370

371
372
  int cdf_num = pick_spatial_seg_cdf(prev_ul, prev_u, prev_l);
  int pred = pick_spatial_seg_pred(prev_ul, prev_u, prev_l);
373

374
  if (skip) return pred;
375

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

379
  int segment_id = neg_deinterleave(coded_id, pred, cm->last_active_segid + 1);
380

381
  assert(segment_id >= 0 && segment_id <= cm->last_active_segid);
382
383
384

  return segment_id;
}
385
386
387
388
#else
static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) {
  return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
}
389
390
#endif

Yaowu Xu's avatar
Yaowu Xu committed
391
static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
392
                               MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
393
394
                               TX_SIZE tx_size, int depth, int blk_row,
                               int blk_col, aom_reader *r) {
395
396
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
397
  int is_split = 0;
398
399
  const int tx_row = blk_row >> 1;
  const int tx_col = blk_col >> 1;
400
401
  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);
402
403
  int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
                                   xd->left_txfm_context + blk_row,
404
                                   mbmi->sb_type, tx_size);
clang-format's avatar
clang-format committed
405
  TX_SIZE(*const inter_tx_size)
406
407
408
  [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
409
  assert(tx_size > TX_4X4);
410

Jingning Han's avatar
Jingning Han committed
411
  if (depth == MAX_VARTX_DEPTH) {
412
413
    int idx, idy;
    inter_tx_size[0][0] = tx_size;
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
417
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
418
    mbmi->min_tx_size = TXSIZEMIN(mbmi->min_tx_size, tx_size);
419
420
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
421
422
423
    return;
  }

424
  is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR);
425
426

  if (is_split) {
427
    const TX_SIZE sub_txs = sub_tx_size_map[1][tx_size];
428
429
    const int bsw = tx_size_wide_unit[sub_txs];
    const int bsh = tx_size_high_unit[sub_txs];
430

431
    if (counts) ++counts->txfm_partition[ctx][1];
432

David Barker's avatar
David Barker committed
433
    if (sub_txs == TX_4X4) {
434
      int idx, idy;
435
      inter_tx_size[0][0] = sub_txs;
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
          inter_tx_size[idy][idx] = inter_tx_size[0][0];
439
      mbmi->tx_size = sub_txs;
440
      mbmi->min_tx_size = mbmi->tx_size;
441
442
      txfm_partition_update(xd->above_txfm_context + blk_col,
                            xd->left_txfm_context + blk_row, sub_txs, tx_size);
443
444
445
      return;
    }

446
447
448
449
450
451
452
453
    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);
      }
454
455
    }
  } else {
456
    int idx, idy;
457
    inter_tx_size[0][0] = tx_size;
458
459
    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)
460
461
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
462
    mbmi->min_tx_size = TXSIZEMIN(mbmi->min_tx_size, tx_size);
463
    if (counts) ++counts->txfm_partition[ctx][0];
464
465
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
466
467
468
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
469
static TX_SIZE read_selected_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd,
470
471
472
473
                                     int is_inter, 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]->mbmi.sb_type;
474
  const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize, is_inter);
475
  const int max_depths = bsize_to_max_depth(bsize, 0);
476
  const int ctx = get_tx_size_context(xd, is_inter);
477
478
479
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;

480
  const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
481
482
                                    max_depths + 1, ACCT_STR);
  assert(depth >= 0 && depth <= max_depths);
483
  const TX_SIZE tx_size = depth_to_tx_size(depth, bsize, 0);
484
  return tx_size;
Jingning Han's avatar
Jingning Han committed
485
486
}

487
488
489
490
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;
491
  if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4;
492
493

  if (block_signals_txsize(bsize)) {
494
    if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) {
495
      const TX_SIZE coded_tx_size = read_selected_tx_size(cm, xd, is_inter, r);
496
      return coded_tx_size;
497
    } else {
498
      return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
499
500
    }
  } else {
Debargha Mukherjee's avatar
Debargha Mukherjee committed
501
    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
502
    return get_max_rect_tx_size(bsize, is_inter);
503
  }
Jingning Han's avatar
Jingning Han committed
504
505
}

Yaowu Xu's avatar
Yaowu Xu committed
506
static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
Jingning Han's avatar
Jingning Han committed
507
                              int mi_offset, int x_mis, int y_mis) {
508
  int segment_id = INT_MAX;
Jingning Han's avatar
Jingning Han committed
509

510
511
  for (int y = 0; y < y_mis; y++)
    for (int x = 0; x < x_mis; x++)
512
      segment_id =
Yaowu Xu's avatar
Yaowu Xu committed
513
          AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
Jingning Han's avatar
Jingning Han committed
514
515
516
517
518

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

Yaowu Xu's avatar
Yaowu Xu committed
519
static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
520
                           int segment_id) {
Jingning Han's avatar
Jingning Han committed
521
522
  assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);

523
524
  for (int y = 0; y < y_mis; y++)
    for (int x = 0; x < x_mis; x++)
Jingning Han's avatar
Jingning Han committed
525
526
527
      cm->current_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
528
static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
529
530
                                 MB_MODE_INFO *const mbmi, int mi_row,
                                 int mi_col, int bsize, int preskip,
Yaowu Xu's avatar
Yaowu Xu committed
531
                                 aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
532
  struct segmentation *const seg = &cm->seg;
533
534
535
536
537
  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);
Jingning Han's avatar
Jingning Han committed
538

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

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

543
544
545
546
547
548
#if CONFIG_SPATIAL_SEGMENTATION
  if (preskip) {
    if (!cm->preskip_segid) return 0;
  } else {
    if (cm->preskip_segid) return mbmi->segment_id;
  }
549
  const int segment_id =
550
551
552
553
554
      read_segment_id(cm, xd, mi_row, mi_col, r, preskip ? 0 : mbmi->skip);
#else
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)preskip;
  (void)mbmi;
555
  const int segment_id = read_segment_id(r, &ec_ctx->seg);
556
#endif
Jingning Han's avatar
Jingning Han committed
557
558
559
560
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
561
static void copy_segment_id(const AV1_COMMON *cm,
562
563
564
                            const uint8_t *last_segment_ids,
                            uint8_t *current_segment_ids, int mi_offset,
                            int x_mis, int y_mis) {
565
566
  for (int y = 0; y < y_mis; y++)
    for (int x = 0; x < x_mis; x++)
567
568
569
      current_segment_ids[mi_offset + y * cm->mi_cols + x] =
          last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
                           : 0;
570
571
}

Yaowu Xu's avatar
Yaowu Xu committed
572
static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
573
574
                                 int mi_row, int mi_col, int preskip,
                                 aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
575
  struct segmentation *const seg = &cm->seg;
576
577
578
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  struct segmentation_probs *const segp = &ec_ctx->seg;

Jingning Han's avatar
Jingning Han committed
579
580
581
  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;
582
583
  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
584
585

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

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

591
592
593
594
  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
595
596
597
598
599
600
601

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

602
603
604
605
606
607
608
609
610
#if CONFIG_SPATIAL_SEGMENTATION
  if (preskip) {
    if (!cm->preskip_segid) return 0;
  } else {
    if (cm->preskip_segid) return mbmi->segment_id;
    if (mbmi->skip) {
      if (seg->temporal_update) {
        mbmi->seg_id_predicted = 0;
      }
611
      segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 1);
612
613
614
615
616
617
      set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
      return segment_id;
    }
  }
#endif
  (void)preskip;
Jingning Han's avatar
Jingning Han committed
618
  if (seg->temporal_update) {
Yaowu Xu's avatar
Yaowu Xu committed
619
    const int ctx = av1_get_pred_context_seg_id(xd);
620
621
    aom_cdf_prob *pred_cdf = segp->pred_cdf[ctx];
    mbmi->seg_id_predicted = aom_read_symbol(r, pred_cdf, 2, ACCT_STR);
622
623
624
    if (mbmi->seg_id_predicted) {
      segment_id = predicted_segment_id;
    } else {
625
626
627
#if CONFIG_SPATIAL_SEGMENTATION
      segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0);
#else
628
      segment_id = read_segment_id(r, segp);
629
#endif
630
    }
Jingning Han's avatar
Jingning Han committed
631
  } else {
632
633
634
#if CONFIG_SPATIAL_SEGMENTATION
    segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0);
#else
635
    segment_id = read_segment_id(r, segp);
636
#endif
Jingning Han's avatar
Jingning Han committed
637
638
639
640
641
  }
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Zoe Liu's avatar
Zoe Liu committed
642
643
644
#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
645
  if (!cm->skip_mode_flag) return 0;
Zoe Liu's avatar
Zoe Liu committed
646
647
648
649
650

  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
651
652
653
654
655
656
657
658
659
660
661

  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
662
663
664
}
#endif  // CONFIG_EXT_SKIP

Yaowu Xu's avatar
Yaowu Xu committed
665
666
static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
                     aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
667
668
669
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
    return 1;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
670
    const int ctx = av1_get_skip_context(xd);
671
672
    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
673
    FRAME_COUNTS *counts = xd->counts;
674
    if (counts) ++counts->skip[ctx][skip];
Jingning Han's avatar
Jingning Han committed
675
676
677
678
    return skip;
  }
}

679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
// 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++];
    }
  }
696
697
698
699
700
}

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];
701
  uint16_t cached_colors[PALETTE_MAX_SIZE];
702
  const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
703
704
705
  const int n = pmi->palette_size[0];
  int idx = 0;
  for (int i = 0; i < n_cache && idx < n; ++i)
706
    if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
707
  if (idx < n) {
708
    const int n_cached_colors = idx;
709
710
711
712
713
714
    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) {
715
        assert(range >= 0);
716
        const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
717
718
719
        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]);
720
721
722
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
723
724
725
    merge_colors(pmi->palette_colors, cached_colors, n, n_cached_colors);
  } else {
    memcpy(pmi->palette_colors, cached_colors, n * sizeof(cached_colors[0]));
726
727
728
729
730
731
732
733
734
  }
}

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];
735
  uint16_t cached_colors[PALETTE_MAX_SIZE];
736
  const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
737
738
739
740
741
742
  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;
743
744
745
746
747
748
    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) {
749
        assert(range >= 0);
750
        const int delta = aom_read_literal(r, bits, ACCT_STR);
751
752
753
        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]);
754
755
756
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
757
758
759
760
761
    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]));
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
  }

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

Yaowu Xu's avatar
Yaowu Xu committed
787
static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
788
                                   int mi_row, int mi_col, aom_reader *r) {
hui su's avatar
hui su committed
789
790
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
791
  const MODE_INFO *const above_mi = xd->above_mi;
792
  const MODE_INFO *const left_mi = xd->left_mi;
hui su's avatar
hui su committed
793
  const BLOCK_SIZE bsize = mbmi->sb_type;
794
  assert(av1_allow_palette(cm->allow_screen_content_tools, bsize));
795
  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
Hui Su's avatar
Hui Su committed
796
  const int bsize_ctx = av1_get_palette_bsize_ctx(bsize);
797

798
  if (mbmi->mode == DC_PRED) {
799
    int palette_y_mode_ctx = 0;
800
    if (above_mi) {
801
802
      palette_y_mode_ctx +=
          (above_mi->mbmi.palette_mode_info.palette_size[0] > 0);
803
804
    }
    if (left_mi) {
805
806
      palette_y_mode_ctx +=
          (left_mi->mbmi.palette_mode_info.palette_size[0] > 0);
807
    }
808
    const int modev = aom_read_symbol(
Hui Su's avatar
Hui Su committed
809
810
        r, xd->tile_ctx->palette_y_mode_cdf[bsize_ctx][palette_y_mode_ctx], 2,
        ACCT_STR);
811
    if (modev) {
812
      pmi->palette_size[0] =
Hui Su's avatar
Hui Su committed
813
          aom_read_symbol(r, xd->tile_ctx->palette_y_size_cdf[bsize_ctx],
814
815
                          PALETTE_SIZES, ACCT_STR) +
          2;
816
      read_palette_colors_y(xd, cm->bit_depth, pmi, r);
817
818
    }
  }
819
820
821
  if (mbmi->uv_mode == UV_DC_PRED &&
      is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x,
                          xd->plane[1].subsampling_y)) {
822
    const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
823
    const int modev = aom_read_symbol(
824
825
        r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR);
    if (modev) {
826
      pmi->palette_size[1] =
Hui Su's avatar
Hui Su committed
827
          aom_read_symbol(r, xd->tile_ctx->palette_uv_size_cdf[bsize_ctx],
828
829
                          PALETTE_SIZES, ACCT_STR) +
          2;
830
      read_palette_colors_uv(xd, cm->bit_depth, pmi, r);
831
    }
hui su's avatar
hui su committed
832
833
834
  }
}

835
#if CONFIG_FILTER_INTRA
836
static void read_filter_intra_mode_info(MACROBLOCKD *const xd, aom_reader *r) {
hui su's avatar
hui su committed
837
838
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
839
840
  FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
      &mbmi->filter_intra_mode_info;
hui su's avatar
hui su committed
841

842
843
  if (mbmi->mode == DC_PRED && mbmi->palette_mode_info.palette_size[0] == 0 &&
      av1_filter_intra_allowed_txsize(mbmi->tx_size)) {
844
    filter_intra_mode_info->use_filter_intra = aom_read_symbol(
845
        r, xd->tile_ctx->filter_intra_cdfs[mbmi->tx_size], 2, ACCT_STR);
846
    if (filter_intra_mode_info->use_filter_intra) {
847
848
      filter_intra_mode_info->filter_intra_mode = aom_read_symbol(
          r, xd->tile_ctx->filter_intra_mode_cdf, FILTER_INTRA_MODES, ACCT_STR);
hui su's avatar
hui su committed
849
850
851
    }
  }
}
852
#endif  // CONFIG_FILTER_INTRA
853

854
#if CONFIG_EXT_INTRA
Joe Young's avatar
Joe Young committed
855
856
857
858
859
860
861
#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
862
static void read_intra_angle_info(MACROBLOCKD *const xd, aom_reader *r) {
863
864
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
  const BLOCK_SIZE bsize = mbmi->sb_type;
Joe Young's avatar
Joe Young committed
865
866
867
868
#if CONFIG_EXT_INTRA_MOD
  FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
#endif  // CONFIG_EXT_INTRA_MOD

869
870
871
  mbmi->angle_delta[0] = 0;
  mbmi->angle_delta[1] = 0;
  if (!av1_use_angle_delta(bsize)) return;
872

hui su's avatar
hui su committed
873
  if (av1_is_directional_mode(mbmi->mode, bsize)) {
Joe Young's avatar
Joe Young committed
874
875
876
877
#if CONFIG_EXT_INTRA_MOD
    mbmi->angle_delta[0] =
        read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED]);
#else
878
    mbmi->angle_delta[0] =
879
        av1_read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
Joe Young's avatar
Joe Young committed
880
#endif  // CONFIG_EXT_INTRA_MOD
881
882
  }

Luc Trudeau's avatar
Luc Trudeau committed
883
  if (av1_is_directional_mode(get_uv_mode(mbmi->uv_mode), bsize)) {
Joe Young's avatar
Joe Young committed
884
885
886
887
#if CONFIG_EXT_INTRA_MOD
    mbmi->angle_delta[1] =
        read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED]);
#else
888
    mbmi->angle_delta[1] =
889
        av1_read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
Joe Young's avatar
Joe Young committed
890
#endif  // CONFIG_EXT_INTRA_MOD
891
892
  }
}
hui su's avatar
hui su committed
893
894
#endif  // CONFIG_EXT_INTRA

895
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd,
Angie Chiang's avatar
Angie Chiang committed
896
#if CONFIG_TXK_SEL
Luc Trudeau's avatar
Luc Trudeau committed
897
                      int blk_row, int blk_col, int plane, TX_SIZE tx_size,
898
899
900
#endif
                      aom_reader *r) {
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
Jingning Han's avatar
Jingning Han committed
901
  const int inter_block = is_inter_block(mbmi);
902
#if !CONFIG_TXK_SEL
903
904
  const TX_SIZE mtx_size =
      get_max_rect_tx_size(xd->mi[0]->mbmi.sb_type, inter_block);
905
  const TX_SIZE tx_size =
906
      inter_block ? AOMMAX(sub_tx_size_map[1][mtx_size], mbmi->min_tx_size)
907
                  : mbmi->tx_size;
908
#endif  // !CONFIG_TXK_SEL
909
910
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;

Angie Chiang's avatar
Angie Chiang committed
911
#if !CONFIG_TXK_SEL
912
913
  TX_TYPE *tx_type = &mbmi->tx_type;
#else
914
915
  // only y plane's tx_type is transmitted
  if (plane > 0) return;
Angie Chiang's avatar
Angie Chiang committed
916
  TX_TYPE *tx_type = &mbmi->txk_type[(blk_row << MAX_MIB_SIZE_LOG2) + blk_col];
917
918
#endif

Jingning Han's avatar
Jingning Han committed
919
  if (!FIXED_TX_TYPE) {
920
    const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
921
922
    if (get_ext_tx_types(tx_size, mbmi->sb_type, inter_block,
                         cm->reduced_tx_set_used) > 1 &&
923
924
925