V4L2 视频采集技术

今天药忘吃喽~ 2021-10-26 11:34 349阅读 0赞

Video4linux 简介  
Video4Linux是为市场现在常见的电视捕获卡和并口及USB口的摄像头提供统一的编程接口。同时也提供无线电通信和文字电视广播解码和垂直消隐的数据接口。本文主要针对USB摄像头设备文件/dev/video0，进行视频图像采集方面的程序设计。

Video4linux 编程指南  
1.视频编程的流程  
（1）打开视频设备：  
（2）读取设备信息  
（3）更改设备当前设置（可以不做）  
（4）进行视频采集，两种方法:  
 a.内存映射  
 b.直接从设备读取  
（5）对采集的视频进行处理（ 本程序没做，下次再show给大家）  
（6）关闭视频设备

//下面我对这些操作做了个简单的函数封装  
\#ifndef \_V4L\_H  
\#define \_V4L\_H

\#include <stdio.h>  
\#include <stdlib.h>  
\#include <unistd.h>  
\#include <error.h>  
\#include <assert.h>  
\#include <fcntl.h>  
\#include <sys/ioctl.h>  
\#include <sys/types.h>  
\#include <sys/mman.h>  
\#include <linux/videodev.h>  
\#include <sys/types.h>  
\#include <string.h>

