decodemv.c 84.7 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
#if CONFIG_EXT_INTRA || CONFIG_FILTER_INTRA || CONFIG_PALETTE
Yaowu Xu's avatar
Yaowu Xu committed
36
static INLINE int read_uniform(aom_reader *r, int n) {
37
38
39
  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
40
41
42
43
  assert(l != 0);
  if (v < m)
    return v;
  else
Michael Bebenita's avatar
Michael Bebenita committed
44
    return (v << 1) - m + aom_read_literal(r, 1, ACCT_STR);
hui su's avatar
hui su committed
45
}
46
#endif  // CONFIG_EXT_INTRA || CONFIG_FILTER_INTRA || CONFIG_PALETTE
hui su's avatar
hui su committed
47

48
#if CONFIG_EC_MULTISYMBOL
49
static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
50
51
52
  return (PREDICTION_MODE)
      av1_intra_mode_inv[aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR)];
}
53
#else
Yaowu Xu's avatar
Yaowu Xu committed
54
static PREDICTION_MODE read_intra_mode(aom_reader *r, const aom_prob *p) {
Michael Bebenita's avatar
Michael Bebenita committed
55
  return (PREDICTION_MODE)aom_read_tree(r, av1_intra_mode_tree, p, ACCT_STR);
Jingning Han's avatar
Jingning Han committed
56
}
57
#endif
Jingning Han's avatar
Jingning Han committed
58

59
60
61
62
63
64
65
66
67
#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
68
69
70
71
72
73
74
75
  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
76

77
  if ((bsize != BLOCK_LARGEST || mbmi->skip == 0) && read_delta_q_flag) {
Thomas Davies's avatar
Thomas Davies committed
78
79
#if !CONFIG_EC_MULTISYMBOL
    int bit = 1;
80
81
    abs = 0;
    while (abs < DELTA_Q_SMALL && bit) {
Thomas Davies's avatar
Thomas Davies committed
82
      bit = aom_read(r, ec_ctx->delta_q_prob[abs], ACCT_STR);
83
84
      abs += bit;
    }
Thomas Davies's avatar
Thomas Davies committed
85
86
87
88
89
90
91
92
93
94
#else
    abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
#endif
    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) {
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
      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
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
#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) {
#if !CONFIG_EC_MULTISYMBOL
    int bit = 1;
    abs = 0;
    while (abs < DELTA_LF_SMALL && bit) {
      bit = aom_read(r, ec_ctx->delta_lf_prob[abs], ACCT_STR);
      abs += bit;
    }
#else
    abs =
        aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1, ACCT_STR);
#endif
    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
163
164
#endif

Yaowu Xu's avatar
Yaowu Xu committed
165
166
static PREDICTION_MODE read_intra_mode_y(AV1_COMMON *cm, MACROBLOCKD *xd,
                                         aom_reader *r, int size_group) {
167
168
169
170
171
172
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#elif CONFIG_EC_MULTISYMBOL
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif

Jingning Han's avatar
Jingning Han committed
173
  const PREDICTION_MODE y_mode =
174
#if CONFIG_EC_MULTISYMBOL
175
      read_intra_mode(r, ec_ctx->y_mode_cdf[size_group]);
176
#else
Jingning Han's avatar
Jingning Han committed
177
      read_intra_mode(r, cm->fc->y_mode_prob[size_group]);
178
#endif
Jingning Han's avatar
Jingning Han committed
179
  FRAME_COUNTS *counts = xd->counts;
180
181
182
#if CONFIG_EC_ADAPT
  (void)cm;
#endif
183
  if (counts) ++counts->y_mode[size_group][y_mode];
Jingning Han's avatar
Jingning Han committed
184
185
186
  return y_mode;
}

