Video for Linux Two API Specification

offending device

/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

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 black level.
`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 also provide an OSS or ALSA mixer interface.
`V4L2_CID_AUDIO_BALANCE`	integer	Audio stereo balance. Minimum corresponds to all the 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, however without affecting `V4L2_CID_AUDIO_VOLUME`. Like ALSA drivers, V4L2 drivers must mute at load time to avoid excessive noise. Actually the entire device should be reset to a low power consumption 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 deprecated and 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 is ignored), the device will do a white balance and then hold the current setting. Contrast this with the boolean `V4L2_CID_AUTO_WHITE_BALANCE`, which, when activated, 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 synonym for `V4L2_CID_GAMMA`. This control is deprecated and 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 is deprecated. New drivers and applications should use the Camera 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 to physically adjust cameras. For image cropping see Section 1.11, for clipping Section 4.2. This control is deprecated. New drivers and applications should use the Camera 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 avoid flicker. 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. The effect of setting `V4L2_CID_HUE` while automatic hue control is enabled is undefined, drivers should ignore such request.
`V4L2_CID_WHITE_BALANCE_TEMPERATURE`	integer	This control specifies the white balance settings as a color temperature in Kelvin. A driver should have a minimum of 2800 (incandescent) to 6500 (daylight). For more information about color temperature see Wikipedia.
`V4L2_CID_SHARPNESS`	integer	Adjusts the sharpness filters in a camera. The minimum value disables the filters, higher values give a sharper picture.
`V4L2_CID_BACKLIGHT_COMPENSATION`	integer	Adjusts the backlight compensation in a camera. The minimum 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 the driver name and version, see Section 1.2.

Video for Linux Two API Specification

Revision 0.24

Michael H Schimek

Bill Dirks

Hans Verkuil

Martin Rubli

Introduction

Chapter 1. Common API Elements

1.1. Opening and Closing Devices

1.1.1. Device Naming

1.1.2. Related Devices

1.1.3. Multiple Opens

1.1.4. Shared Data Streams

1.1.5. Functions

1.2. Querying Capabilities

1.3. Application Priority

1.4. Video Inputs and Outputs

1.5. Audio Inputs and Outputs

1.6. Tuners and Modulators

1.6.1. Tuners

1.6.2. Modulators

1.6.3. Radio Frequency

1.6.4. Satellite Receivers

1.7. Video Standards

1.8. User Controls

1.9. Extended Controls

1.9.1. Introduction

1.9.2. The Extended Control API

1.9.3. Enumerating Extended Controls

1.9.4. Creating Control Panels

1.9.5. MPEG Control Reference

1.9.5.1. Generic MPEG Controls

1.9.5.2. CX2341x MPEG Controls

1.9.6. Camera Control Reference

1.10. Data Formats

1.10.1. Data Format Negotiation

1.10.2. Image Format Enumeration

1.11. Image Cropping, Insertion and Scaling

1.11.1. Cropping Structures

1.11.2. Scaling Adjustments