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

* Copyright (C) 2013-2020 MulticoreWare, Inc

*

* Authors: Deepthi Nandakumar <deepthi@multicorewareinc.com>

*          Steve Borho <steve@borho.org>

*          Min Chen <chenm003@163.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.

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

#include "common.h"

#include "frame.h"

#include "framedata.h"

#include "picyuv.h"

#include "primitives.h"

#include "threading.h"

#include "analysis.h"

#include "rdcost.h"

#include "encoder.h"

using namespace X265_NS;

/* An explanation of rate distortion levels (--rd-level)

 *

 * rd-level 0 generates no recon per CU (NO RDO or Quant)

 *

 *   sa8d selection between merge / skip / inter / intra and split

 *   no recon pixels generated until CTU analysis is complete, requiring

 *   intra predictions to use source pixels

 *

 * rd-level 1 uses RDO for merge and skip, sa8d for all else

 *

 *   RDO selection between merge and skip

 *   sa8d selection between (merge/skip) / inter modes / intra and split

 *   intra prediction uses reconstructed pixels

 *

 * rd-level 2 uses RDO for merge/skip and split

 *

 *   RDO selection between merge and skip

 *   sa8d selection between (merge/skip) / inter modes / intra

 *   RDO split decisions

 *

 * rd-level 3 uses RDO for merge/skip/best inter/intra

 *

 *   RDO selection between merge and skip

 *   sa8d selection of best inter mode

 *   sa8d decisions include chroma residual cost

 *   RDO selection between (merge/skip) / best inter mode / intra / split

 *

 * rd-level 4 enables RDOQuant

 *   chroma residual cost included in satd decisions, including subpel refine

 *    (as a result of --subme 3 being used by preset slow)

 *

 * rd-level 5,6 does RDO for each inter mode

 */

Analysis::Analysis()

{

    m_reuseInterDataCTU = NULL;

    m_reuseRef = NULL;

    m_bHD = false;

    m_modeFlag[0] = false;

    m_modeFlag[1] = false;

    m_checkMergeAndSkipOnly[0] = false;

    m_checkMergeAndSkipOnly[1] = false;

    m_evaluateInter = 0;

}

bool Analysis::create(ThreadLocalData *tld)

{

    m_tld = tld;

    m_bTryLossless = m_param->bCULossless && !m_param->bLossless && m_param->rdLevel >= 2;

    int costArrSize = 1;

    uint32_t maxDQPDepth = g_log2Size[m_param->maxCUSize] - g_log2Size[m_param->rc.qgSize];

    for (uint32_t i = 1; i <= maxDQPDepth; i++)

        costArrSize += (1 << (i * 2));

    cacheCost = X265_MALLOC(uint64_t, costArrSize);

    int csp = m_param->internalCsp;

    uint32_t cuSize = m_param->maxCUSize;

    bool ok = true;

    for (uint32_t depth = 0; depth <= m_param->maxCUDepth; depth++, cuSize >>= 1)

    {

        ModeDepth &md = m_modeDepth[depth];

        ok &= md.cuMemPool.create(depth, csp, MAX_PRED_TYPES, *m_param);

        ok &= md.fencYuv.create(cuSize, csp);

        if (ok)

        {

            for (int j = 0; j < MAX_PRED_TYPES; j++)

            {

                md.pred[j].cu.initialize(md.cuMemPool, depth, *m_param, j);

                ok &= md.pred[j].predYuv.create(cuSize, csp);

                ok &= md.pred[j].reconYuv.create(cuSize, csp);

                md.pred[j].fencYuv = &md.fencYuv;

            }

        }

    }

    if (m_param->sourceHeight >= 1080)

        m_bHD = true;

    return ok;

}

void Analysis::destroy()

{

    for (uint32_t i = 0; i <= m_param->maxCUDepth; i++)

    {

        m_modeDepth[i].cuMemPool.destroy();

        m_modeDepth[i].fencYuv.destroy();

        for (int j = 0; j < MAX_PRED_TYPES; j++)

        {

            m_modeDepth[i].pred[j].predYuv.destroy();

            m_modeDepth[i].pred[j].reconYuv.destroy();

        }

    }

    X265_FREE(cacheCost);

}

Mode& Analysis::compressCTU(CUData& ctu, Frame& frame, const CUGeom& cuGeom, const Entropy& initialContext)

