/*

 * Copyright (c) 2019, Alliance for Open Media. All rights reserved.

 *

 * This source code is subject to the terms of the BSD 2 Clause License and

 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License

 * was not distributed with this source code in the LICENSE file, you can

 * obtain it at www.aomedia.org/license/software. If the Alliance for Open

 * Media Patent License 1.0 was not distributed with this source code in the

 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.

 */

/*!\defgroup gf_group_algo Golden Frame Group

 * \ingroup high_level_algo

 * Algorithms regarding determining the length of GF groups and defining GF

 * group structures.

 * @{

 */

/*! @} - end defgroup gf_group_algo */

#include <assert.h>

#include <limits.h>

#include <stdint.h>

#include "aom_dsp/aom_dsp_common.h"

#include "aom_mem/aom_mem.h"

#include "config/aom_config.h"

#include "config/aom_scale_rtcd.h"

#include "aom/aom_codec.h"

#include "aom/aom_encoder.h"

#include "av1/common/av1_common_int.h"

#include "av1/encoder/encoder.h"

#include "av1/encoder/firstpass.h"

#include "av1/encoder/gop_structure.h"

#include "av1/encoder/pass2_strategy.h"

#include "av1/encoder/ratectrl.h"

#include "av1/encoder/rc_utils.h"

#include "av1/encoder/temporal_filter.h"

#if CONFIG_THREE_PASS

#include "av1/encoder/thirdpass.h"

#endif

#include "av1/encoder/tpl_model.h"

#include "av1/encoder/encode_strategy.h"

#define DEFAULT_KF_BOOST 2300

#define DEFAULT_GF_BOOST 2000

#define GROUP_ADAPTIVE_MAXQ 1

static void init_gf_stats(GF_GROUP_STATS *gf_stats);

#if CONFIG_THREE_PASS

static int define_gf_group_pass3(AV1_COMP *cpi, EncodeFrameParams *frame_params,

                                 int is_final_pass);

#endif

// Calculate an active area of the image that discounts formatting

// bars and partially discounts other 0 energy areas.

#define MIN_ACTIVE_AREA 0.5

#define MAX_ACTIVE_AREA 1.0

static double calculate_active_area(const FRAME_INFO *frame_info,

                                    const FIRSTPASS_STATS *this_frame) {

  const double active_pct =

      1.0 -

      ((this_frame->intra_skip_pct / 2) +

       ((this_frame->inactive_zone_rows * 2) / (double)frame_info->mb_rows));

  return fclamp(active_pct, MIN_ACTIVE_AREA, MAX_ACTIVE_AREA);

}

// Calculate a modified Error used in distributing bits between easier and

// harder frames.

#define ACT_AREA_CORRECTION 0.5

static double calculate_modified_err_new(const FRAME_INFO *frame_info,

                                         const FIRSTPASS_STATS *total_stats,

                                         const FIRSTPASS_STATS *this_stats,

                                         int vbrbias, double modified_error_min,

                                         double modified_error_max) {

  if (total_stats == NULL) {

    return 0;

  }

  const double av_weight = total_stats->weight / total_stats->count;

  const double av_err =

      (total_stats->coded_error * av_weight) / total_stats->count;

  double modified_error =

      av_err * pow(this_stats->coded_error * this_stats->weight /

                       DOUBLE_DIVIDE_CHECK(av_err),

                   vbrbias / 100.0);

  // Correction for active area. Frames with a reduced active area

  // (eg due to formatting bars) have a higher error per mb for the

  // remaining active MBs. The correction here assumes that coding

  // 0.5N blocks of complexity 2X is a little easier than coding N

  // blocks of complexity X.

  modified_error *=

      pow(calculate_active_area(frame_info, this_stats), ACT_AREA_CORRECTION);

  return fclamp(modified_error, modified_error_min, modified_error_max);

}

static double calculate_modified_err(const FRAME_INFO *frame_info,

                                     const TWO_PASS *twopass,

                                     const AV1EncoderConfig *oxcf,

                                     const FIRSTPASS_STATS *this_frame) {

  const FIRSTPASS_STATS *total_stats = twopass->stats_buf_ctx->total_stats;

  return calculate_modified_err_new(

      frame_info, total_stats, this_frame, oxcf->rc_cfg.vbrbias,

      twopass->modified_error_min, twopass->modified_error_max);

}

// Resets the first pass file to the given position using a relative seek from

// the current position.

static void reset_fpf_position(TWO_PASS_FRAME *p_frame,

                               const FIRSTPASS_STATS *position) {

  p_frame->stats_in = position;

}

static int input_stats(TWO_PASS *p, TWO_PASS_FRAME *p_frame,

                       FIRSTPASS_STATS *fps) {

  if (p_frame->stats_in >= p->stats_buf_ctx->stats_in_end) return EOF;

  *fps = *p_frame->stats_in;

  ++p_frame->stats_in;

  return 1;

}

