Coverage Report

Created: 2022-08-24 06:11

/src/aom/av1/decoder/decodemv.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3
 *
4
 * This source code is subject to the terms of the BSD 2 Clause License and
5
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6
 * was not distributed with this source code in the LICENSE file, you can
7
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8
 * Media Patent License 1.0 was not distributed with this source code in the
9
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10
 */
11
12
#include <assert.h>
13
14
#include "av1/common/cfl.h"
15
#include "av1/common/common.h"
16
#include "av1/common/entropy.h"
17
#include "av1/common/entropymode.h"
18
#include "av1/common/entropymv.h"
19
#include "av1/common/mvref_common.h"
20
#include "av1/common/pred_common.h"
21
#include "av1/common/reconinter.h"
22
#include "av1/common/reconintra.h"
23
#include "av1/common/seg_common.h"
24
#include "av1/common/warped_motion.h"
25
26
#include "av1/decoder/decodeframe.h"
27
#include "av1/decoder/decodemv.h"
28
29
#include "aom_dsp/aom_dsp_common.h"
30
31
#define ACCT_STR __func__
32
33
#define DEC_MISMATCH_DEBUG 0
34
35
0
static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
36
0
  return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR);
37
0
}
38
39
0
static void read_cdef(AV1_COMMON *cm, aom_reader *r, MACROBLOCKD *const xd) {
40
0
  const int skip_txfm = xd->mi[0]->skip_txfm;
41
0
  if (cm->features.coded_lossless) return;
42
0
  if (cm->features.allow_intrabc) {
43
0
    assert(cm->cdef_info.cdef_bits == 0);
44
0
    return;
45
0
  }
46
47
  // At the start of a superblock, mark that we haven't yet read CDEF strengths
48
  // for any of the CDEF units contained in this superblock.
49
0
  const int sb_mask = (cm->seq_params->mib_size - 1);
50
0
  const int mi_row_in_sb = (xd->mi_row & sb_mask);
51
0
  const int mi_col_in_sb = (xd->mi_col & sb_mask);
52
0
  if (mi_row_in_sb == 0 && mi_col_in_sb == 0) {
53
0
    xd->cdef_transmitted[0] = xd->cdef_transmitted[1] =
54
0
        xd->cdef_transmitted[2] = xd->cdef_transmitted[3] = false;
55
0
  }
56
57
  // CDEF unit size is 64x64 irrespective of the superblock size.
58
0
  const int cdef_size = 1 << (6 - MI_SIZE_LOG2);
59
60
  // Find index of this CDEF unit in this superblock.
61
0
  const int index_mask = cdef_size;
62
0
  const int cdef_unit_row_in_sb = ((xd->mi_row & index_mask) != 0);
63
0
  const int cdef_unit_col_in_sb = ((xd->mi_col & index_mask) != 0);
64
0
  const int index = (cm->seq_params->sb_size == BLOCK_128X128)
65
0
                        ? cdef_unit_col_in_sb + 2 * cdef_unit_row_in_sb
66
0
                        : 0;
67
68
  // Read CDEF strength from the first non-skip coding block in this CDEF unit.
69
0
  if (!xd->cdef_transmitted[index] && !skip_txfm) {
70
    // CDEF strength for this CDEF unit needs to be read into the MB_MODE_INFO
71
    // of the 1st block in this CDEF unit.
72
0
    const int first_block_mask = ~(cdef_size - 1);
73
0
    CommonModeInfoParams *const mi_params = &cm->mi_params;
74
0
    const int grid_idx =
75
0
        get_mi_grid_idx(mi_params, xd->mi_row & first_block_mask,
76
0
                        xd->mi_col & first_block_mask);
77
0
    MB_MODE_INFO *const mbmi = mi_params->mi_grid_base[grid_idx];
78
0
    mbmi->cdef_strength =
79
0
        aom_read_literal(r, cm->cdef_info.cdef_bits, ACCT_STR);
80
0
    xd->cdef_transmitted[index] = true;
81
0
  }
82
0
}
83
84
static int read_delta_qindex(AV1_COMMON *cm, const MACROBLOCKD *xd,
85
0
                             aom_reader *r, MB_MODE_INFO *const mbmi) {
86
0
  int sign, abs, reduced_delta_qindex = 0;
87
0
  BLOCK_SIZE bsize = mbmi->bsize;
88
0
  const int b_col = xd->mi_col & (cm->seq_params->mib_size - 1);
89
0
  const int b_row = xd->mi_row & (cm->seq_params->mib_size - 1);
90
0
  const int read_delta_q_flag = (b_col == 0 && b_row == 0);
91
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
92
93
0
  if ((bsize != cm->seq_params->sb_size || mbmi->skip_txfm == 0) &&
94
0
      read_delta_q_flag) {
95
0
    abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
96
0
    const int smallval = (abs < DELTA_Q_SMALL);
97
98
0
    if (!smallval) {
99
0
      const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
100
0
      const int thr = (1 << rem_bits) + 1;
101
0
      abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
102
0
    }
103
104
0
    if (abs) {
105
0
      sign = aom_read_bit(r, ACCT_STR);
106
0
    } else {
107
0
      sign = 1;
108
0
    }
109
110
0
    reduced_delta_qindex = sign ? -abs : abs;
111
0
  }
112
0
  return reduced_delta_qindex;
113
0
}
114
static int read_delta_lflevel(const AV1_COMMON *const cm, aom_reader *r,
115
                              aom_cdf_prob *const cdf,
116
                              const MB_MODE_INFO *const mbmi, int mi_col,
117
0
                              int mi_row) {
118
0
  int reduced_delta_lflevel = 0;
119
0
  const BLOCK_SIZE bsize = mbmi->bsize;
120
0
  const int b_col = mi_col & (cm->seq_params->mib_size - 1);
121
0
  const int b_row = mi_row & (cm->seq_params->mib_size - 1);
122
0
  const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
123
124
0
  if ((bsize != cm->seq_params->sb_size || mbmi->skip_txfm == 0) &&
125
0
      read_delta_lf_flag) {
126
0
    int abs = aom_read_symbol(r, cdf, DELTA_LF_PROBS + 1, ACCT_STR);
127
0
    const int smallval = (abs < DELTA_LF_SMALL);
128
0
    if (!smallval) {
129
0
      const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1;
130
0
      const int thr = (1 << rem_bits) + 1;
131
0
      abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
132
0
    }
133
0
    const int sign = abs ? aom_read_bit(r, ACCT_STR) : 1;
134
0
    reduced_delta_lflevel = sign ? -abs : abs;
135
0
  }
136
0
  return reduced_delta_lflevel;
137
0
}
138
139
static UV_PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx,
140
                                             aom_reader *r,
141
                                             CFL_ALLOWED_TYPE cfl_allowed,
142
0
                                             PREDICTION_MODE y_mode) {
143
0
  const UV_PREDICTION_MODE uv_mode =
144
0
      aom_read_symbol(r, ec_ctx->uv_mode_cdf[cfl_allowed][y_mode],
145
0
                      UV_INTRA_MODES - !cfl_allowed, ACCT_STR);
146
0
  return uv_mode;
147
0
}
148
149
static uint8_t read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r,
150
0
                               int8_t *signs_out) {
151
0
  const int8_t joint_sign =
152
0
      aom_read_symbol(r, ec_ctx->cfl_sign_cdf, CFL_JOINT_SIGNS, "cfl:signs");
153
0
  uint8_t idx = 0;
154
  // Magnitudes are only coded for nonzero values
155
0
  if (CFL_SIGN_U(joint_sign) != CFL_SIGN_ZERO) {
156
0
    aom_cdf_prob *cdf_u = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_U(joint_sign)];
157
0
    idx = (uint8_t)aom_read_symbol(r, cdf_u, CFL_ALPHABET_SIZE, "cfl:alpha_u")
158
0
          << CFL_ALPHABET_SIZE_LOG2;
159
0
  }
160
0
  if (CFL_SIGN_V(joint_sign) != CFL_SIGN_ZERO) {
161
0
    aom_cdf_prob *cdf_v = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_V(joint_sign)];
162
0
    idx += (uint8_t)aom_read_symbol(r, cdf_v, CFL_ALPHABET_SIZE, "cfl:alpha_v");
163
0
  }
164
0
  *signs_out = joint_sign;
165
0
  return idx;
166
0
}
167
168
static INTERINTRA_MODE read_interintra_mode(MACROBLOCKD *xd, aom_reader *r,
169
0
                                            int size_group) {
170
0
  const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_symbol(
171
0
      r, xd->tile_ctx->interintra_mode_cdf[size_group], INTERINTRA_MODES,
172
0
      ACCT_STR);
173
0
  return ii_mode;
174
0
}
175
176
static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, aom_reader *r,
177
0
                                       int16_t ctx) {
178
0
  int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
179
0
  int is_newmv, is_zeromv, is_refmv;
180
0
  is_newmv = aom_read_symbol(r, ec_ctx->newmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
181
0
  if (is_newmv) return NEWMV;
182
183
0
  mode_ctx = (ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
184
0
  is_zeromv =
185
0
      aom_read_symbol(r, ec_ctx->zeromv_cdf[mode_ctx], 2, ACCT_STR) == 0;
186
0
  if (is_zeromv) return GLOBALMV;
187
188
0
  mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
189
0
  is_refmv = aom_read_symbol(r, ec_ctx->refmv_cdf[mode_ctx], 2, ACCT_STR) == 0;
190
0
  if (is_refmv)
191
0
    return NEARESTMV;
192
0
  else
193
0
    return NEARMV;
194
0
}
195
196
static void read_drl_idx(FRAME_CONTEXT *ec_ctx, DecoderCodingBlock *dcb,
197
0
                         MB_MODE_INFO *mbmi, aom_reader *r) {
198
0
  MACROBLOCKD *const xd = &dcb->xd;
199
0
  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
200
0
  mbmi->ref_mv_idx = 0;
201
0
  if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
202
0
    for (int idx = 0; idx < 2; ++idx) {
203
0
      if (dcb->ref_mv_count[ref_frame_type] > idx + 1) {
204
0
        uint8_t drl_ctx = av1_drl_ctx(xd->weight[ref_frame_type], idx);
205
0
        int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
206
0
        mbmi->ref_mv_idx = idx + drl_idx;
207
0
        if (!drl_idx) return;
208
0
      }
209
0
    }
210
0
  }
211
0
  if (have_nearmv_in_inter_mode(mbmi->mode)) {
212
    // Offset the NEARESTMV mode.
213
    // TODO(jingning): Unify the two syntax decoding loops after the NEARESTMV
214
    // mode is factored in.
215
0
    for (int idx = 1; idx < 3; ++idx) {
216
0
      if (dcb->ref_mv_count[ref_frame_type] > idx + 1) {
217
0
        uint8_t drl_ctx = av1_drl_ctx(xd->weight[ref_frame_type], idx);
218
0
        int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR);
219
0
        mbmi->ref_mv_idx = idx + drl_idx - 1;
220
0
        if (!drl_idx) return;
221
0
      }
222
0
    }
223
0
  }
224
0
}
225
226
static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
227
0
                                    MB_MODE_INFO *mbmi, aom_reader *r) {
228
0
  if (cm->features.switchable_motion_mode == 0) return SIMPLE_TRANSLATION;
229
0
  if (mbmi->skip_mode) return SIMPLE_TRANSLATION;
230
231
0
  const MOTION_MODE last_motion_mode_allowed = motion_mode_allowed(
232
0
      xd->global_motion, xd, mbmi, cm->features.allow_warped_motion);
233
0
  int motion_mode;
234
235
0
  if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
236
237
0
  if (last_motion_mode_allowed == OBMC_CAUSAL) {
238
0
    motion_mode =
239
0
        aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->bsize], 2, ACCT_STR);
