/*****************************************************************************

 * Copyright (C) 2013-2020 MulticoreWare, Inc

 *

 * Authors: Sumalatha Polureddy <sumalatha@multicorewareinc.com>

 *          Aarthi Priya Thirumalai <aarthi@multicorewareinc.com>

 *          Xun Xu, PPLive Corporation <xunxu@pptv.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

 *

 * This program is also available under a commercial proprietary license.

 * For more information, contact us at license @ x265.com.

 *****************************************************************************/

#if _MSC_VER

#pragma warning(disable: 4127) // conditional expression is constant, yes I know

#endif

#include "common.h"

#include "param.h"

#include "frame.h"

#include "framedata.h"

#include "picyuv.h"

#include "encoder.h"

#include "slicetype.h"

#include "ratecontrol.h"

#include "sei.h"

#define BR_SHIFT  6

#define CPB_SHIFT 4

#define SHARED_DATA_ALIGNMENT      4 ///< 4btye, 32bit

#define CUTREE_SHARED_MEM_NAME     "cutree"

#define GOP_CNT_CU_TREE            3

using namespace X265_NS;

/* Amortize the partial cost of I frames over the next N frames */

const int RateControl::s_slidingWindowFrames = 20;

const char *RateControl::s_defaultStatFileName = "x265_2pass.log";

namespace {

#define CMP_OPT_FIRST_PASS(opt, param_val)\

{\

    bErr = 0;\

    p = strstr(opts, opt "=");\

    char* q = strstr(opts, "no-" opt " ");\

    if (p && sscanf(p, opt "=%d" , &i) && param_val != i)\

        bErr = 1;\

    else if (!param_val && !q && !p)\

        bErr = 1;\

    else if (param_val && (q || !strstr(opts, opt)))\

        bErr = 1;\

    if (bErr)\

    {\

        x265_log(m_param, X265_LOG_ERROR, "different " opt " setting than first pass (%d vs %d)\n", param_val, i);\

        return false;\

    }\

}

inline int calcScale(uint32_t x)

{

    static uint8_t lut[16] = {4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0};

    int y, z = (((x & 0xffff) - 1) >> 27) & 16;

    x >>= z;

    z += y = (((x & 0xff) - 1) >> 28) & 8;

    x >>= y;

    z += y = (((x & 0xf) - 1) >> 29) & 4;

    x >>= y;

    return z + lut[x&0xf];

}

inline int calcLength(uint32_t x)

{

    static uint8_t lut[16] = {4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};

    int y, z = (((x >> 16) - 1) >> 27) & 16;

    x >>= z ^ 16;

    z += y = ((x - 0x100) >> 28) & 8;

    x >>= y ^ 8;

    z += y = ((x - 0x10) >> 29) & 4;

    x >>= y ^ 4;

    return z + lut[x];

}

inline char *strcatFilename(const char *input, const char *suffix)

{

    char *output = X265_MALLOC(char, strlen(input) + strlen(suffix) + 1);

    if (!output)

    {

        x265_log(NULL, X265_LOG_ERROR, "unable to allocate memory for filename\n");

        return NULL;

    }

    strcpy(output, input);

    strcat(output, suffix);

    return output;

}

typedef struct CUTreeSharedDataItem

{

    uint8_t  *type;

    uint16_t *stats;

}CUTreeSharedDataItem;

void static ReadSharedCUTreeData(void *dst, void *src, int32_t size)

{

    CUTreeSharedDataItem *statsDst = reinterpret_cast<CUTreeSharedDataItem *>(dst);

    uint8_t *typeSrc = reinterpret_cast<uint8_t *>(src);

    *statsDst->type = *typeSrc;

    ///< for memory alignment, the type will take 32bit in the shared memory

    int32_t offset = (sizeof(*statsDst->type) + SHARED_DATA_ALIGNMENT - 1) & ~(SHARED_DATA_ALIGNMENT - 1);

    uint16_t *statsSrc = reinterpret_cast<uint16_t *>(typeSrc + offset);

    memcpy(statsDst->stats, statsSrc, size - offset);

}

void static WriteSharedCUTreeData(void *dst, void *src, int32_t size)

{

    CUTreeSharedDataItem *statsSrc = reinterpret_cast<CUTreeSharedDataItem *>(src);

    uint8_t *typeDst = reinterpret_cast<uint8_t *>(dst);

    *typeDst = *statsSrc->type;

    ///< for memory alignment, the type will take 32bit in the shared memory

    int32_t offset = (sizeof(*statsSrc->type) + SHARED_DATA_ALIGNMENT - 1) & ~(SHARED_DATA_ALIGNMENT - 1);

    uint16_t *statsDst = reinterpret_cast<uint16_t *>(typeDst + offset);

    memcpy(statsDst, statsSrc->stats, size - offset);

}

inline double qScale2bits(RateControlEntry *rce, double qScale)

{

    if (qScale < 0.1)

        qScale = 0.1;

    return (rce->coeffBits + .1) * pow(rce->qScale / qScale, 1.1)

           + rce->mvBits * pow(X265_MAX(rce->qScale, 1) / X265_MAX(qScale, 1), 0.5)

           + rce->miscBits;

}

inline void copyRceData(RateControlEntry* rce, RateControlEntry* rce2Pass)

{

    rce->coeffBits = rce2Pass->coeffBits;

    rce->mvBits = rce2Pass->mvBits;

    rce->miscBits = rce2Pass->miscBits;

    rce->iCuCount = rce2Pass->iCuCount;

    rce->pCuCount = rce2Pass->pCuCount;

    rce->skipCuCount = rce2Pass->skipCuCount;

    rce->keptAsRef = rce2Pass->keptAsRef;

    rce->qScale = rce2Pass->qScale;

    rce->newQScale = rce2Pass->newQScale;

    rce->expectedBits = rce2Pass->expectedBits;

    rce->expectedVbv = rce2Pass->expectedVbv;

    rce->blurredComplexity = rce2Pass->blurredComplexity;

    rce->sliceType = rce2Pass->sliceType;

    rce->qpNoVbv = rce2Pass->qpNoVbv;

    rce->newQp = rce2Pass->newQp;

    rce->qRceq = rce2Pass->qRceq;

}

}  // end anonymous namespace