static int input_stats_lap(TWO_PASS *p, TWO_PASS_FRAME *p_frame,

                           FIRSTPASS_STATS *fps) {

  if (p_frame->stats_in >= p->stats_buf_ctx->stats_in_end) return EOF;

  *fps = *p_frame->stats_in;

  /* Move old stats[0] out to accommodate for next frame stats  */

  memmove(p->frame_stats_arr[0], p->frame_stats_arr[1],

          (p->stats_buf_ctx->stats_in_end - p_frame->stats_in - 1) *

              sizeof(FIRSTPASS_STATS));

  p->stats_buf_ctx->stats_in_end--;

  return 1;

}

// Read frame stats at an offset from the current position.

static const FIRSTPASS_STATS *read_frame_stats(const TWO_PASS *p,

                                               const TWO_PASS_FRAME *p_frame,

                                               int offset) {

  if ((offset >= 0 &&

       p_frame->stats_in + offset >= p->stats_buf_ctx->stats_in_end) ||

      (offset < 0 &&

       p_frame->stats_in + offset < p->stats_buf_ctx->stats_in_start)) {

    return NULL;

  }

  return &p_frame->stats_in[offset];

}

// This function returns the maximum target rate per frame.

static int frame_max_bits(const RATE_CONTROL *rc,

                          const AV1EncoderConfig *oxcf) {

  int64_t max_bits = ((int64_t)rc->avg_frame_bandwidth *

                      (int64_t)oxcf->rc_cfg.vbrmax_section) /

                     100;

  if (max_bits < 0)

    max_bits = 0;

  else if (max_bits > rc->max_frame_bandwidth)

    max_bits = rc->max_frame_bandwidth;

  return (int)max_bits;

}

static const double q_pow_term[(QINDEX_RANGE >> 5) + 1] = { 0.65, 0.70, 0.75,

                                                            0.80, 0.85, 0.90,

                                                            0.95, 0.95, 0.95 };

#define ERR_DIVISOR 96.0

static double calc_correction_factor(double err_per_mb, int q) {

  const double error_term = err_per_mb / ERR_DIVISOR;

  const int index = q >> 5;

  // Adjustment to power term based on qindex

  const double power_term =

      q_pow_term[index] +

      (((q_pow_term[index + 1] - q_pow_term[index]) * (q % 32)) / 32.0);

  assert(error_term >= 0.0);

  return fclamp(pow(error_term, power_term), 0.05, 5.0);

}

// Based on history adjust expectations of bits per macroblock.

static void twopass_update_bpm_factor(AV1_COMP *cpi, int rate_err_tol) {

  TWO_PASS *const twopass = &cpi->ppi->twopass;

  const PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;

  // Based on recent history adjust expectations of bits per macroblock.

  double damp_fac = AOMMAX(5.0, rate_err_tol / 10.0);

  double rate_err_factor = 1.0;

  const double adj_limit = AOMMAX(0.2, (double)(100 - rate_err_tol) / 200.0);

  const double min_fac = 1.0 - adj_limit;

  const double max_fac = 1.0 + adj_limit;

#if CONFIG_THREE_PASS

  if (cpi->third_pass_ctx && cpi->third_pass_ctx->frame_info_count > 0) {

    int64_t actual_bits = 0;

    int64_t target_bits = 0;

    double factor = 0.0;

    int count = 0;

    for (int i = 0; i < cpi->third_pass_ctx->frame_info_count; i++) {

      actual_bits += cpi->third_pass_ctx->frame_info[i].actual_bits;

      target_bits += cpi->third_pass_ctx->frame_info[i].bits_allocated;

      factor += cpi->third_pass_ctx->frame_info[i].bpm_factor;

      count++;

    }

    if (count == 0) {

      factor = 1.0;

    } else {

      factor /= (double)count;

    }

    factor *= (double)actual_bits / DOUBLE_DIVIDE_CHECK((double)target_bits);

    if ((twopass->bpm_factor <= 1 && factor < twopass->bpm_factor) ||

        (twopass->bpm_factor >= 1 && factor > twopass->bpm_factor)) {

      twopass->bpm_factor = fclamp(factor, min_fac, max_fac);

    }

  }

#endif  // CONFIG_THREE_PASS

  int err_estimate = p_rc->rate_error_estimate;

  int64_t bits_left = twopass->bits_left;

  int64_t total_actual_bits = p_rc->total_actual_bits;

  int64_t bits_off_target = p_rc->vbr_bits_off_target;

  double rolling_arf_group_actual_bits =

      (double)twopass->rolling_arf_group_actual_bits;

  double rolling_arf_group_target_bits =

      (double)twopass->rolling_arf_group_target_bits;

#if CONFIG_FPMT_TEST

  const int is_parallel_frame =

      cpi->ppi->gf_group.frame_parallel_level[cpi->gf_frame_index] > 0 ? 1 : 0;

  const int simulate_parallel_frame =

      cpi->ppi->fpmt_unit_test_cfg == PARALLEL_SIMULATION_ENCODE

          ? is_parallel_frame

          : 0;

  total_actual_bits = simulate_parallel_frame ? p_rc->temp_total_actual_bits

                                              : p_rc->total_actual_bits;

  bits_off_target = simulate_parallel_frame ? p_rc->temp_vbr_bits_off_target

                                            : p_rc->vbr_bits_off_target;

  bits_left =

      simulate_parallel_frame ? p_rc->temp_bits_left : twopass->bits_left;

  rolling_arf_group_target_bits =

      (double)(simulate_parallel_frame

                   ? p_rc->temp_rolling_arf_group_target_bits

                   : twopass->rolling_arf_group_target_bits);

  rolling_arf_group_actual_bits =

      (double)(simulate_parallel_frame

                   ? p_rc->temp_rolling_arf_group_actual_bits

                   : twopass->rolling_arf_group_actual_bits);

  err_estimate = simulate_parallel_frame ? p_rc->temp_rate_error_estimate

                                         : p_rc->rate_error_estimate;

#endif

  if (p_rc->bits_off_target && total_actual_bits > 0) {

    if (cpi->ppi->lap_enabled) {

      rate_err_factor = rolling_arf_group_actual_bits /

                        DOUBLE_DIVIDE_CHECK(rolling_arf_group_target_bits);

    } else {

      rate_err_factor = 1.0 - ((double)(bits_off_target) /

                               AOMMAX(total_actual_bits, bits_left));

    }

    // Adjustment is damped if this is 1 pass with look ahead processing

    // (as there are only ever a few frames of data) and for all but the first

    // GOP in normal two pass.

    if ((twopass->bpm_factor != 1.0) || cpi->ppi->lap_enabled) {

      rate_err_factor = 1.0 + ((rate_err_factor - 1.0) / damp_fac);

    }

    rate_err_factor = AOMMAX(min_fac, AOMMIN(max_fac, rate_err_factor));

  }

  // Is the rate control trending in the right direction. Only make

  // an adjustment if things are getting worse.

  if ((rate_err_factor < 1.0 && err_estimate >= 0) ||

      (rate_err_factor > 1.0 && err_estimate <= 0)) {

    twopass->bpm_factor *= rate_err_factor;

    if (rate_err_tol >= 100) {

      twopass->bpm_factor =

          AOMMAX(min_fac, AOMMIN(max_fac, twopass->bpm_factor));

    } else {

      twopass->bpm_factor = AOMMAX(0.1, AOMMIN(10.0, twopass->bpm_factor));

    }

  }

}

