Ticket #13653: 0006-remove-local-videodev2.h.patch

File 0006-remove-local-videodev2.h.patch, 96.2 KB (added by Gary Buhrmaster, 4 months ago)

remove local videodev2.h

  • mythtv/docs/doxygen-create-developer-docs.cfg

    From 039aab7231ecb47c88461bd588ebbf5aea8582bc Mon Sep 17 00:00:00 2001
    From: Gary Buhrmaster <gary.buhrmaster@gmail.com>
    Date: Tue, 14 Jul 2020 15:09:04 +0000
    Subject: [PATCH 6/7] remove local videodev2.h
    
    ---
     mythtv/docs/doxygen-create-developer-docs.cfg |    3 -
     mythtv/libs/libmythtv/videodev2.h             | 2432 -----------------
     2 files changed, 2435 deletions(-)
     delete mode 100644 mythtv/libs/libmythtv/videodev2.h
    
    diff --git a/mythtv/docs/doxygen-create-developer-docs.cfg b/mythtv/docs/doxygen-create-developer-docs.cfg
    index a6b875d191..d04ee783d9 100644
    a b EXCLUDE_PATTERNS = moc_*.cpp \ 
    859859                         */test/* \
    860860                         */.git
    861861
    862 # Copy of header from V4L2 code
    863 EXCLUDE_PATTERNS += videodev2.h
    864 
    865862# Skip files from the Qt3Support module.
    866863EXCLUDE_PATTERNS += mmembuf.cpp mmembuf.h \
    867864                    msocketdevice.cpp msocketdevice.h \
  • deleted file mythtv/libs/libmythtv/videodev2.h

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