转： V4L2驱动程序架构

源地址：http://blog.chinaunix.net/uid-26101960-id-3297657.html

1 V4L2简介

 

video4linux2(V4L2)是Linux内核中关于视频设备的内核驱动，它为Linux中视频设备访问提供了通用接口，在Linux系统中，V4L2驱动的Video设备节点路径通常/dev/video/中的videoX
V4L2驱动对用户空间提供字符设备，主设备号为81，对于视频设备，其次设备号为0-63。除此之外，次设备号为64-127的Radio设备，次设备号为192-223的是Teletext设备,次设备号为224-255的是VBI设备
V4L2驱动的Video设备在用户空间通过各种ioctl调用进行控制，并且可以使用mmap进行内存映射

1.1 V4L2驱动主要使用的ioctl

命令值如下所示：

点击(此处)折叠或打开

  1. #define VIDIOC_QUERYCAP _IOR('V', 0, struct v4l2_capability) /*查询能力*/
  2. #define VIDIO_G_FMT _IOWR('V', 4, struct v4l2_format) /*获得格式*/
  3. #define VIDIOC_S_FMT _IOWR('V', 5, struct v4l2_format) /*设置格式*/
  4. #define VIDIOC_REQBUFS _IOWR('V', 8, strut v4l2_requestbuffers) /*申请内存*/
  5. #define VIDIOC_G_FBUF _IOW('V', 10, struct v4l2_framebuffer) /*获得Framebuffer*/
  6. #define VIDIOC_S_BUF _IOW('V', 11, struct v4l2_framebuffer) /*设置Framebuffer*/
  7. #define VIDIOC_OVERLAY _IOW('V', 14, int) /*设置Overlay*/
  8. #define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer) /*将内存加入队列*/
  9. #define VIDIOC_DQBUF _IOWR('V', 17, strut v4l2_buffer) /*从队列取出内存*/
  10. #define VIDIOC_STREAMON _IOW('V', 18, int) /*开始流*/
  11. #define VIDIOC_STREAMOFF _IOW('V', 19, int) /*停止流*/
  12. #define VIDIOC_G_CTRL _IOWR('V', 27, struct v4l2_control) /*得到控制*/
  13. #define VIDIOC_S_CTRL _IOWR('V', 28, struct v4l2_control) /*设置控制*/

 1.2 重要结构

 

头文件 include/linux/videodev2.h

include/media/v4l2-dev.h

V4L2驱动核心实现文件：driver/media/video/v4l2-dev.c

v4l2-dev.h中定义的video_device是V4L2驱动程序的核心数据结构

  1. struct video_device  
  2. {  
  3.     const struct v4l2_file_operations *fops;  
  4.     struct cdev *cdev;//字符设备   
  5.     struct device *parent;//父设备   
  6.     struct v4l2_device *v4l2_dev;//父v4l2_device   
  7.     char name[32];//名称   
  8.     int vfl_type;//类型   
  9.     int minor;//次设备号   
  10.     /*释放回调*/  
  11.     void (*release)(struct video_device *vdev);  
  12.     /*ioctl回调*/  
  13.     const struct v4l2_ioctl_ops *ioctl_ops;  
  14. }  
  15. 常用的结构  
  16. 参见/include/linux/videodev2.h  
  17. 1)设备能力结构  
  18. struct v4l2_capability  
  19. {  
  20.     __u8 driver[16];//驱动名   
  21.     __u8 card[32];//例如Hauppauge winTV   
  22.     __u8 bus_info[32];//PCI总线信息   
  23.     __u32 version;//内核版本   
  24.     __u32 capabilities;//设备能力   
  25.     __u32 reserved[4];  
  26. };  
  27. 2)数据格式结构  
  28. struct v4l2_format  
  29. {  
  30.     enum v4l2_buf_type type;//本结构的数据类型   
  31. };  
  32. 3)像素格式结构  
  33. struct v4l2_pix_format  
  34. {  
  35.     __u32   width;//宽度   
  36.     __u32   height;//高度   
  37. }  
  38. 4)请求缓冲  
  39. struct v4l2_requestbuffers  
  40. {  
  41.     __u32   count;//缓存数量   
  42.     enum v4l2_buf_type type;//数据流类型   
  43. }  
  44. 5)数据流类型包括V4L2_MEMORY_MMAP和V4L2_MEMORY_USERPTR  
  45. enum v4l2_memory{  
  46.   
  47. };  

点击(此处)折叠或打开

5)数据流类型包括V4L2_MEMORY_MMAP和V4L2_MEMORY_USERPTR enum v4l2_memory{ };

2 V4L2驱动注册 2.1 video_register_device

video4linux2驱动程序的注册drivers/media/video