static int qbpm_enumerator(int rate_err_tol) {

  return 1200000 + ((300000 * AOMMIN(75, AOMMAX(rate_err_tol - 25, 0))) / 75);

}

// Similar to find_qindex_by_rate() function in ratectrl.c, but includes

// calculation of a correction_factor.

static int find_qindex_by_rate_with_correction(

    uint64_t desired_bits_per_mb, aom_bit_depth_t bit_depth,

    double error_per_mb, double group_weight_factor, int rate_err_tol,

    int best_qindex, int worst_qindex) {

  assert(best_qindex <= worst_qindex);

  int low = best_qindex;

  int high = worst_qindex;

  while (low < high) {

    const int mid = (low + high) >> 1;

    const double mid_factor = calc_correction_factor(error_per_mb, mid);

    const double q = av1_convert_qindex_to_q(mid, bit_depth);

    const int enumerator = qbpm_enumerator(rate_err_tol);

    const uint64_t mid_bits_per_mb =

        (uint64_t)((enumerator * mid_factor * group_weight_factor) / q);

    if (mid_bits_per_mb > desired_bits_per_mb) {

      low = mid + 1;

    } else {

      high = mid;

    }

  }

  return low;

}

/*!\brief Choose a target maximum Q for a group of frames

 *

 * \ingroup rate_control

 *

 * This function is used to estimate a suitable maximum Q for a

 * group of frames. Inititally it is called to get a crude estimate

 * for the whole clip. It is then called for each ARF/GF group to get

 * a revised estimate for that group.

 *

 * \param[in]    cpi                 Top-level encoder structure

 * \param[in]    av_frame_err        The average per frame coded error score

 *                                   for frames making up this section/group.

 * \param[in]    inactive_zone       Used to mask off /ignore part of the

 *                                   frame. The most common use case is where

 *                                   a wide format video (e.g. 16:9) is

 *                                   letter-boxed into a more square format.

 *                                   Here we want to ignore the bands at the

 *                                   top and bottom.

 * \param[in]    av_target_bandwidth The target bits per frame

 *

 * \return The maximum Q for frames in the group.

 */

