/* -----------------------------------------------------------------------------

The copyright in this software is being made available under the Clear BSD

License, included below. No patent rights, trademark rights and/or

other Intellectual Property Rights other than the copyrights concerning

the Software are granted under this license.

The Clear BSD License

Copyright (c) 2019-2026, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. & The VVenC Authors.

All rights reserved.

Redistribution and use in source and binary forms, with or without modification,

are permitted (subject to the limitations in the disclaimer below) provided that

the following conditions are met:

     * Redistributions of source code must retain the above copyright notice,

     this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above copyright

     notice, this list of conditions and the following disclaimer in the

     documentation and/or other materials provided with the distribution.

     * Neither the name of the copyright holder nor the names of its

     contributors may be used to endorse or promote products derived from this

     software without specific prior written permission.

NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY

THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER

IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

------------------------------------------------------------------------------------------- */

/** \file     vvencCfg.cpp

    \brief    encoder configuration class

*/

#include "vvenc/vvencCfg.h"

#include "CommonLib/CommonDef.h"

#include "CommonLib/Slice.h"

#include "CommonLib/ProfileLevelTier.h"

#include "Utilities/MsgLog.h"

#include "EncoderLib/GOPCfg.h"

#include <math.h>

#include <thread>

#include <iomanip>

#include "apputils/VVEncAppCfg.h"

VVENC_NAMESPACE_BEGIN

static bool checkCfgParameter( vvenc_config *cfg );

static void checkCfgPicPartitioningParameter( vvenc_config *c );

static void checkCfgInputArrays( vvenc_config *c, int &lastNonZeroCol, int &lastNonZeroRow, bool &cfgIsValid );

static void initMultithreading( vvenc_config *c );

static std::string vvenc_cfgString;

static int vvenc_getQpValsSize( int QpVals[] )

{

  int size=0;

  for ( int i = 0; i < VVENC_MAX_QP_VALS_CHROMA; i++ )

  {

    if( QpVals[i] > 0) size++;

    else break;

  }

  if( size == 0)

  {

    size = 1;  // at least first value must be set to 0

  }

  return size;

}

static std::vector<int> vvenc_getQpValsAsVec( int QpVals[] )

{

  std::vector<int> QpValsVec;

  for ( int i = 0; i < VVENC_MAX_QP_VALS_CHROMA; i++ )

  {

    if( QpVals[i] > 0) QpValsVec.push_back( QpVals[i] );

    else break;

  }

  if( QpValsVec.empty() )

  {

    QpValsVec = { 0 };

  }

  return QpValsVec;

}

static void vvenc_checkCharArrayStr( char array[], int size )

{

  bool resetArray = false;

  if ( 0 == strcmp(array, "empty") )

  {

    resetArray = true;

  }

  else if ( 0 == strcmp(array, "undef") )

  {

    resetArray = true;

  }

  else if ( 0 == strcmp(array, "''") )

  {

    resetArray = true;

  }

  else if ( 0 == strcmp(array, "\"\"") )

  {

    resetArray = true;

  }

  else if ( 0 == strcmp(array, "[]") )

  {

    resetArray = true;

  }

  if( resetArray )

  {

    for( int i = 0; i < size; i++ ) memset(&array[i],0, sizeof(char));

    array[0] = '\0';

  }

}

static inline std::string getProfileStr( int profile )

{

  std::string cT;

  switch( profile )

  {

    case VVENC_MAIN_10                              : cT = "main_10"; break;

    case VVENC_MAIN_10_STILL_PICTURE                : cT = "main_10_still_picture"; break;

    case VVENC_MAIN_10_444                          : cT = "main_10_444"; break;

    case VVENC_MAIN_10_444_STILL_PICTURE            : cT = "main_10_444_still_picture"; break;

    case VVENC_MULTILAYER_MAIN_10                   : cT = "multilayer_main_10"; break;

    case VVENC_MULTILAYER_MAIN_10_STILL_PICTURE     : cT = "multilayer_main_10_still_picture"; break;

    case VVENC_MULTILAYER_MAIN_10_444               : cT = "multilayer_main_10_444"; break;

    case VVENC_MULTILAYER_MAIN_10_444_STILL_PICTURE : cT = "multilayer_main_10_444_still_picture"; break;

    case VVENC_PROFILE_AUTO                         : cT = "auto"; break;

    default                                            : cT = "unknown"; break;

  }

  return cT;

}

static inline std::string getLevelStr( int level )

{

  std::string cT;

  switch( level )

  {

    case VVENC_LEVEL_AUTO: cT = "auto";    break;

    case VVENC_LEVEL1    : cT = "1";       break;

    case VVENC_LEVEL2    : cT = "2";       break;

    case VVENC_LEVEL2_1  : cT = "2.1";     break;

    case VVENC_LEVEL3    : cT = "3";       break;

    case VVENC_LEVEL3_1  : cT = "3.1";     break;

    case VVENC_LEVEL4    : cT = "4";       break;

    case VVENC_LEVEL4_1  : cT = "4.1";     break;

    case VVENC_LEVEL5    : cT = "5";       break;

    case VVENC_LEVEL5_1  : cT = "5.1";     break;

    case VVENC_LEVEL5_2  : cT = "5.2";     break;

    case VVENC_LEVEL6    : cT = "6";       break;

    case VVENC_LEVEL6_1  : cT = "6.1";     break;

    case VVENC_LEVEL6_2  : cT = "6.2";     break;

    case VVENC_LEVEL6_3  : cT = "6.3";     break;

    case VVENC_LEVEL15_5 : cT = "15.5";    break;

    default               : cT = "unknown"; break;

  }

  return cT;

}

static inline std::string getCostFunctionStr( int cost )