{

    m_slice = ctu.m_slice;

    m_frame = &frame;

    m_bChromaSa8d = m_param->rdLevel >= 3;

    m_param = m_frame->m_param;

#if _DEBUG || CHECKED_BUILD

    invalidateContexts(0);

#endif

    int qp = setLambdaFromQP(ctu, m_slice->m_pps->bUseDQP ? calculateQpforCuSize(ctu, cuGeom) : m_slice->m_sliceQp);

    ctu.setQPSubParts((int8_t)qp, 0, 0);

    m_rqt[0].cur.load(initialContext);

    ctu.m_meanQP = initialContext.m_meanQP;

    m_modeDepth[0].fencYuv.copyFromPicYuv(*m_frame->m_fencPic, ctu.m_cuAddr, 0);

    if (m_param->bSsimRd)

        calculateNormFactor(ctu, qp);

    uint32_t numPartition = ctu.m_numPartitions;

    if (m_param->bCTUInfo && (*m_frame->m_ctuInfo + ctu.m_cuAddr))

    {

        x265_ctu_info_t* ctuTemp = *m_frame->m_ctuInfo + ctu.m_cuAddr;

        int32_t depthIdx = 0;

        uint32_t maxNum8x8Partitions = 64;

        uint8_t* depthInfoPtr = m_frame->m_addOnDepth[ctu.m_cuAddr];

        uint8_t* contentInfoPtr = m_frame->m_addOnCtuInfo[ctu.m_cuAddr];

        int* prevCtuInfoChangePtr = m_frame->m_addOnPrevChange[ctu.m_cuAddr];

        do

        {

            uint8_t depth = (uint8_t)ctuTemp->ctuPartitions[depthIdx];

            uint8_t content = (uint8_t)(*((int32_t *)ctuTemp->ctuInfo + depthIdx));

            int prevCtuInfoChange = m_frame->m_prevCtuInfoChange[ctu.m_cuAddr * maxNum8x8Partitions + depthIdx];

            memset(depthInfoPtr, depth, sizeof(uint8_t) * numPartition >> 2 * depth);

            memset(contentInfoPtr, content, sizeof(uint8_t) * numPartition >> 2 * depth);

            memset(prevCtuInfoChangePtr, 0, sizeof(int) * numPartition >> 2 * depth);

            for (uint32_t l = 0; l < numPartition >> 2 * depth; l++)

                prevCtuInfoChangePtr[l] = prevCtuInfoChange;

            depthInfoPtr += ctu.m_numPartitions >> 2 * depth;

            contentInfoPtr += ctu.m_numPartitions >> 2 * depth;

            prevCtuInfoChangePtr += ctu.m_numPartitions >> 2 * depth;

            depthIdx++;

        } while (ctuTemp->ctuPartitions[depthIdx] != 0);

        m_additionalCtuInfo = m_frame->m_addOnCtuInfo[ctu.m_cuAddr];

        m_prevCtuInfoChange = m_frame->m_addOnPrevChange[ctu.m_cuAddr];

        memcpy(ctu.m_cuDepth, m_frame->m_addOnDepth[ctu.m_cuAddr], sizeof(uint8_t) * numPartition);

        //Calculate log2CUSize from depth

        for (uint32_t i = 0; i < cuGeom.numPartitions; i++)

            ctu.m_log2CUSize[i] = (uint8_t)m_param->maxLog2CUSize - ctu.m_cuDepth[i];

    }

    if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead && (m_slice->m_sliceType != I_SLICE))

    {

        int numPredDir = m_slice->isInterP() ? 1 : 2;

        m_reuseInterDataCTU = m_frame->m_analysisData.interData;

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

        {

            m_reuseMv[dir] = &m_reuseInterDataCTU->mv[dir][ctu.m_cuAddr * ctu.m_numPartitions];

            m_reuseMvpIdx[dir] = &m_reuseInterDataCTU->mvpIdx[dir][ctu.m_cuAddr * ctu.m_numPartitions];

        }

        m_reuseRef = &m_reuseInterDataCTU->ref[ctu.m_cuAddr * ctu.m_numPartitions];

        m_reuseModes = &m_reuseInterDataCTU->modes[ctu.m_cuAddr * ctu.m_numPartitions];

        m_reuseDepth = &m_reuseInterDataCTU->depth[ctu.m_cuAddr * ctu.m_numPartitions];

    }

    int reuseLevel = X265_MAX(m_param->analysisSaveReuseLevel, m_param->analysisLoadReuseLevel);

    if ((m_param->analysisSave || m_param->analysisLoad) && m_slice->m_sliceType != I_SLICE && reuseLevel > 1 && reuseLevel < 10)

    {

        int numPredDir = m_slice->isInterP() ? 1 : 2;

        m_reuseInterDataCTU = m_frame->m_analysisData.interData;

        if (((m_param->analysisSaveReuseLevel > 1) && (m_param->analysisSaveReuseLevel < 7)) ||

            ((m_param->analysisLoadReuseLevel > 1) && (m_param->analysisLoadReuseLevel < 7)))

            m_reuseRef = &m_reuseInterDataCTU->ref[ctu.m_cuAddr * X265_MAX_PRED_MODE_PER_CTU * numPredDir];

        m_reuseDepth = &m_reuseInterDataCTU->depth[ctu.m_cuAddr * ctu.m_numPartitions];

        m_reuseModes = &m_reuseInterDataCTU->modes[ctu.m_cuAddr * ctu.m_numPartitions];

        if (reuseLevel > 4)

        {

            m_reusePartSize = &m_reuseInterDataCTU->partSize[ctu.m_cuAddr * ctu.m_numPartitions];

            m_reuseMergeFlag = &m_reuseInterDataCTU->mergeFlag[ctu.m_cuAddr * ctu.m_numPartitions];

        }

        if (m_param->analysisSave && !m_param->analysisLoad)

            for (int i = 0; i < X265_MAX_PRED_MODE_PER_CTU * numPredDir; i++)

                m_reuseRef[i] = -1;

    }

    ProfileCUScope(ctu, totalCTUTime, totalCTUs);

    if (m_slice->m_sliceType == I_SLICE)

    {

        x265_analysis_intra_data* intraDataCTU = m_frame->m_analysisData.intraData;

        if (m_param->analysisLoadReuseLevel > 1)

        {

            memcpy(ctu.m_cuDepth, &intraDataCTU->depth[ctu.m_cuAddr * numPartition], sizeof(uint8_t) * numPartition);

            memcpy(ctu.m_lumaIntraDir, &intraDataCTU->modes[ctu.m_cuAddr * numPartition], sizeof(uint8_t) * numPartition);

            memcpy(ctu.m_partSize, &intraDataCTU->partSizes[ctu.m_cuAddr * numPartition], sizeof(char) * numPartition);

            memcpy(ctu.m_chromaIntraDir, &intraDataCTU->chromaModes[ctu.m_cuAddr * numPartition], sizeof(uint8_t) * numPartition);

        }

        compressIntraCU(ctu, cuGeom, qp);

    }

    else

    {

        bool bCopyAnalysis = ((m_param->analysisLoadReuseLevel == 10) || (m_param->bAnalysisType == AVC_INFO && m_param->analysisLoadReuseLevel >= 7 && ctu.m_numPartitions <= 16));

        bool bCompressInterCUrd0_4 = (m_param->bAnalysisType == AVC_INFO && m_param->analysisLoadReuseLevel >= 7 && m_param->rdLevel <= 4);

        bool bCompressInterCUrd5_6 = (m_param->bAnalysisType == AVC_INFO && m_param->analysisLoadReuseLevel >= 7 && m_param->rdLevel >= 5 && m_param->rdLevel <= 6);

        bCopyAnalysis = bCopyAnalysis || bCompressInterCUrd0_4 || bCompressInterCUrd5_6;

        if (bCopyAnalysis)

        {

            x265_analysis_inter_data* interDataCTU = m_frame->m_analysisData.interData;

            int posCTU = ctu.m_cuAddr * numPartition;

            memcpy(ctu.m_cuDepth, &interDataCTU->depth[posCTU], sizeof(uint8_t) * numPartition);

            memcpy(ctu.m_predMode, &interDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);

            memcpy(ctu.m_partSize, &interDataCTU->partSize[posCTU], sizeof(uint8_t) * numPartition);

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

                memcpy(ctu.m_skipFlag[list], &m_frame->m_analysisData.modeFlag[list][posCTU], sizeof(uint8_t) * numPartition);

            if ((m_slice->m_sliceType == P_SLICE || m_param->bIntraInBFrames) && !(m_param->bAnalysisType == AVC_INFO))

            {

                x265_analysis_intra_data* intraDataCTU = m_frame->m_analysisData.intraData;

                memcpy(ctu.m_lumaIntraDir, &intraDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);

                memcpy(ctu.m_chromaIntraDir, &intraDataCTU->chromaModes[posCTU], sizeof(uint8_t) * numPartition);

            }

            //Calculate log2CUSize from depth

            for (uint32_t i = 0; i < cuGeom.numPartitions; i++)

                ctu.m_log2CUSize[i] = (uint8_t)m_param->maxLog2CUSize - ctu.m_cuDepth[i];

        }

        if (m_param->bIntraRefresh && m_slice->m_sliceType == P_SLICE &&

            ctu.m_cuPelX / m_param->maxCUSize >= frame.m_encData->m_pir.pirStartCol

            && ctu.m_cuPelX / m_param->maxCUSize < frame.m_encData->m_pir.pirEndCol)

            compressIntraCU(ctu, cuGeom, qp);

        else if (!m_param->rdLevel)

        {

            /* In RD Level 0/1, copy source pixels into the reconstructed block so

             * they are available for intra predictions */

            m_modeDepth[0].fencYuv.copyToPicYuv(*m_frame->m_reconPic, ctu.m_cuAddr, 0);

            compressInterCU_rd0_4(ctu, cuGeom, qp);

            /* generate residual for entire CTU at once and copy to reconPic */

            encodeResidue(ctu, cuGeom);

        }

        else if ((m_param->analysisLoadReuseLevel == 10 && (!(m_param->bAnalysisType == HEVC_INFO) || m_slice->m_sliceType != P_SLICE)) ||

                ((m_param->bAnalysisType == AVC_INFO) && m_param->analysisLoadReuseLevel >= 7 && ctu.m_numPartitions <= 16))

        {

            x265_analysis_inter_data* interDataCTU = m_frame->m_analysisData.interData;

            int posCTU = ctu.m_cuAddr * numPartition;

            memcpy(ctu.m_cuDepth, &interDataCTU->depth[posCTU], sizeof(uint8_t) * numPartition);

            memcpy(ctu.m_predMode, &interDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);

            memcpy(ctu.m_partSize, &interDataCTU->partSize[posCTU], sizeof(uint8_t) * numPartition);

            if ((m_slice->m_sliceType == P_SLICE || m_param->bIntraInBFrames) && !(m_param->bAnalysisType == AVC_INFO))

            {

                x265_analysis_intra_data* intraDataCTU = m_frame->m_analysisData.intraData;

                memcpy(ctu.m_lumaIntraDir, &intraDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);

                memcpy(ctu.m_chromaIntraDir, &intraDataCTU->chromaModes[posCTU], sizeof(uint8_t) * numPartition);

            }

            //Calculate log2CUSize from depth

            for (uint32_t i = 0; i < cuGeom.numPartitions; i++)

                ctu.m_log2CUSize[i] = (uint8_t)m_param->maxLog2CUSize - ctu.m_cuDepth[i];

            qprdRefine (ctu, cuGeom, qp, qp);

            return *m_modeDepth[0].bestMode;

        }

        else if (m_param->bDistributeModeAnalysis && m_param->rdLevel >= 2)

            compressInterCU_dist(ctu, cuGeom, qp);

        else if (m_param->rdLevel <= 4)

            compressInterCU_rd0_4(ctu, cuGeom, qp);

        else

            compressInterCU_rd5_6(ctu, cuGeom, qp);

    }

    if (m_param->bEnableRdRefine || m_param->bOptCUDeltaQP)

        qprdRefine(ctu, cuGeom, qp, qp);

    if (m_param->csvLogLevel >= 2)

        collectPUStatistics(ctu, cuGeom);

    return *m_modeDepth[0].bestMode;

}