static int get_twopass_worst_quality(AV1_COMP *cpi, const double av_frame_err,

                                     double inactive_zone,

                                     int av_target_bandwidth) {

  const RATE_CONTROL *const rc = &cpi->rc;

  const AV1EncoderConfig *const oxcf = &cpi->oxcf;

  const RateControlCfg *const rc_cfg = &oxcf->rc_cfg;

  inactive_zone = fclamp(inactive_zone, 0.0, 0.9999);

  if (av_target_bandwidth <= 0) {

    return rc->worst_quality;  // Highest value allowed

  } else {

    const int num_mbs = (oxcf->resize_cfg.resize_mode != RESIZE_NONE)

                            ? cpi->initial_mbs

                            : cpi->common.mi_params.MBs;

    const int active_mbs = AOMMAX(1, num_mbs - (int)(num_mbs * inactive_zone));

    const double av_err_per_mb = av_frame_err / (1.0 - inactive_zone);

    const uint64_t target_norm_bits_per_mb =

        ((uint64_t)av_target_bandwidth << BPER_MB_NORMBITS) / active_mbs;

    int rate_err_tol = AOMMIN(rc_cfg->under_shoot_pct, rc_cfg->over_shoot_pct);

    // Update bpm correction factor based on previous GOP rate error.

    twopass_update_bpm_factor(cpi, rate_err_tol);

    // Try and pick a max Q that will be high enough to encode the

    // content at the given rate.

    int q = find_qindex_by_rate_with_correction(

        target_norm_bits_per_mb, cpi->common.seq_params->bit_depth,

        av_err_per_mb, cpi->ppi->twopass.bpm_factor, rate_err_tol,

        rc->best_quality, rc->worst_quality);

    // Restriction on active max q for constrained quality mode.

    if (rc_cfg->mode == AOM_CQ) q = AOMMAX(q, rc_cfg->cq_level);

    return q;

  }

}

#define INTRA_PART 0.005

#define DEFAULT_DECAY_LIMIT 0.75

#define LOW_SR_DIFF_TRHESH 0.01

#define NCOUNT_FRAME_II_THRESH 5.0

#define LOW_CODED_ERR_PER_MB 0.01

/* This function considers how the quality of prediction may be deteriorating

 * with distance. It comapres the coded error for the last frame and the

 * second reference frame (usually two frames old) and also applies a factor

 * based on the extent of INTRA coding.

 *

 * The decay factor is then used to reduce the contribution of frames further

 * from the alt-ref or golden frame, to the bitframe boost calculation for that

 * alt-ref or golden frame.

 */

static double get_sr_decay_rate(const FIRSTPASS_STATS *frame) {

  double sr_diff = (frame->sr_coded_error - frame->coded_error);

  double sr_decay = 1.0;

  double modified_pct_inter;

  double modified_pcnt_intra;

  modified_pct_inter = frame->pcnt_inter;

  if ((frame->coded_error > LOW_CODED_ERR_PER_MB) &&

      ((frame->intra_error / DOUBLE_DIVIDE_CHECK(frame->coded_error)) <

       (double)NCOUNT_FRAME_II_THRESH)) {

    modified_pct_inter = frame->pcnt_inter - frame->pcnt_neutral;

  }

  modified_pcnt_intra = 100 * (1.0 - modified_pct_inter);

  if ((sr_diff > LOW_SR_DIFF_TRHESH)) {

    double sr_diff_part = ((sr_diff * 0.25) / frame->intra_error);

    sr_decay = 1.0 - sr_diff_part - (INTRA_PART * modified_pcnt_intra);

  }

  return AOMMAX(sr_decay, DEFAULT_DECAY_LIMIT);

}

// This function gives an estimate of how badly we believe the prediction

// quality is decaying from frame to frame.

static double get_zero_motion_factor(const FIRSTPASS_STATS *frame) {

  const double zero_motion_pct = frame->pcnt_inter - frame->pcnt_motion;

  double sr_decay = get_sr_decay_rate(frame);

  return AOMMIN(sr_decay, zero_motion_pct);

}

#define DEFAULT_ZM_FACTOR 0.5

static double get_prediction_decay_rate(const FIRSTPASS_STATS *frame_stats) {

  const double sr_decay_rate = get_sr_decay_rate(frame_stats);

  double zero_motion_factor =

      DEFAULT_ZM_FACTOR * (frame_stats->pcnt_inter - frame_stats->pcnt_motion);

  // Clamp value to range 0.0 to 1.0

  // This should happen anyway if input values are sensibly clamped but checked

  // here just in case.

  if (zero_motion_factor > 1.0)

    zero_motion_factor = 1.0;

  else if (zero_motion_factor < 0.0)

    zero_motion_factor = 0.0;

  return AOMMAX(zero_motion_factor,

                (sr_decay_rate + ((1.0 - sr_decay_rate) * zero_motion_factor)));

}

// Function to test for a condition where a complex transition is followed

// by a static section. For example in slide shows where there is a fade

// between slides. This is to help with more optimal kf and gf positioning.

static int detect_transition_to_still(const FIRSTPASS_INFO *firstpass_info,

                                      int next_stats_index,

                                      const int min_gf_interval,

                                      const int frame_interval,

                                      const int still_interval,

                                      const double loop_decay_rate,

                                      const double last_decay_rate) {

  // Break clause to detect very still sections after motion

  // For example a static image after a fade or other transition

  // instead of a clean scene cut.

  if (frame_interval > min_gf_interval && loop_decay_rate >= 0.999 &&

      last_decay_rate < 0.9) {

    int stats_left =

        av1_firstpass_info_future_count(firstpass_info, next_stats_index);

    if (stats_left >= still_interval) {

      int j;

      // Look ahead a few frames to see if static condition persists...

      for (j = 0; j < still_interval; ++j) {

        const FIRSTPASS_STATS *stats =

            av1_firstpass_info_peek(firstpass_info, next_stats_index + j);

        if (stats->pcnt_inter - stats->pcnt_motion < 0.999) break;

      }

      // Only if it does do we signal a transition to still.

      return j == still_interval;

    }

  }

  return 0;

}

