1    /**
 2      * struct v4l2_capability - Describes V4L2 device caps returned by VIDIOC_QUERYCAP
 3      *
 4      * @driver:	   name of the driver module (e.g. "bttv")
 5      * @card:	   name of the card (e.g. "Hauppauge WinTV")
 6      * @bus_info:	   name of the bus (e.g. "PCI:" + pci_name(pci_dev) )
 7      * @version:	   KERNEL_VERSION
 8      * @capabilities: capabilities of the physical device as a whole
 9      * @device_caps:  capabilities accessed via this particular device (node)
10      * @reserved:	   reserved fields for future extensions
11      */
12    struct v4l2_capability {
13        __u8	driver[16];
14        __u8	card[32];
15        __u8	bus_info[32];
16        __u32   version;
17        __u32	capabilities;
18        __u32	device_caps;
19        __u32	reserved[3];
20    };

 1    /* Values for 'capabilities' field */
 2    #define V4L2_CAP_VIDEO_CAPTURE		0x00000001  /* Is a video capture device */
 3    #define V4L2_CAP_VIDEO_OUTPUT		0x00000002  /* Is a video output device */
 4    #define V4L2_CAP_VIDEO_OVERLAY		0x00000004  /* Can do video overlay */
 5    #define V4L2_CAP_VBI_CAPTURE		0x00000010  /* Is a raw VBI capture device */
 6    #define V4L2_CAP_VBI_OUTPUT		0x00000020  /* Is a raw VBI output device */
 7    #define V4L2_CAP_SLICED_VBI_CAPTURE	0x00000040  /* Is a sliced VBI capture device */
 8    #define V4L2_CAP_SLICED_VBI_OUTPUT	0x00000080  /* Is a sliced VBI output device */
 9    #define V4L2_CAP_RDS_CAPTURE		0x00000100  /* RDS data capture */
10    #define V4L2_CAP_VIDEO_OUTPUT_OVERLAY	0x00000200  /* Can do video output overlay */
11    #define V4L2_CAP_HW_FREQ_SEEK		0x00000400  /* Can do hardware frequency seek  */
12    #define V4L2_CAP_RDS_OUTPUT		0x00000800  /* Is an RDS encoder */
13    
14    /* Is a video capture device that supports multiplanar formats */
15    #define V4L2_CAP_VIDEO_CAPTURE_MPLANE	0x00001000
16    /* Is a video output device that supports multiplanar formats */
17    #define V4L2_CAP_VIDEO_OUTPUT_MPLANE	0x00002000
18    /* Is a video mem-to-mem device that supports multiplanar formats */
19    #define V4L2_CAP_VIDEO_M2M_MPLANE	0x00004000
20    /* Is a video mem-to-mem device */
21    #define V4L2_CAP_VIDEO_M2M		0x00008000
22    
23    #define V4L2_CAP_TUNER			0x00010000  /* has a tuner */
24    #define V4L2_CAP_AUDIO			0x00020000  /* has audio support */
25    #define V4L2_CAP_RADIO			0x00040000  /* is a radio device */
26    #define V4L2_CAP_MODULATOR		0x00080000  /* has a modulator */
27
28    #define V4L2_CAP_SDR_CAPTURE		0x00100000  /* Is a SDR capture device */
29    #define V4L2_CAP_EXT_PIX_FORMAT		0x00200000  /* Supports the extended pixel format */
30    #define V4L2_CAP_SDR_OUTPUT		0x00400000  /* Is a SDR output device */
31    #define V4L2_CAP_META_CAPTURE		0x00800000  /* Is a metadata capture device */
32    
33    #define V4L2_CAP_READWRITE              0x01000000  /* read/write systemcalls */
34    #define V4L2_CAP_STREAMING              0x04000000  /* streaming I/O ioctls */
35    #define V4L2_CAP_META_OUTPUT		0x08000000  /* Is a metadata output device */
36    
37    #define V4L2_CAP_TOUCH                  0x10000000  /* Is a touch device */
38    
39    #define V4L2_CAP_IO_MC			0x20000000  /* Is input/output controlled by the media controller */
40    
41    #define V4L2_CAP_DEVICE_CAPS            0x80000000  /* sets device capabilities field */

 1void query_capabilites(int fd)
 2{
 3	struct v4l2_capability cap;
 4
 5	if (-1 == ioctl(fd, VIDIOC_QUERYCAP, &cap)) {
 6		perror("Query capabilites");
 7		exit(EXIT_FAILURE);
 8	}
 9
10	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
11		fprintf(stderr, "Device is no video capture device\\n");
12		exit(EXIT_FAILURE);
13	}
14
15	if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
16		fprintf(stderr, "Device does not support read i/o\\n");
17	}
18
19	if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
20		fprintf(stderr, "Devices does not support streaming i/o\\n");
21		exit(EXIT_FAILURE);
22	}
23}

 1    marcus@goliat:~$ v4l2-ctl -d /dev/video4  --info
 2    Driver Info:
 3        Driver name      : uvcvideo
 4        Card type        : USB 2.0 Camera: USB Camera
 5        Bus info         : usb-0000:00:14.0-8.3.1.1
 6        Driver version   : 6.0.8
 7        Capabilities     : 0x84a00001
 8            Video Capture
 9            Metadata Capture
