decodemv.c 102 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
26
27
#if CONFIG_WARPED_MOTION
#include "av1/common/warped_motion.h"
#endif  // CONFIG_WARPED_MOTION
28
29

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

Yaowu Xu's avatar
Yaowu Xu committed
32
#include "aom_dsp/aom_dsp_common.h"
33

Michael Bebenita's avatar
Michael Bebenita committed
34
#define ACCT_STR __func__
35

36
#define DEC_MISMATCH_DEBUG 0
37

38
#if CONFIG_EXT_INTRA || CONFIG_FILTER_INTRA || CONFIG_PALETTE
Yaowu Xu's avatar
Yaowu Xu committed
39
static INLINE int read_uniform(aom_reader *r, int n) {
40
41
42
  const int l = get_unsigned_bits(n);
  const int m = (1 << l) - n;
  const int v = aom_read_literal(r, l - 1, ACCT_STR);
hui su's avatar
hui su committed
43
44
45
46
  assert(l != 0);
  if (v < m)
    return v;
  else
Michael Bebenita's avatar
Michael Bebenita committed
47
    return (v << 1) - m + aom_read_literal(r, 1, ACCT_STR);
hui su's avatar
hui su committed
48
}
49
#endif  // CONFIG_EXT_INTRA || CONFIG_FILTER_INTRA || CONFIG_PALETTE
hui su's avatar
hui su committed
50

51
static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
52
53
54
  return (PREDICTION_MODE)
      av1_intra_mode_inv[aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR)];
}
Jingning Han's avatar
Jingning Han committed
55

56
57
58
59
60
61
62
63
64
#if CONFIG_DELTA_Q
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;
  const int b_col = mi_col & MAX_MIB_MASK;
  const int b_row = mi_row & MAX_MIB_MASK;
  const int read_delta_q_flag = (b_col == 0 && b_row == 0);
Thomas Davies's avatar
Thomas Davies committed
65
66
67
68
69
70
71
72
  int rem_bits, thr;
  int i, smallval;
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
#else
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif
73

