1 /*
2 * Copyright (c) 2019, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12 #include <stdint.h>
13 #include <float.h>
14
15 #include "config/aom_config.h"
16 #include "config/aom_dsp_rtcd.h"
17 #include "config/aom_scale_rtcd.h"
18
19 #include "aom/aom_codec.h"
20
21 #include "av1/common/av1_common_int.h"
22 #include "av1/common/enums.h"
23 #include "av1/common/idct.h"
24 #include "av1/common/reconintra.h"
25
26 #include "av1/encoder/encoder.h"
27 #include "av1/encoder/ethread.h"
28 #include "av1/encoder/encodeframe_utils.h"
29 #include "av1/encoder/encode_strategy.h"
30 #include "av1/encoder/hybrid_fwd_txfm.h"
31 #include "av1/encoder/motion_search_facade.h"
32 #include "av1/encoder/rd.h"
33 #include "av1/encoder/rdopt.h"
34 #include "av1/encoder/reconinter_enc.h"
35 #include "av1/encoder/tpl_model.h"
36
exp_bounded(double v)37 static INLINE double exp_bounded(double v) {
38 // When v > 700 or <-700, the exp function will be close to overflow
39 // For details, see the "Notes" in the following link.
40 // https://en.cppreference.com/w/c/numeric/math/exp
41 if (v > 700) {
42 return DBL_MAX;
43 } else if (v < -700) {
44 return 0;
45 }
46 return exp(v);
47 }
48
av1_init_tpl_txfm_stats(TplTxfmStats * tpl_txfm_stats)49 void av1_init_tpl_txfm_stats(TplTxfmStats *tpl_txfm_stats) {
50 tpl_txfm_stats->coeff_num = 256;
51 tpl_txfm_stats->txfm_block_count = 0;
52 memset(tpl_txfm_stats->abs_coeff_sum, 0,
53 sizeof(tpl_txfm_stats->abs_coeff_sum[0]) * tpl_txfm_stats->coeff_num);
54 }
55
av1_accumulate_tpl_txfm_stats(const TplTxfmStats * sub_stats,TplTxfmStats * accumulated_stats)56 void av1_accumulate_tpl_txfm_stats(const TplTxfmStats *sub_stats,
57 TplTxfmStats *accumulated_stats) {
58 accumulated_stats->txfm_block_count += sub_stats->txfm_block_count;
59 for (int i = 0; i < accumulated_stats->coeff_num; ++i) {
60 accumulated_stats->abs_coeff_sum[i] += sub_stats->abs_coeff_sum[i];
61 }
62 }
63
av1_record_tpl_txfm_block(TplTxfmStats * tpl_txfm_stats,const tran_low_t * coeff)64 void av1_record_tpl_txfm_block(TplTxfmStats *tpl_txfm_stats,
65 const tran_low_t *coeff) {
66 // For transform larger than 16x16, the scale of coeff need to be adjusted.
67 // It's not LOSSLESS_Q_STEP.
68 assert(tpl_txfm_stats->coeff_num <= 256);
69 for (int i = 0; i < tpl_txfm_stats->coeff_num; ++i) {
70 tpl_txfm_stats->abs_coeff_sum[i] += abs(coeff[i]) / (double)LOSSLESS_Q_STEP;
71 }
72 ++tpl_txfm_stats->txfm_block_count;
73 }
74
av1_tpl_store_txfm_stats(TplParams * tpl_data,const TplTxfmStats * tpl_txfm_stats,const int frame_index)75 static AOM_INLINE void av1_tpl_store_txfm_stats(
76 TplParams *tpl_data, const TplTxfmStats *tpl_txfm_stats,
77 const int frame_index) {
78 tpl_data->txfm_stats_list[frame_index] = *tpl_txfm_stats;
79 }
80
get_quantize_error(const MACROBLOCK * x,int plane,const tran_low_t * coeff,tran_low_t * qcoeff,tran_low_t * dqcoeff,TX_SIZE tx_size,uint16_t * eob,int64_t * recon_error,int64_t * sse)81 static AOM_INLINE void get_quantize_error(const MACROBLOCK *x, int plane,
82 const tran_low_t *coeff,
83 tran_low_t *qcoeff,
84 tran_low_t *dqcoeff, TX_SIZE tx_size,
85 uint16_t *eob, int64_t *recon_error,
86 int64_t *sse) {
87 const struct macroblock_plane *const p = &x->plane[plane];
88 const MACROBLOCKD *xd = &x->e_mbd;
89 const SCAN_ORDER *const scan_order = &av1_scan_orders[tx_size][DCT_DCT];
90 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
91 const int shift = tx_size == TX_32X32 ? 0 : 2;
92
93 QUANT_PARAM quant_param;
94 av1_setup_quant(tx_size, 0, AV1_XFORM_QUANT_FP, 0, &quant_param);
95
96 #if CONFIG_AV1_HIGHBITDEPTH
97 if (is_cur_buf_hbd(xd)) {
98 av1_highbd_quantize_fp_facade(coeff, pix_num, p, qcoeff, dqcoeff, eob,
99 scan_order, &quant_param);
100 *recon_error =
101 av1_highbd_block_error(coeff, dqcoeff, pix_num, sse, xd->bd) >> shift;
102 } else {
103 av1_quantize_fp_facade(coeff, pix_num, p, qcoeff, dqcoeff, eob, scan_order,
104 &quant_param);
105 *recon_error = av1_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
106 }
107 #else
108 (void)xd;
109 av1_quantize_fp_facade(coeff, pix_num, p, qcoeff, dqcoeff, eob, scan_order,
110 &quant_param);
111 *recon_error = av1_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
112 #endif // CONFIG_AV1_HIGHBITDEPTH
113
114 *recon_error = AOMMAX(*recon_error, 1);
115
116 *sse = (*sse) >> shift;
117 *sse = AOMMAX(*sse, 1);
118 }
119
set_tpl_stats_block_size(uint8_t * block_mis_log2,uint8_t * tpl_bsize_1d)120 static AOM_INLINE void set_tpl_stats_block_size(uint8_t *block_mis_log2,
121 uint8_t *tpl_bsize_1d) {
122 // tpl stats bsize: 2 means 16x16
123 *block_mis_log2 = 2;
124 // Block size used in tpl motion estimation
125 *tpl_bsize_1d = 16;
126 // MIN_TPL_BSIZE_1D = 16;
127 assert(*tpl_bsize_1d >= 16);
128 }
129
av1_setup_tpl_buffers(AV1_PRIMARY * const ppi,CommonModeInfoParams * const mi_params,int width,int height,int byte_alignment,int lag_in_frames)130 void av1_setup_tpl_buffers(AV1_PRIMARY *const ppi,
131 CommonModeInfoParams *const mi_params, int width,
132 int height, int byte_alignment, int lag_in_frames) {
133 SequenceHeader *const seq_params = &ppi->seq_params;
134 TplParams *const tpl_data = &ppi->tpl_data;
135 set_tpl_stats_block_size(&tpl_data->tpl_stats_block_mis_log2,
136 &tpl_data->tpl_bsize_1d);
137 const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2;
138 tpl_data->border_in_pixels =
139 ALIGN_POWER_OF_TWO(tpl_data->tpl_bsize_1d + 2 * AOM_INTERP_EXTEND, 5);
140
141 for (int frame = 0; frame < MAX_LENGTH_TPL_FRAME_STATS; ++frame) {
142 const int mi_cols =
143 ALIGN_POWER_OF_TWO(mi_params->mi_cols, MAX_MIB_SIZE_LOG2);
144 const int mi_rows =
145 ALIGN_POWER_OF_TWO(mi_params->mi_rows, MAX_MIB_SIZE_LOG2);
146 TplDepFrame *tpl_frame = &tpl_data->tpl_stats_buffer[frame];
147 tpl_frame->is_valid = 0;
148 tpl_frame->width = mi_cols >> block_mis_log2;
149 tpl_frame->height = mi_rows >> block_mis_log2;
150 tpl_frame->stride = tpl_data->tpl_stats_buffer[frame].width;
151 tpl_frame->mi_rows = mi_params->mi_rows;
152 tpl_frame->mi_cols = mi_params->mi_cols;
153 }
154 tpl_data->tpl_frame = &tpl_data->tpl_stats_buffer[REF_FRAMES + 1];
155
156 // If lag_in_frames <= 1, TPL module is not invoked. Hence tpl recon and
157 // stats buffers are not allocated.
158 if (lag_in_frames <= 1) return;
159
160 for (int frame = 0; frame < lag_in_frames; ++frame) {
161 AOM_CHECK_MEM_ERROR(
162 &ppi->error, tpl_data->tpl_stats_pool[frame],
163 aom_calloc(tpl_data->tpl_stats_buffer[frame].width *
164 tpl_data->tpl_stats_buffer[frame].height,
165 sizeof(*tpl_data->tpl_stats_buffer[frame].tpl_stats_ptr)));
166
167 if (aom_alloc_frame_buffer(&tpl_data->tpl_rec_pool[frame], width, height,
168 seq_params->subsampling_x,
169 seq_params->subsampling_y,
170 seq_params->use_highbitdepth,
171 tpl_data->border_in_pixels, byte_alignment))
172 aom_internal_error(&ppi->error, AOM_CODEC_MEM_ERROR,
173 "Failed to allocate frame buffer");
174 }
175 }
176
tpl_get_satd_cost(BitDepthInfo bd_info,int16_t * src_diff,int diff_stride,const uint8_t * src,int src_stride,const uint8_t * dst,int dst_stride,tran_low_t * coeff,int bw,int bh,TX_SIZE tx_size)177 static AOM_INLINE int64_t tpl_get_satd_cost(BitDepthInfo bd_info,
178 int16_t *src_diff, int diff_stride,
179 const uint8_t *src, int src_stride,
180 const uint8_t *dst, int dst_stride,
181 tran_low_t *coeff, int bw, int bh,
182 TX_SIZE tx_size) {
183 const int pix_num = bw * bh;
184
185 av1_subtract_block(bd_info, bh, bw, src_diff, diff_stride, src, src_stride,
186 dst, dst_stride);
187 av1_quick_txfm(/*use_hadamard=*/0, tx_size, bd_info, src_diff, bw, coeff);
188 return aom_satd(coeff, pix_num);
189 }
190
rate_estimator(const tran_low_t * qcoeff,int eob,TX_SIZE tx_size)191 static int rate_estimator(const tran_low_t *qcoeff, int eob, TX_SIZE tx_size) {
192 const SCAN_ORDER *const scan_order = &av1_scan_orders[tx_size][DCT_DCT];
193
194 assert((1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]]) >= eob);
195 int rate_cost = 1;
196
197 for (int idx = 0; idx < eob; ++idx) {
198 int abs_level = abs(qcoeff[scan_order->scan[idx]]);
199 rate_cost += (int)(log(abs_level + 1.0) / log(2.0)) + 1;
200 }
201
202 return (rate_cost << AV1_PROB_COST_SHIFT);
203 }
204
txfm_quant_rdcost(const MACROBLOCK * x,int16_t * src_diff,int diff_stride,uint8_t * src,int src_stride,uint8_t * dst,int dst_stride,tran_low_t * coeff,tran_low_t * qcoeff,tran_low_t * dqcoeff,int bw,int bh,TX_SIZE tx_size,int * rate_cost,int64_t * recon_error,int64_t * sse)205 static AOM_INLINE void txfm_quant_rdcost(
206 const MACROBLOCK *x, int16_t *src_diff, int diff_stride, uint8_t *src,
207 int src_stride, uint8_t *dst, int dst_stride, tran_low_t *coeff,
208 tran_low_t *qcoeff, tran_low_t *dqcoeff, int bw, int bh, TX_SIZE tx_size,
209 int *rate_cost, int64_t *recon_error, int64_t *sse) {
210 const MACROBLOCKD *xd = &x->e_mbd;
211 const BitDepthInfo bd_info = get_bit_depth_info(xd);
212 uint16_t eob;
213 av1_subtract_block(bd_info, bh, bw, src_diff, diff_stride, src, src_stride,
214 dst, dst_stride);
215 av1_quick_txfm(/*use_hadamard=*/0, tx_size, bd_info, src_diff, bw, coeff);
216
217 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, &eob, recon_error,
218 sse);
219
220 *rate_cost = rate_estimator(qcoeff, eob, tx_size);
221
222 av1_inverse_transform_block(xd, dqcoeff, 0, DCT_DCT, tx_size, dst, dst_stride,
223 eob, 0);
224 }
225
motion_estimation(AV1_COMP * cpi,MACROBLOCK * x,uint8_t * cur_frame_buf,uint8_t * ref_frame_buf,int stride,int stride_ref,BLOCK_SIZE bsize,MV center_mv,int_mv * best_mv)226 static uint32_t motion_estimation(AV1_COMP *cpi, MACROBLOCK *x,
227 uint8_t *cur_frame_buf,
228 uint8_t *ref_frame_buf, int stride,
229 int stride_ref, BLOCK_SIZE bsize,
230 MV center_mv, int_mv *best_mv) {
231 AV1_COMMON *cm = &cpi->common;
232 MACROBLOCKD *const xd = &x->e_mbd;
233 TPL_SPEED_FEATURES *tpl_sf = &cpi->sf.tpl_sf;
234 int step_param;
235 uint32_t bestsme = UINT_MAX;
236 int distortion;
237 uint32_t sse;
238 int cost_list[5];
239 FULLPEL_MV start_mv = get_fullmv_from_mv(¢er_mv);
240
241 // Setup frame pointers
242 x->plane[0].src.buf = cur_frame_buf;
243 x->plane[0].src.stride = stride;
244 xd->plane[0].pre[0].buf = ref_frame_buf;
245 xd->plane[0].pre[0].stride = stride_ref;
246
247 step_param = tpl_sf->reduce_first_step_size;
248 step_param = AOMMIN(step_param, MAX_MVSEARCH_STEPS - 2);
249
250 const search_site_config *search_site_cfg =
251 cpi->mv_search_params.search_site_cfg[SS_CFG_SRC];
252 if (search_site_cfg->stride != stride_ref)
253 search_site_cfg = cpi->mv_search_params.search_site_cfg[SS_CFG_LOOKAHEAD];
254 assert(search_site_cfg->stride == stride_ref);
255
256 FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
257 av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, ¢er_mv,
258 search_site_cfg,
259 /*fine_search_interval=*/0);
260 av1_set_mv_search_method(&full_ms_params, search_site_cfg,
261 tpl_sf->search_method);
262
263 av1_full_pixel_search(start_mv, &full_ms_params, step_param,
264 cond_cost_list(cpi, cost_list), &best_mv->as_fullmv,
265 NULL);
266
267 SUBPEL_MOTION_SEARCH_PARAMS ms_params;
268 av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize, ¢er_mv,
269 cost_list);
270 ms_params.forced_stop = tpl_sf->subpel_force_stop;
271 ms_params.var_params.subpel_search_type = USE_2_TAPS;
272 ms_params.mv_cost_params.mv_cost_type = MV_COST_NONE;
273 MV subpel_start_mv = get_mv_from_fullmv(&best_mv->as_fullmv);
274 bestsme = cpi->mv_search_params.find_fractional_mv_step(
275 xd, cm, &ms_params, subpel_start_mv, &best_mv->as_mv, &distortion, &sse,
276 NULL);
277
278 return bestsme;
279 }
280
281 typedef struct {
282 int_mv mv;
283 int sad;
284 } center_mv_t;
285
compare_sad(const void * a,const void * b)286 static int compare_sad(const void *a, const void *b) {
287 const int diff = ((center_mv_t *)a)->sad - ((center_mv_t *)b)->sad;
288 if (diff < 0)
289 return -1;
290 else if (diff > 0)
291 return 1;
292 return 0;
293 }
294
is_alike_mv(int_mv candidate_mv,center_mv_t * center_mvs,int center_mvs_count,int skip_alike_starting_mv)295 static int is_alike_mv(int_mv candidate_mv, center_mv_t *center_mvs,
296 int center_mvs_count, int skip_alike_starting_mv) {
297 // MV difference threshold is in 1/8 precision.
298 const int mv_diff_thr[3] = { 1, (8 << 3), (16 << 3) };
299 int thr = mv_diff_thr[skip_alike_starting_mv];
300 int i;
301
302 for (i = 0; i < center_mvs_count; i++) {
303 if (abs(center_mvs[i].mv.as_mv.col - candidate_mv.as_mv.col) < thr &&
304 abs(center_mvs[i].mv.as_mv.row - candidate_mv.as_mv.row) < thr)
305 return 1;
306 }
307
308 return 0;
309 }
310
get_rate_distortion(int * rate_cost,int64_t * recon_error,int64_t * pred_error,int16_t * src_diff,tran_low_t * coeff,tran_low_t * qcoeff,tran_low_t * dqcoeff,AV1_COMMON * cm,MACROBLOCK * x,const YV12_BUFFER_CONFIG * ref_frame_ptr[2],uint8_t * rec_buffer_pool[3],const int rec_stride_pool[3],TX_SIZE tx_size,PREDICTION_MODE best_mode,int mi_row,int mi_col,int use_y_only_rate_distortion)311 static void get_rate_distortion(
312 int *rate_cost, int64_t *recon_error, int64_t *pred_error,
313 int16_t *src_diff, tran_low_t *coeff, tran_low_t *qcoeff,
314 tran_low_t *dqcoeff, AV1_COMMON *cm, MACROBLOCK *x,
315 const YV12_BUFFER_CONFIG *ref_frame_ptr[2], uint8_t *rec_buffer_pool[3],
316 const int rec_stride_pool[3], TX_SIZE tx_size, PREDICTION_MODE best_mode,
317 int mi_row, int mi_col, int use_y_only_rate_distortion) {
318 const SequenceHeader *seq_params = cm->seq_params;
319 *rate_cost = 0;
320 *recon_error = 1;
321 *pred_error = 1;
322
323 MACROBLOCKD *xd = &x->e_mbd;
324 int is_compound = (best_mode == NEW_NEWMV);
325 int num_planes = use_y_only_rate_distortion ? 1 : MAX_MB_PLANE;
326
327 uint8_t *src_buffer_pool[MAX_MB_PLANE] = {
328 xd->cur_buf->y_buffer,
329 xd->cur_buf->u_buffer,
330 xd->cur_buf->v_buffer,
331 };
332 const int src_stride_pool[MAX_MB_PLANE] = {
333 xd->cur_buf->y_stride,
334 xd->cur_buf->uv_stride,
335 xd->cur_buf->uv_stride,
336 };
337
338 const int_interpfilters kernel =
339 av1_broadcast_interp_filter(EIGHTTAP_REGULAR);
340
341 for (int plane = 0; plane < num_planes; ++plane) {
342 struct macroblockd_plane *pd = &xd->plane[plane];
343 BLOCK_SIZE bsize_plane =
344 ss_size_lookup[txsize_to_bsize[tx_size]][pd->subsampling_x]
345 [pd->subsampling_y];
346
347 int dst_buffer_stride = rec_stride_pool[plane];
348 int dst_mb_offset =
349 ((mi_row * MI_SIZE * dst_buffer_stride) >> pd->subsampling_y) +
350 ((mi_col * MI_SIZE) >> pd->subsampling_x);
351 uint8_t *dst_buffer = rec_buffer_pool[plane] + dst_mb_offset;
352 for (int ref = 0; ref < 1 + is_compound; ++ref) {
353 if (!is_inter_mode(best_mode)) {
354 av1_predict_intra_block(
355 xd, seq_params->sb_size, seq_params->enable_intra_edge_filter,
356 block_size_wide[bsize_plane], block_size_high[bsize_plane],
357 max_txsize_rect_lookup[bsize_plane], best_mode, 0, 0,
358 FILTER_INTRA_MODES, dst_buffer, dst_buffer_stride, dst_buffer,
359 dst_buffer_stride, 0, 0, plane);
360 } else {
361 int_mv best_mv = xd->mi[0]->mv[ref];
362 uint8_t *ref_buffer_pool[MAX_MB_PLANE] = {
363 ref_frame_ptr[ref]->y_buffer,
364 ref_frame_ptr[ref]->u_buffer,
365 ref_frame_ptr[ref]->v_buffer,
366 };
367 InterPredParams inter_pred_params;
368 struct buf_2d ref_buf = {
369 NULL, ref_buffer_pool[plane],
370 plane ? ref_frame_ptr[ref]->uv_width : ref_frame_ptr[ref]->y_width,
371 plane ? ref_frame_ptr[ref]->uv_height : ref_frame_ptr[ref]->y_height,
372 plane ? ref_frame_ptr[ref]->uv_stride : ref_frame_ptr[ref]->y_stride
373 };
374 av1_init_inter_params(&inter_pred_params, block_size_wide[bsize_plane],
375 block_size_high[bsize_plane],
376 (mi_row * MI_SIZE) >> pd->subsampling_y,
377 (mi_col * MI_SIZE) >> pd->subsampling_x,
378 pd->subsampling_x, pd->subsampling_y, xd->bd,
379 is_cur_buf_hbd(xd), 0,
380 xd->block_ref_scale_factors[0], &ref_buf, kernel);
381 if (is_compound) av1_init_comp_mode(&inter_pred_params);
382 inter_pred_params.conv_params = get_conv_params_no_round(
383 ref, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
384
385 av1_enc_build_one_inter_predictor(dst_buffer, dst_buffer_stride,
386 &best_mv.as_mv, &inter_pred_params);
387 }
388 }
389
390 int src_stride = src_stride_pool[plane];
391 int src_mb_offset = ((mi_row * MI_SIZE * src_stride) >> pd->subsampling_y) +
392 ((mi_col * MI_SIZE) >> pd->subsampling_x);
393
394 int this_rate = 1;
395 int64_t this_recon_error = 1;
396 int64_t sse;
397 txfm_quant_rdcost(
398 x, src_diff, block_size_wide[bsize_plane],
399 src_buffer_pool[plane] + src_mb_offset, src_stride, dst_buffer,
400 dst_buffer_stride, coeff, qcoeff, dqcoeff, block_size_wide[bsize_plane],
401 block_size_high[bsize_plane], max_txsize_rect_lookup[bsize_plane],
402 &this_rate, &this_recon_error, &sse);
403
404 *recon_error += this_recon_error;
405 *pred_error += sse;
406 *rate_cost += this_rate;
407 }
408 }
409
mode_estimation(AV1_COMP * cpi,TplTxfmStats * tpl_txfm_stats,MACROBLOCK * x,int mi_row,int mi_col,BLOCK_SIZE bsize,TX_SIZE tx_size,TplDepStats * tpl_stats)410 static AOM_INLINE void mode_estimation(AV1_COMP *cpi,
411 TplTxfmStats *tpl_txfm_stats,
412 MACROBLOCK *x, int mi_row, int mi_col,
413 BLOCK_SIZE bsize, TX_SIZE tx_size,
414 TplDepStats *tpl_stats) {
415 AV1_COMMON *cm = &cpi->common;
416 const GF_GROUP *gf_group = &cpi->ppi->gf_group;
417
418 (void)gf_group;
419
420 MACROBLOCKD *xd = &x->e_mbd;
421 const BitDepthInfo bd_info = get_bit_depth_info(xd);
422 TplParams *tpl_data = &cpi->ppi->tpl_data;
423 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[tpl_data->frame_idx];
424 const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2;
425
426 const int bw = 4 << mi_size_wide_log2[bsize];
427 const int bh = 4 << mi_size_high_log2[bsize];
428 const int_interpfilters kernel =
429 av1_broadcast_interp_filter(EIGHTTAP_REGULAR);
430
431 int64_t best_intra_cost = INT64_MAX;
432 int64_t intra_cost;
433 PREDICTION_MODE best_mode = DC_PRED;
434
435 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
436 uint8_t *src_mb_buffer = xd->cur_buf->y_buffer + mb_y_offset;
437 int src_stride = xd->cur_buf->y_stride;
438
439 int dst_mb_offset =
440 mi_row * MI_SIZE * tpl_frame->rec_picture->y_stride + mi_col * MI_SIZE;
441 uint8_t *dst_buffer = tpl_frame->rec_picture->y_buffer + dst_mb_offset;
442 int dst_buffer_stride = tpl_frame->rec_picture->y_stride;
443 int use_y_only_rate_distortion = cpi->sf.tpl_sf.use_y_only_rate_distortion;
444
445 uint8_t *rec_buffer_pool[3] = {
446 tpl_frame->rec_picture->y_buffer,
447 tpl_frame->rec_picture->u_buffer,
448 tpl_frame->rec_picture->v_buffer,
449 };
450
451 const int rec_stride_pool[3] = {
452 tpl_frame->rec_picture->y_stride,
453 tpl_frame->rec_picture->uv_stride,
454 tpl_frame->rec_picture->uv_stride,
455 };
456
457 for (int plane = 1; plane < MAX_MB_PLANE; ++plane) {
458 struct macroblockd_plane *pd = &xd->plane[plane];
459 pd->subsampling_x = xd->cur_buf->subsampling_x;
460 pd->subsampling_y = xd->cur_buf->subsampling_y;
461 }
462
463 // Number of pixels in a tpl block
464 const int tpl_block_pels = tpl_data->tpl_bsize_1d * tpl_data->tpl_bsize_1d;
465 // Allocate temporary buffers used in motion estimation.
466 uint8_t *predictor8 = aom_memalign(32, tpl_block_pels * 2 * sizeof(uint8_t));
467 int16_t *src_diff = aom_memalign(32, tpl_block_pels * sizeof(int16_t));
468 tran_low_t *coeff = aom_memalign(32, tpl_block_pels * sizeof(tran_low_t));
469 tran_low_t *qcoeff = aom_memalign(32, tpl_block_pels * sizeof(tran_low_t));
470 tran_low_t *dqcoeff = aom_memalign(32, tpl_block_pels * sizeof(tran_low_t));
471 uint8_t *predictor =
472 is_cur_buf_hbd(xd) ? CONVERT_TO_BYTEPTR(predictor8) : predictor8;
473 int64_t recon_error = 1;
474 int64_t pred_error = 1;
475
476 memset(tpl_stats, 0, sizeof(*tpl_stats));
477 tpl_stats->ref_frame_index[0] = -1;
478 tpl_stats->ref_frame_index[1] = -1;
479
480 const int mi_width = mi_size_wide[bsize];
481 const int mi_height = mi_size_high[bsize];
482 set_mode_info_offsets(&cpi->common.mi_params, &cpi->mbmi_ext_info, x, xd,
483 mi_row, mi_col);
484 set_mi_row_col(xd, &xd->tile, mi_row, mi_height, mi_col, mi_width,
485 cm->mi_params.mi_rows, cm->mi_params.mi_cols);
486 set_plane_n4(xd, mi_size_wide[bsize], mi_size_high[bsize],
487 av1_num_planes(cm));
488 xd->mi[0]->bsize = bsize;
489 xd->mi[0]->motion_mode = SIMPLE_TRANSLATION;
490
491 // Intra prediction search
492 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
493
494 // Pre-load the bottom left line.
495 if (xd->left_available &&
496 mi_row + tx_size_high_unit[tx_size] < xd->tile.mi_row_end) {
497 if (is_cur_buf_hbd(xd)) {
498 uint16_t *dst = CONVERT_TO_SHORTPTR(dst_buffer);
499 for (int i = 0; i < bw; ++i)
500 dst[(bw + i) * dst_buffer_stride - 1] =
501 dst[(bw - 1) * dst_buffer_stride - 1];
502 } else {
503 for (int i = 0; i < bw; ++i)
504 dst_buffer[(bw + i) * dst_buffer_stride - 1] =
505 dst_buffer[(bw - 1) * dst_buffer_stride - 1];
506 }
507 }
508
509 // if cpi->sf.tpl_sf.prune_intra_modes is on, then search only DC_PRED,
510 // H_PRED, and V_PRED
511 const PREDICTION_MODE last_intra_mode =
512 cpi->sf.tpl_sf.prune_intra_modes ? D45_PRED : INTRA_MODE_END;
513 const SequenceHeader *seq_params = cm->seq_params;
514 for (PREDICTION_MODE mode = INTRA_MODE_START; mode < last_intra_mode;
515 ++mode) {
516 av1_predict_intra_block(xd, seq_params->sb_size,
517 seq_params->enable_intra_edge_filter,
518 block_size_wide[bsize], block_size_high[bsize],
519 tx_size, mode, 0, 0, FILTER_INTRA_MODES, dst_buffer,
520 dst_buffer_stride, predictor, bw, 0, 0, 0);
521
522 intra_cost =
523 tpl_get_satd_cost(bd_info, src_diff, bw, src_mb_buffer, src_stride,
524 predictor, bw, coeff, bw, bh, tx_size);
525
526 if (intra_cost < best_intra_cost) {
527 best_intra_cost = intra_cost;
528 best_mode = mode;
529 }
530 }
531
532 // Motion compensated prediction
533 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
534 xd->mi[0]->ref_frame[1] = NONE_FRAME;
535 xd->mi[0]->compound_idx = 1;
536
537 int best_rf_idx = -1;
538 int_mv best_mv[2];
539 int64_t inter_cost;
540 int64_t best_inter_cost = INT64_MAX;
541 int rf_idx;
542 int_mv single_mv[INTER_REFS_PER_FRAME];
543
544 best_mv[0].as_int = INVALID_MV;
545 best_mv[1].as_int = INVALID_MV;
546
547 for (rf_idx = 0; rf_idx < INTER_REFS_PER_FRAME; ++rf_idx) {
548 single_mv[rf_idx].as_int = INVALID_MV;
549 if (tpl_data->ref_frame[rf_idx] == NULL ||
550 tpl_data->src_ref_frame[rf_idx] == NULL) {
551 tpl_stats->mv[rf_idx].as_int = INVALID_MV;
552 continue;
553 }
554
555 const YV12_BUFFER_CONFIG *ref_frame_ptr = tpl_data->src_ref_frame[rf_idx];
556 int ref_mb_offset =
557 mi_row * MI_SIZE * ref_frame_ptr->y_stride + mi_col * MI_SIZE;
558 uint8_t *ref_mb = ref_frame_ptr->y_buffer + ref_mb_offset;
559 int ref_stride = ref_frame_ptr->y_stride;
560
561 int_mv best_rfidx_mv = { 0 };
562 uint32_t bestsme = UINT32_MAX;
563
564 center_mv_t center_mvs[4] = { { { 0 }, INT_MAX },
565 { { 0 }, INT_MAX },
566 { { 0 }, INT_MAX },
567 { { 0 }, INT_MAX } };
568 int refmv_count = 1;
569 int idx;
570
571 if (xd->up_available) {
572 TplDepStats *ref_tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
573 mi_row - mi_height, mi_col, tpl_frame->stride, block_mis_log2)];
574 if (!is_alike_mv(ref_tpl_stats->mv[rf_idx], center_mvs, refmv_count,
575 cpi->sf.tpl_sf.skip_alike_starting_mv)) {
576 center_mvs[refmv_count].mv.as_int = ref_tpl_stats->mv[rf_idx].as_int;
577 ++refmv_count;
578 }
579 }
580
581 if (xd->left_available) {
582 TplDepStats *ref_tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
583 mi_row, mi_col - mi_width, tpl_frame->stride, block_mis_log2)];
584 if (!is_alike_mv(ref_tpl_stats->mv[rf_idx], center_mvs, refmv_count,
585 cpi->sf.tpl_sf.skip_alike_starting_mv)) {
586 center_mvs[refmv_count].mv.as_int = ref_tpl_stats->mv[rf_idx].as_int;
587 ++refmv_count;
588 }
589 }
590
591 if (xd->up_available && mi_col + mi_width < xd->tile.mi_col_end) {
592 TplDepStats *ref_tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
593 mi_row - mi_height, mi_col + mi_width, tpl_frame->stride,
594 block_mis_log2)];
595 if (!is_alike_mv(ref_tpl_stats->mv[rf_idx], center_mvs, refmv_count,
596 cpi->sf.tpl_sf.skip_alike_starting_mv)) {
597 center_mvs[refmv_count].mv.as_int = ref_tpl_stats->mv[rf_idx].as_int;
598 ++refmv_count;
599 }
600 }
601
602 // Prune starting mvs
603 if (cpi->sf.tpl_sf.prune_starting_mv) {
604 // Get each center mv's sad.
605 for (idx = 0; idx < refmv_count; ++idx) {
606 FULLPEL_MV mv = get_fullmv_from_mv(¢er_mvs[idx].mv.as_mv);
607 clamp_fullmv(&mv, &x->mv_limits);
608 center_mvs[idx].sad = (int)cpi->ppi->fn_ptr[bsize].sdf(
609 src_mb_buffer, src_stride, &ref_mb[mv.row * ref_stride + mv.col],
610 ref_stride);
611 }
612
613 // Rank center_mv using sad.
614 if (refmv_count > 1) {
615 qsort(center_mvs, refmv_count, sizeof(center_mvs[0]), compare_sad);
616 }
617 refmv_count = AOMMIN(4 - cpi->sf.tpl_sf.prune_starting_mv, refmv_count);
618 // Further reduce number of refmv based on sad difference.
619 if (refmv_count > 1) {
620 int last_sad = center_mvs[refmv_count - 1].sad;
621 int second_to_last_sad = center_mvs[refmv_count - 2].sad;
622 if ((last_sad - second_to_last_sad) * 5 > second_to_last_sad)
623 refmv_count--;
624 }
625 }
626
627 for (idx = 0; idx < refmv_count; ++idx) {
628 int_mv this_mv;
629 uint32_t thissme = motion_estimation(cpi, x, src_mb_buffer, ref_mb,
630 src_stride, ref_stride, bsize,
631 center_mvs[idx].mv.as_mv, &this_mv);
632
633 if (thissme < bestsme) {
634 bestsme = thissme;
635 best_rfidx_mv = this_mv;
636 }
637 }
638
639 tpl_stats->mv[rf_idx].as_int = best_rfidx_mv.as_int;
640 single_mv[rf_idx] = best_rfidx_mv;
641
642 struct buf_2d ref_buf = { NULL, ref_frame_ptr->y_buffer,
643 ref_frame_ptr->y_width, ref_frame_ptr->y_height,
644 ref_frame_ptr->y_stride };
645 InterPredParams inter_pred_params;
646 av1_init_inter_params(&inter_pred_params, bw, bh, mi_row * MI_SIZE,
647 mi_col * MI_SIZE, 0, 0, xd->bd, is_cur_buf_hbd(xd), 0,
648 &tpl_data->sf, &ref_buf, kernel);
649 inter_pred_params.conv_params = get_conv_params(0, 0, xd->bd);
650
651 av1_enc_build_one_inter_predictor(predictor, bw, &best_rfidx_mv.as_mv,
652 &inter_pred_params);
653
654 inter_cost =
655 tpl_get_satd_cost(bd_info, src_diff, bw, src_mb_buffer, src_stride,
656 predictor, bw, coeff, bw, bh, tx_size);
657 // Store inter cost for each ref frame
658 tpl_stats->pred_error[rf_idx] = AOMMAX(1, inter_cost);
659
660 if (inter_cost < best_inter_cost) {
661 best_rf_idx = rf_idx;
662
663 best_inter_cost = inter_cost;
664 best_mv[0].as_int = best_rfidx_mv.as_int;
665 if (best_inter_cost < best_intra_cost) {
666 best_mode = NEWMV;
667 xd->mi[0]->ref_frame[0] = best_rf_idx + LAST_FRAME;
668 xd->mi[0]->mv[0].as_int = best_mv[0].as_int;
669 }
670 }
671 }
672
673 int comp_ref_frames[3][2] = {
674 { 0, 4 },
675 { 0, 6 },
676 { 3, 6 },
677 };
678
679 xd->mi_row = mi_row;
680 xd->mi_col = mi_col;
681 int best_cmp_rf_idx = -1;
682 for (int cmp_rf_idx = 0; cmp_rf_idx < 3 && cpi->sf.tpl_sf.allow_compound_pred;
683 ++cmp_rf_idx) {
684 int rf_idx0 = comp_ref_frames[cmp_rf_idx][0];
685 int rf_idx1 = comp_ref_frames[cmp_rf_idx][1];
686
687 if (tpl_data->ref_frame[rf_idx0] == NULL ||
688 tpl_data->src_ref_frame[rf_idx0] == NULL ||
689 tpl_data->ref_frame[rf_idx1] == NULL ||
690 tpl_data->src_ref_frame[rf_idx1] == NULL) {
691 continue;
692 }
693
694 const YV12_BUFFER_CONFIG *ref_frame_ptr[2] = {
695 tpl_data->src_ref_frame[rf_idx0],
696 tpl_data->src_ref_frame[rf_idx1],
697 };
698
699 xd->mi[0]->ref_frame[0] = LAST_FRAME;
700 xd->mi[0]->ref_frame[1] = ALTREF_FRAME;
701
702 struct buf_2d yv12_mb[2][MAX_MB_PLANE];
703 for (int i = 0; i < 2; ++i) {
704 av1_setup_pred_block(xd, yv12_mb[i], ref_frame_ptr[i],
705 xd->block_ref_scale_factors[i],
706 xd->block_ref_scale_factors[i], MAX_MB_PLANE);
707 for (int plane = 0; plane < MAX_MB_PLANE; ++plane) {
708 xd->plane[plane].pre[i] = yv12_mb[i][plane];
709 }
710 }
711
712 int_mv tmp_mv[2] = { single_mv[rf_idx0], single_mv[rf_idx1] };
713 int rate_mv;
714 av1_joint_motion_search(cpi, x, bsize, tmp_mv, NULL, 0, &rate_mv,
715 !cpi->sf.mv_sf.disable_second_mv);
716
717 for (int ref = 0; ref < 2; ++ref) {
718 struct buf_2d ref_buf = { NULL, ref_frame_ptr[ref]->y_buffer,
719 ref_frame_ptr[ref]->y_width,
720 ref_frame_ptr[ref]->y_height,
721 ref_frame_ptr[ref]->y_stride };
722 InterPredParams inter_pred_params;
723 av1_init_inter_params(&inter_pred_params, bw, bh, mi_row * MI_SIZE,
724 mi_col * MI_SIZE, 0, 0, xd->bd, is_cur_buf_hbd(xd),
725 0, &tpl_data->sf, &ref_buf, kernel);
726 av1_init_comp_mode(&inter_pred_params);
727
728 inter_pred_params.conv_params = get_conv_params_no_round(
729 ref, 0, xd->tmp_conv_dst, MAX_SB_SIZE, 1, xd->bd);
730
731 av1_enc_build_one_inter_predictor(predictor, bw, &tmp_mv[ref].as_mv,
732 &inter_pred_params);
733 }
734 inter_cost =
735 tpl_get_satd_cost(bd_info, src_diff, bw, src_mb_buffer, src_stride,
736 predictor, bw, coeff, bw, bh, tx_size);
737 if (inter_cost < best_inter_cost) {
738 best_cmp_rf_idx = cmp_rf_idx;
739 best_inter_cost = inter_cost;
740 best_mv[0] = tmp_mv[0];
741 best_mv[1] = tmp_mv[1];
742
743 if (best_inter_cost < best_intra_cost) {
744 best_mode = NEW_NEWMV;
745 xd->mi[0]->ref_frame[0] = rf_idx0 + LAST_FRAME;
746 xd->mi[0]->ref_frame[1] = rf_idx1 + LAST_FRAME;
747 }
748 }
749 }
750
751 if (best_inter_cost < INT64_MAX) {
752 xd->mi[0]->mv[0].as_int = best_mv[0].as_int;
753 xd->mi[0]->mv[1].as_int = best_mv[1].as_int;
754 const YV12_BUFFER_CONFIG *ref_frame_ptr[2] = {
755 best_cmp_rf_idx >= 0
756 ? tpl_data->src_ref_frame[comp_ref_frames[best_cmp_rf_idx][0]]
757 : tpl_data->src_ref_frame[best_rf_idx],
758 best_cmp_rf_idx >= 0
759 ? tpl_data->src_ref_frame[comp_ref_frames[best_cmp_rf_idx][1]]
760 : NULL,
761 };
762 int rate_cost = 1;
763 get_rate_distortion(&rate_cost, &recon_error, &pred_error, src_diff, coeff,
764 qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool,
765 rec_stride_pool, tx_size, best_mode, mi_row, mi_col,
766 use_y_only_rate_distortion);
767 tpl_stats->srcrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2;
768 }
769
770 best_intra_cost = AOMMAX(best_intra_cost, 1);
771 best_inter_cost = AOMMIN(best_intra_cost, best_inter_cost);
772 tpl_stats->inter_cost = best_inter_cost << TPL_DEP_COST_SCALE_LOG2;
773 tpl_stats->intra_cost = best_intra_cost << TPL_DEP_COST_SCALE_LOG2;
774
775 tpl_stats->srcrf_dist = recon_error << TPL_DEP_COST_SCALE_LOG2;
776 tpl_stats->srcrf_sse = pred_error << TPL_DEP_COST_SCALE_LOG2;
777
778 // Final encode
779 int rate_cost = 0;
780 const YV12_BUFFER_CONFIG *ref_frame_ptr[2];
781
782 ref_frame_ptr[0] =
783 best_mode == NEW_NEWMV
784 ? tpl_data->ref_frame[comp_ref_frames[best_cmp_rf_idx][0]]
785 : best_rf_idx >= 0 ? tpl_data->ref_frame[best_rf_idx] : NULL;
786 ref_frame_ptr[1] =
787 best_mode == NEW_NEWMV
788 ? tpl_data->ref_frame[comp_ref_frames[best_cmp_rf_idx][1]]
789 : NULL;
790 get_rate_distortion(&rate_cost, &recon_error, &pred_error, src_diff, coeff,
791 qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool,
792 rec_stride_pool, tx_size, best_mode, mi_row, mi_col,
793 use_y_only_rate_distortion);
794
795 av1_record_tpl_txfm_block(tpl_txfm_stats, coeff);
796
797 tpl_stats->recrf_dist = recon_error << (TPL_DEP_COST_SCALE_LOG2);
798 tpl_stats->recrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2;
799 if (!is_inter_mode(best_mode)) {
800 tpl_stats->srcrf_dist = recon_error << (TPL_DEP_COST_SCALE_LOG2);
801 tpl_stats->srcrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2;
802 tpl_stats->srcrf_sse = pred_error << TPL_DEP_COST_SCALE_LOG2;
803 }
804
805 tpl_stats->recrf_dist = AOMMAX(tpl_stats->srcrf_dist, tpl_stats->recrf_dist);
806 tpl_stats->recrf_rate = AOMMAX(tpl_stats->srcrf_rate, tpl_stats->recrf_rate);
807
808 if (best_mode == NEW_NEWMV) {
809 ref_frame_ptr[0] = tpl_data->ref_frame[comp_ref_frames[best_cmp_rf_idx][0]];
810 ref_frame_ptr[1] =
811 tpl_data->src_ref_frame[comp_ref_frames[best_cmp_rf_idx][1]];
812 get_rate_distortion(&rate_cost, &recon_error, &pred_error, src_diff, coeff,
813 qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool,
814 rec_stride_pool, tx_size, best_mode, mi_row, mi_col,
815 use_y_only_rate_distortion);
816 tpl_stats->cmp_recrf_dist[0] = recon_error << TPL_DEP_COST_SCALE_LOG2;
817 tpl_stats->cmp_recrf_rate[0] = rate_cost << TPL_DEP_COST_SCALE_LOG2;
818
819 tpl_stats->cmp_recrf_dist[0] =
820 AOMMAX(tpl_stats->srcrf_dist, tpl_stats->cmp_recrf_dist[0]);
821 tpl_stats->cmp_recrf_rate[0] =
822 AOMMAX(tpl_stats->srcrf_rate, tpl_stats->cmp_recrf_rate[0]);
823
824 tpl_stats->cmp_recrf_dist[0] =
825 AOMMIN(tpl_stats->recrf_dist, tpl_stats->cmp_recrf_dist[0]);
826 tpl_stats->cmp_recrf_rate[0] =
827 AOMMIN(tpl_stats->recrf_rate, tpl_stats->cmp_recrf_rate[0]);
828
829 rate_cost = 0;
830 ref_frame_ptr[0] =
831 tpl_data->src_ref_frame[comp_ref_frames[best_cmp_rf_idx][0]];
832 ref_frame_ptr[1] = tpl_data->ref_frame[comp_ref_frames[best_cmp_rf_idx][1]];
833 get_rate_distortion(&rate_cost, &recon_error, &pred_error, src_diff, coeff,
834 qcoeff, dqcoeff, cm, x, ref_frame_ptr, rec_buffer_pool,
835 rec_stride_pool, tx_size, best_mode, mi_row, mi_col,
836 use_y_only_rate_distortion);
837 tpl_stats->cmp_recrf_dist[1] = recon_error << TPL_DEP_COST_SCALE_LOG2;
838 tpl_stats->cmp_recrf_rate[1] = rate_cost << TPL_DEP_COST_SCALE_LOG2;
839
840 tpl_stats->cmp_recrf_dist[1] =
841 AOMMAX(tpl_stats->srcrf_dist, tpl_stats->cmp_recrf_dist[1]);
842 tpl_stats->cmp_recrf_rate[1] =
843 AOMMAX(tpl_stats->srcrf_rate, tpl_stats->cmp_recrf_rate[1]);
844
845 tpl_stats->cmp_recrf_dist[1] =
846 AOMMIN(tpl_stats->recrf_dist, tpl_stats->cmp_recrf_dist[1]);
847 tpl_stats->cmp_recrf_rate[1] =
848 AOMMIN(tpl_stats->recrf_rate, tpl_stats->cmp_recrf_rate[1]);
849 }
850
851 if (best_mode == NEWMV) {
852 tpl_stats->mv[best_rf_idx] = best_mv[0];
853 tpl_stats->ref_frame_index[0] = best_rf_idx;
854 tpl_stats->ref_frame_index[1] = NONE_FRAME;
855 } else if (best_mode == NEW_NEWMV) {
856 tpl_stats->ref_frame_index[0] = comp_ref_frames[best_cmp_rf_idx][0];
857 tpl_stats->ref_frame_index[1] = comp_ref_frames[best_cmp_rf_idx][1];
858 tpl_stats->mv[tpl_stats->ref_frame_index[0]] = best_mv[0];
859 tpl_stats->mv[tpl_stats->ref_frame_index[1]] = best_mv[1];
860 }
861
862 for (int idy = 0; idy < mi_height; ++idy) {
863 for (int idx = 0; idx < mi_width; ++idx) {
864 if ((xd->mb_to_right_edge >> (3 + MI_SIZE_LOG2)) + mi_width > idx &&
865 (xd->mb_to_bottom_edge >> (3 + MI_SIZE_LOG2)) + mi_height > idy) {
866 xd->mi[idx + idy * cm->mi_params.mi_stride] = xd->mi[0];
867 }
868 }
869 }
870
871 // Free temporary buffers.
872 aom_free(predictor8);
873 aom_free(src_diff);
874 aom_free(coeff);
875 aom_free(qcoeff);
876 aom_free(dqcoeff);
877 }
878
round_floor(int ref_pos,int bsize_pix)879 static int round_floor(int ref_pos, int bsize_pix) {
880 int round;
881 if (ref_pos < 0)
882 round = -(1 + (-ref_pos - 1) / bsize_pix);
883 else
884 round = ref_pos / bsize_pix;
885
886 return round;
887 }
888
av1_get_overlap_area(int row_a,int col_a,int row_b,int col_b,int width,int height)889 int av1_get_overlap_area(int row_a, int col_a, int row_b, int col_b, int width,
890 int height) {
891 int min_row = AOMMAX(row_a, row_b);
892 int max_row = AOMMIN(row_a + height, row_b + height);
893 int min_col = AOMMAX(col_a, col_b);
894 int max_col = AOMMIN(col_a + width, col_b + width);
895 if (min_row < max_row && min_col < max_col) {
896 return (max_row - min_row) * (max_col - min_col);
897 }
898 return 0;
899 }
900
av1_tpl_ptr_pos(int mi_row,int mi_col,int stride,uint8_t right_shift)901 int av1_tpl_ptr_pos(int mi_row, int mi_col, int stride, uint8_t right_shift) {
902 return (mi_row >> right_shift) * stride + (mi_col >> right_shift);
903 }
904
av1_delta_rate_cost(int64_t delta_rate,int64_t recrf_dist,int64_t srcrf_dist,int pix_num)905 int64_t av1_delta_rate_cost(int64_t delta_rate, int64_t recrf_dist,
906 int64_t srcrf_dist, int pix_num) {
907 double beta = (double)srcrf_dist / recrf_dist;
908 int64_t rate_cost = delta_rate;
909
910 if (srcrf_dist <= 128) return rate_cost;
911
912 double dr =
913 (double)(delta_rate >> (TPL_DEP_COST_SCALE_LOG2 + AV1_PROB_COST_SHIFT)) /
914 pix_num;
915
916 double log_den = log(beta) / log(2.0) + 2.0 * dr;
917
918 if (log_den > log(10.0) / log(2.0)) {
919 rate_cost = (int64_t)((log(1.0 / beta) * pix_num) / log(2.0) / 2.0);
920 rate_cost <<= (TPL_DEP_COST_SCALE_LOG2 + AV1_PROB_COST_SHIFT);
921 return rate_cost;
922 }
923
924 double num = pow(2.0, log_den);
925 double den = num * beta + (1 - beta) * beta;
926
927 rate_cost = (int64_t)((pix_num * log(num / den)) / log(2.0) / 2.0);
928
929 rate_cost <<= (TPL_DEP_COST_SCALE_LOG2 + AV1_PROB_COST_SHIFT);
930
931 return rate_cost;
932 }
933
tpl_model_update_b(TplParams * const tpl_data,int mi_row,int mi_col,const BLOCK_SIZE bsize,int frame_idx,int ref)934 static AOM_INLINE void tpl_model_update_b(TplParams *const tpl_data, int mi_row,
935 int mi_col, const BLOCK_SIZE bsize,
936 int frame_idx, int ref) {
937 TplDepFrame *tpl_frame_ptr = &tpl_data->tpl_frame[frame_idx];
938 TplDepStats *tpl_ptr = tpl_frame_ptr->tpl_stats_ptr;
939 TplDepFrame *tpl_frame = tpl_data->tpl_frame;
940 const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2;
941 TplDepStats *tpl_stats_ptr = &tpl_ptr[av1_tpl_ptr_pos(
942 mi_row, mi_col, tpl_frame->stride, block_mis_log2)];
943
944 int is_compound = tpl_stats_ptr->ref_frame_index[1] >= 0;
945
946 if (tpl_stats_ptr->ref_frame_index[ref] < 0) return;
947 const int ref_frame_index = tpl_stats_ptr->ref_frame_index[ref];
948 TplDepFrame *ref_tpl_frame =
949 &tpl_frame[tpl_frame[frame_idx].ref_map_index[ref_frame_index]];
950 TplDepStats *ref_stats_ptr = ref_tpl_frame->tpl_stats_ptr;
951
952 if (tpl_frame[frame_idx].ref_map_index[ref_frame_index] < 0) return;
953
954 const FULLPEL_MV full_mv =
955 get_fullmv_from_mv(&tpl_stats_ptr->mv[ref_frame_index].as_mv);
956 const int ref_pos_row = mi_row * MI_SIZE + full_mv.row;
957 const int ref_pos_col = mi_col * MI_SIZE + full_mv.col;
958
959 const int bw = 4 << mi_size_wide_log2[bsize];
960 const int bh = 4 << mi_size_high_log2[bsize];
961 const int mi_height = mi_size_high[bsize];
962 const int mi_width = mi_size_wide[bsize];
963 const int pix_num = bw * bh;
964
965 // top-left on grid block location in pixel
966 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
967 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
968 int block;
969
970 int64_t srcrf_dist = is_compound ? tpl_stats_ptr->cmp_recrf_dist[!ref]
971 : tpl_stats_ptr->srcrf_dist;
972 int64_t srcrf_rate = is_compound ? tpl_stats_ptr->cmp_recrf_rate[!ref]
973 : tpl_stats_ptr->srcrf_rate;
974
975 int64_t cur_dep_dist = tpl_stats_ptr->recrf_dist - srcrf_dist;
976 int64_t mc_dep_dist =
977 (int64_t)(tpl_stats_ptr->mc_dep_dist *
978 ((double)(tpl_stats_ptr->recrf_dist - srcrf_dist) /
979 tpl_stats_ptr->recrf_dist));
980 int64_t delta_rate = tpl_stats_ptr->recrf_rate - srcrf_rate;
981 int64_t mc_dep_rate =
982 av1_delta_rate_cost(tpl_stats_ptr->mc_dep_rate, tpl_stats_ptr->recrf_dist,
983 srcrf_dist, pix_num);
984
985 for (block = 0; block < 4; ++block) {
986 int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
987 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
988
989 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
990 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
991 int overlap_area = av1_get_overlap_area(grid_pos_row, grid_pos_col,
992 ref_pos_row, ref_pos_col, bw, bh);
993 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
994 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
995 assert((1 << block_mis_log2) == mi_height);
996 assert((1 << block_mis_log2) == mi_width);
997 TplDepStats *des_stats = &ref_stats_ptr[av1_tpl_ptr_pos(
998 ref_mi_row, ref_mi_col, ref_tpl_frame->stride, block_mis_log2)];
999 des_stats->mc_dep_dist +=
1000 ((cur_dep_dist + mc_dep_dist) * overlap_area) / pix_num;
1001 des_stats->mc_dep_rate +=
1002 ((delta_rate + mc_dep_rate) * overlap_area) / pix_num;
1003 }
1004 }
1005 }
1006
tpl_model_update(TplParams * const tpl_data,int mi_row,int mi_col,int frame_idx)1007 static AOM_INLINE void tpl_model_update(TplParams *const tpl_data, int mi_row,
1008 int mi_col, int frame_idx) {
1009 const BLOCK_SIZE tpl_stats_block_size =
1010 convert_length_to_bsize(MI_SIZE << tpl_data->tpl_stats_block_mis_log2);
1011 tpl_model_update_b(tpl_data, mi_row, mi_col, tpl_stats_block_size, frame_idx,
1012 0);
1013 tpl_model_update_b(tpl_data, mi_row, mi_col, tpl_stats_block_size, frame_idx,
1014 1);
1015 }
1016
tpl_model_store(TplDepStats * tpl_stats_ptr,int mi_row,int mi_col,int stride,const TplDepStats * src_stats,uint8_t block_mis_log2)1017 static AOM_INLINE void tpl_model_store(TplDepStats *tpl_stats_ptr, int mi_row,
1018 int mi_col, int stride,
1019 const TplDepStats *src_stats,
1020 uint8_t block_mis_log2) {
1021 int index = av1_tpl_ptr_pos(mi_row, mi_col, stride, block_mis_log2);
1022 TplDepStats *tpl_ptr = &tpl_stats_ptr[index];
1023 *tpl_ptr = *src_stats;
1024 tpl_ptr->intra_cost = AOMMAX(1, tpl_ptr->intra_cost);
1025 tpl_ptr->inter_cost = AOMMAX(1, tpl_ptr->inter_cost);
1026 tpl_ptr->srcrf_dist = AOMMAX(1, tpl_ptr->srcrf_dist);
1027 tpl_ptr->srcrf_sse = AOMMAX(1, tpl_ptr->srcrf_sse);
1028 tpl_ptr->recrf_dist = AOMMAX(1, tpl_ptr->recrf_dist);
1029 tpl_ptr->srcrf_rate = AOMMAX(1, tpl_ptr->srcrf_rate);
1030 tpl_ptr->recrf_rate = AOMMAX(1, tpl_ptr->recrf_rate);
1031 tpl_ptr->cmp_recrf_dist[0] = AOMMAX(1, tpl_ptr->cmp_recrf_dist[0]);
1032 tpl_ptr->cmp_recrf_dist[1] = AOMMAX(1, tpl_ptr->cmp_recrf_dist[1]);
1033 tpl_ptr->cmp_recrf_rate[0] = AOMMAX(1, tpl_ptr->cmp_recrf_rate[0]);
1034 tpl_ptr->cmp_recrf_rate[1] = AOMMAX(1, tpl_ptr->cmp_recrf_rate[1]);
1035 }
1036
1037 // Reset the ref and source frame pointers of tpl_data.
tpl_reset_src_ref_frames(TplParams * tpl_data)1038 static AOM_INLINE void tpl_reset_src_ref_frames(TplParams *tpl_data) {
1039 for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
1040 tpl_data->ref_frame[i] = NULL;
1041 tpl_data->src_ref_frame[i] = NULL;
1042 }
1043 }
1044
get_gop_length(const GF_GROUP * gf_group)1045 static AOM_INLINE int get_gop_length(const GF_GROUP *gf_group) {
1046 int gop_length = AOMMIN(gf_group->size, MAX_TPL_FRAME_IDX - 1);
1047 return gop_length;
1048 }
1049
1050 // Initialize the mc_flow parameters used in computing tpl data.
init_mc_flow_dispenser(AV1_COMP * cpi,int frame_idx,int pframe_qindex)1051 static AOM_INLINE void init_mc_flow_dispenser(AV1_COMP *cpi, int frame_idx,
1052 int pframe_qindex) {
1053 TplParams *const tpl_data = &cpi->ppi->tpl_data;
1054 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
1055 const YV12_BUFFER_CONFIG *this_frame = tpl_frame->gf_picture;
1056 const YV12_BUFFER_CONFIG *ref_frames_ordered[INTER_REFS_PER_FRAME];
1057 uint32_t ref_frame_display_indices[INTER_REFS_PER_FRAME];
1058 const GF_GROUP *gf_group = &cpi->ppi->gf_group;
1059 int ref_pruning_enabled = is_frame_eligible_for_ref_pruning(
1060 gf_group, cpi->sf.inter_sf.selective_ref_frame,
1061 cpi->sf.tpl_sf.prune_ref_frames_in_tpl, frame_idx);
1062 int gop_length = get_gop_length(gf_group);
1063 int ref_frame_flags;
1064 AV1_COMMON *cm = &cpi->common;
1065 int rdmult, idx;
1066 ThreadData *td = &cpi->td;
1067 MACROBLOCK *x = &td->mb;
1068 MACROBLOCKD *xd = &x->e_mbd;
1069 TplTxfmStats *tpl_txfm_stats = &td->tpl_txfm_stats;
1070 tpl_data->frame_idx = frame_idx;
1071 tpl_reset_src_ref_frames(tpl_data);
1072 av1_tile_init(&xd->tile, cm, 0, 0);
1073
1074 // Setup scaling factor
1075 av1_setup_scale_factors_for_frame(
1076 &tpl_data->sf, this_frame->y_crop_width, this_frame->y_crop_height,
1077 this_frame->y_crop_width, this_frame->y_crop_height);
1078
1079 xd->cur_buf = this_frame;
1080
1081 for (idx = 0; idx < INTER_REFS_PER_FRAME; ++idx) {
1082 TplDepFrame *tpl_ref_frame =
1083 &tpl_data->tpl_frame[tpl_frame->ref_map_index[idx]];
1084 tpl_data->ref_frame[idx] = tpl_ref_frame->rec_picture;
1085 tpl_data->src_ref_frame[idx] = tpl_ref_frame->gf_picture;
1086 ref_frame_display_indices[idx] = tpl_ref_frame->frame_display_index;
1087 }
1088
1089 // Store the reference frames based on priority order
1090 for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
1091 ref_frames_ordered[i] =
1092 tpl_data->ref_frame[ref_frame_priority_order[i] - 1];
1093 }
1094
1095 // Work out which reference frame slots may be used.
1096 ref_frame_flags =
1097 get_ref_frame_flags(&cpi->sf, is_one_pass_rt_params(cpi),
1098 ref_frames_ordered, cpi->ext_flags.ref_frame_flags);
1099
1100 enforce_max_ref_frames(cpi, &ref_frame_flags, ref_frame_display_indices,
1101 tpl_frame->frame_display_index);
1102
1103 // Prune reference frames
1104 for (idx = 0; idx < INTER_REFS_PER_FRAME; ++idx) {
1105 if ((ref_frame_flags & (1 << idx)) == 0) {
1106 tpl_data->ref_frame[idx] = NULL;
1107 }
1108 }
1109
1110 // Skip motion estimation w.r.t. reference frames which are not
1111 // considered in RD search, using "selective_ref_frame" speed feature.
1112 // The reference frame pruning is not enabled for frames beyond the gop
1113 // length, as there are fewer reference frames and the reference frames
1114 // differ from the frames considered during RD search.
1115 if (ref_pruning_enabled && (frame_idx < gop_length)) {
1116 for (idx = 0; idx < INTER_REFS_PER_FRAME; ++idx) {
1117 const MV_REFERENCE_FRAME refs[2] = { idx + 1, NONE_FRAME };
1118 if (prune_ref_by_selective_ref_frame(cpi, NULL, refs,
1119 ref_frame_display_indices)) {
1120 tpl_data->ref_frame[idx] = NULL;
1121 }
1122 }
1123 }
1124
1125 // Make a temporary mbmi for tpl model
1126 MB_MODE_INFO mbmi;
1127 memset(&mbmi, 0, sizeof(mbmi));
1128 MB_MODE_INFO *mbmi_ptr = &mbmi;
1129 xd->mi = &mbmi_ptr;
1130
1131 xd->block_ref_scale_factors[0] = &tpl_data->sf;
1132 xd->block_ref_scale_factors[1] = &tpl_data->sf;
1133
1134 const int base_qindex = pframe_qindex;
1135 // Get rd multiplier set up.
1136 rdmult = (int)av1_compute_rd_mult(cpi, base_qindex);
1137 if (rdmult < 1) rdmult = 1;
1138 av1_set_error_per_bit(&x->errorperbit, rdmult);
1139 av1_set_sad_per_bit(cpi, &x->sadperbit, base_qindex);
1140
1141 tpl_frame->is_valid = 1;
1142
1143 cm->quant_params.base_qindex = base_qindex;
1144 av1_frame_init_quantizer(cpi);
1145
1146 const BitDepthInfo bd_info = get_bit_depth_info(xd);
1147 const FRAME_UPDATE_TYPE update_type =
1148 gf_group->update_type[cpi->gf_frame_index];
1149 tpl_frame->base_rdmult = av1_compute_rd_mult_based_on_qindex(
1150 bd_info.bit_depth, update_type, pframe_qindex) /
1151 6;
1152
1153 av1_init_tpl_txfm_stats(tpl_txfm_stats);
1154 }
1155
1156 // This function stores the motion estimation dependencies of all the blocks in
1157 // a row
av1_mc_flow_dispenser_row(AV1_COMP * cpi,TplTxfmStats * tpl_txfm_stats,MACROBLOCK * x,int mi_row,BLOCK_SIZE bsize,TX_SIZE tx_size)1158 void av1_mc_flow_dispenser_row(AV1_COMP *cpi, TplTxfmStats *tpl_txfm_stats,
1159 MACROBLOCK *x, int mi_row, BLOCK_SIZE bsize,
1160 TX_SIZE tx_size) {
1161 AV1_COMMON *const cm = &cpi->common;
1162 MultiThreadInfo *const mt_info = &cpi->mt_info;
1163 AV1TplRowMultiThreadInfo *const tpl_row_mt = &mt_info->tpl_row_mt;
1164 const CommonModeInfoParams *const mi_params = &cm->mi_params;
1165 const int mi_width = mi_size_wide[bsize];
1166 TplParams *const tpl_data = &cpi->ppi->tpl_data;
1167 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[tpl_data->frame_idx];
1168 MACROBLOCKD *xd = &x->e_mbd;
1169
1170 const int tplb_cols_in_tile =
1171 ROUND_POWER_OF_TWO(mi_params->mi_cols, mi_size_wide_log2[bsize]);
1172 const int tplb_row = ROUND_POWER_OF_TWO(mi_row, mi_size_high_log2[bsize]);
1173 assert(mi_size_high[bsize] == (1 << tpl_data->tpl_stats_block_mis_log2));
1174 assert(mi_size_wide[bsize] == (1 << tpl_data->tpl_stats_block_mis_log2));
1175
1176 for (int mi_col = 0, tplb_col_in_tile = 0; mi_col < mi_params->mi_cols;
1177 mi_col += mi_width, tplb_col_in_tile++) {
1178 (*tpl_row_mt->sync_read_ptr)(&tpl_data->tpl_mt_sync, tplb_row,
1179 tplb_col_in_tile);
1180 TplDepStats tpl_stats;
1181
1182 // Motion estimation column boundary
1183 av1_set_mv_col_limits(mi_params, &x->mv_limits, mi_col, mi_width,
1184 tpl_data->border_in_pixels);
1185 xd->mb_to_left_edge = -GET_MV_SUBPEL(mi_col * MI_SIZE);
1186 xd->mb_to_right_edge =
1187 GET_MV_SUBPEL(mi_params->mi_cols - mi_width - mi_col);
1188 mode_estimation(cpi, tpl_txfm_stats, x, mi_row, mi_col, bsize, tx_size,
1189 &tpl_stats);
1190
1191 // Motion flow dependency dispenser.
1192 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, tpl_frame->stride,
1193 &tpl_stats, tpl_data->tpl_stats_block_mis_log2);
1194 (*tpl_row_mt->sync_write_ptr)(&tpl_data->tpl_mt_sync, tplb_row,
1195 tplb_col_in_tile, tplb_cols_in_tile);
1196 }
1197 }
1198
mc_flow_dispenser(AV1_COMP * cpi)1199 static AOM_INLINE void mc_flow_dispenser(AV1_COMP *cpi) {
1200 AV1_COMMON *cm = &cpi->common;
1201 const CommonModeInfoParams *const mi_params = &cm->mi_params;
1202 ThreadData *td = &cpi->td;
1203 MACROBLOCK *x = &td->mb;
1204 MACROBLOCKD *xd = &x->e_mbd;
1205 const BLOCK_SIZE bsize =
1206 convert_length_to_bsize(cpi->ppi->tpl_data.tpl_bsize_1d);
1207 const TX_SIZE tx_size = max_txsize_lookup[bsize];
1208 const int mi_height = mi_size_high[bsize];
1209 for (int mi_row = 0; mi_row < mi_params->mi_rows; mi_row += mi_height) {
1210 // Motion estimation row boundary
1211 av1_set_mv_row_limits(mi_params, &x->mv_limits, mi_row, mi_height,
1212 cpi->ppi->tpl_data.border_in_pixels);
1213 xd->mb_to_top_edge = -GET_MV_SUBPEL(mi_row * MI_SIZE);
1214 xd->mb_to_bottom_edge =
1215 GET_MV_SUBPEL((mi_params->mi_rows - mi_height - mi_row) * MI_SIZE);
1216 av1_mc_flow_dispenser_row(cpi, &td->tpl_txfm_stats, x, mi_row, bsize,
1217 tx_size);
1218 }
1219 }
1220
mc_flow_synthesizer(TplParams * tpl_data,int frame_idx,int mi_rows,int mi_cols)1221 static void mc_flow_synthesizer(TplParams *tpl_data, int frame_idx, int mi_rows,
1222 int mi_cols) {
1223 if (!frame_idx) {
1224 return;
1225 }
1226 const BLOCK_SIZE bsize = convert_length_to_bsize(tpl_data->tpl_bsize_1d);
1227 const int mi_height = mi_size_high[bsize];
1228 const int mi_width = mi_size_wide[bsize];
1229 assert(mi_height == (1 << tpl_data->tpl_stats_block_mis_log2));
1230 assert(mi_width == (1 << tpl_data->tpl_stats_block_mis_log2));
1231
1232 for (int mi_row = 0; mi_row < mi_rows; mi_row += mi_height) {
1233 for (int mi_col = 0; mi_col < mi_cols; mi_col += mi_width) {
1234 tpl_model_update(tpl_data, mi_row, mi_col, frame_idx);
1235 }
1236 }
1237 }
1238
init_gop_frames_for_tpl(AV1_COMP * cpi,const EncodeFrameParams * const init_frame_params,GF_GROUP * gf_group,int gop_eval,int * tpl_group_frames,const EncodeFrameInput * const frame_input,int * pframe_qindex)1239 static AOM_INLINE void init_gop_frames_for_tpl(
1240 AV1_COMP *cpi, const EncodeFrameParams *const init_frame_params,
1241 GF_GROUP *gf_group, int gop_eval, int *tpl_group_frames,
1242 const EncodeFrameInput *const frame_input, int *pframe_qindex) {
1243 AV1_COMMON *cm = &cpi->common;
1244 int cur_frame_idx = cpi->gf_frame_index;
1245 *pframe_qindex = 0;
1246
1247 #if CONFIG_FRAME_PARALLEL_ENCODE
1248 RefFrameMapPair ref_frame_map_pairs[REF_FRAMES];
1249 init_ref_map_pair(cpi, ref_frame_map_pairs);
1250 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1251
1252 RefBufferStack ref_buffer_stack = cpi->ref_buffer_stack;
1253 int remapped_ref_idx[REF_FRAMES];
1254
1255 EncodeFrameParams frame_params = *init_frame_params;
1256 TplParams *const tpl_data = &cpi->ppi->tpl_data;
1257
1258 int ref_picture_map[REF_FRAMES];
1259
1260 for (int i = 0; i < REF_FRAMES; ++i) {
1261 if (frame_params.frame_type == KEY_FRAME) {
1262 tpl_data->tpl_frame[-i - 1].gf_picture = NULL;
1263 tpl_data->tpl_frame[-i - 1].rec_picture = NULL;
1264 tpl_data->tpl_frame[-i - 1].frame_display_index = 0;
1265 } else {
1266 tpl_data->tpl_frame[-i - 1].gf_picture = &cm->ref_frame_map[i]->buf;
1267 tpl_data->tpl_frame[-i - 1].rec_picture = &cm->ref_frame_map[i]->buf;
1268 tpl_data->tpl_frame[-i - 1].frame_display_index =
1269 cm->ref_frame_map[i]->display_order_hint;
1270 }
1271
1272 ref_picture_map[i] = -i - 1;
1273 }
1274
1275 *tpl_group_frames = cur_frame_idx;
1276
1277 int gf_index;
1278 int anc_frame_offset = gop_eval ? 0 : gf_group->cur_frame_idx[cur_frame_idx];
1279 int process_frame_count = 0;
1280 const int gop_length = get_gop_length(gf_group);
1281
1282 for (gf_index = cur_frame_idx; gf_index < gop_length; ++gf_index) {
1283 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_index];
1284 FRAME_UPDATE_TYPE frame_update_type = gf_group->update_type[gf_index];
1285 int frame_display_index = gf_index == gf_group->size
1286 ? cpi->ppi->p_rc.baseline_gf_interval
1287 : gf_group->cur_frame_idx[gf_index] +
1288 gf_group->arf_src_offset[gf_index];
1289
1290 int lookahead_index = frame_display_index - anc_frame_offset;
1291
1292 frame_params.show_frame = frame_update_type != ARF_UPDATE &&
1293 frame_update_type != INTNL_ARF_UPDATE;
1294 frame_params.show_existing_frame =
1295 frame_update_type == INTNL_OVERLAY_UPDATE ||
1296 frame_update_type == OVERLAY_UPDATE;
1297 frame_params.frame_type = gf_group->frame_type[gf_index];
1298
1299 if (frame_update_type == LF_UPDATE)
1300 *pframe_qindex = gf_group->q_val[gf_index];
1301
1302 struct lookahead_entry *buf;
1303 if (gf_index == cur_frame_idx) {
1304 buf = av1_lookahead_peek(cpi->ppi->lookahead, lookahead_index,
1305 cpi->compressor_stage);
1306 tpl_frame->gf_picture = gop_eval ? &buf->img : frame_input->source;
1307 } else {
1308 buf = av1_lookahead_peek(cpi->ppi->lookahead, lookahead_index,
1309 cpi->compressor_stage);
1310 if (buf == NULL) break;
1311 tpl_frame->gf_picture = &buf->img;
1312 }
1313 if (gop_eval && cpi->rc.frames_since_key > 0 &&
1314 gf_group->arf_index == gf_index)
1315 tpl_frame->gf_picture = &cpi->ppi->alt_ref_buffer;
1316
1317 // 'cm->current_frame.frame_number' is the display number
1318 // of the current frame.
1319 // 'anc_frame_offset' is the number of frames displayed so
1320 // far within the gf group. 'cm->current_frame.frame_number -
1321 // anc_frame_offset' is the offset of the first frame in the gf group.
1322 // 'frame display index' is frame offset within the gf group.
1323 // 'frame_display_index + cm->current_frame.frame_number - anc_frame_offset'
1324 // is the display index of the frame.
1325 tpl_frame->frame_display_index =
1326 frame_display_index + cm->current_frame.frame_number - anc_frame_offset;
1327 assert(buf->display_idx == cpi->frame_index_set.show_frame_count -
1328 anc_frame_offset + frame_display_index);
1329
1330 if (frame_update_type != OVERLAY_UPDATE &&
1331 frame_update_type != INTNL_OVERLAY_UPDATE) {
1332 tpl_frame->rec_picture = &tpl_data->tpl_rec_pool[process_frame_count];
1333 tpl_frame->tpl_stats_ptr = tpl_data->tpl_stats_pool[process_frame_count];
1334 ++process_frame_count;
1335 }
1336 #if CONFIG_FRAME_PARALLEL_ENCODE
1337 const int true_disp = (int)(tpl_frame->frame_display_index);
1338 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1339
1340 av1_get_ref_frames(&ref_buffer_stack,
1341 #if CONFIG_FRAME_PARALLEL_ENCODE
1342 ref_frame_map_pairs, true_disp,
1343 #if CONFIG_FRAME_PARALLEL_ENCODE_2
1344 cpi, gf_index, 0,
1345 #endif // CONFIG_FRAME_PARALLEL_ENCODE_2
1346 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1347 remapped_ref_idx);
1348
1349 int refresh_mask = av1_get_refresh_frame_flags(
1350 cpi, &frame_params, frame_update_type, gf_index,
1351 #if CONFIG_FRAME_PARALLEL_ENCODE
1352 true_disp, ref_frame_map_pairs,
1353 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1354 &ref_buffer_stack);
1355
1356 #if CONFIG_FRAME_PARALLEL_ENCODE
1357 // Make the frames marked as is_frame_non_ref to non-reference frames.
1358 if (cpi->ppi->gf_group.is_frame_non_ref[gf_index]) refresh_mask = 0;
1359 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1360
1361 int refresh_frame_map_index = av1_get_refresh_ref_frame_map(refresh_mask);
1362 #if !CONFIG_FRAME_PARALLEL_ENCODE
1363 av1_update_ref_frame_map(cpi, frame_update_type,
1364 gf_group->refbuf_state[gf_index],
1365 refresh_frame_map_index, &ref_buffer_stack);
1366 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1367
1368 #if CONFIG_FRAME_PARALLEL_ENCODE
1369 if (refresh_frame_map_index < REF_FRAMES &&
1370 refresh_frame_map_index != INVALID_IDX) {
1371 ref_frame_map_pairs[refresh_frame_map_index].disp_order =
1372 AOMMAX(0, true_disp);
1373 ref_frame_map_pairs[refresh_frame_map_index].pyr_level =
1374 get_true_pyr_level(gf_group->layer_depth[gf_index], true_disp,
1375 cpi->ppi->gf_group.max_layer_depth);
1376 }
1377 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1378
1379 for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i)
1380 tpl_frame->ref_map_index[i - LAST_FRAME] =
1381 ref_picture_map[remapped_ref_idx[i - LAST_FRAME]];
1382
1383 if (refresh_mask) ref_picture_map[refresh_frame_map_index] = gf_index;
1384
1385 ++*tpl_group_frames;
1386 }
1387
1388 if (cpi->rc.frames_since_key == 0) return;
1389
1390 const int tpl_extend = cpi->oxcf.gf_cfg.lag_in_frames - MAX_GF_INTERVAL;
1391 int extend_frame_count = 0;
1392 int extend_frame_length = AOMMIN(
1393 tpl_extend, cpi->rc.frames_to_key - cpi->ppi->p_rc.baseline_gf_interval);
1394
1395 int frame_display_index = gf_group->cur_frame_idx[gop_length - 1] +
1396 gf_group->arf_src_offset[gop_length - 1] + 1;
1397
1398 for (;
1399 gf_index < MAX_TPL_FRAME_IDX && extend_frame_count < extend_frame_length;
1400 ++gf_index) {
1401 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_index];
1402 FRAME_UPDATE_TYPE frame_update_type = LF_UPDATE;
1403 frame_params.show_frame = frame_update_type != ARF_UPDATE &&
1404 frame_update_type != INTNL_ARF_UPDATE;
1405 frame_params.show_existing_frame =
1406 frame_update_type == INTNL_OVERLAY_UPDATE;
1407 frame_params.frame_type = INTER_FRAME;
1408
1409 int lookahead_index = frame_display_index - anc_frame_offset;
1410 struct lookahead_entry *buf = av1_lookahead_peek(
1411 cpi->ppi->lookahead, lookahead_index, cpi->compressor_stage);
1412
1413 if (buf == NULL) break;
1414
1415 tpl_frame->gf_picture = &buf->img;
1416 tpl_frame->rec_picture = &tpl_data->tpl_rec_pool[process_frame_count];
1417 tpl_frame->tpl_stats_ptr = tpl_data->tpl_stats_pool[process_frame_count];
1418 // 'cm->current_frame.frame_number' is the display number
1419 // of the current frame.
1420 // 'anc_frame_offset' is the number of frames displayed so
1421 // far within the gf group. 'cm->current_frame.frame_number -
1422 // anc_frame_offset' is the offset of the first frame in the gf group.
1423 // 'frame display index' is frame offset within the gf group.
1424 // 'frame_display_index + cm->current_frame.frame_number - anc_frame_offset'
1425 // is the display index of the frame.
1426 tpl_frame->frame_display_index =
1427 frame_display_index + cm->current_frame.frame_number - anc_frame_offset;
1428
1429 ++process_frame_count;
1430
1431 gf_group->update_type[gf_index] = LF_UPDATE;
1432 gf_group->q_val[gf_index] = *pframe_qindex;
1433 #if CONFIG_FRAME_PARALLEL_ENCODE
1434 const int true_disp = (int)(tpl_frame->frame_display_index);
1435 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1436 av1_get_ref_frames(&ref_buffer_stack,
1437 #if CONFIG_FRAME_PARALLEL_ENCODE
1438 ref_frame_map_pairs, true_disp,
1439 #if CONFIG_FRAME_PARALLEL_ENCODE_2
1440 cpi, gf_index, 0,
1441 #endif // CONFIG_FRAME_PARALLEL_ENCODE_2
1442 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1443 remapped_ref_idx);
1444 int refresh_mask = av1_get_refresh_frame_flags(
1445 cpi, &frame_params, frame_update_type, gf_index,
1446 #if CONFIG_FRAME_PARALLEL_ENCODE
1447 true_disp, ref_frame_map_pairs,
1448 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1449 &ref_buffer_stack);
1450 int refresh_frame_map_index = av1_get_refresh_ref_frame_map(refresh_mask);
1451 #if !CONFIG_FRAME_PARALLEL_ENCODE
1452 av1_update_ref_frame_map(cpi, frame_update_type,
1453 gf_group->refbuf_state[gf_index],
1454 refresh_frame_map_index, &ref_buffer_stack);
1455 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1456
1457 #if CONFIG_FRAME_PARALLEL_ENCODE
1458 if (refresh_frame_map_index < REF_FRAMES &&
1459 refresh_frame_map_index != INVALID_IDX) {
1460 ref_frame_map_pairs[refresh_frame_map_index].disp_order =
1461 AOMMAX(0, true_disp);
1462 ref_frame_map_pairs[refresh_frame_map_index].pyr_level =
1463 get_true_pyr_level(gf_group->layer_depth[gf_index], true_disp,
1464 cpi->ppi->gf_group.max_layer_depth);
1465 }
1466 #endif // CONFIG_FRAME_PARALLEL_ENCODE
1467
1468 for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i)
1469 tpl_frame->ref_map_index[i - LAST_FRAME] =
1470 ref_picture_map[remapped_ref_idx[i - LAST_FRAME]];
1471
1472 tpl_frame->ref_map_index[ALTREF_FRAME - LAST_FRAME] = -1;
1473 tpl_frame->ref_map_index[LAST3_FRAME - LAST_FRAME] = -1;
1474 tpl_frame->ref_map_index[BWDREF_FRAME - LAST_FRAME] = -1;
1475 tpl_frame->ref_map_index[ALTREF2_FRAME - LAST_FRAME] = -1;
1476
1477 if (refresh_mask) ref_picture_map[refresh_frame_map_index] = gf_index;
1478
1479 ++*tpl_group_frames;
1480 ++extend_frame_count;
1481 ++frame_display_index;
1482 }
1483 }
1484
av1_init_tpl_stats(TplParams * const tpl_data)1485 void av1_init_tpl_stats(TplParams *const tpl_data) {
1486 int frame_idx;
1487 tpl_data->ready = 0;
1488 set_tpl_stats_block_size(&tpl_data->tpl_stats_block_mis_log2,
1489 &tpl_data->tpl_bsize_1d);
1490 for (frame_idx = 0; frame_idx < MAX_LAG_BUFFERS; ++frame_idx) {
1491 TplDepFrame *tpl_frame = &tpl_data->tpl_stats_buffer[frame_idx];
1492 if (tpl_data->tpl_stats_pool[frame_idx] == NULL) continue;
1493 memset(tpl_data->tpl_stats_pool[frame_idx], 0,
1494 tpl_frame->height * tpl_frame->width *
1495 sizeof(*tpl_frame->tpl_stats_ptr));
1496 tpl_frame->is_valid = 0;
1497 }
1498 #if CONFIG_BITRATE_ACCURACY
1499 tpl_data->estimated_gop_bitrate = 0;
1500 tpl_data->actual_gop_bitrate = 0;
1501 #endif
1502 }
1503
av1_tpl_stats_ready(const TplParams * tpl_data,int gf_frame_index)1504 int av1_tpl_stats_ready(const TplParams *tpl_data, int gf_frame_index) {
1505 if (tpl_data->ready == 0) {
1506 return 0;
1507 }
1508 if (gf_frame_index >= MAX_TPL_FRAME_IDX) {
1509 assert(gf_frame_index < MAX_TPL_FRAME_IDX && "Invalid gf_frame_index\n");
1510 return 0;
1511 }
1512 return tpl_data->tpl_frame[gf_frame_index].is_valid;
1513 }
1514
eval_gop_length(double * beta,int gop_eval)1515 static AOM_INLINE int eval_gop_length(double *beta, int gop_eval) {
1516 switch (gop_eval) {
1517 case 1:
1518 // Allow larger GOP size if the base layer ARF has higher dependency
1519 // factor than the intermediate ARF and both ARFs have reasonably high
1520 // dependency factors.
1521 return (beta[0] >= beta[1] + 0.7) && beta[0] > 8.0;
1522 case 2:
1523 if ((beta[0] >= beta[1] + 0.4) && beta[0] > 1.6)
1524 return 1; // Don't shorten the gf interval
1525 else if ((beta[0] < beta[1] + 0.1) || beta[0] <= 1.4)
1526 return 0; // Shorten the gf interval
1527 else
1528 return 2; // Cannot decide the gf interval, so redo the
1529 // tpl stats calculation.
1530 case 3: return beta[0] > 1.1;
1531 default: return 2;
1532 }
1533 }
1534
1535 // TODO(jingning): Restructure av1_rc_pick_q_and_bounds() to narrow down
1536 // the scope of input arguments.
av1_tpl_preload_rc_estimate(AV1_COMP * cpi,const EncodeFrameParams * const frame_params)1537 void av1_tpl_preload_rc_estimate(AV1_COMP *cpi,
1538 const EncodeFrameParams *const frame_params) {
1539 AV1_COMMON *cm = &cpi->common;
1540 GF_GROUP *gf_group = &cpi->ppi->gf_group;
1541 int bottom_index, top_index;
1542 cm->current_frame.frame_type = frame_params->frame_type;
1543 for (int gf_index = cpi->gf_frame_index; gf_index < gf_group->size;
1544 ++gf_index) {
1545 cm->current_frame.frame_type = gf_group->frame_type[gf_index];
1546 cm->show_frame = gf_group->update_type[gf_index] != ARF_UPDATE &&
1547 gf_group->update_type[gf_index] != INTNL_ARF_UPDATE;
1548 gf_group->q_val[gf_index] = av1_rc_pick_q_and_bounds(
1549 cpi, cm->width, cm->height, gf_index, &bottom_index, &top_index);
1550 }
1551 }
1552
av1_tpl_setup_stats(AV1_COMP * cpi,int gop_eval,const EncodeFrameParams * const frame_params,const EncodeFrameInput * const frame_input)1553 int av1_tpl_setup_stats(AV1_COMP *cpi, int gop_eval,
1554 const EncodeFrameParams *const frame_params,
1555 const EncodeFrameInput *const frame_input) {
1556 #if CONFIG_COLLECT_COMPONENT_TIMING
1557 start_timing(cpi, av1_tpl_setup_stats_time);
1558 #endif
1559 AV1_COMMON *cm = &cpi->common;
1560 MultiThreadInfo *const mt_info = &cpi->mt_info;
1561 AV1TplRowMultiThreadInfo *const tpl_row_mt = &mt_info->tpl_row_mt;
1562 GF_GROUP *gf_group = &cpi->ppi->gf_group;
1563 EncodeFrameParams this_frame_params = *frame_params;
1564 TplParams *const tpl_data = &cpi->ppi->tpl_data;
1565 int approx_gop_eval = (gop_eval > 1);
1566 int num_arf_layers = MAX_ARF_LAYERS;
1567
1568 // When gop_eval is set to 2, tpl stats calculation is done for ARFs from base
1569 // layer, (base+1) layer and (base+2) layer. When gop_eval is set to 3,
1570 // tpl stats calculation is limited to ARFs from base layer and (base+1)
1571 // layer.
1572 if (approx_gop_eval) num_arf_layers = (gop_eval == 2) ? 3 : 2;
1573
1574 if (cpi->superres_mode != AOM_SUPERRES_NONE) {
1575 assert(cpi->superres_mode != AOM_SUPERRES_AUTO);
1576 av1_init_tpl_stats(tpl_data);
1577 return 0;
1578 }
1579
1580 cm->current_frame.frame_type = frame_params->frame_type;
1581 for (int gf_index = cpi->gf_frame_index; gf_index < gf_group->size;
1582 ++gf_index) {
1583 cm->current_frame.frame_type = gf_group->frame_type[gf_index];
1584 av1_configure_buffer_updates(cpi, &this_frame_params.refresh_frame,
1585 gf_group->update_type[gf_index],
1586 gf_group->refbuf_state[gf_index], 0);
1587
1588 memcpy(&cpi->refresh_frame, &this_frame_params.refresh_frame,
1589 sizeof(cpi->refresh_frame));
1590 }
1591
1592 int pframe_qindex;
1593 int tpl_gf_group_frames;
1594 init_gop_frames_for_tpl(cpi, frame_params, gf_group, gop_eval,
1595 &tpl_gf_group_frames, frame_input, &pframe_qindex);
1596
1597 cpi->ppi->p_rc.base_layer_qp = pframe_qindex;
1598
1599 av1_init_tpl_stats(tpl_data);
1600
1601 tpl_row_mt->sync_read_ptr = av1_tpl_row_mt_sync_read_dummy;
1602 tpl_row_mt->sync_write_ptr = av1_tpl_row_mt_sync_write_dummy;
1603
1604 av1_setup_scale_factors_for_frame(&cm->sf_identity, cm->width, cm->height,
1605 cm->width, cm->height);
1606
1607 if (frame_params->frame_type == KEY_FRAME) {
1608 av1_init_mv_probs(cm);
1609 }
1610 av1_fill_mv_costs(&cm->fc->nmvc, cm->features.cur_frame_force_integer_mv,
1611 cm->features.allow_high_precision_mv, cpi->td.mb.mv_costs);
1612
1613 const int gop_length = get_gop_length(gf_group);
1614 // Backward propagation from tpl_group_frames to 1.
1615 for (int frame_idx = cpi->gf_frame_index; frame_idx < tpl_gf_group_frames;
1616 ++frame_idx) {
1617 if (gf_group->update_type[frame_idx] == INTNL_OVERLAY_UPDATE ||
1618 gf_group->update_type[frame_idx] == OVERLAY_UPDATE)
1619 continue;
1620
1621 // When approx_gop_eval = 1, skip tpl stats calculation for higher layer
1622 // frames and for frames beyond gop length.
1623 if (approx_gop_eval && (gf_group->layer_depth[frame_idx] > num_arf_layers ||
1624 frame_idx >= gop_length))
1625 continue;
1626
1627 init_mc_flow_dispenser(cpi, frame_idx, pframe_qindex);
1628 if (mt_info->num_workers > 1) {
1629 tpl_row_mt->sync_read_ptr = av1_tpl_row_mt_sync_read;
1630 tpl_row_mt->sync_write_ptr = av1_tpl_row_mt_sync_write;
1631 av1_mc_flow_dispenser_mt(cpi);
1632 } else {
1633 mc_flow_dispenser(cpi);
1634 }
1635 av1_tpl_store_txfm_stats(tpl_data, &cpi->td.tpl_txfm_stats, frame_idx);
1636
1637 aom_extend_frame_borders(tpl_data->tpl_frame[frame_idx].rec_picture,
1638 av1_num_planes(cm));
1639 }
1640
1641 for (int frame_idx = tpl_gf_group_frames - 1;
1642 frame_idx >= cpi->gf_frame_index; --frame_idx) {
1643 if (gf_group->update_type[frame_idx] == INTNL_OVERLAY_UPDATE ||
1644 gf_group->update_type[frame_idx] == OVERLAY_UPDATE)
1645 continue;
1646
1647 if (approx_gop_eval && (gf_group->layer_depth[frame_idx] > num_arf_layers ||
1648 frame_idx >= gop_length))
1649 continue;
1650
1651 mc_flow_synthesizer(tpl_data, frame_idx, cm->mi_params.mi_rows,
1652 cm->mi_params.mi_cols);
1653 }
1654
1655 av1_configure_buffer_updates(cpi, &this_frame_params.refresh_frame,
1656 gf_group->update_type[cpi->gf_frame_index],
1657 gf_group->update_type[cpi->gf_frame_index], 0);
1658 cm->current_frame.frame_type = frame_params->frame_type;
1659 cm->show_frame = frame_params->show_frame;
1660
1661 #if CONFIG_COLLECT_COMPONENT_TIMING
1662 // Record the time if the function returns.
1663 if (cpi->common.tiles.large_scale || gf_group->max_layer_depth_allowed == 0 ||
1664 !gop_eval)
1665 end_timing(cpi, av1_tpl_setup_stats_time);
1666 #endif
1667
1668 if (!approx_gop_eval) {
1669 tpl_data->ready = 1;
1670 }
1671 if (cpi->common.tiles.large_scale) return 0;
1672 if (gf_group->max_layer_depth_allowed == 0) return 1;
1673 if (!gop_eval) return 0;
1674 assert(gf_group->arf_index >= 0);
1675
1676 double beta[2] = { 0.0 };
1677 for (int frame_idx = gf_group->arf_index;
1678 frame_idx <= AOMMIN(tpl_gf_group_frames - 1, gf_group->arf_index + 1);
1679 ++frame_idx) {
1680 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
1681 TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
1682 int tpl_stride = tpl_frame->stride;
1683 int64_t intra_cost_base = 0;
1684 int64_t mc_dep_cost_base = 0;
1685 const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
1686 const int row_step = step;
1687 const int col_step_sr =
1688 coded_to_superres_mi(step, cm->superres_scale_denominator);
1689 const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
1690
1691 for (int row = 0; row < cm->mi_params.mi_rows; row += row_step) {
1692 for (int col = 0; col < mi_cols_sr; col += col_step_sr) {
1693 TplDepStats *this_stats = &tpl_stats[av1_tpl_ptr_pos(
1694 row, col, tpl_stride, tpl_data->tpl_stats_block_mis_log2)];
1695 int64_t mc_dep_delta =
1696 RDCOST(tpl_frame->base_rdmult, this_stats->mc_dep_rate,
1697 this_stats->mc_dep_dist);
1698 intra_cost_base += (this_stats->recrf_dist << RDDIV_BITS);
1699 mc_dep_cost_base +=
1700 (this_stats->recrf_dist << RDDIV_BITS) + mc_dep_delta;
1701 }
1702 }
1703 if (intra_cost_base == 0) {
1704 // This should happen very rarely and if it happens, assign a dummy value
1705 // to it since it probably wouldn't influence things much
1706 beta[frame_idx - gf_group->arf_index] = 0;
1707 } else {
1708 beta[frame_idx - gf_group->arf_index] =
1709 (double)mc_dep_cost_base / intra_cost_base;
1710 }
1711 }
1712
1713 #if CONFIG_COLLECT_COMPONENT_TIMING
1714 end_timing(cpi, av1_tpl_setup_stats_time);
1715 #endif
1716 return eval_gop_length(beta, gop_eval);
1717 }
1718
av1_tpl_rdmult_setup(AV1_COMP * cpi)1719 void av1_tpl_rdmult_setup(AV1_COMP *cpi) {
1720 const AV1_COMMON *const cm = &cpi->common;
1721 const int tpl_idx = cpi->gf_frame_index;
1722
1723 assert(
1724 IMPLIES(cpi->ppi->gf_group.size > 0, tpl_idx < cpi->ppi->gf_group.size));
1725
1726 TplParams *const tpl_data = &cpi->ppi->tpl_data;
1727 const TplDepFrame *const tpl_frame = &tpl_data->tpl_frame[tpl_idx];
1728
1729 if (!tpl_frame->is_valid) return;
1730
1731 const TplDepStats *const tpl_stats = tpl_frame->tpl_stats_ptr;
1732 const int tpl_stride = tpl_frame->stride;
1733 const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
1734
1735 const int block_size = BLOCK_16X16;
1736 const int num_mi_w = mi_size_wide[block_size];
1737 const int num_mi_h = mi_size_high[block_size];
1738 const int num_cols = (mi_cols_sr + num_mi_w - 1) / num_mi_w;
1739 const int num_rows = (cm->mi_params.mi_rows + num_mi_h - 1) / num_mi_h;
1740 const double c = 1.2;
1741 const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
1742
1743 // Loop through each 'block_size' X 'block_size' block.
1744 for (int row = 0; row < num_rows; row++) {
1745 for (int col = 0; col < num_cols; col++) {
1746 double intra_cost = 0.0, mc_dep_cost = 0.0;
1747 // Loop through each mi block.
1748 for (int mi_row = row * num_mi_h; mi_row < (row + 1) * num_mi_h;
1749 mi_row += step) {
1750 for (int mi_col = col * num_mi_w; mi_col < (col + 1) * num_mi_w;
1751 mi_col += step) {
1752 if (mi_row >= cm->mi_params.mi_rows || mi_col >= mi_cols_sr) continue;
1753 const TplDepStats *this_stats = &tpl_stats[av1_tpl_ptr_pos(
1754 mi_row, mi_col, tpl_stride, tpl_data->tpl_stats_block_mis_log2)];
1755 int64_t mc_dep_delta =
1756 RDCOST(tpl_frame->base_rdmult, this_stats->mc_dep_rate,
1757 this_stats->mc_dep_dist);
1758 intra_cost += (double)(this_stats->recrf_dist << RDDIV_BITS);
1759 mc_dep_cost +=
1760 (double)(this_stats->recrf_dist << RDDIV_BITS) + mc_dep_delta;
1761 }
1762 }
1763 const double rk = intra_cost / mc_dep_cost;
1764 const int index = row * num_cols + col;
1765 cpi->ppi->tpl_rdmult_scaling_factors[index] = rk / cpi->rd.r0 + c;
1766 }
1767 }
1768 }
1769
av1_tpl_rdmult_setup_sb(AV1_COMP * cpi,MACROBLOCK * const x,BLOCK_SIZE sb_size,int mi_row,int mi_col)1770 void av1_tpl_rdmult_setup_sb(AV1_COMP *cpi, MACROBLOCK *const x,
1771 BLOCK_SIZE sb_size, int mi_row, int mi_col) {
1772 AV1_COMMON *const cm = &cpi->common;
1773 GF_GROUP *gf_group = &cpi->ppi->gf_group;
1774 assert(IMPLIES(cpi->ppi->gf_group.size > 0,
1775 cpi->gf_frame_index < cpi->ppi->gf_group.size));
1776 const int tpl_idx = cpi->gf_frame_index;
1777
1778 if (tpl_idx >= MAX_TPL_FRAME_IDX) return;
1779 TplDepFrame *tpl_frame = &cpi->ppi->tpl_data.tpl_frame[tpl_idx];
1780 if (!tpl_frame->is_valid) return;
1781 if (!is_frame_tpl_eligible(gf_group, cpi->gf_frame_index)) return;
1782 if (cpi->oxcf.q_cfg.aq_mode != NO_AQ) return;
1783
1784 const int mi_col_sr =
1785 coded_to_superres_mi(mi_col, cm->superres_scale_denominator);
1786 const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
1787 const int sb_mi_width_sr = coded_to_superres_mi(
1788 mi_size_wide[sb_size], cm->superres_scale_denominator);
1789
1790 const int bsize_base = BLOCK_16X16;
1791 const int num_mi_w = mi_size_wide[bsize_base];
1792 const int num_mi_h = mi_size_high[bsize_base];
1793 const int num_cols = (mi_cols_sr + num_mi_w - 1) / num_mi_w;
1794 const int num_rows = (cm->mi_params.mi_rows + num_mi_h - 1) / num_mi_h;
1795 const int num_bcols = (sb_mi_width_sr + num_mi_w - 1) / num_mi_w;
1796 const int num_brows = (mi_size_high[sb_size] + num_mi_h - 1) / num_mi_h;
1797 int row, col;
1798
1799 double base_block_count = 0.0;
1800 double log_sum = 0.0;
1801
1802 for (row = mi_row / num_mi_w;
1803 row < num_rows && row < mi_row / num_mi_w + num_brows; ++row) {
1804 for (col = mi_col_sr / num_mi_h;
1805 col < num_cols && col < mi_col_sr / num_mi_h + num_bcols; ++col) {
1806 const int index = row * num_cols + col;
1807 log_sum += log(cpi->ppi->tpl_rdmult_scaling_factors[index]);
1808 base_block_count += 1.0;
1809 }
1810 }
1811
1812 const CommonQuantParams *quant_params = &cm->quant_params;
1813 const int orig_rdmult = av1_compute_rd_mult(
1814 cpi, quant_params->base_qindex + quant_params->y_dc_delta_q);
1815 const int new_rdmult =
1816 av1_compute_rd_mult(cpi, quant_params->base_qindex + x->delta_qindex +
1817 quant_params->y_dc_delta_q);
1818 const double scaling_factor = (double)new_rdmult / (double)orig_rdmult;
1819
1820 double scale_adj = log(scaling_factor) - log_sum / base_block_count;
1821 scale_adj = exp_bounded(scale_adj);
1822
1823 for (row = mi_row / num_mi_w;
1824 row < num_rows && row < mi_row / num_mi_w + num_brows; ++row) {
1825 for (col = mi_col_sr / num_mi_h;
1826 col < num_cols && col < mi_col_sr / num_mi_h + num_bcols; ++col) {
1827 const int index = row * num_cols + col;
1828 cpi->ppi->tpl_sb_rdmult_scaling_factors[index] =
1829 scale_adj * cpi->ppi->tpl_rdmult_scaling_factors[index];
1830 }
1831 }
1832 }
1833
av1_exponential_entropy(double q_step,double b)1834 double av1_exponential_entropy(double q_step, double b) {
1835 b = AOMMAX(b, TPL_EPSILON);
1836 double z = fmax(exp_bounded(-q_step / b), TPL_EPSILON);
1837 return -log2(1 - z) - z * log2(z) / (1 - z);
1838 }
1839
av1_laplace_entropy(double q_step,double b,double zero_bin_ratio)1840 double av1_laplace_entropy(double q_step, double b, double zero_bin_ratio) {
1841 // zero bin's size is zero_bin_ratio * q_step
1842 // non-zero bin's size is q_step
1843 b = AOMMAX(b, TPL_EPSILON);
1844 double z = fmax(exp_bounded(-zero_bin_ratio / 2 * q_step / b), TPL_EPSILON);
1845 double h = av1_exponential_entropy(q_step, b);
1846 double r = -(1 - z) * log2(1 - z) - z * log2(z) + z * (h + 1);
1847 return r;
1848 }
1849
av1_laplace_estimate_frame_rate(int q_index,int block_count,const double * abs_coeff_mean,int coeff_num)1850 double av1_laplace_estimate_frame_rate(int q_index, int block_count,
1851 const double *abs_coeff_mean,
1852 int coeff_num) {
1853 double zero_bin_ratio = 2;
1854 double dc_q_step = av1_dc_quant_QTX(q_index, 0, AOM_BITS_8) / 4.;
1855 double ac_q_step = av1_ac_quant_QTX(q_index, 0, AOM_BITS_8) / 4.;
1856 double est_rate = 0;
1857 // dc coeff
1858 est_rate += av1_laplace_entropy(dc_q_step, abs_coeff_mean[0], zero_bin_ratio);
1859 // ac coeff
1860 for (int i = 1; i < coeff_num; ++i) {
1861 est_rate +=
1862 av1_laplace_entropy(ac_q_step, abs_coeff_mean[i], zero_bin_ratio);
1863 }
1864 est_rate *= block_count;
1865 return est_rate;
1866 }
1867
av1_estimate_gop_bitrate(const int * q_index_list,const int frame_count,const TplTxfmStats * stats_list,const int * stats_valid_list,double * bitrate_byframe_list)1868 double av1_estimate_gop_bitrate(const int *q_index_list, const int frame_count,
1869 const TplTxfmStats *stats_list,
1870 const int *stats_valid_list,
1871 double *bitrate_byframe_list) {
1872 double gop_bitrate = 0;
1873 for (int frame_index = 0; frame_index < frame_count; frame_index++) {
1874 if (stats_valid_list[frame_index]) {
1875 int q_index = q_index_list[frame_index];
1876 TplTxfmStats frame_stats = stats_list[frame_index];
1877
1878 /* Convert to mean absolute deviation */
1879 double abs_coeff_mean[256] = { 0 };
1880 for (int i = 0; i < 256; i++) {
1881 abs_coeff_mean[i] =
1882 frame_stats.abs_coeff_sum[i] / frame_stats.txfm_block_count;
1883 }
1884
1885 double frame_bitrate = av1_laplace_estimate_frame_rate(
1886 q_index, frame_stats.txfm_block_count, abs_coeff_mean, 256);
1887 gop_bitrate += frame_bitrate;
1888
1889 if (bitrate_byframe_list != NULL) {
1890 bitrate_byframe_list[frame_index] = frame_bitrate;
1891 }
1892 }
1893 }
1894 return gop_bitrate;
1895 }
1896
av1_estimate_coeff_entropy(double q_step,double b,double zero_bin_ratio,int qcoeff)1897 double av1_estimate_coeff_entropy(double q_step, double b,
1898 double zero_bin_ratio, int qcoeff) {
1899 b = AOMMAX(b, TPL_EPSILON);
1900 int abs_qcoeff = abs(qcoeff);
1901 double z0 = fmax(exp_bounded(-zero_bin_ratio / 2 * q_step / b), TPL_EPSILON);
1902 if (abs_qcoeff == 0) {
1903 double r = -log2(1 - z0);
1904 return r;
1905 } else {
1906 double z = fmax(exp_bounded(-q_step / b), TPL_EPSILON);
1907 double r = 1 - log2(z0) - log2(1 - z) - (abs_qcoeff - 1) * log2(z);
1908 return r;
1909 }
1910 }
1911
av1_estimate_txfm_block_entropy(int q_index,const double * abs_coeff_mean,int * qcoeff_arr,int coeff_num)1912 double av1_estimate_txfm_block_entropy(int q_index,
1913 const double *abs_coeff_mean,
1914 int *qcoeff_arr, int coeff_num) {
1915 double zero_bin_ratio = 2;
1916 double dc_q_step = av1_dc_quant_QTX(q_index, 0, AOM_BITS_8) / 4.;
1917 double ac_q_step = av1_ac_quant_QTX(q_index, 0, AOM_BITS_8) / 4.;
1918 double est_rate = 0;
1919 // dc coeff
1920 est_rate += av1_estimate_coeff_entropy(dc_q_step, abs_coeff_mean[0],
1921 zero_bin_ratio, qcoeff_arr[0]);
1922 // ac coeff
1923 for (int i = 1; i < coeff_num; ++i) {
1924 est_rate += av1_estimate_coeff_entropy(ac_q_step, abs_coeff_mean[i],
1925 zero_bin_ratio, qcoeff_arr[i]);
1926 }
1927 return est_rate;
1928 }
1929
1930 #if CONFIG_RD_COMMAND
av1_read_rd_command(const char * filepath,RD_COMMAND * rd_command)1931 void av1_read_rd_command(const char *filepath, RD_COMMAND *rd_command) {
1932 FILE *fptr = fopen(filepath, "r");
1933 fscanf(fptr, "%d", &rd_command->frame_count);
1934 rd_command->frame_index = 0;
1935 for (int i = 0; i < rd_command->frame_count; ++i) {
1936 int option;
1937 fscanf(fptr, "%d", &option);
1938 rd_command->option_ls[i] = (RD_OPTION)option;
1939 if (option == RD_OPTION_SET_Q) {
1940 fscanf(fptr, "%d", &rd_command->q_index_ls[i]);
1941 } else if (option == RD_OPTION_SET_Q_RDMULT) {
1942 fscanf(fptr, "%d", &rd_command->q_index_ls[i]);
1943 fscanf(fptr, "%d", &rd_command->rdmult_ls[i]);
1944 }
1945 }
1946 fclose(fptr);
1947 }
1948 #endif // CONFIG_RD_COMMAND
1949
get_tpl_stats_valid_list(const TplParams * tpl_data,int gop_size,int * stats_valid_list)1950 void get_tpl_stats_valid_list(const TplParams *tpl_data, int gop_size,
1951 int *stats_valid_list) {
1952 for (int i = 0; i < gop_size; ++i) {
1953 stats_valid_list[i] = av1_tpl_stats_ready(tpl_data, i);
1954 }
1955 }
1956
1957 /*
1958 * Estimate the optimal base q index for a GOP.
1959 */
av1_q_mode_estimate_base_q(const GF_GROUP * gf_group,const TplTxfmStats * txfm_stats_list,const int * stats_valid_list,double bit_budget,int gf_frame_index,double arf_qstep_ratio,aom_bit_depth_t bit_depth,double scale_factor,int * q_index_list,double * estimated_bitrate_byframe)1960 int av1_q_mode_estimate_base_q(const GF_GROUP *gf_group,
1961 const TplTxfmStats *txfm_stats_list,
1962 const int *stats_valid_list, double bit_budget,
1963 int gf_frame_index, double arf_qstep_ratio,
1964 aom_bit_depth_t bit_depth, double scale_factor,
1965 int *q_index_list,
1966 double *estimated_bitrate_byframe) {
1967 int q_max = 255; // Maximum q value.
1968 int q_min = 0; // Minimum q value.
1969 int q = (q_max + q_min) / 2;
1970
1971 av1_q_mode_compute_gop_q_indices(gf_frame_index, q_max, arf_qstep_ratio,
1972 bit_depth, gf_group, q_index_list);
1973 double q_max_estimate = av1_estimate_gop_bitrate(
1974 q_index_list, gf_group->size, txfm_stats_list, stats_valid_list, NULL);
1975 av1_q_mode_compute_gop_q_indices(gf_frame_index, q_min, arf_qstep_ratio,
1976 bit_depth, gf_group, q_index_list);
1977 double q_min_estimate = av1_estimate_gop_bitrate(
1978 q_index_list, gf_group->size, txfm_stats_list, stats_valid_list, NULL);
1979
1980 while (true) {
1981 av1_q_mode_compute_gop_q_indices(gf_frame_index, q, arf_qstep_ratio,
1982 bit_depth, gf_group, q_index_list);
1983
1984 double estimate = av1_estimate_gop_bitrate(
1985 q_index_list, gf_group->size, txfm_stats_list, stats_valid_list, NULL);
1986
1987 estimate *= scale_factor;
1988
1989 // We want to find the lowest q that satisfies the bit budget constraint.
1990 // A binary search narrows the result down to two values: q_min and q_max.
1991 if (q_max <= q_min + 1 || estimate == bit_budget) {
1992 // Pick the estimate that lands closest to the budget.
1993 if (fabs(q_max_estimate - bit_budget) <
1994 fabs(q_min_estimate - bit_budget)) {
1995 q = q_max;
1996 } else {
1997 q = q_min;
1998 }
1999 break;
2000 } else if (estimate > bit_budget) {
2001 q_min = q;
2002 q_min_estimate = estimate;
2003 q = (q_max + q_min) / 2;
2004 } else if (estimate < bit_budget) {
2005 q_max = q;
2006 q_max_estimate = estimate;
2007 q = (q_max + q_min) / 2;
2008 }
2009 }
2010
2011 // Update q_index_list and vbr_rc_info.
2012 av1_q_mode_compute_gop_q_indices(gf_frame_index, q, arf_qstep_ratio,
2013 bit_depth, gf_group, q_index_list);
2014 av1_estimate_gop_bitrate(q_index_list, gf_group->size, txfm_stats_list,
2015 stats_valid_list, estimated_bitrate_byframe);
2016 return q;
2017 }
2018
av1_tpl_get_qstep_ratio(const TplParams * tpl_data,int gf_frame_index)2019 double av1_tpl_get_qstep_ratio(const TplParams *tpl_data, int gf_frame_index) {
2020 const TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_frame_index];
2021 const TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
2022
2023 const int tpl_stride = tpl_frame->stride;
2024 int64_t intra_cost_base = 0;
2025 int64_t mc_dep_cost_base = 0;
2026 const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
2027
2028 for (int row = 0; row < tpl_frame->mi_rows; row += step) {
2029 for (int col = 0; col < tpl_frame->mi_cols; col += step) {
2030 const TplDepStats *this_stats = &tpl_stats[av1_tpl_ptr_pos(
2031 row, col, tpl_stride, tpl_data->tpl_stats_block_mis_log2)];
2032 const int64_t mc_dep_delta =
2033 RDCOST(tpl_frame->base_rdmult, this_stats->mc_dep_rate,
2034 this_stats->mc_dep_dist);
2035 intra_cost_base += (this_stats->recrf_dist << RDDIV_BITS);
2036 mc_dep_cost_base += (this_stats->recrf_dist << RDDIV_BITS) + mc_dep_delta;
2037 }
2038 }
2039 const double r0 = (double)intra_cost_base / mc_dep_cost_base;
2040 return sqrt(r0);
2041 }
2042
av1_get_q_index_from_qstep_ratio(int leaf_qindex,double qstep_ratio,aom_bit_depth_t bit_depth)2043 int av1_get_q_index_from_qstep_ratio(int leaf_qindex, double qstep_ratio,
2044 aom_bit_depth_t bit_depth) {
2045 const double leaf_qstep = av1_dc_quant_QTX(leaf_qindex, 0, bit_depth);
2046 const double target_qstep = leaf_qstep * qstep_ratio;
2047 int qindex = leaf_qindex;
2048 for (qindex = leaf_qindex; qindex > 0; --qindex) {
2049 const double qstep = av1_dc_quant_QTX(qindex, 0, bit_depth);
2050 if (qstep + 0.1 <= target_qstep) break;
2051 }
2052 return qindex;
2053 }
2054
av1_tpl_get_q_index(const TplParams * tpl_data,int gf_frame_index,int leaf_qindex,aom_bit_depth_t bit_depth)2055 int av1_tpl_get_q_index(const TplParams *tpl_data, int gf_frame_index,
2056 int leaf_qindex, aom_bit_depth_t bit_depth) {
2057 const double qstep_ratio = av1_tpl_get_qstep_ratio(tpl_data, gf_frame_index);
2058 return av1_get_q_index_from_qstep_ratio(leaf_qindex, qstep_ratio, bit_depth);
2059 }
2060
2061 #if CONFIG_BITRATE_ACCURACY
av1_vbr_rc_update_q_index_list(VBR_RATECTRL_INFO * vbr_rc_info,const TplParams * tpl_data,const GF_GROUP * gf_group,int gf_frame_index,aom_bit_depth_t bit_depth)2062 void av1_vbr_rc_update_q_index_list(VBR_RATECTRL_INFO *vbr_rc_info,
2063 const TplParams *tpl_data,
2064 const GF_GROUP *gf_group,
2065 int gf_frame_index,
2066 aom_bit_depth_t bit_depth) {
2067 // We always update q_index_list when gf_frame_index is zero.
2068 // This will make the q indices for the entire gop more consistent
2069 if (gf_frame_index == 0) {
2070 vbr_rc_info->q_index_list_ready = 1;
2071 double gop_bit_budget = vbr_rc_info->gop_bit_budget;
2072 // Use the gop_bit_budget to determine q_index_list.
2073 const double arf_qstep_ratio =
2074 av1_tpl_get_qstep_ratio(tpl_data, gf_frame_index);
2075 // We update the q indices in vbr_rc_info in vbr_rc_info->q_index_list
2076 // rather than gf_group->q_val to avoid conflicts with the existing code.
2077 int stats_valid_list[MAX_LENGTH_TPL_FRAME_STATS] = { 0 };
2078 get_tpl_stats_valid_list(tpl_data, gf_group->size, stats_valid_list);
2079
2080 double mv_bits = av1_tpl_compute_mv_bits(
2081 tpl_data, gf_group->size, gf_frame_index,
2082 gf_group->update_type[gf_frame_index], vbr_rc_info);
2083
2084 mv_bits = AOMMIN(mv_bits, 0.6 * gop_bit_budget);
2085 gop_bit_budget -= mv_bits;
2086
2087 double scale_factor =
2088 vbr_rc_info->scale_factors[gf_group->update_type[gf_frame_index]];
2089
2090 av1_q_mode_estimate_base_q(
2091 gf_group, tpl_data->txfm_stats_list, stats_valid_list, gop_bit_budget,
2092 gf_frame_index, arf_qstep_ratio, bit_depth, scale_factor,
2093 vbr_rc_info->q_index_list, vbr_rc_info->estimated_bitrate_byframe);
2094 }
2095 }
2096
2097 /* For a GOP, calculate the bits used by motion vectors. */
av1_tpl_compute_mv_bits(const TplParams * tpl_data,int gf_group_size,int gf_frame_index,int gf_update_type,VBR_RATECTRL_INFO * vbr_rc_info)2098 double av1_tpl_compute_mv_bits(const TplParams *tpl_data, int gf_group_size,
2099 int gf_frame_index, int gf_update_type,
2100 VBR_RATECTRL_INFO *vbr_rc_info) {
2101 double total_mv_bits = 0;
2102
2103 // Loop through each frame.
2104 for (int i = gf_frame_index; i < gf_group_size; i++) {
2105 if (av1_tpl_stats_ready(tpl_data, i)) {
2106 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[i];
2107 double frame_mv_bits = av1_tpl_compute_frame_mv_entropy(
2108 tpl_frame, tpl_data->tpl_stats_block_mis_log2);
2109 total_mv_bits += frame_mv_bits;
2110 vbr_rc_info->estimated_mv_bitrate_byframe[i] = frame_mv_bits;
2111 } else {
2112 vbr_rc_info->estimated_mv_bitrate_byframe[i] = 0;
2113 }
2114 }
2115
2116 // Scale the final result by the scale factor.
2117 return total_mv_bits * vbr_rc_info->mv_scale_factors[gf_update_type];
2118 }
2119 #endif // CONFIG_BITRATE_ACCURACY
2120
2121 // Use upper and left neighbor block as the reference MVs.
2122 // Compute the minimum difference between current MV and reference MV.
av1_compute_mv_difference(const TplDepFrame * tpl_frame,int row,int col,int step,int tpl_stride,int right_shift)2123 int_mv av1_compute_mv_difference(const TplDepFrame *tpl_frame, int row, int col,
2124 int step, int tpl_stride, int right_shift) {
2125 const TplDepStats *tpl_stats =
2126 &tpl_frame
2127 ->tpl_stats_ptr[av1_tpl_ptr_pos(row, col, tpl_stride, right_shift)];
2128 int_mv current_mv = tpl_stats->mv[tpl_stats->ref_frame_index[0]];
2129 int current_mv_magnitude =
2130 abs(current_mv.as_mv.row) + abs(current_mv.as_mv.col);
2131
2132 // Retrieve the up and left neighbors.
2133 int up_error = INT_MAX;
2134 int_mv up_mv_diff;
2135 if (row - step >= 0) {
2136 tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
2137 row - step, col, tpl_stride, right_shift)];
2138 up_mv_diff = tpl_stats->mv[tpl_stats->ref_frame_index[0]];
2139 up_mv_diff.as_mv.row = current_mv.as_mv.row - up_mv_diff.as_mv.row;
2140 up_mv_diff.as_mv.col = current_mv.as_mv.col - up_mv_diff.as_mv.col;
2141 up_error = abs(up_mv_diff.as_mv.row) + abs(up_mv_diff.as_mv.col);
2142 }
2143
2144 int left_error = INT_MAX;
2145 int_mv left_mv_diff;
2146 if (col - step >= 0) {
2147 tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
2148 row, col - step, tpl_stride, right_shift)];
2149 left_mv_diff = tpl_stats->mv[tpl_stats->ref_frame_index[0]];
2150 left_mv_diff.as_mv.row = current_mv.as_mv.row - left_mv_diff.as_mv.row;
2151 left_mv_diff.as_mv.col = current_mv.as_mv.col - left_mv_diff.as_mv.col;
2152 left_error = abs(left_mv_diff.as_mv.row) + abs(left_mv_diff.as_mv.col);
2153 }
2154
2155 // Return the MV with the minimum distance from current.
2156 if (up_error < left_error && up_error < current_mv_magnitude) {
2157 return up_mv_diff;
2158 } else if (left_error < up_error && left_error < current_mv_magnitude) {
2159 return left_mv_diff;
2160 }
2161 return current_mv;
2162 }
2163
2164 /* Compute the entropy of motion vectors for a single frame. */
av1_tpl_compute_frame_mv_entropy(const TplDepFrame * tpl_frame,uint8_t right_shift)2165 double av1_tpl_compute_frame_mv_entropy(const TplDepFrame *tpl_frame,
2166 uint8_t right_shift) {
2167 if (!tpl_frame->is_valid) {
2168 return 0;
2169 }
2170
2171 int count_row[500] = { 0 };
2172 int count_col[500] = { 0 };
2173 int n = 0; // number of MVs to process
2174
2175 const int tpl_stride = tpl_frame->stride;
2176 const int step = 1 << right_shift;
2177
2178 for (int row = 0; row < tpl_frame->mi_rows; row += step) {
2179 for (int col = 0; col < tpl_frame->mi_cols; col += step) {
2180 int_mv mv = av1_compute_mv_difference(tpl_frame, row, col, step,
2181 tpl_stride, right_shift);
2182 count_row[clamp(mv.as_mv.row, 0, 499)] += 1;
2183 count_col[clamp(mv.as_mv.row, 0, 499)] += 1;
2184 n += 1;
2185 }
2186 }
2187
2188 // Estimate the bits used using the entropy formula.
2189 double rate_row = 0;
2190 double rate_col = 0;
2191 for (int i = 0; i < 500; i++) {
2192 if (count_row[i] != 0) {
2193 double p = count_row[i] / (double)n;
2194 rate_row += count_row[i] * -log2(p);
2195 }
2196 if (count_col[i] != 0) {
2197 double p = count_col[i] / (double)n;
2198 rate_col += count_col[i] * -log2(p);
2199 }
2200 }
2201
2202 return rate_row + rate_col;
2203 }
2204