HM视频编码

最新推荐文章于 2024-07-10 22:49:54 发布
最新推荐文章于 2024-07-10 22:49:54 发布
阅读量247 收藏 3
点赞数
文章标签： c++ 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46613874/article/details/129383024
版权

这篇是学习过程中一些新体会，不得不说编码框架太大了

class TAppEncTop

这个类可以说是整个代码的入口了，在emain函数就是该类对象调用encode开始编码

cTAppEncTop.encode(); 
class TAppEncTop : public TAppEncCfg
{
private:
  // class interface
  TEncTop                    m_cTEncTop;                    ///< 编码类，TAppEncTop是应用层编码类
  TVideoIOYuv                m_cTVideoIOYuvInputFile;       ///< 输入的YUV文件
  TVideoIOYuv                m_cTVideoIOYuvReconFile;       ///< 输出的YUV文件

  TComList<TComPicYuv*>      m_cListPicYuvRec;              ///< 列表，放的是输出的每一帧的YUV

  Int                        m_iFrameRcvd;                  ///<收到的帧数

  UInt m_essentialBytes;
  UInt m_totalBytes;

protected:
  // initialization
  Void  xCreateLib        ();                               ///< 创建编码类
  Void  xInitLibCfg       ();                               ///< 初始化内部变量
  Void  xInitLib          (Bool isFieldCoding);             ///< 初始化编码类
  Void  xDestroyLib       ();                               ///< 销毁编码类

  /// obtain required buffers
  Void xGetBuffer(TComPicYuv*& rpcPicYuvRec); //为重建图像申请内存

  /// delete allocated buffers
  Void  xDeleteBuffer     ();//删除分配的内存

  // file I/O
  Void xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits);//给文件中输出码流
  Void rateStatsAccum(const AccessUnit& au, const std::vector<UInt>& stats);
  Void printRateSummary(); //输出总码率
  Void printChromaFormat();输出视频格式

public:
  TAppEncTop();
  virtual ~TAppEncTop();

  Void        encode      ();                               ///< main encoding function
  TEncTop&    getTEncTop  ()   { return  m_cTEncTop; }      ///< return encoder class pointer reference

};// END CLASS DEFINITION TAppEncTop

TAppEncTop::encode()

//输入的YUV文件读取
fstream bitstreamFile(m_bitstreamFileName.c_str(), fstream::binary | fstream::out);
 //读取失败
 if (!bitstreamFile)
  {
    fprintf(stderr, "\nfailed to open bitstream file `%s' for writing\n", m_bitstreamFileName.c_str());
    exit(EXIT_FAILURE);
  }
 //原始图像和重建图像YUV
  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
  TComPicYuv*       pcPicYuvRec = NULL;
// 初始化编码类和一些参数
  xInitLibCfg();
  xCreateLib();
  xInitLib(m_isField);
  //打印原文件格式
  printChromaFormat();
//刚开始编码的入口，收到的帧数为0
  Int   iNumEncoded = 0;
  Bool  bEos = false;
  list<AccessUnit> outputAccessUnits;//输出的码流，应该就是bin文件
 TComPicYuv cPicYuvTrueOrg;//TrueOrg和pcPicYuvOrg的区别见之前的文章
