[x265] [PATCH] analysis: cleanup intra analysis functions
Steve Borho
steve at borho.org
Thu Oct 8 21:45:30 CEST 2015
On 10/08, kavitha at multicorewareinc.com wrote:
> # HG changeset patch
> # User Kavitha Sampath <kavitha at multicorewareinc.com>
> # Date 1444301894 -19800
> # Thu Oct 08 16:28:14 2015 +0530
> # Node ID bd8087bfd93f7564df436a27c22f7e44f6803c4a
> # Parent 55a4a9b920ff0385fd0b65c73c4c3f63b8a8cc65
> analysis: cleanup intra analysis functions
>
> During the analysis-load mode, the predicted luma and chroma modes saved in
> shared buffers are no longer passed explicitly to intra analysis functions.
> Instead the predicted modes are copied to parentCTU, thereby enabling the intra
> analysis functions to decide implicitly if modes should be reused.
LGTM
> diff -r 55a4a9b920ff -r bd8087bfd93f source/common/cudata.cpp
> --- a/source/common/cudata.cpp Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/common/cudata.cpp Thu Oct 08 16:28:14 2015 +0530
> @@ -199,6 +199,7 @@
> m_qp = (int8_t*)charBuf; charBuf += m_numPartitions;
> m_log2CUSize = charBuf; charBuf += m_numPartitions;
> m_lumaIntraDir = charBuf; charBuf += m_numPartitions;
> + m_chromaIntraDir = charBuf; charBuf += m_numPartitions;
> m_tqBypass = charBuf; charBuf += m_numPartitions;
> m_refIdx[0] = (int8_t*)charBuf; charBuf += m_numPartitions;
> m_refIdx[1] = (int8_t*)charBuf; charBuf += m_numPartitions;
> @@ -216,7 +217,6 @@
> m_cbf[0] = charBuf; charBuf += m_numPartitions;
> m_cbf[1] = charBuf; charBuf += m_numPartitions;
> m_cbf[2] = charBuf; charBuf += m_numPartitions;
> - m_chromaIntraDir = charBuf; charBuf += m_numPartitions;
>
> X265_CHECK(charBuf == dataPool.charMemBlock + (m_numPartitions * BytesPerPartition) * (instance + 1), "CU data layout is broken\n");
>
> @@ -246,7 +246,8 @@
> /* sequential memsets */
> m_partSet((uint8_t*)m_qp, (uint8_t)qp);
> m_partSet(m_log2CUSize, (uint8_t)g_maxLog2CUSize);
> - m_partSet(m_lumaIntraDir, (uint8_t)DC_IDX);
> + m_partSet(m_lumaIntraDir, (uint8_t)ALL_IDX);
> + m_partSet(m_chromaIntraDir, (uint8_t)ALL_IDX);
> m_partSet(m_tqBypass, (uint8_t)frame.m_encData->m_param->bLossless);
> if (m_slice->m_sliceType != I_SLICE)
> {
> @@ -257,7 +258,7 @@
> X265_CHECK(!(frame.m_encData->m_param->bLossless && !m_slice->m_pps->bTransquantBypassEnabled), "lossless enabled without TQbypass in PPS\n");
>
> /* initialize the remaining CU data in one memset */
> - memset(m_cuDepth, 0, (BytesPerPartition - 6) * m_numPartitions);
> + memset(m_cuDepth, 0, (BytesPerPartition - 7) * m_numPartitions);
>
> uint32_t widthInCU = m_slice->m_sps->numCuInWidth;
> m_cuLeft = (m_cuAddr % widthInCU) ? m_encData->getPicCTU(m_cuAddr - 1) : NULL;
> @@ -284,14 +285,15 @@
> m_partSet((uint8_t*)m_qp, (uint8_t)qp);
>
> m_partSet(m_log2CUSize, (uint8_t)cuGeom.log2CUSize);
> - m_partSet(m_lumaIntraDir, (uint8_t)DC_IDX);
> m_partSet(m_tqBypass, (uint8_t)m_encData->m_param->bLossless);
> m_partSet((uint8_t*)m_refIdx[0], (uint8_t)REF_NOT_VALID);
> m_partSet((uint8_t*)m_refIdx[1], (uint8_t)REF_NOT_VALID);
> m_partSet(m_cuDepth, (uint8_t)cuGeom.depth);
> + memcpy(m_lumaIntraDir, ctu.m_lumaIntraDir + cuGeom.absPartIdx, cuGeom.numPartitions);
> + memcpy(m_chromaIntraDir, ctu.m_chromaIntraDir + cuGeom.absPartIdx, cuGeom.numPartitions);
>
> /* initialize the remaining CU data in one memset */
> - memset(m_predMode, 0, (BytesPerPartition - 7) * m_numPartitions);
> + memset(m_predMode, 0, (BytesPerPartition - 8) * m_numPartitions);
> }
>
> /* Copy the results of a sub-part (split) CU to the parent CU */
> diff -r 55a4a9b920ff -r bd8087bfd93f source/common/cudata.h
> --- a/source/common/cudata.h Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/common/cudata.h Thu Oct 08 16:28:14 2015 +0530
> @@ -287,6 +287,12 @@
> const CUData* getPUAboveRightAdi(uint32_t& arPartUnitIdx, uint32_t curPartUnitIdx, uint32_t partUnitOffset) const;
> const CUData* getPUBelowLeftAdi(uint32_t& blPartUnitIdx, uint32_t curPartUnitIdx, uint32_t partUnitOffset) const;
>
> + inline void resetIntraModes(bool resetLuma, bool resetChroma)
> + {
> + if (resetLuma) m_partSet(m_lumaIntraDir, (uint8_t)ALL_IDX);
> + if (resetChroma) m_partSet(m_chromaIntraDir, (uint8_t)ALL_IDX);
> + }
> +
> protected:
>
> template<typename T>
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/analysis.cpp
> --- a/source/encoder/analysis.cpp Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/analysis.cpp Thu Oct 08 16:28:14 2015 +0530
> @@ -72,7 +72,6 @@
>
> Analysis::Analysis()
> {
> - m_reuseIntraDataCTU = NULL;
> m_reuseInterDataCTU = NULL;
> m_reuseRef = NULL;
> m_reuseBestMergeCand = NULL;
> @@ -141,17 +140,12 @@
> m_modeDepth[0].fencYuv.copyFromPicYuv(*m_frame->m_fencPic, ctu.m_cuAddr, 0);
>
> uint32_t numPartition = ctu.m_numPartitions;
> - if (m_param->analysisMode)
> + if (m_param->analysisMode && m_slice->m_sliceType != I_SLICE)
> {
> - if (m_slice->m_sliceType == I_SLICE)
> - m_reuseIntraDataCTU = (analysis_intra_data*)m_frame->m_analysisData.intraData;
> - else
> - {
> - int numPredDir = m_slice->isInterP() ? 1 : 2;
> - m_reuseInterDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
> - m_reuseRef = &m_reuseInterDataCTU->ref[ctu.m_cuAddr * X265_MAX_PRED_MODE_PER_CTU * numPredDir];
> - m_reuseBestMergeCand = &m_reuseInterDataCTU->bestMergeCand[ctu.m_cuAddr * CUGeom::MAX_GEOMS];
> - }
> + int numPredDir = m_slice->isInterP() ? 1 : 2;
> + m_reuseInterDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
> + m_reuseRef = &m_reuseInterDataCTU->ref[ctu.m_cuAddr * X265_MAX_PRED_MODE_PER_CTU * numPredDir];
> + m_reuseBestMergeCand = &m_reuseInterDataCTU->bestMergeCand[ctu.m_cuAddr * CUGeom::MAX_GEOMS];
> }
>
> ProfileCUScope(ctu, totalCTUTime, totalCTUs);
> @@ -159,14 +153,22 @@
> uint32_t zOrder = 0;
> if (m_slice->m_sliceType == I_SLICE)
> {
> + analysis_intra_data* intraDataCTU = (analysis_intra_data*)m_frame->m_analysisData.intraData;
> + if (m_param->analysisMode == X265_ANALYSIS_LOAD)
> + {
> + 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, zOrder, qp);
> - if (m_param->analysisMode == X265_ANALYSIS_SAVE && m_frame->m_analysisData.intraData)
> + if (m_param->analysisMode == X265_ANALYSIS_SAVE && intraDataCTU)
> {
> CUData* bestCU = &m_modeDepth[0].bestMode->cu;
> - memcpy(&m_reuseIntraDataCTU->depth[ctu.m_cuAddr * numPartition], bestCU->m_cuDepth, sizeof(uint8_t) * numPartition);
> - memcpy(&m_reuseIntraDataCTU->modes[ctu.m_cuAddr * numPartition], bestCU->m_lumaIntraDir, sizeof(uint8_t) * numPartition);
> - memcpy(&m_reuseIntraDataCTU->partSizes[ctu.m_cuAddr * numPartition], bestCU->m_partSize, sizeof(uint8_t) * numPartition);
> - memcpy(&m_reuseIntraDataCTU->chromaModes[ctu.m_cuAddr * numPartition], bestCU->m_chromaIntraDir, sizeof(uint8_t) * numPartition);
> + memcpy(&intraDataCTU->depth[ctu.m_cuAddr * numPartition], bestCU->m_cuDepth, sizeof(uint8_t) * numPartition);
> + memcpy(&intraDataCTU->modes[ctu.m_cuAddr * numPartition], bestCU->m_lumaIntraDir, sizeof(uint8_t) * numPartition);
> + memcpy(&intraDataCTU->partSizes[ctu.m_cuAddr * numPartition], bestCU->m_partSize, sizeof(uint8_t) * numPartition);
> + memcpy(&intraDataCTU->chromaModes[ctu.m_cuAddr * numPartition], bestCU->m_chromaIntraDir, sizeof(uint8_t) * numPartition);
> }
> }
> else
> @@ -213,8 +215,7 @@
> 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];
> - uint8_t* modes = md.pred[PRED_LOSSLESS].cu.m_lumaIntraDir;
> - checkIntra(md.pred[PRED_LOSSLESS], cuGeom, size, modes, NULL);
> + checkIntra(md.pred[PRED_LOSSLESS], cuGeom, size);
this has the additional benefit of making --cu-lossless slightly more
compute efficient. It doesn't have to redo the intra angle analysis.
> checkBestMode(md.pred[PRED_LOSSLESS], cuGeom.depth);
> }
> else
> @@ -236,42 +237,37 @@
> bool mightSplit = !(cuGeom.flags & CUGeom::LEAF);
> bool mightNotSplit = !(cuGeom.flags & CUGeom::SPLIT_MANDATORY);
>
> - if (m_param->analysisMode == X265_ANALYSIS_LOAD)
> + bool bAlreadyDecided = parentCTU.m_lumaIntraDir[cuGeom.absPartIdx] != (uint8_t)ALL_IDX;
> + bool bDecidedDepth = parentCTU.m_cuDepth[cuGeom.absPartIdx] == depth;
> +
> + // stop recursion if we reach the depth of previous analysis decision
> + mightSplit &= !(bAlreadyDecided && bDecidedDepth);
> +
> + if (bAlreadyDecided)
> {
> - uint8_t* reuseDepth = &m_reuseIntraDataCTU->depth[parentCTU.m_cuAddr * parentCTU.m_numPartitions];
> - uint8_t* reuseModes = &m_reuseIntraDataCTU->modes[parentCTU.m_cuAddr * parentCTU.m_numPartitions];
> - char* reusePartSizes = &m_reuseIntraDataCTU->partSizes[parentCTU.m_cuAddr * parentCTU.m_numPartitions];
> - uint8_t* reuseChromaModes = &m_reuseIntraDataCTU->chromaModes[parentCTU.m_cuAddr * parentCTU.m_numPartitions];
> -
> - if (mightNotSplit && depth == reuseDepth[zOrder] && zOrder == cuGeom.absPartIdx)
> + if (bDecidedDepth)
> {
> - PartSize size = (PartSize)reusePartSizes[zOrder];
> - Mode& mode = size == SIZE_2Nx2N ? md.pred[PRED_INTRA] : md.pred[PRED_INTRA_NxN];
> + Mode& mode = md.pred[0];
> + md.bestMode = &mode;
> mode.cu.initSubCU(parentCTU, cuGeom, qp);
> - checkIntra(mode, cuGeom, size, &reuseModes[zOrder], &reuseChromaModes[zOrder]);
> - checkBestMode(mode, depth);
> -
> + checkIntra(mode, cuGeom, (PartSize)parentCTU.m_partSize[cuGeom.absPartIdx]);
> if (m_bTryLossless)
> tryLossless(cuGeom);
>
> if (mightSplit)
> addSplitFlagCost(*md.bestMode, cuGeom.depth);
> -
> - // increment zOrder offset to point to next best depth in sharedDepth buffer
> - zOrder += g_depthInc[g_maxCUDepth - 1][reuseDepth[zOrder]];
> - mightSplit = false;
> }
> }
> else if (mightNotSplit)
> {
> md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom, qp);
> - checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N, NULL, NULL);
> + 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, NULL, NULL);
> + checkIntra(md.pred[PRED_INTRA_NxN], cuGeom, SIZE_NxN);
> checkBestMode(md.pred[PRED_INTRA_NxN], depth);
> }
>
> @@ -389,6 +385,7 @@
> switch (pmode.modes[task])
> {
> case PRED_INTRA:
> + md.pred[PRED_INTRA].cu.resetIntraModes(true, true);
> slave.checkIntraInInter(md.pred[PRED_INTRA], pmode.cuGeom);
> if (m_param->rdLevel > 2)
> slave.encodeIntraInInter(md.pred[PRED_INTRA], pmode.cuGeom);
> @@ -454,9 +451,10 @@
> switch (pmode.modes[task])
> {
> case PRED_INTRA:
> - slave.checkIntra(md.pred[PRED_INTRA], pmode.cuGeom, SIZE_2Nx2N, NULL, NULL);
> + md.pred[PRED_INTRA].cu.resetIntraModes(true, true);
> + 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, NULL, NULL);
> + slave.checkIntra(md.pred[PRED_INTRA_NxN], pmode.cuGeom, SIZE_NxN);
> break;
>
> case PRED_2Nx2N:
> @@ -720,6 +718,7 @@
> if (bTryIntra && md.pred[PRED_INTRA].sa8dCost < md.bestMode->sa8dCost)
> {
> md.bestMode = &md.pred[PRED_INTRA];
> + md.bestMode->cu.resetIntraModes(false, true);
> encodeIntraInInter(*md.bestMode, cuGeom);
> }
> else if (!md.bestMode->cu.m_mergeFlag[0])
> @@ -1026,6 +1025,7 @@
> {
> ProfileCounter(parentCTU, totalIntraCU[cuGeom.depth]);
> md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom, qp);
> + md.pred[PRED_INTRA].cu.resetIntraModes(true, true);
> checkIntraInInter(md.pred[PRED_INTRA], cuGeom);
> encodeIntraInInter(md.pred[PRED_INTRA], cuGeom);
> checkBestMode(md.pred[PRED_INTRA], depth);
> @@ -1052,6 +1052,7 @@
> {
> ProfileCounter(parentCTU, totalIntraCU[cuGeom.depth]);
> md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom, qp);
> + md.pred[PRED_INTRA].cu.resetIntraModes(true, false);
> checkIntraInInter(md.pred[PRED_INTRA], cuGeom);
> if (md.pred[PRED_INTRA].sa8dCost < md.bestMode->sa8dCost)
> md.bestMode = &md.pred[PRED_INTRA];
> @@ -1104,7 +1105,10 @@
> else
> {
> if (m_param->rdLevel == 2)
> + {
> + md.bestMode->cu.resetIntraModes(false, true);
> encodeIntraInInter(*md.bestMode, cuGeom);
> + }
> else if (m_param->rdLevel == 1)
> {
> /* generate recon pixels with no rate distortion considerations */
> @@ -1374,13 +1378,15 @@
> {
> ProfileCounter(parentCTU, totalIntraCU[cuGeom.depth]);
> md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom, qp);
> - checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N, NULL, NULL);
> + md.pred[PRED_INTRA].cu.resetIntraModes(true, true);
> + 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, NULL, NULL);
> + md.pred[PRED_INTRA_NxN].cu.resetIntraModes(true, true);
> + checkIntra(md.pred[PRED_INTRA_NxN], cuGeom, SIZE_NxN);
> checkBestMode(md.pred[PRED_INTRA_NxN], depth);
> }
> }
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/analysis.h
> --- a/source/encoder/analysis.h Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/analysis.h Thu Oct 08 16:28:14 2015 +0530
> @@ -104,7 +104,6 @@
> protected:
>
> /* Analysis data for load/save modes, keeps getting incremented as CTU analysis proceeds and data is consumed or read */
> - analysis_intra_data* m_reuseIntraDataCTU;
> analysis_inter_data* m_reuseInterDataCTU;
> int32_t* m_reuseRef;
> uint32_t* m_reuseBestMergeCand;
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/search.cpp
> --- a/source/encoder/search.cpp Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/search.cpp Thu Oct 08 16:28:14 2015 +0530
> @@ -1157,7 +1157,7 @@
> }
> }
>
> -void Search::checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize partSize, uint8_t* sharedModes, uint8_t* sharedChromaModes)
> +void Search::checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize partSize)
> {
> CUData& cu = intraMode.cu;
>
> @@ -1168,8 +1168,8 @@
> cu.getIntraTUQtDepthRange(tuDepthRange, 0);
>
> intraMode.initCosts();
> - intraMode.lumaDistortion += estIntraPredQT(intraMode, cuGeom, tuDepthRange, sharedModes);
> - intraMode.chromaDistortion += estIntraPredChromaQT(intraMode, cuGeom, sharedChromaModes);
> + intraMode.lumaDistortion += estIntraPredQT(intraMode, cuGeom, tuDepthRange);
> + intraMode.chromaDistortion += estIntraPredChromaQT(intraMode, cuGeom);
> intraMode.distortion += intraMode.lumaDistortion + intraMode.chromaDistortion;
>
> m_entropyCoder.resetBits();
> @@ -1388,7 +1388,7 @@
> extractIntraResultQT(cu, *reconYuv, 0, 0);
>
> intraMode.lumaDistortion = icosts.distortion;
> - intraMode.chromaDistortion = estIntraPredChromaQT(intraMode, cuGeom, NULL);
> + intraMode.chromaDistortion = estIntraPredChromaQT(intraMode, cuGeom);
> intraMode.distortion = intraMode.lumaDistortion + intraMode.chromaDistortion;
>
> m_entropyCoder.resetBits();
> @@ -1416,7 +1416,7 @@
> checkDQP(intraMode, cuGeom);
> }
>
> -uint32_t Search::estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom, const uint32_t depthRange[2], uint8_t* sharedModes)
> +uint32_t Search::estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom, const uint32_t depthRange[2])
> {
> CUData& cu = intraMode.cu;
> Yuv* reconYuv = &intraMode.reconYuv;
> @@ -1440,8 +1440,8 @@
> {
> uint32_t bmode = 0;
>
> - if (sharedModes)
> - bmode = sharedModes[puIdx];
> + if (intraMode.cu.m_lumaIntraDir[puIdx] != (uint8_t)ALL_IDX)
> + bmode = intraMode.cu.m_lumaIntraDir[puIdx];
> else
> {
> uint64_t candCostList[MAX_RD_INTRA_MODES];
> @@ -1680,7 +1680,7 @@
> cu.setChromIntraDirSubParts(bestMode, 0, cuGeom.depth);
> }
>
> -uint32_t Search::estIntraPredChromaQT(Mode &intraMode, const CUGeom& cuGeom, uint8_t* sharedChromaModes)
> +uint32_t Search::estIntraPredChromaQT(Mode &intraMode, const CUGeom& cuGeom)
> {
> CUData& cu = intraMode.cu;
> Yuv& reconYuv = intraMode.reconYuv;
> @@ -1708,10 +1708,10 @@
> uint32_t maxMode = NUM_CHROMA_MODE;
> uint32_t modeList[NUM_CHROMA_MODE];
>
> - if (sharedChromaModes && !initTuDepth)
> + if (intraMode.cu.m_chromaIntraDir[0] != (uint8_t)ALL_IDX && !initTuDepth)
> {
> for (uint32_t l = 0; l < NUM_CHROMA_MODE; l++)
> - modeList[l] = sharedChromaModes[0];
> + modeList[l] = intraMode.cu.m_chromaIntraDir[0];
> maxMode = 1;
> }
> else
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/search.h
> --- a/source/encoder/search.h Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/search.h Thu Oct 08 16:28:14 2015 +0530
> @@ -338,8 +338,8 @@
> // mark temp RD entropy contexts as uninitialized; useful for finding loads without stores
> void invalidateContexts(int fromDepth);
>
> - // full RD search of intra modes. if sharedModes is not NULL, it directly uses them
> - void checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize partSize, uint8_t* sharedModes, uint8_t* sharedChromaModes);
> + // full RD search of intra modes
> + void checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize partSizes);
>
> // select best intra mode using only sa8d costs, cannot measure NxN intra
> void checkIntraInInter(Mode& intraMode, const CUGeom& cuGeom);
> @@ -405,10 +405,10 @@
> void saveResidualQTData(CUData& cu, ShortYuv& resiYuv, uint32_t absPartIdx, uint32_t tuDepth);
>
> // RDO search of luma intra modes; result is fully encoded luma. luma distortion is returned
> - uint32_t estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom, const uint32_t depthRange[2], uint8_t* sharedModes);
> + uint32_t estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom, const uint32_t depthRange[2]);
>
> // RDO select best chroma mode from luma; result is fully encode chroma. chroma distortion is returned
> - uint32_t estIntraPredChromaQT(Mode &intraMode, const CUGeom& cuGeom, uint8_t* sharedChromaModes);
> + uint32_t estIntraPredChromaQT(Mode &intraMode, const CUGeom& cuGeom);
>
> void codeSubdivCbfQTChroma(const CUData& cu, uint32_t tuDepth, uint32_t absPartIdx);
> void codeInterSubdivCbfQT(CUData& cu, uint32_t absPartIdx, const uint32_t tuDepth, const uint32_t depthRange[2]);
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> https://mailman.videolan.org/listinfo/x265-devel
--
Steve Borho
More information about the x265-devel
mailing list