FFmpeg开发 Windows环境集成AVS3解码器完整指南

于 2025-07-26 00:18:15 发布
阅读量347 收藏 6
点赞数 3
CC 4.0 BY-SA版权
分类专栏： FFmpeg 学习 文章标签： ffmpeg windows avs3 解码器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/149607697

FFmpeg开发 Windows环境集成AVS3解码器完整指南

概览流程

环境准备 → AVS3库安装 → FFmpeg编译 → AVS3支持 → 验证测试 → 开发集成

环境准备

安装MSYS2环境

# 1. 下载并安装MSYS2
# 访问 https://www.msys2.org/ 下载安装包
# 安装完成后运行 MSYS2 UCRT64

# 2. 更新系统包
pacman -Syu
pacman -Su

# 3. 安装编译工具链
pacman -S mingw-w64-ucrt-x86_64-toolchain
pacman -S mingw-w64-ucrt-x86_64-pkg-config
pacman -S make
pacman -S mingw-w64-ucrt-x86_64-yasm
pacman -S mingw-w64-ucrt-x86_64-nasm
pacman -S git
pacman -S mingw-w64-ucrt-x86_64-cmake
pacman -S mingw-w64-ucrt-x86_64-python

创建工作目录

# 在MSYS2环境中创建目录
mkdir -p /c/ffmpeg_dev/{sources,build,output}
cd /c/ffmpeg_dev

AVS3解码器安装

获取AVS3参考软件

# 注意：AVS3是国产视频编码标准，需要从官方渠道获取解码器
# 由于AVS3的版权和许可限制，这里提供通用的集成方法

# 方案1：使用开源AVS解码器（AVS/AVS2兼容）
cd /c/ffmpeg_dev/sources

# 下载开源AVS解码器（示例）
git clone https://github.com/AVS-Decoder/AVS3Decoder.git
# 或者使用其他开源实现

编译AVS3解码器库

# 如果有AVS3解码器源码，编译步骤如下：
cd /c/ffmpeg_dev/sources/AVS3Decoder

# 创建构建目录
mkdir -p build
cd build

# 配置CMake
cmake .. \
    -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_INSTALL_PREFIX=/c/ffmpeg_dev/build/avs3 \
    -DCMAKE_TOOLCHAIN_FILE=/ucrt64/share/cmake/toolchain-x86_64-w64-mingw32.cmake

# 编译和安装
make -j$(nproc)
make install

使用预编译的AVS3库

# 如果有预编译的AVS3库文件，直接复制到指定目录
mkdir -p /c/ffmpeg_dev/build/avs3/{include,lib}

# 复制头文件和库文件（示例路径）
# cp /path/to/avs3/include/*.h /c/ffmpeg_dev/build/avs3/include/
# cp /path/to/avs3/lib/*.lib /c/ffmpeg_dev/build/avs3/lib/
# cp /path/to/avs3/lib/*.dll /c/ffmpeg_dev/build/avs3/lib/

FFmpeg源码编译（集成AVS3）

下载FFmpeg源码

# 进入源码目录
cd /c/ffmpeg_dev/sources

# 克隆FFmpeg源码
if [ ! -d "ffmpeg" ]; then
    git clone https://git.ffmpeg.org/ffmpeg.git
fi
cd ffmpeg

修改FFmpeg源码支持AVS3

# 由于AVS3支持可能需要自定义修改，创建补丁文件
cat > avs3_support.patch << 'EOF'
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index xxxxxxx..xxxxxxx 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -123,6 +123,7 @@ OBJS-$(CONFIG_AVRP_ENCODER)            += avrpenc.o
 OBJS-$(CONFIG_AVRN_DECODER)            += avrndec.o
 OBJS-$(CONFIG_AVS2_DECODER)            += avs2dec.o
 OBJS-$(CONFIG_AVS_DECODER)             += avsdec.o
