Android Camera 一 源码路径
Android Camera 二 JNI JAVA和C/CPP图像数据传输流程分析
Android Camera 三 CameraService 和 Client 链接到 HAL
Android Camera 四 Camera HAL 分析
Linux v4l2 一 应用层
Linux v4l2 二 驱动和 usb 摄像头
v4l2 ： video for Linux version 2
本文转载： 和菜鸟一起学linux之V4L2摄像头应用流程
V4L2官方例程
从 0 开始学 v4l2 。在网上查阅很多资料，写 demo 采集摄像头的图像数据。感谢大牛们分享的技术博客。
这里做个小结，分享知识。
下面给出写 v4l2 应用程序常用的控制命令和结构体
// linux-3.10.y/include/uapi/linux/videodev2.h
// 常用的结构体
struct v4l2_requestbuffers //申请帧缓冲，对应命令VIDIOC_REQBUFS
struct v4l2_capability //视频设备的功能，对应命令VIDIOC_QUERYCAP
struct v4l2_input //视频输入信息，对应命令VIDIOC_ENUMINPUT
struct v4l2_standard //视频的制式，比如PAL，NTSC，对应命令VIDIOC_ENUMSTD
struct v4l2_format //帧的格式，对应命令VIDIOC_G_FMT、VIDIOC_S_FMT等
struct v4l2_buffer //驱动中的一帧图像缓存，对应命令VIDIOC_QUERYBUF
struct v4l2_crop //视频信号矩形边框// 常用的控制命令 IOCTL CODES FOR VIDEO DEVICES
VIDIOC_ENUM_FMT /* 获取当前驱动支持的视频格式 */
VIDIOC_G_FMT /* 获取设置支持的视频格式 */
VIDIOC_S_FMT /* 设置捕获视频的格式 */
VIDIOC_TRY_FMT /* 验证当前驱动的显示格式 */
VIDIOC_CROPCAP /* 查询驱动的修剪能力 */
VIDIOC_S_CROP /* 设置视频信号的边框 */
VIDIOC_G_CROP /* 获取视频信号的边框 */
VIDIOC_QUERYSTD /* 检查当前视频设备支持的标准，例如PAL或NTSC */
VIDIOC_QUERYCAP /* 获取设备支持的操作 */
VIDIOC_REQBUFS /* 向驱动提出申请内存的请求 */
VIDIOC_QUERYBUF /* 向驱动查询申请到的内存 */
VIDIOC_QBUF /* 将空闲的内存加入可捕获视频的队列 */
VIDIOC_DQBUF /* 将已经捕获好视频的内存拉出已捕获视频的队列 */
VIDIOC_STREAMON /* 打开视频流 */
VIDIOC_STREAMOFF /* 关闭视频流 */
VIDIOC_QUERYCTRL /* 查询驱动是否支持该命令 */
VIDIOC_G_CTRL /* 获取当前命令值 */
VIDIOC_S_CTRL /* 设置新的命令值 */
VIDIOC_G_TUNER /* 获取调谐器信息 */
VIDIOC_S_TUNER /* 设置调谐器信息 */
VIDIOC_G_FREQUENCY /* 获取调谐器频率 */
VIDIOC_S_FREQUENCY /* 设置调谐器频率 */
应用程序流程：
/** V4L2 video capture example** This program can be used and distributed without restrictions.*/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>#include <getopt.h> /* getopt_long() */#include <fcntl.h> /* low-level i/o */
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>#include <asm/types.h> /* for videodev2.h */#include <linux/videodev2.h>#define CLEAR(x) memset (&(x), 0, sizeof (x))typedef enum {IO_METHOD_READ, IO_METHOD_MMAP, IO_METHOD_USERPTR,
} io_method;struct buffer {void * start;size_t length;
};static char * dev_name = NULL;
static io_method io = IO_METHOD_MMAP;
static int fd = -1;
struct buffer * buffers = NULL;
static unsigned int n_buffers = 0;FILE *fp;
char *filename = "test.yuv\0";static void errno_exit(const char * s) {fprintf(stderr, "%s error %d, %s/n", s, errno, strerror(errno));exit(EXIT_FAILURE);
}static int xioctl(int fd, int request, void * arg) {int r;do {r = ioctl(fd, request, arg);} while (-1 == r && EINTR == errno);return r;
}static void process_image(const void * p, int size) {fwrite(p, size, 1, fp);
}static int read_frame(void) {struct v4l2_buffer buf;unsigned int i;switch (io) {case IO_METHOD_READ:if (-1 == read(fd, buffers[0].start, buffers[0].length)) {switch (errno) {case EAGAIN:return 0;case EIO:/* Could ignore EIO, see spec. *//* fall through */default:errno_exit("read");}}process_image(buffers[0].start, buffers[0].length);break;case IO_METHOD_MMAP:CLEAR(buf);buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;buf.memory = V4L2_MEMORY_MMAP;if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {switch (errno) {case EAGAIN:return 0;case EIO:/* Could ignore EIO, see spec. *//* fall through */default:errno_exit("VIDIOC_DQBUF");}}assert(buf.index < n_buffers);process_image(buffers[buf.index].start, buf.length);if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))errno_exit("VIDIOC_QBUF");break;case IO_METHOD_USERPTR:CLEAR(buf);buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;buf.memory = V4L2_MEMORY_USERPTR;if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {switch (errno) {case EAGAIN:return 0;case EIO:/* Could ignore EIO, see spec. *//* fall through */default:errno_exit("VIDIOC_DQBUF");}}for (i = 0; i < n_buffers; ++i)if (buf.m.userptr == (unsigned long) buffers[i].start&& buf.length == buffers[i].length)break;assert(i < n_buffers);process_image((void *) buf.m.userptr, buf.length);if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))errno_exit("VIDIOC_QBUF");break;}return 1;
}static void mainloop(void) {unsigned int count;count = 100;while (count-- > 0) {for (;;) {fd_set fds;struct timeval tv;int r;FD_ZERO(&fds);FD_SET(fd, &fds);/* Timeout. */tv.tv_sec = 2;tv.tv_usec = 0;r = select(fd + 1, &fds, NULL, NULL, &tv);if (-1 == r) {if (EINTR == errno)continue;errno_exit("select");}if (0 == r) {fprintf(stderr, "select timeout/n");exit(EXIT_FAILURE);}if (read_frame())break;/* EAGAIN - continue select loop. */}}
}static void stop_capturing(void) {enum v4l2_buf_type type;switch (io) {case IO_METHOD_READ:/* Nothing to do. */break;case IO_METHOD_MMAP:case IO_METHOD_USERPTR:type = V4L2_BUF_TYPE_VIDEO_CAPTURE;if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))errno_exit("VIDIOC_STREAMOFF");break;}
}static void start_capturing(void) {unsigned int i;enum v4l2_buf_type type;switch (io) {case IO_METHOD_READ:/* Nothing to do. */break;case IO_METHOD_MMAP:for (i = 0; i < n_buffers; ++i) {struct v4l2_buffer buf;CLEAR(buf);buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;buf.memory = V4L2_MEMORY_MMAP;buf.index = i;if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))errno_exit("VIDIOC_QBUF");}type = V4L2_BUF_TYPE_VIDEO_CAPTURE;if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))errno_exit("VIDIOC_STREAMON");break;case IO_METHOD_USERPTR:for (i = 0; i < n_buffers; ++i) {struct v4l2_buffer buf;CLEAR(buf);buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;buf.memory = V4L2_MEMORY_USERPTR;buf.index = i;buf.m.userptr = (unsigned long) buffers[i].start;buf.length = buffers[i].length;if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))errno_exit("VIDIOC_QBUF");}type = V4L2_BUF_TYPE_VIDEO_CAPTURE;if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))errno_exit("VIDIOC_STREAMON");break;}
}static void uninit_device(void) {unsigned int i;switch (io) {case IO_METHOD_READ:free(buffers[0].start);break;case IO_METHOD_MMAP:for (i = 0; i < n_buffers; ++i)if (-1 == munmap(buffers[i].start, buffers[i].length))errno_exit("munmap");break;case IO_METHOD_USERPTR:for (i = 0; i < n_buffers; ++i)free(buffers[i].start);break;}free(buffers);
}static void init_read(unsigned int buffer_size) {buffers = calloc(1, sizeof(*buffers));if (!buffers) {fprintf(stderr, "Out of memory/n");exit(EXIT_FAILURE);}buffers[0].length = buffer_size;buffers[0].start = malloc(buffer_size);if (!buffers[0].start) {fprintf(stderr, "Out of memory/n");exit(EXIT_FAILURE);}
}static void init_mmap(void) {struct v4l2_requestbuffers req;CLEAR(req);req.count = 4;req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;req.memory = V4L2_MEMORY_MMAP;if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {if (EINVAL == errno) {fprintf(stderr, "%s does not support ""memory mapping/n", dev_name);exit(EXIT_FAILURE);} else {errno_exit("VIDIOC_REQBUFS");}}if (req.count < 2) {fprintf(stderr, "Insufficient buffer memory on %s/n", dev_name);exit(EXIT_FAILURE);}buffers = calloc(req.count, sizeof(*buffers));if (!buffers) {fprintf(stderr, "Out of memory/n");exit(EXIT_FAILURE);}for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {struct v4l2_buffer buf;CLEAR(buf);buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;buf.memory = V4L2_MEMORY_MMAP;buf.index = n_buffers;if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))errno_exit("VIDIOC_QUERYBUF");buffers[n_buffers].length = buf.length;buffers[n_buffers].start = mmap(NULL /* start anywhere */, buf.length,PROT_READ | PROT_WRITE /* required */,MAP_SHARED /* recommended */, fd, buf.m.offset);if (MAP_FAILED == buffers[n_buffers].start)errno_exit("mmap");}
}static void init_userp(unsigned int buffer_size) {struct v4l2_requestbuffers req;unsigned int page_size;page_size = getpagesize();buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);CLEAR(req);req.count = 4;req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;req.memory = V4L2_MEMORY_USERPTR;if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {if (EINVAL == errno) {fprintf(stderr, "%s does not support ""user pointer i/o/n", dev_name);exit(EXIT_FAILURE);} else {errno_exit("VIDIOC_REQBUFS");}}buffers = calloc(4, sizeof(*buffers));if (!buffers) {fprintf(stderr, "Out of memory/n");exit(EXIT_FAILURE);}for (n_buffers = 0; n_buffers < 4; ++n_buffers) {buffers[n_buffers].length = buffer_size;buffers[n_buffers].start = memalign(/* boundary */page_size,buffer_size);if (!buffers[n_buffers].start) {fprintf(stderr, "Out of memory/n");exit(EXIT_FAILURE);}}
}static void init_device(void) {struct v4l2_capability cap;struct v4l2_cropcap cropcap;struct v4l2_crop crop;struct v4l2_format fmt;unsigned int min;if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {if (EINVAL == errno) {fprintf(stderr, "%s is no V4L2 device/n", dev_name);exit(EXIT_FAILURE);} else {errno_exit("VIDIOC_QUERYCAP");}}if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {fprintf(stderr, "%s is no video capture device/n", dev_name);exit(EXIT_FAILURE);}switch (io) {case IO_METHOD_READ:if (!(cap.capabilities & V4L2_CAP_READWRITE)) {fprintf(stderr, "%s does not support read i/o/n", dev_name);exit(EXIT_FAILURE);}break;case IO_METHOD_MMAP:case IO_METHOD_USERPTR:if (!(cap.capabilities & V4L2_CAP_STREAMING)) {fprintf(stderr, "%s does not support streaming i/o/n", dev_name);exit(EXIT_FAILURE);}break;}/* Select video input, video standard and tune here. */CLEAR(cropcap);cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;crop.c = cropcap.defrect; /* reset to default */if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {switch (errno) {case EINVAL:/* Cropping not supported. */break;default:/* Errors ignored. */break;}}} else {/* Errors ignored. */}CLEAR(fmt);fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;fmt.fmt.pix.width = 640;fmt.fmt.pix.height = 480;fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))errno_exit("VIDIOC_S_FMT");/* Note VIDIOC_S_FMT may change width and height. *//* Buggy driver paranoia. */min = fmt.fmt.pix.width * 2;if (fmt.fmt.pix.bytesperline < min)fmt.fmt.pix.bytesperline = min;min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;if (fmt.fmt.pix.sizeimage < min)fmt.fmt.pix.sizeimage = min;switch (io) {case IO_METHOD_READ:init_read(fmt.fmt.pix.sizeimage);break;case IO_METHOD_MMAP:init_mmap();break;case IO_METHOD_USERPTR:init_userp(fmt.fmt.pix.sizeimage);break;}
}static void close_device(void) {if (-1 == close(fd))errno_exit("close");fd = -1;
}static void open_device(void) {struct stat st;if (-1 == stat(dev_name, &st)) {fprintf(stderr, "Cannot identify '%s': %d, %s/n", dev_name, errno,strerror(errno));exit(EXIT_FAILURE);}if (!S_ISCHR(st.st_mode)) {fprintf(stderr, "%s is no device/n", dev_name);exit(EXIT_FAILURE);}fd = open(dev_name, O_RDWR /* required */| O_NONBLOCK, 0);if (-1 == fd) {fprintf(stderr, "Cannot open '%s': %d, %s/n", dev_name, errno,strerror(errno));exit(EXIT_FAILURE);}
}static void usage(FILE * fp, int argc, char ** argv) {fprintf(fp, "Usage: %s [options]/n/n""Options:/n""-d | --device name Video device name [/dev/video]/n""-h | --help Print this message/n""-m | --mmap Use memory mapped buffers/n""-r | --read Use read() calls/n""-u | --userp Use application allocated buffers/n""", argv[0]);
}static const char short_options[] = "d:hmru";static const struct option long_options[] = { { "device", required_argument,NULL, 'd' }, { "help", no_argument, NULL, 'h' }, { "mmap", no_argument,NULL, 'm' }, { "read", no_argument, NULL, 'r' }, { "userp", no_argument,NULL, 'u' }, { 0, 0, 0, 0 } };int main(int argc, char ** argv) {dev_name = "/dev/video0";for (;;) {int index;int c;c = getopt_long(argc, argv, short_options, long_options, &index);if (-1 == c)break;switch (c) {case 0: /* getopt_long() flag */break;case 'd':dev_name = optarg;break;case 'h':usage(stdout, argc, argv);exit(EXIT_SUCCESS);case 'm':io = IO_METHOD_MMAP;break;case 'r':io = IO_METHOD_READ;break;case 'u':io = IO_METHOD_USERPTR;break;default:usage(stderr, argc, argv);exit(EXIT_FAILURE);}}open_device();init_device();start_capturing();fp = fopen(filename, "wa+");mainloop();fclose(fp);stop_capturing();uninit_device();close_device();exit(EXIT_SUCCESS);return 0;
}