V4L2 API Specification

V4L2

/dev/video
> insmod mydriver.o video_nr=0,1 radio_nr=0,1
/etc/modules.conf
alias char-major-81-0 mydriver
alias char-major-81-1 mydriver
alias char-major-81-64 mydriver              
options mydriver video_nr=0,1 radio_nr=0,1   

/dev
/dev/v4l
/dev/video
/dev/vbi
/dev/video
/dev/vbi
/dev/radio
struct v4l2_input input;
int index;

if (-1 == ioctl (fd, VIDIOC_G_INPUT, &index)) {
        perror ("VIDIOC_G_INPUT");
        exit (EXIT_FAILURE);
}

memset (&input, 0, sizeof (input));
input.index = index;

if (-1 == ioctl (fd, VIDIOC_ENUMINPUT, &input)) {
        perror ("VIDIOC_ENUMINPUT");
        exit (EXIT_FAILURE);
}

printf ("Current input: %s\n", input.name);

int index;

index = 0;

if (-1 == ioctl (fd, VIDIOC_S_INPUT, &index)) {
        perror ("VIDIOC_S_INPUT");
        exit (EXIT_FAILURE);
}

struct v4l2_audio audio;

memset (&audio, 0, sizeof (audio));

if (-1 == ioctl (fd, VIDIOC_G_AUDIO, &audio)) {
        perror ("VIDIOC_G_AUDIO");
        exit (EXIT_FAILURE);
}

printf ("Current input: %s\n", audio.name);

struct v4l2_audio audio;

memset (&audio, 0, sizeof (audio)); /* clear audio.mode, audio.reserved */

audio.index = 0;

if (-1 == ioctl (fd, VIDIOC_S_AUDIO, &audio)) {
        perror ("VIDIOC_S_AUDIO");
        exit (EXIT_FAILURE);
}

v4l2_std_id std_id;
struct v4l2_standard standard;

if (-1 == ioctl (fd, VIDIOC_G_STD, &std_id)) {
        /* Note when VIDIOC_ENUMSTD always returns EINVAL this
           is no video device or it falls under the USB exception,
           and VIDIOC_G_STD returning EINVAL is no error. */

        perror ("VIDIOC_G_STD");
        exit (EXIT_FAILURE);
}

memset (&standard, 0, sizeof (standard));
standard.index = 0;

while (0 == ioctl (fd, VIDIOC_ENUMSTD, &standard)) {
        if (standard.id & std_id) {
               printf ("Current video standard: %s\n", standard.name);
               exit (EXIT_SUCCESS);
        }

        standard.index++;
}

/* EINVAL indicates the end of the enumeration, which cannot be
   empty unless this device falls under the USB exception. */

if (errno == EINVAL || standard.index == 0) {
        perror ("VIDIOC_ENUMSTD");
        exit (EXIT_FAILURE);
}

struct v4l2_input input;
struct v4l2_standard standard;

memset (&input, 0, sizeof (input));

if (-1 == ioctl (fd, VIDIOC_G_INPUT, &input.index)) {
        perror ("VIDIOC_G_INPUT");
        exit (EXIT_FAILURE);
}

if (-1 == ioctl (fd, VIDIOC_ENUMINPUT, &input)) {
        perror ("VIDIOC_ENUM_INPUT");
        exit (EXIT_FAILURE);
}

printf ("Current input %s supports:\n", input.name);

memset (&standard, 0, sizeof (standard));
standard.index = 0;

while (0 == ioctl (fd, VIDIOC_ENUMSTD, &standard)) {
        if (standard.id & input.std)
                printf ("%s\n", standard.name);

        standard.index++;
}

/* EINVAL indicates the end of the enumeration, which cannot be
   empty unless this device falls under the USB exception. */

if (errno != EINVAL || standard.index == 0) {
        perror ("VIDIOC_ENUMSTD");
        exit (EXIT_FAILURE);
}

struct v4l2_input input;
v4l2_std_id std_id;

memset (&input, 0, sizeof (input));

if (-1 == ioctl (fd, VIDIOC_G_INPUT, &input.index)) {
        perror ("VIDIOC_G_INPUT");
        exit (EXIT_FAILURE);
}

if (-1 == ioctl (fd, VIDIOC_ENUMINPUT, &input)) {
        perror ("VIDIOC_ENUM_INPUT");
        exit (EXIT_FAILURE);
}

if (0 == (input.std & V4L2_STD_PAL_BG)) {
        fprintf (stderr, "Oops. B/G PAL is not supported.\n");
        exit (EXIT_FAILURE);
}

/* Note this is also supposed to work when only B
   or G/PAL is supported. */

std_id = V4L2_STD_PAL_BG;

if (-1 == ioctl (fd, VIDIOC_S_STD, &std_id)) {
        perror ("VIDIOC_S_STD");
        exit (EXIT_FAILURE);
}

struct v4l2_queryctrl queryctrl;
struct v4l2_querymenu querymenu;

static void
enumerate_menu (void)
{
        printf ("  Menu items:\n");

        memset (&querymenu, 0, sizeof (querymenu));
        querymenu.id = queryctrl.id;

        for (querymenu.index = queryctrl.minimum;
             querymenu.index <= queryctrl.maximum;
              querymenu.index++) {
                if (0 == ioctl (fd, VIDIOC_QUERYMENU, &querymenu)) {
                        printf ("  %s\n", querymenu.name);
                } else {
                        perror ("VIDIOC_QUERYMENU");
                        exit (EXIT_FAILURE);
                }
        }
}

memset (&queryctrl, 0, sizeof (queryctrl));

for (queryctrl.id = V4L2_CID_BASE;
     queryctrl.id < V4L2_CID_LASTP1;
     queryctrl.id++) {
        if (0 == ioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
                if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
                        continue;

                printf ("Control %s\n", queryctrl.name);

                if (queryctrl.type == V4L2_CTRL_TYPE_MENU)
                        enumerate_menu ();
        } else {
                if (errno == EINVAL)
                        continue;

                perror ("VIDIOC_QUERYCTRL");
                exit (EXIT_FAILURE);
        }
}

for (queryctrl.id = V4L2_CID_PRIVATE_BASE;;
     queryctrl.id++) {
        if (0 == ioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
                if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
                        continue;

                printf ("Control %s\n", queryctrl.name);

                if (queryctrl.type == V4L2_CTRL_TYPE_MENU)
                        enumerate_menu ();
        } else {
                if (errno == EINVAL)
                        break;

                perror ("VIDIOC_QUERYCTRL");
                exit (EXIT_FAILURE);
        }
}
struct v4l2_queryctrl queryctrl;
struct v4l2_control control;

memset (&queryctrl, 0, sizeof (queryctrl));
queryctrl.id = V4L2_CID_BRIGHTNESS;

if (-1 == ioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
        if (errno != EINVAL) {
                perror ("VIDIOC_QUERYCTRL");
                exit (EXIT_FAILURE);
        } else {
                printf ("V4L2_CID_BRIGHTNESS is not supported\n");
        }
} else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
        printf ("V4L2_CID_BRIGHTNESS is not supported\n");
} else {
        memset (&control, 0, sizeof (control));
        control.id = V4L2_CID_BRIGHTNESS;
        control.value = queryctrl.default_value;

        if (-1 == ioctl (fd, VIDIOC_S_CTRL, &control)) {
                perror ("VIDIOC_S_CTRL");
                exit (EXIT_FAILURE);
        }
}

memset (&control, 0, sizeof (control));
control.id = V4L2_CID_CONTRAST;

if (0 == ioctl (fd, VIDIOC_G_CTRL, &control)) {
        control.value += 1;

        /* The driver may clamp the value or return ERANGE, ignored here */

        if (-1 == ioctl (fd, VIDIOC_S_CTRL, &control)
            && errno != ERANGE) {
                perror ("VIDIOC_S_CTRL");
                exit (EXIT_FAILURE);
        }
/* Ignore if V4L2_CID_CONTRAST is unsupported */
} else if (errno != EINVAL) {
        perror ("VIDIOC_G_CTRL");
        exit (EXIT_FAILURE);
}

control.id = V4L2_CID_AUDIO_MUTE;
control.value = TRUE; /* silence */

/* Errors ignored */
ioctl (fd, VIDIOC_S_CTRL, &control);
struct v4l2_queryctrl qctrl;

qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
while (0 == ioctl (fd, VIDIOC_QUERYCTRL, &qctrl)) {
        /* ... */
        qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
}
qctrl.id = V4L2_CTRL_CLASS_MPEG | V4L2_CTRL_FLAG_NEXT_CTRL;
while (0 == ioctl (fd, VIDIOC_QUERYCTRL, &qctrl)) {
        if (V4L2_CTRL_ID2CLASS (qctrl.id) != V4L2_CTRL_CLASS_MPEG)
                break;
                /* ... */
                qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
        }
Documentation/video4linux/cx2341x/README.vbi
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;

memset (&cropcap, 0, sizeof (cropcap));
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == ioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
        perror ("VIDIOC_CROPCAP");
        exit (EXIT_FAILURE);
}

memset (&crop, 0, sizeof (crop));
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; 

/* Ignore if cropping is not supported (EINVAL). */

if (-1 == ioctl (fd, VIDIOC_S_CROP, &crop)
    && errno != EINVAL) {
        perror ("VIDIOC_S_CROP");
        exit (EXIT_FAILURE);
}

struct v4l2_cropcap cropcap;
struct v4l2_format format;

reset_cropping_parameters ();

/* Scale down to 1/4 size of full picture. */

memset (&format, 0, sizeof (format)); /* defaults */

format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

format.fmt.pix.width = cropcap.defrect.width >> 1;
format.fmt.pix.height = cropcap.defrect.height >> 1;
format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

if (-1 == ioctl (fd, VIDIOC_S_FMT, &format)) {
        perror ("VIDIOC_S_FORMAT");
        exit (EXIT_FAILURE);
}

/* We could check the actual image size now, the actual scaling factor
   or if the driver can scale at all. */

struct v4l2_cropcap cropcap;
struct v4l2_crop crop;

memset (&cropcap, 0, sizeof (cropcap));
cropcap.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;

if (-1 == ioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
        perror ("VIDIOC_CROPCAP");
        exit (EXIT_FAILURE);
}

memset (&crop, 0, sizeof (crop));

crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
crop.c = cropcap.defrect;

/* Scale the width and height to 50 % of their original size
   and center the output. */

crop.c.width /= 2;
crop.c.height /= 2;
crop.c.left += crop.c.width / 2;
crop.c.top += crop.c.height / 2;

/* Ignore if cropping is not supported (EINVAL). */

if (-1 == ioctl (fd, VIDIOC_S_CROP, &crop)
    && errno != EINVAL) {
        perror ("VIDIOC_S_CROP");
        exit (EXIT_FAILURE);
}
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format format;
double hscale, vscale;
double aspect;
int dwidth, dheight;

memset (&cropcap, 0, sizeof (cropcap));
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == ioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
        perror ("VIDIOC_CROPCAP");
        exit (EXIT_FAILURE);
}

memset (&crop, 0, sizeof (crop));
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == ioctl (fd, VIDIOC_G_CROP, &crop)) {
        if (errno != EINVAL) {
                perror ("VIDIOC_G_CROP");
                exit (EXIT_FAILURE);
        }

        /* Cropping not supported. */
        crop.c = cropcap.defrect;
}

memset (&format, 0, sizeof (format));
format.fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (-1 == ioctl (fd, VIDIOC_G_FMT, &format)) {
        perror ("VIDIOC_G_FMT");
        exit (EXIT_FAILURE);
}

/* The scaling applied by the driver. */

hscale = format.fmt.pix.width / (double) crop.c.width;
vscale = format.fmt.pix.height / (double) crop.c.height;

aspect = cropcap.pixelaspect.numerator /
         (double) cropcap.pixelaspect.denominator;
aspect = aspect * hscale / vscale;

/* Devices following ITU-R BT.601 do not capture
   square pixels. For playback on a computer monitor
   we should scale the images to this size. */

dwidth = format.fmt.pix.width / aspect;
dheight = format.fmt.pix.height;

int ER, EG, EB;         /* gamma corrected RGB input [0;255] */
int Y1, Cb, Cr;         /* output [0;255] */

double r, g, b;         /* temporaries */
double y1, pb, pr;

int
clamp (double x)
{
        int r = x;      /* round to nearest */

        if (r < 0)         return 0;
        else if (r > 255)  return 255;
        else               return r;
}

r = ER / 255.0;
g = EG / 255.0;
b = EB / 255.0;

y1  =  0.299  * r + 0.587 * g + 0.114  * b;
pb  = -0.169  * r - 0.331 * g + 0.5    * b;
pr  =  0.5    * r - 0.419 * g - 0.081  * b;

Y1 = clamp (219 * y1 + 16);
Cb = clamp (224 * pb + 128);
Cr = clamp (224 * pr + 128);

/* or shorter */

y1 = 0.299 * ER + 0.587 * EG + 0.114 * EB;

Y1 = clamp ( (219 / 255.0)                    *       y1  + 16);
Cb = clamp (((224 / 255.0) / (2 - 2 * 0.114)) * (EB - y1) + 128);
Cr = clamp (((224 / 255.0) / (2 - 2 * 0.299)) * (ER - y1) + 128);

int Y1, Cb, Cr;         /* gamma pre-corrected input [0;255] */
int ER, EG, EB;         /* output [0;255] */

double r, g, b;         /* temporaries */
double y1, pb, pr;

int
clamp (double x)
{
        int r = x;      /* round to nearest */

        if (r < 0)         return 0;
        else if (r > 255)  return 255;
        else               return r;
}

y1 = (255 / 219.0) * (Y1 - 16);
pb = (255 / 224.0) * (Cb - 128);
pr = (255 / 224.0) * (Cr - 128);

r = 1.0 * y1 + 0     * pb + 1.402 * pr;
g = 1.0 * y1 - 0.344 * pb - 0.714 * pr;
b = 1.0 * y1 + 1.772 * pb + 0     * pr;

ER = clamp (r * 255); /* [ok? one should prob. limit y1,pb,pr] */
EG = clamp (g * 255);
EB = clamp (b * 255);

videodev.h
Documentation/video4linux/cx2341x/README.hm12
> vidctrl /dev/video --input=0 --format=YUYV --size=352x288
> dd if=/dev/video of=myimage.422 bs=202752 count=1
struct v4l2_requestbuffers reqbuf;
struct {
        void *start;
        size_t length;
} *buffers;
unsigned int i;

memset (&reqbuf, 0, sizeof (reqbuf));
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.memory = V4L2_MEMORY_MMAP;
reqbuf.count = 20;

if (-1 == ioctl (fd, VIDIOC_REQBUFS, &reqbuf)) {
        if (errno == EINVAL)
                printf ("Video capturing or mmap-streaming is not supported\n");
        else
                perror ("VIDIOC_REQBUFS");

        exit (EXIT_FAILURE);
}

/* We want at least five buffers. */

if (reqbuf.count < 5) {
        /* You may need to free the buffers here. */
        printf ("Not enough buffer memory\n");
        exit (EXIT_FAILURE);
}

buffers = calloc (reqbuf.count, sizeof (*buffers));
assert (buffers != NULL);

for (i = 0; i < reqbuf.count; i++) {
        struct v4l2_buffer buffer;

        memset (&buffer, 0, sizeof (buffer));
        buffer.type = reqbuf.type;
	buffer.memory = V4L2_MEMORY_MMAP;
        buffer.index = i;

        if (-1 == ioctl (fd, VIDIOC_QUERYBUF, &buffer)) {
                perror ("VIDIOC_QUERYBUF");
                exit (EXIT_FAILURE);
        }

        buffers[i].length = buffer.length; /* remember for munmap() */

        buffers[i].start = mmap (NULL, buffer.length,
                                 PROT_READ | PROT_WRITE, /* recommended */
                                 MAP_SHARED,             /* recommended */
                                 fd, buffer.m.offset);

        if (MAP_FAILED == buffers[i].start) {
                /* If you do not exit here you should unmap() and free()
                   the buffers mapped so far. */
                perror ("mmap");
                exit (EXIT_FAILURE);
        }
}

/* Cleanup. */

for (i = 0; i < reqbuf.count; i++)
        munmap (buffers[i].start, buffers[i].length);

struct v4l2_requestbuffers reqbuf;

memset (&reqbuf, 0, sizeof (reqbuf));
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.memory = V4L2_MEMORY_USERPTR;

if (ioctl (fd, VIDIOC_REQBUFS, &reqbuf) == -1) {
        if (errno == EINVAL)
                printf ("Video capturing or user pointer streaming is not supported\n");
        else
                perror ("VIDIOC_REQBUFS");

        exit (EXIT_FAILURE);
}

/dev/video
/dev/video0
/dev/video63
/dev/video
/dev/video
((__u8 *) bitmap)[w.width * y + x / 8] & (1 << (x & 7))
/dev/video
/dev/video0
/dev/video63
/dev/video
/dev/video
/dev/fbN
linux/fb.h
#include <linux/fb.h>

struct v4l2_framebuffer fbuf;
unsigned int i;
int fb_fd;

if (-1 == ioctl (fd, VIDIOC_G_FBUF, &fbuf)) {
        perror ("VIDIOC_G_FBUF");
        exit (EXIT_FAILURE);
}

for (i = 0; i < 30; ++i) {
        char dev_name[16];
        struct fb_fix_screeninfo si;

        snprintf (dev_name, sizeof (dev_name), "/dev/fb%u", i);

        fb_fd = open (dev_name, O_RDWR);
        if (-1 == fb_fd) {
                switch (errno) {
                case ENOENT: /* no such file */
                case ENXIO:  /* no driver */
                        continue;

                default:
                        perror ("open");
                        exit (EXIT_FAILURE);
                }
        }

        if (0 == ioctl (fb_fd, FBIOGET_FSCREENINFO, &si)) {
                if (si.smem_start == (unsigned long) fbuf.base)
                        break;
        } else {
                /* Apparently not a framebuffer device. */
        }

        close (fb_fd);
        fb_fd = -1;
}

/* fb_fd is the file descriptor of the framebuffer device
   for the video output overlay, or -1 if no device was found. */
/dev/vbi
/dev/vbi0
/dev/vbi31
/dev/vbi
/dev/video
/dev/vbi
(count[0] + count[1]) *
samples_per_line * sample size in bytes
/dev/vbi
/dev/video
Byte         0                 1
      msb         lsb  msb           lsb
 Bit  7 6 5 4 3 2 1 0  x x 13 12 11 10 9
linux/videotext.h
/dev/vtx
/dev/vttuner
/dev/tlkN
/dev/vtx0
/dev/vtx31
/dev/radio
/dev/radio0
/dev/radio63
#include <unistd.h>
#include <sys/ioctl.h>
linux/i2c-id.h
linux/i2c-id.h
#define v4l2_fourcc(a,b,c,d) (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
frame_rate = 1 / frame_interval
#define V4L2_STD_PAL_B          ((v4l2_std_id)0x00000001)
#define V4L2_STD_PAL_B1         ((v4l2_std_id)0x00000002)
#define V4L2_STD_PAL_G          ((v4l2_std_id)0x00000004)
#define V4L2_STD_PAL_H          ((v4l2_std_id)0x00000008)
#define V4L2_STD_PAL_I          ((v4l2_std_id)0x00000010)
#define V4L2_STD_PAL_D          ((v4l2_std_id)0x00000020)
#define V4L2_STD_PAL_D1         ((v4l2_std_id)0x00000040)
#define V4L2_STD_PAL_K          ((v4l2_std_id)0x00000080)

