使用libx265对YUV进行h265编码

最新推荐文章于 2024-03-12 14:31:51 发布
最新推荐文章于 2024-03-12 14:31:51 发布
阅读量2.4k 收藏 12
点赞数 1
分类专栏： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eastcnme/article/details/109197549
版权

文章目录

前言

使用x265对uvc camera视频进行265编码

一、x265 x86编译

  1. 获取x265源码
    去libx265官网上下载源码，地址：http://ftp.videolan.org/pub/videolan/x265/x265_3.2.tar.gz
    tar xvf x265_3.2.tar.gz

  2. 编译libx265源码
    安装cmake,cmake-curses-gui
    sudo apt-get install cmake
    sudo apt install cmake-curses-gui
    cd x265_3.2/build/linux
    sh make-Makefiles.bash
    修改BIN_INSTALL_DIR、CMAKE_INSTALL_PREFIX
    修改BIN_INSTALL_DIR: /project/x265/x265_3.2/build/linux/__install/bin
    CMAKE_INSTALL_PREFIX: /project/x265/x265_3.2/build/linux
    make
    make install
    编译将libx265.a和include目录头文件准备好

二、x265 编码YUV(YUYV)

1. V4L2获取YUV

参考v4l2采集YUV数据

2. YUV格式转换

uvc camera输出yuv视频格式为YUYV(YUV422)格式，需将YUYV格式转换成YUV420格式再使用x265进行编码
YUYV->YUV420代码如下：

int YUV422ToYUV420(unsigned char *yuv422, unsigned char *yuv420, int width, int height)
{
    int y_size = width * height;
    int i, j, k=0;

    //Y
    for (i = 0; i < y_size; i++)
    {
        yuv420[i] = yuv422[i * 2];
    }

    //U
    for (i = 0; i < height; i++)
    {
        if ((i % 2) != 0)
        {
            continue;
        }   
        
        for (j = 0; j < (width / 2); j++)
        {
            if ((4 * j + 1) > (2 * width))
                break;
            yuv420[y_size + k * 2 * width / 4 + j] = yuv422[i * 2 * width + 4 * j + 1];
        }
        k++;
    }
    
    //V
    k = 0;
    for (i = 0; i < height; i++)
    {
        if ((i % 2) == 0)
            continue;
            
        for (j = 0; j < (width / 2); j++)
        {
            if ((4 * j + 3) > (2 * width))
                break;
            yuv420[y_size + y_size / 4 + k * 2 * width / 4 + j] = yuv422[i * 2 * width + 4 * j + 3];
        }
        k++;
    }

    return 0;
}

3. H265编码

编码流程：

  1. x265_param编码参数设置
  2. x265_encoder_open打开编码器
  3. 分配x265_picture用于编码源YUV数据
  4. 为x265_picture的planes分配存放Y,U,V数据内存空间
  5. 使用x265_encoder_headers编码vps, sps, pps(可省略)
  6. 使用x265_encoder_encode对YUV420数据进行编码
  7. 保存编码后265数据，验证编码结果

头文件

#include "x265.h"

数据结构定义

typedef struct x265_encoder_param
{
    char *buff;
    uint32_t i_nal;
    x265_nal *nal;
    x265_encoder *handler;
    x265_picture *picInput;
    x265_picture *picOutput;
    x265_param *param;
} X265_ENCODER_PARAM;

typedef struct x265_sps_pps_vps
{
    int width;
    int height;
    int bitRate;
    int fps;
    unsigned char *sps;
    int sps_len;
    unsigned char *pps;
    int pps_len;
    unsigned char *vps;
    int vps_len;

} X265_SPS_PPS_VPS;

typedef struct x265_encoder
{
    pthread_t thdId;/*编码线程ID*/
    int thdRunFlag;
    uint32_t pixelformat;/*yuv视频格式*/
    int rc_mode;/*编码模式*/
    X265_ENCODER_PARAM encParam;/*参数*/
    X265_SPS_PPS_VPS spsPpsVps;/*vps pps sps*/
    int saveFile;
    FILE *fp;
} X265_ENCODER;

static X265_ENCODER gstX265Encoder;