240
0
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
241
0
  } else {
242
0
    motion_mode = aom_read_symbol(r, xd->tile_ctx->motion_mode_cdf[mbmi->bsize],
243
0
                                  MOTION_MODES, ACCT_STR);
244
0
    return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
245
0
  }
246
0
}
247
248
static PREDICTION_MODE read_inter_compound_mode(MACROBLOCKD *xd, aom_reader *r,
249
0
                                                int16_t ctx) {
250
0
  const int mode =
251
0
      aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx],
252
0
                      INTER_COMPOUND_MODES, ACCT_STR);
253
0
  assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
254
0
  return NEAREST_NEARESTMV + mode;
255
0
}
256
257
0
int av1_neg_deinterleave(int diff, int ref, int max) {
258
0
  if (!ref) return diff;
259
0
  if (ref >= (max - 1)) return max - diff - 1;
260
0
  if (2 * ref < max) {
261
0
    if (diff <= 2 * ref) {
262
0
      if (diff & 1)
263
0
        return ref + ((diff + 1) >> 1);
264
0
      else
265
0
        return ref - (diff >> 1);
266
0
    }
267
0
    return diff;
268
0
  } else {
269
0
    if (diff <= 2 * (max - ref - 1)) {
270
0
      if (diff & 1)
271
0
        return ref + ((diff + 1) >> 1);
272
0
      else
273
0
        return ref - (diff >> 1);
274
0
    }
275
0
    return max - (diff + 1);
276
0
  }
277
0
}
278
279
static int read_segment_id(AV1_COMMON *const cm, const MACROBLOCKD *const xd,
280
0
                           aom_reader *r, int skip) {
281
0
  int cdf_num;
282
0
  const int pred = av1_get_spatial_seg_pred(cm, xd, &cdf_num);
283
0
  if (skip) return pred;
284
285
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
286
0
  struct segmentation *const seg = &cm->seg;
287
0
  struct segmentation_probs *const segp = &ec_ctx->seg;
288
0
  aom_cdf_prob *pred_cdf = segp->spatial_pred_seg_cdf[cdf_num];
289
0
  const int coded_id = aom_read_symbol(r, pred_cdf, MAX_SEGMENTS, ACCT_STR);
290
0
  const int segment_id =
291
0
      av1_neg_deinterleave(coded_id, pred, seg->last_active_segid + 1);
292
293
0
  if (segment_id < 0 || segment_id > seg->last_active_segid) {
294
0
    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
295
0
                       "Corrupted segment_ids");
296
0
  }
297
0
  return segment_id;
298
0
}
299
300
static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
301
0
                              int mi_offset, int x_mis, int y_mis) {
302
0
  int segment_id = INT_MAX;
303
304
0
  for (int y = 0; y < y_mis; y++)
305
0
    for (int x = 0; x < x_mis; x++)
306
0
      segment_id = AOMMIN(
307
0
          segment_id, segment_ids[mi_offset + y * cm->mi_params.mi_cols + x]);
308
309
0
  assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
310
0
  return segment_id;
311
0
}
312
313
static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
314
0
                           int segment_id) {
315
0
  assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
316
317
0
  for (int y = 0; y < y_mis; y++)
318
0
    for (int x = 0; x < x_mis; x++)
319
0
      cm->cur_frame->seg_map[mi_offset + y * cm->mi_params.mi_cols + x] =
320
0
          segment_id;
321
0
}
322
323
static int read_intra_segment_id(AV1_COMMON *const cm,
324
                                 const MACROBLOCKD *const xd, int bsize,
325
0
                                 aom_reader *r, int skip) {
326
0
  struct segmentation *const seg = &cm->seg;
327
0
  if (!seg->enabled) return 0;  // Default for disabled segmentation
328
0
  assert(seg->update_map && !seg->temporal_update);
329
330
0
  const CommonModeInfoParams *const mi_params = &cm->mi_params;
331
0
  const int mi_row = xd->mi_row;
332
0
  const int mi_col = xd->mi_col;
333
0
  const int mi_offset = mi_row * mi_params->mi_cols + mi_col;
334
0
  const int bw = mi_size_wide[bsize];
335
0
  const int bh = mi_size_high[bsize];
336
0
  const int x_mis = AOMMIN(mi_params->mi_cols - mi_col, bw);
337
0
  const int y_mis = AOMMIN(mi_params->mi_rows - mi_row, bh);
338
0
  const int segment_id = read_segment_id(cm, xd, r, skip);
339
0
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
340
0
  return segment_id;
341
0
}
342
343
static void copy_segment_id(const CommonModeInfoParams *const mi_params,
344
                            const uint8_t *last_segment_ids,
345
                            uint8_t *current_segment_ids, int mi_offset,
346
0
                            int x_mis, int y_mis) {
347
0
  for (int y = 0; y < y_mis; y++)
348
0
    for (int x = 0; x < x_mis; x++)
349
0
      current_segment_ids[mi_offset + y * mi_params->mi_cols + x] =
350
0
          last_segment_ids
351
0
              ? last_segment_ids[mi_offset + y * mi_params->mi_cols + x]
352
0
              : 0;
353
0
}
354
355
static int get_predicted_segment_id(AV1_COMMON *const cm, int mi_offset,
356
0
                                    int x_mis, int y_mis) {
357
0
  return cm->last_frame_seg_map ? dec_get_segment_id(cm, cm->last_frame_seg_map,
358
0
                                                     mi_offset, x_mis, y_mis)
359
0
                                : 0;
360
0
}
361
362
static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
363
0
                                 int preskip, aom_reader *r) {
364
0
  struct segmentation *const seg = &cm->seg;
365
0
  const CommonModeInfoParams *const mi_params = &cm->mi_params;
366
0
  MB_MODE_INFO *const mbmi = xd->mi[0];
367
0
  const int mi_row = xd->mi_row;
368
0
  const int mi_col = xd->mi_col;
369
0
  const int mi_offset = mi_row * mi_params->mi_cols + mi_col;
370
0
  const int bw = mi_size_wide[mbmi->bsize];
371
0
  const int bh = mi_size_high[mbmi->bsize];
372
373
  // TODO(slavarnway): move x_mis, y_mis into xd ?????
374
0
  const int x_mis = AOMMIN(mi_params->mi_cols - mi_col, bw);
375
0
  const int y_mis = AOMMIN(mi_params->mi_rows - mi_row, bh);
376
377
0
  if (!seg->enabled) return 0;  // Default for disabled segmentation
378
379
0
  if (!seg->update_map) {
380
0
    copy_segment_id(mi_params, cm->last_frame_seg_map, cm->cur_frame->seg_map,
381
0
                    mi_offset, x_mis, y_mis);
382
0
    return get_predicted_segment_id(cm, mi_offset, x_mis, y_mis);
383
0
  }
384
385
0
  int segment_id;
386
0
  if (preskip) {
387
0
    if (!seg->segid_preskip) return 0;
388
0
  } else {
389
0
    if (mbmi->skip_txfm) {
390
0
      if (seg->temporal_update) {
391
0
        mbmi->seg_id_predicted = 0;
392
0
      }
393
0
      segment_id = read_segment_id(cm, xd, r, 1);
394
0
      set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
395
0
      return segment_id;
396
0
    }
397
0
  }
398
399
0
  if (seg->temporal_update) {
400
0
    const int ctx = av1_get_pred_context_seg_id(xd);
401
0
    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
402
0
    struct segmentation_probs *const segp = &ec_ctx->seg;
403
0
    aom_cdf_prob *pred_cdf = segp->pred_cdf[ctx];
404
0
    mbmi->seg_id_predicted = aom_read_symbol(r, pred_cdf, 2, ACCT_STR);
405
0
    if (mbmi->seg_id_predicted) {
406
0
      segment_id = get_predicted_segment_id(cm, mi_offset, x_mis, y_mis);
407
0
    } else {
408
0
      segment_id = read_segment_id(cm, xd, r, 0);
409
0
    }
410
0
  } else {
411
0
    segment_id = read_segment_id(cm, xd, r, 0);
412
0
  }
413
0
  set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
414
0
  return segment_id;
415
0
}
416
417
static int read_skip_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
418
0
                          aom_reader *r) {
419
0
  if (!cm->current_frame.skip_mode_info.skip_mode_flag) return 0;
420
421
0
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
422
0
    return 0;
423
0
  }