#define V4L2_STD_PAL_M          ((v4l2_std_id)0x00000100)
#define V4L2_STD_PAL_N          ((v4l2_std_id)0x00000200)
#define V4L2_STD_PAL_Nc         ((v4l2_std_id)0x00000400)
#define V4L2_STD_PAL_60         ((v4l2_std_id)0x00000800)
#define V4L2_STD_NTSC_M         ((v4l2_std_id)0x00001000)
#define V4L2_STD_NTSC_M_JP      ((v4l2_std_id)0x00002000)
#define V4L2_STD_NTSC_443       ((v4l2_std_id)0x00004000)
#define V4L2_STD_NTSC_M_KR      ((v4l2_std_id)0x00008000)

#define V4L2_STD_SECAM_B        ((v4l2_std_id)0x00010000)
#define V4L2_STD_SECAM_D        ((v4l2_std_id)0x00020000)
#define V4L2_STD_SECAM_G        ((v4l2_std_id)0x00040000)
#define V4L2_STD_SECAM_H        ((v4l2_std_id)0x00080000)
#define V4L2_STD_SECAM_K        ((v4l2_std_id)0x00100000)
#define V4L2_STD_SECAM_K1       ((v4l2_std_id)0x00200000)
#define V4L2_STD_SECAM_L        ((v4l2_std_id)0x00400000)
#define V4L2_STD_SECAM_LC       ((v4l2_std_id)0x00800000)

/* ATSC/HDTV */
#define V4L2_STD_ATSC_8_VSB     ((v4l2_std_id)0x01000000)
#define V4L2_STD_ATSC_16_VSB    ((v4l2_std_id)0x02000000)
#define V4L2_STD_PAL_BG         (V4L2_STD_PAL_B         |\
                                 V4L2_STD_PAL_B1        |\
                                 V4L2_STD_PAL_G)
#define V4L2_STD_B              (V4L2_STD_PAL_B         |\
                                 V4L2_STD_PAL_B1        |\
                                 V4L2_STD_SECAM_B)
#define V4L2_STD_GH             (V4L2_STD_PAL_G         |\
                                 V4L2_STD_PAL_H         |\
                                 V4L2_STD_SECAM_G       |\
                                 V4L2_STD_SECAM_H)
#define V4L2_STD_PAL_DK         (V4L2_STD_PAL_D         |\
                                 V4L2_STD_PAL_D1        |\
                                 V4L2_STD_PAL_K)
#define V4L2_STD_PAL            (V4L2_STD_PAL_BG        |\
                                 V4L2_STD_PAL_DK        |\
                                 V4L2_STD_PAL_H         |\
                                 V4L2_STD_PAL_I)
#define V4L2_STD_NTSC           (V4L2_STD_NTSC_M        |\
                                 V4L2_STD_NTSC_M_JP     |\
                                 V4L2_STD_NTSC_M_KR)
#define V4L2_STD_MN             (V4L2_STD_PAL_M         |\
                                 V4L2_STD_PAL_N         |\
                                 V4L2_STD_PAL_Nc        |\
                                 V4L2_STD_NTSC)
#define V4L2_STD_SECAM_DK       (V4L2_STD_SECAM_D       |\
                                 V4L2_STD_SECAM_K       |\
                                 V4L2_STD_SECAM_K1)
#define V4L2_STD_DK             (V4L2_STD_PAL_DK        |\
                                 V4L2_STD_SECAM_DK)

#define V4L2_STD_SECAM          (V4L2_STD_SECAM_B       |\
                                 V4L2_STD_SECAM_G       |\
                                 V4L2_STD_SECAM_H       |\
                                 V4L2_STD_SECAM_DK      |\
                                 V4L2_STD_SECAM_L       |\
                                 V4L2_STD_SECAM_LC)

#define V4L2_STD_525_60         (V4L2_STD_PAL_M         |\
                                 V4L2_STD_PAL_60        |\
                                 V4L2_STD_NTSC          |\
                                 V4L2_STD_NTSC_443)
#define V4L2_STD_625_50         (V4L2_STD_PAL           |\
                                 V4L2_STD_PAL_N         |\
                                 V4L2_STD_PAL_Nc        |\
                                 V4L2_STD_SECAM)

#define V4L2_STD_UNKNOWN        0
#define V4L2_STD_ALL            (V4L2_STD_525_60        |\
                                 V4L2_STD_625_50)
linux/i2c-id.h
media/v4l2-chip-ident.h
media/v4l2-chip-ident.h
linux/i2c-id.h
/dev/videoN
Byte        0                 1
     msb         lsb  msb           lsb
Bit  7 6 5 4 3 2 1 0  x x 13 12 11 10 9
/dev/video2
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

__u32 version = KERNEL_VERSION(0, 8, 1);

printf ("Version: %u.%u.%u\n",
        (version >> 16) & 0xFF,
        (version >> 8) & 0xFF,
         version & 0xFF);
#include <unistd.h>
#include <sys/mman.h>
video-buf
video-buf
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/poll.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <unistd.h>
videodev
videodev
/dev/video
/dev/bttv0
/dev/video0
/dev/video63
/dev/radio
/dev/radio0
/dev/radio63
/dev/vtx
/dev/vtx0
/dev/vtx31
/dev/vbi
/dev/vbi0
/dev/vbi31
/dev/video0
Documentation/devices.txt
/dev/radio0
videodev
/dev/vbi
videodev.h
videodev
err = ioctl (fd, VIDIOC_XXX, V4L2_XXX);
int a = V4L2_XXX; err = ioctl(fd, VIDIOC_XXX, &a);
linux/poll.h
videodev.h
videodev.h
videodev.h
videodev.h
videodev.h
videodevX
videodevX
videodev.h
videodevX
videodev.h
videodev.h
videodev.h
videodev2.h
/dev/vout
/dev/video
/dev/vbi0
/dev/vbi31
videodev2.h
videodev2.h
/etc/X11/XF86Config
Section "Module"
    Load "v4l"
EndSection
/*
 *  Video for Linux Two header file
 *
 *  Copyright (C) 1999-2007 the contributors
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  Alternatively you can redistribute this file under the terms of the
 *  BSD license as stated below:
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *  3. The names of its contributors may not be used to endorse or promote
 *     products derived from this software without specific prior written
 *     permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 *  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *      Header file for v4l or V4L2 drivers and applications
 * with public API.
 * All kernel-specific stuff were moved to media/v4l2-dev.h, so
 * no #if __KERNEL tests are allowed here
 *
 *      See http://linuxtv.org for more info
 *
 *      Author: Bill Dirks <bill@thedirks.org>
 *              Justin Schoeman
 *              Hans Verkuil <hverkuil@xs4all.nl>
 *              et al.
 */
#ifndef __LINUX_VIDEODEV2_H
#define __LINUX_VIDEODEV2_H
#ifdef __KERNEL__
#include <linux/time.h>     /* need struct timeval */
#include <linux/compiler.h> /* need __user */
#else
#define __user
#include <sys/time.h>
#endif
#include <linux/ioctl.h>
#include <linux/types.h>

/*
 * Common stuff for both V4L1 and V4L2
 * Moved from videodev.h
 */
#define VIDEO_MAX_FRAME               32

#define VID_TYPE_CAPTURE        1       /* Can capture */
#define VID_TYPE_TUNER          2       /* Can tune */
#define VID_TYPE_TELETEXT       4       /* Does teletext */
#define VID_TYPE_OVERLAY        8       /* Overlay onto frame buffer */
#define VID_TYPE_CHROMAKEY      16      /* Overlay by chromakey */
#define VID_TYPE_CLIPPING       32      /* Can clip */
#define VID_TYPE_FRAMERAM       64      /* Uses the frame buffer memory */
#define VID_TYPE_SCALES         128     /* Scalable */
#define VID_TYPE_MONOCHROME     256     /* Monochrome only */
#define VID_TYPE_SUBCAPTURE     512     /* Can capture subareas of the image */
#define VID_TYPE_MPEG_DECODER   1024    /* Can decode MPEG streams */
#define VID_TYPE_MPEG_ENCODER   2048    /* Can encode MPEG streams */
#define VID_TYPE_MJPEG_DECODER  4096    /* Can decode MJPEG streams */
#define VID_TYPE_MJPEG_ENCODER  8192    /* Can encode MJPEG streams */

/*
 *      M I S C E L L A N E O U S
 */

/*  Four-character-code (FOURCC) */
#define v4l2_fourcc(a,b,c,d)\
        (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))

/*
 *      E N U M S
 */
enum v4l2_field {
        V4L2_FIELD_ANY           = 0, /* driver can choose from none,
                                         top, bottom, interlaced
                                         depending on whatever it thinks
                                         is approximate ... */
        V4L2_FIELD_NONE          = 1, /* this device has no fields ... */
        V4L2_FIELD_TOP           = 2, /* top field only */
        V4L2_FIELD_BOTTOM        = 3, /* bottom field only */
        V4L2_FIELD_INTERLACED    = 4, /* both fields interlaced */
        V4L2_FIELD_SEQ_TB        = 5, /* both fields sequential into one
                                         buffer, top-bottom order */
        V4L2_FIELD_SEQ_BT        = 6, /* same as above + bottom-top order */
        V4L2_FIELD_ALTERNATE     = 7, /* both fields alternating into
                                         separate buffers */
        V4L2_FIELD_INTERLACED_TB = 8, /* both fields interlaced, top field
                                         first and the top field is
                                         transmitted first */
        V4L2_FIELD_INTERLACED_BT = 9, /* both fields interlaced, top field
                                         first and the bottom field is
                                         transmitted first */
};
#define V4L2_FIELD_HAS_TOP(field)       \
        ((field) == V4L2_FIELD_TOP      ||\
         (field) == V4L2_FIELD_INTERLACED ||\
         (field) == V4L2_FIELD_INTERLACED_TB ||\
         (field) == V4L2_FIELD_INTERLACED_BT ||\
         (field) == V4L2_FIELD_SEQ_TB   ||\
         (field) == V4L2_FIELD_SEQ_BT)
#define V4L2_FIELD_HAS_BOTTOM(field)    \
        ((field) == V4L2_FIELD_BOTTOM   ||\
         (field) == V4L2_FIELD_INTERLACED ||\
         (field) == V4L2_FIELD_INTERLACED_TB ||\
         (field) == V4L2_FIELD_INTERLACED_BT ||\
         (field) == V4L2_FIELD_SEQ_TB   ||\
         (field) == V4L2_FIELD_SEQ_BT)
#define V4L2_FIELD_HAS_BOTH(field)      \
        ((field) == V4L2_FIELD_INTERLACED ||\
         (field) == V4L2_FIELD_INTERLACED_TB ||\
         (field) == V4L2_FIELD_INTERLACED_BT ||\
         (field) == V4L2_FIELD_SEQ_TB ||\
         (field) == V4L2_FIELD_SEQ_BT)

enum v4l2_buf_type {
        V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,
        V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,
        V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
        V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
        V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
        V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
        V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
#if 1 /*KEEP*/
        /* Experimental */
        V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
#endif
        V4L2_BUF_TYPE_PRIVATE              = 0x80,
};

enum v4l2_ctrl_type {
        V4L2_CTRL_TYPE_INTEGER       = 1,
        V4L2_CTRL_TYPE_BOOLEAN       = 2,
        V4L2_CTRL_TYPE_MENU          = 3,
        V4L2_CTRL_TYPE_BUTTON        = 4,
        V4L2_CTRL_TYPE_INTEGER64     = 5,
        V4L2_CTRL_TYPE_CTRL_CLASS    = 6,
};

enum v4l2_tuner_type {
        V4L2_TUNER_RADIO             = 1,
        V4L2_TUNER_ANALOG_TV         = 2,
        V4L2_TUNER_DIGITAL_TV        = 3,
};

enum v4l2_memory {
        V4L2_MEMORY_MMAP             = 1,
        V4L2_MEMORY_USERPTR          = 2,
        V4L2_MEMORY_OVERLAY          = 3,
};

/* see also http://vektor.theorem.ca/graphics/ycbcr/ */
enum v4l2_colorspace {
        /* ITU-R 601 -- broadcast NTSC/PAL */
        V4L2_COLORSPACE_SMPTE170M     = 1,

        /* 1125-Line (US) HDTV */
        V4L2_COLORSPACE_SMPTE240M     = 2,

        /* HD and modern captures. */
        V4L2_COLORSPACE_REC709        = 3,

        /* broken BT878 extents (601, luma range 16-253 instead of 16-235) */
        V4L2_COLORSPACE_BT878         = 4,

        /* These should be useful.  Assume 601 extents. */
        V4L2_COLORSPACE_470_SYSTEM_M  = 5,
        V4L2_COLORSPACE_470_SYSTEM_BG = 6,

        /* I know there will be cameras that send this.  So, this is
         * unspecified chromaticities and full 0-255 on each of the
         * Y'CbCr components
         */
        V4L2_COLORSPACE_JPEG          = 7,

        /* For RGB colourspaces, this is probably a good start. */
        V4L2_COLORSPACE_SRGB          = 8,
};

enum v4l2_priority {
        V4L2_PRIORITY_UNSET       = 0,  /* not initialized */
        V4L2_PRIORITY_BACKGROUND  = 1,
        V4L2_PRIORITY_INTERACTIVE = 2,
        V4L2_PRIORITY_RECORD      = 3,
        V4L2_PRIORITY_DEFAULT     = V4L2_PRIORITY_INTERACTIVE,
};

struct v4l2_rect {
        __s32   left;
        __s32   top;
        __s32   width;
        __s32   height;
};

struct v4l2_fract {
        __u32   numerator;
        __u32   denominator;
};

/*
 *      D R I V E R   C A P A B I L I T I E S
 */
struct v4l2_capability
{
        __u8    driver[16];     /* i.e.ie; "bttv" */
        __u8    card[32];       /* i.e.ie; "Hauppauge WinTV" */
        __u8    bus_info[32];   /* "PCI:" + pci_name(pci_dev) */
        __u32   version;        /* should use KERNEL_VERSION() */
        __u32   capabilities;   /* Device capabilities */
        __u32   reserved[4];
};

/* Values for 'capabilities' field */
#define V4L2_CAP_VIDEO_CAPTURE          0x00000001  /* Is a video capture device */
#define V4L2_CAP_VIDEO_OUTPUT           0x00000002  /* Is a video output device */
#define V4L2_CAP_VIDEO_OVERLAY          0x00000004  /* Can do video overlay */
#define V4L2_CAP_VBI_CAPTURE            0x00000010  /* Is a raw VBI capture device */
#define V4L2_CAP_VBI_OUTPUT             0x00000020  /* Is a raw VBI output device */
#define V4L2_CAP_SLICED_VBI_CAPTURE     0x00000040  /* Is a sliced VBI capture device */
#define V4L2_CAP_SLICED_VBI_OUTPUT      0x00000080  /* Is a sliced VBI output device */
#define V4L2_CAP_RDS_CAPTURE            0x00000100  /* RDS data capture */
#define V4L2_CAP_VIDEO_OUTPUT_OVERLAY   0x00000200  /* Can do video output overlay */

#define V4L2_CAP_TUNER                  0x00010000  /* has a tuner */
#define V4L2_CAP_AUDIO                  0x00020000  /* has audio support */
#define V4L2_CAP_RADIO                  0x00040000  /* is a radio device */

#define V4L2_CAP_READWRITE              0x01000000  /* read/write systemcalls */
#define V4L2_CAP_ASYNCIO                0x02000000  /* async I/O */
#define V4L2_CAP_STREAMING              0x04000000  /* streaming I/O ioctls */

/*
 *      V I D E O   I M A G E   F O R M A T
 */
struct v4l2_pix_format
{
        __u32                   width;
        __u32                   height;
        __u32                   pixelformat;
        enum v4l2_field         field;
        __u32                   bytesperline;   /* for padding, zero if unused */
        __u32                   sizeimage;
        enum v4l2_colorspace    colorspace;
        __u32                   priv;           /* private data, depends on pixelformat */
};

/*      Pixel format         FOURCC                        depth  Description  */
#define V4L2_PIX_FMT_RGB332  v4l2_fourcc('R','G','B','1') /*  8  RGB-3-3-2     */
#define V4L2_PIX_FMT_RGB444  v4l2_fourcc('R','4','4','4') /* 16  xxxxrrrr ggggbbbb */
#define V4L2_PIX_FMT_RGB555  v4l2_fourcc('R','G','B','O') /* 16  RGB-5-5-5     */
#define V4L2_PIX_FMT_RGB565  v4l2_fourcc('R','G','B','P') /* 16  RGB-5-6-5     */
#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R','G','B','Q') /* 16  RGB-5-5-5 BE  */
#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R','G','B','R') /* 16  RGB-5-6-5 BE  */
#define V4L2_PIX_FMT_BGR24   v4l2_fourcc('B','G','R','3') /* 24  BGR-8-8-8     */
#define V4L2_PIX_FMT_RGB24   v4l2_fourcc('R','G','B','3') /* 24  RGB-8-8-8     */
#define V4L2_PIX_FMT_BGR32   v4l2_fourcc('B','G','R','4') /* 32  BGR-8-8-8-8   */
#define V4L2_PIX_FMT_RGB32   v4l2_fourcc('R','G','B','4') /* 32  RGB-8-8-8-8   */
#define V4L2_PIX_FMT_GREY    v4l2_fourcc('G','R','E','Y') /*  8  Greyscale     */
#define V4L2_PIX_FMT_Y16     v4l2_fourcc('Y','1','6',' ') /* 16  Greyscale     */
#define V4L2_PIX_FMT_PAL8    v4l2_fourcc('P','A','L','8') /*  8  8-bit palette */
#define V4L2_PIX_FMT_YVU410  v4l2_fourcc('Y','V','U','9') /*  9  YVU 4:1:0     */
#define V4L2_PIX_FMT_YVU420  v4l2_fourcc('Y','V','1','2') /* 12  YVU 4:2:0     */
#define V4L2_PIX_FMT_YUYV    v4l2_fourcc('Y','U','Y','V') /* 16  YUV 4:2:2     */
#define V4L2_PIX_FMT_UYVY    v4l2_fourcc('U','Y','V','Y') /* 16  YUV 4:2:2     */
#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4','2','2','P') /* 16  YVU422 planar */
#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4','1','1','P') /* 16  YVU411 planar */
#define V4L2_PIX_FMT_Y41P    v4l2_fourcc('Y','4','1','P') /* 12  YUV 4:1:1     */
#define V4L2_PIX_FMT_YUV444  v4l2_fourcc('Y','4','4','4') /* 16  xxxxyyyy uuuuvvvv */
#define V4L2_PIX_FMT_YUV555  v4l2_fourcc('Y','U','V','O') /* 16  YUV-5-5-5     */
#define V4L2_PIX_FMT_YUV565  v4l2_fourcc('Y','U','V','P') /* 16  YUV-5-6-5     */
#define V4L2_PIX_FMT_YUV32   v4l2_fourcc('Y','U','V','4') /* 32  YUV-8-8-8-8   */

/* two planes -- one Y, one Cr + Cb interleaved  */
#define V4L2_PIX_FMT_NV12    v4l2_fourcc('N','V','1','2') /* 12  Y/CbCr 4:2:0  */
#define V4L2_PIX_FMT_NV21    v4l2_fourcc('N','V','2','1') /* 12  Y/CrCb 4:2:0  */

/*  The following formats are not defined in the V4L2 specification */
#define V4L2_PIX_FMT_YUV410  v4l2_fourcc('Y','U','V','9') /*  9  YUV 4:1:0     */
#define V4L2_PIX_FMT_YUV420  v4l2_fourcc('Y','U','1','2') /* 12  YUV 4:2:0     */
#define V4L2_PIX_FMT_YYUV    v4l2_fourcc('Y','Y','U','V') /* 16  YUV 4:2:2     */
#define V4L2_PIX_FMT_HI240   v4l2_fourcc('H','I','2','4') /*  8  8-bit color   */
#define V4L2_PIX_FMT_HM12    v4l2_fourcc('H','M','1','2') /*  8  YUV 4:2:0 16x16 macroblocks */