video_register_device函数用来注册一个v4l驱动程序

  1. int video_register_device(struct video_device *vdev, int type, int nr)  
  2. {  
  3.     return __video_register_device(vdev, type, nr, 1);  
  4. }  
  5. 其中参数type支持的类型如下  
  6. #define VFL_TYPE_GRABBER 0//视频  
  7. #define VFL_TYPE_VBI    1//从视频消隐的时间取得信息的设备  
  8. #define VFL_TYPE_RADIO  2 //广播  
  9. #define VFL_TYPE_VTX    3//视传设备  
  10. #define VFL_TYPE_MAX    4//最大值   
  11. ----------------->返回调用 __video_register_device()  
  12. __video_register_device 函数先检查设备类型，接下来  
  13. 寻找一个可用的子设备号，最后注册相应的字符设备  
  14. static int __video_register_device(struct video_device *vdev, int type, int nr, int warn_if_nr_in_use)  
  15. {  
  16.       
  17. switch (type) {  
  18.         case VFL_TYPE_GRABBER:  
  19.             minor_offset = 0;  
  20.             minor_cnt = 64;  
  21.             break;  
  22.         case VFL_TYPE_RADIO:  
  23.             minor_offset = 64;  
  24.             minor_cnt = 64;  
  25.             break;  
  26.         case VFL_TYPE_VTX:  
  27.             minor_offset = 192;  
  28.             minor_cnt = 32;  
  29.             break;  
  30.         case VFL_TYPE_VBI:  
  31.             minor_offset = 224;  
  32.             minor_cnt = 32;  
  33.             break;  
  34.         nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);  
  35.     }     
  36.     nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);  
  37.     vdev->cdev->ops = &v4l2_fops;  
  38. //注册字符设备   
  39. ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);  
  40.     ret = device_register(&vdev->dev);  
  41. //注册完毕设备信息存储在video_device数组中   
  42.     mutex_lock(&videodev_lock);  
  43.     video_device[vdev->minor] = vdev;  
  44.     mutex_unlock(&videodev_lock);  
  45. }  
int video_register_device(struct video_device *vdev, int type, int nr)
{
return __video_register_device(vdev, type, nr, 1);
}
其中参数type支持的类型如下
#define VFL_TYPE_GRABBER 0//视频
#define VFL_TYPE_VBI 1//从视频消隐的时间取得信息的设备
#define VFL_TYPE_RADIO 2 //广播
#define VFL_TYPE_VTX 3//视传设备
#define VFL_TYPE_MAX 4//最大值
 ----------------->返回调用 __video_register_device() __video_register_device 函数先检查设备类型，接下来寻找一个可用的子设备号，
最后注册相应的字符设备

点击(此处)折叠或打开



2.2 v4l2_fops接口

v4l2_fops为video4linux2设备提供了统一的应用层接口，v4l2_fops定义如下

  1. static const struct file_operations v4l2_fops = {  
  2.     .owner = THIS_MODULE,  
  3.         .read = v4l2_read,  
  4.         .write = v4l2_write,  
  5.         .open = v4l2_open,  
  6.         .get_unmapped_area = v4l2_get_unmapped_area,  
  7.         .mmap = v4l2_mmap,  
  8.         .unlocked_ioctl = v4l2_ioctl,  
  9.         .release = v4l2_release,  
  10.         .poll = v4l2_poll,  
  11.         .llseek = no_llseek,  
  12.   
  13. };  
  14. v4l2_fops中的成员函数最终要调用struct video_device->fops中相应的成员  
  15. struct video_device->fops是具体video4linux2摄像头驱动程序必须实现的接口  
  16. static ssize_t v4l2_read(struct file *filp, char __user *buf, size_t sz, loff_t *off)  
  17. {  
  18.     return vdev->fops->read(filp, buf, sz, off);  
  19. }  

2.3 /drivers/media/video/samsung/fimc/s3c_fimc_core.c

驱动探测函数s3c_fimc_probe定义

  1. static int s3c_fimc_probe(struct platform_device *dev)  
  2. {  
  3.     ctrl = s3c_fimc_register_controller(pdev);  
  4.       
  5.     clk_enable(ctrl->clock);//使能时钟   
  6.     //注册V4L2驱动   
  7.     ret = video_register_device(ctrl->vd, VFL_TYPE_GRABBER, ctrl->id);  
  8. }  
  9. s3c_fimc_register_contoller函数主要用来分配资源与申请中断  
  10. static struct s3c_fimc_control *s3c_fimc_register_controller(struct platform_device *pdev)  
  11. {  
  12.     ctrl->vd = &s3c_fimc_video_device[id];  
  13.     //申请中断   
  14.     ctrl->irq = platform_get_irq(pdev, 0);  
  15.     if(request_irq(ctrl->irq, s3c_fimc_irq, IRQF_DISABLED, ctrl->name, ctrl))  
  16. };  
  17. struct video_device s3c_fimc_video_device[S3C_FIMC_MAX_CTRLS] = {  
  18.     [0] = {  
  19.         .vfl_type = VID_TYPE_OVERLAY | VID_TYPE_CAPTURE | VID_TYPE_CLIPPING | VID_TYPE_SCALES,  
  20.         .fops = &s3c_fimc_fops,  
  21.         .ioctl_ops = &s3c_fimc_v4l2_ops,  
  22.         .release  = s3c_fimc_vdev_release,  
  23.           
  24.         .name = "sc3_video0",  
  25.     },  
  26. }  

