Coverage Report

Created: 2022-08-24 06:17

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