ffmpeg彩色转灰色(黑白)

最新推荐文章于 2025-03-04 12:18:17 发布
最新推荐文章于 2025-03-04 12:18:17 发布
阅读量4.1k 收藏 3
点赞数 1
文章标签： 音视频 图像处理 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tusong86/article/details/122991525
版权
本文介绍了如何在FFmpeg中读取并处理YUV格式的图片，通过清除色度信息（UV分量设为128）实现灰度转换，展示了关键的内存操作和编码处理流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

ffmpeg中一般图像视频编解码中像素格式用的是yuv，其中y是亮度(灰度)，uv表示色度，当没有uv时，彩色就变成了黑白色。
ffmpeg读取的图片yuv分量中，是经过量化后的，所谓量化，是指将范围固定到某一范围，此时y,u,v取值128，才表示此分量真正没有。

所以对读取到图片，进行下面的处理

memset(pFrameVideoA->data[1], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);
memset(pFrameVideoA->data[2], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);

则相当于清除了色度信息。

代码结构如下：
在这里插入图片描述
其中FfmpegConvertToGray.cpp的代码如下：

#include <iostream>
#include "ConvertToGray.h"

#ifdef	__cplusplus
extern "C"
{
#endif

#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avformat.lib")
#pragma comment(lib, "avutil.lib")
#pragma comment(lib, "avdevice.lib")
#pragma comment(lib, "avfilter.lib")
#pragma comment(lib, "postproc.lib")
#pragma comment(lib, "swresample.lib")
#pragma comment(lib, "swscale.lib")


#ifdef __cplusplus
};
#endif





int main()
{
	CConvertToGray cConvertToGray;
	const char *pFileA = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\in-vs.mp4";

	const char *pFileOut = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\out-gray.mp4";
	cConvertToGray.StartConvertToGray(pFileA, pFileOut);
	cConvertToGray.WaitFinish();
	return 0;
}

ConvertToGray.h的代码如下：

#pragma once

#include <Windows.h>

#ifdef	__cplusplus
extern "C"
{
#endif
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
#include "libavdevice/avdevice.h"
#include "libavutil/audio_fifo.h"
#include "libavutil/avutil.h"
#include "libavutil/fifo.h"
#include "libavutil/frame.h"
#include "libavutil/imgutils.h"

#include "libavfilter/avfilter.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"


#ifdef __cplusplus
};
#endif

class CConvertToGray
{
public:
	CConvertToGray();
	~CConvertToGray();
public:
	int StartConvertToGray(const char *pFileA, const char *pFileOut);
	int WaitFinish();
private:
	int OpenFileA(const char *pFileA);
	int OpenOutPut(const char *pFileOut);
private:
	static DWORD WINAPI VideoAReadProc(LPVOID lpParam);
	void VideoARead();


	static DWORD WINAPI VideoConvertToGrayProc(LPVOID lpParam);
	void VideoConvertToGray();
private:
	AVFormatContext *m_pFormatCtx_FileA = NULL;

	AVCodecContext *m_pReadCodecCtx_VideoA = NULL;
	AVCodec *m_pReadCodec_VideoA = NULL;


	AVCodecContext	*m_pCodecEncodeCtx_Video = NULL;
	AVFormatContext *m_pFormatCtx_Out = NULL;

	AVFifoBuffer *m_pVideoAFifo = NULL;

	int m_iMergeWidth = 1920;
	int m_iMergeHeight = 1080;
	int m_iYuv420FrameSize = 0;
private:
	CRITICAL_SECTION m_csVideoASection;
	HANDLE m_hVideoAReadThread = NULL;
	HANDLE m_hVideoConvertToGrayThread = NULL;
};

ConvertToGray.cpp的代码如下：


#include "ConvertToGray.h"
//#include "log/log.h"





CConvertToGray::CConvertToGray()
{
	InitializeCriticalSection(&m_csVideoASection);
}

CConvertToGray::~CConvertToGray()
{
	DeleteCriticalSection(&m_csVideoASection);
}

int CConvertToGray::StartConvertToGray(const char *pFileA, const char *pFileOut)
{
	int ret = -1;
	do 
	{
		ret = OpenFileA(pFileA);
		if (ret != 0)
		{
			break;
		}

		ret = OpenOutPut(pFileOut);
		if (ret != 0)
		{
			break;
		}

		m_iYuv420FrameSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, 1);
		//申请30帧缓存
		m_pVideoAFifo = av_fifo_alloc(30 * m_iYuv420FrameSize);

		m_hVideoAReadThread = CreateThread(NULL, 0, VideoAReadProc, this, 0, NULL);

		m_hVideoConvertToGrayThread = CreateThread(NULL, 0, VideoConvertToGrayProc, this, 0, NULL);

	} while (0);

	return ret;
}

