/*

 * 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 <stdlib.h>

#include <string.h>

#include "aom_mem/aom_mem.h"

#include "config/aom_config.h"

#include "config/aom_version.h"

#include "aom_ports/mem_ops.h"

#include "aom/aom_encoder.h"

#include "aom/internal/aom_codec_internal.h"

#include "av1/av1_iface_common.h"

#include "av1/encoder/bitstream.h"

#include "av1/encoder/encoder.h"

#include "av1/encoder/ethread.h"

#include "av1/encoder/external_partition.h"

#include "av1/encoder/firstpass.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 static_thresh;

  unsigned int row_mt;

#if CONFIG_FRAME_PARALLEL_ENCODE

  unsigned int fp_mt;

#endif

  unsigned int tile_columns;  // log2 number of tile columns

  unsigned int tile_rows;     // log2 number of tile rows

  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 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;

  int deltaq_strength;

  int deltalf_mode;

  unsigned int frame_periodic_boost;

  aom_bit_depth_t bit_depth;

  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_FRAME_PARALLEL_ENCODE && 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 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;

  // 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;

};

#if CONFIG_REALTIME_ONLY

// Settings changed for realtime only build:

// cpu_used: 7

// enable_tpl_model: 0

// enable_restoration: 0

// enable_obmc: 0

// deltaq_mode: NO_DELTA_Q

// enable_global_motion usage: 0

// enable_warped_motion at sequence level: 0

// allow_warped_motion at frame level: 0

// coeff_cost_upd_freq: COST_UPD_OFF

// mode_cost_upd_freq: COST_UPD_OFF

// mv_cost_upd_freq: COST_UPD_OFF

static const struct av1_extracfg default_extra_cfg = {

  7,  // cpu_used

  1,  // enable_auto_alt_ref

  0,  // enable_auto_bwd_ref

  0,  // noise_sensitivity

  0,  // sharpness

  0,  // static_thresh

  1,  // row_mt

#if CONFIG_FRAME_PARALLEL_ENCODE

  0,  // fp_mt

#endif

  0,              // tile_columns

  0,              // tile_rows

  0,              // 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

  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

  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

  1,                            // enable dual filter

  0,                            // enable delta quant in chroma planes

  NO_AQ,                        // aq_mode

  NO_DELTA_Q,                   // deltaq_mode

  100,                          // deltaq_strength

  0,                            // delta lf mode

  0,                            // frame_periodic_boost

  AOM_BITS_8,                   // Bit depth

  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

  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

  0,                            // enable_global_motion usage

  0,                            // enable_warped_motion at sequence level

  0,                            // 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

  !CONFIG_SHARP_SETTINGS,  // enable intrabc

  1,                       // enable angle delta

#if CONFIG_DENOISE

  0,   // noise_level

  32,  // noise_block_size

  1,   // enable_dnl_denoising

#endif

  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_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

  NULL,            // two_pass_output

  NULL,            // second_pass_log

  0,               // auto_intra_tools_off

};

#else

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,              // static_thresh

  1,              // row_mt

#if CONFIG_FRAME_PARALLEL_ENCODE

  0,              // fp_mt

#endif

  0,              // tile_columns

  0,              // tile_rows

  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

  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_BITS_8,                   // Bit depth

  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_FRAME_PARALLEL_ENCODE && 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

  !CONFIG_SHARP_SETTINGS,  // enable intrabc

  1,                       // enable angle delta

#if CONFIG_DENOISE

  0,                       // noise_level

  32,                      // noise_block_size

  1,                       // enable_dnl_denoising

#endif

  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

  NULL,            // two_pass_output

  NULL,            // second_pass_log

  0,               // auto_intra_tools_off

};

#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;

};

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 INLINE void reduce_ratio(aom_rational64_t *ratio) {

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

  ratio->num /= denom;

  ratio->den /= denom;

}

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, 65535);  // 16 bits available

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

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

  RANGE_CHECK(cfg, g_timebase.num, 1, cfg->g_timebase.den);

  RANGE_CHECK_HI(cfg, g_profile, MAX_PROFILES - 1);

  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);

  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);

  if (cfg->g_pass == AOM_RC_ONE_PASS) {

    RANGE_CHECK_HI(cfg, g_lag_in_frames, MAX_TOTAL_BUFFERS);

  } else {

    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_FRAME_PARALLEL_ENCODE && 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) ? 10 : 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, row_mt, 1);

#if CONFIG_FRAME_PARALLEL_ENCODE

  RANGE_CHECK_HI(extra_cfg, fp_mt, 1);

#endif

  RANGE_CHECK_HI(extra_cfg, tile_columns, 6);

  RANGE_CHECK_HI(extra_cfg, tile_rows, 6);

  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, 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->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);

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

      RANGE_CHECK_HI(cfg, fixed_qp_offsets[i], 63);

    }

  } else {

    if (cfg->use_fixed_qp_offsets > 0) {

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

    }

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

      if (cfg->fixed_qp_offsets[i] >= 0) {

        ERROR("--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_BUTTERAUGLI);

  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, chroma_subsampling_x, 1);

  RANGE_CHECK_HI(extra_cfg, chroma_subsampling_y, 1);

  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_LEVELS) {

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

    }

  }

  RANGE_CHECK(extra_cfg, deltaq_strength, 0, 1000);

  RANGE_CHECK_HI(extra_cfg, loopfilter_control, 3);

  RANGE_CHECK_HI(extra_cfg, enable_cdef, 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_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, 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");

#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_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 update_default_encoder_config(const cfg_options_t *cfg,

                                          struct av1_extracfg *extra_cfg) {

  extra_cfg->enable_cdef = (cfg->disable_cdef == 0) ? 1 : 0;

  extra_cfg->enable_restoration = (cfg->disable_lr == 0);

  extra_cfg->superblock_size = (cfg->super_block_size == 64)

                                   ? AOM_SUPERBLOCK_SIZE_64X64

                                   : (cfg->super_block_size == 128)

                                         ? AOM_SUPERBLOCK_SIZE_128X128

                                         : AOM_SUPERBLOCK_SIZE_DYNAMIC;

  extra_cfg->enable_warped_motion = (cfg->disable_warp_motion == 0);

  extra_cfg->enable_dist_wtd_comp = (cfg->disable_dist_wtd_comp == 0);

  extra_cfg->enable_diff_wtd_comp = (cfg->disable_diff_wtd_comp == 0);

  extra_cfg->enable_dual_filter = (cfg->disable_dual_filter == 0);

  extra_cfg->enable_angle_delta = (cfg->disable_intra_angle_delta == 0);

  extra_cfg->enable_rect_partitions = (cfg->disable_rect_partition_type == 0);

  extra_cfg->enable_ab_partitions = (cfg->disable_ab_partition_type == 0);

  extra_cfg->enable_1to4_partitions = (cfg->disable_1to4_partition_type == 0);

  extra_cfg->max_partition_size = cfg->max_partition_size;

  extra_cfg->min_partition_size = cfg->min_partition_size;

  extra_cfg->enable_intra_edge_filter = (cfg->disable_intra_edge_filter == 0);

  extra_cfg->enable_tx64 = (cfg->disable_tx_64x64 == 0);

  extra_cfg->enable_flip_idtx = (cfg->disable_flip_idtx == 0);

  extra_cfg->enable_masked_comp = (cfg->disable_masked_comp == 0);

  extra_cfg->enable_interintra_comp = (cfg->disable_inter_intra_comp == 0);

  extra_cfg->enable_smooth_interintra = (cfg->disable_smooth_inter_intra == 0);

  extra_cfg->enable_interinter_wedge = (cfg->disable_inter_inter_wedge == 0);

  extra_cfg->enable_interintra_wedge = (cfg->disable_inter_intra_wedge == 0);

  extra_cfg->enable_global_motion = (cfg->disable_global_motion == 0);

  extra_cfg->enable_filter_intra = (cfg->disable_filter_intra == 0);

  extra_cfg->enable_smooth_intra = (cfg->disable_smooth_intra == 0);

  extra_cfg->enable_paeth_intra = (cfg->disable_paeth_intra == 0);

  extra_cfg->enable_cfl_intra = (cfg->disable_cfl == 0);

  extra_cfg->enable_obmc = (cfg->disable_obmc == 0);

  extra_cfg->enable_palette = (cfg->disable_palette == 0);

  extra_cfg->enable_intrabc = (cfg->disable_intrabc == 0);

  extra_cfg->disable_trellis_quant = cfg->disable_trellis_quant;

  extra_cfg->allow_ref_frame_mvs = (cfg->disable_ref_frame_mv == 0);

  extra_cfg->enable_ref_frame_mvs = (cfg->disable_ref_frame_mv == 0);

  extra_cfg->enable_onesided_comp = (cfg->disable_one_sided_comp == 0);

  extra_cfg->enable_reduced_reference_set = cfg->reduced_reference_set;

  extra_cfg->reduced_tx_type_set = cfg->reduced_tx_type_set;

}

static double convert_qp_offset(int cq_level, int q_offset, int bit_depth) {

  const double base_q_val = av1_convert_qindex_to_q(cq_level, bit_depth);

  const int new_q_index_offset = av1_quantizer_to_qindex(q_offset);

  const int new_q_index = AOMMAX(cq_level - new_q_index_offset, 0);

  const double new_q_val = av1_convert_qindex_to_q(new_q_index, bit_depth);

  return (base_q_val - new_q_val);

}

static double get_modeled_qp_offset(int cq_level, int level, int bit_depth) {

  // 80% for keyframe was derived empirically.

  // 40% similar to rc_pick_q_and_bounds_one_pass_vbr() for Q mode ARF.

  // Rest derived similar to rc_pick_q_and_bounds_two_pass()

  static const int percents[FIXED_QP_OFFSET_COUNT] = { 76, 60, 30, 15, 8 };

  const double q_val = av1_convert_qindex_to_q(cq_level, bit_depth);

  return q_val * percents[level] / 100;

}

static aom_codec_err_t set_encoder_config(AV1EncoderConfig *oxcf,

                                          const aom_codec_enc_cfg_t *cfg,

                                          struct av1_extracfg *extra_cfg) {

  if (cfg->encoder_cfg.init_by_cfg_file) {

    update_default_encoder_config(&cfg->encoder_cfg, extra_cfg);

  }

  TuneCfg *const tune_cfg = &oxcf->tune_cfg;

  FrameDimensionCfg *const frm_dim_cfg = &oxcf->frm_dim_cfg;

  TileConfig *const tile_cfg = &oxcf->tile_cfg;

  ResizeCfg *const resize_cfg = &oxcf->resize_cfg;

  GFConfig *const gf_cfg = &oxcf->gf_cfg;

  PartitionCfg *const part_cfg = &oxcf->part_cfg;

  IntraModeCfg *const intra_mode_cfg = &oxcf->intra_mode_cfg;

  TxfmSizeTypeCfg *const txfm_cfg = &oxcf->txfm_cfg;

  CompoundTypeCfg *const comp_type_cfg = &oxcf->comp_type_cfg;

  SuperResCfg *const superres_cfg = &oxcf->superres_cfg;

  KeyFrameCfg *const kf_cfg = &oxcf->kf_cfg;

  DecoderModelCfg *const dec_model_cfg = &oxcf->dec_model_cfg;

  RateControlCfg *const rc_cfg = &oxcf->rc_cfg;

  QuantizationCfg *const q_cfg = &oxcf->q_cfg;

  ColorCfg *const color_cfg = &oxcf->color_cfg;

  InputCfg *const input_cfg = &oxcf->input_cfg;

  AlgoCfg *const algo_cfg = &oxcf->algo_cfg;

  ToolCfg *const tool_cfg = &oxcf->tool_cfg;

  const int is_vbr = cfg->rc_end_usage == AOM_VBR;

  oxcf->profile = cfg->g_profile;

  oxcf->max_threads = (int)cfg->g_threads;

  switch (cfg->g_usage) {

    case AOM_USAGE_REALTIME: oxcf->mode = REALTIME; break;

    case AOM_USAGE_ALL_INTRA: oxcf->mode = ALLINTRA; break;

    default: oxcf->mode = GOOD; break;

  }

  // Set frame-dimension related configuration.

  frm_dim_cfg->width = cfg->g_w;

  frm_dim_cfg->height = cfg->g_h;

  frm_dim_cfg->forced_max_frame_width = cfg->g_forced_max_frame_width;