/*

 * Copyright (c) 2016, 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.

 */

#include <limits.h>

#include <math.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include "config/aom_config.h"

#include "config/aom_version.h"

#include "aom/aomcx.h"

#include "aom/aom_encoder.h"

#include "aom/aom_external_partition.h"

#include "aom/aom_image.h"

#include "aom/internal/aom_codec_internal.h"

#include "aom_dsp/flow_estimation/flow_estimation.h"

#include "aom_mem/aom_mem.h"

#include "aom_scale/yv12config.h"

#include "aom_util/aom_pthread.h"

#include "av1/av1_cx_iface.h"

#include "av1/av1_iface_common.h"

#include "av1/common/av1_common_int.h"

#include "av1/common/enums.h"

#include "av1/common/quant_common.h"

#include "av1/common/scale.h"

#include "av1/encoder/bitstream.h"

#include "av1/encoder/enc_enums.h"

#include "av1/encoder/encoder.h"

#include "av1/encoder/encoder_alloc.h"

#include "av1/encoder/encoder_utils.h"

#include "av1/encoder/ethread.h"

#include "av1/encoder/external_partition.h"

#include "av1/encoder/firstpass.h"

#include "av1/encoder/lookahead.h"

#include "av1/encoder/rc_utils.h"

#include "av1/arg_defs.h"

#include "common/args_helper.h"

struct av1_extracfg {

  int cpu_used;

  unsigned int enable_auto_alt_ref;

  unsigned int enable_auto_bwd_ref;

  unsigned int noise_sensitivity;

  unsigned int sharpness;

  unsigned int enable_adaptive_sharpness;

  unsigned int static_thresh;

  unsigned int row_mt;

  unsigned int fp_mt;

  unsigned int tile_columns;  // log2 number of tile columns

  unsigned int tile_rows;     // log2 number of tile rows

  unsigned int auto_tiles;

  unsigned int enable_tpl_model;

  unsigned int enable_keyframe_filtering;

  unsigned int arnr_max_frames;

  unsigned int arnr_strength;

  unsigned int min_gf_interval;

  unsigned int max_gf_interval;

  unsigned int gf_min_pyr_height;

  unsigned int gf_max_pyr_height;

  aom_tune_metric tuning;

  const char *vmaf_model_path;

  const char *partition_info_path;

  unsigned int enable_rate_guide_deltaq;

  const char *rate_distribution_info;

  aom_dist_metric dist_metric;

  unsigned int cq_level;  // constrained quality level

  unsigned int rc_max_intra_bitrate_pct;

  unsigned int rc_max_inter_bitrate_pct;

  unsigned int gf_cbr_boost_pct;

  unsigned int lossless;

  unsigned int enable_cdef;

  unsigned int enable_restoration;

  unsigned int force_video_mode;

  unsigned int enable_obmc;

  unsigned int disable_trellis_quant;

  unsigned int enable_qm;

  unsigned int qm_y;

  unsigned int qm_u;

  unsigned int qm_v;

  unsigned int qm_min;

  unsigned int qm_max;

  unsigned int num_tg;

  unsigned int mtu_size;

  aom_timing_info_type_t timing_info_type;

  unsigned int frame_parallel_decoding_mode;

  int enable_dual_filter;

  unsigned int enable_chroma_deltaq;

  AQ_MODE aq_mode;

  DELTAQ_MODE deltaq_mode;

  unsigned int deltaq_strength;

  int deltalf_mode;

  unsigned int frame_periodic_boost;

  aom_tune_content content;

  aom_color_primaries_t color_primaries;

  aom_transfer_characteristics_t transfer_characteristics;

  aom_matrix_coefficients_t matrix_coefficients;

  aom_chroma_sample_position_t chroma_sample_position;

  int color_range;

  int render_width;

  int render_height;

  aom_superblock_size_t superblock_size;

  unsigned int single_tile_decoding;

  int error_resilient_mode;

  int s_frame_mode;

  int film_grain_test_vector;

  const char *film_grain_table_filename;

  unsigned int motion_vector_unit_test;

#if CONFIG_FPMT_TEST

  unsigned int fpmt_unit_test;

#endif

  unsigned int cdf_update_mode;

  int enable_rect_partitions;    // enable rectangular partitions for sequence

  int enable_ab_partitions;      // enable AB partitions for sequence

  int enable_1to4_partitions;    // enable 1:4 and 4:1 partitions for sequence

  int min_partition_size;        // min partition size [4,8,16,32,64,128]

  int max_partition_size;        // max partition size [4,8,16,32,64,128]

  int enable_intra_edge_filter;  // enable intra-edge filter for sequence

  int enable_order_hint;         // enable order hint for sequence

  int enable_tx64;               // enable 64-pt transform usage for sequence

  int enable_flip_idtx;          // enable flip and identity transform types

  int enable_rect_tx;        // enable rectangular transform usage for sequence

  int enable_dist_wtd_comp;  // enable dist wtd compound for sequence

  int max_reference_frames;  // maximum number of references per frame

  int enable_reduced_reference_set;  // enable reduced set of references

  int enable_ref_frame_mvs;          // sequence level

  int allow_ref_frame_mvs;           // frame level

  int enable_masked_comp;            // enable masked compound for sequence

  int enable_onesided_comp;          // enable one sided compound for sequence

  int enable_interintra_comp;        // enable interintra compound for sequence

  int enable_smooth_interintra;      // enable smooth interintra mode usage

  int enable_diff_wtd_comp;          // enable diff-wtd compound usage

  int enable_interinter_wedge;       // enable interinter-wedge compound usage

  int enable_interintra_wedge;       // enable interintra-wedge compound usage

  int enable_global_motion;          // enable global motion usage for sequence

  int enable_warped_motion;          // sequence level

  int allow_warped_motion;           // frame level

  int enable_filter_intra;           // enable filter intra for sequence

