[x265] [PATCH] Skip the lookahead when analysis reuse mode is load and analysis file writing
Pradeep Ramachandran
pradeep at multicorewareinc.com
Fri Sep 8 09:56:25 CEST 2017
On Wed, Sep 6, 2017 at 8:30 PM, Divya Manivannan <divya at multicorewareinc.com
> wrote:
> # 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.
>
Pushed into default branch. Thanks!
>
> 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 */
>
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> https://mailman.videolan.org/listinfo/x265-devel
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20170908/d9e564df/attachment-0001.html>
More information about the x265-devel
mailing list