[x265] [PATCH] analysis: at RD 0/4 avoid motion references if not used by split blocks
ashok at multicorewareinc.com
ashok at multicorewareinc.com
Tue May 19 15:15:34 CEST 2015
# HG changeset patch
# User Ashok Kumar Mishra<ashok at multicorewareinc.com>
# Date 1431935334 -19800
# Mon May 18 13:18:54 2015 +0530
# Node ID e1058f78e11de9844c3b6a4ce4debc2fe7210d9a
# Parent 1e2e70f90e4484b32217c7579bca98180929cf72
analysis: at RD 0/4 avoid motion references if not used by split blocks
diff -r 1e2e70f90e44 -r e1058f78e11d source/encoder/analysis.cpp
--- a/source/encoder/analysis.cpp Mon May 18 12:46:18 2015 +0530
+++ b/source/encoder/analysis.cpp Mon May 18 13:18:54 2015 +0530
@@ -387,6 +387,8 @@
{
if (m_param->rdLevel <= 4)
{
+ uint32_t refMasks[2] = { 0, 0 };
+
switch (pmode.modes[task])
{
case PRED_INTRA:
@@ -396,33 +398,33 @@
break;
case PRED_2Nx2N:
- slave.checkInter_rd0_4(md.pred[PRED_2Nx2N], pmode.cuGeom, SIZE_2Nx2N);
+ 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:
- slave.checkInter_rd0_4(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N);
+ slave.checkInter_rd0_4(md.pred[PRED_Nx2N], pmode.cuGeom, SIZE_Nx2N, refMasks);
break;
case PRED_2NxN:
- slave.checkInter_rd0_4(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN);
+ slave.checkInter_rd0_4(md.pred[PRED_2NxN], pmode.cuGeom, SIZE_2NxN, refMasks);
break;
case PRED_2NxnU:
- slave.checkInter_rd0_4(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU);
+ slave.checkInter_rd0_4(md.pred[PRED_2NxnU], pmode.cuGeom, SIZE_2NxnU, refMasks);
break;
case PRED_2NxnD:
- slave.checkInter_rd0_4(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD);
+ slave.checkInter_rd0_4(md.pred[PRED_2NxnD], pmode.cuGeom, SIZE_2NxnD, refMasks);
break;
case PRED_nLx2N:
- slave.checkInter_rd0_4(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N);
+ slave.checkInter_rd0_4(md.pred[PRED_nLx2N], pmode.cuGeom, SIZE_nLx2N, refMasks);
break;
case PRED_nRx2N:
- slave.checkInter_rd0_4(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N);
+ slave.checkInter_rd0_4(md.pred[PRED_nRx2N], pmode.cuGeom, SIZE_nRx2N, refMasks);
break;
default:
@@ -746,7 +748,7 @@
md.bestMode->reconYuv.copyToPicYuv(*m_frame->m_reconPic, cuAddr, cuGeom.absPartIdx);
}
-void Analysis::compressInterCU_rd0_4(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp)
+uint32_t Analysis::compressInterCU_rd0_4(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp)
{
uint32_t depth = cuGeom.depth;
uint32_t cuAddr = parentCTU.m_cuAddr;
@@ -757,6 +759,8 @@
bool mightNotSplit = !(cuGeom.flags & CUGeom::SPLIT_MANDATORY);
uint32_t minDepth = topSkipMinDepth(parentCTU, cuGeom);
bool earlyskip = false;
+ uint32_t splitRefs[4] = { 0, 0, 0, 0 };
+ /* Step 1. Evaluate Merge/Skip candidates for likely early-outs */
if (mightNotSplit && depth >= minDepth)
{
/* Compute Merge Cost */
@@ -775,6 +779,7 @@
bNoSplit = recursionDepthCheck(parentCTU, cuGeom, *md.bestMode);
}
+ /* Step 2. Evaluate each of the 4 split sub-blocks in series */
if (mightSplit && !bNoSplit)
{
Mode* splitPred = &md.pred[PRED_SPLIT];
@@ -799,7 +804,7 @@
if (m_slice->m_pps->bUseDQP && nextDepth <= m_slice->m_pps->maxCuDQPDepth)
nextQP = setLambdaFromQP(parentCTU, calculateQpforCuSize(parentCTU, childGeom));
- compressInterCU_rd0_4(parentCTU, childGeom, nextQP);
+ splitRefs[subPartIdx] = compressInterCU_rd0_4(parentCTU, childGeom, nextQP);
// Save best CU and pred data for this sub CU
splitCU->copyPartFrom(nd.bestMode->cu, childGeom, subPartIdx);
@@ -825,6 +830,11 @@
splitPred->sa8dCost = m_rdCost.calcRdSADCost(splitPred->distortion, splitPred->sa8dBits);
}
+ /* Split CUs
+ * 0 1
+ * 2 3 */
+ uint32_t allSplitRefs = splitRefs[0] | splitRefs[1] | splitRefs[2] | splitRefs[3];
+ /* Step 3. Evaluate ME (2Nx2N, rect, amp) and intra modes at current depth */
if (mightNotSplit && depth >= minDepth)
{
if (m_slice->m_pps->bUseDQP && depth <= m_slice->m_pps->maxCuDQPDepth && m_slice->m_pps->maxCuDQPDepth != 0)
@@ -832,8 +842,10 @@
if (!earlyskip)
{
+ uint32_t refMasks[2];
+ refMasks[0] = allSplitRefs;
md.pred[PRED_2Nx2N].cu.initSubCU(parentCTU, cuGeom, qp);
- checkInter_rd0_4(md.pred[PRED_2Nx2N], cuGeom, SIZE_2Nx2N);
+ checkInter_rd0_4(md.pred[PRED_2Nx2N], cuGeom, SIZE_2Nx2N, refMasks);
if (m_slice->m_sliceType == B_SLICE)
{
@@ -844,13 +856,17 @@
Mode *bestInter = &md.pred[PRED_2Nx2N];
if (m_param->bEnableRectInter)
{
+ refMasks[0] = splitRefs[0] | splitRefs[2]; /* left */
+ refMasks[1] = splitRefs[1] | splitRefs[3]; /* right */
md.pred[PRED_Nx2N].cu.initSubCU(parentCTU, cuGeom, qp);
- checkInter_rd0_4(md.pred[PRED_Nx2N], cuGeom, SIZE_Nx2N);
+ checkInter_rd0_4(md.pred[PRED_Nx2N], cuGeom, SIZE_Nx2N, refMasks);
if (md.pred[PRED_Nx2N].sa8dCost < bestInter->sa8dCost)
bestInter = &md.pred[PRED_Nx2N];
+ refMasks[0] = splitRefs[0] | splitRefs[1]; /* top */
+ refMasks[1] = splitRefs[2] | splitRefs[3]; /* bot */
md.pred[PRED_2NxN].cu.initSubCU(parentCTU, cuGeom, qp);
- checkInter_rd0_4(md.pred[PRED_2NxN], cuGeom, SIZE_2NxN);
+ checkInter_rd0_4(md.pred[PRED_2NxN], cuGeom, SIZE_2NxN, refMasks);
if (md.pred[PRED_2NxN].sa8dCost < bestInter->sa8dCost)
bestInter = &md.pred[PRED_2NxN];
}
@@ -871,25 +887,33 @@
if (bHor)
{
+ refMasks[0] = splitRefs[0] | splitRefs[1]; /* 25% top */
+ refMasks[1] = allSplitRefs; /* 75% bot */
md.pred[PRED_2NxnU].cu.initSubCU(parentCTU, cuGeom, qp);
- checkInter_rd0_4(md.pred[PRED_2NxnU], cuGeom, SIZE_2NxnU);
+ checkInter_rd0_4(md.pred[PRED_2NxnU], cuGeom, SIZE_2NxnU, refMasks);
if (md.pred[PRED_2NxnU].sa8dCost < bestInter->sa8dCost)
bestInter = &md.pred[PRED_2NxnU];
+ refMasks[0] = allSplitRefs; /* 75% top */
+ refMasks[1] = splitRefs[2] | splitRefs[3]; /* 25% bot */
md.pred[PRED_2NxnD].cu.initSubCU(parentCTU, cuGeom, qp);
- checkInter_rd0_4(md.pred[PRED_2NxnD], cuGeom, SIZE_2NxnD);
+ checkInter_rd0_4(md.pred[PRED_2NxnD], cuGeom, SIZE_2NxnD, refMasks);
if (md.pred[PRED_2NxnD].sa8dCost < bestInter->sa8dCost)
bestInter = &md.pred[PRED_2NxnD];
}
if (bVer)
{
+ refMasks[0] = splitRefs[0] | splitRefs[2]; /* 25% left */
+ refMasks[1] = allSplitRefs; /* 75% right */
md.pred[PRED_nLx2N].cu.initSubCU(parentCTU, cuGeom, qp);
- checkInter_rd0_4(md.pred[PRED_nLx2N], cuGeom, SIZE_nLx2N);
+ checkInter_rd0_4(md.pred[PRED_nLx2N], cuGeom, SIZE_nLx2N, refMasks);
if (md.pred[PRED_nLx2N].sa8dCost < bestInter->sa8dCost)
bestInter = &md.pred[PRED_nLx2N];
+ refMasks[0] = allSplitRefs; /* 75% left */
+ refMasks[1] = splitRefs[1] | splitRefs[3]; /* 25% right */
md.pred[PRED_nRx2N].cu.initSubCU(parentCTU, cuGeom, qp);
- checkInter_rd0_4(md.pred[PRED_nRx2N], cuGeom, SIZE_nRx2N);
+ checkInter_rd0_4(md.pred[PRED_nRx2N], cuGeom, SIZE_nRx2N, refMasks);
if (md.pred[PRED_nRx2N].sa8dCost < bestInter->sa8dCost)
bestInter = &md.pred[PRED_nRx2N];
}
@@ -1033,10 +1057,43 @@
checkDQPForSplitPred(*md.bestMode, cuGeom);
}
+ /* determine which motion references the parent CU should search */
+ uint32_t refMask;
+ if (md.bestMode == &md.pred[PRED_SPLIT])
+ refMask = allSplitRefs;
+ else
+ {
+ /* use best merge/inter mode, in case of intra use 2Nx2N inter references */
+ CUData& cu = md.bestMode->cu.isIntra(0) ? md.pred[PRED_2Nx2N].cu : md.bestMode->cu;
+ PartSize partSize = (PartSize)cu.m_partSize[0];
+ uint32_t numPU = (partSize == SIZE_2Nx2N) ? 1 : 2;
+ uint32_t puOffset = (g_puOffset[uint32_t(partSize)] << (g_unitSizeDepth - cu.m_cuDepth[0]) * 2) >> 4;
+ refMask = 0;
+ for (uint32_t puIdx = 0, subPartIdx = 0; puIdx < numPU; puIdx++, subPartIdx += puOffset)
+ {
+ uint32_t interDir = cu.m_interDir[subPartIdx];
+ switch (interDir)
+ {
+ case 1:
+ refMask |= 1 << cu.m_refIdx[0][subPartIdx];
+ break;
+ case 2:
+ refMask |= 1 << (cu.m_refIdx[1][subPartIdx] + 16);
+ break;
+ case 3:
+ refMask |= 1 << cu.m_refIdx[0][subPartIdx];
+ refMask |= 1 << (cu.m_refIdx[1][subPartIdx] + 16);
+ break;
+ }
+ }
+ }
+
/* Copy best data to encData CTU and recon */
X265_CHECK(md.bestMode->ok(), "best mode is not ok");
md.bestMode->cu.copyToPic(depth);
md.bestMode->reconYuv.copyToPicYuv(*m_frame->m_reconPic, cuAddr, cuGeom.absPartIdx);
+
+ return refMask;
}
void Analysis::compressInterCU_rd5_6(const CUData& parentCTU, const CUGeom& cuGeom, uint32_t &zOrder, int32_t qp)
@@ -1469,7 +1526,7 @@
}
}
-void Analysis::checkInter_rd0_4(Mode& interMode, const CUGeom& cuGeom, PartSize partSize)
+void Analysis::checkInter_rd0_4(Mode& interMode, const CUGeom& cuGeom, PartSize partSize, uint32_t refMask[2])
{
interMode.initCosts();
interMode.cu.setPartSizeSubParts(partSize);
@@ -1489,7 +1546,7 @@
}
}
- predInterSearch(interMode, cuGeom, m_bChromaSa8d);
+ predInterSearch(interMode, cuGeom, m_bChromaSa8d, refMask);
/* predInterSearch sets interMode.sa8dBits */
const Yuv& fencYuv = *interMode.fencYuv;
@@ -1537,7 +1594,8 @@
}
}
- predInterSearch(interMode, cuGeom, true);
+ uint32_t refMask[2] = { 0, 0 };
+ predInterSearch(interMode, cuGeom, true, refMask);
/* predInterSearch sets interMode.sa8dBits, but this is ignored */
encodeResAndCalcRdInterCU(interMode, cuGeom);
diff -r 1e2e70f90e44 -r e1058f78e11d source/encoder/analysis.h
--- a/source/encoder/analysis.h Mon May 18 12:46:18 2015 +0530
+++ b/source/encoder/analysis.h Mon May 18 13:18:54 2015 +0530
@@ -113,7 +113,7 @@
/* full analysis for a P or B slice CU */
void compressInterCU_dist(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp);
- void compressInterCU_rd0_4(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp);
+ uint32_t compressInterCU_rd0_4(const CUData& parentCTU, const CUGeom& cuGeom, int32_t qp);
void compressInterCU_rd5_6(const CUData& parentCTU, const CUGeom& cuGeom, uint32_t &zOrder, int32_t qp);
/* measure merge and skip */
@@ -121,7 +121,7 @@
void checkMerge2Nx2N_rd5_6(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_rd0_4(Mode& interMode, const CUGeom& cuGeom, PartSize partSize, uint32_t refmask[2]);
void checkInter_rd5_6(Mode& interMode, const CUGeom& cuGeom, PartSize partSize);
void checkBidir2Nx2N(Mode& inter2Nx2N, Mode& bidir2Nx2N, const CUGeom& cuGeom);
diff -r 1e2e70f90e44 -r e1058f78e11d source/encoder/entropy.cpp
--- a/source/encoder/entropy.cpp Mon May 18 12:46:18 2015 +0530
+++ b/source/encoder/entropy.cpp Mon May 18 13:18:54 2015 +0530
@@ -35,8 +35,6 @@
#define CU_DQP_EG_k 0 // exp-golomb order
#define START_VALUE 8 // start value for dpcm mode
-static const uint32_t g_puOffset[8] = { 0, 8, 4, 4, 2, 10, 1, 5 };
-
namespace x265 {
Entropy::Entropy()
diff -r 1e2e70f90e44 -r e1058f78e11d source/encoder/entropy.h
--- a/source/encoder/entropy.h Mon May 18 12:46:18 2015 +0530
+++ b/source/encoder/entropy.h Mon May 18 13:18:54 2015 +0530
@@ -38,6 +38,8 @@
struct EstBitsSbac;
class ScalingList;
+static const uint32_t g_puOffset[8] = { 0, 8, 4, 4, 2, 10, 1, 5 };
+
enum SplitType
{
DONT_SPLIT = 0,
diff -r 1e2e70f90e44 -r e1058f78e11d source/encoder/search.cpp
--- a/source/encoder/search.cpp Mon May 18 12:46:18 2015 +0530
+++ b/source/encoder/search.cpp Mon May 18 13:18:54 2015 +0530
@@ -1983,7 +1983,7 @@
}
/* find the best inter prediction for each PU of specified mode */
-void Search::predInterSearch(Mode& interMode, const CUGeom& cuGeom, bool bChromaMC)
+void Search::predInterSearch(Mode& interMode, const CUGeom& cuGeom, bool bChromaMC, uint32_t refMasks[2])
{
ProfileCUScope(interMode.cu, motionEstimationElapsedTime, countMotionEstimate);
@@ -2083,10 +2083,15 @@
}
if (bDoUnidir)
{
+ uint32_t refMask = refMasks[puIdx] ? refMasks[puIdx] : (uint32_t)-1;
+
for (int list = 0; list < numPredDir; list++)
{
for (int ref = 0; ref < numRefIdx[list]; ref++)
{
+ if (!(refMask & (1 << ref)))
+ continue;
+
uint32_t bits = m_listSelBits[list] + MVP_IDX_BITS;
bits += getTUBits(ref, numRefIdx[list]);
@@ -2116,6 +2121,8 @@
bestME[list].bits = bits;
}
}
+ /* the second list ref bits start at bit 16 */
+ refMask >>= 16;
}
}
diff -r 1e2e70f90e44 -r e1058f78e11d source/encoder/search.h
--- a/source/encoder/search.h Mon May 18 12:46:18 2015 +0530
+++ b/source/encoder/search.h Mon May 18 13:18:54 2015 +0530
@@ -301,7 +301,7 @@
void encodeIntraInInter(Mode& intraMode, const CUGeom& cuGeom);
// estimation inter prediction (non-skip)
- void predInterSearch(Mode& interMode, const CUGeom& cuGeom, bool bChromaMC);
+ void predInterSearch(Mode& interMode, const CUGeom& cuGeom, bool bChromaMC, uint32_t masks[2]);
// encode residual and compute rd-cost for inter mode
void encodeResAndCalcRdInterCU(Mode& interMode, const CUGeom& cuGeom);
More information about the x265-devel
mailing list