Chinaunix首页 | 论坛 | 博客
  • 博客访问: 446769
  • 博文数量: 1958
  • 博客积分: 44693
  • 博客等级: 大将
  • 技术积分: 22125
  • 用 户 组: 普通用户
  • 注册时间: 2011-01-29 15:19
文章分类

全部博文(1958)

文章存档

2012年(560)

2011年(1398)

分类:

2011-09-09 17:21:39

V4L2 ioctl()
Namev4l2-ioctl -- Program a V4L2 device
Synopsis

#include

int ioctl(int fd, int request, void *argp);

Arguments

fd

File descriptor returned by open().

request

V4L2 ioctl request code as defined in the videodev.h header file, for example VIDIOC_QUERYCAP.

argp

Pointer to a function parameter, usually a structure.

Description

The ioctl() function is used to program V4L2 devices. The argument fd must be an open file descriptor. An ioctl request has encoded in it whether the argument is an input, output or read/write parameter, and the size of the argument argp in bytes. Macros and defines specifying V4L2 ioctl requests are located in the videodev.h header file. Applications should use their own copy, not include the version in the kernel sources on the system they compile on. All V4L2 ioctl requests, their respective function and parameters are specified in Reference I, Function Reference.

Return Value

On success the ioctl() function returns 0 成功,返回0 and does not reset the errno variable. On failure -1 is returned, when the ioctl takes an output or read/write parameter it remains unmodified, and the errno variable is set appropriately. See below for possible error codes. Generic errors like EBADF or EFAULT are not listed in the sections discussing individual ioctl requests.

Note ioctls may return undefined error codes. Since errors may have side effects such as a driver reset applications should abort on unexpected errors.

EBADF

fd is not a valid open file descriptor.

EBUSY

The property cannot be changed right now. Typically this error code is returned when I/O is in progress or the driver supports multiple opens and another process locked the property.

EFAULT

argp references an inaccessible memory area.

ENOTTY

fd is not associated with a character special device.

EINVAL

The request or the data pointed to by argp is not valid. This is a very common error code, see the individual ioctl requests listed in Reference I, Function Reference for actual causes.

ENOMEM

Not enough physical or virtual memory was available to complete the request.

ERANGE

The application attempted to set a control with the VIDIOC_S_CTRL ioctl to a value which is out of bounds.




http://v4l2spec.byte***.org/spec/a16506.htm