  int enable_smooth_intra;           // enable smooth intra modes for sequence

  int enable_paeth_intra;            // enable Paeth intra mode for sequence

  int enable_cfl_intra;              // enable CFL uv intra mode for sequence

  int enable_directional_intra;      // enable directional modes for sequence

  int enable_diagonal_intra;  // enable D45 to D203 intra modes for sequence

  int enable_superres;

  int enable_overlay;  // enable overlay for filtered arf frames

  int enable_palette;

  int enable_intrabc;

  int enable_angle_delta;

#if CONFIG_DENOISE

  float noise_level;

  int noise_block_size;

  int enable_dnl_denoising;

#endif

  unsigned int enable_low_complexity_decode;

  unsigned int chroma_subsampling_x;

  unsigned int chroma_subsampling_y;

  int reduced_tx_type_set;

  int use_intra_dct_only;

  int use_inter_dct_only;

  int use_intra_default_tx_only;

  int enable_tx_size_search;

  int quant_b_adapt;

  unsigned int vbr_corpus_complexity_lap;

  AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];

  // Bit mask to specify which tier each of the 32 possible operating points

  // conforms to.

  unsigned int tier_mask;

  // min_cr / 100 is the target minimum compression ratio for each frame.

  unsigned int min_cr;

  COST_UPDATE_TYPE coeff_cost_upd_freq;

  COST_UPDATE_TYPE mode_cost_upd_freq;

  COST_UPDATE_TYPE mv_cost_upd_freq;

  COST_UPDATE_TYPE dv_cost_upd_freq;

  unsigned int ext_tile_debug;

  unsigned int sb_multipass_unit_test;

  // Total number of passes. If this number is -1, then we assume passes = 1 or

  // 2 (passes = 1 if pass == AOM_RC_ONE_PASS and passes = 2 otherwise).

  int passes;

  int fwd_kf_dist;

  LOOPFILTER_CONTROL loopfilter_control;

  // Indicates if the application of post-processing filters should be skipped

  // on reconstructed frame.

  unsigned int skip_postproc_filtering;

  // the name of the second pass output file when passes > 2

  const char *two_pass_output;

  const char *second_pass_log;

  // Automatically determine whether to disable several intra tools

  // when "--deltaq-mode=3" is true.

  // Default as 0.

  // When set to 1, the encoder will analyze the reconstruction quality

  // as compared to the source image in the preprocessing pass.

  // If the recontruction quality is considered high enough, we disable

  // the following intra coding tools, for better encoding speed:

  // "--enable_smooth_intra",

  // "--enable_paeth_intra",

  // "--enable_cfl_intra",

  // "--enable_diagonal_intra".

  int auto_intra_tools_off;

  int strict_level_conformance;

  int kf_max_pyr_height;

  int sb_qp_sweep;

  aom_screen_detection_mode screen_detection_mode;

};

#if !CONFIG_REALTIME_ONLY

