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

已于 2022-09-02 09:59:55 修改
阅读量1k 收藏 4
点赞数
分类专栏： VVC/H.266 文章标签： 视频编码
于 2021-06-29 21:24:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigDream123/article/details/118343878
版权

xPatternSearchFracDIF函数是用于由xMotionEstimation函数调用，进行亚像素运动估计。

  1. 首先进行 1/2 像素插值，以整像素最佳MV为搜索起点，搜索包含当前点在内的 9 个 1/2 像素点；
  2. 再进行 1/4 像素插值，其中 1/4 像素插值是在上一轮最优的 1/2 像素最优点附近插值，搜索包括当前最优 1/2 像素点在内的 9 个1/4 像素点。

代码及注释如下：

void InterSearch::xPatternSearchFracDIF(
  const PredictionUnit& pu,
  RefPicList            eRefPicList,
  int                   iRefIdx,
  IntTZSearchStruct&    cStruct,
  const Mv&             rcMvInt,
  Mv&                   rcMvHalf,
  Mv&                   rcMvQter,
  Distortion&           ruiCost
)
{

  //  Reference pattern initialization (integer scale) 到预测块像素位置的偏移
  int         iOffset    = rcMvInt.getHor() + rcMvInt.getVer() * cStruct.iRefStride;
  CPelBuf cPatternRoi(cStruct.piRefY + iOffset, cStruct.iRefStride, *cStruct.pcPatternKey); //当前块的整数位置预测像素
  if (m_skipFracME)
  {
    Mv baseRefMv(0, 0);
    rcMvHalf.setZero();
    m_pcRdCost->setCostScale(0);
    xExtDIFUpSamplingH(&cPatternRoi, cStruct.useAltHpelIf);
    rcMvQter = rcMvInt;   rcMvQter <<= 2;    // for mv-cost
    ruiCost = xPatternRefinement(cStruct.pcPatternKey, baseRefMv, 1, rcMvQter, !pu.cs->slice->getDisableSATDForRD());
    return;
  }


  if (cStruct.imvShift > IMV_FPEL || (m_useCompositeRef && cStruct.zeroMV))
  {
    m_pcRdCost->setDistParam(m_cDistParam, *cStruct.pcPatternKey, cStruct.piRefY + iOffset, cStruct.iRefStride, m_lumaClpRng.bd, COMPONENT_Y, 0, 1, m_pcEncCfg->getUseHADME() && !pu.cs->slice->getDisableSATDForRD());
    ruiCost = m_cDistParam.distFunc( m_cDistParam );
    ruiCost += m_pcRdCost->getCostOfVectorWithPredictor( rcMvInt.getHor(), rcMvInt.getVer(), cStruct.imvShift );
    return;
  }

  //  Half-pel refinement 1/2像素细化
  m_pcRdCost->setCostScale(1);
  xExtDIFUpSamplingH(&cPatternRoi, cStruct.useAltHpelIf);//1/2位置像素上采样

  rcMvHalf = rcMvInt;   rcMvHalf <<= 1;    // for mv-cost
  Mv baseRefMv(0, 0); //亚像素精度搜索匹配，得到1/2精度mv rcMvHalf
  // 此时 baseRefMv 为0，即搜索起点整像素最佳MV
  ruiCost = xPatternRefinement(cStruct.pcPatternKey, baseRefMv, 2, rcMvHalf, (!pu.cs->slice->getDisableSATDForRD()));

  //  quarter-pel refinement 1/4像素细化
  if (cStruct.imvShift == IMV_OFF)
  {
  m_pcRdCost->setCostScale( 0 );
  xExtDIFUpSamplingQ ( &cPatternRoi, rcMvHalf ); //1/4位置像素上采样
  baseRefMv = rcMvHalf; 
  baseRefMv <<= 1; // 放大到 1/2 像素精度

  rcMvQter = rcMvInt;    rcMvQter <<= 1;    // for mv-cost
  rcMvQter += rcMvHalf;  rcMvQter <<= 1; // 放大到 1/4 像素精度
  //亚像素精度搜索匹配，得到1/4精度mv rcMvQter，baseRefMv此时为 1/2 像素精度最佳偏移
  ruiCost = xPatternRefinement(cStruct.pcPatternKey, baseRefMv, 1, rcMvQter, (!pu.cs->slice->getDisableSATDForRD()));
  }
}