+OBJS-$(CONFIG_AVS3_DECODER)            += avs3dec.o
 
 # hardware accelerators
 OBJS-$(CONFIG_H263_VAAPI_HWACCEL)      += vaapi_mpeg.c
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index xxxxxxx..xxxxxxx 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -78,6 +78,7 @@ extern const AVCodec ff_avrp_encoder;
 extern const AVCodec ff_avrn_decoder;
 extern const AVCodec ff_avs2_decoder;
 extern const AVCodec ff_avs_decoder;
+extern const AVCodec ff_avs3_decoder;
 
 /* audio codecs */
 extern const AVCodec ff_aac_decoder;
EOF

创建AVS3解码器实现

# 创建AVS3解码器源文件
cat > libavcodec/avs3dec.c << 'EOF'
/*
 * AVS3 (Audio Video coding Standard 3) decoder
 * Copyright (c) 2023 Your Company
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 */

#include "avcodec.h"
#include "internal.h"
#include "decode.h"

// 如果有AVS3库头文件，包含它
// #include "avs3/avs3.h"

typedef struct AVS3Context {
    AVClass *class;
    // AVS3解码器上下文
    void *decoder_handle;
    // 其他需要的变量
} AVS3Context;

static av_cold int avs3_decode_init(AVCodecContext *avctx)
{
    AVS3Context *s = avctx->priv_data;
    
    av_log(avctx, AV_LOG_INFO, "AVS3 decoder initialization\n");
    
    // 初始化AVS3解码器
    // s->decoder_handle = avs3_decoder_init();
    // if (!s->decoder_handle) {
    //     av_log(avctx, AV_LOG_ERROR, "Failed to initialize AVS3 decoder\n");
    //     return AVERROR_EXTERNAL;
    // }
    
    // 设置解码参数
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
    
    return 0;
}

static int avs3_decode_frame(AVCodecContext *avctx, void *data,
                            int *got_frame, AVPacket *avpkt)
{
    AVS3Context *s = avctx->priv_data;
    AVFrame *frame = data;
    int ret;
    
    av_log(avctx, AV_LOG_DEBUG, "AVS3 decoding frame, size=%d\n", avpkt->size);
    
    // 调用AVS3解码器解码
    // ret = avs3_decode_frame(s->decoder_handle, avpkt->data, avpkt->size, frame);
    // if (ret < 0) {
    //     av_log(avctx, AV_LOG_ERROR, "AVS3 decoding failed\n");
    //     return ret;
    // }
    
    *got_frame = 1;
    return avpkt->size;
}

static av_cold int avs3_decode_end(AVCodecContext *avctx)
{
    AVS3Context *s = avctx->priv_data;
    
    av_log(avctx, AV_LOG_INFO, "AVS3 decoder cleanup\n");
    
    // 清理AVS3解码器
    // if (s->decoder_handle) {
    //     avs3_decoder_destroy(s->decoder_handle);
    //     s->decoder_handle = NULL;
    // }
    
    return 0;
}

