H.266/VVC代码学习：去块滤波Deblock代码二

最新推荐文章于 2023-04-24 22:08:29 发布
最新推荐文章于 2023-04-24 22:08:29 发布
阅读量735 收藏 1
点赞数 1
分类专栏： VVC/H.266 文章标签： 视频编码 H.266/VVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigDream123/article/details/115976139
版权

去块滤波原理

目录

xSetEdgefilterMultiple函数

xSetMaxFilterLengthPQFromTransformSizes函数

xGetBoundaryStrengthSingle函数

xSetEdgefilterMultiple函数

xSetEdgefilterMultiple函数遍历全部的边界（垂直或者水平），设置其是否使用滤波

void LoopFilter::xSetEdgefilterMultiple( const CodingUnit&    cu,
                                         const DeblockEdgeDir edgeDir,
                                         const Area&          area,
                                         const bool           bValue,
                                         const bool           EdgeIdx )
{
  const PreCalcValues& pcv = *cu.cs->pcv;

  const unsigned uiAdd     = ( edgeDir == EDGE_VER ) ? pcv.partsInCtuWidth : 1;//垂直滤波往下走1个，水平滤波往右走1个
  // 4x4边界数目
  const unsigned uiNumElem = ( edgeDir == EDGE_VER ) ? ( area.height / pcv.minCUHeight ) : ( area.width / pcv.minCUWidth );
  unsigned uiBsIdx         = getRasterIdx( area, pcv ); //第一个边界光栅扫描的索引值

  for( int ui = 0; ui < uiNumElem; ui++ ) //遍历所有的边界（垂直或者水平）
  {
    m_aapbEdgeFilter[edgeDir][uiBsIdx] = bValue; //设置是否使用滤波器
    if ( m_aapucBS[edgeDir][uiBsIdx] && bValue )
    {
      m_aapucBS[edgeDir][uiBsIdx] = 3;  // both the TU and PU edge 表示既是TU边界也是PU边界
    }
    else
    {
      if( ! EdgeIdx )
      {
        m_aapucBS[edgeDir][uiBsIdx] = bValue;
      }
    }
    uiBsIdx += uiAdd;
  }
}

xSetMaxFilterLengthPQFromTransformSizes函数

xSetMaxFilterLengthPQFromTransformSizes函数是根据边界处相邻块的长度判断需要进行滤波的最大像素数，记边界两侧的块分别为P块和Q块

对于垂直边界，需要判断P块和Q块的宽度（width）；对于水平边界，需要判断P块和Q块的高度（Height）

对于亮度分量，分为以下三种情况：

  • 小块（小于等于4），最多滤波1个像素
  • 大块（大于等于32），最多滤波7个像素
  • 否则，最多滤波3个像素

对于色度分量，分为以下两种情况：

  • 大块（大于等于8），最多滤波3个像素
  • 否则，最多滤波1个像素

这里只是计算了每个边界在进行滤波时的最大像素数，其真正进行滤波的像素数还需要根据滤波强度决策来决定。

代码及注释如下：