void Analysis::collectPUStatistics(const CUData& ctu, const CUGeom& cuGeom)

{

    uint8_t depth = 0;

    uint8_t partSize = 0;

    for (uint32_t absPartIdx = 0; absPartIdx < ctu.m_numPartitions; absPartIdx += ctu.m_numPartitions >> (depth * 2))

    {

        depth = ctu.m_cuDepth[absPartIdx];

        partSize = ctu.m_partSize[absPartIdx];

        uint32_t numPU = nbPartsTable[(int)partSize];

        int shift = 2 * (m_param->maxCUDepth + 1 - depth);

        for (uint32_t puIdx = 0; puIdx < numPU; puIdx++)

        {

            PredictionUnit pu(ctu, cuGeom, puIdx);

            int puabsPartIdx = ctu.getPUOffset(puIdx, absPartIdx);

            int mode = 1;

            if (ctu.m_partSize[puabsPartIdx + absPartIdx] == SIZE_Nx2N || ctu.m_partSize[puabsPartIdx + absPartIdx] == SIZE_2NxN)

                mode = 2;

            else if (ctu.m_partSize[puabsPartIdx + absPartIdx] == SIZE_2NxnU || ctu.m_partSize[puabsPartIdx + absPartIdx] == SIZE_2NxnD || ctu.m_partSize[puabsPartIdx + absPartIdx] == SIZE_nLx2N || ctu.m_partSize[puabsPartIdx + absPartIdx] == SIZE_nRx2N)

                 mode = 3;

            if (ctu.m_predMode[puabsPartIdx + absPartIdx] == MODE_SKIP)

            {

                ctu.m_encData->m_frameStats.cntSkipPu[depth] += 1ULL << shift;

                ctu.m_encData->m_frameStats.totalPu[depth] += 1ULL << shift;

            }

            else if (ctu.m_predMode[puabsPartIdx + absPartIdx] == MODE_INTRA)

            {

                if (ctu.m_partSize[puabsPartIdx + absPartIdx] == SIZE_NxN)

                {

                    ctu.m_encData->m_frameStats.cnt4x4++;

                    ctu.m_encData->m_frameStats.totalPu[4]++;

                }

                else

                {

                    ctu.m_encData->m_frameStats.cntIntraPu[depth] += 1ULL << shift;

                    ctu.m_encData->m_frameStats.totalPu[depth] += 1ULL << shift;

                }

            }

            else if (mode == 3)

            {

                ctu.m_encData->m_frameStats.cntAmp[depth] += 1ULL << shift;

                ctu.m_encData->m_frameStats.totalPu[depth] += 1ULL << shift;

                break;

            }

            else

            {

                if (ctu.m_mergeFlag[puabsPartIdx + absPartIdx])

                    ctu.m_encData->m_frameStats.cntMergePu[depth][ctu.m_partSize[puabsPartIdx + absPartIdx]] += (1 << shift) / mode;

                else

                    ctu.m_encData->m_frameStats.cntInterPu[depth][ctu.m_partSize[puabsPartIdx + absPartIdx]] += (1 << shift) / mode;

                ctu.m_encData->m_frameStats.totalPu[depth] += (1 << shift) / mode;

            }

        }

    }

}