Yaowu Xu's avatar
Yaowu Xu committed
187
188
static PREDICTION_MODE read_intra_mode_uv(AV1_COMMON *cm, MACROBLOCKD *xd,
                                          aom_reader *r,
Jingning Han's avatar
Jingning Han committed
189
                                          PREDICTION_MODE y_mode) {
190
191
192
193
194
195
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#elif CONFIG_EC_MULTISYMBOL
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif

196
  const PREDICTION_MODE uv_mode =
197
#if CONFIG_EC_MULTISYMBOL
198
      read_intra_mode(r, ec_ctx->uv_mode_cdf[y_mode]);
199
#else
200
      read_intra_mode(r, cm->fc->uv_mode_prob[y_mode]);
201
#endif
Jingning Han's avatar
Jingning Han committed
202
  FRAME_COUNTS *counts = xd->counts;
203
204
205
#if CONFIG_EC_ADAPT
  (void)cm;
#endif
206
  if (counts) ++counts->uv_mode[y_mode][uv_mode];
Jingning Han's avatar
Jingning Han committed
207
208
209
  return uv_mode;
}

Luc Trudeau's avatar
Luc Trudeau committed
210
#if CONFIG_CFL
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r, int skip,
                           CFL_SIGN_TYPE signs_out[CFL_PRED_PLANES]) {
  if (skip) {
    signs_out[CFL_PRED_U] = CFL_SIGN_POS;
    signs_out[CFL_PRED_V] = CFL_SIGN_POS;
    return 0;
  } else {
    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] != 0.0)
                                ? aom_read_bit(r, "cfl:sign")
                                : CFL_SIGN_POS;
    signs_out[CFL_PRED_V] = (cfl_alpha_codes[ind][CFL_PRED_V] != 0.0)
                                ? aom_read_bit(r, "cfl:sign")
                                : CFL_SIGN_POS;

    return ind;
  }
Luc Trudeau's avatar
Luc Trudeau committed
232
233
234
}
#endif

235
#if CONFIG_EXT_INTER && CONFIG_INTERINTRA
Yaowu Xu's avatar
Yaowu Xu committed
236
237
238
static INTERINTRA_MODE read_interintra_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
                                            aom_reader *r, int size_group) {
  const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_tree(
Michael Bebenita's avatar
Michael Bebenita committed
239
240
      r, av1_interintra_mode_tree, cm->fc->interintra_mode_prob[size_group],
      ACCT_STR);
241
  FRAME_COUNTS *counts = xd->counts;
242
  if (counts) ++counts->interintra_mode[size_group][ii_mode];
243
244
  return ii_mode;
}
245
#endif  // CONFIG_EXT_INTER && CONFIG_INTERINTRA
246

