V4L2采集yuv视频花屏：Linux视频采集与编码（一）

http://blog.csdn.net/zgyulongfei/article/details/7526249

这两天在Linux下用V4L2采集yuv视频然后用x264编码成h.264文件。

我将yuv视频保存到文件中，然后用pyuv播放器播放它，悲剧的是播放出来的视频花屏了。

如下所示：

我采集视频的参数为：

尺寸：640 * 480

YUV格式：YUYV即YUV422

我一直以为是我代码写错了，因为采集视频的程序我是参考V4L2官方示例代码的，并且我把官方示例代码来运行，发现采集的视频也是花屏的。然后我又猜想可能是我摄像头不能采集数据吗？可是我下载好几个camera都可以正常的拍照，录制视频。这样纠结了好久好久。直到我的手开始犯贱，我把pyuv播放器 Format中的 Interleaved 复选框勾起来了，奇迹出现了。pyuv上清清楚楚的显示出了我录制的视频 Orz

后来认真看代码发现我的设置中有这么一句：fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; 意思就是采集数据的时候使用的是隔行扫描的方式，也就是说我将采集到的yuv写到文件中的方式是用隔行扫描的方式保存。

于是如果不将 Interleaved复选框勾起来，播放器就不能正常的播放你的yuv文件。

下面是正常时候显示的图像：

  XXX   (未经作者同意，所以照片就不贴了，要看帅哥，去原文链接  O(∩_∩)O~)    

嘿嘿，这是本人靓照 ^_^

yuv视频采集正常了，可是用x264编码出来的视频还是花屏到不堪入目！！！

这个是怎么办呢？请看我下一篇博文《YUYV编码成h.264：Linux视频采集与编码（二）》

附上V4L2视频采集代码：

[cpp]  view plain  copy