74
  if ((bsize != BLOCK_LARGEST || mbmi->skip == 0) && read_delta_q_flag) {
Thomas Davies's avatar
Thomas Davies committed
75
76
77
78
79
80
81
82
    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) {
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
      rem_bits = aom_read_literal(r, 3, ACCT_STR);
      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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#if CONFIG_EXT_DELTA_Q
static int read_delta_lflevel(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_lflevel = 0;
  BLOCK_SIZE bsize = mbmi->sb_type;
  const int b_col = mi_col & MAX_MIB_MASK;
  const int b_row = mi_row & MAX_MIB_MASK;
  const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
  int rem_bits, thr;
  int i, smallval;
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
#else
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif

  if ((bsize != BLOCK_64X64 || mbmi->skip == 0) && read_delta_lf_flag) {
    abs =
        aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1, ACCT_STR);
    smallval = (abs < DELTA_LF_SMALL);
    if (counts) {
      for (i = 0; i < abs; ++i) counts->delta_lf[i][1]++;
      if (smallval) counts->delta_lf[abs][0]++;
    }
    if (!smallval) {
      rem_bits = aom_read_literal(r, 3, ACCT_STR);
      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
142
143
#endif

144
static PREDICTION_MODE read_intra_mode_y(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
145
                                         aom_reader *r, int size_group) {
Jingning Han's avatar
Jingning Han committed
146
  const PREDICTION_MODE y_mode =
147
      read_intra_mode(r, ec_ctx->y_mode_cdf[size_group]);
148
#if !CONFIG_EC_ADAPT || CONFIG_ENTROPY_STATS
Jingning Han's avatar
Jingning Han committed
149
  FRAME_COUNTS *counts = xd->counts;
150
  if (counts) ++counts->y_mode[size_group][y_mode];
151
152
153
154
#else
  /* TODO(negge): Can we remove this parameter? */
  (void)xd;
#endif  // !CONFIG_EC_ADAPT || CONFIG_ENTROPY_STATS
Jingning Han's avatar
Jingning Han committed
155
156
157
  return y_mode;
}

158
159
static PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx,
                                          MACROBLOCKD *xd, aom_reader *r,
Jingning Han's avatar
Jingning Han committed
160
                                          PREDICTION_MODE y_mode) {
161
  const PREDICTION_MODE uv_mode =
162
      read_intra_mode(r, ec_ctx->uv_mode_cdf[y_mode]);
163
#if !CONFIG_EC_ADAPT || CONFIG_ENTROPY_STATS
Jingning Han's avatar
Jingning Han committed
164
  FRAME_COUNTS *counts = xd->counts;
165
  if (counts) ++counts->uv_mode[y_mode][uv_mode];
166
167
168
169
#else
  /* TODO(negge): Can we remove this parameter? */
  (void)xd;
#endif  // !CONFIG_EC_ADAPT || CONFIG_ENTROPY_STATS
Jingning Han's avatar
Jingning Han committed
170
171
172
  return uv_mode;
}

Luc Trudeau's avatar
Luc Trudeau committed
173
#if CONFIG_CFL
174
static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r,
175
                           CFL_SIGN_TYPE signs_out[CFL_PRED_PLANES]) {
176
177
178
179
180
181
182
183
184
185
186
187
188
  const int ind =
      aom_read_symbol(r, ec_ctx->cfl_alpha_cdf, CFL_ALPHABET_SIZE, "cfl:alpha");
  // Signs are only coded for nonzero values
  // sign == 0 implies negative alpha
  // sign == 1 implies positive alpha
  signs_out[CFL_PRED_U] = cfl_alpha_codes[ind][CFL_PRED_U]
                              ? aom_read_bit(r, "cfl:sign")
                              : CFL_SIGN_POS;
  signs_out[CFL_PRED_V] = cfl_alpha_codes[ind][CFL_PRED_V]
                              ? aom_read_bit(r, "cfl:sign")
                              : CFL_SIGN_POS;

  return ind;
Luc Trudeau's avatar
Luc Trudeau committed
189
190
191
}
#endif

192
#if CONFIG_EXT_INTER && CONFIG_INTERINTRA
Yaowu Xu's avatar
Yaowu Xu committed
193
194
static INTERINTRA_MODE read_interintra_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
                                            aom_reader *r, int size_group) {
195
196
197
198
199
200
#if CONFIG_EC_ADAPT
  (void)cm;
  const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_symbol(
      r, xd->tile_ctx->interintra_mode_cdf[size_group], INTERINTRA_MODES,
      ACCT_STR);
#else
Yaowu Xu's avatar
Yaowu Xu committed
201
  const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_tree(
Michael Bebenita's avatar
Michael Bebenita committed
202
203
      r, av1_interintra_mode_tree, cm->fc->interintra_mode_prob[size_group],
      ACCT_STR);
204
#endif
205
  FRAME_COUNTS *counts = xd->counts;
206
  if (counts) ++counts->interintra_mode[size_group][ii_mode];
207
208
  return ii_mode;
}
209
#endif  // CONFIG_EXT_INTER && CONFIG_INTERINTRA
210

211
static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
212
                                       aom_reader *r, int16_t ctx) {
213
  FRAME_COUNTS *counts = xd->counts;
214
  int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
215
216
217
218
219
220
  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
221

222
  if (is_newmv) {
223
    if (counts) ++counts->newmv_mode[mode_ctx][0];
224
    return NEWMV;
225
  }
226
  if (counts) ++counts->newmv_mode[mode_ctx][1];
227

228
  if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return ZEROMV;
229

230
  mode_ctx = (ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
231

232
233
234
235
236
237
238
#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) {
239
    if (counts) ++counts->zeromv_mode[mode_ctx][0];
240
241
    return ZEROMV;
  }
242
  if (counts) ++counts->zeromv_mode[mode_ctx][1];
243

244
  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
245

246
247
248
  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;
249

250
251
252
253
254
#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
255

256
  if (is_refmv) {
257
    if (counts) ++counts->refmv_mode[mode_ctx][0];
258

259
260
    return NEARESTMV;
  } else {
261
    if (counts) ++counts->refmv_mode[mode_ctx][1];
262
263
264
265
266
    return NEARMV;
  }

  // Invalid prediction mode.
  assert(0);
Jingning Han's avatar
Jingning Han committed
267
268
}