// This function detects a flash through the high relative pcnt_second_ref

// score in the frame following a flash frame. The offset passed in should

// reflect this.

static int detect_flash(const TWO_PASS *twopass,

                        const TWO_PASS_FRAME *twopass_frame, const int offset) {

  const FIRSTPASS_STATS *const next_frame =

      read_frame_stats(twopass, twopass_frame, offset);

  // What we are looking for here is a situation where there is a

  // brief break in prediction (such as a flash) but subsequent frames

  // are reasonably well predicted by an earlier (pre flash) frame.

  // The recovery after a flash is indicated by a high pcnt_second_ref

  // compared to pcnt_inter.

  return next_frame != NULL &&

         next_frame->pcnt_second_ref > next_frame->pcnt_inter &&

         next_frame->pcnt_second_ref >= 0.5;

}

// Update the motion related elements to the GF arf boost calculation.

static void accumulate_frame_motion_stats(const FIRSTPASS_STATS *stats,

                                          GF_GROUP_STATS *gf_stats, double f_w,

                                          double f_h) {

  const double pct = stats->pcnt_motion;

  // Accumulate Motion In/Out of frame stats.

  gf_stats->this_frame_mv_in_out = stats->mv_in_out_count * pct;

  gf_stats->mv_in_out_accumulator += gf_stats->this_frame_mv_in_out;

  gf_stats->abs_mv_in_out_accumulator += fabs(gf_stats->this_frame_mv_in_out);

  // Accumulate a measure of how uniform (or conversely how random) the motion

  // field is (a ratio of abs(mv) / mv).

  if (pct > 0.05) {

    const double mvr_ratio =

        fabs(stats->mvr_abs) / DOUBLE_DIVIDE_CHECK(fabs(stats->MVr));

    const double mvc_ratio =

        fabs(stats->mvc_abs) / DOUBLE_DIVIDE_CHECK(fabs(stats->MVc));

    gf_stats->mv_ratio_accumulator +=

        pct *

        (mvr_ratio < stats->mvr_abs * f_h ? mvr_ratio : stats->mvr_abs * f_h);

    gf_stats->mv_ratio_accumulator +=

        pct *

        (mvc_ratio < stats->mvc_abs * f_w ? mvc_ratio : stats->mvc_abs * f_w);

  }

}

static void accumulate_this_frame_stats(const FIRSTPASS_STATS *stats,

                                        const double mod_frame_err,

                                        GF_GROUP_STATS *gf_stats) {

  gf_stats->gf_group_err += mod_frame_err;

#if GROUP_ADAPTIVE_MAXQ

  gf_stats->gf_group_raw_error += stats->coded_error;

#endif

  gf_stats->gf_group_skip_pct += stats->intra_skip_pct;

  gf_stats->gf_group_inactive_zone_rows += stats->inactive_zone_rows;

}

static void accumulate_next_frame_stats(const FIRSTPASS_STATS *stats,

                                        const int flash_detected,

                                        const int frames_since_key,

                                        const int cur_idx,

                                        GF_GROUP_STATS *gf_stats, int f_w,

                                        int f_h) {

  accumulate_frame_motion_stats(stats, gf_stats, f_w, f_h);

  // sum up the metric values of current gf group

  gf_stats->avg_sr_coded_error += stats->sr_coded_error;

  gf_stats->avg_pcnt_second_ref += stats->pcnt_second_ref;

  gf_stats->avg_new_mv_count += stats->new_mv_count;

  gf_stats->avg_wavelet_energy += stats->frame_avg_wavelet_energy;

  if (fabs(stats->raw_error_stdev) > 0.000001) {

    gf_stats->non_zero_stdev_count++;

    gf_stats->avg_raw_err_stdev += stats->raw_error_stdev;

  }

  // Accumulate the effect of prediction quality decay

  if (!flash_detected) {

    gf_stats->last_loop_decay_rate = gf_stats->loop_decay_rate;

    gf_stats->loop_decay_rate = get_prediction_decay_rate(stats);

    gf_stats->decay_accumulator =

        gf_stats->decay_accumulator * gf_stats->loop_decay_rate;

    // Monitor for static sections.

    if ((frames_since_key + cur_idx - 1) > 1) {

      gf_stats->zero_motion_accumulator = AOMMIN(

          gf_stats->zero_motion_accumulator, get_zero_motion_factor(stats));

    }

  }

}

static void average_gf_stats(const int total_frame, GF_GROUP_STATS *gf_stats) {

  if (total_frame) {

    gf_stats->avg_sr_coded_error /= total_frame;

    gf_stats->avg_pcnt_second_ref /= total_frame;

    gf_stats->avg_new_mv_count /= total_frame;

    gf_stats->avg_wavelet_energy /= total_frame;

  }

  if (gf_stats->non_zero_stdev_count)

    gf_stats->avg_raw_err_stdev /= gf_stats->non_zero_stdev_count;

}

