iOS渲染-将视频原始数据(RGB,YUV)渲染到屏幕上

最新推荐文章于 2024-09-12 19:36:10 发布
最新推荐文章于 2024-09-12 19:36:10 发布
阅读量698 收藏 2
点赞数 1
原文链接：https://juejin.im/post/5d08f861518825699040ecac
版权

需求

在做如美颜,滤镜等功能时,我们不能使用相机原生的AVCaptureVideoPreviewLayer,而是需要通过其他方式将视频原始帧数据如RGB,NV12等等渲染到iOS界面上.

实现原理

利用OpenGL完成高效的渲染功能.本例中仅提供简单流程讲解,具体每行代码含义可在开源库中查询.

注意:

  • 系统的AVCaptureVideoPreviewLayer仅能直接渲染从相机采集到的数据,当做美颜等功能时无法使用.
  • 本例仅实现了RGB与NV12两种类型视频数据的渲染,其他可根据需求自行添加.

阅读前提

  • 音视频基础
  • OpenGL基础
代码地址 : iOS视频渲染
掘金地址 : iOS视频渲染
简书地址 : iOS视频渲染
博客地址 : iOS视频渲染

具体步骤

1. 创建EAGLContext上下文对象
  • 创建OpenGL预览层
    CAEAGLLayer *eaglLayer       = (CAEAGLLayer *)self.layer;
    eaglLayer.opaque = YES;
    eaglLayer.drawableProperties = @{kEAGLDrawablePropertyRetainedBacking   : [NSNumber numberWithBool:NO],
                                     kEAGLDrawablePropertyColorFormat       : kEAGLColorFormatRGBA8};
复制代码
  • 创建OpenGL上下文对象
    EAGLContext *context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
    [EAGLContext setCurrentContext:context];
复制代码
  • 设置上下文渲染缓冲区
- (void)setupBuffersWithContext:(EAGLContext *)context width:(int *)width height:(int *)height colorBufferHandle:(GLuint *)colorBufferHandle frameBufferHandle:(GLuint *)frameBufferHandle {
    glDisable(GL_DEPTH_TEST);
    
    glEnableVertexAttribArray(ATTRIB_VERTEX);
    glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), 0);
    
    glEnableVertexAttribArray(ATTRIB_TEXCOORD);
    glVertexAttribPointer(ATTRIB_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), 0);
    
    glGenFramebuffers(1, frameBufferHandle);
    glBindFramebuffer(GL_FRAMEBUFFER, *frameBufferHandle);
    
    glGenRenderbuffers(1, colorBufferHandle);
    glBindRenderbuffer(GL_RENDERBUFFER, *colorBufferHandle);
    
    [context renderbufferStorage:GL_RENDERBUFFER fromDrawable:(CAEAGLLayer *)self.layer];
    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH , width);
    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, height);
    
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBufferHandle);
}
复制代码
  • 加载着色器

着色器本Demo中只添加了NV12格式与RGB格式两种原始视频数据.

- (void)loadShaderWithBufferType:(XDXPixelBufferType)type {
    GLuint vertShader, fragShader;
    NSURL  *vertShaderURL, *fragShaderURL;
    
    NSString *shaderName;
    GLuint   program;
    program = glCreateProgram();
    
    if (type == XDXPixelBufferTypeNV12) {
        shaderName = @"XDXPreviewNV12Shader";
        _nv12Program = program;
    } else if (type == XDXPixelBufferTypeRGB) {
        shaderName = @"XDXPreviewRGBShader";
        _rgbProgram = program;
    }
    
    vertShaderURL = [[NSBundle mainBundle] URLForResource:shaderName withExtension:@"vsh"];
    if (![self compileShader:&vertShader type:GL_VERTEX_SHADER URL:vertShaderURL]) {
        log4cplus_error(kModuleName, "Failed to compile vertex shader");
        return;
    }
    
    fragShaderURL = [[NSBundle mainBundle] URLForResource:shaderName withExtension:@"fsh"];
    if (![self compileShader:&fragShader type:GL_FRAGMENT_SHADER URL:fragShaderURL]) {
        log4cplus_error(kModuleName, "Failed to compile fragment shader");
        return;
    }
    
    glAttachShader(program, vertShader);
    glAttachShader(program, fragShader);
    
    glBindAttribLocation(program, ATTRIB_VERTEX  , "position");
    glBindAttribLocation(program, ATTRIB_TEXCOORD, "inputTextureCoordinate");
    
    if (![self linkProgram:program]) {
        if (vertShader) {
            glDeleteShader(vertShader);
            vertShader = 0;
        }
        if (fragShader) {
            glDeleteShader(fragShader);
            fragShader = 0;
        }
        if (program) {
            glDeleteProgram(program);
            program = 0;
        }
        return;
    }
    
    if (type == XDXPixelBufferTypeNV12) {
        uniforms[UNIFORM_Y] = glGetUniformLocation(program , "luminanceTexture");
        uniforms[UNIFORM_UV] = glGetUniformLocation(program, "chrominanceTexture");
        uniforms[UNIFORM_COLOR_CONVERSION_MATRIX] = glGetUniformLocation(program, "colorConversionMatrix");
    } else if (type == XDXPixelBufferTypeRGB) {
        _displayInputTextureUniform = glGetUniformLocation(program, "inputImageTexture");
    }
    
    if (vertShader) {
        glDetachShader(program, vertShader);
        glDeleteShader(vertShader);
    }
    if (fragShader) {
        glDetachShader(program, fragShader);
        glDeleteShader(fragShader);
    }
}