247
static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
248
                                       aom_reader *r, int16_t ctx) {
249
  FRAME_COUNTS *counts = xd->counts;
250
  int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
251
  aom_prob mode_prob = ec_ctx->newmv_prob[mode_ctx];
252

Michael Bebenita's avatar
Michael Bebenita committed
253
  if (aom_read(r, mode_prob, ACCT_STR) == 0) {
254
    if (counts) ++counts->newmv_mode[mode_ctx][0];
255
    return NEWMV;
256
  }
257
  if (counts) ++counts->newmv_mode[mode_ctx][1];
258

259
  if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return ZEROMV;
260

261
  mode_ctx = (ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
262

263
  mode_prob = ec_ctx->zeromv_prob[mode_ctx];
Michael Bebenita's avatar
Michael Bebenita committed
264
  if (aom_read(r, mode_prob, ACCT_STR) == 0) {
265
    if (counts) ++counts->zeromv_mode[mode_ctx][0];
266
267
    return ZEROMV;
  }
268
  if (counts) ++counts->zeromv_mode[mode_ctx][1];
269

270
  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
271

272
273
274
  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;
275

276
  mode_prob = ec_ctx->refmv_prob[mode_ctx];
277

Michael Bebenita's avatar
Michael Bebenita committed
278
  if (aom_read(r, mode_prob, ACCT_STR) == 0) {
279
    if (counts) ++counts->refmv_mode[mode_ctx][0];
280

281
282
    return NEARESTMV;
  } else {
283
    if (counts) ++counts->refmv_mode[mode_ctx][1];
284
285
286
287
288
    return NEARMV;
  }

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

Yaowu Xu's avatar
Yaowu Xu committed
291
292
293
static void read_drl_idx(const AV1_COMMON *cm, MACROBLOCKD *xd,
                         MB_MODE_INFO *mbmi, aom_reader *r) {
  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
294
295
  mbmi->ref_mv_idx = 0;

296
297
298
#if CONFIG_EXT_INTER
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
#else
299
  if (mbmi->mode == NEWMV) {
300
#endif
301
302
303
    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
304
305
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
        aom_prob drl_prob = cm->fc->drl_prob[drl_ctx];
Michael Bebenita's avatar
Michael Bebenita committed
306
        if (!aom_read(r, drl_prob, ACCT_STR)) {
307
          mbmi->ref_mv_idx = idx;
308
          if (xd->counts) ++xd->counts->drl_mode[drl_ctx][0];
309
310
311
          return;
        }
        mbmi->ref_mv_idx = idx + 1;
312
        if (xd->counts) ++xd->counts->drl_mode[drl_ctx][1];
313
314
315
316
      }
    }
  }

David Barker's avatar
David Barker committed
317
  if (have_nearmv_in_inter_mode(mbmi->mode)) {
318
319
320
321
322
323
    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
324
325
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
        aom_prob drl_prob = cm->fc->drl_prob[drl_ctx];
Michael Bebenita's avatar
Michael Bebenita committed
326
        if (!aom_read(r, drl_prob, ACCT_STR)) {
327
          mbmi->ref_mv_idx = idx - 1;
328
          if (xd->counts) ++xd->counts->drl_mode[drl_ctx][0];
329
330
          return;
        }
331
        mbmi->ref_mv_idx = idx;
332
        if (xd->counts) ++xd->counts->drl_mode[drl_ctx][1];
333
334
335
336
337
      }
    }
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
338
339
#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
340
341
342
343
344
345
346
                                    MODE_INFO *mi, aom_reader *r) {
  MB_MODE_INFO *mbmi = &mi->mbmi;
  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);
Yue Chen's avatar
Yue Chen committed
347
348
  int motion_mode;
  FRAME_COUNTS *counts = xd->counts;
Yaowu Xu's avatar
Yaowu Xu committed
349

Yue Chen's avatar
Yue Chen committed
350
351
352
353
354
355
356
357
  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
358
359
360
361
362
    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
363
#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yaowu Xu's avatar
Yaowu Xu committed
364
  }
Yue Chen's avatar
Yue Chen committed
365
#endif  // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yaowu Xu's avatar
Yaowu Xu committed
366
367
368
}
#endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION

369
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
370
371
static PREDICTION_MODE read_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
                                                aom_reader *r, int16_t ctx) {
Michael Bebenita's avatar
Michael Bebenita committed
372
373
374
  const int mode =
      aom_read_tree(r, av1_inter_compound_mode_tree,
                    cm->fc->inter_compound_mode_probs[ctx], ACCT_STR);
375
376
  FRAME_COUNTS *counts = xd->counts;

377
  if (counts) ++counts->inter_compound_mode[ctx][mode];
378
379
380
381
382
383

  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
  return NEAREST_NEARESTMV + mode;
}
#endif  // CONFIG_EXT_INTER

384
static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) {
385
#if CONFIG_EC_MULTISYMBOL
Michael Bebenita's avatar
Michael Bebenita committed
386
  return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
387
#else
Michael Bebenita's avatar
Michael Bebenita committed
388
  return aom_read_tree(r, av1_segment_tree, segp->tree_probs, ACCT_STR);
389
#endif
Jingning Han's avatar
Jingning Han committed
390
391
}

