Hi *,
Michael Schimek currently reviews the v4l2 API documentation and due
to this we recently talked/emailed about some details of the v4l2 api.
We came to the conclusion that it there are good reasons to do some
incompatible changes before submitting v4l2 to the standard kernel:
(1) some quirks from v4l1 still present in v4l2.
(2) some recent changes within the kernel.
The major changes we are thinking about are:
* open() handling.
The recent changes in videodev.c provide a sane way for drivers to
support multiple opens. This allows to take a completely different
approach for using the different functions of a video card: Instead
of having multiple devices (video, vbi, ...) there is only one which
can be opened multiple times and switched to different modes.
Example: to capture vbi data you will simply open /dev/video<n> and
switch the device into vbi mode using the S_FMT ioctl with
v4l2_format->type set to V4L2_BUF_TYPE_VBI_CAPTURE.
This approach removes the need to figure somehow which devices are
related, because all functions of the card can be used using the same
special file. It also allows adding other formats without major
pain (sliced vbi, rds, audio?, ...).
/dev/vbi will still be there for backward compatibility, but it will
be basically the same as /dev/video, just with vbi mode turned on by
default.
This change reqires v4l2_capability being updated, because devices
can support both video and vbi capture now, thus the current type
approach doesn't cut it.
* new field handling, the current v4l2 spec a bit confusing about
this. There is now:
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_SEQUENTIAL = 5, /* both fields sequential into one
buffer */
V4L2_FIELD_ALTERNATE = 6, /* both fields alternating into
separate buffers */
};
Both v4l2_pix_format and v4l2_buffer have this, for v4l2_pix_format
this field is r/w, for v4l2_buffer it is read-only (for the
application).
Because the stuff above implies we will be source and binary
incompatible anyway I've also did a number of other cleanups as well:
* drop open flags
obsolete
* drop all effect stuff
That was planned anyway. Nobody uses it (yet). And I suspect nobody
ever will. Processors become faster, and special hardware is more
expencive + less flexible.
what about the video output stuff btw. Does anybody use that?
* drop mmap v4l1 compat flags
obsolete
* drop v4l2_q_* helper functions
we have <linux/list.h>
* drop zoom stuff
use crop_* instead (whilch needs some review + exact specification)
* drop struct v4l2_performance + ioctl
Applications have to do that themself anyway to keep a/v in sync.
And because the ioctl is optional and thus apps can't depend on it
being present it is even more useless.
* drop VIDIOC_*_FREQ ioctls
There is VIDIOC_*_FREQUENCY ...
* replace stamp_t with struct timeval, drop all time functions.
We'll simply use gettimeofday like everybody else.
* struct v4l2_capability
- drop inputs, outputs, audios (use enum ioctls for these ...)
- drop maxframerate (not really useful here, depends on tv norm).
- replace type + flags with capabilities (see above).
* struct v4l2_pix_format
- drop depth, flags (field changes mentioned above.
depth is redundant, pixelformat implies this.)
- add fields
* struct v4l2_fmtdesc
- drop depth, flags
* struct v4l2_buffer
- add field
* struct v4l2_framebuffer
- one base ptr only (nobody ever used the other two).
* renamed preview => overlay
* v4l2_inout/output
- replace assoc_audio with audioset
- drop capability
* struct v4l2_queryctrl
- drop category, group
There are still some items which are on my / Michaels TODO list. Stuff
which needs some discussion and/or can be added to the API later:
* v4l2_framebuffer
It would be better to pass the (pci) device somehow instead of some
physical address for pci-pci xfer overlay. Not sure how to do that
through, there seems to be no standard struct (yet?) to pass that
kind of info between kernel and userland ...
* The crop/scaling thing needs some work, Michael is busy with that.
* more elements for v4l2_format: rds + maybe sound comes to mind.
* The min/max sizes in v4l2_capabilities are somewhat ugly, maybe
we should move that to another ioctl. First problem is that they
might depend on some device parameters (tv norm, maybe some speed vs.
quality option on usb cams). Second problem is that the size might
be different for overlay and capture (some matrox guys have this
problem IIRC).
* exact read() behaviour needs to be specified (for video + vbi):
- read partial frames: drivers are allowed and/or required to
implement that?
- should read() use a buffer queue? Yes / no / configure via
v4l2_captureparm? A queue has the advantage that you can
do full-rate capture using read() because the driver doesn't
need to start/stop capture for every read() call. The drawback is
that the driver must buffer+copy the video data and can't attempt
to do zerocopy DMA. It may also happen that applications which
capture frames in large intervalls receive old data.
* kernel 2.5.x has async I/O support. I think it would be a good
idea to support aio for video frames in v4l2 drivers. Applications
can queue multiple read requests. This is IMHO a better solution
than configuring the read() queuing behaviour with an ioctl. The
ioctl is somewhat ugly, and the aio way allows zerocopy DMA.
Comments? Anything else we should change?
Gerd
PS: below is the current status of the updated videodev2 header file.
==============================[ cut here ]==============================
#ifndef __LINUX_VIDEODEV2_H
#define __LINUX_VIDEODEV2_H
/*
* Video for Linux Two
*
* Header file for v4l or V4L2 drivers and applications, for
* Linux kernels 2.2.x or 2.4.x.
*
* See http://www.thedirks.org/v4l2/ for API specs and other
* v4l2 documentation.
*
* Author: Bill Dirks <bdirks@xxxxxxxxxxx>
* Justin Schoeman
* et al.
*/
#define V4L2_MAJOR_VERSION 0
#define V4L2_MINOR_VERSION 20
/*
* 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))
/*
* D R I V E R C A P A B I L I T I E S
*/
struct v4l2_capability
{
char name[32]; /* Descriptive, and unique */
int capabilities; /* Device capabilities */
#if 1
/* FIXME: move to other ioctl along the lines
"want size foo, give me the closest the hardware can do please"? */
int maxwidth;
int maxheight;
int minwidth;
int minheight;
#endif
__u32 flags; /* Feature flags, see below */
__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 VBI capture device */
#define V4L2_CAP_VBI_OUTPUT 0x00000020 /* Is a VBI output device */
#define V4L2_CAP_RDS_CAPTURE 0x00000100 /* RDS data capture */
#define V4L2_CAP_TUNER 0x00010000 /* Has a tuner */
/*
* V I D E O I M A G E F O R M A T
*/
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_SEQUENTIAL = 5, /* both fields sequential into one
buffer */
V4L2_FIELD_ALTERNATE = 6, /* both fields alternating into
separate buffers */
};
struct v4l2_pix_format
{
__u32 width;
__u32 height;
__u32 pixelformat;
enum v4l2_field field;
__u32 bytesperline; /* for padding, zero if unused */
__u32 sizeimage;
#if 0
/* FIXME: specify ITU-R 601, ... here ??? */
__u32 colorspace;
#endif
__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_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_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 */
/* 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 */
/* compressed formats */
#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M','J','P','G') /* Motion-JPEG */
/* Vendor-specific formats */
#define V4L2_PIX_FMT_WNVA v4l2_fourcc('W','N','V','A') /* Winnov hw compres */
/*
* F O R M A T E N U M E R A T I O N
*/
struct v4l2_fmtdesc
{
int index; /* Format number */
char description[32]; /* Description string */
__u32 pixelformat; /* Format fourcc */
__u32 reserved[2];
};
/*
* T I M E C O D E
*/
struct v4l2_timecode
{
__u8 frames;
__u8 seconds;
__u8 minutes;
__u8 hours;
__u8 userbits[4];
__u32 flags;
__u32 type;
};
/* 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 */
/*
* C O M P R E S S I O N P A R A M E T E R S
*/
#if 0
/* ### generic compression settings don't work, there is too much
* ### codec-specific stuff. Maybe reuse that for MPEG codec settings
* ### later ... */
struct v4l2_compression
{
int quality;
int keyframerate;
int pframerate;
__u32 reserved[5];
};
#endif
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
{
int count;
__u32 type;
__u32 reserved[2];
};
struct v4l2_buffer
{
int index;
__u32 type;
__u32 offset;
__u32 length;
__u32 bytesused;
__u32 flags;
enum v4l2_field field;
struct timeval timestamp;
struct v4l2_timecode timecode;
__u32 sequence;
__u32 reserved[3];
};
/* Buffer type codes and flags for 'type' field */
#define V4L2_BUF_TYPE_field 0x00001FFF /* Type field mask */
#define V4L2_BUF_TYPE_VIDEO_CAPTURE 0x00000001
#define V4L2_BUF_TYPE_VIDEO_OUTPUT 0x00000002
#define V4L2_BUF_TYPE_VBI_CAPTURE 0x00000010
/* Starting value of driver private buffer types */
#define V4L2_BUF_TYPE_PRIVATE 0x00001000
/* 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 */
/*
* 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
/* Flags for the 'flags' field. */
#define V4L2_FBUF_FLAG_PRIMARY 0x0001
#define V4L2_FBUF_FLAG_OVERLAY 0x0002
#define V4L2_FBUF_FLAG_CHROMAKEY 0x0004
struct v4l2_clip
{
int x;
int y;
int width;
int height;
struct v4l2_clip *next;
};
struct v4l2_window
{
int x;
int y;
int width;
int height;
__u32 chromakey;
struct v4l2_clip *clips;
int clipcount;
void *bitmap;
};
/*
* 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 */
unsigned long 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 */
unsigned long timeperframe; /* Time per frame in .1us units */
__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
*/
#if 0
/* ### FIXME: to be reviewed in detail ... */
struct v4l2_cropcap
{
__u32 capability;
int min_x;
int min_y;
int max_x;
int max_y;
int default_left;
int default_top;
int default_right;
int default_bottom;
__u32 reserved[2];
};
struct v4l2_crop
{
int left;
int top;
int right;
int bottom;
__u32 reserved;
};
#endif
/*
* A N A L O G V I D E O S T A N D A R D
*/
enum v4l2_std_id {
/* FIXME: add separate ids for PAL-BG, PAL-DK, ... ??? */
V4L2_STD_PAL = 1, /* PAL B, G, H, I (...) */
V4L2_STD_PAL_M = 5, /* (Brazil) */
V4L2_STD_PAL_N = 6, /* (Argentina, Paraguay, Uruguay) */
V4L2_STD_PAL_60 = 10, /* PAL/NTSC hybrid */
V4L2_STD_NTSC = 11, /* NTSC M (USA, ...) */
V4L2_STD_NTSC_N = 12, /* (Barbados, Bolivia, Colombia, S. Korea) */
V4L2_STD_NTSC_44 = 15, /* PAL/NTSC hybrid */
V4L2_STD_SECAM = 21, /* SECAM B, D, G, K, K1 (...) */
};
struct v4l2_standard
{
enum v4l2_std_id id;
__u8 name[24];
struct {
__u32 numerator;
__u32 denominator; /* >= 1 */
} frameperiod; /* Frames, not fields */
__u32 framelines;
};
/* Used in the VIDIOC_ENUMSTD ioctl for querying supported standards */
struct v4l2_enumstd
{
int index;
struct v4l2_standard std;
__u32 inputs; /* set of inputs that */
/* support this standard */
__u32 outputs; /* set of outputs that */
/* support this standard */
__u32 reserved[2];
};
/*
* V I D E O I N P U T S
*/
struct v4l2_input
{
int index; /* Which input */
char name[32]; /* Label */
int type; /* Type of input */
int audioset; /* Associated audios (bitfield) */
__u32 reserved[4];
};
/* Values for the 'type' field */
#define V4L2_INPUT_TYPE_TUNER 1
#define V4L2_INPUT_TYPE_CAMERA 2
/*
* V I D E O O U T P U T S
*/
struct v4l2_output
{
int index; /* Which output */
char name[32]; /* Label */
int type; /* Type of output */
int audioset; /* Associated audios (bitfield) */
__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;
int value;
};
/* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
struct v4l2_queryctrl
{
__u32 id;
__u8 name[32]; /* Whatever */
int minimum; /* Note signedness */
int maximum;
unsigned int step;
int default_value;
__u32 flags;
__u32 type;
__u32 reserved[2];
};
/* Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
struct v4l2_querymenu
{
__u32 id;
int index;
__u8 name[32]; /* Whatever */
int reserved;
};
/* Used in V4L2_BUF_TYPE_FXCONTROL buffers */
struct v4l2_fxcontrol
{
__u32 id;
__u32 value;
};
/* Control types */
#define V4L2_CTRL_TYPE_INTEGER 0
#define V4L2_CTRL_TYPE_BOOLEAN 1
#define V4L2_CTRL_TYPE_MENU 2
#define V4L2_CTRL_TYPE_BUTTON 3
/* Control flags */
#define V4L2_CTRL_FLAG_DISABLED 0x0001
#define V4L2_CTRL_FLAG_GRABBED 0x0002
/* Control IDs defined by V4L2 */
#define V4L2_CID_BASE 0x00980900
/* IDs reserved for driver specific controls */
#define V4L2_CID_PRIVATE_BASE 0x08000000
#if 0
/* ### in use ??? */
/* IDs reserved for effect-specific controls on effects devices */
#define V4L2_CID_EFFECT_BASE 0x0A00B000
#endif
#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)
#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) /* ? Not sure */
#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)
#define V4L2_CID_HCENTER (V4L2_CID_BASE+22)
#define V4L2_CID_VCENTER (V4L2_CID_BASE+23)
#define V4L2_CID_LASTP1 (V4L2_CID_BASE+24) /* last CID + 1 */
/*
* T U N I N G
*/
struct v4l2_tuner
{
int tuner;
char name[32];
enum v4l2_std_id std;
__u32 capability;
__u32 rangelow;
__u32 rangehigh;
__u32 rxsubchans;
__u32 audmode;
int signal;
int afc;
__u32 reserved[4];
};
struct v4l2_modulator
{
int output;
char name[32];
enum v4l2_std_id std;
__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
struct v4l2_frequency
{
int tuner;
/* ### FIXME #1: add mode flag here? tv vs. radio, ... */
/* ### FIXME #2: add stuff for analog SAT here ? */
__u32 frequency;
__u32 reserved[2];
};
/*
* A U D I O
*/
struct v4l2_audio
{
int audio;
char name[32];
__u32 capability;
__u32 mode;
__u32 reserved[2];
};
/* Flags for the 'capability' field */
#define V4L2_AUDCAP_EFFECTS 0x0020
#define V4L2_AUDCAP_LOUDNESS 0x0040
#define V4L2_AUDCAP_AVL 0x0080
/* Flags for the 'mode' field */
#define V4L2_AUDMODE_LOUDNESS 0x00002
#define V4L2_AUDMODE_AVL 0x00004
#define V4L2_AUDMODE_STEREO_field 0x0FF00
#define V4L2_AUDMODE_STEREO_LINEAR 0x00100
#define V4L2_AUDMODE_STEREO_PSEUDO 0x00200
#define V4L2_AUDMODE_STEREO_SPATIAL30 0x00300
#define V4L2_AUDMODE_STEREO_SPATIAL50 0x00400
struct v4l2_audioout
{
int audio;
char name[32];
__u32 capability;
__u32 mode;
__u32 reserved[2];
};
/*
* D A T A S E R V I C E S ( V B I )
*
* Data services API by Michael Schimek
*/
struct v4l2_vbi_format
{
__u32 sampling_rate; /* in 1 Hz */
__u32 offset;
__u32 samples_per_line;
__u32 sample_format; /* V4L2_VBI_SF_* */
__s32 start[2];
__u32 count[2];
__u32 flags; /* V4L2_VBI_* */
__u32 reserved2; /* must be zero */
};
/* VBI flags */
#define V4L2_VBI_UNSYNC (1<< 0)
#define V4L2_VBI_INTERLACED (1<< 1)
/*
* 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
{
__u32 type;
union
{
struct v4l2_pix_format pix; /* image format */
struct v4l2_vbi_format vbi; /* VBI data */
__u8 raw_data[200]; /* user-defined */
} fmt;
};
/* Stream type-dependent parameters
*/
struct v4l2_streamparm
{
__u32 type;
union
{
struct v4l2_captureparm capture;
struct v4l2_outputparm output;
__u8 raw_data[200]; /* user-defined */
} parm;
};
/*
* 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_PIXFMT _IOWR ('V', 2, struct v4l2_fmtdesc)
#define VIDIOC_ENUM_FBUFFMT _IOWR ('V', 3, 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_G_COMP _IOR ('V', 6, struct v4l2_compression)
#define VIDIOC_S_COMP _IOW ('V', 7, struct v4l2_compression)
#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_G_WIN _IOR ('V', 12, struct v4l2_window)
#define VIDIOC_S_WIN _IOW ('V', 13, struct v4l2_window)
#define VIDIOC_OVERLAY _IOWR ('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 _IOW ('V', 22, struct v4l2_streamparm)
#define VIDIOC_G_STD _IOR ('V', 23, struct v4l2_standard)
#define VIDIOC_S_STD _IOW ('V', 24, struct v4l2_standard)
#define VIDIOC_ENUMSTD _IOWR ('V', 25, struct v4l2_enumstd)
#define VIDIOC_ENUMINPUT _IOWR ('V', 26, struct v4l2_input)
#define VIDIOC_G_CTRL _IOWR ('V', 27, struct v4l2_control)
#define VIDIOC_S_CTRL _IOW ('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 _IOWR ('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 _IOWR ('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)
#if 0
/* ### to be reviewed ... */
#define VIDIOC_CROPCAP _IOR ('V', 58, struct v4l2_cropcap)
#define VIDIOC_G_CROP _IOR ('V', 59, struct v4l2_crop)
#define VIDIOC_S_CROP _IOW ('V', 60, struct v4l2_crop)
#endif
#define VIDIOC_G_JPEGCOMP _IOR ('V', 61, struct v4l2_jpegcompression)
#define VIDIOC_S_JPEGCOMP _IOW ('V', 62, struct v4l2_jpegcompression)
#define VIDIOC_ENUM_CAPFMT VIDIOC_ENUM_PIXFMT
#define VIDIOC_ENUM_OUTFMT VIDIOC_ENUM_PIXFMT
#define VIDIOC_ENUM_SRCFMT VIDIOC_ENUM_PIXFMT
#define VIDIOC_ENUMFMT VIDIOC_ENUM_PIXFMT
#define BASE_VIDIOC_PRIVATE 192 /* 192-255 are private */
#ifdef __KERNEL__
/*
*
* V 4 L 2 D R I V E R H E L P E R A P I
*
* Some commonly needed functions for drivers (v4l2-common.o module)
*/
#include <linux/fs.h>
/* Video standard functions */
extern unsigned int v4l2_video_std_fps(struct v4l2_standard *vs);
extern unsigned long v4l2_video_std_tpf(struct v4l2_standard *vs);
extern int v4l2_video_std_construct(struct v4l2_standard *vs,
int id, __u32 transmission);
/* Compatibility layer interface */
typedef int (*v4l2_kioctl)(struct inode *inode, struct file *file,
unsigned int cmd, void *arg);
int v4l_compat_translate_ioctl(struct inode *inode, struct file *file,
int cmd, void *arg, v4l2_kioctl driver_ioctl);
#endif /* __KERNEL__ */
#endif /* __LINUX_VIDEODEV2_H */
/*
* Local variables:
* c-basic-offset: 8
* End:
*/