int X265EncodeParamInit(X265_ENCODER *encoder)
{
    int y_size = 0;
    int rc_mode = encoder->rc_mode;
    uint32_t pixel_format = encoder->pixelformat;
    X265_ENCODER_PARAM *x265 = &encoder->encParam;
    X265_SPS_PPS_VPS *sps_pps_vps = &encoder->spsPpsVps;

    x265->param = x265_param_alloc();
    x265_param_default(x265->param);
	x265_param_default_preset(x265->param, "ultrafast", "zerolatency");

    x265->param->frameNumThreads = 0;
	x265->param->sourceWidth = sps_pps_vps->width;
	x265->param->sourceHeight = sps_pps_vps->height;
    x265->param->totalFrames = 0;
	x265->param->bAnnexB = 1;
	x265->param->bRepeatHeaders = 1;
    x265->param->keyframeMin = 0;
    x265->param->keyframeMax = sps_pps_vps->fps * 2;
	x265->param->internalCsp = X265_CSP_I420;

    //muxing parameters
	x265->param->fpsDenom = 1;
	x265->param->fpsNum = sps_pps_vps->fps;

#if 1
	//x265->param.rc.lookahead = 0;
	x265->param->rc.bitrate = sps_pps_vps->bitRate;
    x265->param->rc.rateControlMode = rc_mode;
    switch (rc_mode)
    {
        case X265_RC_ABR:
            //x265->param.rc.b_filler = 1;
		    x265->param->rc.vbvMaxBitrate = sps_pps_vps->bitRate;
		    x265->param->rc.vbvBufferSize = sps_pps_vps->bitRate;
            break;
        case X265_RC_CQP:
            x265->param->rc.qp = 32;
            break;
        case X265_RC_CRF:
            x265->param->rc.rfConstantMin = 25;
            x265->param->rc.rfConstantMax = 45;
            break;
        default:
            break;
    }
#endif

    //encoder open
	x265->handler = x265_encoder_open(x265->param);
    if (x265->handler == NULL)
    {
        ERROR("x265_encoder_open ERROR");
        return -1;
    }

    x265->picInput = x265_picture_alloc();
	x265_picture_init(x265->param, x265->picInput);
    y_size = sps_pps_vps->width * sps_pps_vps->height;

    switch (pixel_format)
    {
		case V4L2_PIX_FMT_YUV420:
            x265->buff =(char *)malloc(y_size * 3 / 2);
            x265->picInput->planes[0] = x265->buff;
            x265->picInput->planes[1] = x265->buff + y_size;
            x265->picInput->planes[2] = x265->buff + y_size * 5 / 4;
            x265->picInput->stride[0] = sps_pps_vps->width;
            x265->picInput->stride[1] = sps_pps_vps->width / 2;
            x265->picInput->stride[2] = sps_pps_vps->width / 2;
            break;

		default:
			break;
	}

	x265->picInput->pts = 0;
	x265->i_nal = 0;
    x265_encoder_headers(x265->handler, &x265->nal, &x265->i_nal);

    // get sps pps
	if (x265->i_nal > 0)
    {
		for (uint32_t i = 0; i < x265->i_nal; i++)
        {
            if (x265->nal[i].type == NAL_UNIT_VPS)
            {
                sps_pps_vps->vps = new unsigned char[x265->nal[i].sizeBytes];;
				sps_pps_vps->vps_len = x265->nal[i].sizeBytes;
				memcpy(sps_pps_vps->vps, x265->nal[i].payload, sps_pps_vps->vps_len);
                DEBUG("vps: %02x %02x %02x %02x %02x",
                    sps_pps_vps->vps[0], sps_pps_vps->vps[1],
                    sps_pps_vps->vps[2], sps_pps_vps->vps[3],
                    sps_pps_vps->vps[4]);
            }
			else if (x265->nal[i].type == NAL_UNIT_SPS)
            {
				sps_pps_vps->sps = new unsigned char[x265->nal[i].sizeBytes];
				sps_pps_vps->sps_len = x265->nal[i].sizeBytes;
				memcpy(sps_pps_vps->sps, x265->nal[i].payload, sps_pps_vps->sps_len);
                DEBUG("sps: %02x %02x %02x %02x %02x",
                    sps_pps_vps->sps[0], sps_pps_vps->sps[1],
                    sps_pps_vps->sps[2], sps_pps_vps->sps[3],
                    sps_pps_vps->sps[4]);
			}
			else if (x265->nal[i].type == NAL_UNIT_PPS)
            {
				sps_pps_vps->pps = new unsigned char[x265->nal[i].sizeBytes];;
				sps_pps_vps->pps_len = x265->nal[i].sizeBytes;
				memcpy(sps_pps_vps->pps, x265->nal[i].payload, sps_pps_vps->pps_len);
                DEBUG("pps: %02x %02x %02x %02x %02x",
                    sps_pps_vps->pps[0], sps_pps_vps->pps[1],
                    sps_pps_vps->pps[2], sps_pps_vps->pps[3],
                    sps_pps_vps->pps[4]);
			}
		}
	}

	return 0;
}