s3c_fimc_v4l2_ops,是在drivers/media/video/samsung/fimc中实现的v4l2_ioctl_ops，在用户空间进行ioctl等调用时，要调用到具体实现的各个函数指针  


3 V4L2 操作

3.1 s3c_fimc_open

  1. static int s3c_fimc_open(struct file *filp)  
  2. {  
  3.     struct s3c_fimc_control *ctrl;  
  4.     int id, ret;  
  5.   
  6.     id =0;  
  7.     ctrl = &s3c_fimc.ctrl[id];  
  8.     mutex_lock(&ctrl->lock);  
  9.     if (atomic_read(&ctrl->in_use)) {  
  10.         ret = -EBUSY;  
  11.         goto resource_busy;  
  12.     } else {  
  13.         atomic_inc(&ctrl->in_use);  
  14.         s3c_fimc_reset(ctrl);  
  15.         filp->private_data = ctrl;  
  16.     }  
  17.     mutex_unlock(&ctrl->lock);  
  18.     return 0;  
  19. resource_busy:  
  20.     mutex_unlock(&ctrl->lock);  
  21.     return ret;  
  22. }  
  23. 用户空间  
  24. 打开设备文件  
  25. fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);  
 用户空间打开设备文件 fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);
 
3.2 获取设备的capability,查看设备有什么功能

1）结构体

  1. struct v4l2_capability cap;  
  2. ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);  
  3. /include/linux/videodev2.h  
  4. struct v4l2_capability {  
  5.     __u8    driver[16]; /* i.e. "bttv" */  
  6.     __u8    card[32];   /* i.e. "Hauppauge WinTV" */  
  7.     __u8    bus_info[32];   /* "PCI:" + pci_name(pci_dev) */  
  8.     __u32   version;        /* should use KERNEL_VERSION() */  
  9.     __u32   capabilities;   /* Device capabilities */  
  10.     __u32   reserved[4];  
  11. };  
  12. 驱动实现  
  13.   
  14. static int s3c_fimc_v4l2_querycap(struct file *filp, void *fh,  
  15.                     struct v4l2_capability *cap)  
  16. {  
  17.     struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;  
  18.     strcpy(cap->driver, "Samsung FIMC Driver");  
  19.     strlcpy(cap->card, ctrl->vd->name, sizeof(cap->card));  
  20.     sprintf(cap->bus_info, "FIMC AHB-bus");  
  21.     cap->version = 0;  
  22.     cap->capabilities = (V4L2_CAP_VIDEO_OVERLAY | \  
  23.                 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING);  
  24.     return 0;  
  25. }  
  26. 应用层调用  
  27. static int video_capability(int fd)  
  28. {  
  29.     int ret = 0;  
  30.     /***********get the device capability********/  
  31.     struct v4l2_capability cap;  
  32.     ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);  
  33.     if (ret < 0) {  
  34.         perror("VIDIOC_QUERYCAP failed ");  
  35.         return ret;  
  36.     }  
  37.       
  38.     printf("\n****Capability informations****\n");  
  39.     printf("driver:   %s\n", cap.driver);  
  40.       
  41.     if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)  
  42.         printf("Capture capability is supported\n");  
  43.   
  44.     if (cap.capabilities & V4L2_CAP_STREAMING)   
  45.         printf("Streaming capability is supported\n");  
  46.           
  47.     if (cap.capabilities & V4L2_CAP_VIDEO_OVERLAY)   
  48.         printf("Overlay capability is supported\n");  
  49.       
  50.     return 0;  
  51. }  

