HEVC代码学习34：compressSlice函数

最新推荐文章于 2022-04-10 20:32:49 发布
最新推荐文章于 2022-04-10 20:32:49 发布
阅读量274 收藏 4
点赞数
分类专栏： HEVC
原文链接：https://blog.csdn.net/lin453701006/article/details/78673978
版权

HEVC代码学习34：compressSlice函数

转载自https://blog.csdn.net/lin453701006/article/details/78673978侵删

compressSlice，是Slice层编码的入口函数，主要完成的功能就是Slice层编码参数的初始化，其中会调用compressCtu（其中会调用xCompressCU，对CU进行划分）和encodeCtu（其中对调用xEncodeCU，对CU进行编码），这两个函数只是入口函数，十分简单，在本文第二部分进行分析。

compressSlice

主要工作流程：
1.计算Slice的起始CTU和边界CTU。
2.初始化率失真参数：bit、RD cost、失真。
3.初始化Sbac熵编码器，根据当前Slice设置参数。
4.遍历当前Slice中的CTU，对CU进行划分和编码，计算bit、RD cost、失真。其中调用了重要函数compressCtu和encodeCtu。

推荐阅读http://blog.csdn.net/nb_vol_1/article/details/51151803，不过大神使用的HM版本较早，没有引入CTU，使用的是LCU。

/** \param pcPic   picture class
 */