int CConvertToGray::WaitFinish()
{
	int ret = 0;
	do 
	{
		if (NULL == m_hVideoAReadThread)
		{
			break;
		}
		WaitForSingleObject(m_hVideoAReadThread, INFINITE);

		CloseHandle(m_hVideoAReadThread);
		m_hVideoAReadThread = NULL;

		WaitForSingleObject(m_hVideoConvertToGrayThread, INFINITE);
		CloseHandle(m_hVideoConvertToGrayThread);
		m_hVideoConvertToGrayThread = NULL;
	} while (0);

	return ret;
}

int CConvertToGray::OpenFileA(const char *pFileA)
{
	int ret = -1;

	do
	{
		if ((ret = avformat_open_input(&m_pFormatCtx_FileA, pFileA, 0, 0)) < 0) {
			printf("Could not open input file.");
			break;
		}
		if ((ret = avformat_find_stream_info(m_pFormatCtx_FileA, 0)) < 0) {
			printf("Failed to retrieve input stream information");
			break;
		}

		if (m_pFormatCtx_FileA->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
		{
			break;
		}
		m_pReadCodec_VideoA = (AVCodec *)avcodec_find_decoder(m_pFormatCtx_FileA->streams[0]->codecpar->codec_id);

		m_pReadCodecCtx_VideoA = avcodec_alloc_context3(m_pReadCodec_VideoA);

		if (m_pReadCodecCtx_VideoA == NULL)
		{
			break;
		}
		avcodec_parameters_to_context(m_pReadCodecCtx_VideoA, m_pFormatCtx_FileA->streams[0]->codecpar);

		m_iMergeWidth = m_pReadCodecCtx_VideoA->width;
		m_iMergeHeight = m_pReadCodecCtx_VideoA->height;

		m_pReadCodecCtx_VideoA->framerate = m_pFormatCtx_FileA->streams[0]->r_frame_rate;

		if (avcodec_open2(m_pReadCodecCtx_VideoA, m_pReadCodec_VideoA, NULL) < 0)
		{
			break;
		}

		ret = 0;
	} while (0);


	return ret;
}


int CConvertToGray::OpenOutPut(const char *pFileOut)
{
	int iRet = -1;

	AVStream *pAudioStream = NULL;
	AVStream *pVideoStream = NULL;

	do
	{
		avformat_alloc_output_context2(&m_pFormatCtx_Out, NULL, NULL, pFileOut);

		{
			AVCodec* pCodecEncode_Video = (AVCodec *)avcodec_find_encoder(m_pFormatCtx_Out->oformat->video_codec);

			m_pCodecEncodeCtx_Video = avcodec_alloc_context3(pCodecEncode_Video);
			if (!m_pCodecEncodeCtx_Video)
			{
				break;
			}

			pVideoStream = avformat_new_stream(m_pFormatCtx_Out, pCodecEncode_Video);
			if (!pVideoStream)
			{
				break;
			}

			int frameRate = 10;
			m_pCodecEncodeCtx_Video->flags |= AV_CODEC_FLAG_QSCALE;
			m_pCodecEncodeCtx_Video->bit_rate = 4000000;
			m_pCodecEncodeCtx_Video->rc_min_rate = 4000000;
			m_pCodecEncodeCtx_Video->rc_max_rate = 4000000;
			m_pCodecEncodeCtx_Video->bit_rate_tolerance = 4000000;
			m_pCodecEncodeCtx_Video->time_base.den = frameRate;
			m_pCodecEncodeCtx_Video->time_base.num = 1;

			m_pCodecEncodeCtx_Video->width = m_iMergeWidth;
			m_pCodecEncodeCtx_Video->height = m_iMergeHeight;
			//pH264Encoder->pCodecCtx->frame_number = 1;
			m_pCodecEncodeCtx_Video->gop_size = 12;
			m_pCodecEncodeCtx_Video->max_b_frames = 0;
			m_pCodecEncodeCtx_Video->thread_count = 4;
			m_pCodecEncodeCtx_Video->pix_fmt = AV_PIX_FMT_YUV420P;
			m_pCodecEncodeCtx_Video->codec_id = AV_CODEC_ID_H264;
			m_pCodecEncodeCtx_Video->codec_type = AVMEDIA_TYPE_VIDEO;

			av_opt_set(m_pCodecEncodeCtx_Video->priv_data, "b-pyramid", "none", 0);
			av_opt_set(m_pCodecEncodeCtx_Video->priv_data, "preset", "superfast", 0);
			av_opt_set(m_pCodecEncodeCtx_Video->priv_data, "tune", "zerolatency", 0);

			if (m_pFormatCtx_Out->oformat->flags & AVFMT_GLOBALHEADER)
				m_pCodecEncodeCtx_Video->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

			if (avcodec_open2(m_pCodecEncodeCtx_Video, pCodecEncode_Video, 0) < 0)
			{
				//编码器打开失败，退出程序
				break;
			}
		}

		if (!(m_pFormatCtx_Out->oformat->flags & AVFMT_NOFILE))
		{
			if (avio_open(&m_pFormatCtx_Out->pb, pFileOut, AVIO_FLAG_WRITE) < 0)
			{
				break;
			}
		}

		avcodec_parameters_from_context(pVideoStream->codecpar, m_pCodecEncodeCtx_Video);

		if (avformat_write_header(m_pFormatCtx_Out, NULL) < 0)
		{
			break;
		}

		iRet = 0;
	} while (0);


	if (iRet != 0)
	{
		if (m_pCodecEncodeCtx_Video != NULL)
		{
			avcodec_free_context(&m_pCodecEncodeCtx_Video);
			m_pCodecEncodeCtx_Video = NULL;
		}

		if (m_pFormatCtx_Out != NULL)
		{
			avformat_free_context(m_pFormatCtx_Out);
			m_pFormatCtx_Out = NULL;
		}
	}

	return iRet;
}


DWORD WINAPI CConvertToGray::VideoAReadProc(LPVOID lpParam)
{
	CConvertToGray *pVideoMerge = (CConvertToGray *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoARead();
	}
	return 0;
}

void CConvertToGray::VideoARead()
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	int y_size = m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height;

	char *pY = new char[y_size];
	char *pU = new char[y_size / 4];
	char *pV = new char[y_size / 4];

	AVPacket packet = { 0 };
	int ret = 0;
	while (1)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(m_pFormatCtx_FileA, &packet);
		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
		else if (ret == AVERROR_EOF)
		{
			break;
		}
		else if (ret < 0) 
		{
			break;
		}

		ret = avcodec_send_packet(m_pReadCodecCtx_VideoA, &packet);

		if (ret >= 0)
		{
			ret = avcodec_receive_frame(m_pReadCodecCtx_VideoA, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			else if (ret == AVERROR_EOF)
			{
				break;
			}
			else if (ret < 0) {
				break;
			}
			while (1)
			{
				if (av_fifo_space(m_pVideoAFifo) >= m_iYuv420FrameSize)
				{
					///Y
					int contY = 0;
					for (int i = 0; i < pFrame->height; i++)
					{
						memcpy(pY + contY, pFrame->data[0] + i * pFrame->linesize[0], pFrame->width);
						contY += pFrame->width;
					}


					///U
					int contU = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pU + contU, pFrame->data[1] + i * pFrame->linesize[1], pFrame->width / 2);
						contU += pFrame->width / 2;
					}


					///V
					int contV = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pV + contV, pFrame->data[2] + i * pFrame->linesize[2], pFrame->width / 2);
						contV += pFrame->width / 2;
					}


					EnterCriticalSection(&m_csVideoASection);
					av_fifo_generic_write(m_pVideoAFifo, pY, y_size, NULL);
					av_fifo_generic_write(m_pVideoAFifo, pU, y_size / 4, NULL);
					av_fifo_generic_write(m_pVideoAFifo, pV, y_size / 4, NULL);
					LeaveCriticalSection(&m_csVideoASection);

					break;
				}
				else
				{
					Sleep(100);
				}
			}

		}


		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
	}

	av_frame_free(&pFrame);
	delete[] pY;
	delete[] pU;
	delete[] pV;
}

