Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/xf86-video-v4l/patches/xf86-video-v4l-0.2.0-support-v4l2-only-drivers.patch

    Contents of /trunk/xf86-video-v4l/patches/xf86-video-v4l-0.2.0-support-v4l2-only-drivers.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2579 - (show annotations) (download)
    Tue Jun 16 07:36:09 2015 UTC (8 years, 10 months ago) by niro
    File size: 144520 byte(s) 
    -fedoras v4l2 only patch
    1 diff --git a/src/v4l.c b/src/v4l.c
    2 --- a/src/v4l.c
    3 +++ b/src/v4l.c
    4 @@ -1,6 +1,9 @@
    5 /*
    6 - * video4linux Xv Driver
    7 + * video4linux Xv Driver
    8 * based on Michael Schimek's permedia 2 driver.
    9 + *
    10 + * Copyright (c) 2011 Mauro Carvalho Chehab <mchehab@redhat.com> for:
    11 + * - Major rewrite, as driver got ported to V4L2 API
    12 */
    13
    14 #ifdef HAVE_CONFIG_H
    15 @@ -9,12 +12,16 @@
    16
    17 #include <sys/types.h>
    18 #include <sys/stat.h>
    19 +#include <ctype.h>
    20 +
    21 #include <fcntl.h>
    22 #include <errno.h>
    23 #include <string.h>
    24 #include <stdio.h>
    25 +#include <unistd.h>
    26 +#include <sys/ioctl.h>
    27
    28 -#include "videodev.h"
    29 +#include "videodev2.h"
    30 #include "xf86.h"
    31 #include "xf86_OSproc.h"
    32 #include "xf86Pci.h"
    33 @@ -25,29 +32,32 @@
    34 #include "regionstr.h"
    35 #include "dgaproc.h"
    36 #include "xf86str.h"
    37 +#include "fourcc.h"
    38
    39 -#include <asm/ioctl.h> /* _IORW(xxx) #defines are here */
    40 +#include <asm/ioctl.h> /* _IORW(xxx) #defines are here */
    41
    42 -#if 0
    43 +#if 1
    44 # define DEBUG(x) (x)
    45 #else
    46 # define DEBUG(x)
    47 #endif
    48
    49 +/***************************************************************************/
    50 +
    51 static void V4LIdentify(int flags);
    52 static Bool V4LProbe(DriverPtr drv, int flags);
    53 static const OptionInfoRec * V4LAvailableOptions(int chipid, int busid);
    54
    55 _X_EXPORT DriverRec V4L = {
    56 - 40000,
    57 - "v4l",
    58 - V4LIdentify, /* Identify*/
    59 - V4LProbe, /* Probe */
    60 - V4LAvailableOptions,
    61 - NULL,
    62 - 0
    63 -};
    64 -
    65 + .driverVersion = 50000,
    66 + .driverName = "v4l",
    67 + .Identify = V4LIdentify,
    68 + .Probe = V4LProbe,
    69 + .AvailableOptions = V4LAvailableOptions,
    70 + .module = NULL,
    71 + .refCount = 0,
    72 + .driverFunc = NULL, /* FIXME: Need to implement for new probing mode */
    73 +};
    74
    75 #ifdef XFree86LOADER
    76
    77 @@ -55,16 +65,16 @@ static MODULESETUPPROTO(v4lSetup);
    78
    79 static XF86ModuleVersionInfo v4lVersRec =
    80 {
    81 - "v4l",
    82 - MODULEVENDORSTRING,
    83 - MODINFOSTRING1,
    84 - MODINFOSTRING2,
    85 - XORG_VERSION_CURRENT,
    86 - 0, 1, 1,
    87 - ABI_CLASS_VIDEODRV,
    88 - ABI_VIDEODRV_VERSION,
    89 - MOD_CLASS_NONE,
    90 - {0,0,0,0}
    91 + "v4l",
    92 + MODULEVENDORSTRING,
    93 + MODINFOSTRING1,
    94 + MODINFOSTRING2,
    95 + XORG_VERSION_CURRENT,
    96 + 0, 1, 1,
    97 + ABI_CLASS_VIDEODRV,
    98 + ABI_VIDEODRV_VERSION,
    99 + MOD_CLASS_NONE,
    100 + {0,0,0,0}
    101 };
    102
    103 _X_EXPORT XF86ModuleData v4lModuleData = { &v4lVersRec, v4lSetup, NULL };
    104 @@ -72,32 +82,32 @@ _X_EXPORT XF86ModuleData v4lModuleData =
    105 static pointer
    106 v4lSetup(pointer module, pointer opts, int *errmaj, int *errmin)
    107 {
    108 - const char *osname;
    109 - static Bool setupDone = FALSE;
    110 + const char *osname;
    111 + static Bool setupDone = FALSE;
    112
    113 - if (setupDone) {
    114 - if (errmaj)
    115 - *errmaj = LDR_ONCEONLY;
    116 - return NULL;
    117 - }
    118 -
    119 - setupDone = TRUE;
    120 + if (setupDone) {
    121 + if (errmaj)
    122 + *errmaj = LDR_ONCEONLY;
    123 + return NULL;
    124 + }
    125
    126 - /* Check that we're being loaded on a Linux system */
    127 - LoaderGetOS(&osname, NULL, NULL, NULL);
    128 - if (!osname || strcmp(osname, "linux") != 0) {
    129 - if (errmaj)
    130 - *errmaj = LDR_BADOS;
    131 - if (errmin)
    132 - *errmin = 0;
    133 - return NULL;
    134 - } else {
    135 - /* OK */
    136 + setupDone = TRUE;
    137
    138 - xf86AddDriver (&V4L, module, 0);
    139 -
    140 - return (pointer)1;
    141 - }
    142 + /* Check that we're being loaded on a Linux system */
    143 + LoaderGetOS(&osname, NULL, NULL, NULL);
    144 + if (!osname || strcmp(osname, "linux") != 0) {
    145 + if (errmaj)
    146 + *errmaj = LDR_BADOS;
    147 + if (errmin)
    148 + *errmin = 0;
    149 + return NULL;
    150 + } else {
    151 + /* OK */
    152 +
    153 + xf86AddDriver (&V4L, module, 0);
    154 +
    155 + return (pointer)1;
    156 + }
    157 }
    158
    159 #else
    160 @@ -112,25 +122,28 @@ v4lSetup(pointer module, pointer opts, i
    161 #define VIDEO_YUV 2 /* yuv overlay (to offscreen memory + hw scaling) */
    162 #define VIDEO_RECLIP 3 /* temporarly off, window clipping changes */
    163
    164 +typedef struct _XvV4LCtrlRec {
    165 + struct v4l2_queryctrl qctrl;
    166 + Atom xv;
    167 +} XvV4LCtrlRec, *XvV4LCtrlPtr;
    168 +
    169 typedef struct _PortPrivRec {
    170 ScrnInfoPtr pScrn;
    171 - FBAreaPtr pFBArea[2];
    172 - int VideoOn;
    173 - Bool StreamOn;
    174 + FBAreaPtr pFBArea[2];
    175 + int VideoOn;
    176 + Bool StreamOn;
    177
    178 /* file handle */
    179 - int nr;
    180 - struct video_capability cap;
    181 + int nr;
    182 + struct v4l2_capability cap;
    183
    184 /* RGB overlay */
    185 - struct video_buffer rgb_fbuf;
    186 - struct video_window rgb_win;
    187 - int rgbpalette;
    188 + struct v4l2_framebuffer rgb_fbuf;
    189 + struct v4l2_window rgb_win;
    190 int rgbdepth;
    191
    192 /* attributes */
    193 - struct video_picture pict;
    194 - struct video_audio audio;
    195 + CARD32 pixelformat;
    196
    197 XF86VideoEncodingPtr enc;
    198 int *input;
    199 @@ -145,24 +158,21 @@ typedef struct _PortPrivRec {
    200
    201 int yuv_width,yuv_height;
    202 XF86SurfacePtr surface;
    203 - struct video_buffer yuv_fbuf;
    204 - struct video_window yuv_win;
    205 + struct v4l2_framebuffer yuv_fbuf;
    206 + struct v4l2_window yuv_win;
    207 +
    208 + struct v4l2_standard *standard; /* FIXME: can be removed */
    209 +
    210 + XvV4LCtrlPtr XvV4LCtrl;
    211 + int n_qctrl;
    212 } PortPrivRec, *PortPrivPtr;
    213
    214 -#define XV_ENCODING "XV_ENCODING"
    215 -#define XV_BRIGHTNESS "XV_BRIGHTNESS"
    216 -#define XV_CONTRAST "XV_CONTRAST"
    217 -#define XV_SATURATION "XV_SATURATION"
    218 -#define XV_HUE "XV_HUE"
    219 +#define XV_ENCODING "XV_ENCODING"
    220 +#define XV_FREQ "XV_FREQ"
    221
    222 -#define XV_FREQ "XV_FREQ"
    223 -#define XV_MUTE "XV_MUTE"
    224 -#define XV_VOLUME "XV_VOLUME"
    225 +#define MAKE_ATOM(a) MakeAtom(a, strlen(a), TRUE)
    226
    227 -#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
    228 -
    229 -static Atom xvEncoding, xvBrightness, xvContrast, xvSaturation, xvHue;
    230 -static Atom xvFreq, xvMute, xvVolume;
    231 +static Atom xvEncoding, xvFreq;
    232
    233 static XF86VideoFormatRec
    234 InputVideoFormats[] = {
    235 @@ -176,16 +186,8 @@ InputVideoFormats[] = {
    236
    237 static const XF86AttributeRec Attributes[] = {
    238 {XvSettable | XvGettable, -1000, 1000, XV_ENCODING},
    239 - {XvSettable | XvGettable, -1000, 1000, XV_BRIGHTNESS},
    240 - {XvSettable | XvGettable, -1000, 1000, XV_CONTRAST},
    241 - {XvSettable | XvGettable, -1000, 1000, XV_SATURATION},
    242 - {XvSettable | XvGettable, -1000, 1000, XV_HUE},
    243 };
    244 -static const XF86AttributeRec VolumeAttr =
    245 - {XvSettable | XvGettable, -1000, 1000, XV_VOLUME};
    246 -static const XF86AttributeRec MuteAttr =
    247 - {XvSettable | XvGettable, 0, 1, XV_MUTE};
    248 -static const XF86AttributeRec FreqAttr =
    249 +static const XF86AttributeRec FreqAttr =
    250 {XvSettable | XvGettable, 0, 16*1000, XV_FREQ};
    251
    252
    253 @@ -206,59 +208,247 @@ static struct V4L_DEVICE {
    254 };
    255
    256 /* ---------------------------------------------------------------------- */
    257 -/* forward decl */
    258
    259 -static void V4lQueryBestSize(ScrnInfoPtr pScrn, Bool motion,
    260 - short vid_w, short vid_h, short drw_w, short drw_h,
    261 - unsigned int *p_w, unsigned int *p_h, pointer data);
    262 +static int SetV4LFmt(int fd, CARD32 pixelformat)
    263 +{
    264 + struct v4l2_framebuffer fbuf;
    265 + char *p = (char *)&pixelformat;
    266 +
    267 + memset(&fbuf, 0, sizeof(fbuf));
    268 + if (ioctl(fd, VIDIOC_G_FBUF, &fbuf) == -1) {
    269 + xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);
    270 + return errno;
    271 + }
    272 + if (fbuf.fmt.pixelformat != pixelformat) {
    273 + fbuf.fmt.pixelformat = pixelformat;
    274 + if (ioctl(fd, VIDIOC_S_FBUF, &fbuf) == -1) {
    275 + xf86Msg(X_ERROR, "v4l: Error %d: Can't set FBUF to %c%c%c%c\n",
    276 + errno, p[0], p[1], p[2], p[3]);
    277 + return errno;
    278 + }
    279 + }
    280 + DEBUG(xf86Msg(X_INFO, "v4l: Set overlay format to %c%c%c%c\n",
    281 + p[0], p[1], p[2], p[3]));
    282 + return 0;
    283 +}
    284 +static int GetV4LFmt(int fd, CARD32 *pixelformat)
    285 +{
    286 + struct v4l2_framebuffer fbuf;
    287 +
    288 + memset(&fbuf, 0, sizeof(fbuf));
    289 + if (ioctl(fd, VIDIOC_G_FBUF, &fbuf) == -1) {
    290 + xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);
    291 + return errno;
    292 + }
    293 +
    294 + *pixelformat = fbuf.fmt.pixelformat;
    295 +
    296 + return 0;
    297 +}
    298 +
    299 +#define ATTR_NAME_PREFIX "XV_"
    300 +static int AddControl(PortPrivPtr p, XF86AttributeRec **list, int *count,
    301 + struct v4l2_queryctrl *qctrl, int *n)
    302 +{
    303 + char *ptr;
    304 +
    305 +/* v4l_add_attr */
    306 + if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
    307 + return 0;
    308 + switch (qctrl->type) {
    309 + case V4L2_CTRL_TYPE_INTEGER:
    310 + case V4L2_CTRL_TYPE_BOOLEAN:
    311 + case V4L2_CTRL_TYPE_MENU:
    312 + case V4L2_CTRL_TYPE_BUTTON:
    313 + break;
    314 + default:
    315 + return 0;
    316 + }
    317 +
    318 + p->XvV4LCtrl = realloc(p->XvV4LCtrl, sizeof(XvV4LCtrlRec) * (*n + 1));
    319 + if (!p->XvV4LCtrl) {
    320 + if (*list) {
    321 + free (*list);
    322 + *count = 0;
    323 + *n = 0;
    324 + }
    325 + return -1;
    326 + }
    327 +
    328 + *list = realloc(*list, sizeof(XF86AttributeRec) * (*count + 1));
    329 + if (NULL == *list) {
    330 + if (p->XvV4LCtrl)
    331 + free (p->XvV4LCtrl);
    332 + *count = 0;
    333 + return -1;
    334 + }
    335 +
    336 + memset(*list + *count, 0, sizeof(XF86AttributeRec));
    337 + (*list)[*count].flags = XvSettable | XvGettable;
    338 +
    339 + if (qctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
    340 + (*list)[*count].flags &= ~XvSettable;
    341 + if (qctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
    342 + (*list)[*count].flags &= ~XvGettable;
    343 + (*list)[*count].min_value = qctrl->minimum;
    344 + (*list)[*count].max_value = qctrl->maximum;
    345 + (*list)[*count].name = malloc(strlen((char *)qctrl->name) + 1 + sizeof (ATTR_NAME_PREFIX));
    346 + strcpy((*list)[*count].name, ATTR_NAME_PREFIX);
    347 + strcat((*list)[*count].name, (char *)qctrl->name);
    348 + for (ptr = (*list)[*count].name; *ptr; ptr++) {
    349 + *ptr = toupper(*ptr);
    350 + if (*ptr == ' ')
    351 + *ptr = '_';
    352 + }
    353 +
    354 + p->XvV4LCtrl[*n].xv = MAKE_ATOM((*list)[*count].name);
    355 + memcpy(&p->XvV4LCtrl[*n].qctrl, qctrl, sizeof(*qctrl));
    356 +
    357 + xf86Msg(X_INFO, "v4l: add attr %s (Xv/GPA %d) (%d to %d)\n",
    358 + (*list)[*count].name, (int)p->XvV4LCtrl[*n].xv,
    359 + p->XvV4LCtrl[*n].qctrl.minimum,
    360 + p->XvV4LCtrl[*n].qctrl.maximum);
    361 +
    362 + (*count)++;
    363 + (*n)++;
    364 +
    365 + return 0;
    366 +}
    367 +
    368 +static void AddAllV4LControls(PortPrivPtr p, XF86AttributeRec **list,
    369 + int *count, int fd)
    370 +{
    371 + int entries = 0;
    372 + CARD32 id;
    373 + struct v4l2_queryctrl qctrl;
    374 +
    375 + memset(&qctrl, 0, sizeof(qctrl));
    376 + qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
    377 + while (!ioctl(fd, VIDIOC_QUERYCTRL, &qctrl)) {
    378 + if (AddControl(p, list, count, &qctrl, &entries))
    379 + return;
    380 + qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
    381 + }
    382 + if (qctrl.id != V4L2_CTRL_FLAG_NEXT_CTRL)
    383 + return;
    384 + for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
    385 + qctrl.id = id;
    386 + if (!ioctl(fd, VIDIOC_QUERYCTRL, &qctrl)) {
    387 + if (AddControl(p, list, count, &qctrl, &entries))
    388 + return;
    389 + }
    390 + }
    391 + qctrl.id = V4L2_CID_PRIVATE_BASE;
    392 + while (!ioctl(fd, VIDIOC_QUERYCTRL, &qctrl)) {
    393 + if (AddControl(p, list, count, &qctrl, &entries))
    394 + return;
    395 + qctrl.id++;
    396 + }
    397 + p->n_qctrl = entries;
    398 +}
    399
    400 /* ---------------------------------------------------------------------- */
    401
    402 +/* setup yuv overlay + hw scaling: look if we find some common video
    403 + format which both v4l driver and the X-Server can handle */
    404 +static int v4l_check_yuv(ScrnInfoPtr pScrn, PortPrivPtr pPPriv,
    405 + char *dev, int fd)
    406 +{
    407 + static const struct {
    408 + CARD32 v4l_palette;
    409 + unsigned int xv_id;
    410 + unsigned int xv_format;
    411 + } yuvlist[] = {
    412 + { V4L2_PIX_FMT_YUYV, FOURCC_YUY2, XvPacked },
    413 + { V4L2_PIX_FMT_UYVY, FOURCC_UYVY, XvPacked },
    414 + { 0 /* end of list */ },
    415 + };
    416 + /* FIXME: Why pScrn->scrnIndex? */
    417 + ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
    418 + int fmt,i;
    419 +
    420 + pPPriv->format = xf86XVQueryOffscreenImages(pScreen, &pPPriv->nformat);
    421 + xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    422 + "v4l: Number of Xv formats: %d\n", pPPriv->nformat);
    423 + if (!pPPriv->nformat)
    424 + return FALSE;
    425 +
    426 + for (fmt = 0; yuvlist[fmt].v4l_palette != 0; fmt++) {
    427 + pPPriv->pixelformat = yuvlist[fmt].v4l_palette;
    428 + if (-1 == SetV4LFmt(fd, pPPriv->pixelformat))
    429 + continue;
    430 + GetV4LFmt(fd, &pPPriv->pixelformat);
    431 + if (pPPriv->pixelformat != yuvlist[fmt].v4l_palette)
    432 + continue;
    433 + /* ... works, check available offscreen image formats now ... */
    434 + for (i = 0; i < pPPriv->nformat; i++) {
    435 + if (pPPriv->format[i].image->id == yuvlist[fmt].xv_id &&
    436 + pPPriv->format[i].image->format == yuvlist[fmt].xv_format) {
    437 + /* ... match found, good. */
    438 + pPPriv->yuv_format = yuvlist[fmt].v4l_palette;
    439 + pPPriv->myfmt = pPPriv->format+i;
    440 + xf86DrvMsg(pScrn->scrnIndex, X_INFO,
    441 + "v4l[%s]: using hw video scaling [%4.4s].\n",
    442 + dev,(char*)&(pPPriv->format[i].image->id));
    443 + return TRUE;
    444 + }
    445 + }
    446 + }
    447 + return TRUE;
    448 +}
    449 +
    450 static int V4lOpenDevice(PortPrivPtr pPPriv, ScrnInfoPtr pScrn)
    451 {
    452 static int first = 1;
    453
    454 +#if 0
    455 + /*
    456 + * It may be a good idea to probe here, but this would break
    457 + * some things, as initialization uses yuv_format
    458 + */
    459 + if (!pPPriv->yuv_format && first)
    460 + v4l_check_yuv(pScrn, pPPriv, V4L_NAME, V4L_FD);
    461 +#endif
    462 if (-1 == V4L_FD) {
    463 - V4L_FD = open(V4L_NAME, O_RDWR, 0);
    464 + V4L_FD = open(V4L_NAME, O_RDWR, 0);
    465
    466 - pPPriv->rgb_fbuf.width = pScrn->virtualX;
    467 - pPPriv->rgb_fbuf.height = pScrn->virtualY;
    468 - pPPriv->rgb_fbuf.depth = pScrn->bitsPerPixel;
    469 - pPPriv->rgb_fbuf.bytesperline = pScrn->displayWidth * ((pScrn->bitsPerPixel + 7)/8);
    470 - pPPriv->rgb_fbuf.base = (pointer)(pScrn->memPhysBase + pScrn->fbOffset);
    471 - if (first) {
    472 - first = 0;
    473 - xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    474 - "v4l: memPhysBase=0x%lx\n", pScrn->memPhysBase);
    475 - }
    476 + if (-1 == V4L_FD)
    477 + return errno;
    478
    479 - switch (pScrn->bitsPerPixel) {
    480 - case 16:
    481 - if (pScrn->weight.green == 5) {
    482 - pPPriv->rgbpalette = VIDEO_PALETTE_RGB555;
    483 - pPPriv->rgbdepth = 16;
    484 - } else {
    485 - pPPriv->rgbpalette = VIDEO_PALETTE_RGB565;
    486 - pPPriv->rgbdepth = 16;
    487 - }
    488 - break;
    489 - case 24:
    490 - pPPriv->rgbpalette = VIDEO_PALETTE_RGB24;
    491 - pPPriv->rgbdepth = 24;
    492 - break;
    493 - case 32:
    494 - pPPriv->rgbpalette = VIDEO_PALETTE_RGB32;
    495 - pPPriv->rgbdepth = 32;
    496 - break;
    497 - }
    498 + if (-1 == ioctl(V4L_FD, VIDIOC_G_FBUF, &pPPriv->rgb_fbuf)) {
    499 + xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);
    500 + return errno;
    501 + }
    502 + pPPriv->rgb_fbuf.fmt.width = pScrn->virtualX;
    503 + pPPriv->rgb_fbuf.fmt.height = pScrn->virtualY;
    504 + pPPriv->rgb_fbuf.fmt.bytesperline = pScrn->displayWidth * ((pScrn->bitsPerPixel + 7)/8);
    505 + pPPriv->rgb_fbuf.base = (pointer)(pScrn->memPhysBase + pScrn->fbOffset);
    506 + if (first) {
    507 + xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    508 + "v4l: memPhysBase=0x%lx\n", pScrn->memPhysBase);
    509 + first = 0;
    510 + }
    511 +
    512 + switch (pScrn->bitsPerPixel) {
    513 + case 16:
    514 + if (pScrn->weight.green == 5) {
    515 + pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB555;
    516 + } else {
    517 + pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB565;
    518 + }
    519 + break;
    520 + case 24:
    521 + pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_BGR24;
    522 + break;
    523 + case 32:
    524 + pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_BGR32;
    525 + break;
    526 + }
    527 }
    528
    529 - if (-1 == V4L_FD)
    530 - return errno;
    531 -
    532 V4L_REF++;
    533 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    534 - "Xv/open: refcount=%d\n",V4L_REF));
    535 + "Xv/open: refcount=%d\n",V4L_REF));
    536
    537 return 0;
    538 }
    539 @@ -267,10 +457,10 @@ static void V4lCloseDevice(PortPrivPtr p
    540 {
    541 V4L_REF--;
    542 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    543 - "Xv/close: refcount=%d\n",V4L_REF));
    544 + "Xv/close: refcount=%d\n",V4L_REF));
    545 if (0 == V4L_REF && -1 != V4L_FD) {
    546 - close(V4L_FD);
    547 - V4L_FD = -1;
    548 + close(V4L_FD);
    549 + V4L_FD = -1;
    550 }
    551 }
    552
    553 @@ -280,8 +470,10 @@ V4lPutVideo(ScrnInfoPtr pScrn,
    554 short vid_w, short vid_h, short drw_w, short drw_h,
    555 RegionPtr clipBoxes, pointer data, DrawablePtr pDraw)
    556 {
    557 + struct v4l2_format fmt;
    558 +
    559 PortPrivPtr pPPriv = (PortPrivPtr) data;
    560 - struct video_clip *clip;
    561 + struct v4l2_clip *clip;
    562 BoxPtr pBox;
    563 RegionRec newReg;
    564 BoxRec newBox;
    565 @@ -291,179 +483,214 @@ V4lPutVideo(ScrnInfoPtr pScrn,
    566
    567 /* Open a file handle to the device */
    568 if (VIDEO_OFF == pPPriv->VideoOn) {
    569 - if (V4lOpenDevice(pPPriv, pScrn))
    570 - return Success;
    571 + if (V4lOpenDevice(pPPriv, pScrn))
    572 + return Success;
    573 }
    574
    575 if (0 != pPPriv->yuv_format) {
    576 - DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/PV yuv\n"));
    577 - width = pPPriv->enc[pPPriv->cenc].width;
    578 + DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/PV yuv\n"));
    579 + width = pPPriv->enc[pPPriv->cenc].width;
    580 height = pPPriv->enc[pPPriv->cenc].height/2; /* no interlace */
    581 - if (drw_w < width)
    582 - width = drw_w;
    583 - if (drw_h < height)
    584 - height = drw_h;
    585 - if ((height != pPPriv->yuv_height) || (width != pPPriv->yuv_width)) {
    586 - /* new size -- free old surface */
    587 - DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, " surface resize\n"));
    588 - if (pPPriv->surface) {
    589 - pPPriv->VideoOn = VIDEO_OFF;
    590 - pPPriv->myfmt->stop(pPPriv->surface);
    591 - pPPriv->myfmt->free_surface(pPPriv->surface);
    592 - xfree(pPPriv->surface);
    593 - pPPriv->surface = NULL;
    594 - }
    595 - pPPriv->yuv_width = width;
    596 - pPPriv->yuv_height = height;
    597 - }
    598 - if (!pPPriv->surface) {
    599 - /* allocate + setup offscreen surface */
    600 - if (NULL == (pPPriv->surface = xalloc(sizeof(XF86SurfaceRec))))
    601 - return FALSE;
    602 - if (Success != pPPriv->myfmt->alloc_surface
    603 - (pScrn,pPPriv->myfmt->image->id,
    604 - pPPriv->yuv_width,pPPriv->yuv_height,pPPriv->surface)) {
    605 - xfree(pPPriv->surface);
    606 - pPPriv->surface = NULL;
    607 - goto fallback_to_rgb;
    608 - }
    609 - pPPriv->yuv_fbuf.width = pPPriv->surface->width;
    610 - pPPriv->yuv_fbuf.height = pPPriv->surface->height;
    611 - pPPriv->yuv_fbuf.depth = 16;
    612 - pPPriv->yuv_fbuf.bytesperline = pPPriv->surface->pitches[0];
    613 - pPPriv->yuv_fbuf.base =
    614 - (pointer)(pScrn->memPhysBase + pPPriv->surface->offsets[0]);
    615 - DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, " surface: %p+%d = %p, %dx%d, pitch %d\n",
    616 - pScrn->memPhysBase,pPPriv->surface->offsets[0],
    617 - pScrn->memPhysBase+pPPriv->surface->offsets[0],
    618 - pPPriv->surface->width,pPPriv->surface->height,
    619 - pPPriv->surface->pitches[0]));
    620 - pPPriv->yuv_win.width = pPPriv->surface->width;
    621 - pPPriv->yuv_win.height = pPPriv->surface->height;
    622 - }
    623 + if (drw_w < width)
    624 + width = drw_w;
    625 + if (drw_h < height)
    626 + height = drw_h;
    627 + if ((height != pPPriv->yuv_height) || (width != pPPriv->yuv_width)) {
    628 + /* new size -- free old surface */
    629 + DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, " surface resize\n"));
    630 + if (pPPriv->surface) {
    631 + pPPriv->VideoOn = VIDEO_OFF;
    632 + pPPriv->myfmt->stop(pPPriv->surface);
    633 + pPPriv->myfmt->free_surface(pPPriv->surface);
    634 + free(pPPriv->surface);
    635 + pPPriv->surface = NULL;
    636 + }
    637 + pPPriv->yuv_width = width;
    638 + pPPriv->yuv_height = height;
    639 + }
    640 + if (!pPPriv->surface) {
    641 + /* allocate + setup offscreen surface */
    642 + if (NULL == (pPPriv->surface = malloc(sizeof(XF86SurfaceRec))))
    643 + return FALSE;
    644 + if (Success != pPPriv->myfmt->alloc_surface
    645 + (pScrn,pPPriv->myfmt->image->id,
    646 + pPPriv->yuv_width,pPPriv->yuv_height,pPPriv->surface)) {
    647 + free(pPPriv->surface);
    648 + pPPriv->surface = NULL;
    649 + goto fallback_to_rgb;
    650 + }
    651
    652 - /* program driver */
    653 - if (-1 == ioctl(V4L_FD,VIDIOCSFBUF,&(pPPriv->yuv_fbuf)))
    654 - perror("ioctl VIDIOCSFBUF");
    655 - if (-1 == ioctl(V4L_FD,VIDIOCGPICT,&pPPriv->pict))
    656 - perror("ioctl VIDIOCGPICT");
    657 - pPPriv->pict.palette = pPPriv->yuv_format;
    658 - pPPriv->pict.depth = 16;
    659 - if (-1 == ioctl(V4L_FD,VIDIOCSPICT,&pPPriv->pict))
    660 - perror("ioctl VIDIOCSPICT");
    661 - if (-1 == ioctl(V4L_FD,VIDIOCSWIN,&(pPPriv->yuv_win)))
    662 - perror("ioctl VIDIOCSWIN");
    663 - if (-1 == ioctl(V4L_FD, VIDIOCCAPTURE, &one))
    664 - perror("ioctl VIDIOCCAPTURE(1)");
    665 + if (-1 == ioctl(V4L_FD, VIDIOC_G_FBUF, &pPPriv->yuv_fbuf)) {
    666 + xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);
    667 + return errno;
    668 + }
    669 + pPPriv->yuv_fbuf.fmt.width = pPPriv->surface->width;
    670 + pPPriv->yuv_fbuf.fmt.height = pPPriv->surface->height;
    671 + pPPriv->yuv_fbuf.fmt.bytesperline = pPPriv->surface->pitches[0];
    672 + pPPriv->yuv_fbuf.fmt.pixelformat = pPPriv->yuv_format;
    673 + pPPriv->yuv_fbuf.base =
    674 + (pointer)(pScrn->memPhysBase + pPPriv->surface->offsets[0]);
    675 + DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    676 + " surface: %p+%d = %p, %dx%d, pitch %d\n",
    677 + (void *)pScrn->memPhysBase, pPPriv->surface->offsets[0],
    678 + (void *)pScrn->memPhysBase+pPPriv->surface->offsets[0],
    679 + pPPriv->surface->width, pPPriv->surface->height,
    680 + pPPriv->surface->pitches[0]));
    681 + memset(&pPPriv->yuv_win, 0, sizeof(pPPriv->yuv_win));
    682 + pPPriv->yuv_win.w.left = 0;
    683 + pPPriv->yuv_win.w.top = 0;
    684 + pPPriv->yuv_win.w.width = pPPriv->surface->width;
    685 + pPPriv->yuv_win.w.height = pPPriv->surface->height;
    686 + }
    687
    688 - if (0 == (pPPriv->myfmt->flags & VIDEO_INVERT_CLIPLIST)) {
    689 - /* invert cliplist */
    690 - newBox.x1 = drw_x;
    691 - newBox.y1 = drw_y;
    692 - newBox.x2 = drw_x + drw_w;
    693 - newBox.y2 = drw_y + drw_h;
    694 + /* program driver */
    695 + if (-1 == ioctl(V4L_FD, VIDIOC_S_FBUF, &pPPriv->yuv_fbuf)) {
    696 + xf86Msg(X_ERROR, "Error %d at VIDIOC_S_FBUF\n", errno);
    697 + return BadValue;
    698 + }
    699 + pPPriv->pixelformat = pPPriv->yuv_format;
    700 + if (-1 == SetV4LFmt(V4L_FD, pPPriv->pixelformat))
    701 + return BadValue;
    702
    703 - if (pPPriv->myfmt->flags & VIDEO_CLIP_TO_VIEWPORT) {
    704 - /* trim to the viewport */
    705 - if(newBox.x1 < pScrn->frameX0)
    706 - newBox.x1 = pScrn->frameX0;
    707 - if(newBox.x2 > pScrn->frameX1)
    708 - newBox.x2 = pScrn->frameX1;
    709 -
    710 - if(newBox.y1 < pScrn->frameY0)
    711 - newBox.y1 = pScrn->frameY0;
    712 - if(newBox.y2 > pScrn->frameY1)
    713 - newBox.y2 = pScrn->frameY1;
    714 - }
    715 + memset(&fmt, 0, sizeof(fmt));
    716 + fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
    717 + memcpy(&fmt.fmt.win, &pPPriv->yuv_win, sizeof(pPPriv->yuv_win));
    718 + if (-1 == ioctl(V4L_FD, VIDIOC_S_FMT, &fmt)) {
    719 + xf86Msg(X_ERROR, "Error %d at VIDIOC_S_FMT\n", errno);
    720 + return BadValue;
    721 + }
    722 + if (-1 == ioctl(V4L_FD, VIDIOC_OVERLAY, &one)) {
    723 + xf86Msg(X_ERROR, "v4l: Error %d while enabling Overlay\n", errno);
    724 + return BadValue;
    725 + }
    726
    727 - REGION_INIT(pScrn->pScreen, &newReg, &newBox, 1);
    728 - REGION_SUBTRACT(pScrn->pScreen, &newReg, &newReg, clipBoxes);
    729 - clipBoxes = &newReg;
    730 - }
    731 -
    732 - /* start overlay */
    733 - DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    734 - "over: - %d,%d -> %d,%d (%dx%d) (yuv=%dx%d)\n",
    735 - drw_x, drw_y,
    736 - drw_x+drw_w, drw_y+drw_h,
    737 - drw_w, drw_h,
    738 - pPPriv->surface->width,pPPriv->surface->height));
    739 - pPPriv->myfmt->display(pPPriv->surface,
    740 - 0, 0, drw_x, drw_y,
    741 - pPPriv->surface->width,
    742 - pPPriv->surface->height,
    743 - drw_w, drw_h,
    744 - clipBoxes);
    745 - if (0 == (pPPriv->myfmt->flags & VIDEO_INVERT_CLIPLIST)) {
    746 - REGION_UNINIT(pScrn->pScreen, &newReg);
    747 - }
    748 - pPPriv->VideoOn = VIDEO_YUV;
    749 - return Success;
    750 + if (0 == (pPPriv->myfmt->flags & VIDEO_INVERT_CLIPLIST)) {
    751 + /* invert cliplist */
    752 + newBox.x1 = drw_x;
    753 + newBox.y1 = drw_y;
    754 + newBox.x2 = drw_x + drw_w;
    755 + newBox.y2 = drw_y + drw_h;
    756 +
    757 + if (pPPriv->myfmt->flags & VIDEO_CLIP_TO_VIEWPORT) {
    758 + /* trim to the viewport */
    759 + if(newBox.x1 < pScrn->frameX0)
    760 + newBox.x1 = pScrn->frameX0;
    761 + if(newBox.x2 > pScrn->frameX1)
    762 + newBox.x2 = pScrn->frameX1;
    763 +
    764 + if(newBox.y1 < pScrn->frameY0)
    765 + newBox.y1 = pScrn->frameY0;
    766 + if(newBox.y2 > pScrn->frameY1)
    767 + newBox.y2 = pScrn->frameY1;
    768 + }
    769 +
    770 + REGION_INIT(pScrn->pScreen, &newReg, &newBox, 1);
    771 + REGION_SUBTRACT(pScrn->pScreen, &newReg, &newReg, clipBoxes);
    772 + clipBoxes = &newReg;
    773 + }
    774 +
    775 + /* start overlay */
    776 + DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    777 + "over: - %d,%d -> %d,%d (%dx%d) (yuv=%dx%d)\n",
    778 + drw_x, drw_y,
    779 + drw_x+drw_w, drw_y+drw_h,
    780 + drw_w, drw_h,
    781 + pPPriv->surface->width,pPPriv->surface->height));
    782 + pPPriv->myfmt->display(pPPriv->surface,
    783 + 0, 0, drw_x, drw_y,
    784 + pPPriv->surface->width,
    785 + pPPriv->surface->height,
    786 + drw_w, drw_h,
    787 + clipBoxes);
    788 + if (0 == (pPPriv->myfmt->flags & VIDEO_INVERT_CLIPLIST)) {
    789 + REGION_UNINIT(pScrn->pScreen, &newReg);
    790 + }
    791 + pPPriv->VideoOn = VIDEO_YUV;
    792 + return Success;
    793 }
    794
    795 - fallback_to_rgb:
    796 +fallback_to_rgb:
    797 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/PV rgb\n"));
    798 /* FIXME: vid-* is ignored for now, not supported by v4l */
    799
    800 dw = (drw_w < pPPriv->enc[pPPriv->cenc].width) ?
    801 - drw_w : pPPriv->enc[pPPriv->cenc].width;
    802 + drw_w : pPPriv->enc[pPPriv->cenc].width;
    803 dh = (drw_h < pPPriv->enc[pPPriv->cenc].height) ?
    804 - drw_h : pPPriv->enc[pPPriv->cenc].height;
    805 + drw_h : pPPriv->enc[pPPriv->cenc].height;
    806 /* if the window is too big, center the video */
    807 dx = drw_x + (drw_w - dw)/2;
    808 dy = drw_y + (drw_h - dh)/2;
    809 /* bttv prefeares aligned addresses */
    810 dx &= ~3;
    811 - if (dx < drw_x) dx += 4;
    812 - if (dx+dw > drw_x+drw_w) dw -= 4;
    813 + if (dx < drw_x)
    814 + dx += 4;
    815 + if (dx+dw > drw_x+drw_w)
    816 + dw -= 4;
    817
    818 /* window */
    819 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, " win: %dx%d+%d+%d\n",
    820 - drw_w,drw_h,drw_x,drw_y));
    821 + drw_w,drw_h,drw_x,drw_y));
    822 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, " use: %dx%d+%d+%d\n",
    823 - dw,dh,dx,dy));
    824 - pPPriv->rgb_win.x = dx;
    825 - pPPriv->rgb_win.y = dy;
    826 - pPPriv->rgb_win.width = dw;
    827 - pPPriv->rgb_win.height = dh;
    828 - pPPriv->rgb_win.flags = 0;
    829 -
    830 + dw,dh,dx,dy));
    831 + memset(&pPPriv->rgb_win, 0, sizeof(pPPriv->rgb_win));
    832 + pPPriv->rgb_win.w.left = dx;
    833 + pPPriv->rgb_win.w.top = dy;
    834 + pPPriv->rgb_win.w.width = dw;
    835 + pPPriv->rgb_win.w.height = dh;
    836 +
    837 /* clipping */
    838 if (pPPriv->rgb_win.clips) {
    839 - xfree(pPPriv->rgb_win.clips);
    840 - pPPriv->rgb_win.clips = NULL;
    841 + free(pPPriv->rgb_win.clips);
    842 + pPPriv->rgb_win.clips = NULL;
    843 }
    844 pPPriv->rgb_win.clipcount = REGION_NUM_RECTS(clipBoxes);
    845 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2," clip: have #%d\n",
    846 - pPPriv->rgb_win.clipcount));
    847 + pPPriv->rgb_win.clipcount));
    848 if (0 != pPPriv->rgb_win.clipcount) {
    849 - pPPriv->rgb_win.clips = xalloc(pPPriv->rgb_win.clipcount*sizeof(struct video_clip));
    850 - if (NULL != pPPriv->rgb_win.clips) {
    851 - memset(pPPriv->rgb_win.clips,0,pPPriv->rgb_win.clipcount*sizeof(struct video_clip));
    852 - pBox = REGION_RECTS(clipBoxes);
    853 - clip = pPPriv->rgb_win.clips;
    854 - for (i = 0; i < REGION_NUM_RECTS(clipBoxes); i++, pBox++, clip++) {
    855 - clip->x = pBox->x1 - dx;
    856 - clip->y = pBox->y1 - dy;
    857 - clip->width = pBox->x2 - pBox->x1;
    858 - clip->height = pBox->y2 - pBox->y1;
    859 - }
    860 - }
    861 + pPPriv->rgb_win.clips = malloc(pPPriv->rgb_win.clipcount*sizeof(struct v4l2_clip));
    862 + if (NULL != pPPriv->rgb_win.clips) {
    863 + memset(pPPriv->rgb_win.clips,0,pPPriv->rgb_win.clipcount*sizeof(struct v4l2_clip));
    864 + pBox = REGION_RECTS(clipBoxes);
    865 + clip = pPPriv->rgb_win.clips;
    866 +
    867 + /*
    868 + * FIXME: This code currently does nothing, as we don't emulate
    869 + * The V4L1 clipping stuff
    870 + */
    871 + for (i = 0; i < REGION_NUM_RECTS(clipBoxes); i++, pBox++, clip++) {
    872 + clip->c.left = pBox->x1 - dx;
    873 + clip->c.top = pBox->y1 - dy;
    874 + clip->c.width = pBox->x2 - pBox->x1;
    875 + clip->c.height = pBox->y2 - pBox->y1;
    876 + }
    877 + }
    878 }
    879
    880 /* start */
    881 - if (-1 == ioctl(V4L_FD,VIDIOCSFBUF,&(pPPriv->rgb_fbuf)))
    882 - perror("ioctl VIDIOCSFBUF");
    883 - if (-1 == ioctl(V4L_FD,VIDIOCGPICT,&pPPriv->pict))
    884 - perror("ioctl VIDIOCGPICT");
    885 - pPPriv->pict.palette = pPPriv->rgbpalette;
    886 - pPPriv->pict.depth = pPPriv->rgbdepth;
    887 - if (-1 == ioctl(V4L_FD,VIDIOCSPICT,&pPPriv->pict))
    888 - perror("ioctl VIDIOCSPICT");
    889 - if (-1 == ioctl(V4L_FD,VIDIOCSWIN,&(pPPriv->rgb_win)))
    890 - perror("ioctl VIDIOCSWIN");
    891 - if (-1 == ioctl(V4L_FD, VIDIOCCAPTURE, &one))
    892 - perror("ioctl VIDIOCCAPTURE(1)");
    893 + if (-1 == ioctl(V4L_FD, VIDIOC_S_FBUF, &pPPriv->rgb_fbuf)) {
    894 + xf86Msg(X_ERROR, "Error %d at VIDIOC_S_FBUF\n", errno);
    895 + return BadValue;
    896 + }
    897 + if (-1 == GetV4LFmt(V4L_FD, &pPPriv->pixelformat)) {
    898 + xf86Msg(X_ERROR, "Error %d getting pixelformat\n", errno);
    899 + return BadValue;
    900 + }
    901 + pPPriv->pixelformat = pPPriv->rgb_fbuf.fmt.pixelformat;
    902 + if (-1 == SetV4LFmt(V4L_FD, pPPriv->pixelformat)) {
    903 + xf86Msg(X_ERROR, "Error %d getting pixelformat\n", errno);
    904 + return BadValue;
    905 + }
    906 + memset(&fmt, 0, sizeof(fmt));
    907 + fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
    908 + memcpy(&fmt.fmt.win, &pPPriv->rgb_win, sizeof(pPPriv->rgb_win));
    909 + if (-1 == ioctl(V4L_FD, VIDIOC_S_FMT, &fmt)) {
    910 + xf86Msg(X_ERROR, "Error %d at VIDIOC_S_FMT\n", errno);
    911 + return BadValue;
    912 + }
    913 + if (-1 == ioctl(V4L_FD, VIDIOC_OVERLAY, &one)) {
    914 + xf86Msg(X_ERROR, "v4l: Error %d while enabling Overlay\n", errno);
    915 + return BadValue;
    916 + }
    917 pPPriv->VideoOn = VIDEO_RGB;
    918
    919 return Success;
    920 @@ -476,7 +703,7 @@ V4lPutStill(ScrnInfoPtr pScrn,
    921 RegionPtr clipBoxes, pointer data, DrawablePtr pDraw)
    922 {
    923 #if 0
    924 - PortPrivPtr pPPriv = (PortPrivPtr) data;
    925 + PortPrivPtr pPPriv = (PortPrivPtr) data;
    926 #endif
    927
    928 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/PS\n"));
    929 @@ -488,177 +715,152 @@ V4lPutStill(ScrnInfoPtr pScrn,
    930 static void
    931 V4lStopVideo(ScrnInfoPtr pScrn, pointer data, Bool shutdown)
    932 {
    933 - PortPrivPtr pPPriv = (PortPrivPtr) data;
    934 + PortPrivPtr pPPriv = (PortPrivPtr) data;
    935 int zero=0;
    936
    937 if (VIDEO_OFF == pPPriv->VideoOn) {
    938 - DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    939 - "Xv/StopVideo called with video already off\n"));
    940 - return;
    941 + DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    942 + "Xv/StopVideo called with video already off\n"));
    943 + return;
    944 }
    945 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/StopVideo shutdown=%d\n",shutdown));
    946
    947 if (!shutdown) {
    948 - /* just reclipping, we have to stop DMA transfers to the visible screen */
    949 - if (VIDEO_RGB == pPPriv->VideoOn) {
    950 - if (-1 == ioctl(V4L_FD, VIDIOCCAPTURE, &zero))
    951 - perror("ioctl VIDIOCCAPTURE(0)");
    952 - pPPriv->VideoOn = VIDEO_RECLIP;
    953 - }
    954 + /* just reclipping, we have to stop DMA transfers to the visible screen */
    955 + if (VIDEO_RGB == pPPriv->VideoOn) {
    956 + if (-1 == ioctl(V4L_FD, VIDIOC_OVERLAY, &zero))
    957 + xf86Msg(X_ERROR, "v4l: Error %d while disabling Overlay\n", errno);
    958 + pPPriv->VideoOn = VIDEO_RECLIP;
    959 + }
    960 } else {
    961 - /* video stop - turn off and free everything */
    962 - if (VIDEO_YUV == pPPriv->VideoOn) {
    963 - pPPriv->myfmt->stop(pPPriv->surface);
    964 - pPPriv->myfmt->free_surface(pPPriv->surface);
    965 - xfree(pPPriv->surface);
    966 - pPPriv->surface = NULL;
    967 - }
    968 - if (-1 == ioctl(V4L_FD, VIDIOCCAPTURE, &zero))
    969 - perror("ioctl VIDIOCCAPTURE(0)");
    970 -
    971 - V4lCloseDevice(pPPriv,pScrn);
    972 - pPPriv->VideoOn = VIDEO_OFF;
    973 + /* video stop - turn off and free everything */
    974 + if (VIDEO_YUV == pPPriv->VideoOn) {
    975 + pPPriv->myfmt->stop(pPPriv->surface);
    976 + pPPriv->myfmt->free_surface(pPPriv->surface);
    977 + free(pPPriv->surface);
    978 + pPPriv->surface = NULL;
    979 + }
    980 + if (-1 == ioctl(V4L_FD, VIDIOC_OVERLAY, &zero))
    981 + xf86Msg(X_ERROR, "v4l: Error %d while disabling Overlay\n", errno);
    982 +
    983 + V4lCloseDevice(pPPriv,pScrn);
    984 + pPPriv->VideoOn = VIDEO_OFF;
    985 }
    986 }
    987
    988 -/* v4l uses range 0 - 65535; Xv uses -1000 - 1000 */
    989 -static int
    990 -v4l_to_xv(int val) {
    991 - val = val * 2000 / 65536 - 1000;
    992 - if (val < -1000) val = -1000;
    993 - if (val > 1000) val = 1000;
    994 - return val;
    995 -}
    996 -static int
    997 -xv_to_v4l(int val) {
    998 - val = val * 65536 / 2000 + 32768;
    999 - if (val < -0) val = 0;
    1000 - if (val > 65535) val = 65535;
    1001 - return val;
    1002 -}
    1003 -
    1004 static int
    1005 V4lSetPortAttribute(ScrnInfoPtr pScrn,
    1006 Atom attribute, INT32 value, pointer data)
    1007 {
    1008 - PortPrivPtr pPPriv = (PortPrivPtr) data;
    1009 - struct video_channel chan;
    1010 - int ret = Success;
    1011 + struct v4l2_control ctrl;
    1012 + PortPrivPtr pPPriv = (PortPrivPtr) data;
    1013 + int i, ret = BadValue;
    1014
    1015 if (V4lOpenDevice(pPPriv, pScrn))
    1016 - return Success;
    1017 + return Success;
    1018
    1019 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/SPA %d, %d\n",
    1020 - attribute, value));
    1021 + (int)attribute, (int)value));
    1022
    1023 if (-1 == V4L_FD) {
    1024 - ret = Success;
    1025 + ret = Success;
    1026 } else if (attribute == xvEncoding) {
    1027 - if (value >= 0 && value < pPPriv->nenc) {
    1028 - pPPriv->cenc = value;
    1029 - chan.channel = pPPriv->input[value];
    1030 - chan.norm = pPPriv->norm[value];
    1031 - if (-1 == ioctl(V4L_FD,VIDIOCSCHAN,&chan))
    1032 - perror("ioctl VIDIOCSCHAN");
    1033 - } else {
    1034 - ret = BadValue;
    1035 - }
    1036 - } else if (attribute == xvBrightness ||
    1037 - attribute == xvContrast ||
    1038 - attribute == xvSaturation ||
    1039 - attribute == xvHue) {
    1040 - ioctl(V4L_FD,VIDIOCGPICT,&pPPriv->pict);
    1041 - if (attribute == xvBrightness) pPPriv->pict.brightness = xv_to_v4l(value);
    1042 - if (attribute == xvContrast) pPPriv->pict.contrast = xv_to_v4l(value);
    1043 - if (attribute == xvSaturation) pPPriv->pict.colour = xv_to_v4l(value);
    1044 - if (attribute == xvHue) pPPriv->pict.hue = xv_to_v4l(value);
    1045 - if (-1 == ioctl(V4L_FD,VIDIOCSPICT,&pPPriv->pict))
    1046 - perror("ioctl VIDIOCSPICT");
    1047 - } else if (attribute == xvMute ||
    1048 - attribute == xvVolume) {
    1049 - ioctl(V4L_FD,VIDIOCGAUDIO,&pPPriv->audio);
    1050 - if (attribute == xvMute) {
    1051 - if (value)
    1052 - pPPriv->audio.flags |= VIDEO_AUDIO_MUTE;
    1053 - else
    1054 - pPPriv->audio.flags &= ~VIDEO_AUDIO_MUTE;
    1055 - } else if (attribute == xvVolume) {
    1056 - if (pPPriv->audio.flags & VIDEO_AUDIO_VOLUME)
    1057 - pPPriv->audio.volume = xv_to_v4l(value);
    1058 - } else {
    1059 - ret = BadValue;
    1060 - }
    1061 - if (ret != BadValue)
    1062 - if (-1 == ioctl(V4L_FD,VIDIOCSAUDIO,&pPPriv->audio))
    1063 - perror("ioctl VIDIOCSAUDIO");
    1064 + if (value < 0 || value >= pPPriv->nenc)
    1065 + goto err;
    1066 + if (ioctl(V4L_FD, VIDIOC_S_INPUT, &pPPriv->input[value]) == -1) {
    1067 + xf86Msg(X_ERROR, "v4l: Error %d while setting input\n", errno);
    1068 + goto err;
    1069 + }
    1070 + if (ioctl(V4L_FD, VIDIOC_S_STD, &pPPriv->norm[value]) == -1) {
    1071 + xf86Msg(X_ERROR, "v4l: Error %d while setting standard\n", errno);
    1072 + goto err;
    1073 + }
    1074 + pPPriv->cenc = value;
    1075 + ret = Success;
    1076 } else if (attribute == xvFreq) {
    1077 - unsigned long freq = value;
    1078 - if (-1 == ioctl(V4L_FD,VIDIOCSFREQ,&freq))
    1079 - perror("ioctl VIDIOCSFREQ");
    1080 - } else if (0 != pPPriv->yuv_format &&
    1081 - pPPriv->myfmt->setAttribute) {
    1082 - /* not mine -> pass to yuv scaler driver */
    1083 - ret = pPPriv->myfmt->setAttribute(pScrn, attribute, value);
    1084 + struct v4l2_frequency freq;
    1085 + memset(&freq, 0, sizeof(freq));
    1086 + ioctl(V4L_FD, VIDIOC_G_FREQUENCY, &freq);
    1087 + freq.frequency = value;
    1088 + if (ioctl(V4L_FD, VIDIOC_S_FREQUENCY, &freq) == -1)
    1089 + xf86Msg(X_ERROR, "v4l: Error %d while setting frequency\n", errno);
    1090 + else
    1091 + ret = Success;
    1092 } else {
    1093 - ret = BadValue;
    1094 + for (i = 0; i < pPPriv->n_qctrl; i++)
    1095 + if (pPPriv->XvV4LCtrl[i].xv == attribute)
    1096 + break;
    1097 + if (i == pPPriv->n_qctrl) {
    1098 + /* not mine -> pass to yuv scaler driver */
    1099 + if (0 != pPPriv->yuv_format && pPPriv->myfmt->setAttribute)
    1100 + ret = pPPriv->myfmt->setAttribute(pScrn, attribute, value);
    1101 + else
    1102 + ret = BadMatch;
    1103 + goto err;
    1104 + }
    1105 + if (pPPriv->XvV4LCtrl[i].qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
    1106 + goto err;
    1107 + ctrl.id = pPPriv->XvV4LCtrl[i].qctrl.id;
    1108 + ctrl.value = value;
    1109 + if (ioctl(V4L_FD, VIDIOC_S_CTRL, &ctrl) != 1)
    1110 + ret = Success;
    1111 }
    1112
    1113 +err:
    1114 V4lCloseDevice(pPPriv,pScrn);
    1115 return ret;
    1116 }
    1117
    1118 static int
    1119 -V4lGetPortAttribute(ScrnInfoPtr pScrn,
    1120 +V4lGetPortAttribute(ScrnInfoPtr pScrn,
    1121 Atom attribute, INT32 *value, pointer data)
    1122 {
    1123 + struct v4l2_control ctrl;
    1124 PortPrivPtr pPPriv = (PortPrivPtr) data;
    1125 - int ret = Success;
    1126 + int i, ret = BadValue;
    1127
    1128 if (V4lOpenDevice(pPPriv, pScrn))
    1129 - return Success;
    1130 + return Success;
    1131
    1132 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/GPA %d\n",
    1133 - attribute));
    1134 + (int)attribute));
    1135
    1136 if (-1 == V4L_FD) {
    1137 - ret = Success;
    1138 + ret = Success;
    1139 } else if (attribute == xvEncoding) {
    1140 - *value = pPPriv->cenc;
    1141 - } else if (attribute == xvBrightness ||
    1142 - attribute == xvContrast ||
    1143 - attribute == xvSaturation ||
    1144 - attribute == xvHue) {
    1145 - ioctl(V4L_FD,VIDIOCGPICT,&pPPriv->pict);
    1146 - if (attribute == xvBrightness) *value = v4l_to_xv(pPPriv->pict.brightness);
    1147 - if (attribute == xvContrast) *value = v4l_to_xv(pPPriv->pict.contrast);
    1148 - if (attribute == xvSaturation) *value = v4l_to_xv(pPPriv->pict.colour);
    1149 - if (attribute == xvHue) *value = v4l_to_xv(pPPriv->pict.hue);
    1150 - } else if (attribute == xvMute ||
    1151 - attribute == xvVolume) {
    1152 - ioctl(V4L_FD,VIDIOCGAUDIO,&pPPriv->audio);
    1153 - if (attribute == xvMute) {
    1154 - *value = (pPPriv->audio.flags & VIDEO_AUDIO_MUTE) ? 1 : 0;
    1155 - } else if (attribute == xvVolume) {
    1156 - if (pPPriv->audio.flags & VIDEO_AUDIO_VOLUME)
    1157 - *value = v4l_to_xv(pPPriv->audio.volume);
    1158 - } else {
    1159 - ret = BadValue;
    1160 - }
    1161 + *value = pPPriv->cenc;
    1162 + ret = Success;
    1163 } else if (attribute == xvFreq) {
    1164 - unsigned long freq;
    1165 - ioctl(V4L_FD,VIDIOCGFREQ,&freq);
    1166 - *value = freq;
    1167 - } else if (0 != pPPriv->yuv_format &&
    1168 - pPPriv->myfmt->getAttribute) {
    1169 - /* not mine -> pass to yuv scaler driver */
    1170 - ret = pPPriv->myfmt->getAttribute(pScrn, attribute, value);
    1171 + struct v4l2_frequency freq;
    1172 + memset(&freq, 0, sizeof(freq));
    1173 + if (ioctl(V4L_FD, VIDIOC_G_FREQUENCY, &freq) != -1) {
    1174 + *value = freq.frequency;
    1175 + ret = Success;
    1176 + }
    1177 } else {
    1178 - ret = BadValue;
    1179 + for (i = 0; i < pPPriv->n_qctrl; i++)
    1180 + if (pPPriv->XvV4LCtrl[i].xv == attribute)
    1181 + break;
    1182 + if (i == pPPriv->n_qctrl) {
    1183 + /* not mine -> pass to yuv scaler driver */
    1184 + if (0 != pPPriv->yuv_format && pPPriv->myfmt->getAttribute)
    1185 + ret = pPPriv->myfmt->getAttribute(pScrn, attribute, value);
    1186 + else
    1187 + ret = BadMatch;
    1188 + goto err;
    1189 + }
    1190 + if (pPPriv->XvV4LCtrl[i].qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
    1191 + goto err;
    1192 + ctrl.id = pPPriv->XvV4LCtrl[i].qctrl.id;
    1193 + if (ioctl(V4L_FD, VIDIOC_G_CTRL, &ctrl) != -1) {
    1194 + *value = ctrl.value;
    1195 + ret = Success;
    1196 + }
    1197 }
    1198 + DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/GPA %d, %d\n",
    1199 + (int)attribute, (int)*value));
    1200
    1201 - DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/GPA %d, %d\n",
    1202 - attribute, *value));
    1203 -
    1204 +err:
    1205 V4lCloseDevice(pPPriv,pScrn);
    1206 return ret;
    1207 }
    1208 @@ -673,15 +875,15 @@ V4lQueryBestSize(ScrnInfoPtr pScrn, Bool
    1209 int maxy = pPPriv->enc[pPPriv->cenc].height;
    1210
    1211 if (0 != pPPriv->yuv_format) {
    1212 - *p_w = pPPriv->myfmt->max_width;
    1213 - *p_h = pPPriv->myfmt->max_height;
    1214 + *p_w = pPPriv->myfmt->max_width;
    1215 + *p_h = pPPriv->myfmt->max_height;
    1216 } else {
    1217 - *p_w = (drw_w < maxx) ? drw_w : maxx;
    1218 - *p_h = (drw_h < maxy) ? drw_h : maxy;
    1219 + *p_w = (drw_w < maxx) ? drw_w : maxx;
    1220 + *p_h = (drw_h < maxy) ? drw_h : maxy;
    1221 }
    1222
    1223 DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/BS %d %dx%d %dx%d\n",
    1224 - pPPriv->cenc,drw_w,drw_h,*p_w,*p_h));
    1225 + pPPriv->cenc,drw_w,drw_h,*p_w,*p_h));
    1226 }
    1227
    1228 static const OptionInfoRec *
    1229 @@ -693,132 +895,198 @@ V4LAvailableOptions(int chipid, int busi
    1230 static void
    1231 V4LIdentify(int flags)
    1232 {
    1233 - xf86Msg(X_INFO, "v4l driver for Video4Linux\n");
    1234 -}
    1235 + xf86Msg(X_INFO, "v4l driver for Video4Linux overlay mode (V4L2)\n");
    1236 +}
    1237
    1238 static char*
    1239 fixname(char *str)
    1240 {
    1241 int s,d;
    1242 for (s=0, d=0;; s++) {
    1243 - if (str[s] == '-')
    1244 - continue;
    1245 - str[d++] = tolower(str[s]);
    1246 - if (0 == str[s])
    1247 - break;
    1248 + if (str[s] == '-')
    1249 + continue;
    1250 + str[d++] = tolower(str[s]);
    1251 + if (0 == str[s])
    1252 + break;
    1253 }
    1254 return str;
    1255 }
    1256
    1257 static int
    1258 -v4l_add_enc(XF86VideoEncodingPtr enc, int i,
    1259 - char *norm, char *input, int width, int height, int n, int d)
    1260 +AddV4LEnc(XF86VideoEncodingPtr enc, int entry,
    1261 + char *norm, char *input, int width, int height, int n, int d)
    1262 {
    1263 - enc[i].id = i;
    1264 - enc[i].name = xalloc(strlen(norm)+strlen(input)+2);
    1265 - if (NULL == enc[i].name)
    1266 - return -1;
    1267 - enc[i].width = width;
    1268 - enc[i].height = height;
    1269 - enc[i].rate.numerator = n;
    1270 - enc[i].rate.denominator = d;
    1271 - sprintf(enc[i].name,"%s-%s",norm,fixname(input));
    1272 + enc->id = entry;
    1273 + enc->name = malloc(strlen(norm) + strlen(input) + 2);
    1274 + if (!enc->name)
    1275 + return -1;
    1276 +
    1277 + enc->width = width;
    1278 + enc->height = height;
    1279 + enc->rate.numerator = n;
    1280 + enc->rate.denominator = d * 2; /* Refresh rate is twice, due to interlace */
    1281 + sprintf(enc->name,"%s-%s",norm,fixname(input));
    1282 +
    1283 + xf86Msg(X_INFO, "v4l: adding input %s, %dx%d %d fps\n",
    1284 + enc->name, enc->width, enc->height, (d + n - 1)/n);
    1285 +
    1286 return 0;
    1287 }
    1288
    1289 +static int
    1290 +V4LGetStd(PortPrivPtr p, int fd)
    1291 +{
    1292 + struct v4l2_standard standard;
    1293 + int entries = 0;
    1294 +
    1295 + /*
    1296 + * 128 is just an arbitrary large number. There aren't that many video stds
    1297 + * The max value is there just to avoid an endless loop, if the driver is
    1298 + * broken.
    1299 + */
    1300 + for (entries = 0; entries < 128; entries++) {
    1301 + memset(&standard, 0, sizeof(standard));
    1302 + standard.index = entries;
    1303 + if (-1 == ioctl(fd,VIDIOC_ENUMSTD, &standard))
    1304 + break;
    1305 + p->standard = realloc(p->standard, sizeof(standard) * (entries + 1));
    1306 + memcpy(&p->standard[entries], &standard, sizeof(standard));
    1307 + }
    1308 +
    1309 + /*
    1310 + * Some webcam drivers don't implement VIDIOC_ENUMSTD. Fake it
    1311 + * This is currently unused, as no webcam driver allows OVERLAY mode,
    1312 + * but the code is here, in the case some webcam driver starts allowing
    1313 + * overlay.
    1314 + * FIXME: Webcam drivers may use VIDIOC_ENUM_FRAMESIZES and
    1315 + * VIDIOC_ENUM_FRAMEINTERVALS ioctl's that may help to fine-tune
    1316 + * their needs. Those ioctl's could be used here in order to better
    1317 + * support webcams.
    1318 + */
    1319 + if (!entries) {
    1320 + xf86Msg(X_INFO, "v4l: VIDIOC_ENUMSTD error %d.\n",errno);
    1321 + p->standard = realloc(p->standard, sizeof(standard) * (entries + 1));
    1322 + p->standard[0].id = V4L2_STD_ALL;
    1323 + strcpy((char *)p->standard[0].name, "CAMERA");
    1324 + p->standard[0].frameperiod.numerator = 1001;
    1325 + p->standard[0].frameperiod.denominator = 300001;
    1326 + p->standard[0].framelines = 480;
    1327 + entries++;
    1328 + }
    1329 + return entries;
    1330 +}
    1331 +
    1332 static void
    1333 -V4LBuildEncodings(PortPrivPtr p, int fd, int channels)
    1334 +V4LBuildEncodings(PortPrivPtr p, int fd)
    1335 {
    1336 - static struct video_channel channel;
    1337 - int i,entries,have_bttv,bttv_ver;
    1338 + unsigned int inp, std, num_std;
    1339
    1340 -#define BTTV_VERSION _IOR('v' , BASE_VIDIOCPRIVATE+6, int)
    1341 - have_bttv = 0;
    1342 - if (-1 != ioctl(fd,BTTV_VERSION,&bttv_ver))
    1343 - have_bttv = 1;
    1344 -
    1345 - entries = (have_bttv ? 7 : 3) * channels;
    1346 - p->enc = xalloc(sizeof(XF86VideoEncodingRec) * entries);
    1347 - if (NULL == p->enc)
    1348 - goto fail;
    1349 - memset(p->enc,0,sizeof(XF86VideoEncodingRec) * entries);
    1350 - p->norm = xalloc(sizeof(int) * entries);
    1351 - if (NULL == p->norm)
    1352 - goto fail;
    1353 - memset(p->norm,0,sizeof(int) * entries);
    1354 - p->input = xalloc(sizeof(int) * entries);
    1355 - if (NULL == p->input)
    1356 - goto fail;
    1357 - memset(p->input,0,sizeof(int) * entries);
    1358 + num_std = V4LGetStd(p, fd);
    1359
    1360 p->nenc = 0;
    1361 - for (i = 0; i < channels; i++) {
    1362 - channel.channel = i;
    1363 - if (-1 == ioctl(fd,VIDIOCGCHAN,&channel)) {
    1364 - perror("ioctl VIDIOCGCHAN");
    1365 - continue;
    1366 - }
    1367 -
    1368 - v4l_add_enc(p->enc, p->nenc,"PAL", channel.name, 768,576, 1,50);
    1369 - p->norm[p->nenc] = VIDEO_MODE_PAL;
    1370 - p->input[p->nenc] = i;
    1371 - p->nenc++;
    1372 -
    1373 - v4l_add_enc(p->enc,p->nenc,"NTSC", channel.name, 640,480, 1001,60000);
    1374 - p->norm[p->nenc] = VIDEO_MODE_NTSC;
    1375 - p->input[p->nenc] = i;
    1376 - p->nenc++;
    1377 -
    1378 - v4l_add_enc(p->enc,p->nenc,"SECAM",channel.name, 768,576, 1,50);
    1379 - p->norm[p->nenc] = VIDEO_MODE_SECAM;
    1380 - p->input[p->nenc] = i;
    1381 - p->nenc++;
    1382
    1383 - if (have_bttv) {
    1384 - /* workaround for a v4l design flaw: The v4l API knows just pal,
    1385 - ntsc and secam. But there are a few more norms (pal versions
    1386 - with a different timings used in south america for example).
    1387 - The bttv driver can handle these too. */
    1388 - if (0 != v4l_add_enc(p->enc,p->nenc,"PAL-Nc",channel.name,
    1389 - 640, 576, 1,50))
    1390 - goto fail;
    1391 - p->norm[p->nenc] = 3;
    1392 - p->input[p->nenc] = i;
    1393 - p->nenc++;
    1394 + /*
    1395 + * 256 is just an arbitrary large number. There aren't that many video
    1396 + * inputs on any driver. The max value is there just to avoid an endless
    1397 + * loop, if the driver is broken.
    1398 + */
    1399 + for (inp = 0; inp < 256; inp++) {
    1400 + struct v4l2_input input;
    1401
    1402 - if (0 != v4l_add_enc(p->enc,p->nenc,"PAL-M",channel.name,
    1403 - 640, 576, 1,50))
    1404 - goto fail;
    1405 - p->norm[p->nenc] = 4;
    1406 - p->input[p->nenc] = i;
    1407 - p->nenc++;
    1408 + memset(&input, 0, sizeof(input));
    1409 + input.index = inp;
    1410 + if (ioctl(fd, VIDIOC_ENUMINPUT, &input) == -1)
    1411 + break;
    1412
    1413 - if (0 != v4l_add_enc(p->enc, p->nenc,"PAL-N", channel.name,
    1414 - 768,576, 1,50))
    1415 - goto fail;
    1416 - p->norm[p->nenc] = 5;
    1417 - p->input[p->nenc] = i;
    1418 - p->nenc++;
    1419 -
    1420 - if (0 != v4l_add_enc(p->enc,p->nenc,"NTSC-JP", channel.name,
    1421 - 640,480, 1001,60000))
    1422 - goto fail;
    1423 - p->norm[p->nenc] = 6;
    1424 - p->input[p->nenc] = i;
    1425 - p->nenc++;
    1426 - }
    1427 + for (std = 0; std < num_std; std++) {
    1428 + int width, height;
    1429 +
    1430 + /*
    1431 + * Currently, this code is not reliable, due to driver
    1432 + * non-compliance on both saa7134 and bttv. So, instead,
    1433 + * just use the video standard information
    1434 + */
    1435 +#if 0
    1436 + struct v4l2_framebuffer fbuf;
    1437 +
    1438 + /* Some webcam drivers will fail here, but that's OK */
    1439 + ioctl(fd, VIDIOC_S_STD, &p->standard[std].id);
    1440 +
    1441 + memset(&fbuf, 0, sizeof(fbuf));
    1442 + if (ioctl(fd, VIDIOC_G_FBUF, &fbuf) == -1) {
    1443 + xf86Msg(X_INFO, "v4l: Error %d: Can't get FBUF\n", errno);
    1444 + return;
    1445 + }
    1446 + height = fbuf.fmt.height;
    1447 + width = fbuf.fmt.width;
    1448 +
    1449 + /*
    1450 + * If the overlay method fails, get the resolution
    1451 + * via checking V4L2_BUF_TYPE_VIDEO_CAPTURE
    1452 + */
    1453 + if (!height || !width) {
    1454 + struct v4l2_format format;
    1455 +
    1456 + format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    1457 + if (ioctl(fd, VIDIOC_G_FMT, &format) == -1) {
    1458 + /* Hmm... device doesn't support capture. */
    1459 + height = p->standard[std].framelines;
    1460 + if (height == 480)
    1461 + width = 640;
    1462 + else if (height == 576)
    1463 + width = 768;
    1464 + else
    1465 + continue;
    1466 + } else {
    1467 + height = format.fmt.pix.height;
    1468 + width = format.fmt.pix.width;
    1469 + }
    1470 + }
    1471 +#else
    1472 + if (p->standard[std].id & V4L2_STD_525_60) {
    1473 + height = 480;
    1474 + width = 640;
    1475 + } else {
    1476 + height = 576;
    1477 + width = 768;
    1478 + }
    1479 +
    1480 +#endif
    1481 + /* Fixup for some driver bug */
    1482 + if ((p->standard[std].id & V4L2_STD_525_60) && (height == 576))
    1483 + height = 480;
    1484 +
    1485 + p->enc = realloc(p->enc, sizeof(XF86VideoEncodingRec) * (p->nenc + 1));
    1486 + p->norm = realloc(p->norm, sizeof(int) * (p->nenc + 1));
    1487 + p->input = realloc(p->input, sizeof(int) * (p->nenc + 1));
    1488 + if (!p->enc || !p->norm || !p->input)
    1489 + goto fail;
    1490 + if (AddV4LEnc(&p->enc[p->nenc], p->nenc,
    1491 + (char *)p->standard[std].name,
    1492 + (char *)input.name, width, height,
    1493 + p->standard[std].frameperiod.numerator,
    1494 + p->standard[std].frameperiod.denominator))
    1495 + goto fail;
    1496 + p->norm[p->nenc] = p->standard[std].id;
    1497 + p->input[p->nenc] = inp;
    1498 + p->nenc++;
    1499 + }
    1500 }
    1501 +
    1502 + if (!p->nenc)
    1503 + xf86Msg(X_ERROR, "v4l: couldn't detect any valid input/standard\n");
    1504 return;
    1505 -
    1506 - fail:
    1507 +
    1508 +fail:
    1509 + xf86Msg(X_ERROR, "v4l: Fail to get standards: %d\n", errno);
    1510 if (p->input)
    1511 - xfree(p->input);
    1512 + free(p->input);
    1513 p->input = NULL;
    1514 if (p->norm)
    1515 - xfree(p->norm);
    1516 + free(p->norm);
    1517 p->norm = NULL;
    1518 if (p->enc)
    1519 - xfree(p->enc);
    1520 + free(p->enc);
    1521 p->enc = NULL;
    1522 p->nenc = 0;
    1523 }
    1524 @@ -826,75 +1094,35 @@ V4LBuildEncodings(PortPrivPtr p, int fd,
    1525 /* add a attribute a list */
    1526 static void
    1527 v4l_add_attr(XF86AttributeRec **list, int *count,
    1528 - const XF86AttributeRec *attr)
    1529 + const XF86AttributeRec *attr)
    1530 {
    1531 XF86AttributeRec *oldlist = *list;
    1532 int i;
    1533 + Atom gpa;
    1534
    1535 for (i = 0; i < *count; i++) {
    1536 - if (0 == strcmp((*list)[i].name,attr->name)) {
    1537 - DEBUG(xf86Msg(X_INFO, "v4l: skip dup attr %s\n",attr->name));
    1538 - return;
    1539 - }
    1540 + if (0 == strcmp((*list)[i].name,attr->name)) {
    1541 + DEBUG(xf86Msg(X_INFO, "v4l: skip dup attr %s\n",attr->name));
    1542 + return;
    1543 + }
    1544 }
    1545 -
    1546 - DEBUG(xf86Msg(X_INFO, "v4l: add attr %s\n",attr->name));
    1547 - *list = xalloc((*count + 1) * sizeof(XF86AttributeRec));
    1548 +
    1549 + *list = malloc((*count + 1) * sizeof(XF86AttributeRec));
    1550 if (NULL == *list) {
    1551 - *count = 0;
    1552 - return;
    1553 + *count = 0;
    1554 + return;
    1555 }
    1556 if (*count)
    1557 - memcpy(*list, oldlist, *count * sizeof(XF86AttributeRec));
    1558 + memcpy(*list, oldlist, *count * sizeof(XF86AttributeRec));
    1559 memcpy(*list + *count, attr, sizeof(XF86AttributeRec));
    1560 +
    1561 + gpa = MAKE_ATOM((*list)[*count].name);
    1562 + xf86Msg(X_INFO, "v4l: add attr %s (Xv/GPA %d) (%d to %d)\n",
    1563 + attr->name, (int)gpa, attr->min_value, attr->max_value);
    1564 +
    1565 (*count)++;
    1566 }
    1567
    1568 -/* setup yuv overlay + hw scaling: look if we find some common video
    1569 - format which both v4l driver and the X-Server can handle */
    1570 -static void v4l_check_yuv(ScrnInfoPtr pScrn, PortPrivPtr pPPriv,
    1571 - char *dev, int fd)
    1572 -{
    1573 - static const struct {
    1574 - unsigned int v4l_palette;
    1575 - unsigned int v4l_depth;
    1576 - unsigned int xv_id;
    1577 - unsigned int xv_format;
    1578 - } yuvlist[] = {
    1579 - { VIDEO_PALETTE_YUV422, 16, 0x32595559, XvPacked },
    1580 - { VIDEO_PALETTE_UYVY, 16, 0x59565955, XvPacked },
    1581 - { 0 /* end of list */ },
    1582 - };
    1583 - ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
    1584 - int fmt,i;
    1585 -
    1586 - pPPriv->format = xf86XVQueryOffscreenImages(pScreen,&pPPriv->nformat);
    1587 - for (fmt = 0; yuvlist[fmt].v4l_palette != 0; fmt++) {
    1588 - /* check v4l ... */
    1589 - ioctl(fd,VIDIOCGPICT,&pPPriv->pict);
    1590 - pPPriv->pict.palette = yuvlist[fmt].v4l_palette;
    1591 - pPPriv->pict.depth = yuvlist[fmt].v4l_depth;
    1592 - if (-1 == ioctl(fd,VIDIOCSPICT,&pPPriv->pict))
    1593 - continue;
    1594 - ioctl(fd,VIDIOCGPICT,&pPPriv->pict);
    1595 - if (pPPriv->pict.palette != yuvlist[fmt].v4l_palette)
    1596 - continue;
    1597 - /* ... works, check available offscreen image formats now ... */
    1598 - for (i = 0; i < pPPriv->nformat; i++) {
    1599 - if (pPPriv->format[i].image->id == yuvlist[fmt].xv_id &&
    1600 - pPPriv->format[i].image->format == yuvlist[fmt].xv_format) {
    1601 - /* ... match found, good. */
    1602 - pPPriv->yuv_format = yuvlist[fmt].v4l_palette;
    1603 - pPPriv->myfmt = pPPriv->format+i;
    1604 - xf86DrvMsg(pScrn->scrnIndex, X_INFO,
    1605 - "v4l[%s]: using hw video scaling [%4.4s].\n",
    1606 - dev,(char*)&(pPPriv->format[i].image->id));
    1607 - return;
    1608 - }
    1609 - }
    1610 - }
    1611 -}
    1612 -
    1613 static int
    1614 V4LInit(ScrnInfoPtr pScrn, XF86VideoAdaptorPtr **adaptors)
    1615 {
    1616 @@ -904,118 +1132,114 @@ V4LInit(ScrnInfoPtr pScrn, XF86VideoAdap
    1617 char dev[18];
    1618 int fd,i,j,d;
    1619
    1620 - DEBUG(xf86Msg(X_INFO, "v4l: init start\n"));
    1621 + for (i = 0, d = 0; d < MAX_V4L_DEVICES; d++) {
    1622 + sprintf(dev, "/dev/video%d", d);
    1623 + fd = open(dev, O_RDWR, 0);
    1624 + if (fd == -1) {
    1625 + sprintf(dev, "/dev/v4l/video%d", d);
    1626 + fd = open(dev, O_RDWR, 0);
    1627 + if (fd == -1)
    1628 + break;
    1629 + }
    1630 + DEBUG(xf86Msg(X_INFO, "v4l: %s open ok\n",dev));
    1631
    1632 - for (i = 0, d = 0; d < MAX_V4L_DEVICES; d++) {
    1633 - sprintf(dev, "/dev/video%d", d);
    1634 - fd = open(dev, O_RDWR, 0);
    1635 - if (fd == -1) {
    1636 - sprintf(dev, "/dev/v4l/video%d", d);
    1637 - fd = open(dev, O_RDWR, 0);
    1638 - if (fd == -1)
    1639 - break;
    1640 - }
    1641 - DEBUG(xf86Msg(X_INFO, "v4l: %s open ok\n",dev));
    1642 + /* our private data */
    1643 + pPPriv = malloc(sizeof(PortPrivRec));
    1644 + if (!pPPriv)
    1645 + return FALSE;
    1646 + memset(pPPriv,0,sizeof(PortPrivRec));
    1647 + pPPriv->nr = d;
    1648
    1649 - /* our private data */
    1650 - pPPriv = xalloc(sizeof(PortPrivRec));
    1651 - if (!pPPriv)
    1652 - return FALSE;
    1653 - memset(pPPriv,0,sizeof(PortPrivRec));
    1654 - pPPriv->nr = d;
    1655 + /* check device capabilities */
    1656 + memset(&pPPriv->cap, 0, sizeof(&pPPriv->cap));
    1657 + if (-1 == ioctl(fd, VIDIOC_QUERYCAP, &pPPriv->cap) ||
    1658 + 0 == (pPPriv->cap.capabilities & V4L2_CAP_VIDEO_OVERLAY)) {
    1659 + xf86Msg(X_ERROR, "v4l: %s: no overlay support\n",dev);
    1660 + free(pPPriv);
    1661 + close(fd);
    1662 + continue;
    1663 + }
    1664
    1665 - /* check device */
    1666 - if (-1 == ioctl(fd,VIDIOCGCAP,&pPPriv->cap) ||
    1667 - 0 == (pPPriv->cap.type & VID_TYPE_OVERLAY)) {
    1668 - DEBUG(xf86Msg(X_INFO, "v4l: %s: no overlay support\n",dev));
    1669 - xfree(pPPriv);
    1670 - close(fd);
    1671 - continue;
    1672 - }
    1673 - strncpy(V4L_NAME, dev, 16);
    1674 - V4LBuildEncodings(pPPriv,fd,pPPriv->cap.channels);
    1675 - if (NULL == pPPriv->enc)
    1676 - return FALSE;
    1677 - v4l_check_yuv(pScrn,pPPriv,dev,fd);
    1678 -
    1679 - /* alloc VideoAdaptorRec */
    1680 - VAR = xrealloc(VAR,sizeof(XF86VideoAdaptorPtr)*(i+1));
    1681 - VAR[i] = xalloc(sizeof(XF86VideoAdaptorRec));
    1682 - if (!VAR[i])
    1683 - return FALSE;
    1684 - memset(VAR[i],0,sizeof(XF86VideoAdaptorRec));
    1685 + if (v4l_check_yuv(pScrn, pPPriv, dev, fd) == FALSE) {
    1686 + xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
    1687 + "Xv Overlay not supported. Can't use v4l driver\n");
    1688 + free(pPPriv);
    1689 + close(fd);
    1690 + continue;
    1691 + }
    1692
    1693 + xf86Msg(X_INFO, "v4l: enabling overlay mode for %s.\n", dev);
    1694 + strncpy(V4L_NAME, dev, 16);
    1695 + V4LBuildEncodings(pPPriv, fd);
    1696 + if (NULL == pPPriv->enc)
    1697 + return FALSE;
    1698
    1699 - /* build attribute list */
    1700 - for (j = 0; j < V4L_ATTR; j++) {
    1701 - /* video attributes */
    1702 - v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1703 - &Attributes[j]);
    1704 - }
    1705 - if (0 == ioctl(fd,VIDIOCGAUDIO,&pPPriv->audio)) {
    1706 - /* audio attributes */
    1707 - if (pPPriv->audio.flags & VIDEO_AUDIO_VOLUME)
    1708 - v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1709 - &VolumeAttr);
    1710 - if (pPPriv->audio.flags & VIDEO_AUDIO_MUTABLE)
    1711 - v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1712 - &MuteAttr);
    1713 - }
    1714 - if (pPPriv->cap.type & VID_TYPE_TUNER) {
    1715 - /* tuner attributes */
    1716 - v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1717 - &FreqAttr);
    1718 - }
    1719 - if (0 != pPPriv->yuv_format) {
    1720 - /* pass throuth scaler attributes */
    1721 - for (j = 0; j < pPPriv->myfmt->num_attributes; j++) {
    1722 - v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1723 - pPPriv->myfmt->attributes+j);
    1724 - }
    1725 - }
    1726 -
    1727 -
    1728 - /* hook in private data */
    1729 - Private = xalloc(sizeof(DevUnion));
    1730 - if (!Private)
    1731 - return FALSE;
    1732 - memset(Private,0,sizeof(DevUnion));
    1733 - Private->ptr = (pointer)pPPriv;
    1734 - VAR[i]->pPortPrivates = Private;
    1735 - VAR[i]->nPorts = 1;
    1736 + /* alloc VideoAdaptorRec */
    1737 + VAR = realloc(VAR,sizeof(XF86VideoAdaptorPtr)*(i+1));
    1738 + VAR[i] = malloc(sizeof(XF86VideoAdaptorRec));
    1739 + if (!VAR[i])
    1740 + return FALSE;
    1741 + memset(VAR[i],0,sizeof(XF86VideoAdaptorRec));
    1742
    1743 - /* init VideoAdaptorRec */
    1744 - VAR[i]->type = XvInputMask | XvWindowMask | XvVideoMask;
    1745 - VAR[i]->name = "video4linux";
    1746 - VAR[i]->flags = VIDEO_INVERT_CLIPLIST;
    1747 + /* build attribute list */
    1748 + AddAllV4LControls(pPPriv, &VAR[i]->pAttributes, &VAR[i]->nAttributes, fd);
    1749
    1750 - VAR[i]->PutVideo = V4lPutVideo;
    1751 - VAR[i]->PutStill = V4lPutStill;
    1752 - VAR[i]->StopVideo = V4lStopVideo;
    1753 - VAR[i]->SetPortAttribute = V4lSetPortAttribute;
    1754 - VAR[i]->GetPortAttribute = V4lGetPortAttribute;
    1755 - VAR[i]->QueryBestSize = V4lQueryBestSize;
    1756 + for (j = 0; j < V4L_ATTR; j++) {
    1757 + /* Other video attributes */
    1758 + v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1759 + &Attributes[j]);
    1760 + }
    1761 + if (pPPriv->cap.capabilities & V4L2_CAP_TUNER) {
    1762 + /* tuner attributes */
    1763 + v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1764 + &FreqAttr);
    1765 + }
    1766
    1767 - VAR[i]->nEncodings = pPPriv->nenc;
    1768 - VAR[i]->pEncodings = pPPriv->enc;
    1769 - VAR[i]->nFormats =
    1770 - sizeof(InputVideoFormats) / sizeof(InputVideoFormats[0]);
    1771 - VAR[i]->pFormats = InputVideoFormats;
    1772 + /* Initialize yuv_format */
    1773 + if (0 != pPPriv->yuv_format) {
    1774 + /* pass throuth scaler attributes */
    1775 + for (j = 0; j < pPPriv->myfmt->num_attributes; j++) {
    1776 + v4l_add_attr(&VAR[i]->pAttributes, &VAR[i]->nAttributes,
    1777 + pPPriv->myfmt->attributes+j);
    1778 + }
    1779 + }
    1780
    1781 - if (fd != -1)
    1782 - close(fd);
    1783 - i++;
    1784 + DEBUG(xf86Msg(X_INFO, "v4l: saving config into driver data\n"));
    1785 + /* hook in private data */
    1786 + Private = malloc(sizeof(DevUnion));
    1787 + if (!Private)
    1788 + return FALSE;
    1789 + memset(Private,0,sizeof(DevUnion));
    1790 + Private->ptr = (pointer)pPPriv;
    1791 + VAR[i]->pPortPrivates = Private;
    1792 + VAR[i]->nPorts = 1;
    1793 +
    1794 + /* init VideoAdaptorRec */
    1795 + VAR[i]->type = XvInputMask | XvWindowMask | XvVideoMask;
    1796 + VAR[i]->name = "video4linux";
    1797 + VAR[i]->flags = VIDEO_INVERT_CLIPLIST;
    1798 +
    1799 + VAR[i]->PutVideo = V4lPutVideo;
    1800 + VAR[i]->PutStill = V4lPutStill;
    1801 + VAR[i]->StopVideo = V4lStopVideo;
    1802 + VAR[i]->SetPortAttribute = V4lSetPortAttribute;
    1803 + VAR[i]->GetPortAttribute = V4lGetPortAttribute;
    1804 + VAR[i]->QueryBestSize = V4lQueryBestSize;
    1805 +
    1806 + VAR[i]->nEncodings = pPPriv->nenc;
    1807 + VAR[i]->pEncodings = pPPriv->enc;
    1808 + VAR[i]->nFormats = sizeof(InputVideoFormats) / sizeof(InputVideoFormats[0]);
    1809 + VAR[i]->pFormats = InputVideoFormats;
    1810 +
    1811 + if (fd != -1) {
    1812 + DEBUG(xf86Msg(X_INFO, "v4l: %s init finished.\n",dev));
    1813 + close(fd);
    1814 + }
    1815 + i++;
    1816 }
    1817
    1818 xvEncoding = MAKE_ATOM(XV_ENCODING);
    1819 - xvHue = MAKE_ATOM(XV_HUE);
    1820 - xvSaturation = MAKE_ATOM(XV_SATURATION);
    1821 - xvBrightness = MAKE_ATOM(XV_BRIGHTNESS);
    1822 - xvContrast = MAKE_ATOM(XV_CONTRAST);
    1823 -
    1824 xvFreq = MAKE_ATOM(XV_FREQ);
    1825 - xvMute = MAKE_ATOM(XV_MUTE);
    1826 - xvVolume = MAKE_ATOM(XV_VOLUME);
    1827
    1828 DEBUG(xf86Msg(X_INFO, "v4l: init done, %d device(s) found\n",i));
    1829
    1830 @@ -1024,10 +1248,43 @@ V4LInit(ScrnInfoPtr pScrn, XF86VideoAdap
    1831 }
    1832
    1833 static Bool
    1834 +V4LDetect(void)
    1835 +{
    1836 + struct v4l2_capability cap;
    1837 + int fd, d, n = 0;
    1838 + char dev[18];
    1839 +
    1840 + for (d = 0; d < MAX_V4L_DEVICES; d++) {
    1841 + sprintf(dev, "/dev/video%d", d);
    1842 + fd = open(dev, O_RDWR, 0);
    1843 + if (fd == -1) {
    1844 + sprintf(dev, "/dev/v4l/video%d", d);
    1845 + fd = open(dev, O_RDWR, 0);
    1846 + if (fd == -1)
    1847 + break;
    1848 + }
    1849 + close (fd);
    1850 + memset(&cap, 0, sizeof(cap));
    1851 + if (!ioctl(fd, VIDIOC_QUERYCAP, &cap) &&
    1852 + (cap.capabilities & V4L2_CAP_VIDEO_OVERLAY))
    1853 + n++;
    1854 + }
    1855 + xf86Msg(X_INFO, "v4l: %d video adapters with overlay support detected\n", n);
    1856 +
    1857 + return (n > 0) ? TRUE : FALSE;
    1858 +}
    1859 +
    1860 +static Bool
    1861 V4LProbe(DriverPtr drv, int flags)
    1862 {
    1863 - if (flags & PROBE_DETECT)
    1864 - return TRUE;
    1865 + /*
    1866 + * Don't try to register adapter at the detection phase, as Xv
    1867 + * extensions won't be there
    1868 + */
    1869 + if (flags == PROBE_DETECT)
    1870 + return V4LDetect();
    1871 +
    1872 + DEBUG(xf86Msg(X_INFO, "v4l: Initiating device probe\n"));
    1873
    1874 xf86XVRegisterGenericAdaptorDriver(V4LInit);
    1875 drv->refCount++;
    1876 diff --git a/src/videodev.h b/src/videodev.h
    1877 deleted file mode 100644
    1878 --- a/src/videodev.h
    1879 +++ /dev/null
    1880 @@ -1,254 +0,0 @@
    1881 -#ifndef __LINUX_VIDEODEV_H
    1882 -#define __LINUX_VIDEODEV_H
    1883 -
    1884 -/* Linux V4L API, Version 1
    1885 - * videodev.h from v4l driver in Linux 2.2.3
    1886 - *
    1887 - * Used here with the explicit permission of the original author, Alan Cox.
    1888 - * <alan@lxorguk.ukuu.org.uk>
    1889 - */
    1890 -
    1891 -#include <X11/Xmd.h>
    1892 -
    1893 -#define VID_TYPE_CAPTURE 1 /* Can capture */
    1894 -#define VID_TYPE_TUNER 2 /* Can tune */
    1895 -#define VID_TYPE_TELETEXT 4 /* Does teletext */
    1896 -#define VID_TYPE_OVERLAY 8 /* Overlay onto frame buffer */
    1897 -#define VID_TYPE_CHROMAKEY 16 /* Overlay by chromakey */
    1898 -#define VID_TYPE_CLIPPING 32 /* Can clip */
    1899 -#define VID_TYPE_FRAMERAM 64 /* Uses the frame buffer memory */
    1900 -#define VID_TYPE_SCALES 128 /* Scalable */
    1901 -#define VID_TYPE_MONOCHROME 256 /* Monochrome only */
    1902 -#define VID_TYPE_SUBCAPTURE 512 /* Can capture subareas of the image */
    1903 -
    1904 -struct video_capability
    1905 -{
    1906 - char name[32];
    1907 - int type;
    1908 - int channels; /* Num channels */
    1909 - int audios; /* Num audio devices */
    1910 - int maxwidth; /* Supported width */
    1911 - int maxheight; /* And height */
    1912 - int minwidth; /* Supported width */
    1913 - int minheight; /* And height */
    1914 -};
    1915 -
    1916 -
    1917 -struct video_channel
    1918 -{
    1919 - int channel;
    1920 - char name[32];
    1921 - int tuners;
    1922 - CARD32 flags;
    1923 -#define VIDEO_VC_TUNER 1 /* Channel has a tuner */
    1924 -#define VIDEO_VC_AUDIO 2 /* Channel has audio */
    1925 - CARD16 type;
    1926 -#define VIDEO_TYPE_TV 1
    1927 -#define VIDEO_TYPE_CAMERA 2
    1928 - CARD16 norm; /* Norm set by channel */
    1929 -};
    1930 -
    1931 -struct video_tuner
    1932 -{
    1933 - int tuner;
    1934 - char name[32];
    1935 - unsigned long rangelow, rangehigh; /* Tuner range */
    1936 - CARD32 flags;
    1937 -#define VIDEO_TUNER_PAL 1
    1938 -#define VIDEO_TUNER_NTSC 2
    1939 -#define VIDEO_TUNER_SECAM 4
    1940 -#define VIDEO_TUNER_LOW 8 /* Uses KHz not MHz */
    1941 -#define VIDEO_TUNER_NORM 16 /* Tuner can set norm */
    1942 -#define VIDEO_TUNER_STEREO_ON 128 /* Tuner is seeing stereo */
    1943 - CARD16 mode; /* PAL/NTSC/SECAM/OTHER */
    1944 -#define VIDEO_MODE_PAL 0
    1945 -#define VIDEO_MODE_NTSC 1
    1946 -#define VIDEO_MODE_SECAM 2
    1947 -#define VIDEO_MODE_AUTO 3
    1948 - CARD16 signal; /* Signal strength 16bit scale */
    1949 -};
    1950 -
    1951 -struct video_picture
    1952 -{
    1953 - CARD16 brightness;
    1954 - CARD16 hue;
    1955 - CARD16 colour;
    1956 - CARD16 contrast;
    1957 - CARD16 whiteness; /* Black and white only */
    1958 - CARD16 depth; /* Capture depth */
    1959 - CARD16 palette; /* Palette in use */
    1960 -#define VIDEO_PALETTE_GREY 1 /* Linear greyscale */
    1961 -#define VIDEO_PALETTE_HI240 2 /* High 240 cube (BT848) */
    1962 -#define VIDEO_PALETTE_RGB565 3 /* 565 16 bit RGB */
    1963 -#define VIDEO_PALETTE_RGB24 4 /* 24bit RGB */
    1964 -#define VIDEO_PALETTE_RGB32 5 /* 32bit RGB */
    1965 -#define VIDEO_PALETTE_RGB555 6 /* 555 15bit RGB */
    1966 -#define VIDEO_PALETTE_YUV422 7 /* YUV422 capture */
    1967 -#define VIDEO_PALETTE_YUYV 8
    1968 -#define VIDEO_PALETTE_UYVY 9 /* The great thing about standards is ... */
    1969 -#define VIDEO_PALETTE_YUV420 10
    1970 -#define VIDEO_PALETTE_YUV411 11 /* YUV411 capture */
    1971 -#define VIDEO_PALETTE_RAW 12 /* RAW capture (BT848) */
    1972 -#define VIDEO_PALETTE_YUV422P 13 /* YUV 4:2:2 Planar */
    1973 -#define VIDEO_PALETTE_YUV411P 14 /* YUV 4:1:1 Planar */
    1974 -#define VIDEO_PALETTE_YUV420P 15 /* YUV 4:2:0 Planar */
    1975 -#define VIDEO_PALETTE_YUV410P 16 /* YUV 4:1:0 Planar */
    1976 -#define VIDEO_PALETTE_PLANAR 13 /* start of planar entries */
    1977 -#define VIDEO_PALETTE_COMPONENT 7 /* start of component entries */
    1978 -};
    1979 -
    1980 -struct video_audio
    1981 -{
    1982 - int audio; /* Audio channel */
    1983 - CARD16 volume; /* If settable */
    1984 - CARD16 bass, treble;
    1985 - CARD32 flags;
    1986 -#define VIDEO_AUDIO_MUTE 1
    1987 -#define VIDEO_AUDIO_MUTABLE 2
    1988 -#define VIDEO_AUDIO_VOLUME 4
    1989 -#define VIDEO_AUDIO_BASS 8
    1990 -#define VIDEO_AUDIO_TREBLE 16
    1991 - char name[16];
    1992 -#define VIDEO_SOUND_MONO 1
    1993 -#define VIDEO_SOUND_STEREO 2
    1994 -#define VIDEO_SOUND_LANG1 4
    1995 -#define VIDEO_SOUND_LANG2 8
    1996 - CARD16 mode;
    1997 - CARD16 balance; /* Stereo balance */
    1998 - CARD16 step; /* Step actual volume uses */
    1999 -};
    2000 -
    2001 -struct video_clip
    2002 -{
    2003 - INT32 x,y;
    2004 - INT32 width, height;
    2005 - struct video_clip *next; /* For user use/driver use only */
    2006 -};
    2007 -
    2008 -struct video_window
    2009 -{
    2010 - CARD32 x,y; /* Position of window */
    2011 - CARD32 width,height; /* Its size */
    2012 - CARD32 chromakey;
    2013 - CARD32 flags;
    2014 - struct video_clip *clips; /* Set only */
    2015 - int clipcount;
    2016 -#define VIDEO_WINDOW_INTERLACE 1
    2017 -#define VIDEO_CLIP_BITMAP -1
    2018 -/* bitmap is 1024x625, a '1' bit represents a clipped pixel */
    2019 -#define VIDEO_CLIPMAP_SIZE (128 * 625)
    2020 -};
    2021 -
    2022 -struct video_capture
    2023 -{
    2024 - CARD32 x,y; /* Offsets into image */
    2025 - CARD32 width, height; /* Area to capture */
    2026 - CARD16 decimation; /* Decimation divder */
    2027 - CARD16 flags; /* Flags for capture */
    2028 -#define VIDEO_CAPTURE_ODD 0 /* Temporal */
    2029 -#define VIDEO_CAPTURE_EVEN 1
    2030 -};
    2031 -
    2032 -struct video_buffer
    2033 -{
    2034 - void *base;
    2035 - int height,width;
    2036 - int depth;
    2037 - int bytesperline;
    2038 -};
    2039 -
    2040 -struct video_mmap
    2041 -{
    2042 - unsigned int frame; /* Frame (0 - n) for double buffer */
    2043 - int height,width;
    2044 - unsigned int format; /* should be VIDEO_PALETTE_* */
    2045 -};
    2046 -
    2047 -struct video_key
    2048 -{
    2049 - CARD8 key[8];
    2050 - CARD32 flags;
    2051 -};
    2052 -
    2053 -
    2054 -#define VIDEO_MAX_FRAME 32
    2055 -
    2056 -struct video_mbuf
    2057 -{
    2058 - int size; /* Total memory to map */
    2059 - int frames; /* Frames */
    2060 - int offsets[VIDEO_MAX_FRAME];
    2061 -};
    2062 -
    2063 -
    2064 -#define VIDEO_NO_UNIT (-1)
    2065 -
    2066 -
    2067 -struct video_unit
    2068 -{
    2069 - int video; /* Video minor */
    2070 - int vbi; /* VBI minor */
    2071 - int radio; /* Radio minor */
    2072 - int audio; /* Audio minor */
    2073 - int teletext; /* Teletext minor */
    2074 -};
    2075 -
    2076 -#define VIDIOCGCAP _IOR('v',1,struct video_capability) /* Get capabilities */
    2077 -#define VIDIOCGCHAN _IOWR('v',2,struct video_channel) /* Get channel info (sources) */
    2078 -#define VIDIOCSCHAN _IOW('v',3,struct video_channel) /* Set channel */
    2079 -#define VIDIOCGTUNER _IOWR('v',4,struct video_tuner) /* Get tuner abilities */
    2080 -#define VIDIOCSTUNER _IOW('v',5,struct video_tuner) /* Tune the tuner for the current channel */
    2081 -#define VIDIOCGPICT _IOR('v',6,struct video_picture) /* Get picture properties */
    2082 -#define VIDIOCSPICT _IOW('v',7,struct video_picture) /* Set picture properties */
    2083 -#define VIDIOCCAPTURE _IOW('v',8,int) /* Start, end capture */
    2084 -#define VIDIOCGWIN _IOR('v',9, struct video_window) /* Set the video overlay window */
    2085 -#define VIDIOCSWIN _IOW('v',10, struct video_window) /* Set the video overlay window - passes clip list for hardware smarts , chromakey etc */
    2086 -#define VIDIOCGFBUF _IOR('v',11, struct video_buffer) /* Get frame buffer */
    2087 -#define VIDIOCSFBUF _IOW('v',12, struct video_buffer) /* Set frame buffer - root only */
    2088 -#define VIDIOCKEY _IOR('v',13, struct video_key) /* Video key event - to dev 255 is to all - cuts capture on all DMA windows with this key (0xFFFFFFFF == all) */
    2089 -#define VIDIOCGFREQ _IOR('v',14, unsigned long) /* Set tuner */
    2090 -#define VIDIOCSFREQ _IOW('v',15, unsigned long) /* Set tuner */
    2091 -#define VIDIOCGAUDIO _IOR('v',16, struct video_audio) /* Get audio info */
    2092 -#define VIDIOCSAUDIO _IOW('v',17, struct video_audio) /* Audio source, mute etc */
    2093 -#define VIDIOCSYNC _IOW('v',18, int) /* Sync with mmap grabbing */
    2094 -#define VIDIOCMCAPTURE _IOW('v',19, struct video_mmap) /* Grab frames */
    2095 -#define VIDIOCGMBUF _IOR('v', 20, struct video_mbuf) /* Memory map buffer info */
    2096 -#define VIDIOCGUNIT _IOR('v', 21, struct video_unit) /* Get attached units */
    2097 -#define VIDIOCGCAPTURE _IOR('v',22, struct video_capture) /* Get frame buffer */
    2098 -#define VIDIOCSCAPTURE _IOW('v',23, struct video_capture) /* Set frame buffer - root only */
    2099 -
    2100 -#define BASE_VIDIOCPRIVATE 192 /* 192-255 are private */
    2101 -
    2102 -
    2103 -#define VID_HARDWARE_BT848 1
    2104 -#define VID_HARDWARE_QCAM_BW 2
    2105 -#define VID_HARDWARE_PMS 3
    2106 -#define VID_HARDWARE_QCAM_C 4
    2107 -#define VID_HARDWARE_PSEUDO 5
    2108 -#define VID_HARDWARE_SAA5249 6
    2109 -#define VID_HARDWARE_AZTECH 7
    2110 -#define VID_HARDWARE_SF16MI 8
    2111 -#define VID_HARDWARE_RTRACK 9
    2112 -#define VID_HARDWARE_ZOLTRIX 10
    2113 -#define VID_HARDWARE_SAA7146 11
    2114 -#define VID_HARDWARE_VIDEUM 12 /* Reserved for Winnov videum */
    2115 -#define VID_HARDWARE_RTRACK2 13
    2116 -#define VID_HARDWARE_PERMEDIA2 14 /* Reserved for Permedia2 */
    2117 -#define VID_HARDWARE_RIVA128 15 /* Reserved for RIVA 128 */
    2118 -#define VID_HARDWARE_PLANB 16 /* PowerMac motherboard video-in */
    2119 -#define VID_HARDWARE_BROADWAY 17 /* Broadway project */
    2120 -#define VID_HARDWARE_GEMTEK 18
    2121 -#define VID_HARDWARE_TYPHOON 19
    2122 -#define VID_HARDWARE_VINO 20 /* Reserved for SGI Indy Vino */
    2123 -
    2124 -/*
    2125 - * Initialiser list
    2126 - */
    2127 -
    2128 -struct video_init
    2129 -{
    2130 - char *name;
    2131 - int (*init)(struct video_init *);
    2132 -};
    2133 -
    2134 -#endif
    2135 diff --git a/src/videodev2.h b/src/videodev2.h
    2136 new file mode 100644
    2137 --- /dev/null
    2138 +++ b/src/videodev2.h
    2139 @@ -0,0 +1,1929 @@
    2140 +/*
    2141 + * Video for Linux Two header file
    2142 + *
    2143 + * Copyright (C) 1999-2007 the contributors
    2144 + *
    2145 + * This program is free software; you can redistribute it and/or modify
    2146 + * it under the terms of the GNU General Public License as published by
    2147 + * the Free Software Foundation; either version 2 of the License, or
    2148 + * (at your option) any later version.
    2149 + *
    2150 + * This program is distributed in the hope that it will be useful,
    2151 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    2152 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    2153 + * GNU General Public License for more details.
    2154 + *
    2155 + * Alternatively you can redistribute this file under the terms of the
    2156 + * BSD license as stated below:
    2157 + *
    2158 + * Redistribution and use in source and binary forms, with or without
    2159 + * modification, are permitted provided that the following conditions
    2160 + * are met:
    2161 + * 1. Redistributions of source code must retain the above copyright
    2162 + * notice, this list of conditions and the following disclaimer.
    2163 + * 2. Redistributions in binary form must reproduce the above copyright
    2164 + * notice, this list of conditions and the following disclaimer in
    2165 + * the documentation and/or other materials provided with the
    2166 + * distribution.
    2167 + * 3. The names of its contributors may not be used to endorse or promote
    2168 + * products derived from this software without specific prior written
    2169 + * permission.
    2170 + *
    2171 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    2172 + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    2173 + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    2174 + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    2175 + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    2176 + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
    2177 + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
    2178 + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
    2179 + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
    2180 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    2181 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2182 + *
    2183 + * Header file for v4l or V4L2 drivers and applications
    2184 + * with public API.
    2185 + * All kernel-specific stuff were moved to media/v4l2-dev.h, so
    2186 + * no #if __KERNEL tests are allowed here
    2187 + *
    2188 + * See http://linuxtv.org for more info
    2189 + *
    2190 + * Author: Bill Dirks <bill@thedirks.org>
    2191 + * Justin Schoeman
    2192 + * Hans Verkuil <hverkuil@xs4all.nl>
    2193 + * et al.
    2194 + */
    2195 +#ifndef __LINUX_VIDEODEV2_H
    2196 +#define __LINUX_VIDEODEV2_H
    2197 +
    2198 +#include <linux/ioctl.h>
    2199 +#include <linux/types.h>
    2200 +#include <sys/time.h>
    2201 +
    2202 +/*
    2203 + * Common stuff for both V4L1 and V4L2
    2204 + * Moved from videodev.h
    2205 + */
    2206 +#define VIDEO_MAX_FRAME 32
    2207 +#define VIDEO_MAX_PLANES 8
    2208 +
    2209 +/* These defines are V4L1 specific and should not be used with the V4L2 API!
    2210 + They will be removed from this header in the future. */
    2211 +
    2212 +#define VID_TYPE_CAPTURE 1 /* Can capture */
    2213 +#define VID_TYPE_TUNER 2 /* Can tune */
    2214 +#define VID_TYPE_TELETEXT 4 /* Does teletext */
    2215 +#define VID_TYPE_OVERLAY 8 /* Overlay onto frame buffer */
    2216 +#define VID_TYPE_CHROMAKEY 16 /* Overlay by chromakey */
    2217 +#define VID_TYPE_CLIPPING 32 /* Can clip */
    2218 +#define VID_TYPE_FRAMERAM 64 /* Uses the frame buffer memory */
    2219 +#define VID_TYPE_SCALES 128 /* Scalable */
    2220 +#define VID_TYPE_MONOCHROME 256 /* Monochrome only */
    2221 +#define VID_TYPE_SUBCAPTURE 512 /* Can capture subareas of the image */
    2222 +#define VID_TYPE_MPEG_DECODER 1024 /* Can decode MPEG streams */
    2223 +#define VID_TYPE_MPEG_ENCODER 2048 /* Can encode MPEG streams */
    2224 +#define VID_TYPE_MJPEG_DECODER 4096 /* Can decode MJPEG streams */
    2225 +#define VID_TYPE_MJPEG_ENCODER 8192 /* Can encode MJPEG streams */
    2226 +
    2227 +/*
    2228 + * M I S C E L L A N E O U S
    2229 + */
    2230 +
    2231 +/* Four-character-code (FOURCC) */
    2232 +#define v4l2_fourcc(a, b, c, d)\
    2233 + ((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) | ((__u32)(d) << 24))
    2234 +
    2235 +/*
    2236 + * E N U M S
    2237 + */
    2238 +enum v4l2_field {
    2239 + V4L2_FIELD_ANY = 0, /* driver can choose from none,
    2240 + top, bottom, interlaced
    2241 + depending on whatever it thinks
    2242 + is approximate ... */
    2243 + V4L2_FIELD_NONE = 1, /* this device has no fields ... */
    2244 + V4L2_FIELD_TOP = 2, /* top field only */
    2245 + V4L2_FIELD_BOTTOM = 3, /* bottom field only */
    2246 + V4L2_FIELD_INTERLACED = 4, /* both fields interlaced */
    2247 + V4L2_FIELD_SEQ_TB = 5, /* both fields sequential into one
    2248 + buffer, top-bottom order */
    2249 + V4L2_FIELD_SEQ_BT = 6, /* same as above + bottom-top order */
    2250 + V4L2_FIELD_ALTERNATE = 7, /* both fields alternating into
    2251 + separate buffers */
    2252 + V4L2_FIELD_INTERLACED_TB = 8, /* both fields interlaced, top field
    2253 + first and the top field is
    2254 + transmitted first */
    2255 + V4L2_FIELD_INTERLACED_BT = 9, /* both fields interlaced, top field
    2256 + first and the bottom field is
    2257 + transmitted first */
    2258 +};
    2259 +#define V4L2_FIELD_HAS_TOP(field) \
    2260 + ((field) == V4L2_FIELD_TOP ||\
    2261 + (field) == V4L2_FIELD_INTERLACED ||\
    2262 + (field) == V4L2_FIELD_INTERLACED_TB ||\
    2263 + (field) == V4L2_FIELD_INTERLACED_BT ||\
    2264 + (field) == V4L2_FIELD_SEQ_TB ||\
    2265 + (field) == V4L2_FIELD_SEQ_BT)
    2266 +#define V4L2_FIELD_HAS_BOTTOM(field) \
    2267 + ((field) == V4L2_FIELD_BOTTOM ||\
    2268 + (field) == V4L2_FIELD_INTERLACED ||\
    2269 + (field) == V4L2_FIELD_INTERLACED_TB ||\
    2270 + (field) == V4L2_FIELD_INTERLACED_BT ||\
    2271 + (field) == V4L2_FIELD_SEQ_TB ||\
    2272 + (field) == V4L2_FIELD_SEQ_BT)
    2273 +#define V4L2_FIELD_HAS_BOTH(field) \
    2274 + ((field) == V4L2_FIELD_INTERLACED ||\
    2275 + (field) == V4L2_FIELD_INTERLACED_TB ||\
    2276 + (field) == V4L2_FIELD_INTERLACED_BT ||\
    2277 + (field) == V4L2_FIELD_SEQ_TB ||\
    2278 + (field) == V4L2_FIELD_SEQ_BT)
    2279 +
    2280 +enum v4l2_buf_type {
    2281 + V4L2_BUF_TYPE_VIDEO_CAPTURE = 1,
    2282 + V4L2_BUF_TYPE_VIDEO_OUTPUT = 2,
    2283 + V4L2_BUF_TYPE_VIDEO_OVERLAY = 3,
    2284 + V4L2_BUF_TYPE_VBI_CAPTURE = 4,
    2285 + V4L2_BUF_TYPE_VBI_OUTPUT = 5,
    2286 + V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6,
    2287 + V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7,
    2288 +#if 1
    2289 + /* Experimental */
    2290 + V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
    2291 +#endif
    2292 + V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
    2293 + V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE = 10,
    2294 + V4L2_BUF_TYPE_PRIVATE = 0x80,
    2295 +};
    2296 +
    2297 +#define V4L2_TYPE_IS_MULTIPLANAR(type) \
    2298 + ((type) == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE \
    2299 + || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
    2300 +
    2301 +#define V4L2_TYPE_IS_OUTPUT(type) \
    2302 + ((type) == V4L2_BUF_TYPE_VIDEO_OUTPUT \
    2303 + || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE \
    2304 + || (type) == V4L2_BUF_TYPE_VIDEO_OVERLAY \
    2305 + || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY \
    2306 + || (type) == V4L2_BUF_TYPE_VBI_OUTPUT \
    2307 + || (type) == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT)
    2308 +
    2309 +enum v4l2_tuner_type {
    2310 + V4L2_TUNER_RADIO = 1,
    2311 + V4L2_TUNER_ANALOG_TV = 2,
    2312 + V4L2_TUNER_DIGITAL_TV = 3,
    2313 +};
    2314 +
    2315 +enum v4l2_memory {
    2316 + V4L2_MEMORY_MMAP = 1,
    2317 + V4L2_MEMORY_USERPTR = 2,
    2318 + V4L2_MEMORY_OVERLAY = 3,
    2319 +};
    2320 +
    2321 +/* see also http://vektor.theorem.ca/graphics/ycbcr/ */
    2322 +enum v4l2_colorspace {
    2323 + /* ITU-R 601 -- broadcast NTSC/PAL */
    2324 + V4L2_COLORSPACE_SMPTE170M = 1,
    2325 +
    2326 + /* 1125-Line (US) HDTV */
    2327 + V4L2_COLORSPACE_SMPTE240M = 2,
    2328 +
    2329 + /* HD and modern captures. */
    2330 + V4L2_COLORSPACE_REC709 = 3,
    2331 +
    2332 + /* broken BT878 extents (601, luma range 16-253 instead of 16-235) */
    2333 + V4L2_COLORSPACE_BT878 = 4,
    2334 +
    2335 + /* These should be useful. Assume 601 extents. */
    2336 + V4L2_COLORSPACE_470_SYSTEM_M = 5,
    2337 + V4L2_COLORSPACE_470_SYSTEM_BG = 6,
    2338 +
    2339 + /* I know there will be cameras that send this. So, this is
    2340 + * unspecified chromaticities and full 0-255 on each of the
    2341 + * Y'CbCr components
    2342 + */
    2343 + V4L2_COLORSPACE_JPEG = 7,
    2344 +
    2345 + /* For RGB colourspaces, this is probably a good start. */
    2346 + V4L2_COLORSPACE_SRGB = 8,
    2347 +};
    2348 +
    2349 +enum v4l2_priority {
    2350 + V4L2_PRIORITY_UNSET = 0, /* not initialized */
    2351 + V4L2_PRIORITY_BACKGROUND = 1,
    2352 + V4L2_PRIORITY_INTERACTIVE = 2,
    2353 + V4L2_PRIORITY_RECORD = 3,
    2354 + V4L2_PRIORITY_DEFAULT = V4L2_PRIORITY_INTERACTIVE,
    2355 +};
    2356 +
    2357 +struct v4l2_rect {
    2358 + __s32 left;
    2359 + __s32 top;
    2360 + __s32 width;
    2361 + __s32 height;
    2362 +};
    2363 +
    2364 +struct v4l2_fract {
    2365 + __u32 numerator;
    2366 + __u32 denominator;
    2367 +};
    2368 +
    2369 +/*
    2370 + * D R I V E R C A P A B I L I T I E S
    2371 + */
    2372 +struct v4l2_capability {
    2373 + __u8 driver[16]; /* i.e. "bttv" */
    2374 + __u8 card[32]; /* i.e. "Hauppauge WinTV" */
    2375 + __u8 bus_info[32]; /* "PCI:" + pci_name(pci_dev) */
    2376 + __u32 version; /* should use KERNEL_VERSION() */
    2377 + __u32 capabilities; /* Device capabilities */
    2378 + __u32 reserved[4];
    2379 +};
    2380 +
    2381 +/* Values for 'capabilities' field */
    2382 +#define V4L2_CAP_VIDEO_CAPTURE 0x00000001 /* Is a video capture device */
    2383 +#define V4L2_CAP_VIDEO_OUTPUT 0x00000002 /* Is a video output device */
    2384 +#define V4L2_CAP_VIDEO_OVERLAY 0x00000004 /* Can do video overlay */
    2385 +#define V4L2_CAP_VBI_CAPTURE 0x00000010 /* Is a raw VBI capture device */
    2386 +#define V4L2_CAP_VBI_OUTPUT 0x00000020 /* Is a raw VBI output device */
    2387 +#define V4L2_CAP_SLICED_VBI_CAPTURE 0x00000040 /* Is a sliced VBI capture device */
    2388 +#define V4L2_CAP_SLICED_VBI_OUTPUT 0x00000080 /* Is a sliced VBI output device */
    2389 +#define V4L2_CAP_RDS_CAPTURE 0x00000100 /* RDS data capture */
    2390 +#define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200 /* Can do video output overlay */
    2391 +#define V4L2_CAP_HW_FREQ_SEEK 0x00000400 /* Can do hardware frequency seek */
    2392 +#define V4L2_CAP_RDS_OUTPUT 0x00000800 /* Is an RDS encoder */
    2393 +
    2394 +/* Is a video capture device that supports multiplanar formats */
    2395 +#define V4L2_CAP_VIDEO_CAPTURE_MPLANE 0x00001000
    2396 +/* Is a video output device that supports multiplanar formats */
    2397 +#define V4L2_CAP_VIDEO_OUTPUT_MPLANE 0x00002000
    2398 +
    2399 +#define V4L2_CAP_TUNER 0x00010000 /* has a tuner */
    2400 +#define V4L2_CAP_AUDIO 0x00020000 /* has audio support */
    2401 +#define V4L2_CAP_RADIO 0x00040000 /* is a radio device */
    2402 +#define V4L2_CAP_MODULATOR 0x00080000 /* has a modulator */
    2403 +
    2404 +#define V4L2_CAP_READWRITE 0x01000000 /* read/write systemcalls */
    2405 +#define V4L2_CAP_ASYNCIO 0x02000000 /* async I/O */
    2406 +#define V4L2_CAP_STREAMING 0x04000000 /* streaming I/O ioctls */
    2407 +
    2408 +/*
    2409 + * V I D E O I M A G E F O R M A T
    2410 + */
    2411 +struct v4l2_pix_format {
    2412 + __u32 width;
    2413 + __u32 height;
    2414 + __u32 pixelformat;
    2415 + enum v4l2_field field;
    2416 + __u32 bytesperline; /* for padding, zero if unused */
    2417 + __u32 sizeimage;
    2418 + enum v4l2_colorspace colorspace;
    2419 + __u32 priv; /* private data, depends on pixelformat */
    2420 +};
    2421 +
    2422 +/* Pixel format FOURCC depth Description */
    2423 +
    2424 +/* RGB formats */
    2425 +#define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R', 'G', 'B', '1') /* 8 RGB-3-3-2 */
    2426 +#define V4L2_PIX_FMT_RGB444 v4l2_fourcc('R', '4', '4', '4') /* 16 xxxxrrrr ggggbbbb */
    2427 +#define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R', 'G', 'B', 'O') /* 16 RGB-5-5-5 */
    2428 +#define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R', 'G', 'B', 'P') /* 16 RGB-5-6-5 */
    2429 +#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R', 'G', 'B', 'Q') /* 16 RGB-5-5-5 BE */
    2430 +#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R', 'G', 'B', 'R') /* 16 RGB-5-6-5 BE */
    2431 +#define V4L2_PIX_FMT_BGR666 v4l2_fourcc('B', 'G', 'R', 'H') /* 18 BGR-6-6-6 */
    2432 +#define V4L2_PIX_FMT_BGR24 v4l2_fourcc('B', 'G', 'R', '3') /* 24 BGR-8-8-8 */
    2433 +#define V4L2_PIX_FMT_RGB24 v4l2_fourcc('R', 'G', 'B', '3') /* 24 RGB-8-8-8 */
    2434 +#define V4L2_PIX_FMT_BGR32 v4l2_fourcc('B', 'G', 'R', '4') /* 32 BGR-8-8-8-8 */
    2435 +#define V4L2_PIX_FMT_RGB32 v4l2_fourcc('R', 'G', 'B', '4') /* 32 RGB-8-8-8-8 */
    2436 +
    2437 +/* Grey formats */
    2438 +#define V4L2_PIX_FMT_GREY v4l2_fourcc('G', 'R', 'E', 'Y') /* 8 Greyscale */
    2439 +#define V4L2_PIX_FMT_Y4 v4l2_fourcc('Y', '0', '4', ' ') /* 4 Greyscale */
    2440 +#define V4L2_PIX_FMT_Y6 v4l2_fourcc('Y', '0', '6', ' ') /* 6 Greyscale */
    2441 +#define V4L2_PIX_FMT_Y10 v4l2_fourcc('Y', '1', '0', ' ') /* 10 Greyscale */
    2442 +#define V4L2_PIX_FMT_Y16 v4l2_fourcc('Y', '1', '6', ' ') /* 16 Greyscale */
    2443 +
    2444 +/* Palette formats */
    2445 +#define V4L2_PIX_FMT_PAL8 v4l2_fourcc('P', 'A', 'L', '8') /* 8 8-bit palette */
    2446 +
    2447 +/* Luminance+Chrominance formats */
    2448 +#define V4L2_PIX_FMT_YVU410 v4l2_fourcc('Y', 'V', 'U', '9') /* 9 YVU 4:1:0 */
    2449 +#define V4L2_PIX_FMT_YVU420 v4l2_fourcc('Y', 'V', '1', '2') /* 12 YVU 4:2:0 */
    2450 +#define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y', 'U', 'Y', 'V') /* 16 YUV 4:2:2 */
    2451 +#define V4L2_PIX_FMT_YYUV v4l2_fourcc('Y', 'Y', 'U', 'V') /* 16 YUV 4:2:2 */
    2452 +#define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */
    2453 +#define V4L2_PIX_FMT_UYVY v4l2_fourcc('U', 'Y', 'V', 'Y') /* 16 YUV 4:2:2 */
    2454 +#define V4L2_PIX_FMT_VYUY v4l2_fourcc('V', 'Y', 'U', 'Y') /* 16 YUV 4:2:2 */
    2455 +#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4', '2', '2', 'P') /* 16 YVU422 planar */
    2456 +#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4', '1', '1', 'P') /* 16 YVU411 planar */
    2457 +#define V4L2_PIX_FMT_Y41P v4l2_fourcc('Y', '4', '1', 'P') /* 12 YUV 4:1:1 */
    2458 +#define V4L2_PIX_FMT_YUV444 v4l2_fourcc('Y', '4', '4', '4') /* 16 xxxxyyyy uuuuvvvv */
    2459 +#define V4L2_PIX_FMT_YUV555 v4l2_fourcc('Y', 'U', 'V', 'O') /* 16 YUV-5-5-5 */
    2460 +#define V4L2_PIX_FMT_YUV565 v4l2_fourcc('Y', 'U', 'V', 'P') /* 16 YUV-5-6-5 */
    2461 +#define V4L2_PIX_FMT_YUV32 v4l2_fourcc('Y', 'U', 'V', '4') /* 32 YUV-8-8-8-8 */
    2462 +#define V4L2_PIX_FMT_YUV410 v4l2_fourcc('Y', 'U', 'V', '9') /* 9 YUV 4:1:0 */
    2463 +#define V4L2_PIX_FMT_YUV420 v4l2_fourcc('Y', 'U', '1', '2') /* 12 YUV 4:2:0 */
    2464 +#define V4L2_PIX_FMT_HI240 v4l2_fourcc('H', 'I', '2', '4') /* 8 8-bit color */
    2465 +#define V4L2_PIX_FMT_HM12 v4l2_fourcc('H', 'M', '1', '2') /* 8 YUV 4:2:0 16x16 macroblocks */
    2466 +
    2467 +/* two planes -- one Y, one Cr + Cb interleaved */
    2468 +#define V4L2_PIX_FMT_NV12 v4l2_fourcc('N', 'V', '1', '2') /* 12 Y/CbCr 4:2:0 */
    2469 +#define V4L2_PIX_FMT_NV21 v4l2_fourcc('N', 'V', '2', '1') /* 12 Y/CrCb 4:2:0 */
    2470 +#define V4L2_PIX_FMT_NV16 v4l2_fourcc('N', 'V', '1', '6') /* 16 Y/CbCr 4:2:2 */
    2471 +#define V4L2_PIX_FMT_NV61 v4l2_fourcc('N', 'V', '6', '1') /* 16 Y/CrCb 4:2:2 */
    2472 +
    2473 +/* two non contiguous planes - one Y, one Cr + Cb interleaved */
    2474 +#define V4L2_PIX_FMT_NV12M v4l2_fourcc('N', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 */
    2475 +#define V4L2_PIX_FMT_NV12MT v4l2_fourcc('T', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 64x32 macroblocks */
    2476 +
    2477 +/* three non contiguous planes - Y, Cb, Cr */
    2478 +#define V4L2_PIX_FMT_YUV420M v4l2_fourcc('Y', 'M', '1', '2') /* 12 YUV420 planar */
    2479 +
    2480 +/* Bayer formats - see http://www.siliconimaging.com/RGB%20Bayer.htm */
    2481 +#define V4L2_PIX_FMT_SBGGR8 v4l2_fourcc('B', 'A', '8', '1') /* 8 BGBG.. GRGR.. */
    2482 +#define V4L2_PIX_FMT_SGBRG8 v4l2_fourcc('G', 'B', 'R', 'G') /* 8 GBGB.. RGRG.. */
    2483 +#define V4L2_PIX_FMT_SGRBG8 v4l2_fourcc('G', 'R', 'B', 'G') /* 8 GRGR.. BGBG.. */
    2484 +#define V4L2_PIX_FMT_SRGGB8 v4l2_fourcc('R', 'G', 'G', 'B') /* 8 RGRG.. GBGB.. */
    2485 +#define V4L2_PIX_FMT_SBGGR10 v4l2_fourcc('B', 'G', '1', '0') /* 10 BGBG.. GRGR.. */
    2486 +#define V4L2_PIX_FMT_SGBRG10 v4l2_fourcc('G', 'B', '1', '0') /* 10 GBGB.. RGRG.. */
    2487 +#define V4L2_PIX_FMT_SGRBG10 v4l2_fourcc('B', 'A', '1', '0') /* 10 GRGR.. BGBG.. */
    2488 +#define V4L2_PIX_FMT_SRGGB10 v4l2_fourcc('R', 'G', '1', '0') /* 10 RGRG.. GBGB.. */
    2489 + /* 10bit raw bayer DPCM compressed to 8 bits */
    2490 +#define V4L2_PIX_FMT_SGRBG10DPCM8 v4l2_fourcc('B', 'D', '1', '0')
    2491 + /*
    2492 + * 10bit raw bayer, expanded to 16 bits
    2493 + * xxxxrrrrrrrrrrxxxxgggggggggg xxxxggggggggggxxxxbbbbbbbbbb...
    2494 + */
    2495 +#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B', 'Y', 'R', '2') /* 16 BGBG.. GRGR.. */
    2496 +
    2497 +/* compressed formats */
    2498 +#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG */
    2499 +#define V4L2_PIX_FMT_JPEG v4l2_fourcc('J', 'P', 'E', 'G') /* JFIF JPEG */
    2500 +#define V4L2_PIX_FMT_DV v4l2_fourcc('d', 'v', 's', 'd') /* 1394 */
    2501 +#define V4L2_PIX_FMT_MPEG v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4 */
    2502 +
    2503 +/* Vendor-specific formats */
    2504 +#define V4L2_PIX_FMT_CPIA1 v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */
    2505 +#define V4L2_PIX_FMT_WNVA v4l2_fourcc('W', 'N', 'V', 'A') /* Winnov hw compress */
    2506 +#define V4L2_PIX_FMT_SN9C10X v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */
    2507 +#define V4L2_PIX_FMT_SN9C20X_I420 v4l2_fourcc('S', '9', '2', '0') /* SN9C20x YUV 4:2:0 */
    2508 +#define V4L2_PIX_FMT_PWC1 v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam */
    2509 +#define V4L2_PIX_FMT_PWC2 v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam */
    2510 +#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E', '6', '2', '5') /* ET61X251 compression */
    2511 +#define V4L2_PIX_FMT_SPCA501 v4l2_fourcc('S', '5', '0', '1') /* YUYV per line */
    2512 +#define V4L2_PIX_FMT_SPCA505 v4l2_fourcc('S', '5', '0', '5') /* YYUV per line */
    2513 +#define V4L2_PIX_FMT_SPCA508 v4l2_fourcc('S', '5', '0', '8') /* YUVY per line */
    2514 +#define V4L2_PIX_FMT_SPCA561 v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */
    2515 +#define V4L2_PIX_FMT_PAC207 v4l2_fourcc('P', '2', '0', '7') /* compressed BGGR bayer */
    2516 +#define V4L2_PIX_FMT_MR97310A v4l2_fourcc('M', '3', '1', '0') /* compressed BGGR bayer */
    2517 +#define V4L2_PIX_FMT_SN9C2028 v4l2_fourcc('S', 'O', 'N', 'X') /* compressed GBRG bayer */
    2518 +#define V4L2_PIX_FMT_SQ905C v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */
    2519 +#define V4L2_PIX_FMT_PJPG v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */
    2520 +#define V4L2_PIX_FMT_OV511 v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */
    2521 +#define V4L2_PIX_FMT_OV518 v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */
    2522 +#define V4L2_PIX_FMT_STV0680 v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer */
    2523 +#define V4L2_PIX_FMT_TM6000 v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 */
    2524 +#define V4L2_PIX_FMT_CIT_YYVYUY v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY */
    2525 +#define V4L2_PIX_FMT_KONICA420 v4l2_fourcc('K', 'O', 'N', 'I') /* YUV420 planar in blocks of 256 pixels */
    2526 +
    2527 +/*
    2528 + * F O R M A T E N U M E R A T I O N
    2529 + */
    2530 +struct v4l2_fmtdesc {
    2531 + __u32 index; /* Format number */
    2532 + enum v4l2_buf_type type; /* buffer type */
    2533 + __u32 flags;
    2534 + __u8 description[32]; /* Description string */
    2535 + __u32 pixelformat; /* Format fourcc */
    2536 + __u32 reserved[4];
    2537 +};
    2538 +
    2539 +#define V4L2_FMT_FLAG_COMPRESSED 0x0001
    2540 +#define V4L2_FMT_FLAG_EMULATED 0x0002
    2541 +
    2542 +#if 1
    2543 + /* Experimental Frame Size and frame rate enumeration */
    2544 +/*
    2545 + * F R A M E S I Z E E N U M E R A T I O N
    2546 + */
    2547 +enum v4l2_frmsizetypes {
    2548 + V4L2_FRMSIZE_TYPE_DISCRETE = 1,
    2549 + V4L2_FRMSIZE_TYPE_CONTINUOUS = 2,
    2550 + V4L2_FRMSIZE_TYPE_STEPWISE = 3,
    2551 +};
    2552 +
    2553 +struct v4l2_frmsize_discrete {
    2554 + __u32 width; /* Frame width [pixel] */
    2555 + __u32 height; /* Frame height [pixel] */
    2556 +};
    2557 +
    2558 +struct v4l2_frmsize_stepwise {
    2559 + __u32 min_width; /* Minimum frame width [pixel] */
    2560 + __u32 max_width; /* Maximum frame width [pixel] */
    2561 + __u32 step_width; /* Frame width step size [pixel] */
    2562 + __u32 min_height; /* Minimum frame height [pixel] */
    2563 + __u32 max_height; /* Maximum frame height [pixel] */
    2564 + __u32 step_height; /* Frame height step size [pixel] */
    2565 +};
    2566 +
    2567 +struct v4l2_frmsizeenum {
    2568 + __u32 index; /* Frame size number */
    2569 + __u32 pixel_format; /* Pixel format */
    2570 + __u32 type; /* Frame size type the device supports. */
    2571 +
    2572 + union { /* Frame size */
    2573 + struct v4l2_frmsize_discrete discrete;
    2574 + struct v4l2_frmsize_stepwise stepwise;
    2575 + };
    2576 +
    2577 + __u32 reserved[2]; /* Reserved space for future use */
    2578 +};
    2579 +
    2580 +/*
    2581 + * F R A M E R A T E E N U M E R A T I O N
    2582 + */
    2583 +enum v4l2_frmivaltypes {
    2584 + V4L2_FRMIVAL_TYPE_DISCRETE = 1,
    2585 + V4L2_FRMIVAL_TYPE_CONTINUOUS = 2,
    2586 + V4L2_FRMIVAL_TYPE_STEPWISE = 3,
    2587 +};
    2588 +
    2589 +struct v4l2_frmival_stepwise {
    2590 + struct v4l2_fract min; /* Minimum frame interval [s] */
    2591 + struct v4l2_fract max; /* Maximum frame interval [s] */
    2592 + struct v4l2_fract step; /* Frame interval step size [s] */
    2593 +};
    2594 +
    2595 +struct v4l2_frmivalenum {
    2596 + __u32 index; /* Frame format index */
    2597 + __u32 pixel_format; /* Pixel format */
    2598 + __u32 width; /* Frame width */
    2599 + __u32 height; /* Frame height */
    2600 + __u32 type; /* Frame interval type the device supports. */
    2601 +
    2602 + union { /* Frame interval */
    2603 + struct v4l2_fract discrete;
    2604 + struct v4l2_frmival_stepwise stepwise;
    2605 + };
    2606 +
    2607 + __u32 reserved[2]; /* Reserved space for future use */
    2608 +};
    2609 +#endif
    2610 +
    2611 +/*
    2612 + * T I M E C O D E
    2613 + */
    2614 +struct v4l2_timecode {
    2615 + __u32 type;
    2616 + __u32 flags;
    2617 + __u8 frames;
    2618 + __u8 seconds;
    2619 + __u8 minutes;
    2620 + __u8 hours;
    2621 + __u8 userbits[4];
    2622 +};
    2623 +
    2624 +/* Type */
    2625 +#define V4L2_TC_TYPE_24FPS 1
    2626 +#define V4L2_TC_TYPE_25FPS 2
    2627 +#define V4L2_TC_TYPE_30FPS 3
    2628 +#define V4L2_TC_TYPE_50FPS 4
    2629 +#define V4L2_TC_TYPE_60FPS 5
    2630 +
    2631 +/* Flags */
    2632 +#define V4L2_TC_FLAG_DROPFRAME 0x0001 /* "drop-frame" mode */
    2633 +#define V4L2_TC_FLAG_COLORFRAME 0x0002
    2634 +#define V4L2_TC_USERBITS_field 0x000C
    2635 +#define V4L2_TC_USERBITS_USERDEFINED 0x0000
    2636 +#define V4L2_TC_USERBITS_8BITCHARS 0x0008
    2637 +/* The above is based on SMPTE timecodes */
    2638 +
    2639 +struct v4l2_jpegcompression {
    2640 + int quality;
    2641 +
    2642 + int APPn; /* Number of APP segment to be written,
    2643 + * must be 0..15 */
    2644 + int APP_len; /* Length of data in JPEG APPn segment */
    2645 + char APP_data[60]; /* Data in the JPEG APPn segment. */
    2646 +
    2647 + int COM_len; /* Length of data in JPEG COM segment */
    2648 + char COM_data[60]; /* Data in JPEG COM segment */
    2649 +
    2650 + __u32 jpeg_markers; /* Which markers should go into the JPEG
    2651 + * output. Unless you exactly know what
    2652 + * you do, leave them untouched.
    2653 + * Inluding less markers will make the
    2654 + * resulting code smaller, but there will
    2655 + * be fewer applications which can read it.
    2656 + * The presence of the APP and COM marker
    2657 + * is influenced by APP_len and COM_len
    2658 + * ONLY, not by this property! */
    2659 +
    2660 +#define V4L2_JPEG_MARKER_DHT (1<<3) /* Define Huffman Tables */
    2661 +#define V4L2_JPEG_MARKER_DQT (1<<4) /* Define Quantization Tables */
    2662 +#define V4L2_JPEG_MARKER_DRI (1<<5) /* Define Restart Interval */
    2663 +#define V4L2_JPEG_MARKER_COM (1<<6) /* Comment segment */
    2664 +#define V4L2_JPEG_MARKER_APP (1<<7) /* App segment, driver will
    2665 + * allways use APP0 */
    2666 +};
    2667 +
    2668 +/*
    2669 + * M E M O R Y - M A P P I N G B U F F E R S
    2670 + */
    2671 +struct v4l2_requestbuffers {
    2672 + __u32 count;
    2673 + enum v4l2_buf_type type;
    2674 + enum v4l2_memory memory;
    2675 + __u32 reserved[2];
    2676 +};
    2677 +
    2678 +/**
    2679 + * struct v4l2_plane - plane info for multi-planar buffers
    2680 + * @bytesused: number of bytes occupied by data in the plane (payload)
    2681 + * @length: size of this plane (NOT the payload) in bytes
    2682 + * @mem_offset: when memory in the associated struct v4l2_buffer is
    2683 + * V4L2_MEMORY_MMAP, equals the offset from the start of
    2684 + * the device memory for this plane (or is a "cookie" that
    2685 + * should be passed to mmap() called on the video node)
    2686 + * @userptr: when memory is V4L2_MEMORY_USERPTR, a userspace pointer
    2687 + * pointing to this plane
    2688 + * @data_offset: offset in the plane to the start of data; usually 0,
    2689 + * unless there is a header in front of the data
    2690 + *
    2691 + * Multi-planar buffers consist of one or more planes, e.g. an YCbCr buffer
    2692 + * with two planes can have one plane for Y, and another for interleaved CbCr
    2693 + * components. Each plane can reside in a separate memory buffer, or even in
    2694 + * a completely separate memory node (e.g. in embedded devices).
    2695 + */
    2696 +struct v4l2_plane {
    2697 + __u32 bytesused;
    2698 + __u32 length;
    2699 + union {
    2700 + __u32 mem_offset;
    2701 + unsigned long userptr;
    2702 + } m;
    2703 + __u32 data_offset;
    2704 + __u32 reserved[11];
    2705 +};
    2706 +
    2707 +/**
    2708 + * struct v4l2_buffer - video buffer info
    2709 + * @index: id number of the buffer
    2710 + * @type: buffer type (type == *_MPLANE for multiplanar buffers)
    2711 + * @bytesused: number of bytes occupied by data in the buffer (payload);
    2712 + * unused (set to 0) for multiplanar buffers
    2713 + * @flags: buffer informational flags
    2714 + * @field: field order of the image in the buffer
    2715 + * @timestamp: frame timestamp
    2716 + * @timecode: frame timecode
    2717 + * @sequence: sequence count of this frame
    2718 + * @memory: the method, in which the actual video data is passed
    2719 + * @offset: for non-multiplanar buffers with memory == V4L2_MEMORY_MMAP;
    2720 + * offset from the start of the device memory for this plane,
    2721 + * (or a "cookie" that should be passed to mmap() as offset)
    2722 + * @userptr: for non-multiplanar buffers with memory == V4L2_MEMORY_USERPTR;
    2723 + * a userspace pointer pointing to this buffer
    2724 + * @planes: for multiplanar buffers; userspace pointer to the array of plane
    2725 + * info structs for this buffer
    2726 + * @length: size in bytes of the buffer (NOT its payload) for single-plane
    2727 + * buffers (when type != *_MPLANE); number of elements in the
    2728 + * planes array for multi-plane buffers
    2729 + * @input: input number from which the video data has has been captured
    2730 + *
    2731 + * Contains data exchanged by application and driver using one of the Streaming
    2732 + * I/O methods.
    2733 + */
    2734 +struct v4l2_buffer {
    2735 + __u32 index;
    2736 + enum v4l2_buf_type type;
    2737 + __u32 bytesused;
    2738 + __u32 flags;
    2739 + enum v4l2_field field;
    2740 + struct timeval timestamp;
    2741 + struct v4l2_timecode timecode;
    2742 + __u32 sequence;
    2743 +
    2744 + /* memory location */
    2745 + enum v4l2_memory memory;
    2746 + union {
    2747 + __u32 offset;
    2748 + unsigned long userptr;
    2749 + struct v4l2_plane *planes;
    2750 + } m;
    2751 + __u32 length;
    2752 + __u32 input;
    2753 + __u32 reserved;
    2754 +};
    2755 +
    2756 +/* Flags for 'flags' field */
    2757 +#define V4L2_BUF_FLAG_MAPPED 0x0001 /* Buffer is mapped (flag) */
    2758 +#define V4L2_BUF_FLAG_QUEUED 0x0002 /* Buffer is queued for processing */
    2759 +#define V4L2_BUF_FLAG_DONE 0x0004 /* Buffer is ready */
    2760 +#define V4L2_BUF_FLAG_KEYFRAME 0x0008 /* Image is a keyframe (I-frame) */
    2761 +#define V4L2_BUF_FLAG_PFRAME 0x0010 /* Image is a P-frame */
    2762 +#define V4L2_BUF_FLAG_BFRAME 0x0020 /* Image is a B-frame */
    2763 +/* Buffer is ready, but the data contained within is corrupted. */
    2764 +#define V4L2_BUF_FLAG_ERROR 0x0040
    2765 +#define V4L2_BUF_FLAG_TIMECODE 0x0100 /* timecode field is valid */
    2766 +#define V4L2_BUF_FLAG_INPUT 0x0200 /* input field is valid */
    2767 +
    2768 +/*
    2769 + * O V E R L A Y P R E V I E W
    2770 + */
    2771 +struct v4l2_framebuffer {
    2772 + __u32 capability;
    2773 + __u32 flags;
    2774 +/* FIXME: in theory we should pass something like PCI device + memory
    2775 + * region + offset instead of some physical address */
    2776 + void *base;
    2777 + struct v4l2_pix_format fmt;
    2778 +};
    2779 +/* Flags for the 'capability' field. Read only */
    2780 +#define V4L2_FBUF_CAP_EXTERNOVERLAY 0x0001
    2781 +#define V4L2_FBUF_CAP_CHROMAKEY 0x0002
    2782 +#define V4L2_FBUF_CAP_LIST_CLIPPING 0x0004
    2783 +#define V4L2_FBUF_CAP_BITMAP_CLIPPING 0x0008
    2784 +#define V4L2_FBUF_CAP_LOCAL_ALPHA 0x0010
    2785 +#define V4L2_FBUF_CAP_GLOBAL_ALPHA 0x0020
    2786 +#define V4L2_FBUF_CAP_LOCAL_INV_ALPHA 0x0040
    2787 +#define V4L2_FBUF_CAP_SRC_CHROMAKEY 0x0080
    2788 +/* Flags for the 'flags' field. */
    2789 +#define V4L2_FBUF_FLAG_PRIMARY 0x0001
    2790 +#define V4L2_FBUF_FLAG_OVERLAY 0x0002
    2791 +#define V4L2_FBUF_FLAG_CHROMAKEY 0x0004
    2792 +#define V4L2_FBUF_FLAG_LOCAL_ALPHA 0x0008
    2793 +#define V4L2_FBUF_FLAG_GLOBAL_ALPHA 0x0010
    2794 +#define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA 0x0020
    2795 +#define V4L2_FBUF_FLAG_SRC_CHROMAKEY 0x0040
    2796 +
    2797 +struct v4l2_clip {
    2798 + struct v4l2_rect c;
    2799 + struct v4l2_clip *next;
    2800 +};
    2801 +
    2802 +struct v4l2_window {
    2803 + struct v4l2_rect w;
    2804 + enum v4l2_field field;
    2805 + __u32 chromakey;
    2806 + struct v4l2_clip *clips;
    2807 + __u32 clipcount;
    2808 + void *bitmap;
    2809 + __u8 global_alpha;
    2810 +};
    2811 +
    2812 +/*
    2813 + * C A P T U R E P A R A M E T E R S
    2814 + */
    2815 +struct v4l2_captureparm {
    2816 + __u32 capability; /* Supported modes */
    2817 + __u32 capturemode; /* Current mode */
    2818 + struct v4l2_fract timeperframe; /* Time per frame in .1us units */
    2819 + __u32 extendedmode; /* Driver-specific extensions */
    2820 + __u32 readbuffers; /* # of buffers for read */
    2821 + __u32 reserved[4];
    2822 +};
    2823 +
    2824 +/* Flags for 'capability' and 'capturemode' fields */
    2825 +#define V4L2_MODE_HIGHQUALITY 0x0001 /* High quality imaging mode */
    2826 +#define V4L2_CAP_TIMEPERFRAME 0x1000 /* timeperframe field is supported */
    2827 +
    2828 +struct v4l2_outputparm {
    2829 + __u32 capability; /* Supported modes */
    2830 + __u32 outputmode; /* Current mode */
    2831 + struct v4l2_fract timeperframe; /* Time per frame in seconds */
    2832 + __u32 extendedmode; /* Driver-specific extensions */
    2833 + __u32 writebuffers; /* # of buffers for write */
    2834 + __u32 reserved[4];
    2835 +};
    2836 +
    2837 +/*
    2838 + * I N P U T I M A G E C R O P P I N G
    2839 + */
    2840 +struct v4l2_cropcap {
    2841 + enum v4l2_buf_type type;
    2842 + struct v4l2_rect bounds;
    2843 + struct v4l2_rect defrect;
    2844 + struct v4l2_fract pixelaspect;
    2845 +};
    2846 +
    2847 +struct v4l2_crop {
    2848 + enum v4l2_buf_type type;
    2849 + struct v4l2_rect c;
    2850 +};
    2851 +
    2852 +/*
    2853 + * A N A L O G V I D E O S T A N D A R D
    2854 + */
    2855 +
    2856 +typedef __u64 v4l2_std_id;
    2857 +
    2858 +/* one bit for each */
    2859 +#define V4L2_STD_PAL_B ((v4l2_std_id)0x00000001)
    2860 +#define V4L2_STD_PAL_B1 ((v4l2_std_id)0x00000002)
    2861 +#define V4L2_STD_PAL_G ((v4l2_std_id)0x00000004)
    2862 +#define V4L2_STD_PAL_H ((v4l2_std_id)0x00000008)
    2863 +#define V4L2_STD_PAL_I ((v4l2_std_id)0x00000010)
    2864 +#define V4L2_STD_PAL_D ((v4l2_std_id)0x00000020)
    2865 +#define V4L2_STD_PAL_D1 ((v4l2_std_id)0x00000040)
    2866 +#define V4L2_STD_PAL_K ((v4l2_std_id)0x00000080)
    2867 +
    2868 +#define V4L2_STD_PAL_M ((v4l2_std_id)0x00000100)
    2869 +#define V4L2_STD_PAL_N ((v4l2_std_id)0x00000200)
    2870 +#define V4L2_STD_PAL_Nc ((v4l2_std_id)0x00000400)
    2871 +#define V4L2_STD_PAL_60 ((v4l2_std_id)0x00000800)
    2872 +
    2873 +#define V4L2_STD_NTSC_M ((v4l2_std_id)0x00001000)
    2874 +#define V4L2_STD_NTSC_M_JP ((v4l2_std_id)0x00002000)
    2875 +#define V4L2_STD_NTSC_443 ((v4l2_std_id)0x00004000)
    2876 +#define V4L2_STD_NTSC_M_KR ((v4l2_std_id)0x00008000)
    2877 +
    2878 +#define V4L2_STD_SECAM_B ((v4l2_std_id)0x00010000)
    2879 +#define V4L2_STD_SECAM_D ((v4l2_std_id)0x00020000)
    2880 +#define V4L2_STD_SECAM_G ((v4l2_std_id)0x00040000)
    2881 +#define V4L2_STD_SECAM_H ((v4l2_std_id)0x00080000)
    2882 +#define V4L2_STD_SECAM_K ((v4l2_std_id)0x00100000)
    2883 +#define V4L2_STD_SECAM_K1 ((v4l2_std_id)0x00200000)
    2884 +#define V4L2_STD_SECAM_L ((v4l2_std_id)0x00400000)
    2885 +#define V4L2_STD_SECAM_LC ((v4l2_std_id)0x00800000)
    2886 +
    2887 +/* ATSC/HDTV */
    2888 +#define V4L2_STD_ATSC_8_VSB ((v4l2_std_id)0x01000000)
    2889 +#define V4L2_STD_ATSC_16_VSB ((v4l2_std_id)0x02000000)
    2890 +
    2891 +/* FIXME:
    2892 + Although std_id is 64 bits, there is an issue on PPC32 architecture that
    2893 + makes switch(__u64) to break. So, there's a hack on v4l2-common.c rounding
    2894 + this value to 32 bits.
    2895 + As, currently, the max value is for V4L2_STD_ATSC_16_VSB (30 bits wide),
    2896 + it should work fine. However, if needed to add more than two standards,
    2897 + v4l2-common.c should be fixed.
    2898 + */
    2899 +
    2900 +/* some merged standards */
    2901 +#define V4L2_STD_MN (V4L2_STD_PAL_M|V4L2_STD_PAL_N|V4L2_STD_PAL_Nc|V4L2_STD_NTSC)
    2902 +#define V4L2_STD_B (V4L2_STD_PAL_B|V4L2_STD_PAL_B1|V4L2_STD_SECAM_B)
    2903 +#define V4L2_STD_GH (V4L2_STD_PAL_G|V4L2_STD_PAL_H|V4L2_STD_SECAM_G|V4L2_STD_SECAM_H)
    2904 +#define V4L2_STD_DK (V4L2_STD_PAL_DK|V4L2_STD_SECAM_DK)
    2905 +
    2906 +/* some common needed stuff */
    2907 +#define V4L2_STD_PAL_BG (V4L2_STD_PAL_B |\
    2908 + V4L2_STD_PAL_B1 |\
    2909 + V4L2_STD_PAL_G)
    2910 +#define V4L2_STD_PAL_DK (V4L2_STD_PAL_D |\
    2911 + V4L2_STD_PAL_D1 |\
    2912 + V4L2_STD_PAL_K)
    2913 +#define V4L2_STD_PAL (V4L2_STD_PAL_BG |\
    2914 + V4L2_STD_PAL_DK |\
    2915 + V4L2_STD_PAL_H |\
    2916 + V4L2_STD_PAL_I)
    2917 +#define V4L2_STD_NTSC (V4L2_STD_NTSC_M |\
    2918 + V4L2_STD_NTSC_M_JP |\
    2919 + V4L2_STD_NTSC_M_KR)
    2920 +#define V4L2_STD_SECAM_DK (V4L2_STD_SECAM_D |\
    2921 + V4L2_STD_SECAM_K |\
    2922 + V4L2_STD_SECAM_K1)
    2923 +#define V4L2_STD_SECAM (V4L2_STD_SECAM_B |\
    2924 + V4L2_STD_SECAM_G |\
    2925 + V4L2_STD_SECAM_H |\
    2926 + V4L2_STD_SECAM_DK |\
    2927 + V4L2_STD_SECAM_L |\
    2928 + V4L2_STD_SECAM_LC)
    2929 +
    2930 +#define V4L2_STD_525_60 (V4L2_STD_PAL_M |\
    2931 + V4L2_STD_PAL_60 |\
    2932 + V4L2_STD_NTSC |\
    2933 + V4L2_STD_NTSC_443)
    2934 +#define V4L2_STD_625_50 (V4L2_STD_PAL |\
    2935 + V4L2_STD_PAL_N |\
    2936 + V4L2_STD_PAL_Nc |\
    2937 + V4L2_STD_SECAM)
    2938 +#define V4L2_STD_ATSC (V4L2_STD_ATSC_8_VSB |\
    2939 + V4L2_STD_ATSC_16_VSB)
    2940 +
    2941 +#define V4L2_STD_UNKNOWN 0
    2942 +#define V4L2_STD_ALL (V4L2_STD_525_60 |\
    2943 + V4L2_STD_625_50)
    2944 +
    2945 +struct v4l2_standard {
    2946 + __u32 index;
    2947 + v4l2_std_id id;
    2948 + __u8 name[24];
    2949 + struct v4l2_fract frameperiod; /* Frames, not fields */
    2950 + __u32 framelines;
    2951 + __u32 reserved[4];
    2952 +};
    2953 +
    2954 +/*
    2955 + * V I D E O T I M I N G S D V P R E S E T
    2956 + */
    2957 +struct v4l2_dv_preset {
    2958 + __u32 preset;
    2959 + __u32 reserved[4];
    2960 +};
    2961 +
    2962 +/*
    2963 + * D V P R E S E T S E N U M E R A T I O N
    2964 + */
    2965 +struct v4l2_dv_enum_preset {
    2966 + __u32 index;
    2967 + __u32 preset;
    2968 + __u8 name[32]; /* Name of the preset timing */
    2969 + __u32 width;
    2970 + __u32 height;
    2971 + __u32 reserved[4];
    2972 +};
    2973 +
    2974 +/*
    2975 + * D V P R E S E T V A L U E S
    2976 + */
    2977 +#define V4L2_DV_INVALID 0
    2978 +#define V4L2_DV_480P59_94 1 /* BT.1362 */
    2979 +#define V4L2_DV_576P50 2 /* BT.1362 */
    2980 +#define V4L2_DV_720P24 3 /* SMPTE 296M */
    2981 +#define V4L2_DV_720P25 4 /* SMPTE 296M */
    2982 +#define V4L2_DV_720P30 5 /* SMPTE 296M */
    2983 +#define V4L2_DV_720P50 6 /* SMPTE 296M */
    2984 +#define V4L2_DV_720P59_94 7 /* SMPTE 274M */
    2985 +#define V4L2_DV_720P60 8 /* SMPTE 274M/296M */
    2986 +#define V4L2_DV_1080I29_97 9 /* BT.1120/ SMPTE 274M */
    2987 +#define V4L2_DV_1080I30 10 /* BT.1120/ SMPTE 274M */
    2988 +#define V4L2_DV_1080I25 11 /* BT.1120 */
    2989 +#define V4L2_DV_1080I50 12 /* SMPTE 296M */
    2990 +#define V4L2_DV_1080I60 13 /* SMPTE 296M */
    2991 +#define V4L2_DV_1080P24 14 /* SMPTE 296M */
    2992 +#define V4L2_DV_1080P25 15 /* SMPTE 296M */
    2993 +#define V4L2_DV_1080P30 16 /* SMPTE 296M */
    2994 +#define V4L2_DV_1080P50 17 /* BT.1120 */
    2995 +#define V4L2_DV_1080P60 18 /* BT.1120 */
    2996 +
    2997 +/*
    2998 + * D V B T T I M I N G S
    2999 + */
    3000 +
    3001 +/* BT.656/BT.1120 timing data */
    3002 +struct v4l2_bt_timings {
    3003 + __u32 width; /* width in pixels */
    3004 + __u32 height; /* height in lines */
    3005 + __u32 interlaced; /* Interlaced or progressive */
    3006 + __u32 polarities; /* Positive or negative polarity */
    3007 + __u64 pixelclock; /* Pixel clock in HZ. Ex. 74.25MHz->74250000 */
    3008 + __u32 hfrontporch; /* Horizpontal front porch in pixels */
    3009 + __u32 hsync; /* Horizontal Sync length in pixels */
    3010 + __u32 hbackporch; /* Horizontal back porch in pixels */
    3011 + __u32 vfrontporch; /* Vertical front porch in pixels */
    3012 + __u32 vsync; /* Vertical Sync length in lines */
    3013 + __u32 vbackporch; /* Vertical back porch in lines */
    3014 + __u32 il_vfrontporch; /* Vertical front porch for bottom field of
    3015 + * interlaced field formats
    3016 + */
    3017 + __u32 il_vsync; /* Vertical sync length for bottom field of
    3018 + * interlaced field formats
    3019 + */
    3020 + __u32 il_vbackporch; /* Vertical back porch for bottom field of
    3021 + * interlaced field formats
    3022 + */
    3023 + __u32 reserved[16];
    3024 +} __attribute__ ((packed));
    3025 +
    3026 +/* Interlaced or progressive format */
    3027 +#define V4L2_DV_PROGRESSIVE 0
    3028 +#define V4L2_DV_INTERLACED 1
    3029 +
    3030 +/* Polarities. If bit is not set, it is assumed to be negative polarity */
    3031 +#define V4L2_DV_VSYNC_POS_POL 0x00000001
    3032 +#define V4L2_DV_HSYNC_POS_POL 0x00000002
    3033 +
    3034 +
    3035 +/* DV timings */
    3036 +struct v4l2_dv_timings {
    3037 + __u32 type;
    3038 + union {
    3039 + struct v4l2_bt_timings bt;
    3040 + __u32 reserved[32];
    3041 + };
    3042 +} __attribute__ ((packed));
    3043 +
    3044 +/* Values for the type field */
    3045 +#define V4L2_DV_BT_656_1120 0 /* BT.656/1120 timing type */
    3046 +
    3047 +/*
    3048 + * V I D E O I N P U T S
    3049 + */
    3050 +struct v4l2_input {
    3051 + __u32 index; /* Which input */
    3052 + __u8 name[32]; /* Label */
    3053 + __u32 type; /* Type of input */
    3054 + __u32 audioset; /* Associated audios (bitfield) */
    3055 + __u32 tuner; /* Associated tuner */
    3056 + v4l2_std_id std;
    3057 + __u32 status;
    3058 + __u32 capabilities;
    3059 + __u32 reserved[3];
    3060 +};
    3061 +
    3062 +/* Values for the 'type' field */
    3063 +#define V4L2_INPUT_TYPE_TUNER 1
    3064 +#define V4L2_INPUT_TYPE_CAMERA 2
    3065 +
    3066 +/* field 'status' - general */
    3067 +#define V4L2_IN_ST_NO_POWER 0x00000001 /* Attached device is off */
    3068 +#define V4L2_IN_ST_NO_SIGNAL 0x00000002
    3069 +#define V4L2_IN_ST_NO_COLOR 0x00000004
    3070 +
    3071 +/* field 'status' - sensor orientation */
    3072 +/* If sensor is mounted upside down set both bits */
    3073 +#define V4L2_IN_ST_HFLIP 0x00000010 /* Frames are flipped horizontally */
    3074 +#define V4L2_IN_ST_VFLIP 0x00000020 /* Frames are flipped vertically */
    3075 +
    3076 +/* field 'status' - analog */
    3077 +#define V4L2_IN_ST_NO_H_LOCK 0x00000100 /* No horizontal sync lock */
    3078 +#define V4L2_IN_ST_COLOR_KILL 0x00000200 /* Color killer is active */
    3079 +
    3080 +/* field 'status' - digital */
    3081 +#define V4L2_IN_ST_NO_SYNC 0x00010000 /* No synchronization lock */
    3082 +#define V4L2_IN_ST_NO_EQU 0x00020000 /* No equalizer lock */
    3083 +#define V4L2_IN_ST_NO_CARRIER 0x00040000 /* Carrier recovery failed */
    3084 +
    3085 +/* field 'status' - VCR and set-top box */
    3086 +#define V4L2_IN_ST_MACROVISION 0x01000000 /* Macrovision detected */
    3087 +#define V4L2_IN_ST_NO_ACCESS 0x02000000 /* Conditional access denied */
    3088 +#define V4L2_IN_ST_VTR 0x04000000 /* VTR time constant */
    3089 +
    3090 +/* capabilities flags */
    3091 +#define V4L2_IN_CAP_PRESETS 0x00000001 /* Supports S_DV_PRESET */
    3092 +#define V4L2_IN_CAP_CUSTOM_TIMINGS 0x00000002 /* Supports S_DV_TIMINGS */
    3093 +#define V4L2_IN_CAP_STD 0x00000004 /* Supports S_STD */
    3094 +
    3095 +/*
    3096 + * V I D E O O U T P U T S
    3097 + */
    3098 +struct v4l2_output {
    3099 + __u32 index; /* Which output */
    3100 + __u8 name[32]; /* Label */
    3101 + __u32 type; /* Type of output */
    3102 + __u32 audioset; /* Associated audios (bitfield) */
    3103 + __u32 modulator; /* Associated modulator */
    3104 + v4l2_std_id std;
    3105 + __u32 capabilities;
    3106 + __u32 reserved[3];
    3107 +};
    3108 +/* Values for the 'type' field */
    3109 +#define V4L2_OUTPUT_TYPE_MODULATOR 1
    3110 +#define V4L2_OUTPUT_TYPE_ANALOG 2
    3111 +#define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY 3
    3112 +
    3113 +/* capabilities flags */
    3114 +#define V4L2_OUT_CAP_PRESETS 0x00000001 /* Supports S_DV_PRESET */
    3115 +#define V4L2_OUT_CAP_CUSTOM_TIMINGS 0x00000002 /* Supports S_DV_TIMINGS */
    3116 +#define V4L2_OUT_CAP_STD 0x00000004 /* Supports S_STD */
    3117 +
    3118 +/*
    3119 + * C O N T R O L S
    3120 + */
    3121 +struct v4l2_control {
    3122 + __u32 id;
    3123 + __s32 value;
    3124 +};
    3125 +
    3126 +struct v4l2_ext_control {
    3127 + __u32 id;
    3128 + __u32 size;
    3129 + __u32 reserved2[1];
    3130 + union {
    3131 + __s32 value;
    3132 + __s64 value64;
    3133 + char *string;
    3134 + };
    3135 +} __attribute__ ((packed));
    3136 +
    3137 +struct v4l2_ext_controls {
    3138 + __u32 ctrl_class;
    3139 + __u32 count;
    3140 + __u32 error_idx;
    3141 + __u32 reserved[2];
    3142 + struct v4l2_ext_control *controls;
    3143 +};
    3144 +
    3145 +/* Values for ctrl_class field */
    3146 +#define V4L2_CTRL_CLASS_USER 0x00980000 /* Old-style 'user' controls */
    3147 +#define V4L2_CTRL_CLASS_MPEG 0x00990000 /* MPEG-compression controls */
    3148 +#define V4L2_CTRL_CLASS_CAMERA 0x009a0000 /* Camera class controls */
    3149 +#define V4L2_CTRL_CLASS_FM_TX 0x009b0000 /* FM Modulator control class */
    3150 +
    3151 +#define V4L2_CTRL_ID_MASK (0x0fffffff)
    3152 +#define V4L2_CTRL_ID2CLASS(id) ((id) & 0x0fff0000UL)
    3153 +#define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)
    3154 +
    3155 +enum v4l2_ctrl_type {
    3156 + V4L2_CTRL_TYPE_INTEGER = 1,
    3157 + V4L2_CTRL_TYPE_BOOLEAN = 2,
    3158 + V4L2_CTRL_TYPE_MENU = 3,
    3159 + V4L2_CTRL_TYPE_BUTTON = 4,
    3160 + V4L2_CTRL_TYPE_INTEGER64 = 5,
    3161 + V4L2_CTRL_TYPE_CTRL_CLASS = 6,
    3162 + V4L2_CTRL_TYPE_STRING = 7,
    3163 +};
    3164 +
    3165 +/* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
    3166 +struct v4l2_queryctrl {
    3167 + __u32 id;
    3168 + enum v4l2_ctrl_type type;
    3169 + __u8 name[32]; /* Whatever */
    3170 + __s32 minimum; /* Note signedness */
    3171 + __s32 maximum;
    3172 + __s32 step;
    3173 + __s32 default_value;
    3174 + __u32 flags;
    3175 + __u32 reserved[2];
    3176 +};
    3177 +
    3178 +/* Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
    3179 +struct v4l2_querymenu {
    3180 + __u32 id;
    3181 + __u32 index;
    3182 + __u8 name[32]; /* Whatever */
    3183 + __u32 reserved;
    3184 +};
    3185 +
    3186 +/* Control flags */
    3187 +#define V4L2_CTRL_FLAG_DISABLED 0x0001
    3188 +#define V4L2_CTRL_FLAG_GRABBED 0x0002
    3189 +#define V4L2_CTRL_FLAG_READ_ONLY 0x0004
    3190 +#define V4L2_CTRL_FLAG_UPDATE 0x0008
    3191 +#define V4L2_CTRL_FLAG_INACTIVE 0x0010
    3192 +#define V4L2_CTRL_FLAG_SLIDER 0x0020
    3193 +#define V4L2_CTRL_FLAG_WRITE_ONLY 0x0040
    3194 +
    3195 +/* Query flag, to be ORed with the control ID */
    3196 +#define V4L2_CTRL_FLAG_NEXT_CTRL 0x80000000
    3197 +
    3198 +/* User-class control IDs defined by V4L2 */
    3199 +#define V4L2_CID_BASE (V4L2_CTRL_CLASS_USER | 0x900)
    3200 +#define V4L2_CID_USER_BASE V4L2_CID_BASE
    3201 +/* IDs reserved for driver specific controls */
    3202 +#define V4L2_CID_PRIVATE_BASE 0x08000000
    3203 +
    3204 +#define V4L2_CID_USER_CLASS (V4L2_CTRL_CLASS_USER | 1)
    3205 +#define V4L2_CID_BRIGHTNESS (V4L2_CID_BASE+0)
    3206 +#define V4L2_CID_CONTRAST (V4L2_CID_BASE+1)
    3207 +#define V4L2_CID_SATURATION (V4L2_CID_BASE+2)
    3208 +#define V4L2_CID_HUE (V4L2_CID_BASE+3)
    3209 +#define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE+5)
    3210 +#define V4L2_CID_AUDIO_BALANCE (V4L2_CID_BASE+6)
    3211 +#define V4L2_CID_AUDIO_BASS (V4L2_CID_BASE+7)
    3212 +#define V4L2_CID_AUDIO_TREBLE (V4L2_CID_BASE+8)
    3213 +#define V4L2_CID_AUDIO_MUTE (V4L2_CID_BASE+9)
    3214 +#define V4L2_CID_AUDIO_LOUDNESS (V4L2_CID_BASE+10)
    3215 +#define V4L2_CID_BLACK_LEVEL (V4L2_CID_BASE+11) /* Deprecated */
    3216 +#define V4L2_CID_AUTO_WHITE_BALANCE (V4L2_CID_BASE+12)
    3217 +#define V4L2_CID_DO_WHITE_BALANCE (V4L2_CID_BASE+13)
    3218 +#define V4L2_CID_RED_BALANCE (V4L2_CID_BASE+14)
    3219 +#define V4L2_CID_BLUE_BALANCE (V4L2_CID_BASE+15)
    3220 +#define V4L2_CID_GAMMA (V4L2_CID_BASE+16)
    3221 +#define V4L2_CID_WHITENESS (V4L2_CID_GAMMA) /* Deprecated */
    3222 +#define V4L2_CID_EXPOSURE (V4L2_CID_BASE+17)
    3223 +#define V4L2_CID_AUTOGAIN (V4L2_CID_BASE+18)
    3224 +#define V4L2_CID_GAIN (V4L2_CID_BASE+19)
    3225 +#define V4L2_CID_HFLIP (V4L2_CID_BASE+20)
    3226 +#define V4L2_CID_VFLIP (V4L2_CID_BASE+21)
    3227 +
    3228 +/* Deprecated; use V4L2_CID_PAN_RESET and V4L2_CID_TILT_RESET */
    3229 +#define V4L2_CID_HCENTER (V4L2_CID_BASE+22)
    3230 +#define V4L2_CID_VCENTER (V4L2_CID_BASE+23)
    3231 +
    3232 +#define V4L2_CID_POWER_LINE_FREQUENCY (V4L2_CID_BASE+24)
    3233 +enum v4l2_power_line_frequency {
    3234 + V4L2_CID_POWER_LINE_FREQUENCY_DISABLED = 0,
    3235 + V4L2_CID_POWER_LINE_FREQUENCY_50HZ = 1,
    3236 + V4L2_CID_POWER_LINE_FREQUENCY_60HZ = 2,
    3237 +};
    3238 +#define V4L2_CID_HUE_AUTO (V4L2_CID_BASE+25)
    3239 +#define V4L2_CID_WHITE_BALANCE_TEMPERATURE (V4L2_CID_BASE+26)
    3240 +#define V4L2_CID_SHARPNESS (V4L2_CID_BASE+27)
    3241 +#define V4L2_CID_BACKLIGHT_COMPENSATION (V4L2_CID_BASE+28)
    3242 +#define V4L2_CID_CHROMA_AGC (V4L2_CID_BASE+29)
    3243 +#define V4L2_CID_COLOR_KILLER (V4L2_CID_BASE+30)
    3244 +#define V4L2_CID_COLORFX (V4L2_CID_BASE+31)
    3245 +enum v4l2_colorfx {
    3246 + V4L2_COLORFX_NONE = 0,
    3247 + V4L2_COLORFX_BW = 1,
    3248 + V4L2_COLORFX_SEPIA = 2,
    3249 + V4L2_COLORFX_NEGATIVE = 3,
    3250 + V4L2_COLORFX_EMBOSS = 4,
    3251 + V4L2_COLORFX_SKETCH = 5,
    3252 + V4L2_COLORFX_SKY_BLUE = 6,
    3253 + V4L2_COLORFX_GRASS_GREEN = 7,
    3254 + V4L2_COLORFX_SKIN_WHITEN = 8,
    3255 + V4L2_COLORFX_VIVID = 9,
    3256 +};
    3257 +#define V4L2_CID_AUTOBRIGHTNESS (V4L2_CID_BASE+32)
    3258 +#define V4L2_CID_BAND_STOP_FILTER (V4L2_CID_BASE+33)
    3259 +
    3260 +#define V4L2_CID_ROTATE (V4L2_CID_BASE+34)
    3261 +#define V4L2_CID_BG_COLOR (V4L2_CID_BASE+35)
    3262 +
    3263 +#define V4L2_CID_CHROMA_GAIN (V4L2_CID_BASE+36)
    3264 +
    3265 +#define V4L2_CID_ILLUMINATORS_1 (V4L2_CID_BASE+37)
    3266 +#define V4L2_CID_ILLUMINATORS_2 (V4L2_CID_BASE+38)
    3267 +
    3268 +/* last CID + 1 */
    3269 +#define V4L2_CID_LASTP1 (V4L2_CID_BASE+39)
    3270 +
    3271 +/* MPEG-class control IDs defined by V4L2 */
    3272 +#define V4L2_CID_MPEG_BASE (V4L2_CTRL_CLASS_MPEG | 0x900)
    3273 +#define V4L2_CID_MPEG_CLASS (V4L2_CTRL_CLASS_MPEG | 1)
    3274 +
    3275 +/* MPEG streams */
    3276 +#define V4L2_CID_MPEG_STREAM_TYPE (V4L2_CID_MPEG_BASE+0)
    3277 +enum v4l2_mpeg_stream_type {
    3278 + V4L2_MPEG_STREAM_TYPE_MPEG2_PS = 0, /* MPEG-2 program stream */
    3279 + V4L2_MPEG_STREAM_TYPE_MPEG2_TS = 1, /* MPEG-2 transport stream */
    3280 + V4L2_MPEG_STREAM_TYPE_MPEG1_SS = 2, /* MPEG-1 system stream */
    3281 + V4L2_MPEG_STREAM_TYPE_MPEG2_DVD = 3, /* MPEG-2 DVD-compatible stream */
    3282 + V4L2_MPEG_STREAM_TYPE_MPEG1_VCD = 4, /* MPEG-1 VCD-compatible stream */
    3283 + V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD = 5, /* MPEG-2 SVCD-compatible stream */
    3284 +};
    3285 +#define V4L2_CID_MPEG_STREAM_PID_PMT (V4L2_CID_MPEG_BASE+1)
    3286 +#define V4L2_CID_MPEG_STREAM_PID_AUDIO (V4L2_CID_MPEG_BASE+2)
    3287 +#define V4L2_CID_MPEG_STREAM_PID_VIDEO (V4L2_CID_MPEG_BASE+3)
    3288 +#define V4L2_CID_MPEG_STREAM_PID_PCR (V4L2_CID_MPEG_BASE+4)
    3289 +#define V4L2_CID_MPEG_STREAM_PES_ID_AUDIO (V4L2_CID_MPEG_BASE+5)
    3290 +#define V4L2_CID_MPEG_STREAM_PES_ID_VIDEO (V4L2_CID_MPEG_BASE+6)
    3291 +#define V4L2_CID_MPEG_STREAM_VBI_FMT (V4L2_CID_MPEG_BASE+7)
    3292 +enum v4l2_mpeg_stream_vbi_fmt {
    3293 + V4L2_MPEG_STREAM_VBI_FMT_NONE = 0, /* No VBI in the MPEG stream */
    3294 + V4L2_MPEG_STREAM_VBI_FMT_IVTV = 1, /* VBI in private packets, IVTV format */
    3295 +};
    3296 +
    3297 +/* MPEG audio */
    3298 +#define V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ (V4L2_CID_MPEG_BASE+100)
    3299 +enum v4l2_mpeg_audio_sampling_freq {
    3300 + V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100 = 0,
    3301 + V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000 = 1,
    3302 + V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000 = 2,
    3303 +};
    3304 +#define V4L2_CID_MPEG_AUDIO_ENCODING (V4L2_CID_MPEG_BASE+101)
    3305 +enum v4l2_mpeg_audio_encoding {
    3306 + V4L2_MPEG_AUDIO_ENCODING_LAYER_1 = 0,
    3307 + V4L2_MPEG_AUDIO_ENCODING_LAYER_2 = 1,
    3308 + V4L2_MPEG_AUDIO_ENCODING_LAYER_3 = 2,
    3309 + V4L2_MPEG_AUDIO_ENCODING_AAC = 3,
    3310 + V4L2_MPEG_AUDIO_ENCODING_AC3 = 4,
    3311 +};
    3312 +#define V4L2_CID_MPEG_AUDIO_L1_BITRATE (V4L2_CID_MPEG_BASE+102)
    3313 +enum v4l2_mpeg_audio_l1_bitrate {
    3314 + V4L2_MPEG_AUDIO_L1_BITRATE_32K = 0,
    3315 + V4L2_MPEG_AUDIO_L1_BITRATE_64K = 1,
    3316 + V4L2_MPEG_AUDIO_L1_BITRATE_96K = 2,
    3317 + V4L2_MPEG_AUDIO_L1_BITRATE_128K = 3,
    3318 + V4L2_MPEG_AUDIO_L1_BITRATE_160K = 4,
    3319 + V4L2_MPEG_AUDIO_L1_BITRATE_192K = 5,
    3320 + V4L2_MPEG_AUDIO_L1_BITRATE_224K = 6,
    3321 + V4L2_MPEG_AUDIO_L1_BITRATE_256K = 7,
    3322 + V4L2_MPEG_AUDIO_L1_BITRATE_288K = 8,
    3323 + V4L2_MPEG_AUDIO_L1_BITRATE_320K = 9,
    3324 + V4L2_MPEG_AUDIO_L1_BITRATE_352K = 10,
    3325 + V4L2_MPEG_AUDIO_L1_BITRATE_384K = 11,
    3326 + V4L2_MPEG_AUDIO_L1_BITRATE_416K = 12,
    3327 + V4L2_MPEG_AUDIO_L1_BITRATE_448K = 13,
    3328 +};
    3329 +#define V4L2_CID_MPEG_AUDIO_L2_BITRATE (V4L2_CID_MPEG_BASE+103)
    3330 +enum v4l2_mpeg_audio_l2_bitrate {
    3331 + V4L2_MPEG_AUDIO_L2_BITRATE_32K = 0,
    3332 + V4L2_MPEG_AUDIO_L2_BITRATE_48K = 1,
    3333 + V4L2_MPEG_AUDIO_L2_BITRATE_56K = 2,
    3334 + V4L2_MPEG_AUDIO_L2_BITRATE_64K = 3,
    3335 + V4L2_MPEG_AUDIO_L2_BITRATE_80K = 4,
    3336 + V4L2_MPEG_AUDIO_L2_BITRATE_96K = 5,
    3337 + V4L2_MPEG_AUDIO_L2_BITRATE_112K = 6,
    3338 + V4L2_MPEG_AUDIO_L2_BITRATE_128K = 7,
    3339 + V4L2_MPEG_AUDIO_L2_BITRATE_160K = 8,
    3340 + V4L2_MPEG_AUDIO_L2_BITRATE_192K = 9,
    3341 + V4L2_MPEG_AUDIO_L2_BITRATE_224K = 10,
    3342 + V4L2_MPEG_AUDIO_L2_BITRATE_256K = 11,
    3343 + V4L2_MPEG_AUDIO_L2_BITRATE_320K = 12,
    3344 + V4L2_MPEG_AUDIO_L2_BITRATE_384K = 13,
    3345 +};
    3346 +#define V4L2_CID_MPEG_AUDIO_L3_BITRATE (V4L2_CID_MPEG_BASE+104)
    3347 +enum v4l2_mpeg_audio_l3_bitrate {
    3348 + V4L2_MPEG_AUDIO_L3_BITRATE_32K = 0,
    3349 + V4L2_MPEG_AUDIO_L3_BITRATE_40K = 1,
    3350 + V4L2_MPEG_AUDIO_L3_BITRATE_48K = 2,
    3351 + V4L2_MPEG_AUDIO_L3_BITRATE_56K = 3,
    3352 + V4L2_MPEG_AUDIO_L3_BITRATE_64K = 4,
    3353 + V4L2_MPEG_AUDIO_L3_BITRATE_80K = 5,
    3354 + V4L2_MPEG_AUDIO_L3_BITRATE_96K = 6,
    3355 + V4L2_MPEG_AUDIO_L3_BITRATE_112K = 7,
    3356 + V4L2_MPEG_AUDIO_L3_BITRATE_128K = 8,
    3357 + V4L2_MPEG_AUDIO_L3_BITRATE_160K = 9,
    3358 + V4L2_MPEG_AUDIO_L3_BITRATE_192K = 10,
    3359 + V4L2_MPEG_AUDIO_L3_BITRATE_224K = 11,
    3360 + V4L2_MPEG_AUDIO_L3_BITRATE_256K = 12,
    3361 + V4L2_MPEG_AUDIO_L3_BITRATE_320K = 13,
    3362 +};
    3363 +#define V4L2_CID_MPEG_AUDIO_MODE (V4L2_CID_MPEG_BASE+105)
    3364 +enum v4l2_mpeg_audio_mode {
    3365 + V4L2_MPEG_AUDIO_MODE_STEREO = 0,
    3366 + V4L2_MPEG_AUDIO_MODE_JOINT_STEREO = 1,
    3367 + V4L2_MPEG_AUDIO_MODE_DUAL = 2,
    3368 + V4L2_MPEG_AUDIO_MODE_MONO = 3,
    3369 +};
    3370 +#define V4L2_CID_MPEG_AUDIO_MODE_EXTENSION (V4L2_CID_MPEG_BASE+106)
    3371 +enum v4l2_mpeg_audio_mode_extension {
    3372 + V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4 = 0,
    3373 + V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_8 = 1,
    3374 + V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_12 = 2,
    3375 + V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16 = 3,
    3376 +};
    3377 +#define V4L2_CID_MPEG_AUDIO_EMPHASIS (V4L2_CID_MPEG_BASE+107)
    3378 +enum v4l2_mpeg_audio_emphasis {
    3379 + V4L2_MPEG_AUDIO_EMPHASIS_NONE = 0,
    3380 + V4L2_MPEG_AUDIO_EMPHASIS_50_DIV_15_uS = 1,
    3381 + V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17 = 2,
    3382 +};
    3383 +#define V4L2_CID_MPEG_AUDIO_CRC (V4L2_CID_MPEG_BASE+108)
    3384 +enum v4l2_mpeg_audio_crc {
    3385 + V4L2_MPEG_AUDIO_CRC_NONE = 0,
    3386 + V4L2_MPEG_AUDIO_CRC_CRC16 = 1,
    3387 +};
    3388 +#define V4L2_CID_MPEG_AUDIO_MUTE (V4L2_CID_MPEG_BASE+109)
    3389 +#define V4L2_CID_MPEG_AUDIO_AAC_BITRATE (V4L2_CID_MPEG_BASE+110)
    3390 +#define V4L2_CID_MPEG_AUDIO_AC3_BITRATE (V4L2_CID_MPEG_BASE+111)
    3391 +enum v4l2_mpeg_audio_ac3_bitrate {
    3392 + V4L2_MPEG_AUDIO_AC3_BITRATE_32K = 0,
    3393 + V4L2_MPEG_AUDIO_AC3_BITRATE_40K = 1,
    3394 + V4L2_MPEG_AUDIO_AC3_BITRATE_48K = 2,
    3395 + V4L2_MPEG_AUDIO_AC3_BITRATE_56K = 3,
    3396 + V4L2_MPEG_AUDIO_AC3_BITRATE_64K = 4,
    3397 + V4L2_MPEG_AUDIO_AC3_BITRATE_80K = 5,
    3398 + V4L2_MPEG_AUDIO_AC3_BITRATE_96K = 6,
    3399 + V4L2_MPEG_AUDIO_AC3_BITRATE_112K = 7,
    3400 + V4L2_MPEG_AUDIO_AC3_BITRATE_128K = 8,
    3401 + V4L2_MPEG_AUDIO_AC3_BITRATE_160K = 9,
    3402 + V4L2_MPEG_AUDIO_AC3_BITRATE_192K = 10,
    3403 + V4L2_MPEG_AUDIO_AC3_BITRATE_224K = 11,
    3404 + V4L2_MPEG_AUDIO_AC3_BITRATE_256K = 12,
    3405 + V4L2_MPEG_AUDIO_AC3_BITRATE_320K = 13,
    3406 + V4L2_MPEG_AUDIO_AC3_BITRATE_384K = 14,
    3407 + V4L2_MPEG_AUDIO_AC3_BITRATE_448K = 15,
    3408 + V4L2_MPEG_AUDIO_AC3_BITRATE_512K = 16,
    3409 + V4L2_MPEG_AUDIO_AC3_BITRATE_576K = 17,
    3410 + V4L2_MPEG_AUDIO_AC3_BITRATE_640K = 18,
    3411 +};
    3412 +
    3413 +/* MPEG video */
    3414 +#define V4L2_CID_MPEG_VIDEO_ENCODING (V4L2_CID_MPEG_BASE+200)
    3415 +enum v4l2_mpeg_video_encoding {
    3416 + V4L2_MPEG_VIDEO_ENCODING_MPEG_1 = 0,
    3417 + V4L2_MPEG_VIDEO_ENCODING_MPEG_2 = 1,
    3418 + V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC = 2,
    3419 +};
    3420 +#define V4L2_CID_MPEG_VIDEO_ASPECT (V4L2_CID_MPEG_BASE+201)
    3421 +enum v4l2_mpeg_video_aspect {
    3422 + V4L2_MPEG_VIDEO_ASPECT_1x1 = 0,
    3423 + V4L2_MPEG_VIDEO_ASPECT_4x3 = 1,
    3424 + V4L2_MPEG_VIDEO_ASPECT_16x9 = 2,
    3425 + V4L2_MPEG_VIDEO_ASPECT_221x100 = 3,
    3426 +};
    3427 +#define V4L2_CID_MPEG_VIDEO_B_FRAMES (V4L2_CID_MPEG_BASE+202)
    3428 +#define V4L2_CID_MPEG_VIDEO_GOP_SIZE (V4L2_CID_MPEG_BASE+203)
    3429 +#define V4L2_CID_MPEG_VIDEO_GOP_CLOSURE (V4L2_CID_MPEG_BASE+204)
    3430 +#define V4L2_CID_MPEG_VIDEO_PULLDOWN (V4L2_CID_MPEG_BASE+205)
    3431 +#define V4L2_CID_MPEG_VIDEO_BITRATE_MODE (V4L2_CID_MPEG_BASE+206)
    3432 +enum v4l2_mpeg_video_bitrate_mode {
    3433 + V4L2_MPEG_VIDEO_BITRATE_MODE_VBR = 0,
    3434 + V4L2_MPEG_VIDEO_BITRATE_MODE_CBR = 1,
    3435 +};
    3436 +#define V4L2_CID_MPEG_VIDEO_BITRATE (V4L2_CID_MPEG_BASE+207)
    3437 +#define V4L2_CID_MPEG_VIDEO_BITRATE_PEAK (V4L2_CID_MPEG_BASE+208)
    3438 +#define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
    3439 +#define V4L2_CID_MPEG_VIDEO_MUTE (V4L2_CID_MPEG_BASE+210)
    3440 +#define V4L2_CID_MPEG_VIDEO_MUTE_YUV (V4L2_CID_MPEG_BASE+211)
    3441 +
    3442 +/* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */
    3443 +#define V4L2_CID_MPEG_CX2341X_BASE (V4L2_CTRL_CLASS_MPEG | 0x1000)
    3444 +#define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_MPEG_CX2341X_BASE+0)
    3445 +enum v4l2_mpeg_cx2341x_video_spatial_filter_mode {
    3446 + V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL = 0,
    3447 + V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO = 1,
    3448 +};
    3449 +#define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER (V4L2_CID_MPEG_CX2341X_BASE+1)
    3450 +#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+2)
    3451 +enum v4l2_mpeg_cx2341x_video_luma_spatial_filter_type {
    3452 + V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF = 0,
    3453 + V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
    3454 + V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_VERT = 2,
    3455 + V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_HV_SEPARABLE = 3,
    3456 + V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE = 4,
    3457 +};
    3458 +#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+3)
    3459 +enum v4l2_mpeg_cx2341x_video_chroma_spatial_filter_type {
    3460 + V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF = 0,
    3461 + V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
    3462 +};
    3463 +#define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE (V4L2_CID_MPEG_CX2341X_BASE+4)
    3464 +enum v4l2_mpeg_cx2341x_video_temporal_filter_mode {
    3465 + V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL = 0,
    3466 + V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO = 1,
    3467 +};
    3468 +#define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER (V4L2_CID_MPEG_CX2341X_BASE+5)
    3469 +#define V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+6)
    3470 +enum v4l2_mpeg_cx2341x_video_median_filter_type {
    3471 + V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF = 0,
    3472 + V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR = 1,
    3473 + V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_VERT = 2,
    3474 + V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR_VERT = 3,
    3475 + V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG = 4,
    3476 +};
    3477 +#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+7)
    3478 +#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+8)
    3479 +#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+9)
    3480 +#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+10)
    3481 +#define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS (V4L2_CID_MPEG_CX2341X_BASE+11)
    3482 +
    3483 +/* Camera class control IDs */
    3484 +#define V4L2_CID_CAMERA_CLASS_BASE (V4L2_CTRL_CLASS_CAMERA | 0x900)
    3485 +#define V4L2_CID_CAMERA_CLASS (V4L2_CTRL_CLASS_CAMERA | 1)
    3486 +
    3487 +#define V4L2_CID_EXPOSURE_AUTO (V4L2_CID_CAMERA_CLASS_BASE+1)
    3488 +enum v4l2_exposure_auto_type {
    3489 + V4L2_EXPOSURE_AUTO = 0,
    3490 + V4L2_EXPOSURE_MANUAL = 1,
    3491 + V4L2_EXPOSURE_SHUTTER_PRIORITY = 2,
    3492 + V4L2_EXPOSURE_APERTURE_PRIORITY = 3
    3493 +};
    3494 +#define V4L2_CID_EXPOSURE_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+2)
    3495 +#define V4L2_CID_EXPOSURE_AUTO_PRIORITY (V4L2_CID_CAMERA_CLASS_BASE+3)
    3496 +
    3497 +#define V4L2_CID_PAN_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+4)
    3498 +#define V4L2_CID_TILT_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+5)
    3499 +#define V4L2_CID_PAN_RESET (V4L2_CID_CAMERA_CLASS_BASE+6)
    3500 +#define V4L2_CID_TILT_RESET (V4L2_CID_CAMERA_CLASS_BASE+7)
    3501 +
    3502 +#define V4L2_CID_PAN_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+8)
    3503 +#define V4L2_CID_TILT_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+9)
    3504 +
    3505 +#define V4L2_CID_FOCUS_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+10)
    3506 +#define V4L2_CID_FOCUS_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+11)
    3507 +#define V4L2_CID_FOCUS_AUTO (V4L2_CID_CAMERA_CLASS_BASE+12)
    3508 +
    3509 +#define V4L2_CID_ZOOM_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+13)
    3510 +#define V4L2_CID_ZOOM_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+14)
    3511 +#define V4L2_CID_ZOOM_CONTINUOUS (V4L2_CID_CAMERA_CLASS_BASE+15)
    3512 +
    3513 +#define V4L2_CID_PRIVACY (V4L2_CID_CAMERA_CLASS_BASE+16)
    3514 +
    3515 +#define V4L2_CID_IRIS_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+17)
    3516 +#define V4L2_CID_IRIS_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+18)
    3517 +
    3518 +/* FM Modulator class control IDs */
    3519 +#define V4L2_CID_FM_TX_CLASS_BASE (V4L2_CTRL_CLASS_FM_TX | 0x900)
    3520 +#define V4L2_CID_FM_TX_CLASS (V4L2_CTRL_CLASS_FM_TX | 1)
    3521 +
    3522 +#define V4L2_CID_RDS_TX_DEVIATION (V4L2_CID_FM_TX_CLASS_BASE + 1)
    3523 +#define V4L2_CID_RDS_TX_PI (V4L2_CID_FM_TX_CLASS_BASE + 2)
    3524 +#define V4L2_CID_RDS_TX_PTY (V4L2_CID_FM_TX_CLASS_BASE + 3)
    3525 +#define V4L2_CID_RDS_TX_PS_NAME (V4L2_CID_FM_TX_CLASS_BASE + 5)
    3526 +#define V4L2_CID_RDS_TX_RADIO_TEXT (V4L2_CID_FM_TX_CLASS_BASE + 6)
    3527 +
    3528 +#define V4L2_CID_AUDIO_LIMITER_ENABLED (V4L2_CID_FM_TX_CLASS_BASE + 64)
    3529 +#define V4L2_CID_AUDIO_LIMITER_RELEASE_TIME (V4L2_CID_FM_TX_CLASS_BASE + 65)
    3530 +#define V4L2_CID_AUDIO_LIMITER_DEVIATION (V4L2_CID_FM_TX_CLASS_BASE + 66)
    3531 +
    3532 +#define V4L2_CID_AUDIO_COMPRESSION_ENABLED (V4L2_CID_FM_TX_CLASS_BASE + 80)
    3533 +#define V4L2_CID_AUDIO_COMPRESSION_GAIN (V4L2_CID_FM_TX_CLASS_BASE + 81)
    3534 +#define V4L2_CID_AUDIO_COMPRESSION_THRESHOLD (V4L2_CID_FM_TX_CLASS_BASE + 82)
    3535 +#define V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME (V4L2_CID_FM_TX_CLASS_BASE + 83)
    3536 +#define V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME (V4L2_CID_FM_TX_CLASS_BASE + 84)
    3537 +
    3538 +#define V4L2_CID_PILOT_TONE_ENABLED (V4L2_CID_FM_TX_CLASS_BASE + 96)
    3539 +#define V4L2_CID_PILOT_TONE_DEVIATION (V4L2_CID_FM_TX_CLASS_BASE + 97)
    3540 +#define V4L2_CID_PILOT_TONE_FREQUENCY (V4L2_CID_FM_TX_CLASS_BASE + 98)
    3541 +
    3542 +#define V4L2_CID_TUNE_PREEMPHASIS (V4L2_CID_FM_TX_CLASS_BASE + 112)
    3543 +enum v4l2_preemphasis {
    3544 + V4L2_PREEMPHASIS_DISABLED = 0,
    3545 + V4L2_PREEMPHASIS_50_uS = 1,
    3546 + V4L2_PREEMPHASIS_75_uS = 2,
    3547 +};
    3548 +#define V4L2_CID_TUNE_POWER_LEVEL (V4L2_CID_FM_TX_CLASS_BASE + 113)
    3549 +#define V4L2_CID_TUNE_ANTENNA_CAPACITOR (V4L2_CID_FM_TX_CLASS_BASE + 114)
    3550 +
    3551 +/*
    3552 + * T U N I N G
    3553 + */
    3554 +struct v4l2_tuner {
    3555 + __u32 index;
    3556 + __u8 name[32];
    3557 + enum v4l2_tuner_type type;
    3558 + __u32 capability;
    3559 + __u32 rangelow;
    3560 + __u32 rangehigh;
    3561 + __u32 rxsubchans;
    3562 + __u32 audmode;
    3563 + __s32 signal;
    3564 + __s32 afc;
    3565 + __u32 reserved[4];
    3566 +};
    3567 +
    3568 +struct v4l2_modulator {
    3569 + __u32 index;
    3570 + __u8 name[32];
    3571 + __u32 capability;
    3572 + __u32 rangelow;
    3573 + __u32 rangehigh;
    3574 + __u32 txsubchans;
    3575 + __u32 reserved[4];
    3576 +};
    3577 +
    3578 +/* Flags for the 'capability' field */
    3579 +#define V4L2_TUNER_CAP_LOW 0x0001
    3580 +#define V4L2_TUNER_CAP_NORM 0x0002
    3581 +#define V4L2_TUNER_CAP_STEREO 0x0010
    3582 +#define V4L2_TUNER_CAP_LANG2 0x0020
    3583 +#define V4L2_TUNER_CAP_SAP 0x0020
    3584 +#define V4L2_TUNER_CAP_LANG1 0x0040
    3585 +#define V4L2_TUNER_CAP_RDS 0x0080
    3586 +#define V4L2_TUNER_CAP_RDS_BLOCK_IO 0x0100
    3587 +#define V4L2_TUNER_CAP_RDS_CONTROLS 0x0200
    3588 +
    3589 +/* Flags for the 'rxsubchans' field */
    3590 +#define V4L2_TUNER_SUB_MONO 0x0001
    3591 +#define V4L2_TUNER_SUB_STEREO 0x0002
    3592 +#define V4L2_TUNER_SUB_LANG2 0x0004
    3593 +#define V4L2_TUNER_SUB_SAP 0x0004
    3594 +#define V4L2_TUNER_SUB_LANG1 0x0008
    3595 +#define V4L2_TUNER_SUB_RDS 0x0010
    3596 +
    3597 +/* Values for the 'audmode' field */
    3598 +#define V4L2_TUNER_MODE_MONO 0x0000
    3599 +#define V4L2_TUNER_MODE_STEREO 0x0001
    3600 +#define V4L2_TUNER_MODE_LANG2 0x0002
    3601 +#define V4L2_TUNER_MODE_SAP 0x0002
    3602 +#define V4L2_TUNER_MODE_LANG1 0x0003
    3603 +#define V4L2_TUNER_MODE_LANG1_LANG2 0x0004
    3604 +
    3605 +struct v4l2_frequency {
    3606 + __u32 tuner;
    3607 + enum v4l2_tuner_type type;
    3608 + __u32 frequency;
    3609 + __u32 reserved[8];
    3610 +};
    3611 +
    3612 +struct v4l2_hw_freq_seek {
    3613 + __u32 tuner;
    3614 + enum v4l2_tuner_type type;
    3615 + __u32 seek_upward;
    3616 + __u32 wrap_around;
    3617 + __u32 spacing;
    3618 + __u32 reserved[7];
    3619 +};
    3620 +
    3621 +/*
    3622 + * R D S
    3623 + */
    3624 +
    3625 +struct v4l2_rds_data {
    3626 + __u8 lsb;
    3627 + __u8 msb;
    3628 + __u8 block;
    3629 +} __attribute__ ((packed));
    3630 +
    3631 +#define V4L2_RDS_BLOCK_MSK 0x7
    3632 +#define V4L2_RDS_BLOCK_A 0
    3633 +#define V4L2_RDS_BLOCK_B 1
    3634 +#define V4L2_RDS_BLOCK_C 2
    3635 +#define V4L2_RDS_BLOCK_D 3
    3636 +#define V4L2_RDS_BLOCK_C_ALT 4
    3637 +#define V4L2_RDS_BLOCK_INVALID 7
    3638 +
    3639 +#define V4L2_RDS_BLOCK_CORRECTED 0x40
    3640 +#define V4L2_RDS_BLOCK_ERROR 0x80
    3641 +
    3642 +/*
    3643 + * A U D I O
    3644 + */
    3645 +struct v4l2_audio {
    3646 + __u32 index;
    3647 + __u8 name[32];
    3648 + __u32 capability;
    3649 + __u32 mode;
    3650 + __u32 reserved[2];
    3651 +};
    3652 +
    3653 +/* Flags for the 'capability' field */
    3654 +#define V4L2_AUDCAP_STEREO 0x00001
    3655 +#define V4L2_AUDCAP_AVL 0x00002
    3656 +
    3657 +/* Flags for the 'mode' field */
    3658 +#define V4L2_AUDMODE_AVL 0x00001
    3659 +
    3660 +struct v4l2_audioout {
    3661 + __u32 index;
    3662 + __u8 name[32];
    3663 + __u32 capability;
    3664 + __u32 mode;
    3665 + __u32 reserved[2];
    3666 +};
    3667 +
    3668 +/*
    3669 + * M P E G S E R V I C E S
    3670 + *
    3671 + * NOTE: EXPERIMENTAL API
    3672 + */
    3673 +#if 1
    3674 +#define V4L2_ENC_IDX_FRAME_I (0)
    3675 +#define V4L2_ENC_IDX_FRAME_P (1)
    3676 +#define V4L2_ENC_IDX_FRAME_B (2)
    3677 +#define V4L2_ENC_IDX_FRAME_MASK (0xf)
    3678 +
    3679 +struct v4l2_enc_idx_entry {
    3680 + __u64 offset;
    3681 + __u64 pts;
    3682 + __u32 length;
    3683 + __u32 flags;
    3684 + __u32 reserved[2];
    3685 +};
    3686 +
    3687 +#define V4L2_ENC_IDX_ENTRIES (64)
    3688 +struct v4l2_enc_idx {
    3689 + __u32 entries;
    3690 + __u32 entries_cap;
    3691 + __u32 reserved[4];
    3692 + struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
    3693 +};
    3694 +
    3695 +
    3696 +#define V4L2_ENC_CMD_START (0)
    3697 +#define V4L2_ENC_CMD_STOP (1)
    3698 +#define V4L2_ENC_CMD_PAUSE (2)
    3699 +#define V4L2_ENC_CMD_RESUME (3)
    3700 +
    3701 +/* Flags for V4L2_ENC_CMD_STOP */
    3702 +#define V4L2_ENC_CMD_STOP_AT_GOP_END (1 << 0)
    3703 +
    3704 +struct v4l2_encoder_cmd {
    3705 + __u32 cmd;
    3706 + __u32 flags;
    3707 + union {
    3708 + struct {
    3709 + __u32 data[8];
    3710 + } raw;
    3711 + };
    3712 +};
    3713 +
    3714 +#endif
    3715 +
    3716 +
    3717 +/*
    3718 + * D A T A S E R V I C E S ( V B I )
    3719 + *
    3720 + * Data services API by Michael Schimek
    3721 + */
    3722 +
    3723 +/* Raw VBI */
    3724 +struct v4l2_vbi_format {
    3725 + __u32 sampling_rate; /* in 1 Hz */
    3726 + __u32 offset;
    3727 + __u32 samples_per_line;
    3728 + __u32 sample_format; /* V4L2_PIX_FMT_* */
    3729 + __s32 start[2];
    3730 + __u32 count[2];
    3731 + __u32 flags; /* V4L2_VBI_* */
    3732 + __u32 reserved[2]; /* must be zero */
    3733 +};
    3734 +
    3735 +/* VBI flags */
    3736 +#define V4L2_VBI_UNSYNC (1 << 0)
    3737 +#define V4L2_VBI_INTERLACED (1 << 1)
    3738 +
    3739 +/* Sliced VBI
    3740 + *
    3741 + * This implements is a proposal V4L2 API to allow SLICED VBI
    3742 + * required for some hardware encoders. It should change without
    3743 + * notice in the definitive implementation.
    3744 + */
    3745 +
    3746 +struct v4l2_sliced_vbi_format {
    3747 + __u16 service_set;
    3748 + /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
    3749 + service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
    3750 + (equals frame lines 313-336 for 625 line video
    3751 + standards, 263-286 for 525 line standards) */
    3752 + __u16 service_lines[2][24];
    3753 + __u32 io_size;
    3754 + __u32 reserved[2]; /* must be zero */
    3755 +};
    3756 +
    3757 +/* Teletext World System Teletext
    3758 + (WST), defined on ITU-R BT.653-2 */
    3759 +#define V4L2_SLICED_TELETEXT_B (0x0001)
    3760 +/* Video Program System, defined on ETS 300 231*/
    3761 +#define V4L2_SLICED_VPS (0x0400)
    3762 +/* Closed Caption, defined on EIA-608 */
    3763 +#define V4L2_SLICED_CAPTION_525 (0x1000)
    3764 +/* Wide Screen System, defined on ITU-R BT1119.1 */
    3765 +#define V4L2_SLICED_WSS_625 (0x4000)
    3766 +
    3767 +#define V4L2_SLICED_VBI_525 (V4L2_SLICED_CAPTION_525)
    3768 +#define V4L2_SLICED_VBI_625 (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)
    3769 +
    3770 +struct v4l2_sliced_vbi_cap {
    3771 + __u16 service_set;
    3772 + /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
    3773 + service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
    3774 + (equals frame lines 313-336 for 625 line video
    3775 + standards, 263-286 for 525 line standards) */
    3776 + __u16 service_lines[2][24];
    3777 + enum v4l2_buf_type type;
    3778 + __u32 reserved[3]; /* must be 0 */
    3779 +};
    3780 +
    3781 +struct v4l2_sliced_vbi_data {
    3782 + __u32 id;
    3783 + __u32 field; /* 0: first field, 1: second field */
    3784 + __u32 line; /* 1-23 */
    3785 + __u32 reserved; /* must be 0 */
    3786 + __u8 data[48];
    3787 +};
    3788 +
    3789 +/*
    3790 + * Sliced VBI data inserted into MPEG Streams
    3791 + */
    3792 +
    3793 +/*
    3794 + * V4L2_MPEG_STREAM_VBI_FMT_IVTV:
    3795 + *
    3796 + * Structure of payload contained in an MPEG 2 Private Stream 1 PES Packet in an
    3797 + * MPEG-2 Program Pack that contains V4L2_MPEG_STREAM_VBI_FMT_IVTV Sliced VBI
    3798 + * data
    3799 + *
    3800 + * Note, the MPEG-2 Program Pack and Private Stream 1 PES packet header
    3801 + * definitions are not included here. See the MPEG-2 specifications for details
    3802 + * on these headers.
    3803 + */
    3804 +
    3805 +/* Line type IDs */
    3806 +#define V4L2_MPEG_VBI_IVTV_TELETEXT_B (1)
    3807 +#define V4L2_MPEG_VBI_IVTV_CAPTION_525 (4)
    3808 +#define V4L2_MPEG_VBI_IVTV_WSS_625 (5)
    3809 +#define V4L2_MPEG_VBI_IVTV_VPS (7)
    3810 +
    3811 +struct v4l2_mpeg_vbi_itv0_line {
    3812 + __u8 id; /* One of V4L2_MPEG_VBI_IVTV_* above */
    3813 + __u8 data[42]; /* Sliced VBI data for the line */
    3814 +} __attribute__ ((packed));
    3815 +
    3816 +struct v4l2_mpeg_vbi_itv0 {
    3817 + __le32 linemask[2]; /* Bitmasks of VBI service lines present */
    3818 + struct v4l2_mpeg_vbi_itv0_line line[35];
    3819 +} __attribute__ ((packed));
    3820 +
    3821 +struct v4l2_mpeg_vbi_ITV0 {
    3822 + struct v4l2_mpeg_vbi_itv0_line line[36];
    3823 +} __attribute__ ((packed));
    3824 +
    3825 +#define V4L2_MPEG_VBI_IVTV_MAGIC0 "itv0"
    3826 +#define V4L2_MPEG_VBI_IVTV_MAGIC1 "ITV0"
    3827 +
    3828 +struct v4l2_mpeg_vbi_fmt_ivtv {
    3829 + __u8 magic[4];
    3830 + union {
    3831 + struct v4l2_mpeg_vbi_itv0 itv0;
    3832 + struct v4l2_mpeg_vbi_ITV0 ITV0;
    3833 + };
    3834 +} __attribute__ ((packed));
    3835 +
    3836 +/*
    3837 + * A G G R E G A T E S T R U C T U R E S
    3838 + */
    3839 +
    3840 +/**
    3841 + * struct v4l2_plane_pix_format - additional, per-plane format definition
    3842 + * @sizeimage: maximum size in bytes required for data, for which
    3843 + * this plane will be used
    3844 + * @bytesperline: distance in bytes between the leftmost pixels in two
    3845 + * adjacent lines
    3846 + */
    3847 +struct v4l2_plane_pix_format {
    3848 + __u32 sizeimage;
    3849 + __u16 bytesperline;
    3850 + __u16 reserved[7];
    3851 +} __attribute__ ((packed));
    3852 +
    3853 +/**
    3854 + * struct v4l2_pix_format_mplane - multiplanar format definition
    3855 + * @width: image width in pixels
    3856 + * @height: image height in pixels
    3857 + * @pixelformat: little endian four character code (fourcc)
    3858 + * @field: field order (for interlaced video)
    3859 + * @colorspace: supplemental to pixelformat
    3860 + * @plane_fmt: per-plane information
    3861 + * @num_planes: number of planes for this format
    3862 + */
    3863 +struct v4l2_pix_format_mplane {
    3864 + __u32 width;
    3865 + __u32 height;
    3866 + __u32 pixelformat;
    3867 + enum v4l2_field field;
    3868 + enum v4l2_colorspace colorspace;
    3869 +
    3870 + struct v4l2_plane_pix_format plane_fmt[VIDEO_MAX_PLANES];
    3871 + __u8 num_planes;
    3872 + __u8 reserved[11];
    3873 +} __attribute__ ((packed));
    3874 +
    3875 +/**
    3876 + * struct v4l2_format - stream data format
    3877 + * @type: type of the data stream
    3878 + * @pix: definition of an image format
    3879 + * @pix_mp: definition of a multiplanar image format
    3880 + * @win: definition of an overlaid image
    3881 + * @vbi: raw VBI capture or output parameters
    3882 + * @sliced: sliced VBI capture or output parameters
    3883 + * @raw_data: placeholder for future extensions and custom formats
    3884 + */
    3885 +struct v4l2_format {
    3886 + enum v4l2_buf_type type;
    3887 + union {
    3888 + struct v4l2_pix_format pix; /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
    3889 + struct v4l2_pix_format_mplane pix_mp; /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */
    3890 + struct v4l2_window win; /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
    3891 + struct v4l2_vbi_format vbi; /* V4L2_BUF_TYPE_VBI_CAPTURE */
    3892 + struct v4l2_sliced_vbi_format sliced; /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
    3893 + __u8 raw_data[200]; /* user-defined */
    3894 + } fmt;
    3895 +};
    3896 +
    3897 +/* Stream type-dependent parameters
    3898 + */
    3899 +struct v4l2_streamparm {
    3900 + enum v4l2_buf_type type;
    3901 + union {
    3902 + struct v4l2_captureparm capture;
    3903 + struct v4l2_outputparm output;
    3904 + __u8 raw_data[200]; /* user-defined */
    3905 + } parm;
    3906 +};
    3907 +
    3908 +/*
    3909 + * E V E N T S
    3910 + */
    3911 +
    3912 +#define V4L2_EVENT_ALL 0
    3913 +#define V4L2_EVENT_VSYNC 1
    3914 +#define V4L2_EVENT_EOS 2
    3915 +#define V4L2_EVENT_PRIVATE_START 0x08000000
    3916 +
    3917 +/* Payload for V4L2_EVENT_VSYNC */
    3918 +struct v4l2_event_vsync {
    3919 + /* Can be V4L2_FIELD_ANY, _NONE, _TOP or _BOTTOM */
    3920 + __u8 field;
    3921 +} __attribute__ ((packed));
    3922 +
    3923 +struct v4l2_event {
    3924 + __u32 type;
    3925 + union {
    3926 + struct v4l2_event_vsync vsync;
    3927 + __u8 data[64];
    3928 + } u;
    3929 + __u32 pending;
    3930 + __u32 sequence;
    3931 + struct timespec timestamp;
    3932 + __u32 reserved[9];
    3933 +};
    3934 +
    3935 +struct v4l2_event_subscription {
    3936 + __u32 type;
    3937 + __u32 reserved[7];
    3938 +};
    3939 +
    3940 +/*
    3941 + * A D V A N C E D D E B U G G I N G
    3942 + *
    3943 + * NOTE: EXPERIMENTAL API, NEVER RELY ON THIS IN APPLICATIONS!
    3944 + * FOR DEBUGGING, TESTING AND INTERNAL USE ONLY!
    3945 + */
    3946 +
    3947 +/* VIDIOC_DBG_G_REGISTER and VIDIOC_DBG_S_REGISTER */
    3948 +
    3949 +#define V4L2_CHIP_MATCH_HOST 0 /* Match against chip ID on host (0 for the host) */
    3950 +#define V4L2_CHIP_MATCH_I2C_DRIVER 1 /* Match against I2C driver name */
    3951 +#define V4L2_CHIP_MATCH_I2C_ADDR 2 /* Match against I2C 7-bit address */
    3952 +#define V4L2_CHIP_MATCH_AC97 3 /* Match against anciliary AC97 chip */
    3953 +
    3954 +struct v4l2_dbg_match {
    3955 + __u32 type; /* Match type */
    3956 + union { /* Match this chip, meaning determined by type */
    3957 + __u32 addr;
    3958 + char name[32];
    3959 + };
    3960 +} __attribute__ ((packed));
    3961 +
    3962 +struct v4l2_dbg_register {
    3963 + struct v4l2_dbg_match match;
    3964 + __u32 size; /* register size in bytes */
    3965 + __u64 reg;
    3966 + __u64 val;
    3967 +} __attribute__ ((packed));
    3968 +
    3969 +/* VIDIOC_DBG_G_CHIP_IDENT */
    3970 +struct v4l2_dbg_chip_ident {
    3971 + struct v4l2_dbg_match match;
    3972 + __u32 ident; /* chip identifier as specified in <media/v4l2-chip-ident.h> */
    3973 + __u32 revision; /* chip revision, chip specific */
    3974 +} __attribute__ ((packed));
    3975 +
    3976 +/*
    3977 + * 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
    3978 + *
    3979 + */
    3980 +#define VIDIOC_QUERYCAP _IOR('V', 0, struct v4l2_capability)
    3981 +#define VIDIOC_RESERVED _IO('V', 1)
    3982 +#define VIDIOC_ENUM_FMT _IOWR('V', 2, struct v4l2_fmtdesc)
    3983 +#define VIDIOC_G_FMT _IOWR('V', 4, struct v4l2_format)
    3984 +#define VIDIOC_S_FMT _IOWR('V', 5, struct v4l2_format)
    3985 +#define VIDIOC_REQBUFS _IOWR('V', 8, struct v4l2_requestbuffers)
    3986 +#define VIDIOC_QUERYBUF _IOWR('V', 9, struct v4l2_buffer)
    3987 +#define VIDIOC_G_FBUF _IOR('V', 10, struct v4l2_framebuffer)
    3988 +#define VIDIOC_S_FBUF _IOW('V', 11, struct v4l2_framebuffer)
    3989 +#define VIDIOC_OVERLAY _IOW('V', 14, int)
    3990 +#define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer)
    3991 +#define VIDIOC_DQBUF _IOWR('V', 17, struct v4l2_buffer)
    3992 +#define VIDIOC_STREAMON _IOW('V', 18, int)
    3993 +#define VIDIOC_STREAMOFF _IOW('V', 19, int)
    3994 +#define VIDIOC_G_PARM _IOWR('V', 21, struct v4l2_streamparm)
    3995 +#define VIDIOC_S_PARM _IOWR('V', 22, struct v4l2_streamparm)
    3996 +#define VIDIOC_G_STD _IOR('V', 23, v4l2_std_id)
    3997 +#define VIDIOC_S_STD _IOW('V', 24, v4l2_std_id)
    3998 +#define VIDIOC_ENUMSTD _IOWR('V', 25, struct v4l2_standard)
    3999 +#define VIDIOC_ENUMINPUT _IOWR('V', 26, struct v4l2_input)
    4000 +#define VIDIOC_G_CTRL _IOWR('V', 27, struct v4l2_control)
    4001 +#define VIDIOC_S_CTRL _IOWR('V', 28, struct v4l2_control)
    4002 +#define VIDIOC_G_TUNER _IOWR('V', 29, struct v4l2_tuner)
    4003 +#define VIDIOC_S_TUNER _IOW('V', 30, struct v4l2_tuner)
    4004 +#define VIDIOC_G_AUDIO _IOR('V', 33, struct v4l2_audio)
    4005 +#define VIDIOC_S_AUDIO _IOW('V', 34, struct v4l2_audio)
    4006 +#define VIDIOC_QUERYCTRL _IOWR('V', 36, struct v4l2_queryctrl)
    4007 +#define VIDIOC_QUERYMENU _IOWR('V', 37, struct v4l2_querymenu)
    4008 +#define VIDIOC_G_INPUT _IOR('V', 38, int)
    4009 +#define VIDIOC_S_INPUT _IOWR('V', 39, int)
    4010 +#define VIDIOC_G_OUTPUT _IOR('V', 46, int)
    4011 +#define VIDIOC_S_OUTPUT _IOWR('V', 47, int)
    4012 +#define VIDIOC_ENUMOUTPUT _IOWR('V', 48, struct v4l2_output)
    4013 +#define VIDIOC_G_AUDOUT _IOR('V', 49, struct v4l2_audioout)
    4014 +#define VIDIOC_S_AUDOUT _IOW('V', 50, struct v4l2_audioout)
    4015 +#define VIDIOC_G_MODULATOR _IOWR('V', 54, struct v4l2_modulator)
    4016 +#define VIDIOC_S_MODULATOR _IOW('V', 55, struct v4l2_modulator)
    4017 +#define VIDIOC_G_FREQUENCY _IOWR('V', 56, struct v4l2_frequency)
    4018 +#define VIDIOC_S_FREQUENCY _IOW('V', 57, struct v4l2_frequency)
    4019 +#define VIDIOC_CROPCAP _IOWR('V', 58, struct v4l2_cropcap)
    4020 +#define VIDIOC_G_CROP _IOWR('V', 59, struct v4l2_crop)
    4021 +#define VIDIOC_S_CROP _IOW('V', 60, struct v4l2_crop)
    4022 +#define VIDIOC_G_JPEGCOMP _IOR('V', 61, struct v4l2_jpegcompression)
    4023 +#define VIDIOC_S_JPEGCOMP _IOW('V', 62, struct v4l2_jpegcompression)
    4024 +#define VIDIOC_QUERYSTD _IOR('V', 63, v4l2_std_id)
    4025 +#define VIDIOC_TRY_FMT _IOWR('V', 64, struct v4l2_format)
    4026 +#define VIDIOC_ENUMAUDIO _IOWR('V', 65, struct v4l2_audio)
    4027 +#define VIDIOC_ENUMAUDOUT _IOWR('V', 66, struct v4l2_audioout)
    4028 +#define VIDIOC_G_PRIORITY _IOR('V', 67, enum v4l2_priority)
    4029 +#define VIDIOC_S_PRIORITY _IOW('V', 68, enum v4l2_priority)
    4030 +#define VIDIOC_G_SLICED_VBI_CAP _IOWR('V', 69, struct v4l2_sliced_vbi_cap)
    4031 +#define VIDIOC_LOG_STATUS _IO('V', 70)
    4032 +#define VIDIOC_G_EXT_CTRLS _IOWR('V', 71, struct v4l2_ext_controls)
    4033 +#define VIDIOC_S_EXT_CTRLS _IOWR('V', 72, struct v4l2_ext_controls)
    4034 +#define VIDIOC_TRY_EXT_CTRLS _IOWR('V', 73, struct v4l2_ext_controls)
    4035 +#if 1
    4036 +#define VIDIOC_ENUM_FRAMESIZES _IOWR('V', 74, struct v4l2_frmsizeenum)
    4037 +#define VIDIOC_ENUM_FRAMEINTERVALS _IOWR('V', 75, struct v4l2_frmivalenum)
    4038 +#define VIDIOC_G_ENC_INDEX _IOR('V', 76, struct v4l2_enc_idx)
    4039 +#define VIDIOC_ENCODER_CMD _IOWR('V', 77, struct v4l2_encoder_cmd)
    4040 +#define VIDIOC_TRY_ENCODER_CMD _IOWR('V', 78, struct v4l2_encoder_cmd)
    4041 +#endif
    4042 +
    4043 +#if 1
    4044 +/* Experimental, meant for debugging, testing and internal use.
    4045 + Only implemented if CONFIG_VIDEO_ADV_DEBUG is defined.
    4046 + You must be root to use these ioctls. Never use these in applications! */
    4047 +#define VIDIOC_DBG_S_REGISTER _IOW('V', 79, struct v4l2_dbg_register)
    4048 +#define VIDIOC_DBG_G_REGISTER _IOWR('V', 80, struct v4l2_dbg_register)
    4049 +
    4050 +/* Experimental, meant for debugging, testing and internal use.
    4051 + Never use this ioctl in applications! */
    4052 +#define VIDIOC_DBG_G_CHIP_IDENT _IOWR('V', 81, struct v4l2_dbg_chip_ident)
    4053 +#endif
    4054 +
    4055 +#define VIDIOC_S_HW_FREQ_SEEK _IOW('V', 82, struct v4l2_hw_freq_seek)
    4056 +#define VIDIOC_ENUM_DV_PRESETS _IOWR('V', 83, struct v4l2_dv_enum_preset)
    4057 +#define VIDIOC_S_DV_PRESET _IOWR('V', 84, struct v4l2_dv_preset)
    4058 +#define VIDIOC_G_DV_PRESET _IOWR('V', 85, struct v4l2_dv_preset)
    4059 +#define VIDIOC_QUERY_DV_PRESET _IOR('V', 86, struct v4l2_dv_preset)
    4060 +#define VIDIOC_S_DV_TIMINGS _IOWR('V', 87, struct v4l2_dv_timings)
    4061 +#define VIDIOC_G_DV_TIMINGS _IOWR('V', 88, struct v4l2_dv_timings)
    4062 +#define VIDIOC_DQEVENT _IOR('V', 89, struct v4l2_event)
    4063 +#define VIDIOC_SUBSCRIBE_EVENT _IOW('V', 90, struct v4l2_event_subscription)
    4064 +#define VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
    4065 +
    4066 +#define BASE_VIDIOC_PRIVATE 192 /* 192-255 are private */
    4067 +
    4068 +#endif /* __LINUX_VIDEODEV2_H */