424
425
0
  if (!is_comp_ref_allowed(xd->mi[0]->bsize)) return 0;
426
427
0
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME) ||
428
0
      segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
429
    // These features imply single-reference mode, while skip mode implies
430
    // compound reference. Hence, the two are mutually exclusive.
431
    // In other words, skip_mode is implicitly 0 here.
432
0
    return 0;
433
0
  }
434
435
0
  const int ctx = av1_get_skip_mode_context(xd);
436
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
437
0
  const int skip_mode =
438
0
      aom_read_symbol(r, ec_ctx->skip_mode_cdfs[ctx], 2, ACCT_STR);
439
0
  return skip_mode;
440
0
}
441
442
static int read_skip_txfm(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
443
0
                          aom_reader *r) {
444
0
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
445
0
    return 1;
446
0
  } else {
447
0
    const int ctx = av1_get_skip_txfm_context(xd);
448
0
    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
449
0
    const int skip_txfm =
450
0
        aom_read_symbol(r, ec_ctx->skip_txfm_cdfs[ctx], 2, ACCT_STR);
451
0
    return skip_txfm;
452
0
  }
453
0
}
454
455
// Merge the sorted list of cached colors(cached_colors[0...n_cached_colors-1])
456
// and the sorted list of transmitted colors(colors[n_cached_colors...n-1]) into
457
// one single sorted list(colors[...]).
458
static void merge_colors(uint16_t *colors, uint16_t *cached_colors,
459
0
                         int n_colors, int n_cached_colors) {
460
0
  if (n_cached_colors == 0) return;
461
0
  int cache_idx = 0, trans_idx = n_cached_colors;
462
0
  for (int i = 0; i < n_colors; ++i) {
463
0
    if (cache_idx < n_cached_colors &&
464
0
        (trans_idx >= n_colors ||
465
0
         cached_colors[cache_idx] <= colors[trans_idx])) {
466
0
      colors[i] = cached_colors[cache_idx++];
467
0
    } else {
468
0
      assert(trans_idx < n_colors);
469
0
      colors[i] = colors[trans_idx++];
470
0
    }
471
0
  }
472
0
}
473
474
static void read_palette_colors_y(MACROBLOCKD *const xd, int bit_depth,
475
0
                                  PALETTE_MODE_INFO *const pmi, aom_reader *r) {
476
0
  uint16_t color_cache[2 * PALETTE_MAX_SIZE];
477
0
  uint16_t cached_colors[PALETTE_MAX_SIZE];
478
0
  const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
479
0
  const int n = pmi->palette_size[0];
480
0
  int idx = 0;
481
0
  for (int i = 0; i < n_cache && idx < n; ++i)
482
0
    if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
483
0
  if (idx < n) {
484
0
    const int n_cached_colors = idx;
485
0
    pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
486
0
    if (idx < n) {
487
0
      const int min_bits = bit_depth - 3;
488
0
      int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
489
0
      int range = (1 << bit_depth) - pmi->palette_colors[idx - 1] - 1;
490
0
      for (; idx < n; ++idx) {
491
0
        assert(range >= 0);
492
0
        const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
493
0
        pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
494
0
                                         0, (1 << bit_depth) - 1);
495
0
        range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
496
0
        bits = AOMMIN(bits, av1_ceil_log2(range));
497
0
      }
498
0
    }
499
0
    merge_colors(pmi->palette_colors, cached_colors, n, n_cached_colors);
500
0
  } else {
501
0
    memcpy(pmi->palette_colors, cached_colors, n * sizeof(cached_colors[0]));
502
0
  }
503
0
}
504
505
static void read_palette_colors_uv(MACROBLOCKD *const xd, int bit_depth,
506
                                   PALETTE_MODE_INFO *const pmi,
507
0
                                   aom_reader *r) {
508
0
  const int n = pmi->palette_size[1];
509
  // U channel colors.
510
0
  uint16_t color_cache[2 * PALETTE_MAX_SIZE];
511
0
  uint16_t cached_colors[PALETTE_MAX_SIZE];
512
0
  const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
513
0
  int idx = 0;
514
0
  for (int i = 0; i < n_cache && idx < n; ++i)
515
0
    if (aom_read_bit(r, ACCT_STR)) cached_colors[idx++] = color_cache[i];
516
0
  if (idx < n) {
517
0
    const int n_cached_colors = idx;
518
0
    idx += PALETTE_MAX_SIZE;
519
0
    pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
520
0
    if (idx < PALETTE_MAX_SIZE + n) {
521
0
      const int min_bits = bit_depth - 3;
522
0
      int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
523
0
      int range = (1 << bit_depth) - pmi->palette_colors[idx - 1];
524
0
      for (; idx < PALETTE_MAX_SIZE + n; ++idx) {
525
0
        assert(range >= 0);
526
0
        const int delta = aom_read_literal(r, bits, ACCT_STR);
527
0
        pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
528
0
                                         0, (1 << bit_depth) - 1);
529
0
        range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
530
0
        bits = AOMMIN(bits, av1_ceil_log2(range));
531
0
      }
532
0
    }
533
0
    merge_colors(pmi->palette_colors + PALETTE_MAX_SIZE, cached_colors, n,
534
0
                 n_cached_colors);
535
0
  } else {
536
0
    memcpy(pmi->palette_colors + PALETTE_MAX_SIZE, cached_colors,
537
0
           n * sizeof(cached_colors[0]));
538
0
  }
539
540
  // V channel colors.
541
0
  if (aom_read_bit(r, ACCT_STR)) {  // Delta encoding.
542
0
    const int min_bits_v = bit_depth - 4;
543
0
    const int max_val = 1 << bit_depth;
544
0
    int bits = min_bits_v + aom_read_literal(r, 2, ACCT_STR);
545
0
    pmi->palette_colors[2 * PALETTE_MAX_SIZE] =
546
0
        aom_read_literal(r, bit_depth, ACCT_STR);
547
0
    for (int i = 1; i < n; ++i) {
548
0
      int delta = aom_read_literal(r, bits, ACCT_STR);
549
0
      if (delta && aom_read_bit(r, ACCT_STR)) delta = -delta;
550
0
      int val = (int)pmi->palette_colors[2 * PALETTE_MAX_SIZE + i - 1] + delta;
551
0
      if (val < 0) val += max_val;
552
0
      if (val >= max_val) val -= max_val;
553
0
      pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] = val;
554
0
    }
555
0
  } else {
556
0
    for (int i = 0; i < n; ++i) {
557
0
      pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
558
0
          aom_read_literal(r, bit_depth, ACCT_STR);
559
0
    }
560
0
  }
561
0
}
562
563
static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
564
0
                                   aom_reader *r) {
565
0
  const int num_planes = av1_num_planes(cm);
566
0
  MB_MODE_INFO *const mbmi = xd->mi[0];
567
0
  const BLOCK_SIZE bsize = mbmi->bsize;
568
0
  assert(av1_allow_palette(cm->features.allow_screen_content_tools, bsize));
569
0
  PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
570
0
  const int bsize_ctx = av1_get_palette_bsize_ctx(bsize);
571
572
0
  if (mbmi->mode == DC_PRED) {
573
0
    const int palette_mode_ctx = av1_get_palette_mode_ctx(xd);
574
0
    const int modev = aom_read_symbol(
575
0
        r, xd->tile_ctx->palette_y_mode_cdf[bsize_ctx][palette_mode_ctx], 2,
576
0
        ACCT_STR);
577
0
    if (modev) {
578
0
      pmi->palette_size[0] =
579
0
          aom_read_symbol(r, xd->tile_ctx->palette_y_size_cdf[bsize_ctx],
580
0
                          PALETTE_SIZES, ACCT_STR) +
581
0
          2;
582
0
      read_palette_colors_y(xd, cm->seq_params->bit_depth, pmi, r);
583
0
    }
584
0
  }
585
0
  if (num_planes > 1 && mbmi->uv_mode == UV_DC_PRED && xd->is_chroma_ref) {
586
0
    const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
587
0
    const int modev = aom_read_symbol(
588
0
        r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR);
589
0
    if (modev) {
590
0
      pmi->palette_size[1] =
591
0
          aom_read_symbol(r, xd->tile_ctx->palette_uv_size_cdf[bsize_ctx],
592
0
                          PALETTE_SIZES, ACCT_STR) +
593
0
          2;
594
0
      read_palette_colors_uv(xd, cm->seq_params->bit_depth, pmi, r);
595
0
    }
596
0
  }
597
0
}
598
599
0
static int read_angle_delta(aom_reader *r, aom_cdf_prob *cdf) {
600
0
  const int sym = aom_read_symbol(r, cdf, 2 * MAX_ANGLE_DELTA + 1, ACCT_STR);
601
0
  return sym - MAX_ANGLE_DELTA;
602
0
}
603
604
static void read_filter_intra_mode_info(const AV1_COMMON *const cm,
605
0
                                        MACROBLOCKD *const xd, aom_reader *r) {
606
0
  MB_MODE_INFO *const mbmi = xd->mi[0];
607
0
  FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
608
0
      &mbmi->filter_intra_mode_info;
609
610
0
  if (av1_filter_intra_allowed(cm, mbmi)) {
611
0
    filter_intra_mode_info->use_filter_intra = aom_read_symbol(
612
0
        r, xd->tile_ctx->filter_intra_cdfs[mbmi->bsize], 2, ACCT_STR);
613
0
    if (filter_intra_mode_info->use_filter_intra) {
614
0
      filter_intra_mode_info->filter_intra_mode = aom_read_symbol(
615
0
          r, xd->tile_ctx->filter_intra_mode_cdf, FILTER_INTRA_MODES, ACCT_STR);
616
0
    }
617
0
  } else {
618
0
    filter_intra_mode_info->use_filter_intra = 0;
619
0
  }
620
0
}
621
622
void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row,
623
0
                      int blk_col, TX_SIZE tx_size, aom_reader *r) {
624
0
  MB_MODE_INFO *mbmi = xd->mi[0];
625
0
  uint8_t *tx_type =
626
0
      &xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col];
