Search::encodeResAndCalcRd[Skip/Inter]CU()

最新推荐文章于 2022-09-14 13:17:34 发布
最新推荐文章于 2022-09-14 13:17:34 发布
阅读量376 收藏 3
点赞数 2
分类专栏： X265
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lj501886285/article/details/105420495
版权

Search::encodeResAndCalcRdSkipCU()

/* Note: this function overwrites the RD cost variables of interMode, but leaves the sa8d cost unharmed 
   计算interMode为skip mode时的rdcost

   过程:
		1.计算luma+chroma的distiortion
		2.计算skipFlag+mergeIdx的bits开销，skip模式无残差bits开销。
		3.更新energe和rdcost
		4.保存熵编码上下文
*/
void Search::encodeResAndCalcRdSkipCU(Mode& interMode)
{
	//取interMode的CUData
    CUData& cu = interMode.cu;
	//取interMode的reconYUV、fencYUV、predYUV
    Yuv* reconYuv = &interMode.reconYuv;
    const Yuv* fencYuv = interMode.fencYuv;
    Yuv* predYuv = &interMode.predYuv;
    X265_CHECK(!cu.isIntra(0), "intra CU not expected\n");
	//得到当前CU的深度
    uint32_t depth  = cu.m_cuDepth[0];

    // No residual coding : SKIP mode

	//设置CU为skip
    cu.setPredModeSubParts(MODE_SKIP);
	//清空cbf
    cu.clearCbf();
    //设置TU深度
	cu.setTUDepthSubParts(0, 0, depth);
	//将interMode的预测YUV拷贝给recon
    reconYuv->copyFromYuv(interMode.predYuv);

    // 计算Luma的distortion
    int part = partitionFromLog2Size(cu.m_log2CUSize[0]);
    interMode.lumaDistortion = primitives.cu[part].sse_pp(fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size);
    interMode.distortion = interMode.lumaDistortion;
    // 若有色度，则累加上Chroma的distortion
    if (m_csp != X265_CSP_I400 && m_frame->m_fencPic->m_picCsp != X265_CSP_I400)
    {
        interMode.chromaDistortion = m_rdCost.scaleChromaDist(1, primitives.chroma[m_csp].cu[part].sse_pp(fencYuv->m_buf[1], fencYuv->m_csize, reconYuv->m_buf[1], reconYuv->m_csize));
        interMode.chromaDistortion += m_rdCost.scaleChromaDist(2, primitives.chroma[m_csp].cu[part].sse_pp(fencYuv->m_buf[2], fencYuv->m_csize, reconYuv->m_buf[2], reconYuv->m_csize));
        interMode.distortion += interMode.chromaDistortion;
    }
    cu.m_distortion[0] = interMode.distortion;
    
	//加载熵编码上下文
	m_entropyCoder.load(m_rqt[depth].cur);
	//重置bits
    m_entropyCoder.resetBits();
    if (m_slice->m_pps->bTransquantBypassEnabled)
        m_entropyCoder.codeCUTransquantBypassFlag(cu.m_tqBypass[0]);
	//编码skipFlag
    m_entropyCoder.codeSkipFlag(cu, 0);
	//得到skipFlag的bits开销
    int skipFlagBits = m_entropyCoder.getNumberOfWrittenBits();
	//编码merge备选集索引
    m_entropyCoder.codeMergeIndex(cu, 0);
	//得到merge备选集索引开销
    interMode.mvBits = m_entropyCoder.getNumberOfWrittenBits() - skipFlagBits;
	//skip无系数开销
    interMode.coeffBits = 0;
	//总开销 = mv开销 + merge备选集索引开销
    interMode.totalBits = interMode.mvBits + skipFlagBits;
	//更新psy/ssim能量
    if (m_rdCost.m_psyRd)
        interMode.psyEnergy = m_rdCost.psyCost(part, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size);
    else if(m_rdCost.m_ssimRd)
        interMode.ssimEnergy = m_quant.ssimDistortion(cu, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size, cu.m_log2CUSize[0], TEXT_LUMA, 0);
	//更新残差能量
    interMode.resEnergy = primitives.cu[part].sse_pp(fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size);
    //更新rdcost
	updateModeCost(interMode);
	//保持上下文
    m_entropyCoder.store(interMode.contexts);
}

