1 /*
2 * Copyright (c) 2019, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12 #include <stdint.h>
13 #include <float.h>
14
15 #include "config/aom_config.h"
16 #include "config/aom_dsp_rtcd.h"
17 #include "config/aom_scale_rtcd.h"
18
19 #include "aom/aom_codec.h"
20 #include "aom_ports/system_state.h"
21
22 #include "av1/common/av1_common_int.h"
23 #include "av1/common/enums.h"
24 #include "av1/common/idct.h"
25 #include "av1/common/reconintra.h"
26
27 #include "av1/encoder/encoder.h"
28 #include "av1/encoder/encode_strategy.h"
29 #include "av1/encoder/hybrid_fwd_txfm.h"
30 #include "av1/encoder/rdopt.h"
31 #include "av1/encoder/reconinter_enc.h"
32 #include "av1/encoder/tpl_model.h"
33
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)34 static AOM_INLINE void get_quantize_error(const MACROBLOCK *x, int plane,
35 const tran_low_t *coeff,
36 tran_low_t *qcoeff,
37 tran_low_t *dqcoeff, TX_SIZE tx_size,
38 uint16_t *eob, int64_t *recon_error,
39 int64_t *sse) {
40 const struct macroblock_plane *const p = &x->plane[plane];
41 const SCAN_ORDER *const scan_order = &av1_default_scan_orders[tx_size];
42 int pix_num = 1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]];
43 const int shift = tx_size == TX_32X32 ? 0 : 2;
44
45 av1_quantize_fp(coeff, pix_num, p->zbin_QTX, p->round_fp_QTX, p->quant_fp_QTX,
46 p->quant_shift_QTX, qcoeff, dqcoeff, p->dequant_QTX, eob,
47 scan_order->scan, scan_order->iscan);
48
49 *recon_error = av1_block_error(coeff, dqcoeff, pix_num, sse) >> shift;
50 *recon_error = AOMMAX(*recon_error, 1);
51
52 *sse = (*sse) >> shift;
53 *sse = AOMMAX(*sse, 1);
54 }
55
tpl_fwd_txfm(const int16_t * src_diff,int bw,tran_low_t * coeff,TX_SIZE tx_size,int bit_depth,int is_hbd)56 static AOM_INLINE void tpl_fwd_txfm(const int16_t *src_diff, int bw,
57 tran_low_t *coeff, TX_SIZE tx_size,
58 int bit_depth, int is_hbd) {
59 TxfmParam txfm_param;
60 txfm_param.tx_type = DCT_DCT;
61 txfm_param.tx_size = tx_size;
62 txfm_param.lossless = 0;
63 txfm_param.tx_set_type = EXT_TX_SET_ALL16;
64
65 txfm_param.bd = bit_depth;
66 txfm_param.is_hbd = is_hbd;
67 av1_fwd_txfm(src_diff, coeff, bw, &txfm_param);
68 }
69
tpl_get_satd_cost(const MACROBLOCK * x,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)70 static AOM_INLINE int64_t tpl_get_satd_cost(const MACROBLOCK *x,
71 int16_t *src_diff, int diff_stride,
72 const uint8_t *src, int src_stride,
73 const uint8_t *dst, int dst_stride,
74 tran_low_t *coeff, int bw, int bh,
75 TX_SIZE tx_size) {
76 const MACROBLOCKD *xd = &x->e_mbd;
77 const int pix_num = bw * bh;
78
79 av1_subtract_block(xd, bh, bw, src_diff, diff_stride, src, src_stride, dst,
80 dst_stride);
81 tpl_fwd_txfm(src_diff, bw, coeff, tx_size, xd->bd, is_cur_buf_hbd(xd));
82 return aom_satd(coeff, pix_num);
83 }
84
rate_estimator(const tran_low_t * qcoeff,int eob,TX_SIZE tx_size)85 static int rate_estimator(const tran_low_t *qcoeff, int eob, TX_SIZE tx_size) {
86 const SCAN_ORDER *const scan_order = &av1_default_scan_orders[tx_size];
87
88 assert((1 << num_pels_log2_lookup[txsize_to_bsize[tx_size]]) >= eob);
89
90 int rate_cost = 1;
91
92 for (int idx = 0; idx < eob; ++idx) {
93 int abs_level = abs(qcoeff[scan_order->scan[idx]]);
94 rate_cost += (int)(log(abs_level + 1.0) / log(2.0)) + 1;
95 }
96
97 return (rate_cost << AV1_PROB_COST_SHIFT);
98 }
99
txfm_quant_rdcost(const MACROBLOCK * x,int16_t * src_diff,int diff_stride,uint8_t * src,int src_stride,uint8_t * dst,int dst_stride,tran_low_t * coeff,tran_low_t * qcoeff,tran_low_t * dqcoeff,int bw,int bh,TX_SIZE tx_size,int * rate_cost,int64_t * recon_error,int64_t * sse)100 static AOM_INLINE void txfm_quant_rdcost(
101 const MACROBLOCK *x, int16_t *src_diff, int diff_stride, uint8_t *src,
102 int src_stride, uint8_t *dst, int dst_stride, tran_low_t *coeff,
103 tran_low_t *qcoeff, tran_low_t *dqcoeff, int bw, int bh, TX_SIZE tx_size,
104 int *rate_cost, int64_t *recon_error, int64_t *sse) {
105 const MACROBLOCKD *xd = &x->e_mbd;
106 uint16_t eob;
107 av1_subtract_block(xd, bh, bw, src_diff, diff_stride, src, src_stride, dst,
108 dst_stride);
109 tpl_fwd_txfm(src_diff, diff_stride, coeff, tx_size, xd->bd,
110 is_cur_buf_hbd(xd));
111
112 get_quantize_error(x, 0, coeff, qcoeff, dqcoeff, tx_size, &eob, recon_error,
113 sse);
114
115 *rate_cost = rate_estimator(qcoeff, eob, tx_size);
116
117 av1_inverse_transform_block(xd, dqcoeff, 0, DCT_DCT, tx_size, dst, dst_stride,
118 eob, 0);
119 }
120
motion_estimation(AV1_COMP * cpi,MACROBLOCK * x,uint8_t * cur_frame_buf,uint8_t * ref_frame_buf,int stride,int stride_ref,BLOCK_SIZE bsize,MV center_mv,int_mv * best_mv)121 static uint32_t motion_estimation(AV1_COMP *cpi, MACROBLOCK *x,
122 uint8_t *cur_frame_buf,
123 uint8_t *ref_frame_buf, int stride,
124 int stride_ref, BLOCK_SIZE bsize,
125 MV center_mv, int_mv *best_mv) {
126 AV1_COMMON *cm = &cpi->common;
127 MACROBLOCKD *const xd = &x->e_mbd;
128 TPL_SPEED_FEATURES *tpl_sf = &cpi->sf.tpl_sf;
129 int step_param;
130 uint32_t bestsme = UINT_MAX;
131 int distortion;
132 uint32_t sse;
133 int cost_list[5];
134 FULLPEL_MV start_mv = get_fullmv_from_mv(¢er_mv);
135
136 // Setup frame pointers
137 x->plane[0].src.buf = cur_frame_buf;
138 x->plane[0].src.stride = stride;
139 xd->plane[0].pre[0].buf = ref_frame_buf;
140 xd->plane[0].pre[0].stride = stride_ref;
141
142 step_param = tpl_sf->reduce_first_step_size;
143 step_param = AOMMIN(step_param, MAX_MVSEARCH_STEPS - 2);
144
145 search_site_config *ss_cfg = &cpi->mv_search_params.ss_cfg[SS_CFG_SRC];
146 if (ss_cfg->stride != stride_ref)
147 ss_cfg = &cpi->mv_search_params.ss_cfg[SS_CFG_LOOKAHEAD];
148
149 assert(ss_cfg->stride == stride_ref);
150
151 FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
152 av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, ¢er_mv,
153 ss_cfg);
154
155 av1_full_pixel_search(start_mv, &full_ms_params, step_param,
156 cond_cost_list(cpi, cost_list), &best_mv->as_fullmv,
157 NULL);
158
159 SUBPEL_MOTION_SEARCH_PARAMS ms_params;
160 av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize, ¢er_mv,
161 cost_list);
162 ms_params.forced_stop = tpl_sf->subpel_force_stop;
163 ms_params.var_params.subpel_search_type = USE_2_TAPS;
164 ms_params.mv_cost_params.mv_cost_type = MV_COST_NONE;
165 MV subpel_start_mv = get_mv_from_fullmv(&best_mv->as_fullmv);
166 bestsme = cpi->mv_search_params.find_fractional_mv_step(
167 xd, cm, &ms_params, subpel_start_mv, &best_mv->as_mv, &distortion, &sse,
168 NULL);
169
170 return bestsme;
171 }
172
is_alike_mv(int_mv candidate_mv,int_mv * center_mvs,int center_mvs_count,int skip_alike_starting_mv)173 static int is_alike_mv(int_mv candidate_mv, int_mv *center_mvs,
174 int center_mvs_count, int skip_alike_starting_mv) {
175 // MV difference threshold is in 1/8 precision.
176 const int mv_diff_thr[3] = { 1, (8 << 3), (16 << 3) };
177 int thr = mv_diff_thr[skip_alike_starting_mv];
178 int i;
179
180 for (i = 0; i < center_mvs_count; i++) {
181 if (abs(center_mvs[i].as_mv.col - candidate_mv.as_mv.col) < thr &&
182 abs(center_mvs[i].as_mv.row - candidate_mv.as_mv.row) < thr)
183 return 1;
184 }
185
186 return 0;
187 }
188
mode_estimation(AV1_COMP * cpi,MACROBLOCK * x,MACROBLOCKD * xd,struct scale_factors * sf,int frame_idx,int mi_row,int mi_col,BLOCK_SIZE bsize,TX_SIZE tx_size,const YV12_BUFFER_CONFIG * ref_frame[],const YV12_BUFFER_CONFIG * src_ref_frame[],TplDepStats * tpl_stats)189 static AOM_INLINE void mode_estimation(
190 AV1_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd, struct scale_factors *sf,
191 int frame_idx, int mi_row, int mi_col, BLOCK_SIZE bsize, TX_SIZE tx_size,
192 const YV12_BUFFER_CONFIG *ref_frame[],
193 const YV12_BUFFER_CONFIG *src_ref_frame[], TplDepStats *tpl_stats) {
194 AV1_COMMON *cm = &cpi->common;
195 const GF_GROUP *gf_group = &cpi->gf_group;
196
197 (void)gf_group;
198
199 TplParams *tpl_data = &cpi->tpl_data;
200 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
201 const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2;
202
203 const int bw = 4 << mi_size_wide_log2[bsize];
204 const int bh = 4 << mi_size_high_log2[bsize];
205 const int_interpfilters kernel =
206 av1_broadcast_interp_filter(EIGHTTAP_REGULAR);
207
208 int64_t best_intra_cost = INT64_MAX;
209 int64_t intra_cost;
210 PREDICTION_MODE best_mode = DC_PRED;
211
212 int mb_y_offset = mi_row * MI_SIZE * xd->cur_buf->y_stride + mi_col * MI_SIZE;
213 uint8_t *src_mb_buffer = xd->cur_buf->y_buffer + mb_y_offset;
214 const int src_stride = xd->cur_buf->y_stride;
215
216 const int dst_mb_offset =
217 mi_row * MI_SIZE * tpl_frame->rec_picture->y_stride + mi_col * MI_SIZE;
218 uint8_t *dst_buffer = tpl_frame->rec_picture->y_buffer + dst_mb_offset;
219 const int dst_buffer_stride = tpl_frame->rec_picture->y_stride;
220
221 // Temporaray buffers
222 DECLARE_ALIGNED(32, uint8_t, predictor8[MC_FLOW_NUM_PELS * 2]);
223 DECLARE_ALIGNED(32, int16_t, src_diff[MC_FLOW_NUM_PELS]);
224 DECLARE_ALIGNED(32, tran_low_t, coeff[MC_FLOW_NUM_PELS]);
225 DECLARE_ALIGNED(32, tran_low_t, qcoeff[MC_FLOW_NUM_PELS]);
226 DECLARE_ALIGNED(32, tran_low_t, dqcoeff[MC_FLOW_NUM_PELS]);
227 DECLARE_ALIGNED(32, tran_low_t, best_coeff[MC_FLOW_NUM_PELS]);
228 uint8_t *predictor =
229 is_cur_buf_hbd(xd) ? CONVERT_TO_BYTEPTR(predictor8) : predictor8;
230 int64_t recon_error = 1, sse = 1;
231
232 memset(tpl_stats, 0, sizeof(*tpl_stats));
233
234 const int mi_width = mi_size_wide[bsize];
235 const int mi_height = mi_size_high[bsize];
236 set_mode_info_offsets(&cpi->common.mi_params, &cpi->mbmi_ext_info, x, xd,
237 mi_row, mi_col);
238 set_mi_row_col(xd, &xd->tile, mi_row, mi_height, mi_col, mi_width,
239 cm->mi_params.mi_rows, cm->mi_params.mi_cols);
240 set_plane_n4(xd, mi_size_wide[bsize], mi_size_high[bsize],
241 av1_num_planes(cm));
242 xd->mi[0]->sb_type = bsize;
243 xd->mi[0]->motion_mode = SIMPLE_TRANSLATION;
244
245 // Intra prediction search
246 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
247
248 // Pre-load the bottom left line.
249 if (xd->left_available &&
250 mi_row + tx_size_high_unit[tx_size] < xd->tile.mi_row_end) {
251 #if CONFIG_AV1_HIGHBITDEPTH
252 if (is_cur_buf_hbd(xd)) {
253 uint16_t *dst = CONVERT_TO_SHORTPTR(dst_buffer);
254 for (int i = 0; i < bw; ++i)
255 dst[(bw + i) * dst_buffer_stride - 1] =
256 dst[(bw - 1) * dst_buffer_stride - 1];
257 } else {
258 for (int i = 0; i < bw; ++i)
259 dst_buffer[(bw + i) * dst_buffer_stride - 1] =
260 dst_buffer[(bw - 1) * dst_buffer_stride - 1];
261 }
262 #else
263 for (int i = 0; i < bw; ++i)
264 dst_buffer[(bw + i) * dst_buffer_stride - 1] =
265 dst_buffer[(bw - 1) * dst_buffer_stride - 1];
266 #endif
267 }
268
269 // if cpi->sf.tpl_sf.prune_intra_modes is on, then search only DC_PRED,
270 // H_PRED, and V_PRED
271 const PREDICTION_MODE last_intra_mode =
272 cpi->sf.tpl_sf.prune_intra_modes ? D45_PRED : INTRA_MODE_END;
273 for (PREDICTION_MODE mode = INTRA_MODE_START; mode < last_intra_mode;
274 ++mode) {
275 av1_predict_intra_block(cm, xd, block_size_wide[bsize],
276 block_size_high[bsize], tx_size, mode, 0, 0,
277 FILTER_INTRA_MODES, dst_buffer, dst_buffer_stride,
278 predictor, bw, 0, 0, 0);
279
280 intra_cost = tpl_get_satd_cost(x, src_diff, bw, src_mb_buffer, src_stride,
281 predictor, bw, coeff, bw, bh, tx_size);
282
283 if (intra_cost < best_intra_cost) {
284 best_intra_cost = intra_cost;
285 best_mode = mode;
286 }
287 }
288
289 // Motion compensated prediction
290 xd->mi[0]->ref_frame[0] = INTRA_FRAME;
291
292 int best_rf_idx = -1;
293 int_mv best_mv;
294 int64_t inter_cost;
295 int64_t best_inter_cost = INT64_MAX;
296 int rf_idx;
297
298 best_mv.as_int = INVALID_MV;
299
300 for (rf_idx = 0; rf_idx < INTER_REFS_PER_FRAME; ++rf_idx) {
301 if (ref_frame[rf_idx] == NULL || src_ref_frame[rf_idx] == NULL) {
302 tpl_stats->mv[rf_idx].as_int = INVALID_MV;
303 continue;
304 }
305
306 const YV12_BUFFER_CONFIG *ref_frame_ptr = src_ref_frame[rf_idx];
307 int ref_mb_offset =
308 mi_row * MI_SIZE * ref_frame_ptr->y_stride + mi_col * MI_SIZE;
309 uint8_t *ref_mb = ref_frame_ptr->y_buffer + ref_mb_offset;
310 int ref_stride = ref_frame_ptr->y_stride;
311
312 int_mv best_rfidx_mv = { 0 };
313 uint32_t bestsme = UINT32_MAX;
314
315 int_mv center_mvs[4] = { { 0 } };
316 int refmv_count = 1;
317
318 if (xd->up_available) {
319 TplDepStats *ref_tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
320 mi_row - mi_height, mi_col, tpl_frame->stride, block_mis_log2)];
321 if (!is_alike_mv(ref_tpl_stats->mv[rf_idx], center_mvs, refmv_count,
322 cpi->sf.tpl_sf.skip_alike_starting_mv)) {
323 center_mvs[refmv_count].as_int = ref_tpl_stats->mv[rf_idx].as_int;
324 ++refmv_count;
325 }
326 }
327
328 if (xd->left_available) {
329 TplDepStats *ref_tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
330 mi_row, mi_col - mi_width, tpl_frame->stride, block_mis_log2)];
331 if (!is_alike_mv(ref_tpl_stats->mv[rf_idx], center_mvs, refmv_count,
332 cpi->sf.tpl_sf.skip_alike_starting_mv)) {
333 center_mvs[refmv_count].as_int = ref_tpl_stats->mv[rf_idx].as_int;
334 ++refmv_count;
335 }
336 }
337
338 if (xd->up_available && mi_col + mi_width < xd->tile.mi_col_end) {
339 TplDepStats *ref_tpl_stats = &tpl_frame->tpl_stats_ptr[av1_tpl_ptr_pos(
340 mi_row - mi_height, mi_col + mi_width, tpl_frame->stride,
341 block_mis_log2)];
342 if (!is_alike_mv(ref_tpl_stats->mv[rf_idx], center_mvs, refmv_count,
343 cpi->sf.tpl_sf.skip_alike_starting_mv)) {
344 center_mvs[refmv_count].as_int = ref_tpl_stats->mv[rf_idx].as_int;
345 ++refmv_count;
346 }
347 }
348
349 for (int idx = 0; idx < refmv_count; ++idx) {
350 int_mv this_mv;
351 uint32_t thissme =
352 motion_estimation(cpi, x, src_mb_buffer, ref_mb, src_stride,
353 ref_stride, bsize, center_mvs[idx].as_mv, &this_mv);
354
355 if (thissme < bestsme) {
356 bestsme = thissme;
357 best_rfidx_mv = this_mv;
358 }
359 }
360
361 tpl_stats->mv[rf_idx].as_int = best_rfidx_mv.as_int;
362
363 struct buf_2d ref_buf = { NULL, ref_frame_ptr->y_buffer,
364 ref_frame_ptr->y_width, ref_frame_ptr->y_height,
365 ref_frame_ptr->y_stride };
366 InterPredParams inter_pred_params;
367 av1_init_inter_params(&inter_pred_params, bw, bh, mi_row * MI_SIZE,
368 mi_col * MI_SIZE, 0, 0, xd->bd, is_cur_buf_hbd(xd), 0,
369 sf, &ref_buf, kernel);
370 inter_pred_params.conv_params = get_conv_params(0, 0, xd->bd);
371
372 av1_enc_build_one_inter_predictor(predictor, bw, &best_rfidx_mv.as_mv,
373 &inter_pred_params);
374
375 inter_cost = tpl_get_satd_cost(x, src_diff, bw, src_mb_buffer, src_stride,
376 predictor, bw, coeff, bw, bh, tx_size);
377 // Store inter cost for each ref frame
378 tpl_stats->pred_error[rf_idx] = AOMMAX(1, inter_cost);
379
380 if (inter_cost < best_inter_cost) {
381 memcpy(best_coeff, coeff, sizeof(best_coeff));
382 best_rf_idx = rf_idx;
383
384 best_inter_cost = inter_cost;
385 best_mv.as_int = best_rfidx_mv.as_int;
386 if (best_inter_cost < best_intra_cost) {
387 best_mode = NEWMV;
388 xd->mi[0]->ref_frame[0] = best_rf_idx + LAST_FRAME;
389 xd->mi[0]->mv[0].as_int = best_mv.as_int;
390 }
391 }
392 }
393
394 if (best_inter_cost < INT64_MAX) {
395 uint16_t eob;
396 get_quantize_error(x, 0, best_coeff, qcoeff, dqcoeff, tx_size, &eob,
397 &recon_error, &sse);
398
399 const int rate_cost = rate_estimator(qcoeff, eob, tx_size);
400 tpl_stats->srcrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2;
401 }
402
403 best_intra_cost = AOMMAX(best_intra_cost, 1);
404 if (frame_idx == 0) {
405 best_inter_cost = 0;
406 } else {
407 best_inter_cost = AOMMIN(best_intra_cost, best_inter_cost);
408 }
409 tpl_stats->inter_cost = best_inter_cost << TPL_DEP_COST_SCALE_LOG2;
410 tpl_stats->intra_cost = best_intra_cost << TPL_DEP_COST_SCALE_LOG2;
411
412 tpl_stats->srcrf_dist = recon_error << (TPL_DEP_COST_SCALE_LOG2);
413
414 // Final encode
415 if (is_inter_mode(best_mode)) {
416 const YV12_BUFFER_CONFIG *ref_frame_ptr = ref_frame[best_rf_idx];
417
418 InterPredParams inter_pred_params;
419 struct buf_2d ref_buf = { NULL, ref_frame_ptr->y_buffer,
420 ref_frame_ptr->y_width, ref_frame_ptr->y_height,
421 ref_frame_ptr->y_stride };
422 av1_init_inter_params(&inter_pred_params, bw, bh, mi_row * MI_SIZE,
423 mi_col * MI_SIZE, 0, 0, xd->bd, is_cur_buf_hbd(xd), 0,
424 sf, &ref_buf, kernel);
425 inter_pred_params.conv_params = get_conv_params(0, 0, xd->bd);
426
427 av1_enc_build_one_inter_predictor(dst_buffer, dst_buffer_stride,
428 &best_mv.as_mv, &inter_pred_params);
429 } else {
430 av1_predict_intra_block(cm, xd, block_size_wide[bsize],
431 block_size_high[bsize], tx_size, best_mode, 0, 0,
432 FILTER_INTRA_MODES, dst_buffer, dst_buffer_stride,
433 dst_buffer, dst_buffer_stride, 0, 0, 0);
434 }
435
436 int rate_cost;
437 txfm_quant_rdcost(x, src_diff, bw, src_mb_buffer, src_stride, dst_buffer,
438 dst_buffer_stride, coeff, qcoeff, dqcoeff, bw, bh, tx_size,
439 &rate_cost, &recon_error, &sse);
440
441 tpl_stats->recrf_dist = recon_error << (TPL_DEP_COST_SCALE_LOG2);
442 tpl_stats->recrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2;
443 if (!is_inter_mode(best_mode)) {
444 tpl_stats->srcrf_dist = recon_error << (TPL_DEP_COST_SCALE_LOG2);
445 tpl_stats->srcrf_rate = rate_cost << TPL_DEP_COST_SCALE_LOG2;
446 }
447 tpl_stats->recrf_dist = AOMMAX(tpl_stats->srcrf_dist, tpl_stats->recrf_dist);
448 tpl_stats->recrf_rate = AOMMAX(tpl_stats->srcrf_rate, tpl_stats->recrf_rate);
449
450 if (best_rf_idx >= 0) {
451 tpl_stats->mv[best_rf_idx].as_int = best_mv.as_int;
452 tpl_stats->ref_frame_index = best_rf_idx;
453 }
454
455 for (int idy = 0; idy < mi_height; ++idy) {
456 for (int idx = 0; idx < mi_width; ++idx) {
457 if ((xd->mb_to_right_edge >> (3 + MI_SIZE_LOG2)) + mi_width > idx &&
458 (xd->mb_to_bottom_edge >> (3 + MI_SIZE_LOG2)) + mi_height > idy) {
459 xd->mi[idx + idy * cm->mi_params.mi_stride] = xd->mi[0];
460 }
461 }
462 }
463 }
464
round_floor(int ref_pos,int bsize_pix)465 static int round_floor(int ref_pos, int bsize_pix) {
466 int round;
467 if (ref_pos < 0)
468 round = -(1 + (-ref_pos - 1) / bsize_pix);
469 else
470 round = ref_pos / bsize_pix;
471
472 return round;
473 }
474
get_overlap_area(int grid_pos_row,int grid_pos_col,int ref_pos_row,int ref_pos_col,int block,BLOCK_SIZE bsize)475 static int get_overlap_area(int grid_pos_row, int grid_pos_col, int ref_pos_row,
476 int ref_pos_col, int block, BLOCK_SIZE bsize) {
477 int width = 0, height = 0;
478 int bw = 4 << mi_size_wide_log2[bsize];
479 int bh = 4 << mi_size_high_log2[bsize];
480
481 switch (block) {
482 case 0:
483 width = grid_pos_col + bw - ref_pos_col;
484 height = grid_pos_row + bh - ref_pos_row;
485 break;
486 case 1:
487 width = ref_pos_col + bw - grid_pos_col;
488 height = grid_pos_row + bh - ref_pos_row;
489 break;
490 case 2:
491 width = grid_pos_col + bw - ref_pos_col;
492 height = ref_pos_row + bh - grid_pos_row;
493 break;
494 case 3:
495 width = ref_pos_col + bw - grid_pos_col;
496 height = ref_pos_row + bh - grid_pos_row;
497 break;
498 default: assert(0);
499 }
500
501 return width * height;
502 }
503
av1_tpl_ptr_pos(int mi_row,int mi_col,int stride,uint8_t right_shift)504 int av1_tpl_ptr_pos(int mi_row, int mi_col, int stride, uint8_t right_shift) {
505 return (mi_row >> right_shift) * stride + (mi_col >> right_shift);
506 }
507
delta_rate_cost(int64_t delta_rate,int64_t recrf_dist,int64_t srcrf_dist,int pix_num)508 static int64_t delta_rate_cost(int64_t delta_rate, int64_t recrf_dist,
509 int64_t srcrf_dist, int pix_num) {
510 double beta = (double)srcrf_dist / recrf_dist;
511 int64_t rate_cost = delta_rate;
512
513 if (srcrf_dist <= 128) return rate_cost;
514
515 double dr =
516 (double)(delta_rate >> (TPL_DEP_COST_SCALE_LOG2 + AV1_PROB_COST_SHIFT)) /
517 pix_num;
518
519 double log_den = log(beta) / log(2.0) + 2.0 * dr;
520
521 if (log_den > log(10.0) / log(2.0)) {
522 rate_cost = (int64_t)((log(1.0 / beta) * pix_num) / log(2.0) / 2.0);
523 rate_cost <<= (TPL_DEP_COST_SCALE_LOG2 + AV1_PROB_COST_SHIFT);
524 return rate_cost;
525 }
526
527 double num = pow(2.0, log_den);
528 double den = num * beta + (1 - beta) * beta;
529
530 rate_cost = (int64_t)((pix_num * log(num / den)) / log(2.0) / 2.0);
531
532 rate_cost <<= (TPL_DEP_COST_SCALE_LOG2 + AV1_PROB_COST_SHIFT);
533
534 return rate_cost;
535 }
536
tpl_model_update_b(TplParams * const tpl_data,int mi_row,int mi_col,const BLOCK_SIZE bsize,int frame_idx)537 static AOM_INLINE void tpl_model_update_b(TplParams *const tpl_data, int mi_row,
538 int mi_col, const BLOCK_SIZE bsize,
539 int frame_idx) {
540 TplDepFrame *tpl_frame_ptr = &tpl_data->tpl_frame[frame_idx];
541 TplDepStats *tpl_ptr = tpl_frame_ptr->tpl_stats_ptr;
542 TplDepFrame *tpl_frame = tpl_data->tpl_frame;
543 const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2;
544 TplDepStats *tpl_stats_ptr = &tpl_ptr[av1_tpl_ptr_pos(
545 mi_row, mi_col, tpl_frame->stride, block_mis_log2)];
546
547 if (tpl_stats_ptr->ref_frame_index < 0) return;
548 const int ref_frame_index = tpl_stats_ptr->ref_frame_index;
549 TplDepFrame *ref_tpl_frame =
550 &tpl_frame[tpl_frame[frame_idx].ref_map_index[ref_frame_index]];
551 TplDepStats *ref_stats_ptr = ref_tpl_frame->tpl_stats_ptr;
552
553 if (tpl_frame[frame_idx].ref_map_index[ref_frame_index] < 0) return;
554
555 const FULLPEL_MV full_mv =
556 get_fullmv_from_mv(&tpl_stats_ptr->mv[ref_frame_index].as_mv);
557 const int ref_pos_row = mi_row * MI_SIZE + full_mv.row;
558 const int ref_pos_col = mi_col * MI_SIZE + full_mv.col;
559
560 const int bw = 4 << mi_size_wide_log2[bsize];
561 const int bh = 4 << mi_size_high_log2[bsize];
562 const int mi_height = mi_size_high[bsize];
563 const int mi_width = mi_size_wide[bsize];
564 const int pix_num = bw * bh;
565
566 // top-left on grid block location in pixel
567 int grid_pos_row_base = round_floor(ref_pos_row, bh) * bh;
568 int grid_pos_col_base = round_floor(ref_pos_col, bw) * bw;
569 int block;
570
571 int64_t cur_dep_dist = tpl_stats_ptr->recrf_dist - tpl_stats_ptr->srcrf_dist;
572 int64_t mc_dep_dist = (int64_t)(
573 tpl_stats_ptr->mc_dep_dist *
574 ((double)(tpl_stats_ptr->recrf_dist - tpl_stats_ptr->srcrf_dist) /
575 tpl_stats_ptr->recrf_dist));
576 int64_t delta_rate = tpl_stats_ptr->recrf_rate - tpl_stats_ptr->srcrf_rate;
577 int64_t mc_dep_rate =
578 delta_rate_cost(tpl_stats_ptr->mc_dep_rate, tpl_stats_ptr->recrf_dist,
579 tpl_stats_ptr->srcrf_dist, pix_num);
580
581 for (block = 0; block < 4; ++block) {
582 int grid_pos_row = grid_pos_row_base + bh * (block >> 1);
583 int grid_pos_col = grid_pos_col_base + bw * (block & 0x01);
584
585 if (grid_pos_row >= 0 && grid_pos_row < ref_tpl_frame->mi_rows * MI_SIZE &&
586 grid_pos_col >= 0 && grid_pos_col < ref_tpl_frame->mi_cols * MI_SIZE) {
587 int overlap_area = get_overlap_area(
588 grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
589 int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
590 int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
591 const int step = 1 << block_mis_log2;
592
593 for (int idy = 0; idy < mi_height; idy += step) {
594 for (int idx = 0; idx < mi_width; idx += step) {
595 TplDepStats *des_stats = &ref_stats_ptr[av1_tpl_ptr_pos(
596 ref_mi_row + idy, ref_mi_col + idx, ref_tpl_frame->stride,
597 block_mis_log2)];
598 des_stats->mc_dep_dist +=
599 ((cur_dep_dist + mc_dep_dist) * overlap_area) / pix_num;
600 des_stats->mc_dep_rate +=
601 ((delta_rate + mc_dep_rate) * overlap_area) / pix_num;
602
603 assert(overlap_area >= 0);
604 }
605 }
606 }
607 }
608 }
609
tpl_model_update(TplParams * const tpl_data,int mi_row,int mi_col,const BLOCK_SIZE bsize,int frame_idx)610 static AOM_INLINE void tpl_model_update(TplParams *const tpl_data, int mi_row,
611 int mi_col, const BLOCK_SIZE bsize,
612 int frame_idx) {
613 const int mi_height = mi_size_high[bsize];
614 const int mi_width = mi_size_wide[bsize];
615 const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
616 const BLOCK_SIZE tpl_block_size =
617 convert_length_to_bsize(MI_SIZE << tpl_data->tpl_stats_block_mis_log2);
618
619 for (int idy = 0; idy < mi_height; idy += step) {
620 for (int idx = 0; idx < mi_width; idx += step) {
621 tpl_model_update_b(tpl_data, mi_row + idy, mi_col + idx, tpl_block_size,
622 frame_idx);
623 }
624 }
625 }
626
tpl_model_store(TplDepStats * tpl_stats_ptr,int mi_row,int mi_col,BLOCK_SIZE bsize,int stride,const TplDepStats * src_stats,uint8_t block_mis_log2)627 static AOM_INLINE void tpl_model_store(TplDepStats *tpl_stats_ptr, int mi_row,
628 int mi_col, BLOCK_SIZE bsize, int stride,
629 const TplDepStats *src_stats,
630 uint8_t block_mis_log2) {
631 const int mi_height = mi_size_high[bsize];
632 const int mi_width = mi_size_wide[bsize];
633 const int step = 1 << block_mis_log2;
634
635 int64_t intra_cost = src_stats->intra_cost / (mi_height * mi_width);
636 int64_t inter_cost = src_stats->inter_cost / (mi_height * mi_width);
637 int64_t srcrf_dist = src_stats->srcrf_dist / (mi_height * mi_width);
638 int64_t recrf_dist = src_stats->recrf_dist / (mi_height * mi_width);
639 int64_t srcrf_rate = src_stats->srcrf_rate / (mi_height * mi_width);
640 int64_t recrf_rate = src_stats->recrf_rate / (mi_height * mi_width);
641
642 intra_cost = AOMMAX(1, intra_cost);
643 inter_cost = AOMMAX(1, inter_cost);
644 srcrf_dist = AOMMAX(1, srcrf_dist);
645 recrf_dist = AOMMAX(1, recrf_dist);
646 srcrf_rate = AOMMAX(1, srcrf_rate);
647 recrf_rate = AOMMAX(1, recrf_rate);
648
649 for (int idy = 0; idy < mi_height; idy += step) {
650 TplDepStats *tpl_ptr = &tpl_stats_ptr[av1_tpl_ptr_pos(
651 mi_row + idy, mi_col, stride, block_mis_log2)];
652 for (int idx = 0; idx < mi_width; idx += step) {
653 tpl_ptr->intra_cost = intra_cost;
654 tpl_ptr->inter_cost = inter_cost;
655 tpl_ptr->srcrf_dist = srcrf_dist;
656 tpl_ptr->recrf_dist = recrf_dist;
657 tpl_ptr->srcrf_rate = srcrf_rate;
658 tpl_ptr->recrf_rate = recrf_rate;
659 memcpy(tpl_ptr->mv, src_stats->mv, sizeof(tpl_ptr->mv));
660 memcpy(tpl_ptr->pred_error, src_stats->pred_error,
661 sizeof(tpl_ptr->pred_error));
662 tpl_ptr->ref_frame_index = src_stats->ref_frame_index;
663 ++tpl_ptr;
664 }
665 }
666 }
667
mc_flow_dispenser(AV1_COMP * cpi,int frame_idx,int pframe_qindex)668 static AOM_INLINE void mc_flow_dispenser(AV1_COMP *cpi, int frame_idx,
669 int pframe_qindex) {
670 const GF_GROUP *gf_group = &cpi->gf_group;
671 if (frame_idx == gf_group->size) return;
672 TplParams *const tpl_data = &cpi->tpl_data;
673 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
674 const YV12_BUFFER_CONFIG *this_frame = tpl_frame->gf_picture;
675 const YV12_BUFFER_CONFIG *ref_frame[7] = { NULL, NULL, NULL, NULL,
676 NULL, NULL, NULL };
677 const YV12_BUFFER_CONFIG *ref_frames_ordered[INTER_REFS_PER_FRAME];
678 int ref_frame_flags;
679 const YV12_BUFFER_CONFIG *src_frame[7] = { NULL, NULL, NULL, NULL,
680 NULL, NULL, NULL };
681
682 AV1_COMMON *cm = &cpi->common;
683 const CommonModeInfoParams *const mi_params = &cm->mi_params;
684 struct scale_factors sf;
685 int rdmult, idx;
686 ThreadData *td = &cpi->td;
687 MACROBLOCK *x = &td->mb;
688 MACROBLOCKD *xd = &x->e_mbd;
689 int mi_row, mi_col;
690 const BLOCK_SIZE bsize = convert_length_to_bsize(MC_FLOW_BSIZE_1D);
691 av1_tile_init(&xd->tile, cm, 0, 0);
692
693 const TX_SIZE tx_size = max_txsize_lookup[bsize];
694 const int mi_height = mi_size_high[bsize];
695 const int mi_width = mi_size_wide[bsize];
696
697 // Setup scaling factor
698 av1_setup_scale_factors_for_frame(
699 &sf, this_frame->y_crop_width, this_frame->y_crop_height,
700 this_frame->y_crop_width, this_frame->y_crop_height);
701
702 xd->cur_buf = this_frame;
703
704 for (idx = 0; idx < INTER_REFS_PER_FRAME; ++idx) {
705 ref_frame[idx] =
706 tpl_data->tpl_frame[tpl_frame->ref_map_index[idx]].rec_picture;
707 src_frame[idx] =
708 tpl_data->tpl_frame[tpl_frame->ref_map_index[idx]].gf_picture;
709 }
710
711 // Store the reference frames based on priority order
712 for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
713 ref_frames_ordered[i] = ref_frame[ref_frame_priority_order[i] - 1];
714 }
715
716 // Work out which reference frame slots may be used.
717 ref_frame_flags = get_ref_frame_flags(&cpi->sf, ref_frames_ordered,
718 cpi->ext_flags.ref_frame_flags);
719
720 enforce_max_ref_frames(cpi, &ref_frame_flags);
721
722 // Prune reference frames
723 for (idx = 0; idx < INTER_REFS_PER_FRAME; ++idx) {
724 if ((ref_frame_flags & (1 << idx)) == 0) {
725 ref_frame[idx] = NULL;
726 }
727 }
728
729 // Make a temporary mbmi for tpl model
730 MB_MODE_INFO mbmi;
731 memset(&mbmi, 0, sizeof(mbmi));
732 MB_MODE_INFO *mbmi_ptr = &mbmi;
733 xd->mi = &mbmi_ptr;
734
735 xd->block_ref_scale_factors[0] = &sf;
736
737 const int base_qindex = pframe_qindex;
738 // Get rd multiplier set up.
739 rdmult = (int)av1_compute_rd_mult(cpi, base_qindex);
740 if (rdmult < 1) rdmult = 1;
741 set_error_per_bit(x, rdmult);
742 av1_initialize_me_consts(cpi, x, base_qindex);
743
744 tpl_frame->is_valid = 1;
745
746 cm->quant_params.base_qindex = base_qindex;
747 av1_frame_init_quantizer(cpi);
748
749 tpl_frame->base_rdmult =
750 av1_compute_rd_mult_based_on_qindex(cpi, pframe_qindex) / 6;
751
752 for (mi_row = 0; mi_row < mi_params->mi_rows; mi_row += mi_height) {
753 // Motion estimation row boundary
754 av1_set_mv_row_limits(mi_params, &x->mv_limits, mi_row, mi_height,
755 cpi->oxcf.border_in_pixels);
756 xd->mb_to_top_edge = -GET_MV_SUBPEL(mi_row * MI_SIZE);
757 xd->mb_to_bottom_edge =
758 GET_MV_SUBPEL((mi_params->mi_rows - mi_height - mi_row) * MI_SIZE);
759 for (mi_col = 0; mi_col < mi_params->mi_cols; mi_col += mi_width) {
760 TplDepStats tpl_stats;
761
762 // Motion estimation column boundary
763 av1_set_mv_col_limits(mi_params, &x->mv_limits, mi_col, mi_width,
764 cpi->oxcf.border_in_pixels);
765 xd->mb_to_left_edge = -GET_MV_SUBPEL(mi_col * MI_SIZE);
766 xd->mb_to_right_edge =
767 GET_MV_SUBPEL(mi_params->mi_cols - mi_width - mi_col);
768 mode_estimation(cpi, x, xd, &sf, frame_idx, mi_row, mi_col, bsize,
769 tx_size, ref_frame, src_frame, &tpl_stats);
770
771 // Motion flow dependency dispenser.
772 tpl_model_store(tpl_frame->tpl_stats_ptr, mi_row, mi_col, bsize,
773 tpl_frame->stride, &tpl_stats,
774 tpl_data->tpl_stats_block_mis_log2);
775 }
776 }
777 }
778
mc_flow_synthesizer(AV1_COMP * cpi,int frame_idx)779 static void mc_flow_synthesizer(AV1_COMP *cpi, int frame_idx) {
780 AV1_COMMON *cm = &cpi->common;
781
782 const GF_GROUP *gf_group = &cpi->gf_group;
783 if (frame_idx == gf_group->size) return;
784
785 TplParams *const tpl_data = &cpi->tpl_data;
786
787 const BLOCK_SIZE bsize = convert_length_to_bsize(MC_FLOW_BSIZE_1D);
788 const int mi_height = mi_size_high[bsize];
789 const int mi_width = mi_size_wide[bsize];
790
791 for (int mi_row = 0; mi_row < cm->mi_params.mi_rows; mi_row += mi_height) {
792 for (int mi_col = 0; mi_col < cm->mi_params.mi_cols; mi_col += mi_width) {
793 if (frame_idx) {
794 tpl_model_update(tpl_data, mi_row, mi_col, bsize, frame_idx);
795 }
796 }
797 }
798 }
799
init_gop_frames_for_tpl(AV1_COMP * cpi,const EncodeFrameParams * const init_frame_params,GF_GROUP * gf_group,int gop_eval,int * tpl_group_frames,const EncodeFrameInput * const frame_input,int * pframe_qindex)800 static AOM_INLINE void init_gop_frames_for_tpl(
801 AV1_COMP *cpi, const EncodeFrameParams *const init_frame_params,
802 GF_GROUP *gf_group, int gop_eval, int *tpl_group_frames,
803 const EncodeFrameInput *const frame_input, int *pframe_qindex) {
804 AV1_COMMON *cm = &cpi->common;
805 int cur_frame_idx = gf_group->index;
806 *pframe_qindex = 0;
807
808 RefBufferStack ref_buffer_stack = cpi->ref_buffer_stack;
809 EncodeFrameParams frame_params = *init_frame_params;
810 TplParams *const tpl_data = &cpi->tpl_data;
811
812 int ref_picture_map[REF_FRAMES];
813
814 for (int i = 0; i < REF_FRAMES; ++i) {
815 if (frame_params.frame_type == KEY_FRAME || gop_eval) {
816 tpl_data->tpl_frame[-i - 1].gf_picture = NULL;
817 tpl_data->tpl_frame[-1 - 1].rec_picture = NULL;
818 tpl_data->tpl_frame[-i - 1].frame_display_index = 0;
819 } else {
820 tpl_data->tpl_frame[-i - 1].gf_picture = &cm->ref_frame_map[i]->buf;
821 tpl_data->tpl_frame[-i - 1].rec_picture = &cm->ref_frame_map[i]->buf;
822 tpl_data->tpl_frame[-i - 1].frame_display_index =
823 cm->ref_frame_map[i]->display_order_hint;
824 }
825
826 ref_picture_map[i] = -i - 1;
827 }
828
829 *tpl_group_frames = cur_frame_idx;
830
831 int gf_index;
832 int use_arf = gf_group->update_type[1] == ARF_UPDATE;
833 int anc_frame_offset = gf_group->cur_frame_idx[cur_frame_idx] + 1;
834 int process_frame_count = 0;
835 const int gop_length =
836 AOMMIN(gf_group->size - 1 + use_arf, MAX_LENGTH_TPL_FRAME_STATS - 1);
837 for (gf_index = cur_frame_idx; gf_index <= gop_length; ++gf_index) {
838 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_index];
839 FRAME_UPDATE_TYPE frame_update_type = gf_group->update_type[gf_index];
840
841 frame_params.show_frame = frame_update_type != ARF_UPDATE &&
842 frame_update_type != INTNL_ARF_UPDATE;
843 frame_params.show_existing_frame =
844 frame_update_type == INTNL_OVERLAY_UPDATE ||
845 frame_update_type == OVERLAY_UPDATE;
846 frame_params.frame_type =
847 frame_update_type == KF_UPDATE ? KEY_FRAME : INTER_FRAME;
848
849 if (frame_update_type == LF_UPDATE)
850 *pframe_qindex = gf_group->q_val[gf_index];
851
852 if (gf_index == cur_frame_idx) {
853 tpl_frame->gf_picture = frame_input->source;
854 // frame display index = frame offset within the gf group + start frame of
855 // the gf group
856 tpl_frame->frame_display_index =
857 gf_group->frame_disp_idx[gf_index] +
858 cpi->common.current_frame.display_order_hint;
859 } else {
860 int frame_display_index = gf_index == gf_group->size
861 ? cpi->rc.baseline_gf_interval
862 : gf_group->frame_disp_idx[gf_index];
863 struct lookahead_entry *buf = av1_lookahead_peek(
864 cpi->lookahead, frame_display_index - anc_frame_offset,
865 cpi->compressor_stage);
866 if (buf == NULL) break;
867 tpl_frame->gf_picture = &buf->img;
868 // frame display index = frame offset within the gf group + start frame of
869 // the gf group
870 tpl_frame->frame_display_index =
871 frame_display_index + cpi->common.current_frame.display_order_hint;
872 }
873
874 if (frame_update_type != OVERLAY_UPDATE &&
875 frame_update_type != INTNL_OVERLAY_UPDATE) {
876 tpl_frame->rec_picture = &tpl_data->tpl_rec_pool[process_frame_count];
877 tpl_frame->tpl_stats_ptr = tpl_data->tpl_stats_pool[process_frame_count];
878 ++process_frame_count;
879 }
880
881 av1_get_ref_frames(cpi, &ref_buffer_stack);
882 int refresh_mask = av1_get_refresh_frame_flags(
883 cpi, &frame_params, frame_update_type, &ref_buffer_stack);
884
885 int refresh_frame_map_index = av1_get_refresh_ref_frame_map(refresh_mask);
886 av1_update_ref_frame_map(cpi, frame_update_type,
887 frame_params.show_existing_frame,
888 refresh_frame_map_index, &ref_buffer_stack);
889
890 for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i)
891 tpl_frame->ref_map_index[i - LAST_FRAME] =
892 ref_picture_map[cm->remapped_ref_idx[i - LAST_FRAME]];
893
894 if (refresh_mask) ref_picture_map[refresh_frame_map_index] = gf_index;
895
896 ++*tpl_group_frames;
897 }
898
899 if (cur_frame_idx == 0) return;
900
901 int extend_frame_count = 0;
902 int extend_frame_length =
903 AOMMIN(cpi->rc.baseline_gf_interval,
904 cpi->rc.frames_to_key - cpi->rc.baseline_gf_interval);
905 int frame_display_index = cpi->rc.baseline_gf_interval + 1;
906
907 for (; gf_index < MAX_LENGTH_TPL_FRAME_STATS &&
908 extend_frame_count < extend_frame_length;
909 ++gf_index) {
910 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_index];
911 FRAME_UPDATE_TYPE frame_update_type = LF_UPDATE;
912 frame_params.show_frame = frame_update_type != ARF_UPDATE &&
913 frame_update_type != INTNL_ARF_UPDATE;
914 frame_params.show_existing_frame =
915 frame_update_type == INTNL_OVERLAY_UPDATE;
916 frame_params.frame_type = INTER_FRAME;
917
918 struct lookahead_entry *buf = av1_lookahead_peek(
919 cpi->lookahead, frame_display_index - anc_frame_offset,
920 cpi->compressor_stage);
921
922 if (buf == NULL) break;
923
924 tpl_frame->gf_picture = &buf->img;
925 tpl_frame->rec_picture = &tpl_data->tpl_rec_pool[process_frame_count];
926 tpl_frame->tpl_stats_ptr = tpl_data->tpl_stats_pool[process_frame_count];
927 ++process_frame_count;
928
929 // frame display index = frame offset within the gf group + start frame of
930 // the gf group
931 tpl_frame->frame_display_index =
932 frame_display_index + cpi->common.current_frame.display_order_hint;
933
934 gf_group->update_type[gf_index] = LF_UPDATE;
935 gf_group->q_val[gf_index] = *pframe_qindex;
936
937 av1_get_ref_frames(cpi, &ref_buffer_stack);
938 int refresh_mask = av1_get_refresh_frame_flags(
939 cpi, &frame_params, frame_update_type, &ref_buffer_stack);
940 int refresh_frame_map_index = av1_get_refresh_ref_frame_map(refresh_mask);
941 av1_update_ref_frame_map(cpi, frame_update_type,
942 frame_params.show_existing_frame,
943 refresh_frame_map_index, &ref_buffer_stack);
944
945 for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i)
946 tpl_frame->ref_map_index[i - LAST_FRAME] =
947 ref_picture_map[cm->remapped_ref_idx[i - LAST_FRAME]];
948
949 tpl_frame->ref_map_index[ALTREF_FRAME - LAST_FRAME] = -1;
950 tpl_frame->ref_map_index[LAST3_FRAME - LAST_FRAME] = -1;
951 tpl_frame->ref_map_index[BWDREF_FRAME - LAST_FRAME] = -1;
952 tpl_frame->ref_map_index[ALTREF2_FRAME - LAST_FRAME] = -1;
953
954 if (refresh_mask) ref_picture_map[refresh_frame_map_index] = gf_index;
955
956 ++*tpl_group_frames;
957 ++extend_frame_count;
958 ++frame_display_index;
959 }
960
961 av1_get_ref_frames(cpi, &cpi->ref_buffer_stack);
962 }
963
init_tpl_stats(TplParams * const tpl_data)964 static AOM_INLINE void init_tpl_stats(TplParams *const tpl_data) {
965 for (int frame_idx = 0; frame_idx < MAX_LAG_BUFFERS; ++frame_idx) {
966 TplDepFrame *tpl_frame = &tpl_data->tpl_stats_buffer[frame_idx];
967 memset(tpl_data->tpl_stats_pool[frame_idx], 0,
968 tpl_frame->height * tpl_frame->width *
969 sizeof(*tpl_frame->tpl_stats_ptr));
970 tpl_frame->is_valid = 0;
971 }
972 }
973
av1_tpl_setup_stats(AV1_COMP * cpi,int gop_eval,const EncodeFrameParams * const frame_params,const EncodeFrameInput * const frame_input)974 int av1_tpl_setup_stats(AV1_COMP *cpi, int gop_eval,
975 const EncodeFrameParams *const frame_params,
976 const EncodeFrameInput *const frame_input) {
977 AV1_COMMON *cm = &cpi->common;
978 GF_GROUP *gf_group = &cpi->gf_group;
979 int bottom_index, top_index;
980 EncodeFrameParams this_frame_params = *frame_params;
981 TplParams *const tpl_data = &cpi->tpl_data;
982
983 if (cpi->superres_mode != SUPERRES_NONE) return 0;
984
985 cm->current_frame.frame_type = frame_params->frame_type;
986 for (int gf_index = gf_group->index; gf_index < gf_group->size; ++gf_index) {
987 av1_configure_buffer_updates(cpi, &this_frame_params,
988 gf_group->update_type[gf_index], 0);
989
990 cpi->refresh_golden_frame = this_frame_params.refresh_golden_frame;
991 cpi->refresh_bwd_ref_frame = this_frame_params.refresh_bwd_ref_frame;
992 cpi->refresh_alt_ref_frame = this_frame_params.refresh_alt_ref_frame;
993
994 cm->show_frame = gf_group->update_type[gf_index] != ARF_UPDATE &&
995 gf_group->update_type[gf_index] != INTNL_ARF_UPDATE;
996
997 gf_group->q_val[gf_index] =
998 av1_rc_pick_q_and_bounds(cpi, &cpi->rc, cm->width, cm->height, gf_index,
999 &bottom_index, &top_index);
1000
1001 cm->current_frame.frame_type = INTER_FRAME;
1002 }
1003
1004 int pframe_qindex;
1005 int tpl_gf_group_frames;
1006 init_gop_frames_for_tpl(cpi, frame_params, gf_group, gop_eval,
1007 &tpl_gf_group_frames, frame_input, &pframe_qindex);
1008
1009 cpi->rc.base_layer_qp = pframe_qindex;
1010
1011 init_tpl_stats(tpl_data);
1012
1013 // Backward propagation from tpl_group_frames to 1.
1014 for (int frame_idx = gf_group->index; frame_idx < tpl_gf_group_frames;
1015 ++frame_idx) {
1016 if (gf_group->update_type[frame_idx] == INTNL_OVERLAY_UPDATE ||
1017 gf_group->update_type[frame_idx] == OVERLAY_UPDATE)
1018 continue;
1019
1020 mc_flow_dispenser(cpi, frame_idx, pframe_qindex);
1021
1022 aom_extend_frame_borders(tpl_data->tpl_frame[frame_idx].rec_picture,
1023 av1_num_planes(cm));
1024 }
1025
1026 for (int frame_idx = tpl_gf_group_frames - 1; frame_idx >= gf_group->index;
1027 --frame_idx) {
1028 if (gf_group->update_type[frame_idx] == INTNL_OVERLAY_UPDATE ||
1029 gf_group->update_type[frame_idx] == OVERLAY_UPDATE)
1030 continue;
1031
1032 mc_flow_synthesizer(cpi, frame_idx);
1033 }
1034
1035 av1_configure_buffer_updates(cpi, &this_frame_params,
1036 gf_group->update_type[gf_group->index], 0);
1037 cm->current_frame.frame_type = frame_params->frame_type;
1038 cm->show_frame = frame_params->show_frame;
1039
1040 if (cpi->common.tiles.large_scale) return 0;
1041 if (gf_group->max_layer_depth_allowed == 0) return 1;
1042
1043 double beta[2] = { 0.0 };
1044 for (int frame_idx = 1; frame_idx <= AOMMIN(tpl_gf_group_frames - 1, 2);
1045 ++frame_idx) {
1046 TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
1047 TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
1048 int tpl_stride = tpl_frame->stride;
1049 int64_t intra_cost_base = 0;
1050 int64_t mc_dep_cost_base = 0;
1051 const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
1052 const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
1053
1054 for (int row = 0; row < cm->mi_params.mi_rows; row += step) {
1055 for (int col = 0; col < mi_cols_sr; col += step) {
1056 TplDepStats *this_stats = &tpl_stats[av1_tpl_ptr_pos(
1057 row, col, tpl_stride, tpl_data->tpl_stats_block_mis_log2)];
1058 int64_t mc_dep_delta =
1059 RDCOST(tpl_frame->base_rdmult, this_stats->mc_dep_rate,
1060 this_stats->mc_dep_dist);
1061 intra_cost_base += (this_stats->recrf_dist << RDDIV_BITS);
1062 mc_dep_cost_base +=
1063 (this_stats->recrf_dist << RDDIV_BITS) + mc_dep_delta;
1064 }
1065 }
1066 beta[frame_idx - 1] = (double)mc_dep_cost_base / intra_cost_base;
1067 }
1068
1069 // Allow larger GOP size if the base layer ARF has higher dependency factor
1070 // than the intermediate ARF and both ARFs have reasonably high dependency
1071 // factors.
1072 return (beta[0] >= beta[1] + 0.7) && beta[0] > 3.0;
1073 }
1074
av1_tpl_rdmult_setup(AV1_COMP * cpi)1075 void av1_tpl_rdmult_setup(AV1_COMP *cpi) {
1076 const AV1_COMMON *const cm = &cpi->common;
1077 const GF_GROUP *const gf_group = &cpi->gf_group;
1078 const int tpl_idx = gf_group->index;
1079
1080 assert(IMPLIES(gf_group->size > 0, tpl_idx < gf_group->size));
1081
1082 TplParams *const tpl_data = &cpi->tpl_data;
1083 const TplDepFrame *const tpl_frame = &tpl_data->tpl_frame[tpl_idx];
1084
1085 if (!tpl_frame->is_valid) return;
1086 if (cpi->superres_mode != SUPERRES_NONE) return;
1087
1088 const TplDepStats *const tpl_stats = tpl_frame->tpl_stats_ptr;
1089 const int tpl_stride = tpl_frame->stride;
1090 const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
1091
1092 const int block_size = BLOCK_16X16;
1093 const int num_mi_w = mi_size_wide[block_size];
1094 const int num_mi_h = mi_size_high[block_size];
1095 const int num_cols = (mi_cols_sr + num_mi_w - 1) / num_mi_w;
1096 const int num_rows = (cm->mi_params.mi_rows + num_mi_h - 1) / num_mi_h;
1097 const double c = 1.2;
1098 const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
1099
1100 aom_clear_system_state();
1101
1102 // Loop through each 'block_size' X 'block_size' block.
1103 for (int row = 0; row < num_rows; row++) {
1104 for (int col = 0; col < num_cols; col++) {
1105 double intra_cost = 0.0, mc_dep_cost = 0.0;
1106 // Loop through each mi block.
1107 for (int mi_row = row * num_mi_h; mi_row < (row + 1) * num_mi_h;
1108 mi_row += step) {
1109 for (int mi_col = col * num_mi_w; mi_col < (col + 1) * num_mi_w;
1110 mi_col += step) {
1111 if (mi_row >= cm->mi_params.mi_rows || mi_col >= mi_cols_sr) continue;
1112 const TplDepStats *this_stats = &tpl_stats[av1_tpl_ptr_pos(
1113 mi_row, mi_col, tpl_stride, tpl_data->tpl_stats_block_mis_log2)];
1114 int64_t mc_dep_delta =
1115 RDCOST(tpl_frame->base_rdmult, this_stats->mc_dep_rate,
1116 this_stats->mc_dep_dist);
1117 intra_cost += (double)(this_stats->recrf_dist << RDDIV_BITS);
1118 mc_dep_cost +=
1119 (double)(this_stats->recrf_dist << RDDIV_BITS) + mc_dep_delta;
1120 }
1121 }
1122 const double rk = intra_cost / mc_dep_cost;
1123 const int index = row * num_cols + col;
1124 cpi->tpl_rdmult_scaling_factors[index] = rk / cpi->rd.r0 + c;
1125 }
1126 }
1127 aom_clear_system_state();
1128 }
1129
av1_tpl_rdmult_setup_sb(AV1_COMP * cpi,MACROBLOCK * const x,BLOCK_SIZE sb_size,int mi_row,int mi_col)1130 void av1_tpl_rdmult_setup_sb(AV1_COMP *cpi, MACROBLOCK *const x,
1131 BLOCK_SIZE sb_size, int mi_row, int mi_col) {
1132 AV1_COMMON *const cm = &cpi->common;
1133 assert(IMPLIES(cpi->gf_group.size > 0,
1134 cpi->gf_group.index < cpi->gf_group.size));
1135 const int tpl_idx = cpi->gf_group.index;
1136 TplDepFrame *tpl_frame = &cpi->tpl_data.tpl_frame[tpl_idx];
1137
1138 if (tpl_frame->is_valid == 0) return;
1139 if (!is_frame_tpl_eligible(cpi)) return;
1140 if (tpl_idx >= MAX_LAG_BUFFERS) return;
1141 if (cpi->superres_mode != SUPERRES_NONE) return;
1142 if (cpi->oxcf.aq_mode != NO_AQ) return;
1143
1144 const int bsize_base = BLOCK_16X16;
1145 const int num_mi_w = mi_size_wide[bsize_base];
1146 const int num_mi_h = mi_size_high[bsize_base];
1147 const int num_cols = (cm->mi_params.mi_cols + num_mi_w - 1) / num_mi_w;
1148 const int num_rows = (cm->mi_params.mi_rows + num_mi_h - 1) / num_mi_h;
1149 const int num_bcols = (mi_size_wide[sb_size] + num_mi_w - 1) / num_mi_w;
1150 const int num_brows = (mi_size_high[sb_size] + num_mi_h - 1) / num_mi_h;
1151 int row, col;
1152
1153 double base_block_count = 0.0;
1154 double log_sum = 0.0;
1155
1156 aom_clear_system_state();
1157 for (row = mi_row / num_mi_w;
1158 row < num_rows && row < mi_row / num_mi_w + num_brows; ++row) {
1159 for (col = mi_col / num_mi_h;
1160 col < num_cols && col < mi_col / num_mi_h + num_bcols; ++col) {
1161 const int index = row * num_cols + col;
1162 log_sum += log(cpi->tpl_rdmult_scaling_factors[index]);
1163 base_block_count += 1.0;
1164 }
1165 }
1166
1167 MACROBLOCKD *const xd = &x->e_mbd;
1168 const CommonQuantParams *quant_params = &cm->quant_params;
1169 const int orig_rdmult = av1_compute_rd_mult(
1170 cpi, quant_params->base_qindex + quant_params->y_dc_delta_q);
1171 const int new_rdmult =
1172 av1_compute_rd_mult(cpi, quant_params->base_qindex + xd->delta_qindex +
1173 quant_params->y_dc_delta_q);
1174 const double scaling_factor = (double)new_rdmult / (double)orig_rdmult;
1175
1176 double scale_adj = log(scaling_factor) - log_sum / base_block_count;
1177 scale_adj = exp(scale_adj);
1178
1179 for (row = mi_row / num_mi_w;
1180 row < num_rows && row < mi_row / num_mi_w + num_brows; ++row) {
1181 for (col = mi_col / num_mi_h;
1182 col < num_cols && col < mi_col / num_mi_h + num_bcols; ++col) {
1183 const int index = row * num_cols + col;
1184 cpi->tpl_sb_rdmult_scaling_factors[index] =
1185 scale_adj * cpi->tpl_rdmult_scaling_factors[index];
1186 }
1187 }
1188 aom_clear_system_state();
1189 }
1190