VTM11中关于码率控制的疑问笔记（一）

最新推荐文章于 2022-08-16 22:21:39 发布
最新推荐文章于 2022-08-16 22:21:39 发布
阅读量986 收藏 2
点赞数 2
分类专栏： H.266/VVC 文章标签： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36672636/article/details/118999670
版权
本文详细解读了VVC（H.266的后续标准）中码率控制模块的初始化过程，涉及isLowdelay判断、GOPSize与level的关系、bitsRatio数组的使用，以及如何根据比特率目标调整编码配置。通过实例解析，帮助理解关键参数在编码效率和延迟之间的权衡。
摘要由CSDN通过智能技术生成

最近一直在看vtm11的代码，研究方向是H.266/VVC的码率控制。关于代码以及代码引申出VVC一些概念的疑问在此记录一下，希望研究这方面的前辈多指教。

一、码率控制模块初始化（序列级）

//码率控制模块初始化
void RateCtrl::init(int totalFrames, int targetBitrate, int frameRate, int GOPSize, int picWidth, int picHeight, int LCUWidth, int LCUHeight, int bitDepth, int keepHierBits, bool useLCUSeparateModel, GOPEntry  GOPList[MAX_GOP])
{
  destroy();

  bool isLowdelay = true;
  for ( int i=0; i<GOPSize-1; i++ )
  {//m_POC帧序列号
    if ( GOPList[i].m_POC > GOPList[i+1].m_POC )
    {//如果GOPList中前一个图像的播放序号比后一个图像的播放序号大，那他就不是低时延编码
      isLowdelay = false;
      break;
    }
  }

  int numberOfLevel = 1;
  int adaptiveBit = 0;
  //keepHierBits:即是否采用分层编码，若采用，则各帧的比特分配是不一样的，否则，各帧的比特分配权重相同
  if ( keepHierBits > 0 || ( !isLowdelay && (GOPSize == 32 || GOPSize == 16 || GOPSize == 8) ) )
  {
    numberOfLevel = int( log((double)GOPSize)/log(2.0) + 0.5 ) + 1;
  }
  numberOfLevel++;    // intra picture
  numberOfLevel++;    // non-reference picture


  int* bitsRatio;
  bitsRatio = new int[ GOPSize ];//这个数组其实不是分配给gop中各帧的比特数，而是分配给各帧的比特数比例(w)
  for ( int i=0; i<GOPSize; i++ )
  {
    bitsRatio[i] = 10;
    if ( !GOPList[i].m_refPic )
    {//m_refPic：参考图像 布尔值
      bitsRatio[i] = 2;
    }
  }

  if ( keepHierBits > 0 )
  {
   //bpp：每像素比特数
    double bpp = (double)( targetBitrate / (double)( frameRate*picWidth*picHeight ) );
    if ( GOPSize == 4 && isLowdelay )
    {
      if ( bpp > 0.2 )
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 6;
      }
      else if( bpp > 0.1 )
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 10;
      }
      else if ( bpp > 0.05 )
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 12;
      }
      else
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 14;
      }

      if ( keepHierBits == 2 )
      {
        adaptiveBit = 1;
      }
    }
    else if (GOPSize == 8 && isLowdelay)
    {
      if (bpp > 0.2)
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 3;
        bitsRatio[4] = 2;
        bitsRatio[5] = 3;
        bitsRatio[6] = 2;
        bitsRatio[7] = 6;
      }
      else if (bpp > 0.1)
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 3;
        bitsRatio[4] = 2;
        bitsRatio[5] = 3;
        bitsRatio[6] = 2;
        bitsRatio[7] = 10;
      }
      else if (bpp > 0.05)
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 3;
        bitsRatio[4] = 2;
        bitsRatio[5] = 3;
        bitsRatio[6] = 2;
        bitsRatio[7] = 12;
      }
      else
      {
        bitsRatio[0] = 2;
        bitsRatio[1] = 3;
        bitsRatio[2] = 2;
        bitsRatio[3] = 3;
        bitsRatio[4] = 2;
        bitsRatio[5] = 3;
        bitsRatio[6] = 2;
        bitsRatio[7] = 14;
      }

      if (keepHierBits == 2)
      {
        adaptiveBit = 1;
      }
    }
    else if ( GOPSize == 8 && !isLowdelay )
    {
      if ( bpp > 0.2 )
      {
        bitsRatio[0] = 15;
        bitsRatio[1] = 5;
        bitsRatio[2] = 4;
        bitsRatio[3] = 1;
        bitsRatio[4] = 1;
        bitsRatio[5] = 4;
        bitsRatio[6] = 1;
        bitsRatio[7] = 1;
      }
      else if ( bpp > 0.1 )
      {
        bitsRatio[0] = 20;
        bitsRatio[1] = 6;
        bitsRatio[2] = 4;
        bitsRatio[3] = 1;
        bitsRatio[4] = 1;
        bitsRatio[5] = 4;
        bitsRatio[6] = 1;
        bitsRatio[7] = 1;
      }
      else if ( bpp > 0.05 )
      {
        bitsRatio[0] = 25;
        bitsRatio[1] = 7;
        bitsRatio[2] = 4;
        bitsRatio[3] = 1;
        bitsRatio[4] = 1;
        bitsRatio[5] = 4;
        bitsRatio[6] = 1;
        bitsRatio[7] = 1;
      }
      else
      {
        bitsRatio[0] = 30;
        bitsRatio[1] = 8;
        bitsRatio[2] = 4;
        bitsRatio[3] = 1;
        bitsRatio[4] = 1;
        bitsRatio[5] = 4;
        bitsRatio[6] = 1;
        bitsRatio[7] = 1;
      }

      if ( keepHierBits == 2 )
      {
        adaptiveBit = 2;
      }
    }
    else if (GOPSize == 16 && !isLowdelay)
    {
      if (bpp > 0.2)
      {
        bitsRatio[0] = 10;
        bitsRatio[1] = 8;
        bitsRatio[2] = 4;
        bitsRatio[3] = 2;
        bitsRatio[4] = 1;
        bitsRatio[5] = 1;
        bitsRatio[6] = 2;
        bitsRatio[7] = 1;
        bitsRatio[8] = 1;
        bitsRatio[9] = 4;
        bitsRatio[10] = 2;
        bitsRatio[11] = 1;
        bitsRatio[12] = 1;
        bitsRatio[13] = 2;
        bitsRatio[14] = 1;
        bitsRatio[15] = 1;
      }
      else if (bpp > 0.1)
      {
        bitsRatio[0] = 15;
        bitsRatio[1] = 9;
        bitsRatio[2] = 4;
        bitsRatio[3] = 2;
        bitsRatio[4] = 1;
        bitsRatio[5] = 1;
        bitsRatio[6] = 2;
        bitsRatio[7] = 1;
        bitsRatio[8] = 1;
        bitsRatio[9] = 4;
        bitsRatio[10] = 2;
        bitsRatio[11] = 1;
        bitsRatio[12] = 1;
        bitsRatio[13] = 2;
        bitsRatio[14] = 1;
        bitsRatio[15] = 1;
      }
      else if (bpp > 0.05)
      {
        bitsRatio[0] = 40;
        bitsRatio[1] = 17;
        bitsRatio[2] = 7;
        bitsRatio[3] = 2;
        bitsRatio[4] = 1;
        bitsRatio[5] = 1;
        bitsRatio[6] = 2;
        bitsRatio[7] = 1;
        bitsRatio[8] = 1;
        bitsRatio[9] = 7;
        bitsRatio[10] = 2;
        bitsRatio[11] = 1;
        bitsRatio[12] = 1;
        bitsRatio[13] = 2;
        bitsRatio[14] = 1;
        bitsRatio[15] = 1;
      }
      else
      {
        bitsRatio[0] = 40;
        bitsRatio[1] = 15;
        bitsRatio[2] = 6;
        bitsRatio[3] = 3;
        bitsRatio[4] = 1;
        bitsRatio[5] = 1;
        bitsRatio[6] = 3;
        bitsRatio[7] = 1;
        bitsRatio[8] = 1;
        bitsRatio[9] = 6;
        bitsRatio[10] = 3;
        bitsRatio[11] = 1;
        bitsRatio[12] = 1;
        bitsRatio[13] = 3;
        bitsRatio[14] = 1;
        bitsRatio[15] = 1;
      }

      if (keepHierBits == 2)
      {
        adaptiveBit = 2;
      }
    }
    else if (GOPSize == 32 && !isLowdelay)
    {
      int bitsRatioInit[4][6]={
        {16, 10, 8, 4, 2, 1},
        {16, 10, 8, 4, 2, 1},
        {16, 10, 8, 4, 2, 1},
        {10, 8, 6, 4, 2, 1},
      };
      int cls;
      if (bpp > 0.2)
      {
        cls = 0;
      }
      else if(bpp > 0.1)
      {
        cls = 1;
      }
      else if(bpp > 0.05)
      {
        cls = 2;
      }
      else
      {
        cls = 3;
      }
      int index[32] = {0, 1, 2, 3, 4, 5, 5, 4, 5, 5, 3, 4, 5, 5, 4, 5, 5, 2, 3, 4, 5, 5, 4, 5, 5, 3, 4, 5, 5, 4, 5, 5};

      for (int i = 0; i < 32; i++)
      {
        bitsRatio[i] = bitsRatioInit[cls][index[i]];
      }
      if (keepHierBits == 2)
      {
        adaptiveBit = 2;
      }
    }
    else
    {
      msg( WARNING, "\n hierarchical bit allocation is not support for the specified coding structure currently.\n" );
    }
  }
  //GOPID2Level:gop图像序号到level的映射
  int* GOPID2Level = new int[ GOPSize ];
  for ( int i=0; i<GOPSize; i++ )
  {
    GOPID2Level[i] = 1;
    if ( !GOPList[i].m_refPic )
    {
      GOPID2Level[i] = 2;
    }
  }

  if ( keepHierBits > 0 )
  {
    if ( GOPSize == 4 && isLowdelay )
    {
      GOPID2Level[0] = 3;
      GOPID2Level[1] = 2;
      GOPID2Level[2] = 3;
      GOPID2Level[3] = 1;
    }
    if (GOPSize == 8 && isLowdelay)
    {
      GOPID2Level[0] = 3;
      GOPID2Level[1] = 2;
      GOPID2Level[2] = 3;
      GOPID2Level[3] = 2;
      GOPID2Level[4] = 3;
      GOPID2Level[5] = 2;
      GOPID2Level[6] = 3;
      GOPID2Level[7] = 1;
    }
    else if ( GOPSize == 8 && !isLowdelay )
    {
      GOPID2Level[0] = 1;
      GOPID2Level[1] = 2;
      GOPID2Level[2] = 3;
      GOPID2Level[3] = 4;
      GOPID2Level[4] = 4;
      GOPID2Level[5] = 3;
      GOPID2Level[6] = 4;
      GOPID2Level[7] = 4;
    }
    else if (GOPSize == 16 && !isLowdelay)
    {
      GOPID2Level[0] = 1;
      GOPID2Level[1] = 2;
      GOPID2Level[2] = 3;
      GOPID2Level[3] = 4;
      GOPID2Level[4] = 5;
      GOPID2Level[5] = 5;
      GOPID2Level[6] = 4;
      GOPID2Level[7] = 5;
      GOPID2Level[8] = 5;
      GOPID2Level[9] = 3;
      GOPID2Level[10] = 4;
      GOPID2Level[11] = 5;
      GOPID2Level[12] = 5;
      GOPID2Level[13] = 4;
      GOPID2Level[14] = 5;
      GOPID2Level[15] = 5;
    }
  }

  if ( !isLowdelay && GOPSize == 8 )
  {
    GOPID2Level[0] = 1;
    GOPID2Level[1] = 2;
    GOPID2Level[2] = 3;
    GOPID2Level[3] = 4;
    GOPID2Level[4] = 4;
    GOPID2Level[5] = 3;
    GOPID2Level[6] = 4;
    GOPID2Level[7] = 4;
  }
  else if (GOPSize == 16 && !isLowdelay)
  {
    GOPID2Level[0] = 1;
    GOPID2Level[1] = 2;
    GOPID2Level[2] = 3;
    GOPID2Level[3] = 4;
    GOPID2Level[4] = 5;
    GOPID2Level[5] = 5;
    GOPID2Level[6] = 4;
    GOPID2Level[7] = 5;
    GOPID2Level[8] = 5;
    GOPID2Level[9] = 3;
    GOPID2Level[10] = 4;
    GOPID2Level[11] = 5;
    GOPID2Level[12] = 5;
    GOPID2Level[13] = 4;
    GOPID2Level[14] = 5;
    GOPID2Level[15] = 5;
  }
  else if(GOPSize == 32 && !isLowdelay)
  {
    GOPID2Level[0]  = 1;
    GOPID2Level[1]  = 2;
    GOPID2Level[2]  = 3;
    GOPID2Level[3]  = 4;
    GOPID2Level[4]  = 5;
    GOPID2Level[5]  = 6;
    GOPID2Level[6]  = 6;
    GOPID2Level[7]  = 5;
    GOPID2Level[8]  = 6;
    GOPID2Level[9]  = 6;
    GOPID2Level[10] = 4;
    GOPID2Level[11] = 5;
    GOPID2Level[12] = 6;
    GOPID2Level[13] = 6;
    GOPID2Level[14] = 5;
    GOPID2Level[15] = 6;
    GOPID2Level[16] = 6;
    GOPID2Level[17] = 3;
    GOPID2Level[18] = 4;
    GOPID2Level[19] = 5;
    GOPID2Level[20] = 6;
    GOPID2Level[21] = 6;
    GOPID2Level[22] = 5;
    GOPID2Level[23] = 6;
    GOPID2Level[24] = 6;
    GOPID2Level[25] = 4;
    GOPID2Level[26] = 5;
    GOPID2Level[27] = 6;
    GOPID2Level[28] = 6;
    GOPID2Level[29] = 5;
    GOPID2Level[30] = 6;
    GOPID2Level[31] = 6;
  }

  m_encRCSeq = new EncRCSeq;//将计算后得到的各项数据传入码率控制的初始化函数（EncRCSeq.cpp）之中
  m_encRCSeq->create( totalFrames, targetBitrate, frameRate, GOPSize, picWidth, picHeight, LCUWidth, LCUHeight, numberOfLevel, useLCUSeparateModel, adaptiveBit );
  m_encRCSeq->initBitsRatio( bitsRatio );//设置每一帧的比特率比重
  m_encRCSeq->initGOPID2Level( GOPID2Level );
  m_encRCSeq->setBitDepth(bitDepth);
  m_encRCSeq->initPicPara();// 主要是帧级别的alpha和beta参数的设置(JCTVC-K0103)
  if ( useLCUSeparateModel )
  {
    m_encRCSeq->initLCUPara();// 主要是LCU级别的alpha和beta参数的设置

  }
