Video4linux 中文解析

Video4linux 中文解析 收藏

•Video4linux（简称V4L),是linux中关于视频设备的内核驱动。

•现在已有Video4linux2，还未加入linux内核，使用需自己下载补丁

•在Linux中，视频设备是设备文件，可以像访问普通文件一样对其进行读写

•摄像头在/dev/video0下

1.打开视频设备：

2. 读取设备信息

3.更改设备当前设置（如果有必要）

4.进行视频采集，两种方法: (都没成功）L

                            1.内存映射

                            2.直接从设备读取

5.对采集的视频进行处理（没做）

6.关闭视频设备。

 

 

为程序定义的数据结构

 

•typedef struct v4l_struct

•{

•   int fd;

•   struct video_capability capability;

•   struct video_channel channel[4];

•   struct video_picture picture; 

•   struct video_window window;

•   struct video_capture capture;

•   struct video_buffer buffer;

•   struct video_mmap mmap;

•   struct video_mbuf mbuf;   

•   unsigned char *map;

•   int frame;

•   int framestat[2];

•}vd;

 

 

•1. video_capability

•包含设备的基本信息（设备名称、支持的最大最小分辨率、信号源信息等）

•包含的分量：

•name[32]   //设备名称

•maxwidth ，maxheight，minwidth，minheight

•Channels    //信号源个数

•type    //是否能capture，彩色还是黑白，是否          能裁剪等等。                                      值如VID_TYPE_CAPTURE等

 

2 •video_picture

•设备采集的图象的各种属性

•brightness 0~65535

•hue

•colour

•contrast

•whiteness

•depth // 24

•palette //VIDEO_PALETTE_RGB24

3•video_channel         关于各个信号源的属性

     Channel //信号源的编号

     name

     tuners

    Type     VIDEO_TYPE_TV  |  IDEO_TYPE_CAMERA

     Norm  制式

4

•video_window  //包含关于capture area的信息

     x  x windows 中的坐标.

     y     x windows 中的坐标.

     width    The width of the image capture.

     height   The height of the image capture.

     chromakey A host order RGB32 value for the chroma key.

     flags      Additional capture flags.

     clips      A list of clipping rectangles. (Set only)

clipcount    The number of clipping rectangles. (Set only)

 

 

5 •video_mbuf

       利用mmap进行映射的帧的信息

       size  //每帧大小

       Frames //最多支持的帧数

       Offsets  //每帧相对基址的偏移

6 •video_buffer   最底层对buffer的描述

       void *baseBase   physical address of the buffer

       int height      Height of the frame buffer

       int widthWidth    of the frame buffer

       int depthDepth   of the frame buffer

       int bytesperline  Number of bytes of memory between the start of two adjacent lines

    实际显示的部分一般比它描述的部分小

7 •video_mmap //用于mmap 

 

关键步骤介绍

•初始化阶段做的工作

•int ioctl(int fd, ind cmd, …)   input output control 的缩写

•用于和设备进行“对话”。

•如果驱动程序提供了对ioctl的支 持，用户就可以在用户程序中使用ioctl函数控制设备的I/O通道。

•fd：设备的文件描述符，cmd:用户程序对设备的控制命令 ，.省略号一般是一个表示类型长度的参数，也可以没有。

•1.打开视频：

•Open（”/dev/video0”，vdàfd);

•关闭视频设备用close（”/dev/video0”，vdàfd);

•2. 读video_capability 中信息

•ioctl(vd->fd, VIDIOCGCAP, &(vd->capability))

•成功后可读取vd->capability各分量  eg.

•Printf（”maxwidth = %d”vd->capability .maxwidth）;

 

 

 

•3.读video_picture中信息

•ioctl(vd->fd, VIDIOCGPICT, &(vd->picture))；

•

•

•4.改变video_picture中分量的值

•先为分量赋新值，再调用VIDIOCSPICT

•Eg.

•vd->picture.colour = 65535;

