v4l2 preview capture 测试程序

最新推荐文章于 2024-04-22 20:23:34 发布
最新推荐文章于 2024-04-22 20:23:34 发布
阅读量3.5k 收藏
点赞数
分类专栏： V4L2 文章标签： 测试 video function buffer include output

#ifdef __cplusplus
extern "C"{
#endif

/*=======================================================================
                                        INCLUDE FILES
=======================================================================*/
/* Standard Include Files */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
    
/* Verification Test Environment Include Files */
#include <sys/types.h>    
#include <sys/stat.h>    
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h> 
#include <stdio.h>
#include <stdlib.h>
#include <asm/types.h>
#include <linux/compiler.h>
#include <linux/videodev.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <math.h>
#include <string.h>
#include <malloc.h>


#if 1
#define OUTDEB(fmt,arg...)        printf("%s--"fmt,__FUNCTION__,##arg)
#else
#define OUTDEB(fmt,arg)
#endif

//#define ROTATE


#define V4L_DEVICE "/dev/video0"

#define BUFF_CNT    3

#define ipu_fourcc(a,b,c,d)/
        (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))

#define IPU_PIX_FMT_RGB332 ipu_fourcc('R','G','B','1') /*!< 8 RGB-3-3-2 */
#define IPU_PIX_FMT_RGB555 ipu_fourcc('R','G','B','O') /*!< 16 RGB-5-5-5 */
#define IPU_PIX_FMT_RGB565 ipu_fourcc('R','G','B','P') /*!< 16 RGB-5-6-5 */
#define IPU_PIX_FMT_RGB666 ipu_fourcc('R','G','B','6') /*!< 18 RGB-6-6-6 */
#define IPU_PIX_FMT_BGR24 ipu_fourcc('B','G','R','3') /*!< 24 BGR-8-8-8 */
#define IPU_PIX_FMT_RGB24 ipu_fourcc('R','G','B','3') /*!< 24 RGB-8-8-8 */
#define IPU_PIX_FMT_BGR32 ipu_fourcc('B','G','R','4') /*!< 32 BGR-8-8-8-8 */
#define IPU_PIX_FMT_BGRA32 ipu_fourcc('B','G','R','A') /*!< 32 BGR-8-8-8-8 */
#define IPU_PIX_FMT_RGB32 ipu_fourcc('R','G','B','4') /*!< 32 RGB-8-8-8-8 */
#define IPU_PIX_FMT_RGBA32 ipu_fourcc('R','G','B','A') /*!< 32 RGB-8-8-8-8 */
#define IPU_PIX_FMT_ABGR32 ipu_fourcc('A','B','G','R') /*!< 32 ABGR-8-8-8-8 */

#ifdef ROTATE
#define V4L2_CID_MXC_ROT        (V4L2_CID_PRIVATE_BASE + 0)
#define V4L2_CID_MXC_FLASH        (V4L2_CID_PRIVATE_BASE + 1)
#define V4L2_CID_MXC_FLICKER        (V4L2_CID_PRIVATE_BASE + 2)
#define V4L2_CID_MXC_TEAR_PROTECT    (V4L2_CID_PRIVATE_BASE + 3)

#define V4L2_MXC_ROTATE_NONE            0
#define V4L2_MXC_ROTATE_VERT_FLIP        1
#define V4L2_MXC_ROTATE_HORIZ_FLIP        2
#define V4L2_MXC_ROTATE_180            3
#define V4L2_MXC_ROTATE_90_RIGHT        4
#define V4L2_MXC_ROTATE_90_RIGHT_VFLIP        5
#define V4L2_MXC_ROTATE_90_RIGHT_HFLIP        6
#define V4L2_MXC_ROTATE_90_LEFT            7
#endif

typedef struct _BUFF_DESC
{
    struct v4l2_buffer        BuffParam;
    unsigned     char            *pMapedAddr;
}BUFF_DESC;