#define BOOST_FACTOR 12.5

static double baseline_err_per_mb(const FRAME_INFO *frame_info) {

  unsigned int screen_area = frame_info->frame_height * frame_info->frame_width;

  // Use a different error per mb factor for calculating boost for

  //  different formats.

  if (screen_area <= 640 * 360) {

    return 500.0;

  } else {

    return 1000.0;

  }

}

// scale_max_boost = (cpi->oxcf.mode != REALTIME) in most cases as it was only

// tuned in non-rtc cases. The only exception is when we derive

// gfu_boost_average, we pass scale_max_boost = false for better coding

// efficiency.

static double calc_frame_boost(const PRIMARY_RATE_CONTROL *p_rc,

                               const FRAME_INFO *frame_info,

                               const FIRSTPASS_STATS *this_frame,

                               double this_frame_mv_in_out, double max_boost,

                               const bool scale_max_boost) {

  double frame_boost;

  const double lq = av1_convert_qindex_to_q(p_rc->avg_frame_qindex[INTER_FRAME],

                                            frame_info->bit_depth);

  const double boost_q_correction = AOMMIN((0.5 + (lq * 0.015)), 1.5);

  const double active_area = calculate_active_area(frame_info, this_frame);

  // Underlying boost factor is based on inter error ratio.

  frame_boost = AOMMAX(baseline_err_per_mb(frame_info) * active_area,

                       this_frame->intra_error * active_area) /

                DOUBLE_DIVIDE_CHECK(this_frame->coded_error);

  frame_boost = frame_boost * BOOST_FACTOR * boost_q_correction;

  // Increase boost for frames where new data coming into frame (e.g. zoom out).

  // Slightly reduce boost if there is a net balance of motion out of the frame

  // (zoom in). The range for this_frame_mv_in_out is -1.0 to +1.0.

  if (this_frame_mv_in_out > 0.0) {

    frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);

    if (scale_max_boost) max_boost += max_boost * (this_frame_mv_in_out * 2.0);

  }

  // In the extreme case the boost is halved.

  else {

    frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);

  }

  return AOMMIN(frame_boost, max_boost * boost_q_correction);

}

static double calc_kf_frame_boost(const PRIMARY_RATE_CONTROL *p_rc,

                                  const FRAME_INFO *frame_info,

                                  const FIRSTPASS_STATS *this_frame,

                                  double *sr_accumulator, double max_boost) {

  double frame_boost;

  const double lq = av1_convert_qindex_to_q(p_rc->avg_frame_qindex[INTER_FRAME],

                                            frame_info->bit_depth);

  const double boost_q_correction = AOMMIN((0.50 + (lq * 0.015)), 2.00);

  const double active_area = calculate_active_area(frame_info, this_frame);

  // Underlying boost factor is based on inter error ratio.

  frame_boost = AOMMAX(baseline_err_per_mb(frame_info) * active_area,

                       this_frame->intra_error * active_area) /

                DOUBLE_DIVIDE_CHECK(

                    (this_frame->coded_error + *sr_accumulator) * active_area);

  // Update the accumulator for second ref error difference.

  // This is intended to give an indication of how much the coded error is

  // increasing over time.

  *sr_accumulator += (this_frame->sr_coded_error - this_frame->coded_error);

  *sr_accumulator = AOMMAX(0.0, *sr_accumulator);

  // Q correction and scaling

  // The 40.0 value here is an experimentally derived baseline minimum.

  // This value is in line with the minimum per frame boost in the alt_ref

  // boost calculation.

  frame_boost = ((frame_boost + 40.0) * boost_q_correction);

  return AOMMIN(frame_boost, max_boost * boost_q_correction);

}

static int get_projected_gfu_boost(const PRIMARY_RATE_CONTROL *p_rc,

                                   int gfu_boost, int frames_to_project,

                                   int num_stats_used_for_gfu_boost) {

  /*

   * If frames_to_project is equal to num_stats_used_for_gfu_boost,

   * it means that gfu_boost was calculated over frames_to_project to

   * begin with(ie; all stats required were available), hence return

   * the original boost.

   */

  if (num_stats_used_for_gfu_boost >= frames_to_project) return gfu_boost;

  double min_boost_factor = sqrt(p_rc->baseline_gf_interval);

  // Get the current tpl factor (number of frames = frames_to_project).

  double tpl_factor = av1_get_gfu_boost_projection_factor(

      min_boost_factor, MAX_GFUBOOST_FACTOR, frames_to_project);

  // Get the tpl factor when number of frames = num_stats_used_for_prior_boost.

  double tpl_factor_num_stats = av1_get_gfu_boost_projection_factor(

      min_boost_factor, MAX_GFUBOOST_FACTOR, num_stats_used_for_gfu_boost);

  int projected_gfu_boost =

      (int)rint((tpl_factor * gfu_boost) / tpl_factor_num_stats);

  return projected_gfu_boost;

}

#define GF_MAX_BOOST 90.0

#define GF_MIN_BOOST 50

