linux下usb camera图像采集（V4l2）

head.h

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <fcntl.h> /* low-level i/o */

5. #include <unistd.h>

6. #include <errno.h>

7. #include <malloc.h>

8. #include <sys/stat.h>

9. #include <sys/types.h>

10. #include <sys/time.h>

11. #include <sys/mman.h>

12. #include <sys/ioctl.h>

13. #include <linux/videodev2.h>

14. #define DEVICE "/dev/video"

15. static struct v4l2_requestbuffers req;

16. struct buffer

17. {

18. void* start;

19. unsigned int length;

20. };

21. static struct buffer *buffers;

22. static struct v4l2_buffer buf;

usb_camera.c

1. #include "head.h"

2. int main()

3. {

4. int fd;

5. fd=open_device();

6. get_device_info(fd);

7. get_frame_fmt(fd);

8. get_current_frame_info(fd);

9. try_format_support(fd);

10. set_frame_format(fd);

11. apply_memory_buf(fd);

12. memory_mapping(fd);

13. buffer_enqueue(fd);

14. close(fd);

15. return 0;

16. }

17. int open_device()

18. {

19. int fd;

20. if(-1==(fd=open(DEVICE,O_RDWR)))

21. printf("info:Can't open video device\n");

22. else

23. printf("info:Open the device :%d\n",fd);

24. return fd;

25. }

26. int get_device_info(int fd)

27. {

28. struct v4l2_capability cap;

29. if(-1==ioctl(fd,VIDIOC_QUERYCAP,&cap))

30. printf("info:VIDIOC_QUERYCAP ERROR\n");

31. else

32. printf("info:Driver Name:%s....Card Name:%s....Bus info:%s....Driver Version:%u.%u.%u\n",

version的各字段提取如下：
driver = version >> 16 & 0xfff
card = version >> 8 & 0xfff
bus_info = version & 0xfff

34. return 1;

35. }

36. int get_frame_fmt(int fd)

37. {

38. struct v4l2_fmtdesc fmtdesc;

39. fmtdesc.index=0;

40. fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

41. printf("info:Support format:");

42. while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)

43. {

44. printf("\t%d.%s",fmtdesc.index+1,fmtdesc.description);

45. fmtdesc.index++;

46. }

47. printf("\n");

48. return 1;

49. }

50. int get_current_frame_info(int fd)

51. {

52. struct v4l2_format fmt;

53. fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

54. ioctl(fd,VIDIOC_G_FMT,&fmt);

55. printf("info:Current version data formats information:\n\t宽度（px）:%d\n\t高度（px）:%d\n",fmt.fmt.pix.width,fmt.fmt.pix.height);

56. struct v4l2_fmtdesc fmtdesc;

57. fmtdesc.index=0;

58. fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

59. while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)

60. {

61. if(fmtdesc.pixelformat & fmt.fmt.pix.pixelformat)

62. {

63. printf("\tformat:%s\n",fmtdesc.description);

64. break;

65. }

66. fmtdesc.index++;

67. }

68. return 1;

69. }

70. int try_format_support(int fd)

71. {

72. struct v4l2_format fmt;

73. fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

74. //fmt.fmt.pix.pixelformat=V4L2_PIX_FMT_RGB32;

75. fmt.fmt.pix.pixelformat=V4L2_PIX_FMT_YUYV;

76. if(ioctl(fd,VIDIOC_TRY_FMT,&fmt)==-1)

77. if(errno==EINVAL)

78. printf("info:not support format RGB32!\n");

79. return 1;

80. }

81. int set_frame_format(int fd)

82. {

83. struct v4l2_format fmt;

84. fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

85. fmt.fmt.pix.width=640;

86. fmt.fmt.pix.height=480;

87. fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

88. fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

89. if(ioctl(fd,VIDIOC_S_FMT,&fmt)==-1)

90. if(errno==EINVAL)

91. printf("info:set frame format error!\n");

92. return 1;

93. }

94. int apply_memory_buf(int fd)

95. {

96. //struct v4l2_requestbuffers req;

97. req.count=4;

98. req.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

99. req.memory=V4L2_MEMORY_MMAP;

100. if(-1==ioctl(fd,VIDIOC_REQBUFS,&req))

101. printf("info:VIDIOC_REQBUFS FAILED\n");

102. else

103. printf("info:VIDIOC_REQBUFS SUCCESS\n");

104. return 1;

105. }

106. int memory_mapping(int fd)

107. {

108. unsigned int n_buffers;

109. buffers = (struct buffer*)calloc(req.count,sizeof(struct buffer));

110. if (!buffers) {

111. fprintf (stderr, "Out of memory\n");

112. exit (EXIT_FAILURE);

113. }

114. // 映射

115. for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {

116. //struct v4l2_buffer buf;

117. memset(&buf,0,sizeof(buf));

118. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

119. buf.memory = V4L2_MEMORY_MMAP;

120. buf.index = n_buffers;

121. // 查询序号为n_buffers 的缓冲区，得到其起始物理地址和大小

122. if (-1 == ioctl (fd, VIDIOC_QUERYBUF, &buf))

123. exit(-1);

124. buffers[n_buffers].length = buf.length;

125. // 映射内存

编号为126的缓冲区[buffers[n_buffers]]在其起始位置[.start]处调用内存映射函数[mmap]（null, buffer长度[buf.length]、可读性和可写性 flags [PROT_READ | PROT_WRITE]、共享模式[MAP_SHARED]、文件描述符[fd]以及偏移量[buf.m.offset]）。

127. if (MAP_FAILED == buffers[n_buffers].start)

128. exit(-1);

129. }

130. printf("info:memory mapping success\n");

131. return 1;

132. }

133. int buffer_enqueue(int fd)

134. {

135. unsigned int i;

136. enum v4l2_buf_type type;

137. // 将缓冲帧放入队列

138. for (i = 0; i < 4; ++i)

139. {

140. struct v4l2_buffer buf;

141. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

142. buf.memory = V4L2_MEMORY_MMAP;

143. buf.index = i;

144. if(-1==ioctl (fd, VIDIOC_QBUF, &buf))

145. printf("buffer enqueue failed\n");

146. }

147. type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

148. //open stream

149. if(-1==ioctl (fd, VIDIOC_STREAMON, &type))

150. printf("info:open stream failed\n");

151. else

152. printf("info:open stream success\n");

153. return 1;

154. }