Appendix A. Video For Linux Two Header File
非常重要的头文件。

  1. Video for Linux Two API Specification: Revision 0.24
  2. Prev        Next
  3. Appendix A. Video For Linux Two Header File

  4. /*
  5.  * Video for Linux Two header file
  6.  *
  7.  * Copyright (C) 1999-2007 the contributors
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * Alternatively you can redistribute this file under the terms of the
  20.  * BSD license as stated below:
  21.  *
  22.  * Redistribution and use in source and binary forms, with or without
  23.  * modification, are permitted provided that the following conditions
  24.  * are met:
  25.  * 1. Redistributions of source code must retain the above copyright
  26.  * notice, this list of conditions and the following disclaimer.
  27.  * 2. Redistributions in binary form must reproduce the above copyright
  28.  * notice, this list of conditions and the following disclaimer in
  29.  * the documentation and/or other materials provided with the
  30.  * distribution.
  31.  * 3. The names of its contributors may not be used to endorse or promote
  32.  * products derived from this software without specific prior written
  33.  * permission.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  36.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  38.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  39.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  41.  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  42.  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  43.  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  44.  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  45.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46.  *
  47.  * Header file for v4l or V4L2 drivers and applications
  48.  * with public API.
  49.  * All kernel-specific stuff were moved to media/v4l2-dev.h, so
  50.  * no #if __KERNEL tests are allowed here
  51.  *
  52.  * See http://linuxtv.org for more info
  53.  *
  54.  * Author: Bill Dirks <bill@thedirks.org>
  55.  * Justin Schoeman
  56.  * Hans Verkuil <hverkuil@xs4all.nl>
  57.  * et al.
  58.  */
  59. #ifndef __LINUX_VIDEODEV2_H
  60. #define __LINUX_VIDEODEV2_H
  61. #ifdef __KERNEL__
  62. #include <linux/time.h> /* need struct timeval */
  63. #include <linux/compiler.h> /* need __user */
  64. #else
  65. #define __user
  66. #include <sys/time.h>
  67. #endif
  68. #include <linux/ioctl.h>
  69. #include <linux/types.h>

  70. /*
  71.  * Common stuff for both V4L1 and V4L2
  72.  * Moved from videodev.h
  73.  */
  74. #define VIDEO_MAX_FRAME 32

  75. #define VID_TYPE_CAPTURE 1 /* Can capture */
  76. #define VID_TYPE_TUNER 2 /* Can tune */
  77. #define VID_TYPE_TELETEXT 4 /* Does teletext */
  78. #define VID_TYPE_OVERLAY 8 /* Overlay onto frame buffer */
  79. #define VID_TYPE_CHROMAKEY 16 /* Overlay by chromakey */
  80. #define VID_TYPE_CLIPPING 32 /* Can clip */
  81. #define VID_TYPE_FRAMERAM 64 /* Uses the frame buffer memory */
  82. #define VID_TYPE_SCALES 128 /* Scalable */
  83. #define VID_TYPE_MONOCHROME 256 /* Monochrome only */
  84. #define VID_TYPE_SUBCAPTURE 512 /* Can capture subareas of the image */
  85. #define VID_TYPE_MPEG_DECODER 1024 /* Can decode MPEG streams */
  86. #define VID_TYPE_MPEG_ENCODER 2048 /* Can encode MPEG streams */
  87. #define VID_TYPE_MJPEG_DECODER 4096 /* Can decode MJPEG streams */
  88. #define VID_TYPE_MJPEG_ENCODER 8192 /* Can encode MJPEG streams */

  89. /*
  90.  * M I S C E L L A N E O U S
  91.  */

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

  95. /*
  96.  * E N U M S
  97.  */
  98. enum v4l2_field {
  99.         V4L2_FIELD_ANY = 0, /* driver can choose from none,
  100.                                          top, bottom, interlaced
  101.                                          depending on whatever it thinks
  102.                                          is approximate ... */
  103.         V4L2_FIELD_NONE = 1, /* this device has no fields ... */
  104.         V4L2_FIELD_TOP = 2, /* top field only */
  105.         V4L2_FIELD_BOTTOM = 3, /* bottom field only */
  106.         V4L2_FIELD_INTERLACED = 4, /* both fields interlaced */
  107.         V4L2_FIELD_SEQ_TB = 5, /* both fields sequential into one
  108.                                          buffer, top-bottom order */
  109.         V4L2_FIELD_SEQ_BT = 6, /* same as above + bottom-top order */
  110.         V4L2_FIELD_ALTERNATE = 7, /* both fields alternating into
  111.                                          separate buffers */
  112.         V4L2_FIELD_INTERLACED_TB = 8, /* both fields interlaced, top field
  113.                                          first and the top field is
  114.                                          transmitted first */
  115.         V4L2_FIELD_INTERLACED_BT = 9, /* both fields interlaced, top field
  116.                                          first and the bottom field is
  117.                                          transmitted first */
  118. };
  119. #define V4L2_FIELD_HAS_TOP(field) \
  120.         ((field) == V4L2_FIELD_TOP ||\
  121.          (field) == V4L2_FIELD_INTERLACED ||\
  122.          (field) == V4L2_FIELD_INTERLACED_TB ||\
  123.          (field) == V4L2_FIELD_INTERLACED_BT ||\
  124.          (field) == V4L2_FIELD_SEQ_TB ||\
  125.          (field) == V4L2_FIELD_SEQ_BT)
  126. #define V4L2_FIELD_HAS_BOTTOM(field) \
  127.         ((field) == V4L2_FIELD_BOTTOM ||\
  128.          (field) == V4L2_FIELD_INTERLACED ||\
  129.          (field) == V4L2_FIELD_INTERLACED_TB ||\
  130.          (field) == V4L2_FIELD_INTERLACED_BT ||\
  131.          (field) == V4L2_FIELD_SEQ_TB ||\
  132.          (field) == V4L2_FIELD_SEQ_BT)
  133. #define V4L2_FIELD_HAS_BOTH(field) \
  134.         ((field) == V4L2_FIELD_INTERLACED ||\
  135.          (field) == V4L2_FIELD_INTERLACED_TB ||\
  136.          (field) == V4L2_FIELD_INTERLACED_BT ||\
  137.          (field) == V4L2_FIELD_SEQ_TB ||\
  138.          (field) == V4L2_FIELD_SEQ_BT)

  139. enum v4l2_buf_type {
  140.         V4L2_BUF_TYPE_VIDEO_CAPTURE = 1,
  141.         V4L2_BUF_TYPE_VIDEO_OUTPUT = 2,
  142.         V4L2_BUF_TYPE_VIDEO_OVERLAY = 3,
  143.         V4L2_BUF_TYPE_VBI_CAPTURE = 4,
  144.         V4L2_BUF_TYPE_VBI_OUTPUT = 5,
  145.         V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6,
  146.         V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7,
  147. #if 1 /*KEEP*/
  148.         /* Experimental */
  149.         V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
  150. #endif
  151.         V4L2_BUF_TYPE_PRIVATE = 0x80,
  152. };

  153. enum v4l2_ctrl_type {
  154.         V4L2_CTRL_TYPE_INTEGER = 1,
  155.         V4L2_CTRL_TYPE_BOOLEAN = 2,
  156.         V4L2_CTRL_TYPE_MENU = 3,
  157.         V4L2_CTRL_TYPE_BUTTON = 4,
  158.         V4L2_CTRL_TYPE_INTEGER64 = 5,
  159.         V4L2_CTRL_TYPE_CTRL_CLASS = 6,
  160. };

  161. enum v4l2_tuner_type {
  162.         V4L2_TUNER_RADIO = 1,
  163.         V4L2_TUNER_ANALOG_TV = 2,
  164.         V4L2_TUNER_DIGITAL_TV = 3,
  165. };

  166. enum v4l2_memory {
  167.         V4L2_MEMORY_MMAP = 1,
  168.         V4L2_MEMORY_USERPTR = 2,
  169.         V4L2_MEMORY_OVERLAY = 3,
  170. };

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

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

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

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

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

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

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

  192. enum v4l2_priority {
  193.         V4L2_PRIORITY_UNSET = 0, /* not initialized */
  194.         V4L2_PRIORITY_BACKGROUND = 1,
  195.         V4L2_PRIORITY_INTERACTIVE = 2,
  196.         V4L2_PRIORITY_RECORD = 3,
  197.         V4L2_PRIORITY_DEFAULT = V4L2_PRIORITY_INTERACTIVE,
  198. };

  199. struct v4l2_rect {
  200.         __s32 left;
  201.         __s32 top;
  202.         __s32 width;
  203.         __s32 height;
  204. };

  205. struct v4l2_fract {
  206.         __u32 numerator;
  207.         __u32 denominator;
  208. };

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

  221. /* Values for 'capabilities' field */
  222. #define V4L2_CAP_VIDEO_CAPTURE 0x00000001 /* Is a video capture device */
  223. #define V4L2_CAP_VIDEO_OUTPUT 0x00000002 /* Is a video output device */
  224. #define V4L2_CAP_VIDEO_OVERLAY 0x00000004 /* Can do video overlay */
  225. #define V4L2_CAP_VBI_CAPTURE 0x00000010 /* Is a raw VBI capture device */
  226. #define V4L2_CAP_VBI_OUTPUT 0x00000020 /* Is a raw VBI output device */
  227. #define V4L2_CAP_SLICED_VBI_CAPTURE 0x00000040 /* Is a sliced VBI capture device */
  228. #define V4L2_CAP_SLICED_VBI_OUTPUT 0x00000080 /* Is a sliced VBI output device */
  229. #define V4L2_CAP_RDS_CAPTURE 0x00000100 /* RDS data capture */
  230. #define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200 /* Can do video output overlay */

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

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

  237. /*
  238.  * V I D E O I M A G E F O R M A T
  239.  */
  240. struct v4l2_pix_format
  241. {
  242.         __u32 width;
  243.         __u32 height;
  244.         __u32 pixelformat;
  245.         enum v4l2_field field;
  246.         __u32 bytesperline; /* for padding, zero if unused */
  247.         __u32 sizeimage;
  248.         enum v4l2_colorspace colorspace;
  249.         __u32 priv; /* private data, depends on pixelformat */
  250. };

  251. /* Pixel format FOURCC depth Description */
  252. #define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R','G','B','1') /* 8 RGB-3-3-2 */
  253. #define V4L2_PIX_FMT_RGB444 v4l2_fourcc('R','4','4','4') /* 16 xxxxrrrr ggggbbbb */
  254. #define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R','G','B','O') /* 16 RGB-5-5-5 */
  255. #define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R','G','B','P') /* 16 RGB-5-6-5 */
  256. #define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R','G','B','Q') /* 16 RGB-5-5-5 BE */
  257. #define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R','G','B','R') /* 16 RGB-5-6-5 BE */
  258. #define V4L2_PIX_FMT_BGR24 v4l2_fourcc('B','G','R','3') /* 24 BGR-8-8-8 */
  259. #define V4L2_PIX_FMT_RGB24 v4l2_fourcc('R','G','B','3') /* 24 RGB-8-8-8 */
  260. #define V4L2_PIX_FMT_BGR32 v4l2_fourcc('B','G','R','4') /* 32 BGR-8-8-8-8 */
  261. #define V4L2_PIX_FMT_RGB32 v4l2_fourcc('R','G','B','4') /* 32 RGB-8-8-8-8 */
  262. #define V4L2_PIX_FMT_GREY v4l2_fourcc('G','R','E','Y') /* 8 Greyscale */
  263. #define V4L2_PIX_FMT_Y16 v4l2_fourcc('Y','1','6',' ') /* 16 Greyscale */
  264. #define V4L2_PIX_FMT_PAL8 v4l2_fourcc('P','A','L','8') /* 8 8-bit palette */
  265. #define V4L2_PIX_FMT_YVU410 v4l2_fourcc('Y','V','U','9') /* 9 YVU 4:1:0 */
  266. #define V4L2_PIX_FMT_YVU420 v4l2_fourcc('Y','V','1','2') /* 12 YVU 4:2:0 */
  267. #define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y','U','Y','V') /* 16 YUV 4:2:2 */
  268. #define V4L2_PIX_FMT_UYVY v4l2_fourcc('U','Y','V','Y') /* 16 YUV 4:2:2 */
  269. #define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4','2','2','P') /* 16 YVU422 planar */
  270. #define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4','1','1','P') /* 16 YVU411 planar */
  271. #define V4L2_PIX_FMT_Y41P v4l2_fourcc('Y','4','1','P') /* 12 YUV 4:1:1 */
  272. #define V4L2_PIX_FMT_YUV444 v4l2_fourcc('Y','4','4','4') /* 16 xxxxyyyy uuuuvvvv */
  273. #define V4L2_PIX_FMT_YUV555 v4l2_fourcc('Y','U','V','O') /* 16 YUV-5-5-5 */
  274. #define V4L2_PIX_FMT_YUV565 v4l2_fourcc('Y','U','V','P') /* 16 YUV-5-6-5 */
  275. #define V4L2_PIX_FMT_YUV32 v4l2_fourcc('Y','U','V','4') /* 32 YUV-8-8-8-8 */

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

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

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

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

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

  299. /*
  300.  * F O R M A T E N U M E R A T I O N
  301.  */
  302. struct v4l2_fmtdesc
  303. {
  304.         __u32 index; /* Format number */
  305.         enum v4l2_buf_type type; /* buffer type */
  306.         __u32 flags;
  307.         __u8 description[32]; /* Description string */
  308.         __u32 pixelformat; /* Format fourcc */
  309.         __u32 reserved[4];
  310. };

  311. #define V4L2_FMT_FLAG_COMPRESSED 0x0001

  312. #if 1 /*KEEP*/
  313.         /* Experimental Frame Size and frame rate enumeration */
  314. /*
  315.  * F R A M E S I Z E E N U M E R A T I O N
  316.  */
  317. enum v4l2_frmsizetypes
  318. {
  319.         V4L2_FRMSIZE_TYPE_DISCRETE = 1,
  320.         V4L2_FRMSIZE_TYPE_CONTINUOUS = 2,
  321.         V4L2_FRMSIZE_TYPE_STEPWISE = 3,
  322. };

  323. struct v4l2_frmsize_discrete
  324. {
  325.         __u32 width; /* Frame width [pixel] */
  326.         __u32 height; /* Frame height [pixel] */
  327. };

  328. struct v4l2_frmsize_stepwise
  329. {
  330.         __u32 min_width; /* Minimum frame width [pixel] */
  331.         __u32 max_width; /* Maximum frame width [pixel] */
  332.         __u32 step_width; /* Frame width step size [pixel] */
  333.         __u32 min_height; /* Minimum frame height [pixel] */
  334.         __u32 max_height; /* Maximum frame height [pixel] */
  335.         __u32 step_height; /* Frame height step size [pixel] */
  336. };

  337. struct v4l2_frmsizeenum
  338. {
  339.         __u32 index; /* Frame size number */
  340.         __u32 pixel_format; /* Pixel format */
  341.         __u32 type; /* Frame size type the device supports. */

  342.         union { /* Frame size */
  343.                 struct v4l2_frmsize_discrete discrete;
  344.                 struct v4l2_frmsize_stepwise stepwise;
  345.         };

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

  348. /*
  349.  * F R A M E R A T E E N U M E R A T I O N
  350.  */
  351. enum v4l2_frmivaltypes
  352. {
  353.         V4L2_FRMIVAL_TYPE_DISCRETE = 1,
  354.         V4L2_FRMIVAL_TYPE_CONTINUOUS = 2,
  355.         V4L2_FRMIVAL_TYPE_STEPWISE = 3,
  356. };

  357. struct v4l2_frmival_stepwise
  358. {
  359.         struct v4l2_fract min; /* Minimum frame interval [s] */
  360.         struct v4l2_fract max; /* Maximum frame interval [s] */
  361.         struct v4l2_fract step; /* Frame interval step size [s] */
  362. };

  363. struct v4l2_frmivalenum
  364. {
  365.         __u32 index; /* Frame format index */
  366.         __u32 pixel_format; /* Pixel format */
  367.         __u32 width; /* Frame width */
  368.         __u32 height; /* Frame height */
  369.         __u32 type; /* Frame interval type the device supports. */

  370.         union { /* Frame interval */
  371.                 struct v4l2_fract discrete;
  372.                 struct v4l2_frmival_stepwise stepwise;
  373.         };

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

  377. /*
  378.  * T I M E C O D E
  379.  */
  380. struct v4l2_timecode
  381. {
  382.         __u32 type;
  383.         __u32 flags;
  384.         __u8 frames;
  385.         __u8 seconds;
  386.         __u8 minutes;
  387.         __u8 hours;
  388.         __u8 userbits[4];
  389. };

  390. /* Type */
  391. #define V4L2_TC_TYPE_24FPS 1
  392. #define V4L2_TC_TYPE_25FPS 2
  393. #define V4L2_TC_TYPE_30FPS 3
  394. #define V4L2_TC_TYPE_50FPS 4
  395. #define V4L2_TC_TYPE_60FPS 5

  396. /* Flags */
  397. #define V4L2_TC_FLAG_DROPFRAME 0x0001 /* "drop-frame" mode */
  398. #define V4L2_TC_FLAG_COLORFRAME 0x0002
  399. #define V4L2_TC_USERBITS_field 0x000C
  400. #define V4L2_TC_USERBITS_USERDEFINED 0x0000
  401. #define V4L2_TC_USERBITS_8BITCHARS 0x0008
  402. /* The above is based on SMPTE timecodes */

  403. struct v4l2_jpegcompression
  404. {
  405.         int quality;

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

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

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

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

  428. /*
  429.  * M E M O R Y - M A P P I N G B U F F E R S
  430.  */
  431. struct v4l2_requestbuffers
  432. {
  433.         __u32 count;
  434.         enum v4l2_buf_type type;
  435.         enum v4l2_memory memory;
  436.         __u32 reserved[2];
  437. };

  438. struct v4l2_buffer
  439. {
  440.         __u32 index;
  441.         enum v4l2_buf_type type;
  442.         __u32 bytesused;
  443.         __u32 flags;
  444.         enum v4l2_field field;
  445.         struct timeval timestamp;
  446.         struct v4l2_timecode timecode;
  447.         __u32 sequence;

  448.         /* memory location */
  449.         enum v4l2_memory memory;
  450.         union {
  451.                 __u32 offset;
  452.                 unsigned long userptr;
  453.         } m;
  454.         __u32 length;
  455.         __u32 input;
  456.         __u32 reserved;
  457. };

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

  467. /*
  468.  * O V E R L A Y P R E V I E W
  469.  */
  470. struct v4l2_framebuffer
  471. {
  472.         __u32 capability;
  473.         __u32 flags;
  474. /* FIXME: in theory we should pass something like PCI device + memory
  475.  * region + offset instead of some physical address */
  476.         void* base;
  477.         struct v4l2_pix_format fmt;
  478. };
  479. /* Flags for the 'capability' field. Read only */
  480. #define V4L2_FBUF_CAP_EXTERNOVERLAY 0x0001
  481. #define V4L2_FBUF_CAP_CHROMAKEY 0x0002
  482. #define V4L2_FBUF_CAP_LIST_CLIPPING 0x0004
  483. #define V4L2_FBUF_CAP_BITMAP_CLIPPING 0x0008
  484. #define V4L2_FBUF_CAP_LOCAL_ALPHA 0x0010
  485. #define V4L2_FBUF_CAP_GLOBAL_ALPHA 0x0020
  486. #define V4L2_FBUF_CAP_LOCAL_INV_ALPHA 0x0040
  487. /* Flags for the 'flags' field. */
  488. #define V4L2_FBUF_FLAG_PRIMARY 0x0001
  489. #define V4L2_FBUF_FLAG_OVERLAY 0x0002
  490. #define V4L2_FBUF_FLAG_CHROMAKEY 0x0004
  491. #define V4L2_FBUF_FLAG_LOCAL_ALPHA 0x0008
  492. #define V4L2_FBUF_FLAG_GLOBAL_ALPHA 0x0010
  493. #define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA 0x0020

  494. struct v4l2_clip
  495. {
  496.         struct v4l2_rect c;
  497.         struct v4l2_clip __user *next;
  498. };

  499. struct v4l2_window
  500. {
  501.         struct v4l2_rect w;
  502.         enum v4l2_field field;
  503.         __u32 chromakey;
  504.         struct v4l2_clip __user *clips;
  505.         __u32 clipcount;
  506.         void __user *bitmap;
  507.         __u8 global_alpha;
  508. };

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

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

  524. struct v4l2_outputparm
  525. {
  526.         __u32 capability; /* Supported modes */
  527.         __u32 outputmode; /* Current mode */
  528.         struct v4l2_fract timeperframe; /* Time per frame in seconds */
  529.         __u32 extendedmode; /* Driver-specific extensions */
  530.         __u32 writebuffers; /* # of buffers for write */
  531.         __u32 reserved[4];
  532. };

  533. /*
  534.  * I N P U T I M A G E C R O P P I N G
  535.  */
  536. struct v4l2_cropcap {
  537.         enum v4l2_buf_type type;
  538.         struct v4l2_rect bounds;
  539.         struct v4l2_rect defrect;
  540.         struct v4l2_fract pixelaspect;
  541. };

  542. struct v4l2_crop {
  543.         enum v4l2_buf_type type;
  544.         struct v4l2_rect c;
  545. };

  546. /*
  547.  * A N A L O G V I D E O S T A N D A R D
  548.  */

  549. typedef __u64 v4l2_std_id;

  550. /* one bit for each */
  551. #define V4L2_STD_PAL_B ((v4l2_std_id)0x00000001)
  552. #define V4L2_STD_PAL_B1 ((v4l2_std_id)0x00000002)
  553. #define V4L2_STD_PAL_G ((v4l2_std_id)0x00000004)
  554. #define V4L2_STD_PAL_H ((v4l2_std_id)0x00000008)
  555. #define V4L2_STD_PAL_I ((v4l2_std_id)0x00000010)
  556. #define V4L2_STD_PAL_D ((v4l2_std_id)0x00000020)
  557. #define V4L2_STD_PAL_D1 ((v4l2_std_id)0x00000040)
  558. #define V4L2_STD_PAL_K ((v4l2_std_id)0x00000080)

  559. #define V4L2_STD_PAL_M ((v4l2_std_id)0x00000100)
  560. #define V4L2_STD_PAL_N ((v4l2_std_id)0x00000200)
  561. #define V4L2_STD_PAL_Nc ((v4l2_std_id)0x00000400)
  562. #define V4L2_STD_PAL_60 ((v4l2_std_id)0x00000800)

  563. #define V4L2_STD_NTSC_M ((v4l2_std_id)0x00001000)
  564. #define V4L2_STD_NTSC_M_JP ((v4l2_std_id)0x00002000)
  565. #define V4L2_STD_NTSC_443 ((v4l2_std_id)0x00004000)
  566. #define V4L2_STD_NTSC_M_KR ((v4l2_std_id)0x00008000)

  567. #define V4L2_STD_SECAM_B ((v4l2_std_id)0x00010000)
  568. #define V4L2_STD_SECAM_D ((v4l2_std_id)0x00020000)
  569. #define V4L2_STD_SECAM_G ((v4l2_std_id)0x00040000)
  570. #define V4L2_STD_SECAM_H ((v4l2_std_id)0x00080000)
  571. #define V4L2_STD_SECAM_K ((v4l2_std_id)0x00100000)
  572. #define V4L2_STD_SECAM_K1 ((v4l2_std_id)0x00200000)
  573. #define V4L2_STD_SECAM_L ((v4l2_std_id)0x00400000)
  574. #define V4L2_STD_SECAM_LC ((v4l2_std_id)0x00800000)

  575. /* ATSC/HDTV */
  576. #define V4L2_STD_ATSC_8_VSB ((v4l2_std_id)0x01000000)
  577. #define V4L2_STD_ATSC_16_VSB ((v4l2_std_id)0x02000000)

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

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

  591. /* some common needed stuff */
  592. #define V4L2_STD_PAL_BG (V4L2_STD_PAL_B |\
  593.                                  V4L2_STD_PAL_B1 |\
  594.                                  V4L2_STD_PAL_G)
  595. #define V4L2_STD_PAL_DK (V4L2_STD_PAL_D |\
  596.                                  V4L2_STD_PAL_D1 |\
  597.                                  V4L2_STD_PAL_K)
  598. #define V4L2_STD_PAL (V4L2_STD_PAL_BG |\
  599.                                  V4L2_STD_PAL_DK |\
  600.                                  V4L2_STD_PAL_H |\
  601.                                  V4L2_STD_PAL_I)
  602. #define V4L2_STD_NTSC (V4L2_STD_NTSC_M |\
  603.                                  V4L2_STD_NTSC_M_JP |\
  604.                                  V4L2_STD_NTSC_M_KR)
  605. #define V4L2_STD_SECAM_DK (V4L2_STD_SECAM_D |\
  606.                                  V4L2_STD_SECAM_K |\
  607.                                  V4L2_STD_SECAM_K1)
  608. #define V4L2_STD_SECAM (V4L2_STD_SECAM_B |\
  609.                                  V4L2_STD_SECAM_G |\
  610.                                  V4L2_STD_SECAM_H |\
  611.                                  V4L2_STD_SECAM_DK |\
  612.                                  V4L2_STD_SECAM_L |\
  613.                                  V4L2_STD_SECAM_LC)

  614. #define V4L2_STD_525_60 (V4L2_STD_PAL_M |\
  615.                                  V4L2_STD_PAL_60 |\
  616.                                  V4L2_STD_NTSC |\
  617.                                  V4L2_STD_NTSC_443)
  618. #define V4L2_STD_625_50 (V4L2_STD_PAL |\
  619.                                  V4L2_STD_PAL_N |\
  620.                                  V4L2_STD_PAL_Nc |\
  621.                                  V4L2_STD_SECAM)
  622. #define V4L2_STD_ATSC (V4L2_STD_ATSC_8_VSB |\
  623.                                  V4L2_STD_ATSC_16_VSB)

  624. #define V4L2_STD_UNKNOWN 0
  625. #define V4L2_STD_ALL (V4L2_STD_525_60 |\
  626.                                  V4L2_STD_625_50)

  627. struct v4l2_standard
  628. {
  629.         __u32 index;
  630.         v4l2_std_id id;
  631.         __u8 name[24];
  632.         struct v4l2_fract frameperiod; /* Frames, not fields */
  633.         __u32 framelines;
  634.         __u32 reserved[4];
  635. };

  636. /*
  637.  * V I D E O I N P U T S
  638.  */
  639. struct v4l2_input
  640. {
  641.         __u32 index; /* Which input */
  642.         __u8 name[32]; /* Label */
  643.         __u32 type; /* Type of input */
  644.         __u32 audioset; /* Associated audios (bitfield) */
  645.         __u32 tuner; /* Associated tuner */
  646.         v4l2_std_id std;
  647.         __u32 status;
  648.         __u32 reserved[4];
  649. };

  650. /* Values for the 'type' field */
  651. #define V4L2_INPUT_TYPE_TUNER 1
  652. #define V4L2_INPUT_TYPE_CAMERA 2

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

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

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

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

  668. /*
  669.  * V I D E O O U T P U T S
  670.  */
  671. struct v4l2_output
  672. {
  673.         __u32 index; /* Which output */
  674.         __u8 name[32]; /* Label */
  675.         __u32 type; /* Type of output */
  676.         __u32 audioset; /* Associated audios (bitfield) */
  677.         __u32 modulator; /* Associated modulator */
  678.         v4l2_std_id std;
  679.         __u32 reserved[4];
  680. };
  681. /* Values for the 'type' field */
  682. #define V4L2_OUTPUT_TYPE_MODULATOR 1
  683. #define V4L2_OUTPUT_TYPE_ANALOG 2
  684. #define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY 3

  685. /*
  686.  * C O N T R O L S
  687.  */
  688. struct v4l2_control
  689. {
  690.         __u32 id;
  691.         __s32 value;
  692. };

  693. struct v4l2_ext_control
  694. {
  695.         __u32 id;
  696.         __u32 reserved2[2];
  697.         union {
  698.                 __s32 value;
  699.                 __s64 value64;
  700.                 void *reserved;
  701.         };
  702. } __attribute__ ((packed));

  703. struct v4l2_ext_controls
  704. {
  705.         __u32 ctrl_class;
  706.         __u32 count;
  707.         __u32 error_idx;
  708.         __u32 reserved[2];
  709.         struct v4l2_ext_control *controls;
  710. };

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

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

  718. /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
  719. struct v4l2_queryctrl
  720. {
  721.         __u32 id;
  722.         enum v4l2_ctrl_type type;
  723.         __u8 name[32]; /* Whatever */
  724.         __s32 minimum; /* Note signedness */
  725.         __s32 maximum;
  726.         __s32 step;
  727.         __s32 default_value;
  728.         __u32 flags;
  729.         __u32 reserved[2];
  730. };

  731. /* Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
  732. struct v4l2_querymenu
  733. {
  734.         __u32 id;
  735.         __u32 index;
  736.         __u8 name[32]; /* Whatever */
  737.         __u32 reserved;
  738. };

  739. /* Control flags */
  740. #define V4L2_CTRL_FLAG_DISABLED 0x0001
  741. #define V4L2_CTRL_FLAG_GRABBED 0x0002
  742. #define V4L2_CTRL_FLAG_READ_ONLY 0x0004
  743. #define V4L2_CTRL_FLAG_UPDATE 0x0008
  744. #define V4L2_CTRL_FLAG_INACTIVE 0x0010
  745. #define V4L2_CTRL_FLAG_SLIDER 0x0020

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

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

  753. #define V4L2_CID_USER_CLASS (V4L2_CTRL_CLASS_USER | 1)
  754. #define V4L2_CID_BRIGHTNESS (V4L2_CID_BASE+0)
  755. #define V4L2_CID_CONTRAST (V4L2_CID_BASE+1)
  756. #define V4L2_CID_SATURATION (V4L2_CID_BASE+2)
  757. #define V4L2_CID_HUE (V4L2_CID_BASE+3)
  758. #define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE+5)
  759. #define V4L2_CID_AUDIO_BALANCE (V4L2_CID_BASE+6)
  760. #define V4L2_CID_AUDIO_BASS (V4L2_CID_BASE+7)
  761. #define V4L2_CID_AUDIO_TREBLE (V4L2_CID_BASE+8)
  762. #define V4L2_CID_AUDIO_MUTE (V4L2_CID_BASE+9)
  763. #define V4L2_CID_AUDIO_LOUDNESS (V4L2_CID_BASE+10)
  764. #define V4L2_CID_BLACK_LEVEL (V4L2_CID_BASE+11) /* Deprecated */
  765. #define V4L2_CID_AUTO_WHITE_BALANCE (V4L2_CID_BASE+12)
  766. #define V4L2_CID_DO_WHITE_BALANCE (V4L2_CID_BASE+13)
  767. #define V4L2_CID_RED_BALANCE (V4L2_CID_BASE+14)
  768. #define V4L2_CID_BLUE_BALANCE (V4L2_CID_BASE+15)
  769. #define V4L2_CID_GAMMA (V4L2_CID_BASE+16)
  770. #define V4L2_CID_WHITENESS (V4L2_CID_GAMMA) /* Deprecated */
  771. #define V4L2_CID_EXPOSURE (V4L2_CID_BASE+17)
  772. #define V4L2_CID_AUTOGAIN (V4L2_CID_BASE+18)
  773. #define V4L2_CID_GAIN (V4L2_CID_BASE+19)
  774. #define V4L2_CID_HFLIP (V4L2_CID_BASE+20)
  775. #define V4L2_CID_VFLIP (V4L2_CID_BASE+21)

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

  779. #define V4L2_CID_POWER_LINE_FREQUENCY (V4L2_CID_BASE+24)
  780. enum v4l2_power_line_frequency {
  781.         V4L2_CID_POWER_LINE_FREQUENCY_DISABLED = 0,
  782.         V4L2_CID_POWER_LINE_FREQUENCY_50HZ = 1,
  783.         V4L2_CID_POWER_LINE_FREQUENCY_60HZ = 2,
  784. };
  785. #define V4L2_CID_HUE_AUTO (V4L2_CID_BASE+25)
  786. #define V4L2_CID_WHITE_BALANCE_TEMPERATURE (V4L2_CID_BASE+26)
  787. #define V4L2_CID_SHARPNESS (V4L2_CID_BASE+27)
  788. #define V4L2_CID_BACKLIGHT_COMPENSATION (V4L2_CID_BASE+28)
  789. #define V4L2_CID_LASTP1 (V4L2_CID_BASE+29) /* last CID + 1 */

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

  793. /* MPEG streams */
  794. #define V4L2_CID_MPEG_STREAM_TYPE (V4L2_CID_MPEG_BASE+0)
  795. enum v4l2_mpeg_stream_type {
  796.         V4L2_MPEG_STREAM_TYPE_MPEG2_PS = 0, /* MPEG-2 program stream */
  797.         V4L2_MPEG_STREAM_TYPE_MPEG2_TS = 1, /* MPEG-2 transport stream */
  798.         V4L2_MPEG_STREAM_TYPE_MPEG1_SS = 2, /* MPEG-1 system stream */
  799.         V4L2_MPEG_STREAM_TYPE_MPEG2_DVD = 3, /* MPEG-2 DVD-compatible stream */
  800.         V4L2_MPEG_STREAM_TYPE_MPEG1_VCD = 4, /* MPEG-1 VCD-compatible stream */
  801.         V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD = 5, /* MPEG-2 SVCD-compatible stream */
  802. };
  803. #define V4L2_CID_MPEG_STREAM_PID_PMT (V4L2_CID_MPEG_BASE+1)
  804. #define V4L2_CID_MPEG_STREAM_PID_AUDIO (V4L2_CID_MPEG_BASE+2)
  805. #define V4L2_CID_MPEG_STREAM_PID_VIDEO (V4L2_CID_MPEG_BASE+3)
  806. #define V4L2_CID_MPEG_STREAM_PID_PCR (V4L2_CID_MPEG_BASE+4)
  807. #define V4L2_CID_MPEG_STREAM_PES_ID_AUDIO (V4L2_CID_MPEG_BASE+5)
  808. #define V4L2_CID_MPEG_STREAM_PES_ID_VIDEO (V4L2_CID_MPEG_BASE+6)
  809. #define V4L2_CID_MPEG_STREAM_VBI_FMT (V4L2_CID_MPEG_BASE+7)
  810. enum v4l2_mpeg_stream_vbi_fmt {
  811.         V4L2_MPEG_STREAM_VBI_FMT_NONE = 0, /* No VBI in the MPEG stream */
  812.         V4L2_MPEG_STREAM_VBI_FMT_IVTV = 1, /* VBI in private packets, IVTV format */
  813. };

  814. /* MPEG audio */
  815. #define V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ (V4L2_CID_MPEG_BASE+100)
  816. enum v4l2_mpeg_audio_sampling_freq {
  817.         V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100 = 0,
  818.         V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000 = 1,
  819.         V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000 = 2,
  820. };
  821. #define V4L2_CID_MPEG_AUDIO_ENCODING (V4L2_CID_MPEG_BASE+101)
  822. enum v4l2_mpeg_audio_encoding {
  823.         V4L2_MPEG_AUDIO_ENCODING_LAYER_1 = 0,
  824.         V4L2_MPEG_AUDIO_ENCODING_LAYER_2 = 1,
  825.         V4L2_MPEG_AUDIO_ENCODING_LAYER_3 = 2,
  826. };
  827. #define V4L2_CID_MPEG_AUDIO_L1_BITRATE (V4L2_CID_MPEG_BASE+102)
  828. enum v4l2_mpeg_audio_l1_bitrate {
  829.         V4L2_MPEG_AUDIO_L1_BITRATE_32K = 0,
  830.         V4L2_MPEG_AUDIO_L1_BITRATE_64K = 1,
  831.         V4L2_MPEG_AUDIO_L1_BITRATE_96K = 2,
  832.         V4L2_MPEG_AUDIO_L1_BITRATE_128K = 3,
  833.         V4L2_MPEG_AUDIO_L1_BITRATE_160K = 4,
  834.         V4L2_MPEG_AUDIO_L1_BITRATE_192K = 5,
  835.         V4L2_MPEG_AUDIO_L1_BITRATE_224K = 6,
  836.         V4L2_MPEG_AUDIO_L1_BITRATE_256K = 7,
  837.         V4L2_MPEG_AUDIO_L1_BITRATE_288K = 8,
  838.         V4L2_MPEG_AUDIO_L1_BITRATE_320K = 9,
  839.         V4L2_MPEG_AUDIO_L1_BITRATE_352K = 10,
  840.         V4L2_MPEG_AUDIO_L1_BITRATE_384K = 11,
  841.         V4L2_MPEG_AUDIO_L1_BITRATE_416K = 12,
  842.         V4L2_MPEG_AUDIO_L1_BITRATE_448K = 13,
  843. };
  844. #define V4L2_CID_MPEG_AUDIO_L2_BITRATE (V4L2_CID_MPEG_BASE+103)
  845. enum v4l2_mpeg_audio_l2_bitrate {
  846.         V4L2_MPEG_AUDIO_L2_BITRATE_32K = 0,
  847.         V4L2_MPEG_AUDIO_L2_BITRATE_48K = 1,
  848.         V4L2_MPEG_AUDIO_L2_BITRATE_56K = 2,
  849.         V4L2_MPEG_AUDIO_L2_BITRATE_64K = 3,
  850.         V4L2_MPEG_AUDIO_L2_BITRATE_80K = 4,
  851.         V4L2_MPEG_AUDIO_L2_BITRATE_96K = 5,
  852.         V4L2_MPEG_AUDIO_L2_BITRATE_112K = 6,
  853.         V4L2_MPEG_AUDIO_L2_BITRATE_128K = 7,
  854.         V4L2_MPEG_AUDIO_L2_BITRATE_160K = 8,
  855.         V4L2_MPEG_AUDIO_L2_BITRATE_192K = 9,
  856.         V4L2_MPEG_AUDIO_L2_BITRATE_224K = 10,
  857.         V4L2_MPEG_AUDIO_L2_BITRATE_256K = 11,
  858.         V4L2_MPEG_AUDIO_L2_BITRATE_320K = 12,
  859.         V4L2_MPEG_AUDIO_L2_BITRATE_384K = 13,
  860. };
  861. #define V4L2_CID_MPEG_AUDIO_L3_BITRATE (V4L2_CID_MPEG_BASE+104)
  862. enum v4l2_mpeg_audio_l3_bitrate {
  863.         V4L2_MPEG_AUDIO_L3_BITRATE_32K = 0,
  864.         V4L2_MPEG_AUDIO_L3_BITRATE_40K = 1,
  865.         V4L2_MPEG_AUDIO_L3_BITRATE_48K = 2,
  866.         V4L2_MPEG_AUDIO_L3_BITRATE_56K = 3,
  867.         V4L2_MPEG_AUDIO_L3_BITRATE_64K = 4,
  868.         V4L2_MPEG_AUDIO_L3_BITRATE_80K = 5,
  869.         V4L2_MPEG_AUDIO_L3_BITRATE_96K = 6,
  870.         V4L2_MPEG_AUDIO_L3_BITRATE_112K = 7,
  871.         V4L2_MPEG_AUDIO_L3_BITRATE_128K = 8,
  872.         V4L2_MPEG_AUDIO_L3_BITRATE_160K = 9,
  873.         V4L2_MPEG_AUDIO_L3_BITRATE_192K = 10,
  874.         V4L2_MPEG_AUDIO_L3_BITRATE_224K = 11,
  875.         V4L2_MPEG_AUDIO_L3_BITRATE_256K = 12,
  876.         V4L2_MPEG_AUDIO_L3_BITRATE_320K = 13,
  877. };
  878. #define V4L2_CID_MPEG_AUDIO_MODE (V4L2_CID_MPEG_BASE+105)
  879. enum v4l2_mpeg_audio_mode {
  880.         V4L2_MPEG_AUDIO_MODE_STEREO = 0,
  881.         V4L2_MPEG_AUDIO_MODE_JOINT_STEREO = 1,
  882.         V4L2_MPEG_AUDIO_MODE_DUAL = 2,
  883.         V4L2_MPEG_AUDIO_MODE_MONO = 3,
  884. };
  885. #define V4L2_CID_MPEG_AUDIO_MODE_EXTENSION (V4L2_CID_MPEG_BASE+106)
  886. enum v4l2_mpeg_audio_mode_extension {
  887.         V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4 = 0,
  888.         V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_8 = 1,
  889.         V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_12 = 2,
  890.         V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16 = 3,
  891. };
  892. #define V4L2_CID_MPEG_AUDIO_EMPHASIS (V4L2_CID_MPEG_BASE+107)
  893. enum v4l2_mpeg_audio_emphasis {
  894.         V4L2_MPEG_AUDIO_EMPHASIS_NONE = 0,
  895.         V4L2_MPEG_AUDIO_EMPHASIS_50_DIV_15_uS = 1,
  896.         V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17 = 2,
  897. };
  898. #define V4L2_CID_MPEG_AUDIO_CRC (V4L2_CID_MPEG_BASE+108)
  899. enum v4l2_mpeg_audio_crc {
  900.         V4L2_MPEG_AUDIO_CRC_NONE = 0,
  901.         V4L2_MPEG_AUDIO_CRC_CRC16 = 1,
  902. };
  903. #define V4L2_CID_MPEG_AUDIO_MUTE (V4L2_CID_MPEG_BASE+109)

  904. /* MPEG video */
  905. #define V4L2_CID_MPEG_VIDEO_ENCODING (V4L2_CID_MPEG_BASE+200)
  906. enum v4l2_mpeg_video_encoding {
  907.         V4L2_MPEG_VIDEO_ENCODING_MPEG_1 = 0,
  908.         V4L2_MPEG_VIDEO_ENCODING_MPEG_2 = 1,
  909. };
  910. #define V4L2_CID_MPEG_VIDEO_ASPECT (V4L2_CID_MPEG_BASE+201)
  911. enum v4l2_mpeg_video_aspect {
  912.         V4L2_MPEG_VIDEO_ASPECT_1x1 = 0,
  913.         V4L2_MPEG_VIDEO_ASPECT_4x3 = 1,
  914.         V4L2_MPEG_VIDEO_ASPECT_16x9 = 2,
  915.         V4L2_MPEG_VIDEO_ASPECT_221x100 = 3,
  916. };
  917. #define V4L2_CID_MPEG_VIDEO_B_FRAMES (V4L2_CID_MPEG_BASE+202)
  918. #define V4L2_CID_MPEG_VIDEO_GOP_SIZE (V4L2_CID_MPEG_BASE+203)
  919. #define V4L2_CID_MPEG_VIDEO_GOP_CLOSURE (V4L2_CID_MPEG_BASE+204)
  920. #define V4L2_CID_MPEG_VIDEO_PULLDOWN (V4L2_CID_MPEG_BASE+205)
  921. #define V4L2_CID_MPEG_VIDEO_BITRATE_MODE (V4L2_CID_MPEG_BASE+206)
  922. enum v4l2_mpeg_video_bitrate_mode {
  923.         V4L2_MPEG_VIDEO_BITRATE_MODE_VBR = 0,
  924.         V4L2_MPEG_VIDEO_BITRATE_MODE_CBR = 1,
  925. };
  926. #define V4L2_CID_MPEG_VIDEO_BITRATE (V4L2_CID_MPEG_BASE+207)
  927. #define V4L2_CID_MPEG_VIDEO_BITRATE_PEAK (V4L2_CID_MPEG_BASE+208)
  928. #define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
  929. #define V4L2_CID_MPEG_VIDEO_MUTE (V4L2_CID_MPEG_BASE+210)
  930. #define V4L2_CID_MPEG_VIDEO_MUTE_YUV (V4L2_CID_MPEG_BASE+211)

  931. /* MPEG-class control IDs specific to the CX2584x driver as defined by V4L2 */
  932. #define V4L2_CID_MPEG_CX2341X_BASE (V4L2_CTRL_CLASS_MPEG | 0x1000)
  933. #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_MPEG_CX2341X_BASE+0)
  934. enum v4l2_mpeg_cx2341x_video_spatial_filter_mode {
  935.         V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL = 0,
  936.         V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO = 1,
  937. };
  938. #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER (V4L2_CID_MPEG_CX2341X_BASE+1)
  939. #define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+2)
  940. enum v4l2_mpeg_cx2341x_video_luma_spatial_filter_type {
  941.         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF = 0,
  942.         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
  943.         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_VERT = 2,
  944.         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_HV_SEPARABLE = 3,
  945.         V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE = 4,
  946. };
  947. #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+3)
  948. enum v4l2_mpeg_cx2341x_video_chroma_spatial_filter_type {
  949.         V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF = 0,
  950.         V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
  951. };
  952. #define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE (V4L2_CID_MPEG_CX2341X_BASE+4)
  953. enum v4l2_mpeg_cx2341x_video_temporal_filter_mode {
  954.         V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL = 0,
  955.         V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO = 1,
  956. };
  957. #define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER (V4L2_CID_MPEG_CX2341X_BASE+5)
  958. #define V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+6)
  959. enum v4l2_mpeg_cx2341x_video_median_filter_type {
  960.         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF = 0,
  961.         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR = 1,
  962.         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_VERT = 2,
  963.         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR_VERT = 3,
  964.         V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG = 4,
  965. };
  966. #define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+7)
  967. #define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+8)
  968. #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+9)
  969. #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+10)
  970. #define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS (V4L2_CID_MPEG_CX2341X_BASE+11)

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

  974. #define V4L2_CID_EXPOSURE_AUTO (V4L2_CID_CAMERA_CLASS_BASE+1)
  975. enum v4l2_exposure_auto_type {
  976.         V4L2_EXPOSURE_AUTO = 0,
  977.         V4L2_EXPOSURE_MANUAL = 1,
  978.         V4L2_EXPOSURE_SHUTTER_PRIORITY = 2,
  979.         V4L2_EXPOSURE_APERTURE_PRIORITY = 3
  980. };
  981. #define V4L2_CID_EXPOSURE_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+2)
  982. #define V4L2_CID_EXPOSURE_AUTO_PRIORITY (V4L2_CID_CAMERA_CLASS_BASE+3)

  983. #define V4L2_CID_PAN_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+4)
  984. #define V4L2_CID_TILT_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+5)
  985. #define V4L2_CID_PAN_RESET (V4L2_CID_CAMERA_CLASS_BASE+6)
  986. #define V4L2_CID_TILT_RESET (V4L2_CID_CAMERA_CLASS_BASE+7)

  987. #define V4L2_CID_PAN_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+8)
  988. #define V4L2_CID_TILT_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+9)

  989. #define V4L2_CID_FOCUS_ABSOLUTE (V4L2_CID_CAMERA_CLASS_BASE+10)
  990. #define V4L2_CID_FOCUS_RELATIVE (V4L2_CID_CAMERA_CLASS_BASE+11)
  991. #define V4L2_CID_FOCUS_AUTO (V4L2_CID_CAMERA_CLASS_BASE+12)

  992. /*
  993.  * T U N I N G
  994.  */
  995. struct v4l2_tuner
  996. {
  997.         __u32 index;
  998.         __u8 name[32];
  999.         enum v4l2_tuner_type type;
  1000.         __u32 capability;
  1001.         __u32 rangelow;
  1002.         __u32 rangehigh;
  1003.         __u32 rxsubchans;
  1004.         __u32 audmode;
  1005.         __s32 signal;
  1006.         __s32 afc;
  1007.         __u32 reserved[4];
  1008. };

  1009. struct v4l2_modulator
  1010. {
  1011.         __u32 index;
  1012.         __u8 name[32];
  1013.         __u32 capability;
  1014.         __u32 rangelow;
  1015.         __u32 rangehigh;
  1016.         __u32 txsubchans;
  1017.         __u32 reserved[4];
  1018. };

  1019. /* Flags for the 'capability' field */
  1020. #define V4L2_TUNER_CAP_LOW 0x0001
  1021. #define V4L2_TUNER_CAP_NORM 0x0002
  1022. #define V4L2_TUNER_CAP_STEREO 0x0010
  1023. #define V4L2_TUNER_CAP_LANG2 0x0020
  1024. #define V4L2_TUNER_CAP_SAP 0x0020
  1025. #define V4L2_TUNER_CAP_LANG1 0x0040

  1026. /* Flags for the 'rxsubchans' field */
  1027. #define V4L2_TUNER_SUB_MONO 0x0001
  1028. #define V4L2_TUNER_SUB_STEREO 0x0002
  1029. #define V4L2_TUNER_SUB_LANG2 0x0004
  1030. #define V4L2_TUNER_SUB_SAP 0x0004
  1031. #define V4L2_TUNER_SUB_LANG1 0x0008

  1032. /* Values for the 'audmode' field */
  1033. #define V4L2_TUNER_MODE_MONO 0x0000
  1034. #define V4L2_TUNER_MODE_STEREO 0x0001
  1035. #define V4L2_TUNER_MODE_LANG2 0x0002
  1036. #define V4L2_TUNER_MODE_SAP 0x0002
  1037. #define V4L2_TUNER_MODE_LANG1 0x0003
  1038. #define V4L2_TUNER_MODE_LANG1_LANG2 0x0004

  1039. struct v4l2_frequency
  1040. {
  1041.         __u32 tuner;
  1042.         enum v4l2_tuner_type type;
  1043.         __u32 frequency;
  1044.         __u32 reserved[8];
  1045. };

  1046. /*
  1047.  * A U D I O
  1048.  */
  1049. struct v4l2_audio
  1050. {
  1051.         __u32 index;
  1052.         __u8 name[32];
  1053.         __u32 capability;
  1054.         __u32 mode;
  1055.         __u32 reserved[2];
  1056. };

  1057. /* Flags for the 'capability' field */
  1058. #define V4L2_AUDCAP_STEREO 0x00001
  1059. #define V4L2_AUDCAP_AVL 0x00002

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

  1062. struct v4l2_audioout
  1063. {
  1064.         __u32 index;
  1065.         __u8 name[32];
  1066.         __u32 capability;
  1067.         __u32 mode;
  1068.         __u32 reserved[2];
  1069. };

  1070. /*
  1071.  * M P E G S E R V I C E S
  1072.  *
  1073.  * NOTE: EXPERIMENTAL API
  1074.  */
  1075. #if 1 /*KEEP*/
  1076. #define V4L2_ENC_IDX_FRAME_I (0)
  1077. #define V4L2_ENC_IDX_FRAME_P (1)
  1078. #define V4L2_ENC_IDX_FRAME_B (2)
  1079. #define V4L2_ENC_IDX_FRAME_MASK (0xf)

  1080. struct v4l2_enc_idx_entry {
  1081.         __u64 offset;
  1082.         __u64 pts;
  1083.         __u32 length;
  1084.         __u32 flags;
  1085.         __u32 reserved[2];
  1086. };

  1087. #define V4L2_ENC_IDX_ENTRIES (64)
  1088. struct v4l2_enc_idx {
  1089.         __u32 entries;
  1090.         __u32 entries_cap;
  1091.         __u32 reserved[4];
  1092.         struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
  1093. };


  1094. #define V4L2_ENC_CMD_START (0)
  1095. #define V4L2_ENC_CMD_STOP (1)
  1096. #define V4L2_ENC_CMD_PAUSE (2)
  1097. #define V4L2_ENC_CMD_RESUME (3)

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

  1100. struct v4l2_encoder_cmd {
  1101.         __u32 cmd;
  1102.         __u32 flags;
  1103.         union {
  1104.                 struct {
  1105.                         __u32 data[8];
  1106.                 } raw;
  1107.         };
  1108. };

  1109. #endif


  1110. /*
  1111.  * D A T A S E R V I C E S ( V B I )
  1112.  *
  1113.  * Data services API by Michael Schimek
  1114.  */

  1115. /* Raw VBI */
  1116. struct v4l2_vbi_format
  1117. {
  1118.         __u32 sampling_rate; /* in 1 Hz */
  1119.         __u32 offset;
  1120.         __u32 samples_per_line;
  1121.         __u32 sample_format; /* V4L2_PIX_FMT_* */
  1122.         __s32 start[2];
  1123.         __u32 count[2];
  1124.         __u32 flags; /* V4L2_VBI_* */
  1125.         __u32 reserved[2]; /* must be zero */
  1126. };

  1127. /* VBI flags */
  1128. #define V4L2_VBI_UNSYNC (1<< 0)
  1129. #define V4L2_VBI_INTERLACED (1<< 1)

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

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

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

  1156. #define V4L2_SLICED_VBI_525 (V4L2_SLICED_CAPTION_525)
  1157. #define V4L2_SLICED_VBI_625 (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)

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

  1169. struct v4l2_sliced_vbi_data
  1170. {
  1171.         __u32 id;
  1172.         __u32 field; /* 0: first field, 1: second field */
  1173.         __u32 line; /* 1-23 */
  1174.         __u32 reserved; /* must be 0 */
  1175.         __u8 data[48];
  1176. };

  1177. /*
  1178.  * A G G R E G A T E S T R U C T U R E S
  1179.  */

  1180. /* Stream data format
  1181.  */
  1182. struct v4l2_format
  1183. {
  1184.         enum v4l2_buf_type type;
  1185.         union
  1186.         {
  1187.                 struct v4l2_pix_format pix; // V4L2_BUF_TYPE_VIDEO_CAPTURE
  1188.                 struct v4l2_window win; // V4L2_BUF_TYPE_VIDEO_OVERLAY
  1189.                 struct v4l2_vbi_format vbi; // V4L2_BUF_TYPE_VBI_CAPTURE
  1190.                 struct v4l2_sliced_vbi_format sliced; // V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
  1191.                 __u8 raw_data[200]; // user-defined
  1192.         } fmt;
  1193. };


  1194. /* Stream type-dependent parameters
  1195.  */
  1196. struct v4l2_streamparm
  1197. {
  1198.         enum v4l2_buf_type type;
  1199.         union
  1200.         {
  1201.                 struct v4l2_captureparm capture;
  1202.                 struct v4l2_outputparm output;
  1203.                 __u8 raw_data[200]; /* user-defined */
  1204.         } parm;
  1205. };

  1206. /*
  1207.  * A D V A N C E D D E B U G G I N G
  1208.  *
  1209.  * NOTE: EXPERIMENTAL API
  1210.  */

  1211. /* VIDIOC_DBG_G_REGISTER and VIDIOC_DBG_S_REGISTER */

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

  1215. struct v4l2_register {
  1216.         __u32 match_type; /* Match type */
  1217.         __u32 match_chip; /* Match this chip, meaning determined by match_type */
  1218.         __u64 reg;
  1219.         __u64 val;
  1220. };

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

  1228. /*
  1229.  * 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
  1230.  *
  1231.  */
  1232. #define VIDIOC_QUERYCAP _IOR ('V', 0, struct v4l2_capability)
  1233. #define VIDIOC_RESERVED _IO ('V', 1)
  1234. #define VIDIOC_ENUM_FMT _IOWR ('V', 2, struct v4l2_fmtdesc)
  1235. #define VIDIOC_G_FMT _IOWR ('V', 4, struct v4l2_format)
  1236. #define VIDIOC_S_FMT _IOWR ('V', 5, struct v4l2_format)
  1237. #define VIDIOC_REQBUFS _IOWR ('V', 8, struct v4l2_requestbuffers)
  1238. #define VIDIOC_QUERYBUF _IOWR ('V', 9, struct v4l2_buffer)
  1239. #define VIDIOC_G_FBUF _IOR ('V', 10, struct v4l2_framebuffer)
  1240. #define VIDIOC_S_FBUF _IOW ('V', 11, struct v4l2_framebuffer)
  1241. #define VIDIOC_OVERLAY _IOW ('V', 14, int)
  1242. #define VIDIOC_QBUF _IOWR ('V', 15, struct v4l2_buffer)
  1243. #define VIDIOC_DQBUF _IOWR ('V', 17, struct v4l2_buffer)
  1244. #define VIDIOC_STREAMON _IOW ('V', 18, int)
  1245. #define VIDIOC_STREAMOFF _IOW ('V', 19, int)
  1246. #define VIDIOC_G_PARM _IOWR ('V', 21, struct v4l2_streamparm)
  1247. #define VIDIOC_S_PARM _IOWR ('V', 22, struct v4l2_streamparm)
  1248. #define VIDIOC_G_STD _IOR ('V', 23, v4l2_std_id)
  1249. #define VIDIOC_S_STD _IOW ('V', 24, v4l2_std_id)
  1250. #define VIDIOC_ENUMSTD _IOWR ('V', 25, struct v4l2_standard)
  1251. #define VIDIOC_ENUMINPUT _IOWR ('V', 26, struct v4l2_input)
  1252. #define VIDIOC_G_CTRL _IOWR ('V', 27, struct v4l2_control)
  1253. #define VIDIOC_S_CTRL _IOWR ('V', 28, struct v4l2_control)
  1254. #define VIDIOC_G_TUNER _IOWR ('V', 29, struct v4l2_tuner)
  1255. #define VIDIOC_S_TUNER _IOW ('V', 30, struct v4l2_tuner)
  1256. #define VIDIOC_G_AUDIO _IOR ('V', 33, struct v4l2_audio)
  1257. #define VIDIOC_S_AUDIO _IOW ('V', 34, struct v4l2_audio)
  1258. #define VIDIOC_QUERYCTRL _IOWR ('V', 36, struct v4l2_queryctrl)
  1259. #define VIDIOC_QUERYMENU _IOWR ('V', 37, struct v4l2_querymenu)
  1260. #define VIDIOC_G_INPUT _IOR ('V', 38, int)
  1261. #define VIDIOC_S_INPUT _IOWR ('V', 39, int)
  1262. #define VIDIOC_G_OUTPUT _IOR ('V', 46, int)
  1263. #define VIDIOC_S_OUTPUT _IOWR ('V', 47, int)
  1264. #define VIDIOC_ENUMOUTPUT _IOWR ('V', 48, struct v4l2_output)
  1265. #define VIDIOC_G_AUDOUT _IOR ('V', 49, struct v4l2_audioout)
  1266. #define VIDIOC_S_AUDOUT _IOW ('V', 50, struct v4l2_audioout)
  1267. #define VIDIOC_G_MODULATOR _IOWR ('V', 54, struct v4l2_modulator)
  1268. #define VIDIOC_S_MODULATOR _IOW ('V', 55, struct v4l2_modulator)
  1269. #define VIDIOC_G_FREQUENCY _IOWR ('V', 56, struct v4l2_frequency)
  1270. #define VIDIOC_S_FREQUENCY _IOW ('V', 57, struct v4l2_frequency)
  1271. #define VIDIOC_CROPCAP _IOWR ('V', 58, struct v4l2_cropcap)
  1272. #define VIDIOC_G_CROP _IOWR ('V', 59, struct v4l2_crop)
  1273. #define VIDIOC_S_CROP _IOW ('V', 60, struct v4l2_crop)
  1274. #define VIDIOC_G_JPEGCOMP _IOR ('V', 61, struct v4l2_jpegcompression)
  1275. #define VIDIOC_S_JPEGCOMP _IOW ('V', 62, struct v4l2_jpegcompression)
  1276. #define VIDIOC_QUERYSTD _IOR ('V', 63, v4l2_std_id)
  1277. #define VIDIOC_TRY_FMT _IOWR ('V', 64, struct v4l2_format)
  1278. #define VIDIOC_ENUMAUDIO _IOWR ('V', 65, struct v4l2_audio)
  1279. #define VIDIOC_ENUMAUDOUT _IOWR ('V', 66, struct v4l2_audioout)
  1280. #define VIDIOC_G_PRIORITY _IOR ('V', 67, enum v4l2_priority)
  1281. #define VIDIOC_S_PRIORITY _IOW ('V', 68, enum v4l2_priority)
  1282. #define VIDIOC_G_SLICED_VBI_CAP _IOWR ('V', 69, struct v4l2_sliced_vbi_cap)
  1283. #define VIDIOC_LOG_STATUS _IO ('V', 70)
  1284. #define VIDIOC_G_EXT_CTRLS _IOWR ('V', 71, struct v4l2_ext_controls)
  1285. #define VIDIOC_S_EXT_CTRLS _IOWR ('V', 72, struct v4l2_ext_controls)
  1286. #define VIDIOC_TRY_EXT_CTRLS _IOWR ('V', 73, struct v4l2_ext_controls)
  1287. #if 1 /*KEEP*/
  1288. #define VIDIOC_ENUM_FRAMESIZES _IOWR ('V', 74, struct v4l2_frmsizeenum)
  1289. #define VIDIOC_ENUM_FRAMEINTERVALS _IOWR ('V', 75, struct v4l2_frmivalenum)
  1290. #define VIDIOC_G_ENC_INDEX _IOR ('V', 76, struct v4l2_enc_idx)
  1291. #define VIDIOC_ENCODER_CMD _IOWR ('V', 77, struct v4l2_encoder_cmd)
  1292. #define VIDIOC_TRY_ENCODER_CMD _IOWR ('V', 78, struct v4l2_encoder_cmd)

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

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

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

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

  1308. #endif /* __LINUX_VIDEODEV2_H */

  1309. /*
  1310.  * Local variables:
  1311.  * c-basic-offset: 8
  1312.  * End:
  1313.  */
  1314. Prev    Home    Next
  1315. Obsolete API Elements         Video Capture Example