{

  std::string cT;

  switch( cost )

  {

    case VVENC_COST_STANDARD_LOSSY               : cT = "Lossy coding"; break;

    case VVENC_COST_SEQUENCE_LEVEL_LOSSLESS      : cT = "Sequence level lossless coding"; break;

    case VVENC_COST_LOSSLESS_CODING              : cT = "Lossless coding"; break;

    case VVENC_COST_MIXED_LOSSLESS_LOSSY_CODING  : cT = "Mixed lossless lossy coding"; break;

    default                                : cT = "Unknown"; break;

  }

  return cT;

}

static inline std::string getDynamicRangeStr( int dynamicRange )

{

  std::string cT;

  switch( dynamicRange )

  {

    case VVENC_HDR_OFF            : cT = "SDR"; break;

    case VVENC_HDR_PQ             : cT = "HDR10/PQ"; break;

    case VVENC_HDR_HLG            : cT = "HDR HLG"; break;

    case VVENC_HDR_PQ_BT2020      : cT = "HDR10/PQ BT.2020"; break;

    case VVENC_HDR_HLG_BT2020     : cT = "HDR HLG BT.2020"; break;

    case VVENC_HDR_USER_DEFINED   : cT = "HDR user defined"; break;

    case VVENC_SDR_BT709          : cT = "SDR BT.709"; break;

    case VVENC_SDR_BT2020         : cT = "SDR BT.2020"; break;

    case VVENC_SDR_BT470BG        : cT = "SDR BT.470 B/G"; break;

    default                       : cT = "unknown"; break;

  }

  return cT;

}

static inline bool isHDRMode( vvencHDRMode hdrMode )

{

  return ( hdrMode == VVENC_HDR_PQ || hdrMode == VVENC_HDR_PQ_BT2020 ||

           hdrMode == VVENC_HDR_HLG || hdrMode == VVENC_HDR_HLG_BT2020 ) ? true : false;

}

static inline std::string vvenc_getMasteringDisplayStr( unsigned int md[10]  )

{

  std::stringstream css;

  css << "G(" << md[0] << "," << md[1] << ")";

  css << "B(" << md[2] << "," << md[3] << ")";

  css << "R(" << md[4] << "," << md[5] << ")";

  css << "WP("<< md[6] << "," << md[7] << ")";

  css << "L(" << md[8] << "," << md[9] << ")";

  css << " (= nits: ";

  css << "G(" << md[0]/50000.0 << "," << md[1]/50000.0 << ")";

  css << "B(" << md[2]/50000.0 << "," << md[3]/50000.0 << ")";

  css << "R(" << md[4]/50000.0 << "," << md[5]/50000.0 << ")";

  css << "WP("<< md[6]/50000.0 << "," << md[7]/50000.0 << ")";

  css << "L(" << md[8]/10000.0 << "," << md[9]/10000.0 << ")";

  css << ")";

  return css.str();

}

static inline std::string vvenc_getContentLightLevelStr( unsigned int cll[2] )

{

  std::stringstream css;

  css << cll[0] << "," << cll[1] << " (cll,fall)";

  return css.str();

}

static inline std::string vvenc_getDecodingRefreshTypeStr(  int type, bool poc0idr )

{

  std::string cType( "CRA");

  switch( type )

  {

    case 0: cType = "none"; break;

    case 1: cType = "CRA"; break;

    case 2: cType = "IDR"; break;

    case 3: cType = "RecPointSEI"; break;

    case 4: cType = "IDR2 (deprecated)"; break; //deprecated

    case 5: cType = "CRA_CRE (CRA with constrained encoding for RASL pictures)"; break;

    case 6: cType = "IDR_NO_RADL"; break;

    default: cType = "unknown"; break;

  }

  if( poc0idr ) cType += " with POC 0 IDR";

  return cType;

}

static inline int getNumThreadsDefault( vvenc_config *c )

{

  const int minSize = std::min( c->m_SourceWidth, c->m_SourceHeight );

  if( minSize >= 2880 )

    return 12;

  else if( minSize >= 720 )

    return 8;

  return 4;

}

VVENC_DECL void vvenc_GOPEntry_default(vvencGOPEntry *GOPEntry )

{

  GOPEntry->m_POC                       = -1;

  GOPEntry->m_QPOffset                  = 0;

  GOPEntry->m_QPOffsetModelOffset       = 0.0;

  GOPEntry->m_QPOffsetModelScale        = 0.0;

  GOPEntry->m_CbQPoffset                = 0;

  GOPEntry->m_CrQPoffset                = 0;

  GOPEntry->m_QPFactor                  = 0.0;

  GOPEntry->m_tcOffsetDiv2              = 0;

  GOPEntry->m_betaOffsetDiv2            = 0;

  GOPEntry->m_cfgUnused1                = 0;

  GOPEntry->m_cfgUnused2                = 0;

  GOPEntry->m_cfgUnused3                = 0;

  GOPEntry->m_cfgUnused4                = 0;

  GOPEntry->m_temporalId                = 0;

  GOPEntry->m_sliceType                 = 'P';

  memset( GOPEntry->m_numRefPicsActive, 0, sizeof( GOPEntry->m_numRefPicsActive ) );

  memset( GOPEntry->m_numRefPics, 0, sizeof( GOPEntry->m_numRefPics ) );

  memset( GOPEntry->m_deltaRefPics, 0, sizeof( GOPEntry->m_deltaRefPics ) );

}

VVENC_DECL void vvenc_WCGChromaQPControl_default(vvencWCGChromaQPControl *WCGChromaQPControl )

{

  memset( WCGChromaQPControl, 0, sizeof( vvencWCGChromaQPControl ) );

}

VVENC_DECL void vvenc_ChromaQpMappingTableParams_default(vvencChromaQpMappingTableParams *p )

{

  p->m_numQpTables                                          = 0;

  p->m_qpBdOffset                                           = 12;

  p->m_sameCQPTableForAllChromaFlag                         = true;

  memset( p->m_qpTableStartMinus26, 0, sizeof( p->m_qpTableStartMinus26 ) );

  memset( p->m_numPtsInCQPTableMinus1, 0, sizeof( p->m_numPtsInCQPTableMinus1 ) );

  memset( p->m_deltaQpInValMinus1, 0, sizeof( p->m_deltaQpInValMinus1 ) );

  memset( p->m_deltaQpOutVal, 0, sizeof( p->m_deltaQpOutVal ) );

}