static const AVClass avs3_decoder_class = {
    .class_name = "avs3 decoder",
    .item_name  = av_default_item_name,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_avs3_decoder = {
    .name           = "avs3",
    .long_name      = NULL_IF_CONFIG_SMALL("AVS3 (Audio Video coding Standard 3)"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_AVS3,
    .priv_data_size = sizeof(AVS3Context),
    .init           = avs3_decode_init,
    .decode         = avs3_decode_frame,
    .close          = avs3_decode_end,
    .capabilities   = AV_CODEC_CAP_DR1,
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
    .priv_class     = &avs3_decoder_class,
};
EOF

配置FFmpeg（启用AVS3支持）

# 配置FFmpeg编译选项
./configure \
    --prefix=/c/ffmpeg_dev/output \
    --enable-shared \
    --enable-static \
    --enable-gpl \
    --enable-nonfree \
    --enable-version3 \
    --enable-runtime-cpudetect \
    --enable-postproc \
    --enable-avfilter \
    --enable-pthreads \
    --enable-network \
    --enable-decoder=avs3 \
    --enable-parser=h264,hevc,avs3 \
    --enable-demuxer=avs,avs2,avs3 \
    --enable-protocol=file,http,https \
    --arch=x86_64 \
    --target-os=mingw32 \
    --cross-prefix=x86_64-w64-mingw32- \
    --extra-cflags="-I/c/ffmpeg_dev/build/avs3/include" \
    --extra-ldflags="-L/c/ffmpeg_dev/build/avs3/lib" \
    --extra-libs="-lavs3 -lpthread -lm"

编译和安装

# 应用补丁（如果有）
# patch -p1 < avs3_support.patch

# 清理之前的构建
make clean

# 并行编译
make -j$(nproc)

# 安装到指定目录
make install

使用vcpkg编译（推荐方法）

安装vcpkg

# 在Windows命令提示符中执行
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
bootstrap-vcpkg.bat

注意：AVS3支持在vcpkg中的情况

# 检查vcpkg中是否有AVS3支持
vcpkg search avs3

# 如果没有官方支持，需要自定义端口
# 或者使用基础FFmpeg包
vcpkg install ffmpeg[core]:x64-windows

完整构建脚本

# 创建完整构建脚本
cat > build_ffmpeg_windows_avs3.sh << 'EOF'
#!/bin/bash

# 设置环境变量
WORK_DIR=/c/ffmpeg_dev
SOURCES_DIR=$WORK_DIR/sources
BUILD_DIR=$WORK_DIR/build
OUTPUT_DIR=$WORK_DIR/output

# 创建目录结构
mkdir -p $SOURCES_DIR $BUILD_DIR $OUTPUT_DIR

echo "开始FFmpeg AVS3集成编译..."

# 安装依赖包
echo "安装依赖库..."
pacman -Syu --noconfirm
pacman -S --noconfirm \
    mingw-w64-ucrt-x86_64-toolchain \
    mingw-w64-ucrt-x86_64-pkg-config \
    make \
    mingw-w64-ucrt-x86_64-yasm \
    mingw-w64-ucrt-x86_64-nasm \
    git \
    mingw-w64-ucrt-x86_64-cmake

# 检查AVS3库是否存在
if [ ! -d "/c/ffmpeg_dev/build/avs3" ]; then
    echo "警告: AVS3库未找到，请先安装AVS3解码器库"
    echo "继续编译基础FFmpeg..."
fi

# 下载FFmpeg源码
cd $SOURCES_DIR
if [ ! -d "ffmpeg" ]; then
    git clone https://git.ffmpeg.org/ffmpeg.git
fi
cd ffmpeg

# 配置FFmpeg（基础配置，AVS3需要自定义）
echo "配置FFmpeg..."
./configure \
    --prefix=$OUTPUT_DIR \
    --enable-shared \
    --enable-static \
    --enable-gpl \
    --enable-nonfree \
    --enable-version3 \
    --enable-runtime-cpudetect \
    --enable-postproc \
    --enable-avfilter \
    --enable-pthreads \
    --enable-network \
    --enable-libx264 \
    --enable-libx265 \
    --enable-decoder=h264,hevc,mpeg4,avs,avs2 \
    --enable-encoder=libx264,libx265,mpeg4 \
    --enable-parser=h264,hevc,mpeg4video \
    --enable-demuxer=h264,hevc,mp4,mov,avs,avs2 \
    --enable-muxer=mp4,mov \
    --enable-protocol=file,http,https \
    --arch=x86_64 \
    --target-os=mingw32 \
    --cross-prefix=x86_64-w64-mingw32- \
    --extra-libs="-lpthread -lm"

# 编译和安装
echo "编译FFmpeg..."
make clean
make -j$(nproc)
make install

echo "FFmpeg编译完成！"
echo "输出目录: $OUTPUT_DIR"
echo "可执行文件: $OUTPUT_DIR/bin/ffmpeg.exe"
EOF

chmod +x build_ffmpeg_windows_avs3.sh

验证安装

功能验证脚本

# 创建验证脚本
cat > verify_ffmpeg_avs3.sh << 'EOF'
#!/bin/bash

OUTPUT_DIR=/c/ffmpeg_dev/output
FFMPEG_EXE=$OUTPUT_DIR/bin/ffmpeg.exe

echo "验证FFmpeg AVS3功能支持"

# 检查FFmpeg是否可执行
if [ ! -f "$FFMPEG_EXE" ]; then
    echo "错误: FFmpeg未找到"
    exit 1
fi

echo "FFmpeg可执行文件存在"

# 检查AVS相关支持
echo "检查AVS支持..."
$FFMPEG_EXE -decoders | grep avs > /dev/null && echo "✓ AVS解码器支持正常" || echo "✗ AVS解码器支持异常"
$FFMPEG_EXE -demuxers | grep avs > /dev/null && echo "✓ AVS容器支持正常" || echo "✗ AVS容器支持异常"

# 显示版本信息
echo "FFmpeg版本信息:"
$FFMPEG_EXE -version | head -5

# 显示编译配置
echo "AVS编译配置:"
$FFMPEG_EXE -buildconf | grep -i avs

echo "验证完成"
EOF

chmod +x verify_ffmpeg_avs3.sh

测试AVS3功能

# AVS3解码测试（需要AVS3文件）
test_avs3_decoding() {
    echo "测试AVS3解码功能..."
    
    # 检查是否有测试文件
    if [ ! -f "test_avs3.avs3" ]; then
        echo "警告: AVS3测试文件不存在，跳过测试"
        return
    fi
    
    # AVS3解码测试
    /c/ffmpeg_dev/output/bin/ffmpeg.exe \
        -i test_avs3.avs3 \
        -f null -
    
    if [ $? -eq 0 ]; then
        echo "AVS3解码测试成功"
    else
        echo "AVS3解码测试失败"
    fi
}

# AVS兼容性测试
test_avs_compatibility() {
    echo "测试AVS兼容性..."
    
    # 创建AVS测试文件（如果需要）
    /c/ffmpeg_dev/output/bin/ffmpeg.exe \
        -f lavfi -i testsrc=duration=5:size=720x576:rate=25 \
        -c:v rawvideo -pix_fmt yuv420p \
        -f rawvideo test_avs.yuv
    
    if [ -f "test_avs.yuv" ]; then
        echo "AVS兼容性测试文件创建成功"
        rm test_avs.yuv
    else
        echo "AVS兼容性测试文件创建失败"
    fi
}

Visual Studio开发集成

项目配置

// 在Visual Studio项目属性中设置：

// 包含目录：
// C:\ffmpeg_dev\output\include

// 库目录：
// C:\ffmpeg_dev\output\lib

// 附加依赖项：
// avformat.lib
// avcodec.lib
// avutil.lib
// swscale.lib
// swresample.lib
// avfilter.lib
// avdevice.lib

CMake配置

# CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(FFmpegAVS3Test)

set(CMAKE_CXX_STANDARD 17)

# FFmpeg配置
set(FFMPEG_ROOT "C:/ffmpeg_dev/output")

# 包含目录
include_directories(${FFMPEG_ROOT}/include)

# 库目录
link_directories(${FFMPEG_ROOT}/lib)

# 源文件
add_executable(${PROJECT_NAME} main.cpp)

# 链接库
target_link_libraries(${PROJECT_NAME}
    avformat
    avcodec
    avutil
    swscale
    swresample
    avfilter
    avdevice
)

# 复制DLL文件到输出目录
file(GLOB FFMPEG_DLLS "${FFMPEG_ROOT}/bin/*.dll")
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    ${FFMPEG_DLLS}
    $<TARGET_FILE_DIR:${PROJECT_NAME}>
)

AVS3处理示例代码

// avs3_example.cpp - AVS3处理示例
extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/avutil.h>
}