- (BOOL)compileShader:(GLuint *)shader type:(GLenum)type URL:(NSURL *)URL {
    NSError *error;
    NSString *sourceString = [[NSString alloc] initWithContentsOfURL:URL
                                                            encoding:NSUTF8StringEncoding
                                                               error:&error];
    if (sourceString == nil) {
        log4cplus_error(kModuleName, "Failed to load vertex shader: %s", [error localizedDescription].UTF8String);
        return NO;
    }
    
    GLint status;
    const GLchar *source;
    source = (GLchar *)[sourceString UTF8String];
    
    *shader = glCreateShader(type);
    glShaderSource(*shader, 1, &source, NULL);
    glCompileShader(*shader);
    
    glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
    if (status == 0) {
        glDeleteShader(*shader);
        return NO;
    }
    return YES;
}

- (BOOL)linkProgram:(GLuint)prog {
    GLint status;
    glLinkProgram(prog);
    
    glGetProgramiv(prog, GL_LINK_STATUS, &status);
    if (status == 0) {
        return NO;
    }
    return YES;
}
复制代码
  • 创建视频纹理缓存区
    if (!*videoTextureCache) {
        CVReturn err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL, context, NULL, videoTextureCache);
        if (err != noErr)
            log4cplus_error(kModuleName, "Error at CVOpenGLESTextureCacheCreate %d",err);
    }
复制代码
2. 将pixelBuffer渲染到屏幕
  • 开始渲染前先清空缓存数据

- (void)cleanUpTextures {
    if (_lumaTexture) {
        CFRelease(_lumaTexture);
        _lumaTexture = NULL;
    }
    
    if (_chromaTexture) {
        CFRelease(_chromaTexture);
        _chromaTexture = NULL;
    }
    
    if (_renderTexture) {
        CFRelease(_renderTexture);
        _renderTexture = NULL;
    }
    
    CVOpenGLESTextureCacheFlush(_videoTextureCache, 0);
}

复制代码
  • 根据pixelBuffer格式确定视频数据类型
    XDXPixelBufferType bufferType;
    if (CVPixelBufferGetPixelFormatType(pixelBuffer) == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange || CVPixelBufferGetPixelFormatType(pixelBuffer) == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange) {
        bufferType = XDXPixelBufferTypeNV12;
    } else if (CVPixelBufferGetPixelFormatType(pixelBuffer) == kCVPixelFormatType_32BGRA) {
        bufferType = XDXPixelBufferTypeRGB;
    }else {
        log4cplus_error(kModuleName, "Not support current format.");
        return;
    }
复制代码
  • 通过当前的pixelBuffer对象创建CVOpenGLESTexture对象