static const struct av1_extracfg default_extra_cfg = {

  0,              // cpu_used

  1,              // enable_auto_alt_ref

  0,              // enable_auto_bwd_ref

  0,              // noise_sensitivity

  0,              // sharpness

  0,              // enable_adaptive_sharpness

  0,              // static_thresh

  1,              // row_mt

  0,              // fp_mt

  0,              // tile_columns

  0,              // tile_rows

  0,              // auto_tiles

  1,              // enable_tpl_model

  1,              // enable_keyframe_filtering

  7,              // arnr_max_frames

  5,              // arnr_strength

  0,              // min_gf_interval; 0 -> default decision

  0,              // max_gf_interval; 0 -> default decision

  0,              // gf_min_pyr_height

  5,              // gf_max_pyr_height

  AOM_TUNE_PSNR,  // tuning

  "/usr/local/share/model/vmaf_v0.6.1.json",  // VMAF model path

  ".",                                        // partition info path

  0,                                          // enable rate guide deltaq

  "./rate_map.txt",                           // rate distribution input

  AOM_DIST_METRIC_PSNR,                       // dist_metric

  10,                                         // cq_level

  0,                                          // rc_max_intra_bitrate_pct

  0,                                          // rc_max_inter_bitrate_pct

  0,                                          // gf_cbr_boost_pct

  0,                                          // lossless

  1,                                          // enable_cdef

  1,                                          // enable_restoration

  0,                                          // force_video_mode

  1,                                          // enable_obmc

  3,                                          // disable_trellis_quant

  0,                                          // enable_qm

  DEFAULT_QM_Y,                               // qm_y

  DEFAULT_QM_U,                               // qm_u

  DEFAULT_QM_V,                               // qm_v

  DEFAULT_QM_FIRST,                           // qm_min

  DEFAULT_QM_LAST,                            // qm_max

  1,                                          // max number of tile groups

  0,                                          // mtu_size

  AOM_TIMING_UNSPECIFIED,       // No picture timing signaling in bitstream

  0,                            // frame_parallel_decoding_mode

  1,                            // enable dual filter

  0,                            // enable delta quant in chroma planes

  NO_AQ,                        // aq_mode

  DELTA_Q_OBJECTIVE,            // deltaq_mode

  100,                          // deltaq_strength

  0,                            // delta lf mode

  0,                            // frame_periodic_boost

  AOM_CONTENT_DEFAULT,          // content

  AOM_CICP_CP_UNSPECIFIED,      // CICP color primaries

  AOM_CICP_TC_UNSPECIFIED,      // CICP transfer characteristics

  AOM_CICP_MC_UNSPECIFIED,      // CICP matrix coefficients

  AOM_CSP_UNKNOWN,              // chroma sample position

  0,                            // color range

  0,                            // render width

  0,                            // render height

  AOM_SUPERBLOCK_SIZE_DYNAMIC,  // superblock_size

  1,                            // this depends on large_scale_tile.

  0,                            // error_resilient_mode off by default.

  0,                            // s_frame_mode off by default.

  0,                            // film_grain_test_vector

  NULL,                         // film_grain_table_filename

  0,                            // motion_vector_unit_test

#if CONFIG_FPMT_TEST

  0,  // fpmt_unit_test

#endif

  1,    // CDF update mode

  1,    // enable rectangular partitions

  1,    // enable ab shape partitions

  1,    // enable 1:4 and 4:1 partitions

  4,    // min_partition_size

  128,  // max_partition_size

  1,    // enable intra edge filter

  1,    // frame order hint

  1,    // enable 64-pt transform usage

  1,    // enable flip and identity transform

  1,    // enable rectangular transform usage

  1,    // dist-wtd compound

  7,    // max_reference_frames

  0,    // enable_reduced_reference_set

  1,    // enable_ref_frame_mvs sequence level

  1,    // allow ref_frame_mvs frame level

  1,    // enable masked compound at sequence level

  1,    // enable one sided compound at sequence level

  1,    // enable interintra compound at sequence level

  1,    // enable smooth interintra mode

  1,    // enable difference-weighted compound

  1,    // enable interinter wedge compound

  1,    // enable interintra wedge compound

  1,    // enable_global_motion usage

  1,    // enable_warped_motion at sequence level

  1,    // allow_warped_motion at frame level

  1,    // enable filter intra at sequence level

  1,    // enable smooth intra modes usage for sequence

  1,    // enable Paeth intra mode usage for sequence

  1,    // enable CFL uv intra mode usage for sequence

  1,    // enable directional intra mode usage for sequence

  1,    // enable D45 to D203 intra mode usage for sequence

  1,    // superres

  1,    // enable overlay

  1,    // enable palette

  1,    // enable intrabc

  1,    // enable angle delta

#if CONFIG_DENOISE

  0,   // noise_level

  32,  // noise_block_size

  1,   // enable_dnl_denoising

#endif

  0,  // enable_low_complexity_decode

  0,  // chroma_subsampling_x

  0,  // chroma_subsampling_y

  0,  // reduced_tx_type_set

  0,  // use_intra_dct_only

  0,  // use_inter_dct_only

  0,  // use_intra_default_tx_only

  1,  // enable_tx_size_search

  0,  // quant_b_adapt

  0,  // vbr_corpus_complexity_lap

  {

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

  },               // target_seq_level_idx

  0,               // tier_mask

  0,               // min_cr

  COST_UPD_SB,     // coeff_cost_upd_freq

  COST_UPD_SB,     // mode_cost_upd_freq

  COST_UPD_SB,     // mv_cost_upd_freq

  COST_UPD_SB,     // dv_cost_upd_freq

  0,               // ext_tile_debug

  0,               // sb_multipass_unit_test

  -1,              // passes

  -1,              // fwd_kf_dist

  LOOPFILTER_ALL,  // loopfilter_control

  0,               // skip_postproc_filtering

  NULL,            // two_pass_output

  NULL,            // second_pass_log

  0,               // auto_intra_tools_off

  0,               // strict_level_conformance

  -1,              // kf_max_pyr_height

  0,               // sb_qp_sweep

  AOM_SCREEN_DETECTION_STANDARD,

};

#else

// Some settings are changed for realtime only build.

