decodemv.c 96.5 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]);
Jingning Han's avatar
Jingning Han committed
148
  FRAME_COUNTS *counts = xd->counts;
149
  if (counts) ++counts->y_mode[size_group][y_mode];
Jingning Han's avatar
Jingning Han committed
150
151
152
  return y_mode;
}

153
154
static PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx,
                                          MACROBLOCKD *xd, aom_reader *r,
Jingning Han's avatar
Jingning Han committed
155
                                          PREDICTION_MODE y_mode) {
156
  const PREDICTION_MODE uv_mode =
157
      read_intra_mode(r, ec_ctx->uv_mode_cdf[y_mode]);
Jingning Han's avatar
Jingning Han committed
158
  FRAME_COUNTS *counts = xd->counts;
159
  if (counts) ++counts->uv_mode[y_mode][uv_mode];
Jingning Han's avatar
Jingning Han committed
160
161
162
  return uv_mode;
}

Luc Trudeau's avatar
Luc Trudeau committed
163
#if CONFIG_CFL
164
165
166
167
168
169
170
171
172
173
174
175
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
176
    signs_out[CFL_PRED_U] = cfl_alpha_codes[ind][CFL_PRED_U]
177
178
                                ? aom_read_bit(r, "cfl:sign")
                                : CFL_SIGN_POS;
179
    signs_out[CFL_PRED_V] = cfl_alpha_codes[ind][CFL_PRED_V]
180
181
182
183
184
                                ? aom_read_bit(r, "cfl:sign")
                                : CFL_SIGN_POS;

    return ind;
  }
Luc Trudeau's avatar
Luc Trudeau committed
185
186
187
}
#endif

188
#if CONFIG_EXT_INTER && CONFIG_INTERINTRA
Yaowu Xu's avatar
Yaowu Xu committed
189
190
191
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
192
193
      r, av1_interintra_mode_tree, cm->fc->interintra_mode_prob[size_group],
      ACCT_STR);
194
  FRAME_COUNTS *counts = xd->counts;
195
  if (counts) ++counts->interintra_mode[size_group][ii_mode];
196
197
  return ii_mode;
}
198
#endif  // CONFIG_EXT_INTER && CONFIG_INTERINTRA
199

200
static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
201
                                       aom_reader *r, int16_t ctx) {
202
  FRAME_COUNTS *counts = xd->counts;
203
  int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
204
205
206
207
208
209
  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
210

211
  if (is_newmv) {
212
    if (counts) ++counts->newmv_mode[mode_ctx][0];
213
    return NEWMV;
214
  }
215
  if (counts) ++counts->newmv_mode[mode_ctx][1];
216

217
  if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return ZEROMV;
218

219
  mode_ctx = (ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
220

221
222
223
224
225
226
227
#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) {
228
    if (counts) ++counts->zeromv_mode[mode_ctx][0];
229
230
    return ZEROMV;
  }
231
  if (counts) ++counts->zeromv_mode[mode_ctx][1];
232

233
  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
234

235
236
237
  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;
238

239
240
241
242
243
#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
244

245
  if (is_refmv) {
246
    if (counts) ++counts->refmv_mode[mode_ctx][0];
247

248
249
    return NEARESTMV;
  } else {
250
    if (counts) ++counts->refmv_mode[mode_ctx][1];
251
252
253
254
255
    return NEARMV;
  }

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

258
static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
259
260
                         MB_MODE_INFO *mbmi, aom_reader *r) {
  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
261
262
  mbmi->ref_mv_idx = 0;

263
#if CONFIG_EXT_INTER
264
265
266
267
#if CONFIG_COMPOUND_SINGLEREF
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV ||
      mbmi->mode == SR_NEW_NEWMV) {
#else   // !CONFIG_COMPOUND_SINGLEREF
268
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
269
270
#endif  // CONFIG_COMPOUND_SINGLEREF
#else   // !CONFIG_EXT_INTER
271
  if (mbmi->mode == NEWMV) {
272
#endif  // CONFIG_EXT_INTER
273
274
275
    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
276
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
277
278
279
280
281
282
283
284
#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;
285
286
287
288
      }
    }
  }