/* see http://www.siliconimaging.com/RGB%20Bayer.htm */
#define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B','A','8','1') /*  8  BGBG.. GRGR.. */
#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B','Y','R','2') /* 16  BGBG.. GRGR.. */

/* compressed formats */
#define V4L2_PIX_FMT_MJPEG    v4l2_fourcc('M','J','P','G') /* Motion-JPEG   */
#define V4L2_PIX_FMT_JPEG     v4l2_fourcc('J','P','E','G') /* JFIF JPEG     */
#define V4L2_PIX_FMT_DV       v4l2_fourcc('d','v','s','d') /* 1394          */
#define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M','P','E','G') /* MPEG-1/2/4    */

/*  Vendor-specific formats   */
#define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W','N','V','A') /* Winnov hw compress */
#define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S','9','1','0') /* SN9C10x compression */
#define V4L2_PIX_FMT_PWC1     v4l2_fourcc('P','W','C','1') /* pwc older webcam */
#define V4L2_PIX_FMT_PWC2     v4l2_fourcc('P','W','C','2') /* pwc newer webcam */
#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E','6','2','5') /* ET61X251 compression */

/*
 *      F O R M A T   E N U M E R A T I O N
 */
struct v4l2_fmtdesc
{
        __u32               index;             /* Format number      */
        enum v4l2_buf_type  type;              /* buffer type        */
        __u32               flags;
        __u8                description[32];   /* Description string */
        __u32               pixelformat;       /* Format fourcc      */
        __u32               reserved[4];
};

#define V4L2_FMT_FLAG_COMPRESSED 0x0001

#if 1 /*KEEP*/
        /* Experimental Frame Size and frame rate enumeration */
/*
 *      F R A M E   S I Z E   E N U M E R A T I O N
 */
enum v4l2_frmsizetypes
{
        V4L2_FRMSIZE_TYPE_DISCRETE      = 1,
        V4L2_FRMSIZE_TYPE_CONTINUOUS    = 2,
        V4L2_FRMSIZE_TYPE_STEPWISE      = 3,
};

struct v4l2_frmsize_discrete
{
        __u32                   width;          /* Frame width [pixel] */
        __u32                   height;         /* Frame height [pixel] */
};

struct v4l2_frmsize_stepwise
{
        __u32                   min_width;      /* Minimum frame width [pixel] */
        __u32                   max_width;      /* Maximum frame width [pixel] */
        __u32                   step_width;     /* Frame width step size [pixel] */
        __u32                   min_height;     /* Minimum frame height [pixel] */
        __u32                   max_height;     /* Maximum frame height [pixel] */
        __u32                   step_height;    /* Frame height step size [pixel] */
};

struct v4l2_frmsizeenum
{
        __u32                   index;          /* Frame size number */
        __u32                   pixel_format;   /* Pixel format */
        __u32                   type;           /* Frame size type the device supports. */

        union {                                 /* Frame size */
                struct v4l2_frmsize_discrete    discrete;
                struct v4l2_frmsize_stepwise    stepwise;
        };

        __u32   reserved[2];                    /* Reserved space for future use */
};

/*
 *      F R A M E   R A T E   E N U M E R A T I O N
 */
enum v4l2_frmivaltypes
{
        V4L2_FRMIVAL_TYPE_DISCRETE      = 1,
        V4L2_FRMIVAL_TYPE_CONTINUOUS    = 2,
        V4L2_FRMIVAL_TYPE_STEPWISE      = 3,
};

struct v4l2_frmival_stepwise
{
        struct v4l2_fract       min;            /* Minimum frame interval [s] */
        struct v4l2_fract       max;            /* Maximum frame interval [s] */
        struct v4l2_fract       step;           /* Frame interval step size [s] */
};

struct v4l2_frmivalenum
{
        __u32                   index;          /* Frame format index */
        __u32                   pixel_format;   /* Pixel format */
        __u32                   width;          /* Frame width */
        __u32                   height;         /* Frame height */
        __u32                   type;           /* Frame interval type the device supports. */

        union {                                 /* Frame interval */
                struct v4l2_fract               discrete;
                struct v4l2_frmival_stepwise    stepwise;
        };

        __u32   reserved[2];                    /* Reserved space for future use */
};
#endif

/*
 *      T I M E C O D E
 */
struct v4l2_timecode
{
        __u32   type;
        __u32   flags;
        __u8    frames;
        __u8    seconds;
        __u8    minutes;
        __u8    hours;
        __u8    userbits[4];
};

/*  Type  */
#define V4L2_TC_TYPE_24FPS              1
#define V4L2_TC_TYPE_25FPS              2
#define V4L2_TC_TYPE_30FPS              3
#define V4L2_TC_TYPE_50FPS              4
#define V4L2_TC_TYPE_60FPS              5

/*  Flags  */
#define V4L2_TC_FLAG_DROPFRAME          0x0001 /* "drop-frame" mode */
#define V4L2_TC_FLAG_COLORFRAME         0x0002
#define V4L2_TC_USERBITS_field          0x000C
#define V4L2_TC_USERBITS_USERDEFINED    0x0000
#define V4L2_TC_USERBITS_8BITCHARS      0x0008
/* The above is based on SMPTE timecodes */

struct v4l2_jpegcompression
{
        int quality;

        int  APPn;              /* Number of APP segment to be written,
                                 * must be 0..15 */
        int  APP_len;           /* Length of data in JPEG APPn segment */
        char APP_data[60];      /* Data in the JPEG APPn segment. */

        int  COM_len;           /* Length of data in JPEG COM segment */
        char COM_data[60];      /* Data in JPEG COM segment */

        __u32 jpeg_markers;     /* Which markers should go into the JPEG
                                 * output. Unless you exactly know what
                                 * you do, leave them untouched.
                                 * Inluding less markers will make the
                                 * resulting code smaller, but there will
                                 * be fewer aplications which can read it.
                                 * The presence of the APP and COM marker
                                 * is influenced by APP_len and COM_len
                                 * ONLY, not by this property! */

#define V4L2_JPEG_MARKER_DHT (1<<3)    /* Define Huffman Tables */
#define V4L2_JPEG_MARKER_DQT (1<<4)    /* Define Quantization Tables */
#define V4L2_JPEG_MARKER_DRI (1<<5)    /* Define Restart Interval */
#define V4L2_JPEG_MARKER_COM (1<<6)    /* Comment segment */
#define V4L2_JPEG_MARKER_APP (1<<7)    /* App segment, driver will
                                        * allways use APP0 */
};

/*
 *      M E M O R Y - M A P P I N G   B U F F E R S
 */
struct v4l2_requestbuffers
{
        __u32                   count;
        enum v4l2_buf_type      type;
        enum v4l2_memory        memory;
        __u32                   reserved[2];
};

struct v4l2_buffer
{
        __u32                   index;
        enum v4l2_buf_type      type;
        __u32                   bytesused;
        __u32                   flags;
        enum v4l2_field         field;
        struct timeval          timestamp;
        struct v4l2_timecode    timecode;
        __u32                   sequence;

        /* memory location */
        enum v4l2_memory        memory;
        union {
                __u32           offset;
                unsigned long   userptr;
        } m;
        __u32                   length;
        __u32                   input;
        __u32                   reserved;
};

/*  Flags for 'flags' field */
#define V4L2_BUF_FLAG_MAPPED    0x0001  /* Buffer is mapped (flag) */
#define V4L2_BUF_FLAG_QUEUED    0x0002  /* Buffer is queued for processing */
#define V4L2_BUF_FLAG_DONE      0x0004  /* Buffer is ready */
#define V4L2_BUF_FLAG_KEYFRAME  0x0008  /* Image is a keyframe (I-frame) */
#define V4L2_BUF_FLAG_PFRAME    0x0010  /* Image is a P-frame */
#define V4L2_BUF_FLAG_BFRAME    0x0020  /* Image is a B-frame */
#define V4L2_BUF_FLAG_TIMECODE  0x0100  /* timecode field is valid */
#define V4L2_BUF_FLAG_INPUT     0x0200  /* input field is valid */

/*
 *      O V E R L A Y   P R E V I E W
 */
struct v4l2_framebuffer
{
        __u32                   capability;
        __u32                   flags;
/* FIXME: in theory we should pass something like PCI device + memory
 * region + offset instead of some physical address */
        void*                   base;
        struct v4l2_pix_format  fmt;
};
/*  Flags for the 'capability' field. Read only */
#define V4L2_FBUF_CAP_EXTERNOVERLAY     0x0001
#define V4L2_FBUF_CAP_CHROMAKEY         0x0002
#define V4L2_FBUF_CAP_LIST_CLIPPING     0x0004
#define V4L2_FBUF_CAP_BITMAP_CLIPPING   0x0008
#define V4L2_FBUF_CAP_LOCAL_ALPHA       0x0010
#define V4L2_FBUF_CAP_GLOBAL_ALPHA      0x0020
#define V4L2_FBUF_CAP_LOCAL_INV_ALPHA   0x0040
/*  Flags for the 'flags' field. */
#define V4L2_FBUF_FLAG_PRIMARY          0x0001
#define V4L2_FBUF_FLAG_OVERLAY          0x0002
#define V4L2_FBUF_FLAG_CHROMAKEY        0x0004
#define V4L2_FBUF_FLAG_LOCAL_ALPHA      0x0008
#define V4L2_FBUF_FLAG_GLOBAL_ALPHA     0x0010
#define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA  0x0020

struct v4l2_clip
{
        struct v4l2_rect        c;
        struct v4l2_clip        __user *next;
};

struct v4l2_window
{
        struct v4l2_rect        w;
        enum v4l2_field         field;
        __u32                   chromakey;
        struct v4l2_clip        __user *clips;
        __u32                   clipcount;
        void                    __user *bitmap;
        __u8                    global_alpha;
};

/*
 *      C A P T U R E   P A R A M E T E R S
 */
struct v4l2_captureparm
{
        __u32              capability;    /*  Supported modes */
        __u32              capturemode;   /*  Current mode */
        struct v4l2_fract  timeperframe;  /*  Time per frame in .1us units */
        __u32              extendedmode;  /*  Driver-specific extensions */
        __u32              readbuffers;   /*  # of buffers for read */
        __u32              reserved[4];
};

/*  Flags for 'capability' and 'capturemode' fields */
#define V4L2_MODE_HIGHQUALITY   0x0001  /*  High quality imaging mode */
#define V4L2_CAP_TIMEPERFRAME   0x1000  /*  timeperframe field is supported */

struct v4l2_outputparm
{
        __u32              capability;   /*  Supported modes */
        __u32              outputmode;   /*  Current mode */
        struct v4l2_fract  timeperframe; /*  Time per frame in seconds */
        __u32              extendedmode; /*  Driver-specific extensions */
        __u32              writebuffers; /*  # of buffers for write */
        __u32              reserved[4];
};

/*
 *      I N P U T   I M A G E   C R O P P I N G
 */
struct v4l2_cropcap {
        enum v4l2_buf_type      type;
        struct v4l2_rect        bounds;
        struct v4l2_rect        defrect;
        struct v4l2_fract       pixelaspect;
};

struct v4l2_crop {
        enum v4l2_buf_type      type;
        struct v4l2_rect        c;
};

/*
 *      A N A L O G   V I D E O   S T A N D A R D
 */

typedef __u64 v4l2_std_id;

/* one bit for each */
#define V4L2_STD_PAL_B          ((v4l2_std_id)0x00000001)
#define V4L2_STD_PAL_B1         ((v4l2_std_id)0x00000002)
#define V4L2_STD_PAL_G          ((v4l2_std_id)0x00000004)
#define V4L2_STD_PAL_H          ((v4l2_std_id)0x00000008)
#define V4L2_STD_PAL_I          ((v4l2_std_id)0x00000010)
#define V4L2_STD_PAL_D          ((v4l2_std_id)0x00000020)
#define V4L2_STD_PAL_D1         ((v4l2_std_id)0x00000040)
#define V4L2_STD_PAL_K          ((v4l2_std_id)0x00000080)

#define V4L2_STD_PAL_M          ((v4l2_std_id)0x00000100)
#define V4L2_STD_PAL_N          ((v4l2_std_id)0x00000200)
#define V4L2_STD_PAL_Nc         ((v4l2_std_id)0x00000400)
#define V4L2_STD_PAL_60         ((v4l2_std_id)0x00000800)

#define V4L2_STD_NTSC_M         ((v4l2_std_id)0x00001000)
#define V4L2_STD_NTSC_M_JP      ((v4l2_std_id)0x00002000)
#define V4L2_STD_NTSC_443       ((v4l2_std_id)0x00004000)
#define V4L2_STD_NTSC_M_KR      ((v4l2_std_id)0x00008000)

#define V4L2_STD_SECAM_B        ((v4l2_std_id)0x00010000)
#define V4L2_STD_SECAM_D        ((v4l2_std_id)0x00020000)
#define V4L2_STD_SECAM_G        ((v4l2_std_id)0x00040000)
#define V4L2_STD_SECAM_H        ((v4l2_std_id)0x00080000)
#define V4L2_STD_SECAM_K        ((v4l2_std_id)0x00100000)
#define V4L2_STD_SECAM_K1       ((v4l2_std_id)0x00200000)
#define V4L2_STD_SECAM_L        ((v4l2_std_id)0x00400000)
#define V4L2_STD_SECAM_LC       ((v4l2_std_id)0x00800000)

/* ATSC/HDTV */
#define V4L2_STD_ATSC_8_VSB     ((v4l2_std_id)0x01000000)
#define V4L2_STD_ATSC_16_VSB    ((v4l2_std_id)0x02000000)

/* FIXME:
   Although std_id is 64 bits, there is an issue on PPC32 architecture that
   makes switch(__u64) to break. So, there's a hack on v4l2-common.c rounding
   this value to 32 bits.
   As, currently, the max value is for V4L2_STD_ATSC_16_VSB (30 bits wide),
   it should work fine. However, if needed to add more than two standards,
   v4l2-common.c should be fixed.
 */

/* some merged standards */
#define V4L2_STD_MN     (V4L2_STD_PAL_M|V4L2_STD_PAL_N|V4L2_STD_PAL_Nc|V4L2_STD_NTSC)
#define V4L2_STD_B      (V4L2_STD_PAL_B|V4L2_STD_PAL_B1|V4L2_STD_SECAM_B)
#define V4L2_STD_GH     (V4L2_STD_PAL_G|V4L2_STD_PAL_H|V4L2_STD_SECAM_G|V4L2_STD_SECAM_H)
#define V4L2_STD_DK     (V4L2_STD_PAL_DK|V4L2_STD_SECAM_DK)

/* some common needed stuff */
#define V4L2_STD_PAL_BG         (V4L2_STD_PAL_B         |\
                                 V4L2_STD_PAL_B1        |\
                                 V4L2_STD_PAL_G)
#define V4L2_STD_PAL_DK         (V4L2_STD_PAL_D         |\
                                 V4L2_STD_PAL_D1        |\
                                 V4L2_STD_PAL_K)
#define V4L2_STD_PAL            (V4L2_STD_PAL_BG        |\
                                 V4L2_STD_PAL_DK        |\
                                 V4L2_STD_PAL_H         |\
                                 V4L2_STD_PAL_I)
#define V4L2_STD_NTSC           (V4L2_STD_NTSC_M        |\
                                 V4L2_STD_NTSC_M_JP     |\
                                 V4L2_STD_NTSC_M_KR)
#define V4L2_STD_SECAM_DK       (V4L2_STD_SECAM_D       |\
                                 V4L2_STD_SECAM_K       |\
                                 V4L2_STD_SECAM_K1)
#define V4L2_STD_SECAM          (V4L2_STD_SECAM_B       |\
                                 V4L2_STD_SECAM_G       |\
                                 V4L2_STD_SECAM_H       |\
                                 V4L2_STD_SECAM_DK      |\
                                 V4L2_STD_SECAM_L       |\
                                 V4L2_STD_SECAM_LC)

#define V4L2_STD_525_60         (V4L2_STD_PAL_M         |\
                                 V4L2_STD_PAL_60        |\
                                 V4L2_STD_NTSC          |\
                                 V4L2_STD_NTSC_443)
#define V4L2_STD_625_50         (V4L2_STD_PAL           |\
                                 V4L2_STD_PAL_N         |\
                                 V4L2_STD_PAL_Nc        |\
                                 V4L2_STD_SECAM)
#define V4L2_STD_ATSC           (V4L2_STD_ATSC_8_VSB    |\
                                 V4L2_STD_ATSC_16_VSB)

#define V4L2_STD_UNKNOWN        0
#define V4L2_STD_ALL            (V4L2_STD_525_60        |\
                                 V4L2_STD_625_50)

struct v4l2_standard
{
        __u32                index;
        v4l2_std_id          id;
        __u8                 name[24];
        struct v4l2_fract    frameperiod; /* Frames, not fields */
        __u32                framelines;
        __u32                reserved[4];
};

/*
 *      V I D E O   I N P U T S
 */
struct v4l2_input
{
        __u32        index;             /*  Which input */
        __u8         name[32];          /*  Label */
        __u32        type;              /*  Type of input */
        __u32        audioset;          /*  Associated audios (bitfield) */
        __u32        tuner;             /*  Associated tuner */
        v4l2_std_id  std;
        __u32        status;
        __u32        reserved[4];
};

/*  Values for the 'type' field */
#define V4L2_INPUT_TYPE_TUNER           1
#define V4L2_INPUT_TYPE_CAMERA          2

/* field 'status' - general */
#define V4L2_IN_ST_NO_POWER    0x00000001  /* Attached device is off */
#define V4L2_IN_ST_NO_SIGNAL   0x00000002
#define V4L2_IN_ST_NO_COLOR    0x00000004

/* field 'status' - analog */
#define V4L2_IN_ST_NO_H_LOCK   0x00000100  /* No horizontal sync lock */
#define V4L2_IN_ST_COLOR_KILL  0x00000200  /* Color killer is active */

/* field 'status' - digital */
#define V4L2_IN_ST_NO_SYNC     0x00010000  /* No synchronization lock */
#define V4L2_IN_ST_NO_EQU      0x00020000  /* No equalizer lock */
#define V4L2_IN_ST_NO_CARRIER  0x00040000  /* Carrier recovery failed */

/* field 'status' - VCR and set-top box */
#define V4L2_IN_ST_MACROVISION 0x01000000  /* Macrovision detected */
#define V4L2_IN_ST_NO_ACCESS   0x02000000  /* Conditional access denied */
#define V4L2_IN_ST_VTR         0x04000000  /* VTR time constant */

/*
 *      V I D E O   O U T P U T S
 */
struct v4l2_output
{
        __u32        index;             /*  Which output */
        __u8         name[32];          /*  Label */
        __u32        type;              /*  Type of output */
        __u32        audioset;          /*  Associated audios (bitfield) */
        __u32        modulator;         /*  Associated modulator */
        v4l2_std_id  std;
        __u32        reserved[4];
};
/*  Values for the 'type' field */
#define V4L2_OUTPUT_TYPE_MODULATOR              1
#define V4L2_OUTPUT_TYPE_ANALOG                 2
#define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY       3

/*
 *      C O N T R O L S
 */
struct v4l2_control
{
        __u32                id;
        __s32                value;
};

struct v4l2_ext_control
{
        __u32 id;
        __u32 reserved2[2];
        union {
                __s32 value;
                __s64 value64;
                void *reserved;
        };
} __attribute__ ((packed));

struct v4l2_ext_controls
{
        __u32 ctrl_class;
        __u32 count;
        __u32 error_idx;
        __u32 reserved[2];
        struct v4l2_ext_control *controls;
};

/*  Values for ctrl_class field */
#define V4L2_CTRL_CLASS_USER 0x00980000 /* Old-style 'user' controls */
#define V4L2_CTRL_CLASS_MPEG 0x00990000 /* MPEG-compression controls */
#define V4L2_CTRL_CLASS_CAMERA 0x009a0000       /* Camera class controls */

