Line data Source code
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/common.h"
15 : #include "av1/common/entropy.h"
16 : #include "av1/common/entropymode.h"
17 : #include "av1/common/entropymv.h"
18 : #include "av1/common/mvref_common.h"
19 : #include "av1/common/pred_common.h"
20 : #include "av1/common/reconinter.h"
21 : #if CONFIG_EXT_INTRA
22 : #include "av1/common/reconintra.h"
23 : #endif // CONFIG_EXT_INTRA
24 : #include "av1/common/seg_common.h"
25 : #if CONFIG_WARPED_MOTION
26 : #include "av1/common/warped_motion.h"
27 : #endif // CONFIG_WARPED_MOTION
28 :
29 : #include "av1/decoder/decodeframe.h"
30 : #include "av1/decoder/decodemv.h"
31 :
32 : #include "aom_dsp/aom_dsp_common.h"
33 :
34 : #define ACCT_STR __func__
35 : #if CONFIG_EXT_INTRA || CONFIG_FILTER_INTRA || CONFIG_PALETTE
36 0 : static INLINE int read_uniform(aom_reader *r, int n) {
37 0 : const int l = get_unsigned_bits(n);
38 0 : const int m = (1 << l) - n;
39 0 : const int v = aom_read_literal(r, l - 1, ACCT_STR);
40 0 : assert(l != 0);
41 0 : if (v < m)
42 0 : return v;
43 : else
44 0 : return (v << 1) - m + aom_read_literal(r, 1, ACCT_STR);
45 : }
46 : #endif // CONFIG_EXT_INTRA || CONFIG_FILTER_INTRA || CONFIG_PALETTE
47 :
48 0 : static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) {
49 0 : return (PREDICTION_MODE)
50 0 : av1_intra_mode_inv[aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR)];
51 : }
52 :
53 : #if CONFIG_DELTA_Q
54 0 : static int read_delta_qindex(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r,
55 : MB_MODE_INFO *const mbmi, int mi_col, int mi_row) {
56 0 : FRAME_COUNTS *counts = xd->counts;
57 0 : int sign, abs, reduced_delta_qindex = 0;
58 0 : BLOCK_SIZE bsize = mbmi->sb_type;
59 0 : const int b_col = mi_col & MAX_MIB_MASK;
60 0 : const int b_row = mi_row & MAX_MIB_MASK;
61 0 : const int read_delta_q_flag = (b_col == 0 && b_row == 0);
62 : int rem_bits, thr;
63 : int i, smallval;
64 : #if CONFIG_EC_ADAPT
65 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
66 : (void)cm;
67 : #else
68 : FRAME_CONTEXT *ec_ctx = cm->fc;
69 : #endif
70 :
71 0 : if ((bsize != BLOCK_LARGEST || mbmi->skip == 0) && read_delta_q_flag) {
72 0 : abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
73 0 : smallval = (abs < DELTA_Q_SMALL);
74 0 : if (counts) {
75 0 : for (i = 0; i < abs; ++i) counts->delta_q[i][1]++;
76 0 : if (smallval) counts->delta_q[abs][0]++;
77 : }
78 :
79 0 : if (!smallval) {
80 0 : rem_bits = aom_read_literal(r, 3, ACCT_STR);
81 0 : thr = (1 << rem_bits) + 1;
82 0 : abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
83 : }
84 :
85 0 : if (abs) {
86 0 : sign = aom_read_bit(r, ACCT_STR);
87 : } else {
88 0 : sign = 1;
89 : }
90 :
91 0 : reduced_delta_qindex = sign ? -abs : abs;
92 : }
93 0 : return reduced_delta_qindex;
94 : }
95 : #if CONFIG_EXT_DELTA_Q
96 0 : static int read_delta_lflevel(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r,
97 : MB_MODE_INFO *const mbmi, int mi_col,
98 : int mi_row) {
99 0 : FRAME_COUNTS *counts = xd->counts;
100 0 : int sign, abs, reduced_delta_lflevel = 0;
101 0 : BLOCK_SIZE bsize = mbmi->sb_type;
102 0 : const int b_col = mi_col & MAX_MIB_MASK;
103 0 : const int b_row = mi_row & MAX_MIB_MASK;
104 0 : const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
105 : int rem_bits, thr;
106 : int i, smallval;
107 : #if CONFIG_EC_ADAPT
108 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
109 : (void)cm;
110 : #else
111 : FRAME_CONTEXT *ec_ctx = cm->fc;
112 : #endif
113 :
114 0 : if ((bsize != BLOCK_64X64 || mbmi->skip == 0) && read_delta_lf_flag) {
115 0 : abs =
116 0 : aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1, ACCT_STR);
117 0 : smallval = (abs < DELTA_LF_SMALL);
118 0 : if (counts) {
119 0 : for (i = 0; i < abs; ++i) counts->delta_lf[i][1]++;
120 0 : if (smallval) counts->delta_lf[abs][0]++;
121 : }
122 0 : if (!smallval) {
123 0 : rem_bits = aom_read_literal(r, 3, ACCT_STR);
124 0 : thr = (1 << rem_bits) + 1;
125 0 : abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr;
126 : }
127 :
128 0 : if (abs) {
129 0 : sign = aom_read_bit(r, ACCT_STR);
130 : } else {
131 0 : sign = 1;
132 : }
133 :
134 0 : reduced_delta_lflevel = sign ? -abs : abs;
135 : }
136 0 : return reduced_delta_lflevel;
137 : }
138 : #endif
139 : #endif
140 :
141 0 : static PREDICTION_MODE read_intra_mode_y(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
142 : aom_reader *r, int size_group) {
143 0 : const PREDICTION_MODE y_mode =
144 0 : read_intra_mode(r, ec_ctx->y_mode_cdf[size_group]);
145 0 : FRAME_COUNTS *counts = xd->counts;
146 0 : if (counts) ++counts->y_mode[size_group][y_mode];
147 0 : return y_mode;
148 : }
149 :
150 0 : static PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx,
151 : MACROBLOCKD *xd, aom_reader *r,
152 : PREDICTION_MODE y_mode) {
153 0 : const PREDICTION_MODE uv_mode =
154 0 : read_intra_mode(r, ec_ctx->uv_mode_cdf[y_mode]);
155 0 : FRAME_COUNTS *counts = xd->counts;
156 0 : if (counts) ++counts->uv_mode[y_mode][uv_mode];
157 0 : return uv_mode;
158 : }
159 :
160 : #if CONFIG_CFL
161 : static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r, int skip,
162 : CFL_SIGN_TYPE signs_out[CFL_PRED_PLANES]) {
163 : if (skip) {
164 : signs_out[CFL_PRED_U] = CFL_SIGN_POS;
165 : signs_out[CFL_PRED_V] = CFL_SIGN_POS;
166 : return 0;
167 : } else {
168 : const int ind = aom_read_symbol(r, ec_ctx->cfl_alpha_cdf, CFL_ALPHABET_SIZE,
169 : "cfl:alpha");
170 : // Signs are only coded for nonzero values
171 : // sign == 0 implies negative alpha
172 : // sign == 1 implies positive alpha
173 : signs_out[CFL_PRED_U] = cfl_alpha_codes[ind][CFL_PRED_U]
174 : ? aom_read_bit(r, "cfl:sign")
175 : : CFL_SIGN_POS;
176 : signs_out[CFL_PRED_V] = cfl_alpha_codes[ind][CFL_PRED_V]
177 : ? aom_read_bit(r, "cfl:sign")
178 : : CFL_SIGN_POS;
179 :
180 : return ind;
181 : }
182 : }
183 : #endif
184 :
185 : #if CONFIG_EXT_INTER && CONFIG_INTERINTRA
186 0 : static INTERINTRA_MODE read_interintra_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
187 : aom_reader *r, int size_group) {
188 0 : const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_tree(
189 : r, av1_interintra_mode_tree, cm->fc->interintra_mode_prob[size_group],
190 : ACCT_STR);
191 0 : FRAME_COUNTS *counts = xd->counts;
192 0 : if (counts) ++counts->interintra_mode[size_group][ii_mode];
193 0 : return ii_mode;
194 : }
195 : #endif // CONFIG_EXT_INTER && CONFIG_INTERINTRA
196 :
197 0 : static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd,
198 : aom_reader *r, int16_t ctx) {
199 0 : FRAME_COUNTS *counts = xd->counts;
200 0 : int16_t mode_ctx = ctx & NEWMV_CTX_MASK;
201 0 : aom_prob mode_prob = ec_ctx->newmv_prob[mode_ctx];
202 :
203 0 : if (aom_read(r, mode_prob, ACCT_STR) == 0) {
204 0 : if (counts) ++counts->newmv_mode[mode_ctx][0];
205 0 : return NEWMV;
206 : }
207 0 : if (counts) ++counts->newmv_mode[mode_ctx][1];
208 :
209 0 : if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return ZEROMV;
210 :
211 0 : mode_ctx = (ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
212 :
213 0 : mode_prob = ec_ctx->zeromv_prob[mode_ctx];
214 0 : if (aom_read(r, mode_prob, ACCT_STR) == 0) {
215 0 : if (counts) ++counts->zeromv_mode[mode_ctx][0];
216 0 : return ZEROMV;
217 : }
218 0 : if (counts) ++counts->zeromv_mode[mode_ctx][1];
219 :
220 0 : mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
221 :
222 0 : if (ctx & (1 << SKIP_NEARESTMV_OFFSET)) mode_ctx = 6;
223 0 : if (ctx & (1 << SKIP_NEARMV_OFFSET)) mode_ctx = 7;
224 0 : if (ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) mode_ctx = 8;
225 :
226 0 : mode_prob = ec_ctx->refmv_prob[mode_ctx];
227 :
228 0 : if (aom_read(r, mode_prob, ACCT_STR) == 0) {
229 0 : if (counts) ++counts->refmv_mode[mode_ctx][0];
230 :
231 0 : return NEARESTMV;
232 : } else {
233 0 : if (counts) ++counts->refmv_mode[mode_ctx][1];
234 0 : return NEARMV;
235 : }
236 :
237 : // Invalid prediction mode.
238 : assert(0);
239 : }
240 :
241 0 : static void read_drl_idx(const AV1_COMMON *cm, MACROBLOCKD *xd,
242 : MB_MODE_INFO *mbmi, aom_reader *r) {
243 0 : uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
244 0 : mbmi->ref_mv_idx = 0;
245 :
246 : #if CONFIG_EXT_INTER
247 0 : if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) {
248 : #else
249 : if (mbmi->mode == NEWMV) {
250 : #endif
251 : int idx;
252 0 : for (idx = 0; idx < 2; ++idx) {
253 0 : if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
254 0 : uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
255 0 : aom_prob drl_prob = cm->fc->drl_prob[drl_ctx];
256 0 : if (!aom_read(r, drl_prob, ACCT_STR)) {
257 0 : mbmi->ref_mv_idx = idx;
258 0 : if (xd->counts) ++xd->counts->drl_mode[drl_ctx][0];
259 0 : return;
260 : }
261 0 : mbmi->ref_mv_idx = idx + 1;
262 0 : if (xd->counts) ++xd->counts->drl_mode[drl_ctx][1];
263 : }
264 : }
265 : }
266 :
267 0 : if (have_nearmv_in_inter_mode(mbmi->mode)) {
268 : int idx;
269 : // Offset the NEARESTMV mode.
270 : // TODO(jingning): Unify the two syntax decoding loops after the NEARESTMV
271 : // mode is factored in.
272 0 : for (idx = 1; idx < 3; ++idx) {
273 0 : if (xd->ref_mv_count[ref_frame_type] > idx + 1) {
274 0 : uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx);
275 0 : aom_prob drl_prob = cm->fc->drl_prob[drl_ctx];
276 0 : if (!aom_read(r, drl_prob, ACCT_STR)) {
277 0 : mbmi->ref_mv_idx = idx - 1;
278 0 : if (xd->counts) ++xd->counts->drl_mode[drl_ctx][0];
279 0 : return;
280 : }
281 0 : mbmi->ref_mv_idx = idx;
282 0 : if (xd->counts) ++xd->counts->drl_mode[drl_ctx][1];
283 : }
284 : }
285 : }
286 : }
287 :
288 : #if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
289 0 : static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
290 : MODE_INFO *mi, aom_reader *r) {
291 0 : MB_MODE_INFO *mbmi = &mi->mbmi;
292 0 : const MOTION_MODE last_motion_mode_allowed = motion_mode_allowed(
293 : #if CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
294 0 : 0, xd->global_motion,
295 : #endif // CONFIG_GLOBAL_MOTION && SEPARATE_GLOBAL_MOTION
296 : mi);
297 : int motion_mode;
298 0 : FRAME_COUNTS *counts = xd->counts;
299 :
300 0 : if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION;
301 : #if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
302 0 : if (last_motion_mode_allowed == OBMC_CAUSAL) {
303 0 : motion_mode = aom_read(r, cm->fc->obmc_prob[mbmi->sb_type], ACCT_STR);
304 0 : if (counts) ++counts->obmc[mbmi->sb_type][motion_mode];
305 0 : return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
306 : } else {
307 : #endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
308 0 : motion_mode =
309 0 : aom_read_tree(r, av1_motion_mode_tree,
310 : cm->fc->motion_mode_prob[mbmi->sb_type], ACCT_STR);
311 0 : if (counts) ++counts->motion_mode[mbmi->sb_type][motion_mode];
312 0 : return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode);
313 : #if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
314 : }
315 : #endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
316 : }
317 : #endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
318 :
319 : #if CONFIG_EXT_INTER
320 0 : static PREDICTION_MODE read_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd,
321 : aom_reader *r, int16_t ctx) {
322 0 : const int mode =
323 0 : aom_read_tree(r, av1_inter_compound_mode_tree,
324 : cm->fc->inter_compound_mode_probs[ctx], ACCT_STR);
325 0 : FRAME_COUNTS *counts = xd->counts;
326 :
327 0 : if (counts) ++counts->inter_compound_mode[ctx][mode];
328 :
329 0 : assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode));
330 0 : return NEAREST_NEARESTMV + mode;
331 : }
332 : #endif // CONFIG_EXT_INTER
333 :
334 0 : static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) {
335 0 : return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
336 : }
337 :
338 : #if CONFIG_VAR_TX
339 0 : static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
340 : MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
341 : TX_SIZE tx_size, int depth, int blk_row,
342 : int blk_col, aom_reader *r) {
343 0 : int is_split = 0;
344 0 : const int tx_row = blk_row >> 1;
345 0 : const int tx_col = blk_col >> 1;
346 0 : const int max_blocks_high = max_block_high(xd, mbmi->sb_type, 0);
347 0 : const int max_blocks_wide = max_block_wide(xd, mbmi->sb_type, 0);
348 0 : int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
349 0 : xd->left_txfm_context + blk_row,
350 0 : mbmi->sb_type, tx_size);
351 0 : TX_SIZE(*const inter_tx_size)
352 : [MAX_MIB_SIZE] =
353 : (TX_SIZE(*)[MAX_MIB_SIZE]) & mbmi->inter_tx_size[tx_row][tx_col];
354 0 : if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
355 :
356 0 : if (depth == MAX_VARTX_DEPTH) {
357 : int idx, idy;
358 0 : inter_tx_size[0][0] = tx_size;
359 0 : for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
360 0 : for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
361 0 : inter_tx_size[idy][idx] = tx_size;
362 0 : mbmi->tx_size = tx_size;
363 0 : mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
364 0 : if (counts) ++counts->txfm_partition[ctx][0];
365 0 : txfm_partition_update(xd->above_txfm_context + blk_col,
366 0 : xd->left_txfm_context + blk_row, tx_size, tx_size);
367 0 : return;
368 : }
369 :
370 0 : is_split = aom_read(r, cm->fc->txfm_partition_prob[ctx], ACCT_STR);
371 :
372 0 : if (is_split) {
373 0 : const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
374 0 : const int bsl = tx_size_wide_unit[sub_txs];
375 : int i;
376 :
377 0 : if (counts) ++counts->txfm_partition[ctx][1];
378 :
379 0 : if (tx_size == TX_8X8) {
380 : int idx, idy;
381 0 : inter_tx_size[0][0] = sub_txs;
382 0 : for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
383 0 : for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
384 0 : inter_tx_size[idy][idx] = inter_tx_size[0][0];
385 0 : mbmi->tx_size = sub_txs;
386 0 : mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
387 0 : txfm_partition_update(xd->above_txfm_context + blk_col,
388 0 : xd->left_txfm_context + blk_row, sub_txs, tx_size);
389 0 : return;
390 : }
391 :
392 0 : assert(bsl > 0);
393 0 : for (i = 0; i < 4; ++i) {
394 0 : int offsetr = blk_row + (i >> 1) * bsl;
395 0 : int offsetc = blk_col + (i & 0x01) * bsl;
396 0 : read_tx_size_vartx(cm, xd, mbmi, counts, sub_txs, depth + 1, offsetr,
397 : offsetc, r);
398 : }
399 : } else {
400 : int idx, idy;
401 0 : inter_tx_size[0][0] = tx_size;
402 0 : for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy)
403 0 : for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx)
404 0 : inter_tx_size[idy][idx] = tx_size;
405 0 : mbmi->tx_size = tx_size;
406 0 : mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size));
407 0 : if (counts) ++counts->txfm_partition[ctx][0];
408 0 : txfm_partition_update(xd->above_txfm_context + blk_col,
409 0 : xd->left_txfm_context + blk_row, tx_size, tx_size);
410 : }
411 : }
412 : #endif
413 :
414 0 : static TX_SIZE read_selected_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd,
415 : int tx_size_cat, aom_reader *r) {
416 0 : FRAME_COUNTS *counts = xd->counts;
417 0 : const int ctx = get_tx_size_context(xd);
418 : #if CONFIG_EC_ADAPT
419 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
420 : (void)cm;
421 : #else
422 : FRAME_CONTEXT *ec_ctx = cm->fc;
423 : #endif
424 :
425 0 : const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
426 : tx_size_cat + 2, ACCT_STR);
427 0 : const TX_SIZE tx_size = depth_to_tx_size(depth);
428 : #if CONFIG_RECT_TX
429 0 : assert(!is_rect_tx(tx_size));
430 : #endif // CONFIG_RECT_TX
431 0 : if (counts) ++counts->tx_size[tx_size_cat][ctx][depth];
432 0 : return tx_size;
433 : }
434 :
435 0 : static TX_SIZE read_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd, int is_inter,
436 : int allow_select_inter, aom_reader *r) {
437 0 : const TX_MODE tx_mode = cm->tx_mode;
438 0 : const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
439 0 : if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4;
440 : #if CONFIG_CB4X4 && (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
441 0 : if (bsize > BLOCK_4X4) {
442 : #else
443 : if (bsize >= BLOCK_8X8) {
444 : #endif // CONFIG_CB4X4 && CONFIG_VAR_TX
445 0 : if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) {
446 0 : const int32_t tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize]
447 0 : : intra_tx_size_cat_lookup[bsize];
448 0 : const TX_SIZE coded_tx_size =
449 : read_selected_tx_size(cm, xd, tx_size_cat, r);
450 : #if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
451 0 : if (coded_tx_size > max_txsize_lookup[bsize]) {
452 0 : assert(coded_tx_size == max_txsize_lookup[bsize] + 1);
453 : #if CONFIG_EXT_TX && CONFIG_RECT_TX_EXT
454 : if (is_quarter_tx_allowed(xd, &xd->mi[0]->mbmi, is_inter)) {
455 : int quarter_tx = aom_read(r, cm->fc->quarter_tx_size_prob, ACCT_STR);
456 : FRAME_COUNTS *counts = xd->counts;
457 :
458 : if (counts) ++counts->quarter_tx_size[quarter_tx];
459 : return quarter_tx ? quarter_txsize_lookup[bsize]
460 : : max_txsize_rect_lookup[bsize];
461 : }
462 : #endif // CONFIG_EXT_TX && CONFIG_RECT_TX_EXT
463 :
464 0 : return max_txsize_rect_lookup[bsize];
465 : }
466 : #else
467 : assert(coded_tx_size <= max_txsize_lookup[bsize]);
468 : #endif // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
469 0 : return coded_tx_size;
470 : } else {
471 0 : return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
472 : }
473 : } else {
474 : #if CONFIG_EXT_TX && CONFIG_RECT_TX
475 0 : assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
476 0 : return max_txsize_rect_lookup[bsize];
477 : #else
478 : return TX_4X4;
479 : #endif // CONFIG_EXT_TX && CONFIG_RECT_TX
480 : }
481 : }
482 :
483 0 : static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids,
484 : int mi_offset, int x_mis, int y_mis) {
485 0 : int x, y, segment_id = INT_MAX;
486 :
487 0 : for (y = 0; y < y_mis; y++)
488 0 : for (x = 0; x < x_mis; x++)
489 0 : segment_id =
490 0 : AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]);
491 :
492 0 : assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
493 0 : return segment_id;
494 : }
495 :
496 0 : static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis,
497 : int segment_id) {
498 : int x, y;
499 :
500 0 : assert(segment_id >= 0 && segment_id < MAX_SEGMENTS);
501 :
502 0 : for (y = 0; y < y_mis; y++)
503 0 : for (x = 0; x < x_mis; x++)
504 0 : cm->current_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id;
505 0 : }
506 :
507 0 : static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
508 : int mi_offset, int x_mis, int y_mis,
509 : aom_reader *r) {
510 0 : struct segmentation *const seg = &cm->seg;
511 0 : FRAME_COUNTS *counts = xd->counts;
512 0 : struct segmentation_probs *const segp = &cm->fc->seg;
513 : int segment_id;
514 :
515 0 : if (!seg->enabled) return 0; // Default for disabled segmentation
516 :
517 0 : assert(seg->update_map && !seg->temporal_update);
518 :
519 0 : segment_id = read_segment_id(r, segp);
520 0 : if (counts) ++counts->seg.tree_total[segment_id];
521 0 : set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
522 0 : return segment_id;
523 : }
524 :
525 0 : static void copy_segment_id(const AV1_COMMON *cm,
526 : const uint8_t *last_segment_ids,
527 : uint8_t *current_segment_ids, int mi_offset,
528 : int x_mis, int y_mis) {
529 : int x, y;
530 :
531 0 : for (y = 0; y < y_mis; y++)
532 0 : for (x = 0; x < x_mis; x++)
533 0 : current_segment_ids[mi_offset + y * cm->mi_cols + x] =
534 0 : last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x]
535 : : 0;
536 0 : }
537 :
538 0 : static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd,
539 : int mi_row, int mi_col, aom_reader *r) {
540 0 : struct segmentation *const seg = &cm->seg;
541 0 : FRAME_COUNTS *counts = xd->counts;
542 0 : struct segmentation_probs *const segp = &cm->fc->seg;
543 0 : MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
544 : int predicted_segment_id, segment_id;
545 0 : const int mi_offset = mi_row * cm->mi_cols + mi_col;
546 0 : const int bw = mi_size_wide[mbmi->sb_type];
547 0 : const int bh = mi_size_high[mbmi->sb_type];
548 :
549 : // TODO(slavarnway): move x_mis, y_mis into xd ?????
550 0 : const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw);
551 0 : const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh);
552 :
553 0 : if (!seg->enabled) return 0; // Default for disabled segmentation
554 :
555 0 : predicted_segment_id = cm->last_frame_seg_map
556 0 : ? dec_get_segment_id(cm, cm->last_frame_seg_map,
557 : mi_offset, x_mis, y_mis)
558 0 : : 0;
559 :
560 0 : if (!seg->update_map) {
561 0 : copy_segment_id(cm, cm->last_frame_seg_map, cm->current_frame_seg_map,
562 : mi_offset, x_mis, y_mis);
563 0 : return predicted_segment_id;
564 : }
565 :
566 0 : if (seg->temporal_update) {
567 0 : const int ctx = av1_get_pred_context_seg_id(xd);
568 0 : const aom_prob pred_prob = segp->pred_probs[ctx];
569 0 : mbmi->seg_id_predicted = aom_read(r, pred_prob, ACCT_STR);
570 0 : if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted];
571 0 : if (mbmi->seg_id_predicted) {
572 0 : segment_id = predicted_segment_id;
573 : } else {
574 0 : segment_id = read_segment_id(r, segp);
575 0 : if (counts) ++counts->seg.tree_mispred[segment_id];
576 : }
577 : } else {
578 0 : segment_id = read_segment_id(r, segp);
579 0 : if (counts) ++counts->seg.tree_total[segment_id];
580 : }
581 0 : set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id);
582 0 : return segment_id;
583 : }
584 :
585 0 : static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id,
586 : aom_reader *r) {
587 0 : if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
588 0 : return 1;
589 : } else {
590 0 : const int ctx = av1_get_skip_context(xd);
591 0 : const int skip = aom_read(r, cm->fc->skip_probs[ctx], ACCT_STR);
592 0 : FRAME_COUNTS *counts = xd->counts;
593 0 : if (counts) ++counts->skip[ctx][skip];
594 0 : return skip;
595 : }
596 : }
597 :
598 : #if CONFIG_PALETTE
599 : #if CONFIG_PALETTE_DELTA_ENCODING
600 : static int uint16_compare(const void *a, const void *b) {
601 : const uint16_t va = *(const uint16_t *)a;
602 : const uint16_t vb = *(const uint16_t *)b;
603 : return va - vb;
604 : }
605 :
606 : static void read_palette_colors_y(MACROBLOCKD *const xd, int bit_depth,
607 : PALETTE_MODE_INFO *const pmi, aom_reader *r) {
608 : uint16_t color_cache[2 * PALETTE_MAX_SIZE];
609 : const MODE_INFO *const above_mi = xd->above_mi;
610 : const MODE_INFO *const left_mi = xd->left_mi;
611 : const int n_cache = av1_get_palette_cache(above_mi, left_mi, 0, color_cache);
612 : const int n = pmi->palette_size[0];
613 : int idx = 0;
614 : for (int i = 0; i < n_cache && idx < n; ++i)
615 : if (aom_read_bit(r, ACCT_STR)) pmi->palette_colors[idx++] = color_cache[i];
616 : if (idx < n) {
617 : pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
618 : if (idx < n) {
619 : const int min_bits = bit_depth - 3;
620 : int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
621 : int range = (1 << bit_depth) - pmi->palette_colors[idx - 1] - 1;
622 : for (; idx < n; ++idx) {
623 : const int delta = aom_read_literal(r, bits, ACCT_STR) + 1;
624 : pmi->palette_colors[idx] = pmi->palette_colors[idx - 1] + delta;
625 : range -= delta;
626 : bits = AOMMIN(bits, av1_ceil_log2(range));
627 : }
628 : }
629 : }
630 : qsort(pmi->palette_colors, n, sizeof(pmi->palette_colors[0]), uint16_compare);
631 : }
632 :
633 : static void read_palette_colors_uv(MACROBLOCKD *const xd, int bit_depth,
634 : PALETTE_MODE_INFO *const pmi,
635 : aom_reader *r) {
636 : const int n = pmi->palette_size[1];
637 : // U channel colors.
638 : uint16_t color_cache[2 * PALETTE_MAX_SIZE];
639 : const MODE_INFO *const above_mi = xd->above_mi;
640 : const MODE_INFO *const left_mi = xd->left_mi;
641 : const int n_cache = av1_get_palette_cache(above_mi, left_mi, 1, color_cache);
642 : int idx = PALETTE_MAX_SIZE;
643 : for (int i = 0; i < n_cache && idx < PALETTE_MAX_SIZE + n; ++i)
644 : if (aom_read_bit(r, ACCT_STR)) pmi->palette_colors[idx++] = color_cache[i];
645 : if (idx < PALETTE_MAX_SIZE + n) {
646 : pmi->palette_colors[idx++] = aom_read_literal(r, bit_depth, ACCT_STR);
647 : if (idx < PALETTE_MAX_SIZE + n) {
648 : const int min_bits = bit_depth - 3;
649 : int bits = min_bits + aom_read_literal(r, 2, ACCT_STR);
650 : int range = (1 << bit_depth) - pmi->palette_colors[idx - 1];
651 : for (; idx < PALETTE_MAX_SIZE + n; ++idx) {
652 : const int delta = aom_read_literal(r, bits, ACCT_STR);
653 : pmi->palette_colors[idx] = pmi->palette_colors[idx - 1] + delta;
654 : range -= delta;
655 : bits = AOMMIN(bits, av1_ceil_log2(range));
656 : }
657 : }
658 : }
659 : qsort(pmi->palette_colors + PALETTE_MAX_SIZE, n,
660 : sizeof(pmi->palette_colors[0]), uint16_compare);
661 :
662 : // V channel colors.
663 : if (aom_read_bit(r, ACCT_STR)) { // Delta encoding.
664 : const int min_bits_v = bit_depth - 4;
665 : const int max_val = 1 << bit_depth;
666 : int bits = min_bits_v + aom_read_literal(r, 2, ACCT_STR);
667 : pmi->palette_colors[2 * PALETTE_MAX_SIZE] =
668 : aom_read_literal(r, bit_depth, ACCT_STR);
669 : for (int i = 1; i < n; ++i) {
670 : int delta = aom_read_literal(r, bits, ACCT_STR);
671 : if (delta && aom_read_bit(r, ACCT_STR)) delta = -delta;
672 : int val = (int)pmi->palette_colors[2 * PALETTE_MAX_SIZE + i - 1] + delta;
673 : if (val < 0) val += max_val;
674 : if (val >= max_val) val -= max_val;
675 : pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] = val;
676 : }
677 : } else {
678 : for (int i = 0; i < n; ++i) {
679 : pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
680 : aom_read_literal(r, bit_depth, ACCT_STR);
681 : }
682 : }
683 : }
684 : #endif // CONFIG_PALETTE_DELTA_ENCODING
685 :
686 0 : static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
687 : aom_reader *r) {
688 0 : MODE_INFO *const mi = xd->mi[0];
689 0 : MB_MODE_INFO *const mbmi = &mi->mbmi;
690 0 : const MODE_INFO *const above_mi = xd->above_mi;
691 0 : const MODE_INFO *const left_mi = xd->left_mi;
692 0 : const BLOCK_SIZE bsize = mbmi->sb_type;
693 : int n;
694 0 : PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
695 :
696 0 : if (mbmi->mode == DC_PRED) {
697 0 : int palette_y_mode_ctx = 0;
698 0 : if (above_mi)
699 0 : palette_y_mode_ctx +=
700 0 : (above_mi->mbmi.palette_mode_info.palette_size[0] > 0);
701 0 : if (left_mi)
702 0 : palette_y_mode_ctx +=
703 0 : (left_mi->mbmi.palette_mode_info.palette_size[0] > 0);
704 0 : if (aom_read(r, av1_default_palette_y_mode_prob[bsize - BLOCK_8X8]
705 : [palette_y_mode_ctx],
706 : ACCT_STR)) {
707 0 : pmi->palette_size[0] =
708 0 : aom_read_tree(r, av1_palette_size_tree,
709 : av1_default_palette_y_size_prob[bsize - BLOCK_8X8],
710 0 : ACCT_STR) +
711 : 2;
712 0 : n = pmi->palette_size[0];
713 : #if CONFIG_PALETTE_DELTA_ENCODING
714 : read_palette_colors_y(xd, cm->bit_depth, pmi, r);
715 : #else
716 : int i;
717 0 : for (i = 0; i < n; ++i)
718 0 : pmi->palette_colors[i] = aom_read_literal(r, cm->bit_depth, ACCT_STR);
719 : #endif // CONFIG_PALETTE_DELTA_ENCODING
720 0 : xd->plane[0].color_index_map[0] = read_uniform(r, n);
721 0 : assert(xd->plane[0].color_index_map[0] < n);
722 : }
723 : }
724 :
725 0 : if (mbmi->uv_mode == DC_PRED) {
726 0 : const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
727 0 : if (aom_read(r, av1_default_palette_uv_mode_prob[palette_uv_mode_ctx],
728 : ACCT_STR)) {
729 0 : pmi->palette_size[1] =
730 0 : aom_read_tree(r, av1_palette_size_tree,
731 : av1_default_palette_uv_size_prob[bsize - BLOCK_8X8],
732 0 : ACCT_STR) +
733 : 2;
734 0 : n = pmi->palette_size[1];
735 : #if CONFIG_PALETTE_DELTA_ENCODING
736 : read_palette_colors_uv(xd, cm->bit_depth, pmi, r);
737 : #else
738 : int i;
739 0 : for (i = 0; i < n; ++i) {
740 0 : pmi->palette_colors[PALETTE_MAX_SIZE + i] =
741 0 : aom_read_literal(r, cm->bit_depth, ACCT_STR);
742 0 : pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] =
743 0 : aom_read_literal(r, cm->bit_depth, ACCT_STR);
744 : }
745 : #endif // CONFIG_PALETTE_DELTA_ENCODING
746 0 : xd->plane[1].color_index_map[0] = read_uniform(r, n);
747 0 : assert(xd->plane[1].color_index_map[0] < n);
748 : }
749 : }
750 0 : }
751 : #endif // CONFIG_PALETTE
752 :
753 : #if CONFIG_FILTER_INTRA
754 : static void read_filter_intra_mode_info(AV1_COMMON *const cm,
755 : MACROBLOCKD *const xd, int mi_row,
756 : int mi_col, aom_reader *r) {
757 : MODE_INFO *const mi = xd->mi[0];
758 : MB_MODE_INFO *const mbmi = &mi->mbmi;
759 : FRAME_COUNTS *counts = xd->counts;
760 : FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
761 : &mbmi->filter_intra_mode_info;
762 :
763 : if (mbmi->mode == DC_PRED
764 : #if CONFIG_PALETTE
765 : && mbmi->palette_mode_info.palette_size[0] == 0
766 : #endif // CONFIG_PALETTE
767 : ) {
768 : filter_intra_mode_info->use_filter_intra_mode[0] =
769 : aom_read(r, cm->fc->filter_intra_probs[0], ACCT_STR);
770 : if (filter_intra_mode_info->use_filter_intra_mode[0]) {
771 : filter_intra_mode_info->filter_intra_mode[0] =
772 : read_uniform(r, FILTER_INTRA_MODES);
773 : }
774 : if (counts) {
775 : ++counts
776 : ->filter_intra[0][filter_intra_mode_info->use_filter_intra_mode[0]];
777 : }
778 : }
779 :
780 : #if CONFIG_CB4X4
781 : if (!is_chroma_reference(mi_row, mi_col, mbmi->sb_type,
782 : xd->plane[1].subsampling_x,
783 : xd->plane[1].subsampling_y))
784 : return;
785 : #else
786 : (void)mi_row;
787 : (void)mi_col;
788 : #endif // CONFIG_CB4X4
789 :
790 : if (mbmi->uv_mode == DC_PRED
791 : #if CONFIG_PALETTE
792 : && mbmi->palette_mode_info.palette_size[1] == 0
793 : #endif // CONFIG_PALETTE
794 : ) {
795 : filter_intra_mode_info->use_filter_intra_mode[1] =
796 : aom_read(r, cm->fc->filter_intra_probs[1], ACCT_STR);
797 : if (filter_intra_mode_info->use_filter_intra_mode[1]) {
798 : filter_intra_mode_info->filter_intra_mode[1] =
799 : read_uniform(r, FILTER_INTRA_MODES);
800 : }
801 : if (counts) {
802 : ++counts
803 : ->filter_intra[1][filter_intra_mode_info->use_filter_intra_mode[1]];
804 : }
805 : }
806 : }
807 : #endif // CONFIG_FILTER_INTRA
808 :
809 : #if CONFIG_EXT_INTRA
810 0 : static void read_intra_angle_info(AV1_COMMON *const cm, MACROBLOCKD *const xd,
811 : aom_reader *r) {
812 0 : MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
813 0 : const BLOCK_SIZE bsize = mbmi->sb_type;
814 : #if CONFIG_INTRA_INTERP
815 : #if CONFIG_EC_ADAPT
816 : FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
817 : #else
818 : FRAME_CONTEXT *const ec_ctx = cm->fc;
819 : #endif // CONFIG_EC_ADAPT
820 : const int ctx = av1_get_pred_context_intra_interp(xd);
821 : int p_angle;
822 : #endif // CONFIG_INTRA_INTERP
823 :
824 : (void)cm;
825 0 : if (bsize < BLOCK_8X8) return;
826 :
827 0 : if (av1_is_directional_mode(mbmi->mode, bsize)) {
828 0 : mbmi->angle_delta[0] =
829 0 : read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
830 : #if CONFIG_INTRA_INTERP
831 : p_angle = mode_to_angle_map[mbmi->mode] + mbmi->angle_delta[0] * ANGLE_STEP;
832 : if (av1_is_intra_filter_switchable(p_angle)) {
833 : FRAME_COUNTS *counts = xd->counts;
834 : mbmi->intra_filter = aom_read_symbol(r, ec_ctx->intra_filter_cdf[ctx],
835 : INTRA_FILTERS, ACCT_STR);
836 : if (counts) ++counts->intra_filter[ctx][mbmi->intra_filter];
837 : } else {
838 : mbmi->intra_filter = INTRA_FILTER_LINEAR;
839 : }
840 : #endif // CONFIG_INTRA_INTERP
841 : }
842 :
843 0 : if (av1_is_directional_mode(mbmi->uv_mode, bsize)) {
844 0 : mbmi->angle_delta[1] =
845 0 : read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA;
846 : }
847 : }
848 : #endif // CONFIG_EXT_INTRA
849 :
850 0 : void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd,
851 : #if CONFIG_SUPERTX
852 : int supertx_enabled,
853 : #endif
854 : #if CONFIG_TXK_SEL
855 : int block, int plane,
856 : #endif
857 : aom_reader *r) {
858 0 : MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
859 0 : const int inter_block = is_inter_block(mbmi);
860 : #if CONFIG_VAR_TX
861 0 : const TX_SIZE tx_size = inter_block ? mbmi->min_tx_size : mbmi->tx_size;
862 : #else
863 : const TX_SIZE tx_size = mbmi->tx_size;
864 : #endif
865 : #if CONFIG_EC_ADAPT
866 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
867 : #else
868 : FRAME_CONTEXT *ec_ctx = cm->fc;
869 : #endif
870 :
871 : #if !CONFIG_TXK_SEL
872 0 : TX_TYPE *tx_type = &mbmi->tx_type;
873 : #else
874 : // only y plane's tx_type is transmitted
875 : if (plane > 0) return;
876 : TX_TYPE *tx_type = &mbmi->txk_type[block];
877 : #endif
878 :
879 : if (!FIXED_TX_TYPE) {
880 : #if CONFIG_EXT_TX
881 0 : const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
882 0 : if (get_ext_tx_types(tx_size, mbmi->sb_type, inter_block,
883 0 : cm->reduced_tx_set_used) > 1 &&
884 0 : ((!cm->seg.enabled && cm->base_qindex > 0) ||
885 0 : (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
886 0 : !mbmi->skip &&
887 : #if CONFIG_SUPERTX
888 : !supertx_enabled &&
889 : #endif // CONFIG_SUPERTX
890 0 : !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
891 0 : const int eset = get_ext_tx_set(tx_size, mbmi->sb_type, inter_block,
892 : cm->reduced_tx_set_used);
893 0 : FRAME_COUNTS *counts = xd->counts;
894 :
895 0 : if (inter_block) {
896 0 : if (eset > 0) {
897 0 : *tx_type = av1_ext_tx_inter_inv[eset][aom_read_symbol(
898 : r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size],
899 : ext_tx_cnt_inter[eset], ACCT_STR)];
900 0 : if (counts) ++counts->inter_ext_tx[eset][square_tx_size][*tx_type];
901 : }
902 : } else if (ALLOW_INTRA_EXT_TX) {
903 0 : if (eset > 0) {
904 0 : *tx_type = av1_ext_tx_intra_inv[eset][aom_read_symbol(
905 : r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode],
906 : ext_tx_cnt_intra[eset], ACCT_STR)];
907 0 : if (counts)
908 0 : ++counts->intra_ext_tx[eset][square_tx_size][mbmi->mode][*tx_type];
909 : }
910 : }
911 : } else {
912 0 : *tx_type = DCT_DCT;
913 : }
914 : #else
915 :
916 : if (tx_size < TX_32X32 &&
917 : ((!cm->seg.enabled && cm->base_qindex > 0) ||
918 : (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
919 : !mbmi->skip &&
920 : #if CONFIG_SUPERTX
921 : !supertx_enabled &&
922 : #endif // CONFIG_SUPERTX
923 : !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
924 : FRAME_COUNTS *counts = xd->counts;
925 :
926 : if (inter_block) {
927 : *tx_type = av1_ext_tx_inv[aom_read_symbol(
928 : r, ec_ctx->inter_ext_tx_cdf[tx_size], TX_TYPES, ACCT_STR)];
929 : if (counts) ++counts->inter_ext_tx[tx_size][*tx_type];
930 : } else {
931 : const TX_TYPE tx_type_nom = intra_mode_to_tx_type_context[mbmi->mode];
932 : *tx_type = av1_ext_tx_inv[aom_read_symbol(
933 : r, ec_ctx->intra_ext_tx_cdf[tx_size][tx_type_nom], TX_TYPES,
934 : ACCT_STR)];
935 : if (counts) ++counts->intra_ext_tx[tx_size][tx_type_nom][*tx_type];
936 : }
937 : } else {
938 : *tx_type = DCT_DCT;
939 : }
940 : #endif // CONFIG_EXT_TX
941 : }
942 0 : }
943 :
944 : #if CONFIG_INTRABC
945 : static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref,
946 : nmv_context *ctx, nmv_context_counts *counts,
947 : int allow_hp);
948 :
949 : static INLINE int is_mv_valid(const MV *mv);
950 :
951 : static INLINE int assign_dv(AV1_COMMON *cm, MACROBLOCKD *xd, int_mv *mv,
952 : const int_mv *ref_mv, int mi_row, int mi_col,
953 : BLOCK_SIZE bsize, aom_reader *r) {
954 : #if CONFIG_EC_ADAPT
955 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
956 : (void)cm;
957 : #else
958 : FRAME_CONTEXT *ec_ctx = cm->fc;
959 : #endif
960 : FRAME_COUNTS *counts = xd->counts;
961 : nmv_context_counts *const dv_counts = counts ? &counts->dv : NULL;
962 : read_mv(r, &mv->as_mv, &ref_mv->as_mv, &ec_ctx->ndvc, dv_counts, 0);
963 : int valid = is_mv_valid(&mv->as_mv) &&
964 : is_dv_valid(mv->as_mv, &xd->tile, mi_row, mi_col, bsize);
965 : return valid;
966 : }
967 : #endif // CONFIG_INTRABC
968 :
969 0 : static void read_intra_frame_mode_info(AV1_COMMON *const cm,
970 : MACROBLOCKD *const xd, int mi_row,
971 : int mi_col, aom_reader *r) {
972 0 : MODE_INFO *const mi = xd->mi[0];
973 0 : MB_MODE_INFO *const mbmi = &mi->mbmi;
974 0 : const MODE_INFO *above_mi = xd->above_mi;
975 0 : const MODE_INFO *left_mi = xd->left_mi;
976 0 : const BLOCK_SIZE bsize = mbmi->sb_type;
977 : int i;
978 0 : const int mi_offset = mi_row * cm->mi_cols + mi_col;
979 0 : const int bw = mi_size_wide[bsize];
980 0 : const int bh = mi_size_high[bsize];
981 :
982 : // TODO(slavarnway): move x_mis, y_mis into xd ?????
983 0 : const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw);
984 0 : const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh);
985 : #if CONFIG_EC_ADAPT
986 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
987 : #else
988 : FRAME_CONTEXT *ec_ctx = cm->fc;
989 : #endif
990 :
991 0 : mbmi->segment_id = read_intra_segment_id(cm, xd, mi_offset, x_mis, y_mis, r);
992 0 : mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
993 :
994 : #if CONFIG_DELTA_Q
995 0 : if (cm->delta_q_present_flag) {
996 0 : xd->current_qindex =
997 0 : xd->prev_qindex +
998 0 : read_delta_qindex(cm, xd, r, mbmi, mi_col, mi_row) * cm->delta_q_res;
999 : /* Normative: Clamp to [1,MAXQ] to not interfere with lossless mode */
1000 0 : xd->current_qindex = clamp(xd->current_qindex, 1, MAXQ);
1001 0 : xd->prev_qindex = xd->current_qindex;
1002 : #if CONFIG_EXT_DELTA_Q
1003 0 : if (cm->delta_lf_present_flag) {
1004 0 : mbmi->current_delta_lf_from_base = xd->current_delta_lf_from_base =
1005 0 : xd->prev_delta_lf_from_base +
1006 0 : read_delta_lflevel(cm, xd, r, mbmi, mi_col, mi_row) *
1007 0 : cm->delta_lf_res;
1008 0 : xd->prev_delta_lf_from_base = xd->current_delta_lf_from_base;
1009 : }
1010 : #endif
1011 : }
1012 : #endif
1013 :
1014 0 : mbmi->ref_frame[0] = INTRA_FRAME;
1015 0 : mbmi->ref_frame[1] = NONE_FRAME;
1016 0 : mbmi->tx_size = read_tx_size(cm, xd, 0, 1, r);
1017 :
1018 : #if CONFIG_INTRABC
1019 : if (bsize >= BLOCK_8X8 && cm->allow_screen_content_tools) {
1020 : mbmi->use_intrabc = aom_read(r, ec_ctx->intrabc_prob, ACCT_STR);
1021 : if (mbmi->use_intrabc) {
1022 : mbmi->mode = mbmi->uv_mode = DC_PRED;
1023 : #if CONFIG_DUAL_FILTER
1024 : for (int idx = 0; idx < 4; ++idx) mbmi->interp_filter[idx] = BILINEAR;
1025 : #else
1026 : mbmi->interp_filter = BILINEAR;
1027 : #endif
1028 :
1029 : int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES];
1030 : int_mv ref_mvs[MAX_MV_REF_CANDIDATES] = {};
1031 :
1032 : av1_find_mv_refs(cm, xd, mi, INTRA_FRAME, &xd->ref_mv_count[INTRA_FRAME],
1033 : xd->ref_mv_stack[INTRA_FRAME],
1034 : #if CONFIG_EXT_INTER
1035 : NULL,
1036 : #endif // CONFIG_EXT_INTER
1037 : ref_mvs, mi_row, mi_col, NULL, NULL, inter_mode_ctx);
1038 :
1039 : int_mv nearestmv, nearmv;
1040 : av1_find_best_ref_mvs(0, ref_mvs, &nearestmv, &nearmv);
1041 :
1042 : int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv;
1043 : if (dv_ref.as_int == 0) av1_find_ref_dv(&dv_ref, mi_row, mi_col);
1044 :
1045 : xd->corrupted |=
1046 : !assign_dv(cm, xd, &mbmi->mv[0], &dv_ref, mi_row, mi_col, bsize, r);
1047 : #if CONFIG_VAR_TX
1048 : // TODO(aconverse@google.com): Evaluate allowing VAR TX on intrabc blocks
1049 : const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
1050 : const int height = block_size_high[bsize] >> tx_size_high_log2[0];
1051 : int idx, idy;
1052 : for (idy = 0; idy < height; ++idy)
1053 : for (idx = 0; idx < width; ++idx)
1054 : mbmi->inter_tx_size[idy >> 1][idx >> 1] = mbmi->tx_size;
1055 : mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
1056 : #endif // CONFIG_VAR_TX
1057 : #if CONFIG_EXT_TX && !CONFIG_TXK_SEL
1058 : av1_read_tx_type(cm, xd,
1059 : #if CONFIG_SUPERTX
1060 : 0,
1061 : #endif
1062 : r);
1063 : #endif // CONFIG_EXT_TX && !CONFIG_TXK_SEL
1064 : return;
1065 : }
1066 : }
1067 : #endif // CONFIG_INTRABC
1068 :
1069 : #if CONFIG_CB4X4
1070 : (void)i;
1071 0 : mbmi->mode =
1072 0 : read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0));
1073 : #else
1074 : switch (bsize) {
1075 : case BLOCK_4X4:
1076 : for (i = 0; i < 4; ++i)
1077 : mi->bmi[i].as_mode = read_intra_mode(
1078 : r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, i));
1079 : mbmi->mode = mi->bmi[3].as_mode;
1080 : break;
1081 : case BLOCK_4X8:
1082 : mi->bmi[0].as_mode = mi->bmi[2].as_mode =
1083 : read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0));
1084 : mi->bmi[1].as_mode = mi->bmi[3].as_mode = mbmi->mode =
1085 : read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 1));
1086 : break;
1087 : case BLOCK_8X4:
1088 : mi->bmi[0].as_mode = mi->bmi[1].as_mode =
1089 : read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0));
1090 : mi->bmi[2].as_mode = mi->bmi[3].as_mode = mbmi->mode =
1091 : read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 2));
1092 : break;
1093 : default:
1094 : mbmi->mode =
1095 : read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0));
1096 : }
1097 : #endif
1098 :
1099 : #if CONFIG_CB4X4
1100 0 : if (is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x,
1101 : xd->plane[1].subsampling_y)) {
1102 0 : mbmi->uv_mode = read_intra_mode_uv(ec_ctx, xd, r, mbmi->mode);
1103 : #else
1104 : mbmi->uv_mode = read_intra_mode_uv(ec_ctx, xd, r, mbmi->mode);
1105 : #endif
1106 :
1107 : #if CONFIG_CFL
1108 : // TODO(ltrudeau) support PALETTE
1109 : if (mbmi->uv_mode == DC_PRED) {
1110 : mbmi->cfl_alpha_idx =
1111 : read_cfl_alphas(ec_ctx, r, mbmi->skip, mbmi->cfl_alpha_signs);
1112 : }
1113 : #endif // CONFIG_CFL
1114 :
1115 : #if CONFIG_CB4X4
1116 : }
1117 : #endif
1118 :
1119 : #if CONFIG_EXT_INTRA
1120 0 : read_intra_angle_info(cm, xd, r);
1121 : #endif // CONFIG_EXT_INTRA
1122 : #if CONFIG_PALETTE
1123 0 : mbmi->palette_mode_info.palette_size[0] = 0;
1124 0 : mbmi->palette_mode_info.palette_size[1] = 0;
1125 0 : if (bsize >= BLOCK_8X8 && cm->allow_screen_content_tools)
1126 0 : read_palette_mode_info(cm, xd, r);
1127 : #endif // CONFIG_PALETTE
1128 : #if CONFIG_FILTER_INTRA
1129 : mbmi->filter_intra_mode_info.use_filter_intra_mode[0] = 0;
1130 : mbmi->filter_intra_mode_info.use_filter_intra_mode[1] = 0;
1131 : if (bsize >= BLOCK_8X8 || CONFIG_CB4X4)
1132 : read_filter_intra_mode_info(cm, xd, mi_row, mi_col, r);
1133 : #endif // CONFIG_FILTER_INTRA
1134 :
1135 : #if !CONFIG_TXK_SEL
1136 0 : av1_read_tx_type(cm, xd,
1137 : #if CONFIG_SUPERTX
1138 : 0,
1139 : #endif
1140 : r);
1141 : #endif // !CONFIG_TXK_SEL
1142 0 : }
1143 :
1144 0 : static int read_mv_component(aom_reader *r, nmv_component *mvcomp, int usehp) {
1145 : int mag, d, fr, hp;
1146 0 : const int sign = aom_read(r, mvcomp->sign, ACCT_STR);
1147 0 : const int mv_class =
1148 0 : aom_read_symbol(r, mvcomp->class_cdf, MV_CLASSES, ACCT_STR);
1149 0 : const int class0 = mv_class == MV_CLASS_0;
1150 :
1151 : // Integer part
1152 0 : if (class0) {
1153 0 : d = aom_read(r, mvcomp->class0[0], ACCT_STR);
1154 0 : mag = 0;
1155 : } else {
1156 : int i;
1157 0 : const int n = mv_class + CLASS0_BITS - 1; // number of bits
1158 :
1159 0 : d = 0;
1160 0 : for (i = 0; i < n; ++i) d |= aom_read(r, mvcomp->bits[i], ACCT_STR) << i;
1161 0 : mag = CLASS0_SIZE << (mv_class + 2);
1162 : }
1163 :
1164 : // Fractional part
1165 0 : fr = aom_read_symbol(r, class0 ? mvcomp->class0_fp_cdf[d] : mvcomp->fp_cdf,
1166 : MV_FP_SIZE, ACCT_STR);
1167 :
1168 : // High precision part (if hp is not used, the default value of the hp is 1)
1169 0 : hp = usehp ? aom_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp, ACCT_STR)
1170 0 : : 1;
1171 :
1172 : // Result
1173 0 : mag += ((d << 3) | (fr << 1) | hp) + 1;
1174 0 : return sign ? -mag : mag;
1175 : }
1176 :
1177 0 : static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref,
1178 : nmv_context *ctx, nmv_context_counts *counts,
1179 : int allow_hp) {
1180 : MV_JOINT_TYPE joint_type;
1181 0 : MV diff = { 0, 0 };
1182 0 : joint_type =
1183 0 : (MV_JOINT_TYPE)aom_read_symbol(r, ctx->joint_cdf, MV_JOINTS, ACCT_STR);
1184 :
1185 0 : if (mv_joint_vertical(joint_type))
1186 0 : diff.row = read_mv_component(r, &ctx->comps[0], allow_hp);
1187 :
1188 0 : if (mv_joint_horizontal(joint_type))
1189 0 : diff.col = read_mv_component(r, &ctx->comps[1], allow_hp);
1190 :
1191 0 : av1_inc_mv(&diff, counts, allow_hp);
1192 :
1193 0 : mv->row = ref->row + diff.row;
1194 0 : mv->col = ref->col + diff.col;
1195 0 : }
1196 :
1197 0 : static REFERENCE_MODE read_block_reference_mode(AV1_COMMON *cm,
1198 : const MACROBLOCKD *xd,
1199 : aom_reader *r) {
1200 : #if !SUB8X8_COMP_REF
1201 0 : if (xd->mi[0]->mbmi.sb_type == BLOCK_4X4) return SINGLE_REFERENCE;
1202 : #endif
1203 0 : if (cm->reference_mode == REFERENCE_MODE_SELECT) {
1204 0 : const int ctx = av1_get_reference_mode_context(cm, xd);
1205 0 : const REFERENCE_MODE mode =
1206 0 : (REFERENCE_MODE)aom_read(r, cm->fc->comp_inter_prob[ctx], ACCT_STR);
1207 0 : FRAME_COUNTS *counts = xd->counts;
1208 0 : if (counts) ++counts->comp_inter[ctx][mode];
1209 0 : return mode; // SINGLE_REFERENCE or COMPOUND_REFERENCE
1210 : } else {
1211 0 : return cm->reference_mode;
1212 : }
1213 : }
1214 :
1215 : // Read the referncence frame
1216 0 : static void read_ref_frames(AV1_COMMON *const cm, MACROBLOCKD *const xd,
1217 : aom_reader *r, int segment_id,
1218 : MV_REFERENCE_FRAME ref_frame[2]) {
1219 0 : FRAME_CONTEXT *const fc = cm->fc;
1220 0 : FRAME_COUNTS *counts = xd->counts;
1221 :
1222 0 : if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
1223 0 : ref_frame[0] = (MV_REFERENCE_FRAME)get_segdata(&cm->seg, segment_id,
1224 : SEG_LVL_REF_FRAME);
1225 0 : ref_frame[1] = NONE_FRAME;
1226 : } else {
1227 0 : const REFERENCE_MODE mode = read_block_reference_mode(cm, xd, r);
1228 : // FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
1229 0 : if (mode == COMPOUND_REFERENCE) {
1230 : #if CONFIG_ONE_SIDED_COMPOUND // Normative in decoder (for low delay)
1231 0 : const int idx = 1;
1232 : #else
1233 : #if CONFIG_EXT_REFS
1234 : const int idx = cm->ref_frame_sign_bias[cm->comp_bwd_ref[0]];
1235 : #else
1236 : const int idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
1237 : #endif // CONFIG_EXT_REFS
1238 : #endif
1239 0 : const int ctx = av1_get_pred_context_comp_ref_p(cm, xd);
1240 :
1241 0 : const int bit = aom_read(r, fc->comp_ref_prob[ctx][0], ACCT_STR);
1242 0 : if (counts) ++counts->comp_ref[ctx][0][bit];
1243 :
1244 : #if CONFIG_EXT_REFS
1245 : // Decode forward references.
1246 0 : if (!bit) {
1247 0 : const int ctx1 = av1_get_pred_context_comp_ref_p1(cm, xd);
1248 0 : const int bit1 = aom_read(r, fc->comp_ref_prob[ctx1][1], ACCT_STR);
1249 0 : if (counts) ++counts->comp_ref[ctx1][1][bit1];
1250 0 : ref_frame[!idx] = cm->comp_fwd_ref[bit1 ? 0 : 1];
1251 : } else {
1252 0 : const int ctx2 = av1_get_pred_context_comp_ref_p2(cm, xd);
1253 0 : const int bit2 = aom_read(r, fc->comp_ref_prob[ctx2][2], ACCT_STR);
1254 0 : if (counts) ++counts->comp_ref[ctx2][2][bit2];
1255 0 : ref_frame[!idx] = cm->comp_fwd_ref[bit2 ? 3 : 2];
1256 : }
1257 :
1258 : // Decode backward references.
1259 : {
1260 0 : const int ctx_bwd = av1_get_pred_context_comp_bwdref_p(cm, xd);
1261 0 : const int bit_bwd =
1262 0 : aom_read(r, fc->comp_bwdref_prob[ctx_bwd][0], ACCT_STR);
1263 0 : if (counts) ++counts->comp_bwdref[ctx_bwd][0][bit_bwd];
1264 0 : ref_frame[idx] = cm->comp_bwd_ref[bit_bwd];
1265 : }
1266 : #else
1267 : ref_frame[!idx] = cm->comp_var_ref[bit];
1268 : ref_frame[idx] = cm->comp_fixed_ref;
1269 : #endif // CONFIG_EXT_REFS
1270 0 : } else if (mode == SINGLE_REFERENCE) {
1271 : #if CONFIG_EXT_REFS
1272 0 : const int ctx0 = av1_get_pred_context_single_ref_p1(xd);
1273 0 : const int bit0 = aom_read(r, fc->single_ref_prob[ctx0][0], ACCT_STR);
1274 0 : if (counts) ++counts->single_ref[ctx0][0][bit0];
1275 :
1276 0 : if (bit0) {
1277 0 : const int ctx1 = av1_get_pred_context_single_ref_p2(xd);
1278 0 : const int bit1 = aom_read(r, fc->single_ref_prob[ctx1][1], ACCT_STR);
1279 0 : if (counts) ++counts->single_ref[ctx1][1][bit1];
1280 0 : ref_frame[0] = bit1 ? ALTREF_FRAME : BWDREF_FRAME;
1281 : } else {
1282 0 : const int ctx2 = av1_get_pred_context_single_ref_p3(xd);
1283 0 : const int bit2 = aom_read(r, fc->single_ref_prob[ctx2][2], ACCT_STR);
1284 0 : if (counts) ++counts->single_ref[ctx2][2][bit2];
1285 0 : if (bit2) {
1286 0 : const int ctx4 = av1_get_pred_context_single_ref_p5(xd);
1287 0 : const int bit4 = aom_read(r, fc->single_ref_prob[ctx4][4], ACCT_STR);
1288 0 : if (counts) ++counts->single_ref[ctx4][4][bit4];
1289 0 : ref_frame[0] = bit4 ? GOLDEN_FRAME : LAST3_FRAME;
1290 : } else {
1291 0 : const int ctx3 = av1_get_pred_context_single_ref_p4(xd);
1292 0 : const int bit3 = aom_read(r, fc->single_ref_prob[ctx3][3], ACCT_STR);
1293 0 : if (counts) ++counts->single_ref[ctx3][3][bit3];
1294 0 : ref_frame[0] = bit3 ? LAST2_FRAME : LAST_FRAME;
1295 : }
1296 : }
1297 : #else
1298 : const int ctx0 = av1_get_pred_context_single_ref_p1(xd);
1299 : const int bit0 = aom_read(r, fc->single_ref_prob[ctx0][0], ACCT_STR);
1300 : if (counts) ++counts->single_ref[ctx0][0][bit0];
1301 :
1302 : if (bit0) {
1303 : const int ctx1 = av1_get_pred_context_single_ref_p2(xd);
1304 : const int bit1 = aom_read(r, fc->single_ref_prob[ctx1][1], ACCT_STR);
1305 : if (counts) ++counts->single_ref[ctx1][1][bit1];
1306 : ref_frame[0] = bit1 ? ALTREF_FRAME : GOLDEN_FRAME;
1307 : } else {
1308 : ref_frame[0] = LAST_FRAME;
1309 : }
1310 : #endif // CONFIG_EXT_REFS
1311 :
1312 0 : ref_frame[1] = NONE_FRAME;
1313 : } else {
1314 0 : assert(0 && "Invalid prediction mode.");
1315 : }
1316 : }
1317 0 : }
1318 :
1319 0 : static INLINE void read_mb_interp_filter(AV1_COMMON *const cm,
1320 : MACROBLOCKD *const xd,
1321 : MB_MODE_INFO *const mbmi,
1322 : aom_reader *r) {
1323 0 : FRAME_COUNTS *counts = xd->counts;
1324 : #if CONFIG_EC_ADAPT
1325 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1326 : #else
1327 : FRAME_CONTEXT *ec_ctx = cm->fc;
1328 : #endif
1329 :
1330 0 : if (!av1_is_interp_needed(xd)) {
1331 0 : set_default_interp_filters(mbmi, cm->interp_filter);
1332 0 : return;
1333 : }
1334 :
1335 : #if CONFIG_DUAL_FILTER
1336 0 : if (cm->interp_filter != SWITCHABLE) {
1337 : int dir;
1338 :
1339 0 : for (dir = 0; dir < 4; ++dir) mbmi->interp_filter[dir] = cm->interp_filter;
1340 : } else {
1341 : int dir;
1342 :
1343 0 : for (dir = 0; dir < 2; ++dir) {
1344 0 : const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
1345 0 : mbmi->interp_filter[dir] = EIGHTTAP_REGULAR;
1346 :
1347 0 : if (has_subpel_mv_component(xd->mi[0], xd, dir) ||
1348 0 : (mbmi->ref_frame[1] > INTRA_FRAME &&
1349 0 : has_subpel_mv_component(xd->mi[0], xd, dir + 2))) {
1350 0 : mbmi->interp_filter[dir] =
1351 0 : (InterpFilter)av1_switchable_interp_inv[aom_read_symbol(
1352 : r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS,
1353 : ACCT_STR)];
1354 0 : if (counts) ++counts->switchable_interp[ctx][mbmi->interp_filter[dir]];
1355 : }
1356 : }
1357 : // The index system works as:
1358 : // (0, 1) -> (vertical, horizontal) filter types for the first ref frame.
1359 : // (2, 3) -> (vertical, horizontal) filter types for the second ref frame.
1360 0 : mbmi->interp_filter[2] = mbmi->interp_filter[0];
1361 0 : mbmi->interp_filter[3] = mbmi->interp_filter[1];
1362 : }
1363 : #else // CONFIG_DUAL_FILTER
1364 : if (cm->interp_filter != SWITCHABLE) {
1365 : mbmi->interp_filter = cm->interp_filter;
1366 : } else {
1367 : const int ctx = av1_get_pred_context_switchable_interp(xd);
1368 : mbmi->interp_filter =
1369 : (InterpFilter)av1_switchable_interp_inv[aom_read_symbol(
1370 : r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS,
1371 : ACCT_STR)];
1372 : if (counts) ++counts->switchable_interp[ctx][mbmi->interp_filter];
1373 : }
1374 : #endif // CONFIG_DUAL_FILTER
1375 : }
1376 :
1377 0 : static void read_intra_block_mode_info(AV1_COMMON *const cm, const int mi_row,
1378 : const int mi_col, MACROBLOCKD *const xd,
1379 : MODE_INFO *mi, aom_reader *r) {
1380 0 : MB_MODE_INFO *const mbmi = &mi->mbmi;
1381 0 : const BLOCK_SIZE bsize = mi->mbmi.sb_type;
1382 : int i;
1383 :
1384 0 : mbmi->ref_frame[0] = INTRA_FRAME;
1385 0 : mbmi->ref_frame[1] = NONE_FRAME;
1386 :
1387 : #if CONFIG_EC_ADAPT
1388 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1389 : #else
1390 : FRAME_CONTEXT *ec_ctx = cm->fc;
1391 : #endif
1392 :
1393 : #if CONFIG_CB4X4
1394 : (void)i;
1395 0 : mbmi->mode = read_intra_mode_y(ec_ctx, xd, r, size_group_lookup[bsize]);
1396 : #else
1397 : switch (bsize) {
1398 : case BLOCK_4X4:
1399 : for (i = 0; i < 4; ++i)
1400 : mi->bmi[i].as_mode = read_intra_mode_y(ec_ctx, xd, r, 0);
1401 : mbmi->mode = mi->bmi[3].as_mode;
1402 : break;
1403 : case BLOCK_4X8:
1404 : mi->bmi[0].as_mode = mi->bmi[2].as_mode =
1405 : read_intra_mode_y(ec_ctx, xd, r, 0);
1406 : mi->bmi[1].as_mode = mi->bmi[3].as_mode = mbmi->mode =
1407 : read_intra_mode_y(ec_ctx, xd, r, 0);
1408 : break;
1409 : case BLOCK_8X4:
1410 : mi->bmi[0].as_mode = mi->bmi[1].as_mode =
1411 : read_intra_mode_y(ec_ctx, xd, r, 0);
1412 : mi->bmi[2].as_mode = mi->bmi[3].as_mode = mbmi->mode =
1413 : read_intra_mode_y(ec_ctx, xd, r, 0);
1414 : break;
1415 : default:
1416 : mbmi->mode = read_intra_mode_y(ec_ctx, xd, r, size_group_lookup[bsize]);
1417 : }
1418 : #endif
1419 :
1420 : #if CONFIG_CB4X4
1421 0 : if (is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x,
1422 : xd->plane[1].subsampling_y)) {
1423 0 : mbmi->uv_mode = read_intra_mode_uv(ec_ctx, xd, r, mbmi->mode);
1424 : #else
1425 : mbmi->uv_mode = read_intra_mode_uv(ec_ctx, xd, r, mbmi->mode);
1426 : (void)mi_row;
1427 : (void)mi_col;
1428 : #endif
1429 :
1430 : #if CONFIG_CFL
1431 : // TODO(ltrudeau) support PALETTE
1432 : if (mbmi->uv_mode == DC_PRED) {
1433 : mbmi->cfl_alpha_idx = read_cfl_alphas(
1434 : #if CONFIG_EC_ADAPT
1435 : xd->tile_ctx,
1436 : #else
1437 : cm->fc,
1438 : #endif // CONFIG_EC_ADAPT
1439 : r, mbmi->skip, mbmi->cfl_alpha_signs);
1440 : }
1441 : #endif // CONFIG_CFL
1442 :
1443 : #if CONFIG_CB4X4
1444 : }
1445 : #endif
1446 :
1447 : #if CONFIG_EXT_INTRA
1448 0 : read_intra_angle_info(cm, xd, r);
1449 : #endif // CONFIG_EXT_INTRA
1450 : #if CONFIG_PALETTE
1451 0 : mbmi->palette_mode_info.palette_size[0] = 0;
1452 0 : mbmi->palette_mode_info.palette_size[1] = 0;
1453 0 : if (bsize >= BLOCK_8X8 && cm->allow_screen_content_tools)
1454 0 : read_palette_mode_info(cm, xd, r);
1455 : #endif // CONFIG_PALETTE
1456 : #if CONFIG_FILTER_INTRA
1457 : mbmi->filter_intra_mode_info.use_filter_intra_mode[0] = 0;
1458 : mbmi->filter_intra_mode_info.use_filter_intra_mode[1] = 0;
1459 : if (bsize >= BLOCK_8X8 || CONFIG_CB4X4)
1460 : read_filter_intra_mode_info(cm, xd, mi_row, mi_col, r);
1461 : #endif // CONFIG_FILTER_INTRA
1462 0 : }
1463 :
1464 0 : static INLINE int is_mv_valid(const MV *mv) {
1465 0 : return mv->row > MV_LOW && mv->row < MV_UPP && mv->col > MV_LOW &&
1466 0 : mv->col < MV_UPP;
1467 : }
1468 :
1469 0 : static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd,
1470 : PREDICTION_MODE mode,
1471 : MV_REFERENCE_FRAME ref_frame[2], int block,
1472 : int_mv mv[2], int_mv ref_mv[2],
1473 : int_mv nearest_mv[2], int_mv near_mv[2], int mi_row,
1474 : int mi_col, int is_compound, int allow_hp,
1475 : aom_reader *r) {
1476 : int i;
1477 0 : int ret = 1;
1478 : #if CONFIG_EC_ADAPT
1479 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1480 : #else
1481 : FRAME_CONTEXT *ec_ctx = cm->fc;
1482 : #endif
1483 0 : BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
1484 0 : MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
1485 : #if CONFIG_CB4X4
1486 0 : int_mv *pred_mv = mbmi->pred_mv;
1487 : (void)block;
1488 : #else
1489 : int_mv *pred_mv =
1490 : (bsize >= BLOCK_8X8) ? mbmi->pred_mv : xd->mi[0]->bmi[block].pred_mv;
1491 : #endif // CONFIG_CB4X4
1492 : (void)ref_frame;
1493 : (void)cm;
1494 : (void)mi_row;
1495 : (void)mi_col;
1496 : (void)bsize;
1497 :
1498 0 : switch (mode) {
1499 : case NEWMV: {
1500 0 : FRAME_COUNTS *counts = xd->counts;
1501 0 : for (i = 0; i < 1 + is_compound; ++i) {
1502 0 : int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame);
1503 0 : int nmv_ctx =
1504 0 : av1_nmv_ctx(xd->ref_mv_count[rf_type], xd->ref_mv_stack[rf_type], i,
1505 0 : mbmi->ref_mv_idx);
1506 0 : nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx];
1507 0 : nmv_context_counts *const mv_counts =
1508 0 : counts ? &counts->mv[nmv_ctx] : NULL;
1509 0 : read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, nmvc, mv_counts, allow_hp);
1510 0 : ret = ret && is_mv_valid(&mv[i].as_mv);
1511 :
1512 0 : pred_mv[i].as_int = ref_mv[i].as_int;
1513 : }
1514 0 : break;
1515 : }
1516 : case NEARESTMV: {
1517 0 : mv[0].as_int = nearest_mv[0].as_int;
1518 0 : if (is_compound) mv[1].as_int = nearest_mv[1].as_int;
1519 :
1520 0 : pred_mv[0].as_int = nearest_mv[0].as_int;
1521 0 : if (is_compound) pred_mv[1].as_int = nearest_mv[1].as_int;
1522 0 : break;
1523 : }
1524 : case NEARMV: {
1525 0 : mv[0].as_int = near_mv[0].as_int;
1526 0 : if (is_compound) mv[1].as_int = near_mv[1].as_int;
1527 :
1528 0 : pred_mv[0].as_int = near_mv[0].as_int;
1529 0 : if (is_compound) pred_mv[1].as_int = near_mv[1].as_int;
1530 0 : break;
1531 : }
1532 : case ZEROMV: {
1533 : #if CONFIG_GLOBAL_MOTION
1534 0 : mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
1535 : cm->allow_high_precision_mv, bsize,
1536 : mi_col, mi_row, block)
1537 0 : .as_int;
1538 0 : if (is_compound)
1539 0 : mv[1].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[1]],
1540 : cm->allow_high_precision_mv, bsize,
1541 : mi_col, mi_row, block)
1542 0 : .as_int;
1543 : #else
1544 : mv[0].as_int = 0;
1545 : if (is_compound) mv[1].as_int = 0;
1546 : #endif // CONFIG_GLOBAL_MOTION
1547 :
1548 0 : pred_mv[0].as_int = mv[0].as_int;
1549 0 : if (is_compound) pred_mv[1].as_int = mv[1].as_int;
1550 0 : break;
1551 : }
1552 : #if CONFIG_EXT_INTER
1553 : case NEW_NEWMV: {
1554 0 : FRAME_COUNTS *counts = xd->counts;
1555 0 : assert(is_compound);
1556 0 : for (i = 0; i < 2; ++i) {
1557 0 : int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame);
1558 0 : int nmv_ctx =
1559 0 : av1_nmv_ctx(xd->ref_mv_count[rf_type], xd->ref_mv_stack[rf_type], i,
1560 0 : mbmi->ref_mv_idx);
1561 0 : nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx];
1562 0 : nmv_context_counts *const mv_counts =
1563 0 : counts ? &counts->mv[nmv_ctx] : NULL;
1564 0 : read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, nmvc, mv_counts, allow_hp);
1565 0 : ret = ret && is_mv_valid(&mv[i].as_mv);
1566 : }
1567 0 : break;
1568 : }
1569 : case NEAREST_NEARESTMV: {
1570 0 : assert(is_compound);
1571 0 : mv[0].as_int = nearest_mv[0].as_int;
1572 0 : mv[1].as_int = nearest_mv[1].as_int;
1573 0 : break;
1574 : }
1575 : case NEAR_NEARMV: {
1576 0 : assert(is_compound);
1577 0 : mv[0].as_int = near_mv[0].as_int;
1578 0 : mv[1].as_int = near_mv[1].as_int;
1579 0 : break;
1580 : }
1581 : case NEW_NEARESTMV: {
1582 0 : FRAME_COUNTS *counts = xd->counts;
1583 0 : int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame);
1584 0 : int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type],
1585 0 : xd->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx);
1586 0 : nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx];
1587 0 : nmv_context_counts *const mv_counts =
1588 0 : counts ? &counts->mv[nmv_ctx] : NULL;
1589 0 : read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp);
1590 0 : assert(is_compound);
1591 0 : ret = ret && is_mv_valid(&mv[0].as_mv);
1592 0 : mv[1].as_int = nearest_mv[1].as_int;
1593 0 : break;
1594 : }
1595 : case NEAREST_NEWMV: {
1596 0 : FRAME_COUNTS *counts = xd->counts;
1597 0 : int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame);
1598 0 : int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type],
1599 0 : xd->ref_mv_stack[rf_type], 1, mbmi->ref_mv_idx);
1600 0 : nmv_context_counts *const mv_counts =
1601 0 : counts ? &counts->mv[nmv_ctx] : NULL;
1602 0 : nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx];
1603 0 : mv[0].as_int = nearest_mv[0].as_int;
1604 0 : read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, mv_counts, allow_hp);
1605 0 : assert(is_compound);
1606 0 : ret = ret && is_mv_valid(&mv[1].as_mv);
1607 0 : break;
1608 : }
1609 : case NEAR_NEWMV: {
1610 0 : FRAME_COUNTS *counts = xd->counts;
1611 0 : int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame);
1612 0 : int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type],
1613 0 : xd->ref_mv_stack[rf_type], 1, mbmi->ref_mv_idx);
1614 0 : nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx];
1615 0 : nmv_context_counts *const mv_counts =
1616 0 : counts ? &counts->mv[nmv_ctx] : NULL;
1617 0 : mv[0].as_int = near_mv[0].as_int;
1618 0 : read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, mv_counts, allow_hp);
1619 0 : assert(is_compound);
1620 :
1621 0 : ret = ret && is_mv_valid(&mv[1].as_mv);
1622 0 : break;
1623 : }
1624 : case NEW_NEARMV: {
1625 0 : FRAME_COUNTS *counts = xd->counts;
1626 0 : int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame);
1627 0 : int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type],
1628 0 : xd->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx);
1629 0 : nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx];
1630 0 : nmv_context_counts *const mv_counts =
1631 0 : counts ? &counts->mv[nmv_ctx] : NULL;
1632 0 : read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp);
1633 0 : assert(is_compound);
1634 0 : ret = ret && is_mv_valid(&mv[0].as_mv);
1635 0 : mv[1].as_int = near_mv[1].as_int;
1636 0 : break;
1637 : }
1638 : case ZERO_ZEROMV: {
1639 0 : assert(is_compound);
1640 : #if CONFIG_GLOBAL_MOTION
1641 0 : mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]],
1642 : cm->allow_high_precision_mv, bsize,
1643 : mi_col, mi_row, block)
1644 0 : .as_int;
1645 0 : mv[1].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[1]],
1646 : cm->allow_high_precision_mv, bsize,
1647 : mi_col, mi_row, block)
1648 0 : .as_int;
1649 : #else
1650 : mv[0].as_int = 0;
1651 : mv[1].as_int = 0;
1652 : #endif // CONFIG_GLOBAL_MOTION
1653 0 : break;
1654 : }
1655 : #endif // CONFIG_EXT_INTER
1656 0 : default: { return 0; }
1657 : }
1658 0 : return ret;
1659 : }
1660 :
1661 0 : static int read_is_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd,
1662 : int segment_id, aom_reader *r) {
1663 0 : if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
1664 0 : return get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME) != INTRA_FRAME;
1665 : } else {
1666 0 : const int ctx = av1_get_intra_inter_context(xd);
1667 0 : const int is_inter = aom_read(r, cm->fc->intra_inter_prob[ctx], ACCT_STR);
1668 0 : FRAME_COUNTS *counts = xd->counts;
1669 0 : if (counts) ++counts->intra_inter[ctx][is_inter];
1670 0 : return is_inter;
1671 : }
1672 : }
1673 :
1674 0 : static void fpm_sync(void *const data, int mi_row) {
1675 0 : AV1Decoder *const pbi = (AV1Decoder *)data;
1676 0 : av1_frameworker_wait(pbi->frame_worker_owner, pbi->common.prev_frame,
1677 0 : mi_row << pbi->common.mib_size_log2);
1678 0 : }
1679 :
1680 0 : static void read_inter_block_mode_info(AV1Decoder *const pbi,
1681 : MACROBLOCKD *const xd,
1682 : MODE_INFO *const mi,
1683 : #if (CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION || CONFIG_EXT_INTER) && \
1684 : CONFIG_SUPERTX
1685 : int mi_row, int mi_col, aom_reader *r,
1686 : int supertx_enabled) {
1687 : #else
1688 : int mi_row, int mi_col, aom_reader *r) {
1689 : #endif // CONFIG_MOTION_VAR && CONFIG_SUPERTX
1690 0 : AV1_COMMON *const cm = &pbi->common;
1691 0 : MB_MODE_INFO *const mbmi = &mi->mbmi;
1692 0 : const BLOCK_SIZE bsize = mbmi->sb_type;
1693 0 : const int allow_hp = cm->allow_high_precision_mv;
1694 0 : const int unify_bsize = CONFIG_CB4X4;
1695 : int_mv nearestmv[2], nearmv[2];
1696 : int_mv ref_mvs[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES];
1697 : int ref, is_compound;
1698 : int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES];
1699 : #if CONFIG_EXT_INTER
1700 : int16_t compound_inter_mode_ctx[MODE_CTX_REF_FRAMES];
1701 : #endif // CONFIG_EXT_INTER
1702 0 : int16_t mode_ctx = 0;
1703 : #if CONFIG_WARPED_MOTION
1704 : int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE];
1705 : #endif // CONFIG_WARPED_MOTION
1706 : #if CONFIG_EC_ADAPT
1707 0 : FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
1708 : #else
1709 : FRAME_CONTEXT *ec_ctx = cm->fc;
1710 : #endif
1711 :
1712 : assert(NELEMENTS(mode_2_counter) == MB_MODE_COUNT);
1713 :
1714 : #if CONFIG_PALETTE
1715 0 : mbmi->palette_mode_info.palette_size[0] = 0;
1716 0 : mbmi->palette_mode_info.palette_size[1] = 0;
1717 : #endif // CONFIG_PALETTE
1718 :
1719 0 : memset(ref_mvs, 0, sizeof(ref_mvs));
1720 :
1721 0 : read_ref_frames(cm, xd, r, mbmi->segment_id, mbmi->ref_frame);
1722 0 : is_compound = has_second_ref(mbmi);
1723 :
1724 0 : for (ref = 0; ref < 1 + is_compound; ++ref) {
1725 0 : MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
1726 :
1727 0 : av1_find_mv_refs(
1728 0 : cm, xd, mi, frame, &xd->ref_mv_count[frame], xd->ref_mv_stack[frame],
1729 : #if CONFIG_EXT_INTER
1730 : compound_inter_mode_ctx,
1731 : #endif // CONFIG_EXT_INTER
1732 0 : ref_mvs[frame], mi_row, mi_col, fpm_sync, (void *)pbi, inter_mode_ctx);
1733 : }
1734 :
1735 0 : if (is_compound) {
1736 0 : MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame);
1737 0 : av1_find_mv_refs(cm, xd, mi, ref_frame, &xd->ref_mv_count[ref_frame],
1738 0 : xd->ref_mv_stack[ref_frame],
1739 : #if CONFIG_EXT_INTER
1740 : compound_inter_mode_ctx,
1741 : #endif // CONFIG_EXT_INTER
1742 0 : ref_mvs[ref_frame], mi_row, mi_col, fpm_sync, (void *)pbi,
1743 : inter_mode_ctx);
1744 :
1745 0 : if (xd->ref_mv_count[ref_frame] < 2) {
1746 : MV_REFERENCE_FRAME rf[2];
1747 : int_mv zeromv[2];
1748 0 : av1_set_ref_frame(rf, ref_frame);
1749 : #if CONFIG_GLOBAL_MOTION
1750 0 : zeromv[0].as_int = gm_get_motion_vector(&cm->global_motion[rf[0]],
1751 : cm->allow_high_precision_mv,
1752 : bsize, mi_col, mi_row, 0)
1753 0 : .as_int;
1754 0 : zeromv[1].as_int = (rf[1] != NONE_FRAME)
1755 0 : ? gm_get_motion_vector(&cm->global_motion[rf[1]],
1756 : cm->allow_high_precision_mv,
1757 : bsize, mi_col, mi_row, 0)
1758 : .as_int
1759 0 : : 0;
1760 : #else
1761 : zeromv[0].as_int = zeromv[1].as_int = 0;
1762 : #endif
1763 0 : for (ref = 0; ref < 2; ++ref) {
1764 0 : if (rf[ref] == NONE_FRAME) continue;
1765 0 : lower_mv_precision(&ref_mvs[rf[ref]][0].as_mv, allow_hp);
1766 0 : lower_mv_precision(&ref_mvs[rf[ref]][1].as_mv, allow_hp);
1767 0 : if (ref_mvs[rf[ref]][0].as_int != zeromv[ref].as_int ||
1768 0 : ref_mvs[rf[ref]][1].as_int != zeromv[ref].as_int)
1769 0 : inter_mode_ctx[ref_frame] &= ~(1 << ALL_ZERO_FLAG_OFFSET);
1770 : }
1771 : }
1772 : }
1773 :
1774 : #if CONFIG_EXT_INTER
1775 0 : if (is_compound)
1776 0 : mode_ctx = compound_inter_mode_ctx[mbmi->ref_frame[0]];
1777 : else
1778 : #endif // CONFIG_EXT_INTER
1779 0 : mode_ctx =
1780 0 : av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame, bsize, -1);
1781 0 : mbmi->ref_mv_idx = 0;
1782 :
1783 0 : if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
1784 0 : mbmi->mode = ZEROMV;
1785 0 : if (bsize < BLOCK_8X8 && !unify_bsize) {
1786 0 : aom_internal_error(xd->error_info, AOM_CODEC_UNSUP_BITSTREAM,
1787 : "Invalid usage of segement feature on small blocks");
1788 0 : return;
1789 : }
1790 : } else {
1791 0 : if (bsize >= BLOCK_8X8 || unify_bsize) {
1792 : #if CONFIG_EXT_INTER
1793 0 : if (is_compound)
1794 0 : mbmi->mode = read_inter_compound_mode(cm, xd, r, mode_ctx);
1795 : else
1796 : #endif // CONFIG_EXT_INTER
1797 0 : mbmi->mode = read_inter_mode(ec_ctx, xd, r, mode_ctx);
1798 : #if CONFIG_EXT_INTER
1799 0 : if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV ||
1800 0 : have_nearmv_in_inter_mode(mbmi->mode))
1801 : #else
1802 : if (mbmi->mode == NEARMV || mbmi->mode == NEWMV)
1803 : #endif
1804 0 : read_drl_idx(cm, xd, mbmi, r);
1805 : }
1806 : }
1807 :
1808 : #if CONFIG_EXT_INTER
1809 0 : if ((bsize < BLOCK_8X8 && unify_bsize) ||
1810 0 : (mbmi->mode != ZEROMV && mbmi->mode != ZERO_ZEROMV)) {
1811 : #else
1812 : if ((bsize < BLOCK_8X8 && !unify_bsize) || mbmi->mode != ZEROMV) {
1813 : #endif // CONFIG_EXT_INTER
1814 0 : for (ref = 0; ref < 1 + is_compound; ++ref) {
1815 0 : av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[ref]],
1816 : &nearestmv[ref], &nearmv[ref]);
1817 : }
1818 : }
1819 :
1820 0 : if (mbmi->ref_mv_idx > 0) {
1821 0 : int_mv cur_mv =
1822 0 : xd->ref_mv_stack[mbmi->ref_frame[0]][1 + mbmi->ref_mv_idx].this_mv;
1823 0 : nearmv[0] = cur_mv;
1824 : }
1825 :
1826 : #if CONFIG_EXT_INTER
1827 0 : if (is_compound && (bsize >= BLOCK_8X8 || unify_bsize) &&
1828 0 : mbmi->mode != ZERO_ZEROMV) {
1829 : #else
1830 : if (is_compound && (bsize >= BLOCK_8X8 || unify_bsize) &&
1831 : mbmi->mode != NEWMV && mbmi->mode != ZEROMV) {
1832 : #endif // CONFIG_EXT_INTER
1833 0 : uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
1834 :
1835 : #if CONFIG_EXT_INTER
1836 0 : if (xd->ref_mv_count[ref_frame_type] > 0) {
1837 : #else
1838 : if (xd->ref_mv_count[ref_frame_type] == 1 && mbmi->mode == NEARESTMV) {
1839 : #endif // CONFIG_EXT_INTER
1840 : #if CONFIG_EXT_INTER
1841 0 : if (mbmi->mode == NEAREST_NEARESTMV) {
1842 : #endif // CONFIG_EXT_INTER
1843 0 : nearestmv[0] = xd->ref_mv_stack[ref_frame_type][0].this_mv;
1844 0 : nearestmv[1] = xd->ref_mv_stack[ref_frame_type][0].comp_mv;
1845 0 : lower_mv_precision(&nearestmv[0].as_mv, allow_hp);
1846 0 : lower_mv_precision(&nearestmv[1].as_mv, allow_hp);
1847 : #if CONFIG_EXT_INTER
1848 0 : } else if (mbmi->mode == NEAREST_NEWMV) {
1849 0 : nearestmv[0] = xd->ref_mv_stack[ref_frame_type][0].this_mv;
1850 0 : lower_mv_precision(&nearestmv[0].as_mv, allow_hp);
1851 0 : } else if (mbmi->mode == NEW_NEARESTMV) {
1852 0 : nearestmv[1] = xd->ref_mv_stack[ref_frame_type][0].comp_mv;
1853 0 : lower_mv_precision(&nearestmv[1].as_mv, allow_hp);
1854 : }
1855 : #endif // CONFIG_EXT_INTER
1856 : }
1857 :
1858 : #if CONFIG_EXT_INTER
1859 0 : if (xd->ref_mv_count[ref_frame_type] > 1) {
1860 0 : int ref_mv_idx = 1 + mbmi->ref_mv_idx;
1861 0 : if (compound_ref0_mode(mbmi->mode) == NEARMV) {
1862 0 : nearmv[0] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv;
1863 0 : lower_mv_precision(&nearmv[0].as_mv, allow_hp);
1864 : }
1865 :
1866 0 : if (compound_ref1_mode(mbmi->mode) == NEARMV) {
1867 0 : nearmv[1] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].comp_mv;
1868 0 : lower_mv_precision(&nearmv[1].as_mv, allow_hp);
1869 : }
1870 : }
1871 : #else
1872 : if (xd->ref_mv_count[ref_frame_type] > 1) {
1873 : int ref_mv_idx = 1 + mbmi->ref_mv_idx;
1874 : nearestmv[0] = xd->ref_mv_stack[ref_frame_type][0].this_mv;
1875 : nearestmv[1] = xd->ref_mv_stack[ref_frame_type][0].comp_mv;
1876 : nearmv[0] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv;
1877 : nearmv[1] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].comp_mv;
1878 : }
1879 : #endif // CONFIG_EXT_INTER
1880 : }
1881 :
1882 : #if !CONFIG_DUAL_FILTER && !CONFIG_WARPED_MOTION && !CONFIG_GLOBAL_MOTION
1883 : read_mb_interp_filter(cm, xd, mbmi, r);
1884 : #endif // !CONFIG_DUAL_FILTER && !CONFIG_WARPED_MOTION
1885 :
1886 0 : if (bsize < BLOCK_8X8 && !unify_bsize) {
1887 0 : const int num_4x4_w = 1 << xd->bmode_blocks_wl;
1888 0 : const int num_4x4_h = 1 << xd->bmode_blocks_hl;
1889 : int idx, idy;
1890 : PREDICTION_MODE b_mode;
1891 : int_mv nearest_sub8x8[2], near_sub8x8[2];
1892 : #if CONFIG_EXT_INTER
1893 : int_mv ref_mv[2][2];
1894 : #endif // CONFIG_EXT_INTER
1895 0 : for (idy = 0; idy < 2; idy += num_4x4_h) {
1896 0 : for (idx = 0; idx < 2; idx += num_4x4_w) {
1897 : int_mv block[2];
1898 0 : const int j = idy * 2 + idx;
1899 : int_mv ref_mv_s8[2];
1900 : #if CONFIG_EXT_INTER
1901 0 : if (!is_compound)
1902 : #endif // CONFIG_EXT_INTER
1903 0 : mode_ctx = av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame,
1904 : bsize, j);
1905 : #if CONFIG_EXT_INTER
1906 0 : if (is_compound)
1907 0 : b_mode = read_inter_compound_mode(cm, xd, r, mode_ctx);
1908 : else
1909 : #endif // CONFIG_EXT_INTER
1910 0 : b_mode = read_inter_mode(ec_ctx, xd, r, mode_ctx);
1911 :
1912 : #if CONFIG_EXT_INTER
1913 0 : if (b_mode != ZEROMV && b_mode != ZERO_ZEROMV) {
1914 : #else
1915 : if (b_mode != ZEROMV) {
1916 : #endif // CONFIG_EXT_INTER
1917 : CANDIDATE_MV ref_mv_stack[2][MAX_REF_MV_STACK_SIZE];
1918 : uint8_t ref_mv_count[2];
1919 0 : for (ref = 0; ref < 1 + is_compound; ++ref)
1920 : #if CONFIG_EXT_INTER
1921 : {
1922 : int_mv mv_ref_list[MAX_MV_REF_CANDIDATES];
1923 0 : av1_update_mv_context(cm, xd, mi, mbmi->ref_frame[ref], mv_ref_list,
1924 : j, mi_row, mi_col, NULL);
1925 : #endif // CONFIG_EXT_INTER
1926 0 : av1_append_sub8x8_mvs_for_idx(cm, xd, j, ref, mi_row, mi_col,
1927 0 : ref_mv_stack[ref], &ref_mv_count[ref],
1928 : #if CONFIG_EXT_INTER
1929 : mv_ref_list,
1930 : #endif // CONFIG_EXT_INTER
1931 : &nearest_sub8x8[ref],
1932 : &near_sub8x8[ref]);
1933 : #if CONFIG_EXT_INTER
1934 0 : if (have_newmv_in_inter_mode(b_mode)) {
1935 0 : mv_ref_list[0].as_int = nearest_sub8x8[ref].as_int;
1936 0 : mv_ref_list[1].as_int = near_sub8x8[ref].as_int;
1937 0 : av1_find_best_ref_mvs(allow_hp, mv_ref_list, &ref_mv[0][ref],
1938 : &ref_mv[1][ref]);
1939 : }
1940 : }
1941 : #endif // CONFIG_EXT_INTER
1942 : }
1943 :
1944 0 : for (ref = 0; ref < 1 + is_compound && b_mode != ZEROMV; ++ref) {
1945 0 : ref_mv_s8[ref] = nearest_sub8x8[ref];
1946 0 : lower_mv_precision(&ref_mv_s8[ref].as_mv, allow_hp);
1947 : }
1948 : #if CONFIG_EXT_INTER
1949 : (void)ref_mv_s8;
1950 : #endif
1951 :
1952 0 : if (!assign_mv(cm, xd, b_mode, mbmi->ref_frame, j, block,
1953 : #if CONFIG_EXT_INTER
1954 : ref_mv[0],
1955 : #else // !CONFIG_EXT_INTER
1956 : ref_mv_s8,
1957 : #endif // CONFIG_EXT_INTER
1958 : nearest_sub8x8, near_sub8x8, mi_row, mi_col, is_compound,
1959 : allow_hp, r)) {
1960 0 : aom_merge_corrupted_flag(&xd->corrupted, 1);
1961 0 : break;
1962 : };
1963 :
1964 0 : mi->bmi[j].as_mv[0].as_int = block[0].as_int;
1965 0 : mi->bmi[j].as_mode = b_mode;
1966 0 : if (is_compound) mi->bmi[j].as_mv[1].as_int = block[1].as_int;
1967 :
1968 0 : if (num_4x4_h == 2) mi->bmi[j + 2] = mi->bmi[j];
1969 0 : if (num_4x4_w == 2) mi->bmi[j + 1] = mi->bmi[j];
1970 : }
1971 : }
1972 :
1973 0 : mbmi->pred_mv[0].as_int = mi->bmi[3].pred_mv[0].as_int;
1974 0 : mbmi->pred_mv[1].as_int = mi->bmi[3].pred_mv[1].as_int;
1975 0 : mi->mbmi.mode = b_mode;
1976 :
1977 0 : mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int;
1978 0 : mbmi->mv[1].as_int = mi->bmi[3].as_mv[1].as_int;
1979 : } else {
1980 : int_mv ref_mv[2];
1981 0 : ref_mv[0] = nearestmv[0];
1982 0 : ref_mv[1] = nearestmv[1];
1983 :
1984 : #if CONFIG_EXT_INTER
1985 0 : if (is_compound) {
1986 0 : int ref_mv_idx = mbmi->ref_mv_idx;
1987 : // Special case: NEAR_NEWMV and NEW_NEARMV modes use
1988 : // 1 + mbmi->ref_mv_idx (like NEARMV) instead of
1989 : // mbmi->ref_mv_idx (like NEWMV)
1990 0 : if (mbmi->mode == NEAR_NEWMV || mbmi->mode == NEW_NEARMV)
1991 0 : ref_mv_idx = 1 + mbmi->ref_mv_idx;
1992 :
1993 0 : if (compound_ref0_mode(mbmi->mode) == NEWMV) {
1994 0 : uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
1995 0 : if (xd->ref_mv_count[ref_frame_type] > 1) {
1996 0 : ref_mv[0] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv;
1997 0 : clamp_mv_ref(&ref_mv[0].as_mv, xd->n8_w << MI_SIZE_LOG2,
1998 0 : xd->n8_h << MI_SIZE_LOG2, xd);
1999 : }
2000 0 : nearestmv[0] = ref_mv[0];
2001 : }
2002 0 : if (compound_ref1_mode(mbmi->mode) == NEWMV) {
2003 0 : uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
2004 0 : if (xd->ref_mv_count[ref_frame_type] > 1) {
2005 0 : ref_mv[1] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].comp_mv;
2006 0 : clamp_mv_ref(&ref_mv[1].as_mv, xd->n8_w << MI_SIZE_LOG2,
2007 0 : xd->n8_h << MI_SIZE_LOG2, xd);
2008 : }
2009 0 : nearestmv[1] = ref_mv[1];
2010 : }
2011 : } else {
2012 : #endif // CONFIG_EXT_INTER
2013 0 : if (mbmi->mode == NEWMV) {
2014 0 : for (ref = 0; ref < 1 + is_compound; ++ref) {
2015 0 : uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
2016 0 : if (xd->ref_mv_count[ref_frame_type] > 1) {
2017 0 : ref_mv[ref] =
2018 : (ref == 0)
2019 0 : ? xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].this_mv
2020 0 : : xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx]
2021 0 : .comp_mv;
2022 0 : clamp_mv_ref(&ref_mv[ref].as_mv, xd->n8_w << MI_SIZE_LOG2,
2023 0 : xd->n8_h << MI_SIZE_LOG2, xd);
2024 : }
2025 0 : nearestmv[ref] = ref_mv[ref];
2026 : }
2027 : }
2028 : #if CONFIG_EXT_INTER
2029 : }
2030 : #endif // CONFIG_EXT_INTER
2031 :
2032 0 : int mv_corrupted_flag =
2033 0 : !assign_mv(cm, xd, mbmi->mode, mbmi->ref_frame, 0, mbmi->mv, ref_mv,
2034 : nearestmv, nearmv, mi_row, mi_col, is_compound, allow_hp, r);
2035 0 : aom_merge_corrupted_flag(&xd->corrupted, mv_corrupted_flag);
2036 : }
2037 :
2038 : #if CONFIG_EXT_INTER && CONFIG_INTERINTRA
2039 0 : mbmi->use_wedge_interintra = 0;
2040 0 : if (cm->reference_mode != COMPOUND_REFERENCE &&
2041 : #if CONFIG_SUPERTX
2042 : !supertx_enabled &&
2043 : #endif
2044 0 : cm->allow_interintra_compound && is_interintra_allowed(mbmi)) {
2045 0 : const int bsize_group = size_group_lookup[bsize];
2046 0 : const int interintra =
2047 0 : aom_read(r, cm->fc->interintra_prob[bsize_group], ACCT_STR);
2048 0 : if (xd->counts) xd->counts->interintra[bsize_group][interintra]++;
2049 0 : assert(mbmi->ref_frame[1] == NONE_FRAME);
2050 0 : if (interintra) {
2051 0 : const INTERINTRA_MODE interintra_mode =
2052 : read_interintra_mode(cm, xd, r, bsize_group);
2053 0 : mbmi->ref_frame[1] = INTRA_FRAME;
2054 0 : mbmi->interintra_mode = interintra_mode;
2055 : #if CONFIG_EXT_INTRA
2056 0 : mbmi->angle_delta[0] = 0;
2057 0 : mbmi->angle_delta[1] = 0;
2058 : #if CONFIG_INTRA_INTERP
2059 : mbmi->intra_filter = INTRA_FILTER_LINEAR;
2060 : #endif // CONFIG_INTRA_INTERP
2061 : #endif // CONFIG_EXT_INTRA
2062 : #if CONFIG_FILTER_INTRA
2063 : mbmi->filter_intra_mode_info.use_filter_intra_mode[0] = 0;
2064 : mbmi->filter_intra_mode_info.use_filter_intra_mode[1] = 0;
2065 : #endif // CONFIG_FILTER_INTRA
2066 0 : if (is_interintra_wedge_used(bsize)) {
2067 0 : mbmi->use_wedge_interintra =
2068 0 : aom_read(r, cm->fc->wedge_interintra_prob[bsize], ACCT_STR);
2069 0 : if (xd->counts)
2070 0 : xd->counts->wedge_interintra[bsize][mbmi->use_wedge_interintra]++;
2071 0 : if (mbmi->use_wedge_interintra) {
2072 0 : mbmi->interintra_wedge_index =
2073 0 : aom_read_literal(r, get_wedge_bits_lookup(bsize), ACCT_STR);
2074 0 : mbmi->interintra_wedge_sign = 0;
2075 : }
2076 : }
2077 : }
2078 : }
2079 : #endif // CONFIG_EXT_INTER && CONFIG_INTERINTRA
2080 :
2081 : #if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
2082 0 : mbmi->motion_mode = SIMPLE_TRANSLATION;
2083 : #if CONFIG_WARPED_MOTION
2084 0 : if (mbmi->sb_type >= BLOCK_8X8 && !has_second_ref(mbmi))
2085 0 : mbmi->num_proj_ref[0] = findSamples(cm, xd, mi_row, mi_col, pts, pts_inref);
2086 : #endif // CONFIG_WARPED_MOTION
2087 : #if CONFIG_MOTION_VAR
2088 0 : av1_count_overlappable_neighbors(cm, xd, mi_row, mi_col);
2089 : #endif
2090 :
2091 : #if CONFIG_SUPERTX
2092 : if (!supertx_enabled) {
2093 : #endif // CONFIG_SUPERTX
2094 : #if CONFIG_EXT_INTER
2095 0 : if (mbmi->ref_frame[1] != INTRA_FRAME)
2096 : #endif // CONFIG_EXT_INTER
2097 0 : mbmi->motion_mode = read_motion_mode(cm, xd, mi, r);
2098 : #if CONFIG_WARPED_MOTION
2099 0 : if (mbmi->motion_mode == WARPED_CAUSAL) {
2100 0 : mbmi->wm_params[0].wmtype = DEFAULT_WMTYPE;
2101 0 : if (find_projection(mbmi->num_proj_ref[0], pts, pts_inref, bsize,
2102 0 : mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col,
2103 : &mbmi->wm_params[0], mi_row, mi_col)) {
2104 0 : assert(0 && "Invalid Warped Model.");
2105 : }
2106 : }
2107 : #endif // CONFIG_WARPED_MOTION
2108 : #if CONFIG_SUPERTX
2109 : }
2110 : #endif // CONFIG_SUPERTX
2111 : #endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
2112 :
2113 : #if CONFIG_EXT_INTER
2114 0 : mbmi->interinter_compound_type = COMPOUND_AVERAGE;
2115 0 : if (cm->reference_mode != SINGLE_REFERENCE &&
2116 0 : is_inter_compound_mode(mbmi->mode)
2117 : #if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
2118 0 : && mbmi->motion_mode == SIMPLE_TRANSLATION
2119 : #endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
2120 : ) {
2121 0 : if (is_any_masked_compound_used(bsize)) {
2122 : #if CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE
2123 0 : if (cm->allow_masked_compound) {
2124 0 : mbmi->interinter_compound_type =
2125 0 : aom_read_tree(r, av1_compound_type_tree,
2126 : cm->fc->compound_type_prob[bsize], ACCT_STR);
2127 : #if CONFIG_WEDGE
2128 0 : if (mbmi->interinter_compound_type == COMPOUND_WEDGE) {
2129 0 : mbmi->wedge_index =
2130 0 : aom_read_literal(r, get_wedge_bits_lookup(bsize), ACCT_STR);
2131 0 : mbmi->wedge_sign = aom_read_bit(r, ACCT_STR);
2132 : }
2133 : #endif // CONFIG_WEDGE
2134 : #if CONFIG_COMPOUND_SEGMENT
2135 0 : if (mbmi->interinter_compound_type == COMPOUND_SEG) {
2136 0 : mbmi->mask_type = aom_read_literal(r, MAX_SEG_MASK_BITS, ACCT_STR);
2137 : }
2138 : #endif // CONFIG_COMPOUND_SEGMENT
2139 : }
2140 : #endif // CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE
2141 : } else {
2142 0 : mbmi->interinter_compound_type = COMPOUND_AVERAGE;
2143 : }
2144 0 : if (xd->counts)
2145 0 : xd->counts->compound_interinter[bsize][mbmi->interinter_compound_type]++;
2146 : }
2147 : #endif // CONFIG_EXT_INTER
2148 :
2149 : #if CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION
2150 0 : read_mb_interp_filter(cm, xd, mbmi, r);
2151 : #endif // CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION
2152 : }
2153 :
2154 0 : static void read_inter_frame_mode_info(AV1Decoder *const pbi,
2155 : MACROBLOCKD *const xd,
2156 : #if CONFIG_SUPERTX
2157 : int supertx_enabled,
2158 : #endif // CONFIG_SUPERTX
2159 : int mi_row, int mi_col, aom_reader *r) {
2160 0 : AV1_COMMON *const cm = &pbi->common;
2161 0 : MODE_INFO *const mi = xd->mi[0];
2162 0 : MB_MODE_INFO *const mbmi = &mi->mbmi;
2163 0 : int inter_block = 1;
2164 : #if CONFIG_VAR_TX
2165 0 : BLOCK_SIZE bsize = mbmi->sb_type;
2166 : #endif // CONFIG_VAR_TX
2167 :
2168 0 : mbmi->mv[0].as_int = 0;
2169 0 : mbmi->mv[1].as_int = 0;
2170 0 : mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, r);
2171 : #if CONFIG_SUPERTX
2172 : if (!supertx_enabled)
2173 : #endif // CONFIG_SUPERTX
2174 0 : mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
2175 :
2176 : #if CONFIG_DELTA_Q
2177 0 : if (cm->delta_q_present_flag) {
2178 0 : xd->current_qindex =
2179 0 : xd->prev_qindex +
2180 0 : read_delta_qindex(cm, xd, r, mbmi, mi_col, mi_row) * cm->delta_q_res;
2181 : /* Normative: Clamp to [1,MAXQ] to not interfere with lossless mode */
2182 0 : xd->current_qindex = clamp(xd->current_qindex, 1, MAXQ);
2183 0 : xd->prev_qindex = xd->current_qindex;
2184 : #if CONFIG_EXT_DELTA_Q
2185 0 : if (cm->delta_lf_present_flag) {
2186 0 : mbmi->current_delta_lf_from_base = xd->current_delta_lf_from_base =
2187 0 : xd->prev_delta_lf_from_base +
2188 0 : read_delta_lflevel(cm, xd, r, mbmi, mi_col, mi_row) *
2189 0 : cm->delta_lf_res;
2190 0 : xd->prev_delta_lf_from_base = xd->current_delta_lf_from_base;
2191 : }
2192 : #endif
2193 : }
2194 : #endif
2195 :
2196 : #if CONFIG_SUPERTX
2197 : if (!supertx_enabled) {
2198 : #endif // CONFIG_SUPERTX
2199 0 : inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
2200 :
2201 : #if CONFIG_VAR_TX
2202 0 : xd->above_txfm_context =
2203 0 : cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
2204 0 : xd->left_txfm_context = xd->left_txfm_context_buffer +
2205 0 : ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2);
2206 :
2207 0 : if (cm->tx_mode == TX_MODE_SELECT &&
2208 : #if CONFIG_CB4X4
2209 0 : bsize > BLOCK_4X4 &&
2210 : #else
2211 : bsize >= BLOCK_8X8 &&
2212 : #endif
2213 0 : !mbmi->skip && inter_block) {
2214 0 : const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
2215 0 : const int bh = tx_size_high_unit[max_tx_size];
2216 0 : const int bw = tx_size_wide_unit[max_tx_size];
2217 0 : const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
2218 0 : const int height = block_size_high[bsize] >> tx_size_wide_log2[0];
2219 : int idx, idy;
2220 :
2221 0 : mbmi->min_tx_size = TX_SIZES_ALL;
2222 0 : for (idy = 0; idy < height; idy += bh)
2223 0 : for (idx = 0; idx < width; idx += bw)
2224 0 : read_tx_size_vartx(cm, xd, mbmi, xd->counts, max_tx_size,
2225 : height != width, idy, idx, r);
2226 : } else {
2227 0 : mbmi->tx_size = read_tx_size(cm, xd, inter_block, !mbmi->skip, r);
2228 :
2229 0 : if (inter_block) {
2230 0 : const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
2231 0 : const int height = block_size_high[bsize] >> tx_size_high_log2[0];
2232 : int idx, idy;
2233 0 : for (idy = 0; idy < height; ++idy)
2234 0 : for (idx = 0; idx < width; ++idx)
2235 0 : mbmi->inter_tx_size[idy >> 1][idx >> 1] = mbmi->tx_size;
2236 : }
2237 0 : mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
2238 0 : set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, mbmi->skip, xd);
2239 : }
2240 : #else
2241 : mbmi->tx_size = read_tx_size(cm, xd, inter_block, !mbmi->skip, r);
2242 : #endif // CONFIG_VAR_TX
2243 : #if CONFIG_SUPERTX
2244 : }
2245 : #if CONFIG_VAR_TX
2246 : else if (inter_block) {
2247 : const int width = num_4x4_blocks_wide_lookup[bsize];
2248 : const int height = num_4x4_blocks_high_lookup[bsize];
2249 : int idx, idy;
2250 : xd->mi[0]->mbmi.tx_size = xd->supertx_size;
2251 : for (idy = 0; idy < height; ++idy)
2252 : for (idx = 0; idx < width; ++idx)
2253 : xd->mi[0]->mbmi.inter_tx_size[idy >> 1][idx >> 1] = xd->supertx_size;
2254 : }
2255 : #endif // CONFIG_VAR_TX
2256 : #endif // CONFIG_SUPERTX
2257 :
2258 0 : if (inter_block)
2259 0 : read_inter_block_mode_info(pbi, xd,
2260 : #if (CONFIG_MOTION_VAR || CONFIG_EXT_INTER || CONFIG_WARPED_MOTION) && \
2261 : CONFIG_SUPERTX
2262 :
2263 : mi, mi_row, mi_col, r, supertx_enabled);
2264 : #else
2265 : mi, mi_row, mi_col, r);
2266 : #endif // CONFIG_MOTION_VAR && CONFIG_SUPERTX
2267 : else
2268 0 : read_intra_block_mode_info(cm, mi_row, mi_col, xd, mi, r);
2269 :
2270 : #if !CONFIG_TXK_SEL
2271 0 : av1_read_tx_type(cm, xd,
2272 : #if CONFIG_SUPERTX
2273 : supertx_enabled,
2274 : #endif
2275 : r);
2276 : #endif // !CONFIG_TXK_SEL
2277 0 : }
2278 :
2279 0 : void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd,
2280 : #if CONFIG_SUPERTX
2281 : int supertx_enabled,
2282 : #endif // CONFIG_SUPERTX
2283 : int mi_row, int mi_col, aom_reader *r, int x_mis,
2284 : int y_mis) {
2285 0 : AV1_COMMON *const cm = &pbi->common;
2286 0 : MODE_INFO *const mi = xd->mi[0];
2287 0 : MV_REF *frame_mvs = cm->cur_frame->mvs + mi_row * cm->mi_cols + mi_col;
2288 : int w, h;
2289 :
2290 : #if CONFIG_INTRABC
2291 : mi->mbmi.use_intrabc = 0;
2292 : #endif // CONFIG_INTRABC
2293 :
2294 0 : if (frame_is_intra_only(cm)) {
2295 0 : read_intra_frame_mode_info(cm, xd, mi_row, mi_col, r);
2296 0 : for (h = 0; h < y_mis; ++h) {
2297 0 : MV_REF *const frame_mv = frame_mvs + h * cm->mi_cols;
2298 0 : for (w = 0; w < x_mis; ++w) {
2299 0 : MV_REF *const mv = frame_mv + w;
2300 0 : mv->ref_frame[0] = NONE_FRAME;
2301 0 : mv->ref_frame[1] = NONE_FRAME;
2302 : }
2303 : }
2304 : } else {
2305 0 : read_inter_frame_mode_info(pbi, xd,
2306 : #if CONFIG_SUPERTX
2307 : supertx_enabled,
2308 : #endif // CONFIG_SUPERTX
2309 : mi_row, mi_col, r);
2310 0 : for (h = 0; h < y_mis; ++h) {
2311 0 : MV_REF *const frame_mv = frame_mvs + h * cm->mi_cols;
2312 0 : for (w = 0; w < x_mis; ++w) {
2313 0 : MV_REF *const mv = frame_mv + w;
2314 0 : mv->ref_frame[0] = mi->mbmi.ref_frame[0];
2315 0 : mv->ref_frame[1] = mi->mbmi.ref_frame[1];
2316 0 : mv->mv[0].as_int = mi->mbmi.mv[0].as_int;
2317 0 : mv->mv[1].as_int = mi->mbmi.mv[1].as_int;
2318 0 : mv->pred_mv[0].as_int = mi->mbmi.pred_mv[0].as_int;
2319 0 : mv->pred_mv[1].as_int = mi->mbmi.pred_mv[1].as_int;
2320 : }
2321 : }
2322 : }
2323 0 : }
|