//Slice层编码
Void TEncSlice::compressSlice( TComPic* pcPic, const Bool bCompressEntireSlice, const Bool bFastDeltaQP )
{
  // if bCompressEntireSlice is true, then the entire slice (not slice segment) is compressed,
  //   effectively disabling the slice-segment-mode.

  //起始CTU序号
  UInt   startCtuTsAddr;    
  //CTU边界序号
  UInt   boundingCtuTsAddr;
  //当前Slice
  TComSlice* const pcSlice            = pcPic->getSlice(getSliceIdx());
  //将Slice中当前bit置零
  pcSlice->setSliceSegmentBits(0);      
  //计算当前Slice中的起始CTU和边界CTU
  xDetermineStartAndBoundingCtuTsAddr ( startCtuTsAddr, boundingCtuTsAddr, pcPic );     

  //bCompressEntireSlice默认为false
  if (bCompressEntireSlice)     
  {
    boundingCtuTsAddr = pcSlice->getSliceCurEndCtuTsAddr();
    pcSlice->setSliceSegmentCurEndCtuTsAddr(boundingCtuTsAddr);
  }

  // initialize cost values - these are used by precompressSlice (they should be parameters).
  //初始化总bit、RD cost和失真
  m_uiPicTotalBits  = 0;
  m_dPicRdCost      = 0; // NOTE: This is a write-only variable!
  m_uiPicDist       = 0;

  //初始化熵编码器
  m_pcEntropyCoder->setEntropyCoder   ( m_pppcRDSbacCoder[0][CI_CURR_BEST] );
  //根据当前Slice设置熵编码参数
  m_pcEntropyCoder->resetEntropy      ( pcSlice );      

  //加载熵编码器SBAC
  TEncBinCABAC* pRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
  pRDSbacCoder->setBinCountingEnableFlag( false );
  pRDSbacCoder->setBinsCoded( 0 );

  //bit计数
  TComBitCounter  tempBitCounter;   
  //帧每行的CTU个数
  const UInt      frameWidthInCtus = pcPic->getPicSym()->getFrameWidthInCtus();     

  //快速DeltaQp默认关闭
  m_pcCuEncoder->setFastDeltaQp(bFastDeltaQP);      

  //------------------------------------------------------------------------------
  //  Weighted Prediction parameters estimation.
  //------------------------------------------------------------------------------
  // calculate AC/DC values for current picture
  //默认关闭
  if( pcSlice->getPPS()->getUseWP() || pcSlice->getPPS()->getWPBiPred() )   
  {
    xCalcACDCParamSlice(pcSlice);
  }

  const Bool bWp_explicit = (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) || (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPred());

  //bWp_explicit默认为false
  if ( bWp_explicit )   
  {
    //------------------------------------------------------------------------------
    //  Weighted Prediction implemented at Slice level. SliceMode=2 is not supported yet.
    //------------------------------------------------------------------------------
    if ( pcSlice->getSliceMode()==FIXED_NUMBER_OF_BYTES || pcSlice->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES )
    {
      printf("Weighted Prediction is not supported with slice mode determined by max number of bins.\n"); exit(0);
    }

    xEstimateWPParamSlice( pcSlice, m_pcCfg->getWeightedPredictionMethod() );
    pcSlice->initWpScaling(pcSlice->getSPS());

    // check WP on/off
    xCheckWPEnable( pcSlice );
  }

#if ADAPTIVE_QP_SELECTION   
  //自适应QP，默认关闭
  if( m_pcCfg->getUseAdaptQpSelect() && !(pcSlice->getDependentSliceSegmentFlag()))     
  {
    // TODO: this won't work with dependent slices: they do not have their own QP. Check fix to mask clause execution with && !(pcSlice->getDependentSliceSegmentFlag())
    m_pcTrQuant->clearSliceARLCnt(); // TODO: this looks wrong for multiple slices - the results of all but the last slice will be cleared before they are used (all slices compressed, and then all slices encoded)
    if(pcSlice->getSliceType()!=I_SLICE)
    {
      Int qpBase = pcSlice->getSliceQpBase();
      pcSlice->setSliceQp(qpBase + m_pcTrQuant->getQpDelta(qpBase));
    }
  }
#endif



  // Adjust initial state if this is the start of a dependent slice.
  //调整初始状态
  {
    //CTU地址
    const UInt      ctuRsAddr               = pcPic->getPicSym()->getCtuTsToRsAddrMap( startCtuTsAddr);
    //当前Tile序号
    const UInt      currentTileIdx          = pcPic->getPicSym()->getTileIdxMap(ctuRsAddr);
    //当前Tile
    const TComTile *pCurrentTile            = pcPic->getPicSym()->getTComTile(currentTileIdx);
    //Tile中第一个CTU的地址
    const UInt      firstCtuRsAddrOfTile    = pCurrentTile->getFirstCtuRsAddr();

    //独立Slice且非第一个Tile时启用
    if( pcSlice->getDependentSliceSegmentFlag() && ctuRsAddr != firstCtuRsAddrOfTile )
    {
      // This will only occur if dependent slice-segments (m_entropyCodingSyncContextState=true) are being used.
      if( pCurrentTile->getTileWidthInCtus() >= 2 || !m_pcCfg->getEntropyCodingSyncEnabledFlag() )
      {
        m_pppcRDSbacCoder[0][CI_CURR_BEST]->loadContexts( &m_lastSliceSegmentEndContextState );
      }
    }
  }

  // for every CTU in the slice segment (may terminate sooner if there is a byte limit on the slice-segment)
  //遍历Slice中的每一个CTU，对CTU进行编码
  for( UInt ctuTsAddr = startCtuTsAddr; ctuTsAddr < boundingCtuTsAddr; ++ctuTsAddr )
  {
    //CTU地址
    const UInt ctuRsAddr = pcPic->getPicSym()->getCtuTsToRsAddrMap(ctuTsAddr);

    // initialize CTU encoder
    //当前CTU
    TComDataCU* pCtu = pcPic->getCtu( ctuRsAddr );
    //初始化CTU
    pCtu->initCtu( pcPic, ctuRsAddr );

    // update CABAC state
    //第一个CTU的地址
    const UInt firstCtuRsAddrOfTile = pcPic->getPicSym()->getTComTile(pcPic->getPicSym()->getTileIdxMap(ctuRsAddr))->getFirstCtuRsAddr();
    //计算Tile的x坐标
    const UInt tileXPosInCtus = firstCtuRsAddrOfTile % frameWidthInCtus;
    //计算CTU的x坐标
    const UInt ctuXPosInCtus  = ctuRsAddr % frameWidthInCtus;

    //如果是Tile的第一个CTU
    if (ctuRsAddr == firstCtuRsAddrOfTile)
    {
      //设置熵编码参数
      m_pppcRDSbacCoder[0][CI_CURR_BEST]->resetEntropy(pcSlice);
    }
    else if ( ctuXPosInCtus == tileXPosInCtus && m_pcCfg->getEntropyCodingSyncEnabledFlag())
    {
      // reset and then update contexts to the state at the end of the top-right CTU (if within current slice and tile).
      m_pppcRDSbacCoder[0][CI_CURR_BEST]->resetEntropy(pcSlice);
      // Sync if the Top-Right is available.
      TComDataCU *pCtuUp = pCtu->getCtuAbove();
      if ( pCtuUp && ((ctuRsAddr%frameWidthInCtus+1) < frameWidthInCtus)  )
      {
        TComDataCU *pCtuTR = pcPic->getCtu( ctuRsAddr - frameWidthInCtus + 1 );
        if ( pCtu->CUIsFromSameSliceAndTile(pCtuTR) )
        {
          // Top-Right is available, we use it.
          m_pppcRDSbacCoder[0][CI_CURR_BEST]->loadContexts( &m_entropyCodingSyncContextState );
        }
      }
    }

    // set go-on entropy coder (used for all trial encodings - the cu encoder and encoder search also have a copy of the same pointer)
    //设置熵编码器
    m_pcEntropyCoder->setEntropyCoder ( m_pcRDGoOnSbacCoder );
    m_pcEntropyCoder->setBitstream( &tempBitCounter );
    tempBitCounter.resetBits();
    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[0][CI_CURR_BEST] ); // this copy is not strictly necessary here, but indicates that the GoOnSbacCoder
                                                                     // is reset to a known state before every decision process.

    ((TEncBinCABAC*)m_pcRDGoOnSbacCoder->getEncBinIf())->setBinCountingEnableFlag(true);

    //当前lambda
    Double oldLambda = m_pcRdCost->getLambda();

    //码率控制时启用
    if ( m_pcCfg->getUseRateCtrl() )
    {
      Int estQP        = pcSlice->getSliceQp();
      Double estLambda = -1.0;
      Double bpp       = -1.0;

      if ( ( pcPic->getSlice( 0 )->getSliceType() == I_SLICE && m_pcCfg->getForceIntraQP() ) || !m_pcCfg->getLCULevelRC() )
      {
        estQP = pcSlice->getSliceQp();
      }
      else
      {
        bpp = m_pcRateCtrl->getRCPic()->getLCUTargetBpp(pcSlice->getSliceType());
        if ( pcPic->getSlice( 0 )->getSliceType() == I_SLICE)
        {
          estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambdaAndQP(bpp, pcSlice->getSliceQp(), &estQP);
        }
        else
        {
          estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );
          estQP     = m_pcRateCtrl->getRCPic()->getLCUEstQP    ( estLambda, pcSlice->getSliceQp() );
        }

        estQP     = Clip3( -pcSlice->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, estQP );

        m_pcRdCost->setLambda(estLambda, pcSlice->getSPS()->getBitDepths());

#if RDOQ_CHROMA_LAMBDA
        // set lambda for RDOQ
        const Double chromaLambda = estLambda / m_pcRdCost->getChromaWeight();
        const Double lambdaArray[MAX_NUM_COMPONENT] = { estLambda, chromaLambda, chromaLambda };
        m_pcTrQuant->setLambdas( lambdaArray );
#else
        m_pcTrQuant->setLambda( estLambda );
#endif
      }

      m_pcRateCtrl->setRCQP( estQP );
#if ADAPTIVE_QP_SELECTION
      pCtu->getSlice()->setSliceQpBase( estQP );
#endif
    }

    // run CTU trial encoder
    //CU划分
    m_pcCuEncoder->compressCtu( pCtu );


    // All CTU decisions have now been made. Restore entropy coder to an initial stage, ready to make a true encode,
    // which will result in the state of the contexts being correct. It will also count up the number of bits coded,
    // which is used if there is a limit of the number of bytes per slice-segment.

    //设置熵编码器参数
    m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST] );
    m_pcEntropyCoder->setBitstream( &tempBitCounter );
    pRDSbacCoder->setBinCountingEnableFlag( true );
    m_pppcRDSbacCoder[0][CI_CURR_BEST]->resetBits();
    pRDSbacCoder->setBinsCoded( 0 );

    // encode CTU and calculate the true bit counters.
    //CTU编码
    m_pcCuEncoder->encodeCtu( pCtu );


    pRDSbacCoder->setBinCountingEnableFlag( false );

    const Int numberOfWrittenBits = m_pcEntropyCoder->getNumberOfWrittenBits();

    // Calculate if this CTU puts us over slice bit size.
    // cannot terminate if current slice/slice-segment would be 0 Ctu in size,
    const UInt validEndOfSliceCtuTsAddr = ctuTsAddr + (ctuTsAddr == startCtuTsAddr ? 1 : 0);
    // Set slice end parameter
    //设置Slice结束参数
    if(pcSlice->getSliceMode()==FIXED_NUMBER_OF_BYTES && pcSlice->getSliceBits()+numberOfWrittenBits > (pcSlice->getSliceArgument()<<3))
    {
      pcSlice->setSliceSegmentCurEndCtuTsAddr(validEndOfSliceCtuTsAddr);
      pcSlice->setSliceCurEndCtuTsAddr(validEndOfSliceCtuTsAddr);
      boundingCtuTsAddr=validEndOfSliceCtuTsAddr;
    }
    else if((!bCompressEntireSlice) && pcSlice->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES && pcSlice->getSliceSegmentBits()+numberOfWrittenBits > (pcSlice->getSliceSegmentArgument()<<3))
    {
      pcSlice->setSliceSegmentCurEndCtuTsAddr(validEndOfSliceCtuTsAddr);
      boundingCtuTsAddr=validEndOfSliceCtuTsAddr;
    }

    //如果当前CTU超过了边界CTU，跳出
    if (boundingCtuTsAddr <= ctuTsAddr)
    {
      break;
    }

    //设置bit数
    pcSlice->setSliceBits( (UInt)(pcSlice->getSliceBits() + numberOfWrittenBits) );
    pcSlice->setSliceSegmentBits(pcSlice->getSliceSegmentBits()+numberOfWrittenBits);

    // Store probabilities of second CTU in line into buffer - used only if wavefront-parallel-processing is enabled.
    //默认关闭
    if ( ctuXPosInCtus == tileXPosInCtus+1 && m_pcCfg->getEntropyCodingSyncEnabledFlag())
    {
      m_entropyCodingSyncContextState.loadContexts(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
    }

    //码率控制时启用
    if ( m_pcCfg->getUseRateCtrl() )
    {
      Int actualQP        = g_RCInvalidQPValue;
      Double actualLambda = m_pcRdCost->getLambda();
      Int actualBits      = pCtu->getTotalBits();
      Int numberOfEffectivePixels    = 0;
      for ( Int idx = 0; idx < pcPic->getNumPartitionsInCtu(); idx++ )
      {
        if ( pCtu->getPredictionMode( idx ) != NUMBER_OF_PREDICTION_MODES && ( !pCtu->isSkipped( idx ) ) )
        {
          numberOfEffectivePixels = numberOfEffectivePixels + 16;
          break;
        }
      }

      if ( numberOfEffectivePixels == 0 )
      {
        actualQP = g_RCInvalidQPValue;
      }
      else
      {
        actualQP = pCtu->getQP( 0 );
      }
      m_pcRdCost->setLambda(oldLambda, pcSlice->getSPS()->getBitDepths());
      m_pcRateCtrl->getRCPic()->updateAfterCTU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,
                                                pCtu->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );
    }

    //计算总的bit、RD cost、失真
    m_uiPicTotalBits += pCtu->getTotalBits();
    m_dPicRdCost     += pCtu->getTotalCost();
    m_uiPicDist      += pCtu->getTotalDistortion();
  }

  // store context state at the end of this slice-segment, in case the next slice is a dependent slice and continues using the CABAC contexts.
  if( pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag() )
  {
    m_lastSliceSegmentEndContextState.loadContexts( m_pppcRDSbacCoder[0][CI_CURR_BEST] );//ctx end of dep.slice
  }

  // stop use of temporary bit counter object.
  m_pppcRDSbacCoder[0][CI_CURR_BEST]->setBitstream(NULL);
  m_pcRDGoOnSbacCoder->setBitstream(NULL); // stop use of tempBitCounter.

  // TODO: optimise cabac_init during compress slice to improve multi-slice operation
  //if (pcSlice->getPPS()->getCabacInitPresentFlag() && !pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag())
  //{
  //  m_encCABACTableIdx = m_pcEntropyCoder->determineCabacInitIdx();
  //}
  //else
  //{
  //  m_encCABACTableIdx = pcSlice->getSliceType();
  //}
}