int X265EncodeYUV(X265_ENCODER *coder, unsigned char *yuvData)
{
    int num,i;
    unsigned char *data = yuvData;
    X265_ENCODER_PARAM *enc = &coder->encParam;
    X265_SPS_PPS_VPS *spsPpsVps = &coder->spsPpsVps;
    int y_size = spsPpsVps->width * spsPpsVps->height;

	switch (coder->pixelformat)
	{
		case V4L2_PIX_FMT_YUV420:
            memcpy(enc->picInput->planes[0], data, y_size); // copy y
            memcpy(enc->picInput->planes[1], data + y_size, y_size / 4);
            memcpy(enc->picInput->planes[2], data + y_size + y_size / 4, y_size / 4);
			break;

		default:
			break;
	}

	enc->i_nal = 0;
	x265_encoder_encode(enc->handler, &enc->nal, &enc->i_nal, enc->picInput, NULL);
    enc->picInput->pts++;

	for (uint32_t i = 0; i < enc->i_nal; i++)
	{
        /* H265RtmpAcceptFrame(RING_BUFF_RTMP,
                           enc->nal[i].type,
                            enc->nal[i].payload,
                            enc->nal[i].sizeBytes);
                            */
        if (coder->fp && coder->saveFile)
        {
            fwrite(enc->nal[i].payload, enc->nal[i].sizeBytes, 1, coder->fp);
            fflush(coder->fp);
        }
	}

	return 0;
}

void *X265EncodeThread(void *args)
{
    int ret = -1;
    int buffId = 0;
    YUV_RING_BUFFER *ringBuff = NULL;
    X265_ENCODER *encoder = NULL;
    YUV_NODE yuvNode;
    int yuv420Size = 0;
    int width = 0;
    int height = 0;
    unsigned char *yuv420 = NULL;
    char cName[128] = {0};

    snprintf(cName, sizeof(cName) - 1, "%s", "X265EncodeThread");
    prctl(PR_SET_NAME, (unsigned long)cName, 0, 0, 0);

    encoder = (X265_ENCODER *)args;
    if (!encoder)
    {
        return NULL;
    }

    width = encoder->spsPpsVps.width;
    height = encoder->spsPpsVps.height;
    yuv420Size = width * height * 3 / 2;
    yuv420 = (unsigned char *)malloc(yuv420Size);
    if (yuv420 == NULL)
    {
        ERROR("malloc yuv420 memory error!");
        goto __exit;
    }

    ringBuff = YUVRingBufferHandle(buffId);
    if (ringBuff == NULL)
    {
        ERROR("YUVRingBufferHandle error");
        goto __exit;
    }

    ret = X265EncodeParamInit(encoder);
    if (0 != ret)
    {
        ERROR("X264_EncodeInit error");
        goto __exit;
    }

    DEBUG("%s have been created, Id(%lu)", __func__, pthread_self());

    while (encoder->thdRunFlag)
    {
        usleep(100);
        memset(&yuvNode, 0, sizeof(YUV_NODE));
        if (YUVRingBufferGet(ringBuff, &yuvNode) > 0)
        {
            YUV422ToYUV420(yuvNode.yuvData, yuv420, width, height);
            X265EncodeYUV(encoder, yuv420);
            free(yuvNode.yuvData);
            yuvNode.yuvData = NULL;
        }
    }

__exit:

    if (yuv420)
    {
        free(yuv420);
        yuv420 = NULL;
    }

    DEBUG("%s will exit, Id(%lu)", __func__, pthread_self());

    return NULL;
}