/\*采集的图像的最大长和宽\*/  
\#define MAX\_WIDTH 400  
\#define MAX\_HEIGHT 300  
/\*设备文件\*/  
\#define DEFAULT\_DEVICE “/dev/video0″  
/\*自定义数据结构,包含v4l 中用到的数据结构\*/  
typedef struct v4l\_struct  
\{  
    int fd;/\*设备号\*/  
    struct video\_capability capability; //包含设备的基本信息（设备名称、支持的最大最小分辨率、信号源信息等）  
    struct video\_channel channel\[8\];//信号源个数  
    struct video\_picture picture;//设备采集的图象的各种属性  
    struct video\_mmap mmap;//用于mmap           
    struct video\_mbuf mbuf;//利用mmap进行映射的帧的信息              
    unsigned char \*buffer ;/\*图像数据存放区\*/  
    unsigned char \*map;/\*mmap方式获取数据时,数据的首地址\*/  
    int frame\_current;  
    int frame\_using\[2\]; /\*这个帧的状态0 表示可用,1表示不可用\*/  
\}v4l\_device;

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名:v4l\_open  
\* 功  能: 打开设备  
\* 输  入: dev,vd  
\* 输  出: 无  
\* 返  回:  -1—-失败  0—-成功  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_open( char \*dev, v4l\_device \*vd )  
\{  
    if( !dev )  
    \{  
        dev=DEFAULT\_DEVICE ;  
    \}  
    if( ( vd->fd = open( dev, O\_RDWR ) )  < 0 )  
    \{  
        perror( “v4l\_open error” );  
        return -1;  
    \}  
    return 0;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_get\_capability  
\* 功  能: 获取设备属性  
\* 输  入: vd  
\* 输  出: 无  
\* 返  回:  -1—-失败 0—-成功  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_get\_capability( v4l\_device \*vd )  
\{  
    if( ioctl( vd->fd, VIDIOCGCAP, &( vd->capability ) ) <0 )  
    \{  
        perror( “v4l\_get\_capability” );  
        return -1 ;  
    \}  
    return 0;   
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名:v4l\_get\_picture  
\* 功  能:获取图片属性  
\* 输  入: vd  
\* 输  出: 无  
\* 返  回:  -1—-失败  0—-成功  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_get\_picture( v4l\_device \*vd )  
\{  
    if( ioctl( vd->fd,VIDIOCGPICT,&( vd->picture ) ) < 0 )  
    \{  
        return -1;  
    \}  
    return 0;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_set\_picture  
\* 功  能: 设置图片属性  
\* 输  入: vd  
\* 输  出: 无  
\* 返  回: -1—-失败 0—-成功  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_set\_picture( v4l\_device \*vd )   
\{  
    if( ioctl( vd->fd, VIDIOCSPICT, &( vd->picture ) ) < 0 )  
    \{  
        return -1;  
    \}  
    return 0;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名:v4l\_get\_channels  
\* 功  能:获取通道信息  
\* 输  入: vd  
\* 输  出: 无  
\* 返  回:  -1—-失败 0—-成功  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_get\_channels( v4l\_device \*vd )  
\{  
    int i;  
    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;  
        \}  
    \}  
    return 0;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_get\_mbuf  
\* 功  能: 获取内存映射信息  
\* 输  入: vd  
\* 输  出: 无  
\* 返  回:  -1—-失败 0—-成功  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_get\_mbuf( v4l\_device \*vd )  
\{  
    if( ioctl ( vd->fd,VIDIOCGMBUF,&( vd->mbuf ) ) <0 )  
    \{  
        perror( “get\_mbuf:” );  
        return -1;  
    \}  
    if ( ( vd->map = ( unsigned char \* )mmap( 0, vd->mbuf.size, PROT\_READ | PROT\_WRITE, MAP\_SHARED, vd->fd, 0 ) ) < 0 )  
    \{  
        perror(“v4l\_mmap\_init:mmap”);  
        return -1;  
    \}  
    return 0 ;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_init\_mbuff  
\* 功  能: 初始化内存映射信息  
\* 输  入: vd  
\* 输  出: 无  
\* 返  回: 0—-成功  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_init\_mbuf(v4l\_device \*vd)  
\{  
    //vd->mmap.frame = 10 ; //不懂双帧是怎样设置的这个frame 该是当前帧的可mbuf 以又没有设置怎么确定是双帧不是单帧还是更多  
    vd->mmap.width = MAX\_WIDTH;  
    vd->mmap.height = MAX\_HEIGHT;  
    vd->mmap.format = vd->picture.palette;  
    vd->frame\_current = 0;  
    vd->frame\_using\[0\] = 0;  
    vd->frame\_using\[1\] = 0;  
    return 0;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_get\_address  
\* 功  能: 获取数据在图像的地址  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
unsigned char \*v4l\_get\_address(v4l\_device \*vd)  
\{  
    return (vd->map + vd->mbuf.offsets\[vd->frame\_current\]);  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_grab\_frame  
\* 功  能: 捕获帧  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_grab\_frame(v4l\_device \*vd, int frame)  
\{  
    if (vd->frame\_using\[frame\])   
    \{  
        fprintf(stderr, “v4l\_grab\_frame: frame %d is already used.\\n”, frame);  
        return -1;  
    \}  
    vd->mmap.frame = frame;  
    if ( ioctl(vd->fd, VIDIOCMCAPTURE, &(vd->mmap ) ) < 0 )   
    \{  
        perror( “v4l\_grab\_frame” );  
        return -1;  
    \}  
    vd->frame\_using\[frame\] = 1;  
    vd->frame\_current = frame;  
    return 0;      
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_grab\_sync  
\* 功  能:与内存映射捕获一致  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_grab\_sync(v4l\_device \*vd)  
\{    
    if (ioctl(vd->fd, VIDIOCSYNC, &(vd->frame\_current)) < 0)   
    \{  
        perror(“v4l\_grab\_sync”);  
    \}  
    vd->frame\_using\[vd->frame\_current\] = 0;  
    return 0;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_munmap  
\* 功  能:停止内存映射  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_munmap( v4l\_device \*vd )  
\{  
    if ( munmap( vd->map, vd->mbuf.size ) < 0 )   
    \{  
        perror( “v4lmunmap:munmap” );  
        return -1;  
    \}  
    return 0;  
\}

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_close  
\* 功  能:关闭设备  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
int v4l\_close(v4l\_device \*vd)  
\{  
    close(vd->fd);  
    return 0;  
\}

\#endif

//简单的封装了关于SDL的相关操作”ScreenSurface.h”  
\#ifndef SCREEN\_SURFACE\_H  
\#define SCREEN\_SURFACE\_H

\#include <stdio.h>  
\#include <stdlib.h>  
\#include <SDL/SDL.h>

class ScreenSurface   
\{  
public:  
    ScreenSurface();  
    bool screen\_init(int w, int h, int b = 0, Uint32 f = 0);//初始化  
    ~ScreenSurface();  
    SDL\_Surface\* point() const;  
    int screen\_lock();  
    void screen\_unlock();  
    void screen\_quit();  
    void screen\_set\_caption( const char \*str );//设置标题  
    bool flip( unsigned char \* src) ;//显示  
    int startTV();//开始采集  
private:  
    static int screenNum;  
    int width;  
    int height;  
    int bpp;  
    Uint32 flags;  
    SDL\_Surface\* pScreen;  
\};

\#endif

//ScreenSurface.cpp  
\#include “ScreenSurface.h”  
\#include “qt\_v4l.h”  
v4l\_device  v4l\_dev;  
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* 函数名: v4l\_grab\_movie  
\* 功  能:捕获连续图像  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
void  v4l\_grab\_movie()  
\{  
    v4l\_grab\_frame(&v4l\_dev, v4l\_dev.frame\_current);/\*获取下一 帧\*/  
    v4l\_grab\_sync(&v4l\_dev);/\*等待传完一 帧\*/  
    v4l\_dev.buffer = v4l\_get\_address(&v4l\_dev);/\*得到这一帧的地址\*/  
    v4l\_dev.frame\_current = (v4l\_dev.frame\_current+1)%2; /\* 下一帧的frame\*/  
\}

//构造函数。如果创建1个以上的screen surface，则会抛出异常  
ScreenSurface::ScreenSurface():width(640), height(480), bpp(32), flags(0)  
\{   
    pScreen = 0;  
    v4l\_open(DEFAULT\_DEVICE, &v4l\_dev);/\*打开设备\*/  
    v4l\_get\_capability(&v4l\_dev);  
    v4l\_get\_picture(&v4l\_dev);  
    v4l\_init\_mbuf(&v4l\_dev);/\*初始化设备\*/  
    v4l\_get\_mbuf(&v4l\_dev);/\*内存映射\*/  
\}

bool ScreenSurface::screen\_init(int w, int h, int b, Uint32 f)  
\{  
    width = w ;  
    height = h ;  
    bpp = b ;  
    flags = f ;  
      
    if(SDL\_Init(SDL\_INIT\_VIDEO) < 0)  
    \{  
        printf(“SDL\_Init Failed!\\n”);  
        return false;  
    \}  
    //设置图象模式(宽\*高 位数 标志 SDL\_SWSURFACE | SDL\_DOUBLEBUF)  
    pScreen = SDL\_SetVideoMode(width, height, bpp, flags);  
    if ( pScreen == 0 )  
    \{  
        printf(“Could’t set display mode \\n”);  
        SDL\_Quit();  
        return false;  
    \}  
    SDL\_ShowCursor(SDL\_DISABLE);  
    return true;  
\}

//析构函数。在对象消亡时，退出SDL系统。  
ScreenSurface::~ScreenSurface()  
\{  
      
\}

//返回screen surface中SDL\_Surface结构的指针，主要提供给SDL的函数调用  
SDL\_Surface\* ScreenSurface::point() const  
\{  
    return pScreen;  
\}

int ScreenSurface::screen\_lock()  
\{  
    if ( SDL\_MUSTLOCK(pScreen))  
        return SDL\_LockSurface(pScreen);  
    return 0;  
\}  
void ScreenSurface::screen\_unlock()  
\{  
    if ( SDL\_MUSTLOCK(pScreen))  
        SDL\_UnlockSurface(pScreen);   
\}

void ScreenSurface::screen\_quit()  
\{  
    SDL\_Quit();  
    v4l\_munmap(&v4l\_dev) ;  
    v4l\_close(&v4l\_dev);   
\}

void ScreenSurface::screen\_set\_caption( const char \*str )  
\{  
    SDL\_WM\_SetCaption( str, 0 );  
\}

//显示（弹出flip）screen surface到屏幕上  
bool ScreenSurface::flip( unsigned char \* src )  
\{  
    if ( screen\_lock() < 0)  
        return false;  
    unsigned char  \*dest;  
    dest = ( unsigned char \* )pScreen->pixels;  
    memcpy( dest , src , width \* height \* 4 );  
    screen\_unlock();  
      
    if ( SDL\_Flip(pScreen) < 0 )  
        return false;  
    else   
        return true;     
\}

int ScreenSurface::startTV()  
\{  
    bool bFlag = true;  
    while(bFlag)  
    \{  
        v4l\_grab\_movie();   
        unsigned char \*buf= v4l\_dev.buffer;  
        if (buf != NULL)  
        \{  
            flip(buf);  
        \}  
        SDL\_Event event;  
        while(SDL\_PollEvent(event))  
        \{  
            if (event.type == SDL\_QUIT)  
            \{  
                //bFlag = false;  
                screen\_quit();  
            \}  
        \}  
    \}  
\}  
//main.cpp  
\#include “ScreenSurface.h”  
void main()  
\{  
    ScreenSurface \*m\_pScreen;  
    m\_pScreen = new ScreenSurface( );  
    m\_pScreen->screen\_init(400 , 300 , 32 , SDL\_SWSURFACE | SDL\_ANYFORMAT);  
    m\_pScreen->screen\_set\_caption(“DemoTV”);     
    m\_pScreen->startTV();  
\}