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