学步园

static const struct v4l2_file_operations vivi_fops = {
 
       .owner           = THIS_MODULE,
 
       .open           = vivi_open,
 
       .release        = vivi_close,
 
       .read           = vivi_read,
 
       .poll        = vivi_poll,
 
       .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
 
       .mmap           = vivi_mmap,
 
};

static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
 
       .vidioc_querycap      = vidioc_querycap,
 
       .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
 
       .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
 
       .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
 
       .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
 
       .vidioc_reqbufs       = vidioc_reqbufs,
 
       .vidioc_querybuf      = vidioc_querybuf,
 
       .vidioc_qbuf          = vidioc_qbuf,
 
       .vidioc_dqbuf         = vidioc_dqbuf,
 
       .vidioc_s_std         = vidioc_s_std,
 
       .vidioc_enum_input    = vidioc_enum_input,
 
       .vidioc_g_input       = vidioc_g_input,
 
       .vidioc_s_input       = vidioc_s_input,
 
       .vidioc_queryctrl     = vidioc_queryctrl,
 
       .vidioc_g_ctrl        = vidioc_g_ctrl,
 
       .vidioc_s_ctrl        = vidioc_s_ctrl,
 
       .vidioc_streamon      = vidioc_streamon,
 
       .vidioc_streamoff     = vidioc_streamoff,
 
#ifdef CONFIG_VIDEO_V4L1_COMPAT
 
       .vidiocgmbuf          = vidiocgmbuf,
 
#endif
 
};

static struct video_device vivi_template = {
 
       .name             = "vivi",
 
       .fops           = &vivi_fops,
 
       .ioctl_ops       = &vivi_ioctl_ops,
 
       .minor            = -1,
 
       .release    = video_device_release,
 
 
 
       .tvnorms              = V4L2_STD_525_60,
 
       .current_norm         = V4L2_STD_NTSC_M,
 
};

struct vivi_dev {
    struct list_head           vivi_devlist; //内核双向链表,在内核数据结构里有描述
    struct semaphore           lock;   //信号量,防止竞态访问
    int                        users;  //用户数量计数
    /* various device info */
    unsigned int               resources;
    struct video_device        video_dev; //这个成员是这个结构的核心,用面向对象的话来说就是基类
    struct vivi_dmaqueue       vidq;       //DMA队列
    /* Several counters */
    int                        h,m,s,us,jiffies;   //定时器定义
    char                       timestr[13];     //其它一些资源变量.
};

struct vivi_fh {
    struct vivi_dev            *dev;
 
    /* video capture */
    struct vivi_fmt            *fmt;
    unsigned int               width,height;
    struct videobuf_queue      vb_vidq;
 
    enum v4l2_buf_type         type;
};

static int
vivi_mmap(struct file *file, struct vm_area_struct * vma)
{
    struct vivi_fh *fh = file->private_data;
    int ret;
 
    dprintk (1,"mmap called, vma=0x%08lx/n",(unsigned long)vma);
 
    ret=videobuf_mmap_mapper(&fh->vb_vidq, vma);
 
    dprintk (1,"vma start=0x%08lx, size=%ld, ret=%d/n",
        (unsigned long)vma->vm_start,
        (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
        ret);
 
    return ret;
}

static int vivi_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    return video_usercopy(inode, file, cmd, arg, vivi_do_ioctl);  
}

// 用非阻塞模式打开摄像头设备
int cameraFd;
cameraFd = open("/dev/video0", O_RDWR | O_NONBLOCK, 0);
// 如果用阻塞模式打开摄像头设备，上述代码变为：
//cameraFd = open("/dev/video0", O_RDWR, 0);

extern int ioctl (int __fd, unsigned long int __request, ...) __THROW;

VIDIOC_REQBUFS：分配内存
 
VIDIOC_QUERYBUF：把VIDIOC_REQBUFS中分配的数据缓存转换成物理地址
 
VIDIOC_QUERYCAP：查询驱动功能
 
VIDIOC_ENUM_FMT：获取当前驱动支持的视频格式
 
VIDIOC_S_FMT：设置当前驱动的频捕获格式
 
VIDIOC_G_FMT：读取当前驱动的频捕获格式
 
VIDIOC_TRY_FMT：验证当前驱动的显示格式
 
VIDIOC_CROPCAP：查询驱动的修剪能力
 
VIDIOC_S_CROP：设置视频信号的边框
 
VIDIOC_G_CROP：读取视频信号的边框
 
VIDIOC_QBUF：把数据从缓存中读取出来
 
VIDIOC_DQBUF：把数据放回缓存队列
 
VIDIOC_STREAMON：开始视频显示函数
 
VIDIOC_STREAMOFF：结束视频显示函数
 
VIDIOC_QUERYSTD：检查当前视频设备支持的标准，例如PAL或NTSC。