269
static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
270
271
                         MB_MODE_INFO *mbmi, aom_reader *r) {
  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
272
273
  mbmi->ref_mv_idx = 0;

274
#if CONFIG_EXT_INTER
275
276
277
278
#if CONFIG_COMPOUND_SINGLEREF
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV ||
      mbmi->mode == SR_NEW_NEWMV) {
#else   // !CONFIG_COMPOUND_SINGLEREF
279
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
280
281
#endif  // CONFIG_COMPOUND_SINGLEREF
#else   // !CONFIG_EXT_INTER
282
  if (mbmi->mode == NEWMV) {
283
#endif  // CONFIG_EXT_INTER
284
285
286
    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
287
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
288
289
290
291
292
293
294
295
#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;
296
297
298
299
      }
    }
  }

David Barker's avatar
David Barker committed
300
  if (have_nearmv_in_inter_mode(mbmi->mode)) {
301
302
303
304
305
306
    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
307
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
308
309
310
311
312
313
314
315
#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;
316
317
318
319
320
      }
    }
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
321
322
#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
323
324
                                    MODE_INFO *mi, aom_reader *r) {
  MB_MODE_INFO *mbmi = &mi->mbmi;
325
326
327
328
329
330
331
332
#if CONFIG_NCOBMC_ADAPT_WEIGHT
  const MOTION_MODE last_motion_mode_allowed =
      motion_mode_allowed_wrapper(0,
#if CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
                                  0, xd->global_motion,
#endif  // CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
                                  mi);
#else
333
334
335
336
337
  const MOTION_MODE last_motion_mode_allowed = motion_mode_allowed(
#if CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
      0, xd->global_motion,
#endif  // CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
      mi);
338
#endif  // CONFIG_NCOBMC_ADAPT_WEIGHT
Yue Chen's avatar
Yue Chen committed
339
340
  int motion_mode;
  FRAME_COUNTS *counts = xd->counts;
Yaowu Xu's avatar
Yaowu Xu committed
341

Yue Chen's avatar
Yue Chen committed
342
343
344
345
346
347
348
349
  if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
  if (last_motion_mode_allowed == OBMC_CAUSAL) {
    motion_mode = aom_read(r, cm->fc->obmc_prob[mbmi->sb_type], ACCT_STR);
    if (counts) ++counts->obmc[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
  } else {
#endif  // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yaowu Xu's avatar
Yaowu Xu committed
350
351
352
353
354
    motion_mode =
        aom_read_tree(r, av1_motion_mode_tree,
                      cm->fc->motion_mode_prob[mbmi->sb_type], ACCT_STR);
    if (counts) ++counts->motion_mode[mbmi->sb_type][motion_mode];
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
Yue Chen's avatar
Yue Chen committed
355
#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yaowu Xu's avatar
Yaowu Xu committed
356
  }
Yue Chen's avatar
Yue Chen committed
357
#endif  // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yaowu Xu's avatar
Yaowu Xu committed
358
}
359
360
361
362
363
364

#if CONFIG_NCOBMC_ADAPT_WEIGHT
static void read_ncobmc_mode(AV1_COMMON *cm, MACROBLOCKD *xd, MODE_INFO *mi,
                             NCOBMC_MODE ncobmc_mode[2], aom_reader *r) {
  MB_MODE_INFO *mbmi = &mi->mbmi;
  FRAME_COUNTS *counts = xd->counts;
365
366
367
368
369
370
  MOTION_MODE last_motion_mode_allowed =
      motion_mode_allowed_wrapper(0,
#if CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
                                  0, cm->global_motion,
#endif  // CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
                                  mi);
371
  ADAPT_OVERLAP_BLOCK ao_block = adapt_overlap_block_lookup[mbmi->sb_type];
372
  if (last_motion_mode_allowed < NCOBMC_ADAPT_WEIGHT) return;
373
374
375
376
377
378
379
380
381
382
383
384

  ncobmc_mode[0] = aom_read_tree(r, av1_ncobmc_mode_tree,
                                 cm->fc->ncobmc_mode_prob[ao_block], ACCT_STR);
  if (counts) ++counts->ncobmc_mode[ao_block][ncobmc_mode[0]];

  if (mi_size_wide[mbmi->sb_type] != mi_size_high[mbmi->sb_type]) {
    ncobmc_mode[1] = aom_read_tree(
        r, av1_ncobmc_mode_tree, cm->fc->ncobmc_mode_prob[ao_block], ACCT_STR);
    if (counts) ++counts->ncobmc_mode[ao_block][ncobmc_mode[1]];
  }
}
#endif
Yaowu Xu's avatar
Yaowu Xu committed
385
386
#endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION

387
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
388
389
static PREDICTION_MODE read_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
                                                aom_reader *r, int16_t ctx) {
390
391
392
393
394
395
#if CONFIG_EC_ADAPT
  (void)cm;
  const int mode =
      aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
                      INTER_COMPOUND_MODES, ACCT_STR);