David Barker's avatar
David Barker committed
289
  if (have_nearmv_in_inter_mode(mbmi->mode)) {
290
291
292
293
294
295
    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
296
        uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
297
298
299
300
301
302
303
304
#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;
305
306
307
308
309
      }
    }
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
310
311
#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
312
313
314
315
316
317
318
                                    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
319
320
  int motion_mode;
  FRAME_COUNTS *counts = xd->counts;
Yaowu Xu's avatar
Yaowu Xu committed
321

Yue Chen's avatar
Yue Chen committed
322
323
324
325
326
327
328
329
  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
330
331
332
333
334
    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
335
#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yaowu Xu's avatar
Yaowu Xu committed
336
  }
Yue Chen's avatar
Yue Chen committed
337
#endif  // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yaowu Xu's avatar
Yaowu Xu committed
338
339
340
}
#endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION

341
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
342
343
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
344
345
346
  const int mode =
      aom_read_tree(r, av1_inter_compound_mode_tree,
                    cm->fc->inter_compound_mode_probs[ctx], ACCT_STR);
347
348
  FRAME_COUNTS *counts = xd->counts;

349
  if (counts) ++counts->inter_compound_mode[ctx][mode];
350
351
352
353

  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
  return NEAREST_NEARESTMV + mode;
}
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370

#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
371
372
#endif  // CONFIG_EXT_INTER

373
static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) {
Michael Bebenita's avatar
Michael Bebenita committed
374
  return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
Jingning Han's avatar
Jingning Han committed
375
376
}

377
#if CONFIG_VAR_TX
Yaowu Xu's avatar
Yaowu Xu committed
378
static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
379
                               MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
380
381
                               TX_SIZE tx_size, int depth, int blk_row,
                               int blk_col, aom_reader *r) {
382
  int is_split = 0;
383
384
  const int tx_row = blk_row >> 1;
  const int tx_col = blk_col >> 1;
385
386
  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);
387
388
  int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
                                   xd->left_txfm_context + blk_row,
389
                                   mbmi->sb_type, tx_size);
clang-format's avatar
clang-format committed
390
  TX_SIZE(*const inter_tx_size)
391
392
393
  [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;
394

Jingning Han's avatar
Jingning Han committed
395
  if (depth == MAX_VARTX_DEPTH) {
396
397
    int idx, idy;
    inter_tx_size[0][0] = tx_size;
398
399
    for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
      for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
400
401
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
402
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
403
    if (counts) ++counts->txfm_partition[ctx][0];
404
405
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
406
407
408
    return;
  }

Michael Bebenita's avatar
Michael Bebenita committed
409
  is_split = aom_read(r, cm->fc->txfm_partition_prob[ctx], ACCT_STR);
410
411

  if (is_split) {
412
413
    const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
    const int bsl = tx_size_wide_unit[sub_txs];
414
    int i;
415

416
    if (counts) ++counts->txfm_partition[ctx][1];
417

418
    if (tx_size == TX_8X8) {
419
      int idx, idy;
420
      inter_tx_size[0][0] = sub_txs;
421
422
      for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
        for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
423
          inter_tx_size[idy][idx] = inter_tx_size[0][0];
424
      mbmi->tx_size = sub_txs;
425
      mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
426
427
      txfm_partition_update(xd->above_txfm_context + blk_col,
                            xd->left_txfm_context + blk_row, sub_txs, tx_size);
428
429
430
431
432
      return;
    }

    assert(bsl > 0);
    for (i = 0; i < 4; ++i) {
433
434
435
      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,
436
                         offsetc, r);
437
438
    }
  } else {
439
    int idx, idy;
440
    inter_tx_size[0][0] = tx_size;
441
442
    for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
      for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
443
444
        inter_tx_size[idy][idx] = tx_size;
    mbmi->tx_size = tx_size;
445
    mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
446
    if (counts) ++counts->txfm_partition[ctx][0];
447
448
    txfm_partition_update(xd->above_txfm_context + blk_col,
                          xd->left_txfm_context + blk_row, tx_size, tx_size);
449
450
451
452
  }
}
#endif