#define V4L2_CTRL_ID_MASK         (0x0fffffff)
#define V4L2_CTRL_ID2CLASS(id)    ((id) & 0x0fff0000UL)
#define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)

/*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
struct v4l2_queryctrl
{
        __u32                id;
        enum v4l2_ctrl_type  type;
        __u8                 name[32];  /* Whatever */
        __s32                minimum;   /* Note signedness */
        __s32                maximum;
        __s32                step;
        __s32                default_value;
        __u32                flags;
        __u32                reserved[2];
};

/*  Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
struct v4l2_querymenu
{
        __u32           id;
        __u32           index;
        __u8            name[32];       /* Whatever */
        __u32           reserved;
};

/*  Control flags  */
#define V4L2_CTRL_FLAG_DISABLED         0x0001
#define V4L2_CTRL_FLAG_GRABBED          0x0002
#define V4L2_CTRL_FLAG_READ_ONLY        0x0004
#define V4L2_CTRL_FLAG_UPDATE           0x0008
#define V4L2_CTRL_FLAG_INACTIVE         0x0010
#define V4L2_CTRL_FLAG_SLIDER           0x0020

/*  Query flag, to be ORed with the control ID */
#define V4L2_CTRL_FLAG_NEXT_CTRL        0x80000000

/*  User-class control IDs defined by V4L2 */
#define V4L2_CID_BASE                   (V4L2_CTRL_CLASS_USER | 0x900)
#define V4L2_CID_USER_BASE              V4L2_CID_BASE
/*  IDs reserved for driver specific controls */
#define V4L2_CID_PRIVATE_BASE           0x08000000

#define V4L2_CID_USER_CLASS             (V4L2_CTRL_CLASS_USER | 1)
#define V4L2_CID_BRIGHTNESS             (V4L2_CID_BASE+0)
#define V4L2_CID_CONTRAST               (V4L2_CID_BASE+1)
#define V4L2_CID_SATURATION             (V4L2_CID_BASE+2)
#define V4L2_CID_HUE                    (V4L2_CID_BASE+3)
#define V4L2_CID_AUDIO_VOLUME           (V4L2_CID_BASE+5)
#define V4L2_CID_AUDIO_BALANCE          (V4L2_CID_BASE+6)
#define V4L2_CID_AUDIO_BASS             (V4L2_CID_BASE+7)
#define V4L2_CID_AUDIO_TREBLE           (V4L2_CID_BASE+8)
#define V4L2_CID_AUDIO_MUTE             (V4L2_CID_BASE+9)
#define V4L2_CID_AUDIO_LOUDNESS         (V4L2_CID_BASE+10)
#define V4L2_CID_BLACK_LEVEL            (V4L2_CID_BASE+11) /* Deprecated */
#define V4L2_CID_AUTO_WHITE_BALANCE     (V4L2_CID_BASE+12)
#define V4L2_CID_DO_WHITE_BALANCE       (V4L2_CID_BASE+13)
#define V4L2_CID_RED_BALANCE            (V4L2_CID_BASE+14)
#define V4L2_CID_BLUE_BALANCE           (V4L2_CID_BASE+15)
#define V4L2_CID_GAMMA                  (V4L2_CID_BASE+16)
#define V4L2_CID_WHITENESS              (V4L2_CID_GAMMA) /* Deprecated */
#define V4L2_CID_EXPOSURE               (V4L2_CID_BASE+17)
#define V4L2_CID_AUTOGAIN               (V4L2_CID_BASE+18)
#define V4L2_CID_GAIN                   (V4L2_CID_BASE+19)
#define V4L2_CID_HFLIP                  (V4L2_CID_BASE+20)
#define V4L2_CID_VFLIP                  (V4L2_CID_BASE+21)

/* Deprecated, use V4L2_CID_PAN_RESET and V4L2_CID_TILT_RESET */
#define V4L2_CID_HCENTER_DEPRECATED     (V4L2_CID_BASE+22)
#define V4L2_CID_VCENTER_DEPRECATED     (V4L2_CID_BASE+23)

#define V4L2_CID_POWER_LINE_FREQUENCY   (V4L2_CID_BASE+24)
enum v4l2_power_line_frequency {
        V4L2_CID_POWER_LINE_FREQUENCY_DISABLED  = 0,
        V4L2_CID_POWER_LINE_FREQUENCY_50HZ      = 1,
        V4L2_CID_POWER_LINE_FREQUENCY_60HZ      = 2,
};
#define V4L2_CID_HUE_AUTO                       (V4L2_CID_BASE+25)
#define V4L2_CID_WHITE_BALANCE_TEMPERATURE      (V4L2_CID_BASE+26)
#define V4L2_CID_SHARPNESS                      (V4L2_CID_BASE+27)
#define V4L2_CID_BACKLIGHT_COMPENSATION         (V4L2_CID_BASE+28)
#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+29) /* last CID + 1 */

/*  MPEG-class control IDs defined by V4L2 */
#define V4L2_CID_MPEG_BASE                      (V4L2_CTRL_CLASS_MPEG | 0x900)
#define V4L2_CID_MPEG_CLASS                     (V4L2_CTRL_CLASS_MPEG | 1)

/*  MPEG streams */
#define V4L2_CID_MPEG_STREAM_TYPE               (V4L2_CID_MPEG_BASE+0)
enum v4l2_mpeg_stream_type {
        V4L2_MPEG_STREAM_TYPE_MPEG2_PS   = 0, /* MPEG-2 program stream */
        V4L2_MPEG_STREAM_TYPE_MPEG2_TS   = 1, /* MPEG-2 transport stream */
        V4L2_MPEG_STREAM_TYPE_MPEG1_SS   = 2, /* MPEG-1 system stream */
        V4L2_MPEG_STREAM_TYPE_MPEG2_DVD  = 3, /* MPEG-2 DVD-compatible stream */
        V4L2_MPEG_STREAM_TYPE_MPEG1_VCD  = 4, /* MPEG-1 VCD-compatible stream */
        V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD = 5, /* MPEG-2 SVCD-compatible stream */
};
#define V4L2_CID_MPEG_STREAM_PID_PMT            (V4L2_CID_MPEG_BASE+1)
#define V4L2_CID_MPEG_STREAM_PID_AUDIO          (V4L2_CID_MPEG_BASE+2)
#define V4L2_CID_MPEG_STREAM_PID_VIDEO          (V4L2_CID_MPEG_BASE+3)
#define V4L2_CID_MPEG_STREAM_PID_PCR            (V4L2_CID_MPEG_BASE+4)
#define V4L2_CID_MPEG_STREAM_PES_ID_AUDIO       (V4L2_CID_MPEG_BASE+5)
#define V4L2_CID_MPEG_STREAM_PES_ID_VIDEO       (V4L2_CID_MPEG_BASE+6)
#define V4L2_CID_MPEG_STREAM_VBI_FMT            (V4L2_CID_MPEG_BASE+7)
enum v4l2_mpeg_stream_vbi_fmt {
        V4L2_MPEG_STREAM_VBI_FMT_NONE = 0,  /* No VBI in the MPEG stream */
        V4L2_MPEG_STREAM_VBI_FMT_IVTV = 1,  /* VBI in private packets, IVTV format */
};

/*  MPEG audio */
#define V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ       (V4L2_CID_MPEG_BASE+100)
enum v4l2_mpeg_audio_sampling_freq {
        V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100 = 0,
        V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000 = 1,
        V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000 = 2,
};
#define V4L2_CID_MPEG_AUDIO_ENCODING            (V4L2_CID_MPEG_BASE+101)
enum v4l2_mpeg_audio_encoding {
        V4L2_MPEG_AUDIO_ENCODING_LAYER_1 = 0,
        V4L2_MPEG_AUDIO_ENCODING_LAYER_2 = 1,
        V4L2_MPEG_AUDIO_ENCODING_LAYER_3 = 2,
};
#define V4L2_CID_MPEG_AUDIO_L1_BITRATE          (V4L2_CID_MPEG_BASE+102)
enum v4l2_mpeg_audio_l1_bitrate {
        V4L2_MPEG_AUDIO_L1_BITRATE_32K  = 0,
        V4L2_MPEG_AUDIO_L1_BITRATE_64K  = 1,
        V4L2_MPEG_AUDIO_L1_BITRATE_96K  = 2,
        V4L2_MPEG_AUDIO_L1_BITRATE_128K = 3,
        V4L2_MPEG_AUDIO_L1_BITRATE_160K = 4,
        V4L2_MPEG_AUDIO_L1_BITRATE_192K = 5,
        V4L2_MPEG_AUDIO_L1_BITRATE_224K = 6,
        V4L2_MPEG_AUDIO_L1_BITRATE_256K = 7,
        V4L2_MPEG_AUDIO_L1_BITRATE_288K = 8,
        V4L2_MPEG_AUDIO_L1_BITRATE_320K = 9,
        V4L2_MPEG_AUDIO_L1_BITRATE_352K = 10,
        V4L2_MPEG_AUDIO_L1_BITRATE_384K = 11,
        V4L2_MPEG_AUDIO_L1_BITRATE_416K = 12,
        V4L2_MPEG_AUDIO_L1_BITRATE_448K = 13,
};
#define V4L2_CID_MPEG_AUDIO_L2_BITRATE          (V4L2_CID_MPEG_BASE+103)
enum v4l2_mpeg_audio_l2_bitrate {
        V4L2_MPEG_AUDIO_L2_BITRATE_32K  = 0,
        V4L2_MPEG_AUDIO_L2_BITRATE_48K  = 1,
        V4L2_MPEG_AUDIO_L2_BITRATE_56K  = 2,
        V4L2_MPEG_AUDIO_L2_BITRATE_64K  = 3,
        V4L2_MPEG_AUDIO_L2_BITRATE_80K  = 4,
        V4L2_MPEG_AUDIO_L2_BITRATE_96K  = 5,
        V4L2_MPEG_AUDIO_L2_BITRATE_112K = 6,
        V4L2_MPEG_AUDIO_L2_BITRATE_128K = 7,
        V4L2_MPEG_AUDIO_L2_BITRATE_160K = 8,
        V4L2_MPEG_AUDIO_L2_BITRATE_192K = 9,
        V4L2_MPEG_AUDIO_L2_BITRATE_224K = 10,
        V4L2_MPEG_AUDIO_L2_BITRATE_256K = 11,
        V4L2_MPEG_AUDIO_L2_BITRATE_320K = 12,
        V4L2_MPEG_AUDIO_L2_BITRATE_384K = 13,
};
#define V4L2_CID_MPEG_AUDIO_L3_BITRATE          (V4L2_CID_MPEG_BASE+104)
enum v4l2_mpeg_audio_l3_bitrate {
        V4L2_MPEG_AUDIO_L3_BITRATE_32K  = 0,
        V4L2_MPEG_AUDIO_L3_BITRATE_40K  = 1,
        V4L2_MPEG_AUDIO_L3_BITRATE_48K  = 2,
        V4L2_MPEG_AUDIO_L3_BITRATE_56K  = 3,
        V4L2_MPEG_AUDIO_L3_BITRATE_64K  = 4,
        V4L2_MPEG_AUDIO_L3_BITRATE_80K  = 5,
        V4L2_MPEG_AUDIO_L3_BITRATE_96K  = 6,
        V4L2_MPEG_AUDIO_L3_BITRATE_112K = 7,
        V4L2_MPEG_AUDIO_L3_BITRATE_128K = 8,
        V4L2_MPEG_AUDIO_L3_BITRATE_160K = 9,
        V4L2_MPEG_AUDIO_L3_BITRATE_192K = 10,
        V4L2_MPEG_AUDIO_L3_BITRATE_224K = 11,
        V4L2_MPEG_AUDIO_L3_BITRATE_256K = 12,
        V4L2_MPEG_AUDIO_L3_BITRATE_320K = 13,
};
#define V4L2_CID_MPEG_AUDIO_MODE                (V4L2_CID_MPEG_BASE+105)
enum v4l2_mpeg_audio_mode {
        V4L2_MPEG_AUDIO_MODE_STEREO       = 0,
        V4L2_MPEG_AUDIO_MODE_JOINT_STEREO = 1,
        V4L2_MPEG_AUDIO_MODE_DUAL         = 2,
        V4L2_MPEG_AUDIO_MODE_MONO         = 3,
};
#define V4L2_CID_MPEG_AUDIO_MODE_EXTENSION      (V4L2_CID_MPEG_BASE+106)
enum  v4l2_mpeg_audio_mode_extension {
        V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4  = 0,
        V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_8  = 1,
        V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_12 = 2,
        V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16 = 3,
};
#define V4L2_CID_MPEG_AUDIO_EMPHASIS            (V4L2_CID_MPEG_BASE+107)
enum v4l2_mpeg_audio_emphasis {
        V4L2_MPEG_AUDIO_EMPHASIS_NONE         = 0,
        V4L2_MPEG_AUDIO_EMPHASIS_50_DIV_15_uS = 1,
        V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17    = 2,
};
#define V4L2_CID_MPEG_AUDIO_CRC                 (V4L2_CID_MPEG_BASE+108)
enum v4l2_mpeg_audio_crc {
        V4L2_MPEG_AUDIO_CRC_NONE  = 0,
        V4L2_MPEG_AUDIO_CRC_CRC16 = 1,
};
#define V4L2_CID_MPEG_AUDIO_MUTE                (V4L2_CID_MPEG_BASE+109)

/*  MPEG video */
#define V4L2_CID_MPEG_VIDEO_ENCODING            (V4L2_CID_MPEG_BASE+200)
enum v4l2_mpeg_video_encoding {
        V4L2_MPEG_VIDEO_ENCODING_MPEG_1 = 0,
        V4L2_MPEG_VIDEO_ENCODING_MPEG_2 = 1,
};
#define V4L2_CID_MPEG_VIDEO_ASPECT              (V4L2_CID_MPEG_BASE+201)
enum v4l2_mpeg_video_aspect {
        V4L2_MPEG_VIDEO_ASPECT_1x1     = 0,
        V4L2_MPEG_VIDEO_ASPECT_4x3     = 1,
        V4L2_MPEG_VIDEO_ASPECT_16x9    = 2,
        V4L2_MPEG_VIDEO_ASPECT_221x100 = 3,
};
#define V4L2_CID_MPEG_VIDEO_B_FRAMES            (V4L2_CID_MPEG_BASE+202)
#define V4L2_CID_MPEG_VIDEO_GOP_SIZE            (V4L2_CID_MPEG_BASE+203)
#define V4L2_CID_MPEG_VIDEO_GOP_CLOSURE         (V4L2_CID_MPEG_BASE+204)
#define V4L2_CID_MPEG_VIDEO_PULLDOWN            (V4L2_CID_MPEG_BASE+205)
#define V4L2_CID_MPEG_VIDEO_BITRATE_MODE        (V4L2_CID_MPEG_BASE+206)
enum v4l2_mpeg_video_bitrate_mode {
        V4L2_MPEG_VIDEO_BITRATE_MODE_VBR = 0,
        V4L2_MPEG_VIDEO_BITRATE_MODE_CBR = 1,
};
#define V4L2_CID_MPEG_VIDEO_BITRATE             (V4L2_CID_MPEG_BASE+207)
#define V4L2_CID_MPEG_VIDEO_BITRATE_PEAK        (V4L2_CID_MPEG_BASE+208)
#define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
#define V4L2_CID_MPEG_VIDEO_MUTE                (V4L2_CID_MPEG_BASE+210)
#define V4L2_CID_MPEG_VIDEO_MUTE_YUV            (V4L2_CID_MPEG_BASE+211)

/*  MPEG-class control IDs specific to the CX2584x driver as defined by V4L2 */
#define V4L2_CID_MPEG_CX2341X_BASE                              (V4L2_CTRL_CLASS_MPEG | 0x1000)
#define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE         (V4L2_CID_MPEG_CX2341X_BASE+0)
enum v4l2_mpeg_cx2341x_video_spatial_filter_mode {
        V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL = 0,
        V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO   = 1,
};
#define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER              (V4L2_CID_MPEG_CX2341X_BASE+1)
#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE    (V4L2_CID_MPEG_CX2341X_BASE+2)
enum v4l2_mpeg_cx2341x_video_luma_spatial_filter_type {
        V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF                  = 0,
        V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR               = 1,
        V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_VERT              = 2,
        V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_HV_SEPARABLE      = 3,
        V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE = 4,
};
#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE  (V4L2_CID_MPEG_CX2341X_BASE+3)
enum v4l2_mpeg_cx2341x_video_chroma_spatial_filter_type {
        V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF    = 0,
        V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
};
#define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE        (V4L2_CID_MPEG_CX2341X_BASE+4)
enum v4l2_mpeg_cx2341x_video_temporal_filter_mode {
        V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL = 0,
        V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO   = 1,
};
#define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER             (V4L2_CID_MPEG_CX2341X_BASE+5)
#define V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE          (V4L2_CID_MPEG_CX2341X_BASE+6)
enum v4l2_mpeg_cx2341x_video_median_filter_type {
        V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF      = 0,
        V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR      = 1,
        V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_VERT     = 2,
        V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR_VERT = 3,
        V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG     = 4,
};
#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM   (V4L2_CID_MPEG_CX2341X_BASE+7)
#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP      (V4L2_CID_MPEG_CX2341X_BASE+8)
#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+9)
#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP    (V4L2_CID_MPEG_CX2341X_BASE+10)
#define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS         (V4L2_CID_MPEG_CX2341X_BASE+11)

/*  Camera class control IDs */
#define V4L2_CID_CAMERA_CLASS_BASE      (V4L2_CTRL_CLASS_CAMERA | 0x900)
#define V4L2_CID_CAMERA_CLASS           (V4L2_CTRL_CLASS_CAMERA | 1)

#define V4L2_CID_EXPOSURE_AUTO                  (V4L2_CID_CAMERA_CLASS_BASE+1)
enum v4l2_exposure_auto_type {
        V4L2_EXPOSURE_AUTO = 0,
        V4L2_EXPOSURE_MANUAL = 1,
        V4L2_EXPOSURE_SHUTTER_PRIORITY = 2,
        V4L2_EXPOSURE_APERTURE_PRIORITY = 3
};
#define V4L2_CID_EXPOSURE_ABSOLUTE              (V4L2_CID_CAMERA_CLASS_BASE+2)
#define V4L2_CID_EXPOSURE_AUTO_PRIORITY         (V4L2_CID_CAMERA_CLASS_BASE+3)

#define V4L2_CID_PAN_RELATIVE                   (V4L2_CID_CAMERA_CLASS_BASE+4)
#define V4L2_CID_TILT_RELATIVE                  (V4L2_CID_CAMERA_CLASS_BASE+5)
#define V4L2_CID_PAN_RESET                      (V4L2_CID_CAMERA_CLASS_BASE+6)
#define V4L2_CID_TILT_RESET                     (V4L2_CID_CAMERA_CLASS_BASE+7)

#define V4L2_CID_PAN_ABSOLUTE                   (V4L2_CID_CAMERA_CLASS_BASE+8)
#define V4L2_CID_TILT_ABSOLUTE                  (V4L2_CID_CAMERA_CLASS_BASE+9)

#define V4L2_CID_FOCUS_ABSOLUTE                 (V4L2_CID_CAMERA_CLASS_BASE+10)
#define V4L2_CID_FOCUS_RELATIVE                 (V4L2_CID_CAMERA_CLASS_BASE+11)
#define V4L2_CID_FOCUS_AUTO                     (V4L2_CID_CAMERA_CLASS_BASE+12)

/*
 *      T U N I N G
 */
