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

 * Copyright (C) 2013-2020 MulticoreWare, Inc

 *

 * Authors: Chung Shin Yee <shinyee@multicorewareinc.com>

 *          Min Chen <chenm003@163.com>

 *          Steve Borho <steve@borho.org>

 *

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

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

#include "common.h"

#include "frame.h"

#include "framedata.h"

#include "wavefront.h"

#include "param.h"

#include "encoder.h"

#include "frameencoder.h"

#include "common.h"

#include "slicetype.h"

#include "nal.h"

namespace X265_NS {

void weightAnalyse(Slice& slice, Frame& frame, x265_param& param);

FrameEncoder::FrameEncoder()

{

    m_prevOutputTime = x265_mdate();

    m_reconfigure = false;

    m_isFrameEncoder = true;

    m_threadActive = true;

    m_slicetypeWaitTime = 0;

    m_activeWorkerCount = 0;

    m_completionCount = 0;

    m_bAllRowsStop = false;

    m_vbvResetTriggerRow = -1;

    m_outStreams = NULL;

    m_backupStreams = NULL;

    m_substreamSizes = NULL;

    m_nr = NULL;

    m_tld = NULL;

    m_rows = NULL;

    m_top = NULL;

    m_param = NULL;

    m_frame = NULL;

    m_cuGeoms = NULL;

    m_ctuGeomMap = NULL;

    m_localTldIdx = 0;

    memset(&m_rce, 0, sizeof(RateControlEntry));

}

void FrameEncoder::destroy()

{

    if (m_pool)

    {

        if (!m_jpId)

        {

            int numTLD = m_pool->m_numWorkers;

            if (!m_param->bEnableWavefront)

                numTLD += m_pool->m_numProviders;

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

                m_tld[i].destroy();

            delete [] m_tld;

        }

    }

    else

    {

        m_tld->destroy();

        delete m_tld;

    }

    delete[] m_rows;

    delete[] m_outStreams;

    delete[] m_backupStreams;

    X265_FREE(m_sliceBaseRow);

    X265_FREE(m_sliceMaxBlockRow);

    X265_FREE(m_cuGeoms);

    X265_FREE(m_ctuGeomMap);

    X265_FREE(m_substreamSizes);

    X265_FREE(m_nr);

    m_frameFilter.destroy();

    if (m_param->bEmitHRDSEI || !!m_param->interlaceMode)

    {

        delete m_rce.picTimingSEI;

        delete m_rce.hrdTiming;

    }

}

bool FrameEncoder::init(Encoder *top, int numRows, int numCols)

{

    m_top = top;

    m_param = top->m_param;

    m_numRows = numRows;

    m_numCols = numCols;

    m_reconfigure = false;

    m_filterRowDelay = ((m_param->bEnableSAO && m_param->bSaoNonDeblocked)

                        || (!m_param->bEnableLoopFilter && m_param->bEnableSAO)) ?

                        2 : (m_param->bEnableSAO || m_param->bEnableLoopFilter ? 1 : 0);

    m_filterRowDelayCus = m_filterRowDelay * numCols;

    m_rows = new CTURow[m_numRows];

    bool ok = !!m_numRows;

    m_sliceBaseRow = X265_MALLOC(uint32_t, m_param->maxSlices + 1);

    ok &= !!m_sliceBaseRow;

    m_sliceGroupSize = (uint16_t)(m_numRows + m_param->maxSlices - 1) / m_param->maxSlices;

    uint32_t sliceGroupSizeAccu = (m_numRows << 8) / m_param->maxSlices;    

    uint32_t rowSum = sliceGroupSizeAccu;

    uint32_t sidx = 0;

    for (uint32_t i = 0; i < m_numRows; i++)

    {

        const uint32_t rowRange = (rowSum >> 8);

        if ((i >= rowRange) & (sidx != m_param->maxSlices - 1))

        {

            rowSum += sliceGroupSizeAccu;

            m_sliceBaseRow[++sidx] = i;

        }

    }

    X265_CHECK(sidx < m_param->maxSlices, "sliceID check failed!");

    m_sliceBaseRow[0] = 0;

    m_sliceBaseRow[m_param->maxSlices] = m_numRows;

    m_sliceMaxBlockRow = X265_MALLOC(uint32_t, m_param->maxSlices + 1);

    ok &= !!m_sliceMaxBlockRow;

    uint32_t maxBlockRows = (m_param->sourceHeight + (16 - 1)) / 16;

    sliceGroupSizeAccu = (maxBlockRows << 8) / m_param->maxSlices;

    rowSum = sliceGroupSizeAccu;

    sidx = 0;

    for (uint32_t i = 0; i < maxBlockRows; i++)

    {

        const uint32_t rowRange = (rowSum >> 8);

        if ((i >= rowRange) & (sidx != m_param->maxSlices - 1))

        {

            rowSum += sliceGroupSizeAccu;

            m_sliceMaxBlockRow[++sidx] = i;

        }

    }

    m_sliceMaxBlockRow[0] = 0;

    m_sliceMaxBlockRow[m_param->maxSlices] = maxBlockRows;

    /* determine full motion search range */

    int range  = m_param->searchRange;       /* fpel search */

    range += !!(m_param->searchMethod < 2);  /* diamond/hex range check lag */

    range += NTAPS_LUMA / 2;                 /* subpel filter half-length */

    range += 2 + (MotionEstimate::hpelIterationCount(m_param->subpelRefine) + 1) / 2; /* subpel refine steps */

    m_refLagRows = /*(m_param->maxSlices > 1 ? 1 : 0) +*/ 1 + ((range + m_param->maxCUSize - 1) / m_param->maxCUSize);

    // NOTE: 2 times of numRows because both Encoder and Filter in same queue

    if (!WaveFront::init(m_numRows * 2))

    {

        x265_log(m_param, X265_LOG_ERROR, "unable to initialize wavefront queue\n");

        m_pool = NULL;

    }

    m_frameFilter.init(top, this, numRows, numCols);

    // initialize HRD parameters of SPS

    if (m_param->bEmitHRDSEI || !!m_param->interlaceMode)

    {

        m_rce.picTimingSEI = new SEIPictureTiming;

        m_rce.hrdTiming = new HRDTiming;

        ok &= m_rce.picTimingSEI && m_rce.hrdTiming;

    }

    if (m_param->noiseReductionIntra || m_param->noiseReductionInter)

        m_nr = X265_MALLOC(NoiseReduction, 1);

    if (m_nr)

        memset(m_nr, 0, sizeof(NoiseReduction));

    else

        m_param->noiseReductionIntra = m_param->noiseReductionInter = 0;

    // 7.4.7.1 - Ceil( Log2( PicSizeInCtbsY ) ) bits

    {

        unsigned long tmp;

        CLZ(tmp, (numRows * numCols - 1));

        m_sliceAddrBits = (uint16_t)(tmp + 1);

    }

    return ok;

}

/* Generate a complete list of unique geom sets for the current picture dimensions */

bool FrameEncoder::initializeGeoms()

{

    /* Geoms only vary between CTUs in the presence of picture edges */

    int maxCUSize = m_param->maxCUSize;

    int minCUSize = m_param->minCUSize;

    int heightRem = m_param->sourceHeight & (maxCUSize - 1);

    int widthRem = m_param->sourceWidth & (maxCUSize - 1);

    int allocGeoms = 1; // body

    if (heightRem && widthRem)

        allocGeoms = 4; // body, right, bottom, corner

    else if (heightRem || widthRem)

        allocGeoms = 2; // body, right or bottom

    m_ctuGeomMap = X265_MALLOC(uint32_t, m_numRows * m_numCols);

    m_cuGeoms = X265_MALLOC(CUGeom, allocGeoms * CUGeom::MAX_GEOMS);

    if (!m_cuGeoms || !m_ctuGeomMap)

        return false;

    // body

    CUData::calcCTUGeoms(maxCUSize, maxCUSize, maxCUSize, minCUSize, m_cuGeoms);

    memset(m_ctuGeomMap, 0, sizeof(uint32_t) * m_numRows * m_numCols);

    if (allocGeoms == 1)

        return true;

    int countGeoms = 1;

    if (widthRem)

    {

        // right

        CUData::calcCTUGeoms(widthRem, maxCUSize, maxCUSize, minCUSize, m_cuGeoms + countGeoms * CUGeom::MAX_GEOMS);

        for (uint32_t i = 0; i < m_numRows; i++)

        {

            uint32_t ctuAddr = m_numCols * (i + 1) - 1;

            m_ctuGeomMap[ctuAddr] = countGeoms * CUGeom::MAX_GEOMS;

        }

        countGeoms++;

    }

    if (heightRem)

    {

        // bottom

        CUData::calcCTUGeoms(maxCUSize, heightRem, maxCUSize, minCUSize, m_cuGeoms + countGeoms * CUGeom::MAX_GEOMS);

        for (uint32_t i = 0; i < m_numCols; i++)

        {

            uint32_t ctuAddr = m_numCols * (m_numRows - 1) + i;

            m_ctuGeomMap[ctuAddr] = countGeoms * CUGeom::MAX_GEOMS;

        }

        countGeoms++;

        if (widthRem)

        {

            // corner

            CUData::calcCTUGeoms(widthRem, heightRem, maxCUSize, minCUSize, m_cuGeoms + countGeoms * CUGeom::MAX_GEOMS);

            uint32_t ctuAddr = m_numCols * m_numRows - 1;

            m_ctuGeomMap[ctuAddr] = countGeoms * CUGeom::MAX_GEOMS;

            countGeoms++;

        }

        X265_CHECK(countGeoms == allocGeoms, "geometry match check failure\n");

    }

    return true;

}

bool FrameEncoder::startCompressFrame(Frame* curFrame)

{

    m_slicetypeWaitTime = x265_mdate() - m_prevOutputTime;

    m_frame = curFrame;

    m_sliceType = curFrame->m_lowres.sliceType;

    curFrame->m_encData->m_frameEncoderID = m_jpId;

    curFrame->m_encData->m_jobProvider = this;

    curFrame->m_encData->m_slice->m_mref = m_mref;

    if (!m_cuGeoms)

    {

        if (!initializeGeoms())

            return false;

    }

    m_enable.trigger();

    return true;

}

void FrameEncoder::threadMain()

{

    THREAD_NAME("Frame", m_jpId);

    if (m_pool)

    {

        m_pool->setCurrentThreadAffinity();

        /* the first FE on each NUMA node is responsible for allocating thread

         * local data for all worker threads in that pool. If WPP is disabled, then

         * each FE also needs a TLD instance */

        if (!m_jpId)

        {

            int numTLD = m_pool->m_numWorkers;

            if (!m_param->bEnableWavefront)

                numTLD += m_pool->m_numProviders;

            m_tld = new ThreadLocalData[numTLD];

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

            {

                m_tld[i].analysis.initSearch(*m_param, m_top->m_scalingList);

                m_tld[i].analysis.create(m_tld);

            }

            for (int i = 0; i < m_pool->m_numProviders; i++)

            {

                if (m_pool->m_jpTable[i]->m_isFrameEncoder) /* ugh; over-allocation and other issues here */

                {

                    FrameEncoder *peer = dynamic_cast<FrameEncoder*>(m_pool->m_jpTable[i]);

                    peer->m_tld = m_tld;

                }

            }

        }

        if (m_param->bEnableWavefront)

            m_localTldIdx = -1; // cause exception if used

        else

            m_localTldIdx = m_pool->m_numWorkers + m_jpId;

    }

    else

    {

        m_tld = new ThreadLocalData;

        m_tld->analysis.initSearch(*m_param, m_top->m_scalingList);

        m_tld->analysis.create(NULL);

        m_localTldIdx = 0;

    }

    m_done.trigger();     /* signal that thread is initialized */

    m_enable.wait();      /* Encoder::encode() triggers this event */

    while (m_threadActive)

    {

        if (m_param->bCTUInfo)

        {

            while (!m_frame->m_ctuInfo)

                m_frame->m_copied.wait();

        }

        if ((m_param->bAnalysisType == AVC_INFO) && !m_param->analysisSave && !m_param->analysisLoad && !(IS_X265_TYPE_I(m_frame->m_lowres.sliceType)))

        {

            while (((m_frame->m_analysisData.interData == NULL && m_frame->m_analysisData.intraData == NULL) || (uint32_t)m_frame->m_poc != m_frame->m_analysisData.poc))

                m_frame->m_copyMVType.wait();

        }

        compressFrame();

        m_done.trigger(); /* FrameEncoder::getEncodedPicture() blocks for this event */

        m_enable.wait();

    }

}

void FrameEncoder::WeightAnalysis::processTasks(int /* workerThreadId */)

{

    Frame* frame = master.m_frame;

    weightAnalyse(*frame->m_encData->m_slice, *frame, *master.m_param);

}

uint32_t getBsLength( int32_t code )

{

    uint32_t ucode = (code <= 0) ? -code << 1 : (code << 1) - 1;

    ++ucode;

    unsigned long idx;

    CLZ( idx, ucode );

    uint32_t length = (uint32_t)idx * 2 + 1;

    return length;

}

bool FrameEncoder::writeToneMapInfo(x265_sei_payload *payload)

{

    bool payloadChange = false;

    if (m_top->m_prevTonemapPayload.payload != NULL && payload->payloadSize == m_top->m_prevTonemapPayload.payloadSize)

    {

        if (memcmp(m_top->m_prevTonemapPayload.payload, payload->payload, payload->payloadSize) != 0)

            payloadChange = true;

    }

    else

    {

        payloadChange = true;

        if (m_top->m_prevTonemapPayload.payload != NULL)

            x265_free(m_top->m_prevTonemapPayload.payload);

        m_top->m_prevTonemapPayload.payload = (uint8_t*)x265_malloc(sizeof(uint8_t)* payload->payloadSize);

    }

    if (payloadChange)

    {

        m_top->m_prevTonemapPayload.payloadType = payload->payloadType;

        m_top->m_prevTonemapPayload.payloadSize = payload->payloadSize;

        memcpy(m_top->m_prevTonemapPayload.payload, payload->payload, payload->payloadSize);

    }

    bool isIDR = m_frame->m_lowres.sliceType == X265_TYPE_IDR;

    return (payloadChange || isIDR);

}

void FrameEncoder::writeTrailingSEIMessages()

{

    Slice* slice = m_frame->m_encData->m_slice;

    int planes = (m_param->internalCsp != X265_CSP_I400) ? 3 : 1;

    int32_t payloadSize = 0;

    if (m_param->decodedPictureHashSEI == 1)

    {

        m_seiReconPictureDigest.m_method = SEIDecodedPictureHash::MD5;

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

            MD5Final(&m_seiReconPictureDigest.m_state[i], m_seiReconPictureDigest.m_digest[i]);

        payloadSize = 1 + 16 * planes;

    }

    else if (m_param->decodedPictureHashSEI == 2)

    {

        m_seiReconPictureDigest.m_method = SEIDecodedPictureHash::CRC;

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

            crcFinish(m_seiReconPictureDigest.m_crc[i], m_seiReconPictureDigest.m_digest[i]);

        payloadSize = 1 + 2 * planes;

    }

    else if (m_param->decodedPictureHashSEI == 3)

    {

        m_seiReconPictureDigest.m_method = SEIDecodedPictureHash::CHECKSUM;

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

            checksumFinish(m_seiReconPictureDigest.m_checksum[i], m_seiReconPictureDigest.m_digest[i]);

        payloadSize = 1 + 4 * planes;

    }

    m_seiReconPictureDigest.setSize(payloadSize);

    m_seiReconPictureDigest.writeSEImessages(m_bs, *slice->m_sps, NAL_UNIT_SUFFIX_SEI, m_nalList, false);

}

void FrameEncoder::compressFrame()

{

    ProfileScopeEvent(frameThread);

    m_startCompressTime = x265_mdate();

    m_totalActiveWorkerCount = 0;

    m_activeWorkerCountSamples = 0;

    m_totalWorkerElapsedTime = 0;

    m_totalNoWorkerTime = 0;

    m_countRowBlocks = 0;

    m_allRowsAvailableTime = 0;

    m_stallStartTime = 0;

    m_completionCount = 0;

    m_bAllRowsStop = false;

    m_vbvResetTriggerRow = -1;

    m_rowSliceTotalBits[0] = 0;

    m_rowSliceTotalBits[1] = 0;

    m_SSDY = m_SSDU = m_SSDV = 0;

    m_ssim = 0;

    m_ssimCnt = 0;

    memset(&(m_frame->m_encData->m_frameStats), 0, sizeof(m_frame->m_encData->m_frameStats));

    if (!m_param->bHistBasedSceneCut && m_param->rc.aqMode != X265_AQ_EDGE && m_param->recursionSkipMode == EDGE_BASED_RSKIP)

    {

        int height = m_frame->m_fencPic->m_picHeight;

        int width = m_frame->m_fencPic->m_picWidth;

        intptr_t stride = m_frame->m_fencPic->m_stride;

        if (!computeEdge(m_frame->m_edgeBitPic, m_frame->m_fencPic->m_picOrg[0], NULL, stride, height, width, false, 1))

        {

            x265_log(m_param, X265_LOG_ERROR, " Failed to compute edge !");

        }

    }

    /* Emit access unit delimiter unless this is the first frame and the user is

     * not repeating headers (since AUD is supposed to be the first NAL in the access

     * unit) */

    Slice* slice = m_frame->m_encData->m_slice;

    if (m_param->bEnableAccessUnitDelimiters && (m_frame->m_poc || m_param->bRepeatHeaders))

    {

        m_bs.resetBits();

        m_entropyCoder.setBitstream(&m_bs);

        m_entropyCoder.codeAUD(*slice);

        m_bs.writeByteAlignment();

        m_nalList.serialize(NAL_UNIT_ACCESS_UNIT_DELIMITER, m_bs);

        if (m_param->bSingleSeiNal)

            m_bs.resetBits();

    }

    if (m_frame->m_lowres.bKeyframe && m_param->bRepeatHeaders)

    {

        if (m_param->bOptRefListLengthPPS)

        {

            ScopedLock refIdxLock(m_top->m_sliceRefIdxLock);

            m_top->updateRefIdx();

        }

        if (m_top->m_param->rc.bStatRead  && m_top->m_param->bMultiPassOptRPS)

        {

            ScopedLock refIdxLock(m_top->m_rpsInSpsLock);

            if (!m_top->computeSPSRPSIndex())

            {

                x265_log(m_param, X265_LOG_ERROR, "compute commonly RPS failed!\n");

                m_top->m_aborted = true;

            }

            m_top->getStreamHeaders(m_nalList, m_entropyCoder, m_bs);

        }

        else

            m_top->getStreamHeaders(m_nalList, m_entropyCoder, m_bs);

    }

    if (m_top->m_param->rc.bStatRead && m_top->m_param->bMultiPassOptRPS)

        m_frame->m_encData->m_slice->m_rpsIdx = (m_top->m_rateControl->m_rce2Pass + m_frame->m_encodeOrder)->rpsIdx;

    // Weighted Prediction parameters estimation.

    bool bUseWeightP = slice->m_sliceType == P_SLICE && slice->m_pps->bUseWeightPred;

    bool bUseWeightB = slice->m_sliceType == B_SLICE && slice->m_pps->bUseWeightedBiPred;

    WeightParam* reuseWP = NULL;

    if (m_param->analysisLoad && (bUseWeightP || bUseWeightB))

        reuseWP = (WeightParam*)m_frame->m_analysisData.wt;

    if (bUseWeightP || bUseWeightB)

    {

#if DETAILED_CU_STATS

        m_cuStats.countWeightAnalyze++;

        ScopedElapsedTime time(m_cuStats.weightAnalyzeTime);

#endif

        if (m_param->analysisLoad)

        {

            for (int list = 0; list < slice->isInterB() + 1; list++) 

            {

                for (int plane = 0; plane < (m_param->internalCsp != X265_CSP_I400 ? 3 : 1); plane++)

                {

                    for (int ref = 1; ref < slice->m_numRefIdx[list]; ref++)

                        SET_WEIGHT(slice->m_weightPredTable[list][ref][plane], false, 1 << reuseWP->log2WeightDenom, reuseWP->log2WeightDenom, 0);

                    slice->m_weightPredTable[list][0][plane] = *(reuseWP++);

                }

            }

        }

        else

        {

            WeightAnalysis wa(*this);

            if (m_pool && wa.tryBondPeers(*this, 1))

                /* use an idle worker for weight analysis */

                wa.waitForExit();

            else

                weightAnalyse(*slice, *m_frame, *m_param);

        }

    }

    else

        slice->disableWeights();

    if (m_param->analysisSave && (bUseWeightP || bUseWeightB))

        reuseWP = (WeightParam*)m_frame->m_analysisData.wt;

    // Generate motion references

    int numPredDir = slice->isInterP() ? 1 : slice->isInterB() ? 2 : 0;

    for (int l = 0; l < numPredDir; l++)

    {

        for (int ref = 0; ref < slice->m_numRefIdx[l]; ref++)

        {

            WeightParam *w = NULL;

            if ((bUseWeightP || bUseWeightB) && slice->m_weightPredTable[l][ref][0].wtPresent)

                w = slice->m_weightPredTable[l][ref];

            slice->m_refReconPicList[l][ref] = slice->m_refFrameList[l][ref]->m_reconPic;

            m_mref[l][ref].init(slice->m_refReconPicList[l][ref], w, *m_param);

        }

        if (m_param->analysisSave && (bUseWeightP || bUseWeightB))

        {

            for (int i = 0; i < (m_param->internalCsp != X265_CSP_I400 ? 3 : 1); i++)

                *(reuseWP++) = slice->m_weightPredTable[l][0][i];

        }

    }

    int numTLD;

    if (m_pool)

        numTLD = m_param->bEnableWavefront ? m_pool->m_numWorkers : m_pool->m_numWorkers + m_pool->m_numProviders;

    else

        numTLD = 1;

    /* Get the QP for this frame from rate control. This call may block until

     * frames ahead of it in encode order have called rateControlEnd() */

    int qp = m_top->m_rateControl->rateControlStart(m_frame, &m_rce, m_top);

    m_rce.newQp = qp;

    if (m_nr)

    {

        if (qp > QP_MAX_SPEC && m_frame->m_param->rc.vbvBufferSize)

        {

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

            {

                m_tld[i].analysis.m_quant.m_frameNr[m_jpId].offset = m_top->m_offsetEmergency[qp - QP_MAX_SPEC - 1];

                m_tld[i].analysis.m_quant.m_frameNr[m_jpId].residualSum = m_top->m_residualSumEmergency;

                m_tld[i].analysis.m_quant.m_frameNr[m_jpId].count = m_top->m_countEmergency;

            }

        }

        else

        {

            if (m_param->noiseReductionIntra || m_param->noiseReductionInter)

            {

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

                {

                    m_tld[i].analysis.m_quant.m_frameNr[m_jpId].offset = m_tld[i].analysis.m_quant.m_frameNr[m_jpId].nrOffsetDenoise;

                    m_tld[i].analysis.m_quant.m_frameNr[m_jpId].residualSum = m_tld[i].analysis.m_quant.m_frameNr[m_jpId].nrResidualSum;

                    m_tld[i].analysis.m_quant.m_frameNr[m_jpId].count = m_tld[i].analysis.m_quant.m_frameNr[m_jpId].nrCount;

                }

            }

            else

            {

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

                    m_tld[i].analysis.m_quant.m_frameNr[m_jpId].offset = NULL;

            }

        }

    }

    /* Clip slice QP to 0-51 spec range before encoding */

    slice->m_sliceQp = x265_clip3(-QP_BD_OFFSET, QP_MAX_SPEC, qp);

    if (m_param->bHDR10Opt)

    {

        int qpCb = x265_clip3(-12, 0, (int)floor((m_top->m_cB * ((-.46) * qp + 9.26)) + 0.5 ));

        int qpCr = x265_clip3(-12, 0, (int)floor((m_top->m_cR * ((-.46) * qp + 9.26)) + 0.5 ));

        slice->m_chromaQpOffset[0] = slice->m_pps->chromaQpOffset[0] + qpCb < -12 ? (qpCb + (-12 - (slice->m_pps->chromaQpOffset[0] + qpCb))) : qpCb;

        slice->m_chromaQpOffset[1] = slice->m_pps->chromaQpOffset[1] + qpCr < -12 ? (qpCr + (-12 - (slice->m_pps->chromaQpOffset[1] + qpCr))) : qpCr;

    }

    if (m_param->bOptQpPPS && m_param->bRepeatHeaders)

    {

        ScopedLock qpLock(m_top->m_sliceQpLock);

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

        {

            int delta = slice->m_sliceQp - (i + 1);

            int codeLength = getBsLength( delta );

            m_top->m_iBitsCostSum[i] += codeLength;

        }

        m_top->m_iFrameNum++;

    }

    m_initSliceContext.resetEntropy(*slice);

    m_frameFilter.start(m_frame, m_initSliceContext);

    /* ensure all rows are blocked prior to initializing row CTU counters */

    WaveFront::clearEnabledRowMask();

    /* reset entropy coders and compute slice id */

    m_entropyCoder.load(m_initSliceContext);

    for (uint32_t sliceId = 0; sliceId < m_param->maxSlices; sliceId++)   

        for (uint32_t row = m_sliceBaseRow[sliceId]; row < m_sliceBaseRow[sliceId + 1]; row++)

            m_rows[row].init(m_initSliceContext, sliceId);   

    // reset slice counter for rate control update

    m_sliceCnt = 0;

    uint32_t numSubstreams = m_param->bEnableWavefront ? slice->m_sps->numCuInHeight : m_param->maxSlices;

    X265_CHECK(m_param->bEnableWavefront || (m_param->maxSlices == 1), "Multiple slices without WPP unsupport now!");

    if (!m_outStreams)

    {

        m_outStreams = new Bitstream[numSubstreams];

        if (!m_param->bEnableWavefront)

            m_backupStreams = new Bitstream[numSubstreams];

        m_substreamSizes = X265_MALLOC(uint32_t, numSubstreams);

        if (!slice->m_bUseSao)

        {

            for (uint32_t i = 0; i < numSubstreams; i++)

                m_rows[i].rowGoOnCoder.setBitstream(&m_outStreams[i]);

        }

    }

    else

    {

        for (uint32_t i = 0; i < numSubstreams; i++)

        {

            m_outStreams[i].resetBits();

            if (!slice->m_bUseSao)

                m_rows[i].rowGoOnCoder.setBitstream(&m_outStreams[i]);

            else

                m_rows[i].rowGoOnCoder.setBitstream(NULL);

        }

    }

    m_rce.encodeOrder = m_frame->m_encodeOrder;

    int prevBPSEI = m_rce.encodeOrder ? m_top->m_lastBPSEI : 0;

    if (m_frame->m_lowres.bKeyframe)

    {

        if (m_param->bEmitHRDSEI)

        {

            SEIBufferingPeriod* bpSei = &m_top->m_rateControl->m_bufPeriodSEI;

            // since the temporal layer HRD is not ready, we assumed it is fixed

            bpSei->m_auCpbRemovalDelayDelta = 1;

            bpSei->m_cpbDelayOffset = 0;

            bpSei->m_dpbDelayOffset = 0;

            bpSei->m_concatenationFlag = (m_param->bEnableHRDConcatFlag && !m_frame->m_poc) ? true : false;

            // hrdFullness() calculates the initial CPB removal delay and offset

            m_top->m_rateControl->hrdFullness(bpSei);

            bpSei->writeSEImessages(m_bs, *slice->m_sps, NAL_UNIT_PREFIX_SEI, m_nalList, m_param->bSingleSeiNal);

            m_top->m_lastBPSEI = m_rce.encodeOrder;

        }

        if (m_frame->m_lowres.sliceType == X265_TYPE_IDR && m_param->bEmitIDRRecoverySEI)

        {

            /* Recovery Point SEI require the SPS to be "activated" */

            SEIRecoveryPoint sei;

            sei.m_recoveryPocCnt = 0;

            sei.m_exactMatchingFlag = true;

            sei.m_brokenLinkFlag = false;

            sei.writeSEImessages(m_bs, *slice->m_sps, NAL_UNIT_PREFIX_SEI, m_nalList, m_param->bSingleSeiNal);

        }

    }

    if ((m_param->bEmitHRDSEI || !!m_param->interlaceMode))

    {

        SEIPictureTiming *sei = m_rce.picTimingSEI;

        const VUI *vui = &slice->m_sps->vuiParameters;

        const HRDInfo *hrd = &vui->hrdParameters;

        int poc = slice->m_poc;

        if (vui->frameFieldInfoPresentFlag)

        {

            if (m_param->interlaceMode > 0)

            {

                if( m_param->interlaceMode == 2 )

                {   

                    // m_picStruct should be set to 3 or 4 when field feature is enabled

                    if (m_param->bField)

                        // 3: Top field, bottom field, in that order; 4: Bottom field, top field, in that order

                        sei->m_picStruct = (slice->m_fieldNum == 1) ? 4 : 3;

                    else

                        sei->m_picStruct = (poc & 1) ? 1 /* top */ : 2 /* bottom */;

                }     

                else if (m_param->interlaceMode == 1)

                {

                    if (m_param->bField)

                        sei->m_picStruct = (slice->m_fieldNum == 1) ? 3: 4;

                    else

                        sei->m_picStruct = (poc & 1) ? 2 /* bottom */ : 1 /* top */;

                }

            }

            else if (m_param->bEnableFrameDuplication)

                sei->m_picStruct = m_frame->m_picStruct;

            else

                sei->m_picStruct = m_param->pictureStructure;

            sei->m_sourceScanType = m_param->interlaceMode ? 0 : 1;

            sei->m_duplicateFlag = false;

        }

        if (vui->hrdParametersPresentFlag)

        {

            // The m_aucpbremoval delay specifies how many clock ticks the

            // access unit associated with the picture timing SEI message has to

            // wait after removal of the access unit with the most recent

            // buffering period SEI message

            sei->m_auCpbRemovalDelay = X265_MIN(X265_MAX(1, m_rce.encodeOrder - prevBPSEI), (1 << hrd->cpbRemovalDelayLength));

            sei->m_picDpbOutputDelay = slice->m_sps->numReorderPics + poc - m_rce.encodeOrder;

        }

        sei->writeSEImessages(m_bs, *slice->m_sps, NAL_UNIT_PREFIX_SEI, m_nalList, m_param->bSingleSeiNal);

    }

    if (m_param->preferredTransferCharacteristics > -1 && slice->isIRAP())

    {

        SEIAlternativeTC m_seiAlternativeTC;

        m_seiAlternativeTC.m_preferredTransferCharacteristics = m_param->preferredTransferCharacteristics;

        m_seiAlternativeTC.writeSEImessages(m_bs, *slice->m_sps, NAL_UNIT_PREFIX_SEI, m_nalList, m_param->bSingleSeiNal);

    }

    /* Write user SEI */

    for (int i = 0; i < m_frame->m_userSEI.numPayloads; i++)

    {

        x265_sei_payload *payload = &m_frame->m_userSEI.payloads[i];

        if (payload->payloadType == USER_DATA_UNREGISTERED)

        {

            SEIuserDataUnregistered sei;

            sei.m_userData = payload->payload;

            sei.setSize(payload->payloadSize);

            sei.writeSEImessages(m_bs, *slice->m_sps, NAL_UNIT_PREFIX_SEI, m_nalList, m_param->bSingleSeiNal);

        }

        else if (payload->payloadType == USER_DATA_REGISTERED_ITU_T_T35)

        {

            bool writeSei = m_param->bDhdr10opt ? writeToneMapInfo(payload) : true;

            if (writeSei)

            {

                SEIuserDataRegistered sei;

                sei.m_userData = payload->payload;

                sei.setSize(payload->payloadSize);

                sei.writeSEImessages(m_bs, *slice->m_sps, NAL_UNIT_PREFIX_SEI, m_nalList, m_param->bSingleSeiNal);

            }

        }

        else

            x265_log(m_param, X265_LOG_ERROR, "Unrecognized SEI type\n");

    }

    bool isSei = ((m_frame->m_lowres.bKeyframe && m_param->bRepeatHeaders) || m_param->bEmitHRDSEI ||

                 !!m_param->interlaceMode || (m_frame->m_lowres.sliceType == X265_TYPE_IDR && m_param->bEmitIDRRecoverySEI) ||

                   m_frame->m_userSEI.numPayloads);

    if (isSei && m_param->bSingleSeiNal)

    {

        m_bs.writeByteAlignment();

        m_nalList.serialize(NAL_UNIT_PREFIX_SEI, m_bs);

    }

    /* CQP and CRF (without capped VBV) doesn't use mid-frame statistics to 

     * tune RateControl parameters for other frames.

     * Hence, for these modes, update m_startEndOrder and unlock RC for previous threads waiting in

     * RateControlEnd here, after the slice contexts are initialized. For the rest - ABR

     * and VBV, unlock only after rateControlUpdateStats of this frame is called */

    if (m_param->rc.rateControlMode != X265_RC_ABR && !m_top->m_rateControl->m_isVbv)

    {

        m_top->m_rateControl->m_startEndOrder.incr();

        if (m_rce.encodeOrder < m_param->frameNumThreads - 1)

            m_top->m_rateControl->m_startEndOrder.incr(); // faked rateControlEnd calls for negative frames

    }

    if (m_param->bDynamicRefine)

        computeAvgTrainingData();

    /* Analyze CTU rows, most of the hard work is done here.  Frame is

     * compressed in a wave-front pattern if WPP is enabled. Row based loop

     * filters runs behind the CTU compression and reconstruction */

    for (uint32_t sliceId = 0; sliceId < m_param->maxSlices; sliceId++)    

        m_rows[m_sliceBaseRow[sliceId]].active = true;

    if (m_param->bEnableWavefront)

    {

        int i = 0;

        for (uint32_t rowInSlice = 0; rowInSlice < m_sliceGroupSize; rowInSlice++)

        {

            for (uint32_t sliceId = 0; sliceId < m_param->maxSlices; sliceId++)

            {

                const uint32_t sliceStartRow = m_sliceBaseRow[sliceId];

                const uint32_t sliceEndRow = m_sliceBaseRow[sliceId + 1] - 1;

                const uint32_t row = sliceStartRow + rowInSlice;

                if (row > sliceEndRow)

                    continue;

                m_row_to_idx[row] = i;

                m_idx_to_row[i] = row;

                i += 1;

            }

        }

    }