•if(ioctl(vd->fd, VIDIOCSPICT, &(vd->picture)) < 0)

•     {

•            perror("VIDIOCSPICT");

•            return -1;

•     }

 

••5.初始化channel

•必须先做得到vd->capability中的信息

•for (i = 0; i < vd->capability.channels; i++)

•   {

•      vd->channel[i].channel = i; 

•      if (ioctl(vd->fd, VIDIOCGCHAN, &(vd->channel[i])) < 0)

•       {

•          perror("v4l_get_channel:");

•         return -1;

•         }

•   }

•截取图象的第一种方法：用mmap（内存映射）方式截取视频

•mmap( )系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。

•两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然

•采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝

•1.设置picture的属性

•2. 初始化video_mbuf，以得到所映射的buffer的信息

–ioctl(vd->fd, VIDIOCGMBUF, &(vd->mbuf))

 

••3.可以修改video_mmap和帧状态的当前设置

•    Eg.     vd->mmap.format = VIDEO_PALETTE_RGB24

•              vd->framestat[0] = vd->framestat[1] = 0;  vd->frame = 0;

•

•4.将mmap与video_mbuf绑定

•void* mmap ( void * addr , size_t len , int prot , int flags , int fd , off_t offset )

•len //映射到调用进程地址空间的字节数，它从被映射文件开头   offset个字节开始算起

•Prot //指定共享内存的访问权限  PROT_READ（可 读） ,    PROT_WRITE （可写）, PROT_EXEC        （可执行）

•flags  // MAP_SHARED   MAP_PRIVATE中必选一个

•         // MAP_ FIXED不推荐使用  

•

••addr  //共内存享的起始地址，一般设0，表示由系统分配

•Mmap( )  返回值是系统实际分配的起始地址

•if((vd->map = (unsigned char*)mmap(0, vd->mbuf.size, PROT_READ|PROT_WRITE, MAP_SHARED, vd->fd, 0)) < 0)

•     {

•            perror("v4l_mmap mmap:");

•            return -1;

•     }

•

•4.Mmap方式下真正做视频截取的 VIDIOCMCAPTURE

•ioctl(vd->fd, VIDIOCMCAPTURE, &(vd->mmap)) ;

•若调用成功，开始一帧的截取，是非阻塞的，

•是否截取完毕留给VIDIOCSYNC来判断

••5. 调用VIDIOCSYNC等待一帧截取结束

•if(ioctl(vd->fd, VIDIOCSYNC, &frame) < 0)

•     {

•            perror("v4l_sync:VIDIOCSYNC");

•            return -1;

•     }

•若成功，表明一帧截取已完成。可以开始做下一次 VIDIOCMCAPTURE

•frame是当前截取的帧的序号。

••关于双缓冲：

•video_bmuf  bmuf.frames = 2;

•一帧被处理时可以采集另一帧

•   int frame; //当前采集的是哪一帧

•   int framestat[2]; //帧的状态  没开始采集|等待                         采集结束

•帧的地址由

•vd->map + vd->mbuf.offsets[vd->frame]得到

•

•采集工作结束后调用munmap取消绑定

•munmap(vd->map, vd->mbuf.size)

•关于mmap过程的总结：

•1.得到图象的信息                    

•2.初始化video_mbuf                      VIDIOCGMBUF

•3. video_mbuf与mmap绑定           mmap（）

•4. 可以修改video_mmap和帧状态的当前设置

•    Eg.     vd->mmap.format = VIDEO_PALETTE_RGB24

•              vd->framestat[0] = vd->framestat[1] = 0;  vd->frame = 0;

•Loop：