int X265EncodeInit(int width, int height)
{
    int ret = -1;
    X265_ENCODER *encoder = &gstX265Encoder;

    memset(encoder, 0, sizeof(X265_ENCODER));
    encoder->spsPpsVps.width = width;
    encoder->spsPpsVps.height = height;
    encoder->spsPpsVps.fps = 15; //real frame rate
    encoder->spsPpsVps.bitRate = 512;
    encoder->pixelformat = V4L2_PIX_FMT_YUV420;
    encoder->rc_mode = X265_RC_ABR;
    encoder->saveFile = 1;
    encoder->fp = fopen("test.h265", "wb");
    if (!encoder->fp)
    {
        ERROR("open test.h265 error");
    }

    encoder->thdRunFlag = 1;
    ret = pthread_create(&encoder->thdId, NULL, X265EncodeThread, (void *)encoder);
    if (0 != ret)
    {
        ERROR("Create X265EncodeThread error");
        return -1;
    }

    return 0;
}

void X265EnocdeDestroy()
{
    X265_ENCODER *encoder = &gstX265Encoder;

    if (encoder->thdId > 0)
    {
        encoder->thdRunFlag = 0;
        pthread_join(encoder->thdId, 0);
        encoder->thdId  = 0;
    }

    if (encoder->fp)
    {
        fclose(encoder->fp);
        encoder->fp = NULL;
    }

    if (encoder->spsPpsVps.sps)
    {
        free(encoder->spsPpsVps.sps);
        encoder->spsPpsVps.sps = NULL;
    }

    if (encoder->spsPpsVps.pps)
    {
        free(encoder->spsPpsVps.pps);
        encoder->spsPpsVps.pps = NULL;
    }

    if (encoder->encParam.handler)
    {
        x265_encoder_close(encoder->encParam.handler);
        encoder->encParam.handler = NULL;
    }

    if (encoder->encParam.param)
    {
        x265_param_free(encoder->encParam.param);
        encoder->encParam.param = NULL;
    }

    if (encoder->encParam.picInput)
    {
        x265_picture_free(encoder->encParam.picInput);
        encoder->encParam.picInput = NULL;
    }

    if (encoder->encParam.buff)
    {
        free(encoder->encParam.buff);
        encoder->encParam.buff = NULL;
    }
}

总结

以上就是今天要讲的内容，本文仅仅简单介绍了x265的使用，而x265提供了大量能使我们快速便捷地处理数据的函数和方法。

参考

最简单的视频编码器：基于libx265（编码YUV为H.265）
在linux下源码编译x265