Search::encodeResAndCalcRdInterCU（）

/* encode residual and calculate rate-distortion for a CU block.
 * Note: this function overwrites the RD cost variables of interMode, but leaves the sa8d cost unharmed 
 * 为CU编码残差并计算rdcost。该函数可能重写rdcost，但不会改变sa8d cost 
  
	过程：
		1.取interMode的CUData、reconYUV、fencYUV、predYUV、resiYUV以及当前CU深度depth
		2.根据fencYUV和predYUV计算resiYUV，即resiYUV = fencYUV - predYUV
		3.加载熵编码上下文
		4.对残差resiYUV进行编码并得到cost
		5.若不允许transform-quantization旁路，则计算cbf = 0时候的rdcost
			1.计算cbf = 0时候的distortion
			2.计算cbf = 0时候的bits
			3.根据distortion和bits得到cbf = 0时候的rdcost
			4.若cbf = 0时的rdcost<有残差时候的rdcost，则设置cbf = 0
		6.若cbf != 0，也就是有残差，则保存残差数据
		7.编码TransquantBypassFlag
		8.计算bits
			·若是skip，则bits = SkipFlag + MergeIndex
			·若非skip，则bits = SkipFlag + PredMode + PartSize + PredInfo + Coeff
		9.恢复reconYUV，即reconYUV = predYUV + resiYUV
		10.更新interMode的distortion
		11.更新interMode的energy、bits、rdcost
 */