392
#if CONFIG_VAR_TX
Yaowu Xu's avatar
Yaowu Xu committed
393
static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
394
                               MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
395
396
                               TX_SIZE tx_size, int depth, int blk_row,
                               int blk_col, aom_reader *r) {
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
  int ctx = txfm_partition_context(xd->above_txfm_context + tx_col,
403
404
                                   xd->left_txfm_context + tx_row,
                                   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;
409

Jingning Han's avatar
Jingning Han committed
410
  if (depth == MAX_VARTX_DEPTH) {
411
412
    int idx, idy;
    inter_tx_size[0][0] = tx_size;
413
414
    for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
      for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
415
416
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
417
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
418
419
    if (counts) ++counts->txfm_partition[ctx][0];
    txfm_partition_update(xd->above_txfm_context + tx_col,
420
                          xd->left_txfm_context + tx_row, tx_size, tx_size);
421
422
423
    return;
  }

Michael Bebenita's avatar
Michael Bebenita committed
424
  is_split = aom_read(r, cm->fc->txfm_partition_prob[ctx], ACCT_STR);
425
426

  if (is_split) {
427
428
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
    const int bsl = tx_size_wide_unit[sub_txs];
429
    int i;
430

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

433
    if (tx_size == TX_8X8) {
434
      int idx, idy;
435
      inter_tx_size[0][0] = sub_txs;
436
437
      for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
        for (idx = 0; idx < 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 = get_min_tx_size(mbmi->tx_size);
441
      txfm_partition_update(xd->above_txfm_context + tx_col,
442
                            xd->left_txfm_context + tx_row, sub_txs, tx_size);
443
444
445
446
447
      return;
    }

    assert(bsl > 0);
    for (i = 0; i < 4; ++i) {
448
449
450
      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,
451
                         offsetc, r);
452
453
    }
  } else {
454
    int idx, idy;
455
    inter_tx_size[0][0] = tx_size;
456
457
    for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
      for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
458
459
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
460
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
461
    if (counts) ++counts->txfm_partition[ctx][0];
462
    txfm_partition_update(xd->above_txfm_context + tx_col,
463
                          xd->left_txfm_context + tx_row, tx_size, tx_size);
464
465
466
467
  }
}
#endif

Yaowu Xu's avatar
Yaowu Xu committed
468
469
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
470
471
  FRAME_COUNTS *counts = xd->counts;
  const int ctx = get_tx_size_context(xd);
472
473
474
475
476
477
478
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
#else
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif

479
  const int depth =
480
#if CONFIG_EC_MULTISYMBOL
481
      aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx], tx_size_cat + 2,
482
483
                      ACCT_STR);
#else
484
      aom_read_tree(r, av1_tx_size_tree[tx_size_cat],
485
                    ec_ctx->tx_size_probs[tx_size_cat][ctx], ACCT_STR);
486
#endif
487
488
489
490
  const TX_SIZE tx_size = depth_to_tx_size(depth);
#if CONFIG_RECT_TX
  assert(!is_rect_tx(tx_size));
#endif  // CONFIG_RECT_TX
491
  if (counts) ++counts->tx_size[tx_size_cat][ctx][depth];
492
  return tx_size;
Jingning Han's avatar
Jingning Han committed
493
494
}

495
496
497
498
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;
499
  if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4;
500
#if CONFIG_CB4X4 && (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
501
  if (bsize > BLOCK_4X4) {
502
#else
503
  if (bsize >= BLOCK_8X8) {
504
505
506
507
#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];
508
      const TX_SIZE coded_tx_size =
509
          read_selected_tx_size(cm, xd, tx_size_cat, r);
510
#if CONFIG_EXT_TX && CONFIG_RECT_TX
511
512
513
514
      if (coded_tx_size > max_txsize_lookup[bsize]) {
        assert(coded_tx_size == max_txsize_lookup[bsize] + 1);
        return max_txsize_rect_lookup[bsize];
      }
515
516
517
#else
      assert(coded_tx_size <= max_txsize_lookup[bsize]);
#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
518
      return coded_tx_size;
519
    } else {
520
      return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
521
522
    }
  } else {
523
#if CONFIG_EXT_TX && CONFIG_RECT_TX
Debargha Mukherjee's avatar
Debargha Mukherjee committed
524
    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
525
526
527
    return max_txsize_rect_lookup[bsize];
#else
    return TX_4X4;
528
#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
529
  }