VVENC_DECL void vvenc_RPLEntry_default(vvencRPLEntry *RPLEntry )

{

  RPLEntry->m_POC                              = -1;

  RPLEntry->m_temporalId                       = 0;

  RPLEntry->m_refPic                           = false;

  RPLEntry->m_ltrp_in_slice_header_flag        = false;

  RPLEntry->m_numRefPicsActive                 = 0;

  RPLEntry->m_sliceType                        ='P';

  RPLEntry->m_numRefPics                       = 0;

  memset(&RPLEntry->m_deltaRefPics,0, sizeof(RPLEntry->m_deltaRefPics));

}

VVENC_DECL void vvenc_ReshapeCW_default(vvencReshapeCW *reshapeCW )

{

  memset( reshapeCW->binCW, 0, sizeof( reshapeCW->binCW ) );

  reshapeCW->updateCtrl = 0;

  reshapeCW->adpOption  = 0;

  reshapeCW->initialCW  = 0;

  reshapeCW->rspPicSize = 0;

  reshapeCW->rspFps     = 0;

  reshapeCW->rspTid     = 0;

  reshapeCW->rspFpsToIp = 0;

}

VVENC_DECL void vvenc_vvencMCTF_default(vvencMCTF *vvencMCTF )

{

  vvencMCTF->MCTF = 0;

  vvencMCTF->MCTFSpeed = 0;

  vvencMCTF->MCTFFutureReference = true;

  vvencMCTF->numFrames = 0;

  vvencMCTF->numStrength = 0;

  vvencMCTF->MCTFUnitSize = -1;

  memset( vvencMCTF->MCTFFrames, 0, sizeof( vvencMCTF->MCTFFrames ) );

  memset( vvencMCTF->MCTFStrengths, 0, sizeof( vvencMCTF->MCTFStrengths ) );

}

VVENC_DECL void vvenc_config_default(vvenc_config *c )

