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