•{

•     if（framestat[帧号] = 0）

     VIDIOCMCAPTURE( );  // 开始 截取，置framestat[帧号] = 1

     if（framestat[帧号] = 1）

         VIDIOCSYNC( );  //等待截取完成，置framestat[帧号] = 0

       对采集的帧做处理；//帧地址是vd->map + vd->mbuf.offsets[vd->frame]

      帧号 = 帧号 ^ 1;

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lanmanck/archive/2009/04/15/4075089.aspx

 

linux 下视频设备设置的几个参数 v4l video4linux v4l2 ioctl 收藏
用一系列的ioctl发命令控制设备。v4l支持的ioctl命令大概有二十几个，为了尽快的编出一个
简单的图象捕捉程序，让我们先来看看几个主要的命令：

1. ioctl(fd,VIDIOCGCAP,&cap);
   该命令主要是为了获取电视卡的功能信息。例如电视卡的名称，类型，channel等。参数cap是一个结构，当ioctl命令返回时，结构的各成员就被赋值了，结构体的定义为：
struct video_capability
{
        char name[32];
        int type;
        int channels;        /* Num channels */
        int audios;        /* Num audio devices */
        int maxwidth;        /* Supported width */
        int maxheight;        /* And height */
        int minwidth;        /* Supported width */
        int minheight;        /* And height */
};
channel 指的是有几个信号输入源，例如television,composite,s-video等。

2.ioctl(fd,VIDIOCGCHAN,&vc)
3.ioctl(fd,VIDIOCSCHAN.&vc)
这两个命令用来取得和设置电视卡的channel信息，例如使用那个输入源，制式等。
vc 是一个video_channel结构，其定义为：
struct video_capability
{
        char name[32];
        int type;
        int channels;        /* Num channels */
        int audios;        /* Num audio devices */
        int maxwidth;        /* Supported width */
        int maxheight;        /* And height */
        int minwidth;        /* Supported width */
        int minheight;        /* And height */
};

struct video_channel
{
        int channel;
        char name[32];
        int tuners;//number of tuners for this input
        __u32  flags;
        __u16  type;       
        __u16 norm;               
};
成员channel代表输入源，通常，0: television 1:composite1 2:s-video
name 表示该输入源的名称。
norm 表示制式，通常，0:pal 1:ntsc 2:secam 3:auto

4. ioctl(fd,VIDIOCGMBUF,*mbuf)
获得电视卡缓存的信息，参数mbuf是video_mbuf结构。其定义如下：
struct video_mbuf
{
        int        size;                /* Total memory to map */
        int        frames;                /* Frames */
        int        offsets[VIDEO_MAX_FRAME];
};
size是缓存的大小，frames表明该电视卡的缓存可以容纳的帧数，数组offsets则表明
对应一帧的起始位置，0帧对应offsets[0],1帧对应offsets[1]....
执行完该命令后，就可以用mmap函数将缓存映射到内存中了。大致用法可以参考以下的代
码
struct video_mbuf mbuf;
unsigned char *buf1,*buf2;

if(ioctl(fd,VIDIOCGMBUF,&mbuf)<0)
{
        perror("VIDIOCGMBUF");
        return -1;
}

printf("the frame number is %d\n",mbuf.frames);

buf1 = (unsigned char*)mmap(0,mbuf.size,PROT_READ|PROT_WRITE,MAP_SHARED,fd.0);

buf1 = buf1 + mbuf.offset[0];
buf2 = buf1 + mbuf.offset[1];//当然，如果mbuf.frames=1,就不需要下面的了。
......

5. ioctl(fd.VIDIOCMCAPTURE，&mm)
   启动硬件去捕捉图象，mm 是video_mmap 结构，设置捕捉图象需要设置的信息。结构体
如下定义：

struct video_mmap
{
        unsigned        int frame;                /* Frame (0 - n) for double buffer */
        int                height,width;
        unsigned        int format;                /* should be VIDEO_PALETTE_* */
};
frame :设置当前是第几帧
height,width:设置图象的高和宽。
format :颜色模式

要注意的是，该命令是非阻塞的，也就是说，它仅仅设置了硬件，而不负责是否捕捉到图象。
要确定是否捕捉到图象，要用到下一个命令。

6. ioctl(fd,VIDIOCSYNC,&frame)
等待捕捉到这一帧图象。frame 是要等待的图象，它的值应和上一个命令中设置的frame相对应。

好了，说了这么多，读者大概也对视频捕捉有了一个了解，是不是想亲自动手试一下，那就让我们
开始实际程序的编写吧。
下面我们会编一个程序，将捕捉到的图象存为jpeg文件。为此，还要向大家介绍一个函数，

int write_jpeg(char *filename,unsigned char *buf,int quality,int width, int height, int gray)
{
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
    FILE *fp;
    int i;
    unsigned char *line;
    int line_length;
   
    if (NULL == (fp = fopen(filename,"w")))
    {
                fprintf(stderr,"grab: can't open %s: %s\n",filename,strerror(errno));
                return -1;
    }
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    jpeg_stdio_dest(&cinfo, fp);
    cinfo.image_width  = width;
    cinfo.image_height = height;
    cinfo.input_components = gray ? 1: 3;
    cinfo.in_color_space = gray ? JCS_GRAYSCALE: JCS_RGB;
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, quality, TRUE);
    jpeg_start_compress(&cinfo, TRUE);

    line_length = gray ? width : width * 3;
    for (i = 0, line = buf; i < height; i++, line += line_length)
        jpeg_write_scanlines(&cinfo, &line, 1);
   
    jpeg_finish_compress(&(cinfo));
    jpeg_destroy_compress(&(cinfo));
    fclose(fp);

    return 0;
}