//非场，默认执行下面else
if( m_isField )
  {
    pcPicYuvOrg->create  ( m_iSourceWidth, m_iSourceHeightOrg, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    cPicYuvTrueOrg.create(m_iSourceWidth, m_iSourceHeightOrg, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true);
  }
  else
  {
//为pcPicYuvOrg和cPicYuvTrueOrg初始化空间
    pcPicYuvOrg->create  ( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
    cPicYuvTrueOrg.create(m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
  }
//开始循环压缩每一帧
while ( !bEos )
  {
    // 为重建图像申请内存
    xGetBuffer(pcPicYuvRec);

    // 从输入的YUV文件中读取帧，放到pcPicYuvOrg和cPicYuvTrueOrg中
    m_cTVideoIOYuvInputFile.read( pcPicYuvOrg, &cPicYuvTrueOrg, ipCSC, m_aiPad, m_InputChromaFormatIDC, m_bClipInputVideoToRec709Range );

    // 收到的帧数+1
    m_iFrameRcvd++;
//当m_iFrameRcvd==m_framesToBeEncoded（总共要编码的帧数，cfg文件中配置）时，bEos=true，退出循环，编码结束
    bEos = (m_isField && (m_iFrameRcvd == (m_framesToBeEncoded >> 1) )) || ( !m_isField && (m_iFrameRcvd == m_framesToBeEncoded) );

    Bool flush = 0;
    // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
    if (m_cTVideoIOYuvInputFile.isEof())
    {
      flush = true;
      bEos = true;
      m_iFrameRcvd--;
      m_cTEncTop.setFramesToBeEncoded(m_iFrameRcvd);
    }

    // 开始编码每一帧
    if ( m_isField )
    {
      m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, flush ? 0 : &cPicYuvTrueOrg, snrCSC, m_cListPicYuvRec, outputAccessUnits, iNumEncoded, m_isTopFieldFirst );
    }
    else
    {
      m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, flush ? 0 : &cPicYuvTrueOrg, snrCSC, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );
    }


    //如果有帧被编码，就把码流输出到文件中
    if ( iNumEncoded > 0 )
    {
//输出码流和YUV文件
      xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits);
      outputAccessUnits.clear();
    }
    // temporally skip frames
    if( m_temporalSubsampleRatio > 1 )
    {
      m_cTVideoIOYuvInputFile.skipFrames(m_temporalSubsampleRatio-1, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1], m_InputChromaFormatIDC);
    }
  }

  m_cTEncTop.printSummary(m_isField);

  // delete original YUV buffer
  pcPicYuvOrg->destroy();
  delete pcPicYuvOrg;
  pcPicYuvOrg = NULL;

  // delete used buffers in encoder class
  m_cTEncTop.deletePicBuffer();
  cPicYuvTrueOrg.destroy();

  // delete buffers & classes
  xDeleteBuffer();
  xDestroyLib();

  printRateSummary();

  return;
}

TAppEncTop::xWriteOutput

该函数输出码流和YUV文件

Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
{
  const InputColourSpaceConversion ipCSC = (!m_outputInternalColourSpace) ? m_inputColourSpaceConvert : IPCOLOURSPACE_UNCHANGED;

  if (m_isField)
  {
    //Reinterlace fields
    Int i;
    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();

    for ( i = 0; i < iNumEncoded; i++ )
    {
      --iterPicYuvRec;
    }

    for ( i = 0; i < iNumEncoded/2; i++ )
    {
      TComPicYuv*  pcPicYuvRecTop  = *(iterPicYuvRec++);
      TComPicYuv*  pcPicYuvRecBottom  = *(iterPicYuvRec++);

      if (!m_reconFileName.empty())
      {
        m_cTVideoIOYuvReconFile.write( pcPicYuvRecTop, pcPicYuvRecBottom, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom, NUM_CHROMA_FORMAT, m_isTopFieldFirst );
      }

      const AccessUnit& auTop = *(iterBitstream++);
      const vector<UInt>& statsTop = writeAnnexB(bitstreamFile, auTop);
      rateStatsAccum(auTop, statsTop);

      const AccessUnit& auBottom = *(iterBitstream++);
      const vector<UInt>& statsBottom = writeAnnexB(bitstreamFile, auBottom);
      rateStatsAccum(auBottom, statsBottom);
    }
  }
  else
  {
    Int i;

    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();

    for ( i = 0; i < iNumEncoded; i++ )
    {
      --iterPicYuvRec;
    }

    for ( i = 0; i < iNumEncoded; i++ )
    {
      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
      if (!m_reconFileName.empty())
      {
        m_cTVideoIOYuvReconFile.write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom,
            NUM_CHROMA_FORMAT, m_bClipOutputVideoToRec709Range  );
      }

      const AccessUnit& au = *(iterBitstream++);
      const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
      rateStatsAccum(au, stats);
    }
  }
}

TAppEncTop::xGetBuffer