#else
Michael Bebenita's avatar
Michael Bebenita committed
396
397
398
  const int mode =
      aom_read_tree(r, av1_inter_compound_mode_tree,
                    cm->fc->inter_compound_mode_probs[ctx], ACCT_STR);
399
#endif
400
401
  FRAME_COUNTS *counts = xd->counts;

402
  if (counts) ++counts->inter_compound_mode[ctx][mode];
403
404
405
406

  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
  return NEAREST_NEARESTMV + mode;
}
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423

#if CONFIG_COMPOUND_SINGLEREF
static PREDICTION_MODE read_inter_singleref_comp_mode(AV1_COMMON *cm,
                                                      MACROBLOCKD *xd,
                                                      aom_reader *r,
                                                      int16_t ctx) {
  const int mode =
      aom_read_tree(r, av1_inter_singleref_comp_mode_tree,
                    cm->fc->inter_singleref_comp_mode_probs[ctx], ACCT_STR);
  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
424
425
#endif  // CONFIG_EXT_INTER

426
static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) {
Michael Bebenita's avatar
Michael Bebenita committed
427
  return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
Jingning Han's avatar
Jingning Han committed
428
429
}

430
#if CONFIG_VAR_TX
Yaowu Xu's avatar
Yaowu Xu committed
431
static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
432
                               MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
433
434
                               TX_SIZE tx_size, int depth, int blk_row,
                               int blk_col, aom_reader *r) {
435
  int is_split = 0;
436
437
  const int tx_row = blk_row >> 1;
  const int tx_col = blk_col >> 1;
438
439
  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);
440
441
  int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
                                   xd->left_txfm_context + blk_row,
442
                                   mbmi->sb_type, tx_size);
clang-format's avatar
clang-format committed
443
  TX_SIZE(*const inter_tx_size)
444
445
446
  [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;
447

Jingning Han's avatar
Jingning Han committed
448
  if (depth == MAX_VARTX_DEPTH) {
449
450
    int idx, idy;
    inter_tx_size[0][0] = tx_size;
451
452
    for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
      for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
453
454
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
455
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
456
    if (counts) ++counts->txfm_partition[ctx][0];
457
458
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
459
460
461
    return;
  }

Michael Bebenita's avatar
Michael Bebenita committed
462
  is_split = aom_read(r, cm->fc->txfm_partition_prob[ctx], ACCT_STR);
463
464

  if (is_split) {
465
466
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
    const int bsl = tx_size_wide_unit[sub_txs];
467
    int i;
468

469
    if (counts) ++counts->txfm_partition[ctx][1];
470

471
    if (tx_size == TX_8X8) {
472
      int idx, idy;
473
      inter_tx_size[0][0] = sub_txs;
474
475
      for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
        for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
476
          inter_tx_size[idy][idx] = inter_tx_size[0][0];
477
      mbmi->tx_size = sub_txs;
478
      mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
479
480
      txfm_partition_update(xd->above_txfm_context + blk_col,
                            xd->left_txfm_context + blk_row, sub_txs, tx_size);
481
482
483
484
485
      return;
    }

    assert(bsl > 0);
    for (i = 0; i < 4; ++i) {
486
487
488
      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,
489
                         offsetc, r);
490
491
    }
  } else {
492
    int idx, idy;
493
    inter_tx_size[0][0] = tx_size;
494
495
    for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
      for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
496
497
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
498
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
499
    if (counts) ++counts->txfm_partition[ctx][0];
500
501
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
502
503
504
505
  }
}
#endif

Yaowu Xu's avatar
Yaowu Xu committed
506
507
static TX_SIZE read_selected_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd,
                                     int tx_size_cat, aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