#include <iostream>
#include <string>

class AVS3Processor {
private:
    AVFormatContext* format_ctx;
    AVCodecContext* codec_ctx;
    const AVCodec* codec;

public:
    AVS3Processor() : format_ctx(nullptr), codec_ctx(nullptr), codec(nullptr) {}
    
    ~AVS3Processor() {
        cleanup();
    }
    
    bool checkAVS3Support() {
        std::cout << "检查AVS3支持..." << std::endl;
        
        // 检查AVS3解码器
        const AVCodec* avs3_codec = avcodec_find_decoder(AV_CODEC_ID_AVS3);
        if (avs3_codec) {
            std::cout << "AVS3解码器: " << avs3_codec->name << std::endl;
            return true;
        } else {
            std::cout << "AVS3解码器不可用" << std::endl;
            
            // 检查AVS/AVS2支持作为备选
            const AVCodec* avs_codec = avcodec_find_decoder(AV_CODEC_ID_AVS);
            const AVCodec* avs2_codec = avcodec_find_decoder(AV_CODEC_ID_AVS2);
            
            if (avs_codec) {
                std::cout << "AVS解码器: " << avs_codec->name << std::endl;
            }
            if (avs2_codec) {
                std::cout << "AVS2解码器: " << avs2_codec->name << std::endl;
            }
            
            return (avs_codec != nullptr || avs2_codec != nullptr);
        }
    }
    