#define MIN_DECAY_FACTOR 0.01

int av1_calc_arf_boost(const TWO_PASS *twopass,

                       const TWO_PASS_FRAME *twopass_frame,

                       const PRIMARY_RATE_CONTROL *p_rc, FRAME_INFO *frame_info,

                       int offset, int f_frames, int b_frames,

                       int *num_fpstats_used, int *num_fpstats_required,

                       int project_gfu_boost, const bool scale_max_boost) {

  int i;

  GF_GROUP_STATS gf_stats;

  init_gf_stats(&gf_stats);

  double boost_score = (double)NORMAL_BOOST;

  int arf_boost;

  int flash_detected = 0;

  if (num_fpstats_used) *num_fpstats_used = 0;

  // Search forward from the proposed arf/next gf position.

  for (i = 0; i < f_frames; ++i) {

    const FIRSTPASS_STATS *this_frame =

        read_frame_stats(twopass, twopass_frame, i + offset);

    if (this_frame == NULL) break;

    // Update the motion related elements to the boost calculation.

    accumulate_frame_motion_stats(this_frame, &gf_stats,

                                  frame_info->frame_width,

                                  frame_info->frame_height);

    // We want to discount the flash frame itself and the recovery

    // frame that follows as both will have poor scores.

    flash_detected = detect_flash(twopass, twopass_frame, i + offset) ||

                     detect_flash(twopass, twopass_frame, i + offset + 1);

    // Accumulate the effect of prediction quality decay.

    if (!flash_detected) {

      gf_stats.decay_accumulator *= get_prediction_decay_rate(this_frame);

      gf_stats.decay_accumulator = gf_stats.decay_accumulator < MIN_DECAY_FACTOR

                                       ? MIN_DECAY_FACTOR

                                       : gf_stats.decay_accumulator;

    }

    boost_score += gf_stats.decay_accumulator *

                   calc_frame_boost(p_rc, frame_info, this_frame,

                                    gf_stats.this_frame_mv_in_out, GF_MAX_BOOST,

                                    scale_max_boost);

    if (num_fpstats_used) (*num_fpstats_used)++;

  }

  arf_boost = (int)boost_score;

  // Reset for backward looking loop.

  boost_score = 0.0;

  init_gf_stats(&gf_stats);

  // Search backward towards last gf position.

  for (i = -1; i >= -b_frames; --i) {

    const FIRSTPASS_STATS *this_frame =

        read_frame_stats(twopass, twopass_frame, i + offset);

    if (this_frame == NULL) break;

    // Update the motion related elements to the boost calculation.

    accumulate_frame_motion_stats(this_frame, &gf_stats,

                                  frame_info->frame_width,

                                  frame_info->frame_height);

    // We want to discount the the flash frame itself and the recovery

    // frame that follows as both will have poor scores.

    flash_detected = detect_flash(twopass, twopass_frame, i + offset) ||

                     detect_flash(twopass, twopass_frame, i + offset + 1);

    // Cumulative effect of prediction quality decay.

    if (!flash_detected) {

      gf_stats.decay_accumulator *= get_prediction_decay_rate(this_frame);

      gf_stats.decay_accumulator = gf_stats.decay_accumulator < MIN_DECAY_FACTOR

                                       ? MIN_DECAY_FACTOR

                                       : gf_stats.decay_accumulator;

    }

    boost_score += gf_stats.decay_accumulator *

                   calc_frame_boost(p_rc, frame_info, this_frame,

                                    gf_stats.this_frame_mv_in_out, GF_MAX_BOOST,

                                    scale_max_boost);

    if (num_fpstats_used) (*num_fpstats_used)++;

  }

  arf_boost += (int)boost_score;

  if (project_gfu_boost) {

    assert(num_fpstats_required != NULL);

    assert(num_fpstats_used != NULL);

    *num_fpstats_required = f_frames + b_frames;

    arf_boost = get_projected_gfu_boost(p_rc, arf_boost, *num_fpstats_required,

                                        *num_fpstats_used);

  }

  if (arf_boost < ((b_frames + f_frames) * GF_MIN_BOOST))

    arf_boost = ((b_frames + f_frames) * GF_MIN_BOOST);

  return arf_boost;

}

// Calculate a section intra ratio used in setting max loop filter.

static int calculate_section_intra_ratio(const FIRSTPASS_STATS *begin,

                                         const FIRSTPASS_STATS *end,

                                         int section_length) {

  const FIRSTPASS_STATS *s = begin;

  double intra_error = 0.0;

  double coded_error = 0.0;

  int i = 0;

  while (s < end && i < section_length) {

    intra_error += s->intra_error;

    coded_error += s->coded_error;

    ++s;

    ++i;

  }

  return (int)(intra_error / DOUBLE_DIVIDE_CHECK(coded_error));

}

/*!\brief Calculates the bit target for this GF/ARF group

 *

 * \ingroup rate_control

 *

 * Calculates the total bits to allocate in this GF/ARF group.

 *

 * \param[in]    cpi              Top-level encoder structure

 * \param[in]    gf_group_err     Cumulative coded error score for the

 *                                frames making up this group.

 *

 * \return The target total number of bits for this GF/ARF group.

 */