/* Returns the zone for the current frame */

x265_zone* RateControl::getZone()

{

    for (int i = m_param->rc.zoneCount - 1; i >= 0; i--)

    {

        x265_zone *z = &m_param->rc.zones[i];

        if (m_framesDone + 1 >= z->startFrame && m_framesDone < z->endFrame)

            return z;

    }

    return NULL;

}

RateControl::RateControl(x265_param& p, Encoder *top)

{

    m_param = &p;

    m_top = top;

    int lowresCuWidth = ((m_param->sourceWidth / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;

    int lowresCuHeight = ((m_param->sourceHeight / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;

    m_ncu = lowresCuWidth * lowresCuHeight;

    m_qCompress = (m_param->rc.cuTree && !m_param->rc.hevcAq) ? 1 : m_param->rc.qCompress;

    // validate for param->rc, maybe it is need to add a function like x265_parameters_valiate()

    m_zoneBufferIdx = 0;

    m_residualFrames = 0;

    m_partialResidualFrames = 0;

    m_residualCost = 0;

    m_partialResidualCost = 0;

    m_rateFactorMaxIncrement = 0;

    m_rateFactorMaxDecrement = 0;

    m_fps = (double)m_param->fpsNum / m_param->fpsDenom;

    m_startEndOrder.set(0);

    m_bTerminated = false;

    m_finalFrameCount = 0;

    m_numEntries = 0;

    m_isSceneTransition = false;

    m_lastPredictorReset = 0;

    m_avgPFrameQp = 0;

    m_isFirstMiniGop = false;

    m_lastScenecut = -1;

    m_lastScenecutAwareIFrame = -1;

    m_totalFrames = -1;

    if (m_param->rc.rateControlMode == X265_RC_CRF)

    {

        m_param->rc.qp = (int)m_param->rc.rfConstant;

        m_param->rc.bitrate = 0;

        double baseCplx = m_ncu * (m_param->bframes ? 120 : 80);

        double mbtree_offset = m_param->rc.cuTree ? (1.0 - m_param->rc.qCompress) * 13.5 : 0;

        m_rateFactorConstant = pow(baseCplx, 1 - m_qCompress) /

            x265_qp2qScale(m_param->rc.rfConstant + mbtree_offset);

        if (m_param->rc.rfConstantMax)

        {

            m_rateFactorMaxIncrement = m_param->rc.rfConstantMax - m_param->rc.rfConstant;

            if (m_rateFactorMaxIncrement <= 0)

            {

                x265_log(m_param, X265_LOG_WARNING, "CRF max must be greater than CRF\n");

                m_rateFactorMaxIncrement = 0;

            }

        }

        if (m_param->rc.rfConstantMin)

            m_rateFactorMaxDecrement = m_param->rc.rfConstant - m_param->rc.rfConstantMin;

    }

    m_isAbr = m_param->rc.rateControlMode != X265_RC_CQP && !m_param->rc.bStatRead;

    m_2pass = m_param->rc.rateControlMode != X265_RC_CQP && m_param->rc.bStatRead;

    m_bitrate = m_param->rc.bitrate * 1000;

    m_frameDuration = (double)m_param->fpsDenom / m_param->fpsNum;

    m_qp = m_param->rc.qp;

    m_lastRceq = 1; /* handles the cmplxrsum when the previous frame cost is zero */

    m_shortTermCplxSum = 0;

    m_shortTermCplxCount = 0;

    m_lastNonBPictType = I_SLICE;

    m_isAbrReset = false;

    m_lastAbrResetPoc = -1;

    m_statFileOut = NULL;

    m_cutreeStatFileOut = m_cutreeStatFileIn = NULL;

    m_cutreeShrMem = NULL;

    m_rce2Pass = NULL;

    m_encOrder = NULL;

    m_lastBsliceSatdCost = 0;

    m_movingAvgSum = 0.0;

    m_isNextGop = false;

    m_relativeComplexity = NULL;

    // vbv initialization

    m_param->rc.vbvBufferSize = x265_clip3(0, 8000000, m_param->rc.vbvBufferSize);

    m_param->rc.vbvMaxBitrate = x265_clip3(0, 8000000, m_param->rc.vbvMaxBitrate);

    m_param->rc.vbvBufferInit = x265_clip3(0.0, 8000000.0, m_param->rc.vbvBufferInit);

    m_param->vbvBufferEnd = x265_clip3(0.0, 8000000.0, m_param->vbvBufferEnd);

    m_initVbv = false;

    m_singleFrameVbv = 0;

    m_rateTolerance = 1.0;

    m_encodedSegmentBits = 0;

    m_segDur = 0;

    if (m_param->rc.vbvBufferSize)

    {

        if (m_param->rc.rateControlMode == X265_RC_CQP)

        {

            x265_log(m_param, X265_LOG_WARNING, "VBV is incompatible with constant QP, ignored.\n");

            m_param->rc.vbvBufferSize = 0;

            m_param->rc.vbvMaxBitrate = 0;

        }

        else if (m_param->rc.vbvMaxBitrate == 0)

        {

            if (m_param->rc.rateControlMode == X265_RC_ABR)

            {

                x265_log(m_param, X265_LOG_WARNING, "VBV maxrate unspecified, assuming CBR\n");

                m_param->rc.vbvMaxBitrate = m_param->rc.bitrate;

            }

            else

            {

                x265_log(m_param, X265_LOG_WARNING, "VBV bufsize set but maxrate unspecified, ignored\n");

                m_param->rc.vbvBufferSize = 0;

            }

        }

        else if (m_param->rc.vbvMaxBitrate < m_param->rc.bitrate &&

                 m_param->rc.rateControlMode == X265_RC_ABR)

        {

            x265_log(m_param, X265_LOG_WARNING, "max bitrate less than average bitrate, assuming CBR\n");

            m_param->rc.bitrate = m_param->rc.vbvMaxBitrate;

        }

    }

    else if (m_param->rc.vbvMaxBitrate)

    {

        x265_log(m_param, X265_LOG_WARNING, "VBV maxrate specified, but no bufsize, ignored\n");

        m_param->rc.vbvMaxBitrate = 0;

    }

    m_isVbv = m_param->rc.vbvMaxBitrate > 0 && m_param->rc.vbvBufferSize > 0;

    if (m_param->vbvBufferEnd && !m_isVbv)

    {

        x265_log(m_param, X265_LOG_WARNING, "vbv-end requires VBV parameters, ignored\n");

        m_param->vbvBufferEnd = 0;

    }

    if (m_param->bEmitHRDSEI && !m_isVbv)

    {

        x265_log(m_param, X265_LOG_WARNING, "NAL HRD parameters require VBV parameters, ignored\n");

        m_param->bEmitHRDSEI = 0;

    }

    m_isCbr = m_param->rc.rateControlMode == X265_RC_ABR && m_isVbv && m_param->rc.vbvMaxBitrate <= m_param->rc.bitrate;

    if (m_param->rc.bStrictCbr && !m_isCbr)

    {

        x265_log(m_param, X265_LOG_WARNING, "strict CBR set without CBR mode, ignored\n");

        m_param->rc.bStrictCbr = 0;

    }

    if(m_param->rc.bStrictCbr)

        m_rateTolerance = 0.7;

    m_bframeBits = 0;

    m_leadingNoBSatd = 0;

    m_ipOffset = 6.0 * X265_LOG2(m_param->rc.ipFactor);

    m_pbOffset = 6.0 * X265_LOG2(m_param->rc.pbFactor);

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

        m_qpToEncodedBits[i] = 0;

    /* Adjust the first frame in order to stabilize the quality level compared to the rest */

#define ABR_INIT_QP_MIN (24)

#define ABR_INIT_QP_MAX (37)

#define ABR_INIT_QP_GRAIN_MAX (33)

#define ABR_SCENECUT_INIT_QP_MIN (12)

#define CRF_INIT_QP (int)m_param->rc.rfConstant

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

    {

        m_lastQScaleFor[i] = x265_qp2qScale(m_param->rc.rateControlMode == X265_RC_CRF ? CRF_INIT_QP : ABR_INIT_QP_MIN);

        m_lmin[i] = x265_qp2qScale(m_param->rc.qpMin);

        m_lmax[i] = x265_qp2qScale(m_param->rc.qpMax);

    }

    if (m_param->rc.rateControlMode == X265_RC_CQP)

    {

        if (m_qp && !m_param->bLossless)

        {

            m_qpConstant[P_SLICE] = m_qp;

            m_qpConstant[I_SLICE] = x265_clip3(QP_MIN, QP_MAX_MAX, (int)(m_qp - m_ipOffset + 0.5));

            m_qpConstant[B_SLICE] = x265_clip3(QP_MIN, QP_MAX_MAX, (int)(m_qp + m_pbOffset + 0.5));

        }

        else

        {

            m_qpConstant[P_SLICE] = m_qpConstant[I_SLICE] = m_qpConstant[B_SLICE] = m_qp;

        }

    }

    m_bRcReConfig = false;

    /* qpstep - value set as encoder specific */

    m_lstep = pow(2, m_param->rc.qpStep / 6.0);

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

        m_cuTreeStats.qpBuffer[i] = NULL;

}

bool RateControl::initCUTreeSharedMem()

{

    if (!m_cutreeShrMem) {

        m_cutreeShrMem = new RingMem();

        if (!m_cutreeShrMem)

        {

            return false;

        }

        ///< now cutree data form at most 3 gops would be stored in the shared memory at the same time

        int32_t itemSize = (sizeof(uint8_t) + SHARED_DATA_ALIGNMENT - 1) & ~(SHARED_DATA_ALIGNMENT - 1);

        if (m_param->rc.qgSize == 8)

        {

            itemSize += sizeof(uint16_t) * m_ncu * 4;

        }

        else

        {

            itemSize += sizeof(uint16_t) * m_ncu;

        }

        int32_t itemCnt = X265_MIN(m_param->keyframeMax, (int)(m_fps + 0.5));

        itemCnt *= GOP_CNT_CU_TREE;

        char shrname[MAX_SHR_NAME_LEN] = { 0 };

        strcpy(shrname, m_param->rc.sharedMemName);

        strcat(shrname, CUTREE_SHARED_MEM_NAME);

        if (!m_cutreeShrMem->init(itemSize, itemCnt, shrname))

        {

            return false;

        }

    }

    return true;

}

void RateControl::initVBV(const SPS& sps)

{

    /* We don't support changing the ABR bitrate right now,

 * so if the stream starts as CBR, keep it CBR. */

    if (m_param->rc.vbvBufferSize < (int)(m_param->rc.vbvMaxBitrate / m_fps))

    {

        m_param->rc.vbvBufferSize = (int)(m_param->rc.vbvMaxBitrate / m_fps);

        x265_log(m_param, X265_LOG_WARNING, "VBV buffer size cannot be smaller than one frame, using %d kbit\n",

            m_param->rc.vbvBufferSize);

    }

    int vbvBufferSize = m_param->rc.vbvBufferSize * 1000;

    int vbvMaxBitrate = m_param->rc.vbvMaxBitrate * 1000;

    if (m_param->bEmitHRDSEI && !m_param->decoderVbvMaxRate)

    {

        const HRDInfo* hrd = &sps.vuiParameters.hrdParameters;

        vbvBufferSize = hrd->cpbSizeValue << (hrd->cpbSizeScale + CPB_SHIFT);

        vbvMaxBitrate = hrd->bitRateValue << (hrd->bitRateScale + BR_SHIFT);

    }

    m_bufferRate = vbvMaxBitrate / m_fps;

    m_vbvMaxRate = vbvMaxBitrate;

    m_bufferSize = vbvBufferSize;

    m_singleFrameVbv = m_bufferRate * 1.1 > m_bufferSize;

    if (m_param->rc.vbvBufferInit > 1.)

        m_param->rc.vbvBufferInit = x265_clip3(0.0, 1.0, m_param->rc.vbvBufferInit / m_param->rc.vbvBufferSize);

    if (m_param->vbvBufferEnd > 1.)

        m_param->vbvBufferEnd = x265_clip3(0.0, 1.0, m_param->vbvBufferEnd / m_param->rc.vbvBufferSize);

    if (m_param->vbvEndFrameAdjust > 1.)

        m_param->vbvEndFrameAdjust = x265_clip3(0.0, 1.0, m_param->vbvEndFrameAdjust);

    m_param->rc.vbvBufferInit = x265_clip3(0.0, 1.0, X265_MAX(m_param->rc.vbvBufferInit, m_bufferRate / m_bufferSize));

    m_bufferFillFinal = m_bufferSize * m_param->rc.vbvBufferInit;

    m_bufferFillActual = m_bufferFillFinal;

    m_bufferExcess = 0;

    m_minBufferFill = m_param->minVbvFullness / 100;

    m_maxBufferFill = 1 - (m_param->maxVbvFullness / 100);

    m_initVbv = true;

}

bool RateControl::init(const SPS& sps)

{

    if (m_isVbv && !m_initVbv)

        initVBV(sps);

    if (!m_param->bResetZoneConfig && (m_relativeComplexity == NULL))

    {

        m_relativeComplexity = X265_MALLOC(double, m_param->reconfigWindowSize);

        if (m_relativeComplexity == NULL)

        {

            x265_log(m_param, X265_LOG_ERROR, "Failed to allocate memory for m_relativeComplexity\n");

            return false;

        }

    }

    m_totalBits = 0;

    m_encodedBits = 0;

    m_encodedSegmentBits = 0;

    m_framesDone = 0;

    m_segDur = 0;

    m_residualCost = 0;

    m_partialResidualCost = 0;

    m_amortizeFraction = 0.85;

    m_amortizeFrames = 75;

    m_bRcReConfig = false;

    if (m_param->totalFrames && m_param->totalFrames <= 2 * m_fps && m_param->rc.bStrictCbr) /* Strict CBR segment encode */

    {

        m_amortizeFraction = 0.85;

        m_amortizeFrames = m_param->totalFrames / 2;

    }

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

    {

        m_satdCostWindow[i] = 0;

        m_encodedBitsWindow[i] = 0;

    }

    m_sliderPos = 0;

    m_isPatternPresent = false;

    m_numBframesInPattern = 0;

    m_isGrainEnabled = false;

    if(m_param->rc.bEnableGrain) // tune for grainy content OR equal p-b frame sizes

        m_isGrainEnabled = true;

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

        m_lastQScaleFor[i] = x265_qp2qScale(m_param->rc.rateControlMode == X265_RC_CRF ? CRF_INIT_QP : ABR_INIT_QP_MIN);

    m_avgPFrameQp = 0 ;

    /* 720p videos seem to be a good cutoff for cplxrSum */

    double tuneCplxFactor = (m_ncu > 3600 && m_param->rc.cuTree && !m_param->rc.hevcAq) ? 2.5 : m_param->rc.hevcAq ? 1.5 : m_isGrainEnabled ? 1.9 : 1.0;

    /* estimated ratio that produces a reasonable QP for the first I-frame */

    m_cplxrSum = .01 * pow(7.0e5, m_qCompress) * pow(m_ncu, 0.5) * tuneCplxFactor;

    m_wantedBitsWindow = m_bitrate * m_frameDuration;

    m_accumPNorm = .01;

    m_accumPQp = (m_param->rc.rateControlMode == X265_RC_CRF ? CRF_INIT_QP : ABR_INIT_QP_MIN) * m_accumPNorm;

    /* Frame Predictors used in vbv */

    initFramePredictors();

    if (!m_statFileOut && (m_param->rc.bStatWrite || m_param->rc.bStatRead))

    {

        /* If the user hasn't defined the stat filename, use the default value */

        const char *fileName = m_param->rc.statFileName;

        if (!strlen(fileName))

            fileName = s_defaultStatFileName;

        /* Load stat file and init 2pass algo */

        if (m_param->rc.bStatRead)

        {

            if (X265_SHARE_MODE_FILE == m_param->rc.dataShareMode)

            {

                m_expectedBitsSum = 0;

                char *p, *statsIn, *statsBuf;

                /* read 1st pass stats */

                statsIn = statsBuf = x265_slurp_file(fileName);

                if (!statsBuf)

                    return false;

                if (m_param->rc.cuTree)

                {

                    char *tmpFile = strcatFilename(fileName, ".cutree");

                    if (!tmpFile)

                        return false;

                    m_cutreeStatFileIn = x265_fopen(tmpFile, "rb");

                    X265_FREE(tmpFile);

                    if (!m_cutreeStatFileIn)

                    {

                        x265_log_file(m_param, X265_LOG_ERROR, "can't open stats file %s.cutree\n", fileName);

                        return false;

                    }

                }

                /* check whether 1st pass options were compatible with current options */

                if (strncmp(statsBuf, "#options:", 9))

                {

                    x265_log(m_param, X265_LOG_ERROR, "options list in stats file not valid\n");

                    return false;

                }

                {

                    int i, j, m;

                    uint32_t k, l;

                    bool bErr = false;

                    char *opts = statsBuf;

                    statsIn = strchr(statsBuf, '\n');

                    if (!statsIn)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "Malformed stats file\n");

                        return false;

                    }

                    *statsIn = '\0';

                    statsIn++;

                    if ((p = strstr(opts, " input-res=")) == 0 || sscanf(p, " input-res=%dx%d", &i, &j) != 2)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "Resolution specified in stats file not valid\n");

                        return false;

                    }

                    if ((p = strstr(opts, " fps=")) == 0 || sscanf(p, " fps=%u/%u", &k, &l) != 2)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "fps specified in stats file not valid\n");

                        return false;

                    }

                    if (((p = strstr(opts, " vbv-maxrate=")) == 0 || sscanf(p, " vbv-maxrate=%d", &m) != 1) && m_param->rc.rateControlMode == X265_RC_CRF)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "Constant rate-factor is incompatible with 2pass without vbv-maxrate in the previous pass\n");

                        return false;

                    }

                    if (k != m_param->fpsNum || l != m_param->fpsDenom)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "fps mismatch with 1st pass (%u/%u vs %u/%u)\n",

                            m_param->fpsNum, m_param->fpsDenom, k, l);

                        return false;

                    }

                    if (m_param->analysisMultiPassRefine)

                    {

                        p = strstr(opts, "ref=");

                        sscanf(p, "ref=%d", &i);

                        if (i > m_param->maxNumReferences)

                        {

                            x265_log(m_param, X265_LOG_ERROR, "maxNumReferences cannot be less than 1st pass (%d vs %d)\n",

                                i, m_param->maxNumReferences);

                            return false;

                        }

                    }

                    if (m_param->analysisMultiPassRefine || m_param->analysisMultiPassDistortion)

                    {

                        p = strstr(opts, "ctu=");

                        sscanf(p, "ctu=%u", &k);

                        if (k != m_param->maxCUSize)

                        {

                            x265_log(m_param, X265_LOG_ERROR, "maxCUSize mismatch with 1st pass (%u vs %u)\n",

                                k, m_param->maxCUSize);

                            return false;

                        }

                    }

                    CMP_OPT_FIRST_PASS("bitdepth", m_param->internalBitDepth);

                    CMP_OPT_FIRST_PASS("weightp", m_param->bEnableWeightedPred);

                    CMP_OPT_FIRST_PASS("bframes", m_param->bframes);

                    CMP_OPT_FIRST_PASS("b-pyramid", m_param->bBPyramid);

                    CMP_OPT_FIRST_PASS("open-gop", m_param->bOpenGOP);

                    CMP_OPT_FIRST_PASS(" keyint", m_param->keyframeMax);

                    CMP_OPT_FIRST_PASS("scenecut", m_param->scenecutThreshold);

                    CMP_OPT_FIRST_PASS("intra-refresh", m_param->bIntraRefresh);

                    CMP_OPT_FIRST_PASS("frame-dup", m_param->bEnableFrameDuplication);

                    if (m_param->bMultiPassOptRPS)

                    {

                        CMP_OPT_FIRST_PASS("multi-pass-opt-rps", m_param->bMultiPassOptRPS);

                        CMP_OPT_FIRST_PASS("repeat-headers", m_param->bRepeatHeaders);

                        CMP_OPT_FIRST_PASS("min-keyint", m_param->keyframeMin);

                    }

                    if ((p = strstr(opts, "b-adapt=")) != 0 && sscanf(p, "b-adapt=%d", &i) && i >= X265_B_ADAPT_NONE && i <= X265_B_ADAPT_TRELLIS)

                    {

                        m_param->bFrameAdaptive = i;

                    }

                    else if (m_param->bframes)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "b-adapt method specified in stats file not valid\n");

                        return false;

                    }

                    if ((p = strstr(opts, "rc-lookahead=")) != 0 && sscanf(p, "rc-lookahead=%d", &i))

                        m_param->lookaheadDepth = i;

                }

                /* find number of pics */

                p = statsIn;

                int numEntries;

                for (numEntries = -1; p; numEntries++)

                    p = strchr(p + 1, ';');

                if (!numEntries)

                {

                    x265_log(m_param, X265_LOG_ERROR, "empty stats file\n");

                    return false;

                }

                m_numEntries = numEntries;

                if (m_param->totalFrames < m_numEntries && m_param->totalFrames > 0)

                {

                    x265_log(m_param, X265_LOG_WARNING, "2nd pass has fewer frames than 1st pass (%d vs %d)\n",

                        m_param->totalFrames, m_numEntries);

                }

                if (m_param->totalFrames > m_numEntries && !m_param->bEnableFrameDuplication)

                {

                    x265_log(m_param, X265_LOG_ERROR, "2nd pass has more frames than 1st pass (%d vs %d)\n",

                        m_param->totalFrames, m_numEntries);

                    return false;

                }

                m_rce2Pass = X265_MALLOC(RateControlEntry, m_numEntries);

                if (!m_rce2Pass)

                {

                    x265_log(m_param, X265_LOG_ERROR, "Rce Entries for 2 pass cannot be allocated\n");

                    return false;

                }

                m_encOrder = X265_MALLOC(int, m_numEntries);

                if (!m_encOrder)

                {

                    x265_log(m_param, X265_LOG_ERROR, "Encode order for 2 pass cannot be allocated\n");

                    return false;

                }

                /* init all to skipped p frames */

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

                {

                    RateControlEntry *rce = &m_rce2Pass[i];

                    rce->sliceType = P_SLICE;

                    rce->qScale = rce->newQScale = x265_qp2qScale(20);

                    rce->miscBits = m_ncu + 10;

                    rce->newQp = 0;

                }

                /* read stats */

                p = statsIn;

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

                {

                    RateControlEntry *rce, *rcePocOrder;

                    int frameNumber;

                    int encodeOrder;

                    char picType;

                    int e;

                    char *next;

                    double qpRc, qpAq, qNoVbv, qRceq;

                    next = strstr(p, ";");

                    if (next)

                        *next++ = 0;

                    e = sscanf(p, " in:%d out:%d", &frameNumber, &encodeOrder);

                    if (frameNumber < 0 || frameNumber >= m_numEntries)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "bad frame number (%d) at stats line %d\n", frameNumber, i);

                        return false;

                    }

                    rce = &m_rce2Pass[encodeOrder];

                    rcePocOrder = &m_rce2Pass[frameNumber];

                    m_encOrder[frameNumber] = encodeOrder;

                    if (!m_param->bMultiPassOptRPS)

                    {

                        int scenecut = 0;

                        e += sscanf(p, " in:%*d out:%*d type:%c q:%lf q-aq:%lf q-noVbv:%lf q-Rceq:%lf tex:%d mv:%d misc:%d icu:%lf pcu:%lf scu:%lf sc:%d",

                            &picType, &qpRc, &qpAq, &qNoVbv, &qRceq, &rce->coeffBits,

                            &rce->mvBits, &rce->miscBits, &rce->iCuCount, &rce->pCuCount,

                            &rce->skipCuCount, &scenecut);

                        rcePocOrder->scenecut = scenecut != 0;

                    }

                    else

                    {

                        char deltaPOC[128];

                        char bUsed[40];

                        memset(deltaPOC, 0, sizeof(deltaPOC));

                        memset(bUsed, 0, sizeof(bUsed));

                        e += sscanf(p, " in:%*d out:%*d type:%c q:%lf q-aq:%lf q-noVbv:%lf q-Rceq:%lf tex:%d mv:%d misc:%d icu:%lf pcu:%lf scu:%lf nump:%d numnegp:%d numposp:%d deltapoc:%127s bused:%39s",

                            &picType, &qpRc, &qpAq, &qNoVbv, &qRceq, &rce->coeffBits,

                            &rce->mvBits, &rce->miscBits, &rce->iCuCount, &rce->pCuCount,

                            &rce->skipCuCount, &rce->rpsData.numberOfPictures, &rce->rpsData.numberOfNegativePictures, &rce->rpsData.numberOfPositivePictures, deltaPOC, bUsed);

                        splitdeltaPOC(deltaPOC, rce);

                        splitbUsed(bUsed, rce);

                        rce->rpsIdx = -1;

                    }

                    rce->keptAsRef = true;

                    rce->isIdr = false;

                    if (picType == 'b' || picType == 'p')

                        rce->keptAsRef = false;

                    if (picType == 'I')

                        rce->isIdr = true;

                    if (picType == 'I' || picType == 'i')

                        rce->sliceType = I_SLICE;

                    else if (picType == 'P' || picType == 'p')

                        rce->sliceType = P_SLICE;

                    else if (picType == 'B' || picType == 'b')

                        rce->sliceType = B_SLICE;

                    else

                        e = -1;

                    if (e < 10)

                    {

                        x265_log(m_param, X265_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e);

                        return false;

                    }

                    rce->qScale = rce->newQScale = x265_qp2qScale(qpRc);

                    rce->qpNoVbv = qNoVbv;

                    rce->qpaRc = qpRc;

                    rce->qpAq = qpAq;

                    rce->qRceq = qRceq;

                    p = next;

                }

                X265_FREE(statsBuf);

                if (m_param->rc.rateControlMode != X265_RC_CQP)

                {

                    m_start = 0;

                    m_isQpModified = true;

                    if (!initPass2())

                        return false;

                } /* else we're using constant quant, so no need to run the bitrate allocation */

            }

            else // X265_SHARE_MODE_SHAREDMEM == m_param->rc.dataShareMode

            {

                if (m_param->rc.cuTree)

                {

                    if (!initCUTreeSharedMem())

                    {

                        return false;

                    }

                }

            }

        }

        /* Open output file */

        /* If input and output files are the same, output to a temp file

         * and move it to the real name only when it's complete */

        if (m_param->rc.bStatWrite)

        {

            char *p, *statFileTmpname;

            statFileTmpname = strcatFilename(fileName, ".temp");

            if (!statFileTmpname)

                return false;

            m_statFileOut = x265_fopen(statFileTmpname, "wb");

            X265_FREE(statFileTmpname);

            if (!m_statFileOut)

            {

                x265_log_file(m_param, X265_LOG_ERROR, "can't open stats file %s.temp\n", fileName);

                return false;

            }

            p = x265_param2string(m_param, sps.conformanceWindow.rightOffset, sps.conformanceWindow.bottomOffset);

            if (p)

                fprintf(m_statFileOut, "#options: %s\n", p);

            X265_FREE(p);

            if (m_param->rc.cuTree && !m_param->rc.bStatRead)

            {

                if (X265_SHARE_MODE_FILE == m_param->rc.dataShareMode)

                {

                    statFileTmpname = strcatFilename(fileName, ".cutree.temp");

                    if (!statFileTmpname)

                        return false;

                    m_cutreeStatFileOut = x265_fopen(statFileTmpname, "wb");

                    X265_FREE(statFileTmpname);

                    if (!m_cutreeStatFileOut)

                    {

                        x265_log_file(m_param, X265_LOG_ERROR, "can't open mbtree stats file %s.cutree.temp\n", fileName);

                        return false;

                    }

                }

                else // X265_SHARE_MODE_SHAREDMEM == m_param->rc.dataShareMode

                {

                    if (!initCUTreeSharedMem())

                    {

                        return false;

                    }

                }

            }

        }

        if (m_param->rc.cuTree && !m_cuTreeStats.qpBuffer[0])

        {

            if (m_param->rc.qgSize == 8)

            {

                m_cuTreeStats.qpBuffer[0] = X265_MALLOC(uint16_t, m_ncu * 4 * sizeof(uint16_t));

                if (m_param->bBPyramid && m_param->rc.bStatRead)

                    m_cuTreeStats.qpBuffer[1] = X265_MALLOC(uint16_t, m_ncu * 4 * sizeof(uint16_t));

            }

            else

            {

                m_cuTreeStats.qpBuffer[0] = X265_MALLOC(uint16_t, m_ncu * sizeof(uint16_t));

                if (m_param->bBPyramid && m_param->rc.bStatRead)

                    m_cuTreeStats.qpBuffer[1] = X265_MALLOC(uint16_t, m_ncu * sizeof(uint16_t));

            }

            m_cuTreeStats.qpBufPos = -1;

        }

    }

    return true;

}

void RateControl::skipCUTreeSharedMemRead(int32_t cnt)

{

    m_cutreeShrMem->skipRead(cnt);

}

void RateControl::reconfigureRC()

{

    if (m_isVbv)

    {

        m_param->rc.vbvBufferSize = x265_clip3(0, 8000000, m_param->rc.vbvBufferSize);

        m_param->rc.vbvMaxBitrate = x265_clip3(0, 8000000, m_param->rc.vbvMaxBitrate);

        if (m_param->reconfigWindowSize)

            m_param->rc.vbvMaxBitrate = (int)(m_param->rc.vbvMaxBitrate * (double)(m_fps / m_param->reconfigWindowSize));