compressCtu和encodeCtu

compressCtu是块划分的入口函数，主要包含两部分：初始化CTU和调用xCompressCU进行块划分。xCompressCU是非常重要的函数，详细介绍见：http://blog.csdn.net/lin453701006/article/details/72401400

代码分析如下：

/** 
 \param  pCtu pointer of CU data class
 */
Void TEncCu::compressCtu( TComDataCU* pCtu )
{
  // initialize CU data
  //将最优CU置为当前CTU
  m_ppcBestCU[0]->initCtu( pCtu->getPic(), pCtu->getCtuRsAddr() );
  //将当前CU置为当前CTU
  m_ppcTempCU[0]->initCtu( pCtu->getPic(), pCtu->getCtuRsAddr() );

  // analysis of CU
  DEBUG_STRING_NEW(sDebug)

  //递归进行块划分
  xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 DEBUG_STRING_PASS_INTO(sDebug) );
  DEBUG_STRING_OUTPUT(std::cout, sDebug)

#if ADAPTIVE_QP_SELECTION
  if( m_pcEncCfg->getUseAdaptQpSelect() )
  {
    if(pCtu->getSlice()->getSliceType()!=I_SLICE) //IIII
    {
      xCtuCollectARLStats( pCtu );
    }
  }
#endif
}