10            Streaming
11            Extended Pix Format
12            Device Capabilities
13        Device Caps      : 0x04200001
14            Video Capture
15            Streaming
16            Extended Pix Format

 1    marcus@goliat:~$ v4l2-ctl -d /dev/video4  --get-fmt-video
 2    Format Video Capture:
 3        Width/Height      : 320/240
 4        Pixel Format      : 'YUYV' (YUYV 4:2:2)
 5        Field             : None
 6        Bytes per Line    : 640
 7        Size Image        : 153600
 8        Colorspace        : sRGB
 9        Transfer Function : Rec. 709
10        YCbCr/HSV Encoding: ITU-R 601
11        Quantization      : Default (maps to Limited Range)
12        Flags             : 

 1    /**
 2     * struct v4l2_format - stream data format
 3     * @type:	enum v4l2_buf_type; type of the data stream
 4     * @pix:	definition of an image format
 5     * @pix_mp:	definition of a multiplanar image format
 6     * @win:	definition of an overlaid image
 7     * @vbi:	raw VBI capture or output parameters
 8     * @sliced:	sliced VBI capture or output parameters
 9     * @raw_data:	placeholder for future extensions and custom formats
10     * @fmt:	union of @pix, @pix_mp, @win, @vbi, @sliced, @sdr, @meta
11     *		and @raw_data
12     */
13    struct v4l2_format {
14        __u32	 type;
15        union {
16            struct v4l2_pix_format		pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
17            struct v4l2_pix_format_mplane	pix_mp;  /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */
18            struct v4l2_window		win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
19            struct v4l2_vbi_format		vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */
20            struct v4l2_sliced_vbi_format	sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
21            struct v4l2_sdr_format		sdr;     /* V4L2_BUF_TYPE_SDR_CAPTURE */
22            struct v4l2_meta_format		meta;    /* V4L2_BUF_TYPE_META_CAPTURE */
23            __u8	raw_data[200];                   /* user-defined */
24        } fmt;
25    };

 1int set_format(int fd)
 2{
 3	struct v4l2_format format = {0};
 4	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 5	format.fmt.pix.width = 320;
 6	format.fmt.pix.height = 240;
 7	format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
 8	format.fmt.pix.field = V4L2_FIELD_NONE;
 9
10	int res = ioctl(fd, VIDIOC_S_FMT, &format);
11	if(res == -1) {
12		perror("Could not set format");
13		exit(EXIT_FAILURE);
14	}
15
16	return res;
17}