void LoopFilter::xSetMaxFilterLengthPQFromTransformSizes( const DeblockEdgeDir edgeDir, const CodingUnit& cu, const TransformUnit& currTU )
{
  const TransformUnit& tuQ = currTU;// 将Q设置为当前TU

  if ( edgeDir == EDGE_HOR ) //水平边界
  { // 遍历所有的颜色分量
    for ( int cIdx = 0; cIdx < ::getNumberValidComponents(tuQ.chromaFormat); cIdx++ ) // per component
    {
      const ComponentID comp = ComponentID(cIdx);
      const ChannelType ch   = toChannelType(comp);
      const int shiftHor     = ( ( ch == CH_L ) ? 0 : m_shiftHor );
      const int shiftVer     = ( ( ch == CH_L ) ? 0 : m_shiftVer );
      const int ctuXOff      = currTU.block(comp).x - ( m_ctuXLumaSamples >> shiftHor ); // x方向距离左CTU的距离 x offset from left edge of CTU in respective channel sample units
      const int ctuYOff      = currTU.block(comp).y - ( m_ctuYLumaSamples >> shiftVer ); // y方向距离上CTU的距离 y offset from top edge of CTU in respective channel sample units
      const int minCUWidth   = cu.cs->pcv->minCUWidth >> shiftHor;
      if ( currTU.block(comp).valid() && ( ( currTU.block(comp).y == cu.block(comp).y ) ? m_stLFCUParam.topEdge : m_stLFCUParam.internalEdge ) ) // Edge deblocking needs to be recomputed since ISP contains whole CU chroma transforms in last TU of the CU
      { 
        //边缘去块需要重新计算，因为ISP在CU的最后一个TU中包含整个CU色度变换
        for ( int x = 0; x < currTU.blocks[cIdx].width; x += minCUWidth ) //以4x4为单位遍历边界
        {
          const Position  posQ     = Position( currTU.blocks[ch].x + x, currTU.blocks[ch].y );
          const Position  posP     = posQ.offset( 0, -1 );
          const int sizeQSide      = tuQ.block(comp).height;//Q像素长度
          const TransformUnit& tuP = *cu.cs->getTU( posP, ch );
          const int sizePSide      = tuP.block(comp).height;//P像素长度
          m_transformEdge[cIdx][ctuXOff+x][ctuYOff] = true;

          if ( comp == COMPONENT_Y )
          {
            bool smallBlock = (sizePSide <= 4) || (sizeQSide <= 4);
            if (smallBlock) //对于亮度的小块（小于等于4x4），仅滤波1个像素
            {
              m_maxFilterLengthQ[cIdx][ctuXOff + x][ctuYOff] = 1;
              m_maxFilterLengthP[cIdx][ctuXOff + x][ctuYOff] = 1;
            }
            else //对于大块（大于等于32），滤波7个像素，否则滤波3个像素
            {
              m_maxFilterLengthQ[cIdx][ctuXOff + x][ctuYOff] = (sizeQSide >= 32) ? 7 : 3;
              m_maxFilterLengthP[cIdx][ctuXOff + x][ctuYOff] = (sizePSide >= 32) ? 7 : 3;
            }
          }
          else
          { //对于色度大块（大于等于8），滤波3个像素，否则滤波1个像素
            m_maxFilterLengthQ[cIdx][ctuXOff+x][ctuYOff] = ( sizeQSide >= 8 && sizePSide >= 8 ) ? 3 : 1;
            m_maxFilterLengthP[cIdx][ctuXOff+x][ctuYOff] = ( sizeQSide >= 8 && sizePSide >= 8 ) ? 3 : 1;
          }
        }
      }
    }
  }
  if ( edgeDir == EDGE_VER ) //垂直边界
  {
    for ( int cIdx = 0; cIdx < ::getNumberValidComponents(tuQ.chromaFormat); cIdx++ ) // per component
    {
      const ComponentID comp = ComponentID(cIdx);
      const ChannelType ch   = toChannelType(comp);
      const int shiftHor     = ( ( ch == CH_L ) ? 0 : m_shiftHor );
      const int shiftVer     = ( ( ch == CH_L ) ? 0 : m_shiftVer );
      const int ctuXOff      = currTU.block(comp).x - ( m_ctuXLumaSamples >> shiftHor ); // x offset from left edge of CTU in respective channel sample units
      const int ctuYOff      = currTU.block(comp).y - ( m_ctuYLumaSamples >> shiftVer ); // y offset from top edge of CTU in respective channel sample units
      const int minCUHeight  = cu.cs->pcv->minCUHeight >> shiftVer;
      if ( currTU.block(comp).valid() && ( ( currTU.block(comp).x == cu.block(comp).x ) ? m_stLFCUParam.leftEdge : m_stLFCUParam.internalEdge ) ) // Edge deblocking needs to be recomputed since ISP contains whole CU chroma transforms in last TU of the CU
      {
        for ( int y = 0; y < currTU.blocks[cIdx].height; y += minCUHeight )
        {
          const Position  posQ     = Position( currTU.blocks[ch].x, currTU.blocks[ch].y + y );
          const Position  posP     = posQ.offset( -1, 0 );
          const int sizeQSide      = tuQ.block(comp).width;
          const TransformUnit& tuP = *cu.cs->getTU( posP, ch );
          const int sizePSide      = tuP.block(comp).width;
          m_transformEdge[cIdx][ctuXOff][ctuYOff+y] = true;

          if ( comp == COMPONENT_Y )
          {
            bool smallBlock = (sizePSide <= 4) || (sizeQSide <= 4);
            if (smallBlock)
            {
              m_maxFilterLengthQ[cIdx][ctuXOff][ctuYOff + y] = 1;
              m_maxFilterLengthP[cIdx][ctuXOff][ctuYOff + y] = 1;
            }
            else
            {
              m_maxFilterLengthQ[cIdx][ctuXOff][ctuYOff + y] = (sizeQSide >= 32) ? 7 : 3;
              m_maxFilterLengthP[cIdx][ctuXOff][ctuYOff + y] = (sizePSide >= 32) ? 7 : 3;
            }
          }
          else
          {
            m_maxFilterLengthQ[cIdx][ctuXOff][ctuYOff+y] = ( sizeQSide >= 8 && sizePSide >= 8 ) ? 3 : 1;
            m_maxFilterLengthP[cIdx][ctuXOff][ctuYOff+y] = ( sizeQSide >= 8 && sizePSide >= 8 ) ? 3 : 1;
          }
        }
      }
    }
  }
}