encodeCtu是CTU编码的入口函数，主要包含两部分：根据情况设置QP相关Flag和调用xEncodeCU进行CU编码。xEncodeCU详细分析见http://blog.csdn.net/lin453701006/article/details/78688889。

/** \param  pCtu  pointer of CU data class
 */
Void TEncCu::encodeCtu ( TComDataCU* pCtu )
{
  //当开启DQP时，置flag
  if ( pCtu->getSlice()->getPPS()->getUseDQP() )
  {
    setdQPFlag(true);
  }

  //当开启色度QP自适应时，置flag
  if ( pCtu->getSlice()->getUseChromaQpAdj() )
  {
    setCodeChromaQpAdjFlag(true);
  }

  // Encode CU data
  //CU编码
  xEncodeCU( pCtu, 0, 0 );
}
lindergarten
关注
专栏目录
compressSlice函数代码跟踪
weixin_42394155的博客
10-18 230
西巴，上篇随便对付了一下关于GOP的函数，那接下来当然是对付Slice函数啦！ Void TEncSlice::compressSlice( TComPic* pcPic, const Bool bCompressEntireSlice, const Bool bFastDeltaQP ) { // if bCompressEntireSlice is true, then the entire slice (not slice segment) is compressed, // effe
【HEVC代码阅读】帧内预测
qq_37200357的博客
11-18 816
HEVC的帧内预测的架构分为三个步骤： ①构建参考像素数组；②生成预测像素；③后处理操作。 HEVC标准将这三个步骤进行了精密设计，以求达到较高的编码效率，同时降低编码和解码端的运算要求。HEVC标准的多种预定义的预测模式构成一个模式集合，可以对包括视频和静态图像中的多种内容进行预测建模的方法。HEVC的角度预测提供了对包含方向性纹理的物体更高的预测精确度，此外平面和DC模式可以高效地表示图像的平...
HEVC代码追踪（五）：compressSlice
成长Bar的博客专栏
11-26 1669
Void TEncSlice::compressSlice( TComPic*& rpcPic ) { UInt uiCUAddr; UInt uiStartCUAddr; UInt uiBoundingCUAddr; rpcPic->getSlice(getSliceIdx())->setSliceSegmentBits(0); TEncBinCABAC* pppc
HEVC编码之precompressSlice函数
杨杨子江的博客
04-22 603
HEVC中每一个slice的QP值并不一定像设定的QP值一样，之所以会这样都是precompressSlice函数的“功劳” Void TEncSlice::precompressSlice( TComPic* pcPic ) { // if deltaQP RD is not used, simply return if ( m_pcCfg->getDeltaQpRD() == 0...
compressSlice
Villa_7的博客
04-12 692
Void TEncSlice::compressSlice( TComPic* pcPic, const Bool bCompressEntireSlice, const Bool bFastDeltaQP ) { // if bCompressEntireSlice is true, then the entire slice (not slice segment) is compresse
HEVC编码器HM代码详解：GOP、Slice与LCU划分
"此文档主要介绍了HEVC(High Efficiency Video Coding，高效视频编码)标准中的HM(High Efficiency Video Coding Test Model)编码器的代码结构和工作流程，特别关注了编码过程中的GOP(Group of Pictures)、Slice和LCU...
HEVC学习（八） —— 以SAO为例浅析跟踪代码方法
热门推荐
HEVC_CJL的专栏
11-24 1万+
HM的代码跟踪其实在我转载的一篇博客HEVC/H.265参考代码跟踪里就已经有很不错的介绍了，因此，我就不重复里面所说的了，而是对里面一些我觉得需要稍微补充下并且以另一个具体实例SAO即Sample Adaptive Offset的跟踪过程进行说明。由于只是一个跟踪说明，代码的具体细节就不去探究了，其实这也是一个方法，有些时候，你仅仅需要知道实现某个功能的代码在哪，而不需要知道它的实现细节，那
HEVC函数入门（1）——HM编码器的基本结构
不是他人太努力，只是自己努力不够罢了
06-18 1923
首先说明这篇主要是记录用（意思是里面很多是我自己的理解，我也是刚入门的新手，肯定有许多不正确的地方，还请轻喷），使用的是HM 16.3 VS2015 当然如果有新手不太懂的话也可以看看。 本文主要参照http://blog.csdn.net/shaqoneal/article/details/36398707int main(int argc, char* argv[]) { TAppEncT
Void TEncSlice::compressSlice
xhyan523的博客
03-19 490
Void TEncSlice::compressSlice( TComPic* pcPic, const Bool bCompressEntireSlice, const Bool bFastDeltaQP ) { // if bCompressEntireSlice is true, then the entire slice (not slice segment) is compresse...
JVET-代码分析之 片的编码 TEncSlice::compressSlice
liumoude6的博客
04-13 1318
根据看过的HEVC/X265的代码，这里提案有很大的区别，这里先不讨论其他的，只介绍一下我看的基本的内容；水平有限，还请各位大神指点； 先回忆一下 由在CompressGOP函数中，完成了以下的功能：  一，InitGOP将文件的码流分成若干GOP以便后续程序能够顺利执行。    二，InitEncSlice创建编码的Slice。  三，调用preCompressSlice和Com
HM代码-码控（3）-compressslice（）中的RC
qq_42083770的博客
05-16 417
大神传送门 https://blog.csdn.net/cpp12341234/article/details/45867631 https://blog.csdn.net/HEVC_CJL/article/details/11128745 //compressslice()中的关于RC的部分 Double oldLambda = m_pcRdCost->getLambda(); ...
VVC代码阅读 compressSlice()
dfhg54的博客
04-10 874
void EncSlice::compressSlice( Picture* pcPic, const bool bCompressEntireSlice, const bool bFastDeltaQP ) { // if bCompressEntireSlice is true, then the entire slice (not slice segment) is compressed, // effectively disabling the slice-segment-mode. .
HEVC码率控制代码追踪（一）（HEVC code tracing-Rate control）
yang-彧
05-16 3506
接下来的一段时间将对码率控制代码追踪这一块的学习心得和领悟做个简要的记录，在将来的某一天，这些博文将让我清晰地看到自己的成长。 码率控制的关键两个步骤：（1）码率分配（2）目标码率的实现 所以在看代码的时候也尽量将步骤与代码对应起来，分块阅读，整合思考与优化。 在码率控制的两个步骤中又可以依据操作对象（层次）的不同，分别从GOP,picture,lcu这三个方面去看程序。在对功能函数进行解读
HEVC码率控制（二）：从compressGOP()到compressSlice()
xidianliye的博客
12-16 1520
compressGOP()函数要点： 根据iGOPid逐次递增，对一个GOP内的picture依次编码 根据picture level对当前picture进行码率分配 实际中一个Pic就是一个Slice，因此关于slice的循环只执行一次（默认） 根据已经编过的picture，来得到当前picture的lambda 得到当前picture的lambda后，对该picture下每一个CTU进行码率分配
H.266/VVC代码学习13：VTM4.0中的CU层操作（compressCtu 、 xCompressCU）
时间有泪
03-22 5702
从H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）我们了解到了视频最基本的操作块为CTU，现在我们进一步学习CU层的操作。有两个十分重要的函数： 1 compressCtu: 是对encodeCtu中拿到的单个ctu进行操作，是进行CU划分预测等处理的入口。内部一共会调用两次 xCompressCU ，一次是对亮度进行处理，一次是对色度进行处理。可见compre...
HEVC函数入门（16）——Slice编码
不是他人太努力，只是自己努力不够罢了
08-01 2315
本文转载整理自：http://blog.csdn.net/NB_vol_1/article/details/51152578 这篇文章很多东西还没搞懂，所以先转载放在这。 入口函数TEncSlice::compressSlice 这个函数主要是设置一些参数和初始化一些东西，然后对片中的每一个LCU调用initCU（初始化CU）和compressCU（对CU编码）和encodeCU（对CU进行熵
HEVC函数入门（15）——重要变量以及CU索引
不是他人太努力，只是自己努力不够罢了
07-30 3450
本文整理自：1：http://blog.csdn.net/nb_vol_1/article/details/51145006 2：http://blog.csdn.net/NB_vol_1/article/details/71187426 首先感谢大神授权可以整理转载，后面会接着读大神的博客，所以后面一段时间里文章基本也是整理自这位大神。 1、TComDataCU。TComDataCU：LC
HEVC代码学习38：decompressSlice函数
慢慢积累
05-11 1198
好久没看HEVC了，今天回归，来学习一下解码端的decompressSlice函数，有两个，一个是TDecGop类的成员函数，另一个是TDecSlice类的。 TDecGop::decompressSlice 该函数比较简单，是解码一帧图像的上层入口函数，在TDecGop::xDecodeSlice中被调用。主要功能是完成熵解码器初始化和计时工作，并会调用TDecSlice::decompre...
HEVC码率控制解析：标准、技术与代码分析
"HEVC码率控制文献总结与代码分析 - 张晖 - 中国传媒大学" 这篇资源主要探讨了高效视频编码（High Efficiency Video Coding, HEVC）的码率控制策略及其在HM10参考软件中的实现。作者首先概述了HEVC标准的基本背景和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值