H.266/VVC代码学习:xCheckRDCostInter函数

于 2021-07-01 17:41:23 发布
阅读量1.5k 收藏 7
点赞数 2
分类专栏： VVC/H.266 文章标签： 视频编码 H.266/VVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigDream123/article/details/118391630
版权

xCheckRDCostInter函数主要是用来检查inter模式的，包括常规AMVP模式和Affine AMVP模式。该函数主要是通过调用predInterSearch实现对常规AMVP模式和Affine AMVP模式检查的，其调用关系如下所示：

在xCheckRDCostInter函数，遍历所有的BCW权重，对于每个BCW权重，调用predInterSearch找到最优的运动信息，并通过xEncodeInterResidual对预测残差进行变换量化。最后，通过xCalDebCost函数计算去块滤波后最终的Cost。

代码及注释如下：（基于VTM10.0）

void EncCu::xCheckRDCostInter( CodingStructure *&tempCS, CodingStructure *&bestCS, Partitioner &partitioner, const EncTestMode& encTestMode )
{
  tempCS->initStructData( encTestMode.qp );

  m_pcInterSearch->setAffineModeSelected(false);

  if( tempCS->slice->getCheckLDC() )
  {
    m_bestBcwCost[0] = m_bestBcwCost[1] = std::numeric_limits<double>::max();
    m_bestBcwIdx[0] = m_bestBcwIdx[1] = -1;
  }

  m_pcInterSearch->resetBufferedUniMotions();
  // 判断你是否使用BCW，如果是B帧且开启BCW，则BCW待测数目为5，否则为1
  int bcwLoopNum = (tempCS->slice->isInterB() ? BCW_NUM : 1); 
  bcwLoopNum = (tempCS->sps->getUseBcw() ? bcwLoopNum : 1);

  if( tempCS->area.lwidth() * tempCS->area.lheight() < BCW_SIZE_CONSTRAINT )
  {
    bcwLoopNum = 1; //BCW用于宽度*高度大于等于256的CU
  }

  double curBestCost = bestCS->cost; //当前最佳的Cost
  double equBcwCost = MAX_DOUBLE;

  m_bestModeUpdated = tempCS->useDbCost = bestCS->useDbCost = false;

  // 遍历BCW所有权重
  for( int bcwLoopIdx = 0; bcwLoopIdx < bcwLoopNum; bcwLoopIdx++ )
  {
    if( m_pcEncCfg->getUseBcwFast() ) //BCW快速算法
    {
      auto blkCache = dynamic_cast< CacheBlkInfoCtrl* >(m_modeCtrl);

      if( blkCache )
      {
        bool isBestInter = blkCache->getInter(bestCS->area);
        uint8_t bestBcwIdx = blkCache->getBcwIdx(bestCS->area);

        if( isBestInter && g_BcwSearchOrder[bcwLoopIdx] != BCW_DEFAULT && g_BcwSearchOrder[bcwLoopIdx] != bestBcwIdx )
        {
          continue;
        }
      }
    }
    if( !tempCS->slice->getCheckLDC() )
    {
      if( bcwLoopIdx != 0 && bcwLoopIdx != 3 && bcwLoopIdx != 4 )
      {
        continue;
      }
    }

  CodingUnit &cu      = tempCS->addCU( tempCS->area, partitioner.chType );

  partitioner.setCUData( cu );
  cu.slice            = tempCS->slice;
  cu.tileIdx          = tempCS->pps->getTileIdx( tempCS->area.lumaPos() );
  cu.skip             = false;
  cu.mmvdSkip = false;
//cu.affine
  cu.predMode         = MODE_INTER;
  cu.chromaQpAdj      = m_cuChromaQpOffsetIdxPlus1;
  cu.qp               = encTestMode.qp;
  CU::addPUs( cu );

  cu.BcwIdx = g_BcwSearchOrder[bcwLoopIdx];
  uint8_t bcwIdx = cu.BcwIdx;
  bool  testBcw = (bcwIdx != BCW_DEFAULT);

  m_pcInterSearch->predInterSearch( cu, partitioner ); //搜索最佳的帧间预测

  bcwIdx = CU::getValidBcwIdx(cu);
  if( testBcw && bcwIdx == BCW_DEFAULT ) // Enabled Bcw but the search results is uni. 已启用Bcw，但搜索结果为uni。
  {
    tempCS->initStructData(encTestMode.qp);
    continue;
  }
  CHECK(!(testBcw || (!testBcw && bcwIdx == BCW_DEFAULT)), " !( bTestBcw || (!bTestBcw && bcwIdx == BCW_DEFAULT ) )");

  bool isEqualUni = false;
  if( m_pcEncCfg->getUseBcwFast() )
  {
    if( cu.firstPU->interDir != 3 && testBcw == 0 )
    {
      isEqualUni = true;
    }
  }

  xEncodeInterResidual( tempCS, bestCS, partitioner, encTestMode, 0
                        , 0
                        , &equBcwCost
  ); //编码残差

  if( g_BcwSearchOrder[bcwLoopIdx] == BCW_DEFAULT )
    m_pcInterSearch->setAffineModeSelected((bestCS->cus.front()->affine && !(bestCS->cus.front()->firstPU->mergeFlag)));

  tempCS->initStructData(encTestMode.qp);

  double skipTH = MAX_DOUBLE;
  skipTH = (m_pcEncCfg->getUseBcwFast() ? 1.05 : MAX_DOUBLE);
  if( equBcwCost > curBestCost * skipTH )
  {
    // 快速算法
    break;
  }

  if( m_pcEncCfg->getUseBcwFast() )
  {
    if( isEqualUni == true && m_pcEncCfg->getIntraPeriod() == -1 )
    {
      break;
    }
  }
  if( g_BcwSearchOrder[bcwLoopIdx] == BCW_DEFAULT && xIsBcwSkip(cu) && m_pcEncCfg->getUseBcwFast() )
  {
    break;
  }
 }  // for( UChar bcwLoopIdx = 0; bcwLoopIdx < bcwLoopNum; bcwLoopIdx++ )
  if ( m_bestModeUpdated && bestCS->cost != MAX_DOUBLE )
  {
    xCalDebCost( *bestCS, partitioner );
  }
}