struct v4l2_tuner
{
        __u32                   index;
        __u8                    name[32];
        enum v4l2_tuner_type    type;
        __u32                   capability;
        __u32                   rangelow;
        __u32                   rangehigh;
        __u32                   rxsubchans;
        __u32                   audmode;
        __s32                   signal;
        __s32                   afc;
        __u32                   reserved[4];
};

struct v4l2_modulator
{
        __u32                   index;
        __u8                    name[32];
        __u32                   capability;
        __u32                   rangelow;
        __u32                   rangehigh;
        __u32                   txsubchans;
        __u32                   reserved[4];
};

/*  Flags for the 'capability' field */
#define V4L2_TUNER_CAP_LOW              0x0001
#define V4L2_TUNER_CAP_NORM             0x0002
#define V4L2_TUNER_CAP_STEREO           0x0010
#define V4L2_TUNER_CAP_LANG2            0x0020
#define V4L2_TUNER_CAP_SAP              0x0020
#define V4L2_TUNER_CAP_LANG1            0x0040

/*  Flags for the 'rxsubchans' field */
#define V4L2_TUNER_SUB_MONO             0x0001
#define V4L2_TUNER_SUB_STEREO           0x0002
#define V4L2_TUNER_SUB_LANG2            0x0004
#define V4L2_TUNER_SUB_SAP              0x0004
#define V4L2_TUNER_SUB_LANG1            0x0008

/*  Values for the 'audmode' field */
#define V4L2_TUNER_MODE_MONO            0x0000
#define V4L2_TUNER_MODE_STEREO          0x0001
#define V4L2_TUNER_MODE_LANG2           0x0002
#define V4L2_TUNER_MODE_SAP             0x0002
#define V4L2_TUNER_MODE_LANG1           0x0003
#define V4L2_TUNER_MODE_LANG1_LANG2     0x0004

struct v4l2_frequency
{
        __u32                 tuner;
        enum v4l2_tuner_type  type;
        __u32                 frequency;
        __u32                 reserved[8];
};

/*
 *      A U D I O
 */
struct v4l2_audio
{
        __u32   index;
        __u8    name[32];
        __u32   capability;
        __u32   mode;
        __u32   reserved[2];
};

/*  Flags for the 'capability' field */
#define V4L2_AUDCAP_STEREO              0x00001
#define V4L2_AUDCAP_AVL                 0x00002

/*  Flags for the 'mode' field */
#define V4L2_AUDMODE_AVL                0x00001

struct v4l2_audioout
{
        __u32   index;
        __u8    name[32];
        __u32   capability;
        __u32   mode;
        __u32   reserved[2];
};

/*
 *      M P E G   S E R V I C E S
 *
 *      NOTE: EXPERIMENTAL API
 */
#if 1 /*KEEP*/
#define V4L2_ENC_IDX_FRAME_I    (0)
#define V4L2_ENC_IDX_FRAME_P    (1)
#define V4L2_ENC_IDX_FRAME_B    (2)
#define V4L2_ENC_IDX_FRAME_MASK (0xf)

struct v4l2_enc_idx_entry {
        __u64 offset;
        __u64 pts;
        __u32 length;
        __u32 flags;
        __u32 reserved[2];
};

#define V4L2_ENC_IDX_ENTRIES (64)
struct v4l2_enc_idx {
        __u32 entries;
        __u32 entries_cap;
        __u32 reserved[4];
        struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
};

#define V4L2_ENC_CMD_START      (0)
#define V4L2_ENC_CMD_STOP       (1)
#define V4L2_ENC_CMD_PAUSE      (2)
#define V4L2_ENC_CMD_RESUME     (3)

/* Flags for V4L2_ENC_CMD_STOP */
#define V4L2_ENC_CMD_STOP_AT_GOP_END    (1 << 0)

struct v4l2_encoder_cmd {
        __u32 cmd;
        __u32 flags;
        union {
                struct {
                        __u32 data[8];
                } raw;
        };
};

#endif

/*
 *      D A T A   S E R V I C E S   ( V B I )
 *
 *      Data services API by Michael Schimek
 */

/* Raw VBI */
struct v4l2_vbi_format
{
        __u32   sampling_rate;          /* in 1 Hz */
        __u32   offset;
        __u32   samples_per_line;
        __u32   sample_format;          /* V4L2_PIX_FMT_* */
        __s32   start[2];
        __u32   count[2];
        __u32   flags;                  /* V4L2_VBI_* */
        __u32   reserved[2];            /* must be zero */
};

/*  VBI flags  */
#define V4L2_VBI_UNSYNC         (1<< 0)
#define V4L2_VBI_INTERLACED     (1<< 1)

/* Sliced VBI
 *
 *    This implements is a proposal V4L2 API to allow SLICED VBI
 * required for some hardware encoders. It should change without
 * notice in the definitive implementation.
 */

struct v4l2_sliced_vbi_format
{
        __u16   service_set;
        /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
           service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
                                 (equals frame lines 313-336 for 625 line video
                                  standards, 263-286 for 525 line standards) */
        __u16   service_lines[2][24];
        __u32   io_size;
        __u32   reserved[2];            /* must be zero */
};

/* Teletext World System Teletext
   (WST), defined on ITU-R BT.653-2 */
#define V4L2_SLICED_TELETEXT_B          (0x0001)
/* Video Program System, defined on ETS 300 231*/
#define V4L2_SLICED_VPS                 (0x0400)
/* Closed Caption, defined on EIA-608 */
#define V4L2_SLICED_CAPTION_525         (0x1000)
/* Wide Screen System, defined on ITU-R BT1119.1 */
#define V4L2_SLICED_WSS_625             (0x4000)

#define V4L2_SLICED_VBI_525             (V4L2_SLICED_CAPTION_525)
#define V4L2_SLICED_VBI_625             (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)

struct v4l2_sliced_vbi_cap
{
        __u16   service_set;
        /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
           service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
                                 (equals frame lines 313-336 for 625 line video
                                  standards, 263-286 for 525 line standards) */
        __u16   service_lines[2][24];
        enum v4l2_buf_type type;
        __u32   reserved[3];    /* must be 0 */
};

struct v4l2_sliced_vbi_data
{
        __u32   id;
        __u32   field;          /* 0: first field, 1: second field */
        __u32   line;           /* 1-23 */
        __u32   reserved;       /* must be 0 */
        __u8    data[48];
};

/*
 *      A G G R E G A T E   S T R U C T U R E S
 */

/*      Stream data format
 */
struct v4l2_format
{
        enum v4l2_buf_type type;
        union
        {
                struct v4l2_pix_format          pix;     // V4L2_BUF_TYPE_VIDEO_CAPTURE
                struct v4l2_window              win;     // V4L2_BUF_TYPE_VIDEO_OVERLAY
                struct v4l2_vbi_format          vbi;     // V4L2_BUF_TYPE_VBI_CAPTURE
                struct v4l2_sliced_vbi_format   sliced;  // V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
                __u8    raw_data[200];                   // user-defined
        } fmt;
};

/*      Stream type-dependent parameters
 */
struct v4l2_streamparm
{
        enum v4l2_buf_type type;
        union
        {
                struct v4l2_captureparm capture;
                struct v4l2_outputparm  output;
                __u8    raw_data[200];  /* user-defined */
        } parm;
};

/*
 *      A D V A N C E D   D E B U G G I N G
 *
 *      NOTE: EXPERIMENTAL API
 */

/* VIDIOC_DBG_G_REGISTER and VIDIOC_DBG_S_REGISTER */

#define V4L2_CHIP_MATCH_HOST       0  /* Match against chip ID on host (0 for the host) */
#define V4L2_CHIP_MATCH_I2C_DRIVER 1  /* Match against I2C driver ID */
#define V4L2_CHIP_MATCH_I2C_ADDR   2  /* Match against I2C 7-bit address */

struct v4l2_register {
        __u32 match_type; /* Match type */
        __u32 match_chip; /* Match this chip, meaning determined by match_type */
        __u64 reg;
        __u64 val;
};

/* VIDIOC_G_CHIP_IDENT */
struct v4l2_chip_ident {
        __u32 match_type;  /* Match type */
        __u32 match_chip;  /* Match this chip, meaning determined by match_type */
        __u32 ident;       /* chip identifier as specified in <media/v4l2-chip-ident.h> */
        __u32 revision;    /* chip revision, chip specific */
};

/*
 *      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
 *
 */
#define VIDIOC_QUERYCAP         _IOR  ('V',  0, struct v4l2_capability)
#define VIDIOC_RESERVED         _IO   ('V',  1)
#define VIDIOC_ENUM_FMT         _IOWR ('V',  2, struct v4l2_fmtdesc)
#define VIDIOC_G_FMT            _IOWR ('V',  4, struct v4l2_format)
#define VIDIOC_S_FMT            _IOWR ('V',  5, struct v4l2_format)
#define VIDIOC_REQBUFS          _IOWR ('V',  8, struct v4l2_requestbuffers)
#define VIDIOC_QUERYBUF         _IOWR ('V',  9, struct v4l2_buffer)
#define VIDIOC_G_FBUF           _IOR  ('V', 10, struct v4l2_framebuffer)
#define VIDIOC_S_FBUF           _IOW  ('V', 11, struct v4l2_framebuffer)
#define VIDIOC_OVERLAY          _IOW  ('V', 14, int)
#define VIDIOC_QBUF             _IOWR ('V', 15, struct v4l2_buffer)
#define VIDIOC_DQBUF            _IOWR ('V', 17, struct v4l2_buffer)
#define VIDIOC_STREAMON         _IOW  ('V', 18, int)
#define VIDIOC_STREAMOFF        _IOW  ('V', 19, int)
#define VIDIOC_G_PARM           _IOWR ('V', 21, struct v4l2_streamparm)
#define VIDIOC_S_PARM           _IOWR ('V', 22, struct v4l2_streamparm)
#define VIDIOC_G_STD            _IOR  ('V', 23, v4l2_std_id)
#define VIDIOC_S_STD            _IOW  ('V', 24, v4l2_std_id)
#define VIDIOC_ENUMSTD          _IOWR ('V', 25, struct v4l2_standard)
#define VIDIOC_ENUMINPUT        _IOWR ('V', 26, struct v4l2_input)
#define VIDIOC_G_CTRL           _IOWR ('V', 27, struct v4l2_control)
#define VIDIOC_S_CTRL           _IOWR ('V', 28, struct v4l2_control)
#define VIDIOC_G_TUNER          _IOWR ('V', 29, struct v4l2_tuner)
#define VIDIOC_S_TUNER          _IOW  ('V', 30, struct v4l2_tuner)
#define VIDIOC_G_AUDIO          _IOR  ('V', 33, struct v4l2_audio)
#define VIDIOC_S_AUDIO          _IOW  ('V', 34, struct v4l2_audio)
#define VIDIOC_QUERYCTRL        _IOWR ('V', 36, struct v4l2_queryctrl)
#define VIDIOC_QUERYMENU        _IOWR ('V', 37, struct v4l2_querymenu)
#define VIDIOC_G_INPUT          _IOR  ('V', 38, int)
#define VIDIOC_S_INPUT          _IOWR ('V', 39, int)
#define VIDIOC_G_OUTPUT         _IOR  ('V', 46, int)
#define VIDIOC_S_OUTPUT         _IOWR ('V', 47, int)
#define VIDIOC_ENUMOUTPUT       _IOWR ('V', 48, struct v4l2_output)
#define VIDIOC_G_AUDOUT         _IOR  ('V', 49, struct v4l2_audioout)
#define VIDIOC_S_AUDOUT         _IOW  ('V', 50, struct v4l2_audioout)
#define VIDIOC_G_MODULATOR      _IOWR ('V', 54, struct v4l2_modulator)
#define VIDIOC_S_MODULATOR      _IOW  ('V', 55, struct v4l2_modulator)
#define VIDIOC_G_FREQUENCY      _IOWR ('V', 56, struct v4l2_frequency)
#define VIDIOC_S_FREQUENCY      _IOW  ('V', 57, struct v4l2_frequency)
#define VIDIOC_CROPCAP          _IOWR ('V', 58, struct v4l2_cropcap)
#define VIDIOC_G_CROP           _IOWR ('V', 59, struct v4l2_crop)
#define VIDIOC_S_CROP           _IOW  ('V', 60, struct v4l2_crop)
#define VIDIOC_G_JPEGCOMP       _IOR  ('V', 61, struct v4l2_jpegcompression)
#define VIDIOC_S_JPEGCOMP       _IOW  ('V', 62, struct v4l2_jpegcompression)
#define VIDIOC_QUERYSTD         _IOR  ('V', 63, v4l2_std_id)
#define VIDIOC_TRY_FMT          _IOWR ('V', 64, struct v4l2_format)
#define VIDIOC_ENUMAUDIO        _IOWR ('V', 65, struct v4l2_audio)
#define VIDIOC_ENUMAUDOUT       _IOWR ('V', 66, struct v4l2_audioout)
#define VIDIOC_G_PRIORITY       _IOR  ('V', 67, enum v4l2_priority)
#define VIDIOC_S_PRIORITY       _IOW  ('V', 68, enum v4l2_priority)
#define VIDIOC_G_SLICED_VBI_CAP _IOWR ('V', 69, struct v4l2_sliced_vbi_cap)
#define VIDIOC_LOG_STATUS       _IO   ('V', 70)
#define VIDIOC_G_EXT_CTRLS      _IOWR ('V', 71, struct v4l2_ext_controls)
#define VIDIOC_S_EXT_CTRLS      _IOWR ('V', 72, struct v4l2_ext_controls)
#define VIDIOC_TRY_EXT_CTRLS    _IOWR ('V', 73, struct v4l2_ext_controls)
#if 1 /*KEEP*/
#define VIDIOC_ENUM_FRAMESIZES  _IOWR ('V', 74, struct v4l2_frmsizeenum)
#define VIDIOC_ENUM_FRAMEINTERVALS      _IOWR ('V', 75, struct v4l2_frmivalenum)
#define VIDIOC_G_ENC_INDEX      _IOR  ('V', 76, struct v4l2_enc_idx)
#define VIDIOC_ENCODER_CMD      _IOWR ('V', 77, struct v4l2_encoder_cmd)
#define VIDIOC_TRY_ENCODER_CMD  _IOWR ('V', 78, struct v4l2_encoder_cmd)

/* Experimental, only implemented if CONFIG_VIDEO_ADV_DEBUG is defined */
#define VIDIOC_DBG_S_REGISTER   _IOW  ('V', 79, struct v4l2_register)
#define VIDIOC_DBG_G_REGISTER   _IOWR ('V', 80, struct v4l2_register)

#define VIDIOC_G_CHIP_IDENT     _IOWR ('V', 81, struct v4l2_chip_ident)
#endif

#ifdef __OLD_VIDIOC_
/* for compatibility, will go away some day */
#define VIDIOC_OVERLAY_OLD      _IOWR ('V', 14, int)
#define VIDIOC_S_PARM_OLD       _IOW  ('V', 22, struct v4l2_streamparm)
#define VIDIOC_S_CTRL_OLD       _IOW  ('V', 28, struct v4l2_control)
#define VIDIOC_G_AUDIO_OLD      _IOWR ('V', 33, struct v4l2_audio)
#define VIDIOC_G_AUDOUT_OLD     _IOWR ('V', 49, struct v4l2_audioout)
#define VIDIOC_CROPCAP_OLD      _IOR  ('V', 58, struct v4l2_cropcap)
#endif

#define BASE_VIDIOC_PRIVATE     192             /* 192-255 are private */

#endif /* __LINUX_VIDEODEV2_H */

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */
/*
 *  V4L2 video capture example
 *
 *  This program can be used and distributed without restrictions.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include <getopt.h>             /* getopt_long() */

#include <fcntl.h>              /* low-level i/o */
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>

#include <asm/types.h>          /* for videodev2.h */

#include <linux/videodev2.h>

#define CLEAR(x) memset (&(x), 0, sizeof (x))

typedef enum {
        IO_METHOD_READ,
        IO_METHOD_MMAP,
        IO_METHOD_USERPTR,
} io_method;

struct buffer {
        void *                  start;
        size_t                  length;
};

static char *           dev_name        = NULL;
static io_method        io              = IO_METHOD_MMAP;
static int              fd              = -1;
struct buffer *         buffers         = NULL;
static unsigned int     n_buffers       = 0;

static void
errno_exit                      (const char *           s)
{
        fprintf (stderr, "%s error %d, %s\n",
                 s, errno, strerror (errno));

        exit (EXIT_FAILURE);
}

static int
xioctl                          (int                    fd,
                                 int                    request,
                                 void *                 arg)
{
        int r;

        do r = ioctl (fd, request, arg);
        while (-1 == r && EINTR == errno);

        return r;
}

static void
process_image                   (const void *           p)
{
        fputc ('.', stdout);
        fflush (stdout);
}

static int
read_frame                      (void)
{
        struct v4l2_buffer buf;
        unsigned int i;

        switch (io) {
        case IO_METHOD_READ:
                if (-1 == read (fd, buffers[0].start, buffers[0].length)) {
                        switch (errno) {
                        case EAGAIN:
                                return 0;

                        case EIO:
                                /* Could ignore EIO, see spec. */

                                /* fall through */

                        default:
                                errno_exit ("read");
                        }
                }

                process_image (buffers[0].start);

                break;

        case IO_METHOD_MMAP:
                CLEAR (buf);

                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_MMAP;

                if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
                        switch (errno) {
                        case EAGAIN:
                                return 0;

                        case EIO:
                                /* Could ignore EIO, see spec. */

                                /* fall through */

                        default:
                                errno_exit ("VIDIOC_DQBUF");
                        }
                }

                assert (buf.index < n_buffers);

                process_image (buffers[buf.index].start);

                if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
                        errno_exit ("VIDIOC_QBUF");

                break;

        case IO_METHOD_USERPTR:
                CLEAR (buf);

                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_USERPTR;

                if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
                        switch (errno) {
                        case EAGAIN:
                                return 0;

                        case EIO:
                                /* Could ignore EIO, see spec. */

                                /* fall through */

                        default:
                                errno_exit ("VIDIOC_DQBUF");
                        }
                }

                for (i = 0; i < n_buffers; ++i)
                        if (buf.m.userptr == (unsigned long) buffers[i].start
                            && buf.length == buffers[i].length)
                                break;

                assert (i < n_buffers);

                process_image ((void *) buf.m.userptr);

                if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
                        errno_exit ("VIDIOC_QBUF");

                break;
        }

        return 1;
}

static void
mainloop                        (void)
{
        unsigned int count;

        count = 100;

        while (count-- > 0) {
                for (;;) {
                        fd_set fds;
                        struct timeval tv;
                        int r;

                        FD_ZERO (&fds);
                        FD_SET (fd, &fds);

                        /* Timeout. */
                        tv.tv_sec = 2;
                        tv.tv_usec = 0;

                        r = select (fd + 1, &fds, NULL, NULL, &tv);

                        if (-1 == r) {
                                if (EINTR == errno)
                                        continue;

                                errno_exit ("select");
                        }

                        if (0 == r) {
                                fprintf (stderr, "select timeout\n");
                                exit (EXIT_FAILURE);
                        }

                        if (read_frame ())
                                break;

                        /* EAGAIN - continue select loop. */
                }
        }
}

static void
stop_capturing                  (void)
{
        enum v4l2_buf_type type;

        switch (io) {
        case IO_METHOD_READ:
                /* Nothing to do. */
                break;

        case IO_METHOD_MMAP:
        case IO_METHOD_USERPTR:
                type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

                if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
                        errno_exit ("VIDIOC_STREAMOFF");

                break;
        }
}

