开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
capture.c
资源名称：fmradio.zip　[点击查看]
上传用户：ledjyj
上传日期：2014-08-27
资源大小：2639k
文件大小：16k
源码类别：

驱动编程

开发平台：

Unix_Linux

capture.c：源码内容
  1. /*
  2.  *  V4L2 video capture example
  3.  *
  4.  *  This program can be used and distributed without restrictions.
  5.  */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <assert.h>
  12. #include <getopt.h>             /* getopt_long() */
  14. #include <fcntl.h>              /* low-level i/o */
  15. #include <unistd.h>
  16. #include <errno.h>
  17. #include <sys/stat.h>
  18. #include <sys/types.h>
  19. #include <sys/time.h>
  20. #include <sys/mman.h>
  21. #include <sys/ioctl.h>
  23. #include <asm/types.h>          /* for videodev2.h */
  25. #include <linux/videodev2.h>
  27. #define CLEAR(x) memset (&(x), 0, sizeof (x))
  29. typedef enum {
  30. IO_METHOD_READ,
  31. IO_METHOD_MMAP,
  32. IO_METHOD_USERPTR,
  33. } io_method;
  35. struct buffer {
  36.         void *                  start;
  37.         size_t                  length;
  38. };
  40. static char *           dev_name        = NULL;
  41. static io_method io = IO_METHOD_MMAP;
  42. static int              fd              = -1;
  43. struct buffer *         buffers         = NULL;
  44. static unsigned int     n_buffers       = 0;
  46. static void
  47. errno_exit                      (const char *           s)
  48. {
  49.         fprintf (stderr, "%s error %d, %sn",
  50.                  s, errno, strerror (errno));
  52.         exit (EXIT_FAILURE);
  53. }
  55. static int
  56. xioctl                          (int                    fd,
  57.                                  int                    request,
  58.                                  void *                 arg)
  59. {
  60.         int r;
  62.         do r = ioctl (fd, request, arg);
  63.         while (-1 == r && EINTR == errno);
  65.         return r;
  66. }
  68. static void
  69. process_image                   (const void *           p)
  70. {
  71.         fputc ('.', stdout);
  72.         fflush (stdout);
  73. }
  75. static int
  76. read_frame (void)
  77. {
  78.         struct v4l2_buffer buf;
  79. unsigned int i;
  81. switch (io) {
  82. case IO_METHOD_READ:
  83.      if (-1 == read (fd, buffers[0].start, buffers[0].length)) {
  84.              switch (errno) {
  85.              case EAGAIN:
  86.                      return 0;
  88. case EIO:
  89. /* Could ignore EIO, see spec. */
  91. /* fall through */
  93. default:
  94. errno_exit ("read");
  95. }
  96. }
  98.      process_image (buffers[0].start);
  100. break;
  102. case IO_METHOD_MMAP:
  103. CLEAR (buf);
  105.              buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  106.              buf.memory = V4L2_MEMORY_MMAP;
  108.      if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
  109.              switch (errno) {
  110.              case EAGAIN:
  111.                      return 0;
  113. case EIO:
  114. /* Could ignore EIO, see spec. */
  116. /* fall through */
  118. default:
  119. errno_exit ("VIDIOC_DQBUF");
  120. }
  121. }
  123.                 assert (buf.index < n_buffers);
  125.         process_image (buffers[buf.index].start);
  127. if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  128. errno_exit ("VIDIOC_QBUF");
  130. break;
  132. case IO_METHOD_USERPTR:
  133. CLEAR (buf);
  135.      buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  136.      buf.memory = V4L2_MEMORY_USERPTR;
  138. if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
  139. switch (errno) {
  140. case EAGAIN:
  141. return 0;
  143. case EIO:
  144. /* Could ignore EIO, see spec. */
  146. /* fall through */
  148. default:
  149. errno_exit ("VIDIOC_DQBUF");
  150. }
  151. }
  153. for (i = 0; i < n_buffers; ++i)
  154. if (buf.m.userptr == (unsigned long) buffers[i].start
  155.     && buf.length == buffers[i].length)
  156. break;
  158. assert (i < n_buffers);
  160.      process_image ((void *) buf.m.userptr);
  162. if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  163. errno_exit ("VIDIOC_QBUF");
  165. break;
  166. }
  168. return 1;
  169. }
  171. static void
  172. mainloop                        (void)
  173. {
  174. unsigned int count;
  176.         count = 100;
  178.         while (count-- > 0) {
  179.                 for (;;) {
  180.                         fd_set fds;
  181.                         struct timeval tv;
  182.                         int r;
  184.                         FD_ZERO (&fds);
  185.                         FD_SET (fd, &fds);
  187.                         /* Timeout. */
  188.                         tv.tv_sec = 2;
  189.                         tv.tv_usec = 0;
  191.                         r = select (fd + 1, &fds, NULL, NULL, &tv);
  193.                         if (-1 == r) {
  194.                                 if (EINTR == errno)
  195.                                         continue;
  197.                                 errno_exit ("select");
  198.                         }
  200.                         if (0 == r) {
  201.                                 fprintf (stderr, "select timeoutn");
  202.                                 exit (EXIT_FAILURE);
  203.                         }
  205. if (read_frame ())
  206.                      break;
  208. /* EAGAIN - continue select loop. */
  209.                 }
  210.         }
  211. }
  213. static void
  214. stop_capturing                  (void)
  215. {
  216.         enum v4l2_buf_type type;
  218. switch (io) {
  219. case IO_METHOD_READ:
  220. /* Nothing to do. */
  221. break;
  223. case IO_METHOD_MMAP:
  224. case IO_METHOD_USERPTR:
  225. type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  227. if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
  228. errno_exit ("VIDIOC_STREAMOFF");
  230. break;
  231. }
  232. }
  234. static void
  235. start_capturing                 (void)
  236. {
  237.         unsigned int i;
  238.         enum v4l2_buf_type type;
  240. switch (io) {
  241. case IO_METHOD_READ:
  242. /* Nothing to do. */
  243. break;
  245. case IO_METHOD_MMAP:
  246. for (i = 0; i < n_buffers; ++i) {
  247.              struct v4l2_buffer buf;
  249.          CLEAR (buf);
  251.          buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  252.          buf.memory      = V4L2_MEMORY_MMAP;
  253.          buf.index       = i;
  255.          if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  256.                      errno_exit ("VIDIOC_QBUF");
  257. }
  259. type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  261. if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
  262. errno_exit ("VIDIOC_STREAMON");
  264. break;
  266. case IO_METHOD_USERPTR:
  267. for (i = 0; i < n_buffers; ++i) {
  268.              struct v4l2_buffer buf;
  270.          CLEAR (buf);
  272.          buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  273.          buf.memory      = V4L2_MEMORY_USERPTR;
  274. buf.index       = i;
  275. buf.m.userptr = (unsigned long) buffers[i].start;
  276. buf.length      = buffers[i].length;
  278. if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  279.                      errno_exit ("VIDIOC_QBUF");
  280. }
  282. type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  284. if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
  285. errno_exit ("VIDIOC_STREAMON");
  287. break;
  288. }
  289. }
  291. static void
  292. uninit_device                   (void)
  293. {
  294.         unsigned int i;
  296. switch (io) {
  297. case IO_METHOD_READ:
  298. free (buffers[0].start);
  299. break;
  301. case IO_METHOD_MMAP:
  302. for (i = 0; i < n_buffers; ++i)
  303. if (-1 == munmap (buffers[i].start, buffers[i].length))
  304. errno_exit ("munmap");
  305. break;
  307. case IO_METHOD_USERPTR:
  308. for (i = 0; i < n_buffers; ++i)
  309. free (buffers[i].start);
  310. break;
  311. }
  313. free (buffers);
  314. }
  316. static void
  317. init_read (unsigned int buffer_size)
  318. {
  319.         buffers = calloc (1, sizeof (*buffers));
  321.         if (!buffers) {
  322.                 fprintf (stderr, "Out of memoryn");
  323.                 exit (EXIT_FAILURE);
  324.         }
  326. buffers[0].length = buffer_size;
  327. buffers[0].start = malloc (buffer_size);
  329. if (!buffers[0].start) {
  330.      fprintf (stderr, "Out of memoryn");
  331.              exit (EXIT_FAILURE);
  332. }
  333. }
  335. static void
  336. init_mmap (void)
  337. {
  338. struct v4l2_requestbuffers req;
  340.         CLEAR (req);
  342.         req.count               = 4;
  343.         req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  344.         req.memory              = V4L2_MEMORY_MMAP;
  346. if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
  347.                 if (EINVAL == errno) {
  348.                         fprintf (stderr, "%s does not support "
  349.                                  "memory mappingn", dev_name);
  350.                         exit (EXIT_FAILURE);
  351.                 } else {
  352.                         errno_exit ("VIDIOC_REQBUFS");
  353.                 }
  354.         }
  356.         if (req.count < 2) {
  357.                 fprintf (stderr, "Insufficient buffer memory on %sn",
  358.                          dev_name);
  359.                 exit (EXIT_FAILURE);
  360.         }
  362.         buffers = calloc (req.count, sizeof (*buffers));
  364.         if (!buffers) {
  365.                 fprintf (stderr, "Out of memoryn");
  366.                 exit (EXIT_FAILURE);
  367.         }
  369.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
  370.                 struct v4l2_buffer buf;
  372.                 CLEAR (buf);
  374.                 buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  375.                 buf.memory      = V4L2_MEMORY_MMAP;
  376.                 buf.index       = n_buffers;
  378.                 if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
  379.                         errno_exit ("VIDIOC_QUERYBUF");
  381.                 buffers[n_buffers].length = buf.length;
  382.                 buffers[n_buffers].start =
  383.                         mmap (NULL /* start anywhere */,
  384.                               buf.length,
  385.                               PROT_READ | PROT_WRITE /* required */,
  386.                               MAP_SHARED /* recommended */,
  387.                               fd, buf.m.offset);
  389.                 if (MAP_FAILED == buffers[n_buffers].start)
  390.                         errno_exit ("mmap");
  391.         }
  392. }
  394. static void
  395. init_userp (unsigned int buffer_size)
  396. {
  397. struct v4l2_requestbuffers req;
  399.         CLEAR (req);
  401.         req.count               = 4;
  402.         req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  403.         req.memory              = V4L2_MEMORY_USERPTR;
  405.         if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
  406.                 if (EINVAL == errno) {
  407.                         fprintf (stderr, "%s does not support "
  408.                                  "user pointer i/on", dev_name);
  409.                         exit (EXIT_FAILURE);
  410.                 } else {
  411.                         errno_exit ("VIDIOC_REQBUFS");
  412.                 }
  413.         }
  415.         buffers = calloc (4, sizeof (*buffers));
  417.         if (!buffers) {
  418.                 fprintf (stderr, "Out of memoryn");
  419.                 exit (EXIT_FAILURE);
  420.         }
  422.         for (n_buffers = 0; n_buffers < 4; ++n_buffers) {
  423.                 buffers[n_buffers].length = buffer_size;
  424.                 buffers[n_buffers].start = malloc (buffer_size);
  426.                 if (!buffers[n_buffers].start) {
  427.      fprintf (stderr, "Out of memoryn");
  428.              exit (EXIT_FAILURE);
  429. }
  430.         }
  431. }
  433. static void
  434. init_device                     (void)
  435. {
  436.         struct v4l2_capability cap;
  437.         struct v4l2_cropcap cropcap;
  438.         struct v4l2_crop crop;
  439.         struct v4l2_format fmt;
  440. unsigned int min;
  442.         if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
  443.                 if (EINVAL == errno) {
  444.                         fprintf (stderr, "%s is no V4L2 devicen",
  445.                                  dev_name);
  446.                         exit (EXIT_FAILURE);
  447.                 } else {
  448.                         errno_exit ("VIDIOC_QUERYCAP");
  449.                 }
  450.         }
  452.         if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
  453.                 fprintf (stderr, "%s is no video capture devicen",
  454.                          dev_name);
  455.                 exit (EXIT_FAILURE);
  456.         }
  458. switch (io) {
  459. case IO_METHOD_READ:
  460. if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
  461. fprintf (stderr, "%s does not support read i/on",
  462.  dev_name);
  463. exit (EXIT_FAILURE);
  464. }
  466. break;
  468. case IO_METHOD_MMAP:
  469. case IO_METHOD_USERPTR:
  470. if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
  471. fprintf (stderr, "%s does not support streaming i/on",
  472.  dev_name);
  473. exit (EXIT_FAILURE);
  474. }
  476. break;
  477. }
  480.         /* Select video input, video standard and tune here. */
  483. CLEAR (cropcap);
  485.         cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  487.         if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
  488.                 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  489.                 crop.c = cropcap.defrect; /* reset to default */
  491.                 if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
  492.                         switch (errno) {
  493.                         case EINVAL:
  494.                                 /* Cropping not supported. */
  495.                                 break;
  496.                         default:
  497.                                 /* Errors ignored. */
  498.                                 break;
  499.                         }
  500.                 }
  501.         } else {
  502.                 /* Errors ignored. */
  503.         }
  506.         CLEAR (fmt);
  508.         fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  509.         fmt.fmt.pix.width       = 640; 
  510.         fmt.fmt.pix.height      = 480;
  511.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  512.         fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
  514.         if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
  515.                 errno_exit ("VIDIOC_S_FMT");
  517.         /* Note VIDIOC_S_FMT may change width and height. */
  519. /* Buggy driver paranoia. */
  520. min = fmt.fmt.pix.width * 2;
  521. if (fmt.fmt.pix.bytesperline < min)
  522. fmt.fmt.pix.bytesperline = min;
  523. min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
  524. if (fmt.fmt.pix.sizeimage < min)
  525. fmt.fmt.pix.sizeimage = min;
  527. switch (io) {
  528. case IO_METHOD_READ:
  529. init_read (fmt.fmt.pix.sizeimage);
  530. break;
  532. case IO_METHOD_MMAP:
  533. init_mmap ();
  534. break;
  536. case IO_METHOD_USERPTR:
  537. init_userp (fmt.fmt.pix.sizeimage);
  538. break;
  539. }
  540. }
  542. static void
  543. close_device                    (void)
  544. {
  545.         if (-1 == close (fd))
  546.         errno_exit ("close");
  548.         fd = -1;
  549. }
  551. static void
  552. open_device                     (void)
  553. {
  554.         struct stat st; 
  556.         if (-1 == stat (dev_name, &st)) {
  557.                 fprintf (stderr, "Cannot identify '%s': %d, %sn",
  558.                          dev_name, errno, strerror (errno));
  559.                 exit (EXIT_FAILURE);
  560.         }
  562.         if (!S_ISCHR (st.st_mode)) {
  563.                 fprintf (stderr, "%s is no devicen", dev_name);
  564.                 exit (EXIT_FAILURE);
  565.         }
  567.         fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
  569.         if (-1 == fd) {
  570.                 fprintf (stderr, "Cannot open '%s': %d, %sn",
  571.                          dev_name, errno, strerror (errno));
  572.                 exit (EXIT_FAILURE);
  573.         }
  574. }
  576. static void
  577. usage                           (FILE *                 fp,
  578.                                  int                    argc,
  579.                                  char **                argv)
  580. {
  581.         fprintf (fp,
  582.                  "Usage: %s [options]nn"
  583.                  "Options:n"
  584.                  "-d | --device name   Video device name [/dev/video]n"
  585.                  "-h | --help          Print this messagen"
  586.                  "-m | --mmap          Use memory mapped buffersn"
  587.                  "-r | --read          Use read() callsn"
  588.                  "-u | --userp         Use application allocated buffersn"
  589.                  "",
  590.  argv[0]);
  591. }
  593. static const char short_options [] = "d:hmru";
  595. static const struct option
  596. long_options [] = {
  597.         { "device",     required_argument,      NULL,           'd' },
  598.         { "help",       no_argument,            NULL,           'h' },
  599.         { "mmap",       no_argument,            NULL,           'm' },
  600.         { "read",       no_argument,            NULL,           'r' },
  601.         { "userp",      no_argument,            NULL,           'u' },
  602.         { 0, 0, 0, 0 }
  603. };
  605. int
  606. main                            (int                    argc,
  607.                                  char **                argv)
  608. {
  609.         dev_name = "/dev/video";
  611.         for (;;) {
  612.                 int index;
  613.                 int c;
  614.                 
  615.                 c = getopt_long (argc, argv,
  616.                                  short_options, long_options,
  617.                                  &index);
  619.                 if (-1 == c)
  620.                         break;
  622.                 switch (c) {
  623.                 case 0: /* getopt_long() flag */
  624.                         break;
  626.                 case 'd':
  627.                         dev_name = optarg;
  628.                         break;
  630.                 case 'h':
  631.                         usage (stdout, argc, argv);
  632.                         exit (EXIT_SUCCESS);
  634.                 case 'm':
  635.                         io = IO_METHOD_MMAP;
  636. break;
  638.                 case 'r':
  639.                         io = IO_METHOD_READ;
  640. break;
  642.                 case 'u':
  643.                         io = IO_METHOD_USERPTR;
  644. break;
  646.                 default:
  647.                         usage (stderr, argc, argv);
  648.                         exit (EXIT_FAILURE);
  649.                 }
  650.         }
  652.         open_device ();
  654.         init_device ();
  656.         start_capturing ();
  658.         mainloop ();
  660.         stop_capturing ();
  662.         uninit_device ();
  664.         close_device ();
  666.         exit (EXIT_SUCCESS);
  668.         return 0;
  669. }