x265,帧内预测代码分析

 void Analysis::compressIntraCU(const CUData& parentCTU, const CUGeom& cuGeom, uint32_t& zOrder)
 {
     uint32_t depth = cuGeom.depth;//geometric  CU几何结构
     ModeDepth& md = m_modeDepth[depth];
     md.bestMode = NULL;

     bool mightSplit = !(cuGeom.flags & CUGeom::LEAF);//为ture非叶子节点，还需继续分裂
     bool mightNotSplit = !(cuGeom.flags & CUGeom::SPLIT_MANDATORY);//

     if (m_param->analysisMode == X265_ANALYSIS_LOAD)
     {
         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];

         if (mightNotSplit && depth == reuseDepth[zOrder] && zOrder == cuGeom.encodeIdx)
         {
             m_quant.setQPforQuant(parentCTU);

             PartSize size = (PartSize)reusePartSizes[zOrder];
             Mode& mode = size == SIZE_2Nx2N ? md.pred[PRED_INTRA] : md.pred[PRED_INTRA_NxN];
             mode.cu.initSubCU(parentCTU, cuGeom);
             checkIntra(mode, cuGeom, size, &reuseModes[zOrder]);
             checkBestMode(mode, depth);

             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 - ][reuseDepth[zOrder]];
             mightSplit = false;
         }
     }
     else if (mightNotSplit)
     {
         m_quant.setQPforQuant(parentCTU);

         md.pred[PRED_INTRA].cu.initSubCU(parentCTU, cuGeom);
         checkIntra(md.pred[PRED_INTRA], cuGeom, SIZE_2Nx2N, NULL);//intra2Nx2N  模式
         checkBestMode(md.pred[PRED_INTRA], depth);

         if (depth == g_maxCUDepth)
         {
             md.pred[PRED_INTRA_NxN].cu.initSubCU(parentCTU, cuGeom);
             checkIntra(md.pred[PRED_INTRA_NxN], cuGeom, SIZE_NxN, NULL);//INTRA_NxN  模式
             checkBestMode(md.pred[PRED_INTRA_NxN], depth);
         }

         if (m_bTryLossless)
             tryLossless(cuGeom);

         if (mightSplit)
             addSplitFlagCost(*md.bestMode, cuGeom.depth);
     }

     if (mightSplit)
     {
         Mode* splitPred = &md.pred[PRED_SPLIT];
         splitPred->initCosts();
         CUData* splitCU = &splitPred->cu;
         splitCU->initSubCU(parentCTU, cuGeom);//分裂成4四subCU

         uint32_t nextDepth = depth + ;
         ModeDepth& nd = m_modeDepth[nextDepth];
         invalidateContexts(nextDepth);
         Entropy* nextContext = &m_rqt[depth].cur;

         for (uint32_t subPartIdx = ; subPartIdx < ; subPartIdx++)
         {
             const CUGeom& childGeom = *(&cuGeom + cuGeom.childOffset + subPartIdx);
             if (childGeom.flags & CUGeom::PRESENT)
             {
                 m_modeDepth[].fencYuv.copyPartToYuv(nd.fencYuv, childGeom.encodeIdx);
                 m_rqt[nextDepth].cur.load(*nextContext);
                 compressIntraCU(parentCTU, childGeom, zOrder);//递归

                 // Save best CU and pred data for this sub CU
                 splitCU->copyPartFrom(nd.bestMode->cu, childGeom, subPartIdx);
                 splitPred->addSubCosts(*nd.bestMode);
                 nd.bestMode->reconYuv.copyToPartYuv(splitPred->reconYuv, childGeom.numPartitions * subPartIdx);
                 nextContext = &nd.bestMode->contexts;
             }
             else
             {
                 /* record the depth of this non-present sub-CU */
                 splitCU->setEmptyPart(childGeom, subPartIdx);
                 zOrder += g_depthInc[g_maxCUDepth - ][nextDepth];
             }
         }
         nextContext->store(splitPred->contexts);
         if (mightNotSplit)
             addSplitFlagCost(*splitPred, cuGeom.depth);
         else
             updateModeCost(*splitPred);
         checkBestMode(*splitPred, depth);
     }

     checkDQP(md.bestMode->cu, cuGeom);

     /* Copy best data to encData CTU and recon */
     md.bestMode->cu.copyToPic(depth);
     if (md.bestMode != &md.pred[PRED_SPLIT])
         md.bestMode->reconYuv.copyToPicYuv(*m_frame->m_reconPic, parentCTU.m_cuAddr, cuGeom.encodeIdx);
 }