    bool openAVS3File(const std::string& filename) {
        // 打开输入文件
        int ret = avformat_open_input(&format_ctx, filename.c_str(), NULL, NULL);
        if (ret < 0) {
            std::cerr << "无法打开文件: " << filename << std::endl;
            return false;
        }
        
        // 获取流信息
        ret = avformat_find_stream_info(format_ctx, NULL);
        if (ret < 0) {
            std::cerr << "无法获取流信息" << std::endl;
            return false;
        }
        
        // 查找视频流
        int video_stream_index = -1;
        for (unsigned int i = 0; i < format_ctx->nb_streams; i++) {
            if (format_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
                video_stream_index = i;
                break;
            }
        }
        
        if (video_stream_index == -1) {
            std::cerr << "未找到视频流" << std::endl;
            return false;
        }
        
        // 查找解码器
        AVCodecID codec_id = format_ctx->streams[video_stream_index]->codecpar->codec_id;
        codec = avcodec_find_decoder(codec_id);
        if (!codec) {
            std::cerr << "未找到解码器" << std::endl;
            return false;
        }
        
        // 创建解码器上下文
        codec_ctx = avcodec_alloc_context3(codec);
        if (!codec_ctx) {
            std::cerr << "无法分配解码器上下文" << std::endl;
            return false;
        }
        
        // 复制编解码器参数到解码器上下文
        ret = avcodec_parameters_to_context(codec_ctx, format_ctx->streams[video_stream_index]->codecpar);
        if (ret < 0) {
            std::cerr << "无法复制编解码器参数" << std::endl;
            return false;
        }
        
        // 打开解码器
        ret = avcodec_open2(codec_ctx, codec, NULL);
        if (ret < 0) {
            std::cerr << "无法打开解码器" << std::endl;
            return false;
        }
        
        std::cout << "成功打开AVS3文件: " << filename << std::endl;
        return true;
    }
    