627
0
  *tx_type = DCT_DCT;
628
629
  // No need to read transform type if block is skipped.
630
0
  if (mbmi->skip_txfm ||
631
0
      segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP))
632
0
    return;
633
634
  // No need to read transform type for lossless mode(qindex==0).
635
0
  const int qindex = xd->qindex[mbmi->segment_id];
636
0
  if (qindex == 0) return;
637
638
0
  const int inter_block = is_inter_block(mbmi);
639
0
  if (get_ext_tx_types(tx_size, inter_block, cm->features.reduced_tx_set_used) >
640
0
      1) {
641
0
    const TxSetType tx_set_type = av1_get_ext_tx_set_type(
642
0
        tx_size, inter_block, cm->features.reduced_tx_set_used);
643
0
    const int eset =
644
0
        get_ext_tx_set(tx_size, inter_block, cm->features.reduced_tx_set_used);
645
    // eset == 0 should correspond to a set with only DCT_DCT and
646
    // there is no need to read the tx_type
647
0
    assert(eset != 0);
648
649
0
    const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
650
0
    FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
651
0
    if (inter_block) {
652
0
      *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol(
653
0
          r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size],
654
0
          av1_num_ext_tx_set[tx_set_type], ACCT_STR)];
655
0
    } else {
656
0
      const PREDICTION_MODE intra_mode =
657
0
          mbmi->filter_intra_mode_info.use_filter_intra
658
0
              ? fimode_to_intradir[mbmi->filter_intra_mode_info
659
0
                                       .filter_intra_mode]
660
0
              : mbmi->mode;
661
0
      *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol(
662
0
          r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_mode],
663
0
          av1_num_ext_tx_set[tx_set_type], ACCT_STR)];
664
0
    }
665
0
  }
666
0
}
667
668
static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref,
669
                           nmv_context *ctx, MvSubpelPrecision precision);
670
671
static INLINE int is_mv_valid(const MV *mv);
672
673
static INLINE int assign_dv(AV1_COMMON *cm, MACROBLOCKD *xd, int_mv *mv,
674
                            const int_mv *ref_mv, int mi_row, int mi_col,
675
0
                            BLOCK_SIZE bsize, aom_reader *r) {
676
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
677
0
  read_mv(r, &mv->as_mv, &ref_mv->as_mv, &ec_ctx->ndvc, MV_SUBPEL_NONE);
678
  // DV should not have sub-pel.
679
0
  assert((mv->as_mv.col & 7) == 0);
680
0
  assert((mv->as_mv.row & 7) == 0);
681
0
  mv->as_mv.col = (mv->as_mv.col >> 3) * 8;
682
0
  mv->as_mv.row = (mv->as_mv.row >> 3) * 8;
683
0
  int valid = is_mv_valid(&mv->as_mv) &&
684
0
              av1_is_dv_valid(mv->as_mv, cm, xd, mi_row, mi_col, bsize,
685
0
                              cm->seq_params->mib_size_log2);
686
0
  return valid;
687
0
}
688
689
static void read_intrabc_info(AV1_COMMON *const cm, DecoderCodingBlock *dcb,
690
0
                              aom_reader *r) {
691
0
  MACROBLOCKD *const xd = &dcb->xd;
692
0
  MB_MODE_INFO *const mbmi = xd->mi[0];
693
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
694
0
  mbmi->use_intrabc = aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_STR);
695
0
  if (mbmi->use_intrabc) {
696
0
    BLOCK_SIZE bsize = mbmi->bsize;
697
0
    mbmi->mode = DC_PRED;
698
0
    mbmi->uv_mode = UV_DC_PRED;
699
0
    mbmi->interp_filters = av1_broadcast_interp_filter(BILINEAR);
700
0
    mbmi->motion_mode = SIMPLE_TRANSLATION;
701
702
0
    int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES];
703
0
    int_mv ref_mvs[INTRA_FRAME + 1][MAX_MV_REF_CANDIDATES];
704
705
0
    av1_find_mv_refs(cm, xd, mbmi, INTRA_FRAME, dcb->ref_mv_count,
706
0
                     xd->ref_mv_stack, xd->weight, ref_mvs, /*global_mvs=*/NULL,
707
0
                     inter_mode_ctx);
708
709
0
    int_mv nearestmv, nearmv;
710
711
0
    av1_find_best_ref_mvs(0, ref_mvs[INTRA_FRAME], &nearestmv, &nearmv, 0);
712
0
    int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv;
713
0
    if (dv_ref.as_int == 0)
714
0
      av1_find_ref_dv(&dv_ref, &xd->tile, cm->seq_params->mib_size, xd->mi_row);
715
    // Ref DV should not have sub-pel.
716
0
    int valid_dv = (dv_ref.as_mv.col & 7) == 0 && (dv_ref.as_mv.row & 7) == 0;
717
0
    dv_ref.as_mv.col = (dv_ref.as_mv.col >> 3) * 8;
718
0
    dv_ref.as_mv.row = (dv_ref.as_mv.row >> 3) * 8;
719
0
    valid_dv = valid_dv && assign_dv(cm, xd, &mbmi->mv[0], &dv_ref, xd->mi_row,
720
0
                                     xd->mi_col, bsize, r);
721
0
    if (!valid_dv) {
722
      // Intra bc motion vectors are not valid - signal corrupt frame
723
0
      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
724
0
                         "Invalid intrabc dv");
725
0
    }
726
0
  }
727
0
}
728
729
// If delta q is present, reads delta_q index.
730
// Also reads delta_q loop filter levels, if present.
731
static void read_delta_q_params(AV1_COMMON *const cm, MACROBLOCKD *const xd,
732
0
                                aom_reader *r) {
733
0
  DeltaQInfo *const delta_q_info = &cm->delta_q_info;
734
735
0
  if (delta_q_info->delta_q_present_flag) {
736
0
    MB_MODE_INFO *const mbmi = xd->mi[0];
737
0
    xd->current_base_qindex +=
738
0
        read_delta_qindex(cm, xd, r, mbmi) * delta_q_info->delta_q_res;
739
    /* Normative: Clamp to [1,MAXQ] to not interfere with lossless mode */
740
0
    xd->current_base_qindex = clamp(xd->current_base_qindex, 1, MAXQ);
741
0
    FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
742
0
    if (delta_q_info->delta_lf_present_flag) {
743
0
      const int mi_row = xd->mi_row;
744
0
      const int mi_col = xd->mi_col;
745
0
      if (delta_q_info->delta_lf_multi) {
746
0
        const int frame_lf_count =
747
0
            av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
748
0
        for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) {
749
0
          const int tmp_lvl =
750
0
              xd->delta_lf[lf_id] +
751
0
              read_delta_lflevel(cm, r, ec_ctx->delta_lf_multi_cdf[lf_id], mbmi,
752
0
                                 mi_col, mi_row) *
753
0
                  delta_q_info->delta_lf_res;
754
0
          mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id] =
755
0
              clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER);
756
0
        }
757
0
      } else {
758
0
        const int tmp_lvl = xd->delta_lf_from_base +
759
0
                            read_delta_lflevel(cm, r, ec_ctx->delta_lf_cdf,
760
0
                                               mbmi, mi_col, mi_row) *
761
0
                                delta_q_info->delta_lf_res;
762
0
        mbmi->delta_lf_from_base = xd->delta_lf_from_base =
763
0
            clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER);
764
0
      }
765
0
    }
766
0
  }
767
0
}
768
769
static void read_intra_frame_mode_info(AV1_COMMON *const cm,
770
0
                                       DecoderCodingBlock *dcb, aom_reader *r) {
771
0
  MACROBLOCKD *const xd = &dcb->xd;
772
0
  MB_MODE_INFO *const mbmi = xd->mi[0];
773
0
  const MB_MODE_INFO *above_mi = xd->above_mbmi;
774
0
  const MB_MODE_INFO *left_mi = xd->left_mbmi;
775
0
  const BLOCK_SIZE bsize = mbmi->bsize;
776
0
  struct segmentation *const seg = &cm->seg;
777
778
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
779
780
0
  if (seg->segid_preskip)
781
0
    mbmi->segment_id = read_intra_segment_id(cm, xd, bsize, r, 0);
782
783
0
  mbmi->skip_txfm = read_skip_txfm(cm, xd, mbmi->segment_id, r);
784
785
0
  if (!seg->segid_preskip)
786
0
    mbmi->segment_id = read_intra_segment_id(cm, xd, bsize, r, mbmi->skip_txfm);
787
788
0
  read_cdef(cm, r, xd);
789
790
0
  read_delta_q_params(cm, xd, r);
791
792
0
  mbmi->current_qindex = xd->current_base_qindex;
793
794
0
  mbmi->ref_frame[0] = INTRA_FRAME;
795
0
  mbmi->ref_frame[1] = NONE_FRAME;
796
0
  mbmi->palette_mode_info.palette_size[0] = 0;
797
0
  mbmi->palette_mode_info.palette_size[1] = 0;
798
0
  mbmi->filter_intra_mode_info.use_filter_intra = 0;
799
800
0
  const int mi_row = xd->mi_row;
801
0
  const int mi_col = xd->mi_col;
802
0
  xd->above_txfm_context = cm->above_contexts.txfm[xd->tile.tile_row] + mi_col;
803
0
  xd->left_txfm_context =
804
0
      xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
805
806
0
  if (av1_allow_intrabc(cm)) {
807
0
    read_intrabc_info(cm, dcb, r);
808
0
    if (is_intrabc_block(mbmi)) return;
809
0
  }
810
811
0
  mbmi->mode = read_intra_mode(r, get_y_mode_cdf(ec_ctx, above_mi, left_mi));
812
813
0
  const int use_angle_delta = av1_use_angle_delta(bsize);
814
0
  mbmi->angle_delta[PLANE_TYPE_Y] =
815
0
      (use_angle_delta && av1_is_directional_mode(mbmi->mode))
816
0
          ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
817
0
          : 0;
818
819
0
  if (!cm->seq_params->monochrome && xd->is_chroma_ref) {
820
0
    mbmi->uv_mode =
821
0
        read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode);
822
0
    if (mbmi->uv_mode == UV_CFL_PRED) {
823
0
      mbmi->cfl_alpha_idx = read_cfl_alphas(ec_ctx, r, &mbmi->cfl_alpha_signs);
824
0
    }
825
0
    mbmi->angle_delta[PLANE_TYPE_UV] =
826
0
        (use_angle_delta && av1_is_directional_mode(get_uv_mode(mbmi->uv_mode)))
827
0
            ? read_angle_delta(r,
828
0
                               ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED])