{

  int i = 0;

  // internal params

  c->m_configDone                              = false;         ///< state variable, Private context used for internal data ( do not change )

  c->m_confirmFailed                           = false;         ///< state variable, Private context used for internal data ( do not change )

  c->m_msgFnc                                  = nullptr;

  c->m_msgCtx                                  = nullptr;

  // core params

  c->m_SourceWidth                             = 0;             ///< source width in pixel

  c->m_SourceHeight                            = 0;             ///< source height in pixel (when interlaced = field height)

  c->m_FrameRate                               = 0;             ///< source frame-rates (Hz) Numerator

  c->m_FrameScale                              = 1;             ///< source frame-rates (Hz) Denominator

  c->m_TicksPerSecond                          = VVENC_TICKS_PER_SEC_DEF; ///< ticks per second for dts generation (default: 27000000, 1..27000000, -1: ticks per frame=1)

  c->m_framesToBeEncoded                       = 0;             ///< number of encoded frames

  c->m_inputBitDepth[0]                        = 8;             ///< bit-depth of input

  c->m_inputBitDepth[1]                        = 0;

  c->m_numThreads                              = 0;             ///< number of worker threads

  c->m_QP                                      = VVENC_DEFAULT_QP;

  c->m_RCTargetBitrate                         = VVENC_RC_OFF;

  c->m_RCMaxBitrate                            = 0;

  c->m_RCInitialQP                             = 0;

  c->m_verbosity                               = VVENC_INFO;    ///< encoder verbosity

  // basic params

  c->m_profile                                 = vvencProfile::VVENC_PROFILE_AUTO;

  c->m_levelTier                               = vvencTier::VVENC_TIER_MAIN ;

  c->m_level                                   = vvencLevel::VVENC_LEVEL_AUTO;

  c->m_IntraPeriod                             = 0;             ///< period of I-slice (random access period)

  c->m_IntraPeriodSec                          = 1;             ///< period of I-slice in seconds (random access period)

  c->m_DecodingRefreshType                     = VVENC_DRT_CRA;       ///< random access type

  c->m_GOPSize                                 = 32;            ///< GOP size

  c->m_poc0idr                                 = -1;

  c->m_picReordering                           = 1;

  c->m_usePerceptQPA                           = false;         ///< perceptually motivated input-adaptive QP modification, abbrev. perceptual QP adaptation (QPA)

  c->m_sliceTypeAdapt                          = -1;            ///< perceptually and objectively motivated slice type adaptation (STA)

  c->m_minIntraDist                            = -1;

  c->m_RCNumPasses                             = -1;

  c->m_RCPass                                  = -1;

  c->m_LookAhead                               = -1;

  c->m_SegmentMode                             = VVENC_SEG_OFF;

  c->m_internalBitDepth[0]                     =10;                                 ///< bit-depth codec operates at (input/output files will be converted)

  c->m_internalBitDepth[1]                     =0;

  c->m_HdrMode                                 = VVENC_HDR_OFF;

  // expert options

  c->m_conformanceWindowMode                   = 1;

  c->m_confWinLeft                             = 0;

  c->m_confWinRight                            = 0;

  c->m_confWinTop                              = 0;

  c->m_confWinBottom                           = 0;

  c->m_PadSourceWidth                          = 0;                                     ///< source width in pixel

  c->m_PadSourceHeight                         = 0;                                     ///< source height in pixel (when interlaced = field height)

  c->m_maxPicWidth                             = 0;

  c->m_maxPicHeight                            = 0;

  memset(&c->m_aiPad,0, sizeof(c->m_aiPad));                                    ///< number of padded pixels for width and height

  c->m_enablePictureHeaderInSliceHeader        = true;

  c->m_AccessUnitDelimiter                     = -1;                                    ///< add Access Unit Delimiter NAL units, default: auto (only enable if needed by dependent options)

  c->m_printMSEBasedSequencePSNR               = false;

  c->m_printHexPsnr                            = false;

  c->m_printFrameMSE                           = false;

  c->m_printSequenceMSE                        = false;

  c->m_cabacZeroWordPaddingEnabled             = true;

  c->m_subProfile                              = 0;

  c->m_bitDepthConstraintValue                 = 10;

  c->m_intraOnlyConstraintFlag                 = false;

  c->m_rewriteParamSets                        = true;                                 ///< Flag to enable rewriting of parameter sets at random access points

  c->m_idrRefParamList                         = false;                                 ///< indicates if reference picture list syntax elements are present in slice headers of IDR pictures

  for( i = 0; i < VVENC_MAX_GOP; i++ )

  {

    vvenc_GOPEntry_default( &c->m_GOPList[i]);                                          ///< the coding structure entries from the config file

  }

  c->m_useSameChromaQPTables                   = true;

  vvenc_ChromaQpMappingTableParams_default( &c->m_chromaQpMappingTableParams );

  c->m_intraQPOffset                           = 0;                                     ///< QP offset for intra slice (integer)

  c->m_lambdaFromQPEnable                      = false;                                 ///< enable flag for QP:lambda fix

  for( i = 0; i < VVENC_MAX_TLAYER; i++ )

  {

    c->m_adLambdaModifier[i] = 1.0;                                                     ///< Lambda modifier array for each temporal layer

    c->m_adIntraLambdaModifier[i] = 0.0;                                                ///< Lambda modifier for Intra pictures, one for each temporal layer. If size>temporalLayer, then use [temporalLayer], else if size>0, use [size()-1], else use m_adLambdaModifier.

  }

  c->m_dIntraQpFactor                          = -1.0;                                  ///< Intra Q Factor. If negative, use a default equation: 0.57*(1.0 - Clip3( 0.0, 0.5, 0.05*(double)(isField ? (GopSize-1)/2 : GopSize-1) ))

  memset(&c->m_qpInValsCb    ,0, sizeof(c->m_qpInValsCb));                      ///< qp input values used to derive the chroma QP mapping table

  memset(&c->m_qpInValsCr    ,0, sizeof(c->m_qpInValsCr));                      ///< qp input values used to derive the chroma QP mapping table

  memset(&c->m_qpInValsCbCr  ,0, sizeof(c->m_qpInValsCbCr));                      ///< qp input values used to derive the chroma QP mapping table

  memset(&c->m_qpOutValsCb   ,0, sizeof(c->m_qpOutValsCb));                      ///< qp output values used to derive the chroma QP mapping table

  memset(&c->m_qpOutValsCr   ,0, sizeof(c->m_qpOutValsCr));                      ///< qp output values used to derive the chroma QP mapping table

  memset(&c->m_qpOutValsCbCr ,0, sizeof(c->m_qpOutValsCbCr));                      ///< qp output values used to derive the chroma QP mapping table

  c->m_qpInValsCb[0] = 17;  c->m_qpInValsCb[1] = 22;  c->m_qpInValsCb[2] = 34;  c->m_qpInValsCb[3] = 42;

  c->m_qpOutValsCb[0] = 17; c->m_qpOutValsCb[1] = 23; c->m_qpOutValsCb[2] = 35; c->m_qpOutValsCb[3] = 39;

  c->m_cuQpDeltaSubdiv                         = -1;                                    ///< Maximum subdiv for CU luma Qp adjustment (0:default)

  c->m_cuChromaQpOffsetSubdiv                  = -1;                                    ///< If negative, then do not apply chroma qp offsets.

  c->m_chromaCbQpOffset                        = 0;                                     ///< Chroma Cb QP Offset (0:default)

  c->m_chromaCrQpOffset                        = 0;                                     ///< Chroma Cr QP Offset (0:default)

  c->m_chromaCbQpOffsetDualTree                = 0;                                     ///< Chroma Cb QP Offset for dual tree (overwrite m_chromaCbQpOffset for dual tree)

  c->m_chromaCrQpOffsetDualTree                = 0;                                     ///< Chroma Cr QP Offset for dual tree (overwrite m_chromaCrQpOffset for dual tree)

  c->m_chromaCbCrQpOffset                      = -1;                                    ///< QP Offset for joint Cb-Cr mode

  c->m_chromaCbCrQpOffsetDualTree              = 0;                                     ///< QP Offset for joint Cb-Cr mode (overwrite m_chromaCbCrQpOffset for dual tree)

  c->m_sliceChromaQpOffsetPeriodicity          = -1;                                    ///< Used in conjunction with Slice Cb/Cr QpOffsetIntraOrPeriodic. Use 0 (default) to disable periodic nature.

  memset(&c->m_sliceChromaQpOffsetIntraOrPeriodic,0, sizeof(c->m_sliceChromaQpOffsetIntraOrPeriodic));            ///< Chroma Cb QP Offset at slice level for I slice or for periodic inter slices as defined by SliceChromaQPOffsetPeriodicity. Replaces offset in the GOP table.

  c->m_usePerceptQPATempFiltISlice             = -1;                                    ///< Flag indicating if temporal high-pass filtering in visual activity calculation in QPA should (true) or shouldn't (false) be applied for I-slices

  c->m_lumaLevelToDeltaQPEnabled               = false;

  vvenc_WCGChromaQPControl_default( &c->m_cfgUnused24 );

  c->m_internChromaFormat                      = VVENC_NUM_CHROMA_FORMAT;

  c->m_useIdentityTableForNon420Chroma         = true;

  c->m_outputBitDepth[0]      = c->m_outputBitDepth[1]      = 0;                              ///< bit-depth of output file

  c->m_MSBExtendedBitDepth[0] = c->m_MSBExtendedBitDepth[1] = 0;                    ///< bit-depth of input samples after MSB extension

  c->m_costMode                                = VVENC_COST_STANDARD_LOSSY;                   ///< Cost mode to use

  c->m_decodedPictureHashSEIType               = VVENC_HASHTYPE_NONE;                         ///< Checksum mode for decoded picture hash SEI message

  c->m_bufferingPeriodSEIEnabled               = false;

  c->m_pictureTimingSEIEnabled                 = false;

  c->m_decodingUnitInfoSEIEnabled              = false;

  c->m_entropyCodingSyncEnabled                = -1;

  c->m_entryPointsPresent                      = true;

  c->m_CTUSize                                 = 128;

  c->m_MinQT[0] = c->m_MinQT[1] = 8;                                            ///< 0: I slice luma; 1: P/B slice; 2: I slice chroma

  c->m_MinQT[2] = 4;

  c->m_maxMTTDepth                             = 3;

  c->m_maxMTTDepthI                            = 3;

  c->m_maxMTTDepthIChroma                      = -1;

  c->m_maxBT[0]=32;  c->m_maxBT[1]=128;  c->m_maxBT[2]=64;

  c->m_maxTT[0]=32;  c->m_maxTT[1]=64;  c->m_maxTT[2]=32;

  c->m_dualITree                               = true;

  c->m_log2MaxTbSize                           = 6;

  c->m_log2MinCodingBlockSize                  = 2;

  c->m_bUseASR                                 = false;                                 ///< flag for using adaptive motion search range

  c->m_bUseHADME                               = true;                                  ///< flag for using HAD in sub-pel ME

  c->m_fastHad                                 = false;

  c->m_RDOQ                                    = 1;                                     ///< flag for using RD optimized quantization

  c->m_useRDOQTS                               = true;                                  ///< flag for using RD optimized quantization for transform skip

  c->m_useSelectiveRDOQ                        = false;                                 ///< flag for using selective RDOQ

  c->m_JointCbCrMode                           = false;

  c->m_cabacInitPresent                        = -1;

  c->m_useFastLCTU                             = false;

  c->m_usePbIntraFast                          = 0;

  c->m_useFastMrg                              = 0;

  c->m_useAMaxBT                               = -1;

  c->m_fastQtBtEnc                             = true;

  c->m_contentBasedFastQtbt                    = false;

  c->m_fastInterSearchMode                     = VVENC_FASTINTERSEARCH_MODE3;

  c->m_useEarlyCU                              = 0;

  c->m_useFastDecisionForMerge                 = true;

  c->m_bDisableIntraCUsInInterSlices           = false;

  c->m_bFastUDIUseMPMEnabled                   = true;

  c->m_bFastMEForGenBLowDelayEnabled           = true;

  c->m_MTSImplicit                             = false;

  c->m_TMVPModeId                              = 1;

  c->m_DepQuantEnabled                         = true;

  c->m_SignDataHidingEnabled                   = false;

  c->m_MIP                                     = false;

  c->m_useFastMIP                              = 0;

  c->m_maxNumMergeCand                         = 5;

  c->m_maxNumAffineMergeCand                   = 5;

  c->m_Geo                                     = 0;

  c->m_maxNumGeoCand                           = 5;

  c->m_FastIntraTools                          = 0;

  c->m_IntraEstDecBit                          = 1;

  c->m_motionEstimationSearchMethod            = VVENC_MESEARCH_DIAMOND;

  c->m_motionEstimationSearchMethodSCC         = 0;

  c->m_SearchRange                             = 96;

  c->m_bipredSearchRange                       = 4;

  c->m_minSearchWindow                         = 8;

  c->m_bClipForBiPredMeEnabled                 = false;

  c->m_bFastMEAssumingSmootherMVEnabled        = true;

  c->m_bIntegerET                              = false;

  c->m_fastSubPel                              = 0;

  c->m_meReduceTap                             = 0;

  c->m_SMVD                                    = 0;

  c->m_AMVRspeed                               = 0;

  c->m_LMChroma                                = false;

  c->m_horCollocatedChromaFlag                 = true;

  c->m_verCollocatedChromaFlag                 = false;

  c->m_MRL                                     = true;

  c->m_BDOF                                    = false;

  c->m_DMVR                                    = false;

  c->m_EDO                                     = 0;

  c->m_lumaReshapeEnable                       = 0;

  c->m_reshapeSignalType                       = 0;

  c->m_updateCtrl                              = 0;

  c->m_adpOption                               = 0;

  c->m_initialCW                               = 0;

  c->m_LMCSOffset                              = 0;

  vvenc_ReshapeCW_default( &c->m_reshapeCW );

  c->m_Affine                                  = 0;

  c->m_PROF                                    = false;

  c->m_AffineType                              = true;

  c->m_MMVD                                    = 0;

  c->m_MmvdDisNum                              = 6;

  c->m_allowDisFracMMVD                        = false;

  c->m_CIIP                                    = 0;

  c->m_SbTMVP                                  = false;

  c->m_SBT                                     = 0;

  c->m_LFNST                                   = 0;

  c->m_MTS                                     = 0;

  c->m_MTSIntraMaxCand                         = 3;

  c->m_ISP                                     = 0;

  c->m_TS                                      = 0;

  c->m_TSsize                                  = 3;

  c->m_useChromaTS                             = 0;

  c->m_useBDPCM                                = 0;

  c->m_rprEnabledFlag                          = -1;

  c->m_resChangeInClvsEnabled                  = false;

  c->m_craAPSreset                             = false;

  c->m_rprRASLtoolSwitch                       = false;

  c->m_IBCMode                                 = 0;

  c->m_IBCFastMethod                           = 1;

  c->m_BCW                                     = 0;

  c->m_FIMMode                                 = 0;

  c->m_FastInferMerge                          = 0;

  c->m_bLoopFilterDisable                      = false;

  c->m_loopFilterOffsetInPPS                   = true;

  memset(&c->m_loopFilterBetaOffsetDiv2,0, sizeof(c->m_loopFilterBetaOffsetDiv2));

  memset(&c->m_loopFilterTcOffsetDiv2,0, sizeof(c->m_loopFilterTcOffsetDiv2));

  c->m_bDisableLFCrossTileBoundaryFlag         = false;

  c->m_bDisableLFCrossSliceBoundaryFlag        = false;

  c->m_bUseSAO                                 = true;

  c->m_saoScc                                  = false;

  c->m_saoEncodingRate                         = -1.0;

  c->m_saoEncodingRateChroma                   = -1.0;

  c->m_log2SaoOffsetScale[0]=c->m_log2SaoOffsetScale[1] = 0;

  c->m_saoOffsetBitShift[0]=c->m_saoOffsetBitShift[1] = 0;

  c->m_decodingParameterSetEnabled             = false;

  c->m_vuiParametersPresent                    = -1;

  c->m_hrdParametersPresent                    = true;

  c->m_aspectRatioInfoPresent                  = false;

  c->m_aspectRatioIdc                          = 1;

  c->m_sarWidth                                = 0;

  c->m_sarHeight                               = 0;

  c->m_colourDescriptionPresent                = false;

  c->m_colourPrimaries                         = 2;

  c->m_transferCharacteristics                 = 2;

  c->m_matrixCoefficients                      = 2;

  c->m_chromaLocInfoPresent                    = -1;

  c->m_chromaSampleLocType                     = -1;

  c->m_overscanInfoPresent                     = false;

  c->m_overscanAppropriateFlag                 = false;

  c->m_videoFullRangeFlag                      = false;

  memset(&c->m_masteringDisplay,0, sizeof(c->m_masteringDisplay));

  memset(&c->m_contentLightLevel,0, sizeof(c->m_contentLightLevel));

  c->m_preferredTransferCharacteristics        = -1;

  c->m_alf                                     = false;

  c->m_alfSpeed                                = 0;

  c->m_useNonLinearAlfLuma                     = true;

  c->m_useNonLinearAlfChroma                   = true;

  c->m_maxNumAlfAlternativesChroma             = VVENC_MAX_NUM_ALF_ALTERNATIVES_CHROMA;

  c->m_ccalf                                   = false;

  c->m_alfTempPred                             = -1;

  c->m_alfUnitSize                             = -1;

  vvenc_vvencMCTF_default( &c->m_vvencMCTF );

  c->m_blockImportanceMapping                  = true;

  c->m_quantThresholdVal                       = -1;

  c->m_qtbttSpeedUp                            = 1;

  c->m_qtbttSpeedUpMode                        = 0;

  c->m_fastTTSplit                             = 0;

  c->m_fastLocalDualTreeMode                   = 0;

  c->m_maxParallelFrames                       = -1;

  c->m_ensureWppBitEqual                       = -1;

  c->m_tileParallelCtuEnc                      = true;

  c->m_ifpLines                                = -1;

  c->m_ifp                                     = -1;

  c->m_mtProfile                               =  0;

  c->m_numParallelGOPs                         =  0;

  c->m_picPartitionFlag                        = false;

  memset( c->m_tileColumnWidth, 0, sizeof(c->m_tileColumnWidth) );

  memset( c->m_tileRowHeight,   0, sizeof(c->m_tileRowHeight) );

  c->m_numExpTileCols                          = 1;

  c->m_numExpTileRows                          = 1;

  c->m_numTileCols                             = -1;

  c->m_numTileRows                             = -1;

  c->m_numSlicesInPic                          = 1;

  memset( c->m_summaryOutFilename    , '\0', sizeof(c->m_summaryOutFilename) );

  memset( c->m_summaryPicFilenameBase, '\0', sizeof(c->m_summaryPicFilenameBase) );

  c->m_summaryVerboseness                      = 0;

  c->m_listTracingChannels                     = false;

  memset( c->m_traceRule, '\0', sizeof(c->m_traceRule) );

  memset( c->m_traceFile, '\0', sizeof(c->m_traceFile) );

  c->m_numIntraModesFullRD                     = -1;

  c->m_reduceIntraChromaModesFullRD            = false;

  c->m_treatAsSubPic                           = false;

  c->m_explicitAPSid                           = 0;

  c->m_leadFrames                              = 0;

  c->m_trailFrames                             = 0;

  c->m_deblockLastTLayers                      = 0;

  c->m_addGOP32refPics                         = false;

  c->m_numRefPics                              = 0;

  c->m_numRefPicsSCC                           = -1;

  c->m_FirstPassMode                           = 0;

  c->m_forceScc                                = 0;

  c->m_GOPQPA                                  = -1;

  c->m_fga                                     = false;

  memset( c->m_reservedInt8, 0, sizeof(c->m_reservedInt8) );

  memset( c->m_reservedDouble, 0, sizeof(c->m_reservedDouble) );

  // init default preset

  vvenc_init_preset( c, vvencPresetMode::VVENC_MEDIUM );

}

