• Ubuntu10.04中利用V4L2读取摄像头数据并保存成文件【转】

    转自：http://blog.chinaunix.net/uid-29339876-id-4042245.html

    利用V4L2读取UVC摄像头数据并保存成视频文件，主要参考http://linuxtv.org/downloads/v4l-dvb-apis/index.html中的示例Appendix D. Video Capture Example，将读取的文件保存在当前目录下的file.yuv中，修改后的完成代码如下：
        

    点击(此处)折叠或打开

    1. /*
    2.  * V4L2 video capture example
    3.  * AUTHOT : WANGTISHENG
    4.  * DATA : 2013-12-18
    5.  */
    6. #include <stdio.h>
    7. #include <stdlib.h>
    8. #include <string.h>
    9. #include <assert.h>
    10. #include <getopt.h> /* getopt_long() */
    11. #include <fcntl.h> /* low-level i/o */
    12. #include <unistd.h>
    13. #include <errno.h>
    14. #include <sys/stat.h>
    15. #include <sys/types.h>
    16. #include <sys/time.h>
    17. #include <sys/mman.h>
    18. #include <sys/ioctl.h>

    20. #include <linux/videodev2.h>

    22. #define CLEAR(x) memset(&(x), 0, sizeof(x))

    24. struct buffer {
    25.         void *start;
    26.         size_t length;
    27. };

    29. static char *dev_name;
    30. static int fd = -1;        //DEVICE NUMBER
    31. struct buffer *buffers;
    32. static unsigned int n_buffers;
    33. static int frame_count = 70;
    34. FILE *fp;                                //FILE POINTOR

    36. static void errno_exit(const char *s)
    37. {
    38.         fprintf(stderr, "%s error %d, %s ", s, errno, strerror(errno));
    39.         exit(EXIT_FAILURE);
    40. }

    42. static int xioctl(int fh, int request, void *arg)
    43. {
    44.         int r;
    45.         do {
    46.                 r = ioctl(fh, request, arg);
    47.         } while (-1 == r && EINTR == errno);
    48.         return r;
    49. }
    50. //处理函数
    51. static void process_image(const void *p, int size)
    52. {
    53.         fwrite(p,size, 1, fp);
    54. }

    56. static int read_frame(FILE *fp)
    57. {
    58.         struct v4l2_buffer buf;
    59.         CLEAR(buf);

    61.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    62.         buf.memory = V4L2_MEMORY_MMAP;
    63.         
    64.         if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf))
    65.                 errno_exit("VIDIOC_DQBUF");
    66.         
    67.         process_image(buffers[buf.index].start, buf.bytesused);

    69.         if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
    70.             errno_exit("VIDIOC_QBUF");

    72.         return 1;
    73. }

    75. static void mainloop(void)
    76. {
    77.         unsigned int count;
    78.         count = frame_count;
    79.         while (count-- > 0) {
    80.             printf("No.%d ",frame_count - count);        //显示当前帧数目
    81.             read_frame(fp);
    82.         }
    83.         printf(" READ AND SAVE DONE! ");
    84. }

    86. static void stop_capturing(void)
    87. {
    88.         enum v4l2_buf_type type;

    90.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    91.         if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
    92.             errno_exit("VIDIOC_STREAMOFF");
    93. }

    95. static void start_capturing(void)
    96. {
    97.         unsigned int i;
    98.         enum v4l2_buf_type type;

    100.         for (i = 0; i < n_buffers; ++i) {
    101.                 struct v4l2_buffer buf;

    103.                 CLEAR(buf);
    104.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    105.                 buf.memory = V4L2_MEMORY_MMAP;
    106.                 buf.index = i;

    108.                 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
    109.                         errno_exit("VIDIOC_QBUF");
    110.         }
    111.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    112.         if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
    113.                 errno_exit("VIDIOC_STREAMON");
    114. }

    116. static void uninit_device(void)
    117. {
    118.         unsigned int i;

    120.         for (i = 0; i < n_buffers; ++i)
    121.                 if (-1 == munmap(buffers[i].start, buffers[i].length))
    122.                         errno_exit("munmap");

    124.         free(buffers);
    125. }



    129. static void init_mmap(void)
    130. {
    131.         struct v4l2_requestbuffers req;

    133.         CLEAR(req);

    135.         req.count = 4;
    136.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    137.         req.memory = V4L2_MEMORY_MMAP;

    139.         if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
    140.                 if (EINVAL == errno) {
    141.                         fprintf(stderr, "%s does not support "
    142.                                  "memory mapping ", dev_name);
    143.                         exit(EXIT_FAILURE);
    144.                 } else {
    145.                         errno_exit("VIDIOC_REQBUFS");
    146.                 }
    147.         }

    149.         if (req.count < 2) {
    150.                 fprintf(stderr, "Insufficient buffer memory on %s ",
    151.                          dev_name);
    152.                 exit(EXIT_FAILURE);
    153.         }

    155.         buffers = calloc(req.count, sizeof(*buffers));

    157.         if (!buffers) {
    158.                 fprintf(stderr, "Out of memory ");
    159.                 exit(EXIT_FAILURE);
    160.         }

    162.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
    163.                 struct v4l2_buffer buf;

    165.                 CLEAR(buf);

    167.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    168.                 buf.memory = V4L2_MEMORY_MMAP;
    169.                 buf.index = n_buffers;

    171.                 if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
    172.                         errno_exit("VIDIOC_QUERYBUF");

    174.                 buffers[n_buffers].length = buf.length;
    175.                 buffers[n_buffers].start =
    176.                         mmap(NULL /* start anywhere */,
    177.                               buf.length,
    178.                               PROT_READ | PROT_WRITE /* required */,
    179.                               MAP_SHARED /* recommended */,
    180.                               fd, buf.m.offset);

    182.                 if (MAP_FAILED == buffers[n_buffers].start)
    183.                         errno_exit("mmap");
    184.         }
    185. }


    188. static void init_device(void)
    189. {
    190.         struct v4l2_capability cap;
    191.         struct v4l2_format fmt;

    193.         if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {        //测试参数
    194.                 if (EINVAL == errno) {
    195.                         fprintf(stderr, "%s is no V4L2 device ",
    196.                                  dev_name);
    197.                         exit(EXIT_FAILURE);
    198.                 } else {
    199.                         errno_exit("VIDIOC_QUERYCAP");
    200.                 }
    201.         }

    203.         if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
    204.                 fprintf(stderr, "%s is no video capture device ",
    205.                          dev_name);
    206.                 exit(EXIT_FAILURE);
    207.         }

    209.         if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
    210.                 fprintf(stderr, "%s does not support streaming i/o ",
    211.                     dev_name);
    212.                 exit(EXIT_FAILURE);
    213.         }




    218.         CLEAR(fmt);
    219.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    220.         fmt.fmt.pix.width = 640;
    221.         fmt.fmt.pix.height = 480;
    222.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    223.         fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

    225.         if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))        //设置格式
    226.                 errno_exit("VIDIOC_S_FMT");        
    227.         init_mmap();
    228. }

    230. static void close_device(void)
    231. {
    232.         if (-1 == close(fd))
    233.                 errno_exit("close");

    235.         fd = -1;
    236. }

    238. static void open_device(void)
    239. {
    240.         //加上O_NONBLOCK会出现如下错误
    241.         //VIDIOC_DQBUF error 11, Resource temporarily unavailable
    242.         fd = open(dev_name, O_RDWR /* required */ /*| O_NONBLOCK*/, 0);

    244.         if (-1 == fd) {
    245.                 fprintf(stderr, "Cannot open '%s': %d, %s ",
    246.                          dev_name, errno, strerror(errno));
    247.                 exit(EXIT_FAILURE);
    248.         }
    249. }


    252. int main(int argc, char **argv)
    253. {
    254.         dev_name = "/dev/video0";
    255.         
    256.         if(argc != 2)
    257.         {
    258.             printf("usage :%s filename ", argv[0]);
    259.             exit(0);
    260.         }
    261.         if ((fp = fopen(argv[1], "w")) == NULL) {
    262.             perror("Creat file failed");
    263.             exit(0);
    264.         }
    265.         open_device();
    266.         init_device();
    267.         start_capturing();
    268.         mainloop();                //主要处理均在该函数中实现
    269.         fclose(fp);
    270.         stop_capturing();
    271.         uninit_device();
    272.         close_device();
    273.         //fprintf(stderr, " ");
    274.         return 0;
    275. }

    Makefile   

    点击(此处)折叠或打开

    1. v4l2_capture_example:v4l2_capture_example.c
    2.     gcc -Wall -o $@ $<

    4. clean:
    5.     rm -rf v4l2_capture_example

    make测试
        运行方法
            $     ./v4l2_capture_example file.yuv
            可完成摄像头数据的读取和保存。附上查看YUV格式的软件一枚~~~~~~~
    YUV_Tools.rar
  • 相关阅读:
    理解和解决MySQL乱码问题
    搞清字符集和字符编码
    linux下卸载mysql
    mysqldump备份
    mysql 数据类型
    微信对接HIS——微信可查检验结果
    Install Haskell on Ubuntu and CentOS
    php用类生成二维码
    UVA Team Queue
    总有一种正能量触动你的心灵，读刘丁宁的一封信
  • 原文地址：https://www.cnblogs.com/sky-heaven/p/7115061.html
Copyright © 2020-2023  润新知