typedef struct _V4L_PRO
{
    struct v4l2_format     fmt;
    int                     nOutId;

    struct v4l2_control    CtrlId;
    struct v4l2_crop         Crop;//senser input    


    struct v4l2_framebuffer V4l2Fb;

    int                    bStart;
    int                     bOverlay;
/*for capture:*/
    struct v4l2_streamparm    StreamParm;
    struct v4l2_requestbuffers    ReqBufs;
    int                    CapFrameCnt;
    BUFF_DESC            BuffDesc[BUFF_CNT];
}V4L_PRO;

V4L_PRO        CtlParam;


static int CaptureYUV(int hCam)
{
    int i;
    FILE     *hFile;

    hFile = fopen("mm.yuv","wb");
    if(hFile<0)
    {
        printf("%s--open file mm.yuv failed/n",__FUNCTION__);
        return -1;
    }
    
    CtlParam.fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    CtlParam.fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
    CtlParam.fmt.fmt.pix.width = 320;
    CtlParam.fmt.fmt.pix.height = 240;
    CtlParam.fmt.fmt.pix.bytesperline = 320;//????????????????????????

    CtlParam.fmt.fmt.pix.sizeimage = 0;

    if (ioctl(hCam, VIDIOC_S_FMT, &CtlParam.fmt) < 0)
        {
                printf("set format failed/n");
                fclose(hFile);
                return 0;
        } 

    CtlParam.StreamParm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    CtlParam.StreamParm.parm.capture.timeperframe.denominator = 30;
    CtlParam.StreamParm.parm.capture.timeperframe.numerator = 1;
    CtlParam.StreamParm.parm.capture.capturemode = 0;

    if (ioctl(hCam, VIDIOC_S_PARM, &CtlParam.StreamParm) < 0)
        {
                printf("VIDIOC_S_PARM failed/n");
                fclose(hFile);
                return -1;
        } 

    CtlParam.ReqBufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    CtlParam.ReqBufs.count = BUFF_CNT;
    CtlParam.ReqBufs.memory = V4L2_MEMORY_MMAP;

    if (ioctl(hCam, VIDIOC_REQBUFS, &CtlParam.ReqBufs) < 0)
        {
                printf("v4l_capture_setup: VIDIOC_REQBUFS failed/n");
                fclose(hFile);
                return 0;
        }

    for(i=0; i<BUFF_CNT; i++)
    {
        CtlParam.BuffDesc[i].BuffParam.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        CtlParam.BuffDesc[i].BuffParam.index = i;

         /*获得length和m.offset传入下面MMAP函数*/
        if (ioctl(hCam, VIDIOC_QUERYBUF, &CtlParam.BuffDesc[i].BuffParam) < 0)
                {
                        printf("VIDIOC_QUERYBUF error/n");
                        fclose(hFile);
                        return -1;
                }
             
        CtlParam.BuffDesc[i].pMapedAddr = mmap(NULL, CtlParam.BuffDesc[i].BuffParam.length, PROT_READ|PROT_WRITE, 
                                            MAP_SHARED, hCam, CtlParam.BuffDesc[i].BuffParam.m.offset);
        if(CtlParam.BuffDesc[i].pMapedAddr==NULL)
        {
            printf("buffer mmap failed!/n");
            goto __out;
        }
        
        memset(CtlParam.BuffDesc[i].pMapedAddr, 0xff, CtlParam.BuffDesc[i].BuffParam.length);
    }

    for(i=0; i<BUFF_CNT; i++)
    {
        CtlParam.BuffDesc[i].BuffParam.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        CtlParam.BuffDesc[i].BuffParam.index = i;
        CtlParam.BuffDesc[i].BuffParam.memory = V4L2_MEMORY_MMAP;
        /*让该BUFFER 入队列*/
        if (ioctl (hCam, VIDIOC_QBUF, &CtlParam.BuffDesc[i].BuffParam) < 0) 
        {
                      printf("VIDIOC_QBUF error/n");
                      goto __out;
              }
    }
       if (ioctl (hCam, VIDIOC_STREAMON, &i) < 0)
       {
              printf("VIDIOC_STREAMON error/n");
              goto __out;
       }

       CtlParam.CapFrameCnt = 50;

       while(CtlParam.CapFrameCnt-->0)
       {
           struct v4l2_buffer    tmp;
           //CtlParam.BuffDesc[i].BuffParam.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

           //CtlParam.BuffDesc[i].BuffParam.memory = V4L2_MEMORY_MMAP;

        /*让该 BUFFER 出队列*/
           if (ioctl (hCam, VIDIOC_DQBUF, &tmp) < 0) 
        {
                      printf("VIDIOC_QBUF error/n");
                      goto __out;
              }
              
              fwrite(CtlParam.BuffDesc[tmp.index].pMapedAddr, CtlParam.fmt.fmt.pix.sizeimage, 1, hFile);

              if (CtlParam.CapFrameCnt >= BUFF_CNT) 
              { 
                        if (ioctl (hCam, VIDIOC_QBUF, &tmp) < 0) 
                        {
                                printf("VIDIOC_QBUF failed/n");
                                break;
                        }
               }
           printf("buf.index %d/n", tmp.index);
       }

       if (ioctl (hCam, VIDIOC_STREAMOFF, &i) < 0)
       {
              printf("VIDIOC_STREAMOFF error/n");
              goto __out;
       }
__out:
    for(i=0;i<BUFF_CNT;i++)
    {
        if(CtlParam.BuffDesc[i].pMapedAddr!=NULL)
            mumap(CtlParam.BuffDesc[i].pMapedAddr);
    }
       fclose(hFile);
       return 0;
}