static const struct av1_extracfg default_extra_cfg = {

  10,             // cpu_used

  1,              // enable_auto_alt_ref

  0,              // enable_auto_bwd_ref

  0,              // noise_sensitivity

  0,              // sharpness

  0,              // enable_adaptive_sharpness

  0,              // static_thresh

  1,              // row_mt

  0,              // fp_mt

  0,              // tile_columns

  0,              // tile_rows

  0,              // auto_tiles

  0,              // enable_tpl_model

  0,              // enable_keyframe_filtering

  7,              // arnr_max_frames

  5,              // arnr_strength

  0,              // min_gf_interval; 0 -> default decision

  0,              // max_gf_interval; 0 -> default decision

  0,              // gf_min_pyr_height

  5,              // gf_max_pyr_height

  AOM_TUNE_PSNR,  // tuning

  "/usr/local/share/model/vmaf_v0.6.1.json",  // VMAF model path

  ".",                                        // partition info path

  0,                                          // enable rate guide deltaq

  "./rate_map.txt",                           // rate distribution input

  AOM_DIST_METRIC_PSNR,                       // dist_metric

  10,                                         // cq_level

  300,                                        // rc_max_intra_bitrate_pct

  0,                                          // rc_max_inter_bitrate_pct

  0,                                          // gf_cbr_boost_pct

  0,                                          // lossless

  1,                                          // enable_cdef

  0,                                          // enable_restoration

  0,                                          // force_video_mode

  0,                                          // enable_obmc

  3,                                          // disable_trellis_quant

  0,                                          // enable_qm

  DEFAULT_QM_Y,                               // qm_y

  DEFAULT_QM_U,                               // qm_u

  DEFAULT_QM_V,                               // qm_v

  DEFAULT_QM_FIRST,                           // qm_min

  DEFAULT_QM_LAST,                            // qm_max

  1,                                          // max number of tile groups

  0,                                          // mtu_size

  AOM_TIMING_UNSPECIFIED,       // No picture timing signaling in bitstream

  0,                            // frame_parallel_decoding_mode

  0,                            // enable dual filter

  0,                            // enable delta quant in chroma planes

  CYCLIC_REFRESH_AQ,            // aq_mode

  NO_DELTA_Q,                   // deltaq_mode

  100,                          // deltaq_strength

  0,                            // delta lf mode

  0,                            // frame_periodic_boost

  AOM_CONTENT_DEFAULT,          // content

  AOM_CICP_CP_UNSPECIFIED,      // CICP color primaries

  AOM_CICP_TC_UNSPECIFIED,      // CICP transfer characteristics

  AOM_CICP_MC_UNSPECIFIED,      // CICP matrix coefficients

  AOM_CSP_UNKNOWN,              // chroma sample position

  0,                            // color range

  0,                            // render width

  0,                            // render height

  AOM_SUPERBLOCK_SIZE_DYNAMIC,  // superblock_size

  1,                            // this depends on large_scale_tile.

  0,                            // error_resilient_mode off by default.

  0,                            // s_frame_mode off by default.

  0,                            // film_grain_test_vector

  NULL,                         // film_grain_table_filename

  0,                            // motion_vector_unit_test

#if CONFIG_FPMT_TEST

  0,  // fpmt_unit_test

#endif

  1,    // CDF update mode

  0,    // enable rectangular partitions

  0,    // enable ab shape partitions

  0,    // enable 1:4 and 4:1 partitions

  4,    // min_partition_size

  128,  // max_partition_size

  0,    // enable intra edge filter

  0,    // frame order hint

  0,    // enable 64-pt transform usage

  1,    // enable flip and identity transform

  1,    // enable rectangular transform usage

  0,    // dist-wtd compound

  3,    // max_reference_frames

  0,    // enable_reduced_reference_set

  0,    // enable_ref_frame_mvs sequence level

  0,    // allow ref_frame_mvs frame level

  0,    // enable masked compound at sequence level

  0,    // enable one sided compound at sequence level

  0,    // enable interintra compound at sequence level

  0,    // enable smooth interintra mode

  0,    // enable difference-weighted compound

  0,    // enable interinter wedge compound

  0,    // enable interintra wedge compound

  0,    // enable_global_motion usage

  0,    // enable_warped_motion at sequence level

  0,    // allow_warped_motion at frame level

  0,    // enable filter intra at sequence level

  0,    // enable smooth intra modes usage for sequence

  0,    // enable Paeth intra mode usage for sequence

  0,    // enable CFL uv intra mode usage for sequence

  1,    // enable directional intra mode usage for sequence

  1,    // enable D45 to D203 intra mode usage for sequence

  0,    // superres

  0,    // enable overlay

  1,    // enable palette

  0,    // enable intrabc

  0,    // enable angle delta

#if CONFIG_DENOISE

  0,   // noise_level

  32,  // noise_block_size

  1,   // enable_dnl_denoising

#endif

  0,  // enable_low_complexity_decode

  0,  // chroma_subsampling_x

  0,  // chroma_subsampling_y

  0,  // reduced_tx_type_set

  0,  // use_intra_dct_only

  0,  // use_inter_dct_only

  1,  // use_intra_default_tx_only

  1,  // enable_tx_size_search

  0,  // quant_b_adapt

  0,  // vbr_corpus_complexity_lap

  {

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

      SEQ_LEVEL_MAX, SEQ_LEVEL_MAX,

  },               // target_seq_level_idx

  0,               // tier_mask

  0,               // min_cr

  COST_UPD_OFF,    // coeff_cost_upd_freq

  COST_UPD_OFF,    // mode_cost_upd_freq

  COST_UPD_OFF,    // mv_cost_upd_freq

  COST_UPD_OFF,    // dv_cost_upd_freq

  0,               // ext_tile_debug

  0,               // sb_multipass_unit_test

  -1,              // passes

  -1,              // fwd_kf_dist

  LOOPFILTER_ALL,  // loopfilter_control

  0,               // skip_postproc_filtering

  NULL,            // two_pass_output

  NULL,            // second_pass_log

  0,               // auto_intra_tools_off

  0,               // strict_level_conformance

  -1,              // kf_max_pyr_height

  0,               // sb_qp_sweep

  AOM_SCREEN_DETECTION_STANDARD,

};

#endif

struct aom_codec_alg_priv {

  aom_codec_priv_t base;

  aom_codec_enc_cfg_t cfg;

  struct av1_extracfg extra_cfg;

  aom_rational64_t timestamp_ratio;

  aom_codec_pts_t pts_offset;

  unsigned char pts_offset_initialized;

  AV1EncoderConfig oxcf;

  AV1_PRIMARY *ppi;

  unsigned char *cx_data;

  size_t cx_data_sz;

  size_t pending_cx_data_sz;

  aom_image_t preview_img;

  aom_enc_frame_flags_t next_frame_flags;

  aom_codec_pkt_list_decl(256) pkt_list;

  unsigned int fixed_kf_cntr;

  // BufferPool that holds all reference frames.

  BufferPool *buffer_pool;

  // lookahead instance variables

  BufferPool *buffer_pool_lap;

  FIRSTPASS_STATS *frame_stats_buffer;

  // Number of stats buffers required for look ahead

  int num_lap_buffers;

  STATS_BUFFER_CTX stats_buf_context;

  bool monochrome_on_init;

};

static inline int gcd(int64_t a, int b) {

  int remainder;

  while (b > 0) {

    remainder = (int)(a % b);

    a = b;

    b = remainder;

  }

  return (int)a;

}

static void reduce_ratio(aom_rational64_t *ratio) {

  const int denom = gcd(ratio->num, ratio->den);

  ratio->num /= denom;

  ratio->den /= denom;

}

// Called by encoder_encode() only. Must not be called by encoder_init()

// because the `error` paramerer will be destroyed by aom_codec_enc_init_ver()

// after encoder_init() returns an error. See the "IMPORTANT" comment in

// aom_codec_enc_init_ver().

static aom_codec_err_t update_error_state(

    aom_codec_alg_priv_t *ctx, const struct aom_internal_error_info *error) {

  const aom_codec_err_t res = error->error_code;

  if (res != AOM_CODEC_OK)

    ctx->base.err_detail = error->has_detail ? error->detail : NULL;

  return res;

}

// This function deep copies a string src to *dst. For default string we will

// use a string literal, and otherwise we will allocate memory for the string.

