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