    void printFileInfo() {
        if (!format_ctx) return;
        
        std::cout << "文件信息:" << std::endl;
        std::cout << "  格式: " << format_ctx->iformat->name << std::endl;
        std::cout << "  流数: " << format_ctx->nb_streams << std::endl;
        
        for (unsigned int i = 0; i < format_ctx->nb_streams; i++) {
            AVStream* stream = format_ctx->streams[i];
            if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
                std::cout << "  视频流 " << i << ":" << std::endl;
                std::cout << "    编解码器: " << avcodec_get_name(stream->codecpar->codec_id) << std::endl;
                std::cout << "    分辨率: " << stream->codecpar->width << "x" << stream->codecpar->height << std::endl;
                std::cout << "    帧率: " << av_q2d(stream->avg_frame_rate) << " fps" << std::endl;
            }
        }
    }
    
    void cleanup() {
        if (codec_ctx) {
            avcodec_free_context(&codec_ctx);
            codec_ctx = nullptr;
        }
        if (format_ctx) {
            avformat_close_input(&format_ctx);
            format_ctx = nullptr;
        }
    }
};

int main() {
    std::cout << "FFmpeg AVS3处理示例" << std::endl;
    
    AVS3Processor processor;
    
    // 检查AVS3支持
    if (!processor.checkAVS3Support()) {
        std::cout << "AVS3支持检查失败" << std::endl;
        return -1;
    }
    
    // 如果有AVS3文件，可以进行测试
    // if (processor.openAVS3File("test.avs3")) {
    //     processor.printFileInfo();
    // }
    
    std::cout << "AVS3支持测试完成" << std::endl;
    return 0;
}

环境变量配置

# 在Windows系统环境变量中添加：

# 系统PATH变量添加：
C:\ffmpeg_dev\output\bin

# 创建批处理文件设置环境
@echo off
set PATH=C:\ffmpeg_dev\output\bin;%PATH%
set FFmpeg_HOME=C:\ffmpeg_dev\output
echo 环境变量已设置

常见问题解决

1. AVS3库缺失

# 检查AVS3库是否存在
ls /c/ffmpeg_dev/build/avs3/lib/
ls /c/ffmpeg_dev/build/avs3/include/

# 如果缺失，需要联系AVS3官方获取授权库

2. 编译错误

# 检查编译错误
make V=1

# 确保包含路径正确
# 在编译命令中添加 -I 参数

3. 运行时错误

# 复制必要的DLL到可执行文件目录
copy C:\ffmpeg_dev\output\bin\*.dll .\

4. 解码器不可用

# 检查FFmpeg编译配置
/c/ffmpeg_dev/output/bin/ffmpeg.exe -buildconf | grep -i avs
/c/ffmpeg_dev/output/bin/ffmpeg.exe -decoders | grep avs

# 如果显示disable，则需要重新编译

5. 文件格式不支持

# 检查支持的容器格式
/c/ffmpeg_dev/output/bin/ffmpeg.exe -demuxers | grep avs

# 创建测试AVS文件
/c/ffmpeg_dev/output/bin/ffmpeg.exe -f lavfi -i testsrc=duration=5:size=720x576:rate=25 -c:v rawvideo test.avs

性能优化建议

编译优化选项

# 性能优化编译配置
./configure \
    --prefix=/c/ffmpeg_dev/output \
    --enable-shared \
    --enable-static \
    --enable-optimizations \
    --disable-debug \
    --enable-stripping \
    --enable-small \
    --extra-cflags="-O3 -ffast-math -march=native" \
    --extra-ldflags="-s" \
    # AVS3相关配置

运行时优化

# 设置环境变量优化性能
set FFmpeg_THREADS=0  # 自动检测CPU核心数

AVS3特殊说明

由于AVS3是国产视频编码标准，其解码器库可能需要：

  1. 官方授权：联系AVS工作组或相关厂商获取解码器库
  2. 商业许可：某些实现可能需要商业许可
  3. 专利考虑：注意相关的专利问题

替代方案

如果无法获得AVS3解码器，可以考虑：

# 使用AVS/AVS2支持作为替代
# FFmpeg已内置AVS和AVS2支持
/c/ffmpeg_dev/output/bin/ffmpeg.exe -decoders | grep avs

完成这些配置后，你就可以在Windows环境下使用带有AVS3支持的FFmpeg进行开发了。需要注意的是，AVS3的具体实现可能需要官方授权的解码器库。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值