508
509
  FRAME_COUNTS *counts = xd->counts;
  const int ctx = get_tx_size_context(xd);
510
511
512
513
514
515
516
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
#else
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif

517
518
  const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
                                    tx_size_cat + 2, ACCT_STR);
519
520
521
522
  const TX_SIZE tx_size = depth_to_tx_size(depth);
#if CONFIG_RECT_TX
  assert(!is_rect_tx(tx_size));
#endif  // CONFIG_RECT_TX
523
  if (counts) ++counts->tx_size[tx_size_cat][ctx][depth];
524
  return tx_size;
Jingning Han's avatar
Jingning Han committed
525
526
}

527
528
529
530
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;
531
  if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4;
532
#if CONFIG_CB4X4 && (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
533
  if (bsize > BLOCK_4X4) {
534
#else
535
  if (bsize >= BLOCK_8X8) {
536
537
538
539
#endif  // CONFIG_CB4X4 && CONFIG_VAR_TX
    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];
540
      const TX_SIZE coded_tx_size =
541
          read_selected_tx_size(cm, xd, tx_size_cat, r);
542
#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
543
544
      if (coded_tx_size > max_txsize_lookup[bsize]) {
        assert(coded_tx_size == max_txsize_lookup[bsize] + 1);
545
#if CONFIG_EXT_TX && CONFIG_RECT_TX_EXT
546
547
548
549
550
551
552
553
        if (is_quarter_tx_allowed(xd, &xd->mi[0]->mbmi, is_inter)) {
          int 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];
          return quarter_tx ? quarter_txsize_lookup[bsize]
                            : max_txsize_rect_lookup[bsize];
        }
554
#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX_EXT
555

556
557
        return max_txsize_rect_lookup[bsize];
      }
558
559
#else
      assert(coded_tx_size <= max_txsize_lookup[bsize]);
560
#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
561
      return coded_tx_size;
562
    } else {
563
      return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
564
565
    }
  } else {
566
#if CONFIG_EXT_TX && CONFIG_RECT_TX
Debargha Mukherjee's avatar
Debargha Mukherjee committed
567
    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
568
569
570
    return max_txsize_rect_lookup[bsize];
#else
    return TX_4X4;
571
#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
572
  }
Jingning Han's avatar
Jingning Han committed
573
574
}

Yaowu Xu's avatar
Yaowu Xu committed
575
static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
Jingning Han's avatar
Jingning Han committed
576
577
578
579
580
                              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++)
581
      segment_id =
Yaowu Xu's avatar
Yaowu Xu committed
582
          AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
Jingning Han's avatar
Jingning Han committed
583
584
585
586
587

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

Yaowu Xu's avatar
Yaowu Xu committed
588
static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
589
                           int segment_id) {
Jingning Han's avatar
Jingning Han committed
590
591
592
593
594
595
596
597
598
  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
599
static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
600
                                 int mi_offset, int x_mis, int y_mis,
Yaowu Xu's avatar
Yaowu Xu committed
601
                                 aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
602
  struct segmentation *const seg = &cm->seg;
603
604
  FRAME_COUNTS *counts = xd->counts;
  struct segmentation_probs *const segp = &cm->fc->seg;
Jingning Han's avatar
Jingning Han committed
605
606
  int segment_id;

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

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

611
  segment_id = read_segment_id(r, segp);
612
  if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
613
614
615
616
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
617
static void copy_segment_id(const AV1_COMMON *cm,
618
619
620
                            const uint8_t *last_segment_ids,
                            uint8_t *current_segment_ids, int mi_offset,
                            int x_mis, int y_mis) {
621
622
623
624
  int x, y;

  for (y = 0; y < y_mis; y++)
    for (x = 0; x < x_mis; x++)
625
626
627
      current_segment_ids[mi_offset + y * cm->mi_cols + x] =
          last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
                           : 0;
628
629
}

Yaowu Xu's avatar
Yaowu Xu committed
630
631
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
632
  struct segmentation *const seg = &cm->seg;
633
634
  FRAME_COUNTS *counts = xd->counts;
  struct segmentation_probs *const segp = &cm->fc->seg;
Jingning Han's avatar
Jingning Han committed
635
636
637
  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;
638
639
  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
640
641

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

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

647
648
649
650
  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
651
652
653
654
655
656
657
658

  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
659
660
    const int ctx = av1_get_pred_context_seg_id(xd);
    const aom_prob pred_prob = segp->pred_probs[ctx];
Michael Bebenita's avatar
Michael Bebenita committed
661
    mbmi->seg_id_predicted = aom_read(r, pred_prob, ACCT_STR);
662
    if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted];