DWORD WINAPI CConvertToGray::VideoConvertToGrayProc(LPVOID lpParam)
{
	CConvertToGray *pVideoMerge = (CConvertToGray *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoConvertToGray();
	}
	return 0;
}


void CConvertToGray::VideoConvertToGray()
{
	int ret = 0;

	AVFrame *pFrameVideoA = av_frame_alloc();
	uint8_t *videoA_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
	av_image_fill_arrays(pFrameVideoA->data, pFrameVideoA->linesize, videoA_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, 1);

	int iOutVideoWidth = m_pReadCodecCtx_VideoA->width;
	int iOutVideoHeight = m_pReadCodecCtx_VideoA->height;

	AVPacket packet = { 0 };
	int iPicCount = 0;

	while (1)
	{
		if (NULL == m_pVideoAFifo)
		{
			break;
		}

		int iVideoASize = av_fifo_size(m_pVideoAFifo);

		if (iVideoASize >= m_iYuv420FrameSize)
		{
			EnterCriticalSection(&m_csVideoASection);
			av_fifo_generic_read(m_pVideoAFifo, videoA_buffer_yuv420, m_iYuv420FrameSize, NULL);
			LeaveCriticalSection(&m_csVideoASection);

			memset(pFrameVideoA->data[1], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);
			memset(pFrameVideoA->data[2], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);


			pFrameVideoA->pkt_dts = pFrameVideoA->pts = av_rescale_q_rnd(iPicCount, m_pCodecEncodeCtx_Video->time_base, m_pFormatCtx_Out->streams[0]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
			pFrameVideoA->pkt_duration = 0;
			pFrameVideoA->pkt_pos = -1;

			pFrameVideoA->width = iOutVideoWidth;
			pFrameVideoA->height = iOutVideoHeight;
			pFrameVideoA->format = AV_PIX_FMT_YUV420P;

			ret = avcodec_send_frame(m_pCodecEncodeCtx_Video, pFrameVideoA);

			ret = avcodec_receive_packet(m_pCodecEncodeCtx_Video, &packet);

			av_write_frame(m_pFormatCtx_Out, &packet);

			iPicCount++;
		}
		else
		{
			if (m_hVideoAReadThread == NULL)
			{
				break;
			}
			Sleep(1);
		}
	}

	av_write_trailer(m_pFormatCtx_Out);
	avio_close(m_pFormatCtx_Out->pb);

	av_frame_free(&pFrameVideoA);
}
tusong86
关注
FFmpeg —— 通过直接修改yuv数据，将视频转为黑白并输出显示（附：源码）
08-01 1631
通过修改yuv，将视频转为黑白并输出。
FFmpeg入门详解之121：颜色空间转换RGB和YUV的原理与实战
福优学苑@音视频+流媒体
11-02 3388
三种颜色空间模型：RGB、YUV、HSV一、概述颜色通常用三个独立的属性来描述，三个独立变量综合作用，自然就构成一个空间坐标，这就是颜色空间。但被描述的颜色对象本身是客观的，不同颜色空间只是从不同的角度去衡量同一个对象。颜色空间按照基本机构可以分为两大类：基色颜色空间和色、亮分离颜色空间。前者典型的是RGB，后者包括YUV和HSV等等。
将彩色照片变成黑白照片
johncools的博客
11-01 4560
小时候的一些照片都是黑白色的，现在的呢都是彩色，看多了五彩缤纷，反而觉得黑白更顺眼，颜色都是由(R(红色),G(绿色),B(蓝色))混合组成，分别在0-255之间，将(R+G+B)/3,形成的颜色就是黑白的了。程序很简单 1 /**////  2        /// 将彩色图片变成黑白色的照片 3        ///  4        /// 原来图片 5        /// 返回的黑
视音频数据处理入门：颜色空间(二)---ffmpeg
最新发布
打不死的小强
03-04 1930
d
FFmpeg - 通过修改yuv，将视频转为黑白并输出
02-08
本资源包含完整的Vs+Qt+FFmpeg代码。 资源介绍：https://blog.youkuaiyun.com/automoblie0/article/details/126098571 资源视频介绍：https://www.bilibili.com/video/BV1nT41177NE/?spm_id_from=333.999.0.0 【视频中展示的软件效果即是本资源的完整代码】
通过FFMpeg将MOV视频转为黑白通道的mp4（可设置上下/左右）
Unity项目开发中遇到的问题
11-17 1534
Unity播放mov视频解决方案，动态将mov视频转为黑白通道的mp4视频用Avpro播放
Qt 集成 FFmpeg 实现颜色格式转换
StephenZhou
10-30 2016
由于输入输出为纯图片文件，所以需要指定图像的宽高信息；
FFmpeg学习之二 （yuv视频渲染）
kyl282889543的博客
07-19 2439
FFmpeg学习之二 （yuv视频渲染）yuv视频渲染1. iOS YUV视频渲染2. Android YUV视频渲染3. Qt YUV视频渲染 yuv视频渲染 1. iOS YUV视频渲染 2. Android YUV视频渲染 3. Qt YUV视频渲染 ...
C++实现图像灰度化的方法（屏幕截图功能中用到了灰化图像）
dvlinker的技术专栏
07-26 219
C++实现图像灰度化的方法（屏幕截图功能中用到了灰化图像）
音视频面试涨知识（二）
irainsa的博客
12-16 613
信息量不多的区域(颜色变化不明显，比如车体的红色部分和地面的灰色部分)划分的宏块较大，编码后的码字较少，而细节多的地方(轮胎)划分的宏块就相应的小和多一些，编码后的码字较多，这样就相当于对图像进行了有重点的编码，从而降低了整体的码率，编码效率就相应提高了。AAC将PCM音频数据编码压缩，并在头部添加了。I420：YUV 420 Planar，YUV分量分别存放，先是 w * h 长度的Y，后面跟w * h * 0.25长度的U，最后是 w * h * 0.25长度的V，总长度是 w * h * 1.5。
[Camera]摄像头图像处理及色彩模型
Letcos
01-31 6499
参考链接： 1.凹凸思 https://www.zhihu.com/people/jiao-tao-52 2.纸上浅谈 https://glumes.com/post/ffmpeg/understand-yuv-format/ 1.名词解释 光通量(Φ):指人眼所能感觉到的辐射功率，它等于单位时间内某一波段的辐射能量和该波段的相对视见率的乘积。单位：流明。 发光强度(光强):在给定方向上（该方...
做一个directshow的filter，把RGB视频流变成黑白的
07-02
我是按网上的一篇文章（做了一个directshow的filter，把RGB视频流变成黑白的）做的一个filter，有一点改动。可以参考一下。
一个效果非常好的24,16bit真彩位图转化成256彩色或黑白位图的演示程序
03-21
一个效果非常好的24,16bit真彩位图转化成256彩色或黑白位图的演示程序
FFMPEG 实现 YUV，RGB各种图像原始数据之间的转换（swscale）
晚晴小筑
08-24 852
FFMPEG中的swscale提供了视频原始数据（YUV420，YUV422，YUV444，RGB24...）之间的转换，分辨率变换等操作，使用起来十分方便，在这里记录一下它的用法。 swscale主要用于在2个AVFrame之间进行转换。下面来看一个视频解码的简单例子，并将解码后的数据保存为原始数据文件（例如YUV420，YUV422，RGB24等等）。 /** * 使用FFmpeg解析...
将视频转换为灰度
culuo8053的博客
08-05 1108
I'm a JavaScript fanatic but I've always been fascinated with media manipulation. Maybe it's because I've secretly always wanted to be a designer, but I'm fine with being able to manipulate art with s...
关于ffmpeg录制图像是黑白色
落埃无蒂的专栏
12-17 2010
原来我把android得ycbcr420sp当成了yuv420这两个是不同得格式 ycbcr420sp在ffmpeg中是nv21...
ImagesUtil 图片处理 缩放图像、切割图像、图像类型转换、彩色转黑白、文字水印、图片水印
alexgaoyihang的专栏
01-29 1009
import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.Toolkit; import java.awt.color
[FFmpeg] ffplay 播放灰度帧
weixin_43742643的博客
06-05 870
ffplay 读取单通道的灰度图片时会将其扩充为 AV_PIX_FMT_RGB0，upload_texture() 函数中对应的 SDL 格式为 SDL_PIXELFORMAT_BGR888，因此可以正常播放。 经过神经网络算法处理后得到单通道灰度帧数据，ffplay 中的 upload_texture() 函数进行处理时，AV_PIX_FMT_GRAY8 对应的 SDL 格式为 SDL_PIXELFORMAT_UNKNOWN，视频播放会中断。因此需要把灰度帧使用 sws_scale() 函数进行转化。 /
利用ffmpeg cv2取h265码流视频（转换图片灰屏问题解决)
m0_56659620的博客
12-21 2487
【代码】rtsp cv2取h265码流视频（转换图片灰屏问题解决)
FFmpeg视频旋转操作指南
资源摘要信息:"FFmpeg是一个功能强大的开源多媒体框架，能够进行音视频的录制、转换、流处理等多种操作。使用FFmpeg进行视频旋转是一项常见的视频处理任务，通常在视频方向错误或需要调整观看角度时进行。FFmpeg的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值