ffmpeg实战教程（三）音频PCM采样为AAC，视频YUV编码为H264/HEVC

最新推荐文章于 2023-07-29 19:00:13 发布
最新推荐文章于 2023-07-29 19:00:13 发布
阅读量459 收藏
点赞数
分类专栏： 音视频

音频PCM采样数据编码为压缩码流（MP3，WMA，AAC等)

简单介绍一下流程中各个函数的意义：

av_register_all()：注册FFmpeg所有编解码器。

avformat_alloc_output_context2()：初始化输出码流的AVFormatContext。

avio_open()：打开输出文件。

av_new_stream()：创建输出码流的AVStream。

avcodec_find_encoder()：查找编码器。

avcodec_open2()：打开编码器。

avformat_write_header()：写文件头（对于某些没有文件头的封装格式，不需要此函数。比如说MPEG2TS）。

avcodec_encode_audio2()：编码音频。即将AVFrame（存储PCM采样数据）编码为AVPacket（存储AAC，MP3等格式的码流数据）。

av_write_frame()：将编码后的视频码流写入文件。

av_write_trailer()：写文件尾（对于某些没有文件头的封装格式，不需要此函数。比如说MPEG2TS）。

源代码如下：



#include <stdio.h>

#define __STDC_CONSTANT_MACROS

#ifdef _WIN32
//Windows
extern "C"
{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
};
#else
//Linux...
#ifdef __cplusplus
extern "C"
{
#endif
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#ifdef __cplusplus
};
#endif
#endif


int flush_encoder(AVFormatContext *fmt_ctx,unsigned int stream_index){
    int ret;
    int got_frame;
    AVPacket enc_pkt;
    if (!(fmt_ctx->streams[stream_index]->codec->codec->capabilities &
        CODEC_CAP_DELAY))
        return 0;
    while (1) {
        enc_pkt.data = NULL;
        enc_pkt.size = 0;
        av_init_packet(&enc_pkt);
        ret = avcodec_encode_audio2 (fmt_ctx->streams[stream_index]->codec, &enc_pkt,
            NULL, &got_frame);
        av_frame_free(NULL);
        if (ret < 0)
            break;
        if (!got_frame){
            ret=0;
            break;
        }
        printf("Flush Encoder: Succeed to encode 1 frame!\tsize:%5d\n",enc_pkt.size);
        /* mux encoded frame */
        ret = av_write_frame(fmt_ctx, &enc_pkt);
        if (ret < 0)
            break;
    }
    return ret;
}