3.3 选择视频输入，一个视频设备可以有多个视频输入
  1. 结构体  
  2. struct v4l2_input input;  
  3. int index;  
  4. 得到INPUT  
  5. ret = ioctl(fd, VIDIOC_G_INPUT, &index);      
  6. input.index = index;  
  7. 列举INPUT  
  8. ret = ioctl(fd, VIDIOC_ENUMINPUT, &input);  
  9. 设置INPUT  
  10. ret = ioctl(fd, VIDIOC_S_INPUT, &index);  
  11.   
  12. struct v4l2_input {  
  13.     __u32        index;     /*  Which input */  
  14.     __u8         name[32];      /*  Label */  
  15.     __u32        type;      /*  Type of input */  
  16.     __u32        audioset;      /*  Associated audios (bitfield) */  
  17.     __u32        tuner;             /*  Associated tuner */  
  18.     v4l2_std_id  std;  
  19.     __u32        status;  
  20.     __u32        capabilities;  
  21.     __u32        reserved[3];  
  22. };  
  23.   
  24. Ioctl: VIDIOC_S_INPUT This IOCTL takes pointer to integer containing index of the input which has to be set. Application will provide the index number as an argument.   
  25.     0 - Composite input,  
  26.     1 - S-Video input.  
  27. 驱动  
  28. static int s3c_fimc_v4l2_s_input(struct file *filp, void *fh,  
  29.                     unsigned int i)  
  30. {  
  31.     struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;  
  32.   
  33.     if (i >= S3C_FIMC_MAX_INPUT_TYPES)  
  34.         return -EINVAL;  
  35.   
  36.     ctrl->v4l2.input = &s3c_fimc_input_types[i];  
  37.   
  38.     if (s3c_fimc_input_types[i].type == V4L2_INPUT_TYPE_CAMERA)  
  39.         ctrl->in_type = PATH_IN_ITU_CAMERA;  
  40.     else  
  41.         ctrl->in_type = PATH_IN_DMA;  
  42.   
  43.     return 0;  
  44. }  
  45. static struct v4l2_input s3c_fimc_input_types[] = {  
  46.     {  
  47.         .index      = 0,  
  48.         .name       = "External Camera Input",  
  49.         .type       = V4L2_INPUT_TYPE_CAMERA,  
  50.         .audioset   = 1,  
  51.         .tuner      = 0,  
  52.         .std        = V4L2_STD_PAL_BG | V4L2_STD_NTSC_M,  
  53.         .status     = 0,  
  54.     },   
  55.     {  
  56.         .index      = 1,  
  57.         .name       = "Memory Input",  
  58.         .type       = V4L2_INPUT_TYPE_MEMORY,  
  59.         .audioset   = 2,  
  60.         .tuner      = 0,  
  61.         .std        = V4L2_STD_PAL_BG | V4L2_STD_NTSC_M,  
  62.         .status     = 0,  
  63.     }  
  64. };  
  65. static int s3c_fimc_v4l2_enum_input(struct file *filp, void *fh,  
  66.                     struct v4l2_input *i)  
  67. {  
  68.     if (i->index >= S3C_FIMC_MAX_INPUT_TYPES)  
  69.         return -EINVAL;  
  70.   
  71.     memcpy(i, &s3c_fimc_input_types[i->index], sizeof(struct v4l2_input));  
  72.   
  73.     return 0;  
  74. }  
  75. 应用  
  76. static int video_input(int fd)  
  77. {  
  78.     /***********get and set the VIDIO INPUT********/  
  79.     int ret = 0;  
  80.     struct v4l2_input input;//视频输入信息，对应命令VIDIOC_ENUMINPUT    
  81.     int index;  
  82.     index = 0;    //0 - Composite input, 1 - S-Video input.   
  83.      
  84.     ret = ioctl (fd, VIDIOC_S_INPUT, &index);  
  85.     if (ret < 0) {  
  86.         perror ("VIDIOC_S_INPUT");  
  87.         return ret;  
  88.     }  
  89.   
  90.     input.index = index;  
  91.     ret = ioctl (fd, VIDIOC_ENUMINPUT, &input);  
  92.     if (ret < 0){  
  93.         perror ("VIDIOC_ENUMINPUT");  
  94.         return ret;  
  95.     }  
  96.     printf("\n****input informations****\n");  
  97.     printf("name of the input = %s\n", input.name);  
  98.     return 0;  
  99. }  