static int GetFbInfo(void)
{
    int     hFb;
    struct fb_fix_screeninfo    fix;
    struct fb_var_screeninfo    var;
    
    hFb = open("/dev/fb0",O_RDWR);
    if(hFb<0)
    {
        printf("%s--failed to open fb0/n",__FUNCTION__);
        return -1;
    }

    if(ioctl(hFb, FBIOGET_FSCREENINFO,&fix))
    {
        printf("%s--failed to get fix/n",__FUNCTION__);
        close(hFb);
        return -1;
    }

    if(ioctl(hFb, FBIOGET_VSCREENINFO, &var))
    {
        printf("%s--failed to get var/n",__FUNCTION__);
        close(hFb);
        return -1;
    }

    OUTDEB("fb addr:0x%x, xres:%d,yres:%d/n",fix.smem_start,var.xres,var.yres);
    CtlParam.V4l2Fb.fmt.width = var.xres;
    CtlParam.V4l2Fb.fmt.height = var.yres;
    CtlParam.V4l2Fb.fmt.pixelformat = IPU_PIX_FMT_RGB565;
    CtlParam.V4l2Fb.fmt.bytesperline = 2*var.xres;
    CtlParam.V4l2Fb.base = (void *)fix.smem_start;
    CtlParam.V4l2Fb.flags = V4L2_FBUF_FLAG_PRIMARY;

    close(hFb);
    return 0;
}