CVOpenGLESTextureRef lumaTexture,chromaTexture,renderTexture;
    if (bufferType == XDXPixelBufferTypeNV12) {
        // Y
        glActiveTexture(GL_TEXTURE0);
        
        error = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                             videoTextureCache,
                                                             pixelBuffer,
                                                             NULL,
                                                             GL_TEXTURE_2D,
                                                             GL_LUMINANCE,
                                                             frameWidth,
                                                             frameHeight,
                                                             GL_LUMINANCE,
                                                             GL_UNSIGNED_BYTE,
                                                             0,
                                                             &lumaTexture);
        if (error) {
            log4cplus_error(kModuleName, "Error at CVOpenGLESTextureCacheCreateTextureFromImage %d", error);
        }else {
            _lumaTexture = lumaTexture;
        }
        
        glBindTexture(CVOpenGLESTextureGetTarget(lumaTexture), CVOpenGLESTextureGetName(lumaTexture));
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        
        // UV
        glActiveTexture(GL_TEXTURE1);
        error = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                             videoTextureCache,
                                                             pixelBuffer,
                                                             NULL,
                                                             GL_TEXTURE_2D,
                                                             GL_LUMINANCE_ALPHA,
                                                             frameWidth / 2,
                                                             frameHeight / 2,
                                                             GL_LUMINANCE_ALPHA,
                                                             GL_UNSIGNED_BYTE,
                                                             1,
                                                             &chromaTexture);
        if (error) {
            log4cplus_error(kModuleName, "Error at CVOpenGLESTextureCacheCreateTextureFromImage %d", error);
        }else {
            _chromaTexture = chromaTexture;
        }
        
        glBindTexture(CVOpenGLESTextureGetTarget(chromaTexture), CVOpenGLESTextureGetName(chromaTexture));
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        
    } else if (bufferType == XDXPixelBufferTypeRGB) {
        // RGB
        glActiveTexture(GL_TEXTURE0);
        error = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                             videoTextureCache,
                                                             pixelBuffer,
                                                             NULL,
                                                             GL_TEXTURE_2D,
                                                             GL_RGBA,
                                                             frameWidth,
                                                             frameHeight,
                                                             GL_BGRA,
                                                             GL_UNSIGNED_BYTE,
                                                             0,
                                                             &renderTexture);
        if (error) {
            log4cplus_error(kModuleName, "Error at CVOpenGLESTextureCacheCreateTextureFromImage %d", error);
        }else {
            _renderTexture = renderTexture;
        }
        
        glBindTexture(CVOpenGLESTextureGetTarget(renderTexture), CVOpenGLESTextureGetName(renderTexture));
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    }
复制代码
  • 选择OpenGL程序
glBindFramebuffer(GL_FRAMEBUFFER, frameBufferHandle);
    
    glViewport(0, 0, backingWidth, backingHeight);
    
    glClearColor(0.1f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    
    if (bufferType == XDXPixelBufferTypeNV12) {
        if (self.lastBufferType != bufferType) {
            glUseProgram(nv12Program);
            glUniform1i(uniforms[UNIFORM_Y], 0);
            glUniform1i(uniforms[UNIFORM_UV], 1);
            glUniformMatrix3fv(uniforms[UNIFORM_COLOR_CONVERSION_MATRIX], 1, GL_FALSE, preferredConversion);
        }
    } else if (bufferType == XDXPixelBufferTypeRGB) {
        if (self.lastBufferType != bufferType) {
            glUseProgram(rgbProgram);
            glUniform1i(displayInputTextureUniform, 0);
        }
    }
复制代码
  • 计算非全屏尺寸

渲染的画面可能是全屏,可能是留黑边.

    static CGSize normalizedSamplingSize;
    
    if (self.lastFullScreen != self.isFullScreen || self.pixelbufferWidth != frameWidth || self.pixelbufferHeight != frameHeight
        || normalizedSamplingSize.width == 0 || normalizedSamplingSize.height == 0  || self.screenWidth != [UIScreen mainScreen].bounds.size.width) {
        
        normalizedSamplingSize = [self getNormalizedSamplingSize:CGSizeMake(frameWidth, frameHeight)];
        self.lastFullScreen = self.isFullScreen;
        self.pixelbufferWidth = frameWidth;
        self.pixelbufferHeight = frameHeight;
        self.screenWidth = [UIScreen mainScreen].bounds.size.width;
        
        quadVertexData[0] = -1 * normalizedSamplingSize.width;
        quadVertexData[1] = -1 * normalizedSamplingSize.height;
        quadVertexData[2] = normalizedSamplingSize.width;
        quadVertexData[3] = -1 * normalizedSamplingSize.height;
        quadVertexData[4] = -1 * normalizedSamplingSize.width;
        quadVertexData[5] = normalizedSamplingSize.height;
        quadVertexData[6] = normalizedSamplingSize.width;
        quadVertexData[7] = normalizedSamplingSize.height;
    }
    
复制代码
  • 渲染画面
    glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, quadVertexData);
    glEnableVertexAttribArray(ATTRIB_VERTEX);
    
    glVertexAttribPointer(ATTRIB_TEXCOORD, 2, GL_FLOAT, 0, 0, quadTextureData);
    glEnableVertexAttribArray(ATTRIB_TEXCOORD);
    
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    
    glBindRenderbuffer(GL_RENDERBUFFER, colorBufferHandle);
    
    if ([EAGLContext currentContext] == context) {
        [context presentRenderbuffer:GL_RENDERBUFFER];
    }