xGetBoundaryStrengthSingle函数

确定最大滤波像素数后，需要根据边界两侧的块的预测模式和编码参数设置边界强度，具体如下表所示。在xGetBoundaryStrengthSingle函数中获取边界强度。

代码及注释如下： 

unsigned LoopFilter::xGetBoundaryStrengthSingle ( const CodingUnit& cu, const DeblockEdgeDir edgeDir, const Position& localPos, const ChannelType chType ) const
{
  // The boundary strength that is output by the function xGetBoundaryStrengthSingle is a multi component boundary strength that contains boundary strength for luma (bits 0 to 1), cb (bits 2 to 3) and cr (bits 4 to 5).
  // 函数xGetBoundaryStrengthSingle输出的边界强度是多分量边界强度，它包含luma（位0到1）、cb（位2到3）和cr（位4到5）的边界强度。
  const Slice& sliceQ = *cu.slice;

  int shiftHor = cu.Y().valid() ? 0 : ::getComponentScaleX(COMPONENT_Cb, cu.firstPU->chromaFormat);
  int shiftVer = cu.Y().valid() ? 0 : ::getComponentScaleY(COMPONENT_Cb, cu.firstPU->chromaFormat);
  const Position& posQ = Position{ localPos.x >> shiftHor,  localPos.y >> shiftVer };
  const Position  posP  = ( edgeDir == EDGE_VER ) ? posQ.offset( -1, 0 ) : posQ.offset( 0, -1 );

  const CodingUnit& cuQ = cu;
  const CodingUnit& cuP = (chType == CHANNEL_TYPE_CHROMA && cuQ.chType == CHANNEL_TYPE_LUMA) ?
                          *cu.cs->getCU(recalcPosition( cu.chromaFormat, CHANNEL_TYPE_LUMA, CHANNEL_TYPE_CHROMA, posP), CHANNEL_TYPE_CHROMA) :
                          *cu.cs->getCU( posP, cu.chType );

  //-- Set BS for Intra MB : BS = 4 or 3
  //-----------------相邻块中的至少一个用intra或CIIP模式编码----------------------
  if( ( MODE_INTRA == cuP.predMode ) || ( MODE_INTRA == cuQ.predMode ) )
  {
    if( chType == CHANNEL_TYPE_LUMA )
    {
      int bsY = (MODE_INTRA == cuP.predMode && cuP.bdpcmMode) && (MODE_INTRA == cuQ.predMode && cuQ.bdpcmMode) ? 0 : 2;
      return BsSet(bsY, COMPONENT_Y);
    }
    else
    {
      int bsC = (MODE_INTRA == cuP.predMode && cuP.bdpcmModeChroma) && (MODE_INTRA == cuQ.predMode && cuQ.bdpcmModeChroma) ? 0 : 2;
      return (BsSet(bsC, COMPONENT_Cb) + BsSet(bsC, COMPONENT_Cr));
    }
  }

  const TransformUnit& tuQ = *cuQ.cs->getTU(posQ, cuQ.chType);
  const TransformUnit& tuP = (cuP.chType == CHANNEL_TYPE_CHROMA && cuQ.chType == CHANNEL_TYPE_LUMA) ?
                             *cuP.cs->getTU(recalcPosition( cu.chromaFormat, CHANNEL_TYPE_LUMA, CHANNEL_TYPE_CHROMA, posP), CHANNEL_TYPE_CHROMA) :
                             *cuP.cs->getTU(posP, cuQ.chType);

  const PreCalcValues& pcv = *cu.cs->pcv;
  const unsigned rasterIdx = getRasterIdx( Position{ localPos.x,  localPos.y }, pcv );
  if (m_aapucBS[edgeDir][rasterIdx] && (cuP.firstPU->ciipFlag || cuQ.firstPU->ciipFlag))
  {
    if(chType == CHANNEL_TYPE_LUMA)
    {
      return BsSet(2, COMPONENT_Y);
    }
    else
    {
      return BsSet(2, COMPONENT_Cb) + BsSet(2, COMPONENT_Cr);
    }
  }

  unsigned tmpBs = 0;
  //------------------------ 相邻块中的至少一个具有非零变换系数-----------------
  //-- Set BS for not Intra MB : BS = 2 or 1 or 0
  if(chType == CHANNEL_TYPE_LUMA)
  {
    // Y
    if (m_aapucBS[edgeDir][rasterIdx] && (TU::getCbf(tuQ, COMPONENT_Y) || TU::getCbf(tuP, COMPONENT_Y)))
    {
      tmpBs += BsSet(1, COMPONENT_Y);
    }
  }
  else
  {
    if (pcv.chrFormat != CHROMA_400)
    {
      // U
      if (m_aapucBS[edgeDir][rasterIdx]
          && (TU::getCbf(tuQ, COMPONENT_Cb) || TU::getCbf(tuP, COMPONENT_Cb) || tuQ.jointCbCr || tuP.jointCbCr))
      {
        tmpBs += BsSet(1, COMPONENT_Cb);
      }
      // V
      if (m_aapucBS[edgeDir][rasterIdx]
          && (TU::getCbf(tuQ, COMPONENT_Cr) || TU::getCbf(tuP, COMPONENT_Cr) || tuQ.jointCbCr || tuP.jointCbCr))
      {
        tmpBs += BsSet(1, COMPONENT_Cr);
      }
    }
  }
  if (BsGet(tmpBs, COMPONENT_Y) == 1)
  {
    return tmpBs;
  }

  if ( !cu.Y().valid() )
  {
    return tmpBs;
  }

  // and now the pred
  if (m_aapucBS[edgeDir][rasterIdx] != 0 && m_aapucBS[edgeDir][rasterIdx] != 3)
  {
    return tmpBs;
  }
  if( chType == CHANNEL_TYPE_CHROMA )
  {
    return tmpBs;
  }
  if( cuP.predMode != cuQ.predMode && chType == CHANNEL_TYPE_LUMA )
  {
    return BsSet(1, COMPONENT_Y);
  }
  const Position& lumaPosQ  = Position{ localPos.x,  localPos.y };
  const Position  lumaPosP  = ( edgeDir == EDGE_VER ) ? lumaPosQ.offset( -1, 0 ) : lumaPosQ.offset( 0, -1 );
  const MotionInfo&     miQ = cuQ.cs->getMotionInfo( lumaPosQ );
  const MotionInfo&     miP = cuP.cs->getMotionInfo( lumaPosP );
  const Slice&       sliceP = *cuP.slice;
  /************************* 帧间B帧   *********************/
  if (sliceQ.isInterB() || sliceP.isInterB())
  {
    const Picture *piRefP0 = (CU::isIBC(cuP) ? sliceP.getPic() : ((0 > miP.refIdx[0]) ? NULL : sliceP.getRefPic(REF_PIC_LIST_0, miP.refIdx[0])));
    const Picture *piRefP1 = (CU::isIBC(cuP) ? NULL            : ((0 > miP.refIdx[1]) ? NULL : sliceP.getRefPic(REF_PIC_LIST_1, miP.refIdx[1])));
    const Picture *piRefQ0 = (CU::isIBC(cuQ) ? sliceQ.getPic() : ((0 > miQ.refIdx[0]) ? NULL : sliceQ.getRefPic(REF_PIC_LIST_0, miQ.refIdx[0])));
    const Picture *piRefQ1 = (CU::isIBC(cuQ) ? NULL            : ((0 > miQ.refIdx[1]) ? NULL : sliceQ.getRefPic(REF_PIC_LIST_1, miQ.refIdx[1])));
    Mv mvP0, mvP1, mvQ0, mvQ1;

    if (0 <= miP.refIdx[0])
    {
      mvP0 = miP.mv[0];
    }
    if (0 <= miP.refIdx[1])
    {
      mvP1 = miP.mv[1];
    }
    if (0 <= miQ.refIdx[0])
    {
      mvQ0 = miQ.mv[0];
    }
    if (0 <= miQ.refIdx[1])
    {
      mvQ1 = miQ.mv[1];
    }

    int nThreshold = (1 << MV_FRACTIONAL_BITS_INTERNAL) >> 1;
    unsigned uiBs = 0;

    //th can be optimized 
     // P和Q块的参考帧相同，属于相邻块的运动矢量之间的绝对差大于或等于半个亮度样本
    if ( ((piRefP0==piRefQ0)&&(piRefP1==piRefQ1)) || ((piRefP0==piRefQ1)&&(piRefP1==piRefQ0)) )
    {
     
      if ( piRefP0 != piRefP1 )   // Different L0 & L1 如果参考帧不同，其中一个MVD大于半像素精度，则BS为1
      {
        if ( piRefP0 == piRefQ0 )
        {
          uiBs  = ((abs(mvQ0.getHor() - mvP0.getHor()) >= nThreshold) || (abs(mvQ0.getVer() - mvP0.getVer()) >= nThreshold) ||
                   (abs(mvQ1.getHor() - mvP1.getHor()) >= nThreshold) || (abs(mvQ1.getVer() - mvP1.getVer()) >= nThreshold))
                  ? 1 : 0;
        }
        else
        {
          uiBs  = ((abs(mvQ1.getHor() - mvP0.getHor()) >= nThreshold) || (abs(mvQ1.getVer() - mvP0.getVer()) >= nThreshold) ||
                   (abs(mvQ0.getHor() - mvP1.getHor()) >= nThreshold) || (abs(mvQ0.getVer() - mvP1.getVer()) >= nThreshold))
                  ? 1 : 0;
        }
      }
      else    // Same L0 & L1 如果参考帧相同，同时满足两个MVD大于半像素精度，则BS为1
      {
        uiBs  = ((abs(mvQ0.getHor() - mvP0.getHor()) >= nThreshold) || (abs(mvQ0.getVer() - mvP0.getVer()) >= nThreshold) ||
                 (abs(mvQ1.getHor() - mvP1.getHor()) >= nThreshold) || (abs(mvQ1.getVer() - mvP1.getVer()) >= nThreshold))
              &&
                ((abs(mvQ1.getHor() - mvP0.getHor()) >= nThreshold) || (abs(mvQ1.getVer() - mvP0.getVer()) >= nThreshold) ||
                 (abs(mvQ0.getHor() - mvP1.getHor()) >= nThreshold) || (abs(mvQ0.getVer() - mvP1.getVer()) >= nThreshold))
              ? 1 : 0;
      }
    }
    else // for all different Ref_Idx 参考帧不同，则设置滤波强度为1
    {
      uiBs = 1;
    }
    return uiBs + tmpBs;
  }

  /************************* 帧间P帧：如果MVD大于等于半像素精度 *********************/
  // 相邻块中的一个以IBC预测模式编码，另一个以帧间预测模式编码
  // pcSlice->isInterP()
  CHECK(CU::isInter(cuP) && 0 > miP.refIdx[0], "Invalid reference picture list index");
  CHECK(CU::isInter(cuP) && 0 > miQ.refIdx[0], "Invalid reference picture list index");
  const Picture *piRefP0 = (CU::isIBC(cuP) ? sliceP.getPic() : sliceP.getRefPic(REF_PIC_LIST_0, miP.refIdx[0]));
  const Picture *piRefQ0 = (CU::isIBC(cuQ) ? sliceQ.getPic() : sliceQ.getRefPic(REF_PIC_LIST_0, miQ.refIdx[0]));
  if (piRefP0 != piRefQ0)
  {
    return tmpBs + 1;
  }

  Mv mvP0 = miP.mv[0];
  Mv mvQ0 = miQ.mv[0];

  int nThreshold = (1 << MV_FRACTIONAL_BITS_INTERNAL) >> 1;
  return ( ( abs( mvQ0.getHor() - mvP0.getHor() ) >= nThreshold ) || ( abs( mvQ0.getVer() - mvP0.getVer() ) >= nThreshold ) ) ? (tmpBs + 1) : tmpBs;
}

 