int main(int argc, char ** argv)
{
    int     hCam;
    int     i;
#ifdef ROTATE
    struct v4l2_control sCtrl;
#endif
    //struct v4l2_format        fmt;


    hCam = open(V4L_DEVICE, O_RDWR, 0);
    if(hCam<0)
    {
        printf("failed to open device!/n");
        return -1;
    }
#if 1 
    CtlParam.nOutId = 0;//LCD


    if (ioctl(hCam, VIDIOC_S_OUTPUT, &CtlParam.nOutId) < 0)
        {
                printf("VIDIOC_S_OUTPUT failed/n");
                return -1;
        } 

    CtlParam.Crop.type= V4L2_BUF_TYPE_VIDEO_OVERLAY;//overlay??

    CtlParam.Crop.c.top = 0;//1;

    CtlParam.Crop.c.left = 0;
    CtlParam.Crop.c.width = 640;//680;//640;//800;//640;

    CtlParam.Crop.c.height = 480;//510;//600;//480;


    if (ioctl(hCam, VIDIOC_S_CROP, &CtlParam.Crop) < 0)
       {
               printf("set cropping failed/n");
               goto __err;
       } 

    CtlParam.fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
    CtlParam.fmt.fmt.win.w.top = 0;
    CtlParam.fmt.fmt.win.w.left = 0;
    CtlParam.fmt.fmt.win.w.width = 320;//320;//640;//320;

    CtlParam.fmt.fmt.win.w.height = 240;//240;//480;//240;

    
    if (ioctl(hCam, VIDIOC_S_FMT, &CtlParam.fmt) < 0)
        {
                printf("set format failed/n");
                goto __err;
        } 

{
/*
     struct v4l2_streamparm parm;
     
        parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        parm.parm.capture.timeperframe.numerator = 1;
        parm.parm.capture.timeperframe.denominator = 30;
        parm.parm.capture.capturemode = 1;
         
        if (ioctl(hCam, VIDIOC_S_PARM, &parm) < 0)
        {
                printf("VIDIOC_S_PARM failed/n");
                goto __err;
        }
  */
}
#ifdef ROTATE
sCtrl.id = V4L2_CID_MXC_ROT;
    sCtrl.value = V4L2_MXC_ROTATE_90_RIGHT;
    if(ioctl(hCam, VIDIOC_S_CTRL, &sCtrl)<0)
    {
        printf("%s--set ctrl failed!/n",__FUNCTION__);
        goto __err;
    }
#endif
    CtlParam.bOverlay = 1;

    if(!CtlParam.bOverlay)
    {
        if(GetFbInfo())
        goto __err;
    }
    else
    {
        if (ioctl(hCam, VIDIOC_G_FBUF, &CtlParam.V4l2Fb) < 0) 
        {
                       printf("Get framebuffer failed/n");
                       goto __err;
              }
        CtlParam.V4l2Fb.flags = V4L2_FBUF_FLAG_OVERLAY;        
    }

    if (ioctl(hCam, VIDIOC_S_FBUF, &CtlParam.V4l2Fb) < 0)
       {
               printf("set framebuffer failed/n");
               goto __err;
       } 

    if (ioctl(hCam, VIDIOC_G_FBUF, &CtlParam.V4l2Fb) < 0) 
    {
                printf("set framebuffer failed/n");
                goto __err;
        } 

        printf("/n frame buffer width %d, height %d, bytesperline %d, format:0x%x/n", 
                CtlParam.V4l2Fb.fmt.width, CtlParam.V4l2Fb.fmt.height, CtlParam.V4l2Fb.fmt.bytesperline, CtlParam.V4l2Fb.fmt.pixelformat);

    CtlParam.bStart =1;
    if (ioctl(hCam, VIDIOC_OVERLAY, &CtlParam.bStart) < 0)
        {
                printf("VIDIOC_OVERLAY start failed/n");
        } 
/*
    for (i = 0; i < 3 ; i++) 
    { 
                // flash a frame
                CtlParam.CtrlId.id = V4L2_CID_PRIVATE_BASE + 1;
                if (ioctl(hCam, VIDIOC_S_CTRL, &CtlParam.CtrlId) < 0)
                {
                        printf("set ctl failed/n");
                        goto __err;
                }
     sleep(1);
        }
*/
    //sleep(50);

#endif
    CaptureYUV(hCam);
    

    CtlParam.bStart =0;
    if (ioctl(hCam, VIDIOC_OVERLAY, &CtlParam.bStart) < 0)
        {
                printf("VIDIOC_OVERLAY stop failed/n");
        } 

    return 0;
__err:
    close(hCam);
    return -1;
}
#ifdef __cplusplus
}
#endif