int32_t Analysis::loadTUDepth(CUGeom cuGeom, CUData parentCTU)

{

    float predDepth = 0;

    CUData* neighbourCU;

    uint8_t count = 0;

    int32_t maxTUDepth = -1;

    neighbourCU = &m_slice->m_refFrameList[0][0]->m_encData->m_picCTU[parentCTU.m_cuAddr];

    predDepth += neighbourCU->m_refTuDepth[cuGeom.geomRecurId];

    count++;

    if (m_slice->isInterB())

    {

        neighbourCU = &m_slice->m_refFrameList[1][0]->m_encData->m_picCTU[parentCTU.m_cuAddr];

        predDepth += neighbourCU->m_refTuDepth[cuGeom.geomRecurId];

        count++;

    }

    if (parentCTU.m_cuAbove)

    {

        predDepth += parentCTU.m_cuAbove->m_refTuDepth[cuGeom.geomRecurId];

        count++;

        if (parentCTU.m_cuAboveLeft)

        {

            predDepth += parentCTU.m_cuAboveLeft->m_refTuDepth[cuGeom.geomRecurId];

            count++;

        }

        if (parentCTU.m_cuAboveRight)

        {

            predDepth += parentCTU.m_cuAboveRight->m_refTuDepth[cuGeom.geomRecurId];

            count++;

        }

    }

    if (parentCTU.m_cuLeft)

    {

        predDepth += parentCTU.m_cuLeft->m_refTuDepth[cuGeom.geomRecurId];

        count++;

    }

    predDepth /= count;

    if (predDepth == 0)

        maxTUDepth = 0;

    else if (predDepth < 1)

        maxTUDepth = 1;

    else if (predDepth >= 1 && predDepth <= 1.5)

        maxTUDepth = 2;

    else if (predDepth > 1.5 && predDepth <= 2.5)

        maxTUDepth = 3;

    else

        maxTUDepth = -1;

    return maxTUDepth;

}