Jingning Han's avatar
Jingning Han committed
530
531
}

Yaowu Xu's avatar
Yaowu Xu committed
532
static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
Jingning Han's avatar
Jingning Han committed
533
534
535
536
537
                              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++)
538
      segment_id =
Yaowu Xu's avatar
Yaowu Xu committed
539
          AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
Jingning Han's avatar
Jingning Han committed
540
541
542
543
544

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

Yaowu Xu's avatar
Yaowu Xu committed
545
static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
546
                           int segment_id) {
Jingning Han's avatar
Jingning Han committed
547
548
549
550
551
552
553
554
555
  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
556
static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
557
                                 int mi_offset, int x_mis, int y_mis,
Yaowu Xu's avatar
Yaowu Xu committed
558
                                 aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
559
  struct segmentation *const seg = &cm->seg;
560
561
  FRAME_COUNTS *counts = xd->counts;
  struct segmentation_probs *const segp = &cm->fc->seg;
Jingning Han's avatar
Jingning Han committed
562
563
  int segment_id;

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

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

568
  segment_id = read_segment_id(r, segp);
569
  if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
570
571
572
573
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
574
static void copy_segment_id(const AV1_COMMON *cm,
575
576
577
                            const uint8_t *last_segment_ids,
                            uint8_t *current_segment_ids, int mi_offset,
                            int x_mis, int y_mis) {
578
579
580
581
  int x, y;

  for (y = 0; y < y_mis; y++)
    for (x = 0; x < x_mis; x++)
582
583
584
      current_segment_ids[mi_offset + y * cm->mi_cols + x] =
          last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
                           : 0;
585
586
}

Yaowu Xu's avatar
Yaowu Xu committed
587
588
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
589
  struct segmentation *const seg = &cm->seg;
590
591
  FRAME_COUNTS *counts = xd->counts;
  struct segmentation_probs *const segp = &cm->fc->seg;
Jingning Han's avatar
Jingning Han committed
592
593
594
  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;
595
596
  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
597
598

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

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

604
605
606
607
  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
608
609
610
611
612
613
614
615

  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
616
617
    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
618
    mbmi->seg_id_predicted = aom_read(r, pred_prob, ACCT_STR);
619
    if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted];
620
621
622
623
    if (mbmi->seg_id_predicted) {
      segment_id = predicted_segment_id;
    } else {
      segment_id = read_segment_id(r, segp);
624
      if (counts) ++counts->seg.tree_mispred[segment_id];
625
    }
Jingning Han's avatar
Jingning Han committed
626
  } else {
627
    segment_id = read_segment_id(r, segp);
628
    if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
629
630
631
632
633
  }
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

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