663
664
665
666
    if (mbmi->seg_id_predicted) {
      segment_id = predicted_segment_id;
    } else {
      segment_id = read_segment_id(r, segp);
667
      if (counts) ++counts->seg.tree_mispred[segment_id];
668
    }
Jingning Han's avatar
Jingning Han committed
669
  } else {
670
    segment_id = read_segment_id(r, segp);
671
    if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
672
673
674
675
676
  }
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
677
678
static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
                     aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
679
680
681
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
    return 1;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
682
    const int ctx = av1_get_skip_context(xd);
683
684
685
686
#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
687
    const int skip = aom_read(r, cm->fc->skip_probs[ctx], ACCT_STR);
688
#endif
Jingning Han's avatar
Jingning Han committed
689
    FRAME_COUNTS *counts = xd->counts;
690
    if (counts) ++counts->skip[ctx][skip];
Jingning Han's avatar
Jingning Han committed
691
692
693
694
    return skip;
  }
}

695
#if CONFIG_PALETTE
696
697
#if CONFIG_PALETTE_DELTA_ENCODING
static int uint16_compare(const void *a, const void *b) {
698
699
  const uint16_t va = *(const uint16_t *)a;
  const uint16_t vb = *(const uint16_t *)b;
700
701
702
703
704
705
706
707
708
709
710
711
712
713
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
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
  return va - vb;
}

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];
  const MODE_INFO *const above_mi = xd->above_mi;
  const MODE_INFO *const left_mi = xd->left_mi;
  const int n_cache = av1_get_palette_cache(above_mi, left_mi, 0, color_cache);
  const int n = pmi->palette_size[0];
  int idx = 0;
  for (int i = 0; i < n_cache && idx < n; ++i)
    if (aom_read_bit(r, ACCT_STR)) pmi->palette_colors[idx++] = color_cache[i];
  if (idx < n) {
    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) {
        const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
        pmi->palette_colors[idx] = pmi->palette_colors[idx - 1] + delta;
        range -= delta;
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
  }
  qsort(pmi->palette_colors, n, sizeof(pmi->palette_colors[0]), uint16_compare);
}

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];
  const MODE_INFO *const above_mi = xd->above_mi;
  const MODE_INFO *const left_mi = xd->left_mi;
  const int n_cache = av1_get_palette_cache(above_mi, left_mi, 1, color_cache);
  int idx = PALETTE_MAX_SIZE;
  for (int i = 0; i < n_cache && idx < PALETTE_MAX_SIZE + n; ++i)
    if (aom_read_bit(r, ACCT_STR)) pmi->palette_colors[idx++] = color_cache[i];
  if (idx < PALETTE_MAX_SIZE + n) {
    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) {
        const int delta = aom_read_literal(r, bits, ACCT_STR);
        pmi->palette_colors[idx] = pmi->palette_colors[idx - 1] + delta;
        range -= delta;
        bits = AOMMIN(bits, av1_ceil_log2(range));
      }
    }
  }
  qsort(pmi->palette_colors + PALETTE_MAX_SIZE, n,
        sizeof(pmi->palette_colors[0]), uint16_compare);

  // 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