Embedded engineer
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
26 ffmpeg 使用libx265
简单就好
04-04 9689
跟h264和x264一样，h265的开源也有x265。FFMPEG用就是libx265。FFMPEG的h265编码用的是libx265，解码是自身提供的功能。这里跟h264一样。主要是分析ffmpeg如何使用libx264的，但是对于libx265主要细节没有涉及到，这也没那么简单。得先理清h265的相关标准协议才行。这还有很长一步路要走咯。
libx265、libx265的交叉编译
最新发布
泛在安防边缘智能视频分析
05-14 329
为了方便编译aarch64版本，建议x265版本选择3.5版本，此版本build中包含了aarch64配置选项，比较码放。检查下crosscompile.cmake中的编译器是否与当前宿主机一致，如果一致直接执行下面命令即可。编译器版本：aarch64-linux-gnu-目标平台：aarch64。操作系统：麒麟v10。
借助libx265库实现一个简单视频编码器
baozhakaiv的博客
07-11 818
1.VS新建工程 win10+VS2013，新建一个工程，x265_self； 右键源文件，添加新建项，x265_self.cpp； 右键头文件/外部依赖项，添加x265.h, x265_config.h（文末附）。 2. 编写main函数 只是简单实现一个编码过程，主要包括以下几个过程： x265_param结构体：存储编码命令行参数； x265_encoder结构体：编码器相关参数； x265_picture结构体：存储读取的每一帧，用于编码； x265_param_alloc（）：定义参数集并为参数集
H265编码和解码源码
03-03
德国公司 Stuttgarter Struktur AG发布的H.265编解码器的开源实现——libde265，，libde265采用C语言编写，其API很容易整合到其它软件中。libde265还在开发之中，功能还不完整，只支持解码帧内编码帧。
yuv编码成h264格式写成文件
万事亨通
01-11 395
yuv编码成h264格式写成文件 （使用ffmpeg 编码yuv420p编码成h264格式） #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <libavcodec/avcodec.h> #include <libavutil/time.h> #include <libavutil/opt.h> #include <libavutil/img
H265/HEVC编码NAL的单元的介绍
江海细流的专栏
01-09 3866
一、引言 与H.264/AVC 类似，H265/HEVC也采用视频编码层（Video Coding Layer，VCL）和网络适配层（Network Abstract Layer, NAL）的双层结构，以适应不同网络环境和视频应用。网络适配层的主要任务是对视频压缩后的数据进行划分和封装，并进行必要的标识，使其更好的适应各种网络环境。 二、NAL单元的基本结构 从NAL单元的基本结构可知，NAL单元由NAL头和原始字节序列负载（Raw Byte sequence payload,RBSP） 三、N
video-encoder:基于 libx264 libx265 libvpx 编码 YUV 原始视频数据
07-03
本项目“video-encoder”专注于使用libx264、libx265和libvpx这三种开源编码库来处理YUV原始视频数据。下面将详细介绍这三个编码库以及它们在处理YUV数据时的应用。 首先，libx264是用于H.264编码的库，这是一种...
yuv文件及开源的yuv转 h264 h264的项目，已经yuv player 播放工具
08-28
使用FFmpeg，你可以编写命令来读取YUV文件，对其进行编码，然后保存为H264或H265的MP4、MKV等容器格式。 例如，将一个名为"input.yuv"的YUV文件编码为H264，你可以运行以下FFmpeg命令： ``` ffmpeg -i input.yuv -c...
ffmpeg android libx265
05-12
例如，你可以创建一个函数来接收原始的YUV视频帧，调用libx265的API进行编码，并返回编码后的HEVC bitstream。 在编码过程中，libx265提供了丰富的参数设置，允许你调整编码质量和速度。例如，你可以设置码率、关键...
Qt基于FFmpeg读取摄像头并进行H264编码
01-20
在本文中，我们将深入探讨如何使用Qt5结合FFmpeg库来读取摄像头视频流，并进行H264编码。这是一个涉及多媒体处理、图形界面编程以及音视频编解码的复杂任务，对于理解和开发相关应用非常有帮助。 首先，我们要了解...
libx265.zip
07-15
支持采用Visual Studio编译的LibX265工程，便于调试。 具体使用方法： 1.进入目录中的Win32 2.采用VS打开后设置指定的生成目录。
RGB-YUV-H264-H265查看分析
01-24
RawPlaye#可查看rgb yuvplayer#可查看看多种分辨率和多颜色格式的yuv ESEyeTools#可查看264和yuv ElecardStreamEye4#H264流分析 ElecardHEVCAnalyzer#H265流分析 VLC#可查看video container
mpeg4.zip_ffmpeg_ffmpeg mpeg4_ffmpeg yuv编码_mpeg4
09-24
这里，`-i input.yuv`指定输入文件，`-c:v libx264`指定使用H.264编码器（libx264是MPEG-4的一个实现），`-preset slow`设置编码速度，`-crf 23`设定质量因子，`output.mp4`是输出文件。 5. **mpeg4.h文件** ...
H.265视频编码与技术
liveweb视频汇聚平台
11-15 290
一． 概述作为新一代视频编解码格式，H.265得到越来越广泛的应用。不久之前，苹果公司在翘首期盼中发布了iPhone6，该款手机较之以往的iPhone，不仅仅只是简单地增大了屏幕，其采用了H.265视频编码解码技术，可达到在有限带宽下传输更高质量的网络视频。虽然对于大部分人来讲，H.265还有点陌生，然而早在两年前，爱立信就已经推出了首款H.265编解码器。使用H.265编解码的一个巨大优势是仅需目前主流编码视频H.264一半的比特率，就可提供同等质量的视频。
X265的编码流程
dragon_dy的博客
09-08 4644
X265的编码主函数 int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out) 过程为： 1. 先将输入图像x265_picture* pic_in中的数据复制到内部帧结构Frame *inFrame，计算好其它帧信息 2. 调用m_lookahead->addPicture(*inFrame, slice
音视频编解码：使用X265编码视频
m0_73443478的博客
03-12 589
音视频编解码：使用X265编码视频
ffmpeg libx265 编译问题
ontheroad530的专栏
12-03 2915
编译ffmpeg --enable-libx265,configure 时出现错误： ERROR: x265 not found using pkg-config 查看config.log,错误详情如下： /usr/local/include/x265.h:104:5: error: unknown type n/usr/local/include/x265.hame 'bool'
FFMPEG-YUV编码为H264/H265
Hardy20200507的博客
05-13 558
流程## 标题下面附一张使用FFmpeg编码视频的流程图。使用该流程，不仅可以编码H.264的视频，而且可以编码MPEG4/MPEG2/VP8等等各种FFmpeg支持的视频。图中蓝色背景的函数是实际输出数据的函数。浅绿色的函数是视频编码的函数。 简单介绍一下流程中各个函数的意义： av_register_all()：注册FFmpeg所有编解码器。 avformat_alloc_output_context2()：初始化输出码流的AVFormatContext。 avio_open()：打开输出文件。
ffmpeg yuv 编码为h.265
06-20
### 回答1： FFmpeg是一款流媒体处理的工具，支持多种视频编码格式，其中也包括YUV编码。H.265是一种高效的视频编码格式，可以将视频文件的大小压缩至原来的一半。 要将YUV编码的视频文件转换为H.265编码，需要进行以下步骤： 1. 通过FFmpeg获取原始视频的YUV数据。 2. 将YUV数据进行处理，将其转换为H.265编码格式。此处需要使用x265编码器，以实现高质量的视频编码。 3. 将处理后的H.265编码数据转化为保存为视频文件。 在使用FFmpeg进行YUV编码为H.265的操作时，需要注意以下几点： 1. YUV数据的格式应该符合编码器的要求，否则将无法进行编码。 2. 编码参数的选择对于编码质量和压缩率都有很大影响，需要注意对应的参数设置。 3. H.265编码是比较耗时的操作，需要足够的计算机性能支持。 通过上述步骤，我们可以将YUV格式的视频文件转换为高效的H.265格式，实现更好的视频质量和更小的视频文件大小。 ### 回答2： FFmpeg是一个跨平台的音视频处理库，其中也包括了对YUV数据的处理和编码功能。而H.265是一种高效的视频编码标准，能够提供更好的视频质量和更小的文件大小。因此，将YUV数据编码为H.265对于提高视频编码的效率和质量非常重要。 在FFmpeg中，可以使用x265编码器来将YUV数据编码为H.265。首先，需要将YUV数据加载到FFmpeg中，并设置相应的编码器参数。然后，使用x265编码器对YUV数据进行压缩编码，并输出为H.265视频文件格式。 具体步骤如下： 1. 使用FFmpeg加载YUV数据，可以通过命令行输入以下命令： ffmpeg -s:v widthxheight -pix_fmt yuv420p -i input.yuv 其中，width和height分别表示YUV数据的宽度和高度，input.yuv为YUV数据的文件名。 2. 设置编码器参数，可以通过命令行指定编码器的参数，例如： ffmpeg -c:v libx265 -preset medium -x265-params keyint=60 -b:v 2M output.mp4 其中，-c:v表示指定使用x265编码器，-preset medium表示设置为中等压缩质量，-x265-params keyint=60表示设置关键帧间隔为60，-b:v 2M表示设置输出视频的比特率为2M，output.mp4表示输出为H.265视频文件。 3. 进行YUV编码，可以使用以下命令实现： ffmpeg -i input.yuv -c:v libx265 -preset medium -x265-params keyint=60 -b:v 2M output.mp4 其中，-i input.yuv表示输入YUV数据文件，-c:v libx265表示指定使用x265编码器进行编码，后续参数同上。 通过以上步骤，就可以将YUV数据编码为H.265格式的视频文件，从而利用H.265标准的高效性能优势来提高视频编码的效率和质量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值