829
0
            : 0;
830
0
  } else {
831
    // Avoid decoding angle_info if there is is no chroma prediction
832
0
    mbmi->uv_mode = UV_DC_PRED;
833
0
  }
834
0
  xd->cfl.store_y = store_cfl_required(cm, xd);
835
836
0
  if (av1_allow_palette(cm->features.allow_screen_content_tools, bsize))
837
0
    read_palette_mode_info(cm, xd, r);
838
839
0
  read_filter_intra_mode_info(cm, xd, r);
840
0
}
841
842
static int read_mv_component(aom_reader *r, nmv_component *mvcomp,
843
0
                             int use_subpel, int usehp) {
844
0
  int mag, d, fr, hp;
845
0
  const int sign = aom_read_symbol(r, mvcomp->sign_cdf, 2, ACCT_STR);
846
0
  const int mv_class =
847
0
      aom_read_symbol(r, mvcomp->classes_cdf, MV_CLASSES, ACCT_STR);
848
0
  const int class0 = mv_class == MV_CLASS_0;
849
850
  // Integer part
851
0
  if (class0) {
852
0
    d = aom_read_symbol(r, mvcomp->class0_cdf, CLASS0_SIZE, ACCT_STR);
853
0
    mag = 0;
854
0
  } else {
855
0
    const int n = mv_class + CLASS0_BITS - 1;  // number of bits
856
0
    d = 0;
857
0
    for (int i = 0; i < n; ++i)
858
0
      d |= aom_read_symbol(r, mvcomp->bits_cdf[i], 2, ACCT_STR) << i;
859
0
    mag = CLASS0_SIZE << (mv_class + 2);
860
0
  }
861
862
0
  if (use_subpel) {
863
    // Fractional part
864
0
    fr = aom_read_symbol(r, class0 ? mvcomp->class0_fp_cdf[d] : mvcomp->fp_cdf,
865
0
                         MV_FP_SIZE, ACCT_STR);
866
867
    // High precision part (if hp is not used, the default value of the hp is 1)
868
0
    hp = usehp ? aom_read_symbol(
869
0
                     r, class0 ? mvcomp->class0_hp_cdf : mvcomp->hp_cdf, 2,
870
0
                     ACCT_STR)
871
0
               : 1;
872
0
  } else {
873
0
    fr = 3;
874
0
    hp = 1;
875
0
  }
876
877
  // Result
878
0
  mag += ((d << 3) | (fr << 1) | hp) + 1;
879
0
  return sign ? -mag : mag;
880
0
}
881
882
static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref,
883
0
                           nmv_context *ctx, MvSubpelPrecision precision) {
884
0
  MV diff = kZeroMv;
885
0
  const MV_JOINT_TYPE joint_type =
886
0
      (MV_JOINT_TYPE)aom_read_symbol(r, ctx->joints_cdf, MV_JOINTS, ACCT_STR);
887
888
0
  if (mv_joint_vertical(joint_type))
889
0
    diff.row = read_mv_component(r, &ctx->comps[0], precision > MV_SUBPEL_NONE,
890
0
                                 precision > MV_SUBPEL_LOW_PRECISION);
891
892
0
  if (mv_joint_horizontal(joint_type))
893
0
    diff.col = read_mv_component(r, &ctx->comps[1], precision > MV_SUBPEL_NONE,
894
0
                                 precision > MV_SUBPEL_LOW_PRECISION);
895
896
0
  mv->row = ref->row + diff.row;
897
0
  mv->col = ref->col + diff.col;
898
0
}
899
900
static REFERENCE_MODE read_block_reference_mode(AV1_COMMON *cm,
901
                                                const MACROBLOCKD *xd,
902
0
                                                aom_reader *r) {
903
0
  if (!is_comp_ref_allowed(xd->mi[0]->bsize)) return SINGLE_REFERENCE;
904
0
  if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) {
905
0
    const int ctx = av1_get_reference_mode_context(xd);
906
0
    const REFERENCE_MODE mode = (REFERENCE_MODE)aom_read_symbol(
907
0
        r, xd->tile_ctx->comp_inter_cdf[ctx], 2, ACCT_STR);
908
0
    return mode;  // SINGLE_REFERENCE or COMPOUND_REFERENCE
909
0
  } else {
910
0
    assert(cm->current_frame.reference_mode == SINGLE_REFERENCE);
911
0
    return cm->current_frame.reference_mode;
912
0
  }
913
0
}
914
915
#define READ_REF_BIT(pname) \
916
0
  aom_read_symbol(r, av1_get_pred_cdf_##pname(xd), 2, ACCT_STR)
917
918
static COMP_REFERENCE_TYPE read_comp_reference_type(const MACROBLOCKD *xd,
919
0
                                                    aom_reader *r) {
920
0
  const int ctx = av1_get_comp_reference_type_context(xd);
921
0
  const COMP_REFERENCE_TYPE comp_ref_type =
922
0
      (COMP_REFERENCE_TYPE)aom_read_symbol(
923
0
          r, xd->tile_ctx->comp_ref_type_cdf[ctx], 2, ACCT_STR);
924
0
  return comp_ref_type;  // UNIDIR_COMP_REFERENCE or BIDIR_COMP_REFERENCE
925
0
}
926
927
static void set_ref_frames_for_skip_mode(AV1_COMMON *const cm,
928
0
                                         MV_REFERENCE_FRAME ref_frame[2]) {
929
0
  ref_frame[0] = LAST_FRAME + cm->current_frame.skip_mode_info.ref_frame_idx_0;
930
0
  ref_frame[1] = LAST_FRAME + cm->current_frame.skip_mode_info.ref_frame_idx_1;
931
0
}
932
933
// Read the referncence frame
934
static void read_ref_frames(AV1_COMMON *const cm, MACROBLOCKD *const xd,
935
                            aom_reader *r, int segment_id,
936
0
                            MV_REFERENCE_FRAME ref_frame[2]) {
937
0
  if (xd->mi[0]->skip_mode) {
938
0
    set_ref_frames_for_skip_mode(cm, ref_frame);
939
0
    return;
940
0
  }
941
942
0
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
943
0
    ref_frame[0] = (MV_REFERENCE_FRAME)get_segdata(&cm->seg, segment_id,
944
0
                                                   SEG_LVL_REF_FRAME);
945
0
    ref_frame[1] = NONE_FRAME;
946
0
  } else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP) ||
947
0
             segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
948
0
    ref_frame[0] = LAST_FRAME;
949
0
    ref_frame[1] = NONE_FRAME;
950
0
  } else {
951
0
    const REFERENCE_MODE mode = read_block_reference_mode(cm, xd, r);
952
953
0
    if (mode == COMPOUND_REFERENCE) {
954
0
      const COMP_REFERENCE_TYPE comp_ref_type = read_comp_reference_type(xd, r);
955
956
0
      if (comp_ref_type == UNIDIR_COMP_REFERENCE) {
957
0
        const int bit = READ_REF_BIT(uni_comp_ref_p);
958
0
        if (bit) {
959
0
          ref_frame[0] = BWDREF_FRAME;
960
0
          ref_frame[1] = ALTREF_FRAME;
961
0
        } else {
962
0
          const int bit1 = READ_REF_BIT(uni_comp_ref_p1);
963
0
          if (bit1) {
964
0
            const int bit2 = READ_REF_BIT(uni_comp_ref_p2);
965
0
            if (bit2) {
966
0
              ref_frame[0] = LAST_FRAME;
967
0
              ref_frame[1] = GOLDEN_FRAME;
968
0
            } else {
969
0
              ref_frame[0] = LAST_FRAME;
970
0
              ref_frame[1] = LAST3_FRAME;
971
0
            }
972
0
          } else {
973
0
            ref_frame[0] = LAST_FRAME;
974
0
            ref_frame[1] = LAST2_FRAME;
975
0
          }
976
0
        }
977
978
0
        return;
979
0
      }
980
981
0
      assert(comp_ref_type == BIDIR_COMP_REFERENCE);
982
983
0
      const int idx = 1;
984
0
      const int bit = READ_REF_BIT(comp_ref_p);
985
      // Decode forward references.
986
0
      if (!bit) {
987
0
        const int bit1 = READ_REF_BIT(comp_ref_p1);
988
0
        ref_frame[!idx] = bit1 ? LAST2_FRAME : LAST_FRAME;
989
0
      } else {
990
0
        const int bit2 = READ_REF_BIT(comp_ref_p2);
991
0
        ref_frame[!idx] = bit2 ? GOLDEN_FRAME : LAST3_FRAME;
992
0
      }
993
994
      // Decode backward references.
995
0
      const int bit_bwd = READ_REF_BIT(comp_bwdref_p);
996
0
      if (!bit_bwd) {
997
0
        const int bit1_bwd = READ_REF_BIT(comp_bwdref_p1);
998
0
        ref_frame[idx] = bit1_bwd ? ALTREF2_FRAME : BWDREF_FRAME;
999
0
      } else {
1000
0
        ref_frame[idx] = ALTREF_FRAME;
1001
0
      }
1002
0
    } else if (mode == SINGLE_REFERENCE) {
1003
0
      const int bit0 = READ_REF_BIT(single_ref_p1);
1004
0
      if (bit0) {
1005
0
        const int bit1 = READ_REF_BIT(single_ref_p2);
1006
0
        if (!bit1) {
1007
0
          const int bit5 = READ_REF_BIT(single_ref_p6);
1008
0
          ref_frame[0] = bit5 ? ALTREF2_FRAME : BWDREF_FRAME;
1009
0
        } else {
1010
0
          ref_frame[0] = ALTREF_FRAME;
1011
0
        }
1012
0
      } else {
1013
0
        const int bit2 = READ_REF_BIT(single_ref_p3);
1014
0
        if (bit2) {
1015
0
          const int bit4 = READ_REF_BIT(single_ref_p5);
1016
0
          ref_frame[0] = bit4 ? GOLDEN_FRAME : LAST3_FRAME;
1017
0
        } else {
1018
0
          const int bit3 = READ_REF_BIT(single_ref_p4);
1019
0
          ref_frame[0] = bit3 ? LAST2_FRAME : LAST_FRAME;
1020
0
        }
1021
0
      }
1022
1023
0
      ref_frame[1] = NONE_FRAME;
1024
0
    } else {
1025
0
      assert(0 && "Invalid prediction mode.");
1026
0
    }
1027
0
  }
