[x265] [PATCH] LookaheadTLD: frameVariance is not used
Ashok Kumar Mishra
ashok at multicorewareinc.com
Fri Dec 1 16:05:48 CET 2017
Please ignore this patch.
On Fri, Dec 1, 2017 at 8:34 PM, <ashok at multicorewareinc.com> wrote:
> # HG changeset patch
> # User Ashok Kumar Mishra <ashok at multicorewareinc.com>
> # Date 1510144762 -19800
> # Wed Nov 08 18:09:22 2017 +0530
> # Node ID 5bf57563452b17c48486ab73f3fcfa4ce4d639ba
> # Parent b1dfa312234ed72c3541831a15f307feaf79484d
> LookaheadTLD: frameVariance is not used
>
> diff -r b1dfa312234e -r 5bf57563452b source/common/frame.cpp
> --- a/source/common/frame.cpp Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/common/frame.cpp Wed Nov 08 18:09:22 2017 +0530
> @@ -84,21 +84,16 @@
> m_analysisData.interData = NULL;
> m_analysis2Pass.analysisFramedata = NULL;
> }
> -
> - if (m_fencPic->create(param, !!m_param->bCopyPicToFrame) &&
> m_lowres.create(m_fencPic, param->bframes, !!param->rc.aqMode ||
> !!param->bAQMotion, param->rc.qgSize))
> + if (m_fencPic->create(param, !!m_param->bCopyPicToFrame) &&
> m_lowres.create(param, m_fencPic, param->rc.qgSize))
> {
> X265_CHECK((m_reconColCount == NULL), "m_reconColCount was
> initialized");
> m_numRows = (m_fencPic->m_picHeight + param->maxCUSize - 1) /
> param->maxCUSize;
> m_reconRowFlag = new ThreadSafeInteger[m_numRows];
> m_reconColCount = new ThreadSafeInteger[m_numRows];
> -
> if (quantOffsets)
> {
> - int32_t cuCount;
> - if (param->rc.qgSize == 8)
> - cuCount = m_lowres.maxBlocksInRowFullRes * m_lowres.
> maxBlocksInColFullRes;
> - else
> - cuCount = m_lowres.maxBlocksInRow *
> m_lowres.maxBlocksInCol;
> + int32_t cuCount = (param->rc.qgSize == 8) ?
> m_lowres.maxBlocksInRowFullRes * m_lowres.maxBlocksInColFullRes :
> +
> m_lowres.maxBlocksInRowLowRes * m_lowres.maxBlocksInColLowRes;
> m_quantOffsets = new float[cuCount];
> }
> return true;
> diff -r b1dfa312234e -r 5bf57563452b source/common/lowres.cpp
> --- a/source/common/lowres.cpp Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/common/lowres.cpp Wed Nov 08 18:09:22 2017 +0530
> @@ -24,50 +24,58 @@
> #include "picyuv.h"
> #include "lowres.h"
> #include "mv.h"
> -
> using namespace X265_NS;
> -
> -bool Lowres::create(PicYuv *origPic, int _bframes, bool bAQEnabled,
> uint32_t qgSize)
> +void TEncPicQPAdaptationLayer::create(int iWidth, int iHeight, uint32_t
> uiAQPartWidth, uint32_t uiAQPartHeight)
> +{
> + m_AQPartWidth = uiAQPartWidth;
> + m_AQPartHeight = uiAQPartHeight;
> + m_NumAQPartInWidth = (iWidth + m_AQPartWidth - 1) / m_AQPartWidth;
> + m_NumAQPartInHeight = (iHeight + m_AQPartHeight - 1) /
> m_AQPartHeight;
> + m_dActivity = new double[m_NumAQPartInWidth * m_NumAQPartInHeight];
> +}
> +bool Lowres::create(x265_param* param, PicYuv *origPic, uint32_t qgSize)
> {
> isLowres = true;
> - bframes = _bframes;
> + bframes = param->bframes;
> width = origPic->m_picWidth / 2;
> lines = origPic->m_picHeight / 2;
> lumaStride = width + 2 * origPic->m_lumaMarginX;
> if (lumaStride & 31)
> lumaStride += 32 - (lumaStride & 31);
> - maxBlocksInRow = (width + X265_LOWRES_CU_SIZE - 1) >>
> X265_LOWRES_CU_BITS;
> - maxBlocksInCol = (lines + X265_LOWRES_CU_SIZE - 1) >>
> X265_LOWRES_CU_BITS;
> - maxBlocksInRowFullRes = maxBlocksInRow * 2;
> - maxBlocksInColFullRes = maxBlocksInCol * 2;
> - int cuCount = maxBlocksInRow * maxBlocksInCol;
> - int cuCountFullRes;
> - if (qgSize == 8)
> - cuCountFullRes = maxBlocksInRowFullRes * maxBlocksInColFullRes;
> - else
> - cuCountFullRes = cuCount;
> -
> + maxBlocksInRowLowRes = (width + X265_LOWRES_CU_SIZE - 1) >>
> X265_LOWRES_CU_BITS;
> + maxBlocksInColLowRes = (lines + X265_LOWRES_CU_SIZE - 1) >>
> X265_LOWRES_CU_BITS;
> + maxBlocksInRowFullRes = maxBlocksInRowLowRes * 2;
> + maxBlocksInColFullRes = maxBlocksInColLowRes * 2;
> + int cuCountLowRes = maxBlocksInRowLowRes * maxBlocksInColLowRes;
> + int cuCountFullRes = (qgSize > 8) ? maxBlocksInRowLowRes *
> maxBlocksInColLowRes :
> + maxBlocksInRowFullRes *
> maxBlocksInColFullRes;
> /* rounding the width to multiple of lowres CU size */
> - width = maxBlocksInRow * X265_LOWRES_CU_SIZE;
> - lines = maxBlocksInCol * X265_LOWRES_CU_SIZE;
> -
> + width = maxBlocksInRowLowRes * X265_LOWRES_CU_SIZE;
> + lines = maxBlocksInColLowRes * X265_LOWRES_CU_SIZE;
> size_t planesize = lumaStride * (lines + 2 * origPic->m_lumaMarginY);
> size_t padoffset = lumaStride * origPic->m_lumaMarginY +
> origPic->m_lumaMarginX;
> - if (bAQEnabled)
> + if (!!param->rc.aqMode || !!param->bAQMotion)
> {
> CHECKED_MALLOC_ZERO(qpAqOffset, double, cuCountFullRes);
> CHECKED_MALLOC_ZERO(qpAqMotionOffset, double, cuCountFullRes);
> CHECKED_MALLOC_ZERO(invQscaleFactor, int, cuCountFullRes);
> CHECKED_MALLOC_ZERO(qpCuTreeOffset, double, cuCountFullRes);
> - CHECKED_MALLOC_ZERO(blockVariance, uint32_t, cuCountFullRes);
> if (qgSize == 8)
> - CHECKED_MALLOC_ZERO(invQscaleFactor8x8, int, cuCount);
> + CHECKED_MALLOC_ZERO(invQscaleFactor8x8, int,
> cuCountLowRes);
> }
> - CHECKED_MALLOC(propagateCost, uint16_t, cuCount);
> -
> + CHECKED_MALLOC(propagateCost, uint16_t, cuCountLowRes);
> /* allocate lowres buffers */
> CHECKED_MALLOC_ZERO(buffer[0], pixel, 4 * planesize);
> + m_MaxAQDepth = g_log2Size[param->maxCUSize] - g_log2Size[qgSize] +
> 1;
>
> + if (m_MaxAQDepth > 0)
> + {
> + m_acAQLayer = new TEncPicQPAdaptationLayer[m_MaxAQDepth];
> + for (uint32_t d = 0; d < m_MaxAQDepth; d++)
> + {
> + m_acAQLayer[d].create(origPic->m_picWidth,
> origPic->m_picHeight, param->maxCUSize >> d, param->maxCUSize >> d);
> + }
> + }
> buffer[1] = buffer[0] + planesize;
> buffer[2] = buffer[1] + planesize;
> buffer[3] = buffer[2] + planesize;
> @@ -76,29 +84,24 @@
> lowresPlane[1] = buffer[1] + padoffset;
> lowresPlane[2] = buffer[2] + padoffset;
> lowresPlane[3] = buffer[3] + padoffset;
> -
> - CHECKED_MALLOC(intraCost, int32_t, cuCount);
> - CHECKED_MALLOC(intraMode, uint8_t, cuCount);
> -
> + CHECKED_MALLOC(intraCost, int32_t, cuCountLowRes);
> + CHECKED_MALLOC(intraMode, uint8_t, cuCountLowRes);
> for (int i = 0; i < bframes + 2; i++)
> {
> for (int j = 0; j < bframes + 2; j++)
> {
> - CHECKED_MALLOC(rowSatds[i][j], int32_t, maxBlocksInCol);
> - CHECKED_MALLOC(lowresCosts[i][j], uint16_t, cuCount);
> + CHECKED_MALLOC(rowSatds[i][j], int32_t,
> maxBlocksInColLowRes);
> + CHECKED_MALLOC(lowresCosts[i][j], uint16_t,
> cuCountLowRes);
> }
> }
> -
> for (int i = 0; i < bframes + 1; i++)
> {
> - CHECKED_MALLOC(lowresMvs[0][i], MV, cuCount);
> - CHECKED_MALLOC(lowresMvs[1][i], MV, cuCount);
> - CHECKED_MALLOC(lowresMvCosts[0][i], int32_t, cuCount);
> - CHECKED_MALLOC(lowresMvCosts[1][i], int32_t, cuCount);
> + CHECKED_MALLOC(lowresMvs[0][i], MV, cuCountLowRes);
> + CHECKED_MALLOC(lowresMvs[1][i], MV, cuCountLowRes);
> + CHECKED_MALLOC(lowresMvCosts[0][i], int32_t,
> cuCountLowRes);
> + CHECKED_MALLOC(lowresMvCosts[1][i], int32_t,
> cuCountLowRes);
> }
> -
> return true;
> -
> fail:
> return false;
> }
> @@ -130,10 +133,8 @@
> X265_FREE(invQscaleFactor);
> X265_FREE(qpCuTreeOffset);
> X265_FREE(propagateCost);
> - X265_FREE(blockVariance);
> X265_FREE(invQscaleFactor8x8);
> }
> -
> // (re) initialize lowres state
> void Lowres::init(PicYuv *origPic, int poc)
> {
> diff -r b1dfa312234e -r 5bf57563452b source/common/lowres.h
> --- a/source/common/lowres.h Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/common/lowres.h Wed Nov 08 18:09:22 2017 +0530
> @@ -102,7 +102,18 @@
> }
> }
> };
> +struct TEncPicQPAdaptationLayer
> +{
> + uint32_t m_AQPartWidth;
> + uint32_t m_AQPartHeight;
> + uint32_t m_NumAQPartInWidth;
> + uint32_t m_NumAQPartInHeight;
> + double* m_dActivity;
> + double m_dAvgActivity;
>
> + void create(int width, int height, uint32_t AQPartWidth, uint32_t
> AQPartHeight);
> + void destroy();
> +};
> /* lowres buffers, sizes and strides */
> struct Lowres : public ReferencePlanes
> {
> @@ -132,34 +143,30 @@
> uint16_t* lowresCosts[X265_BFRAME_MAX + 2][X265_BFRAME_MAX + 2];
> int32_t* lowresMvCosts[2][X265_BFRAME_MAX + 1];
> MV* lowresMvs[2][X265_BFRAME_MAX + 1];
> - uint32_t maxBlocksInRow;
> - uint32_t maxBlocksInCol;
> + uint32_t maxBlocksInRowLowRes;
> + uint32_t maxBlocksInColLowRes;
> uint32_t maxBlocksInRowFullRes;
> uint32_t maxBlocksInColFullRes;
> -
> /* used for vbvLookahead */
> int plannedType[X265_LOOKAHEAD_MAX + 1];
> int64_t plannedSatd[X265_LOOKAHEAD_MAX + 1];
> int indB;
> int bframes;
> -
> /* rate control / adaptive quant data */
> - double* qpAqOffset; // AQ QP offset values for each 16x16 CU
> - double* qpCuTreeOffset; // cuTree QP offset values for each 16x16
> CU
> + double* qpAqOffset; // AQ QP offset values for each 16x16 CU
> + double* qpCuTreeOffset; // cuTree QP offset values for each
> 16x16 CU
> double* qpAqMotionOffset;
> - int* invQscaleFactor; // qScale values for qp Aq Offsets
> + int* invQscaleFactor; // qScale values for qp Aq Offsets
> int* invQscaleFactor8x8; // temporary buffer for qg-size 8
> - uint32_t* blockVariance;
> - uint64_t wp_ssd[3]; // This is different than SSDY, this is
> sum(pixel^2) - sum(pixel)^2 for entire frame
> + uint64_t wp_ssd[3]; // This is different than SSDY, this is
> sum(pixel^2) - sum(pixel)^2 for entire frame
> uint64_t wp_sum[3];
> - uint64_t frameVariance;
> -
> + TEncPicQPAdaptationLayer* m_acAQLayer;
> + uint32_t m_MaxAQDepth;
> /* cutree intermediate data */
> uint16_t* propagateCost;
> double weightedCostDelta[X265_BFRAME_MAX + 2];
> ReferencePlanes weightedRef[X265_BFRAME_MAX + 2];
> -
> - bool create(PicYuv *origPic, int _bframes, bool bAqEnabled, uint32_t
> qgSize);
> + bool create(x265_param* param, PicYuv *origPic, uint32_t qgSize);
> void destroy();
> void init(PicYuv *origPic, int poc);
> };
> diff -r b1dfa312234e -r 5bf57563452b source/encoder/encoder.cpp
> --- a/source/encoder/encoder.cpp Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/encoder/encoder.cpp Wed Nov 08 18:09:22 2017 +0530
> @@ -1009,10 +1009,9 @@
> if (m_param->rc.qgSize == 8)
> cuCount = inFrame->m_lowres.maxBlocksInRowFullRes *
> inFrame->m_lowres.maxBlocksInColFullRes;
> else
> - cuCount = inFrame->m_lowres.maxBlocksInRow *
> inFrame->m_lowres.maxBlocksInCol;
> + cuCount = inFrame->m_lowres.maxBlocksInRowLowRes
> * inFrame->m_lowres.maxBlocksInColLowRes;
> memcpy(inFrame->m_quantOffsets, pic_in->quantOffsets,
> cuCount * sizeof(float));
> }
> -
> if (m_pocLast == 0)
> m_firstPts = inFrame->m_pts;
> if (m_bframeDelay && m_pocLast == m_bframeDelay)
> diff -r b1dfa312234e -r 5bf57563452b source/encoder/sao.cpp
> --- a/source/encoder/sao.cpp Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/encoder/sao.cpp Wed Nov 08 18:09:22 2017 +0530
> @@ -136,12 +136,9 @@
>
> CHECKED_MALLOC(m_clipTableBase, pixel, maxY + 2 * rangeExt);
> m_clipTable = &(m_clipTableBase[rangeExt]);
> -
> // Share with fast clip lookup table
> -
> for (int i = 0; i < rangeExt; i++)
> m_clipTableBase[i] = 0;
> -
> for (int i = 0; i < maxY; i++)
> m_clipTable[i] = (pixel)i;
>
> diff -r b1dfa312234e -r 5bf57563452b source/encoder/search.cpp
> --- a/source/encoder/search.cpp Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/encoder/search.cpp Wed Nov 08 18:09:22 2017 +0530
> @@ -1951,17 +1951,14 @@
> if (mvs[0].x == 0x7FFF)
> /* this motion search was not estimated by lookahead */
> return 0;
> -
> uint32_t block_x = (cu.m_cuPelX + g_zscanToPelX[pu.puAbsPartIdx] +
> pu.width / 2) >> 4;
> uint32_t block_y = (cu.m_cuPelY + g_zscanToPelY[pu.puAbsPartIdx] +
> pu.height / 2) >> 4;
> - uint32_t idx = block_y * m_frame->m_lowres.maxBlocksInRow + block_x;
> -
> - X265_CHECK(block_x < m_frame->m_lowres.maxBlocksInRow, "block_x is
> too high\n");
> - X265_CHECK(block_y < m_frame->m_lowres.maxBlocksInCol, "block_y is
> too high\n");
> -
> + uint32_t idx = block_y * m_frame->m_lowres.maxBlocksInRowLowRes +
> block_x;
> +
> + X265_CHECK(block_x < m_frame->m_lowres.maxBlocksInRowLowRes,
> "block_x is too high\n");
> + X265_CHECK(block_y < m_frame->m_lowres.maxBlocksInColLowRes,
> "block_y is too high\n");
> return mvs[idx] << 1; /* scale up lowres mv */
> }
> -
> /* Pick between the two AMVP candidates which is the best one to use as
> * MVP for the motion search, based on SAD cost */
> int Search::selectMVP(const CUData& cu, const PredictionUnit& pu, const
> MV amvp[AMVP_NUM_CANDS], int list, int ref)
> diff -r b1dfa312234e -r 5bf57563452b source/encoder/slicetype.cpp
> --- a/source/encoder/slicetype.cpp Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/encoder/slicetype.cpp Wed Nov 08 18:09:22 2017 +0530
> @@ -120,7 +120,93 @@
> x265_emms();
> return (uint32_t)sum_ssd;
> }
> +void LookaheadTLD::xPreanalyze(Frame* curFrame)
> +{
> + const uint32_t iWidth = curFrame->m_fencPic->m_picWidth;
> + const uint32_t iHeight = curFrame->m_fencPic->m_picHeight;
> + const intptr_t iStride = curFrame->m_fencPic->m_stride;
>
> + for (uint32_t d = 0; d < curFrame->m_lowres.m_MaxAQDepth; d++)
> + {
> + const pixel* src = curFrame->m_fencPic->m_picOrg[0];;
> + TEncPicQPAdaptationLayer pcAQLayer = curFrame->m_lowres.m_
> acAQLayer[d];
> + const uint32_t uiAQPartWidth = pcAQLayer.m_AQPartWidth;
> + const uint32_t uiAQPartHeight = pcAQLayer.m_AQPartHeight;
> + double* pcAQU = pcAQLayer.m_dActivity;
> +
> + double dSumAct = 0.0;
> + for (uint32_t y = 0; y < iHeight; y += uiAQPartHeight)
> + {
> + const uint32_t uiCurrAQPartHeight =
> min(uiAQPartHeight, iHeight - y);
> + for (uint32_t x = 0; x < iWidth; x +=
> uiAQPartWidth, pcAQU++)
> + {
> + const uint32_t uiCurrAQPartWidth =
> min(uiAQPartWidth, iWidth - x);
> + const pixel* pBlkY = &src[x];
> + uint64_t uiSum[4] = { 0, 0, 0, 0 };
> + uint64_t uiSumSq[4] = { 0, 0, 0, 0 };
> + uint32_t by = 0;
> + for (; by < uiCurrAQPartHeight >> 1; by++)
> + {
> + uint32_t bx = 0;
> + for (; bx < uiCurrAQPartWidth >>
> 1; bx++)
> + {
> + uiSum[0] += pBlkY[bx];
> + uiSumSq[0] += pBlkY[bx] *
> pBlkY[bx];
> + }
> + for (; bx < uiCurrAQPartWidth;
> bx++)
> + {
> + uiSum[1] += pBlkY[bx];
> + uiSumSq[1] += pBlkY[bx] *
> pBlkY[bx];
> + }
> + pBlkY += iStride;
> + }
> + for (; by < uiCurrAQPartHeight; by++)
> + {
> + uint32_t bx = 0;
> + for (; bx < uiCurrAQPartWidth >>
> 1; bx++)
> + {
> + uiSum[2] += pBlkY[bx];
> + uiSumSq[2] += pBlkY[bx] *
> pBlkY[bx];
> + }
> + for (; bx < uiCurrAQPartWidth;
> bx++)
> + {
> + uiSum[3] += pBlkY[bx];
> + uiSumSq[3] += pBlkY[bx] *
> pBlkY[bx];
> + }
> + pBlkY += iStride;
> + }
> +
> + assert((uiCurrAQPartWidth & 1) == 0);
> + assert((uiCurrAQPartHeight & 1) == 0);
> + const uint32_t pixelWidthOfQuadrants =
> uiCurrAQPartWidth >> 1;
> + const uint32_t pixelHeightOfQuadrants =
> uiCurrAQPartHeight >> 1;
> + const uint32_t numPixInAQPart =
> pixelWidthOfQuadrants * pixelHeightOfQuadrants;
> +
> + double dMinVar = DBL_MAX;
> + if (numPixInAQPart != 0)
> + {
> + for (int i = 0; i < 4; i++)
> + {
> + const double dAverage =
> double(uiSum[i]) / numPixInAQPart;
> + const double dVariance =
> double(uiSumSq[i]) / numPixInAQPart - dAverage * dAverage;
> + dMinVar = min(dMinVar,
> dVariance);
> + }
> + }
> + else
> + {
> + dMinVar = 0.0;
> + }
> + double dActivity = 1.0 + dMinVar;
> + *pcAQU = dActivity;
> + dSumAct += dActivity;
> + }
> + src += iStride * uiCurrAQPartHeight;
> + }
> +
> + const double dAvgAct = dSumAct /
> (pcAQLayer.m_NumAQPartInWidth * pcAQLayer.m_NumAQPartInHeight);
> + pcAQLayer.m_dAvgActivity = dAvgAct;
> + }
> +}
> void LookaheadTLD::calcAdaptiveQuantFrame(Frame *curFrame, x265_param*
> param)
> {
> /* Actual adaptive quantization */
> @@ -156,14 +242,13 @@
> double strength = 0.f;
> if (param->rc.aqMode == X265_AQ_NONE || param->rc.aqStrength == 0)
> {
> - /* Need to init it anyways for CU tree */
> - int cuCount = blockCount;
> -
> +// /* Need to init it anyways for CU tree */
> +// int cuCount = blockCount;
> if (param->rc.aqMode && param->rc.aqStrength == 0)
> {
> if (quantOffsets)
> {
> - for (int cuxy = 0; cuxy < cuCount; cuxy++)
> + for (int cuxy = 0; cuxy < blockCount;
> cuxy++)
> {
> curFrame->m_lowres.qpCuTreeOffset[cuxy] =
> curFrame->m_lowres.qpAqOffset[cuxy] = quantOffsets[cuxy];
> curFrame->m_lowres.invQscaleFactor[cuxy] =
> x265_exp2fix8(curFrame->m_lowres.qpCuTreeOffset[cuxy]);
> @@ -171,9 +256,9 @@
> }
> else
> {
> - memset(curFrame->m_lowres.qpCuTreeOffset, 0, cuCount *
> sizeof(double));
> - memset(curFrame->m_lowres.qpAqOffset, 0, cuCount *
> sizeof(double));
> - for (int cuxy = 0; cuxy < cuCount; cuxy++)
> + memset(curFrame->m_lowres.qpCuTreeOffset,
> 0, blockCount * sizeof(double));
> + memset(curFrame->m_lowres.qpAqOffset, 0,
> blockCount * sizeof(double));
> + for (int cuxy = 0; cuxy < blockCount;
> cuxy++)
> curFrame->m_lowres.invQscaleFactor[cuxy] = 256;
> }
> }
> @@ -188,35 +273,34 @@
> }
> else
> {
> + if (param->rc.aqMode == X265_AQ_AUTO_VARIANCE ||
> param->rc.aqMode == X265_AQ_AUTO_VARIANCE_BIASED)
> + {
> + xPreanalyze(curFrame);
> + }
> +
> blockXY = 0;
> double avg_adj_pow2 = 0, avg_adj = 0, qp_adj = 0;
> double bias_strength = 0.f;
> if (param->rc.aqMode == X265_AQ_AUTO_VARIANCE || param->rc.aqMode
> == X265_AQ_AUTO_VARIANCE_BIASED)
> {
> double bit_depth_correction = 1.f / (1 << (2*(X265_DEPTH-8)));
> - curFrame->m_lowres.frameVariance = 0;
> - uint64_t rowVariance = 0;
> +
> for (blockY = 0; blockY < maxRow; blockY += loopIncr)
> {
> - rowVariance = 0;
> for (blockX = 0; blockX < maxCol; blockX += loopIncr)
> {
> uint32_t energy = acEnergyCu(curFrame, blockX,
> blockY, param->internalCsp, param->rc.qgSize);
> - curFrame->m_lowres.blockVariance[blockXY] = energy;
> - rowVariance += energy;
> qp_adj = pow(energy * bit_depth_correction + 1, 0.1);
> curFrame->m_lowres.qpCuTreeOffset[blockXY] = qp_adj;
> avg_adj += qp_adj;
> avg_adj_pow2 += qp_adj * qp_adj;
> blockXY++;
> }
> - curFrame->m_lowres.frameVariance += (rowVariance /
> maxCol);
> }
> - curFrame->m_lowres.frameVariance /= maxRow;
> avg_adj /= blockCount;
> avg_adj_pow2 /= blockCount;
> strength = param->rc.aqStrength * avg_adj;
> - avg_adj = avg_adj - 0.5f * (avg_adj_pow2 - (modeTwoConst)) /
> avg_adj;
> + avg_adj = avg_adj - 0.5f * (avg_adj_pow2 - modeTwoConst) /
> avg_adj;
> bias_strength = param->rc.aqStrength;
> }
> else
> diff -r b1dfa312234e -r 5bf57563452b source/encoder/slicetype.h
> --- a/source/encoder/slicetype.h Thu Nov 30 10:06:49 2017 +0530
> +++ b/source/encoder/slicetype.h Wed Nov 08 18:09:22 2017 +0530
> @@ -82,14 +82,11 @@
> }
>
> ~LookaheadTLD() { X265_FREE(wbuffer[0]); }
> -
> void calcAdaptiveQuantFrame(Frame *curFrame, x265_param* param);
> void lowresIntraEstimate(Lowres& fenc, uint32_t qgSize);
> -
> void weightsAnalyse(Lowres& fenc, Lowres& ref);
> -
> + void xPreanalyze(Frame* curFrame);
> protected:
> -
> uint32_t acEnergyCu(Frame* curFrame, uint32_t blockX, uint32_t
> blockY, int csp, uint32_t qgSize);
> uint32_t lumaSumCu(Frame* curFrame, uint32_t blockX, uint32_t blockY,
> uint32_t qgSize);
> uint32_t weightCostLuma(Lowres& fenc, Lowres& ref, WeightParam& wp);
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20171201/4762b2d3/attachment-0001.html>
More information about the x265-devel
mailing list