复制代码

转载于:https://juejin.im/post/5d08f861518825699040ecac

weixin_34372728
关注
iOS高级视频渲染
yinshipin007的博客
03-15 517
在代码中，使用FRAGMENT_SHADER_TEXTURE命令，也就是OpenGL ES中的 texture2D 函数，分别从 Y 数据纹理中取出 y值，从 UV 数据纹理中取出 uv值，然后通过公式计算出每个像素(实际是片元)的 rgb值。★文末名片可以免费领取音视频开发学习资料，内容包括（FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）以及音视频学习路线图等等。在iOS中，有两种展示层，一种是 GLKView，另一种是 CAEAGLLayer。
iOS 开发中使用rgb颜色
weixin_34235105的博客
10-08 80
最近在项目中需要使用UILabel定制的字体和颜色，使用rgb颜色的时候，颜色值总是设置不了。 因为当时自己也没仔细研究SDK文档，就随意的想当然直接使用。 [UIColor  colorWithRed:0.0f green:70.0f blue:192f alpha:1.0f] 尝试了好几次，发现居然只支持几种颜色值，后来发现rgb值和alpha值一样支持的范围是0.0~1.0f，SDK文...
深度剖析iOS渲染
最新发布
ScheenDuan的博客
09-12 1579
这样一来又只能另外申请一块内存，把本体内容都先画好。至于优化的话，有以下几种解决方法：1.缓存已经处理好的结果，然后在复用的时候再拿出来用，得用shouldRasterize， 但是这个会导致至少一次离屏渲染，不过相对于有许多layer都各离屏渲染一次，这样处理就优化很多了。如果你的layer本来并不复杂，也没有圆角阴影等等，打开这个开关反而会增加一次不必要的离屏渲染2.贝塞尔曲线优化推荐大佬文章。
ios直播技术（4）-- 视频渲染
haowei0926的博客
03-22 1744
IOS视频渲染相对编解码要简单一些，系统也提供了GLKView，当然我们也可以自定义实现。这里我就分享下自己实现的一点经验。 自定义的renderframe #import @class AVCaptureVideoPreviewLayer; class I420VideoFrame; @interface VideoRenderFrame : UIView @property (nonat
iOS中OpenGL-ES渲染YUV视频
depthlove1的专栏
04-13 6046
OpenGL播放yuv视频（http://www.cocoachina.com/bbs/read.php?tid=100908） 在iOS上使用OpenGL ES渲染YUV （http://blog.csdn.net/cpluser/article/details/41720431）  最简单的视音频播放示例5：OpenGL播放RGB/YUV （http://blog.csdn.net/lei
iOS音视频开发十三：视频渲染，用 Metal 渲染
m0_60259116的博客
05-17 1747
本系列文章通过拆解采集 → 编码 → 封装 → 解封装 → 解码 → 渲染流程并实现 Demo 来向大家介绍如何在 iOS/Android 平台上手音视频开发。 这里是第十三篇：iOS 视频渲染 Demo。这个 Demo 里包含以下内容： 1）实现一个视频采集装模块； 2）实现一个视频渲染模块； 3）串联视频采集和渲染模块，将采集的视频数据输入给渲染模块进行渲染； 4）详尽的代码注释，帮你理解代码逻辑和原理。 1、视频采集模块 在这个 Demo 中，视频采集模块.
ffmpeg 保存图片 将rgb数据_FFMPEG 实现 YUV，RGB各种图像原始数据之间的转换（swscale）...
weixin_36324426的博客
12-29 1906
FFMPEG中的swscale提供了视频原始数据(YUV420，YUV422，YUV444，RGB24...)之间的转换，分辨率变换等操作，使用起来十分方便，在这里记录一下它的用法。swscale主要用于在2个AVFrame之间进行转换。下面来看一个视频解码的简单例子，这个程序完成了对"北京移动开发者大会茶歇视频2.flv"(其实就是优酷上的一个普通视频)的解码工作，并将解码后的数据保存为原始数据...
ios_ffmpeg解码视频
11-22
7. **渲染或处理YUV数据**：处理转换后的YUV数据，如显示到屏幕、保存到文件或进行其他视频处理。 8. **释放资源**：解码完成后，记得释放所有分配的资源，包括`AVPacket`、`AVFrame`以及解码器和格式上下文。 在...
Metal(六) 案例之视频文件的渲染
正在注销账号的博客
08-29 1645
本案例实现使用Metal读取视频文件，并渲染到屏幕上。（此时显示是没有声音的） 思路： 使用AVFundation中的AVAssetReaderTrackOutput方法，并将原始数据传入到CMSempleBuffer中。CMSempleBuffer存储的是每一帧的数据。 Metal渲染回调将 CMSempleBuffer中的数据转成CVPixelBufferRef。 使用CoreVideo获取Y纹理和UV纹理。 自定义片元函数将YUV转成RGBA，显示出来。 1. 顶点函数和片元函数 定点函数 在
ios视频解码
09-20
- 将解码后的像素数据渲染到屏幕上的CALayer或GLKView。 总结来说，iOS视频解码涉及到多个层面的技术，包括视频编码标准的理解、FFmpeg的使用、自定义TCP协议设计、多线程编程以及硬件解码的优化。掌握这些知识点...
VideoToolbox视频编码——在macOS上对获取到的视频进行编码的问题记录 及YUV422转YUV420
念念不忘，必有回响。
08-11 6627
想在macOS平台上写一个将Mac摄像头上获取到的视频数据使用VideoToolBox编码后socket发送出去的服务器，但是遇到了好多问题 先是在接受数据的客户端最终渲染出来的视频中发现绿屏现象，如下图所示： 并且报-12911的错误信息，网上查了一下说是视频数据不完整的原因， 经过验证，初步排除了socket收发数据有误的可能，所以暂时将焦点放在了macOS端的工程上， 将ma
iOS 开发之视频+弹幕渲染库-Demo
04-09
iOS 开发中，用 MPPlayer做的视频播放器，有一层弹幕渲染。弹幕渲染是引用的别人的，在 github 上有。地址：一个 iOS 上的弹幕渲染库. https://github.com/unash/BarrageRenderer
videoshader, 基于脚本的opengl/ios实时视频处理技术.zip
09-18
videoshader, 基于脚本的opengl/ios实时视频处理技术 VideoShader基于脚本的opengl/ios实时视频处理技术概述VideoShader是面向 opengl/ios的视频处理技术，它允许开发人员和设计人员结合多个基于opengl的视频过滤器来设计视频管道。由于每个视频过滤
swift-PPVideoImage设置视频第一帧图片为ImageView的图片
08-15
PPVideoImage设置视频第一帧图片为ImageView的图片
ffmpeg3.4.1 将YUV数据封装成Mp4文件
04-04
封装了ffmpeg api 只调用三个函数，初始化，反初始化，编码生成Mp4 ， 方便工程嵌入
OpenGL ES 显示RGB数据
12-22
自己做过精简，适合做动画，视频播放，纹理加载方式可以根据自己的需求改动。
ios从rgb数据生成UIImage
落埃无蒂的专栏
08-17 4519
int width = 100;     int height = 100;     int bytes_per_pix = 4;          Byte *rgbbuffer = malloc(width*height*bytes_per_pix);     for(int i=0;i     {         rgbbuffer[i+3] = 200;//这个是alfa值，
iOS高级：实现WebRTC视频渲染
WaJulia的博客
09-22 265
通过集成WebRTC库，设置权限，创建WebRTC连接，并使用RTCVideoRenderer来渲染视频帧，我们可以构建出具有实时视频通信功能的应用程序。请注意，上述代码仅提供了实现WebRTC视频渲染的基本框架，具体实现细节可能因应用程序的需求而有所不同。在iOS应用程序中，我们可以使用WebRTC框架提供的RTCPeerConnection类来创建WebRTC连接。要在iOS应用程序中渲染视频，我们可以使用WebRTC框架提供的RTCVideoRenderer类。方法中将视频帧渲染到UIView中。
渲染（iOS渲染过程解析）
yueliangmua的博客
12-07 2020
深刻理解iOS渲染机制，再也不怕面试题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值