【OK210试用体验】OK210 V4l2视频采集

ycdhonker 当前离线 经验 131 窥视卡 雷达卡

ycdhonker ( 楼主 ) 2015-8-11 19:56:59  只看该作者 2738 | 0 倒序浏览

硬件平台OK210 开发板 + USB 摄像头

开发环境：Windows XP 32 bit + Vmware 10.0 + Ubuntu 10.04 + arm-none-linux-gnueabi交叉编译环境

一、视频采集相关知识

1、V4L和V4L2。

V4L是Linux环境下开发视频采集设备驱动程序的一套规范(API)，它为驱动程序的编写提供统一的接口，并将所有的视频采集设备的驱动程序都纳入其的管理之中。V4L不仅给驱动程序编写者带来极大的方便，同时也方便了应用程序的编写和移植。V4L2是V4L的升级版，由于我们使用的OOB是3.3的内核，不再支持V4L，因而编程不再考虑V4L的api和参数定义。

2、YUYV与RGB24

RGB是一种颜色的表示法，计算机中一般采用24位来存储，每个颜色占8位。YUV也是一种颜色空间，为什么要出现YUV,主要有两个原因，一个是为了让彩色信号兼容黑白电视机，另外一个原因是为了减少传输的带宽。YUV中，Y表示亮度，U和V表示色度，总之它是将RGB信号进行了一种处理，根据人对亮度更敏感些，增加亮度的信号，减少颜色的信号，以这样“欺骗”人的眼睛的手段来节省空间。YUV到RGB颜色空间转换关系是：

R = Y + 1.042*(V-128);G = Y - 0.34414*(U-128) - 0.71414*(V-128);B = Y + 1.772*(U-128);

YUV的格式也很多，不过常见的就是422、420等。YUYV就是422形式，简单来说就是，两个像素点P1、P2本应该有Y1、U1、V1和Y2、U2、V2这六个分量，但是实际只保留Y1、U1、Y2、V2。

二、应用程序设计

先定义一些宏和结构体，方便后续编程

#define  TRUE        1
#define  FALSE        0

#define FILE_VIDEO         "/dev/video2"
#define BMP              "/usr/image_bmp.bmp"
#define YUV                        "/usr/image_yuv.yuv"

#define  IMAGEWIDTH    640
#define  IMAGEHEIGHT   480

1. static   int      fd;
   
2. static   struct   v4l2_capability   cap;
   
3. struct v4l2_fmtdesc fmtdesc;
   
4. struct v4l2_format fmt,fmtack;
   
5. struct v4l2_streamparm setfps;  
   
6. struct v4l2_requestbuffers req;
   
7. struct v4l2_buffer buf;
   
8. enum v4l2_buf_type type;
   
9. unsigned char frame_buffer[IMAGEWIDTH*IMAGEHEIGHT*3];
   
10. 
    
11. 
    
12. struct buffer
    
13. {
    
14.         void * start;
    
15.         unsigned int length;
    
16. } * buffers;
    
17. 
    
18. int init_v4l2(void)
    
19. {
    
20.         int i;
    
21.         int ret = 0;
    
22.        
    
23.         //opendev
    
24.         if ((fd = open(FILE_VIDEO, O_RDWR)) == -1)
    
25.         {
    
26.                 printf("Error opening V4L interfacen");
    
27.                 return (FALSE);
    
28.         }
    
29. 
    
30.         //query cap
    
31.         if (ioctl(fd, VIDIOC_QUERYCAP, &cap) == -1)
    
32.         {
    
33.                 printf("Error opening device %s: unable to query device.n",FILE_VIDEO);
    
34.                 return (FALSE);
    
35.         }
    
36.         else
    
37.         {
    
38.              printf("driver:tt%sn",cap.driver);
    
39.              printf("card:tt%sn",cap.card);
    
40.              printf("bus_info:t%sn",cap.bus_info);
    
41.              printf("version:t%dn",cap.version);
    
42.              printf("capabilities:t%xn",cap.capabilities);
    
43.             
    
44.              if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == V4L2_CAP_VIDEO_CAPTURE)
    
45.              {
    
46.                         printf("Device %s: supports capture.n",FILE_VIDEO);
    
47.                 }
    
48. 
    
49.                 if ((cap.capabilities & V4L2_CAP_STREAMING) == V4L2_CAP_STREAMING)
    
50.                 {
    
51.                         printf("Device %s: supports streaming.n",FILE_VIDEO);
    
52.                 }
    
53.         }
    