该函数的作用就是给重建图像申请空间，没啥好讲的，对重建图像的列表m_cListPicYuvRec内帧数进行了限制

Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec)
{
  assert( m_iGOPSize > 0 );
  // org. buffer
  if ( m_cListPicYuvRec.size() >= (UInt)m_iGOPSize ) // buffer will be 1 element longer when using field coding, to maintain first field whilst processing second.
  {
    rpcPicYuvRec = m_cListPicYuvRec.popFront();
  }
  else
  {
    rpcPicYuvRec = new TComPicYuv;
    rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_chromaFormatIDC, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxTotalCUDepth, true );
  }
  m_cListPicYuvRec.pushBack( rpcPicYuvRec );
}

TAppEncTop::xWriteOutput

函数重点就是调用m_cTVideoIOYuvReconFile.write（）写入到文件中

Int i;

    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();

    for ( i = 0; i < iNumEncoded; i++ )
    {
      --iterPicYuvRec;
    }

    for ( i = 0; i < iNumEncoded; i++ )
    {
      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
      if (!m_reconFileName.empty())
      {
        m_cTVideoIOYuvReconFile.write( pcPicYuvRec, ipCSC, m_confWinLeft, m_confWinRight, m_confWinTop, m_confWinBottom,
            NUM_CHROMA_FORMAT, m_bClipOutputVideoToRec709Range  );
      }

      const AccessUnit& au = *(iterBitstream++);
      const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
      rateStatsAccum(au, stats);
    }

总结：

这个类是应用层的一些准备工作，例如读取YUV文件，重建的图像写入到文件中，为图像申请空间，调用encode函数正式开始编码等等

m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, flush ? 0 : &cPicYuvTrueOrg, snrCSC, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );

encode函数的输入值得注意，m_cListPicYuvRec是重建图像的列表，outputAccessUnits是码流，iNumEncoded是调用该函数后总共编码了几帧

class TEncTop

正式的编码类，也真正进入了编码

TEncTop::encode

Void TEncTop::encode( Bool flush, TComPicYuv* pcPicYuvOrg, TComPicYuv* pcPicYuvTrueOrg, const InputColourSpaceConversion snrCSC, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
{


  if (pcPicYuvOrg != NULL)
  {
    // get original YUV
    TComPic* pcPicCurr = NULL;
//给传入的原始图像帧申请一个TComPic的空间，把他加入m_cListPic列表中
    xGetNewPicBuffer( pcPicCurr );
//然后把pcPicYuvOrg和pcPicYuvTrueOrg都复制pcPicCurr对象中
    pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
    pcPicYuvTrueOrg->copyToPic( pcPicCurr->getPicYuvTrueOrg() );

    // compute image characteristics
    if ( getUseAdaptiveQP() )
    {
      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
    }
  }
//如果传入的帧数不满足一个GOP大小，退出，例如GOP大小为4，那我必须传入够4帧才开始编码
  if ((m_iNumPicRcvd == 0) || (!flush && (m_iPOCLast != 0) && (m_iNumPicRcvd != m_iGOPSize) && (m_iGOPSize != 0)))
  {
    iNumEncoded = 0;
    return;
  }
//开启码率控制
  if ( m_RCEnableRateControl )
  {
    m_cRateCtrl.initRCGOP( m_iNumPicRcvd );
  }

  // compress GOP 这个函数是整个编码中的最重要的地方！

  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE);

  if ( m_RCEnableRateControl )
  {
    m_cRateCtrl.destroyRCGOP();
  }
//参数更新
调用encode函数总共编码了帧数。收到的帧数清0
  iNumEncoded         = m_iNumPicRcvd;
  m_iNumPicRcvd       = 0;
  m_uiNumAllPicCoded += iNumEncoded;
}

TEncTop::xGetNewPicBuffer

该函数的作用就是将创建的TComPic* pcPicCurr加入到m_cListPic列表中， m_cListPic.pushBack( rpcPic );

 //一些列表大小限制
if (m_cListPic.size() >= (UInt)(m_iGOPSize + getMaxDecPicBuffering(MAX_TLAYER-1) + 2) )
  {
    TComList<TComPic*>::iterator iterPic  = m_cListPic.begin();
    Int iSize = Int( m_cListPic.size() );
    for ( Int i = 0; i < iSize; i++ )
    {
      rpcPic = *(iterPic++);
      if(rpcPic->getSlice(0)->isReferenced() == false)
      {
        break;
      }
    }
  }
