On Wed, Sep 6, 2017 at 8:30 PM, Divya Manivannan <[email protected] > wrote:
> # HG changeset patch > # User Divya Manivannan <[email protected]> > # 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 > [email protected] > https://mailman.videolan.org/listinfo/x265-devel > >
_______________________________________________ x265-devel mailing list [email protected] https://mailman.videolan.org/listinfo/x265-devel