int main(int argc, char* argv[])
{
    AVFormatContext* pFormatCtx;
    AVOutputFormat* fmt;
    AVStream* audio_st;
    AVCodecContext* pCodecCtx;
    AVCodec* pCodec;

    uint8_t* frame_buf;
    AVFrame* pFrame;
    AVPacket pkt;

    int got_frame=0;
    int ret=0;
    int size=0;

    FILE *in_file=NULL;                         //Raw PCM data
    int framenum=1000;                          //Audio frame number
    const char* out_file = "ws.aac";          //Output URL
    int i;

    in_file= fopen("ws.pcm", "rb");

    av_register_all();


    pFormatCtx = avformat_alloc_context();
    //得到最合适的AVOutputFormat并且返回给avformat_alloc_output_context2()，赋值给刚刚新建的AVFormatContext
    fmt = av_guess_format(NULL, out_file, NULL);
    pFormatCtx->oformat = fmt;


    //Open output URL 创建的AVIOContext结构体 打开输出文件
    if (avio_open(&pFormatCtx->pb,out_file, AVIO_FLAG_READ_WRITE) < 0){
        printf("Failed to open output file!\n");
        return -1;
    }
    //初始化AVFrame
    audio_st = avformat_new_stream(pFormatCtx, 0);
    if (audio_st==NULL){
        return -1;
    }
    pCodecCtx = audio_st->codec;
    pCodecCtx->codec_id = fmt->audio_codec;
    pCodecCtx->codec_type = AVMEDIA_TYPE_AUDIO;
    pCodecCtx->sample_fmt = AV_SAMPLE_FMT_S16;
    pCodecCtx->sample_rate= 44100;
    pCodecCtx->channel_layout=AV_CH_LAYOUT_STEREO;
    pCodecCtx->channels = av_get_channel_layout_nb_channels(pCodecCtx->channel_layout);
    pCodecCtx->bit_rate = 64000;  

    /*av_dump_format()是一个手工调试的函数，能使我们看到pFormatCtx->streams里面有什么内容。
        一般接下来我们使用av_find_stream_info()函数，它的作用是为pFormatCtx->streams填充上正确的信息。*/
    av_dump_format(pFormatCtx, 0, out_file, 1);

    pCodec = avcodec_find_encoder(pCodecCtx->codec_id);//查找编码器
    if (!pCodec){
        printf("Can not find encoder!\n");
        return -1;
    }
    if (avcodec_open2(pCodecCtx, pCodec,NULL) < 0){//初始化一个编解码器的AVCodecContext
        printf("Failed to open encoder!\n");
        return -1;
    }
    pFrame = av_frame_alloc();
    pFrame->nb_samples= pCodecCtx->frame_size;
    pFrame->format= pCodecCtx->sample_fmt;

    size = av_samples_get_buffer_size(NULL, pCodecCtx->channels,pCodecCtx->frame_size,pCodecCtx->sample_fmt, 1);
    frame_buf = (uint8_t *)av_malloc(size);
    avcodec_fill_audio_frame(pFrame, pCodecCtx->channels, pCodecCtx->sample_fmt,(const uint8_t*)frame_buf, size, 1);

    //Write Header
    avformat_write_header(pFormatCtx,NULL);

    av_new_packet(&pkt,size);

    for (i=0; i<framenum; i++){
        //Read PCM
        if (fread(frame_buf, 1, size, in_file) <= 0){
            printf("Failed to read raw data! \n");
            return -1;
        }else if(feof(in_file)){
            break;
        }
        pFrame->data[0] = frame_buf;  //PCM Data

        pFrame->pts=i*100;
        got_frame=0;
        //Encode
        ret = avcodec_encode_audio2(pCodecCtx, &pkt,pFrame, &got_frame);
        if(ret < 0){
            printf("Failed to encode!\n");
            return -1;
        }
        if (got_frame==1){
            printf("Succeed to encode 1 frame! \tsize:%5d\n",pkt.size);
            pkt.stream_index = audio_st->index;
            ret = av_write_frame(pFormatCtx, &pkt);
            av_free_packet(&pkt);
        }
    }

    //Flush Encoder
    ret = flush_encoder(pFormatCtx,0);
    if (ret < 0) {
        printf("Flushing encoder failed\n");
        return -1;
    }

    //Write Trailer
    av_write_trailer(pFormatCtx);

    //Clean
    if (audio_st){
        avcodec_close(audio_st->codec);
        av_free(pFrame);
        av_free(frame_buf);
    }
    avio_close(pFormatCtx->pb);
    avformat_free_context(pFormatCtx);

    fclose(in_file);

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185

程序运行完成后，会将跟目录中的一个PCM采样数据文件（ws.pcm）编码为AAC码流文件（ws.aac）。

const char* out_file = "ws.aac";     
in_file= fopen("ws.pcm", "rb");
  • 1
  • 2

下面我们实现将YUV数据编码为h264/h265

调用libavcodec将YUV数据编码为H.264/HEVC等格式的压缩视频码流。

关键函数： 
avcodec_register_all()：注册所有的编解码器。 
avcodec_find_encoder()：查找编码器。 
avcodec_alloc_context3()：为AVCodecContext分配内存，创建AVCodecContext结构体。 
avcodec_open2()：打开编码器。 
avcodec_encode_video2()：编码一帧数据。

两个存储数据的结构体如下所列：

AVFrame：存储一帧未编码的像素数据。
AVPacket：存储一帧压缩编码数据。

下面先看看运行效果： 
这里写图片描述 
可见运行程序后编码生成了ws.h264和ws.hevc文件，暴风竟然识别hevc文件(⊙o⊙)。



#include <stdio.h>

#define __STDC_CONSTANT_MACROS

#ifdef _WIN32
//Windows
extern "C"
{
#include "libavutil/opt.h"
#include "libavcodec/avcodec.h"
#include "libavutil/imgutils.h"
};
#else
//Linux...
#ifdef __cplusplus
extern "C"
{
#endif
#include <libavutil/opt.h>
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#ifdef __cplusplus
};
#endif
#endif

//test different codec
#define TEST_H264  0
#define TEST_HEVC  1


int main(int argc, char* argv[])
{
    AVCodec *pCodec;
    AVCodecContext *pCodecCtx= NULL;
    int i, ret, got_output;
    FILE *fp_in;
    FILE *fp_out;
    AVFrame *pFrame;
    AVPacket pkt;
    int y_size;
    int framecnt=0;

    char filename_in[]="ws_output.yuv";

#if TEST_HEVC
    AVCodecID codec_id=AV_CODEC_ID_HEVC;
    char filename_out[]="ws.hevc";
#else
    AVCodecID codec_id=AV_CODEC_ID_H264;
    char filename_out[]="ws.h264";
#endif


    int in_w=480,in_h=272;  
    int framenum=100;   

    avcodec_register_all();

    pCodec = avcodec_find_encoder(codec_id);
    if (!pCodec) {
        printf("Codec not found\n");
        return -1;
    }
    pCodecCtx = avcodec_alloc_context3(pCodec);
    if (!pCodecCtx) {
        printf("Could not allocate video codec context\n");
        return -1;
    }
    pCodecCtx->bit_rate = 400000;
    pCodecCtx->width = in_w;
    pCodecCtx->height = in_h;
    pCodecCtx->time_base.num=1;
    pCodecCtx->time_base.den=25;
    pCodecCtx->gop_size = 10;
    pCodecCtx->max_b_frames = 1;
    pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;

    if (codec_id == AV_CODEC_ID_H264)
        av_opt_set(pCodecCtx->priv_data, "preset", "slow", 0);

    if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
        printf("Could not open codec\n");
        return -1;
    }

    pFrame = av_frame_alloc();
    if (!pFrame) {
        printf("Could not allocate video frame\n");
        return -1;
    }
    pFrame->format = pCodecCtx->pix_fmt;
    pFrame->width  = pCodecCtx->width;
    pFrame->height = pCodecCtx->height;

    ret = av_image_alloc(pFrame->data, pFrame->linesize, pCodecCtx->width, pCodecCtx->height,
                         pCodecCtx->pix_fmt, 16);
    if (ret < 0) {
        printf("Could not allocate raw picture buffer\n");
        return -1;
    }
    //Input raw data
    fp_in = fopen(filename_in, "rb");
    if (!fp_in) {
        printf("Could not open %s\n", filename_in);
        return -1;
    }
    //Output bitstream
    fp_out = fopen(filename_out, "wb");
    if (!fp_out) {
        printf("Could not open %s\n", filename_out);
        return -1;
    }

    y_size = pCodecCtx->width * pCodecCtx->height;
    //Encode
    for (i = 0; i < framenum; i++) {
        av_init_packet(&pkt);
        pkt.data = NULL;    // packet data will be allocated by the encoder
        pkt.size = 0;
        //Read raw YUV data
        if (fread(pFrame->data[0],1,y_size,fp_in)<= 0||     // Y
            fread(pFrame->data[1],1,y_size/4,fp_in)<= 0||   // U
            fread(pFrame->data[2],1,y_size/4,fp_in)<= 0){   // V
            return -1;
        }else if(feof(fp_in)){
            break;
        }

        pFrame->pts = i;
        /* encode the image */
        ret = avcodec_encode_video2(pCodecCtx, &pkt, pFrame, &got_output);
        if (ret < 0) {
            printf("Error encoding frame\n");
            return -1;
        }
        if (got_output) {
            printf("Succeed to encode frame: %5d\tsize:%5d\n",framecnt,pkt.size);
            framecnt++;
            fwrite(pkt.data, 1, pkt.size, fp_out);
            av_free_packet(&pkt);
        }
    }
    //Flush Encoder
    for (got_output = 1; got_output; i++) {
        ret = avcodec_encode_video2(pCodecCtx, &pkt, NULL, &got_output);
        if (ret < 0) {
            printf("Error encoding frame\n");
            return -1;
        }
        if (got_output) {
            printf("Flush Encoder: Succeed to encode 1 frame!\tsize:%5d\n",pkt.size);
            fwrite(pkt.data, 1, pkt.size, fp_out);
            av_free_packet(&pkt);
        }
    }

    fclose(fp_out);
    avcodec_close(pCodecCtx);
    av_free(pCodecCtx);
    av_freep(&pFrame->data[0]);
    av_frame_free(&pFrame);

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169

注意： 
当TEST_H264设置为1的时候，编码H.264文件。 
当TEST_HEVC设置为1的时候，解码HEVC文件。

#define TEST_H264  0  
#define TEST_HEVC  1
Louis_815
关注
专栏目录
FFmpeg PCM 编码 AAC
Hanyang Li的专栏
04-24 1305
FFmpeg PCM 编码 AAC
使用ffmpeg对PCM音频进行重采样demo(单通道重采样为双通道)
01-13
该资源使用ffmpeg对pcm音频进行重采样(频率变换),目前这个demo能够实现单通道重采样为双通道的音频数据，使用的是ffmpeg的重采样接口进行不是单纯的字符串操作。如果需要学习参考重采样方面的可以查看我的关于重采样方面的博客
ffmpeg音频采集、编码
weixin_42769449的博客
01-10 3249
不同于视频采集一帧编码一帧，音频采集和编码之间稍微复杂一些，记录下相关内容 音频采集 在windows上获取音频的方法，主要尝试了2种，效果差不多。一种是通过ffmpeg的dshow获取，另一种是直接从windows的Core Audio API 来获取。通过这两种方式采集到的音频的采样率都是当前声音播放的扬声器的采样率。 ffmpeg dshow 采集 使用dshow抓屏需要安装抓屏软件：screen-capture-recorder。 在命令行用dshow: ffmpeg -f dshow -i vid
音视频处理 ffmpeg中级开发 AAC编码
CHYabc123456hh的博客
05-14 1611
介绍 编码流程类似于视频编码，1，查找编码器；2，设定参数，打开编码器；3，数据编码 编码函数 avcodec_encode_audio2 已经被弃用 FFmpeg 过时 Api 汇总整理 - 灰色飘零 - 博客园 未成功 使用 旧版本 if (avcodec_encode_audio2(tmpAvCodecCtx, &pkt_out, frame, &got_picture) < 0) 新版本 if(avcodec_send_frame(tmpAvCodecC.
ffmpeg之PCM转AAC
08-12 6799
AAC是一种常见的音频格式，今天尝试使用ffmpeg把pcm压缩成AAC编码。 第一步：初始化编码相关变量 寻找AAC的编码器 codec = avcodec_find_encoder(AV_CODEC_ID_AAC);  初始化编码器上下文，主要通道数，采样率，采样格式 c = avcodec_alloc_context3(codec); if (!c) { fprintf...
【FFmpeg】录音并编码aac
show me the code.
05-31 1355
FFmpeg对麦克风进行音频采样，重采样保存为pcm，并编码为aac
【FFmpeg】PCM编码成AAC
irainsa的博客
03-01 2186
使用FFmpeg把PCM裸数据编码成AAC音频流，具体步骤跟YUV编码成H264差不多。
ffmpeg pcm转化为aac
qq_15255121的专栏
04-24 1453
我们先看一张pcm转化为aac的流程图 我们根据流程图 第一步获取AVOutputFormat ff_const59 AVOutputFormat *av_guess_format(const char *short_name, const char *filename, const char *...
ffmpeg-非压缩数据编码 YUV转h264/h265 PCM转AAC
qq_42024067的博客
02-05 801
源自ffmpeg实战教程（三）音频PCM采样为AAC，视频YUV编码为H264/HEVC 1、没有使用AVFormatContext 2、一帧图像的Y U V 独立读取，独立编码，独立写入？ 关键代码： #if TEST_HEVC AVCodecID codec_id=AV_CODEC_ID_HEVC; char filename_out[]="ws.hevc"; #else ...
FFmpeg编码（YUV转H264）并改变视频分辨率示例
zcc的博客
03-18 5999
最简单的基于FFmpeg的编码器-纯净版（不包含libavformat）_雷霄骅的博客-CSDN博客_ffmpeg 编码器 初学音视频、ffmpeg。根据雷神的例子跑起来，调用libavcodec将YUV像素数据（YUV420P）编码为H.264码流，H.265为（HEVC）。 视频编码： 视频编码方式就是指通过特定的压缩技术，将某个视频格式的文件转换成另一种视频格式文件的方式。视频编码格式常见到的有：MPEG-2TS、Divx、Xvid、H.264、WMV-HD和VC-1。 原始的图像和声音是需.
音视频开发基础概述 - PCM、YUV、H264、常用软件介绍
我的学习笔记
07-28 9801
前言 相对而言，音视频开发应该算门槛稍高的，记得我刚开始学习的时候，看别人的博客几乎都看不懂。后来总结了一下，看不懂的原因是没有掌握相关基础知识，比如一些概念（码率、采样率、帧率等），音视频中的颜色格式（RGB、YUV）、音频格式（PCM）等，写代码之前不了解这些，会写得非常痛苦——因为你不知道为什么要这么写，也不知道写出来的效果是怎样的。 基础概念 声波 声波有三要素： 1) 频率，代...
FFmpeg 把pcm音频转换为aac
最新发布
a15929748502的博客
07-29 817
【代码】FFmpeg 把pcm音频转换为aac。
FFmpeg 解码 AAC 格式的音频
洪伟的专栏
12-26 5117
FFmpeg 默认是可以解码 AAC 格式的音频，但是如果需要获取 PCM16 此类数据则需要经过音频转码。首先要打开解码器，然后向解码器发送 AAC 音频帧（不带 ADTS），然后从解码器获取解码后的音频帧，数据是 float 类型的，如果需要则进行转码流程将 float 转成整型。 一、AAC 音频 AAC 是高级音频编码（Advanced Audio Coding）的缩写，出现于 1997 年，最初是基于 MPEG-2 的音频编码技术。由Fraunhofer IIS、Dolby Laboratorie
把h264图像数据和pcm声音数据组合成avi格式
SunnyChen的专栏
01-13 1893
http://115.com/file/e6ta40co#
使用FFMPEG库将PCM编码为AAC
yunxiaobaobei的博客
04-20 1114
2.关于比特率，比特率影响的是播放时编码后的数据每秒传递给解码器的数据量，比如比特率128kb/s,那么每秒就会给解码器发送128000 / 8 = 1600个字节的数据，注意这1600个数据是压缩数据，其中是很多的未解码的包（avpacket）， 那么这1600个数据最终会被解码成48000 * 2个字节的数据(双通道)。同时我们播放时发现，过大的比特率编码器并未采用，说明当比特率大于某一个值时，编码器不会丢弃数据，此时将压缩后的数据直接生成文件，而后比特率值有编码器计算后设置。
FFmpeg开发(1)：pcm-＞aac
weixin_63572056的博客
07-25 298
FFmpeg开发(1)：编码pcm-＞aac
使用ffmpeg转码pcm至aac格式
热门推荐
Arbboter的专栏
01-23 1万+
准备工作 去官网下载源码自己编译所需要的库，或者直接从官网下载已经编写好的库，由于本例是Window平台下的开发，而官网已经有了编译好的库，所以直接下载编译所需要的库文件即可。下载地址：需要下载两个压缩包，Dev版本和Shared版本，其中Dev版本是头文件和lib库文件，Shared是包含运行所需要的dll文件。 下载完成后，需要把这些头文件、静态库、动态链接库引入到我们的工程里面，不过在W
实现用FFmpeg接收RTSP，把H264视频和AAC音频录制成MP4文件（附完整代码）
m0_37346206的博客
07-02 1296
FFmpeg支持Rtsp接收功能，并且相关的协议实现已经很完善了，另外它也支持保存文件的功能，这里我就向大家介绍怎么用它的API来实现这两个功能。 我把接收RTSP和录制文件的逻辑都用一个类RtspStreamMuxTask来处理，下面给出这个类的头文件和源文件。 RtspStreamMuxTask.h文件: #ifndef RtspStreamMuxTask_H #define ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值