Yaowu Xu's avatar
Yaowu Xu committed
453
454
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
455
456
  FRAME_COUNTS *counts = xd->counts;
  const int ctx = get_tx_size_context(xd);
457
458
459
460
461
462
463
#if CONFIG_EC_ADAPT
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
  (void)cm;
#else
  FRAME_CONTEXT *ec_ctx = cm->fc;
#endif

464
465
  const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
                                    tx_size_cat + 2, ACCT_STR);
466
467
468
469
  const TX_SIZE tx_size = depth_to_tx_size(depth);
#if CONFIG_RECT_TX
  assert(!is_rect_tx(tx_size));
#endif  // CONFIG_RECT_TX
470
  if (counts) ++counts->tx_size[tx_size_cat][ctx][depth];
471
  return tx_size;
Jingning Han's avatar
Jingning Han committed
472
473
}

474
475
476
477
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;
478
  if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4;
479
#if CONFIG_CB4X4 && (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
480
  if (bsize > BLOCK_4X4) {
481
#else
482
  if (bsize >= BLOCK_8X8) {
483
484
485
486
#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];
487
      const TX_SIZE coded_tx_size =
488
          read_selected_tx_size(cm, xd, tx_size_cat, r);
489
#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
490
491
      if (coded_tx_size > max_txsize_lookup[bsize]) {
        assert(coded_tx_size == max_txsize_lookup[bsize] + 1);
492
#if CONFIG_EXT_TX && CONFIG_RECT_TX_EXT
493
494
495
496
497
498
499
500
        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];
        }
501
#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX_EXT
502

503
504
        return max_txsize_rect_lookup[bsize];
      }
505
506
#else
      assert(coded_tx_size <= max_txsize_lookup[bsize]);
507
#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
508
      return coded_tx_size;
509
    } else {
510
      return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
511
512
    }
  } else {
513
#if CONFIG_EXT_TX && CONFIG_RECT_TX
Debargha Mukherjee's avatar
Debargha Mukherjee committed
514
    assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
515
516
517
    return max_txsize_rect_lookup[bsize];
#else
    return TX_4X4;
518
#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
519
  }
Jingning Han's avatar
Jingning Han committed
520
521
}

Yaowu Xu's avatar
Yaowu Xu committed
522
static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
Jingning Han's avatar
Jingning Han committed
523
524
525
526
527
                              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++)
528
      segment_id =
Yaowu Xu's avatar
Yaowu Xu committed
529
          AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
Jingning Han's avatar
Jingning Han committed
530
531
532
533
534

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