783
784
static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                   aom_reader *r) {
hui su's avatar
hui su committed
785
786
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
787
  const MODE_INFO *const above_mi = xd->above_mi;
788
  const MODE_INFO *const left_mi = xd->left_mi;
hui su's avatar
hui su committed
789
  const BLOCK_SIZE bsize = mbmi->sb_type;
790
  int n;
791
792
793
  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;

  if (mbmi->mode == DC_PRED) {
794
    int palette_y_mode_ctx = 0;
795
    if (above_mi)
796
797
      palette_y_mode_ctx +=
          (above_mi->mbmi.palette_mode_info.palette_size[0] > 0);
798
    if (left_mi)
799
800
801
802
803
      palette_y_mode_ctx +=
          (left_mi->mbmi.palette_mode_info.palette_size[0] > 0);
    if (aom_read(r, av1_default_palette_y_mode_prob[bsize - BLOCK_8X8]
                                                   [palette_y_mode_ctx],
                 ACCT_STR)) {
804
      pmi->palette_size[0] =
Yaowu Xu's avatar
Yaowu Xu committed
805
          aom_read_tree(r, av1_palette_size_tree,
Michael Bebenita's avatar
Michael Bebenita committed
806
807
                        av1_default_palette_y_size_prob[bsize - BLOCK_8X8],
                        ACCT_STR) +
808
          2;
809
      n = pmi->palette_size[0];
hui su's avatar
hui su committed
810
#if CONFIG_PALETTE_DELTA_ENCODING
811
      read_palette_colors_y(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
812
#else
813
      int i;
814
      for (i = 0; i < n; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
815
        pmi->palette_colors[i] = aom_read_literal(r, cm->bit_depth, ACCT_STR);
hui su's avatar
hui su committed
816
#endif  // CONFIG_PALETTE_DELTA_ENCODING
817
818
819
820
      xd->plane[0].color_index_map[0] = read_uniform(r, n);
      assert(xd->plane[0].color_index_map[0] < n);
    }
  }
hui su's avatar
hui su committed
821

822
  if (mbmi->uv_mode == DC_PRED) {
823
824
    const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
    if (aom_read(r, av1_default_palette_uv_mode_prob[palette_uv_mode_ctx],
Michael Bebenita's avatar
Michael Bebenita committed
825
                 ACCT_STR)) {
826
      pmi->palette_size[1] =
Yaowu Xu's avatar
Yaowu Xu committed
827
          aom_read_tree(r, av1_palette_size_tree,
Michael Bebenita's avatar
Michael Bebenita committed
828
829
                        av1_default_palette_uv_size_prob[bsize - BLOCK_8X8],
                        ACCT_STR) +
830
          2;
831
      n = pmi->palette_size[1];
hui su's avatar
hui su committed
832
#if CONFIG_PALETTE_DELTA_ENCODING
833
      read_palette_colors_uv(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
834
#else
835
      int i;
836
837
      for (i = 0; i < n; ++i) {
        pmi->palette_colors[PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
838
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
839
        pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
840
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
841
      }
hui su's avatar
hui su committed
842
#endif  // CONFIG_PALETTE_DELTA_ENCODING
843
844
845
      xd->plane[1].color_index_map[0] = read_uniform(r, n);
      assert(xd->plane[1].color_index_map[0] < n);
    }
hui su's avatar
hui su committed
846
847
  }
}
848
#endif  // CONFIG_PALETTE
hui su's avatar
hui su committed
849

850
851
#if CONFIG_FILTER_INTRA
static void read_filter_intra_mode_info(AV1_COMMON *const cm,
852
853
                                        MACROBLOCKD *const xd, int mi_row,
                                        int mi_col, aom_reader *r) {
hui su's avatar
hui su committed
854
855
856
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
  FRAME_COUNTS *counts = xd->counts;
857
858
  FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
      &mbmi->filter_intra_mode_info;
hui su's avatar
hui su committed
859

860
861
862
863
864
  if (mbmi->mode == DC_PRED
#if CONFIG_PALETTE
      && mbmi->palette_mode_info.palette_size[0] == 0
#endif  // CONFIG_PALETTE
      ) {
865
866
867
868
    filter_intra_mode_info->use_filter_intra_mode[0] =
        aom_read(r, cm->fc->filter_intra_probs[0], ACCT_STR);
    if (filter_intra_mode_info->use_filter_intra_mode[0]) {
      filter_intra_mode_info->filter_intra_mode[0] =
hui su's avatar
hui su committed
869
          read_uniform(r, FILTER_INTRA_MODES);
hui su's avatar
hui su committed
870
    }
871
    if (counts) {
clang-format's avatar
clang-format committed
872
873
      ++counts
            ->filter_intra[0][filter_intra_mode_info->use_filter_intra_mode[0]];
874
    }
hui su's avatar
hui su committed
875
  }
876
877
878
879
880
881

#if CONFIG_CB4X4
  if (!is_chroma_reference(mi_row, mi_col, mbmi->sb_type,
                           xd->plane[1].subsampling_x,
                           xd->plane[1].subsampling_y))
    return;
882
883
884
885
#else
  (void)mi_row;
  (void)mi_col;
#endif  // CONFIG_CB4X4
886

887
888
889
890
891
  if (mbmi->uv_mode == DC_PRED
#if CONFIG_PALETTE
      && mbmi->palette_mode_info.palette_size[1] == 0
#endif  // CONFIG_PALETTE
      ) {
892
893
894
895
    filter_intra_mode_info->use_filter_intra_mode[1] =
        aom_read(r, cm->fc->filter_intra_probs[1], ACCT_STR);
    if (filter_intra_mode_info->use_filter_intra_mode[1]) {
      filter_intra_mode_info->filter_intra_mode[1] =
hui su's avatar
hui su committed
896
          read_uniform(r, FILTER_INTRA_MODES);
hui su's avatar
hui su committed
897
    }
898
    if (counts) {
clang-format's avatar
clang-format committed
899
900
      ++counts
            ->filter_intra[1][filter_intra_mode_info->use_filter_intra_mode[1]];
901
    }
hui su's avatar
hui su committed
902
903
  }
}
904
#endif  // CONFIG_FILTER_INTRA
905

906
#if CONFIG_EXT_INTRA
Yaowu Xu's avatar
Yaowu Xu committed
907
908
static void read_intra_angle_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                  aom_reader *r) {
909
910
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
  const BLOCK_SIZE bsize = mbmi->sb_type;
hui su's avatar
hui su committed
911
#if CONFIG_INTRA_INTERP
912
913
914
915
916
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
#else
  FRAME_CONTEXT *const ec_ctx = cm->fc;
#endif  // CONFIG_EC_ADAPT
Yaowu Xu's avatar
Yaowu Xu committed
917
  const int ctx = av1_get_pred_context_intra_interp(xd);
918
  int p_angle;
hui su's avatar
hui su committed
919
#endif  // CONFIG_INTRA_INTERP
920

hui su's avatar
hui su committed
921
  (void)cm;
922
923
924
925
926

  mbmi->angle_delta[0] = 0;
  mbmi->angle_delta[1] = 0;

  if (!av1_use_angle_delta(bsize)) return;
927

hui su's avatar
hui su committed
928
  if (av1_is_directional_mode(mbmi->mode, bsize)) {
929
    mbmi->angle_delta[0] =
hui su's avatar
hui su committed
930
        read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
hui su's avatar
hui su committed
931
#if CONFIG_INTRA_INTERP
hui su's avatar
hui su committed
932
    p_angle = mode_to_angle_map[mbmi->mode] + mbmi->angle_delta[0] * ANGLE_STEP;
Yaowu Xu's avatar
Yaowu Xu committed
933
    if (av1_is_intra_filter_switchable(p_angle)) {
934
      FRAME_COUNTS *counts = xd->counts;
935
936
      mbmi->intra_filter = aom_read_symbol(r, ec_ctx->intra_filter_cdf[ctx],
                                           INTRA_FILTERS, ACCT_STR);
937
      if (counts) ++counts->intra_filter[ctx][mbmi->intra_filter];
938
939
940
    } else {
      mbmi->intra_filter = INTRA_FILTER_LINEAR;
    }
hui su's avatar
hui su committed
941
#endif  // CONFIG_INTRA_INTERP
942
943
  }

hui su's avatar
hui su committed
944
  if (av1_is_directional_mode(mbmi->uv_mode, bsize)) {
945
    mbmi->angle_delta[1] =
hui su's avatar
hui su committed
946
        read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
947
948
  }
}
hui su's avatar
hui su committed
949
950
#endif  // CONFIG_EXT_INTRA

951
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
952
#if CONFIG_SUPERTX
953
                      int supertx_enabled,
Jingning Han's avatar
Jingning Han committed
954
#endif
Angie Chiang's avatar
Angie Chiang committed
955
#if CONFIG_TXK_SEL
956
                      int block, int plane, TX_SIZE tx_size,
957
958
959
#endif
                      aom_reader *r) {
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
Jingning Han's avatar
Jingning Han committed
960
  const int inter_block = is_inter_block(mbmi);
961
#if !CONFIG_TXK_SEL