3.4 遍历所有视频格式,查询驱动所支持的格式
  1. 结构  
  2. struct v4l2_fmtdes fmtdes;  
  3. ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmtdes);  
  4. struct v4l2_fmtdesc {  
  5.     __u32           index;             /* Format number      */  
  6.     enum v4l2_buf_type  type;              /* buffer type        */  
  7.     __u32               flags;  
  8.     __u8            description[32];   /* Description string */  
  9.     __u32           pixelformat;       /* Format fourcc      */  
  10.     __u32           reserved[4];  
  11. };  
  12. 驱动  
  13. static int s3c_fimc_v4l2_enum_fmt_vid_cap(struct file *filp, void *fh,  
  14.                     struct v4l2_fmtdesc *f)  
  15. {  
  16.     struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;  
  17.     int index = f->index;  
  18.   
  19.     if (index >= S3C_FIMC_MAX_CAPTURE_FORMATS)  
  20.         return -EINVAL;  
  21.   
  22.     memset(f, 0, sizeof(*f));  
  23.     memcpy(f, ctrl->v4l2.fmtdesc + index, sizeof(*f));  
  24.   
  25.     return 0;  
  26. }  
  27. #define S3C_FIMC_MAX_CAPTURE_FORMATS    ARRAY_SIZE(s3c_fimc_capture_formats)   
  28. const static struct v4l2_fmtdesc s3c_fimc_capture_formats[] = {  
  29.     {  
  30.         .index      = 0,  
  31.         .type       = V4L2_BUF_TYPE_VIDEO_CAPTURE,  
  32.         .flags      = FORMAT_FLAGS_PLANAR,  
  33.         .description    = "4:2:0, planar, Y-Cb-Cr",  
  34.         .pixelformat    = V4L2_PIX_FMT_YUV420,  
  35.     },  
  36.     {  
  37.         .index      = 1,  
  38.         .type       = V4L2_BUF_TYPE_VIDEO_CAPTURE,  
  39.         .flags      = FORMAT_FLAGS_PLANAR,  
  40.         .description    = "4:2:2, planar, Y-Cb-Cr",  
  41.         .pixelformat    = V4L2_PIX_FMT_YUV422P,  
  42.   
  43.     },    
  44.     {  
  45.         .index      = 2,  
  46.         .type       = V4L2_BUF_TYPE_VIDEO_CAPTURE,  
  47.         .flags      = FORMAT_FLAGS_PACKED,  
  48.         .description    = "4:2:2, packed, YCBYCR",  
  49.         .pixelformat    = V4L2_PIX_FMT_YUYV,  
  50.     },  
  51.     {  
  52.         .index      = 3,  
  53.         .type       = V4L2_BUF_TYPE_VIDEO_CAPTURE,  
  54.         .flags      = FORMAT_FLAGS_PACKED,  
  55.         .description    = "4:2:2, packed, CBYCRY",  
  56.         .pixelformat    = V4L2_PIX_FMT_UYVY,  
  57.     }  
  58. };  
  59. const static struct v4l2_fmtdesc s3c_fimc_overlay_formats[] = {  
  60.     {  
  61.         .index      = 0,  
  62.         .type       = V4L2_BUF_TYPE_VIDEO_OVERLAY,  
  63.         .flags      = FORMAT_FLAGS_PACKED,  
  64.         .description    = "16 bpp RGB, le",  
  65.         .pixelformat    = V4L2_PIX_FMT_RGB565,        
  66.     },  
  67.     {  
  68.         .index      = 1,  
  69.         .type       = V4L2_BUF_TYPE_VIDEO_OVERLAY,  
  70.         .flags      = FORMAT_FLAGS_PACKED,  
  71.         .description    = "24 bpp RGB, le",  
  72.         .pixelformat    = V4L2_PIX_FMT_RGB24,         
  73.     },  
  74. };  
  75. 应用层  
  76. static int video_fmtdesc(int fd)  
  77. {  
  78.     /***********Format Enumeration************/  
  79.     int ret = 0;  
  80.     struct v4l2_fmtdesc fmtdes;  
  81.     CLEAR(fmtdes);  
  82.     fmtdes.index = 0;  
  83.     fmtdes.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  84.     printf("\n**********vidioc enumeration stream format informations:****\n");  
  85.     while (1) {  
  86.           
  87.         ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmtdes);  
  88.         if (ret < 0)   
  89.             break;  
  90.           
  91.          printf("{ pixelformat = %c%c%c%c, description = %s }\n",  
  92.                 (fmtdes.pixelformat & 0xFF),  
  93.                 (fmtdes.pixelformat >> 8) & 0xFF,  
  94.                 (fmtdes.pixelformat >> 16) & 0xFF,   
  95.                 (fmtdes.pixelformat >> 24) & 0xFF,  
  96.                 fmtdes.description);  
  97.           
  98.         if (fmtdes.type == V4L2_BUF_TYPE_VIDEO_CAPTURE)  
  99.             printf("video capture type:\n");  
  100.         if (fmtdes.pixelformat == V4L2_PIX_FMT_YUYV)  
  101.             printf("V4L2_PIX_FMT_YUYV\n");  
  102.         fmtdes.index++;  
  103.     }  
  104.     return 0;  
  105. }  
