VVC/JEM代码学习8：predIntraAng

最新推荐文章于 2021-05-13 20:18:12 发布
最新推荐文章于 2021-05-13 20:18:12 发布
阅读量833 收藏
点赞数
分类专栏： JEM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxy19931018/article/details/79107963
版权

     （个人理解）

    predIntraAng()主要完成65种角度模式（外加DC和planar模式）的预测，预测之前还要对参考像素进行相应的滤波操作。

Void TComPrediction::predIntraAng( const ComponentID compID, UInt uiDirMode, Pel* piOrg /* Will be null for decoding */, UInt uiOrgStride, Pel* piPred, UInt uiStride, TComTU &rTu, const Bool bUseFilteredPredSamples, const Bool bUseLosslessDPCM )

{
  const ChannelType    channelType = toChannelType(compID);
  const TComRectangle &rect        = rTu.getRect(isLuma(compID) ? COMPONENT_Y : COMPONENT_Cb);
  const Int            iWidth      = rect.width;
  const Int            iHeight     = rect.height;

#if JVET_C0024_QTBT
  assert( g_aucConvertToBit[ iWidth ] >= -1 );  //2x2
  assert( g_aucConvertToBit[ iWidth ] <= MAX_CU_DEPTH - MIN_CU_LOG2 ); 

 Pel *pDst = piPred;

  // get starting pixel in block
#if JVET_C0024_QTBT
  const Int sw = (iHeight + iWidth + 1);
#else
  const Int sw = (2 * iWidth + 1);
#endif
#if COM16_C1046_PDPC_INTRA
  TComDataCU *const pcCU = rTu.getCU();
  const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
#endif

if ( bUseLosslessDPCM )//使用无损DPCM，默认关闭;
  {
    const Pel *ptrSrc = getPredictorPtr( compID, false );
    // Sample Adaptive intra-Prediction (SAP)
    if (uiDirMode==HOR_IDX)//水平模式;
    {
      // left column filled with reference samples
      // remaining columns filled with piOrg data (if available).
      for(Int y=0; y<iHeight; y++)
      {
        piPred[y*uiStride+0] = ptrSrc[(y+1)*sw];//当前块第一列的预测值用参考采样进行填充;
      }
      if (piOrg!=0)
      {
        piPred+=1; // miss off first column
        for(Int y=0; y<iHeight; y++, piPred+=uiStride, piOrg+=uiOrgStride)
        {
          memcpy(piPred, piOrg, (iWidth-1)*sizeof(Pel));//剩余列用piOrg指向的数据进行填充;
        }
      }
    }
    else // VER_IDX
    {
      // top row filled with reference samples
      // remaining rows filled with piOrd data (if available)
      for(Int x=0; x<iWidth; x++)
      {
        piPred[x] = ptrSrc[x+1];
      }
      if (piOrg!=0)
      {
        piPred+=uiStride; // miss off the first row
        for(Int y=1; y<iHeight; y++, piPred+=uiStride, piOrg+=uiOrgStride)
        {
          memcpy(piPred, piOrg, iWidth*sizeof(Pel));
        }
      }
    }
  }
  else
  {
#if COM16_C1046_PDPC_INTRA
#if !COM16_C1046_PDPC_RSAF_HARMONIZATION
    Pel *ptrSrc = getPredictorPtr(compID, false);//指向的是当前块的参考数据（左上角）,即p[-1][-1];
#endif
#if JVET_G0104_PLANAR_PDPC
    if( uiDirMode == PLANAR_IDX )//如果是planar模式;

#if COM16_C1046_PDPC_RSAF_HARMONIZATION 

      Pel *ptrSrc = getPredictorPtr(compID, false);
#endif
#if JVET_C0024_QTBT
      const Int iSrcStride = iWidth + iHeight + 1;//129;
      const Int iDoubleSize = iWidth + iHeight;//128;
#else
      const Int iBlkSize = iWidth;
      const Int iSrcStride = (iWidth<<1) + 1;
      const Int iDoubleWidth = iWidth<<1;
#endif

#if JVET_G0104_PLANAR_PDPC
      const Int blkSizeGroup[2] = { std::min( 4, 1 + (Int)g_aucConvertToBit[iWidth] ), std::min( 4, 1 + (Int)g_aucConvertToBit[iHeight] ) };
      const Short *pdpcParam[2] = { g_pdpcParam[blkSizeGroup[0]], g_pdpcParam[blkSizeGroup[1]] };
      const Short *pPdpcPar = pdpcParam[iWidth < iHeight];

#if JVET_C0024_QTBT
      Int * piRefVector = piTempRef + iDoubleSize;
      Int * piLowpRefer = piFiltRef + iDoubleSize;
#else
      Int * piRefVector = piTempRef + iDoubleWidth;
      Int * piLowpRefer = piFiltRef + iDoubleWidth;
#endif

      //unfiltered reference
#if JVET_C0024_QTBT
      for (Int j = 0; j <= iDoubleSize; j++)
        piRefVector[j] = ptrSrc[j];

      for (Int i = 1; i <= iDoubleSize; i++)
        piRefVector[-i] = ptrSrc[i*iSrcStride];
#else
      for (Int j = 0; j <= iDoubleWidth; j++)
        piRefVector[j] = ptrSrc[j];

      for (Int i = 1; i <= iDoubleWidth; i++)
        piRefVector[-i] = ptrSrc[i*iSrcStride];
#endif

      if (pPdpcPar[5] != 0) 
      { // filter reference samples
#if JVET_C0024_QTBT
        xReferenceFilter(iDoubleSize, pPdpcPar[4], pPdpcPar[5], piRefVector, piLowpRefer);
        for (Int j = 0; j <= iDoubleSize; j++)
          ptrSrc[j] = piLowpRefer[j];
        for (Int i = 1; i <= iDoubleSize; i++)
          ptrSrc[i*iSrcStride] = piLowpRefer[-i];
#else
        xReferenceFilter(iBlkSize, pPdpcPar[4], pPdpcPar[5], piRefVector, piLowpRefer);
        for (Int j = 0; j <= iDoubleWidth; j++)
          ptrSrc[j] = piLowpRefer[j];
        for (Int i = 1; i <= iDoubleWidth; i++)
          ptrSrc[i*iSrcStride] = piLowpRefer[-i];
#endif
      }

      if (uiDirMode == PLANAR_IDX)//若是planar模式，利用对应的计算预测值的公式计算预测值;
        xPredIntraPlanar(ptrSrc + sw + 1, sw, pDst, uiStride, iWidth, iHeight);//ptrSrc + sw + 1,指向当前CU首地址;
      else//不是planar模式;
      {
        const Bool            enableEdgeFilters = !(pcCU->isRDPCMEnabled(uiAbsPartIdx) && pcCU->getCUTransquantBypass(uiAbsPartIdx));
#if O0043_BEST_EFFORT_DECODING
        const Int channelsBitDepthForPrediction = rTu.getCU()->getSlice()->getSPS()->getStreamBitDepth(channelType);
#else
        const Int channelsBitDepthForPrediction = rTu.getCU()->getSlice()->getSPS()->getBitDepth(channelType);
#endif
#if VCEG_AZ07_INTRA_4TAP_FILTER
        const Bool             enable4TapFilter = pcCU->getSlice()->getSPS()->getUseIntra4TapFilter();
#endif
//对DC模式和所有角度模式进行预测;
                xPredIntraAng(channelsBitDepthForPrediction, ptrSrc + sw + 1, sw, pDst, uiStride,
                              iWidth, iHeight,
#if JVET_D0033_ADAPTIVE_CLIPPING
                              compID,
              #else
                              channelType,
              #endif
                              uiDirMode, enableEdgeFilters
#if VCEG_AZ07_INTRA_4TAP_FILTER
          , enable4TapFilter
#endif
          );
      }
  //使用未参考采样用于加权预测，就是JEM里的PDPC;
      //use unfiltered reference sample for weighted prediction
      if (pPdpcPar[5] != 0) 
      {
#if JVET_C0024_QTBT
        for (int j = 0; j <= iDoubleSize; j++)
          ptrSrc[j] = piRefVector[j];

        for (int i = 1; i <= iDoubleSize; i++)
          ptrSrc[i*iSrcStride] = piRefVector[-i];
#else
        for (int j = 0; j <= iDoubleWidth; j++)
          ptrSrc[j] = piRefVector[j];

        for (int i = 1; i <= iDoubleWidth; i++)
          ptrSrc[i*iSrcStride] = piRefVector[-i];
#endif
      }

#if JVET_C0024_QTBT
      Int scale = g_aucConvertToBit[iWidth] + MIN_CU_LOG2 + g_aucConvertToBit[iHeight] + MIN_CU_LOG2 < 10 ? 0: 1;
#else
      Int scale = (iBlkSize < 32 ? 0 : 1);
#endif
#if !JVET_D0033_ADAPTIVE_CLIPPING
      Int bitDepth = rTu.getCU()->getSlice()->getSPS()->getBitDepth(channelType);
#endif
      Int ParShift = 6; //normalization factor
      Int ParScale = 1 << ParShift;//64;
      Int ParOffset = 1 << (ParShift - 1);//32;

#if JVET_C0024_QTBT
      for (Int row = 0; row < iHeight; row++) 
#else
      for (Int row = 0; row < iBlkSize; row++) 
#endif
      {
        Int pos          = row * uiStride;
        Int shiftRow     = row >> scale;
#if JVET_C0024_QTBT
        Int Coeff_Top    = pdpcParam[1][2] >> shiftRow;
        Int Coeff_offset = pdpcParam[1][3] >> shiftRow;
#else
        Int Coeff_Top    = pPdpcPar[2] >> shiftRow;
        Int Coeff_offset = pPdpcPar[3] >> shiftRow;
#endif

#if JVET_C0024_QTBT
        for (Int col = 0; col < iWidth; col++, pos++) 
#else
        for (Int col = 0; col < iBlkSize; col++, pos++) 
#endif
        {
          Int shiftCol      = col >> scale;
#if JVET_C0024_QTBT
          Int Coeff_Left    = pdpcParam[0][0] >> shiftCol;
          Int Coeff_TopLeft = (pdpcParam[0][1] >> shiftCol) + Coeff_offset;
#else
          Int Coeff_Left    = pPdpcPar[0] >> shiftCol;
          Int Coeff_TopLeft = (pPdpcPar[1] >> shiftCol) + Coeff_offset;
#endif
          Int Coeff_Cur     = ParScale - Coeff_Left - Coeff_Top + Coeff_TopLeft;

          Int sampleVal = (Coeff_Left* piRefVector[-row - 1] + Coeff_Top * piRefVector[col + 1] - Coeff_TopLeft * piRefVector[0] + Coeff_Cur * pDst[pos] + ParOffset) >> ParShift;
#if JVET_D0033_ADAPTIVE_CLIPPING
          pDst[pos] = ClipA(sampleVal,compID);
#else
          pDst[pos] = Clip3(0, ((1 << bitDepth) - 1), sampleVal);
#endif
        }
      }
      return; //terminate the prediction process
    }
#else
    const Pel *ptrSrc = getPredictorPtr( compID, bUseFilteredPredSamples );
#endif

#if JVET_G0104_PLANAR_PDPC
    if( isLuma( compID ) )
    {
      if( pcCU->getROTIdx( CHANNEL_TYPE_LUMA, uiAbsPartIdx ) )
      {
        ptrSrc = getPredictorPtr( compID, bUseFilteredPredSamples );
      }
    }
#elif COM16_C1046_PDPC_RSAF_HARMONIZATION
    const Pel *ptrSrc = getPredictorPtr(compID, bUseFilteredPredSamples);
#endif
#if VCEG_AZ05_INTRA_MPI
    TComDataCU *const pcCU = rTu.getCU();
    const UInt              uiAbsPartIdx = rTu.GetAbsPartIdxTU();
#endif
    if ( uiDirMode == PLANAR_IDX )
    {
      xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
    }
    else
    {
      // Create the prediction
#if !VCEG_AZ05_INTRA_MPI && !COM16_C1046_PDPC_INTRA
      TComDataCU *const pcCU = rTu.getCU();
      const UInt              uiAbsPartIdx      = rTu.GetAbsPartIdxTU();
#endif//是否进行边缘滤波的标记;
      const Bool              enableEdgeFilters = !(pcCU->isRDPCMEnabled(uiAbsPartIdx) && pcCU->getCUTransquantBypass(uiAbsPartIdx));
#if O0043_BEST_EFFORT_DECODING
      const Int channelsBitDepthForPrediction = rTu.getCU()->getSlice()->getSPS()->getStreamBitDepth(channelType);
#else
      const Int channelsBitDepthForPrediction = rTu.getCU()->getSlice()->getSPS()->getBitDepth(channelType);
#endif
#if VCEG_AZ07_INTRA_4TAP_FILTER//JEM中新加的4抽头滤波;
      const Bool              enable4TapFilter     = pcCU->getSlice()->getSPS()->getUseIntra4TapFilter();
#endif

#if VCEG_AZ07_INTRA_BOUNDARY_FILTER

#if COM16_C983_RSAF_PREVENT_OVERSMOOTHING
#if VCEG_AZ05_INTRA_MPI
      const Bool              enableBoundaryFilter = pcCU->getSlice()->getSPS()->getUseIntraBoundaryFilter() && (pcCU->getMPIIdx(uiAbsPartIdx) <= 1 || pcCU->getWidth(uiAbsPartIdx)>=16 || !pcCU->getSlice()->getSPS()->getUseRSAF() );
#else
#if COM16_C1046_PDPC_INTRA
      const Bool              enableBoundaryFilter = pcCU->getSlice()->getSPS()->getUseIntraBoundaryFilter() && (pcCU->getPDPCIdx(uiAbsPartIdx) <= 1 || pcCU->getWidth(uiAbsPartIdx) >= 16 || !pcCU->getSlice()->getSPS()->getUseRSAF());
#else
      const Bool              enableBoundaryFilter = pcCU->getSlice()->getSPS()->getUseIntraBoundaryFilter() && (pcCU->getWidth(uiAbsPartIdx) >= 16 || !pcCU->getSlice()->getSPS()->getUseRSAF());
#endif
#endif
#else//是否进行边界滤波的标记，这里的边界指的是当前块的边界，不是参考像素的边界;
      const Bool              enableBoundaryFilter = pcCU->getSlice()->getSPS()->getUseIntraBoundaryFilter();
#endif

#endif
        xPredIntraAng( channelsBitDepthForPrediction, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight,
#if JVET_D0033_ADAPTIVE_CLIPPING
             compID,
#else
             channelType,
#endif
        uiDirMode, enableEdgeFilters
#if VCEG_AZ07_INTRA_4TAP_FILTER
        , enable4TapFilter
#endif
#if COM16_C983_RSAF_PREVENT_OVERSMOOTHING
        , pcCU->getSlice()->getSPS()->getUseRSAF()
#endif
        );

#if VCEG_AZ05_INTRA_MPI
#if JVET_C0024_QTBT
      if (!(pcCU->getMPIIdx(uiAbsPartIdx) && isLuma(compID)) && (uiDirMode == DC_IDX))
#else
      if (!pcCU->getMPIIdx(uiAbsPartIdx) && (uiDirMode == DC_IDX))
#endif
#else
      if ( uiDirMode == DC_IDX )//如果是DC模式.
#endif
      {
        xDCPredFiltering( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, channelType );
      }
#if VCEG_AZ07_INTRA_BOUNDARY_FILTER
#if JVET_C0024_QTBT
      else if( enableBoundaryFilter && isLuma(compID) && iWidth>2 && iHeight>2)
#else
      else if( enableBoundaryFilter && isLuma(compID) )
#endif
      {
#if VCEG_AZ07_INTRA_65ANG_MODES
        if( uiDirMode == VDIA_IDX )
#else
        if( uiDirMode == 34 )
#endif
        {//对模式34进行预测滤波;
          xIntraPredFilteringMode34( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight);
        }
        else  if( uiDirMode == 2 )
        {//对模式02进行预测滤波;
          xIntraPredFilteringMode02( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight);
        }
#if VCEG_AZ07_INTRA_65ANG_MODES
        else if( ( uiDirMode<=10 && uiDirMode>2 ) || ( uiDirMode>=(VDIA_IDX-8) && uiDirMode<VDIA_IDX ) )
#else
        else if( ( uiDirMode<=6 && uiDirMode>2 ) || ( uiDirMode>=30 && uiDirMode<34 ) )
#endif
        {//对2<mode<10和58<mode<66的模式进行滤波;
          xIntraPredFilteringModeDGL( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode );
        }
      }
#endif
    }

 }


}

