[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