evilcode
关注
专栏目录
V4l2应用程序实验
weixin_51332399的博客
06-10 88
3.检测内核中是否添加了摄像头的设备树，在发fsmp1a-linux-5.4.31/arch/arm/boot/dts目录下如下两个文件为。7.由于图片中没有添加头和尾部信息，所有得到的图片只有数据信息，可以通过YUVviewPlus.exe来显示图片信息。在实验过程中的"$"后的操作在主机上，"#"后的操作在开发板上。4.接上摄像头设备，启动linux内核，检测是否存在摄像头节点。5.将摄像头的应用程序交叉编译后拷贝到rootfs目录执行。1.将内核中的虚拟摄像头驱动从内核中选配掉，默认是选中的。
Native层打开 V4L2 video0摄像头 - V4L2_MEMORY_MMAP 方式实现
|~~~热爱生活、努力学习的小伙汁~~~|
11-11 2111
Native层打开 V4L2 video0摄像头 - V4L2_MEMORY_MMAP 方式实现一、打开摄像头 video0 节点，查询摄像头属性二、配置摄像头输出格式三、配置V4L2底层申请Buffer，Native层来mmap映射 Buffer四、下发Stream on命令，开始吐数据五、循环获取摄像头数据 V4L2_MEMORY_MMAP 方式是由V4L2 驱动层来实现申请连续buff，Native 层通过mmap 方式来映射读取数据。 相关代码可参考高通默认代码： \vendor\qcom\prop
camera的v4l2测试代码
04-01
在android的camera中间件，需要确认驱动，此时可以用测试代码去测试
Android camera preview and take picture with V4l2
qikaibinglan的专栏
12-14 1175
<br />  Android camera preview and take picture with V4l2 收藏  FSL camera preview with V4l2<br /> <br />这部分spec的内容没有全看懂，但是根据FSL的代码能知道这其中的sequence，下面就结合着FSL的代码来描述下video overlay过程的sequence，如果有什么错误的地方，请大家指正。<br />首先介绍一下video overlay，vieo overlay不同于video captu
【Android实战】2、用 CameraX 实现：preview 预览、imageCapture 拍照、videoCapture 录像、videoAnalysis 分析各帧
呆呆的猫的博客
10-01 5851
其实是通过 LuminosityAnalyzer.analyze() 函数内的 listener(luma) 将 luma 参数传给 listener() 函数，然后我们通过 setAnalyzer() 自定义了 listener() 函数，其接收亮度，并通过 Logcat 打印。来初始化摄像头的 use case，并绑定到 cameraProvider.bindToLifecycle() 中，完整代码如下。在 MainActivity 的 startCamera() 函数中，添加如下。
v4l2 官方capture 测试程序
09-18
v4l2官方测试程序，有三种capture方式，read，mmap和用户指针模式
v4l2打开相机的基本过程
qilimi1053620912的博客
03-21 2218
    ~~~~    之前在linux下使用v4l2打开相机，现在记录一下，写博客是个好习惯，要好好培养，要坚持。     ~~~~    使用v4l2打开相机，如果相机支持输出yuv，其实很多时候，写起来，感觉还是很爽的，但是有些相机y...