else
    {
      rpcPic = new TComPic;
      rpcPic->create( m_cSPS, m_cPPS, false );
    }

    m_cListPic.pushBack( rpcPic );
  }
  rpcPic->setReconMark (false);
//POC更新，收到的帧数++
  m_iPOCLast++;
  m_iNumPicRcvd++;
//rpcPic可以理解为一个集合体，放了原始图像和重建图像
//设置该帧的POC
  rpcPic->getSlice(0)->setPOC( m_iPOCLast );
  // mark it should be extended
  rpcPic->getPicYuvRec()->setBorderExtension(false);

TComPic类中有个属性是

TComPicYuv* m_apcPicYuv[NUM_PIC_YUV];
NUM_PIC_YUV =3；
typedef enum { PIC_YUV_ORG=0, PIC_YUV_REC=1, PIC_YUV_TRUE_ORG=2, NUM_PIC_YUV=3 } PIC_YUV_T;
原始图像是0，重建图像是1，TRUE_ORG是2

pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );

pcPicYuvTrueOrg->copyToPic( pcPicCurr->getPicYuvTrueOrg() );

上面两行就是把原始图像和TrueOrg图像复制到TComPic::pcPicCurr中

整个编码算法的中心

传入的是m_iPOCLast是当前压缩GOP中最后一帧的POC顺序，m_iNumPicRcvd收到的图像，一般为GOP大小，也有特殊情况，例如第一帧I帧。

m_cListPic就是TComPic列表，rcListPicYuvRecOut是重建图像YUV列表

m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, false, false, snrCSC, m_printFrameMSE);

TEncGOP::compressGOP

 新建三个对象，分别是图像集合体pcPic，重建图像YUVpcPicYuvRecOut,条pcSlice
 TComPic*        pcPic = NULL;
  TComPicYuv*     pcPicYuvRecOut;
  TComSlice*      pcSlice;
//置m_iGopSize，表示当前GOP的大小，除了第一帧是1的情况外，是恒定的即使当前GOP没有读取到足够的帧数
  xInitGOP( iPOCLast, iNumPicRcvd, isField );
 // 将m_GOPList中的m_isEncoded设置为false，表示当前帧还未编码。m_GOPList里面存着一个GOP内每个帧的一些信息（例如POC、I/B/P帧等等），这些都是直接从cfg文件中得到的的信息。

  for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
  {
    m_pcCfg->setEncodedFlag(iGOPid, false);
  }
//当前时间
clock_t iBeforeTime = clock();
Int iTimeOffset;//表示当前编码帧是当前GOP播放顺序的第几帧
    Int pocCurr;//表示当前编码帧的POC
for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
  {
 // 启动新的访问设备：在输出访问设备列表中创建一个条目
    accessUnitsInGOP.push_back(AccessUnit());
    AccessUnit& accessUnit = accessUnitsInGOP.back();
    xGetBuffer( rcListPic, rcListPicYuvRecOut, iNumPicRcvd, iTimeOffset, pcPic, pcPicYuvRecOut, pocCurr, isField );
  //  片级数据初始化
    pcPic->clearSliceBuffer();
    pcPic->allocateNewSlice();
    m_pcSliceEncoder->setSliceIdx(0);
    pcPic->setCurrSliceIdx(0);
    m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iGOPid, pcSlice, isField );
.........
省略了一部分slice级和参考帧的工作
正式进入编码，这是帧级编码，CTU级编码在compressSlice函数中
 Double lambda            = 0.0;
    Int actualHeadBits       = 0;
    Int actualTotalBits      = 0;
    Int estimatedBits        = 0;
    Int tmpBitsBeforeWriting = 0;
//帧级码率控制，这部分内容之前码率控制的文章讲很清楚了，进行省略
 if ( m_pcCfg->getUseRateCtrl() ) // TODO: does this work with multiple slices and slice-segments?
    {
      Int frameLevel = m_pcRateCtrl->getRCSeq()->getGOPID2Level( iGOPid );
      if ( pcPic->getSlice(0)->getSliceType() == I_SLICE )
      {
        frameLevel = 0;
      }
      m_pcRateCtrl->initRCPic( frameLevel );
      estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
......
    }