小小柴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件
04-27
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件是视频编码领域的一项重要工具，它基于最新的视频编码标准——Versatile Video Coding（VVC），也被称为H.266。这个软件包的发布是为了支持开发者、研究人员以及业界...
VTM1.0代码阅读：predIntraAng函数
矛盾统一
12-26 173
predIntraAng函数进行帧内角度预测，根据给定的帧内预测模式，求得该模式下的预测像素piPred： void IntraPrediction::predIntraAng( const ComponentID compId, PelBuf &piPred, const PredictionUnit &pu, const bool useFilteredPredSamples ...
【VTM10.0】predIntraAng函数解析
zzy_pphz的博客
05-13 218
void IntraPrediction::predIntraAng( const ComponentID compId, PelBuf &piPred, const PredictionUnit &pu) { const ComponentID compID = MAP_CHROMA( compId ); const ChannelType channelType = toChannelType( compID ); const int
H.266/VVC代码学习：帧内预测之角度预测函数(predIntraAng、xPredIntraAng)
BigDream123的博客
02-26 5279
VTM7.0中，帧内预测的角度预测的入口函数为predIntraAng函数，该函数主要是用于进行传统的帧内预测（Planar、DC、角度预测），然后对Planar和DC模式使用PDPC（其余角度模式的PDPC在xPredIntraAng函数中进行） void IntraPrediction::predIntraAng( const ComponentID compId, PelBuf &amp......
关于HEVC HM中的xPredIntraAng帧内预测的方向性预测代码说明
u010289908的专栏
05-21 1006
此函数是针对HEVC draft中的8.4.4.2.6部分的解释 /** Function for deriving the simplified angular intra predictions.  * \param pSrc pointer to reconstructed sample array  * \param srcStride the stride of the rec
VTM3.0代码学习：predIntraAng函数
慢慢积累
11-21 1338
今天来学习一下帧内预测函数predIntraAng，用于生成帧内预测图像。 输入参数： const ComponentID compId //In 颜色分量 PelBuf &amp;amp;piPred //In/Out 预测图像 const PredictionUnit &amp;amp;pu //In 当前PU const bool useFilteredPredSamples ...
H.266 JEM参考代码实现
08-12
1. **块划分策略**：JEM引入了更细粒度的块划分方式，包括方形和非方形的划分模式，使得编码器能够更好地适应图像内容的变化，提高压缩性能。 2. **深度多模式运动估计**：除了传统的块匹配方法，JEM还采用了深度...
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 ...
VVC H.266 4K 60FPS 测试片源
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10 秒 0 毫秒 BitRate/String : 10.0 Mb/s BitRate_Maximum/String : ...
VVC学习之五：帧内预测——67个模式预测信号生成 predIntraAng()
Aidoneus_y
05-19 1490
文章目录简介predIntraAng()xPredIntraDc()xPredIntraPlanar()xPredIntraAng() 简介 帧内共有67种预测模式，包括 65种角度+DC+Planar 模式，VTM中调用predIntraAng()生成相应的预测信号。predIntraAng()主要功能是调用相关预测函数，生成67中模式的预测信号，并对满足 PDPC条件 的预测模式进行预测信号矫...
hevc角度预测_HEVC之帧内预测的predIntraAng讲解
weixin_33213367的博客
02-23 200
Void TComPrediction::predIntraAng( const ComponentID compID, UInt uiDirMode, Pel* piOrg /* Will be null for decoding */, UInt uiOrgStride, Pel* piPred, UInt uiStride, TComTU &rTu, Bool bAbove, Boo...
VVC代码 BMS 帧内预测学习之三：67个角度预测 predIntraAng()
Veronica.。oO的博客
08-16 1212
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代码学习21：帧内角度预测的实现 / 近对角模式的PDPC（xPredIntraAng）
时间有泪
04-20 2060
xPredIntraAng函数的作用是对任意大小的块和任意模式，如何将参考像素的值根据其模式的角度填充进每一个像素。 下图是basketball drill的一个16*16的块，其预测模式为10（偏斜上方），得到如下预测结果： 水平模式18可以简单地通过投影的方式得到预测值。但由上图可见，10这个模式并不能简单地通过投影得到像素值。如果单纯看代码，会感觉到这是一个不讲道理的填充方式。 这个函数的...
H.266/VVC代码学习20：角度预测入口 / 特殊模式的PDPC技术（predIntraAng）
时间有泪
04-14 1619
PDPC技术是通过 VTM4.0代码如下： void IntraPrediction::predIntraAng( const ComponentID compId, PelBuf &piPred, const PredictionUnit &pu, const bool useFilteredPredSamples ) { /****************** 初始化 ***...
VVC/JEM代码学习4：xPredIntraAng
小小柴的博客
01-15 923
（个人理解）      该函数的主要作用是计算角度模式（包括DC模式）的预测值。在进行预测值计算前，还要对参考像素进行滤波。      帧内角度模式的基本原理是通过当前像素燕某个预测方向在参考像素集上投影，“投中”的那个参考像素就是当前像素的预测值。在上面参考像素的获得过程中，已经可以看到，某些预测像素，某些预测角度，很多情况下并不能投中某个参考像素，原因可能是该方向上没有参考像素，也可能是投中在...
VTM3.0代码阅读：predIntraAng函数
矛盾统一
12-27 273
predIntraAng函数进行帧内角度预测，根据给定的帧内预测模式，求得该模式下的预测像素piPred。 相比于VTM1，函数在进行完帧内DC、planar、角度预测之后，最后会判断进行PDPC。 相比于VTM1，函数中多了一些MRL和宽角度模式的代码。 planar和DC模式的处理过程和VTM1中没有任何变化。 void IntraPrediction::predIntraAng( const...
VVC代码 BMS 帧内预测学习之二：亮度色度预测函数 estIntraPredLumaQT()及estIntraPredChromaQT()
Veronica.。oO的博客
08-14 1289
亮度预测函数：estIntraPredLumaQT() Void IntraSearch::estIntraPredLumaQT( CodingUnit &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;cu, Partitioner &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;partitioner ) { CodingStructure
H.266/VVC代码学习25：宽角度模式（getWideAngle）
时间有泪
04-29 1423
在前面xPredIntraAng函数中我们学习到了，在亮度预测中，有67种角度预测方向。对于正方形块来说，这67种方向足够描述其纹理特性。然而，当CU的宽高不相等时，只有67种模式对于矩形块来说，有一些纹理不能被表述出来，而还有一些角度没有被囊括。 宽角度模式就是基于这种问题而提出的，对于帧内的亮度分量宽高比不为1的情况下块生效。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值