647
#if CONFIG_PALETTE
648
649
#if CONFIG_PALETTE_DELTA_ENCODING
static int uint16_compare(const void *a, const void *b) {
650
651
  const uint16_t va = *(const uint16_t *)a;
  const uint16_t vb = *(const uint16_t *)b;
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
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
  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
735
736
static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                   aom_reader *r) {
hui su's avatar
hui su committed
737
738
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
739
  const MODE_INFO *const above_mi = xd->above_mi;
740
  const MODE_INFO *const left_mi = xd->left_mi;
hui su's avatar
hui su committed
741
  const BLOCK_SIZE bsize = mbmi->sb_type;
742
  int n;
743
744
745
  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;

  if (mbmi->mode == DC_PRED) {
746
    int palette_y_mode_ctx = 0;
747
    if (above_mi)
748
749
      palette_y_mode_ctx +=
          (above_mi->mbmi.palette_mode_info.palette_size[0] > 0);
750
    if (left_mi)
751
752
753
754
755
      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)) {
756
      pmi->palette_size[0] =
Yaowu Xu's avatar
Yaowu Xu committed
757
          aom_read_tree(r, av1_palette_size_tree,
Michael Bebenita's avatar
Michael Bebenita committed
758
759
                        av1_default_palette_y_size_prob[bsize - BLOCK_8X8],
                        ACCT_STR) +
760
          2;
761
      n = pmi->palette_size[0];
hui su's avatar
hui su committed
762
#if CONFIG_PALETTE_DELTA_ENCODING
763
      read_palette_colors_y(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
764
#else
765
      int i;
766
      for (i = 0; i < n; ++i)
Michael Bebenita's avatar
Michael Bebenita committed
767
        pmi->palette_colors[i] = aom_read_literal(r, cm->bit_depth, ACCT_STR);
hui su's avatar
hui su committed
768
#endif  // CONFIG_PALETTE_DELTA_ENCODING
769
770
771
772
      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
773

774
  if (mbmi->uv_mode == DC_PRED) {
775
776
    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
777
                 ACCT_STR)) {
778
      pmi->palette_size[1] =
Yaowu Xu's avatar
Yaowu Xu committed
779
          aom_read_tree(r, av1_palette_size_tree,
Michael Bebenita's avatar
Michael Bebenita committed
780
781
                        av1_default_palette_uv_size_prob[bsize - BLOCK_8X8],
                        ACCT_STR) +
782
          2;
783
      n = pmi->palette_size[1];
hui su's avatar
hui su committed
784
#if CONFIG_PALETTE_DELTA_ENCODING
785
      read_palette_colors_uv(xd, cm->bit_depth, pmi, r);
hui su's avatar
hui su committed
786
#else
787
      int i;
788
789
      for (i = 0; i < n; ++i) {
        pmi->palette_colors[PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
790
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
791
        pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
Michael Bebenita's avatar
Michael Bebenita committed
792
            aom_read_literal(r, cm->bit_depth, ACCT_STR);
793
      }
hui su's avatar
hui su committed
794
#endif  // CONFIG_PALETTE_DELTA_ENCODING
795
796
797
      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
798
799
  }
}
800
#endif  // CONFIG_PALETTE
hui su's avatar
hui su committed
801

802
803
804
#if CONFIG_FILTER_INTRA
static void read_filter_intra_mode_info(AV1_COMMON *const cm,
                                        MACROBLOCKD *const xd, aom_reader *r) {
hui su's avatar
hui su committed
805
806
807
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
  FRAME_COUNTS *counts = xd->counts;
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
813
814
815
  if (mbmi->mode == DC_PRED
#if CONFIG_PALETTE
      && mbmi->palette_mode_info.palette_size[0] == 0
#endif  // CONFIG_PALETTE
      ) {
816
817
818
819
    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
820
          read_uniform(r, FILTER_INTRA_MODES);
hui su's avatar
hui su committed
821
    }
822
    if (counts) {
clang-format's avatar
clang-format committed
823
824
      ++counts
            ->filter_intra[0][filter_intra_mode_info->use_filter_intra_mode[0]];
825
    }
hui su's avatar
hui su committed
826
  }
827
828
829
830
831
  if (mbmi->uv_mode == DC_PRED
#if CONFIG_PALETTE
      && mbmi->palette_mode_info.palette_size[1] == 0
#endif  // CONFIG_PALETTE
      ) {
832
833
834
835
    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
836
          read_uniform(r, FILTER_INTRA_MODES);
hui su's avatar
hui su committed
837
    }
838
    if (counts) {
clang-format's avatar
clang-format committed
839
840
      ++counts
            ->filter_intra[1][filter_intra_mode_info->use_filter_intra_mode[1]];
841
    }
hui su's avatar
hui su committed
842
843
  }
}
844
#endif  // CONFIG_FILTER_INTRA
845