在进行插值时，先对整像素所在的行或者列进行插值；再在此基础上，对剩余亚像素位置进行插值，以下图为例：

这里写图片描述

1.对整数像素所在行或列进行插值。以A(0,0)点附近的亚像素点为例，a(0,0),b(0,0),c(0,0)可以用水平方向的整像素点计算得出，d(0,0),h(0,0),n(0,0)可以用垂直方向上的整像素点计算得出。
如1/4位置点a(0,0) = -A(-3,0) + 4A(-2,0) -10A(-1,0) + 58A(0,0) + 17A(1,0) - 5A(2,0) + A(3,0)
2.对剩余亚像素位置进行插值，使用步骤1中已计算得到的亚像素位置计算。
如e(0,0) = -a(-3,0) + 4a(-2,0) -10a(-1,0) + 58a(0,0) + 17a(1,0) - 5a(2,0) + a(3,0) >>6
注意，经过亚像素插值后所有像素点都放大了64倍，目的是在中间过程中保持一定精度，在后续的加权预测环节中，会被还原。


在代码实现中，是使用m_filteredBlockTmp[]和m_filteredBlock[][]变量存储插值后的像素块的。

1.m_filteredBlockTmp

m_filteredBlockTmp[]是临时变量，实际用于存储水平插值得到的各像素位置的YUV信息。[]中的数字指示水平插值的像素位置。

对参考图像进行水平插值，整像素位置直接复制给了m_filteredBlockTmp[0]，1/2像素位置插值后给了m_filteredBlockTmp[2]。
在1/4像素插值xExtDIFUpSamplingQ中类似，1/4和3/4像素位置水平插值后给了m_filteredBlockTmp[1]和m_filteredBlockTmp[3]。
2.m_filteredBlock

在做完水平插值之后，会进行垂直插值，得到最终的数据，存储与m_filteredBlock[][]中。m_filteredBlock[][]用来存储最终的插值数据。

m_filteredBlock中存储了不同插值位置的像素数据，第一个[]中的数字指示垂直插值位置，第二个指示水平插值位置。每个m_filteredBlock[ver][hor]的大小都是width*height，不同的索引组合代表不同插值位置得到的像素数据。

xExtDIFUpSamplingH函数主要进行1/2像素插值

/**
* \brief Generate half-sample interpolated block 生成半采样插值块
*
* \param pattern Reference picture ROI 模式参考图片ROI
* \param biPred    Flag indicating whether block is for biprediction 指示块是否用于biprediction的标志
*/
void InterSearch::xExtDIFUpSamplingH(CPelBuf* pattern, bool useAltHpelIf)
{
  const ClpRng& clpRng = m_lumaClpRng;
  int width      = pattern->width;
  int height     = pattern->height;
  int srcStride  = pattern->stride;

  int intStride = width + 1;
  int dstStride = width + 1;
  Pel *intPtr;
  Pel *dstPtr;
  int filterSize = NTAPS_LUMA; // 8
  int halfFilterSize = (filterSize>>1); // 4
  const Pel *srcPtr = pattern->buf - halfFilterSize*srcStride - 1;

  const ChromaFormat chFmt = m_currChromaFormat; //色度格式

  //水平整像素插值，结果存储在m_filteredBlockTmp[0]中
  m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, m_filteredBlockTmp[0][0], intStride, width + 1, height + filterSize, 0 << MV_FRACTIONAL_BITS_DIFF, false, chFmt, clpRng, 0, false, useAltHpelIf);
  if (!m_skipFracME)
  {
    //水平1/2像素插值，结果存储在m_filteredBlockTmp[2]中
    m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, m_filteredBlockTmp[2][0], intStride, width + 1, height + filterSize, 2 << MV_FRACTIONAL_BITS_DIFF, false, chFmt, clpRng, 0, false, useAltHpelIf);
  }

  intPtr = m_filteredBlockTmp[0][0] + halfFilterSize * intStride + 1;
  dstPtr = m_filteredBlock[0][0][0];
  //  水平整像素插值后的Y做垂直方向整像素插值，结果存储在m_filteredBlock[0][0]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width + 0, height + 0, 0 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng, 0, false, useAltHpelIf);
  if (m_skipFracME)
  {
    return;
  }

  intPtr = m_filteredBlockTmp[0][0] + (halfFilterSize - 1) * intStride + 1;
  dstPtr = m_filteredBlock[2][0][0];
  //水平整像素插值后的Y做垂直方向1/2像素插值，结果存储在m_filteredBlock[2][0]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width + 0, height + 1, 2 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng, 0, false, useAltHpelIf);

  intPtr = m_filteredBlockTmp[2][0] + halfFilterSize * intStride;
  dstPtr = m_filteredBlock[0][2][0];
  //水平1/2像素插值后的Y做垂直方向整像素插值，结果存储在m_filteredBlock[0][2]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width + 1, height + 0, 0 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng, 0, false, useAltHpelIf);

  intPtr = m_filteredBlockTmp[2][0] + (halfFilterSize - 1) * intStride;
  dstPtr = m_filteredBlock[2][2][0];
  //水平1/2像素插值后的Y做垂直方向1/2像素插值，结果存储在m_filteredBlock[2][2]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width + 1, height + 1, 2 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng, 0, false, useAltHpelIf);
}

 xExtDIFUpSamplingQ函数进行1/4像素插值