3.5 设置视频捕获格式（重要）
  1. 结构体  
  2. 帧格式包括宽度和高度  
  3. struct v4l2_format fmt;  
  4. ret = ioctl(fd, VIDIOC_S_FMT, &fmt);  
  5. struct v4l2_format {  
  6.     enum v4l2_buf_type type;//数据流类型，必须是V4L2_BUF_TYPE_VIDEO_CAPTURE   
  7.     union {  
  8.         struct v4l2_pix_format      pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */  
  9.         struct v4l2_window      win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */  
  10.         struct v4l2_vbi_format      vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */  
  11.         struct v4l2_sliced_vbi_format   sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */  
  12.         __u8    raw_data[200];                   /* user-defined */  
  13.     } fmt;  
  14. };  
  15. struct v4l2_pix_format  {  
  16.     __u32 pixelformat;//视频数据存储类型，例如是YUV4:2:2还是RGB   
  17. }  
  18. 驱动  
  19. static int s3c_fimc_v4l2_s_fmt_vid_cap(struct file *filp, void *fh,  
  20.                     struct v4l2_format *f)  
  21. {  
  22.   
  23.     struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;  
  24.     ctrl->v4l2.frmbuf.fmt = f->fmt.pix;  
  25.   
  26.     if (f->fmt.pix.priv == V4L2_FMT_IN)  
  27.         s3c_fimc_set_input_frame(ctrl, &f->fmt.pix);  
  28.     else  
  29.         s3c_fimc_set_output_frame(ctrl, &f->fmt.pix);  
  30.   
  31.     return 0;  
  32. }  
  33. int s3c_fimc_set_input_frame(struct s3c_fimc_control *ctrl,  
  34.                 struct v4l2_pix_format *fmt)  
  35. {  
  36.     s3c_fimc_set_input_format(ctrl, fmt);  
  37.   
  38.     return 0;  
  39. }  
  40.   
  41. static void s3c_fimc_set_input_format(struct s3c_fimc_control *ctrl,  
  42.                     struct v4l2_pix_format *fmt)  
  43. {  
  44.     struct s3c_fimc_in_frame *frame = &ctrl->in_frame;  
  45.   
  46.     frame->width = fmt->width;  
  47.     frame->height = fmt->height;  
  48.   
  49.     switch (fmt->pixelformat) {  
  50.     case V4L2_PIX_FMT_RGB565:  
  51.         frame->format = FORMAT_RGB565;  
  52.         frame->planes = 1;  
  53.         break;  
  54.   
  55.     case V4L2_PIX_FMT_RGB24:  
  56.         frame->format = FORMAT_RGB888;  
  57.         frame->planes = 1;  
  58.         break;  
  59.   
  60.     case V4L2_PIX_FMT_NV12:  
  61.         frame->format = FORMAT_YCBCR420;  
  62.         frame->planes = 2;  
  63.         frame->order_2p = LSB_CBCR;  
  64.         break;  
  65.   
  66.     case V4L2_PIX_FMT_NV21:  
  67.         frame->format = FORMAT_YCBCR420;  
  68.         frame->planes = 2;  
  69.         frame->order_2p = LSB_CRCB;  
  70.         break;  
  71.   
  72.     case V4L2_PIX_FMT_NV12X:  
  73.         frame->format = FORMAT_YCBCR420;  
  74.         frame->planes = 2;  
  75.         frame->order_2p = MSB_CBCR;  
  76.         break;  
  77.   
  78.     case V4L2_PIX_FMT_NV21X:  
  79.         frame->format = FORMAT_YCBCR420;  
  80.         frame->planes = 2;  
  81.         frame->order_2p = MSB_CRCB;  
  82.         break;  
  83.   
  84.     case V4L2_PIX_FMT_YUV420:  
  85.         frame->format = FORMAT_YCBCR420;  
  86.         frame->planes = 3;  
  87.         break;  
  88.   
  89.     case V4L2_PIX_FMT_YUYV:  
  90.         frame->format = FORMAT_YCBCR422;  
  91.         frame->planes = 1;  
  92.         frame->order_1p = IN_ORDER422_YCBYCR;  
  93.         break;  
  94.   
  95.     case V4L2_PIX_FMT_YVYU:  
  96.         frame->format = FORMAT_YCBCR422;  
  97.         frame->planes = 1;  
  98.         frame->order_1p = IN_ORDER422_YCRYCB;  
  99.         break;  
  100.   
  101.     case V4L2_PIX_FMT_UYVY:  
  102.         frame->format = FORMAT_YCBCR422;  
  103.         frame->planes = 1;  
  104.         frame->order_1p = IN_ORDER422_CBYCRY;  
  105.         break;  
  106.   
  107.     case V4L2_PIX_FMT_VYUY:  
  108.         frame->format = FORMAT_YCBCR422;  
  109.         frame->planes = 1;  
  110.         frame->order_1p = IN_ORDER422_CRYCBY;  
  111.         break;  
  112.   
  113.     case V4L2_PIX_FMT_NV16:  
  114.         frame->format = FORMAT_YCBCR422;  
  115.         frame->planes = 2;  
  116.         frame->order_1p = LSB_CBCR;  
  117.         break;  
  118.   
  119.     case V4L2_PIX_FMT_NV61:  
  120.         frame->format = FORMAT_YCBCR422;  
  121.         frame->planes = 2;  
  122.         frame->order_1p = LSB_CRCB;  
  123.         break;  
  124.   
  125.     case V4L2_PIX_FMT_NV16X:  
  126.         frame->format = FORMAT_YCBCR422;  
  127.         frame->planes = 2;  
  128.         frame->order_1p = MSB_CBCR;  
  129.         break;  
  130.   
  131.     case V4L2_PIX_FMT_NV61X:  
  132.         frame->format = FORMAT_YCBCR422;  
  133.         frame->planes = 2;  
  134.         frame->order_1p = MSB_CRCB;  
  135.         break;  
  136.   
  137.     case V4L2_PIX_FMT_YUV422P:  
  138.         frame->format = FORMAT_YCBCR422;  
  139.         frame->planes = 3;  
  140.         break;  
  141.     }  
  142. }  
  143. 应用层  
  144. static int video_setfmt(int fd)  
  145. {  
  146.   /***********set Stream data format********/  
  147.   int ret = 0;  
  148.   struct v4l2_format fmt;  
  149.     CLEAR(fmt);  
  150.     fmt.type            =   V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  151.     fmt.fmt.pix.width   =   640;  
  152.     fmt.fmt.pix.height  =   480;  
  153.     fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;//for PAL   
  154.     fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;  
  155.       
  156.     ret = ioctl(fd, VIDIOC_S_FMT, &fmt);  
  157.     if (ret < 0) {  
  158.         perror("VIDIOC_S_FMT");  
  159.         return ret;  
  160.     }  
  161.       
  162.     return 0;  
  163. }  

 

3.6 视频格式查询

在v4l2中，有两种查询视频格式的方法，一个是遍历所有视频格式的

一个是查询出一种格式的

/*查询出一种格式*/

ret = ioctl(fd, VIDIOC_G_FMT, &fmt);