xCheckRDCostInterIMV和xCheckRDCostInter函数类似，不同的是，xCheckRDCostInterIMV函数会提前设置cu.imv（具体细节没看懂），cu.imv的作用如下：

  • 对于常规AMVP模式，imv的值为0 1 2 3分别代表1/4像素精度、整像素精度、4像素精度和1/2像素精度
  • 对于Affine AMVP模式，imv的值为0 1 2分别代表1/4像素精度、1/16像素精度和整像素精度
 const MvPrecision Mv::m_amvrPrecision[4] = { MV_PRECISION_QUARTER, MV_PRECISION_INT, MV_PRECISION_4PEL, MV_PRECISION_HALF }; // for cu.imv=0, 1, 2 and 3
 const MvPrecision Mv::m_amvrPrecAffine[3] = { MV_PRECISION_QUARTER, MV_PRECISION_SIXTEENTH, MV_PRECISION_INT }; // for cu.imv=0, 1 and 2
 
bool EncCu::xCheckRDCostInterIMV(CodingStructure *&tempCS, CodingStructure *&bestCS, Partitioner &partitioner, const EncTestMode& encTestMode, double &bestIntPelCost)
{
  int iIMV = int( ( encTestMode.opts & ETO_IMV ) >> ETO_IMV_SHIFT ); //设置IMV
  m_pcInterSearch->setAffineModeSelected(false);
  // Only Half-Pel, int-Pel, 4-Pel and fast 4-Pel allowed
  CHECK(iIMV < 1 || iIMV > 4, "Unsupported IMV Mode");
  const bool testAltHpelFilter = iIMV == 4;
  // Fast 4-Pel Mode

  m_bestModeUpdated = tempCS->useDbCost = bestCS->useDbCost = false;

  EncTestMode encTestModeBase = encTestMode;                                        // copy for clearing non-IMV options
  encTestModeBase.opts        = EncTestModeOpts( encTestModeBase.opts & ETO_IMV );  // clear non-IMV options (is that intended?)

  tempCS->initStructData( encTestMode.qp );

  m_pcInterSearch->resetBufferedUniMotions();
  int bcwLoopNum = (tempCS->slice->isInterB() ? BCW_NUM : 1);
  bcwLoopNum = (tempCS->slice->getSPS()->getUseBcw() ? bcwLoopNum : 1);

  if( tempCS->area.lwidth() * tempCS->area.lheight() < BCW_SIZE_CONSTRAINT )
  {
    bcwLoopNum = 1;
  }

  bool validMode = false;
  double curBestCost = bestCS->cost;
  double equBcwCost = MAX_DOUBLE;

  for( int bcwLoopIdx = 0; bcwLoopIdx < bcwLoopNum; bcwLoopIdx++ )
  {
    if( m_pcEncCfg->getUseBcwFast() )
    {
      auto blkCache = dynamic_cast< CacheBlkInfoCtrl* >(m_modeCtrl);

      if( blkCache )
      {
        bool isBestInter = blkCache->getInter(bestCS->area);
        uint8_t bestBcwIdx = blkCache->getBcwIdx(bestCS->area);

        if( isBestInter && g_BcwSearchOrder[bcwLoopIdx] != BCW_DEFAULT && g_BcwSearchOrder[bcwLoopIdx] != bestBcwIdx )
        {
          continue;
        }
      }
    }

    if( !tempCS->slice->getCheckLDC() )
    {
      if( bcwLoopIdx != 0 && bcwLoopIdx != 3 && bcwLoopIdx != 4 )
      {
        continue;
      }
    }

    if( m_pcEncCfg->getUseBcwFast() && tempCS->slice->getCheckLDC() && g_BcwSearchOrder[bcwLoopIdx] != BCW_DEFAULT
      && (m_bestBcwIdx[0] >= 0 && g_BcwSearchOrder[bcwLoopIdx] != m_bestBcwIdx[0])
      && (m_bestBcwIdx[1] >= 0 && g_BcwSearchOrder[bcwLoopIdx] != m_bestBcwIdx[1]))
    {
      continue;
    }

  CodingUnit &cu = tempCS->addCU( tempCS->area, partitioner.chType );

  partitioner.setCUData( cu );
  cu.slice            = tempCS->slice;
  cu.tileIdx          = tempCS->pps->getTileIdx( tempCS->area.lumaPos() );
  cu.skip             = false;
  cu.mmvdSkip = false;
//cu.affine
  cu.predMode         = MODE_INTER;
  cu.chromaQpAdj      = m_cuChromaQpOffsetIdxPlus1;
  cu.qp               = encTestMode.qp;

  CU::addPUs( cu );

  if (testAltHpelFilter)
  {
    cu.imv = IMV_HPEL;
  }
  else
  {
    cu.imv = iIMV == 1 ? IMV_FPEL : IMV_4PEL;
  }
  // const MvPrecision Mv::m_amvrPrecision[4] = { MV_PRECISION_QUARTER, MV_PRECISION_INT, MV_PRECISION_4PEL, MV_PRECISION_HALF }; // for cu.imv=0, 1, 2 and 3
  // const MvPrecision Mv::m_amvrPrecAffine[3] = { MV_PRECISION_QUARTER, MV_PRECISION_SIXTEENTH, MV_PRECISION_INT }; // for cu.imv=0, 1 and 2
  bool testBcw;
  uint8_t bcwIdx;
  bool affineAmvrEanbledFlag = !testAltHpelFilter && cu.slice->getSPS()->getAffineAmvrEnabledFlag();

  cu.BcwIdx = g_BcwSearchOrder[bcwLoopIdx];
  bcwIdx = cu.BcwIdx;
  testBcw = (bcwIdx != BCW_DEFAULT);

  cu.firstPU->interDir = 10;

  m_pcInterSearch->predInterSearch( cu, partitioner );

  if ( cu.firstPU->interDir <= 3 )
  {
    bcwIdx = CU::getValidBcwIdx(cu);
  }
  else
  {
    return false;
  }

  if( m_pcEncCfg->getMCTSEncConstraint() && ( ( cu.firstPU->refIdx[L0] < 0 && cu.firstPU->refIdx[L1] < 0 ) || ( !( MCTSHelper::checkMvBufferForMCTSConstraint( *cu.firstPU ) ) ) ) )
  {
    // Do not use this mode
    tempCS->initStructData( encTestMode.qp );
    continue;
  }
  if( testBcw && bcwIdx == BCW_DEFAULT ) // Enabled Bcw but the search results is uni.
  {
    tempCS->initStructData(encTestMode.qp);
    continue;
  }
  CHECK(!(testBcw || (!testBcw && bcwIdx == BCW_DEFAULT)), " !( bTestBcw || (!bTestBcw && bcwIdx == BCW_DEFAULT ) )");

  bool isEqualUni = false;
  if( m_pcEncCfg->getUseBcwFast() )
  {
    if( cu.firstPU->interDir != 3 && testBcw == 0 )
    {
      isEqualUni = true;
    }
  }

  if ( !CU::hasSubCUNonZeroMVd( cu ) && !CU::hasSubCUNonZeroAffineMVd( cu ) )
  {
    if (m_modeCtrl->useModeResult(encTestModeBase, tempCS, partitioner))
    {
      std::swap(tempCS, bestCS);
      // store temp best CI for next CU coding
      m_CurrCtx->best = m_CABACEstimator->getCtx();
    }
    if ( affineAmvrEanbledFlag )
    {
      tempCS->initStructData( encTestMode.qp );
      continue;
    }
    else
    {
      return false;
    }
  }

  xEncodeInterResidual( tempCS, bestCS, partitioner, encTestModeBase, 0
                        , 0
                        , &equBcwCost
  );

  if( cu.imv == IMV_FPEL && tempCS->cost < bestIntPelCost )
  {
    bestIntPelCost = tempCS->cost;
  }
  tempCS->initStructData(encTestMode.qp);

  double skipTH = MAX_DOUBLE;
  skipTH = (m_pcEncCfg->getUseBcwFast() ? 1.05 : MAX_DOUBLE);
  if( equBcwCost > curBestCost * skipTH )
  {
    break;
  }

  if( m_pcEncCfg->getUseBcwFast() )
  {
    if( isEqualUni == true && m_pcEncCfg->getIntraPeriod() == -1 )
    {
      break;
    }
  }
  if( g_BcwSearchOrder[bcwLoopIdx] == BCW_DEFAULT && xIsBcwSkip(cu) && m_pcEncCfg->getUseBcwFast() )
  {
    break;
  }
  validMode = true;
 } // for( UChar bcwLoopIdx = 0; bcwLoopIdx < bcwLoopNum; bcwLoopIdx++ )

  if ( m_bestModeUpdated && bestCS->cost != MAX_DOUBLE )
  {
    xCalDebCost( *bestCS, partitioner );
  }

  return tempCS->slice->getSPS()->getAffineAmvrEnabledFlag() ? validMode : true;
}