Yaowu Xu's avatar
Yaowu Xu committed
535
static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
536
                           int segment_id) {
Jingning Han's avatar
Jingning Han committed
537
538
539
540
541
542
543
544
545
  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
546
static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
547
                                 int mi_offset, int x_mis, int y_mis,
Yaowu Xu's avatar
Yaowu Xu committed
548
                                 aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
549
  struct segmentation *const seg = &cm->seg;
550
551
  FRAME_COUNTS *counts = xd->counts;
  struct segmentation_probs *const segp = &cm->fc->seg;
Jingning Han's avatar
Jingning Han committed
552
553
  int segment_id;

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

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

558
  segment_id = read_segment_id(r, segp);
559
  if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
560
561
562
563
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
564
static void copy_segment_id(const AV1_COMMON *cm,
565
566
567
                            const uint8_t *last_segment_ids,
                            uint8_t *current_segment_ids, int mi_offset,
                            int x_mis, int y_mis) {
568
569
570
571
  int x, y;

  for (y = 0; y < y_mis; y++)
    for (x = 0; x < x_mis; x++)
572
573
574
      current_segment_ids[mi_offset + y * cm->mi_cols + x] =
          last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
                           : 0;
575
576
}

Yaowu Xu's avatar
Yaowu Xu committed
577
578
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
579
  struct segmentation *const seg = &cm->seg;
580
581
  FRAME_COUNTS *counts = xd->counts;
  struct segmentation_probs *const segp = &cm->fc->seg;
Jingning Han's avatar
Jingning Han committed
582
583
584
  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;
585
586
  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
587
588

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

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

594
595
596
597
  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
598
599
600
601
602
603
604
605

  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
606
607
    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
608
    mbmi->seg_id_predicted = aom_read(r, pred_prob, ACCT_STR);
609
    if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted];
610
611
612
613
    if (mbmi->seg_id_predicted) {
      segment_id = predicted_segment_id;
    } else {
      segment_id = read_segment_id(r, segp);
614
      if (counts) ++counts->seg.tree_mispred[segment_id];
615
    }
Jingning Han's avatar
Jingning Han committed
616
  } else {
617
    segment_id = read_segment_id(r, segp);
618
    if (counts) ++counts->seg.tree_total[segment_id];
Jingning Han's avatar
Jingning Han committed
619
620
621
622
623
  }
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
  return segment_id;
}

Yaowu Xu's avatar
Yaowu Xu committed
624
625
static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
                     aom_reader *r) {
Jingning Han's avatar
Jingning Han committed
626
627
628
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
    return 1;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
629
    const int ctx = av1_get_skip_context(xd);
630
631
632
633
#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
634
    const int skip = aom_read(r, cm->fc->skip_probs[ctx], ACCT_STR);
635
#endif
Jingning Han's avatar
Jingning Han committed
636
    FRAME_COUNTS *counts = xd->counts;
637
    if (counts) ++counts->skip[ctx][skip];
Jingning Han's avatar
Jingning Han committed
638
639
640
641
    return skip;
  }
}

642
#if CONFIG_PALETTE
643
644
#if CONFIG_PALETTE_DELTA_ENCODING
static int uint16_compare(const void *a, const void *b) {
645
646
  const uint16_t va = *(const uint16_t *)a;
  const uint16_t vb = *(const uint16_t *)b;
647
648
649
650
651
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
  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
730
731
static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                                   aom_reader *r) {
hui su's avatar
hui su committed
732
733
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
734
  const MODE_INFO *const above_mi = xd->above_mi;
735
  const MODE_INFO *const left_mi = xd->left_mi;
hui su's avatar
hui su committed
736
  const BLOCK_SIZE bsize = mbmi->sb_type;
737
  int n;
738
739
740
  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;

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

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

797
798
#if CONFIG_FILTER_INTRA
static void read_filter_intra_mode_info(AV1_COMMON *const cm,
799
800
                                        MACROBLOCKD *const xd, int mi_row,
                                        int mi_col, aom_reader *r) {
hui su's avatar
hui su committed
801
802
803
  MODE_INFO *const mi = xd->mi[0];
  MB_MODE_INFO *const mbmi = &mi->mbmi;
  FRAME_COUNTS *counts = xd->counts;
804
805
  FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
      &mbmi->filter_intra_mode_info;
hui su's avatar
hui su committed
806

807
808
809
810
811
  if (mbmi->mode == DC_PRED
#if CONFIG_PALETTE
      && mbmi->palette_mode_info.palette_size[0] == 0
#endif  // CONFIG_PALETTE
      ) {
812
813
814
815
    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
816
          read_uniform(r, FILTER_INTRA_MODES);
hui su's avatar
hui su committed
817
    }
818
    if (counts) {
clang-format's avatar
clang-format committed
819
820
      ++counts
            ->filter_intra[0][filter_intra_mode_info->use_filter_intra_mode[0]];
821
    }
hui su's avatar
hui su committed
822
  }
823
824
825
826
827
828

#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;
829
830
831
832
#else
  (void)mi_row;
  (void)mi_col;
#endif  // CONFIG_CB4X4
833

834
835
836
837
838
  if (mbmi->uv_mode == DC_PRED
#if CONFIG_PALETTE
      && mbmi->palette_mode_info.palette_size[1] == 0
#endif  // CONFIG_PALETTE
      ) {
839
840
841
842
    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
843
          read_uniform(r, FILTER_INTRA_MODES);
hui su's avatar
hui su committed
844
    }
845
    if (counts) {
clang-format's avatar
clang-format committed
846
847
      ++counts
            ->filter_intra[1][filter_intra_mode_info->use_filter_intra_mode[1]];
848
    }
hui su's avatar
hui su committed
849
850
  }
}
851
#endif  // CONFIG_FILTER_INTRA
852

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