static void
start_capturing                 (void)
{
        unsigned int i;
        enum v4l2_buf_type type;

        switch (io) {
        case IO_METHOD_READ:
                /* Nothing to do. */
                break;

        case IO_METHOD_MMAP:
                for (i = 0; i < n_buffers; ++i) {
                        struct v4l2_buffer buf;

                        CLEAR (buf);

                        buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                        buf.memory      = V4L2_MEMORY_MMAP;
                        buf.index       = i;

                        if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
                                errno_exit ("VIDIOC_QBUF");
                }

                type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

                if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
                        errno_exit ("VIDIOC_STREAMON");

                break;

        case IO_METHOD_USERPTR:
                for (i = 0; i < n_buffers; ++i) {
                        struct v4l2_buffer buf;

                        CLEAR (buf);

                        buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                        buf.memory      = V4L2_MEMORY_USERPTR;
                        buf.index       = i;
                        buf.m.userptr   = (unsigned long) buffers[i].start;
                        buf.length      = buffers[i].length;

                        if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
                                errno_exit ("VIDIOC_QBUF");
                }

                type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

                if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
                        errno_exit ("VIDIOC_STREAMON");

                break;
        }
}

static void
uninit_device                   (void)
{
        unsigned int i;

        switch (io) {
        case IO_METHOD_READ:
                free (buffers[0].start);
                break;

        case IO_METHOD_MMAP:
                for (i = 0; i < n_buffers; ++i)
                        if (-1 == munmap (buffers[i].start, buffers[i].length))
                                errno_exit ("munmap");
                break;

        case IO_METHOD_USERPTR:
                for (i = 0; i < n_buffers; ++i)
                        free (buffers[i].start);
                break;
        }

        free (buffers);
}

static void
init_read                       (unsigned int           buffer_size)
{
        buffers = calloc (1, sizeof (*buffers));

        if (!buffers) {
                fprintf (stderr, "Out of memory\n");
                exit (EXIT_FAILURE);
        }

        buffers[0].length = buffer_size;
        buffers[0].start = malloc (buffer_size);

        if (!buffers[0].start) {
                fprintf (stderr, "Out of memory\n");
                exit (EXIT_FAILURE);
        }
}

static void
init_mmap                       (void)
{
        struct v4l2_requestbuffers req;

        CLEAR (req);

        req.count               = 4;
        req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        req.memory              = V4L2_MEMORY_MMAP;

        if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
                if (EINVAL == errno) {
                        fprintf (stderr, "%s does not support "
                                 "memory mapping\n", dev_name);
                        exit (EXIT_FAILURE);
                } else {
                        errno_exit ("VIDIOC_REQBUFS");
                }
        }

        if (req.count < 2) {
                fprintf (stderr, "Insufficient buffer memory on %s\n",
                         dev_name);
                exit (EXIT_FAILURE);
        }

        buffers = calloc (req.count, sizeof (*buffers));

        if (!buffers) {
                fprintf (stderr, "Out of memory\n");
                exit (EXIT_FAILURE);
        }

        for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
                struct v4l2_buffer buf;

                CLEAR (buf);

                buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory      = V4L2_MEMORY_MMAP;
                buf.index       = n_buffers;

                if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
                        errno_exit ("VIDIOC_QUERYBUF");

                buffers[n_buffers].length = buf.length;
                buffers[n_buffers].start =
                        mmap (NULL /* start anywhere */,
                              buf.length,
                              PROT_READ | PROT_WRITE /* required */,
                              MAP_SHARED /* recommended */,
                              fd, buf.m.offset);

                if (MAP_FAILED == buffers[n_buffers].start)
                        errno_exit ("mmap");
        }
}

static void
init_userp                      (unsigned int           buffer_size)
{
        struct v4l2_requestbuffers req;
        unsigned int page_size;

        page_size = getpagesize ();
        buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);

        CLEAR (req);

        req.count               = 4;
        req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        req.memory              = V4L2_MEMORY_USERPTR;

        if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
                if (EINVAL == errno) {
                        fprintf (stderr, "%s does not support "
                                 "user pointer i/o\n", dev_name);
                        exit (EXIT_FAILURE);
                } else {
                        errno_exit ("VIDIOC_REQBUFS");
                }
        }

        buffers = calloc (4, sizeof (*buffers));

        if (!buffers) {
                fprintf (stderr, "Out of memory\n");
                exit (EXIT_FAILURE);
        }

        for (n_buffers = 0; n_buffers < 4; ++n_buffers) {
                buffers[n_buffers].length = buffer_size;
                buffers[n_buffers].start = memalign (/* boundary */ page_size,
                                                     buffer_size);

                if (!buffers[n_buffers].start) {
                        fprintf (stderr, "Out of memory\n");
                        exit (EXIT_FAILURE);
                }
        }
}

static void
init_device                     (void)
{
        struct v4l2_capability cap;
        struct v4l2_cropcap cropcap;
        struct v4l2_crop crop;
        struct v4l2_format fmt;
        unsigned int min;

        if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
                if (EINVAL == errno) {
                        fprintf (stderr, "%s is no V4L2 device\n",
                                 dev_name);
                        exit (EXIT_FAILURE);
                } else {
                        errno_exit ("VIDIOC_QUERYCAP");
                }
        }

        if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
                fprintf (stderr, "%s is no video capture device\n",
                         dev_name);
                exit (EXIT_FAILURE);
        }

        switch (io) {
        case IO_METHOD_READ:
                if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
                        fprintf (stderr, "%s does not support read i/o\n",
                                 dev_name);
                        exit (EXIT_FAILURE);
                }

                break;

        case IO_METHOD_MMAP:
        case IO_METHOD_USERPTR:
                if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
                        fprintf (stderr, "%s does not support streaming i/o\n",
                                 dev_name);
                        exit (EXIT_FAILURE);
                }

                break;
        }

        /* Select video input, video standard and tune here. */

        CLEAR (cropcap);

        cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

        if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
                crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                crop.c = cropcap.defrect; /* reset to default */

                if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
                        switch (errno) {
                        case EINVAL:
                                /* Cropping not supported. */
                                break;
                        default:
                                /* Errors ignored. */
                                break;
                        }
                }
        } else {        
                /* Errors ignored. */
        }

        CLEAR (fmt);

        fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        fmt.fmt.pix.width       = 640; 
        fmt.fmt.pix.height      = 480;
        fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
        fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;

        if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
                errno_exit ("VIDIOC_S_FMT");

        /* Note VIDIOC_S_FMT may change width and height. */

        /* Buggy driver paranoia. */
        min = fmt.fmt.pix.width * 2;
        if (fmt.fmt.pix.bytesperline < min)
                fmt.fmt.pix.bytesperline = min;
        min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
        if (fmt.fmt.pix.sizeimage < min)
                fmt.fmt.pix.sizeimage = min;

        switch (io) {
        case IO_METHOD_READ:
                init_read (fmt.fmt.pix.sizeimage);
                break;

        case IO_METHOD_MMAP:
                init_mmap ();
                break;

        case IO_METHOD_USERPTR:
                init_userp (fmt.fmt.pix.sizeimage);
                break;
        }
}

static void
close_device                    (void)
{
        if (-1 == close (fd))
                errno_exit ("close");

        fd = -1;
}

static void
open_device                     (void)
{
        struct stat st; 

        if (-1 == stat (dev_name, &st)) {
                fprintf (stderr, "Cannot identify '%s': %d, %s\n",
                         dev_name, errno, strerror (errno));
                exit (EXIT_FAILURE);
        }

        if (!S_ISCHR (st.st_mode)) {
                fprintf (stderr, "%s is no device\n", dev_name);
                exit (EXIT_FAILURE);
        }

        fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);

        if (-1 == fd) {
                fprintf (stderr, "Cannot open '%s': %d, %s\n",
                         dev_name, errno, strerror (errno));
                exit (EXIT_FAILURE);
        }
}

static void
usage                           (FILE *                 fp,
                                 int                    argc,
                                 char **                argv)
{
        fprintf (fp,
                 "Usage: %s [options]\n\n"
                 "Options:\n"
                 "-d | --device name   Video device name [/dev/video]\n"
                 "-h | --help          Print this message\n"
                 "-m | --mmap          Use memory mapped buffers\n"
                 "-r | --read          Use read() calls\n"
                 "-u | --userp         Use application allocated buffers\n"
                 "",
                 argv[0]);
}

static const char short_options [] = "d:hmru";

static const struct option
long_options [] = {
        { "device",     required_argument,      NULL,           'd' },
        { "help",       no_argument,            NULL,           'h' },
        { "mmap",       no_argument,            NULL,           'm' },
        { "read",       no_argument,            NULL,           'r' },
        { "userp",      no_argument,            NULL,           'u' },
        { 0, 0, 0, 0 }
};

int
main                            (int                    argc,
                                 char **                argv)
{
        dev_name = "/dev/video";

        for (;;) {
                int index;
                int c;

                c = getopt_long (argc, argv,
                                 short_options, long_options,
                                 &index);

                if (-1 == c)
                        break;

                switch (c) {
                case 0: /* getopt_long() flag */
                        break;

                case 'd':
                        dev_name = optarg;
                        break;

                case 'h':
                        usage (stdout, argc, argv);
                        exit (EXIT_SUCCESS);

                case 'm':
                        io = IO_METHOD_MMAP;
                        break;

                case 'r':
                        io = IO_METHOD_READ;
                        break;

                case 'u':
                        io = IO_METHOD_USERPTR;
                        break;

                default:
                        usage (stderr, argc, argv);
                        exit (EXIT_FAILURE);
                }
        }

        open_device ();

        init_device ();

        start_capturing ();

        mainloop ();

        stop_capturing ();

        uninit_device ();

        close_device ();

        exit (EXIT_SUCCESS);

        return 0;
}
Documentation/video4linux
/dev/video2
/dev/vbi2

ID	Type	Description
`V4L2_CID_BASE`		First predefined ID, equal to`V4L2_CID_BRIGHTNESS`.
`V4L2_CID_USER_BASE`		Synonym of `V4L2_CID_BASE`.
`V4L2_CID_BRIGHTNESS`	integer	Picture brightness, or more precisely, the blacklevel.
`V4L2_CID_CONTRAST`	integer	Picture contrast or luma gain.
`V4L2_CID_SATURATION`	integer	Picture color saturation or chroma gain.
`V4L2_CID_HUE`	integer	Hue or color balance.
`V4L2_CID_AUDIO_VOLUME`	integer	Overall audio volume. Note some drivers alsoprovide an OSS or ALSA mixer interface.
`V4L2_CID_AUDIO_BALANCE`	integer	Audio stereo balance. Minimum corresponds to allthe way left, maximum to right.
`V4L2_CID_AUDIO_BASS`	integer	Audio bass adjustment.
`V4L2_CID_AUDIO_TREBLE`	integer	Audio treble adjustment.
`V4L2_CID_AUDIO_MUTE`	boolean	Mute audio, i. e. set the volume to zero, howeverwithout affecting `V4L2_CID_AUDIO_VOLUME`. LikeALSA drivers, V4L2 drivers must mute at load time to avoid excessivenoise. Actually the entire device should be reset to a low powerconsumption state.
`V4L2_CID_AUDIO_LOUDNESS`	boolean	Loudness mode (bass boost).
`V4L2_CID_BLACK_LEVEL`	integer	Another name for brightness (not a synonym of`V4L2_CID_BRIGHTNESS`). This control is deprecatedand should not be used in new drivers and applications.
`V4L2_CID_AUTO_WHITE_BALANCE`	boolean	Automatic white balance (cameras).
`V4L2_CID_DO_WHITE_BALANCE`	button	This is an action control. When set (the value isignored), the device will do a white balance and then hold the currentsetting. Contrast this with the boolean`V4L2_CID_AUTO_WHITE_BALANCE`, which, whenactivated, keeps adjusting the white balance.
`V4L2_CID_RED_BALANCE`	integer	Red chroma balance.
`V4L2_CID_BLUE_BALANCE`	integer	Blue chroma balance.
`V4L2_CID_GAMMA`	integer	Gamma adjust.
`V4L2_CID_WHITENESS`	integer	Whiteness for grey-scale devices. This is a synonymfor`V4L2_CID_GAMMA`. This control is deprecatedand should not be used in new drivers and applications.
`V4L2_CID_EXPOSURE`	integer	Exposure (cameras). [Unit?]
`V4L2_CID_AUTOGAIN`	boolean	Automatic gain/exposure control.
`V4L2_CID_GAIN`	integer	Gain control.
`V4L2_CID_HFLIP`	boolean	Mirror the picture horizontally.
`V4L2_CID_VFLIP`	boolean	Mirror the picture vertically.
`V4L2_CID_HCENTER_DEPRECATED` (formerly`V4L2_CID_HCENTER`)	integer	Horizontal image centering. This control isdeprecated. New drivers and applications should use theCamera class controls`V4L2_CID_PAN_ABSOLUTE`,`V4L2_CID_PAN_RELATIVE`and`V4L2_CID_PAN_RESET` instead.
`V4L2_CID_VCENTER_DEPRECATED` (formerly`V4L2_CID_VCENTER`)	integer	Vertical image centering. Centering is intended tophysically adjust cameras. For image cropping seeSection 1.11, for clippingSection 4.2. Thiscontrol is deprecated. New drivers and applications should use theCamera class controls`V4L2_CID_TILT_ABSOLUTE`,`V4L2_CID_TILT_RELATIVE`and`V4L2_CID_TILT_RESET` instead.
`V4L2_CID_POWER_LINE_FREQUENCY`	integer	Enables a power line frequency filter to avoidflicker. Possible values are:`V4L2_CID_POWER_LINE_FREQUENCY_DISABLED`(0),`V4L2_CID_POWER_LINE_FREQUENCY_50HZ` (1) and`V4L2_CID_POWER_LINE_FREQUENCY_60HZ` (2).
`V4L2_CID_HUE_AUTO`	boolean	Enables automatic hue control by the device. Theeffect of setting `V4L2_CID_HUE` while automatichue control is enabled is undefined, drivers should ignore suchrequest.
`V4L2_CID_WHITE_BALANCE_TEMPERATURE`	integer	This control specifies the white balance settingsas a color temperature in Kelvin. A driver should have a minimum of2800 (incandescent) to 6500 (daylight). For more information aboutcolor temperature seeWikipedia.
`V4L2_CID_SHARPNESS`	integer	Adjusts the sharpness filters in a camera. Theminimum value disables the filters, higher values give a sharperpicture.
`V4L2_CID_BACKLIGHT_COMPENSATION`	integer	Adjusts the backlight compensation in a camera. Theminimum value disables backlight compensation.
`V4L2_CID_LASTP1`		End of the predefined control IDs (currently`V4L2_CID_BACKLIGHT_COMPENSATION` + 1).
`V4L2_CID_PRIVATE_BASE`		ID of the first custom (driver specific) control.Applications depending on particular custom controls should check thedriver name and version, seeSection 1.2.

__u32	`width`	Image width in pixels.
__u32	`height`	Image height in pixels.
Applications set these fields torequest an image size, drivers return the closest possible values. Incase of planar formats the`width` and`height` applies to the largest plane. Toavoid ambiguities drivers must return values rounded up to a multipleof the scale factor of any smaller planes. For example when the imageformat is YUV 4:2:0,`width`and`height` must be multiples of two.
__u32	`pixelformat`	The pixel format or type of compression, set by theapplication. This is a little endianfour character code. V4L2 definesstandard RGB formats inTable 2-1, YUV formats inSection 2.5, and reserved codes inTable 2-8
enum v4l2_field	`field`	Video images are typically interlaced. Applicationscan request to capture or output only the top or bottom field, or bothfields interlaced or sequentially stored in one buffer or alternatingin separate buffers. Drivers return the actual field order selected.For details see Section 3.6.
__u32	`bytesperline`	Distance in bytes between the leftmost pixels in twoadjacent lines.
Both applications and driverscan set this field to request padding bytes at the end of each line.Drivers however may ignore the value requested by the application,returning`width` times bytes per pixel or alarger value required by the hardware. That implies applications canjust set this field to zero to get a reasonabledefault. Video hardware may access padding bytes,therefore they must reside in accessible memory. Consider cases wherepadding bytes after the last line of an image cross a system pageboundary. Input devices may write padding bytes, the value isundefined. Output devices ignore the contents of paddingbytes. When the image format is planar the`bytesperline` value applies to the largestplane and is divided by the same factor as the`width` field for any smaller planes. Forexample the Cb and Cr planes of a YUV 4:2:0 image have half as manypadding bytes following each line as the Y plane. To avoid ambiguitiesdrivers must return a`bytesperline`valuerounded up to a multiple of the scale factor.
__u32	`sizeimage`	Size in bytes of the buffer to hold a complete image,set by the driver. Usually this is`bytesperline` times`height`. When the image consists of variablelength compressed data this is the maximum number of bytes required tohold an image.
enum v4l2_colorspace	`colorspace`	This information supplements the`pixelformat` and must be set by the driver,seeSection 2.2.
__u32	`priv`	Reserved for custom (driver defined) additionalinformation about formats. When not used drivers and applications mustset this field to zero.

Identifier	Value	Description	Chromaticities[a]			White Point	Gamma Correction	Luminance E'_Y	Quantization
Identifier	Value	Description	Red	Green	Blue	White Point	Gamma Correction	Luminance E'_Y	Y'	Cb, Cr
`V4L2_COLORSPACE_SMPTE170M`	1	NTSC/PAL according toSMPTE 170M,ITU BT.601	x = 0.630, y = 0.340	x = 0.310, y = 0.595	x = 0.155, y = 0.070	x = 0.3127, y = 0.3290, Illuminant D₆₅	E' = 4.5 I for I ≤0.018,1.099 I^0.45 - 0.099 for 0.018 < I	0.299 E'_R+ 0.587 E'_G+ 0.114 E'_B	219 E'_Y + 16	224 P_B,R + 128
`V4L2_COLORSPACE_SMPTE240M`	2	1125-Line (US) HDTV, see SMPTE 240M	x = 0.630, y = 0.340	x = 0.310, y = 0.595	x = 0.155, y = 0.070	x = 0.3127, y = 0.3290, Illuminant D₆₅	E' = 4 I for I ≤0.0228,1.1115 I^0.45 - 0.1115 for 0.0228 < I	0.212 E'_R+ 0.701 E'_G+ 0.087 E'_B	219 E'_Y + 16	224 P_B,R + 128
`V4L2_COLORSPACE_REC709`	3	HDTV and modern devices, see ITU BT.709	x = 0.640, y = 0.330	x = 0.300, y = 0.600	x = 0.150, y = 0.060	x = 0.3127, y = 0.3290, Illuminant D₆₅	E' = 4.5 I for I ≤0.018,1.099 I^0.45 - 0.099 for 0.018 < I	0.2125 E'_R+ 0.7154 E'_G+ 0.0721 E'_B	219 E'_Y + 16	224 P_B,R + 128
`V4L2_COLORSPACE_BT878`	4	Broken Bt878 extents[b],ITU BT.601	?	?	?	?	?	0.299 E'_R+ 0.587 E'_G+ 0.114 E'_B	237 E'_Y + 16	224 P_B,R + 128 (probably)
`V4L2_COLORSPACE_470_SYSTEM_M`	5	M/NTSC[c] according toITU BT.470,ITU BT.601	x = 0.67, y = 0.33	x = 0.21, y = 0.71	x = 0.14, y = 0.08	x = 0.310, y = 0.316, Illuminant C	?	0.299 E'_R+ 0.587 E'_G+ 0.114 E'_B	219 E'_Y + 16	224 P_B,R + 128
`V4L2_COLORSPACE_470_SYSTEM_BG`	6	625-line PAL and SECAM systems according toITU BT.470, ITU BT.601	x = 0.64, y = 0.33	x = 0.29, y = 0.60	x = 0.15, y = 0.06	x = 0.313, y = 0.329,Illuminant D₆₅	?	0.299 E'_R+ 0.587 E'_G+ 0.114 E'_B	219 E'_Y + 16	224 P_B,R + 128
`V4L2_COLORSPACE_JPEG`	7	JPEG Y'CbCr, see JFIF,ITU BT.601	?	?	?	?	?	0.299 E'_R+ 0.587 E'_G+ 0.114 E'_B	256 E'_Y + 16[d]	256 P_B,R + 128
`V4L2_COLORSPACE_SRGB`	8	[?]	x = 0.640, y = 0.330	x = 0.300, y = 0.600	x = 0.150, y = 0.060	x = 0.3127, y = 0.3290, Illuminant D₆₅	E' = 4.5 I for I ≤0.018,1.099 I^0.45 - 0.099 for 0.018 < I	n/a
Notes: a. The coordinates of the color primaries aregiven in the CIE system (1931) b. The ubiquitous Bt878 video capture chipquantizes E'_Y to 238 levels, yielding a rangeof Y' = 16 … 253, unlike Rec. 601 Y' = 16 …235. This is not a typo in the Bt878 documentation, it has beenimplemented in silicon. The chroma extents are unclear. c. No identifier exists for M/PAL which usesthe chromaticities of M/NTSC, the remaining parameters are equal to B andG/PAL. d. Note JFIF quantizesY'P_BP_R in range [0;+1] and[-0.5;+0.5] to257 levels, however Y'CbCr signalsare still clamped to [0;255].

