[x265] [PATCH] TEncSlice : Removed Unused Functions, variables and Removed Hungarian Notations
Steve Borho
steve at borho.org
Thu Jul 11 20:01:08 CEST 2013
On Thu, Jul 11, 2013 at 1:37 AM, <gopu at multicorewareinc.com> wrote:
> # HG changeset patch
> # User ggopu
> # Date 1373524666 -19800
> # Node ID aae6cfa2114929d0ebb59b1bd55c3231de664358
> # Parent 2245a4a8b34da61d4d572b40f10024a4f1013030
> TEncSlice : Removed Unused Functions, variables and Removed Hungarian
> Notations
>
I'm not going to push this one, please resolve the problems I've noted
below and then resubmit a new patch from the current tip.
>
> diff -r 2245a4a8b34d -r aae6cfa21149 source/Lib/TLibEncoder/TEncGOP.cpp
> --- a/source/Lib/TLibEncoder/TEncGOP.cpp Wed Jul 10 22:28:41 2013
> -0500
> +++ b/source/Lib/TLibEncoder/TEncGOP.cpp Thu Jul 11 12:07:46 2013
> +0530
> @@ -459,7 +459,6 @@
> }
>
> // Slice data initialization
> - sliceEncoder->setSliceIdx(0);
> slice = sliceEncoder->initEncSlice(pic, frameEncoder, gopSize <=
> 1, pocLast, pocCurr, gopIdx, &m_cSPS, &m_cPPS);
> slice->setLastIDR(m_iLastIDR);
>
> @@ -1088,7 +1087,6 @@
> }
>
> slice->setNextSlice(false);
> - sliceEncoder->setSliceIdx(0);
>
> // Reconstruction slice
> slice->setNextSlice(true);
> diff -r 2245a4a8b34d -r aae6cfa21149 source/Lib/TLibEncoder/TEncSlice.cpp
> --- a/source/Lib/TLibEncoder/TEncSlice.cpp Wed Jul 10 22:28:41 2013
> -0500
> +++ b/source/Lib/TLibEncoder/TEncSlice.cpp Thu Jul 11 12:07:46 2013
> +0530
> @@ -59,21 +59,6 @@
>
> TEncSlice::~TEncSlice()
> {
> - for (std::vector<TEncSbac*>::iterator i = CTXMem.begin(); i !=
> CTXMem.end(); i++)
> - {
> - delete (*i);
> - }
> -}
> -
> -Void TEncSlice::initCtxMem(UInt i)
> -{
> - for (std::vector<TEncSbac*>::iterator j = CTXMem.begin(); j !=
> CTXMem.end(); j++)
> - {
> - delete (*j);
> - }
> -
> - CTXMem.clear();
> - CTXMem.resize(i);
> }
>
>
Yeah, good, I forgot to finish cleaning those up
> Void TEncSlice::create(Int width, Int height, UInt iMaxCUWidth, UInt
> iMaxCUHeight, UChar uhTotalDepth)
> @@ -105,8 +90,8 @@
> */
> TComSlice* TEncSlice::initEncSlice(TComPic* pcPic, x265::FrameEncoder
> *pcEncodeFrame, Bool bForceISlice, Int pocLast, Int pocCurr, Int iGOPid,
> TComSPS* pSPS, TComPPS *pPPS)
> {
> - Double dQP;
> - Double dLambda;
> + Double QP;
> + Double Lambda;
>
lower case lambda. this is a rare function that actually has the same
variable with two type, and so you must differentiate them in a way that
doesn't use hungarian notation. Since the rest of the encoder deals with
QP as an integer, it's best to change iQP to qp, and dQP to qpDouble.
> TComSlice* pcSlice = pcPic->getSlice();
> pcSlice->setSPS(pSPS);
> @@ -148,10 +133,8 @@
>
> // slice type
> SliceType eSliceType;
>
eSliceType is hungarian, it should be sliceType. Why remove the
white-space below?
> -
> eSliceType = B_SLICE;
> eSliceType = (pocLast == 0 || pocCurr % m_pcCfg->getIntraPeriod() ==
> 0 || bForceISlice) ? I_SLICE : eSliceType;
> -
> pcSlice->setSliceType(eSliceType);
>
> //
> ------------------------------------------------------------------------------------------------------------------
> @@ -172,12 +155,12 @@
> // QP setting
> //
> ------------------------------------------------------------------------------------------------------------------
>
> - dQP = m_pcCfg->getQP();
> + QP = m_pcCfg->getQP();
> if (eSliceType != I_SLICE)
> {
> - if (!((dQP == -pcSlice->getSPS()->getQpBDOffsetY()) &&
> (pcSlice->getSPS()->getUseLossless())))
> + if (!((QP == -pcSlice->getSPS()->getQpBDOffsetY()) &&
> (pcSlice->getSPS()->getUseLossless())))
> {
> - dQP += m_pcCfg->getGOPEntry(iGOPid).m_QPOffset;
> + QP += m_pcCfg->getGOPEntry(iGOPid).m_QPOffset;
> }
> }
>
> @@ -185,57 +168,41 @@
> Int* pdQPs = m_pcCfg->getdQPs();
> if (pdQPs)
> {
> - dQP += pdQPs[pcSlice->getPOC()];
> + QP += pdQPs[pcSlice->getPOC()];
> }
>
> //
> ------------------------------------------------------------------------------------------------------------------
> // Lambda computation
> //
> ------------------------------------------------------------------------------------------------------------------
>
> - Int iQP;
>
-
> - // compute lambda value
> Int NumberBFrames = (m_pcCfg->getGOPSize() - 1);
> Int SHIFT_QP = 12;
> + Int iQP;
> Double dLambda_scale = 1.0 - Clip3(0.0, 0.5, 0.05 *
> (Double)NumberBFrames);
> #if FULL_NBIT
> Int bitdepth_luma_qp_scale = 6 * (g_bitDepth - 8);
> #else
> Int bitdepth_luma_qp_scale = 0;
> #endif
> - Double qp_temp = (Double)dQP + bitdepth_luma_qp_scale - SHIFT_QP;
> + Double qp_temp = (Double)QP + bitdepth_luma_qp_scale - SHIFT_QP;
> #if FULL_NBIT
> Double qp_temp_orig = (Double)dQP - SHIFT_QP;
> #endif
> // Case #1: I or P-slices (key-frame)
> - Double dQPFactor = m_pcCfg->getGOPEntry(iGOPid).m_QPFactor;
> + Double QPFactor = m_pcCfg->getGOPEntry(iGOPid).m_QPFactor;
>
qpFactor
> if (eSliceType == I_SLICE)
> {
> - dQPFactor = 0.57 * dLambda_scale;
> + QPFactor = 0.57 * dLambda_scale;
>
lambdaScale, qpFactor
> }
> - dLambda = dQPFactor * pow(2.0, qp_temp / 3.0);
> + Lambda = QPFactor * pow(2.0, qp_temp / 3.0);
>
The below was a very useful comment, because the code had a very unexpected
side-effect. It is better to leave this in place.
> -#if 0
> - // SJB - This logic causes the HM to use different lambdas for the
> same QP between the first
> - // and later GOPs because the cadence changes (the very first I frame
> is handled specially, throwing
> - // off the sequence).
> - if (depth > 0)
> - {
> -#if FULL_NBIT
> - dLambda *= Clip3(2.00, 4.00, (qp_temp_orig / 6.0)); // (j ==
> B_SLICE && p_cur_frm->layer != 0 )
> -#else
> - dLambda *= Clip3(2.00, 4.00, (qp_temp / 6.0)); // (j == B_SLICE
> && p_cur_frm->layer != 0 )
> -#endif
> - }
> -#else
> - if (pcSlice->getSliceType() != I_SLICE) dLambda *= 1.55;
> -#endif
> + if (pcSlice->getSliceType() != I_SLICE) Lambda *= 1.55;
>
> - iQP = max(-pSPS->getQpBDOffsetY(), min(MAX_QP, (Int)floor(dQP +
> 0.5)));
> + iQP = max(-pSPS->getQpBDOffsetY(), min(MAX_QP, (Int)floor(QP + 0.5)));
>
> if (pcSlice->getSliceType() != I_SLICE)
> {
> - dLambda *=
> m_pcCfg->getLambdaModifier(m_pcCfg->getGOPEntry(iGOPid).m_temporalId);
> + Lambda *=
> m_pcCfg->getLambdaModifier(m_pcCfg->getGOPEntry(iGOPid).m_temporalId);
> }
>
> // for RDO
> @@ -255,10 +222,10 @@
> pcEncodeFrame->setCrDistortionWeight(weight);
>
> // for RDOQ
> - pcEncodeFrame->setQPLambda(iQP, dLambda, dLambda / weight);
> + pcEncodeFrame->setQPLambda(iQP, Lambda, Lambda / weight);
>
> // For SAO
> - pcSlice->setLambda(dLambda, dLambda / weight);
> + pcSlice->setLambda(Lambda, Lambda / weight);
>
> #if HB_LAMBDA_FOR_LDC
> // restore original slice type
> @@ -269,8 +236,8 @@
>
> if (m_pcCfg->getUseRecalculateQPAccordingToLambda())
> {
> - dQP = xGetQPValueAccordingToLambda(dLambda);
> - iQP = max(-pSPS->getQpBDOffsetY(), min(MAX_QP, (Int)floor(dQP +
> 0.5)));
>
No magic numbers here. this is not an improvement.
getUseRecalculateQPAccordingToLambda() should probably just get removed.
> + QP = 4.2005 * log(Lambda) + 13.7122;
> + iQP = max(-pSPS->getQpBDOffsetY(), min(MAX_QP, (Int)floor(QP +
> 0.5)));
> }
>
> pcSlice->setSliceQp(iQP);
> @@ -314,16 +281,15 @@
> }
>
> pcSlice->setDepth(depth);
> -
> pcPic->setTLayer(m_pcCfg->getGOPEntry(iGOPid).m_temporalId);
> if (eSliceType == I_SLICE)
> {
> pcPic->setTLayer(0);
> }
> pcSlice->setTLayer(pcPic->getTLayer());
> -
> pcSlice->setMaxNumMergeCand(m_pcCfg->getMaxNumMergeCand());
> xStoreWPparam(pPPS->getUseWP(), pPPS->getWPBiPred());
> +
> return pcSlice;
> }
>
> @@ -364,21 +330,21 @@
>
> Void TEncSlice::setSearchRange(TComSlice* pcSlice, FrameEncoder
> *pcEncodeframe)
> {
> - Int iCurrPOC = pcSlice->getPOC();
> - Int iGOPSize = m_pcCfg->getGOPSize();
> - Int iOffset = (iGOPSize >> 1);
> - Int iMaxSR = m_pcCfg->getSearchRange();
> - Int iNumPredDir = pcSlice->isInterP() ? 1 : 2;
> + Int CurrPOC = pcSlice->getPOC();
> + Int GOPSize = m_pcCfg->getGOPSize();
> + Int Offset = (GOPSize >> 1);
> + Int MaxSR = m_pcCfg->getSearchRange();
> + Int NumPredDir = pcSlice->isInterP() ? 1 : 2;
>
curPOC, gopSize, offset, maxSR, numPredDir
variables must start with lower case letters. UpperCase is reserved for
classes. I'm not going to comment on the rest of them in this patch.
> - for (Int iDir = 0; iDir <= iNumPredDir; iDir++)
> + for (Int Dir = 0; Dir <= NumPredDir; Dir++)
> {
> - RefPicList e = (iDir ? REF_PIC_LIST_1 : REF_PIC_LIST_0);
> - for (Int iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(e);
> iRefIdx++)
> + RefPicList e = (Dir ? REF_PIC_LIST_1 : REF_PIC_LIST_0);
> + for (Int RefIdx = 0; RefIdx < pcSlice->getNumRefIdx(e); RefIdx++)
> {
> - Int iRefPOC = pcSlice->getRefPic(e, iRefIdx)->getPOC();
> - Int iNewSR = Clip3(8, iMaxSR, (iMaxSR * ADAPT_SR_SCALE *
> abs(iCurrPOC - iRefPOC) + iOffset) / iGOPSize);
> + Int RefPOC = pcSlice->getRefPic(e, RefIdx)->getPOC();
> + Int NewSR = Clip3(8, MaxSR, (MaxSR * ADAPT_SR_SCALE *
> abs(CurrPOC - RefPOC) + Offset) / GOPSize);
>
> - pcEncodeframe->setAdaptiveSearchRange(iDir, iRefIdx, iNewSR);
> + pcEncodeframe->setAdaptiveSearchRange(Dir, RefIdx, NewSR);
> }
> }
> }
> @@ -449,24 +415,15 @@
> {
> // TODO: fix this option
> assert(0);
> -#if 0
> - m_pcTrQuant->clearSliceARLCnt();
> - if (pcSlice->getSliceType() != I_SLICE)
> - {
> - Int qpBase = pcSlice->getSliceQpBase();
> - pcSlice->setSliceQp(qpBase + m_pcTrQuant->getQpDelta(qpBase));
> - }
> -#endif
>
This should be left in place until all of the HM's adaptive QP is removed
> }
> -
> pcEncodeFrame->encode(pcPic, pcSlice);
>
> if (m_pcCfg->getWaveFrontsynchro())
> {
> pcSlice->setNextSlice(true);
> }
> + xRestoreWPparam(pcSlice);
>
> - xRestoreWPparam(pcSlice);
> #if CU_STAT_LOGFILE
> if (pcSlice->getSliceType() == P_SLICE)
> {
> @@ -496,9 +453,9 @@
> Void TEncSlice::encodeSlice(TComPic* pcPic, TComOutputBitstream*
> pcSubstreams, FrameEncoder* pcEncodeFrame)
> {
> PPAScopeEvent(TEncSlice_encodeSlice);
> - UInt uiCUAddr;
> - UInt uiStartCUAddr;
> - UInt uiBoundingCUAddr;
> + UInt CUAddr;
> + UInt StartCUAddr;
> + UInt BoundingCUAddr;
> TComSlice* pcSlice = pcPic->getSlice();
>
> // choose entropy coder
> @@ -509,8 +466,8 @@
> pcEncodeFrame->getCuEncoder(0)->setBitCounter(NULL);
> pcEntropyCoder->setEntropyCoder(pcSbacCoder, pcSlice);
>
> - uiStartCUAddr = 0;
> - uiBoundingCUAddr = pcSlice->getSliceCurEndCUAddr();
> + StartCUAddr = 0;
> + BoundingCUAddr = pcSlice->getSliceCurEndCUAddr();
>
> // Appropriate substream bitstream is switched later.
> // for every CU
> @@ -525,47 +482,45 @@
> g_bJustDoIt = g_bEncDecTraceDisable;
> #endif
>
> - const Bool bWaveFrontsynchro = m_pcCfg->getWaveFrontsynchro();
> - const UInt uiHeightInLCUs = pcPic->getPicSym()->getFrameHeightInCU();
> - const Int iNumSubstreams = (bWaveFrontsynchro ? uiHeightInLCUs : 1);
> + const Bool WaveFrontsynchro = m_pcCfg->getWaveFrontsynchro();
> + const UInt HeightInLCUs = pcPic->getPicSym()->getFrameHeightInCU();
> + const Int NumSubstreams = (WaveFrontsynchro ? HeightInLCUs : 1);
> UInt uiBitsOriginallyInSubstreams = 0;
>
> - for (Int iSubstrmIdx = 0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++)
> + for (Int iSubstrmIdx = 0; iSubstrmIdx < NumSubstreams; iSubstrmIdx++)
> {
> -
> pcEncodeFrame->getBufferSBac(iSubstrmIdx)->loadContexts(pcSbacCoder);
> //init. state
> +
> pcEncodeFrame->getBufferSBac(iSubstrmIdx)->loadContexts(pcSbacCoder);
> uiBitsOriginallyInSubstreams +=
> pcSubstreams[iSubstrmIdx].getNumberOfWrittenBits();
> }
>
> - UInt uiWidthInLCUs = pcPic->getPicSym()->getFrameWidthInCU();
> - UInt uiCol = 0, uiLin = 0, uiSubStrm = 0;
> - uiCUAddr = (uiStartCUAddr / pcPic->getNumPartInCU()); /* for tiles,
> uiStartCUAddr is NOT the real raster scan address, it is actually
> + UInt WidthInLCUs = pcPic->getPicSym()->getFrameWidthInCU();
> + UInt Col = 0, Lin = 0, SubStrm = 0;
> + CUAddr = (StartCUAddr / pcPic->getNumPartInCU()); /* for tiles,
> uiStartCUAddr is NOT the real raster scan address, it is actually
> an encoding
> order index, so we need to convert the index (uiStartCUAddr)
> into the
> real raster scan address (uiCUAddr) via the CUOrderMap */
> - UInt uiEncCUOrder;
> - for (uiEncCUOrder = uiStartCUAddr / pcPic->getNumPartInCU();
> - uiEncCUOrder < (uiBoundingCUAddr + pcPic->getNumPartInCU() - 1)
> / pcPic->getNumPartInCU();
> - uiCUAddr = (++uiEncCUOrder))
> + for (UInt EncCUOrder = StartCUAddr / pcPic->getNumPartInCU();
> + EncCUOrder < (BoundingCUAddr + pcPic->getNumPartInCU() - 1) /
> pcPic->getNumPartInCU();
> + CUAddr = (++EncCUOrder))
> {
> - //UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();
> - uiCol = uiCUAddr % uiWidthInLCUs;
> - uiLin = uiCUAddr / uiWidthInLCUs;
> - uiSubStrm = uiLin % iNumSubstreams;
> + Col = CUAddr % WidthInLCUs;
> + Lin = CUAddr / WidthInLCUs;
> + SubStrm = Lin % NumSubstreams;
>
> - pcEntropyCoder->setBitstream(&pcSubstreams[uiSubStrm]);
> + pcEntropyCoder->setBitstream(&pcSubstreams[SubStrm]);
>
> // Synchronize cabac probabilities with upper-right LCU if it's
> available and we're at the start of a line.
> - if ((iNumSubstreams > 1) && (uiCol == 0) && bWaveFrontsynchro)
> + if ((NumSubstreams > 1) && (Col == 0) && WaveFrontsynchro)
> {
> // We'll sync if the TR is available.
> - TComDataCU *pcCUUp = pcPic->getCU(uiCUAddr)->getCUAbove();
> - UInt uiWidthInCU = pcPic->getFrameWidthInCU();
> - UInt uiMaxParts = 1 << (pcSlice->getSPS()->getMaxCUDepth() <<
> 1);
> + TComDataCU *pcCUUp = pcPic->getCU(CUAddr)->getCUAbove();
> + UInt WidthInCU = pcPic->getFrameWidthInCU();
> + UInt MaxParts = 1 << (pcSlice->getSPS()->getMaxCUDepth() <<
> 1);
> TComDataCU *pcCUTR = NULL;
>
> // CHECK_ME: here can br optimize a little, do it later
> - if (pcCUUp && ((uiCUAddr % uiWidthInCU + 1) < uiWidthInCU))
> + if (pcCUUp && ((CUAddr % WidthInCU + 1) < WidthInCU))
> {
> - pcCUTR = pcPic->getCU(uiCUAddr - uiWidthInCU + 1);
> + pcCUTR = pcPic->getCU(CUAddr - WidthInCU + 1);
> }
> if (true /*bEnforceSliceRestriction*/ && ((pcCUTR == NULL) ||
> (pcCUTR->getSlice() == NULL)))
> {
> @@ -574,25 +529,25 @@
> else
> {
> // TR is available, we use it.
> -
> pcEncodeFrame->getSbacCoder(uiSubStrm)->loadContexts(pcEncodeFrame->getBufferSBac(uiLin
> - 1));
> +
> pcEncodeFrame->getSbacCoder(SubStrm)->loadContexts(pcEncodeFrame->getBufferSBac(Lin
> - 1));
> }
> }
> - pcSbacCoder->load(pcEncodeFrame->getSbacCoder(uiSubStrm)); //this
> load is used to simplify the code (avoid to change all the call to
> m_pcSbacCoder)
> + pcSbacCoder->load(pcEncodeFrame->getSbacCoder(SubStrm)); //this
> load is used to simplify the code (avoid to change all the call to
> m_pcSbacCoder)
>
> - TComDataCU* cu = pcPic->getCU(uiCUAddr);
> + TComDataCU* cu = pcPic->getCU(CUAddr);
> if (pcSlice->getSPS()->getUseSAO() &&
> (pcSlice->getSaoEnabledFlag() || pcSlice->getSaoEnabledFlagChroma()))
> {
> SAOParam *saoParam =
> pcSlice->getPic()->getPicSym()->getSaoParam();
> - Int iNumCuInWidth = saoParam->numCuInWidth;
> - Int iCUAddrInSlice = uiCUAddr;
> - Int iCUAddrUpInSlice = iCUAddrInSlice - iNumCuInWidth;
> - Int rx = uiCUAddr % iNumCuInWidth;
> - Int ry = uiCUAddr / iNumCuInWidth;
> + Int NumCuInWidth = saoParam->numCuInWidth;
> + Int CUAddrInSlice = CUAddr;
> + Int CUAddrUpInSlice = CUAddrInSlice - NumCuInWidth;
> + Int rx = CUAddr % NumCuInWidth;
> + Int ry = CUAddr / NumCuInWidth;
> Int allowMergeLeft = 1;
> Int allowMergeUp = 1;
> Int addr = cu->getAddr();
> - allowMergeLeft = (rx > 0) && (iCUAddrInSlice != 0);
> - allowMergeUp = (ry > 0) && (iCUAddrUpInSlice >= 0);
> + allowMergeLeft = (rx > 0) && (CUAddrInSlice != 0);
> + allowMergeUp = (ry > 0) && (CUAddrUpInSlice >= 0);
> if (saoParam->bSaoFlag[0] || saoParam->bSaoFlag[1])
> {
> Int mergeLeft =
> saoParam->saoLcuParam[0][addr].mergeLeftFlag;
> @@ -657,21 +612,18 @@
> #if ENC_DEC_TRACE
> g_bJustDoIt = g_bEncDecTraceDisable;
> #endif
> - pcEncodeFrame->getSbacCoder(uiSubStrm)->load(pcSbacCoder); //load
> back status of the entropy coder after encoding the LCU into relevant
> bitstream entropy coder
> + pcEncodeFrame->getSbacCoder(SubStrm)->load(pcSbacCoder); //load
> back status of the entropy coder after encoding the LCU into relevant
> bitstream entropy coder
>
> // Store probabilities of second LCU in line into buffer
> - if ((iNumSubstreams > 1) && (uiCol == 1) && bWaveFrontsynchro)
> + if ((NumSubstreams > 1) && (Col == 1) && WaveFrontsynchro)
> {
> -
> pcEncodeFrame->getBufferSBac(uiLin)->loadContexts(pcEncodeFrame->getSbacCoder(uiSubStrm));
> +
> pcEncodeFrame->getBufferSBac(Lin)->loadContexts(pcEncodeFrame->getSbacCoder(SubStrm));
> }
> }
>
> if (m_pcCfg->getUseAdaptQpSelect())
> {
> assert(0);
> -#if 0
> - m_pcTrQuant->storeSliceQpNext(pcSlice);
> -#endif
>
Ditto here, leave it in place until getUseAdaptQpSelect() is removed
entirely
> }
> if (pcSlice->getPPS()->getCabacInitPresentFlag())
> {
> @@ -683,19 +635,17 @@
> * \param bEncodeSlice Identifies if the calling function is
> compressSlice() [false] or encodeSlice() [true]
> * \returns Updates uiStartCUAddr, uiBoundingCUAddr with appropriate LCU
> address
> */
> -Void TEncSlice::xDetermineStartAndBoundingCUAddr(TComPic* rpcPic, Bool
> bEncodeSlice)
> +Void TEncSlice::xDetermineStartAndBoundingCUAddr(TComPic* rpcPic, Bool
> EncodeSlice)
> {
> TComSlice* pcSlice = rpcPic->getSlice();
> - UInt uiBoundingCUAddrSlice;
> -
> - UInt uiNumberOfCUsInFrame = rpcPic->getNumCUsInFrame();
> -
> - uiBoundingCUAddrSlice = uiNumberOfCUsInFrame *
> rpcPic->getNumPartInCU();
> + UInt BoundingCUAddrSlice;
> + UInt NumberOfCUsInFrame = rpcPic->getNumCUsInFrame();
> + BoundingCUAddrSlice = NumberOfCUsInFrame * rpcPic->getNumPartInCU();
>
> // WPP: if a slice does not start at the beginning of a CTB row, it
> must end within the same CTB row
> - pcSlice->setSliceCurEndCUAddr(uiBoundingCUAddrSlice);
> + pcSlice->setSliceCurEndCUAddr(BoundingCUAddrSlice);
>
> - if (!bEncodeSlice)
> + if (!EncodeSlice)
> {
> // For fixed number of LCU within an entropy and reconstruction
> slice we already know whether we will encounter end of entropy and/or
> reconstruction slice
> // first. Set the flags accordingly.
> @@ -703,9 +653,4 @@
> }
> }
>
> -Double TEncSlice::xGetQPValueAccordingToLambda(Double lambda)
> -{
> - return 4.2005 * log(lambda) + 13.7122;
> -}
> -
> //! \}
> diff -r 2245a4a8b34d -r aae6cfa21149 source/Lib/TLibEncoder/TEncSlice.h
> --- a/source/Lib/TLibEncoder/TEncSlice.h Wed Jul 10 22:28:41 2013
> -0500
> +++ b/source/Lib/TLibEncoder/TEncSlice.h Thu Jul 11 12:07:46 2013
> +0530
> @@ -47,9 +47,6 @@
> #include "WeightPredAnalysis.h"
> #include "TEncRateCtrl.h"
>
> -//! \ingroup TLibEncoder
> -//! \{
> -
> class TEncTop;
> class TEncGOP;
>
> @@ -63,14 +60,10 @@
> class TEncSlice : public WeightPredAnalysis
> {
> private:
> -
> // encoder configuration
> TEncCfg* m_pcCfg; ///<
> encoder configuration class
> - UInt m_uiSliceIdx;
> - std::vector<TEncSbac*> CTXMem;
>
> public:
> -
> TEncSlice();
> virtual ~TEncSlice();
>
> @@ -80,29 +73,15 @@
>
> /// preparation of slice encoding (reference marking, QP and lambda)
> TComSlice *initEncSlice(TComPic* pcPic, x265::FrameEncoder
> *pcEncodeFrame, Bool bForceISlice, Int pocLast, Int pocCurr, Int iGOPid,
> TComSPS* pSPS, TComPPS *pPPS);
> -
> Void resetQP(TComPic* pic, x265::FrameEncoder *pcEncodeFrame, Int
> sliceQP, Double lambda);
>
> // compress and encode slice
> Void compressSlice(TComPic* pcPic, x265::FrameEncoder*
> pcEncodeFrame); ///< analysis stage of slice
> -
> Void encodeSlice(TComPic* rpcPic, TComOutputBitstream*
> pcSubstreams, x265::FrameEncoder* pcEncodeFrame);
>
> // misc. functions
> Void setSearchRange(TComSlice* pcSlice, x265::FrameEncoder
> *pcEncodeframe); ///< set ME range adaptively
> -
> Void xDetermineStartAndBoundingCUAddr(TComPic* rpcPic, Bool
> bEncodeSlice);
> -
> - UInt getSliceIdx() { return m_uiSliceIdx; }
> -
> - Void setSliceIdx(UInt i) { m_uiSliceIdx = i; }
> -
> - Void initCtxMem(UInt i);
> - Void setCtxMem(TEncSbac* sb, Int b) { CTXMem[b] = sb; }
> -
> -private:
> -
> - Double xGetQPValueAccordingToLambda(Double lambda);
> };
>
> //! \}
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> http://mailman.videolan.org/listinfo/x265-devel
>
--
Steve Borho
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20130711/04609c0e/attachment-0001.html>
More information about the x265-devel
mailing list