#if U0132_TARGET_BITS_SATURATION
  m_CpbSaturationEnabled = false;
  m_cpbSize              = targetBitrate;
  m_cpbState             = (uint32_t)(m_cpbSize*0.5f);
  m_bufferingRate        = (int)(targetBitrate / frameRate);
#endif

  delete[] bitsRatio;
  delete[] GOPID2Level;
}

1.isLowdelay变量

        该变量是判断是否采用低时延（LD）编码配置。VVC中有三种编码配置，即AI（all intra）、RA（random access）、LD（low delay）。关于三种模式，参考：https://blog.csdn.net/dongmie1999/article/details/116131129

2.numberOfLevel变量

        目前没弄懂

3.bitsRatio数组

        根据JCTVC-K0103提案，该数组存放的是GOP中各帧对应的比特数比例（也可以说是比特数权重）。

4.GOPID2Level数组

        虽然知道它是存储GOP中图像序号到level的映射，但这个数组的意义也还不是特别清楚。

5.下面几行就是将得到的一些数据存入m_encRCSeq对象中，其中有个create()函数,如下：

void EncRCSeq::create( int totalFrames, int targetBitrate, int frameRate, int GOPSize, int picWidth, int picHeight, int LCUWidth, int LCUHeight, int numberOfLevel, bool useLCUSeparateModel, int adaptiveBit )
{
  destroy();
  m_totalFrames         = totalFrames;//总帧数
  m_targetRate          = targetBitrate;//目标比特
  m_frameRate           = frameRate;//帧率(fps)
  m_GOPSize             = GOPSize;//gop大小
  m_picWidth            = picWidth;
  m_picHeight           = picHeight;
  m_LCUWidth            = LCUWidth;
  m_LCUHeight           = LCUHeight;
  m_numberOfLevel       = numberOfLevel;
  m_useLCUSeparateModel = useLCUSeparateModel;

  m_numberOfPixel   = m_picWidth * m_picHeight;
  //序列总码率 即输出码流大小
  m_targetBits      = (int64_t)m_totalFrames * (int64_t)m_targetRate / (int64_t)m_frameRate;
  //每像素被分到的目标比特
  m_seqTargetBpp = (double)m_targetRate / (double)m_frameRate / (double)m_numberOfPixel;
  //m_alphaUpdate、m_betaUpdate这两个变量用于在接下来更新lamda的参数值
  if ( m_seqTargetBpp < 0.03 )
  {
    m_alphaUpdate = 0.01;
    m_betaUpdate  = 0.005;
  }
  else if ( m_seqTargetBpp < 0.08 )
  {
    m_alphaUpdate = 0.05;
    m_betaUpdate  = 0.025;
  }
  else if ( m_seqTargetBpp < 0.2 )
  {
    m_alphaUpdate = 0.1;
    m_betaUpdate  = 0.05;
  }
  else if ( m_seqTargetBpp < 0.5 )
  {
    m_alphaUpdate = 0.2;
    m_betaUpdate  = 0.1;
  }
  else
  {
    m_alphaUpdate = 0.4;
    m_betaUpdate  = 0.2;
  }

  m_averageBits     = (int)(m_targetBits / totalFrames);//平均每帧占用的目标比特数
  int picWidthInBU  = ( m_picWidth  % m_LCUWidth  ) == 0 ? m_picWidth  / m_LCUWidth  : m_picWidth  / m_LCUWidth  + 1;
  int picHeightInBU = ( m_picHeight % m_LCUHeight ) == 0 ? m_picHeight / m_LCUHeight : m_picHeight / m_LCUHeight + 1;
  //一帧包含的LCU数量
  m_numberOfLCU     = picWidthInBU * picHeightInBU;

  m_bitsRatio   = new int[m_GOPSize];
  for ( int i=0; i<m_GOPSize; i++ )
  {
    m_bitsRatio[i] = 1;
  }

  m_GOPID2Level = new int[m_GOPSize];
  for ( int i=0; i<m_GOPSize; i++ )
  {
    m_GOPID2Level[i] = 1;
  }

  m_picPara = new TRCParameter[m_numberOfLevel];
  for ( int i=0; i<m_numberOfLevel; i++ )
  {
    m_picPara[i].m_alpha = 0.0;
    m_picPara[i].m_beta  = 0.0;
    m_picPara[i].m_validPix = -1;
    m_picPara[i].m_skipRatio = 0.0;
  }

  if ( m_useLCUSeparateModel )
  {
    m_LCUPara = new TRCParameter*[m_numberOfLevel];
    for ( int i=0; i<m_numberOfLevel; i++ )
    {
      m_LCUPara[i] = new TRCParameter[m_numberOfLCU];
      for ( int j=0; j<m_numberOfLCU; j++)
      {
        m_LCUPara[i][j].m_alpha = 0.0;
        m_LCUPara[i][j].m_beta  = 0.0;
        m_LCUPara[i][j].m_validPix = -1;
        m_LCUPara[i][j].m_skipRatio = 0.0;
      }
    }
  }

  m_framesLeft = m_totalFrames;
  m_bitsLeft   = m_targetBits;
  m_adaptiveBit = adaptiveBit;
  m_lastLambda = 0.0;
}