void Analysis::tryLossless(const CUGeom& cuGeom)

{

    ModeDepth& md = m_modeDepth[cuGeom.depth];

    if (!md.bestMode->distortion)

        /* already lossless */

        return;

    else if (md.bestMode->cu.isIntra(0))

    {

        md.pred[PRED_LOSSLESS].initCosts();

        md.pred[PRED_LOSSLESS].cu.initLosslessCU(md.bestMode->cu, cuGeom);

        PartSize size = (PartSize)md.pred[PRED_LOSSLESS].cu.m_partSize[0];

        checkIntra(md.pred[PRED_LOSSLESS], cuGeom, size);

        checkBestMode(md.pred[PRED_LOSSLESS], cuGeom.depth);

    }

    else

    {

        md.pred[PRED_LOSSLESS].initCosts();

        md.pred[PRED_LOSSLESS].cu.initLosslessCU(md.bestMode->cu, cuGeom);

        md.pred[PRED_LOSSLESS].predYuv.copyFromYuv(md.bestMode->predYuv);

        encodeResAndCalcRdInterCU(md.pred[PRED_LOSSLESS], cuGeom);

        checkBestMode(md.pred[PRED_LOSSLESS], cuGeom.depth);

    }

}

void Analysis::qprdRefine(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp, int32_t lqp)

{

    uint32_t depth = cuGeom.depth;

    ModeDepth& md = m_modeDepth[depth];

    md.bestMode = NULL;

    bool bDecidedDepth = parentCTU.m_cuDepth[cuGeom.absPartIdx] == depth;

    int bestCUQP = qp;

    int lambdaQP = lqp;

    bool doQPRefine = (bDecidedDepth && depth <= m_slice->m_pps->maxCuDQPDepth) || (!bDecidedDepth && depth == m_slice->m_pps->maxCuDQPDepth);

    if (m_param->analysisLoadReuseLevel >= 7)

        doQPRefine = false;

    if (doQPRefine)

    {

        uint64_t bestCUCost, origCUCost, cuCost, cuPrevCost;

        int cuIdx = (cuGeom.childOffset - 1) / 3;

        bestCUCost = origCUCost = cacheCost[cuIdx];

        int direction = m_param->bOptCUDeltaQP ? 1 : 2;

        for (int dir = direction; dir >= -direction; dir -= (direction * 2))

        {

            if (m_param->bOptCUDeltaQP && ((dir != 1) || ((qp + 3) >= (int32_t)parentCTU.m_meanQP)))

                break;

            int threshold = 1;

            int failure = 0;

            cuPrevCost = origCUCost;

            int modCUQP = qp + dir;

            while (modCUQP >= m_param->rc.qpMin && modCUQP <= QP_MAX_SPEC)

            {

                if (m_param->bOptCUDeltaQP && modCUQP > (int32_t)parentCTU.m_meanQP)

                    break;

                recodeCU(parentCTU, cuGeom, modCUQP, qp);

                cuCost = md.bestMode->rdCost;

                COPY2_IF_LT(bestCUCost, cuCost, bestCUQP, modCUQP);

                if (cuCost < cuPrevCost)

                    failure = 0;

                else

                    failure++;

                if (failure > threshold)

                    break;

                cuPrevCost = cuCost;

                modCUQP += dir;

            }

        }

        lambdaQP = bestCUQP;

    }

    recodeCU(parentCTU, cuGeom, bestCUQP, lambdaQP);

    /* Copy best data to encData CTU and recon */

    md.bestMode->cu.copyToPic(depth);

    md.bestMode->reconYuv.copyToPicYuv(*m_frame->m_reconPic, parentCTU.m_cuAddr, cuGeom.absPartIdx);

}

uint64_t Analysis::compressIntraCU(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp)

