| File: | root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c |
| Warning: | line 2146, column 56 The left operand of '!=' is a garbage value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* | ||||
| 2 | * Copyright (c) 2014 The WebM project authors. All Rights Reserved. | ||||
| 3 | * | ||||
| 4 | * Use of this source code is governed by a BSD-style license | ||||
| 5 | * that can be found in the LICENSE file in the root of the source | ||||
| 6 | * tree. An additional intellectual property rights grant can be found | ||||
| 7 | * in the file PATENTS. All contributing project authors may | ||||
| 8 | * be found in the AUTHORS file in the root of the source tree. | ||||
| 9 | */ | ||||
| 10 | |||||
| 11 | #include <assert.h> | ||||
| 12 | #include <limits.h> | ||||
| 13 | #include <math.h> | ||||
| 14 | #include <stdio.h> | ||||
| 15 | #include <stdlib.h> | ||||
| 16 | |||||
| 17 | #include "./vp9_rtcd.h" | ||||
| 18 | #include "./vpx_dsp_rtcd.h" | ||||
| 19 | |||||
| 20 | #include "vpx/vpx_codec.h" | ||||
| 21 | #include "vpx_dsp/vpx_dsp_common.h" | ||||
| 22 | #include "vpx_mem/vpx_mem.h" | ||||
| 23 | #include "vpx_ports/compiler_attributes.h" | ||||
| 24 | |||||
| 25 | #include "vp9/common/vp9_blockd.h" | ||||
| 26 | #include "vp9/common/vp9_common.h" | ||||
| 27 | #include "vp9/common/vp9_mvref_common.h" | ||||
| 28 | #include "vp9/common/vp9_pred_common.h" | ||||
| 29 | #include "vp9/common/vp9_reconinter.h" | ||||
| 30 | #include "vp9/common/vp9_reconintra.h" | ||||
| 31 | #include "vp9/common/vp9_scan.h" | ||||
| 32 | |||||
| 33 | #include "vp9/encoder/vp9_cost.h" | ||||
| 34 | #include "vp9/encoder/vp9_encoder.h" | ||||
| 35 | #include "vp9/encoder/vp9_pickmode.h" | ||||
| 36 | #include "vp9/encoder/vp9_ratectrl.h" | ||||
| 37 | #include "vp9/encoder/vp9_rd.h" | ||||
| 38 | |||||
| 39 | typedef struct { | ||||
| 40 | uint8_t *data; | ||||
| 41 | int stride; | ||||
| 42 | int in_use; | ||||
| 43 | } PRED_BUFFER; | ||||
| 44 | |||||
| 45 | typedef struct { | ||||
| 46 | PRED_BUFFER *best_pred; | ||||
| 47 | PREDICTION_MODE best_mode; | ||||
| 48 | TX_SIZE best_tx_size; | ||||
| 49 | TX_SIZE best_intra_tx_size; | ||||
| 50 | MV_REFERENCE_FRAME best_ref_frame; | ||||
| 51 | MV_REFERENCE_FRAME best_second_ref_frame; | ||||
| 52 | uint8_t best_mode_skip_txfm; | ||||
| 53 | INTERP_FILTER best_pred_filter; | ||||
| 54 | } BEST_PICKMODE; | ||||
| 55 | |||||
| 56 | static const int pos_shift_16x16[4][4] = { | ||||
| 57 | { 9, 10, 13, 14 }, { 11, 12, 15, 16 }, { 17, 18, 21, 22 }, { 19, 20, 23, 24 } | ||||
| 58 | }; | ||||
| 59 | |||||
| 60 | static int mv_refs_rt(VP9_COMP *cpi, const VP9_COMMON *cm, const MACROBLOCK *x, | ||||
| 61 | const MACROBLOCKD *xd, const TileInfo *const tile, | ||||
| 62 | MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, | ||||
| 63 | int_mv *mv_ref_list, int_mv *base_mv, int mi_row, | ||||
| 64 | int mi_col, int use_base_mv) { | ||||
| 65 | const int *ref_sign_bias = cm->ref_frame_sign_bias; | ||||
| 66 | int i, refmv_count = 0; | ||||
| 67 | |||||
| 68 | const POSITION *const mv_ref_search = mv_ref_blocks[mi->sb_type]; | ||||
| 69 | |||||
| 70 | int different_ref_found = 0; | ||||
| 71 | int context_counter = 0; | ||||
| 72 | int const_motion = 0; | ||||
| 73 | |||||
| 74 | // Blank the reference vector list | ||||
| 75 | memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES2); | ||||
| 76 | |||||
| 77 | // The nearest 2 blocks are treated differently | ||||
| 78 | // if the size < 8x8 we get the mv from the bmi substructure, | ||||
| 79 | // and we also need to keep a mode count. | ||||
| 80 | for (i = 0; i < 2; ++i) { | ||||
| 81 | const POSITION *const mv_ref = &mv_ref_search[i]; | ||||
| 82 | if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { | ||||
| 83 | const MODE_INFO *const candidate_mi = | ||||
| 84 | xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]; | ||||
| 85 | // Keep counts for entropy encoding. | ||||
| 86 | context_counter += mode_2_counter[candidate_mi->mode]; | ||||
| 87 | different_ref_found = 1; | ||||
| 88 | |||||
| 89 | if (candidate_mi->ref_frame[0] == ref_frame) | ||||
| 90 | ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 0, mv_ref->col, -1),do { if (refmv_count) { if ((get_sub_block_mv(candidate_mi, 0 , mv_ref->col, -1)).as_int != (mv_ref_list)[0].as_int) { ( mv_ref_list)[(refmv_count)] = (get_sub_block_mv(candidate_mi, 0, mv_ref->col, -1)); goto Done; } } else { (mv_ref_list) [(refmv_count)++] = (get_sub_block_mv(candidate_mi, 0, mv_ref ->col, -1)); } } while (0) | ||||
| 91 | refmv_count, mv_ref_list, Done)do { if (refmv_count) { if ((get_sub_block_mv(candidate_mi, 0 , mv_ref->col, -1)).as_int != (mv_ref_list)[0].as_int) { ( mv_ref_list)[(refmv_count)] = (get_sub_block_mv(candidate_mi, 0, mv_ref->col, -1)); goto Done; } } else { (mv_ref_list) [(refmv_count)++] = (get_sub_block_mv(candidate_mi, 0, mv_ref ->col, -1)); } } while (0); | ||||
| 92 | } | ||||
| 93 | } | ||||
| 94 | |||||
| 95 | const_motion = 1; | ||||
| 96 | |||||
| 97 | // Check the rest of the neighbors in much the same way | ||||
| 98 | // as before except we don't need to keep track of sub blocks or | ||||
| 99 | // mode counts. | ||||
| 100 | for (; i < MVREF_NEIGHBOURS8 && !refmv_count; ++i) { | ||||
| 101 | const POSITION *const mv_ref = &mv_ref_search[i]; | ||||
| 102 | if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { | ||||
| 103 | const MODE_INFO *const candidate_mi = | ||||
| 104 | xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]; | ||||
| 105 | different_ref_found = 1; | ||||
| 106 | |||||
| 107 | if (candidate_mi->ref_frame[0] == ref_frame) | ||||
| 108 | ADD_MV_REF_LIST(candidate_mi->mv[0], refmv_count, mv_ref_list, Done)do { if (refmv_count) { if ((candidate_mi->mv[0]).as_int != (mv_ref_list)[0].as_int) { (mv_ref_list)[(refmv_count)] = (candidate_mi ->mv[0]); goto Done; } } else { (mv_ref_list)[(refmv_count )++] = (candidate_mi->mv[0]); } } while (0); | ||||
| 109 | } | ||||
| 110 | } | ||||
| 111 | |||||
| 112 | // Since we couldn't find 2 mvs from the same reference frame | ||||
| 113 | // go back through the neighbors and find motion vectors from | ||||
| 114 | // different reference frames. | ||||
| 115 | if (different_ref_found && !refmv_count) { | ||||
| 116 | for (i = 0; i < MVREF_NEIGHBOURS8; ++i) { | ||||
| 117 | const POSITION *mv_ref = &mv_ref_search[i]; | ||||
| 118 | if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { | ||||
| 119 | const MODE_INFO *const candidate_mi = | ||||
| 120 | xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]; | ||||
| 121 | |||||
| 122 | // If the candidate is INTRA we don't want to consider its mv. | ||||
| 123 | IF_DIFF_REF_FRAME_ADD_MV(candidate_mi, ref_frame, ref_sign_bias,do { if (is_inter_block(candidate_mi)) { if ((candidate_mi)-> ref_frame[0] != (ref_frame)) do { if (refmv_count) { if ((scale_mv ((candidate_mi), 0, ref_frame, ref_sign_bias)).as_int != (mv_ref_list )[0].as_int) { (mv_ref_list)[(refmv_count)] = (scale_mv((candidate_mi ), 0, ref_frame, ref_sign_bias)); goto Done; } } else { (mv_ref_list )[(refmv_count)++] = (scale_mv((candidate_mi), 0, ref_frame, ref_sign_bias )); } } while (0); if (has_second_ref(candidate_mi) && (candidate_mi)->ref_frame[1] != (ref_frame) && (candidate_mi )->mv[1].as_int != (candidate_mi)->mv[0].as_int) do { if (refmv_count) { if ((scale_mv((candidate_mi), 1, ref_frame, ref_sign_bias )).as_int != (mv_ref_list)[0].as_int) { (mv_ref_list)[(refmv_count )] = (scale_mv((candidate_mi), 1, ref_frame, ref_sign_bias)); goto Done; } } else { (mv_ref_list)[(refmv_count)++] = (scale_mv ((candidate_mi), 1, ref_frame, ref_sign_bias)); } } while (0) ; } } while (0) | ||||
| 124 | refmv_count, mv_ref_list, Done)do { if (is_inter_block(candidate_mi)) { if ((candidate_mi)-> ref_frame[0] != (ref_frame)) do { if (refmv_count) { if ((scale_mv ((candidate_mi), 0, ref_frame, ref_sign_bias)).as_int != (mv_ref_list )[0].as_int) { (mv_ref_list)[(refmv_count)] = (scale_mv((candidate_mi ), 0, ref_frame, ref_sign_bias)); goto Done; } } else { (mv_ref_list )[(refmv_count)++] = (scale_mv((candidate_mi), 0, ref_frame, ref_sign_bias )); } } while (0); if (has_second_ref(candidate_mi) && (candidate_mi)->ref_frame[1] != (ref_frame) && (candidate_mi )->mv[1].as_int != (candidate_mi)->mv[0].as_int) do { if (refmv_count) { if ((scale_mv((candidate_mi), 1, ref_frame, ref_sign_bias )).as_int != (mv_ref_list)[0].as_int) { (mv_ref_list)[(refmv_count )] = (scale_mv((candidate_mi), 1, ref_frame, ref_sign_bias)); goto Done; } } else { (mv_ref_list)[(refmv_count)++] = (scale_mv ((candidate_mi), 1, ref_frame, ref_sign_bias)); } } while (0) ; } } while (0); | ||||
| 125 | } | ||||
| 126 | } | ||||
| 127 | } | ||||
| 128 | if (use_base_mv && | ||||
| 129 | !cpi->svc.layer_context[cpi->svc.temporal_layer_id].is_key_frame && | ||||
| 130 | ref_frame == LAST_FRAME1) { | ||||
| 131 | // Get base layer mv. | ||||
| 132 | const int prev_layer = cpi->svc.spatial_layer_id - 1; | ||||
| 133 | const int index = | ||||
| 134 | (mi_col >> 1) + (mi_row >> 1) * cpi->svc.mi_cols[prev_layer]; | ||||
| 135 | // prev_frame->mvs[] is allocated to size mi_cols * mi_rows corresponding | ||||
| 136 | // to the previous spatial layer, so the index check is against | ||||
| 137 | // svc.mi_col/rows[prev_layer]. | ||||
| 138 | if (index < cpi->svc.mi_cols[prev_layer] * cpi->svc.mi_rows[prev_layer]) { | ||||
| 139 | MV_REF *candidate = &cm->prev_frame->mvs[index]; | ||||
| 140 | // Avoid using base_mv if scaled mv is out of range, for either component. | ||||
| 141 | if (candidate->mv[0].as_int != INVALID_MV0x80008000 && | ||||
| 142 | abs(candidate->mv[0].as_mv.row) <= INT16_MAX(32767) >> 1 && | ||||
| 143 | abs(candidate->mv[0].as_mv.col) <= INT16_MAX(32767) >> 1) { | ||||
| 144 | base_mv->as_mv.row = candidate->mv[0].as_mv.row * 2; | ||||
| 145 | base_mv->as_mv.col = candidate->mv[0].as_mv.col * 2; | ||||
| 146 | clamp_mv_ref(&base_mv->as_mv, xd); | ||||
| 147 | } else { | ||||
| 148 | base_mv->as_int = INVALID_MV0x80008000; | ||||
| 149 | } | ||||
| 150 | } | ||||
| 151 | } | ||||
| 152 | |||||
| 153 | Done: | ||||
| 154 | |||||
| 155 | x->mbmi_ext->mode_context[ref_frame] = counter_to_context[context_counter]; | ||||
| 156 | |||||
| 157 | // Clamp vectors | ||||
| 158 | for (i = 0; i < MAX_MV_REF_CANDIDATES2; ++i) | ||||
| 159 | clamp_mv_ref(&mv_ref_list[i].as_mv, xd); | ||||
| 160 | |||||
| 161 | return const_motion; | ||||
| 162 | } | ||||
| 163 | |||||
| 164 | static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x, | ||||
| 165 | BLOCK_SIZE bsize, int mi_row, int mi_col, | ||||
| 166 | int_mv *tmp_mv, int *rate_mv, | ||||
| 167 | int64_t best_rd_sofar, int use_base_mv) { | ||||
| 168 | MACROBLOCKD *xd = &x->e_mbd; | ||||
| 169 | MODE_INFO *mi = xd->mi[0]; | ||||
| 170 | struct buf_2d backup_yv12[MAX_MB_PLANE3] = { { 0, 0 } }; | ||||
| 171 | const int step_param = cpi->sf.mv.fullpel_search_step_param; | ||||
| 172 | const int sadpb = x->sadperbit16; | ||||
| 173 | MV mvp_full; | ||||
| 174 | const int ref = mi->ref_frame[0]; | ||||
| 175 | const MV ref_mv = x->mbmi_ext->ref_mvs[ref][0].as_mv; | ||||
| 176 | MV center_mv; | ||||
| 177 | uint32_t dis; | ||||
| 178 | int rate_mode; | ||||
| 179 | const MvLimits tmp_mv_limits = x->mv_limits; | ||||
| 180 | int rv = 0; | ||||
| 181 | int cost_list[5]; | ||||
| 182 | int search_subpel = 1; | ||||
| 183 | const YV12_BUFFER_CONFIG *scaled_ref_frame = | ||||
| 184 | vp9_get_scaled_ref_frame(cpi, ref); | ||||
| 185 | if (scaled_ref_frame) { | ||||
| 186 | assert(scaled_ref_frame->y_width == cpi->Source->y_width &&((void) sizeof ((scaled_ref_frame->y_width == cpi->Source ->y_width && scaled_ref_frame->y_height == cpi-> Source->y_height) ? 1 : 0), __extension__ ({ if (scaled_ref_frame ->y_width == cpi->Source->y_width && scaled_ref_frame ->y_height == cpi->Source->y_height) ; else __assert_fail ("scaled_ref_frame->y_width == cpi->Source->y_width && scaled_ref_frame->y_height == cpi->Source->y_height" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 187, __extension__ __PRETTY_FUNCTION__); })) | ||||
| 187 | scaled_ref_frame->y_height == cpi->Source->y_height)((void) sizeof ((scaled_ref_frame->y_width == cpi->Source ->y_width && scaled_ref_frame->y_height == cpi-> Source->y_height) ? 1 : 0), __extension__ ({ if (scaled_ref_frame ->y_width == cpi->Source->y_width && scaled_ref_frame ->y_height == cpi->Source->y_height) ; else __assert_fail ("scaled_ref_frame->y_width == cpi->Source->y_width && scaled_ref_frame->y_height == cpi->Source->y_height" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 187, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 188 | int i; | ||||
| 189 | // Swap out the reference frame for a version that's been scaled to | ||||
| 190 | // match the resolution of the current frame, allowing the existing | ||||
| 191 | // motion search code to be used without additional modifications. | ||||
| 192 | for (i = 0; i < MAX_MB_PLANE3; i++) backup_yv12[i] = xd->plane[i].pre[0]; | ||||
| 193 | vp9_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL((void*)0)); | ||||
| 194 | } | ||||
| 195 | vp9_set_mv_search_range(&x->mv_limits, &ref_mv); | ||||
| 196 | |||||
| 197 | // Limit motion vector for large lightning change. | ||||
| 198 | if (cpi->oxcf.speed > 5 && x->lowvar_highsumdiff) { | ||||
| 199 | x->mv_limits.col_min = VPXMAX(x->mv_limits.col_min, -10)(((x->mv_limits.col_min) > (-10)) ? (x->mv_limits.col_min ) : (-10)); | ||||
| 200 | x->mv_limits.row_min = VPXMAX(x->mv_limits.row_min, -10)(((x->mv_limits.row_min) > (-10)) ? (x->mv_limits.row_min ) : (-10)); | ||||
| 201 | x->mv_limits.col_max = VPXMIN(x->mv_limits.col_max, 10)(((x->mv_limits.col_max) < (10)) ? (x->mv_limits.col_max ) : (10)); | ||||
| 202 | x->mv_limits.row_max = VPXMIN(x->mv_limits.row_max, 10)(((x->mv_limits.row_max) < (10)) ? (x->mv_limits.row_max ) : (10)); | ||||
| 203 | } | ||||
| 204 | |||||
| 205 | assert(x->mv_best_ref_index[ref] <= 2)((void) sizeof ((x->mv_best_ref_index[ref] <= 2) ? 1 : 0 ), __extension__ ({ if (x->mv_best_ref_index[ref] <= 2) ; else __assert_fail ("x->mv_best_ref_index[ref] <= 2" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 205, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 206 | if (x->mv_best_ref_index[ref] < 2) | ||||
| 207 | mvp_full = x->mbmi_ext->ref_mvs[ref][x->mv_best_ref_index[ref]].as_mv; | ||||
| 208 | else | ||||
| 209 | mvp_full = x->pred_mv[ref]; | ||||
| 210 | |||||
| 211 | mvp_full.col >>= 3; | ||||
| 212 | mvp_full.row >>= 3; | ||||
| 213 | |||||
| 214 | if (!use_base_mv) | ||||
| 215 | center_mv = ref_mv; | ||||
| 216 | else | ||||
| 217 | center_mv = tmp_mv->as_mv; | ||||
| 218 | |||||
| 219 | if (x->sb_use_mv_part) { | ||||
| 220 | tmp_mv->as_mv.row = x->sb_mvrow_part >> 3; | ||||
| 221 | tmp_mv->as_mv.col = x->sb_mvcol_part >> 3; | ||||
| 222 | } else { | ||||
| 223 | vp9_full_pixel_search( | ||||
| 224 | cpi, x, bsize, &mvp_full, step_param, cpi->sf.mv.search_method, sadpb, | ||||
| 225 | cond_cost_list(cpi, cost_list), ¢er_mv, &tmp_mv->as_mv, INT_MAX2147483647, 0); | ||||
| 226 | } | ||||
| 227 | |||||
| 228 | x->mv_limits = tmp_mv_limits; | ||||
| 229 | |||||
| 230 | // calculate the bit cost on motion vector | ||||
| 231 | mvp_full.row = tmp_mv->as_mv.row * 8; | ||||
| 232 | mvp_full.col = tmp_mv->as_mv.col * 8; | ||||
| 233 | |||||
| 234 | *rate_mv = vp9_mv_bit_cost(&mvp_full, &ref_mv, x->nmvjointcost, x->mvcost, | ||||
| 235 | MV_COST_WEIGHT108); | ||||
| 236 | |||||
| 237 | rate_mode = | ||||
| 238 | cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref]][INTER_OFFSET(NEWMV)((13) - 10)]; | ||||
| 239 | rv = | ||||
| 240 | !(RDCOST(x->rdmult, x->rddiv, (*rate_mv + rate_mode), 0)(((((int64_t)((*rate_mv + rate_mode))) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((0) << (x->rddiv )) > best_rd_sofar); | ||||
| 241 | |||||
| 242 | // For SVC on non-reference frame, avoid subpel for (0, 0) motion. | ||||
| 243 | if (cpi->use_svc && cpi->svc.non_reference_frame) { | ||||
| 244 | if (mvp_full.row == 0 && mvp_full.col == 0) search_subpel = 0; | ||||
| 245 | } | ||||
| 246 | |||||
| 247 | if (rv && search_subpel) { | ||||
| 248 | SUBPEL_FORCE_STOP subpel_force_stop = cpi->sf.mv.subpel_force_stop; | ||||
| 249 | if (use_base_mv && cpi->sf.base_mv_aggressive) subpel_force_stop = HALF_PEL; | ||||
| 250 | if (cpi->sf.mv.enable_adaptive_subpel_force_stop) { | ||||
| 251 | const int mv_thresh = cpi->sf.mv.adapt_subpel_force_stop.mv_thresh; | ||||
| 252 | if (abs(tmp_mv->as_mv.row) >= mv_thresh || | ||||
| 253 | abs(tmp_mv->as_mv.col) >= mv_thresh) | ||||
| 254 | subpel_force_stop = cpi->sf.mv.adapt_subpel_force_stop.force_stop_above; | ||||
| 255 | else | ||||
| 256 | subpel_force_stop = cpi->sf.mv.adapt_subpel_force_stop.force_stop_below; | ||||
| 257 | } | ||||
| 258 | cpi->find_fractional_mv_step( | ||||
| 259 | x, &tmp_mv->as_mv, &ref_mv, cpi->common.allow_high_precision_mv, | ||||
| 260 | x->errorperbit, &cpi->fn_ptr[bsize], subpel_force_stop, | ||||
| 261 | cpi->sf.mv.subpel_search_level, cond_cost_list(cpi, cost_list), | ||||
| 262 | x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL((void*)0), 0, 0, | ||||
| 263 | cpi->sf.use_accurate_subpel_search); | ||||
| 264 | *rate_mv = vp9_mv_bit_cost(&tmp_mv->as_mv, &ref_mv, x->nmvjointcost, | ||||
| 265 | x->mvcost, MV_COST_WEIGHT108); | ||||
| 266 | } | ||||
| 267 | |||||
| 268 | if (scaled_ref_frame) { | ||||
| 269 | int i; | ||||
| 270 | for (i = 0; i < MAX_MB_PLANE3; i++) xd->plane[i].pre[0] = backup_yv12[i]; | ||||
| 271 | } | ||||
| 272 | return rv; | ||||
| 273 | } | ||||
| 274 | |||||
| 275 | static void block_variance(const uint8_t *src, int src_stride, | ||||
| 276 | const uint8_t *ref, int ref_stride, int w, int h, | ||||
| 277 | unsigned int *sse, int *sum, int block_size, | ||||
| 278 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 279 | int use_highbitdepth, vpx_bit_depth_t bd, | ||||
| 280 | #endif | ||||
| 281 | uint32_t *sse8x8, int *sum8x8, uint32_t *var8x8) { | ||||
| 282 | int i, j, k = 0; | ||||
| 283 | uint32_t k_sqr = 0; | ||||
| 284 | |||||
| 285 | *sse = 0; | ||||
| 286 | *sum = 0; | ||||
| 287 | |||||
| 288 | for (i = 0; i < h; i += block_size) { | ||||
| 289 | for (j = 0; j < w; j += block_size) { | ||||
| 290 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 291 | if (use_highbitdepth) { | ||||
| 292 | switch (bd) { | ||||
| 293 | case VPX_BITS_8: | ||||
| 294 | vpx_highbd_8_get8x8var(src + src_stride * i + j, src_stride, | ||||
| 295 | ref + ref_stride * i + j, ref_stride, | ||||
| 296 | &sse8x8[k], &sum8x8[k]); | ||||
| 297 | break; | ||||
| 298 | case VPX_BITS_10: | ||||
| 299 | vpx_highbd_10_get8x8var(src + src_stride * i + j, src_stride, | ||||
| 300 | ref + ref_stride * i + j, ref_stride, | ||||
| 301 | &sse8x8[k], &sum8x8[k]); | ||||
| 302 | break; | ||||
| 303 | case VPX_BITS_12: | ||||
| 304 | vpx_highbd_12_get8x8var(src + src_stride * i + j, src_stride, | ||||
| 305 | ref + ref_stride * i + j, ref_stride, | ||||
| 306 | &sse8x8[k], &sum8x8[k]); | ||||
| 307 | break; | ||||
| 308 | } | ||||
| 309 | } else { | ||||
| 310 | vpx_get8x8varvpx_get8x8var_sse2(src + src_stride * i + j, src_stride, | ||||
| 311 | ref + ref_stride * i + j, ref_stride, &sse8x8[k], | ||||
| 312 | &sum8x8[k]); | ||||
| 313 | } | ||||
| 314 | #else | ||||
| 315 | vpx_get8x8varvpx_get8x8var_sse2(src + src_stride * i + j, src_stride, | ||||
| 316 | ref + ref_stride * i + j, ref_stride, &sse8x8[k], | ||||
| 317 | &sum8x8[k]); | ||||
| 318 | #endif | ||||
| 319 | *sse += sse8x8[k]; | ||||
| 320 | *sum += sum8x8[k]; | ||||
| 321 | k_sqr = (uint32_t)(((int64_t)sum8x8[k] * sum8x8[k]) >> 6); | ||||
| 322 | var8x8[k] = sse8x8[k] > k_sqr ? sse8x8[k] - k_sqr : k_sqr - sse8x8[k]; | ||||
| 323 | k++; | ||||
| 324 | } | ||||
| 325 | } | ||||
| 326 | } | ||||
| 327 | |||||
| 328 | static void calculate_variance(int bw, int bh, TX_SIZE tx_size, | ||||
| 329 | unsigned int *sse_i, int *sum_i, | ||||
| 330 | unsigned int *var_o, unsigned int *sse_o, | ||||
| 331 | int *sum_o) { | ||||
| 332 | const BLOCK_SIZE unit_size = txsize_to_bsize[tx_size]; | ||||
| 333 | const int nw = 1 << (bw - b_width_log2_lookup[unit_size]); | ||||
| 334 | const int nh = 1 << (bh - b_height_log2_lookup[unit_size]); | ||||
| 335 | int i, j, k = 0; | ||||
| 336 | uint32_t k_sqr = 0; | ||||
| 337 | |||||
| 338 | for (i = 0; i < nh; i += 2) { | ||||
| 339 | for (j = 0; j < nw; j += 2) { | ||||
| 340 | sse_o[k] = sse_i[i * nw + j] + sse_i[i * nw + j + 1] + | ||||
| 341 | sse_i[(i + 1) * nw + j] + sse_i[(i + 1) * nw + j + 1]; | ||||
| 342 | sum_o[k] = sum_i[i * nw + j] + sum_i[i * nw + j + 1] + | ||||
| 343 | sum_i[(i + 1) * nw + j] + sum_i[(i + 1) * nw + j + 1]; | ||||
| 344 | k_sqr = (uint32_t)(((int64_t)sum_o[k] * sum_o[k]) >> | ||||
| 345 | (b_width_log2_lookup[unit_size] + | ||||
| 346 | b_height_log2_lookup[unit_size] + 6)); | ||||
| 347 | var_o[k] = sse_o[k] > k_sqr ? sse_o[k] - k_sqr : k_sqr - sse_o[k]; | ||||
| 348 | k++; | ||||
| 349 | } | ||||
| 350 | } | ||||
| 351 | } | ||||
| 352 | |||||
| 353 | // Adjust the ac_thr according to speed, width, height and normalized sum | ||||
| 354 | static int ac_thr_factor(const int speed, const int width, const int height, | ||||
| 355 | const int norm_sum) { | ||||
| 356 | if (speed >= 8 && norm_sum < 5) { | ||||
| 357 | if (width <= 640 && height <= 480) | ||||
| 358 | return 4; | ||||
| 359 | else | ||||
| 360 | return 2; | ||||
| 361 | } | ||||
| 362 | return 1; | ||||
| 363 | } | ||||
| 364 | |||||
| 365 | static TX_SIZE calculate_tx_size(VP9_COMP *const cpi, BLOCK_SIZE bsize, | ||||
| 366 | MACROBLOCKD *const xd, unsigned int var, | ||||
| 367 | unsigned int sse, int64_t ac_thr, | ||||
| 368 | unsigned int source_variance, int is_intra) { | ||||
| 369 | // TODO(marpan): Tune selection for intra-modes, screen content, etc. | ||||
| 370 | TX_SIZE tx_size; | ||||
| 371 | unsigned int var_thresh = is_intra ? (unsigned int)ac_thr : 1; | ||||
| 372 | int limit_tx = 1; | ||||
| 373 | if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && | ||||
| 374 | (source_variance == 0 || var < var_thresh)) | ||||
| 375 | limit_tx = 0; | ||||
| 376 | if (cpi->common.tx_mode == TX_MODE_SELECT) { | ||||
| 377 | if (sse > (var << 2)) | ||||
| 378 | tx_size = VPXMIN(max_txsize_lookup[bsize],(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) | ||||
| 379 | tx_mode_to_biggest_tx_size[cpi->common.tx_mode])(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])); | ||||
| 380 | else | ||||
| 381 | tx_size = TX_8X8((TX_SIZE)1); | ||||
| 382 | if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && limit_tx && | ||||
| 383 | cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id)) | ||||
| 384 | tx_size = TX_8X8((TX_SIZE)1); | ||||
| 385 | else if (tx_size > TX_16X16((TX_SIZE)2) && limit_tx) | ||||
| 386 | tx_size = TX_16X16((TX_SIZE)2); | ||||
| 387 | // For screen-content force 4X4 tx_size over 8X8, for large variance. | ||||
| 388 | if (cpi->oxcf.content == VP9E_CONTENT_SCREEN && tx_size == TX_8X8((TX_SIZE)1) && | ||||
| 389 | bsize <= BLOCK_16X166 && ((var >> 5) > (unsigned int)ac_thr)) | ||||
| 390 | tx_size = TX_4X4((TX_SIZE)0); | ||||
| 391 | } else { | ||||
| 392 | tx_size = VPXMIN(max_txsize_lookup[bsize],(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) | ||||
| 393 | tx_mode_to_biggest_tx_size[cpi->common.tx_mode])(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])); | ||||
| 394 | } | ||||
| 395 | return tx_size; | ||||
| 396 | } | ||||
| 397 | |||||
| 398 | static void compute_intra_yprediction(PREDICTION_MODE mode, BLOCK_SIZE bsize, | ||||
| 399 | MACROBLOCK *x, MACROBLOCKD *xd) { | ||||
| 400 | struct macroblockd_plane *const pd = &xd->plane[0]; | ||||
| 401 | struct macroblock_plane *const p = &x->plane[0]; | ||||
| 402 | uint8_t *const src_buf_base = p->src.buf; | ||||
| 403 | uint8_t *const dst_buf_base = pd->dst.buf; | ||||
| 404 | const int src_stride = p->src.stride; | ||||
| 405 | const int dst_stride = pd->dst.stride; | ||||
| 406 | // block and transform sizes, in number of 4x4 blocks log 2 ("*_b") | ||||
| 407 | // 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8 | ||||
| 408 | const TX_SIZE tx_size = max_txsize_lookup[bsize]; | ||||
| 409 | const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize]; | ||||
| 410 | const int num_4x4_h = num_4x4_blocks_high_lookup[bsize]; | ||||
| 411 | int row, col; | ||||
| 412 | // If mb_to_right_edge is < 0 we are in a situation in which | ||||
| 413 | // the current block size extends into the UMV and we won't | ||||
| 414 | // visit the sub blocks that are wholly within the UMV. | ||||
| 415 | const int max_blocks_wide = | ||||
| 416 | num_4x4_w + (xd->mb_to_right_edge >= 0 | ||||
| 417 | ? 0 | ||||
| 418 | : xd->mb_to_right_edge >> (5 + pd->subsampling_x)); | ||||
| 419 | const int max_blocks_high = | ||||
| 420 | num_4x4_h + (xd->mb_to_bottom_edge >= 0 | ||||
| 421 | ? 0 | ||||
| 422 | : xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); | ||||
| 423 | |||||
| 424 | // Keep track of the row and column of the blocks we use so that we know | ||||
| 425 | // if we are in the unrestricted motion border. | ||||
| 426 | for (row = 0; row < max_blocks_high; row += (1 << tx_size)) { | ||||
| 427 | // Skip visiting the sub blocks that are wholly within the UMV. | ||||
| 428 | for (col = 0; col < max_blocks_wide; col += (1 << tx_size)) { | ||||
| 429 | p->src.buf = &src_buf_base[4 * (row * (int64_t)src_stride + col)]; | ||||
| 430 | pd->dst.buf = &dst_buf_base[4 * (row * (int64_t)dst_stride + col)]; | ||||
| 431 | vp9_predict_intra_block(xd, b_width_log2_lookup[bsize], tx_size, mode, | ||||
| 432 | x->skip_encode ? p->src.buf : pd->dst.buf, | ||||
| 433 | x->skip_encode ? src_stride : dst_stride, | ||||
| 434 | pd->dst.buf, dst_stride, col, row, 0); | ||||
| 435 | } | ||||
| 436 | } | ||||
| 437 | p->src.buf = src_buf_base; | ||||
| 438 | pd->dst.buf = dst_buf_base; | ||||
| 439 | } | ||||
| 440 | |||||
| 441 | static void model_rd_for_sb_y_large(VP9_COMP *cpi, BLOCK_SIZE bsize, | ||||
| 442 | MACROBLOCK *x, MACROBLOCKD *xd, | ||||
| 443 | int *out_rate_sum, int64_t *out_dist_sum, | ||||
| 444 | unsigned int *var_y, unsigned int *sse_y, | ||||
| 445 | int mi_row, int mi_col, int *early_term, | ||||
| 446 | int *flag_preduv_computed) { | ||||
| 447 | // Note our transform coeffs are 8 times an orthogonal transform. | ||||
| 448 | // Hence quantizer step is also 8 times. To get effective quantizer | ||||
| 449 | // we need to divide by 8 before sending to modeling function. | ||||
| 450 | unsigned int sse; | ||||
| 451 | int rate; | ||||
| 452 | int64_t dist; | ||||
| 453 | struct macroblock_plane *const p = &x->plane[0]; | ||||
| 454 | struct macroblockd_plane *const pd = &xd->plane[0]; | ||||
| 455 | const uint32_t dc_quant = pd->dequant[0]; | ||||
| 456 | const uint32_t ac_quant = pd->dequant[1]; | ||||
| 457 | int64_t dc_thr = dc_quant * dc_quant >> 6; | ||||
| 458 | int64_t ac_thr = ac_quant * ac_quant >> 6; | ||||
| 459 | unsigned int var; | ||||
| 460 | int sum; | ||||
| 461 | int skip_dc = 0; | ||||
| 462 | |||||
| 463 | const int bw = b_width_log2_lookup[bsize]; | ||||
| 464 | const int bh = b_height_log2_lookup[bsize]; | ||||
| 465 | const int num8x8 = 1 << (bw + bh - 2); | ||||
| 466 | unsigned int sse8x8[64] = { 0 }; | ||||
| 467 | int sum8x8[64] = { 0 }; | ||||
| 468 | unsigned int var8x8[64] = { 0 }; | ||||
| 469 | TX_SIZE tx_size; | ||||
| 470 | int i, k; | ||||
| 471 | uint32_t sum_sqr; | ||||
| 472 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 473 | const vpx_bit_depth_t bd = cpi->common.bit_depth; | ||||
| 474 | #endif | ||||
| 475 | // Calculate variance for whole partition, and also save 8x8 blocks' variance | ||||
| 476 | // to be used in following transform skipping test. | ||||
| 477 | block_variance(p->src.buf, p->src.stride, pd->dst.buf, pd->dst.stride, | ||||
| 478 | 4 << bw, 4 << bh, &sse, &sum, 8, | ||||
| 479 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 480 | cpi->common.use_highbitdepth, bd, | ||||
| 481 | #endif | ||||
| 482 | sse8x8, sum8x8, var8x8); | ||||
| 483 | sum_sqr = (uint32_t)((int64_t)sum * sum) >> (bw + bh + 4); | ||||
| 484 | var = sse > sum_sqr ? sse - sum_sqr : sum_sqr - sse; | ||||
| 485 | |||||
| 486 | *var_y = var; | ||||
| 487 | *sse_y = sse; | ||||
| 488 | |||||
| 489 | #if CONFIG_VP9_TEMPORAL_DENOISING0 | ||||
| 490 | if (cpi->oxcf.noise_sensitivity > 0 && denoise_svc(cpi) && | ||||
| 491 | cpi->oxcf.speed > 5) | ||||
| 492 | ac_thr = vp9_scale_acskip_thresh(ac_thr, cpi->denoiser.denoising_level, | ||||
| 493 | (abs(sum) >> (bw + bh)), | ||||
| 494 | cpi->svc.temporal_layer_id); | ||||
| 495 | else | ||||
| 496 | ac_thr *= ac_thr_factor(cpi->oxcf.speed, cpi->common.width, | ||||
| 497 | cpi->common.height, abs(sum) >> (bw + bh)); | ||||
| 498 | #else | ||||
| 499 | ac_thr *= ac_thr_factor(cpi->oxcf.speed, cpi->common.width, | ||||
| 500 | cpi->common.height, abs(sum) >> (bw + bh)); | ||||
| 501 | #endif | ||||
| 502 | |||||
| 503 | tx_size = calculate_tx_size(cpi, bsize, xd, var, sse, ac_thr, | ||||
| 504 | x->source_variance, 0); | ||||
| 505 | // The code below for setting skip flag assumes tranform size of at least 8x8, | ||||
| 506 | // so force this lower limit on transform. | ||||
| 507 | if (tx_size < TX_8X8((TX_SIZE)1)) tx_size = TX_8X8((TX_SIZE)1); | ||||
| 508 | xd->mi[0]->tx_size = tx_size; | ||||
| 509 | |||||
| 510 | if (cpi->oxcf.content == VP9E_CONTENT_SCREEN && x->zero_temp_sad_source && | ||||
| 511 | x->source_variance == 0) | ||||
| 512 | dc_thr = dc_thr << 1; | ||||
| 513 | |||||
| 514 | // Evaluate if the partition block is a skippable block in Y plane. | ||||
| 515 | { | ||||
| 516 | unsigned int sse16x16[16] = { 0 }; | ||||
| 517 | int sum16x16[16] = { 0 }; | ||||
| 518 | unsigned int var16x16[16] = { 0 }; | ||||
| 519 | const int num16x16 = num8x8 >> 2; | ||||
| 520 | |||||
| 521 | unsigned int sse32x32[4] = { 0 }; | ||||
| 522 | int sum32x32[4] = { 0 }; | ||||
| 523 | unsigned int var32x32[4] = { 0 }; | ||||
| 524 | const int num32x32 = num8x8 >> 4; | ||||
| 525 | |||||
| 526 | int ac_test = 1; | ||||
| 527 | int dc_test = 1; | ||||
| 528 | const int num = (tx_size == TX_8X8((TX_SIZE)1)) | ||||
| 529 | ? num8x8 | ||||
| 530 | : ((tx_size == TX_16X16((TX_SIZE)2)) ? num16x16 : num32x32); | ||||
| 531 | const unsigned int *sse_tx = | ||||
| 532 | (tx_size == TX_8X8((TX_SIZE)1)) ? sse8x8 | ||||
| 533 | : ((tx_size == TX_16X16((TX_SIZE)2)) ? sse16x16 : sse32x32); | ||||
| 534 | const unsigned int *var_tx = | ||||
| 535 | (tx_size == TX_8X8((TX_SIZE)1)) ? var8x8 | ||||
| 536 | : ((tx_size == TX_16X16((TX_SIZE)2)) ? var16x16 : var32x32); | ||||
| 537 | |||||
| 538 | // Calculate variance if tx_size > TX_8X8 | ||||
| 539 | if (tx_size >= TX_16X16((TX_SIZE)2)) | ||||
| 540 | calculate_variance(bw, bh, TX_8X8((TX_SIZE)1), sse8x8, sum8x8, var16x16, sse16x16, | ||||
| 541 | sum16x16); | ||||
| 542 | if (tx_size == TX_32X32((TX_SIZE)3)) | ||||
| 543 | calculate_variance(bw, bh, TX_16X16((TX_SIZE)2), sse16x16, sum16x16, var32x32, | ||||
| 544 | sse32x32, sum32x32); | ||||
| 545 | |||||
| 546 | // Skipping test | ||||
| 547 | x->skip_txfm[0] = SKIP_TXFM_NONE0; | ||||
| 548 | for (k = 0; k < num; k++) | ||||
| 549 | // Check if all ac coefficients can be quantized to zero. | ||||
| 550 | if (!(var_tx[k] < ac_thr || var == 0)) { | ||||
| 551 | ac_test = 0; | ||||
| 552 | break; | ||||
| 553 | } | ||||
| 554 | |||||
| 555 | for (k = 0; k < num; k++) | ||||
| 556 | // Check if dc coefficient can be quantized to zero. | ||||
| 557 | if (!(sse_tx[k] - var_tx[k] < dc_thr || sse == var)) { | ||||
| 558 | dc_test = 0; | ||||
| 559 | break; | ||||
| 560 | } | ||||
| 561 | |||||
| 562 | if (ac_test) { | ||||
| 563 | x->skip_txfm[0] = SKIP_TXFM_AC_ONLY2; | ||||
| 564 | |||||
| 565 | if (dc_test) x->skip_txfm[0] = SKIP_TXFM_AC_DC1; | ||||
| 566 | } else if (dc_test) { | ||||
| 567 | skip_dc = 1; | ||||
| 568 | } | ||||
| 569 | } | ||||
| 570 | |||||
| 571 | if (x->skip_txfm[0] == SKIP_TXFM_AC_DC1) { | ||||
| 572 | int skip_uv[2] = { 0 }; | ||||
| 573 | unsigned int var_uv[2]; | ||||
| 574 | unsigned int sse_uv[2]; | ||||
| 575 | |||||
| 576 | *out_rate_sum = 0; | ||||
| 577 | *out_dist_sum = sse << 4; | ||||
| 578 | |||||
| 579 | // Transform skipping test in UV planes. | ||||
| 580 | for (i = 1; i <= 2; i++) { | ||||
| 581 | struct macroblock_plane *const p_uv = &x->plane[i]; | ||||
| 582 | struct macroblockd_plane *const pd_uv = &xd->plane[i]; | ||||
| 583 | const TX_SIZE uv_tx_size = get_uv_tx_size(xd->mi[0], pd_uv); | ||||
| 584 | const BLOCK_SIZE unit_size = txsize_to_bsize[uv_tx_size]; | ||||
| 585 | const BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, pd_uv); | ||||
| 586 | const int uv_bw = b_width_log2_lookup[uv_bsize]; | ||||
| 587 | const int uv_bh = b_height_log2_lookup[uv_bsize]; | ||||
| 588 | const int sf = (uv_bw - b_width_log2_lookup[unit_size]) + | ||||
| 589 | (uv_bh - b_height_log2_lookup[unit_size]); | ||||
| 590 | const uint32_t uv_dc_thr = | ||||
| 591 | pd_uv->dequant[0] * pd_uv->dequant[0] >> (6 - sf); | ||||
| 592 | const uint32_t uv_ac_thr = | ||||
| 593 | pd_uv->dequant[1] * pd_uv->dequant[1] >> (6 - sf); | ||||
| 594 | int j = i - 1; | ||||
| 595 | |||||
| 596 | vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, i); | ||||
| 597 | flag_preduv_computed[i - 1] = 1; | ||||
| 598 | var_uv[j] = cpi->fn_ptr[uv_bsize].vf(p_uv->src.buf, p_uv->src.stride, | ||||
| 599 | pd_uv->dst.buf, pd_uv->dst.stride, | ||||
| 600 | &sse_uv[j]); | ||||
| 601 | |||||
| 602 | if ((var_uv[j] < uv_ac_thr || var_uv[j] == 0) && | ||||
| 603 | (sse_uv[j] - var_uv[j] < uv_dc_thr || sse_uv[j] == var_uv[j])) | ||||
| 604 | skip_uv[j] = 1; | ||||
| 605 | else | ||||
| 606 | break; | ||||
| 607 | } | ||||
| 608 | |||||
| 609 | // If the transform in YUV planes are skippable, the mode search checks | ||||
| 610 | // fewer inter modes and doesn't check intra modes. | ||||
| 611 | if (skip_uv[0] & skip_uv[1]) { | ||||
| 612 | *early_term = 1; | ||||
| 613 | } | ||||
| 614 | return; | ||||
| 615 | } | ||||
| 616 | |||||
| 617 | if (!skip_dc) { | ||||
| 618 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 619 | vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize], | ||||
| 620 | dc_quant >> (xd->bd - 5), &rate, &dist); | ||||
| 621 | #else | ||||
| 622 | vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize], | ||||
| 623 | dc_quant >> 3, &rate, &dist); | ||||
| 624 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 625 | } | ||||
| 626 | |||||
| 627 | if (!skip_dc) { | ||||
| 628 | *out_rate_sum = rate >> 1; | ||||
| 629 | *out_dist_sum = dist << 3; | ||||
| 630 | } else { | ||||
| 631 | *out_rate_sum = 0; | ||||
| 632 | *out_dist_sum = (sse - var) << 4; | ||||
| 633 | } | ||||
| 634 | |||||
| 635 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 636 | vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize], | ||||
| 637 | ac_quant >> (xd->bd - 5), &rate, &dist); | ||||
| 638 | #else | ||||
| 639 | vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize], ac_quant >> 3, | ||||
| 640 | &rate, &dist); | ||||
| 641 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 642 | |||||
| 643 | *out_rate_sum += rate; | ||||
| 644 | *out_dist_sum += dist << 4; | ||||
| 645 | } | ||||
| 646 | |||||
| 647 | static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize, MACROBLOCK *x, | ||||
| 648 | MACROBLOCKD *xd, int *out_rate_sum, | ||||
| 649 | int64_t *out_dist_sum, unsigned int *var_y, | ||||
| 650 | unsigned int *sse_y, int is_intra) { | ||||
| 651 | // Note our transform coeffs are 8 times an orthogonal transform. | ||||
| 652 | // Hence quantizer step is also 8 times. To get effective quantizer | ||||
| 653 | // we need to divide by 8 before sending to modeling function. | ||||
| 654 | unsigned int sse; | ||||
| 655 | int rate; | ||||
| 656 | int64_t dist; | ||||
| 657 | struct macroblock_plane *const p = &x->plane[0]; | ||||
| 658 | struct macroblockd_plane *const pd = &xd->plane[0]; | ||||
| 659 | const int64_t dc_thr = p->quant_thred[0] >> 6; | ||||
| 660 | const int64_t ac_thr = p->quant_thred[1] >> 6; | ||||
| 661 | const uint32_t dc_quant = pd->dequant[0]; | ||||
| 662 | const uint32_t ac_quant = pd->dequant[1]; | ||||
| 663 | unsigned int var = cpi->fn_ptr[bsize].vf(p->src.buf, p->src.stride, | ||||
| 664 | pd->dst.buf, pd->dst.stride, &sse); | ||||
| 665 | int skip_dc = 0; | ||||
| 666 | |||||
| 667 | *var_y = var; | ||||
| 668 | *sse_y = sse; | ||||
| 669 | |||||
| 670 | xd->mi[0]->tx_size = calculate_tx_size(cpi, bsize, xd, var, sse, ac_thr, | ||||
| 671 | x->source_variance, is_intra); | ||||
| 672 | |||||
| 673 | // Evaluate if the partition block is a skippable block in Y plane. | ||||
| 674 | { | ||||
| 675 | const BLOCK_SIZE unit_size = txsize_to_bsize[xd->mi[0]->tx_size]; | ||||
| 676 | const unsigned int num_blk_log2 = | ||||
| 677 | (b_width_log2_lookup[bsize] - b_width_log2_lookup[unit_size]) + | ||||
| 678 | (b_height_log2_lookup[bsize] - b_height_log2_lookup[unit_size]); | ||||
| 679 | const unsigned int sse_tx = sse >> num_blk_log2; | ||||
| 680 | const unsigned int var_tx = var >> num_blk_log2; | ||||
| 681 | |||||
| 682 | x->skip_txfm[0] = SKIP_TXFM_NONE0; | ||||
| 683 | // Check if all ac coefficients can be quantized to zero. | ||||
| 684 | if (var_tx < ac_thr || var == 0) { | ||||
| 685 | x->skip_txfm[0] = SKIP_TXFM_AC_ONLY2; | ||||
| 686 | // Check if dc coefficient can be quantized to zero. | ||||
| 687 | if (sse_tx - var_tx < dc_thr || sse == var) | ||||
| 688 | x->skip_txfm[0] = SKIP_TXFM_AC_DC1; | ||||
| 689 | } else { | ||||
| 690 | if (sse_tx - var_tx < dc_thr || sse == var) skip_dc = 1; | ||||
| 691 | } | ||||
| 692 | } | ||||
| 693 | |||||
| 694 | if (x->skip_txfm[0] == SKIP_TXFM_AC_DC1) { | ||||
| 695 | *out_rate_sum = 0; | ||||
| 696 | *out_dist_sum = sse << 4; | ||||
| 697 | return; | ||||
| 698 | } | ||||
| 699 | |||||
| 700 | if (!skip_dc) { | ||||
| 701 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 702 | vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize], | ||||
| 703 | dc_quant >> (xd->bd - 5), &rate, &dist); | ||||
| 704 | #else | ||||
| 705 | vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize], | ||||
| 706 | dc_quant >> 3, &rate, &dist); | ||||
| 707 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 708 | } | ||||
| 709 | |||||
| 710 | if (!skip_dc) { | ||||
| 711 | *out_rate_sum = rate >> 1; | ||||
| 712 | *out_dist_sum = dist << 3; | ||||
| 713 | } else { | ||||
| 714 | *out_rate_sum = 0; | ||||
| 715 | *out_dist_sum = (sse - var) << 4; | ||||
| 716 | } | ||||
| 717 | |||||
| 718 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 719 | vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize], | ||||
| 720 | ac_quant >> (xd->bd - 5), &rate, &dist); | ||||
| 721 | #else | ||||
| 722 | vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize], ac_quant >> 3, | ||||
| 723 | &rate, &dist); | ||||
| 724 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 725 | |||||
| 726 | *out_rate_sum += rate; | ||||
| 727 | *out_dist_sum += dist << 4; | ||||
| 728 | } | ||||
| 729 | |||||
| 730 | static void block_yrd(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *this_rdc, | ||||
| 731 | int *skippable, int64_t *sse, BLOCK_SIZE bsize, | ||||
| 732 | TX_SIZE tx_size, int rd_computed, int is_intra) { | ||||
| 733 | MACROBLOCKD *xd = &x->e_mbd; | ||||
| 734 | const struct macroblockd_plane *pd = &xd->plane[0]; | ||||
| 735 | struct macroblock_plane *const p = &x->plane[0]; | ||||
| 736 | const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize]; | ||||
| 737 | const int num_4x4_h = num_4x4_blocks_high_lookup[bsize]; | ||||
| 738 | const int step = 1 << (tx_size << 1); | ||||
| 739 | const int block_step = (1 << tx_size); | ||||
| 740 | int block = 0, r, c; | ||||
| 741 | const int max_blocks_wide = | ||||
| 742 | num_4x4_w + (xd->mb_to_right_edge >= 0 ? 0 : xd->mb_to_right_edge >> 5); | ||||
| 743 | const int max_blocks_high = | ||||
| 744 | num_4x4_h + (xd->mb_to_bottom_edge >= 0 ? 0 : xd->mb_to_bottom_edge >> 5); | ||||
| 745 | int eob_cost = 0; | ||||
| 746 | const int bw = 4 * num_4x4_w; | ||||
| 747 | const int bh = 4 * num_4x4_h; | ||||
| 748 | |||||
| 749 | if (cpi->sf.use_simple_block_yrd && cpi->common.frame_type != KEY_FRAME && | ||||
| 750 | (bsize < BLOCK_32X329 || | ||||
| 751 | (cpi->use_svc && | ||||
| 752 | (bsize < BLOCK_32X329 || cpi->svc.temporal_layer_id > 0)))) { | ||||
| 753 | unsigned int var_y, sse_y; | ||||
| 754 | (void)tx_size; | ||||
| 755 | if (!rd_computed) | ||||
| 756 | model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc->rate, &this_rdc->dist, | ||||
| 757 | &var_y, &sse_y, is_intra); | ||||
| 758 | *sse = INT_MAX2147483647; | ||||
| 759 | *skippable = 0; | ||||
| 760 | return; | ||||
| 761 | } | ||||
| 762 | |||||
| 763 | (void)cpi; | ||||
| 764 | |||||
| 765 | // The max tx_size passed in is TX_16X16. | ||||
| 766 | assert(tx_size != TX_32X32)((void) sizeof ((tx_size != ((TX_SIZE)3)) ? 1 : 0), __extension__ ({ if (tx_size != ((TX_SIZE)3)) ; else __assert_fail ("tx_size != TX_32X32" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 766, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 767 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 768 | if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH8) { | ||||
| 769 | vpx_highbd_subtract_block(bh, bw, p->src_diff, bw, p->src.buf, | ||||
| 770 | p->src.stride, pd->dst.buf, pd->dst.stride, | ||||
| 771 | x->e_mbd.bd); | ||||
| 772 | } else { | ||||
| 773 | vpx_subtract_block(bh, bw, p->src_diff, bw, p->src.buf, p->src.stride, | ||||
| 774 | pd->dst.buf, pd->dst.stride); | ||||
| 775 | } | ||||
| 776 | #else | ||||
| 777 | vpx_subtract_block(bh, bw, p->src_diff, bw, p->src.buf, p->src.stride, | ||||
| 778 | pd->dst.buf, pd->dst.stride); | ||||
| 779 | #endif | ||||
| 780 | *skippable = 1; | ||||
| 781 | // Keep track of the row and column of the blocks we use so that we know | ||||
| 782 | // if we are in the unrestricted motion border. | ||||
| 783 | for (r = 0; r < max_blocks_high; r += block_step) { | ||||
| 784 | for (c = 0; c < num_4x4_w; c += block_step) { | ||||
| 785 | if (c < max_blocks_wide) { | ||||
| 786 | const ScanOrder *const scan_order = &vp9_default_scan_orders[tx_size]; | ||||
| 787 | tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block)((p->coeff) + (block) * 16); | ||||
| 788 | tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block)((p->qcoeff) + (block) * 16); | ||||
| 789 | tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block)((pd->dqcoeff) + (block) * 16); | ||||
| 790 | uint16_t *const eob = &p->eobs[block]; | ||||
| 791 | const int diff_stride = bw; | ||||
| 792 | const int16_t *src_diff; | ||||
| 793 | src_diff = &p->src_diff[(r * diff_stride + c) << 2]; | ||||
| 794 | |||||
| 795 | // skip block condition should be handled before this is called. | ||||
| 796 | assert(!x->skip_block)((void) sizeof ((!x->skip_block) ? 1 : 0), __extension__ ( { if (!x->skip_block) ; else __assert_fail ("!x->skip_block" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 796, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 797 | |||||
| 798 | switch (tx_size) { | ||||
| 799 | case TX_16X16((TX_SIZE)2): | ||||
| 800 | vpx_hadamard_16x16(src_diff, diff_stride, coeff); | ||||
| 801 | vp9_quantize_fp(coeff, 256, p, qcoeff, dqcoeff, pd->dequant, eob, | ||||
| 802 | scan_order); | ||||
| 803 | break; | ||||
| 804 | case TX_8X8((TX_SIZE)1): | ||||
| 805 | vpx_hadamard_8x8(src_diff, diff_stride, coeff); | ||||
| 806 | vp9_quantize_fp(coeff, 64, p, qcoeff, dqcoeff, pd->dequant, eob, | ||||
| 807 | scan_order); | ||||
| 808 | break; | ||||
| 809 | default: | ||||
| 810 | assert(tx_size == TX_4X4)((void) sizeof ((tx_size == ((TX_SIZE)0)) ? 1 : 0), __extension__ ({ if (tx_size == ((TX_SIZE)0)) ; else __assert_fail ("tx_size == TX_4X4" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 810, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 811 | x->fwd_txfm4x4(src_diff, coeff, diff_stride); | ||||
| 812 | vp9_quantize_fp(coeff, 16, p, qcoeff, dqcoeff, pd->dequant, eob, | ||||
| 813 | scan_order); | ||||
| 814 | break; | ||||
| 815 | } | ||||
| 816 | *skippable &= (*eob == 0); | ||||
| 817 | eob_cost += 1; | ||||
| 818 | } | ||||
| 819 | block += step; | ||||
| 820 | } | ||||
| 821 | } | ||||
| 822 | |||||
| 823 | this_rdc->rate = 0; | ||||
| 824 | if (*sse < INT64_MAX(9223372036854775807L)) { | ||||
| 825 | *sse = (*sse << 6) >> 2; | ||||
| 826 | if (*skippable) { | ||||
| 827 | this_rdc->dist = *sse; | ||||
| 828 | return; | ||||
| 829 | } | ||||
| 830 | } | ||||
| 831 | |||||
| 832 | block = 0; | ||||
| 833 | this_rdc->dist = 0; | ||||
| 834 | for (r = 0; r < max_blocks_high; r += block_step) { | ||||
| 835 | for (c = 0; c < num_4x4_w; c += block_step) { | ||||
| 836 | if (c < max_blocks_wide) { | ||||
| 837 | tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block)((p->coeff) + (block) * 16); | ||||
| 838 | tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block)((p->qcoeff) + (block) * 16); | ||||
| 839 | tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block)((pd->dqcoeff) + (block) * 16); | ||||
| 840 | uint16_t *const eob = &p->eobs[block]; | ||||
| 841 | |||||
| 842 | if (*eob == 1) | ||||
| 843 | this_rdc->rate += (int)abs(qcoeff[0]); | ||||
| 844 | else if (*eob > 1) | ||||
| 845 | this_rdc->rate += vpx_satd(qcoeff, step << 4); | ||||
| 846 | |||||
| 847 | this_rdc->dist += vp9_block_error_fp(coeff, dqcoeff, step << 4) >> 2; | ||||
| 848 | } | ||||
| 849 | block += step; | ||||
| 850 | } | ||||
| 851 | } | ||||
| 852 | |||||
| 853 | // If skippable is set, rate gets clobbered later. | ||||
| 854 | this_rdc->rate <<= (2 + VP9_PROB_COST_SHIFT9); | ||||
| 855 | this_rdc->rate += (eob_cost << VP9_PROB_COST_SHIFT9); | ||||
| 856 | } | ||||
| 857 | |||||
| 858 | static void model_rd_for_sb_uv(VP9_COMP *cpi, BLOCK_SIZE plane_bsize, | ||||
| 859 | MACROBLOCK *x, MACROBLOCKD *xd, | ||||
| 860 | RD_COST *this_rdc, unsigned int *var_y, | ||||
| 861 | unsigned int *sse_y, int start_plane, | ||||
| 862 | int stop_plane) { | ||||
| 863 | // Note our transform coeffs are 8 times an orthogonal transform. | ||||
| 864 | // Hence quantizer step is also 8 times. To get effective quantizer | ||||
| 865 | // we need to divide by 8 before sending to modeling function. | ||||
| 866 | unsigned int sse; | ||||
| 867 | int rate; | ||||
| 868 | int64_t dist; | ||||
| 869 | int i; | ||||
| 870 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 871 | uint64_t tot_var = *var_y; | ||||
| 872 | uint64_t tot_sse = *sse_y; | ||||
| 873 | #else | ||||
| 874 | uint32_t tot_var = *var_y; | ||||
| 875 | uint32_t tot_sse = *sse_y; | ||||
| 876 | #endif | ||||
| 877 | |||||
| 878 | this_rdc->rate = 0; | ||||
| 879 | this_rdc->dist = 0; | ||||
| 880 | |||||
| 881 | for (i = start_plane; i <= stop_plane; ++i) { | ||||
| 882 | struct macroblock_plane *const p = &x->plane[i]; | ||||
| 883 | struct macroblockd_plane *const pd = &xd->plane[i]; | ||||
| 884 | const uint32_t dc_quant = pd->dequant[0]; | ||||
| 885 | const uint32_t ac_quant = pd->dequant[1]; | ||||
| 886 | const BLOCK_SIZE bs = plane_bsize; | ||||
| 887 | unsigned int var; | ||||
| 888 | if (!x->color_sensitivity[i - 1]) continue; | ||||
| 889 | |||||
| 890 | var = cpi->fn_ptr[bs].vf(p->src.buf, p->src.stride, pd->dst.buf, | ||||
| 891 | pd->dst.stride, &sse); | ||||
| 892 | assert(sse >= var)((void) sizeof ((sse >= var) ? 1 : 0), __extension__ ({ if (sse >= var) ; else __assert_fail ("sse >= var", "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 892, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 893 | tot_var += var; | ||||
| 894 | tot_sse += sse; | ||||
| 895 | |||||
| 896 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 897 | vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bs], | ||||
| 898 | dc_quant >> (xd->bd - 5), &rate, &dist); | ||||
| 899 | #else | ||||
| 900 | vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bs], | ||||
| 901 | dc_quant >> 3, &rate, &dist); | ||||
| 902 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 903 | |||||
| 904 | this_rdc->rate += rate >> 1; | ||||
| 905 | this_rdc->dist += dist << 3; | ||||
| 906 | |||||
| 907 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 908 | vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bs], | ||||
| 909 | ac_quant >> (xd->bd - 5), &rate, &dist); | ||||
| 910 | #else | ||||
| 911 | vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bs], ac_quant >> 3, | ||||
| 912 | &rate, &dist); | ||||
| 913 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 914 | |||||
| 915 | this_rdc->rate += rate; | ||||
| 916 | this_rdc->dist += dist << 4; | ||||
| 917 | } | ||||
| 918 | |||||
| 919 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 920 | *var_y = tot_var > UINT32_MAX(4294967295U) ? UINT32_MAX(4294967295U) : (uint32_t)tot_var; | ||||
| 921 | *sse_y = tot_sse > UINT32_MAX(4294967295U) ? UINT32_MAX(4294967295U) : (uint32_t)tot_sse; | ||||
| 922 | #else | ||||
| 923 | *var_y = tot_var; | ||||
| 924 | *sse_y = tot_sse; | ||||
| 925 | #endif | ||||
| 926 | } | ||||
| 927 | |||||
| 928 | static int get_pred_buffer(PRED_BUFFER *p, int len) { | ||||
| 929 | int i; | ||||
| 930 | |||||
| 931 | for (i = 0; i < len; i++) { | ||||
| 932 | if (!p[i].in_use) { | ||||
| 933 | p[i].in_use = 1; | ||||
| 934 | return i; | ||||
| 935 | } | ||||
| 936 | } | ||||
| 937 | return -1; | ||||
| 938 | } | ||||
| 939 | |||||
| 940 | static void free_pred_buffer(PRED_BUFFER *p) { | ||||
| 941 | if (p != NULL((void*)0)) p->in_use = 0; | ||||
| 942 | } | ||||
| 943 | |||||
| 944 | static void encode_breakout_test( | ||||
| 945 | VP9_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int mi_row, int mi_col, | ||||
| 946 | MV_REFERENCE_FRAME ref_frame, PREDICTION_MODE this_mode, unsigned int var_y, | ||||
| 947 | unsigned int sse_y, struct buf_2d yv12_mb[][MAX_MB_PLANE3], int *rate, | ||||
| 948 | int64_t *dist, int *flag_preduv_computed) { | ||||
| 949 | MACROBLOCKD *xd = &x->e_mbd; | ||||
| 950 | MODE_INFO *const mi = xd->mi[0]; | ||||
| 951 | const BLOCK_SIZE uv_size = get_plane_block_size(bsize, &xd->plane[1]); | ||||
| 952 | unsigned int var = var_y, sse = sse_y; | ||||
| 953 | // Skipping threshold for ac. | ||||
| 954 | unsigned int thresh_ac; | ||||
| 955 | // Skipping threshold for dc. | ||||
| 956 | unsigned int thresh_dc; | ||||
| 957 | int motion_low = 1; | ||||
| 958 | |||||
| 959 | if (cpi->use_svc && ref_frame == GOLDEN_FRAME2) return; | ||||
| 960 | if (mi->mv[0].as_mv.row > 64 || mi->mv[0].as_mv.row < -64 || | ||||
| 961 | mi->mv[0].as_mv.col > 64 || mi->mv[0].as_mv.col < -64) | ||||
| 962 | motion_low = 0; | ||||
| 963 | if (x->encode_breakout > 0 && motion_low == 1) { | ||||
| 964 | // Set a maximum for threshold to avoid big PSNR loss in low bit rate | ||||
| 965 | // case. Use extreme low threshold for static frames to limit | ||||
| 966 | // skipping. | ||||
| 967 | const unsigned int max_thresh = 36000; | ||||
| 968 | // The encode_breakout input | ||||
| 969 | const unsigned int min_thresh = | ||||
| 970 | VPXMIN(((unsigned int)x->encode_breakout << 4), max_thresh)(((((unsigned int)x->encode_breakout << 4)) < (max_thresh )) ? (((unsigned int)x->encode_breakout << 4)) : (max_thresh )); | ||||
| 971 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 972 | const int shift = (xd->bd << 1) - 16; | ||||
| 973 | #endif | ||||
| 974 | |||||
| 975 | // Calculate threshold according to dequant value. | ||||
| 976 | thresh_ac = (xd->plane[0].dequant[1] * xd->plane[0].dequant[1]) >> 3; | ||||
| 977 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 978 | if ((xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH8) && shift > 0) { | ||||
| 979 | thresh_ac = ROUND_POWER_OF_TWO(thresh_ac, shift)(((thresh_ac) + (1 << ((shift) - 1))) >> (shift)); | ||||
| 980 | } | ||||
| 981 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 982 | thresh_ac = clamp(thresh_ac, min_thresh, max_thresh); | ||||
| 983 | |||||
| 984 | // Adjust ac threshold according to partition size. | ||||
| 985 | thresh_ac >>= | ||||
| 986 | 8 - (b_width_log2_lookup[bsize] + b_height_log2_lookup[bsize]); | ||||
| 987 | |||||
| 988 | thresh_dc = (xd->plane[0].dequant[0] * xd->plane[0].dequant[0] >> 6); | ||||
| 989 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 990 | if ((xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH8) && shift > 0) { | ||||
| 991 | thresh_dc = ROUND_POWER_OF_TWO(thresh_dc, shift)(((thresh_dc) + (1 << ((shift) - 1))) >> (shift)); | ||||
| 992 | } | ||||
| 993 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 994 | } else { | ||||
| 995 | thresh_ac = 0; | ||||
| 996 | thresh_dc = 0; | ||||
| 997 | } | ||||
| 998 | |||||
| 999 | // Y skipping condition checking for ac and dc. | ||||
| 1000 | if (var <= thresh_ac && (sse - var) <= thresh_dc) { | ||||
| 1001 | unsigned int sse_u, sse_v; | ||||
| 1002 | unsigned int var_u, var_v; | ||||
| 1003 | unsigned int thresh_ac_uv = thresh_ac; | ||||
| 1004 | unsigned int thresh_dc_uv = thresh_dc; | ||||
| 1005 | if (x->sb_is_skin) { | ||||
| 1006 | thresh_ac_uv = 0; | ||||
| 1007 | thresh_dc_uv = 0; | ||||
| 1008 | } | ||||
| 1009 | |||||
| 1010 | if (!flag_preduv_computed[0] || !flag_preduv_computed[1]) { | ||||
| 1011 | xd->plane[1].pre[0] = yv12_mb[ref_frame][1]; | ||||
| 1012 | xd->plane[2].pre[0] = yv12_mb[ref_frame][2]; | ||||
| 1013 | vp9_build_inter_predictors_sbuv(xd, mi_row, mi_col, bsize); | ||||
| 1014 | } | ||||
| 1015 | |||||
| 1016 | var_u = cpi->fn_ptr[uv_size].vf(x->plane[1].src.buf, x->plane[1].src.stride, | ||||
| 1017 | xd->plane[1].dst.buf, | ||||
| 1018 | xd->plane[1].dst.stride, &sse_u); | ||||
| 1019 | |||||
| 1020 | // U skipping condition checking | ||||
| 1021 | if (((var_u << 2) <= thresh_ac_uv) && (sse_u - var_u <= thresh_dc_uv)) { | ||||
| 1022 | var_v = cpi->fn_ptr[uv_size].vf( | ||||
| 1023 | x->plane[2].src.buf, x->plane[2].src.stride, xd->plane[2].dst.buf, | ||||
| 1024 | xd->plane[2].dst.stride, &sse_v); | ||||
| 1025 | |||||
| 1026 | // V skipping condition checking | ||||
| 1027 | if (((var_v << 2) <= thresh_ac_uv) && (sse_v - var_v <= thresh_dc_uv)) { | ||||
| 1028 | x->skip = 1; | ||||
| 1029 | |||||
| 1030 | // The cost of skip bit needs to be added. | ||||
| 1031 | *rate = cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]] | ||||
| 1032 | [INTER_OFFSET(this_mode)((this_mode) - 10)]; | ||||
| 1033 | |||||
| 1034 | // More on this part of rate | ||||
| 1035 | // rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1); | ||||
| 1036 | |||||
| 1037 | // Scaling factor for SSE from spatial domain to frequency | ||||
| 1038 | // domain is 16. Adjust distortion accordingly. | ||||
| 1039 | // TODO(yunqingwang): In this function, only y-plane dist is | ||||
| 1040 | // calculated. | ||||
| 1041 | *dist = (sse << 4); // + ((sse_u + sse_v) << 4); | ||||
| 1042 | |||||
| 1043 | // *disable_skip = 1; | ||||
| 1044 | } | ||||
| 1045 | } | ||||
| 1046 | } | ||||
| 1047 | } | ||||
| 1048 | |||||
| 1049 | struct estimate_block_intra_args { | ||||
| 1050 | VP9_COMP *cpi; | ||||
| 1051 | MACROBLOCK *x; | ||||
| 1052 | PREDICTION_MODE mode; | ||||
| 1053 | int skippable; | ||||
| 1054 | RD_COST *rdc; | ||||
| 1055 | }; | ||||
| 1056 | |||||
| 1057 | static void estimate_block_intra(int plane, int block, int row, int col, | ||||
| 1058 | BLOCK_SIZE plane_bsize, TX_SIZE tx_size, | ||||
| 1059 | void *arg) { | ||||
| 1060 | struct estimate_block_intra_args *const args = arg; | ||||
| 1061 | VP9_COMP *const cpi = args->cpi; | ||||
| 1062 | MACROBLOCK *const x = args->x; | ||||
| 1063 | MACROBLOCKD *const xd = &x->e_mbd; | ||||
| 1064 | struct macroblock_plane *const p = &x->plane[plane]; | ||||
| 1065 | struct macroblockd_plane *const pd = &xd->plane[plane]; | ||||
| 1066 | const BLOCK_SIZE bsize_tx = txsize_to_bsize[tx_size]; | ||||
| 1067 | uint8_t *const src_buf_base = p->src.buf; | ||||
| 1068 | uint8_t *const dst_buf_base = pd->dst.buf; | ||||
| 1069 | const int src_stride = p->src.stride; | ||||
| 1070 | const int dst_stride = pd->dst.stride; | ||||
| 1071 | RD_COST this_rdc; | ||||
| 1072 | |||||
| 1073 | (void)block; | ||||
| 1074 | |||||
| 1075 | p->src.buf = &src_buf_base[4 * (row * (int64_t)src_stride + col)]; | ||||
| 1076 | pd->dst.buf = &dst_buf_base[4 * (row * (int64_t)dst_stride + col)]; | ||||
| 1077 | // Use source buffer as an approximation for the fully reconstructed buffer. | ||||
| 1078 | vp9_predict_intra_block(xd, b_width_log2_lookup[plane_bsize], tx_size, | ||||
| 1079 | args->mode, x->skip_encode ? p->src.buf : pd->dst.buf, | ||||
| 1080 | x->skip_encode ? src_stride : dst_stride, pd->dst.buf, | ||||
| 1081 | dst_stride, col, row, plane); | ||||
| 1082 | |||||
| 1083 | if (plane == 0) { | ||||
| 1084 | int64_t this_sse = INT64_MAX(9223372036854775807L); | ||||
| 1085 | block_yrd(cpi, x, &this_rdc, &args->skippable, &this_sse, bsize_tx, | ||||
| 1086 | VPXMIN(tx_size, TX_16X16)(((tx_size) < (((TX_SIZE)2))) ? (tx_size) : (((TX_SIZE)2)) ), 0, 1); | ||||
| 1087 | } else { | ||||
| 1088 | unsigned int var = 0; | ||||
| 1089 | unsigned int sse = 0; | ||||
| 1090 | model_rd_for_sb_uv(cpi, bsize_tx, x, xd, &this_rdc, &var, &sse, plane, | ||||
| 1091 | plane); | ||||
| 1092 | } | ||||
| 1093 | |||||
| 1094 | p->src.buf = src_buf_base; | ||||
| 1095 | pd->dst.buf = dst_buf_base; | ||||
| 1096 | args->rdc->rate += this_rdc.rate; | ||||
| 1097 | args->rdc->dist += this_rdc.dist; | ||||
| 1098 | } | ||||
| 1099 | |||||
| 1100 | static const THR_MODES mode_idx[MAX_REF_FRAMES4][4] = { | ||||
| 1101 | { THR_DC, THR_V_PRED, THR_H_PRED, THR_TM }, | ||||
| 1102 | { THR_NEARESTMV, THR_NEARMV, THR_ZEROMV, THR_NEWMV }, | ||||
| 1103 | { THR_NEARESTG, THR_NEARG, THR_ZEROG, THR_NEWG }, | ||||
| 1104 | { THR_NEARESTA, THR_NEARA, THR_ZEROA, THR_NEWA }, | ||||
| 1105 | }; | ||||
| 1106 | |||||
| 1107 | static const PREDICTION_MODE intra_mode_list[] = { DC_PRED0, V_PRED1, H_PRED2, | ||||
| 1108 | TM_PRED9 }; | ||||
| 1109 | |||||
| 1110 | static int mode_offset(const PREDICTION_MODE mode) { | ||||
| 1111 | if (mode >= NEARESTMV10) { | ||||
| 1112 | return INTER_OFFSET(mode)((mode) - 10); | ||||
| 1113 | } else { | ||||
| 1114 | switch (mode) { | ||||
| 1115 | case DC_PRED0: return 0; | ||||
| 1116 | case V_PRED1: return 1; | ||||
| 1117 | case H_PRED2: return 2; | ||||
| 1118 | case TM_PRED9: return 3; | ||||
| 1119 | default: return -1; | ||||
| 1120 | } | ||||
| 1121 | } | ||||
| 1122 | } | ||||
| 1123 | |||||
| 1124 | static INLINEinline int rd_less_than_thresh_row_mt(int64_t best_rd, int thresh, | ||||
| 1125 | const int *const thresh_fact) { | ||||
| 1126 | int is_rd_less_than_thresh; | ||||
| 1127 | is_rd_less_than_thresh = | ||||
| 1128 | best_rd < ((int64_t)thresh * (*thresh_fact) >> 5) || thresh == INT_MAX2147483647; | ||||
| 1129 | return is_rd_less_than_thresh; | ||||
| 1130 | } | ||||
| 1131 | |||||
| 1132 | static INLINEinline void update_thresh_freq_fact_row_mt( | ||||
| 1133 | VP9_COMP *cpi, TileDataEnc *tile_data, unsigned int source_variance, | ||||
| 1134 | int thresh_freq_fact_idx, MV_REFERENCE_FRAME ref_frame, | ||||
| 1135 | THR_MODES best_mode_idx, PREDICTION_MODE mode) { | ||||
| 1136 | THR_MODES thr_mode_idx = mode_idx[ref_frame][mode_offset(mode)]; | ||||
| 1137 | int freq_fact_idx = thresh_freq_fact_idx + thr_mode_idx; | ||||
| 1138 | int *freq_fact = &tile_data->row_base_thresh_freq_fact[freq_fact_idx]; | ||||
| 1139 | if (thr_mode_idx == best_mode_idx) | ||||
| 1140 | *freq_fact -= (*freq_fact >> 4); | ||||
| 1141 | else if (cpi->sf.limit_newmv_early_exit && mode == NEWMV13 && | ||||
| 1142 | ref_frame == LAST_FRAME1 && source_variance < 5) { | ||||
| 1143 | *freq_fact = VPXMIN(*freq_fact + RD_THRESH_INC, 32)(((*freq_fact + 1) < (32)) ? (*freq_fact + 1) : (32)); | ||||
| 1144 | } else { | ||||
| 1145 | *freq_fact = VPXMIN(*freq_fact + RD_THRESH_INC,(((*freq_fact + 1) < (cpi->sf.adaptive_rd_thresh * 64)) ? (*freq_fact + 1) : (cpi->sf.adaptive_rd_thresh * 64)) | ||||
| 1146 | cpi->sf.adaptive_rd_thresh * RD_THRESH_MAX_FACT)(((*freq_fact + 1) < (cpi->sf.adaptive_rd_thresh * 64)) ? (*freq_fact + 1) : (cpi->sf.adaptive_rd_thresh * 64)); | ||||
| 1147 | } | ||||
| 1148 | } | ||||
| 1149 | |||||
| 1150 | static INLINEinline void update_thresh_freq_fact( | ||||
| 1151 | VP9_COMP *cpi, TileDataEnc *tile_data, unsigned int source_variance, | ||||
| 1152 | BLOCK_SIZE bsize, MV_REFERENCE_FRAME ref_frame, THR_MODES best_mode_idx, | ||||
| 1153 | PREDICTION_MODE mode) { | ||||
| 1154 | THR_MODES thr_mode_idx = mode_idx[ref_frame][mode_offset(mode)]; | ||||
| 1155 | int *freq_fact = &tile_data->thresh_freq_fact[bsize][thr_mode_idx]; | ||||
| 1156 | if (thr_mode_idx == best_mode_idx) | ||||
| 1157 | *freq_fact -= (*freq_fact >> 4); | ||||
| 1158 | else if (cpi->sf.limit_newmv_early_exit && mode == NEWMV13 && | ||||
| 1159 | ref_frame == LAST_FRAME1 && source_variance < 5) { | ||||
| 1160 | *freq_fact = VPXMIN(*freq_fact + RD_THRESH_INC, 32)(((*freq_fact + 1) < (32)) ? (*freq_fact + 1) : (32)); | ||||
| 1161 | } else { | ||||
| 1162 | *freq_fact = VPXMIN(*freq_fact + RD_THRESH_INC,(((*freq_fact + 1) < (cpi->sf.adaptive_rd_thresh * 64)) ? (*freq_fact + 1) : (cpi->sf.adaptive_rd_thresh * 64)) | ||||
| 1163 | cpi->sf.adaptive_rd_thresh * RD_THRESH_MAX_FACT)(((*freq_fact + 1) < (cpi->sf.adaptive_rd_thresh * 64)) ? (*freq_fact + 1) : (cpi->sf.adaptive_rd_thresh * 64)); | ||||
| 1164 | } | ||||
| 1165 | } | ||||
| 1166 | |||||
| 1167 | void vp9_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost, | ||||
| 1168 | BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { | ||||
| 1169 | MACROBLOCKD *const xd = &x->e_mbd; | ||||
| 1170 | MODE_INFO *const mi = xd->mi[0]; | ||||
| 1171 | RD_COST this_rdc, best_rdc; | ||||
| 1172 | PREDICTION_MODE this_mode; | ||||
| 1173 | struct estimate_block_intra_args args = { cpi, x, DC_PRED0, 1, 0 }; | ||||
| 1174 | const TX_SIZE intra_tx_size = | ||||
| 1175 | VPXMIN(max_txsize_lookup[bsize],(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) | ||||
| 1176 | tx_mode_to_biggest_tx_size[cpi->common.tx_mode])(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])); | ||||
| 1177 | MODE_INFO *const mic = xd->mi[0]; | ||||
| 1178 | int *bmode_costs; | ||||
| 1179 | const MODE_INFO *above_mi = xd->above_mi; | ||||
| 1180 | const MODE_INFO *left_mi = xd->left_mi; | ||||
| 1181 | const PREDICTION_MODE A = vp9_above_block_mode(mic, above_mi, 0); | ||||
| 1182 | const PREDICTION_MODE L = vp9_left_block_mode(mic, left_mi, 0); | ||||
| 1183 | bmode_costs = cpi->y_mode_costs[A][L]; | ||||
| 1184 | assert(bsize >= BLOCK_8X8)((void) sizeof ((bsize >= 3) ? 1 : 0), __extension__ ({ if (bsize >= 3) ; else __assert_fail ("bsize >= BLOCK_8X8" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 1184, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 1185 | |||||
| 1186 | (void)ctx; | ||||
| 1187 | vp9_rd_cost_reset(&best_rdc); | ||||
| 1188 | vp9_rd_cost_reset(&this_rdc); | ||||
| 1189 | |||||
| 1190 | mi->ref_frame[0] = INTRA_FRAME0; | ||||
| 1191 | // Initialize interp_filter here so we do not have to check for inter block | ||||
| 1192 | // modes in get_pred_context_switchable_interp() | ||||
| 1193 | mi->interp_filter = SWITCHABLE_FILTERS3; | ||||
| 1194 | |||||
| 1195 | mi->mv[0].as_int = INVALID_MV0x80008000; | ||||
| 1196 | mi->uv_mode = DC_PRED0; | ||||
| 1197 | memset(x->skip_txfm, 0, sizeof(x->skip_txfm)); | ||||
| 1198 | |||||
| 1199 | // Change the limit of this loop to add other intra prediction | ||||
| 1200 | // mode tests. | ||||
| 1201 | for (this_mode = DC_PRED0; this_mode <= H_PRED2; ++this_mode) { | ||||
| 1202 | this_rdc.dist = this_rdc.rate = 0; | ||||
| 1203 | args.mode = this_mode; | ||||
| 1204 | args.skippable = 1; | ||||
| 1205 | args.rdc = &this_rdc; | ||||
| 1206 | mi->tx_size = intra_tx_size; | ||||
| 1207 | vp9_foreach_transformed_block_in_plane(xd, bsize, 0, estimate_block_intra, | ||||
| 1208 | &args); | ||||
| 1209 | if (args.skippable) { | ||||
| 1210 | x->skip_txfm[0] = SKIP_TXFM_AC_DC1; | ||||
| 1211 | this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 1)(vp9_prob_cost[(1) ? 256 - (vp9_get_skip_prob(&cpi->common , xd)) : (vp9_get_skip_prob(&cpi->common, xd))]); | ||||
| 1212 | } else { | ||||
| 1213 | x->skip_txfm[0] = SKIP_TXFM_NONE0; | ||||
| 1214 | this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 0)(vp9_prob_cost[(0) ? 256 - (vp9_get_skip_prob(&cpi->common , xd)) : (vp9_get_skip_prob(&cpi->common, xd))]); | ||||
| 1215 | } | ||||
| 1216 | this_rdc.rate += bmode_costs[this_mode]; | ||||
| 1217 | this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist)(((((int64_t)(this_rdc.rate)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((this_rdc.dist) << (x-> rddiv)); | ||||
| 1218 | |||||
| 1219 | if (this_rdc.rdcost < best_rdc.rdcost) { | ||||
| 1220 | best_rdc = this_rdc; | ||||
| 1221 | mi->mode = this_mode; | ||||
| 1222 | } | ||||
| 1223 | } | ||||
| 1224 | |||||
| 1225 | *rd_cost = best_rdc; | ||||
| 1226 | } | ||||
| 1227 | |||||
| 1228 | static void init_ref_frame_cost(VP9_COMMON *const cm, MACROBLOCKD *const xd, | ||||
| 1229 | int ref_frame_cost[MAX_REF_FRAMES4]) { | ||||
| 1230 | vpx_prob intra_inter_p = vp9_get_intra_inter_prob(cm, xd); | ||||
| 1231 | vpx_prob ref_single_p1 = vp9_get_pred_prob_single_ref_p1(cm, xd); | ||||
| 1232 | vpx_prob ref_single_p2 = vp9_get_pred_prob_single_ref_p2(cm, xd); | ||||
| 1233 | |||||
| 1234 | ref_frame_cost[INTRA_FRAME0] = vp9_cost_bit(intra_inter_p, 0)(vp9_prob_cost[(0) ? 256 - (intra_inter_p) : (intra_inter_p)] ); | ||||
| 1235 | ref_frame_cost[LAST_FRAME1] = ref_frame_cost[GOLDEN_FRAME2] = | ||||
| 1236 | ref_frame_cost[ALTREF_FRAME3] = vp9_cost_bit(intra_inter_p, 1)(vp9_prob_cost[(1) ? 256 - (intra_inter_p) : (intra_inter_p)] ); | ||||
| 1237 | |||||
| 1238 | ref_frame_cost[LAST_FRAME1] += vp9_cost_bit(ref_single_p1, 0)(vp9_prob_cost[(0) ? 256 - (ref_single_p1) : (ref_single_p1)] ); | ||||
| 1239 | ref_frame_cost[GOLDEN_FRAME2] += vp9_cost_bit(ref_single_p1, 1)(vp9_prob_cost[(1) ? 256 - (ref_single_p1) : (ref_single_p1)] ); | ||||
| 1240 | ref_frame_cost[ALTREF_FRAME3] += vp9_cost_bit(ref_single_p1, 1)(vp9_prob_cost[(1) ? 256 - (ref_single_p1) : (ref_single_p1)] ); | ||||
| 1241 | ref_frame_cost[GOLDEN_FRAME2] += vp9_cost_bit(ref_single_p2, 0)(vp9_prob_cost[(0) ? 256 - (ref_single_p2) : (ref_single_p2)] ); | ||||
| 1242 | ref_frame_cost[ALTREF_FRAME3] += vp9_cost_bit(ref_single_p2, 1)(vp9_prob_cost[(1) ? 256 - (ref_single_p2) : (ref_single_p2)] ); | ||||
| 1243 | } | ||||
| 1244 | |||||
| 1245 | typedef struct { | ||||
| 1246 | MV_REFERENCE_FRAME ref_frame; | ||||
| 1247 | PREDICTION_MODE pred_mode; | ||||
| 1248 | } REF_MODE; | ||||
| 1249 | |||||
| 1250 | #define RT_INTER_MODES12 12 | ||||
| 1251 | static const REF_MODE ref_mode_set[RT_INTER_MODES12] = { | ||||
| 1252 | { LAST_FRAME1, ZEROMV12 }, { LAST_FRAME1, NEARESTMV10 }, | ||||
| 1253 | { GOLDEN_FRAME2, ZEROMV12 }, { LAST_FRAME1, NEARMV11 }, | ||||
| 1254 | { LAST_FRAME1, NEWMV13 }, { GOLDEN_FRAME2, NEARESTMV10 }, | ||||
| 1255 | { GOLDEN_FRAME2, NEARMV11 }, { GOLDEN_FRAME2, NEWMV13 }, | ||||
| 1256 | { ALTREF_FRAME3, ZEROMV12 }, { ALTREF_FRAME3, NEARESTMV10 }, | ||||
| 1257 | { ALTREF_FRAME3, NEARMV11 }, { ALTREF_FRAME3, NEWMV13 } | ||||
| 1258 | }; | ||||
| 1259 | |||||
| 1260 | #define RT_INTER_MODES_SVC8 8 | ||||
| 1261 | static const REF_MODE ref_mode_set_svc[RT_INTER_MODES_SVC8] = { | ||||
| 1262 | { LAST_FRAME1, ZEROMV12 }, { LAST_FRAME1, NEARESTMV10 }, | ||||
| 1263 | { LAST_FRAME1, NEARMV11 }, { GOLDEN_FRAME2, ZEROMV12 }, | ||||
| 1264 | { GOLDEN_FRAME2, NEARESTMV10 }, { GOLDEN_FRAME2, NEARMV11 }, | ||||
| 1265 | { LAST_FRAME1, NEWMV13 }, { GOLDEN_FRAME2, NEWMV13 } | ||||
| 1266 | }; | ||||
| 1267 | |||||
| 1268 | static INLINEinline void find_predictors( | ||||
| 1269 | VP9_COMP *cpi, MACROBLOCK *x, MV_REFERENCE_FRAME ref_frame, | ||||
| 1270 | int_mv frame_mv[MB_MODE_COUNT14][MAX_REF_FRAMES4], | ||||
| 1271 | int const_motion[MAX_REF_FRAMES4], int *ref_frame_skip_mask, | ||||
| 1272 | TileDataEnc *tile_data, int mi_row, int mi_col, | ||||
| 1273 | struct buf_2d yv12_mb[4][MAX_MB_PLANE3], BLOCK_SIZE bsize, | ||||
| 1274 | int force_skip_low_temp_var, int comp_pred_allowed) { | ||||
| 1275 | VP9_COMMON *const cm = &cpi->common; | ||||
| 1276 | MACROBLOCKD *const xd = &x->e_mbd; | ||||
| 1277 | const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame); | ||||
| 1278 | TileInfo *const tile_info = &tile_data->tile_info; | ||||
| 1279 | // TODO(jingning) placeholder for inter-frame non-RD mode decision. | ||||
| 1280 | x->pred_mv_sad[ref_frame] = INT_MAX2147483647; | ||||
| 1281 | frame_mv[NEWMV13][ref_frame].as_int = INVALID_MV0x80008000; | ||||
| 1282 | frame_mv[ZEROMV12][ref_frame].as_int = 0; | ||||
| 1283 | // this needs various further optimizations. to be continued.. | ||||
| 1284 | if ((cpi->ref_frame_flags & ref_frame_to_flag(ref_frame)) && (yv12
| ||||
| 1285 | int_mv *const candidates = x->mbmi_ext->ref_mvs[ref_frame]; | ||||
| 1286 | const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf; | ||||
| 1287 | vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, sf, sf); | ||||
| 1288 | if (cm->use_prev_frame_mvs || comp_pred_allowed) { | ||||
| 1289 | vp9_find_mv_refs(cm, xd, xd->mi[0], ref_frame, candidates, mi_row, mi_col, | ||||
| 1290 | x->mbmi_ext->mode_context); | ||||
| 1291 | } else { | ||||
| 1292 | const_motion[ref_frame] = | ||||
| 1293 | mv_refs_rt(cpi, cm, x, xd, tile_info, xd->mi[0], ref_frame, | ||||
| 1294 | candidates, &frame_mv[NEWMV13][ref_frame], mi_row, mi_col, | ||||
| 1295 | (int)(cpi->svc.use_base_mv && cpi->svc.spatial_layer_id)); | ||||
| 1296 | } | ||||
| 1297 | vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates, | ||||
| 1298 | &frame_mv[NEARESTMV10][ref_frame], | ||||
| 1299 | &frame_mv[NEARMV11][ref_frame]); | ||||
| 1300 | // Early exit for golden frame if force_skip_low_temp_var is set. | ||||
| 1301 | if (!vp9_is_scaled(sf) && bsize >= BLOCK_8X83 && | ||||
| 1302 | !(force_skip_low_temp_var && ref_frame == GOLDEN_FRAME2)) { | ||||
| 1303 | vp9_mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride, ref_frame, | ||||
| 1304 | bsize); | ||||
| 1305 | } | ||||
| 1306 | } else { | ||||
| 1307 | *ref_frame_skip_mask |= (1 << ref_frame); | ||||
| 1308 | } | ||||
| 1309 | } | ||||
| 1310 | |||||
| 1311 | static void vp9_NEWMV_diff_bias(const NOISE_ESTIMATE *ne, MACROBLOCKD *xd, | ||||
| 1312 | PREDICTION_MODE this_mode, RD_COST *this_rdc, | ||||
| 1313 | BLOCK_SIZE bsize, int mv_row, int mv_col, | ||||
| 1314 | int is_last_frame, int lowvar_highsumdiff, | ||||
| 1315 | int is_skin) { | ||||
| 1316 | // Bias against MVs associated with NEWMV mode that are very different from | ||||
| 1317 | // top/left neighbors. | ||||
| 1318 | if (this_mode == NEWMV13) { | ||||
| 1319 | int al_mv_average_row; | ||||
| 1320 | int al_mv_average_col; | ||||
| 1321 | int left_row, left_col; | ||||
| 1322 | int row_diff, col_diff; | ||||
| 1323 | int above_mv_valid = 0; | ||||
| 1324 | int left_mv_valid = 0; | ||||
| 1325 | int above_row = 0; | ||||
| 1326 | int above_col = 0; | ||||
| 1327 | |||||
| 1328 | if (xd->above_mi) { | ||||
| 1329 | above_mv_valid = xd->above_mi->mv[0].as_int != INVALID_MV0x80008000; | ||||
| 1330 | above_row = xd->above_mi->mv[0].as_mv.row; | ||||
| 1331 | above_col = xd->above_mi->mv[0].as_mv.col; | ||||
| 1332 | } | ||||
| 1333 | if (xd->left_mi) { | ||||
| 1334 | left_mv_valid = xd->left_mi->mv[0].as_int != INVALID_MV0x80008000; | ||||
| 1335 | left_row = xd->left_mi->mv[0].as_mv.row; | ||||
| 1336 | left_col = xd->left_mi->mv[0].as_mv.col; | ||||
| 1337 | } | ||||
| 1338 | if (above_mv_valid && left_mv_valid) { | ||||
| 1339 | al_mv_average_row = (above_row + left_row + 1) >> 1; | ||||
| 1340 | al_mv_average_col = (above_col + left_col + 1) >> 1; | ||||
| 1341 | } else if (above_mv_valid) { | ||||
| 1342 | al_mv_average_row = above_row; | ||||
| 1343 | al_mv_average_col = above_col; | ||||
| 1344 | } else if (left_mv_valid) { | ||||
| 1345 | al_mv_average_row = left_row; | ||||
| 1346 | al_mv_average_col = left_col; | ||||
| 1347 | } else { | ||||
| 1348 | al_mv_average_row = al_mv_average_col = 0; | ||||
| 1349 | } | ||||
| 1350 | row_diff = (al_mv_average_row - mv_row); | ||||
| 1351 | col_diff = (al_mv_average_col - mv_col); | ||||
| 1352 | if (row_diff > 48 || row_diff < -48 || col_diff > 48 || col_diff < -48) { | ||||
| 1353 | if (bsize > BLOCK_32X329) | ||||
| 1354 | this_rdc->rdcost = this_rdc->rdcost << 1; | ||||
| 1355 | else | ||||
| 1356 | this_rdc->rdcost = 3 * this_rdc->rdcost >> 1; | ||||
| 1357 | } | ||||
| 1358 | } | ||||
| 1359 | // If noise estimation is enabled, and estimated level is above threshold, | ||||
| 1360 | // add a bias to LAST reference with small motion, for large blocks. | ||||
| 1361 | if (ne->enabled && ne->level >= kMedium && bsize >= BLOCK_32X329 && | ||||
| 1362 | is_last_frame && mv_row < 8 && mv_row > -8 && mv_col < 8 && mv_col > -8) | ||||
| 1363 | this_rdc->rdcost = 7 * (this_rdc->rdcost >> 3); | ||||
| 1364 | else if (lowvar_highsumdiff && !is_skin && bsize >= BLOCK_16X166 && | ||||
| 1365 | is_last_frame && mv_row < 16 && mv_row > -16 && mv_col < 16 && | ||||
| 1366 | mv_col > -16) | ||||
| 1367 | this_rdc->rdcost = 7 * (this_rdc->rdcost >> 3); | ||||
| 1368 | } | ||||
| 1369 | |||||
| 1370 | #if CONFIG_VP9_TEMPORAL_DENOISING0 | ||||
| 1371 | static void vp9_pickmode_ctx_den_update( | ||||
| 1372 | VP9_PICKMODE_CTX_DEN *ctx_den, int64_t zero_last_cost_orig, | ||||
| 1373 | int ref_frame_cost[MAX_REF_FRAMES4], | ||||
| 1374 | int_mv frame_mv[MB_MODE_COUNT14][MAX_REF_FRAMES4], int reuse_inter_pred, | ||||
| 1375 | BEST_PICKMODE *bp) { | ||||
| 1376 | ctx_den->zero_last_cost_orig = zero_last_cost_orig; | ||||
| 1377 | ctx_den->ref_frame_cost = ref_frame_cost; | ||||
| 1378 | ctx_den->frame_mv = frame_mv; | ||||
| 1379 | ctx_den->reuse_inter_pred = reuse_inter_pred; | ||||
| 1380 | ctx_den->best_tx_size = bp->best_tx_size; | ||||
| 1381 | ctx_den->best_mode = bp->best_mode; | ||||
| 1382 | ctx_den->best_ref_frame = bp->best_ref_frame; | ||||
| 1383 | ctx_den->best_pred_filter = bp->best_pred_filter; | ||||
| 1384 | ctx_den->best_mode_skip_txfm = bp->best_mode_skip_txfm; | ||||
| 1385 | } | ||||
| 1386 | |||||
| 1387 | static void recheck_zeromv_after_denoising( | ||||
| 1388 | VP9_COMP *cpi, MODE_INFO *const mi, MACROBLOCK *x, MACROBLOCKD *const xd, | ||||
| 1389 | VP9_DENOISER_DECISION decision, VP9_PICKMODE_CTX_DEN *ctx_den, | ||||
| 1390 | struct buf_2d yv12_mb[4][MAX_MB_PLANE3], RD_COST *best_rdc, BLOCK_SIZE bsize, | ||||
| 1391 | int mi_row, int mi_col) { | ||||
| 1392 | // If INTRA or GOLDEN reference was selected, re-evaluate ZEROMV on | ||||
| 1393 | // denoised result. Only do this under noise conditions, and if rdcost of | ||||
| 1394 | // ZEROMV onoriginal source is not significantly higher than rdcost of best | ||||
| 1395 | // mode. | ||||
| 1396 | if (cpi->noise_estimate.enabled && cpi->noise_estimate.level > kLow && | ||||
| 1397 | ctx_den->zero_last_cost_orig < (best_rdc->rdcost << 3) && | ||||
| 1398 | ((ctx_den->best_ref_frame == INTRA_FRAME0 && decision >= FILTER_BLOCK) || | ||||
| 1399 | (ctx_den->best_ref_frame == GOLDEN_FRAME2 && | ||||
| 1400 | cpi->svc.number_spatial_layers == 1 && | ||||
| 1401 | decision == FILTER_ZEROMV_BLOCK))) { | ||||
| 1402 | // Check if we should pick ZEROMV on denoised signal. | ||||
| 1403 | VP9_COMMON *const cm = &cpi->common; | ||||
| 1404 | int rate = 0; | ||||
| 1405 | int64_t dist = 0; | ||||
| 1406 | uint32_t var_y = UINT_MAX(2147483647 *2U +1U); | ||||
| 1407 | uint32_t sse_y = UINT_MAX(2147483647 *2U +1U); | ||||
| 1408 | RD_COST this_rdc; | ||||
| 1409 | mi->mode = ZEROMV12; | ||||
| 1410 | mi->ref_frame[0] = LAST_FRAME1; | ||||
| 1411 | mi->ref_frame[1] = NO_REF_FRAME(-1); | ||||
| 1412 | set_ref_ptrs(cm, xd, mi->ref_frame[0], NO_REF_FRAME(-1)); | ||||
| 1413 | mi->mv[0].as_int = 0; | ||||
| 1414 | mi->interp_filter = EIGHTTAP0; | ||||
| 1415 | if (cpi->sf.default_interp_filter == BILINEAR3) mi->interp_filter = BILINEAR3; | ||||
| 1416 | xd->plane[0].pre[0] = yv12_mb[LAST_FRAME1][0]; | ||||
| 1417 | vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); | ||||
| 1418 | model_rd_for_sb_y(cpi, bsize, x, xd, &rate, &dist, &var_y, &sse_y, 0); | ||||
| 1419 | this_rdc.rate = rate + ctx_den->ref_frame_cost[LAST_FRAME1] + | ||||
| 1420 | cpi->inter_mode_cost[x->mbmi_ext->mode_context[LAST_FRAME1]] | ||||
| 1421 | [INTER_OFFSET(ZEROMV)((12) - 10)]; | ||||
| 1422 | this_rdc.dist = dist; | ||||
| 1423 | this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, rate, dist)(((((int64_t)(rate)) * (x->rdmult)) + (1 << ((9) - 1 ))) >> (9)) + ((dist) << (x->rddiv)); | ||||
| 1424 | // Don't switch to ZEROMV if the rdcost for ZEROMV on denoised source | ||||
| 1425 | // is higher than best_ref mode (on original source). | ||||
| 1426 | if (this_rdc.rdcost > best_rdc->rdcost) { | ||||
| 1427 | this_rdc = *best_rdc; | ||||
| 1428 | mi->mode = ctx_den->best_mode; | ||||
| 1429 | mi->ref_frame[0] = ctx_den->best_ref_frame; | ||||
| 1430 | set_ref_ptrs(cm, xd, mi->ref_frame[0], NO_REF_FRAME(-1)); | ||||
| 1431 | mi->interp_filter = ctx_den->best_pred_filter; | ||||
| 1432 | if (ctx_den->best_ref_frame == INTRA_FRAME0) { | ||||
| 1433 | mi->mv[0].as_int = INVALID_MV0x80008000; | ||||
| 1434 | mi->interp_filter = SWITCHABLE_FILTERS3; | ||||
| 1435 | } else if (ctx_den->best_ref_frame == GOLDEN_FRAME2) { | ||||
| 1436 | mi->mv[0].as_int = | ||||
| 1437 | ctx_den->frame_mv[ctx_den->best_mode][ctx_den->best_ref_frame] | ||||
| 1438 | .as_int; | ||||
| 1439 | if (ctx_den->reuse_inter_pred) { | ||||
| 1440 | xd->plane[0].pre[0] = yv12_mb[GOLDEN_FRAME2][0]; | ||||
| 1441 | vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); | ||||
| 1442 | } | ||||
| 1443 | } | ||||
| 1444 | mi->tx_size = ctx_den->best_tx_size; | ||||
| 1445 | x->skip_txfm[0] = ctx_den->best_mode_skip_txfm; | ||||
| 1446 | } else { | ||||
| 1447 | ctx_den->best_ref_frame = LAST_FRAME1; | ||||
| 1448 | *best_rdc = this_rdc; | ||||
| 1449 | } | ||||
| 1450 | } | ||||
| 1451 | } | ||||
| 1452 | #endif // CONFIG_VP9_TEMPORAL_DENOISING | ||||
| 1453 | |||||
| 1454 | static INLINEinline int get_force_skip_low_temp_var(uint8_t *variance_low, int mi_row, | ||||
| 1455 | int mi_col, BLOCK_SIZE bsize) { | ||||
| 1456 | const int i = (mi_row & 0x7) >> 1; | ||||
| 1457 | const int j = (mi_col & 0x7) >> 1; | ||||
| 1458 | int force_skip_low_temp_var = 0; | ||||
| 1459 | // Set force_skip_low_temp_var based on the block size and block offset. | ||||
| 1460 | if (bsize == BLOCK_64X6412) { | ||||
| 1461 | force_skip_low_temp_var = variance_low[0]; | ||||
| 1462 | } else if (bsize == BLOCK_64X3211) { | ||||
| 1463 | if (!(mi_col & 0x7) && !(mi_row & 0x7)) { | ||||
| 1464 | force_skip_low_temp_var = variance_low[1]; | ||||
| 1465 | } else if (!(mi_col & 0x7) && (mi_row & 0x7)) { | ||||
| 1466 | force_skip_low_temp_var = variance_low[2]; | ||||
| 1467 | } | ||||
| 1468 | } else if (bsize == BLOCK_32X6410) { | ||||
| 1469 | if (!(mi_col & 0x7) && !(mi_row & 0x7)) { | ||||
| 1470 | force_skip_low_temp_var = variance_low[3]; | ||||
| 1471 | } else if ((mi_col & 0x7) && !(mi_row & 0x7)) { | ||||
| 1472 | force_skip_low_temp_var = variance_low[4]; | ||||
| 1473 | } | ||||
| 1474 | } else if (bsize == BLOCK_32X329) { | ||||
| 1475 | if (!(mi_col & 0x7) && !(mi_row & 0x7)) { | ||||
| 1476 | force_skip_low_temp_var = variance_low[5]; | ||||
| 1477 | } else if ((mi_col & 0x7) && !(mi_row & 0x7)) { | ||||
| 1478 | force_skip_low_temp_var = variance_low[6]; | ||||
| 1479 | } else if (!(mi_col & 0x7) && (mi_row & 0x7)) { | ||||
| 1480 | force_skip_low_temp_var = variance_low[7]; | ||||
| 1481 | } else if ((mi_col & 0x7) && (mi_row & 0x7)) { | ||||
| 1482 | force_skip_low_temp_var = variance_low[8]; | ||||
| 1483 | } | ||||
| 1484 | } else if (bsize == BLOCK_16X166) { | ||||
| 1485 | force_skip_low_temp_var = variance_low[pos_shift_16x16[i][j]]; | ||||
| 1486 | } else if (bsize == BLOCK_32X168) { | ||||
| 1487 | // The col shift index for the second 16x16 block. | ||||
| 1488 | const int j2 = ((mi_col + 2) & 0x7) >> 1; | ||||
| 1489 | // Only if each 16x16 block inside has low temporal variance. | ||||
| 1490 | force_skip_low_temp_var = variance_low[pos_shift_16x16[i][j]] && | ||||
| 1491 | variance_low[pos_shift_16x16[i][j2]]; | ||||
| 1492 | } else if (bsize == BLOCK_16X327) { | ||||
| 1493 | // The row shift index for the second 16x16 block. | ||||
| 1494 | const int i2 = ((mi_row + 2) & 0x7) >> 1; | ||||
| 1495 | force_skip_low_temp_var = variance_low[pos_shift_16x16[i][j]] && | ||||
| 1496 | variance_low[pos_shift_16x16[i2][j]]; | ||||
| 1497 | } | ||||
| 1498 | return force_skip_low_temp_var; | ||||
| 1499 | } | ||||
| 1500 | |||||
| 1501 | static void search_filter_ref(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *this_rdc, | ||||
| 1502 | int mi_row, int mi_col, PRED_BUFFER *tmp, | ||||
| 1503 | BLOCK_SIZE bsize, int reuse_inter_pred, | ||||
| 1504 | PRED_BUFFER **this_mode_pred, unsigned int *var_y, | ||||
| 1505 | unsigned int *sse_y, int force_smooth_filter, | ||||
| 1506 | int *this_early_term, int *flag_preduv_computed, | ||||
| 1507 | int use_model_yrd_large) { | ||||
| 1508 | MACROBLOCKD *const xd = &x->e_mbd; | ||||
| 1509 | MODE_INFO *const mi = xd->mi[0]; | ||||
| 1510 | struct macroblockd_plane *const pd = &xd->plane[0]; | ||||
| 1511 | const int bw = num_4x4_blocks_wide_lookup[bsize] << 2; | ||||
| 1512 | |||||
| 1513 | int pf_rate[3] = { 0 }; | ||||
| 1514 | int64_t pf_dist[3] = { 0 }; | ||||
| 1515 | int curr_rate[3] = { 0 }; | ||||
| 1516 | unsigned int pf_var[3] = { 0 }; | ||||
| 1517 | unsigned int pf_sse[3] = { 0 }; | ||||
| 1518 | TX_SIZE pf_tx_size[3] = { 0 }; | ||||
| 1519 | int64_t best_cost = INT64_MAX(9223372036854775807L); | ||||
| 1520 | INTERP_FILTER best_filter = SWITCHABLE4, filter; | ||||
| 1521 | PRED_BUFFER *current_pred = *this_mode_pred; | ||||
| 1522 | uint8_t skip_txfm = SKIP_TXFM_NONE0; | ||||
| 1523 | int best_early_term = 0; | ||||
| 1524 | int best_flag_preduv_computed[2] = { 0 }; | ||||
| 1525 | INTERP_FILTER filter_start = force_smooth_filter ? EIGHTTAP_SMOOTH1 : EIGHTTAP0; | ||||
| 1526 | INTERP_FILTER filter_end = EIGHTTAP_SMOOTH1; | ||||
| 1527 | for (filter = filter_start; filter <= filter_end; ++filter) { | ||||
| 1528 | int64_t cost; | ||||
| 1529 | mi->interp_filter = filter; | ||||
| 1530 | vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); | ||||
| 1531 | // For large partition blocks, extra testing is done. | ||||
| 1532 | if (use_model_yrd_large) | ||||
| 1533 | model_rd_for_sb_y_large(cpi, bsize, x, xd, &pf_rate[filter], | ||||
| 1534 | &pf_dist[filter], &pf_var[filter], | ||||
| 1535 | &pf_sse[filter], mi_row, mi_col, this_early_term, | ||||
| 1536 | flag_preduv_computed); | ||||
| 1537 | else | ||||
| 1538 | model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[filter], &pf_dist[filter], | ||||
| 1539 | &pf_var[filter], &pf_sse[filter], 0); | ||||
| 1540 | curr_rate[filter] = pf_rate[filter]; | ||||
| 1541 | pf_rate[filter] += vp9_get_switchable_rate(cpi, xd); | ||||
| 1542 | cost = RDCOST(x->rdmult, x->rddiv, pf_rate[filter], pf_dist[filter])(((((int64_t)(pf_rate[filter])) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((pf_dist[filter]) << (x-> rddiv)); | ||||
| 1543 | pf_tx_size[filter] = mi->tx_size; | ||||
| 1544 | if (cost < best_cost) { | ||||
| 1545 | best_filter = filter; | ||||
| 1546 | best_cost = cost; | ||||
| 1547 | skip_txfm = x->skip_txfm[0]; | ||||
| 1548 | best_early_term = *this_early_term; | ||||
| 1549 | best_flag_preduv_computed[0] = flag_preduv_computed[0]; | ||||
| 1550 | best_flag_preduv_computed[1] = flag_preduv_computed[1]; | ||||
| 1551 | |||||
| 1552 | if (reuse_inter_pred) { | ||||
| 1553 | if (*this_mode_pred != current_pred) { | ||||
| 1554 | free_pred_buffer(*this_mode_pred); | ||||
| 1555 | *this_mode_pred = current_pred; | ||||
| 1556 | } | ||||
| 1557 | if (filter != filter_end) { | ||||
| 1558 | current_pred = &tmp[get_pred_buffer(tmp, 3)]; | ||||
| 1559 | pd->dst.buf = current_pred->data; | ||||
| 1560 | pd->dst.stride = bw; | ||||
| 1561 | } | ||||
| 1562 | } | ||||
| 1563 | } | ||||
| 1564 | } | ||||
| 1565 | |||||
| 1566 | if (reuse_inter_pred && *this_mode_pred != current_pred) | ||||
| 1567 | free_pred_buffer(current_pred); | ||||
| 1568 | |||||
| 1569 | mi->interp_filter = best_filter; | ||||
| 1570 | mi->tx_size = pf_tx_size[best_filter]; | ||||
| 1571 | this_rdc->rate = curr_rate[best_filter]; | ||||
| 1572 | this_rdc->dist = pf_dist[best_filter]; | ||||
| 1573 | *var_y = pf_var[best_filter]; | ||||
| 1574 | *sse_y = pf_sse[best_filter]; | ||||
| 1575 | x->skip_txfm[0] = skip_txfm; | ||||
| 1576 | *this_early_term = best_early_term; | ||||
| 1577 | flag_preduv_computed[0] = best_flag_preduv_computed[0]; | ||||
| 1578 | flag_preduv_computed[1] = best_flag_preduv_computed[1]; | ||||
| 1579 | if (reuse_inter_pred) { | ||||
| 1580 | pd->dst.buf = (*this_mode_pred)->data; | ||||
| 1581 | pd->dst.stride = (*this_mode_pred)->stride; | ||||
| 1582 | } else if (best_filter < filter_end) { | ||||
| 1583 | mi->interp_filter = best_filter; | ||||
| 1584 | vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); | ||||
| 1585 | } | ||||
| 1586 | } | ||||
| 1587 | |||||
| 1588 | static int search_new_mv(VP9_COMP *cpi, MACROBLOCK *x, | ||||
| 1589 | int_mv frame_mv[][MAX_REF_FRAMES4], | ||||
| 1590 | MV_REFERENCE_FRAME ref_frame, int gf_temporal_ref, | ||||
| 1591 | BLOCK_SIZE bsize, int mi_row, int mi_col, | ||||
| 1592 | int best_pred_sad, int *rate_mv, | ||||
| 1593 | unsigned int best_sse_sofar, RD_COST *best_rdc) { | ||||
| 1594 | SVC *const svc = &cpi->svc; | ||||
| 1595 | MACROBLOCKD *const xd = &x->e_mbd; | ||||
| 1596 | MODE_INFO *const mi = xd->mi[0]; | ||||
| 1597 | SPEED_FEATURES *const sf = &cpi->sf; | ||||
| 1598 | |||||
| 1599 | if (ref_frame > LAST_FRAME1 && gf_temporal_ref && | ||||
| 1600 | cpi->oxcf.rc_mode == VPX_CBR) { | ||||
| 1601 | int tmp_sad; | ||||
| 1602 | uint32_t dis; | ||||
| 1603 | int cost_list[5] = { INT_MAX2147483647, INT_MAX2147483647, INT_MAX2147483647, INT_MAX2147483647, INT_MAX2147483647 }; | ||||
| 1604 | |||||
| 1605 | if (bsize < BLOCK_16X166) return -1; | ||||
| 1606 | |||||
| 1607 | tmp_sad = vp9_int_pro_motion_estimation( | ||||
| 1608 | cpi, x, bsize, mi_row, mi_col, | ||||
| 1609 | &x->mbmi_ext->ref_mvs[ref_frame][0].as_mv); | ||||
| 1610 | |||||
| 1611 | if (tmp_sad > x->pred_mv_sad[LAST_FRAME1]) return -1; | ||||
| 1612 | if (tmp_sad + (num_pels_log2_lookup[bsize] << 4) > best_pred_sad) return -1; | ||||
| 1613 | |||||
| 1614 | frame_mv[NEWMV13][ref_frame].as_int = mi->mv[0].as_int; | ||||
| 1615 | *rate_mv = vp9_mv_bit_cost(&frame_mv[NEWMV13][ref_frame].as_mv, | ||||
| 1616 | &x->mbmi_ext->ref_mvs[ref_frame][0].as_mv, | ||||
| 1617 | x->nmvjointcost, x->mvcost, MV_COST_WEIGHT108); | ||||
| 1618 | frame_mv[NEWMV13][ref_frame].as_mv.row >>= 3; | ||||
| 1619 | frame_mv[NEWMV13][ref_frame].as_mv.col >>= 3; | ||||
| 1620 | |||||
| 1621 | cpi->find_fractional_mv_step( | ||||
| 1622 | x, &frame_mv[NEWMV13][ref_frame].as_mv, | ||||
| 1623 | &x->mbmi_ext->ref_mvs[ref_frame][0].as_mv, | ||||
| 1624 | cpi->common.allow_high_precision_mv, x->errorperbit, | ||||
| 1625 | &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop, | ||||
| 1626 | cpi->sf.mv.subpel_search_level, cond_cost_list(cpi, cost_list), | ||||
| 1627 | x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref_frame], NULL((void*)0), 0, 0, | ||||
| 1628 | cpi->sf.use_accurate_subpel_search); | ||||
| 1629 | } else if (svc->use_base_mv && svc->spatial_layer_id) { | ||||
| 1630 | if (frame_mv[NEWMV13][ref_frame].as_int != INVALID_MV0x80008000) { | ||||
| 1631 | const int pre_stride = xd->plane[0].pre[0].stride; | ||||
| 1632 | unsigned int base_mv_sse = UINT_MAX(2147483647 *2U +1U); | ||||
| 1633 | int scale = (cpi->rc.avg_frame_low_motion > 60) ? 2 : 4; | ||||
| 1634 | const uint8_t *const pre_buf = | ||||
| 1635 | xd->plane[0].pre[0].buf + | ||||
| 1636 | (frame_mv[NEWMV13][ref_frame].as_mv.row >> 3) * pre_stride + | ||||
| 1637 | (frame_mv[NEWMV13][ref_frame].as_mv.col >> 3); | ||||
| 1638 | cpi->fn_ptr[bsize].vf(x->plane[0].src.buf, x->plane[0].src.stride, | ||||
| 1639 | pre_buf, pre_stride, &base_mv_sse); | ||||
| 1640 | |||||
| 1641 | // Exit NEWMV search if base_mv is (0,0) && bsize < BLOCK_16x16, | ||||
| 1642 | // for SVC encoding. | ||||
| 1643 | if (cpi->use_svc && svc->use_base_mv && bsize < BLOCK_16X166 && | ||||
| 1644 | frame_mv[NEWMV13][ref_frame].as_mv.row == 0 && | ||||
| 1645 | frame_mv[NEWMV13][ref_frame].as_mv.col == 0) | ||||
| 1646 | return -1; | ||||
| 1647 | |||||
| 1648 | // Exit NEWMV search if base_mv_sse is large. | ||||
| 1649 | if (sf->base_mv_aggressive && (base_mv_sse >> scale) > best_sse_sofar) | ||||
| 1650 | return -1; | ||||
| 1651 | if ((base_mv_sse >> 1) < best_sse_sofar) { | ||||
| 1652 | // Base layer mv is good. | ||||
| 1653 | // Exit NEWMV search if the base_mv is (0, 0) and sse is low, since | ||||
| 1654 | // (0, 0) mode is already tested. | ||||
| 1655 | unsigned int base_mv_sse_normalized = | ||||
| 1656 | base_mv_sse >> | ||||
| 1657 | (b_width_log2_lookup[bsize] + b_height_log2_lookup[bsize]); | ||||
| 1658 | if (sf->base_mv_aggressive && base_mv_sse <= best_sse_sofar && | ||||
| 1659 | base_mv_sse_normalized < 400 && | ||||
| 1660 | frame_mv[NEWMV13][ref_frame].as_mv.row == 0 && | ||||
| 1661 | frame_mv[NEWMV13][ref_frame].as_mv.col == 0) | ||||
| 1662 | return -1; | ||||
| 1663 | if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col, | ||||
| 1664 | &frame_mv[NEWMV13][ref_frame], rate_mv, | ||||
| 1665 | best_rdc->rdcost, 1)) { | ||||
| 1666 | return -1; | ||||
| 1667 | } | ||||
| 1668 | } else if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col, | ||||
| 1669 | &frame_mv[NEWMV13][ref_frame], rate_mv, | ||||
| 1670 | best_rdc->rdcost, 0)) { | ||||
| 1671 | return -1; | ||||
| 1672 | } | ||||
| 1673 | } else if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col, | ||||
| 1674 | &frame_mv[NEWMV13][ref_frame], rate_mv, | ||||
| 1675 | best_rdc->rdcost, 0)) { | ||||
| 1676 | return -1; | ||||
| 1677 | } | ||||
| 1678 | } else if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col, | ||||
| 1679 | &frame_mv[NEWMV13][ref_frame], rate_mv, | ||||
| 1680 | best_rdc->rdcost, 0)) { | ||||
| 1681 | return -1; | ||||
| 1682 | } | ||||
| 1683 | |||||
| 1684 | return 0; | ||||
| 1685 | } | ||||
| 1686 | |||||
| 1687 | static INLINEinline void init_best_pickmode(BEST_PICKMODE *bp) { | ||||
| 1688 | bp->best_mode = ZEROMV12; | ||||
| 1689 | bp->best_ref_frame = LAST_FRAME1; | ||||
| 1690 | bp->best_tx_size = TX_SIZES((TX_SIZE)4); | ||||
| 1691 | bp->best_intra_tx_size = TX_SIZES((TX_SIZE)4); | ||||
| 1692 | bp->best_pred_filter = EIGHTTAP0; | ||||
| 1693 | bp->best_mode_skip_txfm = SKIP_TXFM_NONE0; | ||||
| 1694 | bp->best_second_ref_frame = NO_REF_FRAME(-1); | ||||
| 1695 | bp->best_pred = NULL((void*)0); | ||||
| 1696 | } | ||||
| 1697 | |||||
| 1698 | void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, TileDataEnc *tile_data, | ||||
| 1699 | int mi_row, int mi_col, RD_COST *rd_cost, | ||||
| 1700 | BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { | ||||
| 1701 | VP9_COMMON *const cm = &cpi->common; | ||||
| 1702 | SPEED_FEATURES *const sf = &cpi->sf; | ||||
| 1703 | SVC *const svc = &cpi->svc; | ||||
| 1704 | MACROBLOCKD *const xd = &x->e_mbd; | ||||
| 1705 | MODE_INFO *const mi = xd->mi[0]; | ||||
| 1706 | struct macroblockd_plane *const pd = &xd->plane[0]; | ||||
| 1707 | |||||
| 1708 | BEST_PICKMODE best_pickmode; | ||||
| 1709 | |||||
| 1710 | MV_REFERENCE_FRAME ref_frame; | ||||
| 1711 | MV_REFERENCE_FRAME usable_ref_frame, second_ref_frame; | ||||
| 1712 | int_mv frame_mv[MB_MODE_COUNT14][MAX_REF_FRAMES4]; | ||||
| 1713 | uint8_t mode_checked[MB_MODE_COUNT14][MAX_REF_FRAMES4]; | ||||
| 1714 | struct buf_2d yv12_mb[4][MAX_MB_PLANE3] = { 0 }; | ||||
| 1715 | RD_COST this_rdc, best_rdc; | ||||
| 1716 | // var_y and sse_y are saved to be used in skipping checking | ||||
| 1717 | unsigned int var_y = UINT_MAX(2147483647 *2U +1U); | ||||
| 1718 | unsigned int sse_y = UINT_MAX(2147483647 *2U +1U); | ||||
| 1719 | const int intra_cost_penalty = | ||||
| 1720 | vp9_get_intra_cost_penalty(cpi, bsize, cm->base_qindex, cm->y_dc_delta_q); | ||||
| 1721 | int64_t inter_mode_thresh = | ||||
| 1722 | RDCOST(x->rdmult, x->rddiv, intra_cost_penalty, 0)(((((int64_t)(intra_cost_penalty)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((0) << (x->rddiv)); | ||||
| |||||
| 1723 | const int *const rd_threshes = cpi->rd.threshes[mi->segment_id][bsize]; | ||||
| 1724 | const int sb_row = mi_row >> MI_BLOCK_SIZE_LOG2(6 - 3); | ||||
| 1725 | int thresh_freq_fact_idx = (sb_row * BLOCK_SIZES13 + bsize) * MAX_MODES30; | ||||
| 1726 | const int *const rd_thresh_freq_fact = | ||||
| 1727 | (cpi->sf.adaptive_rd_thresh_row_mt) | ||||
| 1728 | ? &(tile_data->row_base_thresh_freq_fact[thresh_freq_fact_idx]) | ||||
| 1729 | : tile_data->thresh_freq_fact[bsize]; | ||||
| 1730 | #if CONFIG_VP9_TEMPORAL_DENOISING0 | ||||
| 1731 | const int denoise_recheck_zeromv = 1; | ||||
| 1732 | #endif | ||||
| 1733 | INTERP_FILTER filter_ref; | ||||
| 1734 | int pred_filter_search = cm->interp_filter == SWITCHABLE4; | ||||
| 1735 | int const_motion[MAX_REF_FRAMES4] = { 0 }; | ||||
| 1736 | const int bh = num_4x4_blocks_high_lookup[bsize] << 2; | ||||
| 1737 | const int bw = num_4x4_blocks_wide_lookup[bsize] << 2; | ||||
| 1738 | // For speed 6, the result of interp filter is reused later in actual encoding | ||||
| 1739 | // process. | ||||
| 1740 | // tmp[3] points to dst buffer, and the other 3 point to allocated buffers. | ||||
| 1741 | PRED_BUFFER tmp[4]; | ||||
| 1742 | DECLARE_ALIGNED(16, uint8_t, pred_buf[3 * 64 * 64] VPX_UNINITIALIZED)uint8_t pred_buf[3 * 64 * 64] __attribute__((uninitialized)) __attribute__ ((aligned(16))); | ||||
| 1743 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 1744 | DECLARE_ALIGNED(16, uint16_t, pred_buf_16[3 * 64 * 64] VPX_UNINITIALIZED)uint16_t pred_buf_16[3 * 64 * 64] __attribute__((uninitialized )) __attribute__((aligned(16))); | ||||
| 1745 | #endif | ||||
| 1746 | struct buf_2d orig_dst = pd->dst; | ||||
| 1747 | PRED_BUFFER *this_mode_pred = NULL((void*)0); | ||||
| 1748 | const int pixels_in_block = bh * bw; | ||||
| 1749 | int reuse_inter_pred = cpi->sf.reuse_inter_pred_sby && ctx->pred_pixel_ready; | ||||
| 1750 | int ref_frame_skip_mask = 0; | ||||
| 1751 | int idx; | ||||
| 1752 | int best_pred_sad = INT_MAX2147483647; | ||||
| 1753 | int best_early_term = 0; | ||||
| 1754 | int ref_frame_cost[MAX_REF_FRAMES4]; | ||||
| 1755 | int svc_force_zero_mode[3] = { 0 }; | ||||
| 1756 | int perform_intra_pred = 1; | ||||
| 1757 | int use_golden_nonzeromv = 1; | ||||
| 1758 | int force_skip_low_temp_var = 0; | ||||
| 1759 | int skip_ref_find_pred[4] = { 0 }; | ||||
| 1760 | unsigned int sse_zeromv_normalized = UINT_MAX(2147483647 *2U +1U); | ||||
| 1761 | unsigned int best_sse_sofar = UINT_MAX(2147483647 *2U +1U); | ||||
| 1762 | int gf_temporal_ref = 0; | ||||
| 1763 | int force_test_gf_zeromv = 0; | ||||
| 1764 | #if CONFIG_VP9_TEMPORAL_DENOISING0 | ||||
| 1765 | VP9_PICKMODE_CTX_DEN ctx_den; | ||||
| 1766 | int64_t zero_last_cost_orig = INT64_MAX(9223372036854775807L); | ||||
| 1767 | int denoise_svc_pickmode = 1; | ||||
| 1768 | #endif | ||||
| 1769 | INTERP_FILTER filter_gf_svc = EIGHTTAP0; | ||||
| 1770 | MV_REFERENCE_FRAME inter_layer_ref = GOLDEN_FRAME2; | ||||
| 1771 | const struct segmentation *const seg = &cm->seg; | ||||
| 1772 | int comp_modes = 0; | ||||
| 1773 | int num_inter_modes = (cpi->use_svc) ? RT_INTER_MODES_SVC8 : RT_INTER_MODES12; | ||||
| 1774 | int flag_svc_subpel = 0; | ||||
| 1775 | int svc_mv_col = 0; | ||||
| 1776 | int svc_mv_row = 0; | ||||
| 1777 | int no_scaling = 0; | ||||
| 1778 | int large_block = 0; | ||||
| 1779 | int use_model_yrd_large = 0; | ||||
| 1780 | unsigned int thresh_svc_skip_golden = 500; | ||||
| 1781 | unsigned int thresh_skip_golden = 500; | ||||
| 1782 | int force_smooth_filter = cpi->sf.force_smooth_interpol; | ||||
| 1783 | int scene_change_detected = | ||||
| 1784 | cpi->rc.high_source_sad || | ||||
| 1785 | (cpi->use_svc
| ||||
| 1786 | |||||
| 1787 | init_best_pickmode(&best_pickmode); | ||||
| 1788 | |||||
| 1789 | x->encode_breakout = seg->enabled | ||||
| 1790 | ? cpi->segment_encode_breakout[mi->segment_id] | ||||
| 1791 | : cpi->encode_breakout; | ||||
| 1792 | |||||
| 1793 | x->source_variance = UINT_MAX(2147483647 *2U +1U); | ||||
| 1794 | if (cpi->sf.default_interp_filter == BILINEAR3) { | ||||
| 1795 | best_pickmode.best_pred_filter = BILINEAR3; | ||||
| 1796 | filter_gf_svc = BILINEAR3; | ||||
| 1797 | } | ||||
| 1798 | if (cpi->use_svc
| ||||
| 1799 | int layer = | ||||
| 1800 | LAYER_IDS_TO_IDX(svc->spatial_layer_id - 1, svc->temporal_layer_id,((svc->spatial_layer_id - 1) * (svc->number_temporal_layers ) + (svc->temporal_layer_id)) | ||||
| 1801 | svc->number_temporal_layers)((svc->spatial_layer_id - 1) * (svc->number_temporal_layers ) + (svc->temporal_layer_id)); | ||||
| 1802 | LAYER_CONTEXT *const lc = &svc->layer_context[layer]; | ||||
| 1803 | if (lc->scaling_factor_num == lc->scaling_factor_den) no_scaling = 1; | ||||
| 1804 | } | ||||
| 1805 | if (svc->spatial_layer_id > 0 && | ||||
| 1806 | (svc->high_source_sad_superframe || no_scaling)) | ||||
| 1807 | thresh_svc_skip_golden = 0; | ||||
| 1808 | // Lower the skip threshold if lower spatial layer is better quality relative | ||||
| 1809 | // to current layer. | ||||
| 1810 | else if (svc->spatial_layer_id
| ||||
| 1811 | cm->base_qindex > svc->lower_layer_qindex + 15) | ||||
| 1812 | thresh_svc_skip_golden = 100; | ||||
| 1813 | // Increase skip threshold if lower spatial layer is lower quality relative | ||||
| 1814 | // to current layer. | ||||
| 1815 | else if (svc->spatial_layer_id
| ||||
| 1816 | cm->base_qindex < svc->lower_layer_qindex - 20) | ||||
| 1817 | thresh_svc_skip_golden = 1000; | ||||
| 1818 | |||||
| 1819 | if (!cpi->use_svc
| ||||
| 1820 | (svc->use_gf_temporal_ref_current_layer && | ||||
| 1821 | !svc->layer_context[svc->temporal_layer_id].is_key_frame)) { | ||||
| 1822 | struct scale_factors *const sf_last = &cm->frame_refs[LAST_FRAME1 - 1].sf; | ||||
| 1823 | struct scale_factors *const sf_golden = | ||||
| 1824 | &cm->frame_refs[GOLDEN_FRAME2 - 1].sf; | ||||
| 1825 | gf_temporal_ref = 1; | ||||
| 1826 | // For temporal long term prediction, check that the golden reference | ||||
| 1827 | // is same scale as last reference, otherwise disable. | ||||
| 1828 | if ((sf_last->x_scale_fp != sf_golden->x_scale_fp) || | ||||
| 1829 | (sf_last->y_scale_fp != sf_golden->y_scale_fp)) { | ||||
| 1830 | gf_temporal_ref = 0; | ||||
| 1831 | } else { | ||||
| 1832 | if (cpi->rc.avg_frame_low_motion > 70) | ||||
| 1833 | thresh_svc_skip_golden = 500; | ||||
| 1834 | else | ||||
| 1835 | thresh_svc_skip_golden = 0; | ||||
| 1836 | } | ||||
| 1837 | } | ||||
| 1838 | |||||
| 1839 | init_ref_frame_cost(cm, xd, ref_frame_cost); | ||||
| 1840 | memset(&mode_checked[0][0], 0, MB_MODE_COUNT14 * MAX_REF_FRAMES4); | ||||
| 1841 | |||||
| 1842 | if (reuse_inter_pred
| ||||
| 1843 | int i; | ||||
| 1844 | for (i = 0; i < 3; i++) { | ||||
| 1845 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 1846 | if (cm->use_highbitdepth) | ||||
| 1847 | tmp[i].data = CONVERT_TO_BYTEPTR(&pred_buf_16[pixels_in_block * i]); | ||||
| 1848 | else | ||||
| 1849 | tmp[i].data = &pred_buf[pixels_in_block * i]; | ||||
| 1850 | #else | ||||
| 1851 | tmp[i].data = &pred_buf[pixels_in_block * i]; | ||||
| 1852 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 1853 | tmp[i].stride = bw; | ||||
| 1854 | tmp[i].in_use = 0; | ||||
| 1855 | } | ||||
| 1856 | tmp[3].data = pd->dst.buf; | ||||
| 1857 | tmp[3].stride = pd->dst.stride; | ||||
| 1858 | tmp[3].in_use = 0; | ||||
| 1859 | } | ||||
| 1860 | |||||
| 1861 | x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH115; | ||||
| 1862 | x->skip = 0; | ||||
| 1863 | |||||
| 1864 | if (cpi->sf.cb_pred_filter_search) { | ||||
| 1865 | const int bsl = mi_width_log2_lookup[bsize]; | ||||
| 1866 | pred_filter_search = cm->interp_filter == SWITCHABLE4 | ||||
| 1867 | ? (((mi_row + mi_col) >> bsl) + | ||||
| 1868 | get_chessboard_index(cm->current_video_frame)) & | ||||
| 1869 | 0x1 | ||||
| 1870 | : 0; | ||||
| 1871 | } | ||||
| 1872 | // Instead of using vp9_get_pred_context_switchable_interp(xd) to assign | ||||
| 1873 | // filter_ref, we use a less strict condition on assigning filter_ref. | ||||
| 1874 | // This is to reduce the probabily of entering the flow of not assigning | ||||
| 1875 | // filter_ref and then skip filter search. | ||||
| 1876 | filter_ref = cm->interp_filter; | ||||
| 1877 | if (cpi->sf.default_interp_filter
| ||||
| 1878 | if (xd->above_mi
| ||||
| 1879 | filter_ref = xd->above_mi->interp_filter; | ||||
| 1880 | else if (xd->left_mi
| ||||
| 1881 | filter_ref = xd->left_mi->interp_filter; | ||||
| 1882 | } | ||||
| 1883 | |||||
| 1884 | // initialize mode decisions | ||||
| 1885 | vp9_rd_cost_reset(&best_rdc); | ||||
| 1886 | vp9_rd_cost_reset(rd_cost); | ||||
| 1887 | mi->sb_type = bsize; | ||||
| 1888 | mi->ref_frame[0] = NO_REF_FRAME(-1); | ||||
| 1889 | mi->ref_frame[1] = NO_REF_FRAME(-1); | ||||
| 1890 | |||||
| 1891 | mi->tx_size = | ||||
| 1892 | VPXMIN(max_txsize_lookup[bsize], tx_mode_to_biggest_tx_size[cm->tx_mode])(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cm->tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cm->tx_mode])); | ||||
| 1893 | |||||
| 1894 | if (sf->short_circuit_flat_blocks || sf->limit_newmv_early_exit) { | ||||
| 1895 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 1896 | if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH8) | ||||
| 1897 | x->source_variance = vp9_high_get_sby_perpixel_variance( | ||||
| 1898 | cpi, &x->plane[0].src, bsize, xd->bd); | ||||
| 1899 | else | ||||
| 1900 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 1901 | x->source_variance = | ||||
| 1902 | vp9_get_sby_perpixel_variance(cpi, &x->plane[0].src, bsize); | ||||
| 1903 | |||||
| 1904 | if (cpi->oxcf.content == VP9E_CONTENT_SCREEN && | ||||
| 1905 | cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && mi->segment_id > 0 && | ||||
| 1906 | x->zero_temp_sad_source && x->source_variance == 0) { | ||||
| 1907 | mi->segment_id = 0; | ||||
| 1908 | vp9_init_plane_quantizers(cpi, x); | ||||
| 1909 | } | ||||
| 1910 | } | ||||
| 1911 | |||||
| 1912 | #if CONFIG_VP9_TEMPORAL_DENOISING0 | ||||
| 1913 | if (cpi->oxcf.noise_sensitivity > 0) { | ||||
| 1914 | if (cpi->use_svc) denoise_svc_pickmode = vp9_denoise_svc_non_key(cpi); | ||||
| 1915 | if (cpi->denoiser.denoising_level > kDenLowLow && denoise_svc_pickmode) | ||||
| 1916 | vp9_denoiser_reset_frame_stats(ctx); | ||||
| 1917 | } | ||||
| 1918 | #endif | ||||
| 1919 | |||||
| 1920 | if (cpi->rc.frames_since_golden == 0 && gf_temporal_ref && | ||||
| 1921 | !cpi->rc.alt_ref_gf_group && !cpi->rc.last_frame_is_src_altref) { | ||||
| 1922 | usable_ref_frame = LAST_FRAME1; | ||||
| 1923 | } else { | ||||
| 1924 | usable_ref_frame = GOLDEN_FRAME2; | ||||
| 1925 | } | ||||
| 1926 | |||||
| 1927 | if (cpi->oxcf.lag_in_frames > 0 && cpi->oxcf.rc_mode == VPX_VBR) { | ||||
| 1928 | if (cpi->rc.alt_ref_gf_group || cpi->rc.is_src_frame_alt_ref) | ||||
| 1929 | usable_ref_frame = ALTREF_FRAME3; | ||||
| 1930 | |||||
| 1931 | if (cpi->rc.is_src_frame_alt_ref) { | ||||
| 1932 | skip_ref_find_pred[LAST_FRAME1] = 1; | ||||
| 1933 | skip_ref_find_pred[GOLDEN_FRAME2] = 1; | ||||
| 1934 | } | ||||
| 1935 | if (!cm->show_frame) { | ||||
| 1936 | if (cpi->rc.frames_since_key == 1) { | ||||
| 1937 | usable_ref_frame = LAST_FRAME1; | ||||
| 1938 | skip_ref_find_pred[GOLDEN_FRAME2] = 1; | ||||
| 1939 | skip_ref_find_pred[ALTREF_FRAME3] = 1; | ||||
| 1940 | } | ||||
| 1941 | } | ||||
| 1942 | } | ||||
| 1943 | |||||
| 1944 | // For svc mode, on spatial_layer_id > 0: if the reference has different scale | ||||
| 1945 | // constrain the inter mode to only test zero motion. | ||||
| 1946 | if (cpi->use_svc
| ||||
| 1947 | svc->spatial_layer_id > 0 && !gf_temporal_ref) { | ||||
| 1948 | if (cpi->ref_frame_flags & VP9_LAST_FLAG) { | ||||
| 1949 | struct scale_factors *const ref_sf = &cm->frame_refs[LAST_FRAME1 - 1].sf; | ||||
| 1950 | if (vp9_is_scaled(ref_sf)) { | ||||
| 1951 | svc_force_zero_mode[LAST_FRAME1 - 1] = 1; | ||||
| 1952 | inter_layer_ref = LAST_FRAME1; | ||||
| 1953 | } | ||||
| 1954 | } | ||||
| 1955 | if (cpi->ref_frame_flags & VP9_GOLD_FLAG) { | ||||
| 1956 | struct scale_factors *const ref_sf = &cm->frame_refs[GOLDEN_FRAME2 - 1].sf; | ||||
| 1957 | if (vp9_is_scaled(ref_sf)) { | ||||
| 1958 | svc_force_zero_mode[GOLDEN_FRAME2 - 1] = 1; | ||||
| 1959 | inter_layer_ref = GOLDEN_FRAME2; | ||||
| 1960 | } | ||||
| 1961 | } | ||||
| 1962 | } | ||||
| 1963 | |||||
| 1964 | if (cpi->sf.short_circuit_low_temp_var) { | ||||
| 1965 | force_skip_low_temp_var = | ||||
| 1966 | get_force_skip_low_temp_var(&x->variance_low[0], mi_row, mi_col, bsize); | ||||
| 1967 | // If force_skip_low_temp_var is set, and for short circuit mode = 1 and 3, | ||||
| 1968 | // skip golden reference. | ||||
| 1969 | if ((cpi->sf.short_circuit_low_temp_var == 1 || | ||||
| 1970 | cpi->sf.short_circuit_low_temp_var == 3) && | ||||
| 1971 | force_skip_low_temp_var) { | ||||
| 1972 | usable_ref_frame = LAST_FRAME1; | ||||
| 1973 | } | ||||
| 1974 | } | ||||
| 1975 | |||||
| 1976 | if (sf->disable_golden_ref && (x->content_state_sb != kVeryHighSad || | ||||
| 1977 | cpi->rc.avg_frame_low_motion < 60)) | ||||
| 1978 | usable_ref_frame = LAST_FRAME1; | ||||
| 1979 | |||||
| 1980 | if (!((cpi->ref_frame_flags & VP9_GOLD_FLAG) && | ||||
| 1981 | !svc_force_zero_mode[GOLDEN_FRAME2 - 1] && !force_skip_low_temp_var)) | ||||
| 1982 | use_golden_nonzeromv = 0; | ||||
| 1983 | |||||
| 1984 | if (cpi->oxcf.speed >= 8 && !cpi->use_svc && | ||||
| 1985 | ((cpi->rc.frames_since_golden + 1) < x->last_sb_high_content || | ||||
| 1986 | x->last_sb_high_content > 40 || cpi->rc.frames_since_golden > 120)) | ||||
| 1987 | usable_ref_frame = LAST_FRAME1; | ||||
| 1988 | |||||
| 1989 | // Compound prediction modes: (0,0) on LAST/GOLDEN and ARF. | ||||
| 1990 | if (cm->reference_mode == REFERENCE_MODE_SELECT && | ||||
| 1991 | cpi->sf.use_compound_nonrd_pickmode && usable_ref_frame == ALTREF_FRAME3) | ||||
| 1992 | comp_modes = 2; | ||||
| 1993 | |||||
| 1994 | // If the segment reference frame feature is enabled and it's set to GOLDEN | ||||
| 1995 | // reference, then make sure we don't skip checking GOLDEN, this is to | ||||
| 1996 | // prevent possibility of not picking any mode. | ||||
| 1997 | if (segfeature_active(seg, mi->segment_id, SEG_LVL_REF_FRAME) && | ||||
| 1998 | get_segdata(seg, mi->segment_id, SEG_LVL_REF_FRAME) == GOLDEN_FRAME2) { | ||||
| 1999 | usable_ref_frame = GOLDEN_FRAME2; | ||||
| 2000 | skip_ref_find_pred[GOLDEN_FRAME2] = 0; | ||||
| 2001 | thresh_svc_skip_golden = 0; | ||||
| 2002 | } | ||||
| 2003 | |||||
| 2004 | for (ref_frame = LAST_FRAME1; ref_frame <= usable_ref_frame; ++ref_frame) { | ||||
| 2005 | // Skip find_predictor if the reference frame is not in the | ||||
| 2006 | // ref_frame_flags (i.e., not used as a reference for this frame). | ||||
| 2007 | skip_ref_find_pred[ref_frame] = | ||||
| 2008 | !(cpi->ref_frame_flags & ref_frame_to_flag(ref_frame)); | ||||
| 2009 | if (!skip_ref_find_pred[ref_frame]) { | ||||
| 2010 | find_predictors(cpi, x, ref_frame, frame_mv, const_motion, | ||||
| 2011 | &ref_frame_skip_mask, tile_data, mi_row, mi_col, yv12_mb, | ||||
| 2012 | bsize, force_skip_low_temp_var, comp_modes > 0); | ||||
| 2013 | } | ||||
| 2014 | } | ||||
| 2015 | |||||
| 2016 | if (cpi->use_svc
| ||||
| 2017 | x->sb_use_mv_part = 0; | ||||
| 2018 | |||||
| 2019 | // Set the flag_svc_subpel to 1 for SVC if the lower spatial layer used | ||||
| 2020 | // an averaging filter for downsampling (phase = 8). If so, we will test | ||||
| 2021 | // a nonzero motion mode on the spatial reference. | ||||
| 2022 | // The nonzero motion is half pixel shifted to left and top (-4, -4). | ||||
| 2023 | if (cpi->use_svc
| ||||
| 2024 | svc_force_zero_mode[inter_layer_ref - 1] && | ||||
| 2025 | svc->downsample_filter_phase[svc->spatial_layer_id - 1] == 8 && | ||||
| 2026 | !gf_temporal_ref) { | ||||
| 2027 | svc_mv_col = -4; | ||||
| 2028 | svc_mv_row = -4; | ||||
| 2029 | flag_svc_subpel = 1; | ||||
| 2030 | } | ||||
| 2031 | |||||
| 2032 | // For SVC with quality layers, when QP of lower layer is lower | ||||
| 2033 | // than current layer: force check of GF-ZEROMV before early exit | ||||
| 2034 | // due to skip flag. | ||||
| 2035 | if (svc->spatial_layer_id
| ||||
| 2036 | (cpi->ref_frame_flags & VP9_GOLD_FLAG) && | ||||
| 2037 | cm->base_qindex > svc->lower_layer_qindex + 10) | ||||
| 2038 | force_test_gf_zeromv = 1; | ||||
| 2039 | |||||
| 2040 | // For low motion content use x->sb_is_skin in addition to VeryHighSad | ||||
| 2041 | // for setting large_block. | ||||
| 2042 | large_block = (x->content_state_sb == kVeryHighSad || | ||||
| 2043 | (x->sb_is_skin && cpi->rc.avg_frame_low_motion > 70) || | ||||
| 2044 | cpi->oxcf.speed < 7) | ||||
| 2045 | ? bsize > BLOCK_32X329 | ||||
| 2046 | : bsize >= BLOCK_32X329; | ||||
| 2047 | use_model_yrd_large = | ||||
| 2048 | cpi->oxcf.rc_mode == VPX_CBR && large_block && | ||||
| 2049 | !cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id) && | ||||
| 2050 | cm->base_qindex; | ||||
| 2051 | |||||
| 2052 | for (idx = 0; idx < num_inter_modes + comp_modes; ++idx) { | ||||
| 2053 | int rate_mv = 0; | ||||
| 2054 | int mode_rd_thresh; | ||||
| 2055 | int mode_index; | ||||
| 2056 | int i; | ||||
| 2057 | int64_t this_sse; | ||||
| 2058 | int is_skippable; | ||||
| 2059 | int this_early_term = 0; | ||||
| 2060 | int rd_computed = 0; | ||||
| 2061 | int flag_preduv_computed[2] = { 0 }; | ||||
| 2062 | int inter_mv_mode = 0; | ||||
| 2063 | int skip_this_mv = 0; | ||||
| 2064 | int comp_pred = 0; | ||||
| 2065 | int force_mv_inter_layer = 0; | ||||
| 2066 | PREDICTION_MODE this_mode; | ||||
| 2067 | second_ref_frame = NO_REF_FRAME(-1); | ||||
| 2068 | |||||
| 2069 | if (idx
| ||||
| 2070 | this_mode = ref_mode_set[idx].pred_mode; | ||||
| 2071 | ref_frame = ref_mode_set[idx].ref_frame; | ||||
| 2072 | |||||
| 2073 | if (cpi->use_svc
| ||||
| 2074 | this_mode = ref_mode_set_svc[idx].pred_mode; | ||||
| 2075 | ref_frame = ref_mode_set_svc[idx].ref_frame; | ||||
| 2076 | } | ||||
| 2077 | } else { | ||||
| 2078 | // Add (0,0) compound modes. | ||||
| 2079 | this_mode = ZEROMV12; | ||||
| 2080 | ref_frame = LAST_FRAME1; | ||||
| 2081 | if (idx == num_inter_modes + comp_modes - 1) ref_frame = GOLDEN_FRAME2; | ||||
| 2082 | second_ref_frame = ALTREF_FRAME3; | ||||
| 2083 | comp_pred = 1; | ||||
| 2084 | } | ||||
| 2085 | |||||
| 2086 | if (ref_frame
| ||||
| 2087 | if (skip_ref_find_pred[ref_frame]) continue; | ||||
| 2088 | |||||
| 2089 | if (svc->previous_frame_is_intra_only
| ||||
| 2090 | if (ref_frame != LAST_FRAME1 || frame_mv[this_mode][ref_frame].as_int != 0) | ||||
| 2091 | continue; | ||||
| 2092 | } | ||||
| 2093 | |||||
| 2094 | // If the segment reference frame feature is enabled then do nothing if the | ||||
| 2095 | // current ref frame is not allowed. | ||||
| 2096 | if (segfeature_active(seg, mi->segment_id, SEG_LVL_REF_FRAME) && | ||||
| 2097 | get_segdata(seg, mi->segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame) | ||||
| 2098 | continue; | ||||
| 2099 | |||||
| 2100 | if (flag_svc_subpel
| ||||
| 2101 | force_mv_inter_layer = 1; | ||||
| 2102 | // Only test mode if NEARESTMV/NEARMV is (svc_mv_col, svc_mv_row), | ||||
| 2103 | // otherwise set NEWMV to (svc_mv_col, svc_mv_row). | ||||
| 2104 | if (this_mode == NEWMV13) { | ||||
| 2105 | frame_mv[this_mode][ref_frame].as_mv.col = svc_mv_col; | ||||
| 2106 | frame_mv[this_mode][ref_frame].as_mv.row = svc_mv_row; | ||||
| 2107 | } else if (frame_mv[this_mode][ref_frame].as_mv.col != svc_mv_col || | ||||
| 2108 | frame_mv[this_mode][ref_frame].as_mv.row != svc_mv_row) { | ||||
| 2109 | continue; | ||||
| 2110 | } | ||||
| 2111 | } | ||||
| 2112 | |||||
| 2113 | if (comp_pred
| ||||
| 2114 | if (!cpi->allow_comp_inter_inter) continue; | ||||
| 2115 | // Skip compound inter modes if ARF is not available. | ||||
| 2116 | if (!(cpi->ref_frame_flags & ref_frame_to_flag(second_ref_frame))) | ||||
| 2117 | continue; | ||||
| 2118 | // Do not allow compound prediction if the segment level reference frame | ||||
| 2119 | // feature is in use as in this case there can only be one reference. | ||||
| 2120 | if (segfeature_active(seg, mi->segment_id, SEG_LVL_REF_FRAME)) continue; | ||||
| 2121 | } | ||||
| 2122 | |||||
| 2123 | // For CBR mode: skip the golden reference search if sse of zeromv_last is | ||||
| 2124 | // below threshold. | ||||
| 2125 | if (ref_frame
| ||||
| 2126 | ((cpi->use_svc && sse_zeromv_normalized < thresh_svc_skip_golden) || | ||||
| 2127 | (!cpi->use_svc && sse_zeromv_normalized < thresh_skip_golden))) | ||||
| 2128 | continue; | ||||
| 2129 | |||||
| 2130 | if (!(cpi->ref_frame_flags & ref_frame_to_flag(ref_frame))) continue; | ||||
| 2131 | |||||
| 2132 | // For screen content. If zero_temp_sad source is computed: skip | ||||
| 2133 | // non-zero motion check for stationary blocks. If the superblock is | ||||
| 2134 | // non-stationary then for flat blocks skip the zero last check (keep golden | ||||
| 2135 | // as it may be inter-layer reference). Otherwise (if zero_temp_sad_source | ||||
| 2136 | // is not computed) skip non-zero motion check for flat blocks. | ||||
| 2137 | // TODO(marpan): Compute zero_temp_sad_source per coding block. | ||||
| 2138 | if (cpi->oxcf.content
| ||||
| 2139 | if (cpi->compute_source_sad_onepass
| ||||
| 2140 | if ((frame_mv[this_mode][ref_frame].as_int != 0 && | ||||
| 2141 | x->zero_temp_sad_source) || | ||||
| 2142 | (frame_mv[this_mode][ref_frame].as_int == 0 && | ||||
| 2143 | x->source_variance == 0 && ref_frame == LAST_FRAME1 && | ||||
| 2144 | !x->zero_temp_sad_source)) | ||||
| 2145 | continue; | ||||
| 2146 | } else if (frame_mv[this_mode][ref_frame].as_int
| ||||
| |||||
| 2147 | x->source_variance == 0) { | ||||
| 2148 | continue; | ||||
| 2149 | } | ||||
| 2150 | } | ||||
| 2151 | |||||
| 2152 | if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode))) continue; | ||||
| 2153 | |||||
| 2154 | if (cpi->oxcf.lag_in_frames > 0 && cpi->oxcf.rc_mode == VPX_VBR) { | ||||
| 2155 | if (cpi->rc.is_src_frame_alt_ref && | ||||
| 2156 | (ref_frame != ALTREF_FRAME3 || | ||||
| 2157 | frame_mv[this_mode][ref_frame].as_int != 0)) | ||||
| 2158 | continue; | ||||
| 2159 | |||||
| 2160 | if (!cm->show_frame && ref_frame == ALTREF_FRAME3 && | ||||
| 2161 | frame_mv[this_mode][ref_frame].as_int != 0) | ||||
| 2162 | continue; | ||||
| 2163 | |||||
| 2164 | if (cpi->rc.alt_ref_gf_group && cm->show_frame && | ||||
| 2165 | cpi->rc.frames_since_golden > (cpi->rc.baseline_gf_interval >> 1) && | ||||
| 2166 | ref_frame == GOLDEN_FRAME2 && | ||||
| 2167 | frame_mv[this_mode][ref_frame].as_int != 0) | ||||
| 2168 | continue; | ||||
| 2169 | |||||
| 2170 | if (cpi->rc.alt_ref_gf_group && cm->show_frame && | ||||
| 2171 | cpi->rc.frames_since_golden > 0 && | ||||
| 2172 | cpi->rc.frames_since_golden < (cpi->rc.baseline_gf_interval >> 1) && | ||||
| 2173 | ref_frame == ALTREF_FRAME3 && | ||||
| 2174 | frame_mv[this_mode][ref_frame].as_int != 0) | ||||
| 2175 | continue; | ||||
| 2176 | } | ||||
| 2177 | |||||
| 2178 | if (const_motion[ref_frame] && this_mode == NEARMV11) continue; | ||||
| 2179 | |||||
| 2180 | // Skip non-zeromv mode search for golden frame if force_skip_low_temp_var | ||||
| 2181 | // is set. If nearestmv for golden frame is 0, zeromv mode will be skipped | ||||
| 2182 | // later. | ||||
| 2183 | if (!force_mv_inter_layer && force_skip_low_temp_var && | ||||
| 2184 | ref_frame == GOLDEN_FRAME2 && | ||||
| 2185 | frame_mv[this_mode][ref_frame].as_int != 0) { | ||||
| 2186 | continue; | ||||
| 2187 | } | ||||
| 2188 | |||||
| 2189 | if (x->content_state_sb != kVeryHighSad && | ||||
| 2190 | (cpi->sf.short_circuit_low_temp_var >= 2 || | ||||
| 2191 | (cpi->sf.short_circuit_low_temp_var == 1 && bsize == BLOCK_64X6412)) && | ||||
| 2192 | force_skip_low_temp_var && ref_frame == LAST_FRAME1 && | ||||
| 2193 | this_mode == NEWMV13) { | ||||
| 2194 | continue; | ||||
| 2195 | } | ||||
| 2196 | |||||
| 2197 | if (cpi->use_svc) { | ||||
| 2198 | if (!force_mv_inter_layer && svc_force_zero_mode[ref_frame - 1] && | ||||
| 2199 | frame_mv[this_mode][ref_frame].as_int != 0) | ||||
| 2200 | continue; | ||||
| 2201 | } | ||||
| 2202 | |||||
| 2203 | // Disable this drop out case if the ref frame segment level feature is | ||||
| 2204 | // enabled for this segment. This is to prevent the possibility that we end | ||||
| 2205 | // up unable to pick any mode. | ||||
| 2206 | if (!segfeature_active(seg, mi->segment_id, SEG_LVL_REF_FRAME)) { | ||||
| 2207 | if (sf->reference_masking && | ||||
| 2208 | !(frame_mv[this_mode][ref_frame].as_int == 0 && | ||||
| 2209 | ref_frame == LAST_FRAME1)) { | ||||
| 2210 | if (usable_ref_frame < ALTREF_FRAME3) { | ||||
| 2211 | if (!force_skip_low_temp_var && usable_ref_frame > LAST_FRAME1) { | ||||
| 2212 | i = (ref_frame == LAST_FRAME1) ? GOLDEN_FRAME2 : LAST_FRAME1; | ||||
| 2213 | if ((cpi->ref_frame_flags & ref_frame_to_flag(i))) | ||||
| 2214 | if (x->pred_mv_sad[i] < INT_MAX2147483647) | ||||
| 2215 | if (x->pred_mv_sad[ref_frame] > (x->pred_mv_sad[i] << 1)) | ||||
| 2216 | ref_frame_skip_mask |= (1 << ref_frame); | ||||
| 2217 | } | ||||
| 2218 | } else if (!cpi->rc.is_src_frame_alt_ref && | ||||
| 2219 | !(frame_mv[this_mode][ref_frame].as_int == 0 && | ||||
| 2220 | ref_frame == ALTREF_FRAME3)) { | ||||
| 2221 | int ref1 = (ref_frame == GOLDEN_FRAME2) ? LAST_FRAME1 : GOLDEN_FRAME2; | ||||
| 2222 | int ref2 = (ref_frame == ALTREF_FRAME3) ? LAST_FRAME1 : ALTREF_FRAME3; | ||||
| 2223 | if (((cpi->ref_frame_flags & ref_frame_to_flag(ref1)) && | ||||
| 2224 | x->pred_mv_sad[ref1] < INT_MAX2147483647 && | ||||
| 2225 | (x->pred_mv_sad[ref_frame] > (x->pred_mv_sad[ref1] << 1))) || | ||||
| 2226 | ((cpi->ref_frame_flags & ref_frame_to_flag(ref2)) && | ||||
| 2227 | x->pred_mv_sad[ref2] < INT_MAX2147483647 && | ||||
| 2228 | (x->pred_mv_sad[ref_frame] > (x->pred_mv_sad[ref2] << 1)))) | ||||
| 2229 | ref_frame_skip_mask |= (1 << ref_frame); | ||||
| 2230 | } | ||||
| 2231 | } | ||||
| 2232 | if (ref_frame_skip_mask & (1 << ref_frame)) continue; | ||||
| 2233 | } | ||||
| 2234 | |||||
| 2235 | // Select prediction reference frames. | ||||
| 2236 | for (i = 0; i < MAX_MB_PLANE3; i++) { | ||||
| 2237 | xd->plane[i].pre[0] = yv12_mb[ref_frame][i]; | ||||
| 2238 | if (comp_pred) xd->plane[i].pre[1] = yv12_mb[second_ref_frame][i]; | ||||
| 2239 | } | ||||
| 2240 | |||||
| 2241 | mi->ref_frame[0] = ref_frame; | ||||
| 2242 | mi->ref_frame[1] = second_ref_frame; | ||||
| 2243 | set_ref_ptrs(cm, xd, ref_frame, second_ref_frame); | ||||
| 2244 | |||||
| 2245 | mode_index = mode_idx[ref_frame][INTER_OFFSET(this_mode)((this_mode) - 10)]; | ||||
| 2246 | mode_rd_thresh = best_pickmode.best_mode_skip_txfm | ||||
| 2247 | ? rd_threshes[mode_index] << 1 | ||||
| 2248 | : rd_threshes[mode_index]; | ||||
| 2249 | |||||
| 2250 | // Increase mode_rd_thresh value for GOLDEN_FRAME for improved encoding | ||||
| 2251 | // speed with little/no subjective quality loss. | ||||
| 2252 | if (cpi->sf.bias_golden && ref_frame == GOLDEN_FRAME2 && | ||||
| 2253 | cpi->rc.frames_since_golden > 4) | ||||
| 2254 | mode_rd_thresh = mode_rd_thresh << 3; | ||||
| 2255 | |||||
| 2256 | if ((cpi->sf.adaptive_rd_thresh_row_mt && | ||||
| 2257 | rd_less_than_thresh_row_mt(best_rdc.rdcost, mode_rd_thresh, | ||||
| 2258 | &rd_thresh_freq_fact[mode_index])) || | ||||
| 2259 | (!cpi->sf.adaptive_rd_thresh_row_mt && | ||||
| 2260 | rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh, | ||||
| 2261 | &rd_thresh_freq_fact[mode_index]))) | ||||
| 2262 | if (frame_mv[this_mode][ref_frame].as_int != 0) continue; | ||||
| 2263 | |||||
| 2264 | if (this_mode == NEWMV13 && !force_mv_inter_layer) { | ||||
| 2265 | if (search_new_mv(cpi, x, frame_mv, ref_frame, gf_temporal_ref, bsize, | ||||
| 2266 | mi_row, mi_col, best_pred_sad, &rate_mv, best_sse_sofar, | ||||
| 2267 | &best_rdc)) | ||||
| 2268 | continue; | ||||
| 2269 | } | ||||
| 2270 | |||||
| 2271 | // TODO(jianj): Skipping the testing of (duplicate) non-zero motion vector | ||||
| 2272 | // causes some regression, leave it for duplicate zero-mv for now, until | ||||
| 2273 | // regression issue is resolved. | ||||
| 2274 | for (inter_mv_mode = NEARESTMV10; inter_mv_mode <= NEWMV13; inter_mv_mode++) { | ||||
| 2275 | if (inter_mv_mode == this_mode || comp_pred) continue; | ||||
| 2276 | if (mode_checked[inter_mv_mode][ref_frame] && | ||||
| 2277 | frame_mv[this_mode][ref_frame].as_int == | ||||
| 2278 | frame_mv[inter_mv_mode][ref_frame].as_int && | ||||
| 2279 | frame_mv[inter_mv_mode][ref_frame].as_int == 0) { | ||||
| 2280 | skip_this_mv = 1; | ||||
| 2281 | break; | ||||
| 2282 | } | ||||
| 2283 | } | ||||
| 2284 | |||||
| 2285 | if (skip_this_mv) continue; | ||||
| 2286 | |||||
| 2287 | // If use_golden_nonzeromv is false, NEWMV mode is skipped for golden, no | ||||
| 2288 | // need to compute best_pred_sad which is only used to skip golden NEWMV. | ||||
| 2289 | if (use_golden_nonzeromv && this_mode == NEWMV13 && ref_frame == LAST_FRAME1 && | ||||
| 2290 | frame_mv[NEWMV13][LAST_FRAME1].as_int != INVALID_MV0x80008000) { | ||||
| 2291 | struct buf_2d backup_yv12[MAX_MB_PLANE3] = { { 0, 0 } }; | ||||
| 2292 | const YV12_BUFFER_CONFIG *scaled_ref_frame = | ||||
| 2293 | vp9_get_scaled_ref_frame(cpi, ref_frame); | ||||
| 2294 | if (scaled_ref_frame) { | ||||
| 2295 | assert(scaled_ref_frame->y_width == cpi->Source->y_width &&((void) sizeof ((scaled_ref_frame->y_width == cpi->Source ->y_width && scaled_ref_frame->y_height == cpi-> Source->y_height) ? 1 : 0), __extension__ ({ if (scaled_ref_frame ->y_width == cpi->Source->y_width && scaled_ref_frame ->y_height == cpi->Source->y_height) ; else __assert_fail ("scaled_ref_frame->y_width == cpi->Source->y_width && scaled_ref_frame->y_height == cpi->Source->y_height" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 2296, __extension__ __PRETTY_FUNCTION__); })) | ||||
| 2296 | scaled_ref_frame->y_height == cpi->Source->y_height)((void) sizeof ((scaled_ref_frame->y_width == cpi->Source ->y_width && scaled_ref_frame->y_height == cpi-> Source->y_height) ? 1 : 0), __extension__ ({ if (scaled_ref_frame ->y_width == cpi->Source->y_width && scaled_ref_frame ->y_height == cpi->Source->y_height) ; else __assert_fail ("scaled_ref_frame->y_width == cpi->Source->y_width && scaled_ref_frame->y_height == cpi->Source->y_height" , "/root/firefox-clang/media/libvpx/libvpx/vp9/encoder/vp9_pickmode.c" , 2296, __extension__ __PRETTY_FUNCTION__); })); | ||||
| 2297 | // Swap out the reference frame for a version that's been scaled to | ||||
| 2298 | // match the resolution of the current frame, allowing the existing | ||||
| 2299 | // motion search code to be used without additional modifications. | ||||
| 2300 | for (i = 0; i < MAX_MB_PLANE3; i++) backup_yv12[i] = xd->plane[i].pre[0]; | ||||
| 2301 | vp9_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL((void*)0)); | ||||
| 2302 | } | ||||
| 2303 | const int pre_stride = xd->plane[0].pre[0].stride; | ||||
| 2304 | const uint8_t *const pre_buf = | ||||
| 2305 | xd->plane[0].pre[0].buf + | ||||
| 2306 | (frame_mv[NEWMV13][LAST_FRAME1].as_mv.row >> 3) * pre_stride + | ||||
| 2307 | (frame_mv[NEWMV13][LAST_FRAME1].as_mv.col >> 3); | ||||
| 2308 | best_pred_sad = cpi->fn_ptr[bsize].sdf( | ||||
| 2309 | x->plane[0].src.buf, x->plane[0].src.stride, pre_buf, pre_stride); | ||||
| 2310 | x->pred_mv_sad[LAST_FRAME1] = best_pred_sad; | ||||
| 2311 | if (scaled_ref_frame) { | ||||
| 2312 | for (i = 0; i < MAX_MB_PLANE3; i++) xd->plane[i].pre[0] = backup_yv12[i]; | ||||
| 2313 | } | ||||
| 2314 | } | ||||
| 2315 | |||||
| 2316 | if (this_mode != NEARESTMV10 && !comp_pred && | ||||
| 2317 | frame_mv[this_mode][ref_frame].as_int == | ||||
| 2318 | frame_mv[NEARESTMV10][ref_frame].as_int) | ||||
| 2319 | continue; | ||||
| 2320 | |||||
| 2321 | mi->mode = this_mode; | ||||
| 2322 | mi->mv[0].as_int = frame_mv[this_mode][ref_frame].as_int; | ||||
| 2323 | mi->mv[1].as_int = 0; | ||||
| 2324 | |||||
| 2325 | // Search for the best prediction filter type, when the resulting | ||||
| 2326 | // motion vector is at sub-pixel accuracy level for luma component, i.e., | ||||
| 2327 | // the last three bits are all zeros. | ||||
| 2328 | if (reuse_inter_pred) { | ||||
| 2329 | if (!this_mode_pred) { | ||||
| 2330 | this_mode_pred = &tmp[3]; | ||||
| 2331 | } else { | ||||
| 2332 | this_mode_pred = &tmp[get_pred_buffer(tmp, 3)]; | ||||
| 2333 | pd->dst.buf = this_mode_pred->data; | ||||
| 2334 | pd->dst.stride = bw; | ||||
| 2335 | } | ||||
| 2336 | } | ||||
| 2337 | |||||
| 2338 | if ((this_mode == NEWMV13 || filter_ref == SWITCHABLE4) && | ||||
| 2339 | pred_filter_search && | ||||
| 2340 | (ref_frame == LAST_FRAME1 || | ||||
| 2341 | (ref_frame == GOLDEN_FRAME2 && !force_mv_inter_layer && | ||||
| 2342 | (cpi->use_svc || cpi->oxcf.rc_mode == VPX_VBR))) && | ||||
| 2343 | (((mi->mv[0].as_mv.row | mi->mv[0].as_mv.col) & 0x07) != 0)) { | ||||
| 2344 | rd_computed = 1; | ||||
| 2345 | search_filter_ref(cpi, x, &this_rdc, mi_row, mi_col, tmp, bsize, | ||||
| 2346 | reuse_inter_pred, &this_mode_pred, &var_y, &sse_y, | ||||
| 2347 | force_smooth_filter, &this_early_term, | ||||
| 2348 | flag_preduv_computed, use_model_yrd_large); | ||||
| 2349 | } else { | ||||
| 2350 | mi->interp_filter = (filter_ref == SWITCHABLE4) ? EIGHTTAP0 : filter_ref; | ||||
| 2351 | |||||
| 2352 | if (cpi->use_svc && ref_frame == GOLDEN_FRAME2 && | ||||
| 2353 | svc_force_zero_mode[ref_frame - 1]) | ||||
| 2354 | mi->interp_filter = filter_gf_svc; | ||||
| 2355 | |||||
| 2356 | vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); | ||||
| 2357 | |||||
| 2358 | // For large partition blocks, extra testing is done. | ||||
| 2359 | if (use_model_yrd_large) { | ||||
| 2360 | rd_computed = 1; | ||||
| 2361 | model_rd_for_sb_y_large(cpi, bsize, x, xd, &this_rdc.rate, | ||||
| 2362 | &this_rdc.dist, &var_y, &sse_y, mi_row, mi_col, | ||||
| 2363 | &this_early_term, flag_preduv_computed); | ||||
| 2364 | } else { | ||||
| 2365 | rd_computed = 1; | ||||
| 2366 | model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist, | ||||
| 2367 | &var_y, &sse_y, 0); | ||||
| 2368 | } | ||||
| 2369 | // Save normalized sse (between current and last frame) for (0, 0) motion. | ||||
| 2370 | if (ref_frame == LAST_FRAME1 && | ||||
| 2371 | frame_mv[this_mode][ref_frame].as_int == 0) { | ||||
| 2372 | sse_zeromv_normalized = | ||||
| 2373 | sse_y >> (b_width_log2_lookup[bsize] + b_height_log2_lookup[bsize]); | ||||
| 2374 | } | ||||
| 2375 | if (sse_y < best_sse_sofar) best_sse_sofar = sse_y; | ||||
| 2376 | } | ||||
| 2377 | |||||
| 2378 | if (!this_early_term) { | ||||
| 2379 | this_sse = (int64_t)sse_y; | ||||
| 2380 | block_yrd(cpi, x, &this_rdc, &is_skippable, &this_sse, bsize, | ||||
| 2381 | VPXMIN(mi->tx_size, TX_16X16)(((mi->tx_size) < (((TX_SIZE)2))) ? (mi->tx_size) : ( ((TX_SIZE)2))), rd_computed, 0); | ||||
| 2382 | x->skip_txfm[0] = is_skippable; | ||||
| 2383 | if (is_skippable) { | ||||
| 2384 | this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1)(vp9_prob_cost[(1) ? 256 - (vp9_get_skip_prob(cm, xd)) : (vp9_get_skip_prob (cm, xd))]); | ||||
| 2385 | } else { | ||||
| 2386 | if (RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist)(((((int64_t)(this_rdc.rate)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((this_rdc.dist) << (x-> rddiv)) < | ||||
| 2387 | RDCOST(x->rdmult, x->rddiv, 0, this_sse)(((((int64_t)(0)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((this_sse) << (x->rddiv))) { | ||||
| 2388 | this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0)(vp9_prob_cost[(0) ? 256 - (vp9_get_skip_prob(cm, xd)) : (vp9_get_skip_prob (cm, xd))]); | ||||
| 2389 | } else { | ||||
| 2390 | this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1)(vp9_prob_cost[(1) ? 256 - (vp9_get_skip_prob(cm, xd)) : (vp9_get_skip_prob (cm, xd))]); | ||||
| 2391 | this_rdc.dist = this_sse; | ||||
| 2392 | x->skip_txfm[0] = SKIP_TXFM_AC_DC1; | ||||
| 2393 | } | ||||
| 2394 | } | ||||
| 2395 | |||||
| 2396 | if (cm->interp_filter == SWITCHABLE4) { | ||||
| 2397 | if ((mi->mv[0].as_mv.row | mi->mv[0].as_mv.col) & 0x07) | ||||
| 2398 | this_rdc.rate += vp9_get_switchable_rate(cpi, xd); | ||||
| 2399 | } | ||||
| 2400 | } else { | ||||
| 2401 | if (cm->interp_filter == SWITCHABLE4) { | ||||
| 2402 | if ((mi->mv[0].as_mv.row | mi->mv[0].as_mv.col) & 0x07) | ||||
| 2403 | this_rdc.rate += vp9_get_switchable_rate(cpi, xd); | ||||
| 2404 | } | ||||
| 2405 | this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1)(vp9_prob_cost[(1) ? 256 - (vp9_get_skip_prob(cm, xd)) : (vp9_get_skip_prob (cm, xd))]); | ||||
| 2406 | } | ||||
| 2407 | |||||
| 2408 | if (!this_early_term && | ||||
| 2409 | (x->color_sensitivity[0] || x->color_sensitivity[1])) { | ||||
| 2410 | RD_COST rdc_uv; | ||||
| 2411 | const BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]); | ||||
| 2412 | if (x->color_sensitivity[0] && !flag_preduv_computed[0]) { | ||||
| 2413 | vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, 1); | ||||
| 2414 | flag_preduv_computed[0] = 1; | ||||
| 2415 | } | ||||
| 2416 | if (x->color_sensitivity[1] && !flag_preduv_computed[1]) { | ||||
| 2417 | vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, 2); | ||||
| 2418 | flag_preduv_computed[1] = 1; | ||||
| 2419 | } | ||||
| 2420 | model_rd_for_sb_uv(cpi, uv_bsize, x, xd, &rdc_uv, &var_y, &sse_y, 1, 2); | ||||
| 2421 | this_rdc.rate += rdc_uv.rate; | ||||
| 2422 | this_rdc.dist += rdc_uv.dist; | ||||
| 2423 | } | ||||
| 2424 | |||||
| 2425 | this_rdc.rate += rate_mv; | ||||
| 2426 | this_rdc.rate += cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]] | ||||
| 2427 | [INTER_OFFSET(this_mode)((this_mode) - 10)]; | ||||
| 2428 | // TODO(marpan): Add costing for compound mode. | ||||
| 2429 | this_rdc.rate += ref_frame_cost[ref_frame]; | ||||
| 2430 | this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist)(((((int64_t)(this_rdc.rate)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((this_rdc.dist) << (x-> rddiv)); | ||||
| 2431 | |||||
| 2432 | // Bias against NEWMV that is very different from its neighbors, and bias | ||||
| 2433 | // to small motion-lastref for noisy input. | ||||
| 2434 | if (cpi->oxcf.rc_mode == VPX_CBR && cpi->oxcf.speed >= 5 && | ||||
| 2435 | cpi->oxcf.content != VP9E_CONTENT_SCREEN) { | ||||
| 2436 | vp9_NEWMV_diff_bias(&cpi->noise_estimate, xd, this_mode, &this_rdc, bsize, | ||||
| 2437 | frame_mv[this_mode][ref_frame].as_mv.row, | ||||
| 2438 | frame_mv[this_mode][ref_frame].as_mv.col, | ||||
| 2439 | ref_frame == LAST_FRAME1, x->lowvar_highsumdiff, | ||||
| 2440 | x->sb_is_skin); | ||||
| 2441 | } | ||||
| 2442 | |||||
| 2443 | // Skipping checking: test to see if this block can be reconstructed by | ||||
| 2444 | // prediction only. | ||||
| 2445 | if (cpi->allow_encode_breakout && !xd->lossless && !scene_change_detected && | ||||
| 2446 | !svc->high_num_blocks_with_motion) { | ||||
| 2447 | encode_breakout_test(cpi, x, bsize, mi_row, mi_col, ref_frame, this_mode, | ||||
| 2448 | var_y, sse_y, yv12_mb, &this_rdc.rate, | ||||
| 2449 | &this_rdc.dist, flag_preduv_computed); | ||||
| 2450 | if (x->skip) { | ||||
| 2451 | this_rdc.rate += rate_mv; | ||||
| 2452 | this_rdc.rdcost = | ||||
| 2453 | RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist)(((((int64_t)(this_rdc.rate)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((this_rdc.dist) << (x-> rddiv)); | ||||
| 2454 | } | ||||
| 2455 | } | ||||
| 2456 | |||||
| 2457 | // On spatially flat blocks for screne content: bias against zero-last | ||||
| 2458 | // if the sse_y is non-zero. Only on scene change or high motion frames. | ||||
| 2459 | if (cpi->oxcf.content == VP9E_CONTENT_SCREEN && | ||||
| 2460 | (scene_change_detected || svc->high_num_blocks_with_motion) && | ||||
| 2461 | ref_frame == LAST_FRAME1 && frame_mv[this_mode][ref_frame].as_int == 0 && | ||||
| 2462 | svc->spatial_layer_id == 0 && x->source_variance == 0 && sse_y > 0) { | ||||
| 2463 | this_rdc.rdcost = this_rdc.rdcost << 2; | ||||
| 2464 | } | ||||
| 2465 | |||||
| 2466 | #if CONFIG_VP9_TEMPORAL_DENOISING0 | ||||
| 2467 | if (cpi->oxcf.noise_sensitivity > 0 && denoise_svc_pickmode && | ||||
| 2468 | cpi->denoiser.denoising_level > kDenLowLow) { | ||||
| 2469 | vp9_denoiser_update_frame_stats(mi, sse_y, this_mode, ctx); | ||||
| 2470 | // Keep track of zero_last cost. | ||||
| 2471 | if (ref_frame == LAST_FRAME1 && frame_mv[this_mode][ref_frame].as_int == 0) | ||||
| 2472 | zero_last_cost_orig = this_rdc.rdcost; | ||||
| 2473 | } | ||||
| 2474 | #else | ||||
| 2475 | (void)ctx; | ||||
| 2476 | #endif | ||||
| 2477 | |||||
| 2478 | mode_checked[this_mode][ref_frame] = 1; | ||||
| 2479 | |||||
| 2480 | if (this_rdc.rdcost < best_rdc.rdcost || x->skip) { | ||||
| 2481 | best_rdc = this_rdc; | ||||
| 2482 | best_early_term = this_early_term; | ||||
| 2483 | best_pickmode.best_mode = this_mode; | ||||
| 2484 | best_pickmode.best_pred_filter = mi->interp_filter; | ||||
| 2485 | best_pickmode.best_tx_size = mi->tx_size; | ||||
| 2486 | best_pickmode.best_ref_frame = ref_frame; | ||||
| 2487 | best_pickmode.best_mode_skip_txfm = x->skip_txfm[0]; | ||||
| 2488 | best_pickmode.best_second_ref_frame = second_ref_frame; | ||||
| 2489 | |||||
| 2490 | if (reuse_inter_pred) { | ||||
| 2491 | free_pred_buffer(best_pickmode.best_pred); | ||||
| 2492 | best_pickmode.best_pred = this_mode_pred; | ||||
| 2493 | } | ||||
| 2494 | } else { | ||||
| 2495 | if (reuse_inter_pred) free_pred_buffer(this_mode_pred); | ||||
| 2496 | } | ||||
| 2497 | |||||
| 2498 | if (x->skip && | ||||
| 2499 | (!force_test_gf_zeromv || mode_checked[ZEROMV12][GOLDEN_FRAME2])) | ||||
| 2500 | break; | ||||
| 2501 | |||||
| 2502 | // If early termination flag is 1 and at least 2 modes are checked, | ||||
| 2503 | // the mode search is terminated. | ||||
| 2504 | if (best_early_term && idx > 0 && !scene_change_detected && | ||||
| 2505 | (!force_test_gf_zeromv || mode_checked[ZEROMV12][GOLDEN_FRAME2])) { | ||||
| 2506 | x->skip = 1; | ||||
| 2507 | break; | ||||
| 2508 | } | ||||
| 2509 | } | ||||
| 2510 | |||||
| 2511 | mi->mode = best_pickmode.best_mode; | ||||
| 2512 | mi->interp_filter = best_pickmode.best_pred_filter; | ||||
| 2513 | mi->tx_size = best_pickmode.best_tx_size; | ||||
| 2514 | mi->ref_frame[0] = best_pickmode.best_ref_frame; | ||||
| 2515 | mi->mv[0].as_int = | ||||
| 2516 | frame_mv[best_pickmode.best_mode][best_pickmode.best_ref_frame].as_int; | ||||
| 2517 | xd->mi[0]->bmi[0].as_mv[0].as_int = mi->mv[0].as_int; | ||||
| 2518 | x->skip_txfm[0] = best_pickmode.best_mode_skip_txfm; | ||||
| 2519 | mi->ref_frame[1] = best_pickmode.best_second_ref_frame; | ||||
| 2520 | |||||
| 2521 | // For spatial enhancemanent layer: perform intra prediction only if base | ||||
| 2522 | // layer is chosen as the reference. Always perform intra prediction if | ||||
| 2523 | // LAST is the only reference, or is_key_frame is set, or on base | ||||
| 2524 | // temporal layer. | ||||
| 2525 | if (svc->spatial_layer_id && !gf_temporal_ref) { | ||||
| 2526 | perform_intra_pred = | ||||
| 2527 | svc->temporal_layer_id == 0 || | ||||
| 2528 | svc->layer_context[svc->temporal_layer_id].is_key_frame || | ||||
| 2529 | !(cpi->ref_frame_flags & VP9_GOLD_FLAG) || | ||||
| 2530 | (!svc->layer_context[svc->temporal_layer_id].is_key_frame && | ||||
| 2531 | svc_force_zero_mode[best_pickmode.best_ref_frame - 1]); | ||||
| 2532 | inter_mode_thresh = (inter_mode_thresh << 1) + inter_mode_thresh; | ||||
| 2533 | } | ||||
| 2534 | if ((cpi->oxcf.lag_in_frames > 0 && cpi->oxcf.rc_mode == VPX_VBR && | ||||
| 2535 | cpi->rc.is_src_frame_alt_ref) || | ||||
| 2536 | svc->previous_frame_is_intra_only) | ||||
| 2537 | perform_intra_pred = 0; | ||||
| 2538 | |||||
| 2539 | // If the segment reference frame feature is enabled and set then | ||||
| 2540 | // skip the intra prediction. | ||||
| 2541 | if (segfeature_active(seg, mi->segment_id, SEG_LVL_REF_FRAME) && | ||||
| 2542 | get_segdata(seg, mi->segment_id, SEG_LVL_REF_FRAME) > 0) | ||||
| 2543 | perform_intra_pred = 0; | ||||
| 2544 | |||||
| 2545 | // Perform intra prediction search, if the best SAD is above a certain | ||||
| 2546 | // threshold. | ||||
| 2547 | if (best_rdc.rdcost == INT64_MAX(9223372036854775807L) || | ||||
| 2548 | (cpi->oxcf.content == VP9E_CONTENT_SCREEN && x->source_variance == 0) || | ||||
| 2549 | (scene_change_detected && perform_intra_pred) || | ||||
| 2550 | ((!force_skip_low_temp_var || bsize < BLOCK_32X329 || | ||||
| 2551 | x->content_state_sb == kVeryHighSad) && | ||||
| 2552 | perform_intra_pred && !x->skip && best_rdc.rdcost > inter_mode_thresh && | ||||
| 2553 | bsize <= cpi->sf.max_intra_bsize && !x->skip_low_source_sad && | ||||
| 2554 | !x->lowvar_highsumdiff)) { | ||||
| 2555 | struct estimate_block_intra_args args = { cpi, x, DC_PRED0, 1, 0 }; | ||||
| 2556 | int64_t this_sse = INT64_MAX(9223372036854775807L); | ||||
| 2557 | int i; | ||||
| 2558 | PRED_BUFFER *const best_pred = best_pickmode.best_pred; | ||||
| 2559 | TX_SIZE intra_tx_size = | ||||
| 2560 | VPXMIN(max_txsize_lookup[bsize],(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) | ||||
| 2561 | tx_mode_to_biggest_tx_size[cpi->common.tx_mode])(((max_txsize_lookup[bsize]) < (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])) ? (max_txsize_lookup[bsize]) : (tx_mode_to_biggest_tx_size [cpi->common.tx_mode])); | ||||
| 2562 | |||||
| 2563 | if (reuse_inter_pred && best_pred != NULL((void*)0)) { | ||||
| 2564 | if (best_pred->data == orig_dst.buf) { | ||||
| 2565 | this_mode_pred = &tmp[get_pred_buffer(tmp, 3)]; | ||||
| 2566 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 2567 | if (cm->use_highbitdepth) | ||||
| 2568 | vpx_highbd_convolve_copy( | ||||
| 2569 | CONVERT_TO_SHORTPTR(best_pred->data)((uint16_t *)(((uintptr_t)(best_pred->data)) << 1)), best_pred->stride, | ||||
| 2570 | CONVERT_TO_SHORTPTR(this_mode_pred->data)((uint16_t *)(((uintptr_t)(this_mode_pred->data)) << 1)), this_mode_pred->stride, | ||||
| 2571 | NULL((void*)0), 0, 0, 0, 0, bw, bh, xd->bd); | ||||
| 2572 | else | ||||
| 2573 | vpx_convolve_copyvpx_convolve_copy_sse2(best_pred->data, best_pred->stride, | ||||
| 2574 | this_mode_pred->data, this_mode_pred->stride, NULL((void*)0), | ||||
| 2575 | 0, 0, 0, 0, bw, bh); | ||||
| 2576 | #else | ||||
| 2577 | vpx_convolve_copyvpx_convolve_copy_sse2(best_pred->data, best_pred->stride, | ||||
| 2578 | this_mode_pred->data, this_mode_pred->stride, NULL((void*)0), 0, | ||||
| 2579 | 0, 0, 0, bw, bh); | ||||
| 2580 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 2581 | best_pickmode.best_pred = this_mode_pred; | ||||
| 2582 | } | ||||
| 2583 | } | ||||
| 2584 | pd->dst = orig_dst; | ||||
| 2585 | |||||
| 2586 | for (i = 0; i < 4; ++i) { | ||||
| 2587 | const PREDICTION_MODE this_mode = intra_mode_list[i]; | ||||
| 2588 | THR_MODES mode_index = mode_idx[INTRA_FRAME0][mode_offset(this_mode)]; | ||||
| 2589 | int mode_rd_thresh = rd_threshes[mode_index]; | ||||
| 2590 | // For spatially flat blocks, under short_circuit_flat_blocks flag: | ||||
| 2591 | // only check DC mode for stationary blocks, otherwise also check | ||||
| 2592 | // H and V mode. | ||||
| 2593 | if (sf->short_circuit_flat_blocks && x->source_variance == 0 && | ||||
| 2594 | ((x->zero_temp_sad_source && this_mode != DC_PRED0) || i > 2)) { | ||||
| 2595 | continue; | ||||
| 2596 | } | ||||
| 2597 | |||||
| 2598 | if (!((1 << this_mode) & cpi->sf.intra_y_mode_bsize_mask[bsize])) | ||||
| 2599 | continue; | ||||
| 2600 | |||||
| 2601 | if (cpi->sf.rt_intra_dc_only_low_content && this_mode != DC_PRED0 && | ||||
| 2602 | x->content_state_sb != kVeryHighSad) | ||||
| 2603 | continue; | ||||
| 2604 | |||||
| 2605 | if ((cpi->sf.adaptive_rd_thresh_row_mt && | ||||
| 2606 | rd_less_than_thresh_row_mt(best_rdc.rdcost, mode_rd_thresh, | ||||
| 2607 | &rd_thresh_freq_fact[mode_index])) || | ||||
| 2608 | (!cpi->sf.adaptive_rd_thresh_row_mt && | ||||
| 2609 | rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh, | ||||
| 2610 | &rd_thresh_freq_fact[mode_index]))) { | ||||
| 2611 | // Avoid this early exit for screen on base layer, for scene | ||||
| 2612 | // changes or high motion frames. | ||||
| 2613 | if (cpi->oxcf.content != VP9E_CONTENT_SCREEN || | ||||
| 2614 | svc->spatial_layer_id > 0 || | ||||
| 2615 | (!scene_change_detected && !svc->high_num_blocks_with_motion)) | ||||
| 2616 | continue; | ||||
| 2617 | } | ||||
| 2618 | |||||
| 2619 | mi->mode = this_mode; | ||||
| 2620 | mi->ref_frame[0] = INTRA_FRAME0; | ||||
| 2621 | this_rdc.dist = this_rdc.rate = 0; | ||||
| 2622 | args.mode = this_mode; | ||||
| 2623 | args.skippable = 1; | ||||
| 2624 | args.rdc = &this_rdc; | ||||
| 2625 | mi->tx_size = intra_tx_size; | ||||
| 2626 | |||||
| 2627 | compute_intra_yprediction(this_mode, bsize, x, xd); | ||||
| 2628 | model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist, | ||||
| 2629 | &var_y, &sse_y, 1); | ||||
| 2630 | block_yrd(cpi, x, &this_rdc, &args.skippable, &this_sse, bsize, | ||||
| 2631 | VPXMIN(mi->tx_size, TX_16X16)(((mi->tx_size) < (((TX_SIZE)2))) ? (mi->tx_size) : ( ((TX_SIZE)2))), 1, 1); | ||||
| 2632 | |||||
| 2633 | // Check skip cost here since skippable is not set for for uv, this | ||||
| 2634 | // mirrors the behavior used by inter | ||||
| 2635 | if (args.skippable) { | ||||
| 2636 | x->skip_txfm[0] = SKIP_TXFM_AC_DC1; | ||||
| 2637 | this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 1)(vp9_prob_cost[(1) ? 256 - (vp9_get_skip_prob(&cpi->common , xd)) : (vp9_get_skip_prob(&cpi->common, xd))]); | ||||
| 2638 | } else { | ||||
| 2639 | x->skip_txfm[0] = SKIP_TXFM_NONE0; | ||||
| 2640 | this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 0)(vp9_prob_cost[(0) ? 256 - (vp9_get_skip_prob(&cpi->common , xd)) : (vp9_get_skip_prob(&cpi->common, xd))]); | ||||
| 2641 | } | ||||
| 2642 | // Inter and intra RD will mismatch in scale for non-screen content. | ||||
| 2643 | if (cpi->oxcf.content == VP9E_CONTENT_SCREEN) { | ||||
| 2644 | if (x->color_sensitivity[0]) | ||||
| 2645 | vp9_foreach_transformed_block_in_plane(xd, bsize, 1, | ||||
| 2646 | estimate_block_intra, &args); | ||||
| 2647 | if (x->color_sensitivity[1]) | ||||
| 2648 | vp9_foreach_transformed_block_in_plane(xd, bsize, 2, | ||||
| 2649 | estimate_block_intra, &args); | ||||
| 2650 | } | ||||
| 2651 | this_rdc.rate += cpi->mbmode_cost[this_mode]; | ||||
| 2652 | this_rdc.rate += ref_frame_cost[INTRA_FRAME0]; | ||||
| 2653 | this_rdc.rate += intra_cost_penalty; | ||||
| 2654 | this_rdc.rdcost = | ||||
| 2655 | RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist)(((((int64_t)(this_rdc.rate)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((this_rdc.dist) << (x-> rddiv)); | ||||
| 2656 | |||||
| 2657 | if (this_rdc.rdcost < best_rdc.rdcost) { | ||||
| 2658 | best_rdc = this_rdc; | ||||
| 2659 | best_pickmode.best_mode = this_mode; | ||||
| 2660 | best_pickmode.best_intra_tx_size = mi->tx_size; | ||||
| 2661 | best_pickmode.best_ref_frame = INTRA_FRAME0; | ||||
| 2662 | best_pickmode.best_second_ref_frame = NO_REF_FRAME(-1); | ||||
| 2663 | mi->uv_mode = this_mode; | ||||
| 2664 | mi->mv[0].as_int = INVALID_MV0x80008000; | ||||
| 2665 | mi->mv[1].as_int = INVALID_MV0x80008000; | ||||
| 2666 | best_pickmode.best_mode_skip_txfm = x->skip_txfm[0]; | ||||
| 2667 | } | ||||
| 2668 | } | ||||
| 2669 | |||||
| 2670 | // Reset mb_mode_info to the best inter mode. | ||||
| 2671 | if (best_pickmode.best_ref_frame != INTRA_FRAME0) { | ||||
| 2672 | mi->tx_size = best_pickmode.best_tx_size; | ||||
| 2673 | } else { | ||||
| 2674 | mi->tx_size = best_pickmode.best_intra_tx_size; | ||||
| 2675 | } | ||||
| 2676 | } | ||||
| 2677 | |||||
| 2678 | pd->dst = orig_dst; | ||||
| 2679 | mi->mode = best_pickmode.best_mode; | ||||
| 2680 | mi->ref_frame[0] = best_pickmode.best_ref_frame; | ||||
| 2681 | mi->ref_frame[1] = best_pickmode.best_second_ref_frame; | ||||
| 2682 | x->skip_txfm[0] = best_pickmode.best_mode_skip_txfm; | ||||
| 2683 | |||||
| 2684 | if (!is_inter_block(mi)) { | ||||
| 2685 | mi->interp_filter = SWITCHABLE_FILTERS3; | ||||
| 2686 | } | ||||
| 2687 | |||||
| 2688 | if (reuse_inter_pred && best_pickmode.best_pred != NULL((void*)0)) { | ||||
| 2689 | PRED_BUFFER *const best_pred = best_pickmode.best_pred; | ||||
| 2690 | if (best_pred->data != orig_dst.buf && is_inter_mode(mi->mode)) { | ||||
| 2691 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 2692 | if (cm->use_highbitdepth) | ||||
| 2693 | vpx_highbd_convolve_copy( | ||||
| 2694 | CONVERT_TO_SHORTPTR(best_pred->data)((uint16_t *)(((uintptr_t)(best_pred->data)) << 1)), best_pred->stride, | ||||
| 2695 | CONVERT_TO_SHORTPTR(pd->dst.buf)((uint16_t *)(((uintptr_t)(pd->dst.buf)) << 1)), pd->dst.stride, NULL((void*)0), 0, 0, 0, 0, | ||||
| 2696 | bw, bh, xd->bd); | ||||
| 2697 | else | ||||
| 2698 | vpx_convolve_copyvpx_convolve_copy_sse2(best_pred->data, best_pred->stride, pd->dst.buf, | ||||
| 2699 | pd->dst.stride, NULL((void*)0), 0, 0, 0, 0, bw, bh); | ||||
| 2700 | #else | ||||
| 2701 | vpx_convolve_copyvpx_convolve_copy_sse2(best_pred->data, best_pred->stride, pd->dst.buf, | ||||
| 2702 | pd->dst.stride, NULL((void*)0), 0, 0, 0, 0, bw, bh); | ||||
| 2703 | #endif // CONFIG_VP9_HIGHBITDEPTH | ||||
| 2704 | } | ||||
| 2705 | } | ||||
| 2706 | |||||
| 2707 | #if CONFIG_VP9_TEMPORAL_DENOISING0 | ||||
| 2708 | if (cpi->oxcf.noise_sensitivity > 0 && cpi->resize_pending == 0 && | ||||
| 2709 | denoise_svc_pickmode && cpi->denoiser.denoising_level > kDenLowLow && | ||||
| 2710 | cpi->denoiser.reset == 0) { | ||||
| 2711 | VP9_DENOISER_DECISION decision = COPY_BLOCK; | ||||
| 2712 | ctx->sb_skip_denoising = 0; | ||||
| 2713 | // TODO(marpan): There is an issue with denoising when the | ||||
| 2714 | // superblock partitioning scheme is based on the pickmode. | ||||
| 2715 | // Remove this condition when the issue is resolved. | ||||
| 2716 | if (x->sb_pickmode_part) ctx->sb_skip_denoising = 1; | ||||
| 2717 | vp9_pickmode_ctx_den_update(&ctx_den, zero_last_cost_orig, ref_frame_cost, | ||||
| 2718 | frame_mv, reuse_inter_pred, &best_pickmode); | ||||
| 2719 | vp9_denoiser_denoise(cpi, x, mi_row, mi_col, bsize, ctx, &decision, | ||||
| 2720 | gf_temporal_ref); | ||||
| 2721 | if (denoise_recheck_zeromv) | ||||
| 2722 | recheck_zeromv_after_denoising(cpi, mi, x, xd, decision, &ctx_den, | ||||
| 2723 | yv12_mb, &best_rdc, bsize, mi_row, mi_col); | ||||
| 2724 | best_pickmode.best_ref_frame = ctx_den.best_ref_frame; | ||||
| 2725 | } | ||||
| 2726 | #endif | ||||
| 2727 | |||||
| 2728 | if (best_pickmode.best_ref_frame == ALTREF_FRAME3 || | ||||
| 2729 | best_pickmode.best_second_ref_frame == ALTREF_FRAME3) | ||||
| 2730 | x->arf_frame_usage++; | ||||
| 2731 | else if (best_pickmode.best_ref_frame != INTRA_FRAME0) | ||||
| 2732 | x->lastgolden_frame_usage++; | ||||
| 2733 | |||||
| 2734 | if (cpi->sf.adaptive_rd_thresh) { | ||||
| 2735 | THR_MODES best_mode_idx = | ||||
| 2736 | mode_idx[best_pickmode.best_ref_frame][mode_offset(mi->mode)]; | ||||
| 2737 | |||||
| 2738 | if (best_pickmode.best_ref_frame == INTRA_FRAME0) { | ||||
| 2739 | // Only consider the modes that are included in the intra_mode_list. | ||||
| 2740 | int intra_modes = sizeof(intra_mode_list) / sizeof(PREDICTION_MODE); | ||||
| 2741 | int i; | ||||
| 2742 | |||||
| 2743 | // TODO(yunqingwang): Check intra mode mask and only update freq_fact | ||||
| 2744 | // for those valid modes. | ||||
| 2745 | for (i = 0; i < intra_modes; i++) { | ||||
| 2746 | if (cpi->sf.adaptive_rd_thresh_row_mt) | ||||
| 2747 | update_thresh_freq_fact_row_mt(cpi, tile_data, x->source_variance, | ||||
| 2748 | thresh_freq_fact_idx, INTRA_FRAME0, | ||||
| 2749 | best_mode_idx, intra_mode_list[i]); | ||||
| 2750 | else | ||||
| 2751 | update_thresh_freq_fact(cpi, tile_data, x->source_variance, bsize, | ||||
| 2752 | INTRA_FRAME0, best_mode_idx, | ||||
| 2753 | intra_mode_list[i]); | ||||
| 2754 | } | ||||
| 2755 | } else { | ||||
| 2756 | for (ref_frame = LAST_FRAME1; ref_frame <= GOLDEN_FRAME2; ++ref_frame) { | ||||
| 2757 | PREDICTION_MODE this_mode; | ||||
| 2758 | if (best_pickmode.best_ref_frame != ref_frame) continue; | ||||
| 2759 | for (this_mode = NEARESTMV10; this_mode <= NEWMV13; ++this_mode) { | ||||
| 2760 | if (cpi->sf.adaptive_rd_thresh_row_mt) | ||||
| 2761 | update_thresh_freq_fact_row_mt(cpi, tile_data, x->source_variance, | ||||
| 2762 | thresh_freq_fact_idx, ref_frame, | ||||
| 2763 | best_mode_idx, this_mode); | ||||
| 2764 | else | ||||
| 2765 | update_thresh_freq_fact(cpi, tile_data, x->source_variance, bsize, | ||||
| 2766 | ref_frame, best_mode_idx, this_mode); | ||||
| 2767 | } | ||||
| 2768 | } | ||||
| 2769 | } | ||||
| 2770 | } | ||||
| 2771 | |||||
| 2772 | *rd_cost = best_rdc; | ||||
| 2773 | } | ||||
| 2774 | |||||
| 2775 | void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x, int mi_row, | ||||
| 2776 | int mi_col, RD_COST *rd_cost, BLOCK_SIZE bsize, | ||||
| 2777 | PICK_MODE_CONTEXT *ctx) { | ||||
| 2778 | VP9_COMMON *const cm = &cpi->common; | ||||
| 2779 | SPEED_FEATURES *const sf = &cpi->sf; | ||||
| 2780 | MACROBLOCKD *const xd = &x->e_mbd; | ||||
| 2781 | MODE_INFO *const mi = xd->mi[0]; | ||||
| 2782 | MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext; | ||||
| 2783 | const struct segmentation *const seg = &cm->seg; | ||||
| 2784 | MV_REFERENCE_FRAME ref_frame, second_ref_frame = NO_REF_FRAME(-1); | ||||
| 2785 | MV_REFERENCE_FRAME best_ref_frame = NO_REF_FRAME(-1); | ||||
| 2786 | unsigned char segment_id = mi->segment_id; | ||||
| 2787 | struct buf_2d yv12_mb[4][MAX_MB_PLANE3]; | ||||
| 2788 | int64_t best_rd = INT64_MAX(9223372036854775807L); | ||||
| 2789 | b_mode_info bsi[MAX_REF_FRAMES4][4]; | ||||
| 2790 | int ref_frame_skip_mask = 0; | ||||
| 2791 | const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize]; | ||||
| 2792 | const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize]; | ||||
| 2793 | int idx, idy; | ||||
| 2794 | |||||
| 2795 | x->skip_encode = sf->skip_encode_frame && x->q_index < QIDX_SKIP_THRESH115; | ||||
| 2796 | ctx->pred_pixel_ready = 0; | ||||
| 2797 | |||||
| 2798 | for (ref_frame = LAST_FRAME1; ref_frame <= GOLDEN_FRAME2; ++ref_frame) { | ||||
| 2799 | const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame); | ||||
| 2800 | int_mv dummy_mv[2]; | ||||
| 2801 | x->pred_mv_sad[ref_frame] = INT_MAX2147483647; | ||||
| 2802 | |||||
| 2803 | if ((cpi->ref_frame_flags & ref_frame_to_flag(ref_frame)) && | ||||
| 2804 | (yv12 != NULL((void*)0))) { | ||||
| 2805 | int_mv *const candidates = mbmi_ext->ref_mvs[ref_frame]; | ||||
| 2806 | const struct scale_factors *const ref_sf = | ||||
| 2807 | &cm->frame_refs[ref_frame - 1].sf; | ||||
| 2808 | vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, ref_sf, | ||||
| 2809 | ref_sf); | ||||
| 2810 | vp9_find_mv_refs(cm, xd, xd->mi[0], ref_frame, candidates, mi_row, mi_col, | ||||
| 2811 | mbmi_ext->mode_context); | ||||
| 2812 | |||||
| 2813 | vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates, | ||||
| 2814 | &dummy_mv[0], &dummy_mv[1]); | ||||
| 2815 | } else { | ||||
| 2816 | ref_frame_skip_mask |= (1 << ref_frame); | ||||
| 2817 | } | ||||
| 2818 | } | ||||
| 2819 | |||||
| 2820 | mi->sb_type = bsize; | ||||
| 2821 | mi->tx_size = TX_4X4((TX_SIZE)0); | ||||
| 2822 | mi->uv_mode = DC_PRED0; | ||||
| 2823 | mi->ref_frame[0] = LAST_FRAME1; | ||||
| 2824 | mi->ref_frame[1] = NO_REF_FRAME(-1); | ||||
| 2825 | mi->interp_filter = | ||||
| 2826 | cm->interp_filter == SWITCHABLE4 ? EIGHTTAP0 : cm->interp_filter; | ||||
| 2827 | |||||
| 2828 | for (ref_frame = LAST_FRAME1; ref_frame <= GOLDEN_FRAME2; ++ref_frame) { | ||||
| 2829 | int64_t this_rd = 0; | ||||
| 2830 | int plane; | ||||
| 2831 | |||||
| 2832 | if (ref_frame_skip_mask & (1 << ref_frame)) continue; | ||||
| 2833 | |||||
| 2834 | #if CONFIG_BETTER_HW_COMPATIBILITY0 | ||||
| 2835 | if ((bsize == BLOCK_8X42 || bsize == BLOCK_4X81) && ref_frame > INTRA_FRAME0 && | ||||
| 2836 | vp9_is_scaled(&cm->frame_refs[ref_frame - 1].sf)) | ||||
| 2837 | continue; | ||||
| 2838 | #endif | ||||
| 2839 | |||||
| 2840 | // TODO(jingning, agrange): Scaling reference frame not supported for | ||||
| 2841 | // sub8x8 blocks. Is this supported now? | ||||
| 2842 | if (ref_frame > INTRA_FRAME0 && | ||||
| 2843 | vp9_is_scaled(&cm->frame_refs[ref_frame - 1].sf)) | ||||
| 2844 | continue; | ||||
| 2845 | |||||
| 2846 | // If the segment reference frame feature is enabled.... | ||||
| 2847 | // then do nothing if the current ref frame is not allowed.. | ||||
| 2848 | if (segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) && | ||||
| 2849 | get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame) | ||||
| 2850 | continue; | ||||
| 2851 | |||||
| 2852 | mi->ref_frame[0] = ref_frame; | ||||
| 2853 | x->skip = 0; | ||||
| 2854 | set_ref_ptrs(cm, xd, ref_frame, second_ref_frame); | ||||
| 2855 | |||||
| 2856 | // Select prediction reference frames. | ||||
| 2857 | for (plane = 0; plane < MAX_MB_PLANE3; plane++) | ||||
| 2858 | xd->plane[plane].pre[0] = yv12_mb[ref_frame][plane]; | ||||
| 2859 | |||||
| 2860 | for (idy = 0; idy < 2; idy += num_4x4_blocks_high) { | ||||
| 2861 | for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) { | ||||
| 2862 | int_mv b_mv[MB_MODE_COUNT14]; | ||||
| 2863 | int64_t b_best_rd = INT64_MAX(9223372036854775807L); | ||||
| 2864 | const int i = idy * 2 + idx; | ||||
| 2865 | PREDICTION_MODE this_mode; | ||||
| 2866 | RD_COST this_rdc; | ||||
| 2867 | unsigned int var_y, sse_y; | ||||
| 2868 | |||||
| 2869 | struct macroblock_plane *p = &x->plane[0]; | ||||
| 2870 | struct macroblockd_plane *pd = &xd->plane[0]; | ||||
| 2871 | |||||
| 2872 | const struct buf_2d orig_src = p->src; | ||||
| 2873 | const struct buf_2d orig_dst = pd->dst; | ||||
| 2874 | struct buf_2d orig_pre[2]; | ||||
| 2875 | memcpy(orig_pre, xd->plane[0].pre, sizeof(orig_pre)); | ||||
| 2876 | |||||
| 2877 | // set buffer pointers for sub8x8 motion search. | ||||
| 2878 | p->src.buf = | ||||
| 2879 | &p->src.buf[vp9_raster_block_offset(BLOCK_8X83, i, p->src.stride)]; | ||||
| 2880 | pd->dst.buf = | ||||
| 2881 | &pd->dst.buf[vp9_raster_block_offset(BLOCK_8X83, i, pd->dst.stride)]; | ||||
| 2882 | pd->pre[0].buf = | ||||
| 2883 | &pd->pre[0] | ||||
| 2884 | .buf[vp9_raster_block_offset(BLOCK_8X83, i, pd->pre[0].stride)]; | ||||
| 2885 | |||||
| 2886 | b_mv[ZEROMV12].as_int = 0; | ||||
| 2887 | b_mv[NEWMV13].as_int = INVALID_MV0x80008000; | ||||
| 2888 | vp9_append_sub8x8_mvs_for_idx(cm, xd, i, 0, mi_row, mi_col, | ||||
| 2889 | &b_mv[NEARESTMV10], &b_mv[NEARMV11], | ||||
| 2890 | mbmi_ext->mode_context); | ||||
| 2891 | |||||
| 2892 | for (this_mode = NEARESTMV10; this_mode <= NEWMV13; ++this_mode) { | ||||
| 2893 | int b_rate = 0; | ||||
| 2894 | xd->mi[0]->bmi[i].as_mv[0].as_int = b_mv[this_mode].as_int; | ||||
| 2895 | |||||
| 2896 | if (this_mode == NEWMV13) { | ||||
| 2897 | const int step_param = cpi->sf.mv.fullpel_search_step_param; | ||||
| 2898 | MV mvp_full; | ||||
| 2899 | MV tmp_mv; | ||||
| 2900 | int cost_list[5]; | ||||
| 2901 | const MvLimits tmp_mv_limits = x->mv_limits; | ||||
| 2902 | uint32_t dummy_dist; | ||||
| 2903 | |||||
| 2904 | if (i == 0) { | ||||
| 2905 | mvp_full.row = b_mv[NEARESTMV10].as_mv.row >> 3; | ||||
| 2906 | mvp_full.col = b_mv[NEARESTMV10].as_mv.col >> 3; | ||||
| 2907 | } else { | ||||
| 2908 | mvp_full.row = xd->mi[0]->bmi[0].as_mv[0].as_mv.row >> 3; | ||||
| 2909 | mvp_full.col = xd->mi[0]->bmi[0].as_mv[0].as_mv.col >> 3; | ||||
| 2910 | } | ||||
| 2911 | |||||
| 2912 | vp9_set_mv_search_range(&x->mv_limits, | ||||
| 2913 | &mbmi_ext->ref_mvs[ref_frame][0].as_mv); | ||||
| 2914 | |||||
| 2915 | vp9_full_pixel_search( | ||||
| 2916 | cpi, x, bsize, &mvp_full, step_param, cpi->sf.mv.search_method, | ||||
| 2917 | x->sadperbit4, cond_cost_list(cpi, cost_list), | ||||
| 2918 | &mbmi_ext->ref_mvs[ref_frame][0].as_mv, &tmp_mv, INT_MAX2147483647, 0); | ||||
| 2919 | |||||
| 2920 | x->mv_limits = tmp_mv_limits; | ||||
| 2921 | |||||
| 2922 | // calculate the bit cost on motion vector | ||||
| 2923 | mvp_full.row = tmp_mv.row * 8; | ||||
| 2924 | mvp_full.col = tmp_mv.col * 8; | ||||
| 2925 | |||||
| 2926 | b_rate += vp9_mv_bit_cost( | ||||
| 2927 | &mvp_full, &mbmi_ext->ref_mvs[ref_frame][0].as_mv, | ||||
| 2928 | x->nmvjointcost, x->mvcost, MV_COST_WEIGHT108); | ||||
| 2929 | |||||
| 2930 | b_rate += cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]] | ||||
| 2931 | [INTER_OFFSET(NEWMV)((13) - 10)]; | ||||
| 2932 | if (RDCOST(x->rdmult, x->rddiv, b_rate, 0)(((((int64_t)(b_rate)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((0) << (x->rddiv)) > b_best_rd) continue; | ||||
| 2933 | |||||
| 2934 | cpi->find_fractional_mv_step( | ||||
| 2935 | x, &tmp_mv, &mbmi_ext->ref_mvs[ref_frame][0].as_mv, | ||||
| 2936 | cpi->common.allow_high_precision_mv, x->errorperbit, | ||||
| 2937 | &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop, | ||||
| 2938 | cpi->sf.mv.subpel_search_level, cond_cost_list(cpi, cost_list), | ||||
| 2939 | x->nmvjointcost, x->mvcost, &dummy_dist, | ||||
| 2940 | &x->pred_sse[ref_frame], NULL((void*)0), 0, 0, | ||||
| 2941 | cpi->sf.use_accurate_subpel_search); | ||||
| 2942 | |||||
| 2943 | xd->mi[0]->bmi[i].as_mv[0].as_mv = tmp_mv; | ||||
| 2944 | } else { | ||||
| 2945 | b_rate += cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]] | ||||
| 2946 | [INTER_OFFSET(this_mode)((this_mode) - 10)]; | ||||
| 2947 | } | ||||
| 2948 | |||||
| 2949 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 2950 | if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH8) { | ||||
| 2951 | vp9_highbd_build_inter_predictor( | ||||
| 2952 | CONVERT_TO_SHORTPTR(pd->pre[0].buf)((uint16_t *)(((uintptr_t)(pd->pre[0].buf)) << 1)), pd->pre[0].stride, | ||||
| 2953 | CONVERT_TO_SHORTPTR(pd->dst.buf)((uint16_t *)(((uintptr_t)(pd->dst.buf)) << 1)), pd->dst.stride, | ||||
| 2954 | &xd->mi[0]->bmi[i].as_mv[0].as_mv, &xd->block_refs[0]->sf, | ||||
| 2955 | 4 * num_4x4_blocks_wide, 4 * num_4x4_blocks_high, 0, | ||||
| 2956 | vp9_filter_kernels[mi->interp_filter], MV_PRECISION_Q3, | ||||
| 2957 | mi_col * MI_SIZE(1 << 3) + 4 * (i & 0x01), | ||||
| 2958 | mi_row * MI_SIZE(1 << 3) + 4 * (i >> 1), xd->bd); | ||||
| 2959 | } else { | ||||
| 2960 | #endif | ||||
| 2961 | vp9_build_inter_predictor( | ||||
| 2962 | pd->pre[0].buf, pd->pre[0].stride, pd->dst.buf, pd->dst.stride, | ||||
| 2963 | &xd->mi[0]->bmi[i].as_mv[0].as_mv, &xd->block_refs[0]->sf, | ||||
| 2964 | 4 * num_4x4_blocks_wide, 4 * num_4x4_blocks_high, 0, | ||||
| 2965 | vp9_filter_kernels[mi->interp_filter], MV_PRECISION_Q3, | ||||
| 2966 | mi_col * MI_SIZE(1 << 3) + 4 * (i & 0x01), | ||||
| 2967 | mi_row * MI_SIZE(1 << 3) + 4 * (i >> 1)); | ||||
| 2968 | |||||
| 2969 | #if CONFIG_VP9_HIGHBITDEPTH0 | ||||
| 2970 | } | ||||
| 2971 | #endif | ||||
| 2972 | |||||
| 2973 | model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist, | ||||
| 2974 | &var_y, &sse_y, 0); | ||||
| 2975 | |||||
| 2976 | this_rdc.rate += b_rate; | ||||
| 2977 | this_rdc.rdcost = | ||||
| 2978 | RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist)(((((int64_t)(this_rdc.rate)) * (x->rdmult)) + (1 << ((9) - 1))) >> (9)) + ((this_rdc.dist) << (x-> rddiv)); | ||||
| 2979 | if (this_rdc.rdcost < b_best_rd) { | ||||
| 2980 | b_best_rd = this_rdc.rdcost; | ||||
| 2981 | bsi[ref_frame][i].as_mode = this_mode; | ||||
| 2982 | bsi[ref_frame][i].as_mv[0].as_mv = xd->mi[0]->bmi[i].as_mv[0].as_mv; | ||||
| 2983 | } | ||||
| 2984 | } // mode search | ||||
| 2985 | |||||
| 2986 | // restore source and prediction buffer pointers. | ||||
| 2987 | p->src = orig_src; | ||||
| 2988 | pd->pre[0] = orig_pre[0]; | ||||
| 2989 | pd->dst = orig_dst; | ||||
| 2990 | this_rd += b_best_rd; | ||||
| 2991 | |||||
| 2992 | xd->mi[0]->bmi[i] = bsi[ref_frame][i]; | ||||
| 2993 | if (num_4x4_blocks_wide > 1) xd->mi[0]->bmi[i + 1] = xd->mi[0]->bmi[i]; | ||||
| 2994 | if (num_4x4_blocks_high > 1) xd->mi[0]->bmi[i + 2] = xd->mi[0]->bmi[i]; | ||||
| 2995 | } | ||||
| 2996 | } // loop through sub8x8 blocks | ||||
| 2997 | |||||
| 2998 | if (this_rd < best_rd) { | ||||
| 2999 | best_rd = this_rd; | ||||
| 3000 | best_ref_frame = ref_frame; | ||||
| 3001 | } | ||||
| 3002 | } // reference frames | ||||
| 3003 | |||||
| 3004 | mi->tx_size = TX_4X4((TX_SIZE)0); | ||||
| 3005 | mi->ref_frame[0] = best_ref_frame; | ||||
| 3006 | for (idy = 0; idy < 2; idy += num_4x4_blocks_high) { | ||||
| 3007 | for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) { | ||||
| 3008 | const int block = idy * 2 + idx; | ||||
| 3009 | xd->mi[0]->bmi[block] = bsi[best_ref_frame][block]; | ||||
| 3010 | if (num_4x4_blocks_wide > 1) | ||||
| 3011 | xd->mi[0]->bmi[block + 1] = bsi[best_ref_frame][block]; | ||||
| 3012 | if (num_4x4_blocks_high > 1) | ||||
| 3013 | xd->mi[0]->bmi[block + 2] = bsi[best_ref_frame][block]; | ||||
| 3014 | } | ||||
| 3015 | } | ||||
| 3016 | mi->mode = xd->mi[0]->bmi[3].as_mode; | ||||
| 3017 | ctx->mic = *(xd->mi[0]); | ||||
| 3018 | ctx->mbmi_ext = *x->mbmi_ext; | ||||
| 3019 | ctx->skip_txfm[0] = SKIP_TXFM_NONE0; | ||||
| 3020 | ctx->skip = 0; | ||||
| 3021 | // Dummy assignment for speed -5. No effect in speed -6. | ||||
| 3022 | rd_cost->rdcost = best_rd; | ||||
| 3023 | } |