1028
0
}
1029
1030
static INLINE void read_mb_interp_filter(const MACROBLOCKD *const xd,
1031
                                         InterpFilter interp_filter,
1032
                                         bool enable_dual_filter,
1033
                                         MB_MODE_INFO *const mbmi,
1034
0
                                         aom_reader *r) {
1035
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1036
1037
0
  if (!av1_is_interp_needed(xd)) {
1038
0
    set_default_interp_filters(mbmi, interp_filter);
1039
0
    return;
1040
0
  }
1041
1042
0
  if (interp_filter != SWITCHABLE) {
1043
0
    mbmi->interp_filters = av1_broadcast_interp_filter(interp_filter);
1044
0
  } else {
1045
0
    InterpFilter ref0_filter[2] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
1046
0
    for (int dir = 0; dir < 2; ++dir) {
1047
0
      const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
1048
0
      ref0_filter[dir] = (InterpFilter)aom_read_symbol(
1049
0
          r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS, ACCT_STR);
1050
0
      if (!enable_dual_filter) {
1051
0
        ref0_filter[1] = ref0_filter[0];
1052
0
        break;
1053
0
      }
1054
0
    }
1055
    // The index system works as: (0, 1) -> (vertical, horizontal) filter types
1056
0
    mbmi->interp_filters.as_filters.x_filter = ref0_filter[1];
1057
0
    mbmi->interp_filters.as_filters.y_filter = ref0_filter[0];
1058
0
  }
1059
0
}
1060
1061
static void read_intra_block_mode_info(AV1_COMMON *const cm,
1062
                                       MACROBLOCKD *const xd,
1063
                                       MB_MODE_INFO *const mbmi,
1064
0
                                       aom_reader *r) {
1065
0
  const BLOCK_SIZE bsize = mbmi->bsize;
1066
0
  const int use_angle_delta = av1_use_angle_delta(bsize);
1067
1068
0
  mbmi->ref_frame[0] = INTRA_FRAME;
1069
0
  mbmi->ref_frame[1] = NONE_FRAME;
1070
1071
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1072
1073
0
  mbmi->mode = read_intra_mode(r, ec_ctx->y_mode_cdf[size_group_lookup[bsize]]);
1074
1075
0
  mbmi->angle_delta[PLANE_TYPE_Y] =
1076
0
      use_angle_delta && av1_is_directional_mode(mbmi->mode)
1077
0
          ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
1078
0
          : 0;
1079
0
  if (!cm->seq_params->monochrome && xd->is_chroma_ref) {
1080
0
    mbmi->uv_mode =
1081
0
        read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode);
1082
0
    if (mbmi->uv_mode == UV_CFL_PRED) {
1083
0
      mbmi->cfl_alpha_idx =
1084
0
          read_cfl_alphas(xd->tile_ctx, r, &mbmi->cfl_alpha_signs);
1085
0
    }
1086
0
    mbmi->angle_delta[PLANE_TYPE_UV] =
1087
0
        use_angle_delta && av1_is_directional_mode(get_uv_mode(mbmi->uv_mode))
1088
0
            ? read_angle_delta(r,
1089
0
                               ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED])
1090
0
            : 0;
1091
0
  } else {
1092
    // Avoid decoding angle_info if there is is no chroma prediction
1093
0
    mbmi->uv_mode = UV_DC_PRED;
1094
0
  }
1095
0
  xd->cfl.store_y = store_cfl_required(cm, xd);
1096
1097
0
  mbmi->palette_mode_info.palette_size[0] = 0;
1098
0
  mbmi->palette_mode_info.palette_size[1] = 0;
1099
0
  if (av1_allow_palette(cm->features.allow_screen_content_tools, bsize))
1100
0
    read_palette_mode_info(cm, xd, r);
1101
1102
0
  read_filter_intra_mode_info(cm, xd, r);
1103
0
}
1104
1105
0
static INLINE int is_mv_valid(const MV *mv) {
1106
0
  return mv->row > MV_LOW && mv->row < MV_UPP && mv->col > MV_LOW &&
1107
0
         mv->col < MV_UPP;
1108
0
}
1109
1110
static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd,
1111
                            PREDICTION_MODE mode,
1112
                            MV_REFERENCE_FRAME ref_frame[2], int_mv mv[2],
1113
                            int_mv ref_mv[2], int_mv nearest_mv[2],
1114
                            int_mv near_mv[2], int is_compound, int allow_hp,
1115
0
                            aom_reader *r) {
1116
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1117
0
  MB_MODE_INFO *mbmi = xd->mi[0];
1118
0
  BLOCK_SIZE bsize = mbmi->bsize;
1119
0
  FeatureFlags *const features = &cm->features;
1120
0
  if (features->cur_frame_force_integer_mv) {
1121
0
    allow_hp = MV_SUBPEL_NONE;
1122
0
  }
1123
0
  switch (mode) {
1124
0
    case NEWMV: {
1125
0
      nmv_context *const nmvc = &ec_ctx->nmvc;
1126
0
      read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp);
1127
0
      break;
1128
0
    }
1129
0
    case NEARESTMV: {
1130
0
      mv[0].as_int = nearest_mv[0].as_int;
1131
0
      break;
1132
0
    }
1133
0
    case NEARMV: {
1134
0
      mv[0].as_int = near_mv[0].as_int;
1135
0
      break;
1136
0
    }
1137
0
    case GLOBALMV: {
1138
0
      mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
1139
0
                                          features->allow_high_precision_mv,
1140
0
                                          bsize, xd->mi_col, xd->mi_row,
1141
0
                                          features->cur_frame_force_integer_mv)
1142
0
                         .as_int;
1143
0
      break;
1144
0
    }
1145
0
    case NEW_NEWMV: {
1146
0
      assert(is_compound);
1147
0
      for (int i = 0; i < 2; ++i) {
1148
0
        nmv_context *const nmvc = &ec_ctx->nmvc;
1149
0
        read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, nmvc, allow_hp);
1150
0
      }
1151
0
      break;
1152
0
    }
1153
0
    case NEAREST_NEARESTMV: {
1154
0
      assert(is_compound);
1155
0
      mv[0].as_int = nearest_mv[0].as_int;
1156
0
      mv[1].as_int = nearest_mv[1].as_int;
1157
0
      break;
1158
0
    }
1159
0
    case NEAR_NEARMV: {
1160
0
      assert(is_compound);
1161
0
      mv[0].as_int = near_mv[0].as_int;
1162
0
      mv[1].as_int = near_mv[1].as_int;
1163
0
      break;
1164
0
    }
1165
0
    case NEW_NEARESTMV: {
1166
0
      nmv_context *const nmvc = &ec_ctx->nmvc;
1167
0
      read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp);
1168
0
      assert(is_compound);
1169
0
      mv[1].as_int = nearest_mv[1].as_int;
1170
0
      break;
1171
0
    }
1172
0
    case NEAREST_NEWMV: {
1173
0
      nmv_context *const nmvc = &ec_ctx->nmvc;
1174
0
      mv[0].as_int = nearest_mv[0].as_int;
1175
0
      read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, allow_hp);
1176
0
      assert(is_compound);
1177
0
      break;
1178
0
    }
1179
0
    case NEAR_NEWMV: {
1180
0
      nmv_context *const nmvc = &ec_ctx->nmvc;
1181
0
      mv[0].as_int = near_mv[0].as_int;
1182
0
      read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, allow_hp);
1183
0
      assert(is_compound);
1184
0
      break;
1185
0
    }
1186
0
    case NEW_NEARMV: {
1187
0
      nmv_context *const nmvc = &ec_ctx->nmvc;
1188
0
      read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp);
1189
0
      assert(is_compound);
1190
0
      mv[1].as_int = near_mv[1].as_int;
1191
0
      break;
1192
0
    }
1193
0
    case GLOBAL_GLOBALMV: {
1194
0
      assert(is_compound);
1195
0
      mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
1196
0
                                          features->allow_high_precision_mv,
1197
0
                                          bsize, xd->mi_col, xd->mi_row,
1198
0
                                          features->cur_frame_force_integer_mv)
1199
0
                         .as_int;
1200
0
      mv[1].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[1]],
1201
0
                                          features->allow_high_precision_mv,
1202
0
                                          bsize, xd->mi_col, xd->mi_row,
1203
0
                                          features->cur_frame_force_integer_mv)
1204
0
                         .as_int;
1205
0
      break;
1206
0
    }
1207
0
    default: { return 0; }
1208
0
  }
1209
1210
0
  int ret = is_mv_valid(&mv[0].as_mv);
1211
0
  if (is_compound) {
1212
0
    ret = ret && is_mv_valid(&mv[1].as_mv);
1213
0
  }
1214
0
  return ret;
1215
0
}
1216
1217
static int read_is_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd,
1218
0
                               int segment_id, aom_reader *r) {
1219
0
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
1220
0
    const int frame = get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME);
1221
0
    if (frame < LAST_FRAME) return 0;
1222
0
    return frame != INTRA_FRAME;
1223
0
  }
1224
0
  if (segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
1225
0
    return 1;
1226
0
  }
1227
0
  const int ctx = av1_get_intra_inter_context(xd);
1228
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1229
0
  const int is_inter =