CTU级编码
{
      const UInt numberOfCtusInFrame=pcPic->getPicSym()->getNumberOfCtusInFrame();
      pcSlice->setSliceCurStartCtuTsAddr( 0 );
      pcSlice->setSliceSegmentCurStartCtuTsAddr( 0 );

      for(UInt nextCtuTsAddr = 0; nextCtuTsAddr < numberOfCtusInFrame; )
      {
        m_pcSliceEncoder->precompressSlice( pcPic );
        m_pcSliceEncoder->compressSlice   ( pcPic, false, false );

        const UInt curSliceSegmentEnd = pcSlice->getSliceSegmentCurEndCtuTsAddr();
        if (curSliceSegmentEnd < numberOfCtusInFrame)
        {
          const Bool bNextSegmentIsDependentSlice=curSliceSegmentEnd<pcSlice->getSliceCurEndCtuTsAddr();
          const UInt sliceBits=pcSlice->getSliceBits();
          pcPic->allocateNewSlice();
          // prepare for next slice
          pcPic->setCurrSliceIdx                    ( uiNumSliceSegments );
          m_pcSliceEncoder->setSliceIdx             ( uiNumSliceSegments   );
          pcSlice = pcPic->getSlice                 ( uiNumSliceSegments   );
          assert(pcSlice->getPPS()!=0);
          pcSlice->copySliceInfo                    ( pcPic->getSlice(uiNumSliceSegments-1)  );
          pcSlice->setSliceIdx                      ( uiNumSliceSegments   );
          if (bNextSegmentIsDependentSlice)
          {
            pcSlice->setSliceBits(sliceBits);
          }
          else
          {
            pcSlice->setSliceCurStartCtuTsAddr      ( curSliceSegmentEnd );
            pcSlice->setSliceBits(0);
          }
          pcSlice->setDependentSliceSegmentFlag(bNextSegmentIsDependentSlice);
          pcSlice->setSliceSegmentCurStartCtuTsAddr ( curSliceSegmentEnd );
          // TODO: optimise cabac_init during compress slice to improve multi-slice operation
          // pcSlice->setEncCABACTableIdx(m_pcSliceEncoder->getEncCABACTableIdx());
          uiNumSliceSegments ++;
        }
        nextCtuTsAddr = curSliceSegmentEnd;
      }
    }
该帧编码结束，如果开启了码率控制则进行参数更新
 if ( m_pcCfg->getUseRateCtrl() )
    {
      Double avgQP     = m_pcRateCtrl->getRCPic()->calAverageQP();
      Double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
      if ( avgLambda < 0.0 )
      {
        avgLambda = lambda;
      }

      m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, pcSlice->getSliceType());
      m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );

      m_pcRateCtrl->getRCSeq()->updateAfterPic( actualTotalBits );
      if ( pcSlice->getSliceType() != I_SLICE )
      {
        m_pcRateCtrl->getRCGOP()->updateAfterPicture( actualTotalBits );
      }
      else    // for intra picture, the estimated bits are used to update the current status in the GOP
      {
        m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
      }
.......
将pcPic中的重建图像复制到pcPicYuvRecOut
//到这里编码基本就结束了，我在这里的pcPicYuvRecOut中引入了一些错误来证明本文算优劣
pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);

}

TEncGOP::GetBuffer