/*遍历所有视频格式,查询驱动所支持的格式*/

VIDIOC_ENUM_FMT

  1. 驱动  
  2. static int s3c_fimc_v4l2_g_fmt_vid_cap(struct file *filp, void *fh,  
  3.                     struct v4l2_format *f)  
  4. {  
  5.     struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;  
  6.     int size = sizeof(struct v4l2_pix_format);  
  7.   
  8.     memset(&f->fmt.pix, 0, size);  
  9.     memcpy(&f->fmt.pix, &(ctrl->v4l2.frmbuf.fmt), size);  
  10.   
  11.     return 0;  
  12. }  
  13. 应用  
  14. static int video_getfmt(int fd)  
  15. {  
  16.     /***********get Stream data format********/  
  17.     int ret= 0;  
  18.     struct v4l2_format fmt;  
  19.     CLEAR(fmt);  
  20.     fmt.type    =   V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  21.     ret = ioctl(fd, VIDIOC_G_FMT, &fmt);  
  22.     if (ret < 0) {  
  23.         perror("VIDIOC_G_FMT");  
  24.         return ret;  
  25.     }  
  26.     printf("/n**********vidioc get stream format informations:****\n");  
  27.     if (fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)  
  28.         printf("8-bit YUYVV pixel format\n");  
  29.         printf("Size of the buffer = %d\n", fmt.fmt.pix.sizeimage);  
  30.         printf("Line offset = %d\n", fmt.fmt.pix.bytesperline);  
  31.     if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED)  
  32.         printf("Storate format is interlaced frame format\n");  
  33.           
  34.     return 0;  
  35. }  
    3.7 向驱动申请帧缓冲，内存，一般不超过5个,帧缓冲管理
  1. 结构体  
  2. struct v4l2_requestbuffers req;  
  3. ret = ioctl(fd, VIDIOC_REQBUFS, &req);  
  4. ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);//读取缓存   
  5.   
  6. struct v4l2_requestbuffers {  
  7.     __u32           count;  
  8.     enum v4l2_buf_type      type;  
  9.     enum v4l2_memory        memory;  
  10.     __u32           reserved[2];  
  11. };  
  12.       
  13. struct v4l2_buffer {  
  14.     __u32           index;  
  15.     enum v4l2_buf_type      type;  
  16.     __u32           bytesused;  
  17.     __u32           flags;  
  18.     enum v4l2_field     field;  
  19.     struct timeval      timestamp;  
  20.     struct v4l2_timecode    timecode;  
  21.     __u32           sequence;  
  22.   
  23.     /* memory location */  
  24.     enum v4l2_memory        memory;  
  25.     union {  
  26.         __u32           offset;  
  27.         unsigned long   userptr;  
  28.     } m;  
  29.     __u32           length;  
  30.     __u32           input;  
  31.     __u32           reserved;  
  32. };  
  33. 使用VIDIOC_REQBUFS 我们获取了req.count个缓存，下一步通过  
  34. 调用VIDIOC_QUERYBUF 命令来获取这些缓存的地址，然后使用  
  35. mmap函数转换成应用程序中的绝对地址，最后把这些缓存放入  
  36. 缓存队列。  
  37. The main steps that the application must perform for buffer allocation are:   
  38. Allocating Memory   
  39. Getting Physical Address   
  40. Mapping Kernel Space Address to User Space   
  41. 驱动支持  
  42.   
  43. static int s3c_fimc_v4l2_reqbufs(struct file *filp, void *fh,  
  44.                     struct v4l2_requestbuffers *b)  
  45. {  
  46.     if (b->memory != V4L2_MEMORY_MMAP) {  
  47.         err("V4L2_MEMORY_MMAP is only supported\n");  
  48.         return -EINVAL;  
  49.     }  
  50.   
  51.     /* control user input */  
  52.     if (b->count > 4)  
  53.         b->count = 4;  
  54.     else if (b->count < 1)  
  55.         b->count = 1;  
  56.   
  57.     return 0;  
  58. }  
  59. static int s3c_fimc_v4l2_querybuf(struct file *filp, void *fh,  
  60.                     struct v4l2_buffer *b)  
  61. {  
  62.     struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;  
  63.       
  64.     if (b->type != V4L2_BUF_TYPE_VIDEO_OVERLAY && \  
  65.         b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)  
  66.         return -EINVAL;  
  67.   
  68.     if (b->memory != V4L2_MEMORY_MMAP)  
  69.         return -EINVAL;  
  70.   
  71.     b->length = ctrl->out_frame.buf_size;  
  72.   
  73.     /* 
  74.      * NOTE: we use the m.offset as an index for multiple frames out. 
  75.      * Because all frames are not contiguous, we cannot use it as 
  76.      * original purpose. 
  77.      * The index value used to find out which frame user wants to mmap. 
  78.      */  
  79.     b->m.offset = b->index * PAGE_SIZE;  
  80.   
  81.     return 0;  
  82. }  
  83. static int s3c_fimc_v4l2_qbuf(struct file *filp, void *fh,  
  84.                 struct v4l2_buffer *b)  
  85. {  
  86.     return 0;  
  87. }  
  88. 应用层  
  89. static int video_mmap(int fd)  
  90. {  
  91.     /*******step 1*****requestbuffers Allocating Memory *******/  
  92.     int ret = 0;  
  93.     struct v4l2_requestbuffers req;  
  94.     CLEAR(req);  
  95.     req.count    = 4;  
  96.     req.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  97.     req.memory   = V4L2_MEMORY_MMAP;  
  98.       
  99.     ret = ioctl(fd, VIDIOC_REQBUFS, &req);  
  100.     if (ret < 0) {  
  101.         perror("VIDIOC_REQBUFS");  
  102.         return ret;  
  103.     }  
  104.       
  105.     if (req.count < 2)  
  106.         printf("insufficient buffer memory\n");  
  107.         printf("Number of buffers allocated = %d\n", req.count);  
  108.           
  109.     /*******step 2*****Getting Physical Address  *******/  
  110.     buffers = calloc(req.count, sizeof(*buffers));  
  111.     for (n_buffers = 0; n_buffers < req.count; ++n_buffers)  
  112.     {  
  113.         struct v4l2_buffer buf;//驱动中的一帧   
  114.         CLEAR(buf);  
  115.         buf.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  116.         buf.memory  = V4L2_MEMORY_MMAP;  
  117.         buf.index   = n_buffers;  
  118.           
  119.         ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);  
  120.         if (ret < 0) {  
  121.             perror("VIDIOC_QUERYBUF");  
  122.             return ret;  
  123.         }  
  124.           
  125.     /*******step 3*****Mapping Kernel Space Address to User Space*******/  
  126.         buffers[n_buffers].length = buf.length;  
  127.         buffers[n_buffers].start =   
  128.         mmap(NULL,  
  129.             buf.length,  
  130.             PROT_READ | PROT_WRITE,  
  131.             MAP_SHARED,  
  132.             fd,  
  133.             buf.m.offset);  
  134.               
  135.         //if (MAP_FAILED == buffers[n_buffers].start)   
  136.         //perror("mmap failed \n");   
  137.     }  
  138.       
  139.     /************requestbuffers in queue***********/  
  140.     for (i = 0; i < n_buffers; ++i) {  
  141.         struct v4l2_buffer buf;  
  142.         CLEAR(buf);  
  143.           
  144.         buf.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  145.         buf.memory  = V4L2_MEMORY_MMAP;  
  146.         buf.index = i;  
  147.           
  148.         ret = ioctl(fd, VIDIOC_QBUF, &buf);//申请的缓冲进入队列   
  149.         if (ret < 0) {  
  150.             perror("VIDIOC_QBUF");  
  151.             return ret;  
  152.         }     
  153.     }  
  154.       
  155.     return 0;  
  156. }     