{

    uint32_t depth = cuGeom.depth;

    ModeDepth& md = m_modeDepth[depth];

    md.bestMode = NULL;

    bool mightSplit = !(cuGeom.flags & CUGeom::LEAF);

    bool mightNotSplit = !(cuGeom.flags & CUGeom::SPLIT_MANDATORY);

    bool bAlreadyDecided = m_param->intraRefine != 4 && parentCTU.m_lumaIntraDir[cuGeom.absPartIdx] != (uint8_t)ALL_IDX && !(m_param->bAnalysisType == HEVC_INFO);

    bool bDecidedDepth = m_param->intraRefine != 4 && parentCTU.m_cuDepth[cuGeom.absPartIdx] == depth;

    int split = 0;

    if (m_param->intraRefine && m_param->intraRefine != 4)

    {

        split = m_param->scaleFactor && bDecidedDepth && (!mightNotSplit || 

            ((cuGeom.log2CUSize == (uint32_t)(g_log2Size[m_param->minCUSize] + 1))));

        if (cuGeom.log2CUSize == (uint32_t)(g_log2Size[m_param->minCUSize]) && !bDecidedDepth)

            bAlreadyDecided = false;

    }

    if (bAlreadyDecided)

    {

        if (bDecidedDepth && mightNotSplit)

        {

            Mode& mode = md.pred[0];

            md.bestMode = &mode;

            mode.cu.initSubCU(parentCTU, cuGeom, qp);

            bool reuseModes = !((m_param->intraRefine == 3) ||

                                (m_param->intraRefine == 2 && parentCTU.m_lumaIntraDir[cuGeom.absPartIdx] > DC_IDX));

            if (reuseModes)

            {

                memcpy(mode.cu.m_lumaIntraDir, parentCTU.m_lumaIntraDir + cuGeom.absPartIdx, cuGeom.numPartitions);

                memcpy(mode.cu.m_chromaIntraDir, parentCTU.m_chromaIntraDir + cuGeom.absPartIdx, cuGeom.numPartitions);

            }

            checkIntra(mode, cuGeom, (PartSize)parentCTU.m_partSize[cuGeom.absPartIdx]);

            if (m_bTryLossless)

                tryLossless(cuGeom);

            if (mightSplit)

                addSplitFlagCost(*md.bestMode, cuGeom.depth);

        }

    }

    else if (cuGeom.log2CUSize != MAX_LOG2_CU_SIZE && mightNotSplit)

    {

        md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom, qp);

        checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N);

        checkBestMode(md.pred[PRED_INTRA], depth);

        if (cuGeom.log2CUSize == 3 && m_slice->m_sps->quadtreeTULog2MinSize < 3)

        {

            md.pred[PRED_INTRA_NxN].cu.initSubCU(parentCTU, cuGeom, qp);

            checkIntra(md.pred[PRED_INTRA_NxN], cuGeom, SIZE_NxN);

            checkBestMode(md.pred[PRED_INTRA_NxN], depth);

        }

        if (m_bTryLossless)

            tryLossless(cuGeom);

        if (mightSplit)

            addSplitFlagCost(*md.bestMode, cuGeom.depth);

    }

    // stop recursion if we reach the depth of previous analysis decision

    mightSplit &= !(bAlreadyDecided && bDecidedDepth) || split;

    if (mightSplit)

    {

        Mode* splitPred = &md.pred[PRED_SPLIT];

        splitPred->initCosts();

        CUData* splitCU = &splitPred->cu;

        splitCU->initSubCU(parentCTU, cuGeom, qp);

        uint32_t nextDepth = depth + 1;

        ModeDepth& nd = m_modeDepth[nextDepth];

        invalidateContexts(nextDepth);

        Entropy* nextContext = &m_rqt[depth].cur;

        int32_t nextQP = qp;

        uint64_t curCost = 0;

        int skipSplitCheck = 0;

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

        {

            const CUGeom& childGeom = *(&cuGeom + cuGeom.childOffset + subPartIdx);

            if (childGeom.flags & CUGeom::PRESENT)

            {

                m_modeDepth[0].fencYuv.copyPartToYuv(nd.fencYuv, childGeom.absPartIdx);

                m_rqt[nextDepth].cur.load(*nextContext);

                if (m_slice->m_pps->bUseDQP && nextDepth <= m_slice->m_pps->maxCuDQPDepth)

                    nextQP = setLambdaFromQP(parentCTU, calculateQpforCuSize(parentCTU, childGeom));

                if (m_param->bEnableSplitRdSkip)

                {

                    curCost += compressIntraCU(parentCTU, childGeom, nextQP);

                    if (m_modeDepth[depth].bestMode && curCost > m_modeDepth[depth].bestMode->rdCost)

                    {

                        skipSplitCheck = 1;

                        break;

                    }

                }

                else

                    compressIntraCU(parentCTU, childGeom, nextQP);

                // Save best CU and pred data for this sub CU

                splitCU->copyPartFrom(nd.bestMode->cu, childGeom, subPartIdx);

                splitPred->addSubCosts(*nd.bestMode);

                nd.bestMode->reconYuv.copyToPartYuv(splitPred->reconYuv, childGeom.numPartitions * subPartIdx);

                nextContext = &nd.bestMode->contexts;

            }

            else

            {

                /* record the depth of this non-present sub-CU */

                splitCU->setEmptyPart(childGeom, subPartIdx);

                /* Set depth of non-present CU to 0 to ensure that correct CU is fetched as reference to code deltaQP */

                if (bAlreadyDecided)

                    memset(parentCTU.m_cuDepth + childGeom.absPartIdx, 0, childGeom.numPartitions);

            }

        }

        if (!skipSplitCheck)

        {

            nextContext->store(splitPred->contexts);

            if (mightNotSplit)

                addSplitFlagCost(*splitPred, cuGeom.depth);

            else

                updateModeCost(*splitPred);

            checkDQPForSplitPred(*splitPred, cuGeom);

            checkBestMode(*splitPred, depth);

        }

    }

    if (m_param->bEnableRdRefine && depth <= m_slice->m_pps->maxCuDQPDepth)

    {

        int cuIdx = (cuGeom.childOffset - 1) / 3;

        cacheCost[cuIdx] = md.bestMode->rdCost;

    }

    if ((m_limitTU & X265_TU_LIMIT_NEIGH) && cuGeom.log2CUSize >= 4)

    {

        CUData* ctu = md.bestMode->cu.m_encData->getPicCTU(parentCTU.m_cuAddr);

        int8_t maxTUDepth = -1;

        for (uint32_t i = 0; i < cuGeom.numPartitions; i++)

            maxTUDepth = X265_MAX(maxTUDepth, md.bestMode->cu.m_tuDepth[i]);

        ctu->m_refTuDepth[cuGeom.geomRecurId] = maxTUDepth;

    }

    /* Copy best data to encData CTU and recon */

    md.bestMode->cu.copyToPic(depth);

    if (md.bestMode != &md.pred[PRED_SPLIT])

        md.bestMode->reconYuv.copyToPicYuv(*m_frame->m_reconPic, parentCTU.m_cuAddr, cuGeom.absPartIdx);

    return md.bestMode->rdCost;

}