该函数的作用是从rcListPic、rcListPicYuvRecOut获取当前正在编码帧的应该存放的位置，然后突然函数的传入参数传出，即pcPic和pcPicYuvRecOut 
Void TEncGOP::xGetBuffer( TComList<TComPic*>&      rcListPic,
                         TComList<TComPicYuv*>&    rcListPicYuvRecOut,
                         Int                       iNumPicRcvd,
                         Int                       iTimeOffset,
                         TComPic*&                 rpcPic,
                         TComPicYuv*&              rpcPicYuvRecOut,
                         Int                       pocCurr,
                         Bool                      isField)
{
  Int i;
  //  Rec. output
  TComList<TComPicYuv*>::iterator     iterPicYuvRec = rcListPicYuvRecOut.end();
for ( i = 0; i < (iNumPicRcvd - iTimeOffset + 1); i++ )
  {
    iterPicYuvRec--;
  }

  rpcPicYuvRecOut = *(iterPicYuvRec);

  //  Current pic.
  TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
  while (iterPic != rcListPic.end())
  {
    rpcPic = *(iterPic);
    rpcPic->setCurrSliceIdx(0);
    if (rpcPic->getPOC() == pocCurr)
    {
      break;
    }
    iterPic++;
  }

  assert (rpcPic != NULL);
  assert (rpcPic->getPOC() == pocCurr);

  return;
}
华函数
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HM代码阅读（1）编码流程总述
jiamenghu的博客
07-12 887
转载于 https://blog.csdn.net/nb_vol_1/article/details/51144828 目录转载于 https://blog.csdn.net/nb_vol_1/article/details/51144828编码流程1、编码GOP2、编码slice3、slice的划分4、CU的划分5、`compressCU`6、帧内预测的详解(入口函数：`xCheckRDCostIntra`）6.1、对于亮度分量6.1.1、调用`estIntraPredQT`6.1.2、调用`xRecur
HTML5:video标签视频编码格式规范
Andrew_SJ的博客
08-06 589
https://cloud.tencent.com/developer/article/1535603
HEVC解码器解码出现failed to open bitstream file ‘str.bin‘ for reading的问题解决方法记录
qq_42027960的博客
07-07 901
第一次解码的工作目录我设置再如下文件夹，也就是和编码端工作目录一起的文件夹。（我这里的编码生成的bin文件我把名字改了123.bin），当然这对解决问题无关紧要。第一次解码就出现了failed to open bitstream file 'str.bin' for reading 然后，我把解码端的工作目录重新放在了另一个新建的文件夹，如下，当然这个新建的文件夹可以在任何地方新建，前提是你要解码bin文件，必须放在该目录下，也就是你要解码的str.bin文件必须复制在新建的文件夹下面。我这里新.
H.265视频编码原理总结
热门推荐
weixin_43254989的博客
01-12 1万+
H.265视频编码原理总结 转载地址 1 概述 H.265（HEVC High Efficiency Video Coding）是现行H.264标准于2003年实现标准化以来时隔10年推出的新标准，将成为支撑未来十年的影像服务和产品的视频压缩技术。其特点是，支持1080p以上的4K×2K和8K×4K分辨率，将视频压缩率提高至H.264的约2倍。也就是说，能以原来一半的编码速度发送相同画质的视频。例如，按照20Mbit/秒发送的H.264格式视频内容，在相同画质的条件下用HEVC格式只需10Mbit/秒的
视频编解码学习笔记二—HM的使用及数字视频的格式
dujiangscsdn的博客
03-11 2729
一，软件下载 HEVC的官方参考软件是HM（HEVC Test Model）。 下载HM需要使用到SVN。 SVN是一个开源的版本控制系统。相当于一个版本控制器加备份服务器。可以回到修改以前某个时刻的版本，也可以在多人之间共享最新的版本。 首先下载TortoiseSVN，https://tortoisesvn.net/downloads.zh.html，安装完后记得重启电脑。 安装完成后...
HEVC视频编码调试环境HM9.0
10-06
**HEVC视频编码调试环境HM9.0**是高级视频编码标准High Efficiency Video Coding（HEVC）的一个重要组成部分，主要用于研发、测试和优化H.265编码算法。HEVC，也称为MPEG-H Part 2或ITU-T的H.265标准，是H.264/AVC的...
HM-HM-16.22
09-17
标题“HM-HM-16.22”指的是High Efficiency Video Coding (HEVC) 的一个特定版本，由Fraunhofer HHI的JCT-VC（联合视频探索团队 - 视频编码）开发。这个版本是HM (HevcMain) 编码器的16.22更新，用于高效编码视频...
HM码流信息提取工具，可以批量提取编码信息
04-12
HM码流信息提取工具是一款专为视频编码领域设计的专业软件，尤其针对HEVC（High Efficiency Video Coding，高效视频编码）标准，也称为H265编码。HEVC是目前广泛应用于高清视频编码的一种先进标准，它在保持画质的...
HM以及VTM输出信息提取汇总.bat
08-04
可用于提取HM以及VTM输出的文本中的psnr以及bitrate信息，一键即可汇总到csv文件中
HEVC/h.265视频编码解码
12-09
HEVC，全称为High Efficiency Video Coding，中文名为高效视频编码，是目前最先进的一种视频压缩标准，由MPEG（Moving Picture Experts Group）和VCEG（Video Coding Experts Group）联合开发，是H.264/AVC的后续...
记录编码失真
xinlongkun的博客
03-07 179
方式1记录Ctu失真 float Ctudistortiontable[codeframenum + 1][Ctunuminwide + 1][Ctunuminheight + 1]; void recod16BSDioiofCurctu(int poc,int ctupex_x,int ctupex_y,Pel*org,Pel*rec, int orgstride, int recstride) { ..... ctudistortion = 0; for (int i = 0..
HEVC学习之琐事（五）：pcPicYuvOrg与getPicYuvOrg()的对应关系
weixin_34194087的博客
01-07 251
这两天一直纠结于pcPicYuvOrg与getPicYuvOrg()的对应关系，这是因为我自定义了一个pcPicYuvBgf与getPicYuvBgf()，初衷是实现类似于pcPicYuvOrg与getPicYuvOrg()的对应关系，以便于我后面的处理。调试了两天，最后才发现败给了自己的“想太多”。其实这个超简单~~~碰到这种自己想扇自己一巴掌的东西...
HM TLibVideoIO库
qq_46613874的博客
12-07 172
HM TLibVideoIO库
H.266/VVC代码学习4：VTM代码整体结构及最上层函数
时间有泪
03-02 7051
最近在做一些较上层的内容，从老师和师兄师姐的博客里学到了很多，对VTM代码有了进一步的理解。VTM4.0代码整体结构如下，并会后面分别介绍几个主要函数的作用。 EncSlice::encodeCtus 大体操作：以CTU为单位，对划分后的内容进行熵编码。 每个slice为一帧。一帧中对所有CTU（128*128）都进行编码（for循环每个CTU，分别调用compressCtu函数），具体来说主要...
H.265/HEVC视频编码-HM16.9配置文件设置
qq_42539958的博客
11-11 1427
H.265/HEVC视频编码学习，HM-16.9调试过程。
HEVC中类，对象和指向对象的指针
xidianliye的博客
10-12 601
HEVC代码中定义了几十种类，这些类的对象一般只实例化一次，在编码过程中都是通过指针来访问实例化的对象。 唯一以类名实例化的对象：cTAppEncTopmain () { TAppEncTop cTAppEncTop; }这个对象被建立时，它的所有数据成员也被建立，并实例化（占据存储空间）class TAppEncTop { TEncTop m_cTEncTop }而m_cTEnc
H265解码流程理解
叶子
09-04 4221
类的简介 H265内部的Class封装一般分为两种： 一种是编码类，一种是数据类。 编解码类 TDecTop :好像是最顶层的解码器，然后内部封装了几乎下面所有的编解码类别。 TDecGop：解码GOP为单位的解码器类内部也封装了各类的解码器，包括：熵编码器，环路滤波器等等 TDecSlice 就是在TDecGOP中的成员，用于解码图像的Slice， TDecCu： 解码CU的解码器类，内部包含存储CU块级别Res和Rec内存空间，如果要提取Pred信息，需要在这个解码器内部对Pred信息进行维护。 T
常用的一些小程序集合的算法描述和部分代码(输出BMP,截取yuv,边界标记)
TMUC_HM
05-23 1754
在研究视频编码的过程中,总是需要写一些小的算法,下面列举几个最常用的算法 1. 输出BMP 编码的测试序列大部分都是采用yuv颜色空间,这样做的好处就是可以将人眼敏感的亮度和不敏感的色度分离,分别处理,更利于比特的分配 但是yuv必须转成bmp格式后才能显示, 所以我将bmp输出的代码放在这里,便于大家使用(经过测试,本函数可以直接调用) bool saveBmp(char *bmpNam
C++ 多态
最新发布
wxk2227814847的博客
07-10 491
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Xiang2018-Article-ANovelAdaptiveQuantizationMeth.pdf
04-21
X264 AQ 论文

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值