文末还给出了一个capture的列子。


  1. Video for Linux Two API Specification: Revision 0.24
  2. Prev        Next
  3. Appendix B. Video Capture Example

  4. /*
  5.  * V4L2 video capture example
  6.  *
  7.  * This program can be used and distributed without restrictions.
  8.  */

  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <assert.h>

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

  14. #include <fcntl.h> /* low-level i/o */
  15. #include <unistd.h>
  16. #include <errno.h>
  17. #include <malloc.h>
  18. #include <sys/stat.h>
  19. #include <sys/types.h>
  20. #include <sys/time.h>
  21. #include <sys/mman.h>
  22. #include <sys/ioctl.h>

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

  24. #include <linux/videodev2.h>

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

  26. typedef enum {
  27.         IO_METHOD_READ,
  28.         IO_METHOD_MMAP,
  29.         IO_METHOD_USERPTR,
  30. } io_method;

  31. struct buffer {
  32.         void * start;
  33.         size_t length;
  34. };

  35. static char * dev_name = NULL;
  36. static io_method io = IO_METHOD_MMAP;
  37. static int fd = -1;
  38. struct buffer * buffers = NULL;
  39. static unsigned int n_buffers = 0;

  40. static void
  41. errno_exit (const char * s)
  42. {
  43.         fprintf (stderr, "%s error %d, %s\n",
  44.                  s, errno, strerror (errno));

  45.         exit (EXIT_FAILURE);
  46. }

  47. static int
  48. xioctl (int fd,
  49.                                  int request,
  50.                                  void * arg)
  51. {
  52.         int r;

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

  55.         return r;
  56. }

  57. static void
  58. process_image (const void * p)
  59. {
  60.         fputc ('.', stdout);
  61.         fflush (stdout);
  62. }

  63. static int
  64. read_frame (void)
  65. {
  66.         struct v4l2_buffer buf;
  67.         unsigned int i;

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

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

  76.                                 /* fall through */

  77.                         default:
  78.                                 errno_exit ("read");
  79.                         }
  80.                 }

  81.                 process_image (buffers[0].start);

  82.                 break;

  83.         case IO_METHOD_MMAP:
  84.                 CLEAR (buf);

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

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

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

  93.                                 /* fall through */

  94.                         default:
  95.                                 errno_exit ("VIDIOC_DQBUF");
  96.                         }
  97.                 }

  98.                 assert (buf.index < n_buffers);

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

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

  102.                 break;

  103.         case IO_METHOD_USERPTR:
  104.                 CLEAR (buf);

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

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

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

  113.                                 /* fall through */

  114.                         default:
  115.                                 errno_exit ("VIDIOC_DQBUF");
  116.                         }
  117.                 }

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

  122.                 assert (i < n_buffers);

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

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

  126.                 break;
  127.         }

  128.         return 1;
  129. }

  130. static void
  131. mainloop (void)
  132. {
  133.         unsigned int count;

  134.         count = 100;

  135.         while (count-- > 0) {
  136.                 for (;;) {
  137.                         fd_set fds;
  138.                         struct timeval tv;
  139.                         int r;

  140.                         FD_ZERO (&fds);
  141.                         FD_SET (fd, &fds);

  142.                         /* Timeout. */
  143.                         tv.tv_sec = 2;
  144.                         tv.tv_usec = 0;

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

  146.                         if (-1 == r) {
  147.                                 if (EINTR == errno)
  148.                                         continue;

  149.                                 errno_exit ("select");
  150.                         }

  151.                         if (0 == r) {
  152.                                 fprintf (stderr, "select timeout\n");
  153.                                 exit (EXIT_FAILURE);
  154.                         }

  155.                         if (read_frame ())
  156.                                 break;
  157.         
  158.                         /* EAGAIN - continue select loop. */
  159.                 }
  160.         }
  161. }

  162. static void
  163. stop_capturing (void)
  164. {
  165.         enum v4l2_buf_type type;

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

  170.         case IO_METHOD_MMAP:
  171.         case IO_METHOD_USERPTR:
  172.                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

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

  175.                 break;
  176.         }
  177. }

  178. static void
  179. start_capturing (void)
  180. {
  181.         unsigned int i;
  182.         enum v4l2_buf_type type;

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

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

  190.                         CLEAR (buf);

  191.                         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  192.                         buf.memory = V4L2_MEMORY_MMAP;
  193.                         buf.index = i;

  194.                         if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  195.                                 errno_exit ("VIDIOC_QBUF");
  196.                 }
  197.                 
  198.                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

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

  201.                 break;

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

  205.                         CLEAR (buf);

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

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

  214.                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

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

  217.                 break;
  218.         }
  219. }

  220. static void
  221. uninit_device (void)
  222. {
  223.         unsigned int i;

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

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

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

  238.         free (buffers);
  239. }

  240. static void
  241. init_read (unsigned int buffer_size)
  242. {
  243.         buffers = calloc (1, sizeof (*buffers));

  244.         if (!buffers) {
  245.                 fprintf (stderr, "Out of memory\n");
  246.                 exit (EXIT_FAILURE);
  247.         }

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

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

  255. static void
  256. init_mmap (void)
  257. {
  258.         struct v4l2_requestbuffers req;

  259.         CLEAR (req);

  260.         req.count = 4;
  261.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  262.         req.memory = V4L2_MEMORY_MMAP;

  263.         if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
  264.                 if (EINVAL == errno) {
  265.                         fprintf (stderr, "%s does not support "
  266.                                  "memory mapping\n", dev_name);
  267.                         exit (EXIT_FAILURE);
  268.                 } else {
  269.                         errno_exit ("VIDIOC_REQBUFS");
  270.                 }
  271.         }

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

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

  278.         if (!buffers) {
  279.                 fprintf (stderr, "Out of memory\n");
  280.                 exit (EXIT_FAILURE);
  281.         }

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

  284.                 CLEAR (buf);

  285.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  286.                 buf.memory = V4L2_MEMORY_MMAP;
  287.                 buf.index = n_buffers;

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

  290.                 buffers[n_buffers].length = buf.length;
  291.                 buffers[n_buffers].start =
  292.                         mmap (NULL /* start anywhere */,
  293.                               buf.length,
  294.                               PROT_READ | PROT_WRITE /* required */,
  295.                               MAP_SHARED /* recommended */,
  296.                               fd, buf.m.offset);

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

  301. static void
  302. init_userp (unsigned int buffer_size)
  303. {
  304.         struct v4l2_requestbuffers req;
  305.         unsigned int page_size;

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

  308.         CLEAR (req);

  309.         req.count = 4;
  310.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  311.         req.memory = V4L2_MEMORY_USERPTR;

  312.         if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
  313.                 if (EINVAL == errno) {
  314.                         fprintf (stderr, "%s does not support "
  315.                                  "user pointer i/o\n", dev_name);
  316.                         exit (EXIT_FAILURE);
  317.                 } else {
  318.                         errno_exit ("VIDIOC_REQBUFS");
  319.                 }
  320.         }

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

  322.         if (!buffers) {
  323.                 fprintf (stderr, "Out of memory\n");
  324.                 exit (EXIT_FAILURE);
  325.         }

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

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

  336. static void
  337. init_device (void)
  338. {
  339.         struct v4l2_capability cap;
  340.         struct v4l2_cropcap cropcap;
  341.         struct v4l2_crop crop;
  342.         struct v4l2_format fmt;
  343.         unsigned int min;

  344.         if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
  345.                 if (EINVAL == errno) {
  346.                         fprintf (stderr, "%s is no V4L2 device\n",
  347.                                  dev_name);
  348.                         exit (EXIT_FAILURE);
  349.                 } else {
  350.                         errno_exit ("VIDIOC_QUERYCAP");
  351.                 }
  352.         }

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

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

  365.                 break;

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

  373.                 break;
  374.         }


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


  376.         CLEAR (cropcap);

  377.         cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

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

  381.                 if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
  382.                         switch (errno) {
  383.                         case EINVAL:
  384.                                 /* Cropping not supported. */
  385.                                 break;
  386.                         default:
  387.                                 /* Errors ignored. */
  388.                                 break;
  389.                         }
  390.                 }
  391.         } else {
  392.                 /* Errors ignored. */
  393.         }


  394.         CLEAR (fmt);

  395.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  396.         fmt.fmt.pix.width = 640;
  397.         fmt.fmt.pix.height = 480;
  398.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  399.         fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

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

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

  403.         /* Buggy driver paranoia. */
  404.         min = fmt.fmt.pix.width * 2;
  405.         if (fmt.fmt.pix.bytesperline < min)
  406.                 fmt.fmt.pix.bytesperline = min;
  407.         min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
  408.         if (fmt.fmt.pix.sizeimage < min)
  409.                 fmt.fmt.pix.sizeimage = min;

  410.         switch (io) {
  411.         case IO_METHOD_READ:
  412.                 init_read (fmt.fmt.pix.sizeimage);
  413.                 break;

  414.         case IO_METHOD_MMAP:
  415.                 init_mmap ();
  416.                 break;

  417.         case IO_METHOD_USERPTR:
  418.                 init_userp (fmt.fmt.pix.sizeimage);
  419.                 break;
  420.         }
  421. }

  422. static void
  423. close_device (void)
  424. {
  425.         if (-1 == close (fd))
  426.                 errno_exit ("close");

  427.         fd = -1;
  428. }

  429. static void
  430. open_device (void)
  431. {
  432.         struct stat st;

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

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

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

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

  449. static void
  450. usage (FILE * fp,
  451.                                  int argc,
  452.                                  char ** argv)
  453. {
  454.         fprintf (fp,
  455.                  "Usage: %s [options]\n\n"
  456.                  "Options:\n"
  457.                  "-d | --device name Video device name [/dev/video]\n"
  458.                  "-h | --help Print this message\n"
  459.                  "-m | --mmap Use memory mapped buffers\n"
  460.                  "-r | --read Use read() calls\n"
  461.                  "-u | --userp Use application allocated buffers\n"
  462.                  "",
  463.                  argv[0]);
  464. }

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

  466. static const struct option
  467. long_options [] = {
  468.         { "device", required_argument, NULL, 'd' },
  469.         { "help", no_argument, NULL, 'h' },
  470.         { "mmap", no_argument, NULL, 'm' },
  471.         { "read", no_argument, NULL, 'r' },
  472.         { "userp", no_argument, NULL, 'u' },
  473.         { 0, 0, 0, 0 }
  474. };

  475. int
  476. main (int argc,
  477.                                  char ** argv)
  478. {
  479.         dev_name = "/dev/video";

  480.         for (;;) {
  481.                 int index;
  482.                 int c;
  483.                 
  484.                 c = getopt_long (argc, argv,
  485.                                  short_options, long_options,
  486.                                  &index);

  487.                 if (-1 == c)
  488.                         break;

  489.                 switch (c) {
  490.                 case 0: /* getopt_long() flag */
  491.                         break;

  492.                 case 'd':
  493.                         dev_name = optarg;
  494.                         break;

  495.                 case 'h':
  496.                         usage (stdout, argc, argv);
  497.                         exit (EXIT_SUCCESS);

  498.                 case 'm':
  499.                         io = IO_METHOD_MMAP;
  500.                         break;

  501.                 case 'r':
  502.                         io = IO_METHOD_READ;
  503.                         break;

  504.                 case 'u':
  505.                         io = IO_METHOD_USERPTR;
  506.                         break;

  507.                 default:
  508.                         usage (stderr, argc, argv);
  509.                         exit (EXIT_FAILURE);
  510.                 }
  511.         }

  512.         open_device ();

  513.         init_device ();

  514.         start_capturing ();

  515.         mainloop ();

  516.         stop_capturing ();

  517.         uninit_device ();

  518.         close_device ();

  519.         exit (EXIT_SUCCESS);

  520.         return 0;
  521. }
  522. Prev    Home    Next
  523. Video For Linux Two Header File         GNU Free Documentation License








阅读(1219) | 评论(0) | 转发(1) |
0

上一篇:umplayer的pro文件

下一篇:V4L的文档

给主人留下些什么吧!~~