[x265] [PATCH] rdLevel: reset rdLevels to 0-4
deepthi at multicorewareinc.com
deepthi at multicorewareinc.com
Fri Mar 13 12:37:30 CET 2015
# 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
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);
More information about the x265-devel
mailing list