涵小呆
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VTM10.0代码学习17：xCheckRDCostInter()&xCheckRDCostInterIMV()
hjhyxq2014的博客
06-01 1326
此系列是为了记录自己学习VTM10.0的过程，目前正在看编码端。主要的参考文档有JVET-S2001-vH和JVET-S2002-v1。由于本人水平有限，出现的错误恳请大家指正。如果觉得我的文章对您有帮助的话，不妨点赞收藏加关注，谢谢！！ 上次更新博客已是两个月前了，这两个月被internship反复折磨，但收获也是不少。现在终于结束了！！想到的第一件事就是赶快更博客，大家千万别取关/(ㄒoㄒ)/~。从这篇博客就开始讲有关帧间的内容了，不知道大家还记不记得之前的博客(VTM10.0代码学习11)，末尾.
HEVC参考软件HM源码分析--帧间预测（2）--xCheckRDCostInter
qq_40934347的博客
10-27 487
这篇文章对xCompressCU中的一个核心子函数xCheckRDCostInter函数进行介绍。对xCompressCU函数的详细介绍见楼主上一篇博客 https://blog.csdn.net/qq_40934347/article/details/102716826. 函数作用： xCompressCU函数完成的是从众多帧间划分模式、以及帧内、PCM模式中选择最优CU模式的工作，而对于每一个...
HM16.0之帧内模式——xCheckRDCostIntra()函数
weixin_30768175的博客
06-08 480
参考：https://blog.csdn.net/nb_vol_1/article/category/6179825/1? 1、源代码： Void TEncCu::xCheckRDCostIntra( TComDataCU *&rpcBestCU, TComDataCU *&rpcTempCU, ...
VVC/JEM代码学习18：xCheckRDCostInter
小小柴的博客
04-01 806
在xCheckRDCostMerge2N*2N执行完，如果m_useEarlySkipDetection==false,则继续执行xCheckRDCostInter函数。（如果m_useEarlySkipDetection==true,则此函数在帧间的最开始执行）#if AMP_MRG Void TEncCu::xCheckRDCostInter( TComDataCU*&amp; rpcBest...
HEVC代码学习37：帧内预测代码整体学习
慢慢积累
01-22 3599
最近一直在看变换部分的东西，由于很多变换模式是针对帧内预测模式设计的，来简单学习一下帧内预测流程。通过之前xCompressCU的学习，我们知道了帧内、帧间的入口函数都在xCompressCU中，下面回顾一下xCompressCU函数。xCompressCUxCompressCU主要作用是完成块划分，确定最优预测模式，其流程为： 1.帧间预测xCheckRDCostInter、xCheckRDCo
python 修饰器
u013015430的专栏
12-04 620
python 修饰器。 先看下面的结果。  在不调用run的情况下， 输出1。 用test("my_test")  修饰 run 函数， 修饰的实际效果如下 1）先执行 test("my_test") 函数， 结果是impl 函数， （所以再不调用run的情况下，会有输出) 2）再把 run 函数做为参数给impl 函数， 结果是 inter 函数。 在调用run的情况下，
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件
04-27
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件是视频编码领域的一项重要工具，它基于最新的视频编码标准——Versatile Video Coding（VVC），也被称为H.266。这个软件包的发布是为了支持开发者、研究人员以及业界...
最新通用视频编码标准H.266VVC.pdf
11-28
H.266 VVC 标准中文版
VVC H.266 360P 60FPS测试片源
最新发布
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10s 0ms BitRate/String : 507 Kbps BitRate_Maximum/String : 692 ...
最新视频编码标准（H.266）VVC-Draft10版本，预发布版本！
02-24
2. **增强的预测技术**：H.266/VVC采用了新的预测模式，包括角度自适应预测、跨块预测和基于深度学习的预测等。这些模式能更准确地估计像素的运动和变化，减少编码过程中的信息损失。 3. **变换和量化优化**：H.266...
VTM块划分代码_块划分；_H.266_statementzbb_VVC_
10-03
3. **块大小的灵活性**：H.266/VVC支持从最小4x4到最大128x128的块大小，甚至允许非矩形的四边形划分。这种灵活性有助于更好地适应图像内容的细节变化。 4. **变换和量化**：块划分后的像素值会经过离散余弦变换...
VTM1.0代码阅读：predInterSearch函数
矛盾统一
12-26 707
predInterSearch函数在xCheckRDCostInter中被调用，用来获取inter_ME模式下的最优inter_ME运动信息。predInterSearch函数是inter_ME模式的最主要实现函数。 函数首先对单向预测，分别对L0和L1的所有帧进行AMVP、ME，得到各个参考帧下的各种最优的运动信息； 再进行双向预测，双向预测用到了单向时得到的各帧的各种运动信息，通过4次迭代，找...
H.266/VVC代码学习13：VTM4.0中的CU层操作（compressCtu 、 xCompressCU）
时间有泪
03-22 5565
从H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）我们了解到了视频最基本的操作块为CTU，现在我们进一步学习CU层的操作。有两个十分重要的函数： 1 compressCtu: 是对encodeCtu中拿到的单个ctu进行操作，是进行CU划分预测等处理的入口。内部一共会调用两次 xCompressCU ，一次是对亮度进行处理，一次是对色度进行处理。可见compre...
BMS/VTM代码学习：xCompressCU
慢慢积累
09-26 3767
找工作基本结束，收心回来看266了，从xCompressCU开始吧。在初学者阶段写过HEVC代码学习11：xCompressCU函数，当时实际看的一知半解，作为参考吧。 BMS/VTM中xCompressCU代码精简了很多，看起来容易多了，主要流程为： 1.初始化：设置可用模式、上下文模型等。 2.尝试帧间、帧内各种可用预测模式，当遍历完所有可用模式后，调用xCheckModeSplit进行划分，...
H.266/VVC代码学习4：VTM代码整体结构及最上层函数
时间有泪
03-02 7069
最近在做一些较上层的内容，从老师和师兄师姐的博客里学到了很多，对VTM代码有了进一步的理解。VTM4.0代码整体结构如下，并会后面分别介绍几个主要函数的作用。 EncSlice::encodeCtus 大体操作：以CTU为单位，对划分后的内容进行熵编码。 每个slice为一帧。一帧中对所有CTU（128*128）都进行编码（for循环每个CTU，分别调用compressCtu函数），具体来说主要...
Search::predInterSearch()
workspace
05-01 894
/* find the best inter prediction for each PU of specified mode 为CU中的每一个PU找到最佳inter pred 过程： 1.遍历每一个PU，以PU为计算单位 1.为运动估计加载PU的YUV，初始化失真函数指针，设置运动估计方法及下采样等级 2.进行merge估计，得到最优merge备选MV及其cost ...
H.266/VVC代码学习笔记15：VTM6.0中的xCheckRDCostMergeTriangle2Nx2N（）函数
Peter_Red_Boy的博客
10-01 1205
VTM6.0中xCheckRDCostMergeTriangle2Nx2N（）函数是帧间预测技术中Merge模式中TPM技术的主函数的入口，想要了解TPM在代码中的实现，这个函数是啃定了，我只是大概看了一下该函数的大致上的流程以及其中三角Merge列表的构建、加权预测的大致过程。今天将所看的代码分享给大家，如过代码中有理解错的地方，还请指正，谢谢大家~ 还是老套路，用文字过一下该函数的大致流程，再...
H.266/VVC代码学习:xCheckRDCostMerge2Nx2N函数
BigDream123的博客
06-05 1424
xCheckRDCostMerge2Nx2N函数是用来选出Merge模式中最佳的候选MV，根据常规Merge模式、带有运动矢量差的Merge模式(MMVD)以及CIIP模式产生的预测值和原始值得SATD Cost，选出最佳的运动信息。 主要分为以下过程： ① 获取Merge模式候选列表 首先通过getInterMergeCandidates函数和getInterMMVDMergeCandidates函数分别获取常规Merge模式和MMVD模式的候选列表，常规Merge的候选列表推导参考：扩展的Merg
VVC代码 BMS 帧内预测学习之三：67个角度预测 predIntraAng()
Veronica.。oO的博客
08-16 1213
predIntraAng() void IntraPrediction::predIntraAng( const ComponentID compId, PelBuf &amp;amp;amp;piPred, const PredictionUnit &amp;amp;amp;pu, const bool useFilteredPredSamples ) { const ComponentID compID ...
新一代通用视频编码h.266/vvc:原理、标准与实现电子书
01-04
新一代通用视频编码H.266/VVC是一种用于视频压缩和编码的标准，旨在提供更高的压缩效率和更好的视频质量。该标准基于先前的H.265/HEVC标准，但引入了许多新的技术和算法以提高性能。H.266/VVC的主要原理是通过有效地利用视频中的空间和时间相关性来减少数据量，从而实现更高的压缩比和更好的视觉质量。 H.266/VVC标准主要包括两个方面：编码器和解码器。编码器负责将原始视频数据压缩成更小的数据流，而解码器负责将压缩的数据流解码成可视的视频。H.266/VVC标准还定义了一系列的编码器和解码器工具，例如运动估计、变换、量化和熵编码等，以帮助实现更高效的视频压缩和编码。 实现H.266/VVC标准的电子书涵盖了该标准的原理、技术细节和实际应用。电子书的内容包括H.266/VVC标准的基本原理和算法、编码器和解码器的设计和实现、性能评估和比较、以及未来的发展方向。此外，电子书还介绍了如何使用已有的编码和解码工具来实现H.266/VVC标准，并提供了一些实际的示例和案例分析，以帮助读者更好地理解和应用该标准。 总的来说，H.266/VVC标准的电子书涵盖了该标准的理论基础、实际应用和技术实现，对于对视频编码和压缩感兴趣的读者来说是一本很有价值的参考资料。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值