/**
* \brief Generate quarter-sample interpolated blocks
*
* \param pattern    Reference picture ROI
* \param halfPelRef Half-pel mv 1/2像素精度的MV
* \param biPred     Flag indicating whether block is for biprediction
*/
void InterSearch::xExtDIFUpSamplingQ( CPelBuf* pattern, Mv halfPelRef )
{
  const ClpRng& clpRng = m_lumaClpRng;
  int width      = pattern->width;
  int height     = pattern->height;
  int srcStride  = pattern->stride;

  Pel const* srcPtr;
  int intStride = width + 1;
  int dstStride = width + 1;
  Pel *intPtr;
  Pel *dstPtr;
  int filterSize = NTAPS_LUMA; // 8

  int halfFilterSize = (filterSize>>1); // 4

  int extHeight = (halfPelRef.getVer() == 0) ? height + filterSize : height + filterSize-1;

  const ChromaFormat chFmt = m_currChromaFormat;

  // Horizontal filter 1/4
  srcPtr = pattern->buf - halfFilterSize * srcStride - 1;
  intPtr = m_filteredBlockTmp[1][0];//将1/4位置像素存储在m_filteredBlockTmp[1]中
  if (halfPelRef.getVer() > 0)
  {
    srcPtr += srcStride;
  }
  if (halfPelRef.getHor() >= 0)
  {
    srcPtr += 1;
  }
  m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, intPtr, intStride, width, extHeight, 1 << MV_FRACTIONAL_BITS_DIFF, false, chFmt, clpRng);

  // Horizontal filter 3/4
  srcPtr = pattern->buf - halfFilterSize*srcStride - 1;
  intPtr = m_filteredBlockTmp[3][0];//将3/4位置像素存储在m_filteredBlockTmp[3]中
  if (halfPelRef.getVer() > 0)
  {
    srcPtr += srcStride;
  }
  if (halfPelRef.getHor() > 0)
  {
    srcPtr += 1;
  }
  m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, intPtr, intStride, width, extHeight, 3 << MV_FRACTIONAL_BITS_DIFF, false, chFmt, clpRng);

  // Generate @ 1,1
  intPtr = m_filteredBlockTmp[1][0] + (halfFilterSize-1) * intStride;
  dstPtr = m_filteredBlock[1][1][0];
  if (halfPelRef.getVer() == 0)
  {
    intPtr += intStride;
  }
  //水平1/4像素插值后的Y分量做垂直1/4像素插值，结果存储在m_filteredBlock[1][1]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);

  // Generate @ 3,1
  intPtr = m_filteredBlockTmp[1][0] + (halfFilterSize-1) * intStride;
  dstPtr = m_filteredBlock[3][1][0];
  //水平1/4像素插值后的Y分量做垂直3/4像素插值，结果存储在m_filteredBlock[3][1]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);

  if (halfPelRef.getVer() != 0)
  {
    // Generate @ 2,1
    intPtr = m_filteredBlockTmp[1][0] + (halfFilterSize - 1) * intStride;
    dstPtr = m_filteredBlock[2][1][0];
    if (halfPelRef.getVer() == 0)
    {
      intPtr += intStride;
    }
    //水平1/4像素插值后的Y分量做垂直1/2像素插值，结果存储在m_filteredBlock[2][1]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 2 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);

    // Generate @ 2,3
    intPtr = m_filteredBlockTmp[3][0] + (halfFilterSize - 1) * intStride;
    dstPtr = m_filteredBlock[2][3][0];
    if (halfPelRef.getVer() == 0)
    {
      intPtr += intStride;
    }
    //水平3/4像素插值后的Y分量做垂直1/2像素插值，结果存储在m_filteredBlock[2][3]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 2 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);
  }
  else
  {
    // Generate @ 0,1
    intPtr = m_filteredBlockTmp[1][0] + halfFilterSize * intStride;
    dstPtr = m_filteredBlock[0][1][0];
    //水平1/4像素插值后的Y分量做垂直整像素插值，结果存储在m_filteredBlock[0][1]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 0 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);

    // Generate @ 0,3
    intPtr = m_filteredBlockTmp[3][0] + halfFilterSize * intStride;
    dstPtr = m_filteredBlock[0][3][0];
    //水平3/4像素插值后的Y分量做垂直整像素插值，结果存储在m_filteredBlock[0][3]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 0 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);
  }

  if (halfPelRef.getHor() != 0)
  {
    // Generate @ 1,2
    intPtr = m_filteredBlockTmp[2][0] + (halfFilterSize - 1) * intStride;
    dstPtr = m_filteredBlock[1][2][0];
    if (halfPelRef.getHor() > 0)
    {
      intPtr += 1;
    }
    if (halfPelRef.getVer() >= 0)
    {
      intPtr += intStride;
    }
    //水平1/2像素插值后的Y分量做垂直1/4像素插值，结果存储在m_filteredBlock[1][2]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);

    // Generate @ 3,2
    intPtr = m_filteredBlockTmp[2][0] + (halfFilterSize - 1) * intStride;
    dstPtr = m_filteredBlock[3][2][0];
    if (halfPelRef.getHor() > 0)
    {
      intPtr += 1;
    }
    if (halfPelRef.getVer() > 0)
    {
      intPtr += intStride;
    }
    //水平1/2像素插值后的Y分量做垂直3/4像素插值，结果存储在m_filteredBlock[3][2]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);
  }
  else
  {
    // Generate @ 1,0
    intPtr = m_filteredBlockTmp[0][0] + (halfFilterSize - 1) * intStride + 1;
    dstPtr = m_filteredBlock[1][0][0];
    if (halfPelRef.getVer() >= 0)
    {
      intPtr += intStride;
    }
    //水平整像素插值后的Y分量做垂直1/4像素插值，结果存储在m_filteredBlock[1][0]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);

    // Generate @ 3,0
    intPtr = m_filteredBlockTmp[0][0] + (halfFilterSize - 1) * intStride + 1;
    dstPtr = m_filteredBlock[3][0][0];
    if (halfPelRef.getVer() > 0)
    {
      intPtr += intStride;
    }
    //水平整像素插值后的Y分量做垂直3/4像素插值，结果存储在m_filteredBlock[3][0]中
    m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);
  }

  // Generate @ 1,3
  intPtr = m_filteredBlockTmp[3][0] + (halfFilterSize - 1) * intStride;
  dstPtr = m_filteredBlock[1][3][0];
  if (halfPelRef.getVer() == 0)
  {
    intPtr += intStride;
  }
  //水平3/4像素插值后的Y分量做垂直1/4像素插值，结果存储在m_filteredBlock[1][3]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);

  // Generate @ 3,3
  intPtr = m_filteredBlockTmp[3][0] + (halfFilterSize - 1) * intStride;
  dstPtr = m_filteredBlock[3][3][0];
  //水平3/4像素插值后的Y分量做垂直3/4像素插值，结果存储在m_filteredBlock[3][3]中
  m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3 << MV_FRACTIONAL_BITS_DIFF, false, true, chFmt, clpRng);
}

