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

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

#include "temporalfilter.h"

#include <iostream>

namespace X265_NS {

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

FrameEncoder::FrameEncoder()

{

    m_reconfigure = false;

    m_isFrameEncoder = true;

    m_threadActive = true;

    m_activeWorkerCount = 0;

    m_completionCount = 0;

    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_cuGeoms = NULL;

    m_ctuGeomMap = NULL;

    m_localTldIdx = 0;

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

    for (int layer = 0; layer < MAX_LAYERS; layer++)

    {

        m_prevOutputTime[layer] = x265_mdate();

        m_slicetypeWaitTime[layer] = 0;

        m_frame[layer] = NULL;

    }

}

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((void*)m_bAllRowsStop);

    X265_FREE((void*)m_vbvResetTriggerRow);

    X265_FREE(m_sliceMaxBlockRow);

    X265_FREE(m_cuGeoms);

    X265_FREE(m_ctuGeomMap);

    X265_FREE(m_substreamSizes);

    X265_FREE(m_nr);

    X265_FREE(m_retFrameBuffer);

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

    m_bAllRowsStop = X265_MALLOC(bool, m_param->maxSlices);

    m_vbvResetTriggerRow = X265_MALLOC(int, m_param->maxSlices);

    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;

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

        m_sliceAddrBits = (uint16_t)(tmp + 1);

    }

    m_tmeDeps.resize(m_numRows);

    m_retFrameBuffer = X265_MALLOC(Frame*, m_param->numLayers);

    for (int layer = 0; layer < m_param->numLayers; layer++)

        m_retFrameBuffer[layer] = NULL;

    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[MAX_LAYERS])

{

    for (int layer = 0; layer < m_param->numLayers; layer++)

    {

        m_slicetypeWaitTime[layer] = x265_mdate() - m_prevOutputTime[layer];

        m_frame[layer] = curFrame[layer];

        curFrame[layer]->m_encData->m_frameEncoderID = m_jpId;

        curFrame[layer]->m_encData->m_jobProvider = this;

        curFrame[layer]->m_encData->m_slice->m_mref = m_mref;

    }

    m_sliceType = curFrame[0]->m_lowres.sliceType;

    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[0]->m_ctuInfo)

                m_frame[0]->m_copied.wait();

        }

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

        {

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

                m_frame[0]->m_copyMVType.wait();

        }

        for (int layer = 0; layer < m_param->numLayers; layer++)

            compressFrame(layer);

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

        m_enable.wait();

    }

}

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

{

    Frame* frame = master.m_frame[master.m_sLayerId];

    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;

    BSR( 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[0]->m_lowres.sliceType == X265_TYPE_IDR;

    return (payloadChange || isIDR);

}

void FrameEncoder::writeTrailingSEIMessages(int layer)

{

    Slice* slice = m_frame[layer]->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, layer);

}

void FrameEncoder::compressFrame(int layer)