54.        
    
55.         //emu all support fmt
    
56.         fmtdesc.index=0;
    
57.         fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
58.         printf("Support format:n");
    
59.         while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)
    
60.         {
    
61.                 printf("t%d.%sn",fmtdesc.index+1,fmtdesc.description);
    
62.                 fmtdesc.index++;
    
63.         }
    
64.        
    
65.     //set fmt
    
66.     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
67.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    
68.         fmt.fmt.pix.height = IMAGEHEIGHT;
    
69.         fmt.fmt.pix.width = IMAGEWIDTH;
    
70.         fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
    
71.        
    
72.         if(ioctl(fd, VIDIOC_S_FMT, &fmt) == -1)
    
73.         {
    
74.                 printf("Unable to set formatn");
    
75.                 return FALSE;
    
76.         }        
    
77.         if(ioctl(fd, VIDIOC_G_FMT, &fmt) == -1)
    
78.         {
    
79.                 printf("Unable to get formatn");
    
80.                 return FALSE;
    
81.         }
    
82.         {
    
83.              printf("fmt.type:tt%dn",fmt.type);
    
84.              printf("pix.pixelformat:t%c%c%c%cn",fmt.fmt.pix.pixelformat & 0xFF, (fmt.fmt.pix.pixelformat >> 8) & 0xFF,(fmt.fmt.pix.pixelformat >> 16) & 0xFF, (fmt.fmt.pix.pixelformat >> 24) & 0xFF);
    
85.              printf("pix.height:tt%dn",fmt.fmt.pix.height);
    
86.              printf("pix.width:tt%dn",fmt.fmt.pix.width);
    
87.              printf("pix.field:tt%dn",fmt.fmt.pix.field);
    
88.         }
    
89.         //set fps
    
90.         setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
91.         setfps.parm.capture.timeperframe.numerator = 10;
    
92.         setfps.parm.capture.timeperframe.denominator = 10;
    
93.        
    
94.         printf("init %s t[OK]n",FILE_VIDEO);
    
95.             
    
96.         return TRUE;
    
97. }
    
98. 
    
99. int v4l2_grab(void)
    