static aom_codec_err_t allocate_and_set_string(const char *src,

                                               const char *default_src,

                                               const char **dst,

                                               char *err_detail) {

  if (!src) {

    snprintf(err_detail, ARG_ERR_MSG_MAX_LEN,

             "Null pointer given to a string parameter.");

    return AOM_CODEC_INVALID_PARAM;

  }

  if (*dst && strcmp(src, *dst) == 0) return AOM_CODEC_OK;

  // If the input is exactly the same as default, we will use the string

  // literal, so do not free here.

  if (*dst != default_src) {

    aom_free((void *)*dst);

  }

  if (default_src && strcmp(src, default_src) == 0) {

    // default_src should be a string literal

    *dst = default_src;

  } else {

    size_t len = strlen(src) + 1;

    char *tmp = aom_malloc(len * sizeof(*tmp));

    if (!tmp) {

      snprintf(err_detail, ARG_ERR_MSG_MAX_LEN,

               "Failed to allocate memory for copying parameters.");

      return AOM_CODEC_MEM_ERROR;

    }

    memcpy(tmp, src, len);

    *dst = tmp;

  }

  return 0;

}

#undef ERROR

#define ERROR(str)                  \

  do {                              \

    ctx->base.err_detail = str;     \

    return AOM_CODEC_INVALID_PARAM; \

  } while (0)