这个函数很通用，它的作用是把buf中的数据压缩成jpeg格式。

/*         下面是一个完整的程序 test.c
*           gcc test.c -o test -ljpeg
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
        
#include

#define WIDTH  320
#define HEIGHT 240
#define V4L_DEVICE "/dev/video0"

main()
{

   unsigned char* buf;
   int i,j;
   int fd;
   int re;

   struct video_capability vcap;
   struct video_channel    vc;
   struct video_mbuf       mbuf;
   struct video_mmap       mm;

   fd = open(V4L_DEVICE, O_RDWR);
   if(fd<=0)
   {
           perror("open");
             exit(1);
   }

   if(ioctl(fd, VIDIOCGCAP, &vcap)<0)
   {
             perror("VIDIOCGCAP");
             exit(1);
   }

   fprintf(stderr,"Video Capture Device Name : %s\n",vcap.name);

   for(i=0;i   {
             vc.channel = i;
             if(ioctl(fd, VIDIOCGCHAN, &vc)<0)
             {
                       perror("VIDIOCGCHAN");
                       exit(1);
             }

             fprintf(stderr,"Video Source (%d) Name : %s\n",i, vc.name);
   }

   vc.channel =1;
   vc.norm=1;

   if(ioctl(fd, VIDIOCSCHAN, &vc) < 0)
   {
             perror("VIDIOCSCHAN");
             exit(1);
   }

  if(ioctl(fd, VIDIOCGMBUF, &mbuf) < 0)
  {
        perror("VIDIOCGMBUF");
        exit(1);
  }
   fprintf(stderr,"the frames number is %d\n",mbuf.frames);

  buf = (unsigned char*)mmap(0, mbuf.size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
   if((int)buf < 0)
   {
             perror("mmap");
             exit(1);
   }
   mm.frame  = 0;
   mm.height = HEIGHT;
   mm.width  = WIDTH;
   mm.format = VIDEO_PALETTE_RGB24;

   if(ioctl(fd, VIDIOCMCAPTURE, &mm)<0)
   {
             perror("VIDIOCMCAPTURE");
            exit(1);
   }

   if(ioctl(fd, VIDIOCSYNC, &mm.frame)<0)
   {
             perror("VIDIOCSYNC");
             exit(1);
   }

if(-1 == (write_jpeg("./pic001.jpeg",buf,75,WIDTH,HEIGHT,0)))
{
        printf("write_jpeg error\n");
        exit(1);
}

   munmap(buf,mbuf.size);
   close(fd);
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lanmanck/archive/2009/04/13/4069534.aspx