1    struct v4l2_requestbuffers {
2        __u32			count;
3        __u32			type;		/* enum v4l2_buf_type */
4        __u32			memory;		/* enum v4l2_memory */
5        __u32			capabilities;
6        __u8			flags;
7        __u8			reserved[3];
8    };

 1int request_buffer(int fd, int count)
 2{
 3	struct v4l2_requestbuffers req = {0};
 4	req.count = count;
 5	req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 6	req.memory = V4L2_MEMORY_MMAP;
 7
 8	if (ioctl(fd, VIDIOC_REQBUFS, &req) == -1) {
 9		perror("Requesting Buffer");
10		exit(EXIT_FAILURE);
11	}
12
13	return req.count;
14}

 1    /**
 2     * struct v4l2_buffer - video buffer info
 3     * @index:	id number of the buffer
 4     * @type:	enum v4l2_buf_type; buffer type (type == *_MPLANE for
 5     *		multiplanar buffers);
 6     * @bytesused:	number of bytes occupied by data in the buffer (payload);
 7     *		unused (set to 0) for multiplanar buffers
 8     * @flags:	buffer informational flags
 9     * @field:	enum v4l2_field; field order of the image in the buffer
10     * @timestamp:	frame timestamp
11     * @timecode:	frame timecode
12     * @sequence:	sequence count of this frame
13     * @memory:	enum v4l2_memory; the method, in which the actual video data is
14     *		passed
15     * @offset:	for non-multiplanar buffers with memory == V4L2_MEMORY_MMAP;
16     *		offset from the start of the device memory for this plane,
17     *		(or a "cookie" that should be passed to mmap() as offset)
18     * @userptr:	for non-multiplanar buffers with memory == V4L2_MEMORY_USERPTR;
19     *		a userspace pointer pointing to this buffer
20     * @fd:		for non-multiplanar buffers with memory == V4L2_MEMORY_DMABUF;
21     *		a userspace file descriptor associated with this buffer
22     * @planes:	for multiplanar buffers; userspace pointer to the array of plane
23     *		info structs for this buffer
24     * @m:		union of @offset, @userptr, @planes and @fd
25     * @length:	size in bytes of the buffer (NOT its payload) for single-plane
26     *		buffers (when type != *_MPLANE); number of elements in the
27     *		planes array for multi-plane buffers
28     * @reserved2:	drivers and applications must zero this field
29     * @request_fd: fd of the request that this buffer should use
30     * @reserved:	for backwards compatibility with applications that do not know
31     *		about @request_fd
32     *
33     * Contains data exchanged by application and driver using one of the Streaming
34     * I/O methods.
35     */
36    struct v4l2_buffer {
37        __u32			index;
38        __u32			type;
39        __u32			bytesused;
40        __u32			flags;
41        __u32			field;
42        struct timeval		timestamp;
43        struct v4l2_timecode	timecode;
44        __u32			sequence;
45
46        /* memory location */
47        __u32			memory;
48        union {
49            __u32           offset;
50            unsigned long   userptr;
51            struct v4l2_plane *planes;
52            __s32		fd;
53        } m;
54        __u32			length;
55        __u32			reserved2;
56        union {
57            __s32		request_fd;
58            __u32		reserved;
59        };
60    };

 1int query_buffer(int fd, int index, unsigned char **buffer)
 2{
 3	struct v4l2_buffer buf = {0};
 4	buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 5	buf.memory = V4L2_MEMORY_MMAP;
 6	buf.index = index;
 7
 8	if(ioctl(fd, VIDIOC_QUERYBUF, &buf) == -1) {
 9		perror("Could not query buffer");
10		exit(EXIT_FAILURE);
11	}
12
13	*buffer = (u_int8_t*)mmap (NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
14	return buf.length;
15}

 1int queue_buffer(int fd, int index)
 2{
 3	struct v4l2_buffer bufd = {0};
 4	bufd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 5	bufd.memory = V4L2_MEMORY_MMAP;
 6	bufd.index = index;
 7
 8	if (ioctl(fd, VIDIOC_QBUF, &bufd) == -1) {
 9		perror("Queue Buffer");
10		exit(EXIT_FAILURE);
11	}
12
13	return bufd.bytesused;
14}

 1int start_streaming(int fd)
 2{
 3	unsigned int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 4	if(ioctl(fd, VIDIOC_STREAMON, &type) == -1) {
 5		perror("VIDIOC_STREAMON");
 6		exit(EXIT_FAILURE);
 7	}
 8
 9	return 0;
10}

 1int dequeue_buffer(int fd)
 2{
 3	struct v4l2_buffer bufd = {0};
 4	bufd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 5	bufd.memory = V4L2_MEMORY_MMAP;
 6	bufd.index = 0;
 7
 8	if (ioctl(fd, VIDIOC_DQBUF, &bufd) == -1) {
 9		perror("DeQueue Buffer");
10		exit(EXIT_FAILURE);
11	}
12
13	return bufd.index;
14}

 1int stop_streaming(int fd)
 2{
 3	unsigned int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 4	if(ioctl(fd, VIDIOC_STREAMOFF, &type) == -1) {
 5		perror("VIDIOC_STREAMON");
 6		exit(EXIT_FAILURE);
 7	}
 8
 9	return 0;
10}