[x265] [PATCH] Skip the lookahead when analysis reuse mode is load and analysis file writing
Divya Manivannan
divya at multicorewareinc.com
Wed Sep 6 17:00:33 CEST 2017
# HG changeset patch
# User Divya Manivannan <divya at multicorewareinc.com>
# Date 1500875370 -19800
# Mon Jul 24 11:19:30 2017 +0530
# Node ID 6410885f92f602081c650a1322d9a1bc30ea1d21
# Parent 2718cb5dd67f5e6735c9ee37df19c491f1473a60
Skip the lookahead when analysis reuse mode is load and analysis file writing
is disabled and scale factor is enabled.
All the lookahead data are shared from analysis save mode to load mode, so it is
skipped to improve performance. All the lookahead costs are approximated based
on scalefactor.
diff -r 2718cb5dd67f -r 6410885f92f6 source/common/common.h
--- a/source/common/common.h Tue Sep 05 11:21:56 2017 +0530
+++ b/source/common/common.h Mon Jul 24 11:19:30 2017 +0530
@@ -207,7 +207,6 @@
// arbitrary, but low because SATD scores are 1/4 normal
#define X265_LOOKAHEAD_QP (12 + QP_BD_OFFSET)
-#define X265_LOOKAHEAD_MAX 250
// Use the same size blocks as x264. Using larger blocks seems to give artificially
// high cost estimates (intra and inter both suffer)
diff -r 2718cb5dd67f -r 6410885f92f6 source/encoder/encoder.cpp
--- a/source/encoder/encoder.cpp Tue Sep 05 11:21:56 2017 +0530
+++ b/source/encoder/encoder.cpp Mon Jul 24 11:19:30 2017 +0530
@@ -790,9 +790,22 @@
{
/* readAnalysisFile reads analysis data for the frame and allocates memory based on slicetype */
readAnalysisFile(&inFrame->m_analysisData, inFrame->m_poc, pic_in);
+ inFrame->m_poc = inFrame->m_analysisData.poc;
sliceType = inFrame->m_analysisData.sliceType;
inFrame->m_lowres.bScenecut = !!inFrame->m_analysisData.bScenecut;
inFrame->m_lowres.satdCost = inFrame->m_analysisData.satdCost;
+ if (!m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ inFrame->m_lowres.sliceType = sliceType;
+ inFrame->m_lowres.bKeyframe = !!inFrame->m_analysisData.lookahead.keyframe;
+ inFrame->m_lowres.bLastMiniGopBFrame = !!inFrame->m_analysisData.lookahead.lastMiniGopBFrame;
+ int vbvCount = m_param->lookaheadDepth + m_param->bframes + 2;
+ for (int index = 0; index < vbvCount; index++)
+ {
+ inFrame->m_lowres.plannedSatd[index] = inFrame->m_analysisData.lookahead.plannedSatd[index];
+ inFrame->m_lowres.plannedType[index] = inFrame->m_analysisData.lookahead.plannedType[index];
+ }
+ }
}
if (m_param->bUseRcStats && pic_in->rcData)
{
@@ -886,12 +899,39 @@
pic_out->analysisData.poc = pic_out->poc;
pic_out->analysisData.sliceType = pic_out->sliceType;
pic_out->analysisData.bScenecut = outFrame->m_lowres.bScenecut;
- pic_out->analysisData.satdCost = outFrame->m_lowres.satdCost;
+ pic_out->analysisData.satdCost = outFrame->m_lowres.satdCost;
pic_out->analysisData.numCUsInFrame = outFrame->m_analysisData.numCUsInFrame;
+ pic_out->analysisData.numCuInHeight = outFrame->m_analysisData.numCuInHeight;
pic_out->analysisData.numPartitions = outFrame->m_analysisData.numPartitions;
pic_out->analysisData.wt = outFrame->m_analysisData.wt;
pic_out->analysisData.interData = outFrame->m_analysisData.interData;
pic_out->analysisData.intraData = outFrame->m_analysisData.intraData;
+ if (!m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ pic_out->analysisData.satdCost *= m_param->scaleFactor * 2;
+ pic_out->analysisData.lookahead.keyframe = outFrame->m_lowres.bKeyframe;
+ pic_out->analysisData.lookahead.lastMiniGopBFrame = outFrame->m_lowres.bLastMiniGopBFrame;
+ int vbvCount = m_param->lookaheadDepth + m_param->bframes + 2;
+ for (int index = 0; index < vbvCount; index++)
+ {
+ pic_out->analysisData.lookahead.plannedSatd[index] = outFrame->m_lowres.plannedSatd[index] * m_param->scaleFactor * 2;
+ pic_out->analysisData.lookahead.plannedType[index] = outFrame->m_lowres.plannedType[index];
+ }
+ for (uint32_t index = 0; index < pic_out->analysisData.numCuInHeight; index++)
+ {
+ outFrame->m_analysisData.lookahead.intraSatdForVbv[index] = outFrame->m_encData->m_rowStat[index].intraSatdForVbv * m_param->scaleFactor * 2;
+ outFrame->m_analysisData.lookahead.satdForVbv[index] = outFrame->m_encData->m_rowStat[index].satdForVbv * m_param->scaleFactor * 2;
+ }
+ pic_out->analysisData.lookahead.intraSatdForVbv = outFrame->m_analysisData.lookahead.intraSatdForVbv;
+ pic_out->analysisData.lookahead.satdForVbv = outFrame->m_analysisData.lookahead.satdForVbv;
+ for (uint32_t index = 0; index < pic_out->analysisData.numCUsInFrame; index++)
+ {
+ outFrame->m_analysisData.lookahead.intraVbvCost[index] = outFrame->m_encData->m_cuStat[index].intraVbvCost * m_param->scaleFactor * 2;
+ outFrame->m_analysisData.lookahead.vbvCost[index] = outFrame->m_encData->m_cuStat[index].vbvCost * m_param->scaleFactor * 2;
+ }
+ pic_out->analysisData.lookahead.intraVbvCost = outFrame->m_analysisData.lookahead.intraVbvCost;
+ pic_out->analysisData.lookahead.vbvCost = outFrame->m_analysisData.lookahead.vbvCost;
+ }
writeAnalysisFile(&pic_out->analysisData, *outFrame->m_encData);
if (m_param->bUseAnalysisFile)
freeAnalysis(&pic_out->analysisData);
@@ -1054,7 +1094,19 @@
slice->m_maxNumMergeCand = m_param->maxNumMergeCand;
slice->m_endCUAddr = slice->realEndAddress(m_sps.numCUsInFrame * m_param->num4x4Partitions);
}
-
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && !m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ for (uint32_t index = 0; index < frameEnc->m_analysisData.numCuInHeight; index++)
+ {
+ frameEnc->m_encData->m_rowStat[index].intraSatdForVbv = frameEnc->m_analysisData.lookahead.intraSatdForVbv[index];
+ frameEnc->m_encData->m_rowStat[index].satdForVbv = frameEnc->m_analysisData.lookahead.satdForVbv[index];
+ }
+ for (uint32_t index = 0; index < frameEnc->m_analysisData.numCUsInFrame; index++)
+ {
+ frameEnc->m_encData->m_cuStat[index].intraVbvCost = frameEnc->m_analysisData.lookahead.intraVbvCost[index];
+ frameEnc->m_encData->m_cuStat[index].vbvCost = frameEnc->m_analysisData.lookahead.vbvCost[index];
+ }
+ }
if (m_param->searchMethod == X265_SEA && frameEnc->m_lowres.sliceType != X265_TYPE_B)
{
int padX = m_param->maxCUSize + 32;
@@ -1129,6 +1181,7 @@
uint32_t numCUsInFrame = widthInCU * heightInCU;
analysis->numCUsInFrame = numCUsInFrame;
+ analysis->numCuInHeight = heightInCU;
analysis->numPartitions = m_param->num4x4Partitions;
allocAnalysis(analysis);
}
@@ -2705,6 +2758,13 @@
{
X265_CHECK(analysis->sliceType, "invalid slice type\n");
analysis->interData = analysis->intraData = NULL;
+ if (!m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ CHECKED_MALLOC_ZERO(analysis->lookahead.intraSatdForVbv, uint32_t, analysis->numCuInHeight);
+ CHECKED_MALLOC_ZERO(analysis->lookahead.satdForVbv, uint32_t, analysis->numCuInHeight);
+ CHECKED_MALLOC_ZERO(analysis->lookahead.intraVbvCost, uint32_t, analysis->numCUsInFrame);
+ CHECKED_MALLOC_ZERO(analysis->lookahead.vbvCost, uint32_t, analysis->numCUsInFrame);
+ }
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
if (m_param->analysisReuseLevel < 2)
@@ -2770,6 +2830,13 @@
void Encoder::freeAnalysis(x265_analysis_data* analysis)
{
+ if (!m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ X265_FREE(analysis->lookahead.satdForVbv);
+ X265_FREE(analysis->lookahead.intraSatdForVbv);
+ X265_FREE(analysis->lookahead.vbvCost);
+ X265_FREE(analysis->lookahead.intraVbvCost);
+ }
/* Early exit freeing weights alone if level is 1 (when there is no analysis inter/intra) */
if (analysis->sliceType > X265_TYPE_I && analysis->wt)
X265_FREE(analysis->wt);
@@ -2949,7 +3016,12 @@
X265_FREAD(&analysis->bScenecut, sizeof(int), 1, m_analysisFile, &(picData->bScenecut));
X265_FREAD(&analysis->satdCost, sizeof(int64_t), 1, m_analysisFile, &(picData->satdCost));
X265_FREAD(&analysis->numCUsInFrame, sizeof(int), 1, m_analysisFile, &(picData->numCUsInFrame));
+ X265_FREAD(&analysis->numCuInHeight, sizeof(uint32_t), 1, m_analysisFile, &(picData->numCuInHeight));
X265_FREAD(&analysis->numPartitions, sizeof(int), 1, m_analysisFile, &(picData->numPartitions));
+ if (!m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ X265_FREAD(&analysis->lookahead, sizeof(x265_lookahead_data), 1, m_analysisFile, &(picData->lookahead));
+ }
int scaledNumPartition = analysis->numPartitions;
int factor = 1 << m_param->scaleFactor;
@@ -2958,7 +3030,13 @@
/* Memory is allocated for inter and intra analysis data based on the slicetype */
allocAnalysis(analysis);
-
+ if (!m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ X265_FREAD(analysis->lookahead.intraVbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFile, picData->lookahead.intraVbvCost);
+ X265_FREAD(analysis->lookahead.vbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFile, picData->lookahead.vbvCost);
+ X265_FREAD(analysis->lookahead.satdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFile, picData->lookahead.satdForVbv);
+ X265_FREAD(analysis->lookahead.intraSatdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFile, picData->lookahead.intraSatdForVbv);
+ }
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
if (m_param->analysisReuseLevel < 2)
diff -r 2718cb5dd67f -r 6410885f92f6 source/encoder/frameencoder.cpp
--- a/source/encoder/frameencoder.cpp Tue Sep 05 11:21:56 2017 +0530
+++ b/source/encoder/frameencoder.cpp Mon Jul 24 11:19:30 2017 +0530
@@ -1376,17 +1376,19 @@
/* TODO: use defines from slicetype.h for lowres block size */
uint32_t block_y = (ctu->m_cuPelY >> m_param->maxLog2CUSize) * noOfBlocks;
uint32_t block_x = (ctu->m_cuPelX >> m_param->maxLog2CUSize) * noOfBlocks;
-
- cuStat.vbvCost = 0;
- cuStat.intraVbvCost = 0;
- for (uint32_t h = 0; h < noOfBlocks && block_y < maxBlockRows; h++, block_y++)
+ if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD || m_param->bUseAnalysisFile || !m_param->scaleFactor)
{
- uint32_t idx = block_x + (block_y * maxBlockCols);
+ cuStat.vbvCost = 0;
+ cuStat.intraVbvCost = 0;
+ for (uint32_t h = 0; h < noOfBlocks && block_y < maxBlockRows; h++, block_y++)
+ {
+ uint32_t idx = block_x + (block_y * maxBlockCols);
- for (uint32_t w = 0; w < noOfBlocks && (block_x + w) < maxBlockCols; w++, idx++)
- {
- cuStat.vbvCost += m_frame->m_lowres.lowresCostForRc[idx] & LOWRES_COST_MASK;
- cuStat.intraVbvCost += m_frame->m_lowres.intraCost[idx];
+ for (uint32_t w = 0; w < noOfBlocks && (block_x + w) < maxBlockCols; w++, idx++)
+ {
+ cuStat.vbvCost += m_frame->m_lowres.lowresCostForRc[idx] & LOWRES_COST_MASK;
+ cuStat.intraVbvCost += m_frame->m_lowres.intraCost[idx];
+ }
}
}
}
diff -r 2718cb5dd67f -r 6410885f92f6 source/encoder/slicetype.cpp
--- a/source/encoder/slicetype.cpp Tue Sep 05 11:21:56 2017 +0530
+++ b/source/encoder/slicetype.cpp Mon Jul 24 11:19:30 2017 +0530
@@ -742,9 +742,21 @@
/* Called by API thread */
void Lookahead::addPicture(Frame& curFrame, int sliceType)
{
- checkLookaheadQueue(m_inputCount);
- curFrame.m_lowres.sliceType = sliceType;
- addPicture(curFrame);
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && !m_param->bUseAnalysisFile && m_param->scaleFactor)
+ {
+ if (!m_filled)
+ m_filled = true;
+ m_outputLock.acquire();
+ m_outputQueue.pushBack(curFrame);
+ m_outputLock.release();
+ m_inputCount++;
+ }
+ else
+ {
+ checkLookaheadQueue(m_inputCount);
+ curFrame.m_lowres.sliceType = sliceType;
+ addPicture(curFrame);
+ }
}
void Lookahead::addPicture(Frame& curFrame)
@@ -831,6 +843,9 @@
return out;
}
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && !m_param->bUseAnalysisFile && m_param->scaleFactor)
+ return NULL;
+
findJob(-1); /* run slicetypeDecide() if necessary */
m_inputLock.acquire();
@@ -887,68 +902,68 @@
default:
return;
}
+ if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD || m_param->bUseAnalysisFile || !m_param->scaleFactor)
+ {
+ X265_CHECK(curFrame->m_lowres.costEst[b - p0][p1 - b] > 0, "Slice cost not estimated\n")
+ if (m_param->rc.cuTree && !m_param->rc.bStatRead)
+ /* update row satds based on cutree offsets */
+ curFrame->m_lowres.satdCost = frameCostRecalculate(frames, p0, p1, b);
+ else if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD)
+ {
+ if (m_param->rc.aqMode)
+ curFrame->m_lowres.satdCost = curFrame->m_lowres.costEstAq[b - p0][p1 - b];
+ else
+ curFrame->m_lowres.satdCost = curFrame->m_lowres.costEst[b - p0][p1 - b];
+ }
+ if (m_param->rc.vbvBufferSize && m_param->rc.vbvMaxBitrate)
+ {
+ /* aggregate lowres row satds to CTU resolution */
+ curFrame->m_lowres.lowresCostForRc = curFrame->m_lowres.lowresCosts[b - p0][p1 - b];
+ uint32_t lowresRow = 0, lowresCol = 0, lowresCuIdx = 0, sum = 0, intraSum = 0;
+ uint32_t scale = m_param->maxCUSize / (2 * X265_LOWRES_CU_SIZE);
+ uint32_t numCuInHeight = (m_param->sourceHeight + m_param->maxCUSize - 1) / m_param->maxCUSize;
+ uint32_t widthInLowresCu = (uint32_t)m_8x8Width, heightInLowresCu = (uint32_t)m_8x8Height;
+ double *qp_offset = 0;
+ /* Factor in qpoffsets based on Aq/Cutree in CU costs */
+ if (m_param->rc.aqMode || m_param->bAQMotion)
+ qp_offset = (frames[b]->sliceType == X265_TYPE_B || !m_param->rc.cuTree) ? frames[b]->qpAqOffset : frames[b]->qpCuTreeOffset;
- X265_CHECK(curFrame->m_lowres.costEst[b - p0][p1 - b] > 0, "Slice cost not estimated\n")
-
- if (m_param->rc.cuTree && !m_param->rc.bStatRead)
- /* update row satds based on cutree offsets */
- curFrame->m_lowres.satdCost = frameCostRecalculate(frames, p0, p1, b);
- else if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD || m_param->scaleFactor)
- {
- if (m_param->rc.aqMode)
- curFrame->m_lowres.satdCost = curFrame->m_lowres.costEstAq[b - p0][p1 - b];
- else
- curFrame->m_lowres.satdCost = curFrame->m_lowres.costEst[b - p0][p1 - b];
- }
-
- if (m_param->rc.vbvBufferSize && m_param->rc.vbvMaxBitrate)
- {
- /* aggregate lowres row satds to CTU resolution */
- curFrame->m_lowres.lowresCostForRc = curFrame->m_lowres.lowresCosts[b - p0][p1 - b];
- uint32_t lowresRow = 0, lowresCol = 0, lowresCuIdx = 0, sum = 0, intraSum = 0;
- uint32_t scale = m_param->maxCUSize / (2 * X265_LOWRES_CU_SIZE);
- uint32_t numCuInHeight = (m_param->sourceHeight + m_param->maxCUSize - 1) / m_param->maxCUSize;
- uint32_t widthInLowresCu = (uint32_t)m_8x8Width, heightInLowresCu = (uint32_t)m_8x8Height;
- double *qp_offset = 0;
- /* Factor in qpoffsets based on Aq/Cutree in CU costs */
- if (m_param->rc.aqMode || m_param->bAQMotion)
- qp_offset = (frames[b]->sliceType == X265_TYPE_B || !m_param->rc.cuTree) ? frames[b]->qpAqOffset : frames[b]->qpCuTreeOffset;
-
- for (uint32_t row = 0; row < numCuInHeight; row++)
- {
- lowresRow = row * scale;
- for (uint32_t cnt = 0; cnt < scale && lowresRow < heightInLowresCu; lowresRow++, cnt++)
+ for (uint32_t row = 0; row < numCuInHeight; row++)
{
- sum = 0; intraSum = 0;
- int diff = 0;
- lowresCuIdx = lowresRow * widthInLowresCu;
- for (lowresCol = 0; lowresCol < widthInLowresCu; lowresCol++, lowresCuIdx++)
+ lowresRow = row * scale;
+ for (uint32_t cnt = 0; cnt < scale && lowresRow < heightInLowresCu; lowresRow++, cnt++)
{
- uint16_t lowresCuCost = curFrame->m_lowres.lowresCostForRc[lowresCuIdx] & LOWRES_COST_MASK;
- if (qp_offset)
+ sum = 0; intraSum = 0;
+ int diff = 0;
+ lowresCuIdx = lowresRow * widthInLowresCu;
+ for (lowresCol = 0; lowresCol < widthInLowresCu; lowresCol++, lowresCuIdx++)
{
- double qpOffset;
- if (m_param->rc.qgSize == 8)
- qpOffset = (qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4] +
- qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4 + 1] +
- qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4 + curFrame->m_lowres.maxBlocksInRowFullRes] +
- qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4 + curFrame->m_lowres.maxBlocksInRowFullRes + 1]) / 4;
- else
- qpOffset = qp_offset[lowresCuIdx];
- lowresCuCost = (uint16_t)((lowresCuCost * x265_exp2fix8(qpOffset) + 128) >> 8);
- int32_t intraCuCost = curFrame->m_lowres.intraCost[lowresCuIdx];
- curFrame->m_lowres.intraCost[lowresCuIdx] = (intraCuCost * x265_exp2fix8(qpOffset) + 128) >> 8;
+ uint16_t lowresCuCost = curFrame->m_lowres.lowresCostForRc[lowresCuIdx] & LOWRES_COST_MASK;
+ if (qp_offset)
+ {
+ double qpOffset;
+ if (m_param->rc.qgSize == 8)
+ qpOffset = (qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4] +
+ qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4 + 1] +
+ qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4 + curFrame->m_lowres.maxBlocksInRowFullRes] +
+ qp_offset[lowresCol * 2 + lowresRow * widthInLowresCu * 4 + curFrame->m_lowres.maxBlocksInRowFullRes + 1]) / 4;
+ else
+ qpOffset = qp_offset[lowresCuIdx];
+ lowresCuCost = (uint16_t)((lowresCuCost * x265_exp2fix8(qpOffset) + 128) >> 8);
+ int32_t intraCuCost = curFrame->m_lowres.intraCost[lowresCuIdx];
+ curFrame->m_lowres.intraCost[lowresCuIdx] = (intraCuCost * x265_exp2fix8(qpOffset) + 128) >> 8;
+ }
+ if (m_param->bIntraRefresh && slice->m_sliceType == X265_TYPE_P)
+ for (uint32_t x = curFrame->m_encData->m_pir.pirStartCol; x <= curFrame->m_encData->m_pir.pirEndCol; x++)
+ diff += curFrame->m_lowres.intraCost[lowresCuIdx] - lowresCuCost;
+ curFrame->m_lowres.lowresCostForRc[lowresCuIdx] = lowresCuCost;
+ sum += lowresCuCost;
+ intraSum += curFrame->m_lowres.intraCost[lowresCuIdx];
}
- if (m_param->bIntraRefresh && slice->m_sliceType == X265_TYPE_P)
- for (uint32_t x = curFrame->m_encData->m_pir.pirStartCol; x <= curFrame->m_encData->m_pir.pirEndCol; x++)
- diff += curFrame->m_lowres.intraCost[lowresCuIdx] - lowresCuCost;
- curFrame->m_lowres.lowresCostForRc[lowresCuIdx] = lowresCuCost;
- sum += lowresCuCost;
- intraSum += curFrame->m_lowres.intraCost[lowresCuIdx];
+ curFrame->m_encData->m_rowStat[row].satdForVbv += sum;
+ curFrame->m_encData->m_rowStat[row].satdForVbv += diff;
+ curFrame->m_encData->m_rowStat[row].intraSatdForVbv += intraSum;
}
- curFrame->m_encData->m_rowStat[row].satdForVbv += sum;
- curFrame->m_encData->m_rowStat[row].satdForVbv += diff;
- curFrame->m_encData->m_rowStat[row].intraSatdForVbv += intraSum;
}
}
}
diff -r 2718cb5dd67f -r 6410885f92f6 source/x265.h
--- a/source/x265.h Tue Sep 05 11:21:56 2017 +0530
+++ b/source/x265.h Mon Jul 24 11:19:30 2017 +0530
@@ -88,6 +88,20 @@
uint8_t* payload;
} x265_nal;
+#define X265_LOOKAHEAD_MAX 250
+
+typedef struct x265_lookahead_data
+{
+ int64_t plannedSatd[X265_LOOKAHEAD_MAX + 1];
+ uint32_t *vbvCost;
+ uint32_t *intraVbvCost;
+ uint32_t *satdForVbv;
+ uint32_t *intraSatdForVbv;
+ int keyframe;
+ int lastMiniGopBFrame;
+ int plannedType[X265_LOOKAHEAD_MAX + 1];
+} x265_lookahead_data;
+
/* Stores all analysis data for a single frame */
typedef struct x265_analysis_data
{
@@ -102,6 +116,8 @@
void* wt;
void* interData;
void* intraData;
+ uint32_t numCuInHeight;
+ x265_lookahead_data lookahead;
} x265_analysis_data;
/* cu statistics */
-------------- next part --------------
A non-text attachment was scrubbed...
Name: x265-clone.patch
Type: text/x-patch
Size: 22936 bytes
Desc: not available
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20170906/a43ec757/attachment-0001.bin>
More information about the x265-devel
mailing list