Identifier	Code		Byte 0
		Bit	7	6	5	4	3	2	1	0
`V4L2_PIX_FMT_PAL8`	'PAL8'		i₇	i₆	i₅	i₄	i₃	i₂	i₁	i₀

Identifier	Code		Byte 0 in memory								Byte 1								Byte 2								Byte 3
		Bit	7	6	5	4	3	2	1	0	7	6	5	4	3	2	1	0	7	6	5	4	3	2	1	0	7	6	5	4	3	2	1	0
`V4L2_PIX_FMT_RGB332`	'RGB1'		b₁	b₀	g₂	g₁	g₀	r₂	r₁	r₀
`V4L2_PIX_FMT_RGB444`	'R444'		g₃	g₂	g₁	g₀	b₃	b₂	b₁	b₀	a₃	a₂	a₁	a₀	r₃	r₂	r₁	r₀
`V4L2_PIX_FMT_RGB555`	'RGBO'		g₂	g₁	g₀	r₄	r₃	r₂	r₁	r₀	a	b₄	b₃	b₂	b₁	b₀	g₄	g₃
`V4L2_PIX_FMT_RGB565`	'RGBP'		g₂	g₁	g₀	r₄	r₃	r₂	r₁	r₀	b₄	b₃	b₂	b₁	b₀	g₅	g₄	g₃
`V4L2_PIX_FMT_RGB555X`	'RGBQ'		a	b₄	b₃	b₂	b₁	b₀	g₄	g₃	g₂	g₁	g₀	r₄	r₃	r₂	r₁	r₀
`V4L2_PIX_FMT_RGB565X`	'RGBR'		b₄	b₃	b₂	b₁	b₀	g₅	g₄	g₃	g₂	g₁	g₀	r₄	r₃	r₂	r₁	r₀
`V4L2_PIX_FMT_BGR24`	'BGR3'		b₇	b₆	b₅	b₄	b₃	b₂	b₁	b₀	g₇	g₆	g₅	g₄	g₃	g₂	g₁	g₀	r₇	r₆	r₅	r₄	r₃	r₂	r₁	r₀
`V4L2_PIX_FMT_RGB24`	'RGB3'		r₇	r₆	r₅	r₄	r₃	r₂	r₁	r₀	g₇	g₆	g₅	g₄	g₃	g₂	g₁	g₀	b₇	b₆	b₅	b₄	b₃	b₂	b₁	b₀
`V4L2_PIX_FMT_BGR32`	'BGR4'		b₇	b₆	b₅	b₄	b₃	b₂	b₁	b₀	g₇	g₆	g₅	g₄	g₃	g₂	g₁	g₀	r₇	r₆	r₅	r₄	r₃	r₂	r₁	r₀	a₇	a₆	a₅	a₄	a₃	a₂	a₁	a₀
`V4L2_PIX_FMT_RGB32`	'RGB4'		r₇	r₆	r₅	r₄	r₃	r₂	r₁	r₀	g₇	g₆	g₅	g₄	g₃	g₂	g₁	g₀	b₇	b₆	b₅	b₄	b₃	b₂	b₁	b₀	a₇	a₆	a₅	a₄	a₃	a₂	a₁	a₀

start + 0:	B₀₀	G₀₁	B₀₂	G₀₃
start + 4:	G₁₀	R₁₁	G₁₂	R₁₃
start + 8:	B₂₀	G₂₁	B₂₂	G₂₃
start + 12:	G₃₀	R₃₁	G₃₂	R₃₃

start + 0:	B_00low	B_00high	G_01low	G_01high	B_02low	B_02high	G_03low	G_03high
start + 8:	G_10low	G_10high	R_11low	R_11high	G_12low	G_12high	R_13low	R_13high
start + 16:	B_20low	B_20high	G_21low	G_21high	B_22low	B_22high	G_23low	G_23high
start + 24:	G_30low	G_30high	R_31low	R_31high	G_32low	G_32high	R_33low	R_33high

Identifier	Code		Byte 0 in memory								Byte 1								Byte 2								Byte 3
		Bit	7	6	5	4	3	2	1	0	7	6	5	4	3	2	1	0	7	6	5	4	3	2	1	0	7	6	5	4	3	2	1	0
`V4L2_PIX_FMT_YUV444`	'Y444'		Cb₃	Cb₂	Cb₁	Cb₀	Cr₃	Cr₂	Cr₁	Cr₀	a₃	a₂	a₁	a₀	Y'₃	Y'₂	Y'₁	Y'₀
`V4L2_PIX_FMT_YUV555`	'YUVO'		Cb₂	Cb₁	Cb₀	Cr₄	Cr₃	Cr₂	Cr₁	Cr₀	a	Y'₄	Y'₃	Y'₂	Y'₁	Y'₀	Cb₄	Cb₃
`V4L2_PIX_FMT_YUV565`	'YUVP'		Cb₂	Cb₁	Cb₀	Cr₄	Cr₃	Cr₂	Cr₁	Cr₀	Y'₄	Y'₃	Y'₂	Y'₁	Y'₀	Cb₅	Cb₄	Cb₃
`V4L2_PIX_FMT_YUV32`	'YUV4'		a₇	a₆	a₅	a₄	a₃	a₂	a₁	a₀	Y'₇	Y'₆	Y'₅	Y'₄	Y'₃	Y'₂	Y'₁	Y'₀	Cb₇	Cb₆	Cb₅	Cb₄	Cb₃	Cb₂	Cb₁	Cb₀	Cr₇	Cr₆	Cr₅	Cr₄	Cr₃	Cr₂	Cr₁	Cr₀

start + 0:	Y'₀₀	Y'₀₁	Y'₀₂	Y'₀₃
start + 4:	Y'₁₀	Y'₁₁	Y'₁₂	Y'₁₃
start + 8:	Y'₂₀	Y'₂₁	Y'₂₂	Y'₂₃
start + 12:	Y'₃₀	Y'₃₁	Y'₃₂	Y'₃₃

start + 0:	Y'_00low	Y'_00high	Y'_01low	Y'_01high	Y'_02low	Y'_02high	Y'_03low	Y'_03high
start + 8:	Y'_10low	Y'_10high	Y'_11low	Y'_11high	Y'_12low	Y'_12high	Y'_13low	Y'_13high
start + 16:	Y'_20low	Y'_20high	Y'_21low	Y'_21high	Y'_22low	Y'_22high	Y'_23low	Y'_23high
start + 24:	Y'_30low	Y'_30high	Y'_31low	Y'_31high	Y'_32low	Y'_32high	Y'_33low	Y'_33high

start + 0:	Y'₀₀	Cb₀₀	Y'₀₁	Cr₀₀	Y'₀₂	Cb₀₁	Y'₀₃	Cr₀₁
start + 8:	Y'₁₀	Cb₁₀	Y'₁₁	Cr₁₀	Y'₁₂	Cb₁₁	Y'₁₃	Cr₁₁
start + 16:	Y'₂₀	Cb₂₀	Y'₂₁	Cr₂₀	Y'₂₂	Cb₂₁	Y'₂₃	Cr₂₁
start + 24:	Y'₃₀	Cb₃₀	Y'₃₁	Cr₃₀	Y'₃₂	Cb₃₁	Y'₃₃	Cr₃₁

Identifier	Code	Details
`V4L2_PIX_FMT_JPEG`	'JPEG'	TBD. See also `VIDIOC_G_JPEGCOMP`, `VIDIOC_S_JPEGCOMP`.
`V4L2_PIX_FMT_MPEG`	'MPEG'	MPEG stream. The actual format is determined byextended control `V4L2_CID_MPEG_STREAM_TYPE`, seeTable 1-2.

Identifier	Code	Details
`V4L2_PIX_FMT_DV`	'dvsd'	unknown
`V4L2_PIX_FMT_ET61X251`	'E625'	Compressed format of the ET61X251 driver.
`V4L2_PIX_FMT_HI240`	'HI24'	8 bit RGB format used by the BTTV driver,http://bytesex.org/bttv/
`V4L2_PIX_FMT_HM12`	'HM12'	YUV 4:2:0 format used by theIVTV driver,http://www.ivtvdriver.org/ The format is documented in thekernel sources in the file`Documentation/video4linux/cx2341x/README.hm12`
`V4L2_PIX_FMT_MJPEG`	'MJPG'	Compressed format used by the Zoran driver
`V4L2_PIX_FMT_PWC1`	'PWC1'	Compressed format of the PWC driver.
`V4L2_PIX_FMT_PWC2`	'PWC2'	Compressed format of the PWC driver.
`V4L2_PIX_FMT_SN9C10X`	'S910'	Compressed format of the SN9C102 driver.
`V4L2_PIX_FMT_WNVA`	'WNVA'	Used by the Winnov Videum driver,http://www.thedirks.org/winnov/
`V4L2_PIX_FMT_YYUV`	'YYUV'	unknown

__u32	`index`		Number of the buffer, set by the application. Thisfield is only used for memory mappingI/Oand can range from zero to the number of buffers allocatedwith the`VIDIOC_REQBUFS` ioctl (struct v4l2_requestbuffers`count`) minus one.
enum v4l2_buf_type	`type`		Type of the buffer, same as struct v4l2_format`type` or struct v4l2_requestbuffers`type`, set by the application.
__u32	`bytesused`		The number of bytes occupied by the data in thebuffer. It depends on the negotiated data format and may change witheach buffer for compressed variable size data like JPEG images.Drivers must set this field when`type`refers to an input stream, applications when an output stream.
__u32	`flags`		Flags set by the application or driver, seeTable 3-3.
enum v4l2_field	`field`		Indicates the field order of the image in thebuffer, see Table 3-8. This field is not used whenthe buffer contains VBI data. Drivers must set it when`type` refers to an input stream,applications when an output stream.
struct timeval	`timestamp`		For input streams this is thesystem time (as returned by the `gettimeofday()`function) when the first data byte was captured. For output streamsthe data will not be displayed before this time, secondary to thenominal frame rate determined by the current video standard inenqueued order. Applications can for example zero this field todisplay frames as soon as possible. The driver stores the time atwhich the first data byte was actually sent out in the`timestamp` field. This permitsapplications to monitor the drift between the video and systemclock.
struct v4l2_timecode	`timecode`		When `type` is`V4L2_BUF_TYPE_VIDEO_CAPTURE`and the`V4L2_BUF_FLAG_TIMECODE` flag is set in`flags`, this structure contains a frametimecode. InV4L2_FIELD_ALTERNATEmode the top and bottom field contain the same timecode.Timecodes are intended to help video editing and are typically recorded onvideo tapes, but also embedded in compressed formats like MPEG. Thisfield is independent of the `timestamp` and`sequence`fields.
__u32	`sequence`		Set by the driver, counting the frames in thesequence.
In V4L2_FIELD_ALTERNATE mode the top andbottom field have the same sequence number. The count starts at zeroand includes dropped or repeated frames. A dropped frame was receivedby an input device but could not be stored due to lack of free bufferspace. A repeated frame was displayed again by an output devicebecause the application did not pass new data intime. Note this may count the frames receivede.g. over USB, without taking into account the frames dropped by theremote hardware due to limited compression throughput or busbandwidth. These devices identify by not enumerating any videostandards, seeSection 1.7.
enum v4l2_memory	`memory`		This field must be set by applications and/or driversin accordance with the selected I/O method.
union	`m`
	__u32	`offset`	When `memory` is`V4L2_MEMORY_MMAP` this is the offset of the bufferfrom the start of the device memory. The value is returned by thedriver and apart of serving as parameter to the`mmap()` functionnot useful for applications. SeeSection 3.2 for details.
	unsigned long	`userptr`	When `memory` is`V4L2_MEMORY_USERPTR` this is a pointer to thebuffer (casted to unsigned long type) in virtual memory, set by theapplication. SeeSection 3.3 for details.
__u32	`length`		Size of the buffer (not the payload) in bytes.
__u32	`input`		Some video capture drivers support rapid andsynchronous video input changes, a function useful for example invideo surveillance applications. For this purpose applications set the`V4L2_BUF_FLAG_INPUT` flag, and this field to thenumber of a video input as in struct v4l2_input field`index`.
__u32	`reserved`		A place holder for future extensions and custom(driver defined) buffer types`V4L2_BUF_TYPE_PRIVATE` and higher.

`V4L2_BUF_TYPE_VIDEO_CAPTURE`	1	Buffer of a video capture stream, see Section 4.1.
`V4L2_BUF_TYPE_VIDEO_OUTPUT`	2	Buffer of a video output stream, see Section 4.3.
`V4L2_BUF_TYPE_VIDEO_OVERLAY`	3	Buffer for video overlay, see Section 4.2.
`V4L2_BUF_TYPE_VBI_CAPTURE`	4	Buffer of a raw VBI capture stream, see Section 4.7.
`V4L2_BUF_TYPE_VBI_OUTPUT`	5	Buffer of a raw VBI output stream, see Section 4.7.
`V4L2_BUF_TYPE_SLICED_VBI_CAPTURE`	6	Buffer of a sliced VBI capture stream, see Section 4.8.
`V4L2_BUF_TYPE_SLICED_VBI_OUTPUT`	7	Buffer of a sliced VBI output stream, see Section 4.8.
`V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY`	8	Buffer for video output overlay (OSD), see Section 4.4. Status: Experimental.
`V4L2_BUF_TYPE_PRIVATE`	0x80	This and higher values are reserved for custom(driver defined) buffer types.

`V4L2_BUF_FLAG_MAPPED`	0x0001	The buffer resides in device memory and has been mappedinto the application's address space, seeSection 3.2 for details.Drivers set or clear this flag when theVIDIOC_QUERYBUF,VIDIOC_QBUForVIDIOC_DQBUF ioctl is called. Set by the driver.
`V4L2_BUF_FLAG_QUEUED`	0x0002	Internally drivers maintain two buffer queues, anincoming and outgoing queue. When this flag is set, the buffer iscurrently on the incoming queue. It automatically moves to theoutgoing queue after the buffer has been filled (capture devices) ordisplayed (output devices). Drivers set or clear this flag when the`VIDIOC_QUERYBUF` ioctl is called. After(successful) calling the`VIDIOC_QBUF`ioctl it isalways set and after`VIDIOC_DQBUF` alwayscleared.
`V4L2_BUF_FLAG_DONE`	0x0004	When this flag is set, the buffer is currently onthe outgoing queue, ready to be dequeued from the driver. Drivers setor clear this flag when the`VIDIOC_QUERYBUF`ioctlis called. After calling the`VIDIOC_QBUF` or`VIDIOC_DQBUF`it is always cleared. Of course abuffer cannot be on both queues at the same time, the`V4L2_BUF_FLAG_QUEUED`and`V4L2_BUF_FLAG_DONE` flag are mutually exclusive.They can be both cleared however, then the buffer is in "dequeued"state, in the application domain to say so.
`V4L2_BUF_FLAG_KEYFRAME`	0x0008	Drivers set or clear this flag when calling the`VIDIOC_DQBUF` ioctl. It may be set by videocapture devices when the buffer contains a compressed image which is akey frame (or field), i. e. can be decompressed on its own.
`V4L2_BUF_FLAG_PFRAME`	0x0010	Similar to `V4L2_BUF_FLAG_KEYFRAME`this flags predicted frames or fields which contain only differences to aprevious key frame.
`V4L2_BUF_FLAG_BFRAME`	0x0020	Similar to `V4L2_BUF_FLAG_PFRAME` this is a bidirectional predicted frame or field. [ooc tbd]
`V4L2_BUF_FLAG_TIMECODE`	0x0100	The `timecode` field is valid.Drivers set or clear this flag when the`VIDIOC_DQBUF`ioctl is called.
`V4L2_BUF_FLAG_INPUT`	0x0200	The `input` field is valid.Applications set or clear this flag before calling the`VIDIOC_QBUF` ioctl.

`V4L2_MEMORY_MMAP`	1	The buffer is used for memorymapping I/O.
`V4L2_MEMORY_USERPTR`	2	The buffer is used for userpointer I/O.
`V4L2_MEMORY_OVERLAY`	3	[to do]

__u32	`type`	Frame rate the timecodes are based on, see Table 3-6.
__u32	`flags`	Timecode flags, see Table 3-7.
__u8	`frames`	Frame count, 0 ... 23/24/29/49/59, depending on the type of timecode.
__u8	`seconds`	Seconds count, 0 ... 59. This is a binary, not BCD number.
__u8	`minutes`	Minutes count, 0 ... 59. This is a binary, not BCD number.
__u8	`hours`	Hours count, 0 ... 29. This is a binary, not BCD number.
__u8	`userbits`[4]	The "user group" bits from the timecode.

`V4L2_TC_TYPE_24FPS`	1	24 frames per second, i. e. film.
`V4L2_TC_TYPE_25FPS`	2	25 frames per second, i. e. PAL or SECAM video.
`V4L2_TC_TYPE_30FPS`	3	30 frames per second, i. e. NTSC video.
`V4L2_TC_TYPE_50FPS`	4
`V4L2_TC_TYPE_60FPS`	5

`V4L2_TC_FLAG_DROPFRAME`	0x0001	Indicates "drop frame" semantics for counting framesin 29.97 fps material. When set, frame numbers 0 and 1 at the start ofeach minute, except minutes 0, 10, 20, 30, 40, 50 are omitted from thecount.
`V4L2_TC_FLAG_COLORFRAME`	0x0002	The "color frame" flag.
`V4L2_TC_USERBITS_field`	0x000C	Field mask for the "binary group flags".
`V4L2_TC_USERBITS_USERDEFINED`	0x0000	Unspecified format.
`V4L2_TC_USERBITS_8BITCHARS`	0x0008	8-bit ISO characters.