xPatternRefinement函数用来1/2像素精度的MV和1/4像素精度的MV细化，选出最佳的MV 

Distortion InterSearch::xPatternRefinement( const CPelBuf* pcPatternKey, //
                                            Mv baseRefMv, //1/2像素时为(0,0)，1/4像素时为rcMvHalf
                                            int iFrac, Mv& rcMvFrac, //1/2像素时为rcMvHalf，1/4像素时为rcMvQter
                                            bool bAllowUseOfHadamard )
{
  Distortion  uiDist;
  Distortion  uiDistBest  = std::numeric_limits<Distortion>::max();
  uint32_t        uiDirecBest = 0;

  Pel*  piRefPos;
  int iRefStride = pcPatternKey->width + 1;
  //初始化失真参数
  m_pcRdCost->setDistParam( m_cDistParam, *pcPatternKey, m_filteredBlock[0][0][0], iRefStride, m_lumaClpRng.bd, COMPONENT_Y, 0, 1, m_pcEncCfg->getUseHADME() && bAllowUseOfHadamard );

  const Mv* pcMvRefine = (iFrac == 2 ? s_acMvRefineH : s_acMvRefineQ); //搜索邻域的偏移量
  for (uint32_t i = 0; i < 9; i++)
  {
    if (m_skipFracME && i > 0)
    {
      break;
    }
    Mv cMvTest = pcMvRefine[i];
    cMvTest += baseRefMv; // 偏移后的MV

    int horVal = cMvTest.getHor() * iFrac;
    int verVal = cMvTest.getVer() * iFrac;
    piRefPos = m_filteredBlock[verVal & 3][horVal & 3][0];

    if (horVal == 2 && (verVal & 1) == 0)
    {
      piRefPos += 1;
    }
    if ((horVal & 1) == 0 && verVal == 2)
    {
      piRefPos += iRefStride;
    }
    cMvTest = pcMvRefine[i];
    cMvTest += rcMvFrac;


    m_cDistParam.cur.buf   = piRefPos;
    uiDist = m_cDistParam.distFunc( m_cDistParam ); //获取失真
    uiDist += m_pcRdCost->getCostOfVectorWithPredictor( cMvTest.getHor(), cMvTest.getVer(), 0 );

    if ( uiDist < uiDistBest )
    {
      uiDistBest  = uiDist;
      uiDirecBest = i;
      m_cDistParam.maximumDistortionForEarlyExit = uiDist;
    }
  }

参考：

HEVC代码学习17：m_filteredBlockTmp[]和m_filteredBlock[][]_岳麓吹雪的博客-CSDN博客

HEVC代码学习7：xPatternSearchFracDIF函数_岳麓吹雪的博客-CSDN博客

涵小呆
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件
04-27
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件是视频编码领域的一项重要工具，它基于最新的视频编码标准——Versatile Video Coding（VVC），也被称为H.266。这个软件包的发布是为了支持开发者、研究人员以及业界...
.Net术语大全
diaokuai8379的博客
11-27 760
Source Translationabort 中止abstract class 抽象类accelerator 快捷键accelerator mapping 快捷键映射accelerator table 快捷键对应表access modifier 访问修饰符Access Pack 访问包access specifier 访问说明符access violation 访问冲突accessib...
亚像素精度运动估计插值部分
澍yeah的博客
07-26 6219
参考：新一代高效视频编码 H.265/HEVC：原理、标准与实现 亮度分类插值算法： 插值过程主要分为两步：  1.对整数像素所在行或列进行插值。以A(0,0)点附近的亚像素点为例，a(0,0),b(0,0),c(0,0)可以用水平方向的整像素点计算得出，d(0,0),h(0,0),n(0,0)可以用垂直方向上的整像素点计算得出。  如1/4位置点a(0,0) = -A(-3,0) + 4A(...
HEVC代码学习18：运动估计和运动补偿总结
慢慢积累
06-25 1万+
经过了这段时间对帧间预测部分代码的学习，算是大体上了解了其工作原理。只看理论不看代码，体会不深刻，在看了代码后，有了一种恍然大悟的感觉，很多算法实现和看原理时理解的不一样。下面来整理一下之前写的博客，总结一下运动估计和运动补偿具体的代码实现思路，主要谈一下代码处理的思路， 运动估计 运动估计实际就是当前块在参考图像中搜索找到匹配块的处理过程。在实际代码中入口函数是xMotionEstima...
图像处理---亚像素
qq_44628813的博客
05-24 1764
通常情况下，图像的分辨率是有限的，每个像素的大小是固定的。如果需要进行更高精度的测量或计算，例如图像配准、图像插值或者运动估计等，则需要使用亚像素技术来实现更高的精度。亚像素技术可以通过对图像进行插值或者滤波等操作，来实现对像素的进一步划分或者细化，从而提高图像的精度和分辨率。在数字图像处理中，亚像素（Sub-pixel）指的是对像素的进一步划分或者细化，以实现更高精度的测量和计算。这些技术可以通过对图像进行插值、滤波或者梯度计算等操作，来实现对像素的进一步划分或者细化，从而提高图像的精度和分辨率。
简论H.266与H.265、AV1、H.264对比
热门推荐
maryhaocoolcool的博客
02-22 4万+
来源：H系列有MPEG和VCEG推出 ，VPX系列由谷歌推出，H.265有更高的图像质量，而VP9对于流媒体来说更加可靠。H.265更大的预测模型实现了边缘可视化，而VP9实施更严格的编码规则，似乎可以让流媒体更加连贯和可靠。其中，H.265其压缩效率比H.264提升50%，VP9略逊于H.265，H.266编码性能最高,AV1比VP9同等质量下减少30%比特率。 目录： 1.编解码框架差异 ...
HEVC帧间分像素插值
qq_35752161的博客
01-08 710
Void TEncSearch::xPatternSearchFracDIF( Bool bIsLosslessCoded, TComPattern* pcPatternKey, Pel* piRefY, .
最新通用视频编码标准H.266VVC.pdf
11-28
《H.266/VVC 视频编码标准详解》 在数字媒体技术飞速发展的今天，视频编码标准不断演进以满足日益增长的高清、超高清以及虚拟现实等应用场景的需求。H.266，又称为Versatile Video Coding（VVC），是继H.264/AVC和H...
最新视频编码标准（H.266）VVC-Draft10版本，预发布版本！
02-24
2. **增强的预测技术**：H.266/VVC采用了新的预测模式，包括角度自适应预测、跨块预测和基于深度学习的预测等。这些模式能更准确地估计像素的运动和变化，减少编码过程中的信息损失。 3. **变换和量化优化**：H.266...
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 ...
VTM块划分代码_块划分；_H.266_statementzbb_VVC_
10-03
3. **块大小的灵活性**：H.266/VVC支持从最小4x4到最大128x128的块大小，甚至允许非矩形的四边形划分。这种灵活性有助于更好地适应图像内容的细节变化。 4. **变换和量化**：块划分后的像素值会经过离散余弦变换...
关于亚像素运动估计的二次模型3之A NOVEL FAST TWO STEP SUB-PIXEL MOTION ESTIMATION ALGORITHM IN HEVC
澍yeah的博客
08-05 500
HEVC中一种新的快速两步子像素运动估计算法 运动估计（ME）是视频编码标准中最耗时的部分之一。 随着快速整像素ME算法变得越来越强大，开发快速子像素ME算法非常重要，因为与整像素ME相比，子像素ME的计算复杂度变得相对显着。 本文提出了一种新的快速亚像素ME算法。 该算法首先通过二阶函数逼近子像素位置的误差表面，并通过最小化半像素精度的函数来预测最小点。 然后，对由前一步骤确定的较小区域中的另...
亚像素2之1/2插值过程 xExtDIFUpSamplingH
澍yeah的博客
08-05 2461
通过前面一篇亚像素入口和过程的博客，分析了亚像素的入口和过程，这篇文章分析1/2插值的过程： xExtDIFUpSamplingH 这个函数是进行1/2精度插值，首先对参考图像进行水平插值，整像素位置直接复制给了m_filteredBlockTmp[0]，调用了filterHor这个函数进行水平插值 调用了m_if.filterHor(COMPONENT_Y, srcPtr, srcStrid...
H.266/VVC代码学习笔记5：VTM4.0中的熵编码CABAC部分的详细解析
Peter_Red_Boy的博客
05-03 5426
1 CABAC工作流程 1.1 算术编码工作流程 与变长编码不同，算术编码的本质是为整个输入序列分配一个码字，而不是给每个字符分别指定码字，因此平均意义上可以为单个字符分配码长小于1的码字，所以算数编码可以给出接近最优的编码结果。 算术编码的基本原理是：根据信源不同符号的概率把[0,1)区间划分为互不重叠的子区间，子区间的宽度恰好是各符号序列的概率，这样信源发出的不同符...
H.266/VVC代码学习1：帧内预测框架（20190528更新VTM5.0）
时间有泪
11-18 8708
本人是西电研一的一名普通学生，现在在通院信科所多媒体通信实验室，主要研究方向是视频编码标准H.266/VVC。如很多刚上研同学一样，入学以来经历了迷茫、对科研方向无从下手等问题。两个月来，在理清视频编码结构后，终于渐渐理解并敢于修改VVC的代码。并准备在博客这个平台上记录自己的学习，希望可以与更优秀的人交流讨论。 第一次写微博，准备多说些。我是在2017年4月了解的视频编码，当时的计网老师也就是我...
HEVC帧间预测
慢慢积累
01-12 1万+
经过一个月奋斗，终于7门考试考完了，继续来学习HEVC。 之前由于并没有用到帧间预测的东西，没有对帧间预测进行学习，现在来具体学习一下。帧间预测是利用视频时间域的相关性，使用邻近已编码图像像素预测当前图像的像素，以达到有效去除视频时域冗余的目的。目前主要采用基于块的运动补偿技术，原理是为当前图像的每个像素块在之前已编码图像中寻找一个最佳匹配块，即运动估计。用于预测的图像称为参考图像，参考块到当前像
HEVC代码学习7：xPatternSearchFracDIF函数
慢慢积累
04-13 2803
上一次我们学习了运动估计中使用的插值滤波器函数，这次来看具体的分像素差值函数xPatternSearchFracDIF。在运动估计中，首先进行整像素的搜索，确定一个最优MV，然后在进行分像素搜索，得到以1/4为单位的MV。其分像素搜索通过xPatternSearchFracDIF函数实现，代码如下，主要功能是对Y分量进行亚像素搜索。首先进行1/2像素插值，然后进行1/4像素插值，最终得到以1/4为单
H266/VVC帧间预测编码技术概述
人生只有一次，不妨大胆一点～～
12-25 1814
H266/VVC帧间预测编码技术概述
H.264学习笔记3——帧间预测
weixin_30828379的博客
10-13 839
帧间预测主要包括运动估计（运动搜索方法、运动估计准则、亚像素插值和运动矢量估计）和运动补偿。 对于H.264，是对16x16的亮度块和8x8的色度块进行帧间预测编码。 A、树状结构分块 　　H.264的宏块，对于16x16的亮度宏块，可以分成16x16、16x8、8x16和8x8的子块进行帧间预测。对于8x8的块（亚宏块，亮度和色度），往下又可以分成8x8、8x4、4x8、4x4的子块。在运...
H.266/VVC 灰度
最新发布
05-19
H.266/VVC是一种新的视频编码标准，全称为High Efficiency Video Coding，中文名为高效视频编码。它是一种用于压缩视频数据的技术，可以将视频数据压缩到更小的文件大小，同时保持高质量的图像和视频。 灰度通常是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值