#define RANGE_CHECK(p, memb, lo, hi)                   \

  do {                                                 \

    if (!((p)->memb >= (lo) && (p)->memb <= (hi)))     \

      ERROR(#memb " out of range [" #lo ".." #hi "]"); \

  } while (0)

#define RANGE_CHECK_HI(p, memb, hi)                                     \

  do {                                                                  \

    if (!((p)->memb <= (hi))) ERROR(#memb " out of range [.." #hi "]"); \

  } while (0)

#define RANGE_CHECK_BOOL(p, memb)                                     \

  do {                                                                \

    if (!!((p)->memb) != (p)->memb) ERROR(#memb " expected boolean"); \

  } while (0)

static aom_codec_err_t validate_config(aom_codec_alg_priv_t *ctx,

                                       const aom_codec_enc_cfg_t *cfg,

                                       const struct av1_extracfg *extra_cfg) {

  RANGE_CHECK(cfg, g_w, 1, 65536);                        // 16 bits available

  RANGE_CHECK(cfg, g_h, 1, 65536);                        // 16 bits available

  RANGE_CHECK_HI(cfg, g_forced_max_frame_width, 65536);   // 16 bits available

  RANGE_CHECK_HI(cfg, g_forced_max_frame_height, 65536);  // 16 bits available

  if (cfg->g_forced_max_frame_width) {

    RANGE_CHECK_HI(cfg, g_w, cfg->g_forced_max_frame_width);

  }

  if (cfg->g_forced_max_frame_height) {

    RANGE_CHECK_HI(cfg, g_h, cfg->g_forced_max_frame_height);

  }

  // To avoid integer overflows when multiplying width by height (or values

  // derived from width and height) using the int type, impose a maximum frame

  // area (width * height) of 2^30.

  const unsigned int max_frame_width =

      cfg->g_forced_max_frame_width ? cfg->g_forced_max_frame_width : cfg->g_w;

  const unsigned int max_frame_height = cfg->g_forced_max_frame_height

                                            ? cfg->g_forced_max_frame_height

                                            : cfg->g_h;

  const int64_t max_frame_area = (int64_t)max_frame_width * max_frame_height;

  if (max_frame_area > (1 << 30)) {

    ERROR("max_frame_area out of range [..2^30]");

  }

  RANGE_CHECK(cfg, g_timebase.den, 1, 1000000000);

  RANGE_CHECK(cfg, g_timebase.num, 1, 1000000000);

  RANGE_CHECK_HI(cfg, g_profile, MAX_PROFILES - 1);

  RANGE_CHECK_HI(cfg, rc_target_bitrate, 2000000);

  RANGE_CHECK_HI(cfg, rc_max_quantizer, 63);

  RANGE_CHECK_HI(cfg, rc_min_quantizer, cfg->rc_max_quantizer);

  RANGE_CHECK_BOOL(extra_cfg, lossless);

  RANGE_CHECK_HI(extra_cfg, aq_mode, AQ_MODE_COUNT - 1);

  RANGE_CHECK_HI(extra_cfg, deltaq_mode, DELTA_Q_MODE_COUNT - 1);

  if (cfg->g_usage != ALLINTRA &&

      extra_cfg->deltaq_mode == DELTA_Q_VARIANCE_BOOST) {

    ERROR("Variance Boost (deltaq_mode = 6) can only be set in all intra mode");

  }

  RANGE_CHECK_HI(extra_cfg, deltalf_mode, 1);

  RANGE_CHECK_HI(extra_cfg, frame_periodic_boost, 1);

#if CONFIG_REALTIME_ONLY

  RANGE_CHECK(cfg, g_usage, AOM_USAGE_REALTIME, AOM_USAGE_REALTIME);

#else

  RANGE_CHECK_HI(cfg, g_usage, AOM_USAGE_ALL_INTRA);

#endif

  RANGE_CHECK_HI(cfg, g_threads, MAX_NUM_THREADS);

  RANGE_CHECK(cfg, rc_end_usage, AOM_VBR, AOM_Q);

  RANGE_CHECK_HI(cfg, rc_undershoot_pct, 100);

  RANGE_CHECK_HI(cfg, rc_overshoot_pct, 100);

  RANGE_CHECK_HI(cfg, rc_2pass_vbr_bias_pct, 100);

  RANGE_CHECK(cfg, kf_mode, AOM_KF_DISABLED, AOM_KF_AUTO);

  RANGE_CHECK_HI(cfg, rc_dropframe_thresh, 100);

  RANGE_CHECK(cfg, g_pass, AOM_RC_ONE_PASS, AOM_RC_THIRD_PASS);

  RANGE_CHECK_HI(cfg, g_lag_in_frames, MAX_LAG_BUFFERS);

  if (cfg->g_usage == AOM_USAGE_ALL_INTRA) {

    RANGE_CHECK_HI(cfg, g_lag_in_frames, 0);

    RANGE_CHECK_HI(cfg, kf_max_dist, 0);

  }

  RANGE_CHECK_HI(extra_cfg, min_gf_interval, MAX_LAG_BUFFERS - 1);

  RANGE_CHECK_HI(extra_cfg, max_gf_interval, MAX_LAG_BUFFERS - 1);

  if (extra_cfg->max_gf_interval > 0) {

    RANGE_CHECK(extra_cfg, max_gf_interval,

                AOMMAX(2, extra_cfg->min_gf_interval), (MAX_LAG_BUFFERS - 1));

  }

  RANGE_CHECK_HI(extra_cfg, gf_min_pyr_height, 5);

  RANGE_CHECK_HI(extra_cfg, gf_max_pyr_height, 5);

  if (extra_cfg->gf_min_pyr_height > extra_cfg->gf_max_pyr_height) {

    ERROR(

        "gf_min_pyr_height must be less than or equal to "

        "gf_max_pyramid_height");

  }

  RANGE_CHECK_HI(cfg, rc_resize_mode, RESIZE_MODES - 1);

  RANGE_CHECK(cfg, rc_resize_denominator, SCALE_NUMERATOR,

              SCALE_NUMERATOR << 1);

  RANGE_CHECK(cfg, rc_resize_kf_denominator, SCALE_NUMERATOR,

              SCALE_NUMERATOR << 1);

  RANGE_CHECK_HI(cfg, rc_superres_mode, AOM_SUPERRES_AUTO);

  RANGE_CHECK(cfg, rc_superres_denominator, SCALE_NUMERATOR,

              SCALE_NUMERATOR << 1);

  RANGE_CHECK(cfg, rc_superres_kf_denominator, SCALE_NUMERATOR,

              SCALE_NUMERATOR << 1);

  RANGE_CHECK(cfg, rc_superres_qthresh, 1, 63);

  RANGE_CHECK(cfg, rc_superres_kf_qthresh, 1, 63);

  RANGE_CHECK_HI(extra_cfg, cdf_update_mode, 2);

  RANGE_CHECK_HI(extra_cfg, motion_vector_unit_test, 2);

#if CONFIG_FPMT_TEST

  RANGE_CHECK_HI(extra_cfg, fpmt_unit_test, 1);

#endif

  RANGE_CHECK_HI(extra_cfg, sb_multipass_unit_test, 1);

  RANGE_CHECK_HI(extra_cfg, ext_tile_debug, 1);

  RANGE_CHECK_HI(extra_cfg, enable_auto_alt_ref, 1);

  RANGE_CHECK_HI(extra_cfg, enable_auto_bwd_ref, 2);

  RANGE_CHECK(extra_cfg, cpu_used, 0,

              (cfg->g_usage == AOM_USAGE_REALTIME) ? 12 : 9);

  RANGE_CHECK_HI(extra_cfg, noise_sensitivity, 6);

  RANGE_CHECK(extra_cfg, superblock_size, AOM_SUPERBLOCK_SIZE_64X64,

              AOM_SUPERBLOCK_SIZE_DYNAMIC);

  RANGE_CHECK_HI(cfg, large_scale_tile, 1);

  RANGE_CHECK_HI(extra_cfg, single_tile_decoding, 1);

  RANGE_CHECK_HI(extra_cfg, enable_rate_guide_deltaq, 1);

  RANGE_CHECK_HI(extra_cfg, row_mt, 1);

  RANGE_CHECK_HI(extra_cfg, fp_mt, 1);

  RANGE_CHECK_HI(extra_cfg, tile_columns, 6);

  RANGE_CHECK_HI(extra_cfg, tile_rows, 6);

  RANGE_CHECK_HI(extra_cfg, auto_tiles, 1);

  RANGE_CHECK_HI(cfg, monochrome, 1);

  if (cfg->large_scale_tile && extra_cfg->aq_mode)

    ERROR(

        "Adaptive quantization are not supported in large scale tile "

        "coding.");

  RANGE_CHECK_HI(extra_cfg, sharpness, 7);

  RANGE_CHECK_HI(extra_cfg, enable_adaptive_sharpness, 1);

  RANGE_CHECK_HI(extra_cfg, arnr_max_frames, 15);

  RANGE_CHECK_HI(extra_cfg, arnr_strength, 6);

  RANGE_CHECK_HI(extra_cfg, cq_level, 63);

  RANGE_CHECK(cfg, g_bit_depth, AOM_BITS_8, AOM_BITS_12);

  RANGE_CHECK(cfg, g_input_bit_depth, 8, 12);

  RANGE_CHECK(extra_cfg, content, AOM_CONTENT_DEFAULT, AOM_CONTENT_INVALID - 1);

  if (cfg->g_pass >= AOM_RC_SECOND_PASS) {

    const size_t packet_sz = sizeof(FIRSTPASS_STATS);

    const int n_packets = (int)(cfg->rc_twopass_stats_in.sz / packet_sz);

    const FIRSTPASS_STATS *stats;

    if (cfg->rc_twopass_stats_in.buf == NULL)

      ERROR("rc_twopass_stats_in.buf not set.");

    if (cfg->rc_twopass_stats_in.sz % packet_sz)

      ERROR("rc_twopass_stats_in.sz indicates truncated packet.");

    if (cfg->rc_twopass_stats_in.sz < 2 * packet_sz)

      ERROR("rc_twopass_stats_in requires at least two packets.");

    stats =

        (const FIRSTPASS_STATS *)cfg->rc_twopass_stats_in.buf + n_packets - 1;

    if ((int)(stats->count + 0.5) != n_packets - 1)

      ERROR("rc_twopass_stats_in missing EOS stats packet");

  }

  if (extra_cfg->passes != -1 && cfg->g_pass == AOM_RC_ONE_PASS &&

      extra_cfg->passes != 1) {

    ERROR("One pass encoding but passes != 1.");

  }

  if (extra_cfg->passes != -1 && (int)cfg->g_pass > extra_cfg->passes) {

    ERROR("Current pass is larger than total number of passes.");

  }

  if (cfg->g_profile == (unsigned int)PROFILE_1 && cfg->monochrome) {

    ERROR("Monochrome is not supported in profile 1");

  }

  if (cfg->g_profile <= (unsigned int)PROFILE_1 &&

      cfg->g_bit_depth > AOM_BITS_10) {

    ERROR("Codec bit-depth 12 not supported in profile < 2");

  }

  if (cfg->g_profile <= (unsigned int)PROFILE_1 &&

      cfg->g_input_bit_depth > 10) {

    ERROR("Source bit-depth 12 not supported in profile < 2");

  }

  if (cfg->rc_end_usage == AOM_Q) {

    RANGE_CHECK_HI(cfg, use_fixed_qp_offsets, 1);

  } else {

    if (cfg->use_fixed_qp_offsets > 0) {

      ERROR("--use_fixed_qp_offsets can only be used with --end-usage=q");

    }

  }

  RANGE_CHECK(extra_cfg, color_primaries, AOM_CICP_CP_BT_709,

              AOM_CICP_CP_EBU_3213);  // Need to check range more precisely to

                                      // check for reserved values?

  RANGE_CHECK(extra_cfg, transfer_characteristics, AOM_CICP_TC_BT_709,

              AOM_CICP_TC_HLG);

  RANGE_CHECK(extra_cfg, matrix_coefficients, AOM_CICP_MC_IDENTITY,

              AOM_CICP_MC_ICTCP);

  RANGE_CHECK(extra_cfg, color_range, 0, 1);

  /* Average corpus complexity is supported only in the case of single pass

   * VBR*/

  if (cfg->g_pass == AOM_RC_ONE_PASS && cfg->rc_end_usage == AOM_VBR)

    RANGE_CHECK_HI(extra_cfg, vbr_corpus_complexity_lap,

                   MAX_VBR_CORPUS_COMPLEXITY);

  else if (extra_cfg->vbr_corpus_complexity_lap != 0)

    ERROR(

        "VBR corpus complexity is supported only in the case of single pass "

        "VBR mode.");

#if !CONFIG_TUNE_BUTTERAUGLI

  if (extra_cfg->tuning == AOM_TUNE_BUTTERAUGLI) {

    ERROR(

        "This error may be related to the wrong configuration options: try to "

        "set -DCONFIG_TUNE_BUTTERAUGLI=1 at the time CMake is run.");

  }

#endif

#if !CONFIG_TUNE_VMAF

  if (extra_cfg->tuning >= AOM_TUNE_VMAF_WITH_PREPROCESSING &&

      extra_cfg->tuning <= AOM_TUNE_VMAF_NEG_MAX_GAIN) {

    ERROR(

        "This error may be related to the wrong configuration options: try to "

        "set -DCONFIG_TUNE_VMAF=1 at the time CMake is run.");

  }

#endif

  RANGE_CHECK(extra_cfg, tuning, AOM_TUNE_PSNR, AOM_TUNE_SSIMULACRA2);

  RANGE_CHECK(extra_cfg, dist_metric, AOM_DIST_METRIC_PSNR,

              AOM_DIST_METRIC_QM_PSNR);

  RANGE_CHECK(extra_cfg, timing_info_type, AOM_TIMING_UNSPECIFIED,

              AOM_TIMING_DEC_MODEL);

  RANGE_CHECK(extra_cfg, film_grain_test_vector, 0, 16);

  if (extra_cfg->lossless) {

    if (extra_cfg->aq_mode != 0)

      ERROR("Only --aq_mode=0 can be used with --lossless=1.");

    if (extra_cfg->enable_chroma_deltaq)

      ERROR("Only --enable_chroma_deltaq=0 can be used with --lossless=1.");

  }

  RANGE_CHECK(extra_cfg, max_reference_frames, 3, 7);

  RANGE_CHECK(extra_cfg, enable_reduced_reference_set, 0, 1);

  RANGE_CHECK_HI(extra_cfg, enable_low_complexity_decode, 1);

  RANGE_CHECK_HI(extra_cfg, chroma_subsampling_x, 1);

  RANGE_CHECK_HI(extra_cfg, chroma_subsampling_y, 1);

  // 6.4.2 Color config semantics

  // If matrix_coefficients is equal to MC_IDENTITY, it is a requirement of

  // bitstream conformance that subsampling_x is equal to 0 and subsampling_y

  // is equal to 0.

  if (extra_cfg->matrix_coefficients == AOM_CICP_MC_IDENTITY &&

      (extra_cfg->chroma_subsampling_x != 0 ||

       extra_cfg->chroma_subsampling_y != 0)) {

    ERROR("Subsampling must be 0 with AOM_CICP_MC_IDENTITY.");

  }

  RANGE_CHECK_HI(extra_cfg, disable_trellis_quant, 3);

  RANGE_CHECK(extra_cfg, coeff_cost_upd_freq, 0, 3);

  RANGE_CHECK(extra_cfg, mode_cost_upd_freq, 0, 3);

  RANGE_CHECK(extra_cfg, mv_cost_upd_freq, 0, 3);

  RANGE_CHECK(extra_cfg, dv_cost_upd_freq, 0, 3);

  RANGE_CHECK(extra_cfg, min_partition_size, 4, 128);

  RANGE_CHECK(extra_cfg, max_partition_size, 4, 128);

  RANGE_CHECK_HI(extra_cfg, min_partition_size, extra_cfg->max_partition_size);

  for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {

    const int level_idx = extra_cfg->target_seq_level_idx[i];

    if (!is_valid_seq_level_idx(level_idx) &&

        level_idx != SEQ_LEVEL_KEEP_STATS) {

      ERROR("Target sequence level index is invalid");

    }

  }

  RANGE_CHECK_HI(extra_cfg, deltaq_strength, 1000);

  RANGE_CHECK_HI(extra_cfg, loopfilter_control, 3);

  RANGE_CHECK_BOOL(extra_cfg, skip_postproc_filtering);

  RANGE_CHECK_HI(extra_cfg, enable_cdef, 3);

  RANGE_CHECK_BOOL(extra_cfg, auto_intra_tools_off);

  RANGE_CHECK_BOOL(extra_cfg, strict_level_conformance);

  RANGE_CHECK_BOOL(extra_cfg, sb_qp_sweep);

  RANGE_CHECK(extra_cfg, kf_max_pyr_height, -1, 5);

  if (extra_cfg->kf_max_pyr_height != -1 &&

      extra_cfg->kf_max_pyr_height < (int)extra_cfg->gf_min_pyr_height) {

    ERROR(

        "The value of kf-max-pyr-height should not be smaller than "

        "gf-min-pyr-height");

  }

  RANGE_CHECK(extra_cfg, screen_detection_mode, 1, 2);

  return AOM_CODEC_OK;

}

static aom_codec_err_t validate_img(aom_codec_alg_priv_t *ctx,

                                    const aom_image_t *img) {

  switch (img->fmt) {

    case AOM_IMG_FMT_YV12:

    case AOM_IMG_FMT_NV12:

    case AOM_IMG_FMT_I420:

    case AOM_IMG_FMT_YV1216:

    case AOM_IMG_FMT_I42016: break;

    case AOM_IMG_FMT_I444:

    case AOM_IMG_FMT_I44416:

      if (ctx->cfg.g_profile == (unsigned int)PROFILE_0 &&

          !ctx->cfg.monochrome) {

        ERROR("Invalid image format. I444 images not supported in profile.");

      }

      break;

    case AOM_IMG_FMT_I422:

    case AOM_IMG_FMT_I42216:

      if (ctx->cfg.g_profile != (unsigned int)PROFILE_2) {

        ERROR("Invalid image format. I422 images not supported in profile.");

      }

      break;

    default:

      ERROR(

          "Invalid image format. Only YV12, NV12, I420, I422, I444 images are "

          "supported.");

      break;

  }

  if (img->d_w != ctx->cfg.g_w || img->d_h != ctx->cfg.g_h)

    ERROR("Image size must match encoder init configuration size");

  // 6.4.2 Color config semantics

  // If matrix_coefficients is equal to MC_IDENTITY, it is a requirement of

  // bitstream conformance that subsampling_x is equal to 0 and subsampling_y

  // is equal to 0.

  if (ctx->oxcf.color_cfg.matrix_coefficients == AOM_CICP_MC_IDENTITY &&

      (img->x_chroma_shift != 0 || img->y_chroma_shift != 0)) {

    ERROR("Subsampling must be 0 with AOM_CICP_MC_IDENTITY.");

  }

#if CONFIG_TUNE_BUTTERAUGLI

  if (ctx->extra_cfg.tuning == AOM_TUNE_BUTTERAUGLI) {

    if (img->bit_depth > 8) {

      ERROR("Only 8 bit depth images supported in tune=butteraugli mode.");

    }

    if (img->mc != 0 && img->mc != AOM_CICP_MC_BT_709 &&

        img->mc != AOM_CICP_MC_BT_601 && img->mc != AOM_CICP_MC_BT_470_B_G) {

      ERROR(

          "Only BT.709 and BT.601 matrix coefficients supported in "

          "tune=butteraugli mode. Identity matrix is treated as BT.601.");

    }

  }

#endif

  return AOM_CODEC_OK;

}

static int get_image_bps(const aom_image_t *img) {

  switch (img->fmt) {

    case AOM_IMG_FMT_YV12:

    case AOM_IMG_FMT_NV12:

    case AOM_IMG_FMT_I420: return 12;

    case AOM_IMG_FMT_I422: return 16;

    case AOM_IMG_FMT_I444: return 24;

    case AOM_IMG_FMT_YV1216:

    case AOM_IMG_FMT_I42016: return 24;

    case AOM_IMG_FMT_I42216: return 32;

    case AOM_IMG_FMT_I44416: return 48;

    default: assert(0 && "Invalid image format"); break;

  }

  return 0;

}

// Set appropriate options to disable frame super-resolution.

static void disable_superres(SuperResCfg *const superres_cfg) {

  superres_cfg->superres_mode = AOM_SUPERRES_NONE;

  superres_cfg->superres_scale_denominator = SCALE_NUMERATOR;

  superres_cfg->superres_kf_scale_denominator = SCALE_NUMERATOR;

  superres_cfg->superres_qthresh = 255;

  superres_cfg->superres_kf_qthresh = 255;

}

static void set_auto_tiles(TileConfig *const tile_cfg, unsigned int width,

                           unsigned int height, unsigned int threads) {

  int tile_cols_log2 = 0;

  int tile_rows_log2 = 0;

  if (threads < 2) return;

  // Avoid small tiles because they are particularly bad for coding.

  // Use no more tiles than the number of threads. Aim for one tile per

  // thread. Using more than one thread inside one tile could be less

  // efficient. Using more tiles than the number of threads would result

  // in a compression penalty without much benefit.

  const uint32_t kMinTileArea = 128 * 128;

  const uint32_t kMaxTiles = 32;

  uint32_t frame_area = width * height;

  uint32_t tiles = (frame_area + kMinTileArea - 1) / kMinTileArea;

  if (tiles > kMaxTiles) {

    tiles = kMaxTiles;

  }

  if (tiles > threads) {

    tiles = threads;

  }

  int tiles_log2 = (int)log2(tiles);

  // If the frame width is equal or greater than the height, use more tile

  // columns than tile rows.

  if (width >= height) {