void Search::encodeResAndCalcRdInterCU(Mode& interMode, const CUGeom& cuGeom)
{
    ProfileCUScope(interMode.cu, interRDOElapsedTime[cuGeom.depth], countInterRDO[cuGeom.depth]);

	//取interMode的cu
    CUData& cu = interMode.cu;
	//取interMode的recon、pred、enc YUV
    Yuv* reconYuv = &interMode.reconYuv;
    Yuv* predYuv = &interMode.predYuv;
	const Yuv* fencYuv = interMode.fencYuv;
	//取当前CU的depth
    uint32_t depth = cuGeom.depth;
	//取残差YUV
    ShortYuv* resiYuv = &m_rqt[depth].tmpResiYuv;

    X265_CHECK(!cu.isIntra(0), "intra CU not expected\n");

    uint32_t log2CUSize = cuGeom.log2CUSize;
    int sizeIdx = log2CUSize - 2;

	//计算残差YUV，即resiYuv = fencYuv - predYuv
    resiYuv->subtract(*fencYuv, *predYuv, log2CUSize, m_frame->m_fencPic->m_picCsp);

    uint32_t tuDepthRange[2];
    cu.getInterTUQtDepthRange(tuDepthRange, 0);

	//加载熵编码上下文
    m_entropyCoder.load(m_rqt[depth].cur);

    if ((m_limitTU & X265_TU_LIMIT_DFS) && !(m_limitTU & X265_TU_LIMIT_NEIGH))
        m_maxTUDepth = -1;
    else if (m_limitTU & X265_TU_LIMIT_BFS)
        memset(&m_cacheTU, 0, sizeof(TUInfoCache));

	/*
		计算残差值并得到cost
	*/
    Cost costs;
    if (m_limitTU & X265_TU_LIMIT_NEIGH)
    {
        /* Save and reload maxTUDepth to avoid changing of maxTUDepth between modes */
        int32_t tempDepth = m_maxTUDepth;
        if (m_maxTUDepth != -1)
        {
            uint32_t splitFlag = interMode.cu.m_partSize[0] != SIZE_2Nx2N;
            uint32_t minSize = tuDepthRange[0];
            uint32_t maxSize = tuDepthRange[1];
            maxSize = X265_MIN(maxSize, cuGeom.log2CUSize - splitFlag);
            m_maxTUDepth = x265_clip3(cuGeom.log2CUSize - maxSize, cuGeom.log2CUSize - minSize, (uint32_t)m_maxTUDepth);
        }
        estimateResidualQT(interMode, cuGeom, 0, 0, *resiYuv, costs, tuDepthRange);
        m_maxTUDepth = tempDepth;
    }
    else
        estimateResidualQT(interMode, cuGeom, 0, 0, *resiYuv, costs, tuDepthRange);

	//是否旁路transform和quantization，即无损编码
    uint32_t tqBypass = cu.m_tqBypass[0];
	//若不旁路，则有损
    if (!tqBypass)
    {
		/*
			计算cbf = 0时候的distortion
		*/
        sse_t cbf0Dist = primitives.cu[sizeIdx].sse_pp(fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size);
        //若有色度，则累加chroma的失真
		if (m_csp != X265_CSP_I400 && m_frame->m_fencPic->m_picCsp != X265_CSP_I400)
        {
            cbf0Dist += m_rdCost.scaleChromaDist(1, primitives.chroma[m_csp].cu[sizeIdx].sse_pp(fencYuv->m_buf[1], predYuv->m_csize, predYuv->m_buf[1], predYuv->m_csize));
            cbf0Dist += m_rdCost.scaleChromaDist(2, primitives.chroma[m_csp].cu[sizeIdx].sse_pp(fencYuv->m_buf[2], predYuv->m_csize, predYuv->m_buf[2], predYuv->m_csize));
        }

        /* Consider the RD cost of not signaling any residual 
			计算cbf = 0时候的bits开销	*/
		//加载熵编码上下文
        m_entropyCoder.load(m_rqt[depth].cur);
		//重置bits
        m_entropyCoder.resetBits();
		//cbf为0时，进行编码
        m_entropyCoder.codeQtRootCbfZero();
		//得到cbf为0时的bits开销
        uint32_t cbf0Bits = m_entropyCoder.getNumberOfWrittenBits();

		/*
			根据distortion和bits计算energy和rdcost
		*/
        uint32_t cbf0Energy; uint64_t cbf0Cost;
        if (m_rdCost.m_psyRd)
        {
            cbf0Energy = m_rdCost.psyCost(log2CUSize - 2, fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size);
            cbf0Cost = m_rdCost.calcPsyRdCost(cbf0Dist, cbf0Bits, cbf0Energy);
        }
        else if(m_rdCost.m_ssimRd)
        {
            cbf0Energy = m_quant.ssimDistortion(cu, fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size, log2CUSize, TEXT_LUMA, 0);
            cbf0Cost = m_rdCost.calcSsimRdCost(cbf0Dist, cbf0Bits, cbf0Energy);
        }
        else
            cbf0Cost = m_rdCost.calcRdCost(cbf0Dist, cbf0Bits);

		//若cbf = 0时候的rdcost < 有残差的rdcost，则cbf置0
        if (cbf0Cost < costs.rdcost)
        {
            cu.clearCbf();
            cu.setTUDepthSubParts(0, 0, depth);
        }
    }

	//若cbf!=0，则保存残差数据
    if (cu.getQtRootCbf(0))
        saveResidualQTData(cu, *resiYuv, 0, 0);

    /* calculate signal bits for inter/merge/skip coded CU */
	//加载熵编码上下文
    m_entropyCoder.load(m_rqt[depth].cur);
	//重置bits
    m_entropyCoder.resetBits();
    if (m_slice->m_pps->bTransquantBypassEnabled)
        m_entropyCoder.codeCUTransquantBypassFlag(tqBypass);

	/*
		计算bits
	*/
    uint32_t coeffBits, bits, mvBits;
	//若是merge，且2Nx2N，且CBF = 0，则是skip模式
    if (cu.m_mergeFlag[0] && cu.m_partSize[0] == SIZE_2Nx2N && !cu.getQtRootCbf(0))
    {
		//设置为skip模式
        cu.setPredModeSubParts(MODE_SKIP);

        /* Merge/Skip */
        coeffBits = mvBits = 0;
		//编码skipFlag
        m_entropyCoder.codeSkipFlag(cu, 0);
        //得到skipFlag的bits开销
		int skipFlagBits = m_entropyCoder.getNumberOfWrittenBits();
        //编码mergeIdx
		m_entropyCoder.codeMergeIndex(cu, 0);
        //得到mergeIdx的bits开销
		mvBits = m_entropyCoder.getNumberOfWrittenBits() - skipFlagBits;
		//总计skip模式下的bits总开销
        bits = mvBits + skipFlagBits;
    }
	//若非skip模式下
    else
    {
		//编码skipFlag
        m_entropyCoder.codeSkipFlag(cu, 0);
        //得到skipFlag的bits开销
		int skipFlagBits = m_entropyCoder.getNumberOfWrittenBits();
		//编码PredMode
        m_entropyCoder.codePredMode(cu.m_predMode[0]);
        //编码partSize
		m_entropyCoder.codePartSize(cu, 0, cuGeom.depth);
		//编码PredInfo
        m_entropyCoder.codePredInfo(cu, 0);
		//得到PredMode/partSize/PredInfo的bits总开销
        mvBits = m_entropyCoder.getNumberOfWrittenBits() - skipFlagBits;

		//是否DQP
        bool bCodeDQP = m_slice->m_pps->bUseDQP;
		//编码coeff
        m_entropyCoder.codeCoeff(cu, 0, bCodeDQP, tuDepthRange);
        //得到coeff的bits开销
		bits = m_entropyCoder.getNumberOfWrittenBits();
        coeffBits = bits - mvBits - skipFlagBits;
    }
	//保存熵编码上下文
    m_entropyCoder.store(interMode.contexts);

	/*
		得到reconYUV，用于后续计算distortion
	*/
    if (cu.getQtRootCbf(0)) //若有cbf，则reconYUV = predYUV+resiYUV
        reconYuv->addClip(*predYuv, *resiYuv, log2CUSize, m_frame->m_fencPic->m_picCsp);
    else //若无cbf，则reconYUV = predYUV
        reconYuv->copyFromYuv(*predYuv);

    /* 
	   update with clipped distortion and cost (qp estimation loop uses unclipped values)
       记录luma和chroma的distortion
	 */
	//记录interMode的Luma最优distortion
	sse_t bestLumaDist = primitives.cu[sizeIdx].sse_pp(fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size);
    interMode.distortion = bestLumaDist;
    //若有色度，则记录interMode的chroma最优distortion
	if (m_csp != X265_CSP_I400 && m_frame->m_fencPic->m_picCsp != X265_CSP_I400)
    {
        sse_t bestChromaDist = m_rdCost.scaleChromaDist(1, primitives.chroma[m_csp].cu[sizeIdx].sse_pp(fencYuv->m_buf[1], fencYuv->m_csize, reconYuv->m_buf[1], reconYuv->m_csize));
        bestChromaDist += m_rdCost.scaleChromaDist(2, primitives.chroma[m_csp].cu[sizeIdx].sse_pp(fencYuv->m_buf[2], fencYuv->m_csize, reconYuv->m_buf[2], reconYuv->m_csize));
        interMode.chromaDistortion = bestChromaDist;
        interMode.distortion += bestChromaDist;
    }

	//记录energy
    if (m_rdCost.m_psyRd)
        interMode.psyEnergy = m_rdCost.psyCost(sizeIdx, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size);
    else if(m_rdCost.m_ssimRd)
        interMode.ssimEnergy = m_quant.ssimDistortion(cu, fencYuv->m_buf[0], fencYuv->m_size, reconYuv->m_buf[0], reconYuv->m_size, cu.m_log2CUSize[0], TEXT_LUMA, 0);
    interMode.resEnergy = primitives.cu[sizeIdx].sse_pp(fencYuv->m_buf[0], fencYuv->m_size, predYuv->m_buf[0], predYuv->m_size);
    
	/*
		记录interMode的totalBits/lumaDistortion/coeffBits/mvBits/distortion
	*/
	interMode.totalBits = bits;
    interMode.lumaDistortion = bestLumaDist;
    interMode.coeffBits = coeffBits;
    interMode.mvBits = mvBits;
    cu.m_distortion[0] = interMode.distortion;

	//更新interMode的rdcost
    updateModeCost(interMode);
    checkDQP(interMode, cuGeom);
}
JahnLiang
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
x265编码器 encodeResAndCalcRdInterCU 函数分析
人生只有一次，不妨大胆一点～～
10-25 734
x265中encodeResAndCalcRdInterCU()分析
x265编码器 encodeResAndCalcRdSkipCU 函数分析
人生只有一次，不妨大胆一点～～
10-24 556
x265中encodeResAndCalcRdSkipCU()分析
HEVC代码学习24：encodeResAndCalcRdInterCU函数
慢慢积累
08-16 3046
推荐http://blog.csdn.net/nb_vol_1/article/details/51190324在http://blog.csdn.net/lin453701006/article/details/72403936学习中，我们提到xCheckRDCostInter调用了encodeResAndCalcRdInterCU来计算残差和RD cost。今天来学习encodeResAndCa
HM编码器代码阅读(32)——帧间预测之AMVP/Merge模式（七）encodeResAndCalcRdInterCU函数：残差计算、变换量化
NB_vol_1的专栏
02-16 4029
encodeResAndCalcRdInterCU 经过运动估计、运动补偿，我们得到了MV以及参考块，那么接下来是计算残差、计算MVD，然后对系数进行变换、量化。 encodeResAndCalcRdInterCU函数就是帧间预测之后，专门用来计算残差、进行变换量化的函数。 但是，除了变换量化之外，encodeResAndCalcRdInterCU函数中还有熵编码方面的处理，我们
HEVC帧间预测之三——TEncCu::xCheckRDCostMerge2Nx2N函数分析
HEVC_CJL的专栏
03-12 1万+
本文将对实现merge模式的主函数xCheckRDCostMerge2Nx2N进行分析，方便理清merge模式的整个过程。之前的一篇分析了getInterMergeCandidates的具体实现，还有两个比较重要的函数motionCompensation和encodeResAndCalcRdInterCU，将留在后面陆续进行分析，但是根据它们的命名就不难猜出它们的作用，而且事实也是这样，因此对理解
file:///media/repodata/repomd.xml: [Errno 14] curl#37 - "Couldn't open file /media/repodata/repomd.x
热门推荐
向着曙光前进的博客
04-14 1万+
yum makecache 已加载插件：fastestmirror, langpacks Determining fastest mirrors file:///media/repodata/repomd.xml: [Errno 14] curl#37 - "Couldn't open file /media/repodata/repomd.xml" 正在尝试其它镜像。 One of the...
Maven基础（2）：GAV坐标/Repository/Lifecycle/plugin
知行合一 止于至善
01-21 1万+
本文介绍Maven中重要的Coordinates坐标/Repository/Lifecyle/plugin相关概念，并用一个简单的demo来看一下maven是如何动作的。
Linux下的Cannot find a valid baseurl for repo: base/7/x86_64问题记载
qq_41873753的博客
03-14 5333
Linux学习安装docker记载 1、安装尝试安装docker出现Cannot find a valid baseurl for repo: base/7/x86_64问题 [root@localhost ~]# yum install docker Loaded plugins: fastestmirror Could not retrieve mirrorlist http://mirror...
解决通过终端启动Jupyter Notebook，浏览器不弹出问题
m0_72899048的博客
09-14 4535
浏览器名称和浏览器路径需要根据你自己选择适用,我选择浏览器为谷歌,路径为C:\Program Files\Google\Chrome\Application\chrome.exe。在cmd命令终端中输入jupyter notebook --generate-config。重新启动Jupyter Notebook可以自动弹出页面。如何让浏览器自动打开jupyter notebook?此时,在C盘中找到如下文件。修改完成后CTRL+S保存。在该行下面输入以下内容。
Hadoop安装过程中的问题
qq_35906473的博客
06-29 7854
参考： Hadoop3.0完全分布式集群搭建方法（CentOS7+Hadoop3.2.0） 我在虚拟机上安装了3台centos7,并且以普通用户安装hadoop于 /usr/local下 1.在首次启动hadoop,格式化hadoop namenode -format 时 ，提示如下错误： 错误总结： （1）/tmp 文件夹下权限不足，开放 /tmp 文件夹权限即可 sudo ...
HEVC-I帧中CU,TU,PU之间的关系
xietingcandice的专栏
01-08 7355
这里主要是结合HEVC的解码端I帧进行讲解的，其中P,B帧基本上没有太大的出入，主要是PU还存在不规则的情况，因为我现在刚做完I帧，对P帧还没有把握 之后清楚解析后，再进行补充 在之前的博文中提到了编码树结构的相关概念，这里主要结合代码进行进一步的讲解 在帧内模式中： 35中预测模式是在PU的基础上进行定义的，但是在具体的帧内预测过程中是以TU为单位的，标准规定PU可以四叉树的形式划分为T
HEVC代码学习12：xCheckRDCostInter函数
慢慢积累
05-17 3744
之前的xCompressCU函数学习中，我们知道帧间每一个模式的选择都会调用xCheckRDCostInter函数，下面就来具体学习一下。 xCheckRDCostInter主要的功能是，进行帧间搜索，计算当前CU划分模式的RDcostCreated with Raphaël 2.1.0xCheckRDCostInterpredInterSearch：帧间搜索encodeResAndCalcRdI
X265编码核心函数分析
dragon_dy的博客
02-01 1943
X265编码核心函数分析 compressCTU流程 m_bChromaSa8d = m_pParam->rdLevel >= 3; 计算i32CtuQp m_aRqtData[0].m_cEntropyCur.load(cInitEntrConxt); 初始化熵编码环境.推测先做下一层时，要加载下一层的初始环境 对I_SLICE，调compressIntraCU 根据rd设置，调用...
HEVC代码学习35：xEncodeCU函数
慢慢积累
12-01 2762
xEncodeCU是由encodeCtu调用，其作用是从CTU开始迭代对每个CU进行编码。注意，xEncodeCU是在最优分块已经划分完成后进行编码时使用的，在xCompressCU中没有使用。 xEncodeCU会调用以下函数来完成各部分的编码： encodeSplitFlag编码块是否划分 encodeSkipFlag编码是否是skip模式 encodeMergeIndex如果是ski...
HEVC代码学习9：getInterMergeCandidates函数
慢慢积累
05-08 1842
今天需要统计Merge的候选列表信息，来看下getInterMergeCandidates函数，用于建立merge候选列表。 其主要工作流程： 1.建立空间列表，如果达到最大候选数，退出。 2.空间列表不能填满候选列表，建立时域列表补足，如果达到最大候选数，退出。 3.空间+时域列表不能填满候选列表，建立组合列表补足，如果达到最大候选数，退出。 4.若依然为填满，则使用零MV补足。//!
HM编码器代码阅读(7)——整个编码流程以及相关的函数
NB_vol_1的专栏
04-13 7258
来自网上的文档，但是最初来源不知道是哪，谢谢这个作者！ 整个流程可以从compressGOP函数开始着手： 1、compressGOP对一整个图像组（GOP）进行编码，主要是遍历GOP中每一帧，对每一帧进行单独编码 2、每一帧又会被划分成若干slice（HM15中，每一帧对应一个slice），因此对每一帧的处理就转换成对每一片的处理。 3、每一个slice都会调用com
fortran中的一些函数
kiwi's garden
11-28 8513
函数:SIGN(A,B) Description: SIGN(A,B) returns the value of A with the sign of B.  Standard:Fortran 77 and later  Class:Elemental function  Syntax:RESULT = SIGN(A, B)  Arguments: A Shal
ERROR: Failed to Setup IP tables: Unable to enable SKIP DNAT rule: (iptables failed: iptables --wait -t nat -I DOCKER -i br-210bf5cdc48f -j RETURN: iptables: No chain/target/match by that name.
最新发布
05-25
这个错误通常是由于 Docker 或者 Kubernetes 的网络配置出现了问题导致的。您可以尝试以下解决方法： 1. 检查 Docker 或者 Kubernetes 的网络配置是否正确，例如是否存在网络冲突等。 2. 检查您的 iptables 配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值