[x265] [PATCH] analysis: cleanup intra analysis functions

Deepthi Nandakumar deepthi at multicorewareinc.com
Fri Oct 9 12:30:11 CEST 2015


Thanks, looks really good, a couple of comments below.

On Thu, Oct 8, 2015 at 6:24 PM, <kavitha at multicorewareinc.com> wrote:

> # HG changeset patch
> # User Kavitha Sampath <kavitha at multicorewareinc.com>
> # Date 1444301894 -19800
> #      Thu Oct 08 16:28:14 2015 +0530
> # Node ID bd8087bfd93f7564df436a27c22f7e44f6803c4a
> # Parent  55a4a9b920ff0385fd0b65c73c4c3f63b8a8cc65
> analysis: cleanup intra analysis functions
>
> During the analysis-load mode, the predicted luma and chroma modes saved in
> shared buffers are no longer passed explicitly to intra analysis functions.
> Instead the predicted modes are copied to parentCTU, thereby enabling the
> intra
> analysis functions to decide implicitly if modes should be reused.
>
> diff -r 55a4a9b920ff -r bd8087bfd93f source/common/cudata.cpp
> --- a/source/common/cudata.cpp  Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/common/cudata.cpp  Thu Oct 08 16:28:14 2015 +0530
> @@ -199,6 +199,7 @@
>      m_qp        = (int8_t*)charBuf; charBuf += m_numPartitions;
>      m_log2CUSize         = charBuf; charBuf += m_numPartitions;
>      m_lumaIntraDir       = charBuf; charBuf += m_numPartitions;
> +    m_chromaIntraDir     = charBuf; charBuf += m_numPartitions;
>      m_tqBypass           = charBuf; charBuf += m_numPartitions;
>      m_refIdx[0] = (int8_t*)charBuf; charBuf += m_numPartitions;
>      m_refIdx[1] = (int8_t*)charBuf; charBuf += m_numPartitions;
> @@ -216,7 +217,6 @@
>      m_cbf[0]             = charBuf; charBuf += m_numPartitions;
>      m_cbf[1]             = charBuf; charBuf += m_numPartitions;
>      m_cbf[2]             = charBuf; charBuf += m_numPartitions;
> -    m_chromaIntraDir     = charBuf; charBuf += m_numPartitions;
>
>      X265_CHECK(charBuf == dataPool.charMemBlock + (m_numPartitions *
> BytesPerPartition) * (instance + 1), "CU data layout is broken\n");
>
> @@ -246,7 +246,8 @@
>      /* sequential memsets */
>      m_partSet((uint8_t*)m_qp, (uint8_t)qp);
>      m_partSet(m_log2CUSize,   (uint8_t)g_maxLog2CUSize);
> -    m_partSet(m_lumaIntraDir, (uint8_t)DC_IDX);
> +    m_partSet(m_lumaIntraDir, (uint8_t)ALL_IDX);
> +    m_partSet(m_chromaIntraDir, (uint8_t)ALL_IDX);
>      m_partSet(m_tqBypass,
>  (uint8_t)frame.m_encData->m_param->bLossless);
>      if (m_slice->m_sliceType != I_SLICE)
>      {
> @@ -257,7 +258,7 @@
>      X265_CHECK(!(frame.m_encData->m_param->bLossless &&
> !m_slice->m_pps->bTransquantBypassEnabled), "lossless enabled without
> TQbypass in PPS\n");
>
>      /* initialize the remaining CU data in one memset */
> -    memset(m_cuDepth, 0, (BytesPerPartition - 6) * m_numPartitions);
> +    memset(m_cuDepth, 0, (BytesPerPartition - 7) * m_numPartitions);
>
>      uint32_t widthInCU = m_slice->m_sps->numCuInWidth;
>      m_cuLeft = (m_cuAddr % widthInCU) ? m_encData->getPicCTU(m_cuAddr -
> 1) : NULL;
> @@ -284,14 +285,15 @@
>      m_partSet((uint8_t*)m_qp, (uint8_t)qp);
>
>      m_partSet(m_log2CUSize,   (uint8_t)cuGeom.log2CUSize);
> -    m_partSet(m_lumaIntraDir, (uint8_t)DC_IDX);
>      m_partSet(m_tqBypass,     (uint8_t)m_encData->m_param->bLossless);
>      m_partSet((uint8_t*)m_refIdx[0], (uint8_t)REF_NOT_VALID);
>      m_partSet((uint8_t*)m_refIdx[1], (uint8_t)REF_NOT_VALID);
>      m_partSet(m_cuDepth,      (uint8_t)cuGeom.depth);
> +    memcpy(m_lumaIntraDir, ctu.m_lumaIntraDir + cuGeom.absPartIdx,
> cuGeom.numPartitions);
> +    memcpy(m_chromaIntraDir, ctu.m_chromaIntraDir + cuGeom.absPartIdx,
> cuGeom.numPartitions);
>
>      /* initialize the remaining CU data in one memset */
> -    memset(m_predMode, 0, (BytesPerPartition - 7) * m_numPartitions);
> +    memset(m_predMode, 0, (BytesPerPartition - 8) * m_numPartitions);
>  }
>
>  /* Copy the results of a sub-part (split) CU to the parent CU */
> diff -r 55a4a9b920ff -r bd8087bfd93f source/common/cudata.h
> --- a/source/common/cudata.h    Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/common/cudata.h    Thu Oct 08 16:28:14 2015 +0530
> @@ -287,6 +287,12 @@
>      const CUData* getPUAboveRightAdi(uint32_t& arPartUnitIdx, uint32_t
> curPartUnitIdx, uint32_t partUnitOffset) const;
>      const CUData* getPUBelowLeftAdi(uint32_t& blPartUnitIdx, uint32_t
> curPartUnitIdx, uint32_t partUnitOffset) const;
>
> +    inline void resetIntraModes(bool resetLuma, bool resetChroma)
> +    {
> +        if (resetLuma) m_partSet(m_lumaIntraDir, (uint8_t)ALL_IDX);
> +        if (resetChroma) m_partSet(m_chromaIntraDir, (uint8_t)ALL_IDX);
> +    }
> +
>  protected:
>
>      template<typename T>
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/analysis.cpp
> --- a/source/encoder/analysis.cpp       Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/analysis.cpp       Thu Oct 08 16:28:14 2015 +0530
> @@ -72,7 +72,6 @@
>
>  Analysis::Analysis()
>  {
> -    m_reuseIntraDataCTU = NULL;
>      m_reuseInterDataCTU = NULL;
>      m_reuseRef = NULL;
>      m_reuseBestMergeCand = NULL;
> @@ -141,17 +140,12 @@
>      m_modeDepth[0].fencYuv.copyFromPicYuv(*m_frame->m_fencPic,
> ctu.m_cuAddr, 0);
>
>      uint32_t numPartition = ctu.m_numPartitions;
> -    if (m_param->analysisMode)
> +    if (m_param->analysisMode && m_slice->m_sliceType != I_SLICE)
>      {
> -        if (m_slice->m_sliceType == I_SLICE)
> -            m_reuseIntraDataCTU =
> (analysis_intra_data*)m_frame->m_analysisData.intraData;
> -        else
> -        {
> -            int numPredDir = m_slice->isInterP() ? 1 : 2;
> -            m_reuseInterDataCTU =
> (analysis_inter_data*)m_frame->m_analysisData.interData;
> -            m_reuseRef = &m_reuseInterDataCTU->ref[ctu.m_cuAddr *
> X265_MAX_PRED_MODE_PER_CTU * numPredDir];
> -            m_reuseBestMergeCand =
> &m_reuseInterDataCTU->bestMergeCand[ctu.m_cuAddr * CUGeom::MAX_GEOMS];
> -        }
> +        int numPredDir = m_slice->isInterP() ? 1 : 2;
> +        m_reuseInterDataCTU =
> (analysis_inter_data*)m_frame->m_analysisData.interData;
> +        m_reuseRef = &m_reuseInterDataCTU->ref[ctu.m_cuAddr *
> X265_MAX_PRED_MODE_PER_CTU * numPredDir];
> +        m_reuseBestMergeCand =
> &m_reuseInterDataCTU->bestMergeCand[ctu.m_cuAddr * CUGeom::MAX_GEOMS];
>      }
>
>      ProfileCUScope(ctu, totalCTUTime, totalCTUs);
> @@ -159,14 +153,22 @@
>      uint32_t zOrder = 0;
>      if (m_slice->m_sliceType == I_SLICE)
>      {
> +        analysis_intra_data* intraDataCTU =
> (analysis_intra_data*)m_frame->m_analysisData.intraData;
> +        if (m_param->analysisMode == X265_ANALYSIS_LOAD)
> +        {
> +            memcpy(ctu.m_cuDepth, &intraDataCTU->depth[ctu.m_cuAddr *
> numPartition], sizeof(uint8_t) * numPartition);
> +            memcpy(ctu.m_lumaIntraDir, &intraDataCTU->modes[ctu.m_cuAddr
> * numPartition], sizeof(uint8_t) * numPartition);
> +            memcpy(ctu.m_partSize, &intraDataCTU->partSizes[ctu.m_cuAddr
> * numPartition], sizeof(char) * numPartition);
> +            memcpy(ctu.m_chromaIntraDir,
> &intraDataCTU->chromaModes[ctu.m_cuAddr * numPartition], sizeof(uint8_t) *
> numPartition);
> +        }
>          compressIntraCU(ctu, cuGeom, zOrder, qp);
> -        if (m_param->analysisMode == X265_ANALYSIS_SAVE &&
> m_frame->m_analysisData.intraData)
> +        if (m_param->analysisMode == X265_ANALYSIS_SAVE && intraDataCTU)
>          {
>              CUData* bestCU = &m_modeDepth[0].bestMode->cu;
> -            memcpy(&m_reuseIntraDataCTU->depth[ctu.m_cuAddr *
> numPartition], bestCU->m_cuDepth, sizeof(uint8_t) * numPartition);
> -            memcpy(&m_reuseIntraDataCTU->modes[ctu.m_cuAddr *
> numPartition], bestCU->m_lumaIntraDir, sizeof(uint8_t) * numPartition);
> -            memcpy(&m_reuseIntraDataCTU->partSizes[ctu.m_cuAddr *
> numPartition], bestCU->m_partSize, sizeof(uint8_t) * numPartition);
> -            memcpy(&m_reuseIntraDataCTU->chromaModes[ctu.m_cuAddr *
> numPartition], bestCU->m_chromaIntraDir, sizeof(uint8_t) * numPartition);
> +            memcpy(&intraDataCTU->depth[ctu.m_cuAddr * numPartition],
> bestCU->m_cuDepth, sizeof(uint8_t) * numPartition);
> +            memcpy(&intraDataCTU->modes[ctu.m_cuAddr * numPartition],
> bestCU->m_lumaIntraDir, sizeof(uint8_t) * numPartition);
> +            memcpy(&intraDataCTU->partSizes[ctu.m_cuAddr * numPartition],
> bestCU->m_partSize, sizeof(uint8_t) * numPartition);
> +            memcpy(&intraDataCTU->chromaModes[ctu.m_cuAddr *
> numPartition], bestCU->m_chromaIntraDir, sizeof(uint8_t) * numPartition);
>          }
>      }
>      else
> @@ -213,8 +215,7 @@
>          md.pred[PRED_LOSSLESS].initCosts();
>          md.pred[PRED_LOSSLESS].cu.initLosslessCU(md.bestMode->cu, cuGeom);
>          PartSize size = (PartSize)md.pred[PRED_LOSSLESS].cu.m_partSize[0];
> -        uint8_t* modes = md.pred[PRED_LOSSLESS].cu.m_lumaIntraDir;
> -        checkIntra(md.pred[PRED_LOSSLESS], cuGeom, size, modes, NULL);
> +        checkIntra(md.pred[PRED_LOSSLESS], cuGeom, size);
>          checkBestMode(md.pred[PRED_LOSSLESS], cuGeom.depth);
>      }
>      else
> @@ -236,42 +237,37 @@
>      bool mightSplit = !(cuGeom.flags & CUGeom::LEAF);
>      bool mightNotSplit = !(cuGeom.flags & CUGeom::SPLIT_MANDATORY);
>
> -    if (m_param->analysisMode == X265_ANALYSIS_LOAD)
> +    bool bAlreadyDecided = parentCTU.m_lumaIntraDir[cuGeom.absPartIdx] !=
> (uint8_t)ALL_IDX;
> +    bool bDecidedDepth = parentCTU.m_cuDepth[cuGeom.absPartIdx] == depth;
> +
> +    // stop recursion if we reach the depth of previous analysis decision
> +    mightSplit &= !(bAlreadyDecided && bDecidedDepth);
> +
> +    if (bAlreadyDecided)
>      {
> -        uint8_t* reuseDepth  =
> &m_reuseIntraDataCTU->depth[parentCTU.m_cuAddr * parentCTU.m_numPartitions];
> -        uint8_t* reuseModes  =
> &m_reuseIntraDataCTU->modes[parentCTU.m_cuAddr * parentCTU.m_numPartitions];
> -        char* reusePartSizes =
> &m_reuseIntraDataCTU->partSizes[parentCTU.m_cuAddr *
> parentCTU.m_numPartitions];
> -        uint8_t* reuseChromaModes =
> &m_reuseIntraDataCTU->chromaModes[parentCTU.m_cuAddr *
> parentCTU.m_numPartitions];
> -
> -        if (mightNotSplit && depth == reuseDepth[zOrder] && zOrder ==
> cuGeom.absPartIdx)
> +        if (bDecidedDepth)
>          {
> -            PartSize size = (PartSize)reusePartSizes[zOrder];
> -            Mode& mode = size == SIZE_2Nx2N ? md.pred[PRED_INTRA] :
> md.pred[PRED_INTRA_NxN];
> +            Mode& mode = md.pred[0];
>

need to use the correct enum PRED_INTRA above.


> +            md.bestMode = &mode;
>              mode.cu.initSubCU(parentCTU, cuGeom, qp);
> -            checkIntra(mode, cuGeom, size, &reuseModes[zOrder],
> &reuseChromaModes[zOrder]);
> -            checkBestMode(mode, depth);
> -
>

So, instead of copying the dirs in initSubCU and then resetting them
everywhere else,  can't we just copy the dirs into the subCU if
bAlreadyDecided is true right here?

+            checkIntra(mode, cuGeom,
> (PartSize)parentCTU.m_partSize[cuGeom.absPartIdx]);
>              if (m_bTryLossless)
>                  tryLossless(cuGeom);
>
>              if (mightSplit)
>                  addSplitFlagCost(*md.bestMode, cuGeom.depth);
> -
> -            // increment zOrder offset to point to next best depth in
> sharedDepth buffer
> -            zOrder += g_depthInc[g_maxCUDepth - 1][reuseDepth[zOrder]];
> -            mightSplit = false;
>          }
>      }
>      else if (mightNotSplit)
>      {
>          md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom, qp);
> -        checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N, NULL, NULL);
> +        checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N);
>          checkBestMode(md.pred[PRED_INTRA], depth);
>
>          if (cuGeom.log2CUSize == 3 &&
> m_slice->m_sps->quadtreeTULog2MinSize < 3)
>          {
>              md.pred[PRED_INTRA_NxN].cu.initSubCU(parentCTU, cuGeom, qp);
> -            checkIntra(md.pred[PRED_INTRA_NxN], cuGeom, SIZE_NxN, NULL,
> NULL);
> +            checkIntra(md.pred[PRED_INTRA_NxN], cuGeom, SIZE_NxN);
>              checkBestMode(md.pred[PRED_INTRA_NxN], depth);
>          }
>
> @@ -389,6 +385,7 @@
>              switch (pmode.modes[task])
>              {
>              case PRED_INTRA:
> +                md.pred[PRED_INTRA].cu.resetIntraModes(true, true);
>                  slave.checkIntraInInter(md.pred[PRED_INTRA],
> pmode.cuGeom);
>                  if (m_param->rdLevel > 2)
>                      slave.encodeIntraInInter(md.pred[PRED_INTRA],
> pmode.cuGeom);
> @@ -454,9 +451,10 @@
>              switch (pmode.modes[task])
>              {
>              case PRED_INTRA:
> -                slave.checkIntra(md.pred[PRED_INTRA], pmode.cuGeom,
> SIZE_2Nx2N, NULL, NULL);
> +                md.pred[PRED_INTRA].cu.resetIntraModes(true, true);
> +                slave.checkIntra(md.pred[PRED_INTRA], pmode.cuGeom,
> SIZE_2Nx2N);
>                  if (pmode.cuGeom.log2CUSize == 3 &&
> m_slice->m_sps->quadtreeTULog2MinSize < 3)
> -                    slave.checkIntra(md.pred[PRED_INTRA_NxN],
> pmode.cuGeom, SIZE_NxN, NULL, NULL);
> +                    slave.checkIntra(md.pred[PRED_INTRA_NxN],
> pmode.cuGeom, SIZE_NxN);
>                  break;
>
>              case PRED_2Nx2N:
> @@ -720,6 +718,7 @@
>                  if (bTryIntra && md.pred[PRED_INTRA].sa8dCost <
> md.bestMode->sa8dCost)
>                  {
>                      md.bestMode = &md.pred[PRED_INTRA];
> +                    md.bestMode->cu.resetIntraModes(false, true);
>                      encodeIntraInInter(*md.bestMode, cuGeom);
>                  }
>                  else if (!md.bestMode->cu.m_mergeFlag[0])
> @@ -1026,6 +1025,7 @@
>                      {
>                          ProfileCounter(parentCTU,
> totalIntraCU[cuGeom.depth]);
>                          md.pred[PRED_INTRA].cu.initSubCU(parentCTU,
> cuGeom, qp);
> +                        md.pred[PRED_INTRA].cu.resetIntraModes(true,
> true);
>                          checkIntraInInter(md.pred[PRED_INTRA], cuGeom);
>                          encodeIntraInInter(md.pred[PRED_INTRA], cuGeom);
>                          checkBestMode(md.pred[PRED_INTRA], depth);
> @@ -1052,6 +1052,7 @@
>                      {
>                          ProfileCounter(parentCTU,
> totalIntraCU[cuGeom.depth]);
>                          md.pred[PRED_INTRA].cu.initSubCU(parentCTU,
> cuGeom, qp);
> +                        md.pred[PRED_INTRA].cu.resetIntraModes(true,
> false);
>                          checkIntraInInter(md.pred[PRED_INTRA], cuGeom);
>                          if (md.pred[PRED_INTRA].sa8dCost <
> md.bestMode->sa8dCost)
>                              md.bestMode = &md.pred[PRED_INTRA];
> @@ -1104,7 +1105,10 @@
>                  else
>                  {
>                      if (m_param->rdLevel == 2)
> +                    {
> +                        md.bestMode->cu.resetIntraModes(false, true);
>                          encodeIntraInInter(*md.bestMode, cuGeom);
> +                    }
>                      else if (m_param->rdLevel == 1)
>                      {
>                          /* generate recon pixels with no rate distortion
> considerations */
> @@ -1374,13 +1378,15 @@
>                  {
>                      ProfileCounter(parentCTU, totalIntraCU[cuGeom.depth]);
>                      md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom,
> qp);
> -                    checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N,
> NULL, NULL);
> +                    md.pred[PRED_INTRA].cu.resetIntraModes(true, true);
> +                    checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N);
>                      checkBestMode(md.pred[PRED_INTRA], depth);
>
>                      if (cuGeom.log2CUSize == 3 &&
> m_slice->m_sps->quadtreeTULog2MinSize < 3)
>                      {
>                          md.pred[PRED_INTRA_NxN].cu.initSubCU(parentCTU,
> cuGeom, qp);
> -                        checkIntra(md.pred[PRED_INTRA_NxN], cuGeom,
> SIZE_NxN, NULL, NULL);
> +                        md.pred[PRED_INTRA_NxN].cu.resetIntraModes(true,
> true);
> +                        checkIntra(md.pred[PRED_INTRA_NxN], cuGeom,
> SIZE_NxN);
>                          checkBestMode(md.pred[PRED_INTRA_NxN], depth);
>                      }
>                  }
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/analysis.h
> --- a/source/encoder/analysis.h Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/analysis.h Thu Oct 08 16:28:14 2015 +0530
> @@ -104,7 +104,6 @@
>  protected:
>
>      /* Analysis data for load/save modes, keeps getting incremented as
> CTU analysis proceeds and data is consumed or read */
> -    analysis_intra_data* m_reuseIntraDataCTU;
>      analysis_inter_data* m_reuseInterDataCTU;
>      int32_t*             m_reuseRef;
>      uint32_t*            m_reuseBestMergeCand;
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/search.cpp
> --- a/source/encoder/search.cpp Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/search.cpp Thu Oct 08 16:28:14 2015 +0530
> @@ -1157,7 +1157,7 @@
>      }
>  }
>
> -void Search::checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize
> partSize, uint8_t* sharedModes, uint8_t* sharedChromaModes)
> +void Search::checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize
> partSize)
>  {
>      CUData& cu = intraMode.cu;
>
> @@ -1168,8 +1168,8 @@
>      cu.getIntraTUQtDepthRange(tuDepthRange, 0);
>
>      intraMode.initCosts();
> -    intraMode.lumaDistortion += estIntraPredQT(intraMode, cuGeom,
> tuDepthRange, sharedModes);
> -    intraMode.chromaDistortion += estIntraPredChromaQT(intraMode, cuGeom,
> sharedChromaModes);
> +    intraMode.lumaDistortion += estIntraPredQT(intraMode, cuGeom,
> tuDepthRange);
> +    intraMode.chromaDistortion += estIntraPredChromaQT(intraMode, cuGeom);
>      intraMode.distortion += intraMode.lumaDistortion +
> intraMode.chromaDistortion;
>
>      m_entropyCoder.resetBits();
> @@ -1388,7 +1388,7 @@
>      extractIntraResultQT(cu, *reconYuv, 0, 0);
>
>      intraMode.lumaDistortion = icosts.distortion;
> -    intraMode.chromaDistortion = estIntraPredChromaQT(intraMode, cuGeom,
> NULL);
> +    intraMode.chromaDistortion = estIntraPredChromaQT(intraMode, cuGeom);
>      intraMode.distortion = intraMode.lumaDistortion +
> intraMode.chromaDistortion;
>
>      m_entropyCoder.resetBits();
> @@ -1416,7 +1416,7 @@
>      checkDQP(intraMode, cuGeom);
>  }
>
> -uint32_t Search::estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom,
> const uint32_t depthRange[2], uint8_t* sharedModes)
> +uint32_t Search::estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom,
> const uint32_t depthRange[2])
>  {
>      CUData& cu = intraMode.cu;
>      Yuv* reconYuv = &intraMode.reconYuv;
> @@ -1440,8 +1440,8 @@
>      {
>          uint32_t bmode = 0;
>
> -        if (sharedModes)
> -            bmode = sharedModes[puIdx];
> +        if (intraMode.cu.m_lumaIntraDir[puIdx] != (uint8_t)ALL_IDX)
> +            bmode = intraMode.cu.m_lumaIntraDir[puIdx];
>          else
>          {
>              uint64_t candCostList[MAX_RD_INTRA_MODES];
> @@ -1680,7 +1680,7 @@
>      cu.setChromIntraDirSubParts(bestMode, 0, cuGeom.depth);
>  }
>
> -uint32_t Search::estIntraPredChromaQT(Mode &intraMode, const CUGeom&
> cuGeom, uint8_t* sharedChromaModes)
> +uint32_t Search::estIntraPredChromaQT(Mode &intraMode, const CUGeom&
> cuGeom)
>  {
>      CUData& cu = intraMode.cu;
>      Yuv& reconYuv = intraMode.reconYuv;
> @@ -1708,10 +1708,10 @@
>          uint32_t maxMode = NUM_CHROMA_MODE;
>          uint32_t modeList[NUM_CHROMA_MODE];
>
> -        if (sharedChromaModes && !initTuDepth)
> +        if (intraMode.cu.m_chromaIntraDir[0] != (uint8_t)ALL_IDX &&
> !initTuDepth)
>          {
>              for (uint32_t l = 0; l < NUM_CHROMA_MODE; l++)
> -                modeList[l] = sharedChromaModes[0];
> +                modeList[l] = intraMode.cu.m_chromaIntraDir[0];
>              maxMode = 1;
>          }
>          else
> diff -r 55a4a9b920ff -r bd8087bfd93f source/encoder/search.h
> --- a/source/encoder/search.h   Thu Oct 08 15:40:43 2015 +0530
> +++ b/source/encoder/search.h   Thu Oct 08 16:28:14 2015 +0530
> @@ -338,8 +338,8 @@
>      // mark temp RD entropy contexts as uninitialized; useful for finding
> loads without stores
>      void     invalidateContexts(int fromDepth);
>
> -    // full RD search of intra modes. if sharedModes is not NULL, it
> directly uses them
> -    void     checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize
> partSize, uint8_t* sharedModes, uint8_t* sharedChromaModes);
> +    // full RD search of intra modes
> +    void     checkIntra(Mode& intraMode, const CUGeom& cuGeom, PartSize
> partSizes);
>
>      // select best intra mode using only sa8d costs, cannot measure NxN
> intra
>      void     checkIntraInInter(Mode& intraMode, const CUGeom& cuGeom);
> @@ -405,10 +405,10 @@
>      void     saveResidualQTData(CUData& cu, ShortYuv& resiYuv, uint32_t
> absPartIdx, uint32_t tuDepth);
>
>      // RDO search of luma intra modes; result is fully encoded luma. luma
> distortion is returned
> -    uint32_t estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom, const
> uint32_t depthRange[2], uint8_t* sharedModes);
> +    uint32_t estIntraPredQT(Mode &intraMode, const CUGeom& cuGeom, const
> uint32_t depthRange[2]);
>
>      // RDO select best chroma mode from luma; result is fully encode
> chroma. chroma distortion is returned
> -    uint32_t estIntraPredChromaQT(Mode &intraMode, const CUGeom& cuGeom,
> uint8_t* sharedChromaModes);
> +    uint32_t estIntraPredChromaQT(Mode &intraMode, const CUGeom& cuGeom);
>
>      void     codeSubdivCbfQTChroma(const CUData& cu, uint32_t tuDepth,
> uint32_t absPartIdx);
>      void     codeInterSubdivCbfQT(CUData& cu, uint32_t absPartIdx, const
> uint32_t tuDepth, const uint32_t depthRange[2]);
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> https://mailman.videolan.org/listinfo/x265-devel
>



-- 
Deepthi Nandakumar
Engineering Manager, x265
Multicoreware, Inc
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20151009/88a366da/attachment-0001.html>


More information about the x265-devel mailing list