846
#if CONFIG_EXT_INTRA
Yaowu Xu's avatar
Yaowu Xu committed
847
848
static void read_intra_angle_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                  aom_reader *r) {
849
850
  MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
  const BLOCK_SIZE bsize = mbmi->sb_type;
hui su's avatar
hui su committed
851
#if CONFIG_INTRA_INTERP
852
853
854
855
856
#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
857
  const int ctx = av1_get_pred_context_intra_interp(xd);
858
  int p_angle;
hui su's avatar
hui su committed
859
#endif  // CONFIG_INTRA_INTERP
860

hui su's avatar
hui su committed
861
  (void)cm;
862
  if (bsize < BLOCK_8X8) return;
863

hui su's avatar
hui su committed
864
  if (av1_is_directional_mode(mbmi->mode, bsize)) {
865
    mbmi->angle_delta[0] =
hui su's avatar
hui su committed
866
        read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
hui su's avatar
hui su committed
867
#if CONFIG_INTRA_INTERP
hui su's avatar
hui su committed
868
    p_angle = mode_to_angle_map[mbmi->mode] + mbmi->angle_delta[0] * ANGLE_STEP;
Yaowu Xu's avatar
Yaowu Xu committed
869
    if (av1_is_intra_filter_switchable(p_angle)) {
870
      FRAME_COUNTS *counts = xd->counts;
871
872
873
874
#if CONFIG_EC_MULTISYMBOL
      mbmi->intra_filter = aom_read_symbol(r, ec_ctx->intra_filter_cdf[ctx],
                                           INTRA_FILTERS, ACCT_STR);
#else
Michael Bebenita's avatar
Michael Bebenita committed
875
      mbmi->intra_filter = aom_read_tree(
876
877
          r, av1_intra_filter_tree, ec_ctx->intra_filter_probs[ctx], ACCT_STR);
#endif  // CONFIG_EC_MULTISYMBOL
878
      if (counts) ++counts->intra_filter[ctx][mbmi->intra_filter];
879
880
881
    } else {
      mbmi->intra_filter = INTRA_FILTER_LINEAR;
    }
hui su's avatar
hui su committed
882
#endif  // CONFIG_INTRA_INTERP
883
884
  }

hui su's avatar
hui su committed
885
  if (av1_is_directional_mode(mbmi->uv_mode, bsize)) {
886
    mbmi->angle_delta[1] =
hui su's avatar
hui su committed
887
        read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
888
889
  }
}
hui su's avatar
hui su committed
890
891
#endif  // CONFIG_EXT_INTRA

892
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
893
#if CONFIG_SUPERTX
894
                      int supertx_enabled,
Jingning Han's avatar
Jingning Han committed
895
#endif
Angie Chiang's avatar
Angie Chiang committed
896
#if CONFIG_TXK_SEL
897
                      int block, int plane,
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
903
904
#if CONFIG_VAR_TX
  const TX_SIZE tx_size = inter_block ? mbmi->min_tx_size : mbmi->tx_size;
#else
Jingning Han's avatar
Jingning Han committed
905
  const TX_SIZE tx_size = mbmi->tx_size;
906
#endif
907
908
909
910
911
912
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#else
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif

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

Jingning Han's avatar
Jingning Han committed
921
922
  if (!FIXED_TX_TYPE) {
#if CONFIG_EXT_TX
923
    const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
924
925
    if (get_ext_tx_types(tx_size, mbmi->sb_type, inter_block,
                         cm->reduced_tx_set_used) > 1 &&
926
927
928
        ((!cm->seg.enabled && cm->base_qindex > 0) ||
         (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
        !mbmi