~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/uapi/linux/videodev2.h

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp