主题 : Tinny4412使用usb摄像头 复制链接 | 浏览器收藏 | 打印
级别: 新手上路
UID: 118746
精华: 0
发帖: 4
金钱: 20 两
威望: 4 点
综合积分: 8 分
注册时间: 2015-09-06
最后登录: 2015-12-20
楼主  发表于: 2015-12-10 22:37
只看楼主 | 小 中 大

 Tinny4412使用usb摄像头

      使用Tinny做usb摄像头的开发，在开发板上能正确识别设备、能打开设备、能设置参数、能获取设备信息、就是不能获取数据。直接使用VIDIOC_DQBUF系统就死机，使用select函数则报“select timeout”错误（select函数返回值为22即EINVA），但在linux（内核版本为2.6.29）下能运行正常。
       刚学ARM开发，请各位大神解救小弟啊！
              我使用的是开发板自带的内核，也做了v4l的配置，如下：
Device Drivers --->
    <*> Multimedia support --->
        <*> Video For Linux
        [*] Enable Video For Linux API 1 (DEPRECATED)
        [*] Video capture adapters --->
            [*] V4L USB devices --->
                <*> USB Video Class (UVC)
                [*] UVC input events device support
                [*] GSPCA based webcams --->
测试程序用的是官方 v4l2 video capture example
复制代码
  2. /*
  3.  *  V4L2 video capture example
  4.  *
  5.  *  This program can be used and distributed without restrictions.
  6.  *
  7.  *      This program is provided with the V4L2 API
  8.  * see http://linuxtv.org/docs.php for more information
  9.  */
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <assert.h>
  14. #include <getopt.h>             /* getopt_long() */
  15. #include <fcntl.h>              /* low-level i/o */
  16. #include <unistd.h>
  17. #include <errno.h>
  18. #include <sys/stat.h>
  19. #include <sys/types.h>
  20. #include <sys/time.h>
  21. #include <sys/mman.h>
  22. #include <sys/ioctl.h>
  23. #include <linux/videodev2.h>
  24. #define CLEAR(x) memset(&(x), 0, sizeof(x))
  25. enum io_method {
  26.         IO_METHOD_READ,
  27.         IO_METHOD_MMAP,
  28.         IO_METHOD_USERPTR,
  29. };
  30. struct buffer {
  31.         void   *start;
  32.         size_t  length;
  33. };
  34. static char            *dev_name;
  35. static enum io_method   io = IO_METHOD_MMAP;
  36. static int              fd = -1;
  37. struct buffer          *buffers;
  38. static unsigned int     n_buffers;
  39. static int              out_buf;
  40. static int              force_format;
  41. static int              frame_count = 70;
  43. static void errno_exit(const char *s)
  44. {
  45.         fprintf(stderr, "%s error %d, %s\n", s, errno, strerror(errno));
  46.         exit(EXIT_FAILURE);
  47. }
  49. static int xioctl(int fh, int request, void *arg)
  50. {
  51.         int r;
  52.         do {
  53.                 r = ioctl(fh, request, arg);
  54.         } while (-1 == r && EINTR == errno);
  55.         return r;
  56. }
  57. static int read_frame(void)
  58. {
  59.         struct v4l2_buffer buf;
  60.         unsigned int i;
  61.         switch (io) {
  62.         case IO_METHOD_READ: 
  63.               //省略直接读的代码
  64.                 break;
  65.         case IO_METHOD_MMAP:
  66.                 CLEAR(buf);
  67.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  68.                 buf.memory = V4L2_MEMORY_MMAP;
  69.                 if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
  70.                         switch (errno) {
  71.                         case EAGAIN:
  72.                                 return 0;
  73.                         case EIO:
  74.                                 /* Could ignore EIO, see spec. */
  75.                                 /* fall through */
  76.                         default:
  77.                                 errno_exit("VIDIOC_DQBUF");
  78.                         }
  79.                 }
  80.                 assert(buf.index < n_buffers);
  81.                 process_image(buffers[buf.index].start, buf.bytesused);
  82.                 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
  83.                         errno_exit("VIDIOC_QBUF");
  84.                 break;
  85.         case IO_METHOD_USERPTR: 
  86.            //这种模式的也不用
  87.                 break;
  88.         }
  89.         return 1;
  90. }
  91. /* two operations
  92.  * step1 : delay
  93.  * step2 : read frame
  94.  */
  95. static void mainloop(void)
  96. {
  97.         unsigned int count;
  98.         count = frame_count;
  99.         while (count-- > 0) {
  100.                 for (;;) {
  101.                         fd_set fds;
  102.                         struct timeval tv;
  103.                         int r;
  104.                         FD_ZERO(&fds);
  105.                         FD_SET(fd, &fds);
  106.                         /* Timeout. */
  107.                         tv.tv_sec = 2;
  108.                         tv.tv_usec = 0;
  109.                         r = select(fd + 1, &fds, NULL, NULL, &tv);
  110.                         if (-1 == r) {
  111.                                 if (EINTR == errno)
  112.                                         continue;
  113.                                 errno_exit("select");
  114.                         }
  115.                         if (0 == r) {
  116.                                 fprintf(stderr, "select timeout\n");
  117.                                 exit(EXIT_FAILURE);
  118.                         }
  119.                         if (read_frame())
  120.                                 break;
  121.                         /* EAGAIN - continue select loop. */
  122.                 }
  123.         }
  124. }
  125. /*
  126.  * one operation
  127.  * step1 : VIDIOC_STREAMOFF
  128.  */
  129. static void stop_capturing(void)
  130. {
  131.         enum v4l2_buf_type type;
  132.         switch (io) {
  133.         case IO_METHOD_READ:
  134.                 /* Nothing to do. */
  135.                 break;
  136.         case IO_METHOD_MMAP:
  137.         case IO_METHOD_USERPTR:
  138.                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  139.                 if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
  140.                         errno_exit("VIDIOC_STREAMOFF");
  141.                 break;
  142.         }
  143. }
  144. /* tow operations
  145.  * step1 : VIDIOC_QBUF(insert buffer to queue)
  146.  * step2 : VIDIOC_STREAMOFF
  147.  */
  148. static void start_capturing(void)
  149. {
  150.         unsigned int i;
  151.         enum v4l2_buf_type type;
  152.         switch (io) {
  153.         case IO_METHOD_READ:
  154.                 /* Nothing to do. */
  155.                 break;
  156.         case IO_METHOD_MMAP:
  157.                 for (i = 0; i < n_buffers; ++i) {
  158.                         struct v4l2_buffer buf;
  159.                         CLEAR(buf);
  160.                         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  161.                         buf.memory = V4L2_MEMORY_MMAP;
  162.                         buf.index = i;
  163.                         if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
  164.                                 errno_exit("VIDIOC_QBUF");
  165.                 }
  166.                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  167.                 if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
  168.                         errno_exit("VIDIOC_STREAMON");
  169.                 break;
  170.         case IO_METHOD_USERPTR: 
  171.               //省略
  172.                 break;
  173.         }
  174. }
  175. /* two operations
  176.  * step1 : munmap buffers
  177.  * steo2 : free buffers
  178.  */
  179. static void uninit_device(void)
  180. {
  181.         unsigned int i;
  182.         switch (io) {
  183.         case IO_METHOD_READ:
  184.                 free(buffers[0].start);
  185.                 break;
  186.         case IO_METHOD_MMAP:
  187.                 for (i = 0; i < n_buffers; ++i)
  188.                         if (-1 == munmap(buffers[i].start, buffers[i].length))
  189.                                 errno_exit("munmap");
  190.                 break;
  191.         case IO_METHOD_USERPTR: 
  192.                  //省略
  193.                 break;
  194.         }
  195.         free(buffers);
  196. }
  197. static void init_read(unsigned int buffer_size)
  198. { 
  199.          //省略
  200. }
  201. static void init_mmap(void)
  202. {
  203.         struct v4l2_requestbuffers req;
  204.         CLEAR(req);
  205.         req.count = 4;
  206.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  207.         req.memory = V4L2_MEMORY_MMAP;
  208.         if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
  209.                 if (EINVAL == errno) {
  210.                         fprintf(stderr, "%s does not support "
  211.                                  "memory mapping\n", dev_name);
  212.                         exit(EXIT_FAILURE);
  213.                 } else {
  214.                         errno_exit("VIDIOC_REQBUFS");
  215.                 }
  216.         }
  217.         if (req.count < 2) {
  218.                 fprintf(stderr, "Insufficient buffer memory on %s\n",
  219.                          dev_name);
  220.                 exit(EXIT_FAILURE);
  221.         }
  222.         buffers = calloc(req.count, sizeof(*buffers));
  223.         if (!buffers) {
  224.                 fprintf(stderr, "Out of memory\n");
  225.                 exit(EXIT_FAILURE);
  226.         }
  227.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
  228.                 struct v4l2_buffer buf;
  229.                 CLEAR(buf);
  230.                 buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  231.                 buf.memory      = V4L2_MEMORY_MMAP;
  232.                 buf.index       = n_buffers;
  233.                 if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
  234.                         errno_exit("VIDIOC_QUERYBUF");
  235.                 buffers[n_buffers].length = buf.length;
  236.                 buffers[n_buffers].start =
  237.                         mmap(NULL /* start anywhere */,
  238.                               buf.length,
  239.                               PROT_READ | PROT_WRITE /* required */,
  240.                               MAP_SHARED /* recommended */,
  241.                               fd, buf.m.offset);
  242.                 if (MAP_FAILED == buffers[n_buffers].start)
  243.                         errno_exit("mmap");
  244.         }
  245. }
  246. static void init_userp(unsigned int buffer_size)
  247. { 
  248.           //省略
  249. }
  250. /* five operations
  251.  * step1 : cap :query camera's capability and check it(is a video device? is it support read? is it support streaming?)
  252.  * step2 : cropcap:set cropcap's type and get cropcap by VIDIOC_CROPCAP
  253.  * step3 : set crop parameter by VIDIOC_S_CROP (such as frame type and angle)
  254.  * step4 : set fmt
  255.  * step5 : mmap
  256.  */
  257. static void init_device(void)
  258. {
  259.         struct v4l2_capability cap;
  260.         struct v4l2_cropcap cropcap;
  261.         struct v4l2_crop crop;
  262.         struct v4l2_format fmt;
  263.         unsigned int min;
  264.         if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
  265.                 if (EINVAL == errno) {
  266.                         fprintf(stderr, "%s is no V4L2 device\n",
  267.                                  dev_name);
  268.                         exit(EXIT_FAILURE);
  269.                 } else {
  270.                         errno_exit("VIDIOC_QUERYCAP");
  271.                 }
  272.         }
  273.         if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
  274.                 fprintf(stderr, "%s is no video capture device\n",
  275.                          dev_name);
  276.                 exit(EXIT_FAILURE);
  277.         }
  278.         switch (io) {
  279.         case IO_METHOD_READ:
  280.                 if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
  281.                         fprintf(stderr, "%s does not support read i/o\n",
  282.                                  dev_name);
  283.                         exit(EXIT_FAILURE);
  284.                 }
  285.                 break;
  286.         case IO_METHOD_MMAP:
  287.         case IO_METHOD_USERPTR:
  288.                 if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
  289.                         fprintf(stderr, "%s does not support streaming i/o\n",
  290.                                  dev_name);
  291.                         exit(EXIT_FAILURE);
  292.                 }
  293.                 break;
  294.         }
  296.         /* Select video input, video standard and tune here. */
  298.         CLEAR(cropcap);
  299.         cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  300.         /* if device support cropcap's type then set crop */
  301.         if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
  302.                 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  303.                 crop.c = cropcap.defrect; /* reset to default */
  304.                 if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
  305.                         switch (errno) {
  306.                         case EINVAL:
  307.                                 /* Cropping not supported. */
  308.                                 break;
  309.                         default:
  310.                                 /* Errors ignored. */
  311.                                 break;
  312.                         }
  313.                 }
  314.         } else {
  315.                 /* Errors ignored. */
  316.         }
  318.         CLEAR(fmt);
  319.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  320.         if (force_format) {
  321.                 fmt.fmt.pix.width       = 640;
  322.                 fmt.fmt.pix.height      = 480;
  323.                 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  324.                 fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
  325.                 if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
  326.                         errno_exit("VIDIOC_S_FMT");
  327.                 /* Note VIDIOC_S_FMT may change width and height. */
  328.         } else {
  329.                 /* Preserve original settings as set by v4l2-ctl for example */
  330.                 if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt))
  331.                         errno_exit("VIDIOC_G_FMT");
  332.         }
  333.         /* Buggy driver paranoia. */
  334.         min = fmt.fmt.pix.width * 2;
  335.         if (fmt.fmt.pix.bytesperline < min)
  336.                 fmt.fmt.pix.bytesperline = min;
  337.         min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
  338.         if (fmt.fmt.pix.sizeimage < min)
  339.                 fmt.fmt.pix.sizeimage = min;
  340.         switch (io) {
  341.         case IO_METHOD_READ:
  342.                 init_read(fmt.fmt.pix.sizeimage);
  343.                 break;
  344.         case IO_METHOD_MMAP:
  345.                 init_mmap();
  346.                 break;
  347.         case IO_METHOD_USERPTR:
  348.                 init_userp(fmt.fmt.pix.sizeimage);
  349.                 break;
  350.         }
  351. }
  352. /*
  353.  * close (fd)
  354.  */
  355. static void close_device(void)
  356. {
  357.         if (-1 == close(fd))
  358.                 errno_exit("close");
  359.         fd = -1;
  360. }
  361. /* three operations
  362.  * step 1 : check dev_name and st_mode
  363.  * step 2 : open(device)
  364.  */
  365. static void open_device(void)
  366. {
  367.         struct stat st;
  368.         if (-1 == stat(dev_name, &st)) {
  369.                 fprintf(stderr, "Cannot identify '%s': %d, %s\n",
  370.                          dev_name, errno, strerror(errno));
  371.                 exit(EXIT_FAILURE);
  372.         }
  373.         if (!S_ISCHR(st.st_mode)) {
  374.                 fprintf(stderr, "%s is no device\n", dev_name);
  375.                 exit(EXIT_FAILURE);
  376.         }
  377.         fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
  378.         if (-1 == fd) {
  379.                 fprintf(stderr, "Cannot open '%s': %d, %s\n",
  380.                          dev_name, errno, strerror(errno));
  381.                 exit(EXIT_FAILURE);
  382.         }
  383. }
  384. static void usage(FILE *fp, int argc, char **argv)
  385. {
  386.         fprintf(fp,
  387.                  "Usage: %s [options]\n\n"
  388.                  "Version 1.3\n"
  389.                  "Options:\n"
  390.                  "-d | --device name   Video device name [%s]\n"
  391.                  "-h | --help          Print this message\n"
  392.                  "-m | --mmap          Use memory mapped buffers [default]\n"
  393.                  "-r | --read          Use read() calls\n"
  394.                  "-u | --userp         Use application allocated buffers\n"
  395.                  "-o | --output        Outputs stream to stdout\n"
  396.                  "-f | --format        Force format to 640x480 YUYV\n"
  397.                  "-c | --count         Number of frames to grab [%i]\n"
  398.                  "",
  399.                  argv[0], dev_name, frame_count);
  400. }
  401. static const char short_options[] = "d:hmruofc:";
  402. static const struct option
  403. long_options[] = {
  404.         { "device", required_argument, NULL, 'd' },
  405.         { "help",   no_argument,       NULL, 'h' },
  406.         { "mmap",   no_argument,       NULL, 'm' },
  407.         { "read",   no_argument,       NULL, 'r' },
  408.         { "userp",  no_argument,       NULL, 'u' },
  409.         { "output", no_argument,       NULL, 'o' },
  410.         { "format", no_argument,       NULL, 'f' },
  411.         { "count",  required_argument, NULL, 'c' },
  412.         { 0, 0, 0, 0 }
  413. };
  414. int main(int argc, char **argv)
  415. {
  416.         dev_name = "/dev/video4";
  417.         for (;;) {
  418.                 int idx;
  419.                 int c;
  420.                 c = getopt_long(argc, argv,
  421.                                 short_options, long_options, &idx);
  422.                 if (-1 == c)
  423.                         break;
  424.                 switch (c) {
  425.                 case 0: /* getopt_long() flag */
  426.                         break;
  427.                 case 'd':
  428.                         dev_name = optarg;
  429.                         break;
  430.                 case 'h':
  431.                         usage(stdout, argc, argv);
  432.                         exit(EXIT_SUCCESS);
  433.                 case 'm':
  434.                         io = IO_METHOD_MMAP;
  435.                         break;
  436.                 case 'r':
  437.                         io = IO_METHOD_READ;
  438.                         break;
  439.                 case 'u':
  440.                         io = IO_METHOD_USERPTR;
  441.                         break;
  442.                 case 'o':
  443.                         out_buf++;
  444.                         break;
  445.                 case 'f':
  446.                         force_format++;
  447.                         break;
  448.                 case 'c':
  449.                         errno = 0;
  450.                         frame_count = strtol(optarg, NULL, 0);
  451.                         if (errno)
  452.                                 errno_exit(optarg);
  453.                         break;
  454.                 default:
  455.                         usage(stderr, argc, argv);
  456.                         exit(EXIT_FAILURE);
  457.                 }
  458.         }
  459.         open_device();
  460.         init_device();
  461.         start_capturing();
  462.         mainloop();
  463.         stop_capturing();
  464.         uninit_device();
  465.         close_device();
  466.         fprintf(stderr, "\n");
  467.         return 0;
  468. }


         


顶端