涵小呆
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HEVC学习（三十二） —— 去方块滤波之三
HEVC_CJL的专栏
01-25 5121
Void TComLoopFilter::xSetEdgefilterPU( TComDataCU* pcCU, UInt uiAbsZorderIdx ) { const UInt uiDepth = pcCU->getDepth( uiAbsZorderIdx ); const UInt uiWidthInBaseUnits = pcCU->getPic()->getNumPa
VVC/VTM：环路滤波——Deblocking filter(DF)
Moomin的博客
06-03 1944
Deblocking filter
VVC学习之环内滤波器（二）： 去块滤波器（deblocking filter, DF）原理及流程
Aidoneus_y
11-28 1740
去块滤波器可以有效去除目前基于块的压缩框架所带来的方块效应，在提高视频质量方面具有显著成效。VVC中采用的去块滤波器大体上和HEVC差不多，区别在于对亮度和色度编码块增加了强滤波模式，以及对亮度编码块的滤波强度考虑到了其亮度强度。
HM编码器代码阅读(26)——去方块滤波
NB_vol_1的专栏
02-12 2690
去方块滤波 主函数：TComLoopFilter::loopFilterPic     1、水平边界滤波         遍历图像中的每一个CU，对每一个CU中的PU或者TU的水平边界进行滤波（CU可以划分成TU或者PU），即调用xDeblockCU     2、垂直边界滤波         操作同上 Void TComLoopFilter::loopFilterPic( TComPi
H.266/VVC代码学习：去块滤波Deblock代码三
BigDream123的博客
04-21 893
去块滤波原理 目录 xEdgeFilterLuma函数 xUseStrongFiltering函数 xPelFilterLuma函数 xEdgeFilterLuma函数 xEdgeFilterLuma函数是对亮度像素的一边界进行去块滤波，基本过程如下： 以长度4为单位遍历该边界，对于垂直边界，如下图右所示；对于水平边界，如下图左所示。 对于每一个长度为4的边界，进行如下过程： 获取滤波开关和滤波强度阈值参数：根据P块和Q块两侧的Qp值计算索引值，根据索引查表获得参数Tc和β 滤波开关
H.266/VVC技术学习之环路滤波：去块滤波（Deblock）技术
BigDream123的博客
03-19 3047
一、方块效应 目前主流的视频编码标准都是基于分块的混合编码机制，其处理过程是针对每个块单独进行处理的，因此由于编码模式的差异以及量化误差的原因，会导致相邻块重建像素不连续的现象。对于一个两侧强相关性的块边界，当图像较平滑时，就会在重建图像中出现方块效应，如下图所示。 方块效应产生的原因主要包括以下两个方面： 一是由变换、量化的误差引起的。在视频编码中，量化是一个有损压缩过程，因此在反量化、反变换之后的重建图像会出现误差，由于不同块之间的处理不一致，而且边界处的误差格外大一些，会造成图像在边界上的.
最新通用视频编码标准H.266VVC.pdf
11-28
H.266 VVC 标准中文版
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件
04-27
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件是视频编码领域的一项重要工具，它基于最新的视频编码标准——Versatile Video Coding（VVC），也被称为H.266。这个软件包的发布是为了支持开发者、研究人员以及业界...
VTM块划分代码_块划分；_H.266_statementzbb_VVC_
10-03
本文将深入探讨"VTM块划分代码"，这是基于H.266标准（也称为VVC，即Versatile Video Coding）的一种实现。我们将讨论块划分的重要性、其在VTM（Versatile Test Model）中的实现以及可能的优化策略。 块划分是视频...
最新视频编码标准（H.266）VVC-Draft10版本，预发布版本！
02-24
2. **增强的预测技术**：H.266/VVC采用了新的预测模式，包括角度自适应预测、跨块预测和基于深度学习的预测等。这些模式能更准确地估计像素的运动和变化，减少编码过程中的信息损失。 3. **变换和量化优化**：H.266...
H266/VVC码流解析器
10-22
Eleard官方的码流解析器
H. 266 VTM参考实现代码
08-12
H. 266 VTM参考实现代码，研究新标准的实现代码，采纳了多项新技术，值得学习！
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 ...
Graph-Based Information Block Detection inInfographic With Gestalt Organization Principles
m0_54386352的博客
04-24 420
信息图是一种通过信息块显示信息片段的可视化图表。现有的信息块检测工作利用空间接近度将元素分组为几个信息块。然而，先前的研究忽略了信息图的色度和结构特征，导致在检测信息块时出现错误的遗漏。为了缓解这种错误，我们使用场景图来表示信息图，并基于格式塔组织原理（空间邻近性、色相似性和结构相似性原理），提出了一种基于图的信息块检测模型来对元素进行分组。我们还构建了一个用于信息块检测的新数据集。定量和定性实验表明，与基于空间邻近度的方法相比，我们的模型可以更有效地检测信息图中的信息块。
H.266/VVC代码学习：去块滤波Deblock代码一
BigDream123的博客
04-21 1042
最近整个人感觉完全不在状态，什么都看不进，所以准备重新开始学习VTM10.0的代码，找找状态，顺带学习一些新技术。 去块滤波技术的原理参考：去块滤波 VTM中，去块滤波代码的入口函数是loopFilterPic函数，在该函数中遍历全部CU，对每个调用xDeblockCU函数进行去块滤波。 首先对垂直边界进行滤波，再对水平边界滤波。对每一个方向的边界，通过pcv中的widthInCtus和heightInCtus参数遍历全部CTU，再通过cs.traverseCUs函数遍历CTU中所有的CU，针对每个C
VVC/JEM代码学习14:loopFilterPic
小小柴的博客
03-30 949
在代码学习13中，记录了SAO技术的详细过程，其实在执行SAO之前，要先对重建图像进行去方块滤波；去方块滤波和样点自适应补偿合并称为环路滤波。今天就记录一下去方块滤波的详细过程。   去方块滤波的原理：由于在编码时各个块的变换量化相互独立，对不同的块使用了不同的量化参数，导致每个块引入的量化误差大小不一致，导致相邻块边界的不连续性。此外，运动补偿预测过程中，相邻块的预测值可能来自不同图像的不同位置...
去方块滤波
m0_37579288的博客
03-03 1539
推荐NB_vol关于量化部分的解析，代码思路非常清晰：http://blog.csdn.net/nb_vol_1/article/details/51191935自己又梳理了一遍，如下：环路后处理--去方块滤波： 环路后处理包括去方块滤波和样点自适应补偿。去方块滤波主要消除方块效应，SAO则是消除振铃效应。HEVC中，图形中各个块的量化变换独立进行，另外，运动补偿预测中，相邻开的预测值来自于不同图...
HEVC的环路滤波（1）
面海烹鲜的博客
09-07 4276
HEVC的环路滤波（1） 1. 概述 HEVC的环路滤波包括两个部分：去方块滤波（deblocking filter）和样本自适应缩进滤波（sample adaptive offset filter，简称SAO）。 首先进行去方块滤波（见第2节），输入为重构后的图像矩阵，输出滤波后的图像，然后如果sample_adaptive_offset_enabled_flag为1，再进
HEVC学习（三十四） —— 去方块滤波之五
HEVC_CJL的专栏
01-25 4874
本文考察实现去方块滤波的核心函数xDeblockCU： Void TComLoopFilter::xDeblockCU( TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth, Int Edge ) { if(pcCU->getPic()==0||pcCU->getPartitionSize(uiAbsZorderIdx)==SIZE_N
新一代通用视频编码h.266/vvc:原理、标准与实现电子书
01-04
新一代通用视频编码H.266/VVC是一种用于视频压缩和编码的标准，旨在提供更高的压缩效率和更好的视频质量。该标准基于先前的H.265/HEVC标准，但引入了许多新的技术和算法以提高性能。H.266/VVC的主要原理是通过有效地...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值