{

    ProfileScopeEvent(frameThread);

    m_startCompressTime[layer] = x265_mdate();

    m_totalActiveWorkerCount = 0;

    m_activeWorkerCountSamples = 0;

    m_totalWorkerElapsedTime[layer] = 0;

    m_totalThreadedMETime[layer] = 0;

    m_totalThreadedMEWait[layer] = 0;

    m_totalNoWorkerTime[layer] = 0;

    m_countRowBlocks = 0;

    m_allRowsAvailableTime[layer] = 0;

    m_stallStartTime[layer] = 0;

    m_completionCount = 0;

    memset((void*)m_bAllRowsStop, 0, sizeof(bool) * m_param->maxSlices);

    memset((void*)m_vbvResetTriggerRow, -1, sizeof(int) * m_param->maxSlices);

    m_rowSliceTotalBits[0] = 0;

    m_rowSliceTotalBits[1] = 0;

    m_SSDY[layer] = m_SSDU[layer] = m_SSDV[layer] = 0;

    m_ssim[layer] = 0;

    m_ssimCnt[layer] = 0;

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

    m_sLayerId = layer;

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

    {

        int height = m_frame[layer]->m_fencPic->m_picHeight;

        int width = m_frame[layer]->m_fencPic->m_picWidth;

        intptr_t stride = m_frame[layer]->m_fencPic->m_stride;

        if (!computeEdge(m_frame[layer]->m_edgeBitPic, m_frame[layer]->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[layer]->m_encData->m_slice;

    if (m_param->bEnableEndOfSequence && m_frame[layer]->m_lowres.sliceType == X265_TYPE_IDR && m_frame[layer]->m_poc)

    {

        m_bs.resetBits();

        m_nalList.serialize(NAL_UNIT_EOS, m_bs);

    }

    if (m_param->bEnableAccessUnitDelimiters && (m_frame[layer]->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[layer]->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[layer]->m_encData->m_slice->m_rpsIdx = (m_top->m_rateControl->m_rce2Pass + m_frame[layer]->m_encodeOrder)->rpsIdx;

    // Weighted Prediction parameters estimation.

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

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

    WeightParam* reuseWP = NULL;

    if (m_param->analysisLoad[0] && (bUseWeightP || bUseWeightB))

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

    if (bUseWeightP || bUseWeightB)

    {

#if DETAILED_CU_STATS

        m_cuStats.countWeightAnalyze++;

        ScopedElapsedTime time(m_cuStats.weightAnalyzeTime);

#endif

        if (strlen(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[layer], *m_param);

        }

    }

    else

        slice->disableWeights();

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

        reuseWP = (WeightParam*)m_frame[layer]->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[0];

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

        }

        if (strlen(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 = (layer == 0) ? m_top->m_rateControl->rateControlStart(m_frame[layer], &m_rce, m_top) : (int)m_rce.newQp;

    m_rce.newQp = qp;

    if (!!layer && m_top->m_lookahead->m_bAdaptiveQuant)

    {

        int ncu;

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

            ncu = m_top->m_rateControl->m_ncu * 4;

        else

            ncu = m_top->m_rateControl->m_ncu;

        if (m_param->numViews > 1)

        {

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

            {

                m_frame[layer]->m_lowres.qpCuTreeOffset[i] = m_frame[0]->m_lowres.qpCuTreeOffset[i];

                m_frame[layer]->m_lowres.qpAqOffset[i] = m_frame[0]->m_lowres.qpAqOffset[i];

            }

        }

        else if (m_param->numScalableLayers > 1)

        {

            memset(m_frame[layer]->m_lowres.qpCuTreeOffset, 0, sizeof(double)*ncu);

            memset(m_frame[layer]->m_lowres.qpAqOffset, 0, sizeof(double)* ncu);

        }

        m_frame[layer]->m_encData->m_avgQpAq = m_frame[0]->m_encData->m_avgQpAq;

        m_frame[layer]->m_encData->m_avgQpRc = m_frame[0]->m_encData->m_avgQpRc;

        if (!!m_param->rc.hevcAq)

        {

            for (uint32_t d = 0; d < 4; d++)

            {

                int ctuSizeIdx = 6 - g_log2Size[m_param->maxCUSize];

                int aqDepth = g_log2Size[m_param->maxCUSize] - g_log2Size[m_param->rc.qgSize];

                if (!aqLayerDepth[ctuSizeIdx][aqDepth][d])

                    continue;

                PicQPAdaptationLayer* pcAQLayer0 = &m_frame[0]->m_lowres.pAQLayer[d];

                PicQPAdaptationLayer* pcAQLayer1 = &m_frame[layer]->m_lowres.pAQLayer[d];

                const uint32_t aqPartWidth = m_frame[0]->m_lowres.pAQLayer[d].aqPartWidth;

                const uint32_t aqPartHeight = m_frame[0]->m_lowres.pAQLayer[d].aqPartHeight;

                double* pcQP0 = pcAQLayer0->dQpOffset;

                double* pcCuTree0 = pcAQLayer0->dCuTreeOffset;

                double* pcQP1 = pcAQLayer1->dQpOffset;

                double* pcCuTree1 = pcAQLayer1->dCuTreeOffset;

                if (m_param->numViews > 1)

                {

                    for (uint32_t y = 0; y < m_frame[0]->m_fencPic->m_picHeight; y += aqPartHeight)

                    {

                        for (uint32_t x = 0; x < m_frame[0]->m_fencPic->m_picWidth; x += aqPartWidth, pcQP0++, pcCuTree0++, pcQP1++, pcCuTree1++)

                        {

                            *pcQP1 = *pcQP0;

                            *pcCuTree1 = *pcCuTree0;

                        }

                    }

                }

                else if (m_param->numScalableLayers > 1)

                {

                    int numAQPartInWidth = (m_frame[0]->m_fencPic->m_picWidth + aqPartWidth - 1) / aqPartWidth;

                    int numAQPartInHeight = (m_frame[0]->m_fencPic->m_picHeight + aqPartHeight - 1) / aqPartHeight;

                    memset(m_frame[layer]->m_lowres.pAQLayer[d].dQpOffset, 0, sizeof(double)*numAQPartInWidth* numAQPartInHeight);

                    memset(m_frame[layer]->m_lowres.pAQLayer[d].dCuTreeOffset, 0, sizeof(double)* numAQPartInWidth* numAQPartInHeight);

                }

            }

        }

    }

    if (m_param->bEnableTemporalFilter)

    {

        m_frame[layer]->m_mcstf->m_QP = qp;

        m_frame[layer]->m_mcstf->bilateralFilter(m_frame[layer], m_frame[layer]->m_mcstfRefList, m_param->temporalFilterStrength);

    }

    if (m_nr)

    {

        if (qp > QP_MAX_SPEC && m_frame[layer]->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[layer], m_initSliceContext);

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

    WaveFront::clearEnabledRowMask();

    WaveFront::setLayerId(layer);

    /* 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[layer]->m_encodeOrder;

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

    if (m_frame[layer]->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[layer]->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, layer);

            m_top->m_lastBPSEI = m_rce.encodeOrder;

        }

        if (m_frame[layer]->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, layer);

        }

    }

    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[layer]->m_picStruct;

            else