Contents of /trunk/xf86-video-v4l/patches/xf86-video-v4l-0.2.0-support-v4l2-only-drivers.patch
Parent Directory | Revision Log
Revision 2579 -
(show 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 | 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 */ |