v4l2_std_id std;
do {
  ret = ioctl(fd, VIDIOC_QUERYSTD, &std);
} while (ret == -1 && errno == EAGAIN);
switch (std) {
    case V4L2_STD_NTSC:
        //……
    case V4L2_STD_PAL:
        //……
}

struct v4l2_format    fmt;
memset ( &fmt, 0, sizeof(fmt) );
fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width       = 720;
fmt.fmt.pix.height      = 576;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
if (ioctl(fd, VIDIOC_S_FMT, &fmt) == -1) {
  return -1;
}

struct v4l2_format
{
    enum v4l2_buf_type type;    // 数据流类型，必须永远是V4L2_BUF_TYPE_VIDEO_CAPTURE
    union
    {
        struct v4l2_pix_format    pix; 
        struct v4l2_window        win; 
        struct v4l2_vbi_format    vbi; 
        __u8    raw_data[200];         
    } fmt;
};
struct v4l2_pix_format
{
    __u32                   width;         // 宽，必须是16的倍数
    __u32                   height;        // 高，必须是16的倍数
    __u32                   pixelformat;   // 视频数据存储类型，例如是YUV4：2：2还是RGB
    enum v4l2_field         field;
    __u32                   bytesperline;   
    __u32                   sizeimage;
    enum v4l2_colorspace    colorspace;
    __u32                   priv;      
};

struct v4l2_requestbuffers  req;
if (ioctl(fd, VIDIOC_REQBUFS, &req) == -1) {
  return -1;
}
 
v4l2_requestbuffers定义如下：
 
struct v4l2_requestbuffers
{
    __u32               count;  // 缓存数量，也就是说在缓存队列里保持多少张照片
    enum v4l2_buf_type  type;   // 数据流类型，必须永远是V4L2_BUF_TYPE_VIDEO_CAPTURE
    enum v4l2_memory    memory; // V4L2_MEMORY_MMAP 或 V4L2_MEMORY_USERPTR
    __u32               reserved[2];
};

typedef struct VideoBuffer {
    void   *start;
    size_t  length;
} VideoBuffer;
 
VideoBuffer*          buffers = calloc( req.count, sizeof(*buffers) );
struct v4l2_buffer    buf;
 
for (numBufs = 0; numBufs < req.count; numBufs++) {
    memset( &buf, 0, sizeof(buf) );
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    buf.index = numBufs;
    // 读取缓存
    if (ioctl(fd, VIDIOC_QUERYBUF, &buf) == -1) {
        return -1;
    }
 
    buffers[numBufs].length = buf.length;
    // 转换成相对地址
    buffers[numBufs].start = mmap(NULL, buf.length,
        PROT_READ | PROT_WRITE,
        MAP_SHARED,
        fd, buf.m.offset);
 
    if (buffers[numBufs].start == MAP_FAILED) {
        return -1;
    }
 
    // 放入缓存队列
    if (ioctl(fd, VIDIOC_QBUF, &buf) == -1) {
        return -1;
    }
}

struct v4l2_buffer buf;
memset(&buf,0,sizeof(buf));
buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory=V4L2_MEMORY_MMAP;
buf.index=0;
 
//读取缓存
if (ioctl(cameraFd, VIDIOC_DQBUF, &buf) == -1)
{
    return -1;
}
//…………视频处理算法
//重新放入缓存队列
if (ioctl(cameraFd, VIDIOC_QBUF, &buf) == -1) {
 
    return -1;
}

struct buffer {
 
  void * start;
 
  size_t length};

#include <stdio.h>  

 

#include <stdlib.h>  

 

#include <string.h>  

 

#include <assert.h>  

 

#include <getopt.h>             /* getopt_long() */  

 

#include <fcntl.h>              /* low-level i/o */  

 

#include <unistd.h>  

 

#include <errno.h>  

 

#include <malloc.h>  

 

#include <sys/stat.h>  

 

#include <sys/types.h>  

 

#include <sys/time.h>  

 

#include <sys/mman.h>  

 

#include <sys/ioctl.h>  

 

#include <asm/types.h>          /* for videodev2.h */  

 

#include <linux/videodev2.h>  

 

#define CLEAR(x) memset (&(x), 0, sizeof (x))  

 

typedef enum {

 

    IO_METHOD_READ, IO_METHOD_MMAP, IO_METHOD_USERPTR,

 

} io_method;

 

struct buffer {

 

    void * start;

 

    size_t length;//buffer's length is different from cap_image_size  

 

};

 

static char * dev_name = NULL;

 

static io_method io = IO_METHOD_MMAP;//IO_METHOD_READ;//IO_METHOD_MMAP;  

 

static int fd = -1;

 

struct buffer * buffers = NULL;

 

static unsigned int n_buffers = 0;

 

static FILE * outf = 0;

 

static unsigned int cap_image_size = 0;//to keep the real image size!!  

 