1. /* 
2.  *  V4L2 video capture example 
3.  * 
4.  *  This program can be used and distributed without restrictions. 
5.  */  
6.   
7. #include <stdio.h>  
8. #include <stdlib.h>  
9. #include <string.h>  
10. #include <assert.h>  
11.   
12. #include <getopt.h>             /* getopt_long() */  
13.   
14. #include <fcntl.h>              /* low-level i/o */  
15. #include <unistd.h>  
16. #include <errno.h>  
17. #include <malloc.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.   
24. #include <asm/types.h>          /* for videodev2.h */  
25.   
26. #include <linux/videodev2.h>  
27.   
28. #define CLEAR(x) memset (&(x), 0, sizeof (x))  
29.   
30. typedef enum {  
31.     IO_METHOD_READ, IO_METHOD_MMAP, IO_METHOD_USERPTR,  
32. } io_method;  
33.   
34. struct buffer {  
35.     void * start;  
36.     size_t length;  
37. };  
38.   
39. static char * dev_name = NULL;  
40. static io_method io = IO_METHOD_MMAP;  
41. static int fd = -1;  
42. struct buffer * buffers = NULL;  
43. static unsigned int n_buffers = 0;  
44.   
45. FILE *fp;  
46. char *filename = "test.yuv\0";  
47.   
48. static void errno_exit(const char * s) {  
49.     fprintf(stderr, "%s error %d, %s/n", s, errno, strerror(errno));  
50.   
51.     exit(EXIT_FAILURE);  
52. }  
53.   
54. static int xioctl(int fd, int request, void * arg) {  
55.     int r;  
56.   
57.     do {  
58.         r = ioctl(fd, request, arg);  
59.     } while (-1 == r && EINTR == errno);  
60.   
61.     return r;  
62. }  
63.   
64. static void process_image(const void * p, int size) {  
65.     fwrite(p, size, 1, fp);  
66. }  
67.   
68. static int read_frame(void) {  
69.     struct v4l2_buffer buf;  
70.     unsigned int i;  
71.   
72.     switch (io) {  
73.     case IO_METHOD_READ:  
74.         if (-1 == read(fd, buffers[0].start, buffers[0].length)) {  
75.             switch (errno) {  
76.             case EAGAIN:  
77.                 return 0;  
78.   
79.             case EIO:  
80.                 /* Could ignore EIO, see spec. */  
81.                 /* fall through */  
82.             default:  
83.                 errno_exit("read");  
84.             }  
85.         }  
86.   
87.         process_image(buffers[0].start, buffers[0].length);  
88.   
89.         break;  
90.   
91.     case IO_METHOD_MMAP:  
92.         CLEAR(buf);  
93.   
94.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
95.         buf.memory = V4L2_MEMORY_MMAP;  
96.   
97.         if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {  
98.             switch (errno) {  
99.             case EAGAIN:  
100.                 return 0;  
101.   
102.             case EIO:  
103.                 /* Could ignore EIO, see spec. */  
104.   
105.                 /* fall through */  
106.   
107.             default:  
108.                 errno_exit("VIDIOC_DQBUF");  
109.             }  
110.         }  
111.   
112.         assert(buf.index < n_buffers);  
113.   
114.         process_image(buffers[buf.index].start, buf.length);  
115.   
116.         if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))  
117.             errno_exit("VIDIOC_QBUF");  
118.   
119.         break;  
120.   
121.     case IO_METHOD_USERPTR:  
122.         CLEAR(buf);  
123.   
124.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
125.         buf.memory = V4L2_MEMORY_USERPTR;  
126.   
127.         if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {  
128.             switch (errno) {  
129.             case EAGAIN:  
130.                 return 0;  
131.   
132.             case EIO:  
133.                 /* Could ignore EIO, see spec. */  
134.   
135.                 /* fall through */  
136.   
137.             default:  
138.                 errno_exit("VIDIOC_DQBUF");  
139.             }  
140.         }  
141.   
142.         for (i = 0; i < n_buffers; ++i)  
143.             if (buf.m.userptr == (unsigned long) buffers[i].start  
144.                     && buf.length == buffers[i].length)  
145.                 break;  
146.   
147.         assert(i < n_buffers);  
148.   
149.         process_image((void *) buf.m.userptr, buf.length);  
150.   
151.         if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))  
152.             errno_exit("VIDIOC_QBUF");  
153.   
154.         break;  
155.     }  
156.   
157.     return 1;  
158. }  
159.   
160. static void mainloop(void) {  
161.     unsigned int count;  
162.   
163.     count = 100;  
164.   
165.     while (count-- > 0) {  
166.         for (;;) {  
167.             fd_set fds;  
168.             struct timeval tv;  
169.             int r;  
170.   
171.             FD_ZERO(&fds);  
172.             FD_SET(fd, &fds);  
173.   
174.             /* Timeout. */  
175.             tv.tv_sec = 2;  
176.             tv.tv_usec = 0;  
177.   
178.             r = select(fd + 1, &fds, NULL, NULL, &tv);  
179.   
180.             if (-1 == r) {  
181.                 if (EINTR == errno)  
182.                     continue;  
183.   
184.                 errno_exit("select");  
185.             }  
186.   
187.             if (0 == r) {  
188.                 fprintf(stderr, "select timeout/n");  
189.                 exit(EXIT_FAILURE);  
190.             }  
191.   
192.             if (read_frame())  
193.                 break;  
194.   
195.             /* EAGAIN - continue select loop. */  
196.         }  
197.     }  
198. }  
199.   
200. static void stop_capturing(void) {  
201.     enum v4l2_buf_type type;  
202.   
203.     switch (io) {  
204.     case IO_METHOD_READ:  
205.         /* Nothing to do. */  
206.         break;  
207.   
208.     case IO_METHOD_MMAP:  
209.     case IO_METHOD_USERPTR:  
210.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
211.   
212.         if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))  
213.             errno_exit("VIDIOC_STREAMOFF");  
214.   
215.         break;  
216.     }  
217. }  
218.   
219. static void start_capturing(void) {  
220.     unsigned int i;  
221.     enum v4l2_buf_type type;  
222.   
223.     switch (io) {  
224.     case IO_METHOD_READ:  
225.         /* Nothing to do. */  
226.         break;  
227.   
228.     case IO_METHOD_MMAP:  
229.         for (i = 0; i < n_buffers; ++i) {  
230.             struct v4l2_buffer buf;  
231.   
232.             CLEAR(buf);  
233.   
234.             buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
235.             buf.memory = V4L2_MEMORY_MMAP;  
236.             buf.index = i;  
237.   
238.             if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))  
239.                 errno_exit("VIDIOC_QBUF");  
240.         }  
241.   
242.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
243.   
244.         if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))  
245.             errno_exit("VIDIOC_STREAMON");  
246.   
247.         break;  
248.   
249.     case IO_METHOD_USERPTR:  
250.         for (i = 0; i < n_buffers; ++i) {  
251.             struct v4l2_buffer buf;  
252.   
253.             CLEAR(buf);  
254.   
255.             buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
256.             buf.memory = V4L2_MEMORY_USERPTR;  
257.             buf.index = i;  
258.             buf.m.userptr = (unsigned long) buffers[i].start;  
259.             buf.length = buffers[i].length;  
260.   
261.             if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))  
262.                 errno_exit("VIDIOC_QBUF");  
263.         }  
264.   
265.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
266.   
267.         if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))  
268.             errno_exit("VIDIOC_STREAMON");  
269.   
270.         break;  
271.     }  
272. }  
273.   
274. static void uninit_device(void) {  
275.     unsigned int i;  
276.   
277.     switch (io) {  
278.     case IO_METHOD_READ:  
279.         free(buffers[0].start);  
280.         break;  
281.   
282.     case IO_METHOD_MMAP:  
283.         for (i = 0; i < n_buffers; ++i)  
284.             if (-1 == munmap(buffers[i].start, buffers[i].length))  
285.                 errno_exit("munmap");  
286.         break;  
287.   
288.     case IO_METHOD_USERPTR:  
289.         for (i = 0; i < n_buffers; ++i)  
290.             free(buffers[i].start);  
291.         break;  
292.     }  
293.   
294.     free(buffers);  
295. }  
296.   
297. static void init_read(unsigned int buffer_size) {  
298.     buffers = calloc(1, sizeof(*buffers));  
299.   
300.     if (!buffers) {  
301.         fprintf(stderr, "Out of memory/n");  
302.         exit(EXIT_FAILURE);  
303.     }  
304.   
305.     buffers[0].length = buffer_size;  
306.     buffers[0].start = malloc(buffer_size);  
307.   
308.     if (!buffers[0].start) {  
309.         fprintf(stderr, "Out of memory/n");  
310.         exit(EXIT_FAILURE);  
311.     }  
312. }  
313.   
314. static void init_mmap(void) {  
315.     struct v4l2_requestbuffers req;  
316.   
317.     CLEAR(req);  
318.   
319.     req.count = 4;  
320.     req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
321.     req.memory = V4L2_MEMORY_MMAP;  
322.   
323.     if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {  
324.         if (EINVAL == errno) {  
325.             fprintf(stderr, "%s does not support "  
326.                     "memory mapping/n", dev_name);  
327.             exit(EXIT_FAILURE);  
328.         } else {  
329.             errno_exit("VIDIOC_REQBUFS");  
330.         }  
331.     }  
332.   
333.     if (req.count < 2) {  
334.         fprintf(stderr, "Insufficient buffer memory on %s/n", dev_name);  
335.         exit(EXIT_FAILURE);  
336.     }  
337.   
338.     buffers = calloc(req.count, sizeof(*buffers));  
339.   
340.     if (!buffers) {  
341.         fprintf(stderr, "Out of memory/n");  
342.         exit(EXIT_FAILURE);  
343.     }  
344.   
345.     for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {  
346.         struct v4l2_buffer buf;  
347.   
348.         CLEAR(buf);  
349.   
350.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
351.         buf.memory = V4L2_MEMORY_MMAP;  
352.         buf.index = n_buffers;  
353.   
354.         if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))  
355.             errno_exit("VIDIOC_QUERYBUF");  
356.   
357.         buffers[n_buffers].length = buf.length;  
358.         buffers[n_buffers].start = mmap(NULL /* start anywhere */, buf.length,  
359.                 PROT_READ | PROT_WRITE /* required */,  
360.                 MAP_SHARED /* recommended */, fd, buf.m.offset);  
361.   
362.         if (MAP_FAILED == buffers[n_buffers].start)  
363.             errno_exit("mmap");  
364.     }  
365. }  
366.   
367. static void init_userp(unsigned int buffer_size) {  
368.     struct v4l2_requestbuffers req;  
369.     unsigned int page_size;  
370.   
371.     page_size = getpagesize();  
372.     buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);  
373.   
374.     CLEAR(req);  
375.   
376.     req.count = 4;  
377.     req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
378.     req.memory = V4L2_MEMORY_USERPTR;  
379.   
380.     if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {  
381.         if (EINVAL == errno) {  
382.             fprintf(stderr, "%s does not support "  
383.                     "user pointer i/o/n", dev_name);  
384.             exit(EXIT_FAILURE);  
385.         } else {  
386.             errno_exit("VIDIOC_REQBUFS");  
387.         }  
388.     }  
389.   
390.     buffers = calloc(4, sizeof(*buffers));  
391.   
392.     if (!buffers) {  
393.         fprintf(stderr, "Out of memory/n");  
394.         exit(EXIT_FAILURE);  
395.     }  
396.   
397.     for (n_buffers = 0; n_buffers < 4; ++n_buffers) {  
398.         buffers[n_buffers].length = buffer_size;  
399.         buffers[n_buffers].start = memalign(/* boundary */page_size,  
400.                 buffer_size);  
401.   
402.         if (!buffers[n_buffers].start) {  
403.             fprintf(stderr, "Out of memory/n");  
404.             exit(EXIT_FAILURE);  
405.         }  
406.     }  
407. }  
408.   
409. static void init_device(void) {  
410.     struct v4l2_capability cap;  
411.     struct v4l2_cropcap cropcap;  
412.     struct v4l2_crop crop;  
413.     struct v4l2_format fmt;  
414.     unsigned int min;  
415.   
416.     if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {  
417.         if (EINVAL == errno) {  
418.             fprintf(stderr, "%s is no V4L2 device/n", dev_name);  
419.             exit(EXIT_FAILURE);  
420.         } else {  
421.             errno_exit("VIDIOC_QUERYCAP");  
422.         }  
423.     }  
424.   
425.     if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {  
426.         fprintf(stderr, "%s is no video capture device/n", dev_name);  
427.         exit(EXIT_FAILURE);  
428.     }  
429.   
430.     switch (io) {  
431.     case IO_METHOD_READ:  
432.         if (!(cap.capabilities & V4L2_CAP_READWRITE)) {  
433.             fprintf(stderr, "%s does not support read i/o/n", dev_name);  
434.             exit(EXIT_FAILURE);  
435.         }  
436.   
437.         break;  
438.   
439.     case IO_METHOD_MMAP:  
440.     case IO_METHOD_USERPTR:  
441.         if (!(cap.capabilities & V4L2_CAP_STREAMING)) {  
442.             fprintf(stderr, "%s does not support streaming i/o/n", dev_name);  
443.             exit(EXIT_FAILURE);  
444.         }  
445.   
446.         break;  
447.     }  
448.   
449.     /* Select video input, video standard and tune here. */  
450.   
451.     CLEAR(cropcap);  
452.   
453.     cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
454.   
455.     if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {  
456.         crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
457.         crop.c = cropcap.defrect; /* reset to default */  
458.   
459.         if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {  
460.             switch (errno) {  
461.             case EINVAL:  
462.                 /* Cropping not supported. */  
463.                 break;  
464.             default:  
465.                 /* Errors ignored. */  
466.                 break;  
467.             }  
468.         }  
469.     } else {  
470.         /* Errors ignored. */  
471.     }  
472.   
473.     CLEAR(fmt);  
474.   
475.     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
476.     fmt.fmt.pix.width = 640;  
477.     fmt.fmt.pix.height = 480;  
478.     fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;  
479.     fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;  
480.   
481.     if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))  
482.         errno_exit("VIDIOC_S_FMT");  
483.   
484.     /* Note VIDIOC_S_FMT may change width and height. */  
485.   
486.     /* Buggy driver paranoia. */  
487.     min = fmt.fmt.pix.width * 2;  
488.     if (fmt.fmt.pix.bytesperline < min)  
489.         fmt.fmt.pix.bytesperline = min;  
490.     min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;  
491.     if (fmt.fmt.pix.sizeimage < min)  
492.         fmt.fmt.pix.sizeimage = min;  
493.   
494.     switch (io) {  
495.     case IO_METHOD_READ:  
496.         init_read(fmt.fmt.pix.sizeimage);  
497.         break;  
498.   
499.     case IO_METHOD_MMAP:  
500.         init_mmap();  
501.         break;  
502.   
503.     case IO_METHOD_USERPTR:  
504.         init_userp(fmt.fmt.pix.sizeimage);  
505.         break;  
506.     }  
507. }  
508.   
509. static void close_device(void) {  
510.     if (-1 == close(fd))  
511.         errno_exit("close");  
512.   
513.     fd = -1;  
514. }  
515.   
516. static void open_device(void) {  
517.     struct stat st;  
518.   
519.     if (-1 == stat(dev_name, &st)) {  
520.         fprintf(stderr, "Cannot identify '%s': %d, %s/n", dev_name, errno,  
521.                 strerror(errno));  
522.         exit(EXIT_FAILURE);  
523.     }  
524.   
525.     if (!S_ISCHR(st.st_mode)) {  
526.         fprintf(stderr, "%s is no device/n", dev_name);  
527.         exit(EXIT_FAILURE);  
528.     }  
529.   
530.     fd = open(dev_name, O_RDWR /* required */| O_NONBLOCK, 0);  
531.   
532.     if (-1 == fd) {  
533.         fprintf(stderr, "Cannot open '%s': %d, %s/n", dev_name, errno,  
534.                 strerror(errno));  
535.         exit(EXIT_FAILURE);  
536.     }  
537. }  
538.   
539. static void usage(FILE * fp, int argc, char ** argv) {  
540.     fprintf(fp, "Usage: %s [options]/n/n"  
541.             "Options:/n"  
542.             "-d | --device name   Video device name [/dev/video]/n"  
543.             "-h | --help          Print this message/n"  
544.             "-m | --mmap          Use memory mapped buffers/n"  
545.             "-r | --read          Use read() calls/n"  
546.             "-u | --userp         Use application allocated buffers/n"  
547.             "", argv[0]);  
548. }  
549.   
550. static const char short_options[] = "d:hmru";  
551.   
552. static const struct option long_options[] = { { "device", required_argument,  
553.         NULL, 'd' }, { "help", no_argument, NULL, 'h' }, { "mmap", no_argument,  
554.         NULL, 'm' }, { "read", no_argument, NULL, 'r' }, { "userp", no_argument,  
555.         NULL, 'u' }, { 0, 0, 0, 0 } };  
556.   
557. int main(int argc, char ** argv) {  
558.     dev_name = "/dev/video0";  
559.   
560.     for (;;) {  
561.         int index;  
562.         int c;  
563.   
564.         c = getopt_long(argc, argv, short_options, long_options, &index);  
565.   
566.         if (-1 == c)  
567.             break;  
568.   
569.         switch (c) {  
570.         case 0: /* getopt_long() flag */  
571.             break;  
572.   
573.         case 'd':  
574.             dev_name = optarg;  
575.             break;  
576.   
577.         case 'h':  
578.             usage(stdout, argc, argv);  
579.             exit(EXIT_SUCCESS);  
580.   
581.         case 'm':  
582.             io = IO_METHOD_MMAP;  
583.             break;  
584.   
585.         case 'r':  
586.             io = IO_METHOD_READ;  
587.             break;  
588.   
589.         case 'u':  
590.             io = IO_METHOD_USERPTR;  
591.             break;  
592.   
593.         default:  
594.             usage(stderr, argc, argv);  
595.             exit(EXIT_FAILURE);  
596.         }  
597.     }  
598.   
599.     open_device();  
600.   
601.     init_device();  
602.   
603.     start_capturing();  
604.   
605.     fp = fopen(filename, "wa+");  
606.     mainloop();  
607.     fclose(fp);  
608.   
609.     stop_capturing();  
610.   
611.     uninit_device();  
612.   
613.     close_device();  
614.   
615.     exit(EXIT_SUCCESS);  
616.   
617.     return 0;  
618. }