void Analysis::PMODE::processTasks(int workerThreadId)

{

#if DETAILED_CU_STATS

    int fe = master.m_modeDepth[cuGeom.depth].pred[PRED_2Nx2N].cu.m_encData->m_frameEncoderID;

    master.m_stats[fe].countPModeTasks++;

    ScopedElapsedTime pmodeTime(master.m_stats[fe].pmodeTime);

#endif

    ProfileScopeEvent(pmode);

    master.processPmode(*this, master.m_tld[workerThreadId].analysis);

}

/* process pmode jobs until none remain; may be called by the master thread or by

 * a bonded peer (slave) thread via pmodeTasks() */

void Analysis::processPmode(PMODE& pmode, Analysis& slave)

{

    /* acquire a mode task, else exit early */

    int task;

    pmode.m_lock.acquire();

    if (pmode.m_jobTotal > pmode.m_jobAcquired)

    {

        task = pmode.m_jobAcquired++;

        pmode.m_lock.release();

    }

    else

    {

        pmode.m_lock.release();

        return;

    }

    ModeDepth& md = m_modeDepth[pmode.cuGeom.depth];

    /* setup slave Analysis */

    if (&slave != this)

    {

        slave.m_slice = m_slice;

        slave.m_frame = m_frame;

        slave.m_param = m_param;

        slave.m_bChromaSa8d = m_param->rdLevel >= 3;

        slave.setLambdaFromQP(md.pred[PRED_2Nx2N].cu, m_rdCost.m_qp);

        slave.invalidateContexts(0);

        slave.m_rqt[pmode.cuGeom.depth].cur.load(m_rqt[pmode.cuGeom.depth].cur);

    }

    /* perform Mode task, repeat until no more work is available */

    do

    {

        uint32_t refMasks[2] = { 0, 0 };

        if (m_param->rdLevel <= 4)

        {

            switch (pmode.modes[task])

            {

            case PRED_INTRA:

                slave.checkIntraInInter(md.pred[PRED_INTRA], pmode.cuGeom);

                if (m_param->rdLevel > 2)

                    slave.encodeIntraInInter(md.pred[PRED_INTRA], pmode.cuGeom);

                break;

            case PRED_2Nx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3];

                slave.checkInter_rd0_4(md.pred[PRED_2Nx2N], pmode.cuGeom, SIZE_2Nx2N, refMasks);

                if (m_slice->m_sliceType == B_SLICE)

                    slave.checkBidir2Nx2N(md.pred[PRED_2Nx2N], md.pred[PRED_BIDIR], pmode.cuGeom);

                break;

            case PRED_Nx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[2]; /* left */

                refMasks[1] = m_splitRefIdx[1] | m_splitRefIdx[3]; /* right */

                slave.checkInter_rd0_4(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N, refMasks);

                break;

            case PRED_2NxN:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1]; /* top */

                refMasks[1] = m_splitRefIdx[2] | m_splitRefIdx[3]; /* bot */

                slave.checkInter_rd0_4(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN, refMasks);

                break;

            case PRED_2NxnU:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1]; /* 25% top */

                refMasks[1] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% bot */

                slave.checkInter_rd0_4(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU, refMasks);

                break;

            case PRED_2NxnD:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% top */

                refMasks[1] = m_splitRefIdx[2] | m_splitRefIdx[3]; /* 25% bot */

                slave.checkInter_rd0_4(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD, refMasks);

                break;

            case PRED_nLx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[2]; /* 25% left */

                refMasks[1] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% right */

                slave.checkInter_rd0_4(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N, refMasks);

                break;

            case PRED_nRx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% left */

                refMasks[1] = m_splitRefIdx[1] | m_splitRefIdx[3]; /* 25% right */

                slave.checkInter_rd0_4(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N, refMasks);

                break;

            default:

                X265_CHECK(0, "invalid job ID for parallel mode analysis\n");

                break;

            }

        }

        else

        {

            switch (pmode.modes[task])

            {

            case PRED_INTRA:

                slave.checkIntra(md.pred[PRED_INTRA], pmode.cuGeom, SIZE_2Nx2N);

                if (pmode.cuGeom.log2CUSize == 3 && m_slice->m_sps->quadtreeTULog2MinSize < 3)

                    slave.checkIntra(md.pred[PRED_INTRA_NxN], pmode.cuGeom, SIZE_NxN);

                break;

            case PRED_2Nx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3];

                slave.checkInter_rd5_6(md.pred[PRED_2Nx2N], pmode.cuGeom, SIZE_2Nx2N, refMasks);

                md.pred[PRED_BIDIR].rdCost = MAX_INT64;

                if (m_slice->m_sliceType == B_SLICE)

                {

                    slave.checkBidir2Nx2N(md.pred[PRED_2Nx2N], md.pred[PRED_BIDIR], pmode.cuGeom);

                    if (md.pred[PRED_BIDIR].sa8dCost < MAX_INT64)

                        slave.encodeResAndCalcRdInterCU(md.pred[PRED_BIDIR], pmode.cuGeom);

                }

                break;

            case PRED_Nx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[2]; /* left */

                refMasks[1] = m_splitRefIdx[1] | m_splitRefIdx[3]; /* right */

                slave.checkInter_rd5_6(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N, refMasks);

                break;

            case PRED_2NxN:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1]; /* top */

                refMasks[1] = m_splitRefIdx[2] | m_splitRefIdx[3]; /* bot */

                slave.checkInter_rd5_6(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN, refMasks);

                break;

            case PRED_2NxnU:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1]; /* 25% top */

                refMasks[1] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% bot */

                slave.checkInter_rd5_6(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU, refMasks);

                break;

            case PRED_2NxnD:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% top */

                refMasks[1] = m_splitRefIdx[2] | m_splitRefIdx[3]; /* 25% bot */

                slave.checkInter_rd5_6(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD, refMasks);

                break;

            case PRED_nLx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[2]; /* 25% left */

                refMasks[1] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% right */

                slave.checkInter_rd5_6(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N, refMasks);

                break;

            case PRED_nRx2N:

                refMasks[0] = m_splitRefIdx[0] | m_splitRefIdx[1] | m_splitRefIdx[2] | m_splitRefIdx[3]; /* 75% left */

                refMasks[1] = m_splitRefIdx[1] | m_splitRefIdx[3]; /* 25% right */

                slave.checkInter_rd5_6(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N, refMasks);

                break;

            default:

                X265_CHECK(0, "invalid job ID for parallel mode analysis\n");

                break;

            }

        }

        task = -1;

        pmode.m_lock.acquire();

        if (pmode.m_jobTotal > pmode.m_jobAcquired)

            task = pmode.m_jobAcquired++;

        pmode.m_lock.release();

    }

    while (task >= 0);

}

