【OK210试用体验】OK210 V4l2视频采集 - 在线问答 - 电子技术论坛 - 最好最受欢迎电子论坛!

电子发烧友官网论坛在线研讨会活动客服QQ:3144539146
开启辅助访问 收藏本站切换到宽版

电子技术论坛»论坛 › 在线问答

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

ycdhonker ( 楼主 ) 2015-8-11 19:56:59  只看该作者 倒序浏览
本帖最后由 ycdhonker 于 2015-8-11 20:51 编辑

硬件平台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];


  12. struct buffer
  13. {
  14.         void * start;
  15.         unsigned int length;
  16. } * buffers;

  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.         }

  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.                 }

  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. }

  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.         }

  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.                 }

  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);

  154.     printf("grab yuyv OKn");
  155.         return(TRUE);
  156. }


  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. }

  226. int close_v4l2(void)
  227. {
  228.      if(fd != -1)
  229.      {
  230.          close(fd);
  231.          return (TRUE);
  232.      }
  233.      return (FALSE);
  234. }


  237. int main(void)
  238. {

  240.     FILE * fp1,* fp2;

  242.     BITMAPFILEHEADER   bf;
  243.     BITMAPINFOHEADER   bi;
  244.    

  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.         }

  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;


  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)
在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驱动整合起来。
这个问题还需要解决。
未完待续----
【新技能】那些你不知道的红外热像“隐形”功能
回复 赞1

举报 使用道具

0个回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

相关帖子


关闭

站长推荐上一条 /6 下一条

小黑屋|手机版|Archiver|电子发烧友 ( 湘ICP备2023018690号 )

GMT+8, 2024-11-21 19:28 , Processed in 0.552429 second(s), Total 62, Slave 42 queries .

Powered by 电子发烧友网

© 2015 bbs.elecfans.com

微信扫描
快速回复 返回顶部 返回列表