3.8 开始捕捉图像数据(重要)
  1. <PRE class=csharp name="code">

    结构体

    <PRE class=csharp name="code">enum v4l2_buf_type type;//开始捕捉图像数据   
  2.     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  3.     ret = ioctl(fd, VIDIOC_STREAMON, &type);  
  4.       
  5. enum v4l2_buf_type {  
  6.     V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,  
  7.     V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,  
  8.     V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,  
  9.     V4L2_BUF_TYPE_VBI_CAPTURE          = 4,  
  10.     V4L2_BUF_TYPE_VBI_OUTPUT           = 5,  
  11.     V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,  
  12.     V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,  
  13. #if 1   
  14.     /* Experimental */  
  15.     V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,  
  16. #endif   
  17.     V4L2_BUF_TYPE_PRIVATE              = 0x80,  
  18. };  
  19.   
  20. 驱动  
  21.   
  22. static int s3c_fimc_v4l2_streamon(struct file *filp, void *fh,  
  23.                     enum v4l2_buf_type i)  
  24. {  
  25.     struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;  
  26.     if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)  
  27.         return -EINVAL;  
  28. printk("s3c_fimc_v4l2_streamon is called\n");  
  29.     if (ctrl->in_type != PATH_IN_DMA)  
  30.         s3c_fimc_init_camera(ctrl);  
  31.   
  32.     ctrl->out_frame.skip_frames = 0;  
  33.     FSET_CAPTURE(ctrl);  
  34.     FSET_IRQ_NORMAL(ctrl);  
  35.     s3c_fimc_start_dma(ctrl);  
  36.   
  37.     return 0;  
  38. }  
  39. 硬件控制寄存器的配置  
  40. 应用层  
  41. static int video_streamon(int fd)  
  42. {  
  43.     int ret = 0;  
  44.       
  45.     /************start stream on***********/  
  46.   
  47.     enum v4l2_buf_type types;//开始捕捉图像数据   
  48.     types = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  49.     ret = ioctl(fd, VIDIOC_STREAMON, &types);  
  50.     if (ret < 0) {  
  51.         perror("VIDIOC_STREAMON");  
  52.         return ret;  
  53.     }  
  54.   
  55.     return 0;  
  56. }
posted @ 2013-10-09 23:08  天天向上...  阅读(655)  评论(0)  编辑  收藏  举报