涉及几个变量，在之后的帧级初始化和LCU级初始化可能会用到：

1）m_targetBits:序列的目标总比特；这个计算公式我认为应该这么写比较容易理解：

        m_targetBits  = [(int64_t)m_totalFrames / (int64_t)m_frameRate ]* (int64_t)m_targetRate ;即总帧数先除以帧率，求得传输所有帧需要的总秒数，再乘以目标码率(单位是bps)，即得序列的总目标比特数。

2）m_seqTargetBpp：每帧的每像素被分到的目标比特数；序列的目标比特率除以帧率，求得每帧的比特数，再除以像素总数，即得每像素目标比特。

3）m_averageBits：每帧的目标比特数。

道外二蹄脚
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
vtm编码划分_VTM码率控制——代码学习三
weixin_34901508的博客
01-13 557
文章目录码率分配GOP码率分配int EncRCGOP::xEstGOPTargetBits( EncRCSeq* encRCSeq, int GOPSize ){int realInfluencePicture = min( g_RCSmoothWindowSize, encRCSeq->getFramesLeft() );int averageTargetBitsPerPic = (in...
VTM配置
qq_41902850的博客
03-16 515
VTM配置encoderApp/decoder等添加cfg文件更改Encoder/Decoder等中属性-调试-命令参数&工作目录修改第一步添加cfg文件中的I/O配置 encoderApp/decoder等添加cfg文件 更改Encoder/Decoder等中属性-调试-命令参数&工作目录 替换：Ctrl/Command + G 修改第一步添加cfg文件中的I/O配置 ...
VTM码率控制——代码学习一，码率控制流程
Aidoneus_y
07-01 2840
码率控制初始化 -EncApp::encode()调用 EncApp::xcreatedLib() 调用 EncLib::create () : 调用 m_cRateCtrl.init() EncApp::encode()调用EncLib::encode，调用initRCGOP(m_iNumPicRcvd) EncLib::encode调用EncGop::compressGOP()，调用in...
VTM码率控制——代码学习三
Aidoneus_y
07-01 767
文章目录码率分配GOP码率分配帧级码率分配LCU码率分配 码率分配 GOP码率分配 int EncRCGOP::xEstGOPTargetBits( EncRCSeq* encRCSeq, int GOPSize ) { int realInfluencePicture = min( g_RCSmoothWindowSize, encRCSeq->getFramesLeft() ); ...
VTM码率控制——代码学习四
Aidoneus_y
07-01 722
文章目录码率分配参数更新帧之后的更新LCU后的更新 码率分配参数更新 帧之后的更新 void EncRCPic::updateAfterPicture( int actualHeaderBits, int actualTotalBits, double averageQP, double averageLambda, bool isIRAP) { m_picActualHeaderBits =...
VTM码率控制——代码学习二
Aidoneus_y
07-01 952
文章目录码率控制的各级初始化函数码率控制模块初始化GOP码率控制初始化帧级码率控制初始化 码率控制的各级初始化函数 码率控制模块初始化 void RateCtrl::init(int totalFrames, int targetBitrate, int frameRate, int GOPSize, int picWidth, int picHeight, int LCUWidth, int L...
VVCSoftware_VTM-VTM-11.0
04-14
【描述】中的“VVCSoftware_VTM-VTM-11.0”表明这是一个关于VVC编码器的软件版本，版本号11.0意味着这是该软件的一个更新迭代，通常包含了性能优化、错误修复和新特性。 【标签】"编码"指明了讨论的主要领域，即...
电源技术中的Vicor推出适合伺服器应用的130A VTM电压转换模块
11-08
Vicor公司VI晶片业务部公布， 新的一个电压转换模块(VTM)已经批量生产。 VTM采用正弦振幅转换 (SAC) 技术， 显着地改善伺服器供电系统的性能。 利用VIV0005TFJ与上端的预稳压模块PRM ， 可驱动低电压、高电流的...
VVCSoftware_VTM-VTM-5.0.zip
05-18
2019年五月初旬新发布的VVC的参考软件--VTM5.0，其中新添加了帧内帧间预测的新技术，改动较大，还有滤波的一些技术，同时也取消和禁用了一些技术以降低复杂度和保证统一性，让代码看起来更漂亮，这应该是VVC标准发展...
vtm_usage_VTM_
09-29
VTM，全称Virtual Terminal Machine（虚拟终端机），是一种在软件层面上模拟物理终端的技术。在现代计算机系统中，VTM扮演着重要的角色，尤其是在多任务和远程访问场景下。这份名为"vtm_usage.pdf"的文档，想必详细...
ICIP2020:VVC码率控制
热门推荐
Dillon2015的博客
11-05 4万+
本文内容来自ICIP 2020的文章《RATE CONTROL FOR VERSATILE VIDEO CODING》 该文章主要是通过对skip块的分析提出了RD参数的更新策略和帧级码率分配的质量依赖因子。由于VVC增加了很多新的技术尤其是帧间预测技术，使得很多块能很好的预测从而变成skip块其残差为0。 RD参数更新 码率控制问题最终可以转化为公式（1）有约束优化问题， 其中lambda是拉格朗日乘子，它是RD曲线的切线，在数学上表示R(D)函数的导数。 VVC中仍然使用R-...
ICME2021：基于机器学习的VVC帧内编码码率控制
Dillon2015的博客
07-07 3万+
本文来自ICME论文《MACHINE LEARNING-BASED RATE DISTORTION MODELING FOR VVC/H.266INTRA-FRAME 》 文章提出利用4种传统机器学习模型构建VVC帧内编码帧的RD模型。 RD模型 Fig.1是整个算法的流程。首先，从输入序列提取特征。然后，利用模型调整帧内编码帧的RDO。重复以上过程直到整个序列编码完。 RDO可以描述为在给定码率下使得失真最小，如下式， 在构建RD模型时除了要考虑码率，还需要考虑视频内容。本文提...
VVC码率控制中的质量依赖因子QDF
Dillon2015的博客
08-09 1万+
其中VTM中的码控主要做了两处改进，其一是在更新帧级参数时将skip和非skip区域区分开，各自单独更新，其二是改进了码控参数的更新策略，具体可参考提案JVET-K0390。以VTM3.0作为实验平台，提案方法和JVET-K0390中的码控方案相比，在RA配置下YUV的BD-Rate分别为-0.34%/-3.45%/-3.02%，如表2所示。通过实验发现，QDF和图像skip块比例间有很强的关系，根据实验发现QDF和skip比例存在下面的线性关系，Wi表示第i帧的权重，它由以它为参考的帧的QDF决定，...
ICASSP2020：VVC帧内码率控制二次模型
Dillon2015的博客
12-15 4万+
本文来自ICASSP2020论文《INTRA FRAME RATE CONTROL FOR VERSATILE VIDEO CODING WITH QUADRATIC RATE-DISTORTION MODELLING》 本文在VVC中提出了新的二次R-D模型，在VTM2.0平台帧内编码模式下相对于默认码率控制算法在相似控制精度下可达到0.77% BD-BR。 R-D模型 VVC中传统的RD模型 VVC中RD模型是双曲线模型， 其中失真D用MSE度量，码率R用bpp(bit pe...
H.266/VVC相关技术学习笔记5：视频编码中的码率控制的原理和目的
Peter_Red_Boy的博客
05-26 3451
很多学习视频编码的同学一定接触过码率控制这么一个学术名词 今天就给大家简单通俗的介绍一下关于码率控制的相关理论和其在视频编码中的作用 一般视频压缩技术中，为了提高压缩效率，常见的视频压缩技术（如MPEG ， H.264，H.265 ）都采用了变长编码，所以一个视频序列经过压缩编码之后所得到的码流是变速率的，即每帧编码所用的比特数是不相等的。图 1 所示为用MPEG-4 编码器和固定量化步长 30 ...
VVC码率控制改进
Dillon2015的博客
08-16 1万+
在VTM中，LD和RA配置的GOP size分别为32和8，固定SW不适合当前配置和将来扩展，因为提案根据GOP size和IntraPeriod(IP)计算SW，本文来自提案JVET-Y0105 《An improved VVC rate control scheme》，提案对VVC的码率控制做了一些改进，主要包括三部分，第一，CTU级的skip和非skip块码率分配。默认的RD模型无法精准描述skip块的特征，因此提案对skip和非skip块单独处理，首先，skip CTU的码率计算如下，......
HEVC/VVC中R-Lambda码率控制算法原理
Aidoneus_y
06-26 4653
文章目录1. 比特分配1.1 GOP级比特分配1.2 帧级比特分配1.3 LCU级比特分配2. 码率控制2.1 λ的计算和更新2.2 参数QP的确定 VVC中码率控制算法沿用了HEVC中经典的R-λ码率控制模型，R-λ由中科大的李斌博士提出（详情参考JCTVC-K0103）。R-λ模型的基础为视频编码中 R（比特 bpp）和 D（失真 MSE）之间的双曲线模型，即 D(R)=CR−KD(R) = ...
VVC/VTM：VTM运行编解码参数配置
Moomin的博客
05-12 5214
根据下面的博文下载VVC参考软件：https://blog.csdn.net/baidu_28446365/article/details/80308724 其中cfg文件夹中包含如下内容 其中蓝色框中的分别为AI、LDP、LDB、RA模式下的配置文件，主要对不同情况下的运行参数进行规定（包括工具的开关、尺寸的大小、量化参数等）； 红色框中是每个视频序列的配置文件，主要对视频序列的信息进行说明，...
VTM如何开启码率控制
最新发布
07-28
要在VTM（Versatile Video Coding Test Model）中启用码率控制，您可以按照以下步骤进行操作： 1. 打开VTM的源代码文件夹。 2. 导航到源代码文件夹中的EncoderLib目录，找到EncoderCfg.cpp文件。 3. 打开...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值