1230
0
      aom_read_symbol(r, ec_ctx->intra_inter_cdf[ctx], 2, ACCT_STR);
1231
0
  return is_inter;
1232
0
}
1233
1234
#if DEC_MISMATCH_DEBUG
1235
static void dec_dump_logs(AV1_COMMON *cm, MB_MODE_INFO *const mbmi, int mi_row,
1236
                          int mi_col, int16_t mode_ctx) {
1237
  int_mv mv[2] = { { 0 } };
1238
  for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref)
1239
    mv[ref].as_mv = mbmi->mv[ref].as_mv;
1240
1241
  const int16_t newmv_ctx = mode_ctx & NEWMV_CTX_MASK;
1242
  int16_t zeromv_ctx = -1;
1243
  int16_t refmv_ctx = -1;
1244
  if (mbmi->mode != NEWMV) {
1245
    zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
1246
    if (mbmi->mode != GLOBALMV)
1247
      refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
1248
  }
1249
1250
#define FRAME_TO_CHECK 11
1251
  if (cm->current_frame.frame_number == FRAME_TO_CHECK && cm->show_frame == 1) {
1252
    printf(
1253
        "=== DECODER ===: "
1254
        "Frame=%d, (mi_row,mi_col)=(%d,%d), skip_mode=%d, mode=%d, bsize=%d, "
1255
        "show_frame=%d, mv[0]=(%d,%d), mv[1]=(%d,%d), ref[0]=%d, "
1256
        "ref[1]=%d, motion_mode=%d, mode_ctx=%d, "
1257
        "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d, tx_size=%d\n",
1258
        cm->current_frame.frame_number, mi_row, mi_col, mbmi->skip_mode,
1259
        mbmi->mode, mbmi->sb_type, cm->show_frame, mv[0].as_mv.row,
1260
        mv[0].as_mv.col, mv[1].as_mv.row, mv[1].as_mv.col, mbmi->ref_frame[0],
1261
        mbmi->ref_frame[1], mbmi->motion_mode, mode_ctx, newmv_ctx, zeromv_ctx,
1262
        refmv_ctx, mbmi->tx_size);
1263
  }
1264
}
1265
#endif  // DEC_MISMATCH_DEBUG
1266
1267
static void read_inter_block_mode_info(AV1Decoder *const pbi,
1268
                                       DecoderCodingBlock *dcb,
1269
                                       MB_MODE_INFO *const mbmi,
1270
0
                                       aom_reader *r) {
1271
0
  AV1_COMMON *const cm = &pbi->common;
1272
0
  FeatureFlags *const features = &cm->features;
1273
0
  const BLOCK_SIZE bsize = mbmi->bsize;
1274
0
  const int allow_hp = features->allow_high_precision_mv;
1275
0
  int_mv nearestmv[2], nearmv[2];
1276
0
  int_mv ref_mvs[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES] = { { { 0 } } };
1277
0
  int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES];
1278
0
  int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
1279
0
  MACROBLOCKD *const xd = &dcb->xd;
1280
0
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1281
1282
0
  mbmi->uv_mode = UV_DC_PRED;
1283
0
  mbmi->palette_mode_info.palette_size[0] = 0;
1284
0
  mbmi->palette_mode_info.palette_size[1] = 0;
1285
1286
0
  av1_collect_neighbors_ref_counts(xd);
1287
1288
0
  read_ref_frames(cm, xd, r, mbmi->segment_id, mbmi->ref_frame);
1289
0
  const int is_compound = has_second_ref(mbmi);
1290
1291
0
  const MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame);
1292
0
  av1_find_mv_refs(cm, xd, mbmi, ref_frame, dcb->ref_mv_count, xd->ref_mv_stack,
1293
0
                   xd->weight, ref_mvs, /*global_mvs=*/NULL, inter_mode_ctx);
1294
1295
0
  mbmi->ref_mv_idx = 0;
1296
1297
0
  if (mbmi->skip_mode) {
1298
0
    assert(is_compound);
1299
0
    mbmi->mode = NEAREST_NEARESTMV;
1300
0
  } else {
1301
0
    if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP) ||
1302
0
        segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_GLOBALMV)) {
1303
0
      mbmi->mode = GLOBALMV;
1304
0
    } else {
1305
0
      const int mode_ctx =
1306
0
          av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame);
1307
0
      if (is_compound)
1308
0
        mbmi->mode = read_inter_compound_mode(xd, r, mode_ctx);
1309
0
      else
1310
0
        mbmi->mode = read_inter_mode(ec_ctx, r, mode_ctx);
1311
0
      if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV ||
1312
0
          have_nearmv_in_inter_mode(mbmi->mode))
1313
0
        read_drl_idx(ec_ctx, dcb, mbmi, r);
1314
0
    }
1315
0
  }
1316
1317
0
  if (is_compound != is_inter_compound_mode(mbmi->mode)) {
1318
0
    aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
1319
0
                       "Prediction mode %d invalid with ref frame %d %d",
1320
0
                       mbmi->mode, mbmi->ref_frame[0], mbmi->ref_frame[1]);
1321
0
  }
1322
1323
0
  if (!is_compound && mbmi->mode != GLOBALMV) {
1324
0
    av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[0]], &nearestmv[0],
1325
0
                          &nearmv[0], features->cur_frame_force_integer_mv);
1326
0
  }
1327
1328
0
  if (is_compound && mbmi->mode != GLOBAL_GLOBALMV) {
1329
0
    const int ref_mv_idx = mbmi->ref_mv_idx + 1;
1330
0
    nearestmv[0] = xd->ref_mv_stack[ref_frame][0].this_mv;
1331
0
    nearestmv[1] = xd->ref_mv_stack[ref_frame][0].comp_mv;
1332
0
    nearmv[0] = xd->ref_mv_stack[ref_frame][ref_mv_idx].this_mv;
1333
0
    nearmv[1] = xd->ref_mv_stack[ref_frame][ref_mv_idx].comp_mv;
1334
0
    lower_mv_precision(&nearestmv[0].as_mv, allow_hp,
1335
0
                       features->cur_frame_force_integer_mv);
1336
0
    lower_mv_precision(&nearestmv[1].as_mv, allow_hp,
1337
0
                       features->cur_frame_force_integer_mv);
1338
0
    lower_mv_precision(&nearmv[0].as_mv, allow_hp,
1339
0
                       features->cur_frame_force_integer_mv);
1340
0
    lower_mv_precision(&nearmv[1].as_mv, allow_hp,
1341
0
                       features->cur_frame_force_integer_mv);
1342
0
  } else if (mbmi->ref_mv_idx > 0 && mbmi->mode == NEARMV) {
1343
0
    nearmv[0] =
1344
0
        xd->ref_mv_stack[mbmi->ref_frame[0]][1 + mbmi->ref_mv_idx].this_mv;
1345
0
  }
1346
1347
0
  int_mv ref_mv[2] = { nearestmv[0], nearestmv[1] };
1348
1349
0
  if (is_compound) {
1350
0
    int ref_mv_idx = mbmi->ref_mv_idx;
1351
    // Special case: NEAR_NEWMV and NEW_NEARMV modes use
1352
    // 1 + mbmi->ref_mv_idx (like NEARMV) instead of
1353
    // mbmi->ref_mv_idx (like NEWMV)
1354
0
    if (mbmi->mode == NEAR_NEWMV || mbmi->mode == NEW_NEARMV)
1355
0
      ref_mv_idx = 1 + mbmi->ref_mv_idx;
1356
1357
    // TODO(jingning, yunqing): Do we need a lower_mv_precision() call here?
1358
0
    if (compound_ref0_mode(mbmi->mode) == NEWMV)
1359
0
      ref_mv[0] = xd->ref_mv_stack[ref_frame][ref_mv_idx].this_mv;
1360
1361
0
    if (compound_ref1_mode(mbmi->mode) == NEWMV)
1362
0
      ref_mv[1] = xd->ref_mv_stack[ref_frame][ref_mv_idx].comp_mv;
1363
0
  } else {
1364
0
    if (mbmi->mode == NEWMV) {
1365
0
      if (dcb->ref_mv_count[ref_frame] > 1)
1366
0
        ref_mv[0] = xd->ref_mv_stack[ref_frame][mbmi->ref_mv_idx].this_mv;
1367
0
    }
1368
0
  }
1369
1370
0
  if (mbmi->skip_mode) assert(mbmi->mode == NEAREST_NEARESTMV);
1371
1372
0
  const int mv_corrupted_flag =
1373
0
      !assign_mv(cm, xd, mbmi->mode, mbmi->ref_frame, mbmi->mv, ref_mv,
1374
0
                 nearestmv, nearmv, is_compound, allow_hp, r);
1375
0
  aom_merge_corrupted_flag(&dcb->corrupted, mv_corrupted_flag);
1376
1377
0
  mbmi->use_wedge_interintra = 0;
1378
0
  if (cm->seq_params->enable_interintra_compound && !mbmi->skip_mode &&
1379
0
      is_interintra_allowed(mbmi)) {
1380
0
    const int bsize_group = size_group_lookup[bsize];
1381
0
    const int interintra =
1382
0
        aom_read_symbol(r, ec_ctx->interintra_cdf[bsize_group], 2, ACCT_STR);
1383
0
    assert(mbmi->ref_frame[1] == NONE_FRAME);
1384
0
    if (interintra) {
1385
0
      const INTERINTRA_MODE interintra_mode =
1386
0
          read_interintra_mode(xd, r, bsize_group);
1387
0
      mbmi->ref_frame[1] = INTRA_FRAME;
1388
0
      mbmi->interintra_mode = interintra_mode;
1389
0
      mbmi->angle_delta[PLANE_TYPE_Y] = 0;
1390
0
      mbmi->angle_delta[PLANE_TYPE_UV] = 0;
1391
0
      mbmi->filter_intra_mode_info.use_filter_intra = 0;
1392
0
      if (av1_is_wedge_used(bsize)) {
1393
0
        mbmi->use_wedge_interintra = aom_read_symbol(
1394
0
            r, ec_ctx->wedge_interintra_cdf[bsize], 2, ACCT_STR);
1395
0
        if (mbmi->use_wedge_interintra) {
1396
0
          mbmi->interintra_wedge_index = (int8_t)aom_read_symbol(
1397
0
              r, ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES, ACCT_STR);
1398
0
        }
1399
0
      }
1400
0
    }
1401
0
  }