hui su's avatar
hui su committed
868
  (void)cm;
869
  if (bsize < BLOCK_8X8) return;
870

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

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

894
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
895
#if CONFIG_SUPERTX
896
                      int supertx_enabled,
Jingning Han's avatar
Jingning Han committed
897
#endif
Angie Chiang's avatar
Angie Chiang committed
898
#if CONFIG_TXK_SEL
899
                      int block, int plane,
900
901
902
#endif
                      aom_reader *r) {
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
Jingning Han's avatar
Jingning Han committed
903
  const int inter_block = is_inter_block(mbmi);
904
905
906
#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
907
  const TX_SIZE tx_size = mbmi->tx_size;
908
#endif
909
910
911
912
913
914
#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
915
#if !CONFIG_TXK_SEL
916
917
  TX_TYPE *tx_type = &mbmi->tx_type;
#else
918
919
  // only y plane's tx_type is transmitted
  if (plane > 0) return;
920
921
922
  TX_TYPE *tx_type = &mbmi->txk_type[block];
#endif

Jingning Han's avatar
Jingning Han committed
923
924
  if (!FIXED_TX_TYPE) {
#if CONFIG_EXT_TX
925
    const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
926
927
    if (get_ext_tx_types(tx_size, mbmi->sb_type, inter_block,
                         cm->reduced_tx_set_used) > 1 &&
928
929
930
        ((!cm->seg.enabled && cm->base_qindex > 0) ||
         (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
        !mbmi->skip &&
Jingning Han's avatar
Jingning Han committed
931
932
933
934
#if CONFIG_SUPERTX
        !supertx_enabled &&
#endif  // CONFIG_SUPERTX
        !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
935
936
      const int eset = get_ext_tx_set(tx_size, mbmi->sb_type, inter_block,
                                      cm->reduced_tx_set_used);
Jingning Han's avatar
Jingning Han committed
937
938
939
940
      FRAME_COUNTS *counts = xd->counts;

      if (inter_block) {
        if (eset > 0) {
941
          *tx_type = av1_ext_tx_inter_inv[eset][aom_read_symbol(
942
943
              r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size],
              ext_tx_cnt_inter[eset], ACCT_STR)];
944
          if (counts) ++counts->inter_ext_tx[eset][square_tx_size][*tx_type];
Jingning Han's avatar
Jingning Han committed
945
946
947
        }
      } else if (ALLOW_INTRA_EXT_TX) {
        if (eset > 0) {
948
          *tx_type = av1_ext_tx_intra_inv[eset][aom_read_symbol(
949
950
              r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode],
              ext_tx_cnt_intra[eset], ACCT_STR)];
Jingning Han's avatar
Jingning Han committed
951
          if (counts)
952
            ++counts->intra_ext_tx[eset][square_tx_size][mbmi->mode][*tx_type];