[x265] [PATCH] rdLevel: reset rdLevels to 0-4
Steve Borho
steve at borho.org
Fri Mar 13 16:07:44 CET 2015
On 03/13, deepthi at multicorewareinc.com wrote:
> # HG changeset patch
> # User Deepthi Nandakumar <deepthi at multicorewareinc.com>
> # Date 1426245814 -19800
> # Fri Mar 13 16:53:34 2015 +0530
> # Node ID 77ae7adfed6fe47fc4fcd3461984b506c4edbee4
> # Parent c1a8eef8be143a40981ae6909c6c8c3a6b85901c
> rdLevel: reset rdLevels to 0-4.
>
> This change was already enabled by the rdoq-level change, since rdLevels 3,4
> were identical and so were 5,6. No output changes. Also changing the internal
> names of Analysis:: member methods and updating docs
I think the depth-first logic changes will give us ample opportunity to
differentiate 3 from 4 and 5 from 6
> diff -r c1a8eef8be14 -r 77ae7adfed6f doc/reST/cli.rst
> --- a/doc/reST/cli.rst Fri Mar 13 16:40:06 2015 +0530
> +++ b/doc/reST/cli.rst Fri Mar 13 16:53:34 2015 +0530
> @@ -489,11 +489,7 @@
> +-------+---------------------------------------------------------------+
> | 3 | RDO mode and split decisions, chroma residual used for sa8d |
> +-------+---------------------------------------------------------------+
> - | 4 | Currently same as 3 |
> - +-------+---------------------------------------------------------------+
> - | 5 | Adds RDO prediction decisions |
> - +-------+---------------------------------------------------------------+
> - | 6 | Currently same as 5 |
> + | 4 | Adds RDO prediction decisions |
> +-------+---------------------------------------------------------------+
>
> **Range of values:** 0: least .. 6: full RDO analysis
> diff -r c1a8eef8be14 -r 77ae7adfed6f source/common/param.cpp
> --- a/source/common/param.cpp Fri Mar 13 16:40:06 2015 +0530
> +++ b/source/common/param.cpp Fri Mar 13 16:53:34 2015 +0530
> @@ -321,7 +321,7 @@
> {
> param->bEnableRectInter = 1;
> param->lookaheadDepth = 25;
> - param->rdLevel = 4;
> + param->rdLevel = 3;
> param->rdoqLevel = 2;
> param->subpelRefine = 3;
> param->maxNumMergeCand = 3;
> @@ -336,7 +336,7 @@
> param->bframes = 8;
> param->tuQTMaxInterDepth = 2;
> param->tuQTMaxIntraDepth = 2;
> - param->rdLevel = 6;
> + param->rdLevel = 4;
> param->rdoqLevel = 2;
> param->subpelRefine = 3;
> param->maxNumMergeCand = 3;
> @@ -352,7 +352,7 @@
> param->bframes = 8;
> param->tuQTMaxInterDepth = 3;
> param->tuQTMaxIntraDepth = 3;
> - param->rdLevel = 6;
> + param->rdLevel = 4;
> param->rdoqLevel = 2;
> param->subpelRefine = 4;
> param->maxNumMergeCand = 4;
> @@ -370,7 +370,7 @@
> param->bframes = 8;
> param->tuQTMaxInterDepth = 4;
> param->tuQTMaxIntraDepth = 4;
> - param->rdLevel = 6;
> + param->rdLevel = 4;
> param->rdoqLevel = 2;
> param->subpelRefine = 5;
> param->maxNumMergeCand = 5;
> @@ -1049,7 +1049,7 @@
>
> CHECK(param->rc.rateControlMode > X265_RC_CRF || param->rc.rateControlMode < X265_RC_ABR,
> "Rate control mode is out of range");
> - CHECK(param->rdLevel < 0 || param->rdLevel > 6,
> + CHECK(param->rdLevel < 0 || param->rdLevel > 4,
> "RD Level is out of range");
> CHECK(param->rdoqLevel < 0 || param->rdoqLevel > 2,
> "RDOQ Level is out of range");
> diff -r c1a8eef8be14 -r 77ae7adfed6f source/encoder/analysis.cpp
> --- a/source/encoder/analysis.cpp Fri Mar 13 16:40:06 2015 +0530
> +++ b/source/encoder/analysis.cpp Fri Mar 13 16:53:34 2015 +0530
> @@ -168,18 +168,18 @@
> * they are available for intra predictions */
> m_modeDepth[0].fencYuv.copyToPicYuv(*m_frame->m_reconPic, ctu.m_cuAddr, 0);
>
> - compressInterCU_rd0_4(ctu, cuGeom);
> + compressInterCU_rd0_3(ctu, cuGeom);
>
> /* generate residual for entire CTU at once and copy to reconPic */
> encodeResidue(ctu, cuGeom);
> }
> else if (m_param->bDistributeModeAnalysis && m_param->rdLevel >= 2)
> compressInterCU_dist(ctu, cuGeom);
> - else if (m_param->rdLevel <= 4)
> - compressInterCU_rd0_4(ctu, cuGeom);
> + else if (m_param->rdLevel <= 3)
> + compressInterCU_rd0_3(ctu, cuGeom);
> else
> {
> - compressInterCU_rd5_6(ctu, cuGeom, zOrder);
> + compressInterCU_rd4(ctu, cuGeom, zOrder);
> if (m_param->analysisMode == X265_ANALYSIS_SAVE && m_frame->m_analysisData.interData)
> {
> CUData *bestCU = &m_modeDepth[0].bestMode->cu;
> @@ -365,7 +365,7 @@
> slave.setQP(*m_slice, m_rdCost.m_qp);
> slave.invalidateContexts(0);
>
> - if (m_param->rdLevel >= 5)
> + if (m_param->rdLevel == 4)
> {
> slave.m_rqt[pmode.cuGeom.depth].cur.load(m_rqt[pmode.cuGeom.depth].cur);
> slave.m_quant.setQPforQuant(md.pred[PRED_2Nx2N].cu);
> @@ -376,7 +376,7 @@
> /* perform Mode task, repeat until no more work is available */
> do
> {
> - if (m_param->rdLevel <= 4)
> + if (m_param->rdLevel <= 3)
> {
> switch (pmode.modes[task])
> {
> @@ -389,33 +389,33 @@
> break;
>
> case PRED_2Nx2N:
> - slave.checkInter_rd0_4(md.pred[PRED_2Nx2N], pmode.cuGeom, SIZE_2Nx2N);
> + slave.checkInter_rd0_3(md.pred[PRED_2Nx2N], pmode.cuGeom, SIZE_2Nx2N);
> if (m_slice->m_sliceType == B_SLICE)
> slave.checkBidir2Nx2N(md.pred[PRED_2Nx2N], md.pred[PRED_BIDIR], pmode.cuGeom);
> break;
>
> case PRED_Nx2N:
> - slave.checkInter_rd0_4(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N);
> + slave.checkInter_rd0_3(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N);
> break;
>
> case PRED_2NxN:
> - slave.checkInter_rd0_4(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN);
> + slave.checkInter_rd0_3(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN);
> break;
>
> case PRED_2NxnU:
> - slave.checkInter_rd0_4(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU);
> + slave.checkInter_rd0_3(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU);
> break;
>
> case PRED_2NxnD:
> - slave.checkInter_rd0_4(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD);
> + slave.checkInter_rd0_3(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD);
> break;
>
> case PRED_nLx2N:
> - slave.checkInter_rd0_4(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N);
> + slave.checkInter_rd0_3(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N);
> break;
>
> case PRED_nRx2N:
> - slave.checkInter_rd0_4(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N);
> + slave.checkInter_rd0_3(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N);
> break;
>
> default:
> @@ -434,7 +434,7 @@
> break;
>
> case PRED_2Nx2N:
> - slave.checkInter_rd5_6(md.pred[PRED_2Nx2N], pmode.cuGeom, SIZE_2Nx2N, false);
> + slave.checkInter_rd4(md.pred[PRED_2Nx2N], pmode.cuGeom, SIZE_2Nx2N, false);
> md.pred[PRED_BIDIR].rdCost = MAX_INT64;
> if (m_slice->m_sliceType == B_SLICE)
> {
> @@ -445,27 +445,27 @@
> break;
>
> case PRED_Nx2N:
> - slave.checkInter_rd5_6(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N, false);
> + slave.checkInter_rd4(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N, false);
> break;
>
> case PRED_2NxN:
> - slave.checkInter_rd5_6(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN, false);
> + slave.checkInter_rd4(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN, false);
> break;
>
> case PRED_2NxnU:
> - slave.checkInter_rd5_6(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU, bMergeOnly);
> + slave.checkInter_rd4(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU, bMergeOnly);
> break;
>
> case PRED_2NxnD:
> - slave.checkInter_rd5_6(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD, bMergeOnly);
> + slave.checkInter_rd4(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD, bMergeOnly);
> break;
>
> case PRED_nLx2N:
> - slave.checkInter_rd5_6(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N, bMergeOnly);
> + slave.checkInter_rd4(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N, bMergeOnly);
> break;
>
> case PRED_nRx2N:
> - slave.checkInter_rd5_6(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N, bMergeOnly);
> + slave.checkInter_rd4(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N, bMergeOnly);
> break;
>
> default:
> @@ -492,13 +492,13 @@
>
> 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 minDepth = m_param->rdLevel <= 3 ? topSkipMinDepth(parentCTU, cuGeom) : 0;
>
> X265_CHECK(m_param->rdLevel >= 2, "compressInterCU_dist does not support RD 0 or 1\n");
>
> if (mightNotSplit && depth >= minDepth)
> {
> - int bTryAmp = m_slice->m_sps->maxAMPDepth > depth && (cuGeom.log2CUSize < 6 || m_param->rdLevel > 4);
> + int bTryAmp = m_slice->m_sps->maxAMPDepth > depth && (cuGeom.log2CUSize < 6 || m_param->rdLevel == 4);
> int bTryIntra = m_slice->m_sliceType != B_SLICE || m_param->bIntraInBFrames;
>
> PMODE pmode(*this, cuGeom);
> @@ -509,7 +509,7 @@
> if (bTryIntra)
> {
> md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom);
> - if (cuGeom.log2CUSize == 3 && m_slice->m_sps->quadtreeTULog2MinSize < 3 && m_param->rdLevel >= 5)
> + if (cuGeom.log2CUSize == 3 && m_slice->m_sps->quadtreeTULog2MinSize < 3 && m_param->rdLevel == 4)
> md.pred[PRED_INTRA_NxN].cu.initSubCU(parentCTU, cuGeom);
> pmode.modes[pmode.m_jobTotal++] = PRED_INTRA;
> }
> @@ -537,9 +537,9 @@
> * merge after all the other jobs are at least started, we usually avoid
> * blocking on another thread */
>
> - if (m_param->rdLevel <= 4)
> + if (m_param->rdLevel <= 3)
> {
> - checkMerge2Nx2N_rd0_4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);
> + checkMerge2Nx2N_rd0_3(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);
>
> {
> ProfileCUScope(parentCTU, pmodeBlockTime, countPModeMasters);
> @@ -621,7 +621,7 @@
> }
> else
> {
> - checkMerge2Nx2N_rd5_6(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom, false);
> + checkMerge2Nx2N_rd4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom, false);
> {
> ProfileCUScope(parentCTU, pmodeBlockTime, countPModeMasters);
> pmode.waitForExit();
> @@ -671,7 +671,7 @@
> if (md.bestMode)
> {
> bNoSplit = md.bestMode->cu.isSkipped(0);
> - if (mightSplit && depth && depth >= minDepth && !bNoSplit && m_param->rdLevel <= 4)
> + if (mightSplit && depth && depth >= minDepth && !bNoSplit && m_param->rdLevel <= 3)
> bNoSplit = recursionDepthCheck(parentCTU, cuGeom, *md.bestMode);
> }
>
> @@ -733,7 +733,7 @@
> md.bestMode->reconYuv.copyToPicYuv(*m_frame->m_reconPic, cuAddr, cuGeom.absPartIdx);
> }
>
> -void Analysis::compressInterCU_rd0_4(const CUData& parentCTU, const CUGeom& cuGeom)
> +void Analysis::compressInterCU_rd0_3(const CUData& parentCTU, const CUGeom& cuGeom)
> {
> uint32_t depth = cuGeom.depth;
> uint32_t cuAddr = parentCTU.m_cuAddr;
> @@ -751,7 +751,7 @@
> /* Compute Merge Cost */
> md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom);
> md.pred[PRED_SKIP].cu.initSubCU(parentCTU, cuGeom);
> - checkMerge2Nx2N_rd0_4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);
> + checkMerge2Nx2N_rd0_3(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom);
>
> bool earlyskip = false;
> if (m_param->rdLevel)
> @@ -760,7 +760,7 @@
> if (!earlyskip)
> {
> md.pred[PRED_2Nx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd0_4(md.pred[PRED_2Nx2N], cuGeom, SIZE_2Nx2N);
> + checkInter_rd0_3(md.pred[PRED_2Nx2N], cuGeom, SIZE_2Nx2N);
>
> if (m_slice->m_sliceType == B_SLICE)
> {
> @@ -772,12 +772,12 @@
> if (m_param->bEnableRectInter)
> {
> md.pred[PRED_Nx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd0_4(md.pred[PRED_Nx2N], cuGeom, SIZE_Nx2N);
> + checkInter_rd0_3(md.pred[PRED_Nx2N], cuGeom, SIZE_Nx2N);
> if (md.pred[PRED_Nx2N].sa8dCost < bestInter->sa8dCost)
> bestInter = &md.pred[PRED_Nx2N];
>
> md.pred[PRED_2NxN].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd0_4(md.pred[PRED_2NxN], cuGeom, SIZE_2NxN);
> + checkInter_rd0_3(md.pred[PRED_2NxN], cuGeom, SIZE_2NxN);
> if (md.pred[PRED_2NxN].sa8dCost < bestInter->sa8dCost)
> bestInter = &md.pred[PRED_2NxN];
> }
> @@ -799,30 +799,30 @@
> if (bHor)
> {
> md.pred[PRED_2NxnU].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd0_4(md.pred[PRED_2NxnU], cuGeom, SIZE_2NxnU);
> + checkInter_rd0_3(md.pred[PRED_2NxnU], cuGeom, SIZE_2NxnU);
> if (md.pred[PRED_2NxnU].sa8dCost < bestInter->sa8dCost)
> bestInter = &md.pred[PRED_2NxnU];
>
> md.pred[PRED_2NxnD].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd0_4(md.pred[PRED_2NxnD], cuGeom, SIZE_2NxnD);
> + checkInter_rd0_3(md.pred[PRED_2NxnD], cuGeom, SIZE_2NxnD);
> if (md.pred[PRED_2NxnD].sa8dCost < bestInter->sa8dCost)
> bestInter = &md.pred[PRED_2NxnD];
> }
> if (bVer)
> {
> md.pred[PRED_nLx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd0_4(md.pred[PRED_nLx2N], cuGeom, SIZE_nLx2N);
> + checkInter_rd0_3(md.pred[PRED_nLx2N], cuGeom, SIZE_nLx2N);
> if (md.pred[PRED_nLx2N].sa8dCost < bestInter->sa8dCost)
> bestInter = &md.pred[PRED_nLx2N];
>
> md.pred[PRED_nRx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd0_4(md.pred[PRED_nRx2N], cuGeom, SIZE_nRx2N);
> + checkInter_rd0_3(md.pred[PRED_nRx2N], cuGeom, SIZE_nRx2N);
> if (md.pred[PRED_nRx2N].sa8dCost < bestInter->sa8dCost)
> bestInter = &md.pred[PRED_nRx2N];
> }
> }
>
> - if (m_param->rdLevel >= 3)
> + if (m_param->rdLevel == 3)
> {
> /* Calculate RD cost of best inter option */
> if (!m_bChromaSa8d) /* When m_bChromaSa8d is enabled, chroma MC has already been done */
> @@ -966,7 +966,7 @@
> {
> m_modeDepth[0].fencYuv.copyPartToYuv(nd.fencYuv, childGeom.absPartIdx);
> m_rqt[nextDepth].cur.load(*nextContext);
> - compressInterCU_rd0_4(parentCTU, childGeom);
> + compressInterCU_rd0_3(parentCTU, childGeom);
>
> // Save best CU and pred data for this sub CU
> splitCU->copyPartFrom(nd.bestMode->cu, childGeom, subPartIdx);
> @@ -1016,7 +1016,7 @@
> md.bestMode->reconYuv.copyToPicYuv(*m_frame->m_reconPic, cuAddr, cuGeom.absPartIdx);
> }
>
> -void Analysis::compressInterCU_rd5_6(const CUData& parentCTU, const CUGeom& cuGeom, uint32_t &zOrder)
> +void Analysis::compressInterCU_rd4(const CUData& parentCTU, const CUGeom& cuGeom, uint32_t &zOrder)
> {
> uint32_t depth = cuGeom.depth;
> ModeDepth& md = m_modeDepth[depth];
> @@ -1033,7 +1033,7 @@
> {
> md.pred[PRED_SKIP].cu.initSubCU(parentCTU, cuGeom);
> md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom);
> - checkMerge2Nx2N_rd5_6(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom, true);
> + checkMerge2Nx2N_rd4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom, true);
>
> if (m_bTryLossless)
> tryLossless(cuGeom);
> @@ -1053,13 +1053,13 @@
> {
> md.pred[PRED_SKIP].cu.initSubCU(parentCTU, cuGeom);
> md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom);
> - checkMerge2Nx2N_rd5_6(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom, false);
> + checkMerge2Nx2N_rd4(md.pred[PRED_SKIP], md.pred[PRED_MERGE], cuGeom, false);
> bool earlySkip = m_param->bEnableEarlySkip && md.bestMode && !md.bestMode->cu.getQtRootCbf(0);
>
> if (!earlySkip)
> {
> md.pred[PRED_2Nx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd5_6(md.pred[PRED_2Nx2N], cuGeom, SIZE_2Nx2N, false);
> + checkInter_rd4(md.pred[PRED_2Nx2N], cuGeom, SIZE_2Nx2N, false);
> checkBestMode(md.pred[PRED_2Nx2N], cuGeom.depth);
>
> if (m_slice->m_sliceType == B_SLICE)
> @@ -1076,11 +1076,11 @@
> if (m_param->bEnableRectInter)
> {
> md.pred[PRED_Nx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd5_6(md.pred[PRED_Nx2N], cuGeom, SIZE_Nx2N, false);
> + checkInter_rd4(md.pred[PRED_Nx2N], cuGeom, SIZE_Nx2N, false);
> checkBestMode(md.pred[PRED_Nx2N], cuGeom.depth);
>
> md.pred[PRED_2NxN].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd5_6(md.pred[PRED_2NxN], cuGeom, SIZE_2NxN, false);
> + checkInter_rd4(md.pred[PRED_2NxN], cuGeom, SIZE_2NxN, false);
> checkBestMode(md.pred[PRED_2NxN], cuGeom.depth);
> }
>
> @@ -1103,21 +1103,21 @@
> if (bHor)
> {
> md.pred[PRED_2NxnU].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd5_6(md.pred[PRED_2NxnU], cuGeom, SIZE_2NxnU, bMergeOnly);
> + checkInter_rd4(md.pred[PRED_2NxnU], cuGeom, SIZE_2NxnU, bMergeOnly);
> checkBestMode(md.pred[PRED_2NxnU], cuGeom.depth);
>
> md.pred[PRED_2NxnD].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd5_6(md.pred[PRED_2NxnD], cuGeom, SIZE_2NxnD, bMergeOnly);
> + checkInter_rd4(md.pred[PRED_2NxnD], cuGeom, SIZE_2NxnD, bMergeOnly);
> checkBestMode(md.pred[PRED_2NxnD], cuGeom.depth);
> }
> if (bVer)
> {
> md.pred[PRED_nLx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd5_6(md.pred[PRED_nLx2N], cuGeom, SIZE_nLx2N, bMergeOnly);
> + checkInter_rd4(md.pred[PRED_nLx2N], cuGeom, SIZE_nLx2N, bMergeOnly);
> checkBestMode(md.pred[PRED_nLx2N], cuGeom.depth);
>
> md.pred[PRED_nRx2N].cu.initSubCU(parentCTU, cuGeom);
> - checkInter_rd5_6(md.pred[PRED_nRx2N], cuGeom, SIZE_nRx2N, bMergeOnly);
> + checkInter_rd4(md.pred[PRED_nRx2N], cuGeom, SIZE_nRx2N, bMergeOnly);
> checkBestMode(md.pred[PRED_nRx2N], cuGeom.depth);
> }
> }
> @@ -1164,7 +1164,7 @@
> {
> m_modeDepth[0].fencYuv.copyPartToYuv(nd.fencYuv, childGeom.absPartIdx);
> m_rqt[nextDepth].cur.load(*nextContext);
> - compressInterCU_rd5_6(parentCTU, childGeom, zOrder);
> + compressInterCU_rd4(parentCTU, childGeom, zOrder);
>
> // Save best CU and pred data for this sub CU
> splitCU->copyPartFrom(nd.bestMode->cu, childGeom, subPartIdx);
> @@ -1195,7 +1195,7 @@
> }
>
> /* sets md.bestMode if a valid merge candidate is found, else leaves it NULL */
> -void Analysis::checkMerge2Nx2N_rd0_4(Mode& skip, Mode& merge, const CUGeom& cuGeom)
> +void Analysis::checkMerge2Nx2N_rd0_3(Mode& skip, Mode& merge, const CUGeom& cuGeom)
> {
> uint32_t depth = cuGeom.depth;
> ModeDepth& md = m_modeDepth[depth];
> @@ -1299,7 +1299,7 @@
> }
>
> /* sets md.bestMode if a valid merge candidate is found, else leaves it NULL */
> -void Analysis::checkMerge2Nx2N_rd5_6(Mode& skip, Mode& merge, const CUGeom& cuGeom, bool isSkipMode)
> +void Analysis::checkMerge2Nx2N_rd4(Mode& skip, Mode& merge, const CUGeom& cuGeom, bool isSkipMode)
> {
> uint32_t depth = cuGeom.depth;
>
> @@ -1435,7 +1435,7 @@
> checkDQP(bestPred->cu, cuGeom);
> }
>
> -void Analysis::checkInter_rd0_4(Mode& interMode, const CUGeom& cuGeom, PartSize partSize)
> +void Analysis::checkInter_rd0_3(Mode& interMode, const CUGeom& cuGeom, PartSize partSize)
> {
> interMode.initCosts();
> interMode.cu.setPartSizeSubParts(partSize);
> @@ -1483,7 +1483,7 @@
> }
> }
>
> -void Analysis::checkInter_rd5_6(Mode& interMode, const CUGeom& cuGeom, PartSize partSize, bool bMergeOnly)
> +void Analysis::checkInter_rd4(Mode& interMode, const CUGeom& cuGeom, PartSize partSize, bool bMergeOnly)
> {
> interMode.initCosts();
> interMode.cu.setPartSizeSubParts(partSize);
> diff -r c1a8eef8be14 -r 77ae7adfed6f source/encoder/analysis.h
> --- a/source/encoder/analysis.h Fri Mar 13 16:40:06 2015 +0530
> +++ b/source/encoder/analysis.h Fri Mar 13 16:53:34 2015 +0530
> @@ -113,16 +113,16 @@
>
> /* full analysis for a P or B slice CU */
> void compressInterCU_dist(const CUData& parentCTU, const CUGeom& cuGeom);
> - void compressInterCU_rd0_4(const CUData& parentCTU, const CUGeom& cuGeom);
> - void compressInterCU_rd5_6(const CUData& parentCTU, const CUGeom& cuGeom, uint32_t &zOrder);
> + void compressInterCU_rd0_3(const CUData& parentCTU, const CUGeom& cuGeom);
> + void compressInterCU_rd4(const CUData& parentCTU, const CUGeom& cuGeom, uint32_t &zOrder);
>
> /* measure merge and skip */
> - void checkMerge2Nx2N_rd0_4(Mode& skip, Mode& merge, const CUGeom& cuGeom);
> - void checkMerge2Nx2N_rd5_6(Mode& skip, Mode& merge, const CUGeom& cuGeom, bool isSkipMode);
> + void checkMerge2Nx2N_rd0_3(Mode& skip, Mode& merge, const CUGeom& cuGeom);
> + void checkMerge2Nx2N_rd4(Mode& skip, Mode& merge, const CUGeom& cuGeom, bool isSkipMode);
>
> /* measure inter options */
> - void checkInter_rd0_4(Mode& interMode, const CUGeom& cuGeom, PartSize partSize);
> - void checkInter_rd5_6(Mode& interMode, const CUGeom& cuGeom, PartSize partSize, bool bMergeOnly);
> + void checkInter_rd0_3(Mode& interMode, const CUGeom& cuGeom, PartSize partSize);
> + void checkInter_rd4(Mode& interMode, const CUGeom& cuGeom, PartSize partSize, bool bMergeOnly);
>
> void checkBidir2Nx2N(Mode& inter2Nx2N, Mode& bidir2Nx2N, const CUGeom& cuGeom);
>
> diff -r c1a8eef8be14 -r 77ae7adfed6f source/encoder/search.cpp
> --- a/source/encoder/search.cpp Fri Mar 13 16:40:06 2015 +0530
> +++ b/source/encoder/search.cpp Fri Mar 13 16:53:34 2015 +0530
> @@ -1438,7 +1438,7 @@
> uint64_t candCostList[MAX_RD_INTRA_MODES];
> uint32_t rdModeList[MAX_RD_INTRA_MODES];
> uint64_t bcost;
> - int maxCandCount = 2 + m_param->rdLevel + ((depth + initTuDepth) >> 1);
> + int maxCandCount = 2 + m_param->rdLevel + ((depth + initTuDepth) >> 1); /* TODO: Fix dependency on rdLevel now that settings have changed */
>
> {
> ProfileCUScope(intraMode.cu, intraAnalysisElapsedTime, countIntraAnalysis);
> diff -r c1a8eef8be14 -r 77ae7adfed6f source/x265.h
> --- a/source/x265.h Fri Mar 13 16:40:06 2015 +0530
> +++ b/source/x265.h Fri Mar 13 16:53:34 2015 +0530
> @@ -828,8 +828,8 @@
> int bCULossless;
>
> /* Specify whether to attempt to encode intra modes in B frames. By default
> - * enabled, but only applicable for the presets which use rdLevel 5 or 6
> - * (veryslow and placebo). All other presets will not try intra in B frames
> + * enabled, but only applicable for the presets which use rdLevel 4 (slower,
> + * veryslow and placebo). All other presets will not try intra in B frames
> * regardless of this setting */
> int bIntraInBFrames;
>
> diff -r c1a8eef8be14 -r 77ae7adfed6f source/x265cli.h
> --- a/source/x265cli.h Fri Mar 13 16:40:06 2015 +0530
> +++ b/source/x265cli.h Fri Mar 13 16:53:34 2015 +0530
> @@ -275,7 +275,7 @@
> H0(" --tu-intra-depth <integer> Max TU recursive depth for intra CUs. Default %d\n", param->tuQTMaxIntraDepth);
> H0(" --tu-inter-depth <integer> Max TU recursive depth for inter CUs. Default %d\n", param->tuQTMaxInterDepth);
> H0("\nAnalysis:\n");
> - H0(" --rd <0..6> Level of RDO in mode decision 0:least....6:full RDO. Default %d\n", param->rdLevel);
> + H0(" --rd <0..4> Level of RDO in mode decision 0:least....4:full RDO. Default %d\n", param->rdLevel);
> H0(" --[no-]psy-rd <0..2.0> Strength of psycho-visual rate distortion optimization, 0 to disable. Default %.1f\n", param->psyRd);
> H0(" --[no-]rdoq-level <0|1|2> Level of RDO in quantization 0:none, 1:levels, 2:levels & coding groups. Default %d\n", param->rdoqLevel);
> H0(" --[no-]psy-rdoq <0..50.0> Strength of psycho-visual optimization in RDO quantization, 0 to disable. Default %.1f\n", param->psyRdoq);
> _______________________________________________
> 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