1402
1403
0
  for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
1404
0
    const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
1405
0
    xd->block_ref_scale_factors[ref] = get_ref_scale_factors_const(cm, frame);
1406
0
  }
1407
1408
0
  mbmi->motion_mode = SIMPLE_TRANSLATION;
1409
0
  if (is_motion_variation_allowed_bsize(mbmi->bsize) && !mbmi->skip_mode &&
1410
0
      !has_second_ref(mbmi)) {
1411
0
    mbmi->num_proj_ref = av1_findSamples(cm, xd, pts, pts_inref);
1412
0
  }
1413
0
  av1_count_overlappable_neighbors(cm, xd);
1414
1415
0
  if (mbmi->ref_frame[1] != INTRA_FRAME)
1416
0
    mbmi->motion_mode = read_motion_mode(cm, xd, mbmi, r);
1417
1418
  // init
1419
0
  mbmi->comp_group_idx = 0;
1420
0
  mbmi->compound_idx = 1;
1421
0
  mbmi->interinter_comp.type = COMPOUND_AVERAGE;
1422
1423
0
  if (has_second_ref(mbmi) && !mbmi->skip_mode) {
1424
    // Read idx to indicate current compound inter prediction mode group
1425
0
    const int masked_compound_used = is_any_masked_compound_used(bsize) &&
1426
0
                                     cm->seq_params->enable_masked_compound;
1427
1428
0
    if (masked_compound_used) {
1429
0
      const int ctx_comp_group_idx = get_comp_group_idx_context(xd);
1430
0
      mbmi->comp_group_idx = (uint8_t)aom_read_symbol(
1431
0
          r, ec_ctx->comp_group_idx_cdf[ctx_comp_group_idx], 2, ACCT_STR);
1432
0
    }
1433
1434
0
    if (mbmi->comp_group_idx == 0) {
1435
0
      if (cm->seq_params->order_hint_info.enable_dist_wtd_comp) {
1436
0
        const int comp_index_ctx = get_comp_index_context(cm, xd);
1437
0
        mbmi->compound_idx = (uint8_t)aom_read_symbol(
1438
0
            r, ec_ctx->compound_index_cdf[comp_index_ctx], 2, ACCT_STR);
1439
0
        mbmi->interinter_comp.type =
1440
0
            mbmi->compound_idx ? COMPOUND_AVERAGE : COMPOUND_DISTWTD;
1441
0
      } else {
1442
        // Distance-weighted compound is disabled, so always use average
1443
0
        mbmi->compound_idx = 1;
1444
0
        mbmi->interinter_comp.type = COMPOUND_AVERAGE;
1445
0
      }
1446
0
    } else {
1447
0
      assert(cm->current_frame.reference_mode != SINGLE_REFERENCE &&
1448
0
             is_inter_compound_mode(mbmi->mode) &&
1449
0
             mbmi->motion_mode == SIMPLE_TRANSLATION);
1450
0
      assert(masked_compound_used);
1451
1452
      // compound_diffwtd, wedge
1453
0
      if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) {
1454
0
        mbmi->interinter_comp.type =
1455
0
            COMPOUND_WEDGE + aom_read_symbol(r,
1456
0
                                             ec_ctx->compound_type_cdf[bsize],
1457
0
                                             MASKED_COMPOUND_TYPES, ACCT_STR);
1458
0
      } else {
1459
0
        mbmi->interinter_comp.type = COMPOUND_DIFFWTD;
1460
0
      }
1461
1462
0
      if (mbmi->interinter_comp.type == COMPOUND_WEDGE) {
1463
0
        assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize));
1464
0
        mbmi->interinter_comp.wedge_index = (int8_t)aom_read_symbol(
1465
0
            r, ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES, ACCT_STR);
1466
0
        mbmi->interinter_comp.wedge_sign = (int8_t)aom_read_bit(r, ACCT_STR);
1467
0
      } else {
1468
0
        assert(mbmi->interinter_comp.type == COMPOUND_DIFFWTD);
1469
0
        mbmi->interinter_comp.mask_type =
1470
0
            aom_read_literal(r, MAX_DIFFWTD_MASK_BITS, ACCT_STR);
1471
0
      }
1472
0
    }
1473
0
  }
1474
1475
0
  read_mb_interp_filter(xd, features->interp_filter,
1476
0
                        cm->seq_params->enable_dual_filter, mbmi, r);
1477
1478
0
#if !CONFIG_REALTIME_ONLY
1479
0
  if (mbmi->motion_mode == WARPED_CAUSAL) {
1480
0
    const int mi_row = xd->mi_row;
1481
0
    const int mi_col = xd->mi_col;
1482
0
    mbmi->wm_params.wmtype = DEFAULT_WMTYPE;
1483
0
    mbmi->wm_params.invalid = 0;
1484
1485
0
    if (mbmi->num_proj_ref > 1) {
1486
0
      mbmi->num_proj_ref = av1_selectSamples(&mbmi->mv[0].as_mv, pts, pts_inref,
1487
0
                                             mbmi->num_proj_ref, bsize);
1488
0
    }
1489
1490
0
    if (av1_find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize,
1491
0
                            mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col,
1492
0
                            &mbmi->wm_params, mi_row, mi_col)) {
1493
#if WARPED_MOTION_DEBUG
1494
      printf("Warning: unexpected warped model from aomenc\n");
1495
#endif
1496
0
      mbmi->wm_params.invalid = 1;
1497
0
    }
1498
0
  }
1499
0
#endif
1500
1501
0
  xd->cfl.store_y = store_cfl_required(cm, xd);
1502
1503
#if DEC_MISMATCH_DEBUG
1504
  dec_dump_logs(cm, mi, mi_row, mi_col, mode_ctx);
1505
#endif  // DEC_MISMATCH_DEBUG
1506
0
}
1507
1508
static void read_inter_frame_mode_info(AV1Decoder *const pbi,
1509
0
                                       DecoderCodingBlock *dcb, aom_reader *r) {
1510
0
  AV1_COMMON *const cm = &pbi->common;
1511
0
  MACROBLOCKD *const xd = &dcb->xd;
1512
0
  MB_MODE_INFO *const mbmi = xd->mi[0];
1513
0
  int inter_block = 1;
1514
1515
0
  mbmi->mv[0].as_int = 0;
1516
0
  mbmi->mv[1].as_int = 0;
1517
0
  mbmi->segment_id = read_inter_segment_id(cm, xd, 1, r);
1518
1519
0
  mbmi->skip_mode = read_skip_mode(cm, xd, mbmi->segment_id, r);
1520
1521
0
  if (mbmi->skip_mode)
1522
0
    mbmi->skip_txfm = 1;
1523
0
  else
1524
0
    mbmi->skip_txfm = read_skip_txfm(cm, xd, mbmi->segment_id, r);
1525
1526
0
  if (!cm->seg.segid_preskip)
1527
0
    mbmi->segment_id = read_inter_segment_id(cm, xd, 0, r);
1528
1529
0
  read_cdef(cm, r, xd);
1530
1531
0
  read_delta_q_params(cm, xd, r);
1532
1533
0
  if (!mbmi->skip_mode)
1534
0
    inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
1535
1536
0
  mbmi->current_qindex = xd->current_base_qindex;
1537
1538
0
  xd->above_txfm_context =
1539
0
      cm->above_contexts.txfm[xd->tile.tile_row] + xd->mi_col;
1540
0
  xd->left_txfm_context =
1541
0
      xd->left_txfm_context_buffer + (xd->mi_row & MAX_MIB_MASK);
1542
1543
0
  if (inter_block)
1544
0
    read_inter_block_mode_info(pbi, dcb, mbmi, r);
1545
0
  else
1546
0
    read_intra_block_mode_info(cm, xd, mbmi, r);
1547
0
}
1548
1549
static void intra_copy_frame_mvs(AV1_COMMON *const cm, int mi_row, int mi_col,
1550
0
                                 int x_mis, int y_mis) {
1551
0
  const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, 1);
1552
0
  MV_REF *frame_mvs =
1553
0
      cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1);
1554
0
  x_mis = ROUND_POWER_OF_TWO(x_mis, 1);
1555
0
  y_mis = ROUND_POWER_OF_TWO(y_mis, 1);
1556
1557
0
  for (int h = 0; h < y_mis; h++) {
1558
0
    MV_REF *mv = frame_mvs;
1559
0
    for (int w = 0; w < x_mis; w++) {
1560
0
      mv->ref_frame = NONE_FRAME;
1561
0
      mv++;
1562
0
    }
1563
0
    frame_mvs += frame_mvs_stride;
1564
0
  }
1565
0
}
1566
1567
void av1_read_mode_info(AV1Decoder *const pbi, DecoderCodingBlock *dcb,
1568
0
                        aom_reader *r, int x_mis, int y_mis) {
1569
0
  AV1_COMMON *const cm = &pbi->common;
1570
0
  MACROBLOCKD *const xd = &dcb->xd;
1571
0
  MB_MODE_INFO *const mi = xd->mi[0];
1572
0
  mi->use_intrabc = 0;
1573
1574
0
  if (frame_is_intra_only(cm)) {
1575
0
    read_intra_frame_mode_info(cm, dcb, r);
1576
0
    if (cm->seq_params->order_hint_info.enable_ref_frame_mvs)
1577
0
      intra_copy_frame_mvs(cm, xd->mi_row, xd->mi_col, x_mis, y_mis);
1578
0
  } else {
1579
0
    read_inter_frame_mode_info(pbi, dcb, r);
1580
0
    if (cm->seq_params->order_hint_info.enable_ref_frame_mvs)
1581
0
      av1_copy_frame_mvs(cm, mi, xd->mi_row, xd->mi_col, x_mis, y_mis);
1582
0
  }
1583
0
}