static int64_t calculate_total_gf_group_bits(AV1_COMP *cpi,

                                             double gf_group_err) {

  const RATE_CONTROL *const rc = &cpi->rc;

  const PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;

  const TWO_PASS *const twopass = &cpi->ppi->twopass;

  const int max_bits = frame_max_bits(rc, &cpi->oxcf);

  int64_t total_group_bits;

  // Calculate the bits to be allocated to the group as a whole.

  if ((twopass->kf_group_bits > 0) && (twopass->kf_group_error_left > 0)) {

    total_group_bits = (int64_t)(twopass->kf_group_bits *

                                 (gf_group_err / twopass->kf_group_error_left));

  } else {

    total_group_bits = 0;

  }

  // Clamp odd edge cases.

  total_group_bits = (total_group_bits < 0) ? 0

                     : (total_group_bits > twopass->kf_group_bits)

                         ? twopass->kf_group_bits

                         : total_group_bits;

  // Clip based on user supplied data rate variability limit.

  if (total_group_bits > (int64_t)max_bits * p_rc->baseline_gf_interval)

    total_group_bits = (int64_t)max_bits * p_rc->baseline_gf_interval;

  return total_group_bits;

}

// Calculate the number of bits to assign to boosted frames in a group.

static int calculate_boost_bits(int frame_count, int boost,

                                int64_t total_group_bits) {

  int allocation_chunks;

  // return 0 for invalid inputs (could arise e.g. through rounding errors)

  if (!boost || (total_group_bits <= 0)) return 0;

  if (frame_count <= 0) return (int)(AOMMIN(total_group_bits, INT_MAX));

  allocation_chunks = (frame_count * 100) + boost;

  // Prevent overflow.

  if (boost > 1023) {

    int divisor = boost >> 10;

    boost /= divisor;

    allocation_chunks /= divisor;

  }

  // Calculate the number of extra bits for use in the boosted frame or frames.

  return AOMMAX((int)(((int64_t)boost * total_group_bits) / allocation_chunks),

                0);

}

// Calculate the boost factor based on the number of bits assigned, i.e. the

// inverse of calculate_boost_bits().

static int calculate_boost_factor(int frame_count, int bits,

                                  int64_t total_group_bits) {

  return (int)(100.0 * frame_count * bits / (total_group_bits - bits));

}

// Reduce the number of bits assigned to keyframe or arf if necessary, to

// prevent bitrate spikes that may break level constraints.

// frame_type: 0: keyframe; 1: arf.

static int adjust_boost_bits_for_target_level(const AV1_COMP *const cpi,

                                              RATE_CONTROL *const rc,

                                              int bits_assigned,

                                              int64_t group_bits,

                                              int frame_type) {

  const AV1_COMMON *const cm = &cpi->common;

  const SequenceHeader *const seq_params = cm->seq_params;

  PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;

  const int temporal_layer_id = cm->temporal_layer_id;

  const int spatial_layer_id = cm->spatial_layer_id;

  for (int index = 0; index < seq_params->operating_points_cnt_minus_1 + 1;

       ++index) {

    if (!is_in_operating_point(seq_params->operating_point_idc[index],

                               temporal_layer_id, spatial_layer_id)) {

      continue;

    }

    const AV1_LEVEL target_level =

        cpi->ppi->level_params.target_seq_level_idx[index];

    if (target_level >= SEQ_LEVELS) continue;

    assert(is_valid_seq_level_idx(target_level));

    const double level_bitrate_limit = av1_get_max_bitrate_for_level(

        target_level, seq_params->tier[0], seq_params->profile);

    const int target_bits_per_frame =

        (int)(level_bitrate_limit / cpi->framerate);

    if (frame_type == 0) {

      // Maximum bits for keyframe is 8 times the target_bits_per_frame.

      const int level_enforced_max_kf_bits = target_bits_per_frame * 8;

      if (bits_assigned > level_enforced_max_kf_bits) {

        const int frames = rc->frames_to_key - 1;

        p_rc->kf_boost = calculate_boost_factor(

            frames, level_enforced_max_kf_bits, group_bits);

        bits_assigned =

            calculate_boost_bits(frames, p_rc->kf_boost, group_bits);

      }

    } else if (frame_type == 1) {

      // Maximum bits for arf is 4 times the target_bits_per_frame.

      const int level_enforced_max_arf_bits = target_bits_per_frame * 4;

      if (bits_assigned > level_enforced_max_arf_bits) {

        p_rc->gfu_boost =

            calculate_boost_factor(p_rc->baseline_gf_interval,

                                   level_enforced_max_arf_bits, group_bits);

        bits_assigned = calculate_boost_bits(p_rc->baseline_gf_interval,

                                             p_rc->gfu_boost, group_bits);

      }

    } else {

      assert(0);

    }

  }

  return bits_assigned;

}

// Allocate bits to each frame in a GF / ARF group

static void allocate_gf_group_bits(GF_GROUP *gf_group,

                                   PRIMARY_RATE_CONTROL *const p_rc,