static bool vvenc_confirmParameter ( vvenc_config *c, bool bflag, const char* message )

{

  if ( ! bflag )

    return false;

  vvenc::MsgLog msg(c->m_msgCtx,c->m_msgFnc);

  msg.log( VVENC_ERROR, "Parameter Check Error: %s\n", message );

  c->m_confirmFailed = true;

  return true;

}

VVENC_DECL bool vvenc_init_config_parameter( vvenc_config *c )

{

  c->m_confirmFailed = false;

  // check for valid base parameter

  vvenc_confirmParameter( c,  (c->m_SourceWidth <= 0 || c->m_SourceHeight <= 0), "Input resolution not set");

  vvenc_confirmParameter( c, c->m_inputBitDepth[0] < 8 || c->m_inputBitDepth[0] > 16,                    "InputBitDepth must be at least 8" );

  vvenc_confirmParameter( c, c->m_inputBitDepth[0] != 8 && c->m_inputBitDepth[0] != 10,                  "Input bitdepth must be 8 or 10 bit" );

  vvenc_confirmParameter( c, c->m_internalBitDepth[0] != 8 && c->m_internalBitDepth[0] != 10,            "Internal bitdepth must be 8 or 10 bit" );

  vvenc_confirmParameter( c, c->m_FrameRate <= 0,                                                        "Frame rate must be greater than 0" );

  vvenc_confirmParameter( c, c->m_FrameScale <= 0,                                                       "Frame scale must be greater than 0" );

  vvenc_confirmParameter( c, c->m_TicksPerSecond < -1 || c->m_TicksPerSecond == 0 || c->m_TicksPerSecond > 27000000, "TicksPerSecond must be in range from 1 to 27000000, or -1 for ticks per frame=1" );

  std::stringstream css;

  if ( c->m_FrameScale != 1  && c->m_FrameScale != 1001 && c->m_TicksPerSecond == VVENC_TICKS_PER_SEC_DEF )

  {

    double dFrameRate = c->m_FrameRate/(double)c->m_FrameScale;

    css << "Detected non-standard Frame Rate " << c->m_FrameRate << "/" << c->m_FrameScale;

    css << " (" << std::fixed << std:: setprecision(2) << dFrameRate <<  std::setprecision(-1) << " Hz).";

    css << " Default TicksPerSecond (" << VVENC_TICKS_PER_SEC_DEF << ") can not be used.";

    if ( c->m_FrameRate * c->m_FrameScale <= VVENC_TICKS_PER_SEC_DEF )

    {

      css << " possible TicksPerSecond: " << (c->m_FrameRate * c->m_FrameScale) << std::endl;

    }

    else

    {

      css << " cannot find a proper value for TicksPerSecond in the range (1-" << VVENC_TICKS_PER_SEC_DEF << ")" << std::endl;

    }

  }

  else

  {

    css << "TicksPerSecond must be a multiple of FrameRate/Framescale (" << c->m_FrameRate << "/" << c->m_FrameScale << "). Use 27000000 for NTSC content"  << std::endl;

  }

  vvenc_confirmParameter( c, ( c->m_TicksPerSecond > 0 && c->m_FrameRate > 0) && ((int64_t)c->m_TicksPerSecond*(int64_t)c->m_FrameScale)%c->m_FrameRate, css.str().c_str() );

  vvenc_confirmParameter( c, c->m_numThreads < -1 || c->m_numThreads > 256,                              "Number of threads out of range (-1 <= t <= 256)");

  vvenc_confirmParameter( c, c->m_IntraPeriod < -1,                                                      "IDR period (in frames) must be >= -1");

  vvenc_confirmParameter( c, c->m_IntraPeriodSec < 0,                                                    "IDR period (in seconds) must be >= 0");

  vvenc_confirmParameter( c, c->m_GOPSize < 1 || c->m_GOPSize > VVENC_MAX_GOP,                           "GOP Size must be between 1 and 64" );

  vvenc_confirmParameter( c, c->m_leadFrames < 0 || c->m_leadFrames > VVENC_MAX_GOP,                     "Lead frames exceeds supported range (0 to 64)" );

  vvenc_confirmParameter( c, c->m_trailFrames < 0 || c->m_trailFrames > VVENC_MCTF_RANGE,                "Trail frames exceeds supported range (0 to 6)" );

  vvenc_confirmParameter( c, c->m_sliceTypeAdapt < -1 || c->m_sliceTypeAdapt > 2,                        "Slice type adaptation (STA) invalid parameter given, range is (-1 .. 2)" );

  vvenc_confirmParameter( c, c->m_minIntraDist < -1,                                                     "Minimum intra distance cannot be smaller than -1" );

  if( VVENC_RC_OFF == c->m_RCTargetBitrate )

  {

    vvenc_confirmParameter( c, c->m_bufferingPeriodSEIEnabled, "Enabling bufferingPeriod SEI requires rate control" );

    vvenc_confirmParameter( c, c->m_pictureTimingSEIEnabled,   "Enabling pictureTiming SEI requires rate control" );

    vvenc_confirmParameter( c, c->m_RCMaxBitrate > 0 && c->m_RCMaxBitrate != INT32_MAX && !c->m_usePerceptQPA, "Enabling capped CQF requires PerceptQPA to be enabled" );

    vvenc_confirmParameter( c, c->m_RCMaxBitrate > 0 && c->m_RCInitialQP > 0, "Specifying an RCInitialQP value requires rate control" );

    vvenc_confirmParameter( c, c->m_RCMaxBitrate < 0, "Cannot specify a relative max rate when using CQF, please specify an absolute value" );

  }

  if( c->m_RCMaxBitrate == 0 )

  {

    c->m_RCMaxBitrate = INT32_MAX;

  }

  else if( c->m_RCMaxBitrate < 0 )

  {

    c->m_RCMaxBitrate = (int)(( -(int64_t)c->m_RCMaxBitrate * (int64_t)c->m_RCTargetBitrate + 8 ) >> 4);

  }

  vvenc_confirmParameter( c, c->m_HdrMode < VVENC_HDR_OFF || c->m_HdrMode > VVENC_SDR_BT470BG,  "Sdr/Hdr Mode must be in the range 0 - 8" );

  vvenc_confirmParameter( c, c->m_verbosity < VVENC_SILENT || c->m_verbosity > VVENC_DETAILS, "verbosity is out of range[0..6]" );

  vvenc_confirmParameter( c,  (c->m_numIntraModesFullRD < -1 || c->m_numIntraModesFullRD == 0 || c->m_numIntraModesFullRD > 3), "NumIntraModesFullRD must be -1 or between 1 and 3");

#if ! ENABLE_TRACING

  vvenc_confirmParameter( c, c->m_traceFile[0] != '\0', "trace file option '--tracefile' set, but encoder lib not compiled with tracing support, use make ... enable-tracing=1 or set ENABLE_TRACING" );

  vvenc_confirmParameter( c, c->m_traceRule[0] != '\0', "trace rule option '--tracerule' set, but encoder lib not compiled with tracing support, use make ... enable-tracing=1 or set ENABLE_TRACING" );

  vvenc_confirmParameter( c, c->m_listTracingChannels, "list trace channels option '--tracechannellist' set, but encoder lib not compiled with tracing support, use make ... enable-tracing=1 or set ENABLE_TRACING" );

#endif

  if ( c->m_confirmFailed )

  {

    return c->m_confirmFailed;

  }

  //

  // set a lot of dependent parameters

  //

  vvenc::MsgLog msg(c->m_msgCtx, c->m_msgFnc);

  if( c->m_FirstPassMode > 2 && c->m_RCTargetBitrate != 0 )

  {

    // lookahead will only be set to 0 later

    if( c->m_LookAhead > 0 || c->m_RCNumPasses == 1 || std::min( c->m_SourceWidth, c->m_SourceHeight ) < 720 ) 

    {

      c->m_FirstPassMode -= 2;  

      //msg.log( VVENC_NOTICE, "First pass spatial downsampling (FirstPassMode=3/4) cannot be used for single pass encoding and videos with resolution lower than 720p, changing FirstPassMode to %d!\n", c->m_FirstPassMode );

    }

  }

  const double d = (c->m_RCTargetBitrate != VVENC_RC_OFF ? 1.0 : 2.25) * (3840.0 * 2160.0) / double (c->m_SourceWidth * c->m_SourceHeight);

  const double f = 38183.5 * sqrt (0.5 + c->m_GOPSize / double (c->m_IntraPeriod < 0 ? INT32_MAX : c->m_GOPSize + std::max (c->m_GOPSize, (c->m_IntraPeriod == 0 && c->m_IntraPeriodSec > 0 ? (c->m_IntraPeriodSec * c->m_FrameRate) / c->m_FrameScale : c->m_IntraPeriod))));

  const int rcQP = (c->m_RCInitialQP > 0 ? std::min (vvenc::MAX_QP, c->m_RCInitialQP) : std::max (0, vvenc::MAX_QP_INIT_QPA - (c->m_FirstPassMode > 2 ? 4 : 2) - int (0.5 + sqrt ((d * std::max (0, c->m_RCTargetBitrate)) / 500000.0))));

  // TODO 2.0: make this an error

  //vvenc_confirmParameter( c, c->m_RCTargetBitrate != VVENC_RC_OFF && c->m_QP != VVENC_AUTO_QP && c->m_QP != VVENC_DEFAULT_QP, "Rate-control and QP based encoding are mutually exclusive!" );

  if( c->m_RCTargetBitrate != VVENC_RC_OFF && c->m_QP != VVENC_AUTO_QP && c->m_QP != rcQP )

  {

    if( c->m_QP != VVENC_DEFAULT_QP )

      msg.log( VVENC_WARNING, "Configuration warning: Rate control is enabled since a target bitrate is specified, ignoring QP value\n\n" );

    c->m_QP = VVENC_AUTO_QP;

  }

  if( c->m_QP == VVENC_AUTO_QP ) c->m_QP = ( c->m_RCTargetBitrate != VVENC_RC_OFF ? rcQP : VVENC_DEFAULT_QP );

  vvenc_confirmParameter( c, c->m_RCTargetBitrate == VVENC_RC_OFF && ( c->m_QP < 0 || c->m_QP > vvenc::MAX_QP ), "QP exceeds supported range (0 to 63)" );

  vvenc_confirmParameter( c, c->m_RCTargetBitrate != VVENC_RC_OFF && ( c->m_RCTargetBitrate < 0 || c->m_RCTargetBitrate > 800000000 ),  "TargetBitrate must be between 0 and 800000000" );

  vvenc_confirmParameter( c, c->m_RCTargetBitrate != VVENC_RC_OFF && (int64_t) c->m_RCMaxBitrate * 2 < (int64_t) c->m_RCTargetBitrate * 3, "MaxBitrate must be at least 1.5*TargetBitrate" );

  vvenc_confirmParameter( c, c->m_RCTargetBitrate != VVENC_RC_OFF && ( c->m_FirstPassMode < 0 || c->m_FirstPassMode > 4 ), "FirstPassMode must be 0, 1, 2, 3, or 4" );

  if( c->m_RCTargetBitrate == VVENC_RC_OFF && c->m_RCMaxBitrate > 0 )

  {

    bool mbrLowErr = ( (double)c->m_RCMaxBitrate < f * sqrt(c->m_FrameRate / (c->m_FrameScale * d)) );

    vvenc_confirmParameter( c, mbrLowErr, "Capped CQF is used and MaxBitrate is too low for specified Intra period and frame rate/scale" );

    if( ! mbrLowErr && c->m_RCMaxBitrate * std::max (3.0, d) < 18000.0 * pow (2.0, 15.323 - c->m_QP / 4.516) ) // one fifth of ICIP24 paper function

    {

      msg.log( VVENC_WARNING, "Configuration warning: Capped CQF is used and MaxBitrate is very low for specified QP! Increase MaxBitrate to improve visual quality.\n\n" );

    }

  }

  if ( c->m_internChromaFormat < 0 || c->m_internChromaFormat >= VVENC_NUM_CHROMA_FORMAT )

  {

    c->m_internChromaFormat = VVENC_CHROMA_420;

  }

  if( c->m_profile == vvencProfile::VVENC_PROFILE_AUTO )

  {

    const int maxBitDepth= std::max(c->m_internalBitDepth[0], c->m_internalBitDepth[c->m_internChromaFormat==vvencChromaFormat::VVENC_CHROMA_400 ? 0 : 1]);

    if (c->m_internChromaFormat==vvencChromaFormat::VVENC_CHROMA_400 || c->m_internChromaFormat==vvencChromaFormat::VVENC_CHROMA_420)

    {

      if (maxBitDepth<=10)

      {

        c->m_profile=vvencProfile::VVENC_MAIN_10;

      }

    }

    else if (c->m_internChromaFormat==vvencChromaFormat::VVENC_CHROMA_422 || c->m_internChromaFormat==vvencChromaFormat::VVENC_CHROMA_444)

    {

      if (maxBitDepth<=10)

      {