//////////////////////////////////////////  

 

static void errno_exit(const char * s) {

 

    fprintf(stderr, "%s error %d, %s/n", s, errno, strerror(errno));

 

    exit(EXIT_FAILURE);

 

}

 

static int xioctl(int fd, int request, void * arg) {

 

    int r;

 

    do

 

        r = ioctl(fd, request, arg);

 

    while (-1 == r && EINTR == errno);

 

    return r;

 

}

 

static void process_image(const void * p, int len) {

 

    //  static char[115200] Outbuff ;  

 

    fputc('.', stdout);

 

    if (len > 0) {

 

        fputc('.', stdout);

 

        fwrite(p, 1, len, outf);

 

    }

 

    fflush(stdout);

 

}

 

static int read_frame(void) {

 

    struct v4l2_buffer buf;

 

    unsigned int i;

 

    switch (io) {

 

    case IO_METHOD_READ:

 

        if (-1 == read(fd, buffers[0].start, buffers[0].length)) {

 

            switch (errno) {

 

            case EAGAIN:

 

                return 0;

 

            case EIO:

 

                /* Could ignore EIO, see spec. */

 

                /* fall through */

 

            default:

 

                errno_exit("read");

 

            }

 

        }

 

        //      printf("length = %d/r", buffers[0].length);  

 

        //      process_image(buffers[0].start, buffers[0].length);  

 

        printf("image_size = %d,/t IO_METHOD_READ buffer.length=%d/r",

 

                cap_image_size, buffers[0].length);

 

        process_image(buffers[0].start, cap_image_size);

 

        break;

 

    case IO_METHOD_MMAP:

 

        CLEAR (buf);

 

        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

 

        buf.memory = V4L2_MEMORY_MMAP;

 

        if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {

 

            switch (errno) {

 

            case EAGAIN:

 

                return 0;

 

            case EIO:

 

                /* Could ignore EIO, see spec. */

 

                /* fall through */

 

            default:

 

                errno_exit("VIDIOC_DQBUF");

 

            }

 

        }

 

        assert(buf.index < n_buffers);

 

        //      printf("length = %d/r", buffers[buf.index].length);  

 

        //      process_image(buffers[buf.index].start, buffers[buf.index].length);  

 

        printf("image_size = %d,/t IO_METHOD_MMAP buffer.length=%d/r",

 

                cap_image_size, buffers[0].length);

 

        process_image(buffers[0].start, cap_image_size);

 

        if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))

 

            errno_exit("VIDIOC_QBUF");

 

        break;

 

    case IO_METHOD_USERPTR:

 

        CLEAR (buf);

 

        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

 

        buf.memory = V4L2_MEMORY_USERPTR;

 

        if (-1 == xioctl(fd, VIDIOC_DQBUF,











														
							
			

				返回
			
			

			
			
			
		
		

			
			
		
                

		


			

		
	
	


	
	

		
						
		

			【上篇】sql语句,exec执行 拼接的字符串 输出参数   问题
【下篇】Ext Js中Ext.XTemplate使用方法学习			
			
			
			
		
		
								
		

		

			

				


				
				

				

					
作者: manned
				
			
			
				

					
该日志由 manned 于11年前发表在综合分类下，最后更新于 2013年10月06日.
					
转载请注明: V4L2驱动的移植与应用（一） | 学步园 +复制链接
					

				
			
			
			
			

		
		

			
			
		
		
	

	
			
		
抱歉!评论已关闭.
							


	
						
		

		
书签

	

招生
白云飘飘网
青岛房产网

	

    	

			
			
		

	
最新文章New
	
	

		

			

								网站优化可以收获更好的收益
								robots在网页开发中起到了一定的
								SEO引擎优化可以更好的方便搜索
								Dreamweaver教程很实用，值得学习
								很多的photoshop教程值得学习，你
								编程语言很重要，特别是对于计算
								数据库非常常见，也非常实用！
								H5指的是第5代html，不同于传统企
								HTML是什么，该怎么制作？
							
		
		

	
	

		
		
	

	
		

		
本站推荐

	

	

				

			
为什么PHP的吉祥物是一头大象
		
				

			
作业的提交和监控（二）
		
				

			
作业的提交和监控（一）
		
				

			
Boost – Function 分析
		
				

			
奇技淫巧 – C/C++ 宏自身
		
				

			
模板的 SFINAE 原则
		
				

			
Octopress 和 Git 的结合
		
				

			
Electric-fence 介绍
		
			
	



	
	

	

	
	
				

			
	

				
	
		

					
	
				


			


	

		
web前端
数据库
编程语言
搜索技术
关于本站
	
	

	返回首页
		
	



	Copyright © 2013-2018 学步园  保留所有权利.

	软文销售 QQ客服：2265327166 （其他合作也可洽谈）
		
必威体育
	
必威电竞