| File: | root/firefox-clang/third_party/aom/av1/common/mvref_common.c |
| Warning: | line 1322, column 9 Excessive padding in 'REF_FRAME_INFO' (8 padding bytes, where 0 is optimal). Optimal fields order: buf, map_idx, sort_idx, consider reordering the fields or adding explicit padding members |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 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 <stdlib.h> |
| 13 | |
| 14 | #include "av1/common/mvref_common.h" |
| 15 | #include "av1/common/warped_motion.h" |
| 16 | |
| 17 | // Although we assign 32 bit integers, all the values are strictly under 14 |
| 18 | // bits. |
| 19 | static const int div_mult[32] = { 0, 16384, 8192, 5461, 4096, 3276, 2730, |
| 20 | 2340, 2048, 1820, 1638, 1489, 1365, 1260, |
| 21 | 1170, 1092, 1024, 963, 910, 862, 819, |
| 22 | 780, 744, 712, 682, 655, 630, 606, |
| 23 | 585, 564, 546, 528 }; |
| 24 | |
| 25 | // TODO(jingning): Consider the use of lookup table for (num / den) |
| 26 | // altogether. |
| 27 | void av1_get_mv_projection(MV *output, MV ref, int num, int den) { |
| 28 | den = AOMMIN(den, MAX_FRAME_DISTANCE)(((den) < (((1 << 5) - 1))) ? (den) : (((1 << 5 ) - 1))); |
| 29 | num = num > 0 ? AOMMIN(num, MAX_FRAME_DISTANCE)(((num) < (((1 << 5) - 1))) ? (num) : (((1 << 5 ) - 1))) |
| 30 | : AOMMAX(num, -MAX_FRAME_DISTANCE)(((num) > (-((1 << 5) - 1))) ? (num) : (-((1 << 5) - 1))); |
| 31 | const int mv_row = |
| 32 | ROUND_POWER_OF_TWO_SIGNED(ref.row * num * div_mult[den], 14)(((ref.row * num * div_mult[den]) < 0) ? -(((-(ref.row * num * div_mult[den])) + (((1 << ((14))) >> 1))) >> ((14))) : ((((ref.row * num * div_mult[den])) + (((1 << ((14))) >> 1))) >> ((14)))); |
| 33 | const int mv_col = |
| 34 | ROUND_POWER_OF_TWO_SIGNED(ref.col * num * div_mult[den], 14)(((ref.col * num * div_mult[den]) < 0) ? -(((-(ref.col * num * div_mult[den])) + (((1 << ((14))) >> 1))) >> ((14))) : ((((ref.col * num * div_mult[den])) + (((1 << ((14))) >> 1))) >> ((14)))); |
| 35 | const int clamp_max = MV_UPP(1 << 14) - 1; |
| 36 | const int clamp_min = MV_LOW(-(1 << 14)) + 1; |
| 37 | output->row = (int16_t)clamp(mv_row, clamp_min, clamp_max); |
| 38 | output->col = (int16_t)clamp(mv_col, clamp_min, clamp_max); |
| 39 | } |
| 40 | |
| 41 | void av1_copy_frame_mvs(const AV1_COMMON *const cm, |
| 42 | const MB_MODE_INFO *const mi, int mi_row, int mi_col, |
| 43 | int x_mis, int y_mis) { |
| 44 | const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, 1)(((cm->mi_params.mi_cols) + (((1 << (1)) >> 1) )) >> (1)); |
| 45 | MV_REF *frame_mvs = |
| 46 | cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1); |
| 47 | x_mis = ROUND_POWER_OF_TWO(x_mis, 1)(((x_mis) + (((1 << (1)) >> 1))) >> (1)); |
| 48 | y_mis = ROUND_POWER_OF_TWO(y_mis, 1)(((y_mis) + (((1 << (1)) >> 1))) >> (1)); |
| 49 | int w, h; |
| 50 | |
| 51 | for (h = 0; h < y_mis; h++) { |
| 52 | MV_REF *mv = frame_mvs; |
| 53 | for (w = 0; w < x_mis; w++) { |
| 54 | mv->ref_frame = NONE_FRAME; |
| 55 | mv->mv.as_int = 0; |
| 56 | |
| 57 | for (int idx = 0; idx < 2; ++idx) { |
| 58 | MV_REFERENCE_FRAME ref_frame = mi->ref_frame[idx]; |
| 59 | if (ref_frame > INTRA_FRAME) { |
| 60 | int8_t ref_idx = cm->ref_frame_side[ref_frame]; |
| 61 | if (ref_idx) continue; |
| 62 | if ((abs(mi->mv[idx].as_mv.row) > REFMVS_LIMIT((1 << 12) - 1)) || |
| 63 | (abs(mi->mv[idx].as_mv.col) > REFMVS_LIMIT((1 << 12) - 1))) |
| 64 | continue; |
| 65 | mv->ref_frame = ref_frame; |
| 66 | mv->mv.as_int = mi->mv[idx].as_int; |
| 67 | } |
| 68 | } |
| 69 | mv++; |
| 70 | } |
| 71 | frame_mvs += frame_mvs_stride; |
| 72 | } |
| 73 | } |
| 74 | |
| 75 | static inline void add_ref_mv_candidate( |
| 76 | const MB_MODE_INFO *const candidate, const MV_REFERENCE_FRAME rf[2], |
| 77 | uint8_t *refmv_count, uint8_t *ref_match_count, uint8_t *newmv_count, |
| 78 | CANDIDATE_MV *ref_mv_stack, uint16_t *ref_mv_weight, |
| 79 | int_mv *gm_mv_candidates, const WarpedMotionParams *gm_params, |
| 80 | uint16_t weight) { |
| 81 | if (!is_inter_block(candidate)) return; |
| 82 | assert(weight % 2 == 0)((void) sizeof ((weight % 2 == 0) ? 1 : 0), __extension__ ({ if (weight % 2 == 0) ; else __assert_fail ("weight % 2 == 0", "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 82, __extension__ __PRETTY_FUNCTION__); })); |
| 83 | int index, ref; |
| 84 | |
| 85 | if (rf[1] == NONE_FRAME) { |
| 86 | // single reference frame |
| 87 | for (ref = 0; ref < 2; ++ref) { |
| 88 | if (candidate->ref_frame[ref] == rf[0]) { |
| 89 | const int is_gm_block = |
| 90 | is_global_mv_block(candidate, gm_params[rf[0]].wmtype); |
| 91 | const int_mv this_refmv = |
| 92 | is_gm_block ? gm_mv_candidates[0] : get_block_mv(candidate, ref); |
| 93 | for (index = 0; index < *refmv_count; ++index) { |
| 94 | if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) { |
| 95 | ref_mv_weight[index] += weight; |
| 96 | break; |
| 97 | } |
| 98 | } |
| 99 | |
| 100 | // Add a new item to the list. |
| 101 | if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE8) { |
| 102 | ref_mv_stack[index].this_mv = this_refmv; |
| 103 | ref_mv_weight[index] = weight; |
| 104 | ++(*refmv_count); |
| 105 | } |
| 106 | if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; |
| 107 | ++*ref_match_count; |
| 108 | } |
| 109 | } |
| 110 | } else { |
| 111 | // compound reference frame |
| 112 | if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) { |
| 113 | int_mv this_refmv[2]; |
| 114 | |
| 115 | for (ref = 0; ref < 2; ++ref) { |
| 116 | if (is_global_mv_block(candidate, gm_params[rf[ref]].wmtype)) |
| 117 | this_refmv[ref] = gm_mv_candidates[ref]; |
| 118 | else |
| 119 | this_refmv[ref] = get_block_mv(candidate, ref); |
| 120 | } |
| 121 | |
| 122 | for (index = 0; index < *refmv_count; ++index) { |
| 123 | if ((ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int) && |
| 124 | (ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int)) { |
| 125 | ref_mv_weight[index] += weight; |
| 126 | break; |
| 127 | } |
| 128 | } |
| 129 | |
| 130 | // Add a new item to the list. |
| 131 | if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE8) { |
| 132 | ref_mv_stack[index].this_mv = this_refmv[0]; |
| 133 | ref_mv_stack[index].comp_mv = this_refmv[1]; |
| 134 | ref_mv_weight[index] = weight; |
| 135 | ++(*refmv_count); |
| 136 | } |
| 137 | if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; |
| 138 | ++*ref_match_count; |
| 139 | } |
| 140 | } |
| 141 | } |
| 142 | |
| 143 | static inline void scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
| 144 | int mi_col, const MV_REFERENCE_FRAME rf[2], |
| 145 | int row_offset, CANDIDATE_MV *ref_mv_stack, |
| 146 | uint16_t *ref_mv_weight, uint8_t *refmv_count, |
| 147 | uint8_t *ref_match_count, uint8_t *newmv_count, |
| 148 | int_mv *gm_mv_candidates, int max_row_offset, |
| 149 | int *processed_rows) { |
| 150 | int end_mi = AOMMIN(xd->width, cm->mi_params.mi_cols - mi_col)(((xd->width) < (cm->mi_params.mi_cols - mi_col)) ? ( xd->width) : (cm->mi_params.mi_cols - mi_col)); |
| 151 | end_mi = AOMMIN(end_mi, mi_size_wide[BLOCK_64X64])(((end_mi) < (mi_size_wide[BLOCK_64X64])) ? (end_mi) : (mi_size_wide [BLOCK_64X64])); |
| 152 | const int width_8x8 = mi_size_wide[BLOCK_8X8]; |
| 153 | const int width_16x16 = mi_size_wide[BLOCK_16X16]; |
| 154 | int col_offset = 0; |
| 155 | // TODO(jingning): Revisit this part after cb4x4 is stable. |
| 156 | if (abs(row_offset) > 1) { |
| 157 | col_offset = 1; |
| 158 | if ((mi_col & 0x01) && xd->width < width_8x8) --col_offset; |
| 159 | } |
| 160 | const int use_step_16 = (xd->width >= 16); |
| 161 | MB_MODE_INFO **const candidate_mi0 = xd->mi + row_offset * xd->mi_stride; |
| 162 | |
| 163 | for (int i = 0; i < end_mi;) { |
| 164 | const MB_MODE_INFO *const candidate = candidate_mi0[col_offset + i]; |
| 165 | const int candidate_bsize = candidate->bsize; |
| 166 | const int n4_w = mi_size_wide[candidate_bsize]; |
| 167 | int len = AOMMIN(xd->width, n4_w)(((xd->width) < (n4_w)) ? (xd->width) : (n4_w)); |
| 168 | if (use_step_16) |
| 169 | len = AOMMAX(width_16x16, len)(((width_16x16) > (len)) ? (width_16x16) : (len)); |
| 170 | else if (abs(row_offset) > 1) |
| 171 | len = AOMMAX(len, width_8x8)(((len) > (width_8x8)) ? (len) : (width_8x8)); |
| 172 | |
| 173 | uint16_t weight = 2; |
| 174 | if (xd->width >= width_8x8 && xd->width <= n4_w) { |
| 175 | uint16_t inc = AOMMIN(-max_row_offset + row_offset + 1,(((-max_row_offset + row_offset + 1) < (mi_size_high[candidate_bsize ])) ? (-max_row_offset + row_offset + 1) : (mi_size_high[candidate_bsize ])) |
| 176 | mi_size_high[candidate_bsize])(((-max_row_offset + row_offset + 1) < (mi_size_high[candidate_bsize ])) ? (-max_row_offset + row_offset + 1) : (mi_size_high[candidate_bsize ])); |
| 177 | // Obtain range used in weight calculation. |
| 178 | weight = AOMMAX(weight, inc)(((weight) > (inc)) ? (weight) : (inc)); |
| 179 | // Update processed rows. |
| 180 | *processed_rows = inc - row_offset - 1; |
| 181 | } |
| 182 | |
| 183 | add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, |
| 184 | newmv_count, ref_mv_stack, ref_mv_weight, |
| 185 | gm_mv_candidates, cm->global_motion, len * weight); |
| 186 | |
| 187 | i += len; |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | static inline void scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
| 192 | int mi_row, const MV_REFERENCE_FRAME rf[2], |
| 193 | int col_offset, CANDIDATE_MV *ref_mv_stack, |
| 194 | uint16_t *ref_mv_weight, uint8_t *refmv_count, |
| 195 | uint8_t *ref_match_count, uint8_t *newmv_count, |
| 196 | int_mv *gm_mv_candidates, int max_col_offset, |
| 197 | int *processed_cols) { |
| 198 | int end_mi = AOMMIN(xd->height, cm->mi_params.mi_rows - mi_row)(((xd->height) < (cm->mi_params.mi_rows - mi_row)) ? (xd->height) : (cm->mi_params.mi_rows - mi_row)); |
| 199 | end_mi = AOMMIN(end_mi, mi_size_high[BLOCK_64X64])(((end_mi) < (mi_size_high[BLOCK_64X64])) ? (end_mi) : (mi_size_high [BLOCK_64X64])); |
| 200 | const int n8_h_8 = mi_size_high[BLOCK_8X8]; |
| 201 | const int n8_h_16 = mi_size_high[BLOCK_16X16]; |
| 202 | int i; |
| 203 | int row_offset = 0; |
| 204 | if (abs(col_offset) > 1) { |
| 205 | row_offset = 1; |
| 206 | if ((mi_row & 0x01) && xd->height < n8_h_8) --row_offset; |
| 207 | } |
| 208 | const int use_step_16 = (xd->height >= 16); |
| 209 | |
| 210 | for (i = 0; i < end_mi;) { |
| 211 | const MB_MODE_INFO *const candidate = |
| 212 | xd->mi[(row_offset + i) * xd->mi_stride + col_offset]; |
| 213 | const int candidate_bsize = candidate->bsize; |
| 214 | const int n4_h = mi_size_high[candidate_bsize]; |
| 215 | int len = AOMMIN(xd->height, n4_h)(((xd->height) < (n4_h)) ? (xd->height) : (n4_h)); |
| 216 | if (use_step_16) |
| 217 | len = AOMMAX(n8_h_16, len)(((n8_h_16) > (len)) ? (n8_h_16) : (len)); |
| 218 | else if (abs(col_offset) > 1) |
| 219 | len = AOMMAX(len, n8_h_8)(((len) > (n8_h_8)) ? (len) : (n8_h_8)); |
| 220 | |
| 221 | int weight = 2; |
| 222 | if (xd->height >= n8_h_8 && xd->height <= n4_h) { |
| 223 | int inc = AOMMIN(-max_col_offset + col_offset + 1,(((-max_col_offset + col_offset + 1) < (mi_size_wide[candidate_bsize ])) ? (-max_col_offset + col_offset + 1) : (mi_size_wide[candidate_bsize ])) |
| 224 | mi_size_wide[candidate_bsize])(((-max_col_offset + col_offset + 1) < (mi_size_wide[candidate_bsize ])) ? (-max_col_offset + col_offset + 1) : (mi_size_wide[candidate_bsize ])); |
| 225 | // Obtain range used in weight calculation. |
| 226 | weight = AOMMAX(weight, inc)(((weight) > (inc)) ? (weight) : (inc)); |
| 227 | // Update processed cols. |
| 228 | *processed_cols = inc - col_offset - 1; |
| 229 | } |
| 230 | |
| 231 | add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, |
| 232 | newmv_count, ref_mv_stack, ref_mv_weight, |
| 233 | gm_mv_candidates, cm->global_motion, len * weight); |
| 234 | |
| 235 | i += len; |
| 236 | } |
| 237 | } |
| 238 | |
| 239 | static inline void scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
| 240 | const int mi_row, const int mi_col, |
| 241 | const MV_REFERENCE_FRAME rf[2], int row_offset, |
| 242 | int col_offset, CANDIDATE_MV *ref_mv_stack, |
| 243 | uint16_t *ref_mv_weight, |
| 244 | uint8_t *ref_match_count, uint8_t *newmv_count, |
| 245 | int_mv *gm_mv_candidates, |
| 246 | uint8_t *refmv_count) { |
| 247 | const TileInfo *const tile = &xd->tile; |
| 248 | POSITION mi_pos; |
| 249 | |
| 250 | mi_pos.row = row_offset; |
| 251 | mi_pos.col = col_offset; |
| 252 | |
| 253 | if (is_inside(tile, mi_col, mi_row, &mi_pos)) { |
| 254 | const MB_MODE_INFO *const candidate = |
| 255 | xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col]; |
| 256 | const int len = mi_size_wide[BLOCK_8X8]; |
| 257 | |
| 258 | add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, |
| 259 | newmv_count, ref_mv_stack, ref_mv_weight, |
| 260 | gm_mv_candidates, cm->global_motion, 2 * len); |
| 261 | } // Analyze a single 8x8 block motion information. |
| 262 | } |
| 263 | |
| 264 | static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
| 265 | int mi_row, int mi_col, int bs) { |
| 266 | const int sb_mi_size = mi_size_wide[cm->seq_params->sb_size]; |
| 267 | const int mask_row = mi_row & (sb_mi_size - 1); |
| 268 | const int mask_col = mi_col & (sb_mi_size - 1); |
| 269 | |
| 270 | if (bs > mi_size_wide[BLOCK_64X64]) return 0; |
| 271 | |
| 272 | // In a split partition all apart from the bottom right has a top right |
| 273 | int has_tr = !((mask_row & bs) && (mask_col & bs)); |
| 274 | |
| 275 | // bs > 0 and bs is a power of 2 |
| 276 | assert(bs > 0 && !(bs & (bs - 1)))((void) sizeof ((bs > 0 && !(bs & (bs - 1))) ? 1 : 0), __extension__ ({ if (bs > 0 && !(bs & (bs - 1))) ; else __assert_fail ("bs > 0 && !(bs & (bs - 1))" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 276, __extension__ __PRETTY_FUNCTION__); })); |
| 277 | |
| 278 | // For each 4x4 group of blocks, when the bottom right is decoded the blocks |
| 279 | // to the right have not been decoded therefore the bottom right does |
| 280 | // not have a top right |
| 281 | while (bs < sb_mi_size) { |
| 282 | if (mask_col & bs) { |
| 283 | if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) { |
| 284 | has_tr = 0; |
| 285 | break; |
| 286 | } |
| 287 | } else { |
| 288 | break; |
| 289 | } |
| 290 | bs <<= 1; |
| 291 | } |
| 292 | |
| 293 | // In a VERTICAL or VERTICAL_4 partition, all partition before the last one |
| 294 | // always have a top right (as the block above will have been decoded). |
| 295 | if (xd->width < xd->height) { |
| 296 | if (!xd->is_last_vertical_rect) has_tr = 1; |
| 297 | } |
| 298 | |
| 299 | // In a HORIZONTAL or HORIZONTAL_4 partition, partitions after the first one |
| 300 | // never have a top right (as the block to the right won't have been decoded). |
| 301 | if (xd->width > xd->height) { |
| 302 | if (!xd->is_first_horizontal_rect) has_tr = 0; |
| 303 | } |
| 304 | |
| 305 | // The bottom left square of a Vertical A (in the old format) does |
| 306 | // not have a top right as it is decoded before the right hand |
| 307 | // rectangle of the partition |
| 308 | if (xd->mi[0]->partition == PARTITION_VERT_A) { |
| 309 | if (xd->width == xd->height) |
| 310 | if (mask_row & bs) has_tr = 0; |
| 311 | } |
| 312 | |
| 313 | return has_tr; |
| 314 | } |
| 315 | |
| 316 | static int check_sb_border(const int mi_row, const int mi_col, |
| 317 | const int row_offset, const int col_offset) { |
| 318 | const int sb_mi_size = mi_size_wide[BLOCK_64X64]; |
| 319 | const int row = mi_row & (sb_mi_size - 1); |
| 320 | const int col = mi_col & (sb_mi_size - 1); |
| 321 | |
| 322 | if (row + row_offset < 0 || row + row_offset >= sb_mi_size || |
| 323 | col + col_offset < 0 || col + col_offset >= sb_mi_size) |
| 324 | return 0; |
| 325 | |
| 326 | return 1; |
| 327 | } |
| 328 | |
| 329 | static int add_tpl_ref_mv(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
| 330 | int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame, |
| 331 | int blk_row, int blk_col, int_mv *gm_mv_candidates, |
| 332 | uint8_t *const refmv_count, |
| 333 | CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE8], |
| 334 | uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE8], |
| 335 | int16_t *mode_context) { |
| 336 | POSITION mi_pos; |
| 337 | mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1; |
| 338 | mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1; |
| 339 | |
| 340 | if (!is_inside(&xd->tile, mi_col, mi_row, &mi_pos)) return 0; |
| 341 | |
| 342 | const TPL_MV_REF *prev_frame_mvs = |
| 343 | cm->tpl_mvs + |
| 344 | ((mi_row + mi_pos.row) >> 1) * (cm->mi_params.mi_stride >> 1) + |
| 345 | ((mi_col + mi_pos.col) >> 1); |
| 346 | if (prev_frame_mvs->mfmv0.as_int == INVALID_MV0x80008000) return 0; |
| 347 | |
| 348 | MV_REFERENCE_FRAME rf[2]; |
| 349 | av1_set_ref_frame(rf, ref_frame); |
| 350 | |
| 351 | const uint16_t weight_unit = 1; // mi_size_wide[BLOCK_8X8]; |
| 352 | const int cur_frame_index = cm->cur_frame->order_hint; |
| 353 | const RefCntBuffer *const buf_0 = get_ref_frame_buf(cm, rf[0]); |
| 354 | const int frame0_index = buf_0->order_hint; |
| 355 | const int cur_offset_0 = get_relative_dist(&cm->seq_params->order_hint_info, |
| 356 | cur_frame_index, frame0_index); |
| 357 | int idx; |
| 358 | const int allow_high_precision_mv = cm->features.allow_high_precision_mv; |
| 359 | const int force_integer_mv = cm->features.cur_frame_force_integer_mv; |
| 360 | |
| 361 | int_mv this_refmv; |
| 362 | av1_get_mv_projection(&this_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, |
| 363 | cur_offset_0, prev_frame_mvs->ref_frame_offset); |
| 364 | lower_mv_precision(&this_refmv.as_mv, allow_high_precision_mv, |
| 365 | force_integer_mv); |
| 366 | |
| 367 | if (rf[1] == NONE_FRAME) { |
| 368 | if (blk_row == 0 && blk_col == 0) { |
| 369 | if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || |
| 370 | abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16) |
| 371 | mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET3); |
| 372 | } |
| 373 | |
| 374 | for (idx = 0; idx < *refmv_count; ++idx) |
| 375 | if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break; |
| 376 | |
| 377 | if (idx < *refmv_count) ref_mv_weight[idx] += 2 * weight_unit; |
| 378 | |
| 379 | if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE8) { |
| 380 | ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; |
| 381 | ref_mv_weight[idx] = 2 * weight_unit; |
| 382 | ++(*refmv_count); |
| 383 | } |
| 384 | } else { |
| 385 | // Process compound inter mode |
| 386 | const RefCntBuffer *const buf_1 = get_ref_frame_buf(cm, rf[1]); |
| 387 | const int frame1_index = buf_1->order_hint; |
| 388 | const int cur_offset_1 = get_relative_dist(&cm->seq_params->order_hint_info, |
| 389 | cur_frame_index, frame1_index); |
| 390 | int_mv comp_refmv; |
| 391 | av1_get_mv_projection(&comp_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, |
| 392 | cur_offset_1, prev_frame_mvs->ref_frame_offset); |
| 393 | lower_mv_precision(&comp_refmv.as_mv, allow_high_precision_mv, |
| 394 | force_integer_mv); |
| 395 | |
| 396 | if (blk_row == 0 && blk_col == 0) { |
| 397 | if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || |
| 398 | abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16 || |
| 399 | abs(comp_refmv.as_mv.row - gm_mv_candidates[1].as_mv.row) >= 16 || |
| 400 | abs(comp_refmv.as_mv.col - gm_mv_candidates[1].as_mv.col) >= 16) |
| 401 | mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET3); |
| 402 | } |
| 403 | |
| 404 | for (idx = 0; idx < *refmv_count; ++idx) { |
| 405 | if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int && |
| 406 | comp_refmv.as_int == ref_mv_stack[idx].comp_mv.as_int) |
| 407 | break; |
| 408 | } |
| 409 | |
| 410 | if (idx < *refmv_count) ref_mv_weight[idx] += 2 * weight_unit; |
| 411 | |
| 412 | if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE8) { |
| 413 | ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; |
| 414 | ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int; |
| 415 | ref_mv_weight[idx] = 2 * weight_unit; |
| 416 | ++(*refmv_count); |
| 417 | } |
| 418 | } |
| 419 | |
| 420 | return 1; |
| 421 | } |
| 422 | |
| 423 | static inline void process_compound_ref_mv_candidate( |
| 424 | const MB_MODE_INFO *const candidate, const AV1_COMMON *const cm, |
| 425 | const MV_REFERENCE_FRAME *const rf, int_mv ref_id[2][2], |
| 426 | int ref_id_count[2], int_mv ref_diff[2][2], int ref_diff_count[2]) { |
| 427 | for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { |
| 428 | MV_REFERENCE_FRAME can_rf = candidate->ref_frame[rf_idx]; |
| 429 | |
| 430 | for (int cmp_idx = 0; cmp_idx < 2; ++cmp_idx) { |
| 431 | if (can_rf == rf[cmp_idx] && ref_id_count[cmp_idx] < 2) { |
| 432 | ref_id[cmp_idx][ref_id_count[cmp_idx]] = candidate->mv[rf_idx]; |
| 433 | ++ref_id_count[cmp_idx]; |
| 434 | } else if (can_rf > INTRA_FRAME && ref_diff_count[cmp_idx] < 2) { |
| 435 | int_mv this_mv = candidate->mv[rf_idx]; |
| 436 | if (cm->ref_frame_sign_bias[can_rf] != |
| 437 | cm->ref_frame_sign_bias[rf[cmp_idx]]) { |
| 438 | this_mv.as_mv.row = -this_mv.as_mv.row; |
| 439 | this_mv.as_mv.col = -this_mv.as_mv.col; |
| 440 | } |
| 441 | ref_diff[cmp_idx][ref_diff_count[cmp_idx]] = this_mv; |
| 442 | ++ref_diff_count[cmp_idx]; |
| 443 | } |
| 444 | } |
| 445 | } |
| 446 | } |
| 447 | |
| 448 | static inline void process_single_ref_mv_candidate( |
| 449 | const MB_MODE_INFO *const candidate, const AV1_COMMON *const cm, |
| 450 | MV_REFERENCE_FRAME ref_frame, uint8_t *const refmv_count, |
| 451 | CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE8], |
| 452 | uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE8]) { |
| 453 | for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { |
| 454 | if (candidate->ref_frame[rf_idx] > INTRA_FRAME) { |
| 455 | int_mv this_mv = candidate->mv[rf_idx]; |
| 456 | if (cm->ref_frame_sign_bias[candidate->ref_frame[rf_idx]] != |
| 457 | cm->ref_frame_sign_bias[ref_frame]) { |
| 458 | this_mv.as_mv.row = -this_mv.as_mv.row; |
| 459 | this_mv.as_mv.col = -this_mv.as_mv.col; |
| 460 | } |
| 461 | int stack_idx; |
| 462 | for (stack_idx = 0; stack_idx < *refmv_count; ++stack_idx) { |
| 463 | const int_mv stack_mv = ref_mv_stack[stack_idx].this_mv; |
| 464 | if (this_mv.as_int == stack_mv.as_int) break; |
| 465 | } |
| 466 | |
| 467 | if (stack_idx == *refmv_count) { |
| 468 | ref_mv_stack[stack_idx].this_mv = this_mv; |
| 469 | |
| 470 | // TODO(jingning): Set an arbitrary small number here. The weight |
| 471 | // doesn't matter as long as it is properly initialized. |
| 472 | ref_mv_weight[stack_idx] = 2; |
| 473 | ++(*refmv_count); |
| 474 | } |
| 475 | } |
| 476 | } |
| 477 | } |
| 478 | |
| 479 | static inline void setup_ref_mv_list( |
| 480 | const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame, |
| 481 | uint8_t *const refmv_count, |
| 482 | CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE8], |
| 483 | uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE8], |
| 484 | int_mv mv_ref_list[MAX_MV_REF_CANDIDATES2], int_mv *gm_mv_candidates, |
| 485 | int mi_row, int mi_col, int16_t *mode_context) { |
| 486 | const int bs = AOMMAX(xd->width, xd->height)(((xd->width) > (xd->height)) ? (xd->width) : (xd ->height)); |
| 487 | const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs); |
| 488 | MV_REFERENCE_FRAME rf[2]; |
| 489 | |
| 490 | const TileInfo *const tile = &xd->tile; |
| 491 | int max_row_offset = 0, max_col_offset = 0; |
| 492 | const int row_adj = (xd->height < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01); |
| 493 | const int col_adj = (xd->width < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01); |
| 494 | int processed_rows = 0; |
| 495 | int processed_cols = 0; |
| 496 | |
| 497 | av1_set_ref_frame(rf, ref_frame); |
| 498 | mode_context[ref_frame] = 0; |
| 499 | *refmv_count = 0; |
| 500 | |
| 501 | // Find valid maximum row/col offset. |
| 502 | if (xd->up_available) { |
| 503 | max_row_offset = -(MVREF_ROW_COLS3 << 1) + row_adj; |
| 504 | |
| 505 | if (xd->height < mi_size_high[BLOCK_8X8]) |
| 506 | max_row_offset = -(2 << 1) + row_adj; |
| 507 | |
| 508 | max_row_offset = find_valid_row_offset(tile, mi_row, max_row_offset); |
| 509 | } |
| 510 | |
| 511 | if (xd->left_available) { |
| 512 | max_col_offset = -(MVREF_ROW_COLS3 << 1) + col_adj; |
| 513 | |
| 514 | if (xd->width < mi_size_wide[BLOCK_8X8]) |
| 515 | max_col_offset = -(2 << 1) + col_adj; |
| 516 | |
| 517 | max_col_offset = find_valid_col_offset(tile, mi_col, max_col_offset); |
| 518 | } |
| 519 | |
| 520 | uint8_t col_match_count = 0; |
| 521 | uint8_t row_match_count = 0; |
| 522 | uint8_t newmv_count = 0; |
| 523 | |
| 524 | // Scan the first above row mode info. row_offset = -1; |
| 525 | if (abs(max_row_offset) >= 1) |
| 526 | scan_row_mbmi(cm, xd, mi_col, rf, -1, ref_mv_stack, ref_mv_weight, |
| 527 | refmv_count, &row_match_count, &newmv_count, gm_mv_candidates, |
| 528 | max_row_offset, &processed_rows); |
| 529 | // Scan the first left column mode info. col_offset = -1; |
| 530 | if (abs(max_col_offset) >= 1) |
| 531 | scan_col_mbmi(cm, xd, mi_row, rf, -1, ref_mv_stack, ref_mv_weight, |
| 532 | refmv_count, &col_match_count, &newmv_count, gm_mv_candidates, |
| 533 | max_col_offset, &processed_cols); |
| 534 | // Check top-right boundary |
| 535 | if (has_tr) |
| 536 | scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->width, ref_mv_stack, |
| 537 | ref_mv_weight, &row_match_count, &newmv_count, |
| 538 | gm_mv_candidates, refmv_count); |
| 539 | |
| 540 | const uint8_t nearest_match = (row_match_count > 0) + (col_match_count > 0); |
| 541 | const uint8_t nearest_refmv_count = *refmv_count; |
| 542 | |
| 543 | // TODO(yunqing): for comp_search, do it for all 3 cases. |
| 544 | for (int idx = 0; idx < nearest_refmv_count; ++idx) |
| 545 | ref_mv_weight[idx] += REF_CAT_LEVEL640; |
| 546 | |
| 547 | if (cm->features.allow_ref_frame_mvs) { |
| 548 | int is_available = 0; |
| 549 | const int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->height)(((mi_size_high[BLOCK_8X8]) > (xd->height)) ? (mi_size_high [BLOCK_8X8]) : (xd->height)); |
| 550 | const int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->width)(((mi_size_wide[BLOCK_8X8]) > (xd->width)) ? (mi_size_wide [BLOCK_8X8]) : (xd->width)); |
| 551 | const int blk_row_end = AOMMIN(xd->height, mi_size_high[BLOCK_64X64])(((xd->height) < (mi_size_high[BLOCK_64X64])) ? (xd-> height) : (mi_size_high[BLOCK_64X64])); |
| 552 | const int blk_col_end = AOMMIN(xd->width, mi_size_wide[BLOCK_64X64])(((xd->width) < (mi_size_wide[BLOCK_64X64])) ? (xd-> width) : (mi_size_wide[BLOCK_64X64])); |
| 553 | |
| 554 | const int tpl_sample_pos[3][2] = { |
| 555 | { voffset, -2 }, |
| 556 | { voffset, hoffset }, |
| 557 | { voffset - 2, hoffset }, |
| 558 | }; |
| 559 | const int allow_extension = (xd->height >= mi_size_high[BLOCK_8X8]) && |
| 560 | (xd->height < mi_size_high[BLOCK_64X64]) && |
| 561 | (xd->width >= mi_size_wide[BLOCK_8X8]) && |
| 562 | (xd->width < mi_size_wide[BLOCK_64X64]); |
| 563 | |
| 564 | const int step_h = (xd->height >= mi_size_high[BLOCK_64X64]) |
| 565 | ? mi_size_high[BLOCK_16X16] |
| 566 | : mi_size_high[BLOCK_8X8]; |
| 567 | const int step_w = (xd->width >= mi_size_wide[BLOCK_64X64]) |
| 568 | ? mi_size_wide[BLOCK_16X16] |
| 569 | : mi_size_wide[BLOCK_8X8]; |
| 570 | |
| 571 | for (int blk_row = 0; blk_row < blk_row_end; blk_row += step_h) { |
| 572 | for (int blk_col = 0; blk_col < blk_col_end; blk_col += step_w) { |
| 573 | int ret = add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, |
| 574 | blk_col, gm_mv_candidates, refmv_count, |
| 575 | ref_mv_stack, ref_mv_weight, mode_context); |
| 576 | if (blk_row == 0 && blk_col == 0) is_available = ret; |
| 577 | } |
| 578 | } |
| 579 | |
| 580 | if (is_available == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET3); |
| 581 | |
| 582 | for (int i = 0; i < 3 && allow_extension; ++i) { |
| 583 | const int blk_row = tpl_sample_pos[i][0]; |
| 584 | const int blk_col = tpl_sample_pos[i][1]; |
| 585 | |
| 586 | if (!check_sb_border(mi_row, mi_col, blk_row, blk_col)) continue; |
| 587 | add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, blk_col, |
| 588 | gm_mv_candidates, refmv_count, ref_mv_stack, ref_mv_weight, |
| 589 | mode_context); |
| 590 | } |
| 591 | } |
| 592 | |
| 593 | uint8_t dummy_newmv_count = 0; |
| 594 | |
| 595 | // Scan the second outer area. |
| 596 | scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack, ref_mv_weight, |
| 597 | &row_match_count, &dummy_newmv_count, gm_mv_candidates, |
| 598 | refmv_count); |
| 599 | |
| 600 | for (int idx = 2; idx <= MVREF_ROW_COLS3; ++idx) { |
| 601 | const int row_offset = -(idx << 1) + 1 + row_adj; |
| 602 | const int col_offset = -(idx << 1) + 1 + col_adj; |
| 603 | |
| 604 | if (abs(row_offset) <= abs(max_row_offset) && |
| 605 | abs(row_offset) > processed_rows) |
| 606 | scan_row_mbmi(cm, xd, mi_col, rf, row_offset, ref_mv_stack, ref_mv_weight, |
| 607 | refmv_count, &row_match_count, &dummy_newmv_count, |
| 608 | gm_mv_candidates, max_row_offset, &processed_rows); |
| 609 | |
| 610 | if (abs(col_offset) <= abs(max_col_offset) && |
| 611 | abs(col_offset) > processed_cols) |
| 612 | scan_col_mbmi(cm, xd, mi_row, rf, col_offset, ref_mv_stack, ref_mv_weight, |
| 613 | refmv_count, &col_match_count, &dummy_newmv_count, |
| 614 | gm_mv_candidates, max_col_offset, &processed_cols); |
| 615 | } |
| 616 | |
| 617 | const uint8_t ref_match_count = (row_match_count > 0) + (col_match_count > 0); |
| 618 | |
| 619 | switch (nearest_match) { |
| 620 | case 0: |
| 621 | if (ref_match_count >= 1) mode_context[ref_frame] |= 1; |
| 622 | if (ref_match_count == 1) |
| 623 | mode_context[ref_frame] |= (1 << REFMV_OFFSET4); |
| 624 | else if (ref_match_count >= 2) |
| 625 | mode_context[ref_frame] |= (2 << REFMV_OFFSET4); |
| 626 | break; |
| 627 | case 1: |
| 628 | mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3; |
| 629 | if (ref_match_count == 1) |
| 630 | mode_context[ref_frame] |= (3 << REFMV_OFFSET4); |
| 631 | else if (ref_match_count >= 2) |
| 632 | mode_context[ref_frame] |= (4 << REFMV_OFFSET4); |
| 633 | break; |
| 634 | case 2: |
| 635 | default: |
| 636 | if (newmv_count >= 1) |
| 637 | mode_context[ref_frame] |= 4; |
| 638 | else |
| 639 | mode_context[ref_frame] |= 5; |
| 640 | |
| 641 | mode_context[ref_frame] |= (5 << REFMV_OFFSET4); |
| 642 | break; |
| 643 | } |
| 644 | |
| 645 | // Rank the likelihood and assign nearest and near mvs. |
| 646 | int len = nearest_refmv_count; |
| 647 | while (len > 0) { |
| 648 | int nr_len = 0; |
| 649 | for (int idx = 1; idx < len; ++idx) { |
| 650 | if (ref_mv_weight[idx - 1] < ref_mv_weight[idx]) { |
| 651 | const CANDIDATE_MV tmp_mv = ref_mv_stack[idx - 1]; |
| 652 | const uint16_t tmp_ref_mv_weight = ref_mv_weight[idx - 1]; |
| 653 | ref_mv_stack[idx - 1] = ref_mv_stack[idx]; |
| 654 | ref_mv_stack[idx] = tmp_mv; |
| 655 | ref_mv_weight[idx - 1] = ref_mv_weight[idx]; |
| 656 | ref_mv_weight[idx] = tmp_ref_mv_weight; |
| 657 | nr_len = idx; |
| 658 | } |
| 659 | } |
| 660 | len = nr_len; |
| 661 | } |
| 662 | |
| 663 | len = *refmv_count; |
| 664 | while (len > nearest_refmv_count) { |
| 665 | int nr_len = nearest_refmv_count; |
| 666 | for (int idx = nearest_refmv_count + 1; idx < len; ++idx) { |
| 667 | if (ref_mv_weight[idx - 1] < ref_mv_weight[idx]) { |
| 668 | const CANDIDATE_MV tmp_mv = ref_mv_stack[idx - 1]; |
| 669 | const uint16_t tmp_ref_mv_weight = ref_mv_weight[idx - 1]; |
| 670 | ref_mv_stack[idx - 1] = ref_mv_stack[idx]; |
| 671 | ref_mv_stack[idx] = tmp_mv; |
| 672 | ref_mv_weight[idx - 1] = ref_mv_weight[idx]; |
| 673 | ref_mv_weight[idx] = tmp_ref_mv_weight; |
| 674 | nr_len = idx; |
| 675 | } |
| 676 | } |
| 677 | len = nr_len; |
| 678 | } |
| 679 | |
| 680 | int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->width)(((mi_size_wide[BLOCK_64X64]) < (xd->width)) ? (mi_size_wide [BLOCK_64X64]) : (xd->width)); |
| 681 | mi_width = AOMMIN(mi_width, cm->mi_params.mi_cols - mi_col)(((mi_width) < (cm->mi_params.mi_cols - mi_col)) ? (mi_width ) : (cm->mi_params.mi_cols - mi_col)); |
| 682 | int mi_height = AOMMIN(mi_size_high[BLOCK_64X64], xd->height)(((mi_size_high[BLOCK_64X64]) < (xd->height)) ? (mi_size_high [BLOCK_64X64]) : (xd->height)); |
| 683 | mi_height = AOMMIN(mi_height, cm->mi_params.mi_rows - mi_row)(((mi_height) < (cm->mi_params.mi_rows - mi_row)) ? (mi_height ) : (cm->mi_params.mi_rows - mi_row)); |
| 684 | const int mi_size = AOMMIN(mi_width, mi_height)(((mi_width) < (mi_height)) ? (mi_width) : (mi_height)); |
| 685 | if (rf[1] > NONE_FRAME) { |
| 686 | // TODO(jingning, yunqing): Refactor and consolidate the compound and |
| 687 | // single reference frame modes. Reduce unnecessary redundancy. |
| 688 | if (*refmv_count < MAX_MV_REF_CANDIDATES2) { |
| 689 | int_mv ref_id[2][2], ref_diff[2][2]; |
| 690 | int ref_id_count[2] = { 0 }, ref_diff_count[2] = { 0 }; |
| 691 | |
| 692 | for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size;) { |
| 693 | const MB_MODE_INFO *const candidate = xd->mi[-xd->mi_stride + idx]; |
| 694 | process_compound_ref_mv_candidate( |
| 695 | candidate, cm, rf, ref_id, ref_id_count, ref_diff, ref_diff_count); |
| 696 | idx += mi_size_wide[candidate->bsize]; |
| 697 | } |
| 698 | |
| 699 | for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size;) { |
| 700 | const MB_MODE_INFO *const candidate = xd->mi[idx * xd->mi_stride - 1]; |
| 701 | process_compound_ref_mv_candidate( |
| 702 | candidate, cm, rf, ref_id, ref_id_count, ref_diff, ref_diff_count); |
| 703 | idx += mi_size_high[candidate->bsize]; |
| 704 | } |
| 705 | |
| 706 | // Build up the compound mv predictor |
| 707 | int_mv comp_list[MAX_MV_REF_CANDIDATES2][2]; |
| 708 | |
| 709 | for (int idx = 0; idx < 2; ++idx) { |
| 710 | int comp_idx = 0; |
| 711 | for (int list_idx = 0; |
| 712 | list_idx < ref_id_count[idx] && comp_idx < MAX_MV_REF_CANDIDATES2; |
| 713 | ++list_idx, ++comp_idx) |
| 714 | comp_list[comp_idx][idx] = ref_id[idx][list_idx]; |
| 715 | for (int list_idx = 0; |
| 716 | list_idx < ref_diff_count[idx] && comp_idx < MAX_MV_REF_CANDIDATES2; |
| 717 | ++list_idx, ++comp_idx) |
| 718 | comp_list[comp_idx][idx] = ref_diff[idx][list_idx]; |
| 719 | for (; comp_idx < MAX_MV_REF_CANDIDATES2; ++comp_idx) |
| 720 | comp_list[comp_idx][idx] = gm_mv_candidates[idx]; |
| 721 | } |
| 722 | |
| 723 | if (*refmv_count) { |
| 724 | assert(*refmv_count == 1)((void) sizeof ((*refmv_count == 1) ? 1 : 0), __extension__ ( { if (*refmv_count == 1) ; else __assert_fail ("*refmv_count == 1" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 724, __extension__ __PRETTY_FUNCTION__); })); |
| 725 | if (comp_list[0][0].as_int == ref_mv_stack[0].this_mv.as_int && |
| 726 | comp_list[0][1].as_int == ref_mv_stack[0].comp_mv.as_int) { |
| 727 | ref_mv_stack[*refmv_count].this_mv = comp_list[1][0]; |
| 728 | ref_mv_stack[*refmv_count].comp_mv = comp_list[1][1]; |
| 729 | } else { |
| 730 | ref_mv_stack[*refmv_count].this_mv = comp_list[0][0]; |
| 731 | ref_mv_stack[*refmv_count].comp_mv = comp_list[0][1]; |
| 732 | } |
| 733 | ref_mv_weight[*refmv_count] = 2; |
| 734 | ++*refmv_count; |
| 735 | } else { |
| 736 | for (int idx = 0; idx < MAX_MV_REF_CANDIDATES2; ++idx) { |
| 737 | ref_mv_stack[*refmv_count].this_mv = comp_list[idx][0]; |
| 738 | ref_mv_stack[*refmv_count].comp_mv = comp_list[idx][1]; |
| 739 | ref_mv_weight[*refmv_count] = 2; |
| 740 | ++*refmv_count; |
| 741 | } |
| 742 | } |
| 743 | } |
| 744 | |
| 745 | assert(*refmv_count >= 2)((void) sizeof ((*refmv_count >= 2) ? 1 : 0), __extension__ ({ if (*refmv_count >= 2) ; else __assert_fail ("*refmv_count >= 2" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 745, __extension__ __PRETTY_FUNCTION__); })); |
| 746 | |
| 747 | for (int idx = 0; idx < *refmv_count; ++idx) { |
| 748 | clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->width << MI_SIZE_LOG22, |
| 749 | xd->height << MI_SIZE_LOG22, xd); |
| 750 | clamp_mv_ref(&ref_mv_stack[idx].comp_mv.as_mv, xd->width << MI_SIZE_LOG22, |
| 751 | xd->height << MI_SIZE_LOG22, xd); |
| 752 | } |
| 753 | } else { |
| 754 | // Handle single reference frame extension |
| 755 | for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size && |
| 756 | *refmv_count < MAX_MV_REF_CANDIDATES2;) { |
| 757 | const MB_MODE_INFO *const candidate = xd->mi[-xd->mi_stride + idx]; |
| 758 | process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count, |
| 759 | ref_mv_stack, ref_mv_weight); |
| 760 | idx += mi_size_wide[candidate->bsize]; |
| 761 | } |
| 762 | |
| 763 | for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size && |
| 764 | *refmv_count < MAX_MV_REF_CANDIDATES2;) { |
| 765 | const MB_MODE_INFO *const candidate = xd->mi[idx * xd->mi_stride - 1]; |
| 766 | process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count, |
| 767 | ref_mv_stack, ref_mv_weight); |
| 768 | idx += mi_size_high[candidate->bsize]; |
| 769 | } |
| 770 | |
| 771 | for (int idx = 0; idx < *refmv_count; ++idx) { |
| 772 | clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->width << MI_SIZE_LOG22, |
| 773 | xd->height << MI_SIZE_LOG22, xd); |
| 774 | } |
| 775 | |
| 776 | if (mv_ref_list != NULL((void*)0)) { |
| 777 | for (int idx = *refmv_count; idx < MAX_MV_REF_CANDIDATES2; ++idx) |
| 778 | mv_ref_list[idx].as_int = gm_mv_candidates[0].as_int; |
| 779 | |
| 780 | for (int idx = 0; idx < AOMMIN(MAX_MV_REF_CANDIDATES, *refmv_count)(((2) < (*refmv_count)) ? (2) : (*refmv_count)); |
| 781 | ++idx) { |
| 782 | mv_ref_list[idx].as_int = ref_mv_stack[idx].this_mv.as_int; |
| 783 | } |
| 784 | } |
| 785 | } |
| 786 | } |
| 787 | |
| 788 | void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
| 789 | MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, |
| 790 | uint8_t ref_mv_count[MODE_CTX_REF_FRAMES(REF_FRAMES + (FWD_REFS * BWD_REFS + TOTAL_UNIDIR_COMP_REFS))], |
| 791 | CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE8], |
| 792 | uint16_t ref_mv_weight[][MAX_REF_MV_STACK_SIZE8], |
| 793 | int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES2], |
| 794 | int_mv *global_mvs, int16_t *mode_context) { |
| 795 | const int mi_row = xd->mi_row; |
| 796 | const int mi_col = xd->mi_col; |
| 797 | int_mv gm_mv[2]; |
| 798 | |
| 799 | if (ref_frame == INTRA_FRAME) { |
| 800 | gm_mv[0].as_int = gm_mv[1].as_int = 0; |
| 801 | if (global_mvs != NULL((void*)0)) { |
| 802 | global_mvs[ref_frame].as_int = INVALID_MV0x80008000; |
| 803 | } |
| 804 | } else { |
| 805 | const BLOCK_SIZE bsize = mi->bsize; |
| 806 | const int allow_high_precision_mv = cm->features.allow_high_precision_mv; |
| 807 | const int force_integer_mv = cm->features.cur_frame_force_integer_mv; |
| 808 | if (ref_frame < REF_FRAMES) { |
| 809 | gm_mv[0] = gm_get_motion_vector(&cm->global_motion[ref_frame], |
| 810 | allow_high_precision_mv, bsize, mi_col, |
| 811 | mi_row, force_integer_mv); |
| 812 | gm_mv[1].as_int = 0; |
| 813 | if (global_mvs != NULL((void*)0)) global_mvs[ref_frame] = gm_mv[0]; |
| 814 | } else { |
| 815 | MV_REFERENCE_FRAME rf[2]; |
| 816 | av1_set_ref_frame(rf, ref_frame); |
| 817 | gm_mv[0] = gm_get_motion_vector(&cm->global_motion[rf[0]], |
| 818 | allow_high_precision_mv, bsize, mi_col, |
| 819 | mi_row, force_integer_mv); |
| 820 | gm_mv[1] = gm_get_motion_vector(&cm->global_motion[rf[1]], |
| 821 | allow_high_precision_mv, bsize, mi_col, |
| 822 | mi_row, force_integer_mv); |
| 823 | } |
| 824 | } |
| 825 | |
| 826 | setup_ref_mv_list(cm, xd, ref_frame, &ref_mv_count[ref_frame], |
| 827 | ref_mv_stack[ref_frame], ref_mv_weight[ref_frame], |
| 828 | mv_ref_list ? mv_ref_list[ref_frame] : NULL((void*)0), gm_mv, mi_row, |
| 829 | mi_col, mode_context); |
| 830 | } |
| 831 | |
| 832 | void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, |
| 833 | int_mv *near_mv, int is_integer) { |
| 834 | int i; |
| 835 | // Make sure all the candidates are properly clamped etc |
| 836 | for (i = 0; i < MAX_MV_REF_CANDIDATES2; ++i) { |
| 837 | lower_mv_precision(&mvlist[i].as_mv, allow_hp, is_integer); |
| 838 | } |
| 839 | *nearest_mv = mvlist[0]; |
| 840 | *near_mv = mvlist[1]; |
| 841 | } |
| 842 | |
| 843 | void av1_setup_frame_buf_refs(AV1_COMMON *cm) { |
| 844 | cm->cur_frame->order_hint = cm->current_frame.order_hint; |
| 845 | cm->cur_frame->display_order_hint = cm->current_frame.display_order_hint; |
| 846 | cm->cur_frame->pyramid_level = cm->current_frame.pyramid_level; |
| 847 | cm->cur_frame->base_qindex = cm->quant_params.base_qindex; |
| 848 | cm->cur_frame->filter_level[0] = -1; |
| 849 | cm->cur_frame->filter_level[1] = -1; |
| 850 | MV_REFERENCE_FRAME ref_frame; |
| 851 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
| 852 | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
| 853 | if (buf != NULL((void*)0)) { |
| 854 | cm->cur_frame->ref_order_hints[ref_frame - LAST_FRAME] = buf->order_hint; |
| 855 | cm->cur_frame->ref_display_order_hint[ref_frame - LAST_FRAME] = |
| 856 | buf->display_order_hint; |
| 857 | } |
| 858 | } |
| 859 | } |
| 860 | |
| 861 | void av1_setup_frame_sign_bias(AV1_COMMON *cm) { |
| 862 | MV_REFERENCE_FRAME ref_frame; |
| 863 | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
| 864 | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
| 865 | if (cm->seq_params->order_hint_info.enable_order_hint && buf != NULL((void*)0)) { |
| 866 | const int ref_order_hint = buf->order_hint; |
| 867 | cm->ref_frame_sign_bias[ref_frame] = |
| 868 | (get_relative_dist(&cm->seq_params->order_hint_info, ref_order_hint, |
| 869 | (int)cm->current_frame.order_hint) <= 0) |
| 870 | ? 0 |
| 871 | : 1; |
| 872 | } else { |
| 873 | cm->ref_frame_sign_bias[ref_frame] = 0; |
| 874 | } |
| 875 | } |
| 876 | } |
| 877 | |
| 878 | #define MAX_OFFSET_WIDTH64 64 |
| 879 | #define MAX_OFFSET_HEIGHT0 0 |
| 880 | |
| 881 | static int get_block_position(AV1_COMMON *cm, int *mi_r, int *mi_c, int blk_row, |
| 882 | int blk_col, MV mv, int sign_bias) { |
| 883 | const int base_blk_row = (blk_row >> 3) << 3; |
| 884 | const int base_blk_col = (blk_col >> 3) << 3; |
| 885 | |
| 886 | const int row_offset = (mv.row >= 0) ? (mv.row >> (4 + MI_SIZE_LOG22)) |
| 887 | : -((-mv.row) >> (4 + MI_SIZE_LOG22)); |
| 888 | |
| 889 | const int col_offset = (mv.col >= 0) ? (mv.col >> (4 + MI_SIZE_LOG22)) |
| 890 | : -((-mv.col) >> (4 + MI_SIZE_LOG22)); |
| 891 | |
| 892 | const int row = |
| 893 | (sign_bias == 1) ? blk_row - row_offset : blk_row + row_offset; |
| 894 | const int col = |
| 895 | (sign_bias == 1) ? blk_col - col_offset : blk_col + col_offset; |
| 896 | |
| 897 | if (row < 0 || row >= (cm->mi_params.mi_rows >> 1) || col < 0 || |
| 898 | col >= (cm->mi_params.mi_cols >> 1)) |
| 899 | return 0; |
| 900 | |
| 901 | if (row < base_blk_row - (MAX_OFFSET_HEIGHT0 >> 3) || |
| 902 | row >= base_blk_row + 8 + (MAX_OFFSET_HEIGHT0 >> 3) || |
| 903 | col < base_blk_col - (MAX_OFFSET_WIDTH64 >> 3) || |
| 904 | col >= base_blk_col + 8 + (MAX_OFFSET_WIDTH64 >> 3)) |
| 905 | return 0; |
| 906 | |
| 907 | *mi_r = row; |
| 908 | *mi_c = col; |
| 909 | |
| 910 | return 1; |
| 911 | } |
| 912 | |
| 913 | // Note: motion_filed_projection finds motion vectors of current frame's |
| 914 | // reference frame, and projects them to current frame. To make it clear, |
| 915 | // let's call current frame's reference frame as start frame. |
| 916 | // Call Start frame's reference frames as reference frames. |
| 917 | // Call ref_offset as frame distances between start frame and its reference |
| 918 | // frames. |
| 919 | static int motion_field_projection(AV1_COMMON *cm, |
| 920 | MV_REFERENCE_FRAME start_frame, int dir) { |
| 921 | TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; |
| 922 | int ref_offset[REF_FRAMES] = { 0 }; |
| 923 | |
| 924 | const RefCntBuffer *const start_frame_buf = |
| 925 | get_ref_frame_buf(cm, start_frame); |
| 926 | if (start_frame_buf == NULL((void*)0)) return 0; |
| 927 | |
| 928 | if (start_frame_buf->frame_type == KEY_FRAME || |
| 929 | start_frame_buf->frame_type == INTRA_ONLY_FRAME) |
| 930 | return 0; |
| 931 | |
| 932 | if (start_frame_buf->mi_rows != cm->mi_params.mi_rows || |
| 933 | start_frame_buf->mi_cols != cm->mi_params.mi_cols) |
| 934 | return 0; |
| 935 | |
| 936 | const int start_frame_order_hint = start_frame_buf->order_hint; |
| 937 | const unsigned int *const ref_order_hints = |
| 938 | &start_frame_buf->ref_order_hints[0]; |
| 939 | const int cur_order_hint = cm->cur_frame->order_hint; |
| 940 | int start_to_current_frame_offset = get_relative_dist( |
| 941 | &cm->seq_params->order_hint_info, start_frame_order_hint, cur_order_hint); |
| 942 | |
| 943 | for (MV_REFERENCE_FRAME rf = LAST_FRAME; rf <= INTER_REFS_PER_FRAME; ++rf) { |
| 944 | ref_offset[rf] = get_relative_dist(&cm->seq_params->order_hint_info, |
| 945 | start_frame_order_hint, |
| 946 | ref_order_hints[rf - LAST_FRAME]); |
| 947 | } |
| 948 | |
| 949 | if (dir == 2) start_to_current_frame_offset = -start_to_current_frame_offset; |
| 950 | |
| 951 | MV_REF *mv_ref_base = start_frame_buf->mvs; |
| 952 | const int mvs_rows = (cm->mi_params.mi_rows + 1) >> 1; |
| 953 | const int mvs_cols = (cm->mi_params.mi_cols + 1) >> 1; |
| 954 | |
| 955 | for (int blk_row = 0; blk_row < mvs_rows; ++blk_row) { |
| 956 | for (int blk_col = 0; blk_col < mvs_cols; ++blk_col) { |
| 957 | MV_REF *mv_ref = &mv_ref_base[blk_row * mvs_cols + blk_col]; |
| 958 | MV fwd_mv = mv_ref->mv.as_mv; |
| 959 | |
| 960 | if (mv_ref->ref_frame > INTRA_FRAME) { |
| 961 | int_mv this_mv; |
| 962 | int mi_r, mi_c; |
| 963 | const int ref_frame_offset = ref_offset[mv_ref->ref_frame]; |
| 964 | |
| 965 | int pos_valid = |
| 966 | abs(ref_frame_offset) <= MAX_FRAME_DISTANCE((1 << 5) - 1) && |
| 967 | ref_frame_offset > 0 && |
| 968 | abs(start_to_current_frame_offset) <= MAX_FRAME_DISTANCE((1 << 5) - 1); |
| 969 | |
| 970 | if (pos_valid) { |
| 971 | av1_get_mv_projection(&this_mv.as_mv, fwd_mv, |
| 972 | start_to_current_frame_offset, |
| 973 | ref_frame_offset); |
| 974 | pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, |
| 975 | this_mv.as_mv, dir >> 1); |
| 976 | } |
| 977 | |
| 978 | if (pos_valid) { |
| 979 | const int mi_offset = mi_r * (cm->mi_params.mi_stride >> 1) + mi_c; |
| 980 | |
| 981 | tpl_mvs_base[mi_offset].mfmv0.as_mv.row = fwd_mv.row; |
| 982 | tpl_mvs_base[mi_offset].mfmv0.as_mv.col = fwd_mv.col; |
| 983 | tpl_mvs_base[mi_offset].ref_frame_offset = ref_frame_offset; |
| 984 | } |
| 985 | } |
| 986 | } |
| 987 | } |
| 988 | |
| 989 | return 1; |
| 990 | } |
| 991 | |
| 992 | // cm->ref_frame_side is calculated here, and will be used in |
| 993 | // av1_copy_frame_mvs() to affect how mvs are copied. |
| 994 | void av1_calculate_ref_frame_side(AV1_COMMON *cm) { |
| 995 | const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; |
| 996 | |
| 997 | memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side)); |
| 998 | if (!order_hint_info->enable_order_hint) return; |
| 999 | |
| 1000 | const int cur_order_hint = cm->cur_frame->order_hint; |
| 1001 | |
| 1002 | for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { |
| 1003 | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
| 1004 | int order_hint = 0; |
| 1005 | |
| 1006 | if (buf != NULL((void*)0)) order_hint = buf->order_hint; |
| 1007 | |
| 1008 | if (get_relative_dist(order_hint_info, order_hint, cur_order_hint) > 0) |
| 1009 | cm->ref_frame_side[ref_frame] = 1; |
| 1010 | else if (order_hint == cur_order_hint) |
| 1011 | cm->ref_frame_side[ref_frame] = -1; |
| 1012 | } |
| 1013 | } |
| 1014 | |
| 1015 | void av1_setup_motion_field(AV1_COMMON *cm) { |
| 1016 | const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; |
| 1017 | |
| 1018 | if (!order_hint_info->enable_order_hint) return; |
| 1019 | |
| 1020 | TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; |
| 1021 | int size = ((cm->mi_params.mi_rows + MAX_MIB_SIZE(1 << (7 - 2))) >> 1) * |
| 1022 | (cm->mi_params.mi_stride >> 1); |
| 1023 | for (int idx = 0; idx < size; ++idx) { |
| 1024 | tpl_mvs_base[idx].mfmv0.as_int = INVALID_MV0x80008000; |
| 1025 | tpl_mvs_base[idx].ref_frame_offset = 0; |
| 1026 | } |
| 1027 | |
| 1028 | const int cur_order_hint = cm->cur_frame->order_hint; |
| 1029 | const RefCntBuffer *ref_buf[INTER_REFS_PER_FRAME]; |
| 1030 | int ref_order_hint[INTER_REFS_PER_FRAME]; |
| 1031 | |
| 1032 | for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { |
| 1033 | const int ref_idx = ref_frame - LAST_FRAME; |
| 1034 | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
| 1035 | int order_hint = 0; |
| 1036 | |
| 1037 | if (buf != NULL((void*)0)) order_hint = buf->order_hint; |
| 1038 | |
| 1039 | ref_buf[ref_idx] = buf; |
| 1040 | ref_order_hint[ref_idx] = order_hint; |
| 1041 | } |
| 1042 | |
| 1043 | int ref_stamp = MFMV_STACK_SIZE3 - 1; |
| 1044 | |
| 1045 | if (ref_buf[LAST_FRAME - LAST_FRAME] != NULL((void*)0)) { |
| 1046 | const int alt_of_lst_order_hint = |
| 1047 | ref_buf[LAST_FRAME - LAST_FRAME] |
| 1048 | ->ref_order_hints[ALTREF_FRAME - LAST_FRAME]; |
| 1049 | |
| 1050 | const int is_lst_overlay = |
| 1051 | (alt_of_lst_order_hint == ref_order_hint[GOLDEN_FRAME - LAST_FRAME]); |
| 1052 | if (!is_lst_overlay) motion_field_projection(cm, LAST_FRAME, 2); |
| 1053 | --ref_stamp; |
| 1054 | } |
| 1055 | |
| 1056 | if (get_relative_dist(order_hint_info, |
| 1057 | ref_order_hint[BWDREF_FRAME - LAST_FRAME], |
| 1058 | cur_order_hint) > 0) { |
| 1059 | if (motion_field_projection(cm, BWDREF_FRAME, 0)) --ref_stamp; |
| 1060 | } |
| 1061 | |
| 1062 | if (get_relative_dist(order_hint_info, |
| 1063 | ref_order_hint[ALTREF2_FRAME - LAST_FRAME], |
| 1064 | cur_order_hint) > 0) { |
| 1065 | if (motion_field_projection(cm, ALTREF2_FRAME, 0)) --ref_stamp; |
| 1066 | } |
| 1067 | |
| 1068 | if (get_relative_dist(order_hint_info, |
| 1069 | ref_order_hint[ALTREF_FRAME - LAST_FRAME], |
| 1070 | cur_order_hint) > 0 && |
| 1071 | ref_stamp >= 0) |
| 1072 | if (motion_field_projection(cm, ALTREF_FRAME, 0)) --ref_stamp; |
| 1073 | |
| 1074 | if (ref_stamp >= 0) motion_field_projection(cm, LAST2_FRAME, 2); |
| 1075 | } |
| 1076 | |
| 1077 | static inline void record_samples(const MB_MODE_INFO *mbmi, int *pts, |
| 1078 | int *pts_inref, int row_offset, int sign_r, |
| 1079 | int col_offset, int sign_c) { |
| 1080 | const int bw = block_size_wide[mbmi->bsize]; |
| 1081 | const int bh = block_size_high[mbmi->bsize]; |
| 1082 | const int x = col_offset * MI_SIZE(1 << 2) + sign_c * bw / 2 - 1; |
| 1083 | const int y = row_offset * MI_SIZE(1 << 2) + sign_r * bh / 2 - 1; |
| 1084 | |
| 1085 | pts[0] = GET_MV_SUBPEL(x)((x) * 8); |
| 1086 | pts[1] = GET_MV_SUBPEL(y)((y) * 8); |
| 1087 | pts_inref[0] = pts[0] + mbmi->mv[0].as_mv.col; |
| 1088 | pts_inref[1] = pts[1] + mbmi->mv[0].as_mv.row; |
| 1089 | } |
| 1090 | |
| 1091 | // Select samples according to the motion vector difference. |
| 1092 | uint8_t av1_selectSamples(MV *mv, int *pts, int *pts_inref, int len, |
| 1093 | BLOCK_SIZE bsize) { |
| 1094 | const int bw = block_size_wide[bsize]; |
| 1095 | const int bh = block_size_high[bsize]; |
| 1096 | const int thresh = clamp(AOMMAX(bw, bh)(((bw) > (bh)) ? (bw) : (bh)), 16, 112); |
| 1097 | uint8_t ret = 0; |
| 1098 | assert(len <= LEAST_SQUARES_SAMPLES_MAX)((void) sizeof ((len <= (1 << 3)) ? 1 : 0), __extension__ ({ if (len <= (1 << 3)) ; else __assert_fail ("len <= LEAST_SQUARES_SAMPLES_MAX" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1098, __extension__ __PRETTY_FUNCTION__); })); |
| 1099 | |
| 1100 | // Only keep the samples with MV differences within threshold. |
| 1101 | for (int i = 0; i < len; ++i) { |
| 1102 | const int diff = abs(pts_inref[2 * i] - pts[2 * i] - mv->col) + |
| 1103 | abs(pts_inref[2 * i + 1] - pts[2 * i + 1] - mv->row); |
| 1104 | if (diff > thresh) continue; |
| 1105 | if (ret != i) { |
| 1106 | memcpy(pts + 2 * ret, pts + 2 * i, 2 * sizeof(pts[0])); |
| 1107 | memcpy(pts_inref + 2 * ret, pts_inref + 2 * i, 2 * sizeof(pts_inref[0])); |
| 1108 | } |
| 1109 | ++ret; |
| 1110 | } |
| 1111 | // Keep at least 1 sample. |
| 1112 | return AOMMAX(ret, 1)(((ret) > (1)) ? (ret) : (1)); |
| 1113 | } |
| 1114 | |
| 1115 | // Note: Samples returned are at 1/8-pel precision |
| 1116 | // Sample are the neighbor block center point's coordinates relative to the |
| 1117 | // left-top pixel of current block. |
| 1118 | uint8_t av1_findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int *pts, |
| 1119 | int *pts_inref) { |
| 1120 | const MB_MODE_INFO *const mbmi0 = xd->mi[0]; |
| 1121 | const int ref_frame = mbmi0->ref_frame[0]; |
| 1122 | const int up_available = xd->up_available; |
| 1123 | const int left_available = xd->left_available; |
| 1124 | uint8_t np = 0; |
| 1125 | int do_tl = 1; |
| 1126 | int do_tr = 1; |
| 1127 | const int mi_stride = xd->mi_stride; |
| 1128 | const int mi_row = xd->mi_row; |
| 1129 | const int mi_col = xd->mi_col; |
| 1130 | |
| 1131 | // scan the nearest above rows |
| 1132 | if (up_available) { |
| 1133 | const int mi_row_offset = -1; |
| 1134 | const MB_MODE_INFO *mbmi = xd->mi[mi_row_offset * mi_stride]; |
| 1135 | uint8_t superblock_width = mi_size_wide[mbmi->bsize]; |
| 1136 | |
| 1137 | if (xd->width <= superblock_width) { |
| 1138 | // Handle "current block width <= above block width" case. |
| 1139 | const int col_offset = -mi_col % superblock_width; |
| 1140 | |
| 1141 | if (col_offset < 0) do_tl = 0; |
| 1142 | if (col_offset + superblock_width > xd->width) do_tr = 0; |
| 1143 | |
| 1144 | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
| 1145 | record_samples(mbmi, pts, pts_inref, 0, -1, col_offset, 1); |
| 1146 | pts += 2; |
| 1147 | pts_inref += 2; |
| 1148 | if (++np >= LEAST_SQUARES_SAMPLES_MAX(1 << 3)) return LEAST_SQUARES_SAMPLES_MAX(1 << 3); |
| 1149 | } |
| 1150 | } else { |
| 1151 | // Handle "current block width > above block width" case. |
| 1152 | for (int i = 0; i < AOMMIN(xd->width, cm->mi_params.mi_cols - mi_col)(((xd->width) < (cm->mi_params.mi_cols - mi_col)) ? ( xd->width) : (cm->mi_params.mi_cols - mi_col)); |
| 1153 | i += superblock_width) { |
| 1154 | mbmi = xd->mi[i + mi_row_offset * mi_stride]; |
| 1155 | superblock_width = mi_size_wide[mbmi->bsize]; |
| 1156 | |
| 1157 | if (mbmi->ref_frame[0] == ref_frame && |
| 1158 | mbmi->ref_frame[1] == NONE_FRAME) { |
| 1159 | record_samples(mbmi, pts, pts_inref, 0, -1, i, 1); |
| 1160 | pts += 2; |
| 1161 | pts_inref += 2; |
| 1162 | if (++np >= LEAST_SQUARES_SAMPLES_MAX(1 << 3)) |
| 1163 | return LEAST_SQUARES_SAMPLES_MAX(1 << 3); |
| 1164 | } |
| 1165 | } |
| 1166 | } |
| 1167 | } |
| 1168 | assert(np <= LEAST_SQUARES_SAMPLES_MAX)((void) sizeof ((np <= (1 << 3)) ? 1 : 0), __extension__ ({ if (np <= (1 << 3)) ; else __assert_fail ("np <= LEAST_SQUARES_SAMPLES_MAX" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1168, __extension__ __PRETTY_FUNCTION__); })); |
| 1169 | |
| 1170 | // scan the nearest left columns |
| 1171 | if (left_available) { |
| 1172 | const int mi_col_offset = -1; |
| 1173 | const MB_MODE_INFO *mbmi = xd->mi[mi_col_offset]; |
| 1174 | uint8_t superblock_height = mi_size_high[mbmi->bsize]; |
| 1175 | |
| 1176 | if (xd->height <= superblock_height) { |
| 1177 | // Handle "current block height <= above block height" case. |
| 1178 | const int row_offset = -mi_row % superblock_height; |
| 1179 | |
| 1180 | if (row_offset < 0) do_tl = 0; |
| 1181 | |
| 1182 | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
| 1183 | record_samples(mbmi, pts, pts_inref, row_offset, 1, 0, -1); |
| 1184 | pts += 2; |
| 1185 | pts_inref += 2; |
| 1186 | np++; |
| 1187 | if (np >= LEAST_SQUARES_SAMPLES_MAX(1 << 3)) return LEAST_SQUARES_SAMPLES_MAX(1 << 3); |
| 1188 | } |
| 1189 | } else { |
| 1190 | // Handle "current block height > above block height" case. |
| 1191 | for (int i = 0; i < AOMMIN(xd->height, cm->mi_params.mi_rows - mi_row)(((xd->height) < (cm->mi_params.mi_rows - mi_row)) ? (xd->height) : (cm->mi_params.mi_rows - mi_row)); |
| 1192 | i += superblock_height) { |
| 1193 | mbmi = xd->mi[mi_col_offset + i * mi_stride]; |
| 1194 | superblock_height = mi_size_high[mbmi->bsize]; |
| 1195 | |
| 1196 | if (mbmi->ref_frame[0] == ref_frame && |
| 1197 | mbmi->ref_frame[1] == NONE_FRAME) { |
| 1198 | record_samples(mbmi, pts, pts_inref, i, 1, 0, -1); |
| 1199 | pts += 2; |
| 1200 | pts_inref += 2; |
| 1201 | if (++np >= LEAST_SQUARES_SAMPLES_MAX(1 << 3)) |
| 1202 | return LEAST_SQUARES_SAMPLES_MAX(1 << 3); |
| 1203 | } |
| 1204 | } |
| 1205 | } |
| 1206 | } |
| 1207 | assert(np <= LEAST_SQUARES_SAMPLES_MAX)((void) sizeof ((np <= (1 << 3)) ? 1 : 0), __extension__ ({ if (np <= (1 << 3)) ; else __assert_fail ("np <= LEAST_SQUARES_SAMPLES_MAX" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1207, __extension__ __PRETTY_FUNCTION__); })); |
| 1208 | |
| 1209 | // Top-left block |
| 1210 | if (do_tl && left_available && up_available) { |
| 1211 | const int mi_row_offset = -1; |
| 1212 | const int mi_col_offset = -1; |
| 1213 | MB_MODE_INFO *mbmi = xd->mi[mi_col_offset + mi_row_offset * mi_stride]; |
| 1214 | |
| 1215 | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
| 1216 | record_samples(mbmi, pts, pts_inref, 0, -1, 0, -1); |
| 1217 | pts += 2; |
| 1218 | pts_inref += 2; |
| 1219 | if (++np >= LEAST_SQUARES_SAMPLES_MAX(1 << 3)) return LEAST_SQUARES_SAMPLES_MAX(1 << 3); |
| 1220 | } |
| 1221 | } |
| 1222 | assert(np <= LEAST_SQUARES_SAMPLES_MAX)((void) sizeof ((np <= (1 << 3)) ? 1 : 0), __extension__ ({ if (np <= (1 << 3)) ; else __assert_fail ("np <= LEAST_SQUARES_SAMPLES_MAX" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1222, __extension__ __PRETTY_FUNCTION__); })); |
| 1223 | |
| 1224 | // Top-right block |
| 1225 | if (do_tr && |
| 1226 | has_top_right(cm, xd, mi_row, mi_col, AOMMAX(xd->width, xd->height)(((xd->width) > (xd->height)) ? (xd->width) : (xd ->height)))) { |
| 1227 | const POSITION trb_pos = { -1, xd->width }; |
| 1228 | const TileInfo *const tile = &xd->tile; |
| 1229 | if (is_inside(tile, mi_col, mi_row, &trb_pos)) { |
| 1230 | const int mi_row_offset = -1; |
| 1231 | const int mi_col_offset = xd->width; |
| 1232 | const MB_MODE_INFO *mbmi = |
| 1233 | xd->mi[mi_col_offset + mi_row_offset * mi_stride]; |
| 1234 | |
| 1235 | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
| 1236 | record_samples(mbmi, pts, pts_inref, 0, -1, xd->width, 1); |
| 1237 | if (++np >= LEAST_SQUARES_SAMPLES_MAX(1 << 3)) return LEAST_SQUARES_SAMPLES_MAX(1 << 3); |
| 1238 | } |
| 1239 | } |
| 1240 | } |
| 1241 | assert(np <= LEAST_SQUARES_SAMPLES_MAX)((void) sizeof ((np <= (1 << 3)) ? 1 : 0), __extension__ ({ if (np <= (1 << 3)) ; else __assert_fail ("np <= LEAST_SQUARES_SAMPLES_MAX" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1241, __extension__ __PRETTY_FUNCTION__); })); |
| 1242 | |
| 1243 | return np; |
| 1244 | } |
| 1245 | |
| 1246 | void av1_setup_skip_mode_allowed(AV1_COMMON *cm) { |
| 1247 | const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; |
| 1248 | SkipModeInfo *const skip_mode_info = &cm->current_frame.skip_mode_info; |
| 1249 | |
| 1250 | skip_mode_info->skip_mode_allowed = 0; |
| 1251 | skip_mode_info->ref_frame_idx_0 = INVALID_IDX-1; |
| 1252 | skip_mode_info->ref_frame_idx_1 = INVALID_IDX-1; |
| 1253 | |
| 1254 | if (!order_hint_info->enable_order_hint || frame_is_intra_only(cm) || |
| 1255 | cm->current_frame.reference_mode == SINGLE_REFERENCE) |
| 1256 | return; |
| 1257 | |
| 1258 | const int cur_order_hint = cm->current_frame.order_hint; |
| 1259 | int ref_order_hints[2] = { -1, INT_MAX2147483647 }; |
| 1260 | int ref_idx[2] = { INVALID_IDX-1, INVALID_IDX-1 }; |
| 1261 | |
| 1262 | // Identify the nearest forward and backward references. |
| 1263 | for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { |
| 1264 | const RefCntBuffer *const buf = get_ref_frame_buf(cm, LAST_FRAME + i); |
| 1265 | if (buf == NULL((void*)0)) continue; |
| 1266 | |
| 1267 | const int ref_order_hint = buf->order_hint; |
| 1268 | if (get_relative_dist(order_hint_info, ref_order_hint, cur_order_hint) < |
| 1269 | 0) { |
| 1270 | // Forward reference |
| 1271 | if (ref_order_hints[0] == -1 || |
| 1272 | get_relative_dist(order_hint_info, ref_order_hint, |
| 1273 | ref_order_hints[0]) > 0) { |
| 1274 | ref_order_hints[0] = ref_order_hint; |
| 1275 | ref_idx[0] = i; |
| 1276 | } |
| 1277 | } else if (get_relative_dist(order_hint_info, ref_order_hint, |
| 1278 | cur_order_hint) > 0) { |
| 1279 | // Backward reference |
| 1280 | if (ref_order_hints[1] == INT_MAX2147483647 || |
| 1281 | get_relative_dist(order_hint_info, ref_order_hint, |
| 1282 | ref_order_hints[1]) < 0) { |
| 1283 | ref_order_hints[1] = ref_order_hint; |
| 1284 | ref_idx[1] = i; |
| 1285 | } |
| 1286 | } |
| 1287 | } |
| 1288 | |
| 1289 | if (ref_idx[0] != INVALID_IDX-1 && ref_idx[1] != INVALID_IDX-1) { |
| 1290 | // == Bi-directional prediction == |
| 1291 | skip_mode_info->skip_mode_allowed = 1; |
| 1292 | skip_mode_info->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1])(((ref_idx[0]) < (ref_idx[1])) ? (ref_idx[0]) : (ref_idx[1 ])); |
| 1293 | skip_mode_info->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1])(((ref_idx[0]) > (ref_idx[1])) ? (ref_idx[0]) : (ref_idx[1 ])); |
| 1294 | } else if (ref_idx[0] != INVALID_IDX-1 && ref_idx[1] == INVALID_IDX-1) { |
| 1295 | // == Forward prediction only == |
| 1296 | // Identify the second nearest forward reference. |
| 1297 | ref_order_hints[1] = -1; |
| 1298 | for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { |
| 1299 | const RefCntBuffer *const buf = get_ref_frame_buf(cm, LAST_FRAME + i); |
| 1300 | if (buf == NULL((void*)0)) continue; |
| 1301 | |
| 1302 | const int ref_order_hint = buf->order_hint; |
| 1303 | if ((ref_order_hints[0] != -1 && |
| 1304 | get_relative_dist(order_hint_info, ref_order_hint, |
| 1305 | ref_order_hints[0]) < 0) && |
| 1306 | (ref_order_hints[1] == -1 || |
| 1307 | get_relative_dist(order_hint_info, ref_order_hint, |
| 1308 | ref_order_hints[1]) > 0)) { |
| 1309 | // Second closest forward reference |
| 1310 | ref_order_hints[1] = ref_order_hint; |
| 1311 | ref_idx[1] = i; |
| 1312 | } |
| 1313 | } |
| 1314 | if (ref_order_hints[1] != -1) { |
| 1315 | skip_mode_info->skip_mode_allowed = 1; |
| 1316 | skip_mode_info->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1])(((ref_idx[0]) < (ref_idx[1])) ? (ref_idx[0]) : (ref_idx[1 ])); |
| 1317 | skip_mode_info->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1])(((ref_idx[0]) > (ref_idx[1])) ? (ref_idx[0]) : (ref_idx[1 ])); |
| 1318 | } |
| 1319 | } |
| 1320 | } |
| 1321 | |
| 1322 | typedef struct { |
Excessive padding in 'REF_FRAME_INFO' (8 padding bytes, where 0 is optimal). Optimal fields order: buf, map_idx, sort_idx, consider reordering the fields or adding explicit padding members | |
| 1323 | int map_idx; // frame map index |
| 1324 | RefCntBuffer *buf; // frame buffer |
| 1325 | int sort_idx; // index based on the offset to be used for sorting |
| 1326 | } REF_FRAME_INFO; |
| 1327 | |
| 1328 | // Compares the sort_idx fields. If they are equal, then compares the map_idx |
| 1329 | // fields to break the tie. This ensures a stable sort. |
| 1330 | static int compare_ref_frame_info(const void *arg_a, const void *arg_b) { |
| 1331 | const REF_FRAME_INFO *info_a = (REF_FRAME_INFO *)arg_a; |
| 1332 | const REF_FRAME_INFO *info_b = (REF_FRAME_INFO *)arg_b; |
| 1333 | |
| 1334 | const int sort_idx_diff = info_a->sort_idx - info_b->sort_idx; |
| 1335 | if (sort_idx_diff != 0) return sort_idx_diff; |
| 1336 | return info_a->map_idx - info_b->map_idx; |
| 1337 | } |
| 1338 | |
| 1339 | static inline void set_ref_frame_info(int *remapped_ref_idx, int frame_idx, |
| 1340 | REF_FRAME_INFO *ref_info) { |
| 1341 | assert(frame_idx >= 0 && frame_idx < INTER_REFS_PER_FRAME)((void) sizeof ((frame_idx >= 0 && frame_idx < INTER_REFS_PER_FRAME ) ? 1 : 0), __extension__ ({ if (frame_idx >= 0 && frame_idx < INTER_REFS_PER_FRAME) ; else __assert_fail ("frame_idx >= 0 && frame_idx < INTER_REFS_PER_FRAME" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1341, __extension__ __PRETTY_FUNCTION__); })); |
| 1342 | |
| 1343 | remapped_ref_idx[frame_idx] = ref_info->map_idx; |
| 1344 | } |
| 1345 | |
| 1346 | void av1_set_frame_refs(AV1_COMMON *const cm, int *remapped_ref_idx, |
| 1347 | int lst_map_idx, int gld_map_idx) { |
| 1348 | int lst_frame_sort_idx = -1; |
| 1349 | int gld_frame_sort_idx = -1; |
| 1350 | |
| 1351 | assert(cm->seq_params->order_hint_info.enable_order_hint)((void) sizeof ((cm->seq_params->order_hint_info.enable_order_hint ) ? 1 : 0), __extension__ ({ if (cm->seq_params->order_hint_info .enable_order_hint) ; else __assert_fail ("cm->seq_params->order_hint_info.enable_order_hint" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1351, __extension__ __PRETTY_FUNCTION__); })); |
| 1352 | assert(cm->seq_params->order_hint_info.order_hint_bits_minus_1 >= 0)((void) sizeof ((cm->seq_params->order_hint_info.order_hint_bits_minus_1 >= 0) ? 1 : 0), __extension__ ({ if (cm->seq_params-> order_hint_info.order_hint_bits_minus_1 >= 0) ; else __assert_fail ("cm->seq_params->order_hint_info.order_hint_bits_minus_1 >= 0" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1352, __extension__ __PRETTY_FUNCTION__); })); |
| 1353 | const int cur_order_hint = (int)cm->current_frame.order_hint; |
| 1354 | const int cur_frame_sort_idx = |
| 1355 | 1 << cm->seq_params->order_hint_info.order_hint_bits_minus_1; |
| 1356 | |
| 1357 | REF_FRAME_INFO ref_frame_info[REF_FRAMES]; |
| 1358 | int ref_flag_list[INTER_REFS_PER_FRAME] = { 0, 0, 0, 0, 0, 0, 0 }; |
| 1359 | |
| 1360 | for (int i = 0; i < REF_FRAMES; ++i) { |
| 1361 | const int map_idx = i; |
| 1362 | |
| 1363 | ref_frame_info[i].map_idx = map_idx; |
| 1364 | ref_frame_info[i].sort_idx = -1; |
| 1365 | |
| 1366 | RefCntBuffer *const buf = cm->ref_frame_map[map_idx]; |
| 1367 | ref_frame_info[i].buf = buf; |
| 1368 | |
| 1369 | if (buf == NULL((void*)0)) continue; |
| 1370 | // If this assertion fails, there is a reference leak. |
| 1371 | assert(buf->ref_count > 0)((void) sizeof ((buf->ref_count > 0) ? 1 : 0), __extension__ ({ if (buf->ref_count > 0) ; else __assert_fail ("buf->ref_count > 0" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1371, __extension__ __PRETTY_FUNCTION__); })); |
| 1372 | |
| 1373 | const int offset = (int)buf->order_hint; |
| 1374 | ref_frame_info[i].sort_idx = |
| 1375 | (offset == -1) ? -1 |
| 1376 | : cur_frame_sort_idx + |
| 1377 | get_relative_dist(&cm->seq_params->order_hint_info, |
| 1378 | offset, cur_order_hint); |
| 1379 | assert(ref_frame_info[i].sort_idx >= -1)((void) sizeof ((ref_frame_info[i].sort_idx >= -1) ? 1 : 0 ), __extension__ ({ if (ref_frame_info[i].sort_idx >= -1) ; else __assert_fail ("ref_frame_info[i].sort_idx >= -1", "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1379, __extension__ __PRETTY_FUNCTION__); })); |
| 1380 | |
| 1381 | if (map_idx == lst_map_idx) lst_frame_sort_idx = ref_frame_info[i].sort_idx; |
| 1382 | if (map_idx == gld_map_idx) gld_frame_sort_idx = ref_frame_info[i].sort_idx; |
| 1383 | } |
| 1384 | |
| 1385 | // Confirm both LAST_FRAME and GOLDEN_FRAME are valid forward reference |
| 1386 | // frames. |
| 1387 | if (lst_frame_sort_idx == -1 || lst_frame_sort_idx >= cur_frame_sort_idx) { |
| 1388 | aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME, |
| 1389 | "Inter frame requests a look-ahead frame as LAST"); |
| 1390 | } |
| 1391 | if (gld_frame_sort_idx == -1 || gld_frame_sort_idx >= cur_frame_sort_idx) { |
| 1392 | aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME, |
| 1393 | "Inter frame requests a look-ahead frame as GOLDEN"); |
| 1394 | } |
| 1395 | |
| 1396 | // Sort ref frames based on their frame_offset values. |
| 1397 | qsort(ref_frame_info, REF_FRAMES, sizeof(REF_FRAME_INFO), |
| 1398 | compare_ref_frame_info); |
| 1399 | |
| 1400 | // Identify forward and backward reference frames. |
| 1401 | // Forward reference: offset < order_hint |
| 1402 | // Backward reference: offset >= order_hint |
| 1403 | int fwd_start_idx = 0, fwd_end_idx = REF_FRAMES - 1; |
| 1404 | |
| 1405 | for (int i = 0; i < REF_FRAMES; i++) { |
| 1406 | if (ref_frame_info[i].sort_idx == -1) { |
| 1407 | fwd_start_idx++; |
| 1408 | continue; |
| 1409 | } |
| 1410 | |
| 1411 | if (ref_frame_info[i].sort_idx >= cur_frame_sort_idx) { |
| 1412 | fwd_end_idx = i - 1; |
| 1413 | break; |
| 1414 | } |
| 1415 | } |
| 1416 | |
| 1417 | int bwd_start_idx = fwd_end_idx + 1; |
| 1418 | int bwd_end_idx = REF_FRAMES - 1; |
| 1419 | |
| 1420 | // === Backward Reference Frames === |
| 1421 | |
| 1422 | // == ALTREF_FRAME == |
| 1423 | if (bwd_start_idx <= bwd_end_idx) { |
| 1424 | set_ref_frame_info(remapped_ref_idx, ALTREF_FRAME - LAST_FRAME, |
| 1425 | &ref_frame_info[bwd_end_idx]); |
| 1426 | ref_flag_list[ALTREF_FRAME - LAST_FRAME] = 1; |
| 1427 | bwd_end_idx--; |
| 1428 | } |
| 1429 | |
| 1430 | // == BWDREF_FRAME == |
| 1431 | if (bwd_start_idx <= bwd_end_idx) { |
| 1432 | set_ref_frame_info(remapped_ref_idx, BWDREF_FRAME - LAST_FRAME, |
| 1433 | &ref_frame_info[bwd_start_idx]); |
| 1434 | ref_flag_list[BWDREF_FRAME - LAST_FRAME] = 1; |
| 1435 | bwd_start_idx++; |
| 1436 | } |
| 1437 | |
| 1438 | // == ALTREF2_FRAME == |
| 1439 | if (bwd_start_idx <= bwd_end_idx) { |
| 1440 | set_ref_frame_info(remapped_ref_idx, ALTREF2_FRAME - LAST_FRAME, |
| 1441 | &ref_frame_info[bwd_start_idx]); |
| 1442 | ref_flag_list[ALTREF2_FRAME - LAST_FRAME] = 1; |
| 1443 | } |
| 1444 | |
| 1445 | // === Forward Reference Frames === |
| 1446 | |
| 1447 | for (int i = fwd_start_idx; i <= fwd_end_idx; ++i) { |
| 1448 | // == LAST_FRAME == |
| 1449 | if (ref_frame_info[i].map_idx == lst_map_idx) { |
| 1450 | set_ref_frame_info(remapped_ref_idx, LAST_FRAME - LAST_FRAME, |
| 1451 | &ref_frame_info[i]); |
| 1452 | ref_flag_list[LAST_FRAME - LAST_FRAME] = 1; |
| 1453 | } |
| 1454 | |
| 1455 | // == GOLDEN_FRAME == |
| 1456 | if (ref_frame_info[i].map_idx == gld_map_idx) { |
| 1457 | set_ref_frame_info(remapped_ref_idx, GOLDEN_FRAME - LAST_FRAME, |
| 1458 | &ref_frame_info[i]); |
| 1459 | ref_flag_list[GOLDEN_FRAME - LAST_FRAME] = 1; |
| 1460 | } |
| 1461 | } |
| 1462 | |
| 1463 | assert(ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 &&((void) sizeof ((ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1) ? 1 : 0), __extension__ ({ if (ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1) ; else __assert_fail ("ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1464, __extension__ __PRETTY_FUNCTION__); })) |
| 1464 | ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1)((void) sizeof ((ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1) ? 1 : 0), __extension__ ({ if (ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1) ; else __assert_fail ("ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1464, __extension__ __PRETTY_FUNCTION__); })); |
| 1465 | |
| 1466 | // == LAST2_FRAME == |
| 1467 | // == LAST3_FRAME == |
| 1468 | // == BWDREF_FRAME == |
| 1469 | // == ALTREF2_FRAME == |
| 1470 | // == ALTREF_FRAME == |
| 1471 | |
| 1472 | // Set up the reference frames in the anti-chronological order. |
| 1473 | static const MV_REFERENCE_FRAME ref_frame_list[INTER_REFS_PER_FRAME - 2] = { |
| 1474 | LAST2_FRAME, LAST3_FRAME, BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME |
| 1475 | }; |
| 1476 | |
| 1477 | int ref_idx; |
| 1478 | for (ref_idx = 0; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { |
| 1479 | const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; |
| 1480 | |
| 1481 | if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; |
| 1482 | |
| 1483 | while (fwd_start_idx <= fwd_end_idx && |
| 1484 | (ref_frame_info[fwd_end_idx].map_idx == lst_map_idx || |
| 1485 | ref_frame_info[fwd_end_idx].map_idx == gld_map_idx)) { |
| 1486 | fwd_end_idx--; |
| 1487 | } |
| 1488 | if (fwd_start_idx > fwd_end_idx) break; |
| 1489 | |
| 1490 | set_ref_frame_info(remapped_ref_idx, ref_frame - LAST_FRAME, |
| 1491 | &ref_frame_info[fwd_end_idx]); |
| 1492 | ref_flag_list[ref_frame - LAST_FRAME] = 1; |
| 1493 | |
| 1494 | fwd_end_idx--; |
| 1495 | } |
| 1496 | |
| 1497 | // Assign all the remaining frame(s), if any, to the earliest reference |
| 1498 | // frame. |
| 1499 | for (; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { |
| 1500 | const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; |
| 1501 | if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; |
| 1502 | set_ref_frame_info(remapped_ref_idx, ref_frame - LAST_FRAME, |
| 1503 | &ref_frame_info[fwd_start_idx]); |
| 1504 | ref_flag_list[ref_frame - LAST_FRAME] = 1; |
| 1505 | } |
| 1506 | |
| 1507 | for (int i = 0; i < INTER_REFS_PER_FRAME; i++) { |
| 1508 | assert(ref_flag_list[i] == 1)((void) sizeof ((ref_flag_list[i] == 1) ? 1 : 0), __extension__ ({ if (ref_flag_list[i] == 1) ; else __assert_fail ("ref_flag_list[i] == 1" , "/root/firefox-clang/third_party/aom/av1/common/mvref_common.c" , 1508, __extension__ __PRETTY_FUNCTION__); })); |
| 1509 | } |
| 1510 | } |