videodev2.h source code [include/linux/videodev2.h]

1	/ SPDX-License-Identifier: ((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) /
2	/*
3	* Video for Linux Two header file
4	*
5	* Copyright (C) 1999-2012 the contributors
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* Alternatively you can redistribute this file under the terms of the
18	* BSD license as stated below:
19	*
20	* Redistribution and use in source and binary forms, with or without
21	* modification, are permitted provided that the following conditions
22	* are met:
23	* 1. Redistributions of source code must retain the above copyright
24	* notice, this list of conditions and the following disclaimer.
25	* 2. Redistributions in binary form must reproduce the above copyright
26	* notice, this list of conditions and the following disclaimer in
27	* the documentation and/or other materials provided with the
28	* distribution.
29	* 3. The names of its contributors may not be used to endorse or promote
30	* products derived from this software without specific prior written
31	* permission.
32	*
33	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
34	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
35	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
36	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
37	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
38	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
39	* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
40	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
41	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
42	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
43	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
44	*
45	* Header file for v4l or V4L2 drivers and applications
46	* with public API.
47	* All kernel-specific stuff were moved to media/v4l2-dev.h, so
48	* no #if __KERNEL tests are allowed here
49	*
50	* See https://linuxtv.org for more info
51	*
52	* Author: Bill Dirks <bill@thedirks.org>
53	* Justin Schoeman
54	* Hans Verkuil <hverkuil@xs4all.nl>
55	* et al.
56	*/
57	#ifndef __LINUX_VIDEODEV2_H
58	#define __LINUX_VIDEODEV2_H
59
60	#include <sys/time.h>
61
62	#include <linux/ioctl.h>
63	#include <linux/types.h>
64	#include <linux/v4l2-common.h>
65	#include <linux/v4l2-controls.h>
66
67	/*
68	* Common stuff for both V4L1 and V4L2
69	* Moved from videodev.h
70	*/
71	#define VIDEO_MAX_FRAME 32
72	#define VIDEO_MAX_PLANES 8
73
74	/*
75	* M I S C E L L A N E O U S
76	*/
77
78	/ Four-character-code (FOURCC) /
79	#define v4l2_fourcc(a, b, c, d)\
80	((__u32)(a) \| ((__u32)(b) << 8) \| ((__u32)(c) << 16) \| ((__u32)(d) << 24))
81	#define v4l2_fourcc_be(a, b, c, d) (v4l2_fourcc(a, b, c, d) \| (1 << 31))
82
83	/*
84	* E N U M S
85	*/
86	enum v4l2_field {
87	V4L2_FIELD_ANY = `0`, / driver can choose from none,*
88	top, bottom, interlaced
89	depending on whatever it thinks
90	is approximate ... /*
91	V4L2_FIELD_NONE = `1`, / this device has no fields ... /
92	V4L2_FIELD_TOP = `2`, / top field only /
93	V4L2_FIELD_BOTTOM = `3`, / bottom field only /
94	V4L2_FIELD_INTERLACED = `4`, / both fields interlaced /
95	V4L2_FIELD_SEQ_TB = `5`, / both fields sequential into one*
96	buffer, top-bottom order /*
97	V4L2_FIELD_SEQ_BT = `6`, / same as above + bottom-top order /
98	V4L2_FIELD_ALTERNATE = `7`, / both fields alternating into*
99	separate buffers /*
100	V4L2_FIELD_INTERLACED_TB = `8`, / both fields interlaced, top field*
101	first and the top field is
102	transmitted first /*
103	V4L2_FIELD_INTERLACED_BT = `9`, / both fields interlaced, top field*
104	first and the bottom field is
105	transmitted first /*
106	};
107	#define V4L2_FIELD_HAS_TOP(field) \
108	((field) == V4L2_FIELD_TOP \|\|\
109	(field) == V4L2_FIELD_INTERLACED \|\|\
110	(field) == V4L2_FIELD_INTERLACED_TB \|\|\
111	(field) == V4L2_FIELD_INTERLACED_BT \|\|\
112	(field) == V4L2_FIELD_SEQ_TB \|\|\
113	(field) == V4L2_FIELD_SEQ_BT)
114	#define V4L2_FIELD_HAS_BOTTOM(field) \
115	((field) == V4L2_FIELD_BOTTOM \|\|\
116	(field) == V4L2_FIELD_INTERLACED \|\|\
117	(field) == V4L2_FIELD_INTERLACED_TB \|\|\
118	(field) == V4L2_FIELD_INTERLACED_BT \|\|\
119	(field) == V4L2_FIELD_SEQ_TB \|\|\
120	(field) == V4L2_FIELD_SEQ_BT)
121	#define V4L2_FIELD_HAS_BOTH(field) \
122	((field) == V4L2_FIELD_INTERLACED \|\|\
123	(field) == V4L2_FIELD_INTERLACED_TB \|\|\
124	(field) == V4L2_FIELD_INTERLACED_BT \|\|\
125	(field) == V4L2_FIELD_SEQ_TB \|\|\
126	(field) == V4L2_FIELD_SEQ_BT)
127	#define V4L2_FIELD_HAS_T_OR_B(field) \
128	((field) == V4L2_FIELD_BOTTOM \|\|\
129	(field) == V4L2_FIELD_TOP \|\|\
130	(field) == V4L2_FIELD_ALTERNATE)
131
132	enum v4l2_buf_type {
133	V4L2_BUF_TYPE_VIDEO_CAPTURE = `1`,
134	V4L2_BUF_TYPE_VIDEO_OUTPUT = `2`,
135	V4L2_BUF_TYPE_VIDEO_OVERLAY = `3`,
136	V4L2_BUF_TYPE_VBI_CAPTURE = `4`,
137	V4L2_BUF_TYPE_VBI_OUTPUT = `5`,
138	V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = `6`,
139	V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = `7`,
140	V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = `8`,
141	V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = `9`,
142	V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE = `10`,
143	V4L2_BUF_TYPE_SDR_CAPTURE = `11`,
144	V4L2_BUF_TYPE_SDR_OUTPUT = `12`,
145	V4L2_BUF_TYPE_META_CAPTURE = `13`,
146	/ Deprecated, do not use /
147	V4L2_BUF_TYPE_PRIVATE = `0x80`,
148	};
149
150	#define V4L2_TYPE_IS_MULTIPLANAR(type) \
151	((type) == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE \
152	\|\| (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
153
154	#define V4L2_TYPE_IS_OUTPUT(type) \
155	((type) == V4L2_BUF_TYPE_VIDEO_OUTPUT \
156	\|\| (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE \
157	\|\| (type) == V4L2_BUF_TYPE_VIDEO_OVERLAY \
158	\|\| (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY \
159	\|\| (type) == V4L2_BUF_TYPE_VBI_OUTPUT \
160	\|\| (type) == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT \
161	\|\| (type) == V4L2_BUF_TYPE_SDR_OUTPUT)
162
163	enum v4l2_tuner_type {
164	V4L2_TUNER_RADIO = `1`,
165	V4L2_TUNER_ANALOG_TV = `2`,
166	V4L2_TUNER_DIGITAL_TV = `3`,
167	V4L2_TUNER_SDR = `4`,
168	V4L2_TUNER_RF = `5`,
169	};
170
171	/ Deprecated, do not use /
172	#define V4L2_TUNER_ADC V4L2_TUNER_SDR
173
174	enum v4l2_memory {
175	V4L2_MEMORY_MMAP = `1`,
176	V4L2_MEMORY_USERPTR = `2`,
177	V4L2_MEMORY_OVERLAY = `3`,
178	V4L2_MEMORY_DMABUF = `4`,
179	};
180
181	/ see also http://vektor.theorem.ca/graphics/ycbcr/ /
182	enum v4l2_colorspace {
183	/*
184	* Default colorspace, i.e. let the driver figure it out.
185	* Can only be used with video capture.
186	*/
187	V4L2_COLORSPACE_DEFAULT = `0`,
188
189	/ SMPTE 170M: used for broadcast NTSC/PAL SDTV /
190	V4L2_COLORSPACE_SMPTE170M = `1`,
191
192	/ Obsolete pre-1998 SMPTE 240M HDTV standard, superseded by Rec 709 /
193	V4L2_COLORSPACE_SMPTE240M = `2`,
194
195	/ Rec.709: used for HDTV /
196	V4L2_COLORSPACE_REC709 = `3`,
197
198	/*
199	* Deprecated, do not use. No driver will ever return this. This was
200	* based on a misunderstanding of the bt878 datasheet.
201	*/
202	V4L2_COLORSPACE_BT878 = `4`,
203
204	/*
205	* NTSC 1953 colorspace. This only makes sense when dealing with
206	* really, really old NTSC recordings. Superseded by SMPTE 170M.
207	*/
208	V4L2_COLORSPACE_470_SYSTEM_M = `5`,
209
210	/*
211	* EBU Tech 3213 PAL/SECAM colorspace. This only makes sense when
212	* dealing with really old PAL/SECAM recordings. Superseded by
213	* SMPTE 170M.
214	*/
215	V4L2_COLORSPACE_470_SYSTEM_BG = `6`,
216
217	/*
218	* Effectively shorthand for V4L2_COLORSPACE_SRGB, V4L2_YCBCR_ENC_601
219	* and V4L2_QUANTIZATION_FULL_RANGE. To be used for (Motion-)JPEG.
220	*/
221	V4L2_COLORSPACE_JPEG = `7`,
222
223	/ For RGB colorspaces such as produces by most webcams. /
224	V4L2_COLORSPACE_SRGB = `8`,
225
226	/ opRGB colorspace /
227	V4L2_COLORSPACE_OPRGB = `9`,
228
229	/ BT.2020 colorspace, used for UHDTV. /
230	V4L2_COLORSPACE_BT2020 = `10`,
231
232	/ Raw colorspace: for RAW unprocessed images /
233	V4L2_COLORSPACE_RAW = `11`,
234
235	/ DCI-P3 colorspace, used by cinema projectors /
236	V4L2_COLORSPACE_DCI_P3 = `12`,
237	};
238
239	/*
240	* Determine how COLORSPACE_DEFAULT should map to a proper colorspace.
241	* This depends on whether this is a SDTV image (use SMPTE 170M), an
242	* HDTV image (use Rec. 709), or something else (use sRGB).
243	*/
244	#define V4L2_MAP_COLORSPACE_DEFAULT(is_sdtv, is_hdtv) \
245	((is_sdtv) ? V4L2_COLORSPACE_SMPTE170M : \
246	((is_hdtv) ? V4L2_COLORSPACE_REC709 : V4L2_COLORSPACE_SRGB))
247
248	enum v4l2_xfer_func {
249	/*
250	* Mapping of V4L2_XFER_FUNC_DEFAULT to actual transfer functions
251	* for the various colorspaces:
252	*
253	* V4L2_COLORSPACE_SMPTE170M, V4L2_COLORSPACE_470_SYSTEM_M,
254	* V4L2_COLORSPACE_470_SYSTEM_BG, V4L2_COLORSPACE_REC709 and
255	* V4L2_COLORSPACE_BT2020: V4L2_XFER_FUNC_709
256	*
257	* V4L2_COLORSPACE_SRGB, V4L2_COLORSPACE_JPEG: V4L2_XFER_FUNC_SRGB
258	*
259	* V4L2_COLORSPACE_OPRGB: V4L2_XFER_FUNC_OPRGB
260	*
261	* V4L2_COLORSPACE_SMPTE240M: V4L2_XFER_FUNC_SMPTE240M
262	*
263	* V4L2_COLORSPACE_RAW: V4L2_XFER_FUNC_NONE
264	*
265	* V4L2_COLORSPACE_DCI_P3: V4L2_XFER_FUNC_DCI_P3
266	*/
267	V4L2_XFER_FUNC_DEFAULT = `0`,
268	V4L2_XFER_FUNC_709 = `1`,
269	V4L2_XFER_FUNC_SRGB = `2`,
270	V4L2_XFER_FUNC_OPRGB = `3`,
271	V4L2_XFER_FUNC_SMPTE240M = `4`,
272	V4L2_XFER_FUNC_NONE = `5`,
273	V4L2_XFER_FUNC_DCI_P3 = `6`,
274	V4L2_XFER_FUNC_SMPTE2084 = `7`,
275	};
276
277	/*
278	* Determine how XFER_FUNC_DEFAULT should map to a proper transfer function.
279	* This depends on the colorspace.
280	*/
281	#define V4L2_MAP_XFER_FUNC_DEFAULT(colsp) \
282	((colsp) == V4L2_COLORSPACE_OPRGB ? V4L2_XFER_FUNC_OPRGB : \
283	((colsp) == V4L2_COLORSPACE_SMPTE240M ? V4L2_XFER_FUNC_SMPTE240M : \
284	((colsp) == V4L2_COLORSPACE_DCI_P3 ? V4L2_XFER_FUNC_DCI_P3 : \
285	((colsp) == V4L2_COLORSPACE_RAW ? V4L2_XFER_FUNC_NONE : \
286	((colsp) == V4L2_COLORSPACE_SRGB \|\| (colsp) == V4L2_COLORSPACE_JPEG ? \
287	V4L2_XFER_FUNC_SRGB : V4L2_XFER_FUNC_709)))))
288
289	enum v4l2_ycbcr_encoding {
290	/*
291	* Mapping of V4L2_YCBCR_ENC_DEFAULT to actual encodings for the
292	* various colorspaces:
293	*
294	* V4L2_COLORSPACE_SMPTE170M, V4L2_COLORSPACE_470_SYSTEM_M,
295	* V4L2_COLORSPACE_470_SYSTEM_BG, V4L2_COLORSPACE_SRGB,
296	* V4L2_COLORSPACE_OPRGB and V4L2_COLORSPACE_JPEG: V4L2_YCBCR_ENC_601
297	*
298	* V4L2_COLORSPACE_REC709 and V4L2_COLORSPACE_DCI_P3: V4L2_YCBCR_ENC_709
299	*
300	* V4L2_COLORSPACE_BT2020: V4L2_YCBCR_ENC_BT2020
301	*
302	* V4L2_COLORSPACE_SMPTE240M: V4L2_YCBCR_ENC_SMPTE240M
303	*/
304	V4L2_YCBCR_ENC_DEFAULT = `0`,
305
306	/ ITU-R 601 -- SDTV /
307	V4L2_YCBCR_ENC_601 = `1`,
308
309	/ Rec. 709 -- HDTV /
310	V4L2_YCBCR_ENC_709 = `2`,
311
312	/ ITU-R 601/EN 61966-2-4 Extended Gamut -- SDTV /
313	V4L2_YCBCR_ENC_XV601 = `3`,
314
315	/ Rec. 709/EN 61966-2-4 Extended Gamut -- HDTV /
316	V4L2_YCBCR_ENC_XV709 = `4`,
317
318	/*
319	* sYCC (Y'CbCr encoding of sRGB), identical to ENC_601. It was added
320	* originally due to a misunderstanding of the sYCC standard. It should
321	* not be used, instead use V4L2_YCBCR_ENC_601.
322	*/
323	V4L2_YCBCR_ENC_SYCC = `5`,
324
325	/ BT.2020 Non-constant Luminance Y'CbCr /
326	V4L2_YCBCR_ENC_BT2020 = `6`,
327
328	/ BT.2020 Constant Luminance Y'CbcCrc /
329	V4L2_YCBCR_ENC_BT2020_CONST_LUM = `7`,
330
331	/ SMPTE 240M -- Obsolete HDTV /
332	V4L2_YCBCR_ENC_SMPTE240M = `8`,
333	};
334
335	/*
336	* enum v4l2_hsv_encoding values should not collide with the ones from
337	* enum v4l2_ycbcr_encoding.
338	*/
339	enum v4l2_hsv_encoding {
340
341	/ Hue mapped to 0 - 179 /
342	V4L2_HSV_ENC_180 = `128`,
343
344	/ Hue mapped to 0-255 /
345	V4L2_HSV_ENC_256 = `129`,
346	};
347
348	/*
349	* Determine how YCBCR_ENC_DEFAULT should map to a proper Y'CbCr encoding.
350	* This depends on the colorspace.
351	*/
352	#define V4L2_MAP_YCBCR_ENC_DEFAULT(colsp) \
353	(((colsp) == V4L2_COLORSPACE_REC709 \|\| \
354	(colsp) == V4L2_COLORSPACE_DCI_P3) ? V4L2_YCBCR_ENC_709 : \
355	((colsp) == V4L2_COLORSPACE_BT2020 ? V4L2_YCBCR_ENC_BT2020 : \
356	((colsp) == V4L2_COLORSPACE_SMPTE240M ? V4L2_YCBCR_ENC_SMPTE240M : \
357	V4L2_YCBCR_ENC_601)))
358
359	enum v4l2_quantization {
360	/*
361	* The default for R'G'B' quantization is always full range, except
362	* for the BT2020 colorspace. For Y'CbCr the quantization is always
363	* limited range, except for COLORSPACE_JPEG: this is full range.
364	*/
365	V4L2_QUANTIZATION_DEFAULT = `0`,
366	V4L2_QUANTIZATION_FULL_RANGE = `1`,
367	V4L2_QUANTIZATION_LIM_RANGE = `2`,
368	};
369
370	/*
371	* Determine how QUANTIZATION_DEFAULT should map to a proper quantization.
372	* This depends on whether the image is RGB or not, the colorspace and the
373	* Y'CbCr encoding.
374	*/
375	#define V4L2_MAP_QUANTIZATION_DEFAULT(is_rgb_or_hsv, colsp, ycbcr_enc) \
376	(((is_rgb_or_hsv) && (colsp) == V4L2_COLORSPACE_BT2020) ? \
377	V4L2_QUANTIZATION_LIM_RANGE : \
378	(((is_rgb_or_hsv) \|\| (colsp) == V4L2_COLORSPACE_JPEG) ? \
379	V4L2_QUANTIZATION_FULL_RANGE : V4L2_QUANTIZATION_LIM_RANGE))
380
381	/*
382	* Deprecated names for opRGB colorspace (IEC 61966-2-5)
383	*
384	* WARNING: Please don't use these deprecated defines in your code, as
385	* there is a chance we have to remove them in the future.
386	*/
387	#define V4L2_COLORSPACE_ADOBERGB V4L2_COLORSPACE_OPRGB
388	#define V4L2_XFER_FUNC_ADOBERGB V4L2_XFER_FUNC_OPRGB
389
390	enum v4l2_priority {
391	V4L2_PRIORITY_UNSET = `0`, / not initialized /
392	V4L2_PRIORITY_BACKGROUND = `1`,
393	V4L2_PRIORITY_INTERACTIVE = `2`,
394	V4L2_PRIORITY_RECORD = `3`,
395	V4L2_PRIORITY_DEFAULT = V4L2_PRIORITY_INTERACTIVE,
396	};
397
398	struct v4l2_rect {
399	__s32 left;
400	__s32 top;
401	__u32 width;
402	__u32 height;
403	};
404
405	struct v4l2_fract {
406	__u32 numerator;
407	__u32 denominator;
408	};
409
410	/**
411	* struct v4l2_capability - Describes V4L2 device caps returned by VIDIOC_QUERYCAP
412	*
413	* @driver: name of the driver module (e.g. "bttv")
414	* @card: name of the card (e.g. "Hauppauge WinTV")
415	* @bus_info: name of the bus (e.g. "PCI:" + pci_name(pci_dev) )
416	* @version: KERNEL_VERSION
417	* @capabilities: capabilities of the physical device as a whole
418	* @device_caps: capabilities accessed via this particular device (node)
419	* @reserved: reserved fields for future extensions
420	*/
421	struct v4l2_capability {
422	__u8 driver[`16`];
423	__u8 card[`32`];
424	__u8 bus_info[`32`];
425	__u32 version;
426	__u32 capabilities;
427	__u32 device_caps;
428	__u32 reserved[`3`];
429	};
430
431	/ Values for 'capabilities' field /
432	#define V4L2_CAP_VIDEO_CAPTURE 0x00000001 /* Is a video capture device */
433	#define V4L2_CAP_VIDEO_OUTPUT 0x00000002 /* Is a video output device */
434	#define V4L2_CAP_VIDEO_OVERLAY 0x00000004 /* Can do video overlay */
435	#define V4L2_CAP_VBI_CAPTURE 0x00000010 /* Is a raw VBI capture device */
436	#define V4L2_CAP_VBI_OUTPUT 0x00000020 /* Is a raw VBI output device */
437	#define V4L2_CAP_SLICED_VBI_CAPTURE 0x00000040 /* Is a sliced VBI capture device */
438	#define V4L2_CAP_SLICED_VBI_OUTPUT 0x00000080 /* Is a sliced VBI output device */
439	#define V4L2_CAP_RDS_CAPTURE 0x00000100 /* RDS data capture */
440	#define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200 /* Can do video output overlay */
441	#define V4L2_CAP_HW_FREQ_SEEK 0x00000400 /* Can do hardware frequency seek */
442	#define V4L2_CAP_RDS_OUTPUT 0x00000800 /* Is an RDS encoder */
443
444	/ Is a video capture device that supports multiplanar formats /
445	#define V4L2_CAP_VIDEO_CAPTURE_MPLANE 0x00001000
446	/ Is a video output device that supports multiplanar formats /
447	#define V4L2_CAP_VIDEO_OUTPUT_MPLANE 0x00002000
448	/ Is a video mem-to-mem device that supports multiplanar formats /
449	#define V4L2_CAP_VIDEO_M2M_MPLANE 0x00004000
450	/ Is a video mem-to-mem device /
451	#define V4L2_CAP_VIDEO_M2M 0x00008000
452
453	#define V4L2_CAP_TUNER 0x00010000 /* has a tuner */
454	#define V4L2_CAP_AUDIO 0x00020000 /* has audio support */
455	#define V4L2_CAP_RADIO 0x00040000 /* is a radio device */
456	#define V4L2_CAP_MODULATOR 0x00080000 /* has a modulator */
457
458	#define V4L2_CAP_SDR_CAPTURE 0x00100000 /* Is a SDR capture device */
459	#define V4L2_CAP_EXT_PIX_FORMAT 0x00200000 /* Supports the extended pixel format */
460	#define V4L2_CAP_SDR_OUTPUT 0x00400000 /* Is a SDR output device */
461	#define V4L2_CAP_META_CAPTURE 0x00800000 /* Is a metadata capture device */
462
463	#define V4L2_CAP_READWRITE 0x01000000 /* read/write systemcalls */
464	#define V4L2_CAP_ASYNCIO 0x02000000 /* async I/O */
465	#define V4L2_CAP_STREAMING 0x04000000 /* streaming I/O ioctls */
466
467	#define V4L2_CAP_TOUCH 0x10000000 /* Is a touch device */
468
469	#define V4L2_CAP_DEVICE_CAPS 0x80000000 /* sets device capabilities field */
470
471	/*
472	* V I D E O I M A G E F O R M A T
473	*/
474	struct v4l2_pix_format {
475	__u32 width;
476	__u32 height;
477	__u32 pixelformat;
478	__u32 field; / enum v4l2_field /
479	__u32 bytesperline; / for padding, zero if unused /
480	__u32 sizeimage;
481	__u32 colorspace; / enum v4l2_colorspace /
482	__u32 priv; / private data, depends on pixelformat /
483	__u32 flags; / format flags (V4L2_PIX_FMT_FLAG_) /*
484	union {
485	/ enum v4l2_ycbcr_encoding /
486	__u32 ycbcr_enc;
487	/ enum v4l2_hsv_encoding /
488	__u32 hsv_enc;
489	};
490	__u32 quantization; / enum v4l2_quantization /
491	__u32 xfer_func; / enum v4l2_xfer_func /
492	};
493
494	/ Pixel format FOURCC depth Description /
495
496	/ RGB formats /
497	#define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R', 'G', 'B', '1') /* 8 RGB-3-3-2 */
498	#define V4L2_PIX_FMT_RGB444 v4l2_fourcc('R', '4', '4', '4') /* 16 xxxxrrrr ggggbbbb */
499	#define V4L2_PIX_FMT_ARGB444 v4l2_fourcc('A', 'R', '1', '2') /* 16 aaaarrrr ggggbbbb */
500	#define V4L2_PIX_FMT_XRGB444 v4l2_fourcc('X', 'R', '1', '2') /* 16 xxxxrrrr ggggbbbb */
501	#define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R', 'G', 'B', 'O') /* 16 RGB-5-5-5 */
502	#define V4L2_PIX_FMT_ARGB555 v4l2_fourcc('A', 'R', '1', '5') /* 16 ARGB-1-5-5-5 */
503	#define V4L2_PIX_FMT_XRGB555 v4l2_fourcc('X', 'R', '1', '5') /* 16 XRGB-1-5-5-5 */
504	#define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R', 'G', 'B', 'P') /* 16 RGB-5-6-5 */
505	#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R', 'G', 'B', 'Q') /* 16 RGB-5-5-5 BE */
506	#define V4L2_PIX_FMT_ARGB555X v4l2_fourcc_be('A', 'R', '1', '5') /* 16 ARGB-5-5-5 BE */
507	#define V4L2_PIX_FMT_XRGB555X v4l2_fourcc_be('X', 'R', '1', '5') /* 16 XRGB-5-5-5 BE */
508	#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R', 'G', 'B', 'R') /* 16 RGB-5-6-5 BE */
509	#define V4L2_PIX_FMT_BGR666 v4l2_fourcc('B', 'G', 'R', 'H') /* 18 BGR-6-6-6 */
510	#define V4L2_PIX_FMT_BGR24 v4l2_fourcc('B', 'G', 'R', '3') /* 24 BGR-8-8-8 */
511	#define V4L2_PIX_FMT_RGB24 v4l2_fourcc('R', 'G', 'B', '3') /* 24 RGB-8-8-8 */
512	#define V4L2_PIX_FMT_BGR32 v4l2_fourcc('B', 'G', 'R', '4') /* 32 BGR-8-8-8-8 */
513	#define V4L2_PIX_FMT_ABGR32 v4l2_fourcc('A', 'R', '2', '4') /* 32 BGRA-8-8-8-8 */
514	#define V4L2_PIX_FMT_XBGR32 v4l2_fourcc('X', 'R', '2', '4') /* 32 BGRX-8-8-8-8 */
515	#define V4L2_PIX_FMT_RGB32 v4l2_fourcc('R', 'G', 'B', '4') /* 32 RGB-8-8-8-8 */
516	#define V4L2_PIX_FMT_ARGB32 v4l2_fourcc('B', 'A', '2', '4') /* 32 ARGB-8-8-8-8 */
517	#define V4L2_PIX_FMT_XRGB32 v4l2_fourcc('B', 'X', '2', '4') /* 32 XRGB-8-8-8-8 */
518
519	/ Grey formats /
520	#define V4L2_PIX_FMT_GREY v4l2_fourcc('G', 'R', 'E', 'Y') /* 8 Greyscale */
521	#define V4L2_PIX_FMT_Y4 v4l2_fourcc('Y', '0', '4', ' ') /* 4 Greyscale */
522	#define V4L2_PIX_FMT_Y6 v4l2_fourcc('Y', '0', '6', ' ') /* 6 Greyscale */
523	#define V4L2_PIX_FMT_Y10 v4l2_fourcc('Y', '1', '0', ' ') /* 10 Greyscale */
524	#define V4L2_PIX_FMT_Y12 v4l2_fourcc('Y', '1', '2', ' ') /* 12 Greyscale */
525	#define V4L2_PIX_FMT_Y16 v4l2_fourcc('Y', '1', '6', ' ') /* 16 Greyscale */
526	#define V4L2_PIX_FMT_Y16_BE v4l2_fourcc_be('Y', '1', '6', ' ') /* 16 Greyscale BE */
527
528	/ Grey bit-packed formats /
529	#define V4L2_PIX_FMT_Y10BPACK v4l2_fourcc('Y', '1', '0', 'B') /* 10 Greyscale bit-packed */
530
531	/ Palette formats /
532	#define V4L2_PIX_FMT_PAL8 v4l2_fourcc('P', 'A', 'L', '8') /* 8 8-bit palette */
533
534	/ Chrominance formats /
535	#define V4L2_PIX_FMT_UV8 v4l2_fourcc('U', 'V', '8', ' ') /* 8 UV 4:4 */
536
537	/ Luminance+Chrominance formats /
538	#define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y', 'U', 'Y', 'V') /* 16 YUV 4:2:2 */
539	#define V4L2_PIX_FMT_YYUV v4l2_fourcc('Y', 'Y', 'U', 'V') /* 16 YUV 4:2:2 */
540	#define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */
541	#define V4L2_PIX_FMT_UYVY v4l2_fourcc('U', 'Y', 'V', 'Y') /* 16 YUV 4:2:2 */
542	#define V4L2_PIX_FMT_VYUY v4l2_fourcc('V', 'Y', 'U', 'Y') /* 16 YUV 4:2:2 */
543	#define V4L2_PIX_FMT_Y41P v4l2_fourcc('Y', '4', '1', 'P') /* 12 YUV 4:1:1 */
544	#define V4L2_PIX_FMT_YUV444 v4l2_fourcc('Y', '4', '4', '4') /* 16 xxxxyyyy uuuuvvvv */
545	#define V4L2_PIX_FMT_YUV555 v4l2_fourcc('Y', 'U', 'V', 'O') /* 16 YUV-5-5-5 */
546	#define V4L2_PIX_FMT_YUV565 v4l2_fourcc('Y', 'U', 'V', 'P') /* 16 YUV-5-6-5 */
547	#define V4L2_PIX_FMT_YUV32 v4l2_fourcc('Y', 'U', 'V', '4') /* 32 YUV-8-8-8-8 */
548	#define V4L2_PIX_FMT_HI240 v4l2_fourcc('H', 'I', '2', '4') /* 8 8-bit color */
549	#define V4L2_PIX_FMT_HM12 v4l2_fourcc('H', 'M', '1', '2') /* 8 YUV 4:2:0 16x16 macroblocks */
550	#define V4L2_PIX_FMT_M420 v4l2_fourcc('M', '4', '2', '0') /* 12 YUV 4:2:0 2 lines y, 1 line uv interleaved */
551
552	/ two planes -- one Y, one Cr + Cb interleaved /
553	#define V4L2_PIX_FMT_NV12 v4l2_fourcc('N', 'V', '1', '2') /* 12 Y/CbCr 4:2:0 */
554	#define V4L2_PIX_FMT_NV21 v4l2_fourcc('N', 'V', '2', '1') /* 12 Y/CrCb 4:2:0 */
555	#define V4L2_PIX_FMT_NV16 v4l2_fourcc('N', 'V', '1', '6') /* 16 Y/CbCr 4:2:2 */
556	#define V4L2_PIX_FMT_NV61 v4l2_fourcc('N', 'V', '6', '1') /* 16 Y/CrCb 4:2:2 */
557	#define V4L2_PIX_FMT_NV24 v4l2_fourcc('N', 'V', '2', '4') /* 24 Y/CbCr 4:4:4 */
558	#define V4L2_PIX_FMT_NV42 v4l2_fourcc('N', 'V', '4', '2') /* 24 Y/CrCb 4:4:4 */
559
560	/ two non contiguous planes - one Y, one Cr + Cb interleaved /
561	#define V4L2_PIX_FMT_NV12M v4l2_fourcc('N', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 */
562	#define V4L2_PIX_FMT_NV21M v4l2_fourcc('N', 'M', '2', '1') /* 21 Y/CrCb 4:2:0 */
563	#define V4L2_PIX_FMT_NV16M v4l2_fourcc('N', 'M', '1', '6') /* 16 Y/CbCr 4:2:2 */
564	#define V4L2_PIX_FMT_NV61M v4l2_fourcc('N', 'M', '6', '1') /* 16 Y/CrCb 4:2:2 */
565	#define V4L2_PIX_FMT_NV12MT v4l2_fourcc('T', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 64x32 macroblocks */
566	#define V4L2_PIX_FMT_NV12MT_16X16 v4l2_fourcc('V', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 16x16 macroblocks */
567
568	/ three planes - Y Cb, Cr /
569	#define V4L2_PIX_FMT_YUV410 v4l2_fourcc('Y', 'U', 'V', '9') /* 9 YUV 4:1:0 */
570	#define V4L2_PIX_FMT_YVU410 v4l2_fourcc('Y', 'V', 'U', '9') /* 9 YVU 4:1:0 */
571	#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4', '1', '1', 'P') /* 12 YVU411 planar */
572	#define V4L2_PIX_FMT_YUV420 v4l2_fourcc('Y', 'U', '1', '2') /* 12 YUV 4:2:0 */
573	#define V4L2_PIX_FMT_YVU420 v4l2_fourcc('Y', 'V', '1', '2') /* 12 YVU 4:2:0 */
574	#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4', '2', '2', 'P') /* 16 YVU422 planar */
575
576	/ three non contiguous planes - Y, Cb, Cr /
577	#define V4L2_PIX_FMT_YUV420M v4l2_fourcc('Y', 'M', '1', '2') /* 12 YUV420 planar */
578	#define V4L2_PIX_FMT_YVU420M v4l2_fourcc('Y', 'M', '2', '1') /* 12 YVU420 planar */
579	#define V4L2_PIX_FMT_YUV422M v4l2_fourcc('Y', 'M', '1', '6') /* 16 YUV422 planar */
580	#define V4L2_PIX_FMT_YVU422M v4l2_fourcc('Y', 'M', '6', '1') /* 16 YVU422 planar */
581	#define V4L2_PIX_FMT_YUV444M v4l2_fourcc('Y', 'M', '2', '4') /* 24 YUV444 planar */
582	#define V4L2_PIX_FMT_YVU444M v4l2_fourcc('Y', 'M', '4', '2') /* 24 YVU444 planar */
583
584	/ Bayer formats - see http://www.siliconimaging.com/RGB%20Bayer.htm /
585	#define V4L2_PIX_FMT_SBGGR8 v4l2_fourcc('B', 'A', '8', '1') /* 8 BGBG.. GRGR.. */
586	#define V4L2_PIX_FMT_SGBRG8 v4l2_fourcc('G', 'B', 'R', 'G') /* 8 GBGB.. RGRG.. */
587	#define V4L2_PIX_FMT_SGRBG8 v4l2_fourcc('G', 'R', 'B', 'G') /* 8 GRGR.. BGBG.. */
588	#define V4L2_PIX_FMT_SRGGB8 v4l2_fourcc('R', 'G', 'G', 'B') /* 8 RGRG.. GBGB.. */
589	#define V4L2_PIX_FMT_SBGGR10 v4l2_fourcc('B', 'G', '1', '0') /* 10 BGBG.. GRGR.. */
590	#define V4L2_PIX_FMT_SGBRG10 v4l2_fourcc('G', 'B', '1', '0') /* 10 GBGB.. RGRG.. */
591	#define V4L2_PIX_FMT_SGRBG10 v4l2_fourcc('B', 'A', '1', '0') /* 10 GRGR.. BGBG.. */
592	#define V4L2_PIX_FMT_SRGGB10 v4l2_fourcc('R', 'G', '1', '0') /* 10 RGRG.. GBGB.. */
593	/ 10bit raw bayer packed, 5 bytes for every 4 pixels /
594	#define V4L2_PIX_FMT_SBGGR10P v4l2_fourcc('p', 'B', 'A', 'A')
595	#define V4L2_PIX_FMT_SGBRG10P v4l2_fourcc('p', 'G', 'A', 'A')
596	#define V4L2_PIX_FMT_SGRBG10P v4l2_fourcc('p', 'g', 'A', 'A')
597	#define V4L2_PIX_FMT_SRGGB10P v4l2_fourcc('p', 'R', 'A', 'A')
598	/ 10bit raw bayer a-law compressed to 8 bits /
599	#define V4L2_PIX_FMT_SBGGR10ALAW8 v4l2_fourcc('a', 'B', 'A', '8')
600	#define V4L2_PIX_FMT_SGBRG10ALAW8 v4l2_fourcc('a', 'G', 'A', '8')
601	#define V4L2_PIX_FMT_SGRBG10ALAW8 v4l2_fourcc('a', 'g', 'A', '8')
602	#define V4L2_PIX_FMT_SRGGB10ALAW8 v4l2_fourcc('a', 'R', 'A', '8')
603	/ 10bit raw bayer DPCM compressed to 8 bits /
604	#define V4L2_PIX_FMT_SBGGR10DPCM8 v4l2_fourcc('b', 'B', 'A', '8')
605	#define V4L2_PIX_FMT_SGBRG10DPCM8 v4l2_fourcc('b', 'G', 'A', '8')
606	#define V4L2_PIX_FMT_SGRBG10DPCM8 v4l2_fourcc('B', 'D', '1', '0')
607	#define V4L2_PIX_FMT_SRGGB10DPCM8 v4l2_fourcc('b', 'R', 'A', '8')
608	#define V4L2_PIX_FMT_SBGGR12 v4l2_fourcc('B', 'G', '1', '2') /* 12 BGBG.. GRGR.. */
609	#define V4L2_PIX_FMT_SGBRG12 v4l2_fourcc('G', 'B', '1', '2') /* 12 GBGB.. RGRG.. */
610	#define V4L2_PIX_FMT_SGRBG12 v4l2_fourcc('B', 'A', '1', '2') /* 12 GRGR.. BGBG.. */
611	#define V4L2_PIX_FMT_SRGGB12 v4l2_fourcc('R', 'G', '1', '2') /* 12 RGRG.. GBGB.. */
612	/ 12bit raw bayer packed, 6 bytes for every 4 pixels /
613	#define V4L2_PIX_FMT_SBGGR12P v4l2_fourcc('p', 'B', 'C', 'C')
614	#define V4L2_PIX_FMT_SGBRG12P v4l2_fourcc('p', 'G', 'C', 'C')
615	#define V4L2_PIX_FMT_SGRBG12P v4l2_fourcc('p', 'g', 'C', 'C')
616	#define V4L2_PIX_FMT_SRGGB12P v4l2_fourcc('p', 'R', 'C', 'C')
617	#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B', 'Y', 'R', '2') /* 16 BGBG.. GRGR.. */
618	#define V4L2_PIX_FMT_SGBRG16 v4l2_fourcc('G', 'B', '1', '6') /* 16 GBGB.. RGRG.. */
619	#define V4L2_PIX_FMT_SGRBG16 v4l2_fourcc('G', 'R', '1', '6') /* 16 GRGR.. BGBG.. */
620	#define V4L2_PIX_FMT_SRGGB16 v4l2_fourcc('R', 'G', '1', '6') /* 16 RGRG.. GBGB.. */
621
622	/ HSV formats /
623	#define V4L2_PIX_FMT_HSV24 v4l2_fourcc('H', 'S', 'V', '3')
624	#define V4L2_PIX_FMT_HSV32 v4l2_fourcc('H', 'S', 'V', '4')
625
626	/ compressed formats /
627	#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG */
628	#define V4L2_PIX_FMT_JPEG v4l2_fourcc('J', 'P', 'E', 'G') /* JFIF JPEG */
629	#define V4L2_PIX_FMT_DV v4l2_fourcc('d', 'v', 's', 'd') /* 1394 */
630	#define V4L2_PIX_FMT_MPEG v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4 Multiplexed */
631	#define V4L2_PIX_FMT_H264 v4l2_fourcc('H', '2', '6', '4') /* H264 with start codes */
632	#define V4L2_PIX_FMT_H264_NO_SC v4l2_fourcc('A', 'V', 'C', '1') /* H264 without start codes */
633	#define V4L2_PIX_FMT_H264_MVC v4l2_fourcc('M', '2', '6', '4') /* H264 MVC */
634	#define V4L2_PIX_FMT_H263 v4l2_fourcc('H', '2', '6', '3') /* H263 */
635	#define V4L2_PIX_FMT_MPEG1 v4l2_fourcc('M', 'P', 'G', '1') /* MPEG-1 ES */
636	#define V4L2_PIX_FMT_MPEG2 v4l2_fourcc('M', 'P', 'G', '2') /* MPEG-2 ES */
637	#define V4L2_PIX_FMT_MPEG4 v4l2_fourcc('M', 'P', 'G', '4') /* MPEG-4 part 2 ES */
638	#define V4L2_PIX_FMT_XVID v4l2_fourcc('X', 'V', 'I', 'D') /* Xvid */
639	#define V4L2_PIX_FMT_VC1_ANNEX_G v4l2_fourcc('V', 'C', '1', 'G') /* SMPTE 421M Annex G compliant stream */
640	#define V4L2_PIX_FMT_VC1_ANNEX_L v4l2_fourcc('V', 'C', '1', 'L') /* SMPTE 421M Annex L compliant stream */
641	#define V4L2_PIX_FMT_VP8 v4l2_fourcc('V', 'P', '8', '0') /* VP8 */
642	#define V4L2_PIX_FMT_VP9 v4l2_fourcc('V', 'P', '9', '0') /* VP9 */
643
644	/ Vendor-specific formats /
645	#define V4L2_PIX_FMT_CPIA1 v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */
646	#define V4L2_PIX_FMT_WNVA v4l2_fourcc('W', 'N', 'V', 'A') /* Winnov hw compress */
647	#define V4L2_PIX_FMT_SN9C10X v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */
648	#define V4L2_PIX_FMT_SN9C20X_I420 v4l2_fourcc('S', '9', '2', '0') /* SN9C20x YUV 4:2:0 */
649	#define V4L2_PIX_FMT_PWC1 v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam */
650	#define V4L2_PIX_FMT_PWC2 v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam */
651	#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E', '6', '2', '5') /* ET61X251 compression */
652	#define V4L2_PIX_FMT_SPCA501 v4l2_fourcc('S', '5', '0', '1') /* YUYV per line */
653	#define V4L2_PIX_FMT_SPCA505 v4l2_fourcc('S', '5', '0', '5') /* YYUV per line */
654	#define V4L2_PIX_FMT_SPCA508 v4l2_fourcc('S', '5', '0', '8') /* YUVY per line */
655	#define V4L2_PIX_FMT_SPCA561 v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */
656	#define V4L2_PIX_FMT_PAC207 v4l2_fourcc('P', '2', '0', '7') /* compressed BGGR bayer */
657	#define V4L2_PIX_FMT_MR97310A v4l2_fourcc('M', '3', '1', '0') /* compressed BGGR bayer */
658	#define V4L2_PIX_FMT_JL2005BCD v4l2_fourcc('J', 'L', '2', '0') /* compressed RGGB bayer */
659	#define V4L2_PIX_FMT_SN9C2028 v4l2_fourcc('S', 'O', 'N', 'X') /* compressed GBRG bayer */
660	#define V4L2_PIX_FMT_SQ905C v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */
661	#define V4L2_PIX_FMT_PJPG v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */
662	#define V4L2_PIX_FMT_OV511 v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */
663	#define V4L2_PIX_FMT_OV518 v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */
664	#define V4L2_PIX_FMT_STV0680 v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer */
665	#define V4L2_PIX_FMT_TM6000 v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 */
666	#define V4L2_PIX_FMT_CIT_YYVYUY v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY */
667	#define V4L2_PIX_FMT_KONICA420 v4l2_fourcc('K', 'O', 'N', 'I') /* YUV420 planar in blocks of 256 pixels */
668	#define V4L2_PIX_FMT_JPGL v4l2_fourcc('J', 'P', 'G', 'L') /* JPEG-Lite */
669	#define V4L2_PIX_FMT_SE401 v4l2_fourcc('S', '4', '0', '1') /* se401 janggu compressed rgb */
670	#define V4L2_PIX_FMT_S5C_UYVY_JPG v4l2_fourcc('S', '5', 'C', 'I') /* S5C73M3 interleaved UYVY/JPEG */
671	#define V4L2_PIX_FMT_Y8I v4l2_fourcc('Y', '8', 'I', ' ') /* Greyscale 8-bit L/R interleaved */
672	#define V4L2_PIX_FMT_Y12I v4l2_fourcc('Y', '1', '2', 'I') /* Greyscale 12-bit L/R interleaved */
673	#define V4L2_PIX_FMT_Z16 v4l2_fourcc('Z', '1', '6', ' ') /* Depth data 16-bit */
674	#define V4L2_PIX_FMT_MT21C v4l2_fourcc('M', 'T', '2', '1') /* Mediatek compressed block mode */
675	#define V4L2_PIX_FMT_INZI v4l2_fourcc('I', 'N', 'Z', 'I') /* Intel Planar Greyscale 10-bit and Depth 16-bit */
676
677	/ SDR formats - used only for Software Defined Radio devices /
678	#define V4L2_SDR_FMT_CU8 v4l2_fourcc('C', 'U', '0', '8') /* IQ u8 */
679	#define V4L2_SDR_FMT_CU16LE v4l2_fourcc('C', 'U', '1', '6') /* IQ u16le */
680	#define V4L2_SDR_FMT_CS8 v4l2_fourcc('C', 'S', '0', '8') /* complex s8 */
681	#define V4L2_SDR_FMT_CS14LE v4l2_fourcc('C', 'S', '1', '4') /* complex s14le */
682	#define V4L2_SDR_FMT_RU12LE v4l2_fourcc('R', 'U', '1', '2') /* real u12le */
683	#define V4L2_SDR_FMT_PCU16BE v4l2_fourcc('P', 'C', '1', '6') /* planar complex u16be */
684	#define V4L2_SDR_FMT_PCU18BE v4l2_fourcc('P', 'C', '1', '8') /* planar complex u18be */
685	#define V4L2_SDR_FMT_PCU20BE v4l2_fourcc('P', 'C', '2', '0') /* planar complex u20be */
686
687	/ Touch formats - used for Touch devices /
688	#define V4L2_TCH_FMT_DELTA_TD16 v4l2_fourcc('T', 'D', '1', '6') /* 16-bit signed deltas */
689	#define V4L2_TCH_FMT_DELTA_TD08 v4l2_fourcc('T', 'D', '0', '8') /* 8-bit signed deltas */
690	#define V4L2_TCH_FMT_TU16 v4l2_fourcc('T', 'U', '1', '6') /* 16-bit unsigned touch data */
691	#define V4L2_TCH_FMT_TU08 v4l2_fourcc('T', 'U', '0', '8') /* 8-bit unsigned touch data */
692
693	/ Meta-data formats /
694	#define V4L2_META_FMT_VSP1_HGO v4l2_fourcc('V', 'S', 'P', 'H') /* R-Car VSP1 1-D Histogram */
695	#define V4L2_META_FMT_VSP1_HGT v4l2_fourcc('V', 'S', 'P', 'T') /* R-Car VSP1 2-D Histogram */
696
697	/ priv field value to indicates that subsequent fields are valid. /
698	#define V4L2_PIX_FMT_PRIV_MAGIC 0xfeedcafe
699
700	/ Flags /
701	#define V4L2_PIX_FMT_FLAG_PREMUL_ALPHA 0x00000001
702
703	/*
704	* F O R M A T E N U M E R A T I O N
705	*/
706	struct v4l2_fmtdesc {
707	__u32 index; / Format number /
708	__u32 type; / enum v4l2_buf_type /
709	__u32 flags;
710	__u8 description[`32`]; / Description string /
711	__u32 pixelformat; / Format fourcc /
712	__u32 reserved[`4`];
713	};
714
715	#define V4L2_FMT_FLAG_COMPRESSED 0x0001
716	#define V4L2_FMT_FLAG_EMULATED 0x0002
717
718	/ Frame Size and frame rate enumeration /
719	/*
720	* F R A M E S I Z E E N U M E R A T I O N
721	*/
722	enum v4l2_frmsizetypes {
723	V4L2_FRMSIZE_TYPE_DISCRETE = `1`,
724	V4L2_FRMSIZE_TYPE_CONTINUOUS = `2`,
725	V4L2_FRMSIZE_TYPE_STEPWISE = `3`,
726	};
727
728	struct v4l2_frmsize_discrete {
729	__u32 width; / Frame width [pixel] /
730	__u32 height; / Frame height [pixel] /
731	};
732
733	struct v4l2_frmsize_stepwise {
734	__u32 min_width; / Minimum frame width [pixel] /
735	__u32 max_width; / Maximum frame width [pixel] /
736	__u32 step_width; / Frame width step size [pixel] /
737	__u32 min_height; / Minimum frame height [pixel] /
738	__u32 max_height; / Maximum frame height [pixel] /
739	__u32 step_height; / Frame height step size [pixel] /
740	};
741
742	struct v4l2_frmsizeenum {
743	__u32 index; / Frame size number /
744	__u32 pixel_format; / Pixel format /
745	__u32 type; / Frame size type the device supports. /
746
747	union { / Frame size /
748	struct v4l2_frmsize_discrete discrete;
749	struct v4l2_frmsize_stepwise stepwise;
750	};
751
752	__u32 reserved[`2`]; / Reserved space for future use /
753	};
754
755	/*
756	* F R A M E R A T E E N U M E R A T I O N
757	*/
758	enum v4l2_frmivaltypes {
759	V4L2_FRMIVAL_TYPE_DISCRETE = `1`,
760	V4L2_FRMIVAL_TYPE_CONTINUOUS = `2`,
761	V4L2_FRMIVAL_TYPE_STEPWISE = `3`,
762	};
763
764	struct v4l2_frmival_stepwise {
765	struct v4l2_fract min; / Minimum frame interval [s] /
766	struct v4l2_fract max; / Maximum frame interval [s] /
767	struct v4l2_fract step; / Frame interval step size [s] /
768	};
769
770	struct v4l2_frmivalenum {
771	__u32 index; / Frame format index /
772	__u32 pixel_format; / Pixel format /
773	__u32 width; / Frame width /
774	__u32 height; / Frame height /
775	__u32 type; / Frame interval type the device supports. /
776
777	union { / Frame interval /
778	struct v4l2_fract discrete;
779	struct v4l2_frmival_stepwise stepwise;
780	};
781
782	__u32 reserved[`2`]; / Reserved space for future use /
783	};
784
785	/*
786	* T I M E C O D E
787	*/
788	struct v4l2_timecode {
789	__u32 type;
790	__u32 flags;
791	__u8 frames;
792	__u8 seconds;
793	__u8 minutes;
794	__u8 hours;
795	__u8 userbits[`4`];
796	};
797
798	/ Type /
799	#define V4L2_TC_TYPE_24FPS 1
800	#define V4L2_TC_TYPE_25FPS 2
801	#define V4L2_TC_TYPE_30FPS 3
802	#define V4L2_TC_TYPE_50FPS 4
803	#define V4L2_TC_TYPE_60FPS 5
804
805	/ Flags /
806	#define V4L2_TC_FLAG_DROPFRAME 0x0001 /* "drop-frame" mode */
807	#define V4L2_TC_FLAG_COLORFRAME 0x0002
808	#define V4L2_TC_USERBITS_field 0x000C
809	#define V4L2_TC_USERBITS_USERDEFINED 0x0000
810	#define V4L2_TC_USERBITS_8BITCHARS 0x0008
811	/ The above is based on SMPTE timecodes /
812
813	struct v4l2_jpegcompression {
814	int quality;
815
816	int APPn; / Number of APP segment to be written,*
817	* must be 0..15 */
818	int APP_len; / Length of data in JPEG APPn segment /
819	char APP_data[`60`]; / Data in the JPEG APPn segment. /
820
821	int COM_len; / Length of data in JPEG COM segment /
822	char COM_data[`60`]; / Data in JPEG COM segment /
823
824	__u32 jpeg_markers; / Which markers should go into the JPEG*
825	* output. Unless you exactly know what
826	* you do, leave them untouched.
827	* Including less markers will make the
828	* resulting code smaller, but there will
829	* be fewer applications which can read it.
830	* The presence of the APP and COM marker
831	* is influenced by APP_len and COM_len
832	* ONLY, not by this property! */
833
834	#define V4L2_JPEG_MARKER_DHT (1<<3) /* Define Huffman Tables */
835	#define V4L2_JPEG_MARKER_DQT (1<<4) /* Define Quantization Tables */
836	#define V4L2_JPEG_MARKER_DRI (1<<5) /* Define Restart Interval */
837	#define V4L2_JPEG_MARKER_COM (1<<6) /* Comment segment */
838	#define V4L2_JPEG_MARKER_APP (1<<7) /* App segment, driver will
839	* always use APP0 */
840	};
841
842	/*
843	* M E M O R Y - M A P P I N G B U F F E R S
844	*/
845	struct v4l2_requestbuffers {
846	__u32 count;
847	__u32 type; / enum v4l2_buf_type /
848	__u32 memory; / enum v4l2_memory /
849	__u32 reserved[`2`];
850	};
851
852	/**
853	* struct v4l2_plane - plane info for multi-planar buffers
854	* @bytesused: number of bytes occupied by data in the plane (payload)
855	* @length: size of this plane (NOT the payload) in bytes
856	* @mem_offset: when memory in the associated struct v4l2_buffer is
857	* V4L2_MEMORY_MMAP, equals the offset from the start of
858	* the device memory for this plane (or is a "cookie" that
859	* should be passed to mmap() called on the video node)
860	* @userptr: when memory is V4L2_MEMORY_USERPTR, a userspace pointer
861	* pointing to this plane
862	* @fd: when memory is V4L2_MEMORY_DMABUF, a userspace file
863	* descriptor associated with this plane
864	* @data_offset: offset in the plane to the start of data; usually 0,
865	* unless there is a header in front of the data
866	*
867	* Multi-planar buffers consist of one or more planes, e.g. an YCbCr buffer
868	* with two planes can have one plane for Y, and another for interleaved CbCr
869	* components. Each plane can reside in a separate memory buffer, or even in
870	* a completely separate memory node (e.g. in embedded devices).
871	*/
872	struct v4l2_plane {
873	__u32 bytesused;
874	__u32 length;
875	union {
876	__u32 mem_offset;
877	unsigned long userptr;
878	__s32 fd;
879	} m;
880	__u32 data_offset;
881	__u32 reserved[`11`];
882	};
883
884	/**
885	* struct v4l2_buffer - video buffer info
886	* @index: id number of the buffer
887	* @type: enum v4l2_buf_type; buffer type (type == *_MPLANE for
888	* multiplanar buffers);
889	* @bytesused: number of bytes occupied by data in the buffer (payload);
890	* unused (set to 0) for multiplanar buffers
891	* @flags: buffer informational flags
892	* @field: enum v4l2_field; field order of the image in the buffer
893	* @timestamp: frame timestamp
894	* @timecode: frame timecode
895	* @sequence: sequence count of this frame
896	* @memory: enum v4l2_memory; the method, in which the actual video data is
897	* passed
898	* @offset: for non-multiplanar buffers with memory == V4L2_MEMORY_MMAP;
899	* offset from the start of the device memory for this plane,
900	* (or a "cookie" that should be passed to mmap() as offset)
901	* @userptr: for non-multiplanar buffers with memory == V4L2_MEMORY_USERPTR;
902	* a userspace pointer pointing to this buffer
903	* @fd: for non-multiplanar buffers with memory == V4L2_MEMORY_DMABUF;
904	* a userspace file descriptor associated with this buffer
905	* @planes: for multiplanar buffers; userspace pointer to the array of plane
906	* info structs for this buffer
907	* @length: size in bytes of the buffer (NOT its payload) for single-plane
908	* buffers (when type != *_MPLANE); number of elements in the
909	* planes array for multi-plane buffers
910	*
911	* Contains data exchanged by application and driver using one of the Streaming
912	* I/O methods.
913	*/
914	struct v4l2_buffer {
915	__u32 index;
916	__u32 type;
917	__u32 bytesused;
918	__u32 flags;
919	__u32 field;
920	struct timeval timestamp;
921	struct v4l2_timecode timecode;
922	__u32 sequence;
923
924	/ memory location /
925	__u32 memory;
926	union {
927	__u32 offset;
928	unsigned long userptr;
929	struct v4l2_plane *planes;
930	__s32 fd;
931	} m;
932	__u32 length;
933	__u32 reserved2;
934	__u32 reserved;
935	};
936
937	/ Flags for 'flags' field /
938	/ Buffer is mapped (flag) /
939	#define V4L2_BUF_FLAG_MAPPED 0x00000001
940	/ Buffer is queued for processing /
941	#define V4L2_BUF_FLAG_QUEUED 0x00000002
942	/ Buffer is ready /
943	#define V4L2_BUF_FLAG_DONE 0x00000004
944	/ Image is a keyframe (I-frame) /
945	#define V4L2_BUF_FLAG_KEYFRAME 0x00000008
946	/ Image is a P-frame /
947	#define V4L2_BUF_FLAG_PFRAME 0x00000010
948	/ Image is a B-frame /
949	#define V4L2_BUF_FLAG_BFRAME 0x00000020
950	/ Buffer is ready, but the data contained within is corrupted. /
951	#define V4L2_BUF_FLAG_ERROR 0x00000040
952	/ timecode field is valid /
953	#define V4L2_BUF_FLAG_TIMECODE 0x00000100
954	/ Buffer is prepared for queuing /
955	#define V4L2_BUF_FLAG_PREPARED 0x00000400
956	/ Cache handling flags /
957	#define V4L2_BUF_FLAG_NO_CACHE_INVALIDATE 0x00000800
958	#define V4L2_BUF_FLAG_NO_CACHE_CLEAN 0x00001000
959	/ Timestamp type /
960	#define V4L2_BUF_FLAG_TIMESTAMP_MASK 0x0000e000
961	#define V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN 0x00000000
962	#define V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC 0x00002000
963	#define V4L2_BUF_FLAG_TIMESTAMP_COPY 0x00004000
964	/ Timestamp sources. /
965	#define V4L2_BUF_FLAG_TSTAMP_SRC_MASK 0x00070000
966	#define V4L2_BUF_FLAG_TSTAMP_SRC_EOF 0x00000000
967	#define V4L2_BUF_FLAG_TSTAMP_SRC_SOE 0x00010000
968	/ mem2mem encoder/decoder /
969	#define V4L2_BUF_FLAG_LAST 0x00100000
970
971	/**
972	* struct v4l2_exportbuffer - export of video buffer as DMABUF file descriptor
973	*
974	* @index: id number of the buffer
975	* @type: enum v4l2_buf_type; buffer type (type == *_MPLANE for
976	* multiplanar buffers);
977	* @plane: index of the plane to be exported, 0 for single plane queues
978	* @flags: flags for newly created file, currently only O_CLOEXEC is
979	* supported, refer to manual of open syscall for more details
980	* @fd: file descriptor associated with DMABUF (set by driver)
981	*
982	* Contains data used for exporting a video buffer as DMABUF file descriptor.
983	* The buffer is identified by a 'cookie' returned by VIDIOC_QUERYBUF
984	* (identical to the cookie used to mmap() the buffer to userspace). All
985	* reserved fields must be set to zero. The field reserved0 is expected to
986	* become a structure 'type' allowing an alternative layout of the structure
987	* content. Therefore this field should not be used for any other extensions.
988	*/
989	struct v4l2_exportbuffer {
990	__u32 type; / enum v4l2_buf_type /
991	__u32 index;
992	__u32 plane;
993	__u32 flags;
994	__s32 fd;
995	__u32 reserved[`11`];
996	};
997
998	/*
999	* O V E R L A Y P R E V I E W
1000	*/
1001	struct v4l2_framebuffer {
1002	__u32 capability;
1003	__u32 flags;
1004	/ FIXME: in theory we should pass something like PCI device + memory*
1005	* region + offset instead of some physical address */
1006	void *base;
1007	struct {
1008	__u32 width;
1009	__u32 height;
1010	__u32 pixelformat;
1011	__u32 field; / enum v4l2_field /
1012	__u32 bytesperline; / for padding, zero if unused /
1013	__u32 sizeimage;
1014	__u32 colorspace; / enum v4l2_colorspace /
1015	__u32 priv; / reserved field, set to 0 /
1016	} fmt;
1017	};
1018	/ Flags for the 'capability' field. Read only /
1019	#define V4L2_FBUF_CAP_EXTERNOVERLAY 0x0001
1020	#define V4L2_FBUF_CAP_CHROMAKEY 0x0002
1021	#define V4L2_FBUF_CAP_LIST_CLIPPING 0x0004
1022	#define V4L2_FBUF_CAP_BITMAP_CLIPPING 0x0008
1023	#define V4L2_FBUF_CAP_LOCAL_ALPHA 0x0010
1024	#define V4L2_FBUF_CAP_GLOBAL_ALPHA 0x0020
1025	#define V4L2_FBUF_CAP_LOCAL_INV_ALPHA 0x0040
1026	#define V4L2_FBUF_CAP_SRC_CHROMAKEY 0x0080
1027	/ Flags for the 'flags' field. /
1028	#define V4L2_FBUF_FLAG_PRIMARY 0x0001
1029	#define V4L2_FBUF_FLAG_OVERLAY 0x0002
1030	#define V4L2_FBUF_FLAG_CHROMAKEY 0x0004
1031	#define V4L2_FBUF_FLAG_LOCAL_ALPHA 0x0008
1032	#define V4L2_FBUF_FLAG_GLOBAL_ALPHA 0x0010
1033	#define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA 0x0020
1034	#define V4L2_FBUF_FLAG_SRC_CHROMAKEY 0x0040
1035
1036	struct v4l2_clip {
1037	struct v4l2_rect c;
1038	struct v4l2_clip *next;
1039	};
1040
1041	struct v4l2_window {
1042	struct v4l2_rect w;
1043	__u32 field; / enum v4l2_field /
1044	__u32 chromakey;
1045	struct v4l2_clip *clips;
1046	__u32 clipcount;
1047	void *bitmap;
1048	__u8 global_alpha;
1049	};
1050
1051	/*
1052	* C A P T U R E P A R A M E T E R S
1053	*/
1054	struct v4l2_captureparm {
1055	__u32 capability; / Supported modes /
1056	__u32 capturemode; / Current mode /
1057	struct v4l2_fract timeperframe; / Time per frame in seconds /
1058	__u32 extendedmode; / Driver-specific extensions /
1059	__u32 readbuffers; / # of buffers for read /
1060	__u32 reserved[`4`];
1061	};
1062
1063	/ Flags for 'capability' and 'capturemode' fields /
1064	#define V4L2_MODE_HIGHQUALITY 0x0001 /* High quality imaging mode */
1065	#define V4L2_CAP_TIMEPERFRAME 0x1000 /* timeperframe field is supported */
1066
1067	struct v4l2_outputparm {
1068	__u32 capability; / Supported modes /
1069	__u32 outputmode; / Current mode /
1070	struct v4l2_fract timeperframe; / Time per frame in seconds /
1071	__u32 extendedmode; / Driver-specific extensions /
1072	__u32 writebuffers; / # of buffers for write /
1073	__u32 reserved[`4`];
1074	};
1075
1076	/*
1077	* I N P U T I M A G E C R O P P I N G
1078	*/
1079	struct v4l2_cropcap {
1080	__u32 type; / enum v4l2_buf_type /
1081	struct v4l2_rect bounds;
1082	struct v4l2_rect defrect;
1083	struct v4l2_fract pixelaspect;
1084	};
1085
1086	struct v4l2_crop {
1087	__u32 type; / enum v4l2_buf_type /
1088	struct v4l2_rect c;
1089	};
1090
1091	/**
1092	* struct v4l2_selection - selection info
1093	* @type: buffer type (do not use *_MPLANE types)
1094	* @target: Selection target, used to choose one of possible rectangles;
1095	* defined in v4l2-common.h; V4L2_SEL_TGT_* .
1096	* @flags: constraints flags, defined in v4l2-common.h; V4L2_SEL_FLAG_*.
1097	* @r: coordinates of selection window
1098	* @reserved: for future use, rounds structure size to 64 bytes, set to zero
1099	*
1100	* Hardware may use multiple helper windows to process a video stream.
1101	* The structure is used to exchange this selection areas between
1102	* an application and a driver.
1103	*/
1104	struct v4l2_selection {
1105	__u32 type;
1106	__u32 target;
1107	__u32 flags;
1108	struct v4l2_rect r;
1109	__u32 reserved[`9`];
1110	};
1111
1112
1113	/*
1114	* A N A L O G V I D E O S T A N D A R D
1115	*/
1116
1117	typedef __u64 v4l2_std_id;
1118
1119	/ one bit for each /
1120	#define V4L2_STD_PAL_B ((v4l2_std_id)0x00000001)
1121	#define V4L2_STD_PAL_B1 ((v4l2_std_id)0x00000002)
1122	#define V4L2_STD_PAL_G ((v4l2_std_id)0x00000004)
1123	#define V4L2_STD_PAL_H ((v4l2_std_id)0x00000008)
1124	#define V4L2_STD_PAL_I ((v4l2_std_id)0x00000010)
1125	#define V4L2_STD_PAL_D ((v4l2_std_id)0x00000020)
1126	#define V4L2_STD_PAL_D1 ((v4l2_std_id)0x00000040)
1127	#define V4L2_STD_PAL_K ((v4l2_std_id)0x00000080)
1128
1129	#define V4L2_STD_PAL_M ((v4l2_std_id)0x00000100)
1130	#define V4L2_STD_PAL_N ((v4l2_std_id)0x00000200)
1131	#define V4L2_STD_PAL_Nc ((v4l2_std_id)0x00000400)
1132	#define V4L2_STD_PAL_60 ((v4l2_std_id)0x00000800)
1133
1134	#define V4L2_STD_NTSC_M ((v4l2_std_id)0x00001000) /* BTSC */
1135	#define V4L2_STD_NTSC_M_JP ((v4l2_std_id)0x00002000) /* EIA-J */
1136	#define V4L2_STD_NTSC_443 ((v4l2_std_id)0x00004000)
1137	#define V4L2_STD_NTSC_M_KR ((v4l2_std_id)0x00008000) /* FM A2 */
1138
1139	#define V4L2_STD_SECAM_B ((v4l2_std_id)0x00010000)
1140	#define V4L2_STD_SECAM_D ((v4l2_std_id)0x00020000)
1141	#define V4L2_STD_SECAM_G ((v4l2_std_id)0x00040000)
1142	#define V4L2_STD_SECAM_H ((v4l2_std_id)0x00080000)
1143	#define V4L2_STD_SECAM_K ((v4l2_std_id)0x00100000)
1144	#define V4L2_STD_SECAM_K1 ((v4l2_std_id)0x00200000)
1145	#define V4L2_STD_SECAM_L ((v4l2_std_id)0x00400000)
1146	#define V4L2_STD_SECAM_LC ((v4l2_std_id)0x00800000)
1147
1148	/ ATSC/HDTV /
1149	#define V4L2_STD_ATSC_8_VSB ((v4l2_std_id)0x01000000)
1150	#define V4L2_STD_ATSC_16_VSB ((v4l2_std_id)0x02000000)
1151
1152	/ FIXME:*
1153	Although std_id is 64 bits, there is an issue on PPC32 architecture that
1154	makes switch(__u64) to break. So, there's a hack on v4l2-common.c rounding
1155	this value to 32 bits.
1156	As, currently, the max value is for V4L2_STD_ATSC_16_VSB (30 bits wide),
1157	it should work fine. However, if needed to add more than two standards,
1158	v4l2-common.c should be fixed.
1159	*/
1160
1161	/*
1162	* Some macros to merge video standards in order to make live easier for the
1163	* drivers and V4L2 applications
1164	*/
1165
1166	/*
1167	* "Common" NTSC/M - It should be noticed that V4L2_STD_NTSC_443 is
1168	* Missing here.
1169	*/
1170	#define V4L2_STD_NTSC (V4L2_STD_NTSC_M \|\
1171	V4L2_STD_NTSC_M_JP \|\
1172	V4L2_STD_NTSC_M_KR)
1173	/ Secam macros /
1174	#define V4L2_STD_SECAM_DK (V4L2_STD_SECAM_D \|\
1175	V4L2_STD_SECAM_K \|\
1176	V4L2_STD_SECAM_K1)
1177	/ All Secam Standards /
1178	#define V4L2_STD_SECAM (V4L2_STD_SECAM_B \|\
1179	V4L2_STD_SECAM_G \|\
1180	V4L2_STD_SECAM_H \|\
1181	V4L2_STD_SECAM_DK \|\
1182	V4L2_STD_SECAM_L \|\
1183	V4L2_STD_SECAM_LC)
1184	/ PAL macros /
1185	#define V4L2_STD_PAL_BG (V4L2_STD_PAL_B \|\
1186	V4L2_STD_PAL_B1 \|\
1187	V4L2_STD_PAL_G)
1188	#define V4L2_STD_PAL_DK (V4L2_STD_PAL_D \|\
1189	V4L2_STD_PAL_D1 \|\
1190	V4L2_STD_PAL_K)
1191	/*
1192	* "Common" PAL - This macro is there to be compatible with the old
1193	* V4L1 concept of "PAL": /BGDKHI.
1194	* Several PAL standards are missing here: /M, /N and /Nc
1195	*/
1196	#define V4L2_STD_PAL (V4L2_STD_PAL_BG \|\
1197	V4L2_STD_PAL_DK \|\
1198	V4L2_STD_PAL_H \|\
1199	V4L2_STD_PAL_I)
1200	/ Chroma "agnostic" standards /
1201	#define V4L2_STD_B (V4L2_STD_PAL_B \|\
1202	V4L2_STD_PAL_B1 \|\
1203	V4L2_STD_SECAM_B)
1204	#define V4L2_STD_G (V4L2_STD_PAL_G \|\
1205	V4L2_STD_SECAM_G)
1206	#define V4L2_STD_H (V4L2_STD_PAL_H \|\
1207	V4L2_STD_SECAM_H)
1208	#define V4L2_STD_L (V4L2_STD_SECAM_L \|\
1209	V4L2_STD_SECAM_LC)
1210	#define V4L2_STD_GH (V4L2_STD_G \|\
1211	V4L2_STD_H)
1212	#define V4L2_STD_DK (V4L2_STD_PAL_DK \|\
1213	V4L2_STD_SECAM_DK)
1214	#define V4L2_STD_BG (V4L2_STD_B \|\
1215	V4L2_STD_G)
1216	#define V4L2_STD_MN (V4L2_STD_PAL_M \|\
1217	V4L2_STD_PAL_N \|\
1218	V4L2_STD_PAL_Nc \|\
1219	V4L2_STD_NTSC)
1220
1221	/ Standards where MTS/BTSC stereo could be found /
1222	#define V4L2_STD_MTS (V4L2_STD_NTSC_M \|\
1223	V4L2_STD_PAL_M \|\
1224	V4L2_STD_PAL_N \|\
1225	V4L2_STD_PAL_Nc)
1226
1227	/ Standards for Countries with 60Hz Line frequency /
1228	#define V4L2_STD_525_60 (V4L2_STD_PAL_M \|\
1229	V4L2_STD_PAL_60 \|\
1230	V4L2_STD_NTSC \|\
1231	V4L2_STD_NTSC_443)
1232	/ Standards for Countries with 50Hz Line frequency /
1233	#define V4L2_STD_625_50 (V4L2_STD_PAL \|\
1234	V4L2_STD_PAL_N \|\
1235	V4L2_STD_PAL_Nc \|\
1236	V4L2_STD_SECAM)
1237
1238	#define V4L2_STD_ATSC (V4L2_STD_ATSC_8_VSB \|\
1239	V4L2_STD_ATSC_16_VSB)
1240	/ Macros with none and all analog standards /
1241	#define V4L2_STD_UNKNOWN 0
1242	#define V4L2_STD_ALL (V4L2_STD_525_60 \|\
1243	V4L2_STD_625_50)
1244
1245	struct v4l2_standard {
1246	__u32 index;
1247	v4l2_std_id id;
1248	__u8 name[`24`];
1249	struct v4l2_fract frameperiod; / Frames, not fields /
1250	__u32 framelines;
1251	__u32 reserved[`4`];
1252	};
1253
1254	/*
1255	* D V B T T I M I N G S
1256	*/
1257
1258	/* struct v4l2_bt_timings - BT.656/BT.1120 timing data*
1259	* @width: total width of the active video in pixels
1260	* @height: total height of the active video in lines
1261	* @interlaced: Interlaced or progressive
1262	* @polarities: Positive or negative polarities
1263	* @pixelclock: Pixel clock in HZ. Ex. 74.25MHz->74250000
1264	* @hfrontporch:Horizontal front porch in pixels
1265	* @hsync: Horizontal Sync length in pixels
1266	* @hbackporch: Horizontal back porch in pixels
1267	* @vfrontporch:Vertical front porch in lines
1268	* @vsync: Vertical Sync length in lines
1269	* @vbackporch: Vertical back porch in lines
1270	* @il_vfrontporch:Vertical front porch for the even field
1271	* (aka field 2) of interlaced field formats
1272	* @il_vsync: Vertical Sync length for the even field
1273	* (aka field 2) of interlaced field formats
1274	* @il_vbackporch:Vertical back porch for the even field
1275	* (aka field 2) of interlaced field formats
1276	* @standards: Standards the timing belongs to
1277	* @flags: Flags
1278	* @picture_aspect: The picture aspect ratio (hor/vert).
1279	* @cea861_vic: VIC code as per the CEA-861 standard.
1280	* @hdmi_vic: VIC code as per the HDMI standard.
1281	* @reserved: Reserved fields, must be zeroed.
1282	*
1283	* A note regarding vertical interlaced timings: height refers to the total
1284	* height of the active video frame (= two fields). The blanking timings refer
1285	* to the blanking of each field. So the height of the total frame is
1286	* calculated as follows:
1287	*
1288	* tot_height = height + vfrontporch + vsync + vbackporch +
1289	* il_vfrontporch + il_vsync + il_vbackporch
1290	*
1291	* The active height of each field is height / 2.
1292	*/
1293	struct v4l2_bt_timings {
1294	__u32 width;
1295	__u32 height;
1296	__u32 interlaced;
1297	__u32 polarities;
1298	__u64 pixelclock;
1299	__u32 hfrontporch;
1300	__u32 hsync;
1301	__u32 hbackporch;
1302	__u32 vfrontporch;
1303	__u32 vsync;
1304	__u32 vbackporch;
1305	__u32 il_vfrontporch;
1306	__u32 il_vsync;
1307	__u32 il_vbackporch;
1308	__u32 standards;
1309	__u32 flags;
1310	struct v4l2_fract picture_aspect;
1311	__u8 cea861_vic;
1312	__u8 hdmi_vic;
1313	__u8 reserved[`46`];
1314	} __attribute__ ((packed));
1315
1316	/ Interlaced or progressive format /
1317	#define V4L2_DV_PROGRESSIVE 0
1318	#define V4L2_DV_INTERLACED 1
1319
1320	/ Polarities. If bit is not set, it is assumed to be negative polarity /
1321	#define V4L2_DV_VSYNC_POS_POL 0x00000001
1322	#define V4L2_DV_HSYNC_POS_POL 0x00000002
1323
1324	/ Timings standards /
1325	#define V4L2_DV_BT_STD_CEA861 (1 << 0) /* CEA-861 Digital TV Profile */
1326	#define V4L2_DV_BT_STD_DMT (1 << 1) /* VESA Discrete Monitor Timings */
1327	#define V4L2_DV_BT_STD_CVT (1 << 2) /* VESA Coordinated Video Timings */
1328	#define V4L2_DV_BT_STD_GTF (1 << 3) /* VESA Generalized Timings Formula */
1329	#define V4L2_DV_BT_STD_SDI (1 << 4) /* SDI Timings */
1330
1331	/ Flags /
1332
1333	/*
1334	* CVT/GTF specific: timing uses reduced blanking (CVT) or the 'Secondary
1335	* GTF' curve (GTF). In both cases the horizontal and/or vertical blanking
1336	* intervals are reduced, allowing a higher resolution over the same
1337	* bandwidth. This is a read-only flag.
1338	*/
1339	#define V4L2_DV_FL_REDUCED_BLANKING (1 << 0)
1340	/*
1341	* CEA-861 specific: set for CEA-861 formats with a framerate of a multiple
1342	* of six. These formats can be optionally played at 1 / 1.001 speed.
1343	* This is a read-only flag.
1344	*/
1345	#define V4L2_DV_FL_CAN_REDUCE_FPS (1 << 1)
1346	/*
1347	* CEA-861 specific: only valid for video transmitters, the flag is cleared
1348	* by receivers.
1349	* If the framerate of the format is a multiple of six, then the pixelclock
1350	* used to set up the transmitter is divided by 1.001 to make it compatible
1351	* with 60 Hz based standards such as NTSC and PAL-M that use a framerate of
1352	* 29.97 Hz. Otherwise this flag is cleared. If the transmitter can't generate
1353	* such frequencies, then the flag will also be cleared.
1354	*/
1355	#define V4L2_DV_FL_REDUCED_FPS (1 << 2)
1356	/*
1357	* Specific to interlaced formats: if set, then field 1 is really one half-line
1358	* longer and field 2 is really one half-line shorter, so each field has
1359	* exactly the same number of half-lines. Whether half-lines can be detected
1360	* or used depends on the hardware.
1361	*/
1362	#define V4L2_DV_FL_HALF_LINE (1 << 3)
1363	/*
1364	* If set, then this is a Consumer Electronics (CE) video format. Such formats
1365	* differ from other formats (commonly called IT formats) in that if RGB
1366	* encoding is used then by default the RGB values use limited range (i.e.
1367	* use the range 16-235) as opposed to 0-255. All formats defined in CEA-861
1368	* except for the 640x480 format are CE formats.
1369	*/
1370	#define V4L2_DV_FL_IS_CE_VIDEO (1 << 4)
1371	/ Some formats like SMPTE-125M have an interlaced signal with a odd*
1372	* total height. For these formats, if this flag is set, the first
1373	* field has the extra line. If not, it is the second field.
1374	*/
1375	#define V4L2_DV_FL_FIRST_FIELD_EXTRA_LINE (1 << 5)
1376	/*
1377	* If set, then the picture_aspect field is valid. Otherwise assume that the
1378	* pixels are square, so the picture aspect ratio is the same as the width to
1379	* height ratio.
1380	*/
1381	#define V4L2_DV_FL_HAS_PICTURE_ASPECT (1 << 6)
1382	/*
1383	* If set, then the cea861_vic field is valid and contains the Video
1384	* Identification Code as per the CEA-861 standard.
1385	*/
1386	#define V4L2_DV_FL_HAS_CEA861_VIC (1 << 7)
1387	/*
1388	* If set, then the hdmi_vic field is valid and contains the Video
1389	* Identification Code as per the HDMI standard (HDMI Vendor Specific
1390	* InfoFrame).
1391	*/
1392	#define V4L2_DV_FL_HAS_HDMI_VIC (1 << 8)
1393
1394	/ A few useful defines to calculate the total blanking and frame sizes /
1395	#define V4L2_DV_BT_BLANKING_WIDTH(bt) \
1396	((bt)->hfrontporch + (bt)->hsync + (bt)->hbackporch)
1397	#define V4L2_DV_BT_FRAME_WIDTH(bt) \
1398	((bt)->width + V4L2_DV_BT_BLANKING_WIDTH(bt))
1399	#define V4L2_DV_BT_BLANKING_HEIGHT(bt) \
1400	((bt)->vfrontporch + (bt)->vsync + (bt)->vbackporch + \
1401	(bt)->il_vfrontporch + (bt)->il_vsync + (bt)->il_vbackporch)
1402	#define V4L2_DV_BT_FRAME_HEIGHT(bt) \
1403	((bt)->height + V4L2_DV_BT_BLANKING_HEIGHT(bt))
1404
1405	/* struct v4l2_dv_timings - DV timings*
1406	* @type: the type of the timings
1407	* @bt: BT656/1120 timings
1408	*/
1409	struct v4l2_dv_timings {
1410	__u32 type;
1411	union {
1412	struct v4l2_bt_timings bt;
1413	__u32 reserved[`32`];
1414	};
1415	} __attribute__ ((packed));
1416
1417	/ Values for the type field /
1418	#define V4L2_DV_BT_656_1120 0 /* BT.656/1120 timing type */
1419
1420
1421	/* struct v4l2_enum_dv_timings - DV timings enumeration*
1422	* @index: enumeration index
1423	* @pad: the pad number for which to enumerate timings (used with
1424	* v4l-subdev nodes only)
1425	* @reserved: must be zeroed
1426	* @timings: the timings for the given index
1427	*/
1428	struct v4l2_enum_dv_timings {
1429	__u32 index;
1430	__u32 pad;
1431	__u32 reserved[`2`];
1432	struct v4l2_dv_timings timings;
1433	};
1434
1435	/* struct v4l2_bt_timings_cap - BT.656/BT.1120 timing capabilities*
1436	* @min_width: width in pixels
1437	* @max_width: width in pixels
1438	* @min_height: height in lines
1439	* @max_height: height in lines
1440	* @min_pixelclock: Pixel clock in HZ. Ex. 74.25MHz->74250000
1441	* @max_pixelclock: Pixel clock in HZ. Ex. 74.25MHz->74250000
1442	* @standards: Supported standards
1443	* @capabilities: Supported capabilities
1444	* @reserved: Must be zeroed
1445	*/
1446	struct v4l2_bt_timings_cap {
1447	__u32 min_width;
1448	__u32 max_width;
1449	__u32 min_height;
1450	__u32 max_height;
1451	__u64 min_pixelclock;
1452	__u64 max_pixelclock;
1453	__u32 standards;
1454	__u32 capabilities;
1455	__u32 reserved[`16`];
1456	} __attribute__ ((packed));
1457
1458	/ Supports interlaced formats /
1459	#define V4L2_DV_BT_CAP_INTERLACED (1 << 0)
1460	/ Supports progressive formats /
1461	#define V4L2_DV_BT_CAP_PROGRESSIVE (1 << 1)
1462	/ Supports CVT/GTF reduced blanking /
1463	#define V4L2_DV_BT_CAP_REDUCED_BLANKING (1 << 2)
1464	/ Supports custom formats /
1465	#define V4L2_DV_BT_CAP_CUSTOM (1 << 3)
1466
1467	/* struct v4l2_dv_timings_cap - DV timings capabilities*
1468	* @type: the type of the timings (same as in struct v4l2_dv_timings)
1469	* @pad: the pad number for which to query capabilities (used with
1470	* v4l-subdev nodes only)
1471	* @bt: the BT656/1120 timings capabilities
1472	*/
1473	struct v4l2_dv_timings_cap {
1474	__u32 type;
1475	__u32 pad;
1476	__u32 reserved[`2`];
1477	union {
1478	struct v4l2_bt_timings_cap bt;
1479	__u32 raw_data[`32`];
1480	};
1481	};
1482
1483
1484	/*
1485	* V I D E O I N P U T S
1486	*/
1487	struct v4l2_input {
1488	__u32 index; / Which input /
1489	__u8 name[`32`]; / Label /
1490	__u32 type; / Type of input /
1491	__u32 audioset; / Associated audios (bitfield) /
1492	__u32 tuner; / enum v4l2_tuner_type /
1493	v4l2_std_id std;
1494	__u32 status;
1495	__u32 capabilities;
1496	__u32 reserved[`3`];
1497	};
1498
1499	/ Values for the 'type' field /
1500	#define V4L2_INPUT_TYPE_TUNER 1
1501	#define V4L2_INPUT_TYPE_CAMERA 2
1502	#define V4L2_INPUT_TYPE_TOUCH 3
1503
1504	/ field 'status' - general /
1505	#define V4L2_IN_ST_NO_POWER 0x00000001 /* Attached device is off */
1506	#define V4L2_IN_ST_NO_SIGNAL 0x00000002
1507	#define V4L2_IN_ST_NO_COLOR 0x00000004
1508
1509	/ field 'status' - sensor orientation /
1510	/ If sensor is mounted upside down set both bits /
1511	#define V4L2_IN_ST_HFLIP 0x00000010 /* Frames are flipped horizontally */
1512	#define V4L2_IN_ST_VFLIP 0x00000020 /* Frames are flipped vertically */
1513
1514	/ field 'status' - analog /
1515	#define V4L2_IN_ST_NO_H_LOCK 0x00000100 /* No horizontal sync lock */
1516	#define V4L2_IN_ST_COLOR_KILL 0x00000200 /* Color killer is active */
1517	#define V4L2_IN_ST_NO_V_LOCK 0x00000400 /* No vertical sync lock */
1518	#define V4L2_IN_ST_NO_STD_LOCK 0x00000800 /* No standard format lock */
1519
1520	/ field 'status' - digital /
1521	#define V4L2_IN_ST_NO_SYNC 0x00010000 /* No synchronization lock */
1522	#define V4L2_IN_ST_NO_EQU 0x00020000 /* No equalizer lock */
1523	#define V4L2_IN_ST_NO_CARRIER 0x00040000 /* Carrier recovery failed */
1524
1525	/ field 'status' - VCR and set-top box /
1526	#define V4L2_IN_ST_MACROVISION 0x01000000 /* Macrovision detected */
1527	#define V4L2_IN_ST_NO_ACCESS 0x02000000 /* Conditional access denied */
1528	#define V4L2_IN_ST_VTR 0x04000000 /* VTR time constant */
1529
1530	/ capabilities flags /
1531	#define V4L2_IN_CAP_DV_TIMINGS 0x00000002 /* Supports S_DV_TIMINGS */
1532	#define V4L2_IN_CAP_CUSTOM_TIMINGS V4L2_IN_CAP_DV_TIMINGS /* For compatibility */
1533	#define V4L2_IN_CAP_STD 0x00000004 /* Supports S_STD */
1534	#define V4L2_IN_CAP_NATIVE_SIZE 0x00000008 /* Supports setting native size */
1535
1536	/*
1537	* V I D E O O U T P U T S
1538	*/
1539	struct v4l2_output {
1540	__u32 index; / Which output /
1541	__u8 name[`32`]; / Label /
1542	__u32 type; / Type of output /
1543	__u32 audioset; / Associated audios (bitfield) /
1544	__u32 modulator; / Associated modulator /
1545	v4l2_std_id std;
1546	__u32 capabilities;
1547	__u32 reserved[`3`];
1548	};
1549	/ Values for the 'type' field /
1550	#define V4L2_OUTPUT_TYPE_MODULATOR 1
1551	#define V4L2_OUTPUT_TYPE_ANALOG 2
1552	#define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY 3
1553
1554	/ capabilities flags /
1555	#define V4L2_OUT_CAP_DV_TIMINGS 0x00000002 /* Supports S_DV_TIMINGS */
1556	#define V4L2_OUT_CAP_CUSTOM_TIMINGS V4L2_OUT_CAP_DV_TIMINGS /* For compatibility */
1557	#define V4L2_OUT_CAP_STD 0x00000004 /* Supports S_STD */
1558	#define V4L2_OUT_CAP_NATIVE_SIZE 0x00000008 /* Supports setting native size */
1559
1560	/*
1561	* C O N T R O L S
1562	*/
1563	struct v4l2_control {
1564	__u32 id;
1565	__s32 value;
1566	};
1567
1568	struct v4l2_ext_control {
1569	__u32 id;
1570	__u32 size;
1571	__u32 reserved2[`1`];
1572	union {
1573	__s32 value;
1574	__s64 value64;
1575	char *string;
1576	__u8 *p_u8;
1577	__u16 *p_u16;
1578	__u32 *p_u32;
1579	void *ptr;
1580	};
1581	} __attribute__ ((packed));
1582
1583	struct v4l2_ext_controls {
1584	union {
1585	__u32 ctrl_class;
1586	__u32 which;
1587	};
1588	__u32 count;
1589	__u32 error_idx;
1590	__u32 reserved[`2`];
1591	struct v4l2_ext_control *controls;
1592	};
1593
1594	#define V4L2_CTRL_ID_MASK (0x0fffffff)
1595	#define V4L2_CTRL_ID2CLASS(id) ((id) & 0x0fff0000UL)
1596	#define V4L2_CTRL_ID2WHICH(id) ((id) & 0x0fff0000UL)
1597	#define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)
1598	#define V4L2_CTRL_MAX_DIMS (4)
1599	#define V4L2_CTRL_WHICH_CUR_VAL 0
1600	#define V4L2_CTRL_WHICH_DEF_VAL 0x0f000000
1601
1602	enum v4l2_ctrl_type {
1603	V4L2_CTRL_TYPE_INTEGER = `1`,
1604	V4L2_CTRL_TYPE_BOOLEAN = `2`,
1605	V4L2_CTRL_TYPE_MENU = `3`,
1606	V4L2_CTRL_TYPE_BUTTON = `4`,
1607	V4L2_CTRL_TYPE_INTEGER64 = `5`,
1608	V4L2_CTRL_TYPE_CTRL_CLASS = `6`,
1609	V4L2_CTRL_TYPE_STRING = `7`,
1610	V4L2_CTRL_TYPE_BITMASK = `8`,
1611	V4L2_CTRL_TYPE_INTEGER_MENU = `9`,
1612
1613	/ Compound types are >= 0x0100 /
1614	V4L2_CTRL_COMPOUND_TYPES = `0x0100`,
1615	V4L2_CTRL_TYPE_U8 = `0x0100`,
1616	V4L2_CTRL_TYPE_U16 = `0x0101`,
1617	V4L2_CTRL_TYPE_U32 = `0x0102`,
1618	};
1619
1620	/ Used in the VIDIOC_QUERYCTRL ioctl for querying controls /
1621	struct v4l2_queryctrl {
1622	__u32 id;
1623	__u32 type; / enum v4l2_ctrl_type /
1624	__u8 name[`32`]; / Whatever /
1625	__s32 minimum; / Note signedness /
1626	__s32 maximum;
1627	__s32 step;
1628	__s32 default_value;
1629	__u32 flags;
1630	__u32 reserved[`2`];
1631	};
1632
1633	/ Used in the VIDIOC_QUERY_EXT_CTRL ioctl for querying extended controls /
1634	struct v4l2_query_ext_ctrl {
1635	__u32 id;
1636	__u32 type;
1637	char name[`32`];
1638	__s64 minimum;
1639	__s64 maximum;
1640	__u64 step;
1641	__s64 default_value;
1642	__u32 flags;
1643	__u32 elem_size;
1644	__u32 elems;
1645	__u32 nr_of_dims;
1646	__u32 dims[V4L2_CTRL_MAX_DIMS];
1647	__u32 reserved[`32`];
1648	};
1649
1650	/ Used in the VIDIOC_QUERYMENU ioctl for querying menu items /
1651	struct v4l2_querymenu {
1652	__u32 id;
1653	__u32 index;
1654	union {
1655	__u8 name[`32`]; / Whatever /
1656	__s64 value;
1657	};
1658	__u32 reserved;
1659	} __attribute__ ((packed));
1660
1661	/ Control flags /
1662	#define V4L2_CTRL_FLAG_DISABLED 0x0001
1663	#define V4L2_CTRL_FLAG_GRABBED 0x0002
1664	#define V4L2_CTRL_FLAG_READ_ONLY 0x0004
1665	#define V4L2_CTRL_FLAG_UPDATE 0x0008
1666	#define V4L2_CTRL_FLAG_INACTIVE 0x0010
1667	#define V4L2_CTRL_FLAG_SLIDER 0x0020
1668	#define V4L2_CTRL_FLAG_WRITE_ONLY 0x0040
1669	#define V4L2_CTRL_FLAG_VOLATILE 0x0080
1670	#define V4L2_CTRL_FLAG_HAS_PAYLOAD 0x0100
1671	#define V4L2_CTRL_FLAG_EXECUTE_ON_WRITE 0x0200
1672	#define V4L2_CTRL_FLAG_MODIFY_LAYOUT 0x0400
1673
1674	/ Query flags, to be ORed with the control ID /
1675	#define V4L2_CTRL_FLAG_NEXT_CTRL 0x80000000
1676	#define V4L2_CTRL_FLAG_NEXT_COMPOUND 0x40000000
1677
1678	/ User-class control IDs defined by V4L2 /
1679	#define V4L2_CID_MAX_CTRLS 1024
1680	/ IDs reserved for driver specific controls /
1681	#define V4L2_CID_PRIVATE_BASE 0x08000000
1682
1683
1684	/*
1685	* T U N I N G
1686	*/
1687	struct v4l2_tuner {
1688	__u32 index;
1689	__u8 name[`32`];
1690	__u32 type; / enum v4l2_tuner_type /
1691	__u32 capability;
1692	__u32 rangelow;
1693	__u32 rangehigh;
1694	__u32 rxsubchans;
1695	__u32 audmode;
1696	__s32 signal;
1697	__s32 afc;
1698	__u32 reserved[`4`];
1699	};
1700
1701	struct v4l2_modulator {
1702	__u32 index;
1703	__u8 name[`32`];
1704	__u32 capability;
1705	__u32 rangelow;
1706	__u32 rangehigh;
1707	__u32 txsubchans;
1708	__u32 type; / enum v4l2_tuner_type /
1709	__u32 reserved[`3`];
1710	};
1711
1712	/ Flags for the 'capability' field /
1713	#define V4L2_TUNER_CAP_LOW 0x0001
1714	#define V4L2_TUNER_CAP_NORM 0x0002
1715	#define V4L2_TUNER_CAP_HWSEEK_BOUNDED 0x0004
1716	#define V4L2_TUNER_CAP_HWSEEK_WRAP 0x0008
1717	#define V4L2_TUNER_CAP_STEREO 0x0010
1718	#define V4L2_TUNER_CAP_LANG2 0x0020
1719	#define V4L2_TUNER_CAP_SAP 0x0020
1720	#define V4L2_TUNER_CAP_LANG1 0x0040
1721	#define V4L2_TUNER_CAP_RDS 0x0080
1722	#define V4L2_TUNER_CAP_RDS_BLOCK_IO 0x0100
1723	#define V4L2_TUNER_CAP_RDS_CONTROLS 0x0200
1724	#define V4L2_TUNER_CAP_FREQ_BANDS 0x0400
1725	#define V4L2_TUNER_CAP_HWSEEK_PROG_LIM 0x0800
1726	#define V4L2_TUNER_CAP_1HZ 0x1000
1727
1728	/ Flags for the 'rxsubchans' field /
1729	#define V4L2_TUNER_SUB_MONO 0x0001
1730	#define V4L2_TUNER_SUB_STEREO 0x0002
1731	#define V4L2_TUNER_SUB_LANG2 0x0004
1732	#define V4L2_TUNER_SUB_SAP 0x0004
1733	#define V4L2_TUNER_SUB_LANG1 0x0008
1734	#define V4L2_TUNER_SUB_RDS 0x0010
1735
1736	/ Values for the 'audmode' field /
1737	#define V4L2_TUNER_MODE_MONO 0x0000
1738	#define V4L2_TUNER_MODE_STEREO 0x0001
1739	#define V4L2_TUNER_MODE_LANG2 0x0002
1740	#define V4L2_TUNER_MODE_SAP 0x0002
1741	#define V4L2_TUNER_MODE_LANG1 0x0003
1742	#define V4L2_TUNER_MODE_LANG1_LANG2 0x0004
1743
1744	struct v4l2_frequency {
1745	__u32 tuner;
1746	__u32 type; / enum v4l2_tuner_type /
1747	__u32 frequency;
1748	__u32 reserved[`8`];
1749	};
1750
1751	#define V4L2_BAND_MODULATION_VSB (1 << 1)
1752	#define V4L2_BAND_MODULATION_FM (1 << 2)
1753	#define V4L2_BAND_MODULATION_AM (1 << 3)
1754
1755	struct v4l2_frequency_band {
1756	__u32 tuner;
1757	__u32 type; / enum v4l2_tuner_type /
1758	__u32 index;
1759	__u32 capability;
1760	__u32 rangelow;
1761	__u32 rangehigh;
1762	__u32 modulation;
1763	__u32 reserved[`9`];
1764	};
1765
1766	struct v4l2_hw_freq_seek {
1767	__u32 tuner;
1768	__u32 type; / enum v4l2_tuner_type /
1769	__u32 seek_upward;
1770	__u32 wrap_around;
1771	__u32 spacing;
1772	__u32 rangelow;
1773	__u32 rangehigh;
1774	__u32 reserved[`5`];
1775	};
1776
1777	/*
1778	* R D S
1779	*/
1780
1781	struct v4l2_rds_data {
1782	__u8 lsb;
1783	__u8 msb;
1784	__u8 block;
1785	} __attribute__ ((packed));
1786
1787	#define V4L2_RDS_BLOCK_MSK 0x7
1788	#define V4L2_RDS_BLOCK_A 0
1789	#define V4L2_RDS_BLOCK_B 1
1790	#define V4L2_RDS_BLOCK_C 2
1791	#define V4L2_RDS_BLOCK_D 3
1792	#define V4L2_RDS_BLOCK_C_ALT 4
1793	#define V4L2_RDS_BLOCK_INVALID 7
1794
1795	#define V4L2_RDS_BLOCK_CORRECTED 0x40
1796	#define V4L2_RDS_BLOCK_ERROR 0x80
1797
1798	/*
1799	* A U D I O
1800	*/
1801	struct v4l2_audio {
1802	__u32 index;
1803	__u8 name[`32`];
1804	__u32 capability;
1805	__u32 mode;
1806	__u32 reserved[`2`];
1807	};
1808
1809	/ Flags for the 'capability' field /
1810	#define V4L2_AUDCAP_STEREO 0x00001
1811	#define V4L2_AUDCAP_AVL 0x00002
1812
1813	/ Flags for the 'mode' field /
1814	#define V4L2_AUDMODE_AVL 0x00001
1815
1816	struct v4l2_audioout {
1817	__u32 index;
1818	__u8 name[`32`];
1819	__u32 capability;
1820	__u32 mode;
1821	__u32 reserved[`2`];
1822	};
1823
1824	/*
1825	* M P E G S E R V I C E S
1826	*/
1827	#if 1
1828	#define V4L2_ENC_IDX_FRAME_I (0)
1829	#define V4L2_ENC_IDX_FRAME_P (1)
1830	#define V4L2_ENC_IDX_FRAME_B (2)
1831	#define V4L2_ENC_IDX_FRAME_MASK (0xf)
1832
1833	struct v4l2_enc_idx_entry {
1834	__u64 offset;
1835	__u64 pts;
1836	__u32 length;
1837	__u32 flags;
1838	__u32 reserved[`2`];
1839	};
1840
1841	#define V4L2_ENC_IDX_ENTRIES (64)
1842	struct v4l2_enc_idx {
1843	__u32 entries;
1844	__u32 entries_cap;
1845	__u32 reserved[`4`];
1846	struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
1847	};
1848
1849
1850	#define V4L2_ENC_CMD_START (0)
1851	#define V4L2_ENC_CMD_STOP (1)
1852	#define V4L2_ENC_CMD_PAUSE (2)
1853	#define V4L2_ENC_CMD_RESUME (3)
1854
1855	/ Flags for V4L2_ENC_CMD_STOP /
1856	#define V4L2_ENC_CMD_STOP_AT_GOP_END (1 << 0)
1857
1858	struct v4l2_encoder_cmd {
1859	__u32 cmd;
1860	__u32 flags;
1861	union {
1862	struct {
1863	__u32 data[`8`];
1864	} raw;
1865	};
1866	};
1867
1868	/ Decoder commands /
1869	#define V4L2_DEC_CMD_START (0)
1870	#define V4L2_DEC_CMD_STOP (1)
1871	#define V4L2_DEC_CMD_PAUSE (2)
1872	#define V4L2_DEC_CMD_RESUME (3)
1873
1874	/ Flags for V4L2_DEC_CMD_START /
1875	#define V4L2_DEC_CMD_START_MUTE_AUDIO (1 << 0)
1876
1877	/ Flags for V4L2_DEC_CMD_PAUSE /
1878	#define V4L2_DEC_CMD_PAUSE_TO_BLACK (1 << 0)
1879
1880	/ Flags for V4L2_DEC_CMD_STOP /
1881	#define V4L2_DEC_CMD_STOP_TO_BLACK (1 << 0)
1882	#define V4L2_DEC_CMD_STOP_IMMEDIATELY (1 << 1)
1883
1884	/ Play format requirements (returned by the driver): /
1885
1886	/ The decoder has no special format requirements /
1887	#define V4L2_DEC_START_FMT_NONE (0)
1888	/ The decoder requires full GOPs /
1889	#define V4L2_DEC_START_FMT_GOP (1)
1890
1891	/ The structure must be zeroed before use by the application*
1892	This ensures it can be extended safely in the future. /*
1893	struct v4l2_decoder_cmd {
1894	__u32 cmd;
1895	__u32 flags;
1896	union {
1897	struct {
1898	__u64 pts;
1899	} stop;
1900
1901	struct {
1902	/ 0 or 1000 specifies normal speed,*
1903	1 specifies forward single stepping,
1904	-1 specifies backward single stepping,
1905	>1: playback at speed/1000 of the normal speed,
1906	<-1: reverse playback at (-speed/1000) of the normal speed. /*
1907	__s32 speed;
1908	__u32 format;
1909	} start;
1910
1911	struct {
1912	__u32 data[`16`];
1913	} raw;
1914	};
1915	};
1916	#endif
1917
1918
1919	/*
1920	* D A T A S E R V I C E S ( V B I )
1921	*
1922	* Data services API by Michael Schimek
1923	*/
1924
1925	/ Raw VBI /
1926	struct v4l2_vbi_format {
1927	__u32 sampling_rate; / in 1 Hz /
1928	__u32 offset;
1929	__u32 samples_per_line;
1930	__u32 sample_format; / V4L2_PIX_FMT_* /
1931	__s32 start[`2`];
1932	__u32 count[`2`];
1933	__u32 flags; / V4L2_VBI_* /
1934	__u32 reserved[`2`]; / must be zero /
1935	};
1936
1937	/ VBI flags /
1938	#define V4L2_VBI_UNSYNC (1 << 0)
1939	#define V4L2_VBI_INTERLACED (1 << 1)
1940
1941	/ ITU-R start lines for each field /
1942	#define V4L2_VBI_ITU_525_F1_START (1)
1943	#define V4L2_VBI_ITU_525_F2_START (264)
1944	#define V4L2_VBI_ITU_625_F1_START (1)
1945	#define V4L2_VBI_ITU_625_F2_START (314)
1946
1947	/ Sliced VBI*
1948	*
1949	* This implements is a proposal V4L2 API to allow SLICED VBI
1950	* required for some hardware encoders. It should change without
1951	* notice in the definitive implementation.
1952	*/
1953
1954	struct v4l2_sliced_vbi_format {
1955	__u16 service_set;
1956	/ service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field*
1957	service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
1958	(equals frame lines 313-336 for 625 line video
1959	standards, 263-286 for 525 line standards) /*
1960	__u16 service_lines[`2`][`24`];
1961	__u32 io_size;
1962	__u32 reserved[`2`]; / must be zero /
1963	};
1964
1965	/ Teletext World System Teletext*
1966	(WST), defined on ITU-R BT.653-2 /*
1967	#define V4L2_SLICED_TELETEXT_B (0x0001)
1968	/ Video Program System, defined on ETS 300 231/
1969	#define V4L2_SLICED_VPS (0x0400)
1970	/ Closed Caption, defined on EIA-608 /
1971	#define V4L2_SLICED_CAPTION_525 (0x1000)
1972	/ Wide Screen System, defined on ITU-R BT1119.1 /
1973	#define V4L2_SLICED_WSS_625 (0x4000)
1974
1975	#define V4L2_SLICED_VBI_525 (V4L2_SLICED_CAPTION_525)
1976	#define V4L2_SLICED_VBI_625 (V4L2_SLICED_TELETEXT_B \| V4L2_SLICED_VPS \| V4L2_SLICED_WSS_625)
1977
1978	struct v4l2_sliced_vbi_cap {
1979	__u16 service_set;
1980	/ service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field*
1981	service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
1982	(equals frame lines 313-336 for 625 line video
1983	standards, 263-286 for 525 line standards) /*
1984	__u16 service_lines[`2`][`24`];
1985	__u32 type; / enum v4l2_buf_type /
1986	__u32 reserved[`3`]; / must be 0 /
1987	};
1988
1989	struct v4l2_sliced_vbi_data {
1990	__u32 id;
1991	__u32 field; / 0: first field, 1: second field /
1992	__u32 line; / 1-23 /
1993	__u32 reserved; / must be 0 /
1994	__u8 data[`48`];
1995	};
1996
1997	/*
1998	* Sliced VBI data inserted into MPEG Streams
1999	*/
2000
2001	/*
2002	* V4L2_MPEG_STREAM_VBI_FMT_IVTV:
2003	*
2004	* Structure of payload contained in an MPEG 2 Private Stream 1 PES Packet in an
2005	* MPEG-2 Program Pack that contains V4L2_MPEG_STREAM_VBI_FMT_IVTV Sliced VBI
2006	* data
2007	*
2008	* Note, the MPEG-2 Program Pack and Private Stream 1 PES packet header
2009	* definitions are not included here. See the MPEG-2 specifications for details
2010	* on these headers.
2011	*/
2012
2013	/ Line type IDs /
2014	#define V4L2_MPEG_VBI_IVTV_TELETEXT_B (1)
2015	#define V4L2_MPEG_VBI_IVTV_CAPTION_525 (4)
2016	#define V4L2_MPEG_VBI_IVTV_WSS_625 (5)
2017	#define V4L2_MPEG_VBI_IVTV_VPS (7)
2018
2019	struct v4l2_mpeg_vbi_itv0_line {
2020	__u8 id; / One of V4L2_MPEG_VBI_IVTV_* above /
2021	__u8 data[`42`]; / Sliced VBI data for the line /
2022	} __attribute__ ((packed));
2023
2024	struct v4l2_mpeg_vbi_itv0 {
2025	__le32 linemask[`2`]; / Bitmasks of VBI service lines present /
2026	struct v4l2_mpeg_vbi_itv0_line line[`35`];
2027	} __attribute__ ((packed));
2028
2029	struct v4l2_mpeg_vbi_ITV0 {
2030	struct v4l2_mpeg_vbi_itv0_line line[`36`];
2031	} __attribute__ ((packed));
2032
2033	#define V4L2_MPEG_VBI_IVTV_MAGIC0 "itv0"
2034	#define V4L2_MPEG_VBI_IVTV_MAGIC1 "ITV0"
2035
2036	struct v4l2_mpeg_vbi_fmt_ivtv {
2037	__u8 magic[`4`];
2038	union {
2039	struct v4l2_mpeg_vbi_itv0 itv0;
2040	struct v4l2_mpeg_vbi_ITV0 ITV0;
2041	};
2042	} __attribute__ ((packed));
2043
2044	/*
2045	* A G G R E G A T E S T R U C T U R E S
2046	*/
2047
2048	/**
2049	* struct v4l2_plane_pix_format - additional, per-plane format definition
2050	* @sizeimage: maximum size in bytes required for data, for which
2051	* this plane will be used
2052	* @bytesperline: distance in bytes between the leftmost pixels in two
2053	* adjacent lines
2054	*/
2055	struct v4l2_plane_pix_format {
2056	__u32 sizeimage;
2057	__u32 bytesperline;
2058	__u16 reserved[`6`];
2059	} __attribute__ ((packed));
2060
2061	/**
2062	* struct v4l2_pix_format_mplane - multiplanar format definition
2063	* @width: image width in pixels
2064	* @height: image height in pixels
2065	* @pixelformat: little endian four character code (fourcc)
2066	* @field: enum v4l2_field; field order (for interlaced video)
2067	* @colorspace: enum v4l2_colorspace; supplemental to pixelformat
2068	* @plane_fmt: per-plane information
2069	* @num_planes: number of planes for this format
2070	* @flags: format flags (V4L2_PIX_FMT_FLAG_*)
2071	* @ycbcr_enc: enum v4l2_ycbcr_encoding, Y'CbCr encoding
2072	* @quantization: enum v4l2_quantization, colorspace quantization
2073	* @xfer_func: enum v4l2_xfer_func, colorspace transfer function
2074	*/
2075	struct v4l2_pix_format_mplane {
2076	__u32 width;
2077	__u32 height;
2078	__u32 pixelformat;
2079	__u32 field;
2080	__u32 colorspace;
2081
2082	struct v4l2_plane_pix_format plane_fmt[VIDEO_MAX_PLANES];
2083	__u8 num_planes;
2084	__u8 flags;
2085	union {
2086	__u8 ycbcr_enc;
2087	__u8 hsv_enc;
2088	};
2089	__u8 quantization;
2090	__u8 xfer_func;
2091	__u8 reserved[`7`];
2092	} __attribute__ ((packed));
2093
2094	/**
2095	* struct v4l2_sdr_format - SDR format definition
2096	* @pixelformat: little endian four character code (fourcc)
2097	* @buffersize: maximum size in bytes required for data
2098	*/
2099	struct v4l2_sdr_format {
2100	__u32 pixelformat;
2101	__u32 buffersize;
2102	__u8 reserved[`24`];
2103	} __attribute__ ((packed));
2104
2105	/**
2106	* struct v4l2_meta_format - metadata format definition
2107	* @dataformat: little endian four character code (fourcc)
2108	* @buffersize: maximum size in bytes required for data
2109	*/
2110	struct v4l2_meta_format {
2111	__u32 dataformat;
2112	__u32 buffersize;
2113	} __attribute__ ((packed));
2114
2115	/**
2116	* struct v4l2_format - stream data format
2117	* @type: enum v4l2_buf_type; type of the data stream
2118	* @pix: definition of an image format
2119	* @pix_mp: definition of a multiplanar image format
2120	* @win: definition of an overlaid image
2121	* @vbi: raw VBI capture or output parameters
2122	* @sliced: sliced VBI capture or output parameters
2123	* @raw_data: placeholder for future extensions and custom formats
2124	*/
2125	struct v4l2_format {
2126	__u32 type;
2127	union {
2128	struct v4l2_pix_format pix; / V4L2_BUF_TYPE_VIDEO_CAPTURE /
2129	struct v4l2_pix_format_mplane pix_mp; / V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE /
2130	struct v4l2_window win; / V4L2_BUF_TYPE_VIDEO_OVERLAY /
2131	struct v4l2_vbi_format vbi; / V4L2_BUF_TYPE_VBI_CAPTURE /
2132	struct v4l2_sliced_vbi_format sliced; / V4L2_BUF_TYPE_SLICED_VBI_CAPTURE /
2133	struct v4l2_sdr_format sdr; / V4L2_BUF_TYPE_SDR_CAPTURE /
2134	struct v4l2_meta_format meta; / V4L2_BUF_TYPE_META_CAPTURE /
2135	__u8 raw_data[`200`]; / user-defined /
2136	} fmt;
2137	};
2138
2139	/ Stream type-dependent parameters*
2140	*/
2141	struct v4l2_streamparm {
2142	__u32 type; / enum v4l2_buf_type /
2143	union {
2144	struct v4l2_captureparm capture;
2145	struct v4l2_outputparm output;
2146	__u8 raw_data[`200`]; / user-defined /
2147	} parm;
2148	};
2149
2150	/*
2151	* E V E N T S
2152	*/
2153
2154	#define V4L2_EVENT_ALL 0
2155	#define V4L2_EVENT_VSYNC 1
2156	#define V4L2_EVENT_EOS 2
2157	#define V4L2_EVENT_CTRL 3
2158	#define V4L2_EVENT_FRAME_SYNC 4
2159	#define V4L2_EVENT_SOURCE_CHANGE 5
2160	#define V4L2_EVENT_MOTION_DET 6
2161	#define V4L2_EVENT_PRIVATE_START 0x08000000
2162
2163	/ Payload for V4L2_EVENT_VSYNC /
2164	struct v4l2_event_vsync {
2165	/ Can be V4L2_FIELD_ANY, _NONE, _TOP or _BOTTOM /
2166	__u8 field;
2167	} __attribute__ ((packed));
2168
2169	/ Payload for V4L2_EVENT_CTRL /
2170	#define V4L2_EVENT_CTRL_CH_VALUE (1 << 0)
2171	#define V4L2_EVENT_CTRL_CH_FLAGS (1 << 1)
2172	#define V4L2_EVENT_CTRL_CH_RANGE (1 << 2)
2173
2174	struct v4l2_event_ctrl {
2175	__u32 changes;
2176	__u32 type;
2177	union {
2178	__s32 value;
2179	__s64 value64;
2180	};
2181	__u32 flags;
2182	__s32 minimum;
2183	__s32 maximum;
2184	__s32 step;
2185	__s32 default_value;
2186	};
2187
2188	struct v4l2_event_frame_sync {
2189	__u32 frame_sequence;
2190	};
2191
2192	#define V4L2_EVENT_SRC_CH_RESOLUTION (1 << 0)
2193
2194	struct v4l2_event_src_change {
2195	__u32 changes;
2196	};
2197
2198	#define V4L2_EVENT_MD_FL_HAVE_FRAME_SEQ (1 << 0)
2199
2200	/**
2201	* struct v4l2_event_motion_det - motion detection event
2202	* @flags: if V4L2_EVENT_MD_FL_HAVE_FRAME_SEQ is set, then the
2203	* frame_sequence field is valid.
2204	* @frame_sequence: the frame sequence number associated with this event.
2205	* @region_mask: which regions detected motion.
2206	*/
2207	struct v4l2_event_motion_det {
2208	__u32 flags;
2209	__u32 frame_sequence;
2210	__u32 region_mask;
2211	};
2212
2213	struct v4l2_event {
2214	__u32 type;
2215	union {
2216	struct v4l2_event_vsync vsync;
2217	struct v4l2_event_ctrl ctrl;
2218	struct v4l2_event_frame_sync frame_sync;
2219	struct v4l2_event_src_change src_change;
2220	struct v4l2_event_motion_det motion_det;
2221	__u8 data[`64`];
2222	} u;
2223	__u32 pending;
2224	__u32 sequence;
2225	struct timespec timestamp;
2226	__u32 id;
2227	__u32 reserved[`8`];
2228	};
2229
2230	#define V4L2_EVENT_SUB_FL_SEND_INITIAL (1 << 0)
2231	#define V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK (1 << 1)
2232
2233	struct v4l2_event_subscription {
2234	__u32 type;
2235	__u32 id;
2236	__u32 flags;
2237	__u32 reserved[`5`];
2238	};
2239
2240	/*
2241	* A D V A N C E D D E B U G G I N G
2242	*
2243	* NOTE: EXPERIMENTAL API, NEVER RELY ON THIS IN APPLICATIONS!
2244	* FOR DEBUGGING, TESTING AND INTERNAL USE ONLY!
2245	*/
2246
2247	/ VIDIOC_DBG_G_REGISTER and VIDIOC_DBG_S_REGISTER /
2248
2249	#define V4L2_CHIP_MATCH_BRIDGE 0 /* Match against chip ID on the bridge (0 for the bridge) */
2250	#define V4L2_CHIP_MATCH_SUBDEV 4 /* Match against subdev index */
2251
2252	/ The following four defines are no longer in use /
2253	#define V4L2_CHIP_MATCH_HOST V4L2_CHIP_MATCH_BRIDGE
2254	#define V4L2_CHIP_MATCH_I2C_DRIVER 1 /* Match against I2C driver name */
2255	#define V4L2_CHIP_MATCH_I2C_ADDR 2 /* Match against I2C 7-bit address */
2256	#define V4L2_CHIP_MATCH_AC97 3 /* Match against ancillary AC97 chip */
2257
2258	struct v4l2_dbg_match {
2259	__u32 type; / Match type /
2260	union { / Match this chip, meaning determined by type /
2261	__u32 addr;
2262	char name[`32`];
2263	};
2264	} __attribute__ ((packed));
2265
2266	struct v4l2_dbg_register {
2267	struct v4l2_dbg_match match;
2268	__u32 size; / register size in bytes /
2269	__u64 reg;
2270	__u64 val;
2271	} __attribute__ ((packed));
2272
2273	#define V4L2_CHIP_FL_READABLE (1 << 0)
2274	#define V4L2_CHIP_FL_WRITABLE (1 << 1)
2275
2276	/ VIDIOC_DBG_G_CHIP_INFO /
2277	struct v4l2_dbg_chip_info {
2278	struct v4l2_dbg_match match;
2279	char name[`32`];
2280	__u32 flags;
2281	__u32 reserved[`32`];
2282	} __attribute__ ((packed));
2283
2284	/**
2285	* struct v4l2_create_buffers - VIDIOC_CREATE_BUFS argument
2286	* @index: on return, index of the first created buffer
2287	* @count: entry: number of requested buffers,
2288	* return: number of created buffers
2289	* @memory: enum v4l2_memory; buffer memory type
2290	* @format: frame format, for which buffers are requested
2291	* @reserved: future extensions
2292	*/
2293	struct v4l2_create_buffers {
2294	__u32 index;
2295	__u32 count;
2296	__u32 memory;
2297	struct v4l2_format format;
2298	__u32 reserved[`8`];
2299	};
2300
2301	/*
2302	* I O C T L C O D E S F O R V I D E O D E V I C E S
2303	*
2304	*/
2305	#define VIDIOC_QUERYCAP _IOR('V', 0, struct v4l2_capability)
2306	#define VIDIOC_RESERVED _IO('V', 1)
2307	#define VIDIOC_ENUM_FMT _IOWR('V', 2, struct v4l2_fmtdesc)
2308	#define VIDIOC_G_FMT _IOWR('V', 4, struct v4l2_format)
2309	#define VIDIOC_S_FMT _IOWR('V', 5, struct v4l2_format)
2310	#define VIDIOC_REQBUFS _IOWR('V', 8, struct v4l2_requestbuffers)
2311	#define VIDIOC_QUERYBUF _IOWR('V', 9, struct v4l2_buffer)
2312	#define VIDIOC_G_FBUF _IOR('V', 10, struct v4l2_framebuffer)
2313	#define VIDIOC_S_FBUF _IOW('V', 11, struct v4l2_framebuffer)
2314	#define VIDIOC_OVERLAY _IOW('V', 14, int)
2315	#define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer)
2316	#define VIDIOC_EXPBUF _IOWR('V', 16, struct v4l2_exportbuffer)
2317	#define VIDIOC_DQBUF _IOWR('V', 17, struct v4l2_buffer)
2318	#define VIDIOC_STREAMON _IOW('V', 18, int)
2319	#define VIDIOC_STREAMOFF _IOW('V', 19, int)
2320	#define VIDIOC_G_PARM _IOWR('V', 21, struct v4l2_streamparm)
2321	#define VIDIOC_S_PARM _IOWR('V', 22, struct v4l2_streamparm)
2322	#define VIDIOC_G_STD _IOR('V', 23, v4l2_std_id)
2323	#define VIDIOC_S_STD _IOW('V', 24, v4l2_std_id)
2324	#define VIDIOC_ENUMSTD _IOWR('V', 25, struct v4l2_standard)
2325	#define VIDIOC_ENUMINPUT _IOWR('V', 26, struct v4l2_input)
2326	#define VIDIOC_G_CTRL _IOWR('V', 27, struct v4l2_control)
2327	#define VIDIOC_S_CTRL _IOWR('V', 28, struct v4l2_control)
2328	#define VIDIOC_G_TUNER _IOWR('V', 29, struct v4l2_tuner)
2329	#define VIDIOC_S_TUNER _IOW('V', 30, struct v4l2_tuner)
2330	#define VIDIOC_G_AUDIO _IOR('V', 33, struct v4l2_audio)
2331	#define VIDIOC_S_AUDIO _IOW('V', 34, struct v4l2_audio)
2332	#define VIDIOC_QUERYCTRL _IOWR('V', 36, struct v4l2_queryctrl)
2333	#define VIDIOC_QUERYMENU _IOWR('V', 37, struct v4l2_querymenu)
2334	#define VIDIOC_G_INPUT _IOR('V', 38, int)
2335	#define VIDIOC_S_INPUT _IOWR('V', 39, int)
2336	#define VIDIOC_G_EDID _IOWR('V', 40, struct v4l2_edid)
2337	#define VIDIOC_S_EDID _IOWR('V', 41, struct v4l2_edid)
2338	#define VIDIOC_G_OUTPUT _IOR('V', 46, int)
2339	#define VIDIOC_S_OUTPUT _IOWR('V', 47, int)
2340	#define VIDIOC_ENUMOUTPUT _IOWR('V', 48, struct v4l2_output)
2341	#define VIDIOC_G_AUDOUT _IOR('V', 49, struct v4l2_audioout)
2342	#define VIDIOC_S_AUDOUT _IOW('V', 50, struct v4l2_audioout)
2343	#define VIDIOC_G_MODULATOR _IOWR('V', 54, struct v4l2_modulator)
2344	#define VIDIOC_S_MODULATOR _IOW('V', 55, struct v4l2_modulator)
2345	#define VIDIOC_G_FREQUENCY _IOWR('V', 56, struct v4l2_frequency)
2346	#define VIDIOC_S_FREQUENCY _IOW('V', 57, struct v4l2_frequency)
2347	#define VIDIOC_CROPCAP _IOWR('V', 58, struct v4l2_cropcap)
2348	#define VIDIOC_G_CROP _IOWR('V', 59, struct v4l2_crop)
2349	#define VIDIOC_S_CROP _IOW('V', 60, struct v4l2_crop)
2350	#define VIDIOC_G_JPEGCOMP _IOR('V', 61, struct v4l2_jpegcompression)
2351	#define VIDIOC_S_JPEGCOMP _IOW('V', 62, struct v4l2_jpegcompression)
2352	#define VIDIOC_QUERYSTD _IOR('V', 63, v4l2_std_id)
2353	#define VIDIOC_TRY_FMT _IOWR('V', 64, struct v4l2_format)
2354	#define VIDIOC_ENUMAUDIO _IOWR('V', 65, struct v4l2_audio)
2355	#define VIDIOC_ENUMAUDOUT _IOWR('V', 66, struct v4l2_audioout)
2356	#define VIDIOC_G_PRIORITY _IOR('V', 67, __u32) /* enum v4l2_priority */
2357	#define VIDIOC_S_PRIORITY _IOW('V', 68, __u32) /* enum v4l2_priority */
2358	#define VIDIOC_G_SLICED_VBI_CAP _IOWR('V', 69, struct v4l2_sliced_vbi_cap)
2359	#define VIDIOC_LOG_STATUS _IO('V', 70)
2360	#define VIDIOC_G_EXT_CTRLS _IOWR('V', 71, struct v4l2_ext_controls)
2361	#define VIDIOC_S_EXT_CTRLS _IOWR('V', 72, struct v4l2_ext_controls)
2362	#define VIDIOC_TRY_EXT_CTRLS _IOWR('V', 73, struct v4l2_ext_controls)
2363	#define VIDIOC_ENUM_FRAMESIZES _IOWR('V', 74, struct v4l2_frmsizeenum)
2364	#define VIDIOC_ENUM_FRAMEINTERVALS _IOWR('V', 75, struct v4l2_frmivalenum)
2365	#define VIDIOC_G_ENC_INDEX _IOR('V', 76, struct v4l2_enc_idx)
2366	#define VIDIOC_ENCODER_CMD _IOWR('V', 77, struct v4l2_encoder_cmd)
2367	#define VIDIOC_TRY_ENCODER_CMD _IOWR('V', 78, struct v4l2_encoder_cmd)
2368
2369	/*
2370	* Experimental, meant for debugging, testing and internal use.
2371	* Only implemented if CONFIG_VIDEO_ADV_DEBUG is defined.
2372	* You must be root to use these ioctls. Never use these in applications!
2373	*/
2374	#define VIDIOC_DBG_S_REGISTER _IOW('V', 79, struct v4l2_dbg_register)
2375	#define VIDIOC_DBG_G_REGISTER _IOWR('V', 80, struct v4l2_dbg_register)
2376
2377	#define VIDIOC_S_HW_FREQ_SEEK _IOW('V', 82, struct v4l2_hw_freq_seek)
2378	#define VIDIOC_S_DV_TIMINGS _IOWR('V', 87, struct v4l2_dv_timings)
2379	#define VIDIOC_G_DV_TIMINGS _IOWR('V', 88, struct v4l2_dv_timings)
2380	#define VIDIOC_DQEVENT _IOR('V', 89, struct v4l2_event)
2381	#define VIDIOC_SUBSCRIBE_EVENT _IOW('V', 90, struct v4l2_event_subscription)
2382	#define VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
2383	#define VIDIOC_CREATE_BUFS _IOWR('V', 92, struct v4l2_create_buffers)
2384	#define VIDIOC_PREPARE_BUF _IOWR('V', 93, struct v4l2_buffer)
2385	#define VIDIOC_G_SELECTION _IOWR('V', 94, struct v4l2_selection)
2386	#define VIDIOC_S_SELECTION _IOWR('V', 95, struct v4l2_selection)
2387	#define VIDIOC_DECODER_CMD _IOWR('V', 96, struct v4l2_decoder_cmd)
2388	#define VIDIOC_TRY_DECODER_CMD _IOWR('V', 97, struct v4l2_decoder_cmd)
2389	#define VIDIOC_ENUM_DV_TIMINGS _IOWR('V', 98, struct v4l2_enum_dv_timings)
2390	#define VIDIOC_QUERY_DV_TIMINGS _IOR('V', 99, struct v4l2_dv_timings)
2391	#define VIDIOC_DV_TIMINGS_CAP _IOWR('V', 100, struct v4l2_dv_timings_cap)
2392	#define VIDIOC_ENUM_FREQ_BANDS _IOWR('V', 101, struct v4l2_frequency_band)
2393
2394	/*
2395	* Experimental, meant for debugging, testing and internal use.
2396	* Never use this in applications!
2397	*/
2398	#define VIDIOC_DBG_G_CHIP_INFO _IOWR('V', 102, struct v4l2_dbg_chip_info)
2399
2400	#define VIDIOC_QUERY_EXT_CTRL _IOWR('V', 103, struct v4l2_query_ext_ctrl)
2401
2402	/ Reminder: when adding new ioctls please add support for them to*
2403	drivers/media/v4l2-core/v4l2-compat-ioctl32.c as well! /*
2404
2405	#define BASE_VIDIOC_PRIVATE 192 /* 192-255 are private */
2406
2407	#endif /* __LINUX_VIDEODEV2_H */
2408

Browse the source code of include/linux/videodev2.h