uint32_t Analysis::compressInterCU_dist(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp)

{

    uint32_t depth = cuGeom.depth;

    uint32_t cuAddr = parentCTU.m_cuAddr;

    ModeDepth& md = m_modeDepth[depth];

    md.bestMode = NULL;

    bool mightSplit = !(cuGeom.flags & CUGeom::LEAF);

    bool mightNotSplit = !(cuGeom.flags & CUGeom::SPLIT_MANDATORY);

    uint32_t minDepth = m_param->rdLevel <= 4 ? topSkipMinDepth(parentCTU, cuGeom) : 0;

    uint32_t splitRefs[4] = { 0, 0, 0, 0 };

    X265_CHECK(m_param->rdLevel >= 2, "compressInterCU_dist does not support RD 0 or 1\n");

    PMODE pmode(*this, cuGeom);

    if (mightNotSplit && depth >= minDepth)

    {

        /* Initialize all prediction CUs based on parentCTU */

        md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom, qp);

        md.pred[PRED_SKIP].cu.initSubCU(parentCTU, cuGeom, qp);

        if (m_param->rdLevel <= 4)

            checkMerge2Nx2N_rd0_4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);

        else

            checkMerge2Nx2N_rd5_6(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);

    }

    bool bNoSplit = false;

    bool splitIntra = true;

    if (md.bestMode)

    {

        bNoSplit = md.bestMode->cu.isSkipped(0);

        if (mightSplit && depth && depth >= minDepth && !bNoSplit && m_param->rdLevel <= 4)

            bNoSplit = recursionDepthCheck(parentCTU, cuGeom, *md.bestMode);