`V4L2_FIELD_ANY`	0	Applications request this field order when anyone of the`V4L2_FIELD_NONE`,`V4L2_FIELD_TOP`,`V4L2_FIELD_BOTTOM`, or`V4L2_FIELD_INTERLACED` formats is acceptable.Drivers choose depending on hardware capabilities or e. g. therequested image size, and return the actual field order. struct v4l2_buffer`field` can never be`V4L2_FIELD_ANY`.
`V4L2_FIELD_NONE`	1	Images are in progressive format, not interlaced.The driver may also indicate this order when it cannot distinguishbetween`V4L2_FIELD_TOP`and`V4L2_FIELD_BOTTOM`.
`V4L2_FIELD_TOP`	2	Images consist of the top field only.
`V4L2_FIELD_BOTTOM`	3	Images consist of the bottom field only.Applications may wish to prevent a device from capturing interlacedimages because they will have "comb" or "feathering" artefacts aroundmoving objects.
`V4L2_FIELD_INTERLACED`	4	Images contain both fields, interleaved line byline. The temporal order of the fields (whether the top or bottomfield is first transmitted) depends on the current video standard.M/NTSC transmits the bottom field first, all other standards the topfield first.
`V4L2_FIELD_SEQ_TB`	5	Images contain both fields, the top field linesare stored first in memory, immediately followed by the bottom fieldlines. Fields are always stored in temporal order, the older one firstin memory. Image sizes refer to the frame, not fields.
`V4L2_FIELD_SEQ_BT`	6	Images contain both fields, the bottom fieldlines are stored first in memory, immediately followed by the topfield lines. Fields are always stored in temporal order, the older onefirst in memory. Image sizes refer to the frame, not fields.
`V4L2_FIELD_ALTERNATE`	7	The two fields of a frame are passed in separatebuffers, in temporal order, i. e. the older one first. To indicate the fieldparity (whether the current field is a top or bottom field) the driveror application, depending on data direction, must set struct v4l2_buffer`field`to`V4L2_FIELD_TOP` or`V4L2_FIELD_BOTTOM`. Any two successive fields pairto build a frame. If fields are successive, without any dropped fieldsbetween them (fields can drop individually), can be determined fromthe struct v4l2_buffer`sequence` field. Imagesizes refer to the frame, not fields. This format cannot be selectedwhen using the read/write I/O method.
`V4L2_FIELD_INTERLACED_TB`	8	Images contain both fields, interleaved line byline, top field first. The top field is transmitted first.
`V4L2_FIELD_INTERLACED_BT`	9	Images contain both fields, interleaved line byline, top field first. The bottom field is transmitted first.

struct v4l2_rect	`w`	Size and position of the window relative to thetop, left corner of the frame buffer defined with`VIDIOC_S_FBUF`. Thewindow can extend the frame buffer width and height, the`x` and`y`coordinates can be negative, and it can lie completely outside theframe buffer. The driver clips the window accordingly, or if that isnot possible, modifies its size and/or position.
enum v4l2_field	`field`	Applications set this field to determine whichvideo field shall be overlaid, typically one of`V4L2_FIELD_ANY`(0),`V4L2_FIELD_TOP`,`V4L2_FIELD_BOTTOM`or`V4L2_FIELD_INTERLACED`. Drivers may have to choosea different field order and return the actual setting here.
__u32	`chromakey`	When chroma-keying has been negotiated with`VIDIOC_S_FBUF` applications set this field to the desired pixel valuefor the chroma key. The format is the same as the pixel format of theframebuffer (struct v4l2_framebuffer`fmt.pixelformat` field), with bytes in hostorder. E. g. for`V4L2_PIX_FMT_BGR24` the value should be 0xRRGGBB on a little endian, 0xBBGGRR on a bigendian host.
struct v4l2_clip *	`clips`	When chroma-keying has notbeen negotiated and`VIDIOC_G_FBUF` indicated this capability,applications can set this field to point to an array ofclipping rectangles.
Like the window coordinates`w`, clipping rectangles are defined relativeto the top, left corner of the frame buffer. However clippingrectangles must not extend the frame buffer width and height, and theymust not overlap. If possible applications should merge adjacentrectangles. Whether this must create x-y or y-x bands, or the order ofrectangles, is not defined. When clip lists are not supported thedriver ignores this field. Its contents after calling`VIDIOC_S_FMT`are undefined.
__u32	`clipcount`	When the application set the`clips` field, this field must contain thenumber of clipping rectangles in the list. When clip lists are notsupported the driver ignores this field, its contents after calling`VIDIOC_S_FMT` are undefined. When clip lists aresupported but no clipping is desired this field must be set tozero.
void *	`bitmap`	When chroma-keying hasnot been negotiated and`VIDIOC_G_FBUF` indicatedthis capability, applications can set this field to point to aclipping bit mask.
It must be of the same sizeas the window, `w.width` and`w.height`. Each bit corresponds to a pixelin the overlaid image, which is displayed only when the bit isset. Pixel coordinates translate to bits like: ((__u8 ) `bitmap`)[`w.width` y + x / 8] & (1 << (x & 7)) where `0` ≤ x <`w.width` and`0` ≤y <`w.height`.^a When a clippingbit mask is not supported the driver ignores this field, its contentsafter calling`VIDIOC_S_FMT` are undefined. When a bit mask is supportedbut no clipping is desired this field must be set to`NULL`. Applications need not create aclip list or bit mask. When they pass both, or despite negotiatingchroma-keying, the results are undefined. Regardless of the chosenmethod, the clipping abilities of the hardware may be limited inquantity or quality. The results when these limits are exceeded areundefined.^b
__u8	`global_alpha`	The global alpha value used to blend theframebuffer with video images, if global alpha blending has beennegotiated (`V4L2_FBUF_FLAG_GLOBAL_ALPHA`, see`VIDIOC_S_FBUF`,Table 3). Notethis field was added in Linux 2.6.23, extending the structure. Howeverthe VIDIOC_G/S/TRY_FMTioctls,which take a pointer to a v4l2_format parent structure with paddingbytes at the end, are not affected.
Notes: a. Should we require `w.width` to be a multiple of eight? b. When the image is written into frame buffermemory it will be undesirable if the driver clips out less pixelsthan expected, because the application and graphics system are notaware these regions need to be refreshed. The driver should clip outmore pixels or not write the image at all.

struct v4l2_rect	`c`	Coordinates of the clipping rectangle, relative tothe top, left corner of the frame buffer. Only window pixelsoutsideall clipping rectangles aredisplayed.
struct v4l2_clip *	`next`	Pointer to the next clipping rectangle, NULL whenthis is the last rectangle. Drivers ignore this field, it cannot beused to pass a linked list of clipping rectangles.

__s32	`left`	Horizontal offset of the top, left corner of therectangle, in pixels.
__s32	`top`	Vertical offset of the top, left corner of therectangle, in pixels. Offsets increase to the right and down.
__s32	`width`	Width of the rectangle, in pixels.
__s32	`height`	Height of the rectangle, in pixels. Width andheight cannot be negative, the fields are signed for hystericalreasons.

__u32	`sampling_rate`	Samples per second, i. e. unit 1 Hz.
__u32	`offset`	Horizontal offset of the VBI image,relative to the leading edge of the line synchronization pulse andcounted in samples: The first sample in the VBI image will be located`offset` /`sampling_rate` seconds following the leadingedge. See also Figure 4-1.
__u32	`samples_per_line`
__u32	`sample_format`	Defines the sample format as in Chapter 2, a four-character-code.^a Usually this is`V4L2_PIX_FMT_GREY`, i. e. each sampleconsists of 8 bits with lower values oriented towards the black level.Do not assume any other correlation of values with the signal level.For example, the MSB does not necessarily indicate if the signal is'high' or 'low' because 128 may not be the mean value of thesignal. Drivers shall not convert the sample format by software.
__u32	`start`[2]	This is the scanning system line numberassociated with the first line of the VBI image, of the first and thesecond field respectively. SeeFigure 4-2 andFigure 4-3 for valid values. VBI input drivers canreturn start values 0 if the hardware cannot reliable identifyscanning lines, VBI acquisition may not require thisinformation.
__u32	`count`[2]	The number of lines in the first and secondfield image, respectively.
Drivers should be asflexibility as possible. For example, it may be possible to extend ormove the VBI capture window down to the picture area, implementing a'full field mode' to capture data service transmissions embedded inthe picture. An application can set the first or second`count` value to zero if no data is requiredfrom the respective field;`count`[1] if thescanning system is progressive, i. e. not interlaced. Thecorresponding start value shall be ignored by the application anddriver. Anyway, drivers may not support single field capturing andreturn both count values non-zero. Both`count` values set to zero, or line numbersoutside the bounds depicted inFigure 4-2 andFigure 4-3, or a field image coveringlines of two fields, are invalid and shall not be returned by thedriver. To initialize the `start`and `count` fields, applications must firstdetermine the current video standard selection. Thev4l2_std_id orthe`framelines` field of struct v4l2_standard canbe evaluated for this purpose.
__u32	`flags`	See Table 4-5 below. Currentlyonly drivers set flags, applications must set this field tozero.
__u32	`reserved`[2]	This array is reserved for future extensions.Drivers and applications must set it to zero.
Notes: a. A few devices may be unable tosample VBI data at all but can extend the video capture window to theVBI region.

V4L2 API Specification

Revision 0.24

Michael H Schimek

Bill Dirks

Hans Verkuil

Martin Rubli

Introduction

Chapter 1. Common API Elements

Chapter 2. Image Formats

Packed RGB formats

Name

Description

V4L2_PIX_FMT_SBGGR8 ('BA81')

Name

Description

V4L2_PIX_FMT_SBGGR16 ('BA82')

Name

Description

Packed YUV formats

Name

Description

V4L2_PIX_FMT_GREY ('GREY')

Name

Description

V4L2_PIX_FMT_Y16 ('Y16 ')

Name

Description

V4L2_PIX_FMT_YUYV ('YUYV')

Name

Description

V4L2_PIX_FMT_UYVY ('UYVY')

Name

Description

V4L2_PIX_FMT_Y41P ('Y41P')

Name

Description

V4L2_PIX_FMT_YVU420 ('YV12'), V4L2_PIX_FMT_YUV420 ('YU12')

Name

Description

V4L2_PIX_FMT_YVU410 ('YVU9'), V4L2_PIX_FMT_YUV410 ('YUV9')

Name

Description

V4L2_PIX_FMT_YUV422P ('422P')

Name

Description

V4L2_PIX_FMT_YUV411P ('411P')

Name

Description

V4L2_PIX_FMT_NV12 ('NV12'), V4L2_PIX_FMT_NV21 ('NV21')

Name

Description

Chapter 3. Input/Output

Chapter 4. Interfaces

I. Function Reference

V4L2 close()

Name

Synopsis

Arguments

Description

Return Value

V4L2 ioctl()

`V4L2_VBI_UNSYNC`	0x0001	This flag indicates hardware which does notproperly distinguish between fields. Normally the VBI image stores thefirst field (lower scanning line numbers) first in memory. This may bea top or bottom field depending on the video standard. When this flagis set the first or second field may be stored first, however thefields are still in correct temporal order with the older field firstin memory.^a
`V4L2_VBI_INTERLACED`	0x0002	By default the two field images will be passedsequentially; all lines of the first field followed by all lines ofthe second field (compareSection 3.6`V4L2_FIELD_SEQ_TB` and`V4L2_FIELD_SEQ_BT`, whether the top or bottomfield is first in memory depends on the video standard). When thisflag is set, the two fields are interlaced (cf.`V4L2_FIELD_INTERLACED`). The first line of thefirst field followed by the first line of the second field, then thetwo second lines, and so on. Such a layout may be necessary when thehardware has been programmed to capture or output interlaced videoimages and is unable to separate the fields for VBI capturing atthe same time. For simplicity setting this flag implies that both`count` values are equal and non-zero.
Notes: a. Most VBI services transmit on both fields, butsome have different semantics depending on the field number. Thesecannot be reliable decoded or encoded when`V4L2_VBI_UNSYNC` is set.

__u32	`service_set`	If`service_set` is non-zero when passed with`VIDIOC_S_FMT`or`VIDIOC_TRY_FMT`, the`service_lines` array will be filled by thedriver according to the services specified in this field. For example,if`service_set` is initialized with`V4L2_SLICED_TELETEXT_B \| V4L2_SLICED_WSS_625`, adriver for the cx25840 video decoder sets lines 7-22 of bothfields^a to`V4L2_SLICED_TELETEXT_B`and line 23 of the first field to`V4L2_SLICED_WSS_625`. If`service_set` is set to zero, then the valuesof`service_lines` will be used instead. On return the driver sets this field to the union of allelements of the returned`service_lines`array. It may contain less services than requested, perhaps just one,if the hardware cannot handle more services simultaneously. It may beempty (zero) if none of the requested services are supported by thehardware.
__u16	`service_lines`[2][24]	Applications initialize thisarray with sets of data services the driver shall look for or inserton the respective scan line. Subject to hardware capabilities driversreturn the requested set, a subset, which may be just a singleservice, or an empty set. When the hardware cannot handle multipleservices on the same line the driver shall choose one. No assumptionscan be made on which service the driver chooses. Dataservices are defined in Table 4-7. Array indicesmap to ITU-R line numbers (see also Figure 4-2 and Figure 4-3) as follows:
		Element	525 line systems	625 line systems
		`service_lines`[0][1]	1	1
		`service_lines`[0][23]	23	23
		`service_lines`[1][1]	264	314
		`service_lines`[1][23]	286	336
		Drivers must set`service_lines`[0][0] and`service_lines`[1][0] to zero.
__u32	`io_size`	Maximum number of bytes passed byone `read()` or`write()` call, and the buffer size in bytes forthe`VIDIOC_QBUF` and`VIDIOC_DQBUF` ioctl. Drivers set this field tothe size of struct v4l2_sliced_vbi_data times the number of non-zeroelements in the returned`service_lines`array (that is the number of lines potentially carrying data).
__u32	`reserved`[2]	This array is reserved for futureextensions. Applications and drivers must set it to zero.
Notes: a. According to ETS 300 706 lines 6-22 of thefirst field and lines 5-22 of the second field may carry Teletextdata.

Symbol	Value	Reference	Lines, usually	Payload
`V4L2_SLICED_TELETEXT_B`(Teletext System B)	0x0001	ETS 300 706,ITU BT.653	PAL/SECAM line 7-22, 320-335 (second field 7-22)	Last 42 of the 45 byte Teletext packet, that iswithout clock run-in and framing code, lsb first transmitted.
`V4L2_SLICED_VPS`	0x0400	ETS 300 231	PAL line 16	Byte number 3 to 15 according to Figure 9 ofETS 300 231, lsb first transmitted.
`V4L2_SLICED_CAPTION_525`	0x1000	EIA 608-B	NTSC line 21, 284 (second field 21)	Two bytes in transmission order, including paritybit, lsb first transmitted.
`V4L2_SLICED_WSS_625`	0x4000	ITU BT.1119,EN 300 294	PAL/SECAM line 23	Byte 0 1 msb lsb msb lsb Bit 7 6 5 4 3 2 1 0 x x 13 12 11 10 9
`V4L2_SLICED_VBI_525`	0x1000	Set of services applicable to 525line systems.
`V4L2_SLICED_VBI_625`	0x4401	Set of services applicable to 625line systems.

__u32	`id`	A flag from Table 2identifying the type of data in this packet. Only a single bit must beset. When the`id` of a captured packet iszero, the packet is empty and the contents of other fields areundefined. Applications shall ignore empty packets. When the`id` of a packet for output is zero thecontents of the`data` field are undefinedand the driver must no longer insert data on the requested`field`and`line`.
__u32	`field`	The video field number this data has been capturedfrom, or shall be inserted at.`0` for the firstfield,`1` for the second field.
__u32	`line`	The field (as opposed to frame) line number thisdata has been captured from, or shall be inserted at. SeeFigure 4-2 andFigure 4-3 for validvalues. Sliced VBI capture devices can set the line number of allpackets to`0` if the hardware cannot reliablyidentify scan lines. The field number must always be valid.
__u32	`reserved`	This field is reserved for future extensions.Applications and drivers must set it to zero.
__u8	`data`[48]	The packet payload. See Table 2 for the contents and number ofbytes passed for each data type. The contents of padding bytes at theend of this array are undefined, drivers and applications shall ignorethem.

enum v4l2_buf_type	`type`	Type of the data stream, set by the application.Only these types are valid here:`V4L2_BUF_TYPE_VIDEO_CAPTURE`,`V4L2_BUF_TYPE_VIDEO_OUTPUT`,`V4L2_BUF_TYPE_VIDEO_OVERLAY`, and custom (driverdefined) types with code `V4L2_BUF_TYPE_PRIVATE`and higher.
struct v4l2_rect	`bounds`	Defines the window within capturing or output ispossible, this may exclude for example the horizontal and verticalblanking areas. The cropping rectangle cannot exceed these limits.Width and height are defined in pixels, the driver writer is free tochoose origin and units of the coordinate system in the analogdomain.
struct v4l2_rect	`defrect`	Default cropping rectangle, it shall cover the"whole picture". Assuming pixel aspect 1/1 this could be for example a640 × 480 rectangle for NTSC, a768 × 576 rectangle for PAL and SECAM centered overthe active picture area. The same co-ordinate system as for `bounds` is used.
struct v4l2_fract	`pixelaspect`	This is the pixel aspect (y / x) when noscaling is applied, the ratio of the actual samplingfrequency and the frequency required to get squarepixels. When cropping coordinates refer to square pixels,the driver sets `pixelaspect` to 1/1. Othercommon values are 54/59 for PAL and SECAM, 11/10 for NTSC sampledaccording to [ITU BT.601].

__u32	`match_type`	See Table 2 for a list of possible types.
__u32	`match_chip`	Match a chip by this number, interpreted accordingto the`match_type` field.
__u64	`reg`	A register number.
__u64	`val`	The value read from, or to be written into theregister.

`V4L2_CHIP_MATCH_HOST`	0	Match the nth chip on the card, zero for the host chip. Does not match I²C chips.
`V4L2_CHIP_MATCH_I2C_DRIVER`	1	Match an I²C chip by its driver ID from the`linux/i2c-id.h`header file.
`V4L2_CHIP_MATCH_I2C_ADDR`	2	Match a chip by its 7 bit I²C bus address.

__u32	`cmd`	The encoder command, see Table 2.
__u32	`flags`	Flags to go with the command, see Table 3. If no flags are defined forthis command, drivers and applications must set this field tozero.
__u32	`data`[8]	Reserved for future extensions. Drivers andapplications must set the array to zero.

`V4L2_ENC_CMD_START`	0	Start the encoder. When the encoder is alreadyrunning or paused, this command does nothing. No flags are defined forthis command.
`V4L2_ENC_CMD_STOP`	1	Stop the encoder. When the`V4L2_ENC_CMD_STOP_AT_GOP_END` flag is set,encoding will continue until the end of the currentGroupOf Pictures, otherwise encoding will stop immediately.When the encoder is already stopped, this command doesnothing.
`V4L2_ENC_CMD_PAUSE`	2	Pause the encoder. When the encoder has not beenstarted yet, the driver will return anEPERM error code. When the encoder isalready paused, this command does nothing. No flags are defined forthis command.
`V4L2_ENC_CMD_RESUME`	3	Resume encoding after a PAUSE command. When theencoder has not been started yet, the driver will return anEPERM error code.When the encoder is already running, this command does nothing. Noflags are defined for this command.

__u32	`index`	Number of the format in the enumeration, set bythe application. This is in no way related to the`pixelformat` field.
enum v4l2_buf_type	`type`	Type of the data stream, set by the application.Only these types are valid here:`V4L2_BUF_TYPE_VIDEO_CAPTURE`,`V4L2_BUF_TYPE_VIDEO_OUTPUT`,`V4L2_BUF_TYPE_VIDEO_OVERLAY`, and custom (driverdefined) types with code `V4L2_BUF_TYPE_PRIVATE`and higher.
__u32	`flags`	See Table 2
__u8	`description`[32]	Description of the format, a NUL-terminated ASCIIstring. This information is intended for the user, for example: "YUV4:2:2".
__u32	`pixelformat`	The image format identifier. This is afour character code as computed by the v4l2_fourcc()macro:
#define v4l2_fourcc(a,b,c,d) (((__u32)(a)<<0)\|((__u32)(b)<<8)\|((__u32)(c)<<16)\|((__u32)(d)<<24)) Several image formats are alreadydefined by this specification in Chapter 2. Note thesecodes are not the same as those used in the Windows world.
__u32	`reserved`[4]	Reserved for future extensions. Drivers must setthe array to zero.