v4l2驱动2-linux3.0.8中V4L2_CAP_*详解
xxxxxlllllxl的专栏
03-21 3024
这部分涉及不少专业支持，有些可能我的不好，请大家原谅！ /* Values for 'capabilities' field */ #define V4L2_CAP_VIDEO_CAPTURE 0x00000001 /* Is a video capture device */ #define V4L2_CAP_VIDEO_OUTPUT 0x00000002 /* Is a video
Android Camera 通过V4L2与kernel driver的完整交互过程
嵌入式Linux
05-04 1241
Android Camera 通过V4L2与kernel driver的完整交互过程 之前在 Android Camera 的执行流程 http://blog.chinaunix.net/uid-26765074-id-3499537.html 这篇文章中已经详细介绍了 Android Camera app到调用open打开camera 设备的完成过程，但是只是到此为止，并未对较底
android camera v4l2测试代码
01-22
hal层代码，测试前kernel驱动应该调试好。直接测试kernel层驱动，对于学习android cemera数据流buffer很有研究价值。
v4l2的一个测试程序
05-25
v4l2的一个测试程序，能够测试摄像头的实际fps值V4L2_FPS
v4l2应用框架-摄像头v4l2编程
weixin_43824344的博客
10-27 2175
1.简介 V4L2支持三种方式来采集图像，内存映射(mmap),直接读取方式（read）和用户指针，内存映射一般用于连续视频数据的采集，直接读取的方式相对速度慢一些，常用于静态图片数据的采集；用户指针直接传一个buffer指针给内核，从而获取图像数据 2.v4l2采集原理 从上图可知，当视频采集的时候，驱动程序从视频采集输入队列取出一个帧缓冲区填充图像buffer，这个帧缓冲区填充完毕之后会放入视频采集输出队列，交由应用程序处理，应用程序处理完这个帧缓冲区之后在将已经处理过的帧缓冲区交由驱动程序，从而循环
android native播放 yuv420数据
最新发布
jmmingming的专栏
04-22 196
先update一个小demo后面再解析
V4L2 编程 实用滴 好东东必须分享
龙图腾的博客
03-05 730
1. 定义 V 4L2(Video For Linux Two) 是内核提供给应用程序访问音、视频驱动的统一接口。   2. 工作流程： 打开设备－> 检查和设置设备属性－> 设置帧格式－> 设置一种输入输出方法（缓冲区管理）－> 循环获取数据－> 关闭设备。   3. 设备的打开和关闭：   #include int open(const char *device_name,
测试V4L2的摄像头c语言程序
Cox__W的专栏
06-30 732
有的时候接到项目,无非就是想快点的测试手里的驱动到底能不能用,尤其是没有调试过的驱动,现写测试程序,如果不着急还行.最好是能找到能用的,最好就是纯c的,这样简单,又方便调试驱动. 我这里遇到的是v4l2的驱动,想要知到好不好用,就要测试,最简单就是先找一个usb的摄像头来尝试,uvc的驱动大部分bsp都是支持的,插上后,发现有/dev/video0节点产生.接着就是测试,找了好多,也试着自己写,最后还是找到一个能用的,以下代码转载: https://blog.csdn.net/sanmaoljh/art
一、V4L2应用层调用流程
zzsxyl的博客
04-28 1774
1、打开设备 相机设备基本上都是videox节点，以/dev/video0节点为例 int fd = open("/dev/video0",O_RDWR); 2. 获取摄像支持的格式 struct v4l2_fmtdesc v4l2fmt; v4l2fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; int i = 0; while(1) { v4l2fmt.index = i++; ioctl(fd, VIDIOC_ENUM_FMT, &v4l2f
V4L2开发应用流程的各类超实用VIDIOC命令及其结构体集锦
Mark_minGE的博客
08-05 6432
本人作为初入音视频领域的新人，观摩了各位大佬关于V4L2详细开发流程的满满干货，特意为这两周的学习做个总结，希望后来者能顺利完成关于V4L2的第一个demo。这期内容主要内容为V4L2的各类实用VIDIOC命令调用， 各命令顺序总体上呈现的一个V4L2开发流程。 读前必看： 1. 在函数原型中出现的 int request , 其中request 参数即所属的VIDIOC命令。 ...
7.2 ipu_device.c分析（二）---具体函数分析
吾皇的博客
08-24 3074
1. deinterlace_3_field函数 static bool deinterlace_3_field(struct ipu_task_entry *t) { return ((t->set.mode & VDI_MODE) && (t->input.deinterlace.motion != HIGH_MOTION)); } 2. tiled_filed_s
【FFmpeg】编码h.264时，支持的像素格式pix_fmt
热门推荐
郭老二
04-15 1万+
1、简述 使用FFmpeg对视频编码时，编码器格式AVCodecContext—>pix_fmt(类型 enum AVPixelFormat)不是什么格式都支持的。首先x264只支持YUV格式，不支持RGB格式。 2、像素格式列表 在FFmpeg（版本4.1）中编码h.264时，支持的像素格式pix_fmt列表如下： AV_PIX_FMT_YUV420P、 AV_PIX_FMT_YUVJ42...
V4L2摄像头捕获单帧图片测试代码
"该资源提供了一个V4L2（Video for Linux Two）接口的摄像头获取单幅图片的测试程序，适用于Linux系统中的开发者参考。通过这个程序，开发者可以学习如何与V4L2设备交互，从摄像头捕获图像并保存到文件。" V4L2是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值