基于Video4linux的视频采集，用SDL显示

本程序的开发环境是（我当前的系统）：操作系统：RedHat 9.0 及 CG300的视频采集卡

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

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

1. //下面我对这些操作做了个简单的函数封装 （o(∩_∩)o...哈哈）
2. #ifndef _V4L_H
3. #define _V4L_H
5. #include <stdio.h>
6. #include <stdlib.h>
7. #include <unistd.h>
8. #include <error.h>
9. #include <assert.h>
10. #include <fcntl.h>
11. #include <sys/ioctl.h>
12. #include <sys/types.h>
13. #include <sys/mman.h>
14. #include <linux/videodev.h>
15. #include <sys/types.h>
16. #include <string.h>
18. /*采集的图像的最大长和宽*/
19. #define MAX_WIDTH 400
20. #define MAX_HEIGHT 300
21. /*设备文件*/
22. #define DEFAULT_DEVICE "/dev/video0"
25. /*自定义数据结构,包含v4l 中用到的数据结构*/
26. typedef struct v4l_struct
27. {
28.     int fd;/*设备号*/
29.     struct video_capability capability; //包含设备的基本信息（设备名称、支持的最大最小分辨率、信号源信息等）
30.     struct video_channel channel[8];//信号源个数
31.     struct video_picture picture;//设备采集的图象的各种属性
32.     struct video_mmap mmap;//用于mmap         
33.     struct video_mbuf mbuf;//利用mmap进行映射的帧的信息            
34.     unsigned char *buffer ;/*图像数据存放区*/
35.     unsigned char *map;/*mmap方式获取数据时,数据的首地址*/
36.     int frame_current;
37.     int frame_using[2]; /*这个帧的状态0 表示可用,1表示不可用*/
38. }v4l_device;
42. /**************************************************************
43. * 函数名:v4l_open
44. * 功  能: 打开设备
45. * 输  入: dev,vd
46. * 输  出: 无
47. * 返  回:  -1----失败  0----成功
48. **************************************************************/
49. int v4l_open( char *dev, v4l_device *vd )
50. {
51.     if( !dev )
52.     {
53.         dev=DEFAULT_DEVICE ;
54.     }
55.     if( ( vd->fd = open( dev, O_RDWR ) )  < 0 )
56.     {
57.         perror( "v4l_open error" );
58.         return -1;
59.     }
60.     return 0;
61. }
63. /**************************************************************
64. * 函数名: v4l_get_capability
65. * 功  能: 获取设备属性
66. * 输  入: vd
67. * 输  出: 无
68. * 返  回:  -1----失败 0----成功
69. **************************************************************/
70. int v4l_get_capability( v4l_device *vd )
71. {
72.     if( ioctl( vd->fd, VIDIOCGCAP, &( vd->capability ) ) <0 )
73.     {
74.         perror( "v4l_get_capability" );
75.         return -1 ;
76.     }
77.     return 0; 
78. }
80. /***************************************************************
81. * 函数名:v4l_get_picture
82. * 功  能:获取图片属性
83. * 输  入: vd
84. * 输  出: 无
85. * 返  回:  -1----失败  0----成功
86. ***************************************************************/
87. int v4l_get_picture( v4l_device *vd )
88. {
89.     if( ioctl( vd->fd,VIDIOCGPICT,&( vd->picture ) ) < 0 )
90.     {
91.         return -1;
92.     }
93.     return 0;
94. }
96. /**************************************************************
97. * 函数名: v4l_set_picture
98. * 功  能: 设置图片属性
99. * 输  入: vd
100. * 输  出: 无
101. * 返  回: -1----失败 0----成功
102. **************************************************************/
103. int v4l_set_picture( v4l_device *vd ) 
104. {
105.     if( ioctl( vd->fd, VIDIOCSPICT, &( vd->picture ) ) < 0 )
106.     {
107.         return -1;
108.     }
109.     return 0;
110. }
112. /*************************************************************
113. * 函数名:v4l_get_channels
114. * 功  能:获取通道信息
115. * 输  入: vd
116. * 输  出: 无
117. * 返  回:  -1----失败 0----成功
118. *************************************************************/
119. int v4l_get_channels( v4l_device *vd )
120. {
121.     int i;
122.     for( i=0;i < vd->capability.channels ; i++ )
123.     {
124.         vd->channel[i].channel = i;               //确定通道
125.         if( ioctl( vd->fd , VIDIOCGCHAN, &( vd->channel[i] ) ) <0 )
126.         {
127.             perror( "v4l_get_channel" );
128.             return -1;
129.         }
130.     }
131.     return 0;
132. }
134. /*************************************************************
135. * 函数名: v4l_get_mbuf
136. * 功  能: 获取内存映射信息
137. * 输  入: vd
138. * 输  出: 无
139. * 返  回:  -1----失败 0----成功
140. **************************************************************/
141. int v4l_get_mbuf( v4l_device *vd )
142. {
143.     if( ioctl ( vd->fd,VIDIOCGMBUF,&( vd->mbuf ) ) <0 )
144.     {
145.         perror( "get_mbuf:" );
146.         return -1;
147.     }
148.     if ( ( vd->map = ( unsigned char * )mmap( 0, vd->mbuf.size, PROT_READ | PROT_WRITE, MAP_SHARED, vd->fd, 0 ) ) < 0 )
149.     {
150.         perror("v4l_mmap_init:mmap");
151.         return -1;
152.     }
153.     return 0 ;
154. }
156. /*************************************************************
157. * 函数名: v4l_init_mbuff
158. * 功  能: 初始化内存映射信息
159. * 输  入: vd
160. * 输  出: 无
161. * 返  回: 0----成功
162. **************************************************************/
163. int v4l_init_mbuf(v4l_device *vd)
164. {
165.     //vd->mmap.frame = 10 ; //不懂双帧是怎样设置的这个frame 该是当前帧的可mbuf 以又没有设置怎么确定是双帧不是单帧还是更多
166.     vd->mmap.width = MAX_WIDTH;
167.     vd->mmap.height = MAX_HEIGHT;
168.     vd->mmap.format = vd->picture.palette;
169.     vd->frame_current = 0;
170.     vd->frame_using[0] = 0;
171.     vd->frame_using[1] = 0;
172.     return 0;
173. }
175. /**************************************************************
176. * 函数名: v4l_get_address
177. * 功  能: 获取数据在图像的地址
178. ***************************************************************/
179. unsigned char *v4l_get_address(v4l_device *vd)
180. {
181.     return (vd->map + vd->mbuf.offsets[vd->frame_current]);
182. }
184. /*************************************************************
185. * 函数名: v4l_grab_frame
186. * 功  能: 捕获帧
187. **************************************************************/
188. int v4l_grab_frame(v4l_device *vd, int frame)
189. {
190.     if (vd->frame_using[frame]) 
191.     {
192.         fprintf(stderr, "v4l_grab_frame: frame %d is already used./n", frame);
193.         return -1;
194.     }
195.     vd->mmap.frame = frame;
196.     if ( ioctl(vd->fd, VIDIOCMCAPTURE, &(vd->mmap ) ) < 0 ) 
197.     {
198.         perror( "v4l_grab_frame" );
199.         return -1;
200.     }
201.     vd->frame_using[frame] = 1;
202.     vd->frame_current = frame;
203.     return 0;    
204. }
206. /**************************************************************
207. * 函数名: v4l_grab_sync
208. * 功  能:与内存映射捕获一致
209. **************************************************************/
210. int v4l_grab_sync(v4l_device *vd)
211. {  
212.     if (ioctl(vd->fd, VIDIOCSYNC, &(vd->frame_current)) < 0) 
213.     {
214.         perror("v4l_grab_sync");
215.     }
216.     vd->frame_using[vd->frame_current] = 0;
217.     return 0;
218. }
220. /***************************************************************
221. * 函数名: v4l_munmap
222. * 功  能:停止内存映射
223. ***************************************************************/
224. int v4l_munmap( v4l_device *vd )
225. {
226.     if ( munmap( vd->map, vd->mbuf.size ) < 0 ) 
227.     {
228.         perror( "v4lmunmap:munmap" );
229.         return -1;
230.     }
231.     return 0;
232. }
234. /***************************************************************
235. * 函数名: v4l_close
236. * 功  能:关闭设备
237. ***************************************************************/
238. int v4l_close(v4l_device *vd)
239. {
240.     close(vd->fd);
241.     return 0;
242. }
244. #endif
249. //简单的封装了关于SDL的相关操作"ScreenSurface.h"
250. #ifndef SCREEN_SURFACE_H
251. #define SCREEN_SURFACE_H
253. #include <stdio.h>
254. #include <stdlib.h>
255. #include <SDL/SDL.h>
257. class ScreenSurface 
258. {
259. public:
260.     ScreenSurface();
261.     bool screen_init(int w, int h, int b = 0, Uint32 f = 0);//初始化
262.     ~ScreenSurface();
263.     SDL_Surface* point() const;
264.     int screen_lock();
265.     void screen_unlock();
266.     void screen_quit();
267.     void screen_set_caption( const char *str );//设置标题
268.     bool flip( unsigned char * src) ;//显示
269.     int startTV();//开始采集
270. private:
271.     static int screenNum;
272.     int width;
273.     int height;
274.     int bpp;
275.     Uint32 flags;
276.     SDL_Surface* pScreen;
277. };
279. #endif
281. //ScreenSurface.cpp
282. #include "ScreenSurface.h"
283. #include "qt_v4l.h"
284. v4l_device  v4l_dev;
285. /**************************************************************
286. * 函数名: v4l_grab_movie
287. * 功  能:捕获连续图像
288. **************************************************************/
289. void  v4l_grab_movie()
290. {
291.     v4l_grab_frame(&v4l_dev, v4l_dev.frame_current);/*获取下一 帧*/
292.     v4l_grab_sync(&v4l_dev);/*等待传完一 帧*/
293.     v4l_dev.buffer = v4l_get_address(&v4l_dev);/*得到这一帧的地址*/
294.     v4l_dev.frame_current = (v4l_dev.frame_current+1)%2; /* 下一帧的frame*/
295. }
297. //构造函数。如果创建1个以上的screen surface，则会抛出异常
298. ScreenSurface::ScreenSurface():width(640), height(480), bpp(32), flags(0)
299. { 
300.     pScreen = 0;
301.     v4l_open(DEFAULT_DEVICE, &v4l_dev);/*打开设备*/
302.     v4l_get_capability(&v4l_dev);
303.     v4l_get_picture(&v4l_dev);
304.     v4l_init_mbuf(&v4l_dev);/*初始化设备*/
305.     v4l_get_mbuf(&v4l_dev);/*内存映射*/
306. }
308. bool ScreenSurface::screen_init(int w, int h, int b, Uint32 f)
309. {
310.     width = w ;
311.     height = h ;
312.     bpp = b ;
313.     flags = f ;
314.     
315.     if(SDL_Init(SDL_INIT_VIDEO) < 0)
316.     {
317.         printf("SDL_Init Failed!/n");
318.         return false;
319.     }
320.     //设置图象模式(宽*高 位数 标志 SDL_SWSURFACE | SDL_DOUBLEBUF)
321.     pScreen = SDL_SetVideoMode(width, height, bpp, flags);
322.     if ( pScreen == 0 )
323.     {
324.         printf("Could't set display mode /n");
325.         SDL_Quit();
326.         return false;
327.     }
328.     SDL_ShowCursor(SDL_DISABLE);
329.     return true;
330. }
332. //析构函数。在对象消亡时，退出SDL系统。
333. ScreenSurface::~ScreenSurface()
334. {
335.     
336. }
338. //返回screen surface中SDL_Surface结构的指针，主要提供给SDL的函数调用
339. SDL_Surface* ScreenSurface::point() const
340. {
341.     return pScreen;
342. }
344. int ScreenSurface::screen_lock()
345. {
346.     if ( SDL_MUSTLOCK(pScreen))
347.         return SDL_LockSurface(pScreen);
348.     return 0;
349. }
350. void ScreenSurface::screen_unlock()
351. {
352.     if ( SDL_MUSTLOCK(pScreen))
353.         SDL_UnlockSurface(pScreen); 
354. }
356. void ScreenSurface::screen_quit()
357. {
358.     SDL_Quit();
359.     v4l_munmap(&v4l_dev) ;
360.     v4l_close(&v4l_dev); 
361. }
363. void ScreenSurface::screen_set_caption( const char *str )
364. {
365.     SDL_WM_SetCaption( str, 0 );
366. }
368. //显示（弹出flip）screen surface到屏幕上
369. bool ScreenSurface::flip( unsigned char * src )
370. {
371.     if ( screen_lock() < 0)
372.         return false;
373.     unsigned char  *dest;
374.     dest = ( unsigned char * )pScreen->pixels;
375.     memcpy( dest , src , width * height * 4 );
376.     screen_unlock();
377.     
378.     if ( SDL_Flip(pScreen) < 0 )
379.         return false;
380.     else 
381.         return true;   
382. }
384. int ScreenSurface::startTV()
385. {
386.     bool bFlag = true;
387.     while(bFlag)
388.     {
389.         v4l_grab_movie(); 
390.         unsigned char *buf= v4l_dev.buffer;
391.         if (buf != NULL)
392.         {
393.             flip(buf);
394.         }
395.         SDL_Event event;
396.         while(SDL_PollEvent(event))
397.         {
398.             if (event.type == SDL_QUIT)
399.             {
400.                 //bFlag = false;
401.                 screen_quit();
402.             }
403.         }
404.     }
405. }
408. //main.cpp
409. #include "ScreenSurface.h"
410. void main()
411. {
412.     ScreenSurface *m_pScreen;
413.     m_pScreen = new ScreenSurface( );
414.     m_pScreen->screen_init(400 , 300 , 32 , SDL_SWSURFACE | SDL_ANYFORMAT);
415.     m_pScreen->screen_set_caption("DemoTV");   
416.     m_pScreen->startTV();
417. }

代码SHOW完了，下面再附点小信息供大家看看，刚玩LINUX不久，有错误的地方还请大侠们指出。