]>
Commit | Line | Data |
---|---|---|
99af6b95 JR |
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 */ |