100. {
     
101.         unsigned int n_buffers;
     
102.        
     
103.         //request for 4 buffers
     
104.         req.count=4;
     
105.         req.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
106.         req.memory=V4L2_MEMORY_MMAP;
     
107.         if(ioctl(fd,VIDIOC_REQBUFS,&req)==-1)
     
108.         {
     
109.                 printf("request for buffers errorn");
     
110.         }
     
111. 
     
112.         //mmap for buffers
     
113.         buffers = malloc(req.count*sizeof (*buffers));
     
114.         if (!buffers)
     
115.         {
     
116.                 printf ("Out of memoryn");
     
117.                 return(FALSE);
     
118.         }
     
119.        
     
120.         for (n_buffers = 0; n_buffers < req.count; n_buffers++)
     
121.         {
     
122.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
123.                 buf.memory = V4L2_MEMORY_MMAP;
     
124.                 buf.index = n_buffers;
     
125.                 //query buffers
     
126.                 if (ioctl (fd, VIDIOC_QUERYBUF, &buf) == -1)
     
127.                 {
     
128.                         printf("query buffer errorn");
     
129.                         return(FALSE);
     
130.                 }
     
131. 
     
132.                 buffers[n_buffers].length = buf.length;
     
133.                 //map
     
134.                 buffers[n_buffers].start = mmap(NULL,buf.length,PROT_READ |PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
     
135.                 if (buffers[n_buffers].start == MAP_FAILED)
     
136.                 {
     
137.                         printf("buffer map errorn");
     
138.                         return(FALSE);
     
139.                 }
     
140.         }
     
141.                
     
142.         //queue
     
143.         for (n_buffers = 0; n_buffers < req.count; n_buffers++)
     
144.         {
     
145.                 buf.index = n_buffers;
     
146.                 ioctl(fd, VIDIOC_QBUF, &buf);
     
147.         }
     
148.        
     
149.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
150.         ioctl (fd, VIDIOC_STREAMON, &type);
     
151.        
     
152.         ioctl(fd, VIDIOC_DQBUF, &buf);
     
153. 
     
154.     printf("grab yuyv OKn");
     
155.         return(TRUE);
     
156. }
     
157. 
     
158. 
     
159. int yuyv_2_rgb888(void)
     
160. {
     
161.         int           i,j;
     
162.     unsigned char y1,y2,u,v;
     
163.     int r1,g1,b1,r2,g2,b2;
     
164.     char * pointer;
     
165.    
     
166.         pointer = buffers[0].start;
     
167.        
     
168.     for(i=0;i<480;i++)
     
169.     {
     
170.             for(j=0;j<320;j++)
     
171.             {
     
172.                     y1 = *( pointer + (i*320+j)*4);
     
173.                     u  = *( pointer + (i*320+j)*4 + 1);
     
174.                     y2 = *( pointer + (i*320+j)*4 + 2);
     
175.                     v  = *( pointer + (i*320+j)*4 + 3);
     
176.                    
     
177.                     r1 = y1 + 1.042*(v-128);
     
178.                     g1 = y1 - 0.34414*(u-128) - 0.71414*(v-128);
     
179.                     b1 = y1 + 1.772*(u-128);
     
180.                    
     
181.                     r2 = y2 + 1.042*(v-128);
     
182.                     g2 = y2 - 0.34414*(u-128) - 0.71414*(v-128);
     
183.                     b2 = y2 + 1.772*(u-128);
     
184.                    
     
185.                     if(r1>255)
     
186.                             r1 = 255;
     
187.                     else if(r1<0)
     
188.                             r1 = 0;
     
189.                    
     
190.                     if(b1>255)
     
191.                             b1 = 255;
     
192.                     else if(b1<0)
     
193.                             b1 = 0;       
     
194.                    
     
195.                     if(g1>255)
     
196.                             g1 = 255;
     
197.                     else if(g1<0)
     
198.                             g1 = 0;       
     
199.                            
     
200.                     if(r2>255)
     
201.                             r2 = 255;
     
202.                     else if(r2<0)
     
203.                             r2 = 0;
     
204.                    
     
205.                     if(b2>255)
     
206.                             b2 = 255;
     
207.                     else if(b2<0)
     
208.                             b2 = 0;       
     
209.                    
     
210.                     if(g2>255)
     
211.                             g2 = 255;
     
212.                     else if(g2<0)
     
213.                             g2 = 0;               
     
214.                            
     
215.                     *(frame_buffer + ((480-1-i)*320+j)*6    ) = (unsigned char)b1;
     
216.                     *(frame_buffer + ((480-1-i)*320+j)*6 + 1) = (unsigned char)g1;
     
217.                     *(frame_buffer + ((480-1-i)*320+j)*6 + 2) = (unsigned char)r1;
     
218.                     *(frame_buffer + ((480-1-i)*320+j)*6 + 3) = (unsigned char)b2;
     
219.                     *(frame_buffer + ((480-1-i)*320+j)*6 + 4) = (unsigned char)g2;
     
220.                     *(frame_buffer + ((480-1-i)*320+j)*6 + 5) = (unsigned char)r2;
     
221.             }
     
222.     }
     
223.     printf("change to RGB OK n");
     
224. }
     
225. 
     
226. int close_v4l2(void)
     
227. {
     
228.      if(fd != -1)
     
229.      {
     
230.          close(fd);
     
231.          return (TRUE);
     
232.      }
     
233.      return (FALSE);
     
234. }
     
235. 
     
236. 
     
237. int main(void)
     
238. {
     
239. 
     
240.     FILE * fp1,* fp2;
     
241. 
     
242.     BITMAPFILEHEADER   bf;
     
243.     BITMAPINFOHEADER   bi;
     
244.    
     
245. 
     
246.     fp1 = fopen(BMP, "wb");
     
247.     if(!fp1)
     
248.         {
     
249.                 printf("open "BMP"errorn");
     
250.                 return(FALSE);
     
251.         }
     
252.        
     
253.         fp2 = fopen(YUV, "wb");
     
254.     if(!fp2)
     
255.         {
     
256.                 printf("open "YUV"errorn");
     
257.                 return(FALSE);
     
258.         }
     
259. 
     
260.         if(init_v4l2() == FALSE)
     
261.         {
     
262.              return(FALSE);
     
263.         }
     
264.        
     
265.         //Set BITMAPINFOHEADER
     
266.         bi.biSize = 40;
     
267.         bi.biWidth = IMAGEWIDTH;
     
268.         bi.biHeight = IMAGEHEIGHT;
     
269.         bi.biPlanes = 1;
     
270.         bi.biBitCount = 24;
     
271.         bi.biCompression = 0;
     
272.         bi.biSizeImage = IMAGEWIDTH*IMAGEHEIGHT*3;
     
273.         bi.biXPelsPerMeter = 0;
     
274.         bi.biYPelsPerMeter = 0;
     
275.         bi.biClrUsed = 0;
     
276.         bi.biClrImportant = 0;
     
277. 
     
278. 
     
279.     //Set BITMAPFILEHEADER
     
280.     bf.bfType = 0x4d42;
     
281.     bf.bfSize = 54 + bi.biSizeImage;     
     
282.         bf.bfReserved = 0;
     
283.     bf.bfOffBits = 54;
     
284.    
     
285.     v4l2_grab();
     
286.     fwrite(buffers[0].start, 640*480*2, 1, fp2);
     
287.     printf("save "YUV"OKn");
     
288.    
     
289.     yuyv_2_rgb888();
     
290.     fwrite(&bf, 14, 1, fp1);
     
291.     fwrite(&bi, 40, 1, fp1);   
     
292.     fwrite(frame_buffer, bi.biSizeImage, 1, fp1);
     
293.     printf("save "BMP"OKn");
     
294.    
     
295.    
     
296.     fclose(fp1);
     
297.     fclose(fp2);
     
298.     close_v4l2();
     
299.    
     
300.     return(TRUE);
     
301. }
     

复制代码

源程序附件 OK210usb摄像头图像抓取.rar (24.51 KB, 下载次数: 7)

2015-8-11 20:50 上传

点击文件名下载附件
下载积分: 积分 -1 分

在Ubuntu下交叉编译后得到可执行bin文件，通过tftp命令下载到开发板，主要执行chmod +x 改变文件执行权限，生成相应的图片和yuv格式视频文件，可以通过 tftp -p -r 文件名 远程IP 地址传输到ubuntu 端 这里需要注意的是 需要在tftp 文件接收目录中建立一个与开发板下所生成的图片名相同的文件，并且该文件必须有读写权限才能放到ubuntu 端[/url]可惜的是的 我的板子没有执行成功 在ubuntu可以正常执行

结果执行的时候出现了错误
s3c-fimc-0 : fimc_enum_fmt_vid_capture: No capture device.[ 2292.374615] s3c-fimc-0 : fimc_s_fmt_vid_capture: No capture device.Samsung FIMC Dris3c-fimc0card:s3c-fimc0bus_info:FIMC AHB-busversion:0capabilities:4000007Device /dev/video0: supports capture.Device /dev/video0: supports streaming.Support format:Unable to set format
[url=]从网上查询了一下 说s5p210视频驱动架构有两种：一种是用的linuxV4l2驱动架构，一种是三星自己的

驱动可以有两种实现方法：第一种是把摄像头驱动做成普通的V4L2设备，直接调用FIMC里的寄存器实现视频数据的捕捉和处理；第二种利用内核已经实现好的FIMC的驱动，通过某种接口形式，把我们的摄像头驱动挂接在FIMC驱动之下。

这两种方法第一种实现起来代码量比较大，因为需要直接操作FIMC的寄存器，难度也大一些；第二种方法是利用内核已经做好的FIMC驱动，难点在于如何把摄像头驱动和FIMC驱动整合起来。

这个问题还需要解决。

未完待续----