← Back to branch summary

~ubuntu-branches/ubuntu/maverick/zapping/maverick

« back to all changes in this revision

Viewing changes to common/_videodev25.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-03-08 23:19:08 UTC
  • mfrom: (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050308231908-oip7rfv6lcmo8c0e
Tags: 0.9.2-2ubuntu1
Rebuilt for Python transition (2.3 -> 2.4)

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/_videodev25.h
 
1
/* Generated file, do not edit! */
 
2
 
 
3
#include <stdio.h>
 
4
#include "device.h"
 
5
 
 
6
#ifndef __GNUC__
 
7
#undef __attribute__
 
8
#define __attribute__(x)
 
9
#endif
 
10
 
 
11
static void
 
12
fprint_symbol_v4l2_std_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
13
{
 
14
fprint_symbolic (fp, 0, value,
 
15
"PAL_B", (unsigned long) V4L2_STD_PAL_B,
 
16
"PAL_B1", (unsigned long) V4L2_STD_PAL_B1,
 
17
"PAL_G", (unsigned long) V4L2_STD_PAL_G,
 
18
"PAL_H", (unsigned long) V4L2_STD_PAL_H,
 
19
"PAL_I", (unsigned long) V4L2_STD_PAL_I,
 
20
"PAL_D", (unsigned long) V4L2_STD_PAL_D,
 
21
"PAL_D1", (unsigned long) V4L2_STD_PAL_D1,
 
22
"PAL_K", (unsigned long) V4L2_STD_PAL_K,
 
23
"PAL_M", (unsigned long) V4L2_STD_PAL_M,
 
24
"PAL_N", (unsigned long) V4L2_STD_PAL_N,
 
25
"PAL_Nc", (unsigned long) V4L2_STD_PAL_Nc,
 
26
"PAL_60", (unsigned long) V4L2_STD_PAL_60,
 
27
"NTSC_M", (unsigned long) V4L2_STD_NTSC_M,
 
28
"NTSC_M_JP", (unsigned long) V4L2_STD_NTSC_M_JP,
 
29
"SECAM_B", (unsigned long) V4L2_STD_SECAM_B,
 
30
"SECAM_D", (unsigned long) V4L2_STD_SECAM_D,
 
31
"SECAM_G", (unsigned long) V4L2_STD_SECAM_G,
 
32
"SECAM_H", (unsigned long) V4L2_STD_SECAM_H,
 
33
"SECAM_K", (unsigned long) V4L2_STD_SECAM_K,
 
34
"SECAM_K1", (unsigned long) V4L2_STD_SECAM_K1,
 
35
"SECAM_L", (unsigned long) V4L2_STD_SECAM_L,
 
36
"ATSC_8_VSB", (unsigned long) V4L2_STD_ATSC_8_VSB,
 
37
"ATSC_16_VSB", (unsigned long) V4L2_STD_ATSC_16_VSB,
 
38
"PAL_BG", (unsigned long) V4L2_STD_PAL_BG,
 
39
"PAL_DK", (unsigned long) V4L2_STD_PAL_DK,
 
40
"PAL", (unsigned long) V4L2_STD_PAL,
 
41
"NTSC", (unsigned long) V4L2_STD_NTSC,
 
42
"SECAM_DK", (unsigned long) V4L2_STD_SECAM_DK,
 
43
"SECAM", (unsigned long) V4L2_STD_SECAM,
 
44
"525_60", (unsigned long) V4L2_STD_525_60,
 
45
"625_50", (unsigned long) V4L2_STD_625_50,
 
46
"ATSC", (unsigned long) V4L2_STD_ATSC,
 
47
"UNKNOWN", (unsigned long) V4L2_STD_UNKNOWN,
 
48
"ALL", (unsigned long) V4L2_STD_ALL,
 
49
0);
 
50
}
 
51
 
 
52
static void
 
53
fprint_struct_v4l2_fract (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_fract *t)
 
54
{
 
55
 fprintf (fp, "%u/%u", t->numerator, t->denominator); 
 
56
}
 
57
 
 
58
static void
 
59
fprint_struct_v4l2_standard (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_standard *t)
 
60
{
 
61
fprintf (fp, "index=%lu ",
 
62
(unsigned long) t->index);
 
63
if (1 == rw) {
 
64
fputs ("id=", fp);
 
65
fprint_symbol_v4l2_std_ (fp, rw, t->id);
 
66
fprintf (fp, " name=\"%.*s\" "
 
67
"frameperiod={",
 
68
24, (const char *) t->name);
 
69
fprint_struct_v4l2_fract (fp, rw, &t->frameperiod);
 
70
fprintf (fp, "} framelines=%lu "
 
71
"reserved[] ",
 
72
(unsigned long) t->framelines);
 
73
}
 
74
}
 
75
 
 
76
static void
 
77
fprint_enum_v4l2_tuner_type (FILE *fp, int rw __attribute__ ((unused)), int value)
 
78
{
 
79
fprint_symbolic (fp, 1, value,
 
80
"RADIO", V4L2_TUNER_RADIO,
 
81
"ANALOG_TV", V4L2_TUNER_ANALOG_TV,
 
82
0);
 
83
}
 
84
 
 
85
static void
 
86
fprint_symbol_v4l2_tuner_cap_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
87
{
 
88
fprint_symbolic (fp, 0, value,
 
89
"LOW", (unsigned long) V4L2_TUNER_CAP_LOW,
 
90
"NORM", (unsigned long) V4L2_TUNER_CAP_NORM,
 
91
"STEREO", (unsigned long) V4L2_TUNER_CAP_STEREO,
 
92
"LANG2", (unsigned long) V4L2_TUNER_CAP_LANG2,
 
93
"SAP", (unsigned long) V4L2_TUNER_CAP_SAP,
 
94
"LANG1", (unsigned long) V4L2_TUNER_CAP_LANG1,
 
95
0);
 
96
}
 
97
 
 
98
static void
 
99
fprint_symbol_v4l2_tuner_sub_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
100
{
 
101
fprint_symbolic (fp, 0, value,
 
102
"MONO", (unsigned long) V4L2_TUNER_SUB_MONO,
 
103
"STEREO", (unsigned long) V4L2_TUNER_SUB_STEREO,
 
104
"LANG2", (unsigned long) V4L2_TUNER_SUB_LANG2,
 
105
"SAP", (unsigned long) V4L2_TUNER_SUB_SAP,
 
106
"LANG1", (unsigned long) V4L2_TUNER_SUB_LANG1,
 
107
0);
 
108
}
 
109
 
 
110
static void
 
111
fprint_symbol_v4l2_tuner_mode_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
112
{
 
113
fprint_symbolic (fp, 0, value,
 
114
"MONO", (unsigned long) V4L2_TUNER_MODE_MONO,
 
115
"STEREO", (unsigned long) V4L2_TUNER_MODE_STEREO,
 
116
"LANG2", (unsigned long) V4L2_TUNER_MODE_LANG2,
 
117
"SAP", (unsigned long) V4L2_TUNER_MODE_SAP,
 
118
"LANG1", (unsigned long) V4L2_TUNER_MODE_LANG1,
 
119
0);
 
120
}
 
121
 
 
122
static void
 
123
fprint_struct_v4l2_tuner (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_tuner *t)
 
124
{
 
125
fprintf (fp, "index=%lu "
 
126
"name=\"%.*s\" "
 
127
"type=",
 
128
(unsigned long) t->index, 
 
129
32, (const char *) t->name);
 
130
fprint_enum_v4l2_tuner_type (fp, rw, t->type);
 
131
fputs (" capability=", fp);
 
132
fprint_symbol_v4l2_tuner_cap_ (fp, rw, t->capability);
 
133
fprintf (fp, " rangelow=%lu "
 
134
"rangehigh=%lu "
 
135
"rxsubchans=",
 
136
(unsigned long) t->rangelow, 
 
137
(unsigned long) t->rangehigh);
 
138
fprint_symbol_v4l2_tuner_sub_ (fp, rw, t->rxsubchans);
 
139
fputs (" audmode=", fp);
 
140
fprint_symbol_v4l2_tuner_mode_ (fp, rw, t->audmode);
 
141
fprintf (fp, " signal=%ld "
 
142
"afc=%ld "
 
143
"reserved[] ",
 
144
(long) t->signal, 
 
145
(long) t->afc);
 
146
}
 
147
 
 
148
static void
 
149
fprint_symbol_v4l2_jpeg_marker_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
150
{
 
151
fprint_symbolic (fp, 0, value,
 
152
"DHT", (unsigned long) V4L2_JPEG_MARKER_DHT,
 
153
"DQT", (unsigned long) V4L2_JPEG_MARKER_DQT,
 
154
"DRI", (unsigned long) V4L2_JPEG_MARKER_DRI,
 
155
"COM", (unsigned long) V4L2_JPEG_MARKER_COM,
 
156
"APP", (unsigned long) V4L2_JPEG_MARKER_APP,
 
157
0);
 
158
}
 
159
 
 
160
static void
 
161
fprint_struct_v4l2_jpegcompression (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_jpegcompression *t)
 
162
{
 
163
fprintf (fp, "quality=%ld "
 
164
"APPn=%ld "
 
165
"APP_len=%ld "
 
166
"APP_data=\"%.*s\" "
 
167
"COM_len=%ld "
 
168
"COM_data=\"%.*s\" "
 
169
"jpeg_markers=",
 
170
(long) t->quality, 
 
171
(long) t->APPn, 
 
172
(long) t->APP_len, 
 
173
60, (const char *) t->APP_data, 
 
174
(long) t->COM_len, 
 
175
60, (const char *) t->COM_data);
 
176
fprint_symbol_v4l2_jpeg_marker_ (fp, rw, t->jpeg_markers);
 
177
fputs (" ", fp);
 
178
}
 
179
 
 
180
static void
 
181
fprint_symbol_v4l2_cid_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
182
{
 
183
fprint_symbolic (fp, 0, value,
 
184
"BASE", (unsigned long) V4L2_CID_BASE,
 
185
"PRIVATE_BASE", (unsigned long) V4L2_CID_PRIVATE_BASE,
 
186
"BRIGHTNESS", (unsigned long) V4L2_CID_BRIGHTNESS,
 
187
"CONTRAST", (unsigned long) V4L2_CID_CONTRAST,
 
188
"SATURATION", (unsigned long) V4L2_CID_SATURATION,
 
189
"HUE", (unsigned long) V4L2_CID_HUE,
 
190
"AUDIO_VOLUME", (unsigned long) V4L2_CID_AUDIO_VOLUME,
 
191
"AUDIO_BALANCE", (unsigned long) V4L2_CID_AUDIO_BALANCE,
 
192
"AUDIO_BASS", (unsigned long) V4L2_CID_AUDIO_BASS,
 
193
"AUDIO_TREBLE", (unsigned long) V4L2_CID_AUDIO_TREBLE,
 
194
"AUDIO_MUTE", (unsigned long) V4L2_CID_AUDIO_MUTE,
 
195
"AUDIO_LOUDNESS", (unsigned long) V4L2_CID_AUDIO_LOUDNESS,
 
196
"BLACK_LEVEL", (unsigned long) V4L2_CID_BLACK_LEVEL,
 
197
"AUTO_WHITE_BALANCE", (unsigned long) V4L2_CID_AUTO_WHITE_BALANCE,
 
198
"DO_WHITE_BALANCE", (unsigned long) V4L2_CID_DO_WHITE_BALANCE,
 
199
"RED_BALANCE", (unsigned long) V4L2_CID_RED_BALANCE,
 
200
"BLUE_BALANCE", (unsigned long) V4L2_CID_BLUE_BALANCE,
 
201
"GAMMA", (unsigned long) V4L2_CID_GAMMA,
 
202
"WHITENESS", (unsigned long) V4L2_CID_WHITENESS,
 
203
"EXPOSURE", (unsigned long) V4L2_CID_EXPOSURE,
 
204
"AUTOGAIN", (unsigned long) V4L2_CID_AUTOGAIN,
 
205
"GAIN", (unsigned long) V4L2_CID_GAIN,
 
206
"HFLIP", (unsigned long) V4L2_CID_HFLIP,
 
207
"VFLIP", (unsigned long) V4L2_CID_VFLIP,
 
208
"HCENTER", (unsigned long) V4L2_CID_HCENTER,
 
209
"VCENTER", (unsigned long) V4L2_CID_VCENTER,
 
210
"LASTP1", (unsigned long) V4L2_CID_LASTP1,
 
211
0);
 
212
}
 
213
 
 
214
static void
 
215
fprint_struct_v4l2_querymenu (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_querymenu *t)
 
216
{
 
217
fputs ("id=", fp);
 
218
fprint_symbol_v4l2_cid_ (fp, rw, t->id);
 
219
fputs (" index=", fp);
 
220
fprint_symbol_v4l2_cid_ (fp, rw, t->index);
 
221
fputs (" ", fp);
 
222
if (1 == rw) {
 
223
fprintf (fp, "name=\"%.*s\" "
 
224
"reserved ",
 
225
32, (const char *) t->name);
 
226
}
 
227
}
 
228
 
 
229
static void
 
230
fprint_symbol_v4l2_cap_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
231
{
 
232
fprint_symbolic (fp, 0, value,
 
233
"VIDEO_CAPTURE", (unsigned long) V4L2_CAP_VIDEO_CAPTURE,
 
234
"VIDEO_OUTPUT", (unsigned long) V4L2_CAP_VIDEO_OUTPUT,
 
235
"VIDEO_OVERLAY", (unsigned long) V4L2_CAP_VIDEO_OVERLAY,
 
236
"VBI_CAPTURE", (unsigned long) V4L2_CAP_VBI_CAPTURE,
 
237
"VBI_OUTPUT", (unsigned long) V4L2_CAP_VBI_OUTPUT,
 
238
"RDS_CAPTURE", (unsigned long) V4L2_CAP_RDS_CAPTURE,
 
239
"TUNER", (unsigned long) V4L2_CAP_TUNER,
 
240
"AUDIO", (unsigned long) V4L2_CAP_AUDIO,
 
241
"RADIO", (unsigned long) V4L2_CAP_RADIO,
 
242
"READWRITE", (unsigned long) V4L2_CAP_READWRITE,
 
243
"ASYNCIO", (unsigned long) V4L2_CAP_ASYNCIO,
 
244
"STREAMING", (unsigned long) V4L2_CAP_STREAMING,
 
245
"TIMEPERFRAME", (unsigned long) V4L2_CAP_TIMEPERFRAME,
 
246
0);
 
247
}
 
248
 
 
249
static void
 
250
fprint_struct_v4l2_capability (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_capability *t)
 
251
{
 
252
fprintf (fp, "driver=\"%.*s\" "
 
253
"card=\"%.*s\" "
 
254
"bus_info=\"%.*s\" "
 
255
"version=0x%lx "
 
256
"capabilities=",
 
257
16, (const char *) t->driver, 
 
258
32, (const char *) t->card, 
 
259
32, (const char *) t->bus_info, 
 
260
(unsigned long) t->version);
 
261
fprint_symbol_v4l2_cap_ (fp, rw, t->capabilities);
 
262
fputs (" reserved[] ", fp);
 
263
}
 
264
 
 
265
static void
 
266
fprint_enum_v4l2_buf_type (FILE *fp, int rw __attribute__ ((unused)), int value)
 
267
{
 
268
fprint_symbolic (fp, 1, value,
 
269
"VIDEO_CAPTURE", V4L2_BUF_TYPE_VIDEO_CAPTURE,
 
270
"VIDEO_OUTPUT", V4L2_BUF_TYPE_VIDEO_OUTPUT,
 
271
"VIDEO_OVERLAY", V4L2_BUF_TYPE_VIDEO_OVERLAY,
 
272
"VBI_CAPTURE", V4L2_BUF_TYPE_VBI_CAPTURE,
 
273
"VBI_OUTPUT", V4L2_BUF_TYPE_VBI_OUTPUT,
 
274
"PRIVATE", V4L2_BUF_TYPE_PRIVATE,
 
275
0);
 
276
}
 
277
 
 
278
static void
 
279
fprint_enum_v4l2_memory (FILE *fp, int rw __attribute__ ((unused)), int value)
 
280
{
 
281
fprint_symbolic (fp, 1, value,
 
282
"MMAP", V4L2_MEMORY_MMAP,
 
283
"USERPTR", V4L2_MEMORY_USERPTR,
 
284
"OVERLAY", V4L2_MEMORY_OVERLAY,
 
285
0);
 
286
}
 
287
 
 
288
static void
 
289
fprint_struct_v4l2_requestbuffers (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_requestbuffers *t)
 
290
{
 
291
fprintf (fp, "count=%lu "
 
292
"type=",
 
293
(unsigned long) t->count);
 
294
fprint_enum_v4l2_buf_type (fp, rw, t->type);
 
295
fputs (" memory=", fp);
 
296
fprint_enum_v4l2_memory (fp, rw, t->memory);
 
297
fputs (" reserved[] ", fp);
 
298
}
 
299
 
 
300
static void
 
301
fprint_symbol_v4l2_fbuf_cap_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
302
{
 
303
fprint_symbolic (fp, 0, value,
 
304
"EXTERNOVERLAY", (unsigned long) V4L2_FBUF_CAP_EXTERNOVERLAY,
 
305
"CHROMAKEY", (unsigned long) V4L2_FBUF_CAP_CHROMAKEY,
 
306
"LIST_CLIPPING", (unsigned long) V4L2_FBUF_CAP_LIST_CLIPPING,
 
307
"BITMAP_CLIPPING", (unsigned long) V4L2_FBUF_CAP_BITMAP_CLIPPING,
 
308
0);
 
309
}
 
310
 
 
311
static void
 
312
fprint_symbol_v4l2_pix_fmt_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
313
{
 
314
fprint_symbolic (fp, 0, value,
 
315
"RGB332", (unsigned long) V4L2_PIX_FMT_RGB332,
 
316
"RGB555", (unsigned long) V4L2_PIX_FMT_RGB555,
 
317
"RGB565", (unsigned long) V4L2_PIX_FMT_RGB565,
 
318
"RGB555X", (unsigned long) V4L2_PIX_FMT_RGB555X,
 
319
"RGB565X", (unsigned long) V4L2_PIX_FMT_RGB565X,
 
320
"BGR24", (unsigned long) V4L2_PIX_FMT_BGR24,
 
321
"RGB24", (unsigned long) V4L2_PIX_FMT_RGB24,
 
322
"BGR32", (unsigned long) V4L2_PIX_FMT_BGR32,
 
323
"RGB32", (unsigned long) V4L2_PIX_FMT_RGB32,
 
324
"GREY", (unsigned long) V4L2_PIX_FMT_GREY,
 
325
"YVU410", (unsigned long) V4L2_PIX_FMT_YVU410,
 
326
"YVU420", (unsigned long) V4L2_PIX_FMT_YVU420,
 
327
"YUYV", (unsigned long) V4L2_PIX_FMT_YUYV,
 
328
"UYVY", (unsigned long) V4L2_PIX_FMT_UYVY,
 
329
"YUV422P", (unsigned long) V4L2_PIX_FMT_YUV422P,
 
330
"YUV411P", (unsigned long) V4L2_PIX_FMT_YUV411P,
 
331
"Y41P", (unsigned long) V4L2_PIX_FMT_Y41P,
 
332
"NV12", (unsigned long) V4L2_PIX_FMT_NV12,
 
333
"NV21", (unsigned long) V4L2_PIX_FMT_NV21,
 
334
"YUV410", (unsigned long) V4L2_PIX_FMT_YUV410,
 
335
"YUV420", (unsigned long) V4L2_PIX_FMT_YUV420,
 
336
"YYUV", (unsigned long) V4L2_PIX_FMT_YYUV,
 
337
"HI240", (unsigned long) V4L2_PIX_FMT_HI240,
 
338
"SBGGR8", (unsigned long) V4L2_PIX_FMT_SBGGR8,
 
339
"MJPEG", (unsigned long) V4L2_PIX_FMT_MJPEG,
 
340
"JPEG", (unsigned long) V4L2_PIX_FMT_JPEG,
 
341
"DV", (unsigned long) V4L2_PIX_FMT_DV,
 
342
"MPEG", (unsigned long) V4L2_PIX_FMT_MPEG,
 
343
"WNVA", (unsigned long) V4L2_PIX_FMT_WNVA,
 
344
0);
 
345
}
 
346
 
 
347
static void
 
348
fprint_enum_v4l2_field (FILE *fp, int rw __attribute__ ((unused)), int value)
 
349
{
 
350
fprint_symbolic (fp, 1, value,
 
351
"ANY", V4L2_FIELD_ANY,
 
352
"NONE", V4L2_FIELD_NONE,
 
353
"TOP", V4L2_FIELD_TOP,
 
354
"BOTTOM", V4L2_FIELD_BOTTOM,
 
355
"INTERLACED", V4L2_FIELD_INTERLACED,
 
356
"SEQ_TB", V4L2_FIELD_SEQ_TB,
 
357
"SEQ_BT", V4L2_FIELD_SEQ_BT,
 
358
"ALTERNATE", V4L2_FIELD_ALTERNATE,
 
359
0);
 
360
}
 
361
 
 
362
static void
 
363
fprint_enum_v4l2_colorspace (FILE *fp, int rw __attribute__ ((unused)), int value)
 
364
{
 
365
fprint_symbolic (fp, 1, value,
 
366
"SMPTE170M", V4L2_COLORSPACE_SMPTE170M,
 
367
"SMPTE240M", V4L2_COLORSPACE_SMPTE240M,
 
368
"REC709", V4L2_COLORSPACE_REC709,
 
369
"BT878", V4L2_COLORSPACE_BT878,
 
370
"470_SYSTEM_M", V4L2_COLORSPACE_470_SYSTEM_M,
 
371
"470_SYSTEM_BG", V4L2_COLORSPACE_470_SYSTEM_BG,
 
372
"JPEG", V4L2_COLORSPACE_JPEG,
 
373
"SRGB", V4L2_COLORSPACE_SRGB,
 
374
0);
 
375
}
 
376
 
 
377
static void
 
378
fprint_struct_v4l2_pix_format (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_pix_format *t)
 
379
{
 
380
fprintf (fp, "width=%lu "
 
381
"height=%lu "
 
382
"pixelformat=",
 
383
(unsigned long) t->width, 
 
384
(unsigned long) t->height);
 
385
fprint_symbol_v4l2_pix_fmt_ (fp, rw, t->pixelformat);
 
386
fputs (" field=", fp);
 
387
fprint_enum_v4l2_field (fp, rw, t->field);
 
388
fprintf (fp, " bytesperline=%lu "
 
389
"sizeimage=%lu "
 
390
"colorspace=",
 
391
(unsigned long) t->bytesperline, 
 
392
(unsigned long) t->sizeimage);
 
393
fprint_enum_v4l2_colorspace (fp, rw, t->colorspace);
 
394
fprintf (fp, " priv=%lu ",
 
395
(unsigned long) t->priv);
 
396
}
 
397
 
 
398
static void
 
399
fprint_struct_v4l2_framebuffer (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_framebuffer *t)
 
400
{
 
401
fputs ("capability=", fp);
 
402
fprint_symbol_v4l2_fbuf_cap_ (fp, rw, t->capability);
 
403
fputs (" flags=", fp);
 
404
fprint_symbolic (fp, 2, t->flags,
 
405
"PRIMARY", (unsigned long) V4L2_FBUF_FLAG_PRIMARY,
 
406
"OVERLAY", (unsigned long) V4L2_FBUF_FLAG_OVERLAY,
 
407
"CHROMAKEY", (unsigned long) V4L2_FBUF_FLAG_CHROMAKEY,
 
408
0);
 
409
fputs (" base=? "
 
410
"fmt={", fp);
 
411
fprint_struct_v4l2_pix_format (fp, rw, &t->fmt);
 
412
fputs ("} ", fp);
 
413
}
 
414
 
 
415
static void
 
416
fprint_struct_v4l2_rect (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_rect *t)
 
417
{
 
418
fprintf (fp, "left=%ld "
 
419
"top=%ld "
 
420
"width=%ld "
 
421
"height=%ld ",
 
422
(long) t->left, 
 
423
(long) t->top, 
 
424
(long) t->width, 
 
425
(long) t->height);
 
426
}
 
427
 
 
428
static void
 
429
fprint_struct_v4l2_crop (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_crop *t)
 
430
{
 
431
fputs ("type=", fp);
 
432
fprint_enum_v4l2_buf_type (fp, rw, t->type);
 
433
fputs (" c={", fp);
 
434
fprint_struct_v4l2_rect (fp, rw, &t->c);
 
435
fputs ("} ", fp);
 
436
}
 
437
 
 
438
static void
 
439
fprint_struct_v4l2_fmtdesc (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_fmtdesc *t)
 
440
{
 
441
fprintf (fp, "index=%lu ",
 
442
(unsigned long) t->index);
 
443
if (1 == rw) {
 
444
fputs ("type=", fp);
 
445
fprint_enum_v4l2_buf_type (fp, rw, t->type);
 
446
fputs (" flags=", fp);
 
447
fprint_symbolic (fp, 2, t->flags,
 
448
"COMPRESSED", (unsigned long) V4L2_FMT_FLAG_COMPRESSED,
 
449
0);
 
450
fprintf (fp, " description=\"%.*s\" "
 
451
"pixelformat=\"%.4s\"=0x%lx "
 
452
"reserved[] ",
 
453
32, (const char *) t->description, 
 
454
(const char *) & t->pixelformat, (unsigned long) t->pixelformat);
 
455
}
 
456
}
 
457
 
 
458
static void
 
459
fprint_enum_v4l2_ctrl_type (FILE *fp, int rw __attribute__ ((unused)), int value)
 
460
{
 
461
fprint_symbolic (fp, 1, value,
 
462
"INTEGER", V4L2_CTRL_TYPE_INTEGER,
 
463
"BOOLEAN", V4L2_CTRL_TYPE_BOOLEAN,
 
464
"MENU", V4L2_CTRL_TYPE_MENU,
 
465
"BUTTON", V4L2_CTRL_TYPE_BUTTON,
 
466
0);
 
467
}
 
468
 
 
469
static void
 
470
fprint_struct_v4l2_queryctrl (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_queryctrl *t)
 
471
{
 
472
fputs ("id=", fp);
 
473
fprint_symbol_v4l2_cid_ (fp, rw, t->id);
 
474
fputs (" ", fp);
 
475
if (1 == rw) {
 
476
fputs ("type=", fp);
 
477
fprint_enum_v4l2_ctrl_type (fp, rw, t->type);
 
478
fprintf (fp, " name=\"%.*s\" "
 
479
"minimum=%ld "
 
480
"maximum=%ld "
 
481
"step=%ld "
 
482
"default_value=%ld "
 
483
"flags=",
 
484
32, (const char *) t->name, 
 
485
(long) t->minimum, 
 
486
(long) t->maximum, 
 
487
(long) t->step, 
 
488
(long) t->default_value);
 
489
fprint_symbolic (fp, 2, t->flags,
 
490
"DISABLED", (unsigned long) V4L2_CTRL_FLAG_DISABLED,
 
491
"GRABBED", (unsigned long) V4L2_CTRL_FLAG_GRABBED,
 
492
0);
 
493
fputs (" reserved[] ", fp);
 
494
}
 
495
}
 
496
 
 
497
static void
 
498
fprint_struct_v4l2_window (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_window *t)
 
499
{
 
500
fputs ("w={", fp);
 
501
fprint_struct_v4l2_rect (fp, rw, &t->w);
 
502
fputs ("} field=", fp);
 
503
fprint_enum_v4l2_field (fp, rw, t->field);
 
504
fprintf (fp, " chromakey=%lu "
 
505
"clips=%p "
 
506
"clipcount=%lu "
 
507
"bitmap=%p ",
 
508
(unsigned long) t->chromakey, 
 
509
(const void *) t->clips, 
 
510
(unsigned long) t->clipcount, 
 
511
(const void *) t->bitmap);
 
512
}
 
513
 
 
514
static void
 
515
fprint_struct_v4l2_vbi_format (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_vbi_format *t)
 
516
{
 
517
fprintf (fp, "sampling_rate=%lu "
 
518
"offset=%lu "
 
519
"samples_per_line=%lu "
 
520
"sample_format=",
 
521
(unsigned long) t->sampling_rate, 
 
522
(unsigned long) t->offset, 
 
523
(unsigned long) t->samples_per_line);
 
524
fprint_symbol_v4l2_pix_fmt_ (fp, rw, t->sample_format);
 
525
fputs (" start[]=? "
 
526
"count[]=? "
 
527
"flags=", fp);
 
528
fprint_symbolic (fp, 2, t->flags,
 
529
"UNSYNC", (unsigned long) V4L2_VBI_UNSYNC,
 
530
"INTERLACED", (unsigned long) V4L2_VBI_INTERLACED,
 
531
0);
 
532
fputs (" reserved[] ", fp);
 
533
}
 
534
 
 
535
static void
 
536
fprint_struct_v4l2_format (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_format *t)
 
537
{
 
538
fputs ("type=", fp);
 
539
fprint_enum_v4l2_buf_type (fp, rw, t->type);
 
540
fputs (" ", fp);
 
541
fputs ("fmt={", fp);
 
542
if (V4L2_BUF_TYPE_VIDEO_CAPTURE == t->type) {
 
543
fputs ("pix={", fp);
 
544
fprint_struct_v4l2_pix_format (fp, rw, &t->fmt.pix);
 
545
fputs ("} ", fp);
 
546
}
 
547
if (V4L2_BUF_TYPE_VIDEO_OVERLAY == t->type) {
 
548
fputs ("win={", fp);
 
549
fprint_struct_v4l2_window (fp, rw, &t->fmt.win);
 
550
fputs ("} ", fp);
 
551
}
 
552
if (V4L2_BUF_TYPE_VBI_CAPTURE == t->type) {
 
553
fputs ("vbi={", fp);
 
554
fprint_struct_v4l2_vbi_format (fp, rw, &t->fmt.vbi);
 
555
fputs ("} ", fp);
 
556
}
 
557
fputs ("raw_data[]=? ", fp);
 
558
fputs ("} ", fp);
 
559
}
 
560
 
 
561
static void
 
562
fprint_struct_v4l2_control (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_control *t)
 
563
{
 
564
fputs ("id=", fp);
 
565
fprint_symbol_v4l2_cid_ (fp, rw, t->id);
 
566
fprintf (fp, " value=%ld ",
 
567
(long) t->value);
 
568
}
 
569
 
 
570
static void
 
571
fprint_struct_v4l2_cropcap (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_cropcap *t)
 
572
{
 
573
fputs ("type=", fp);
 
574
fprint_enum_v4l2_buf_type (fp, rw, t->type);
 
575
fputs (" bounds={", fp);
 
576
fprint_struct_v4l2_rect (fp, rw, &t->bounds);
 
577
fputs ("} defrect={", fp);
 
578
fprint_struct_v4l2_rect (fp, rw, &t->defrect);
 
579
fputs ("} pixelaspect={", fp);
 
580
fprint_struct_v4l2_fract (fp, rw, &t->pixelaspect);
 
581
fputs ("} ", fp);
 
582
}
 
583
 
 
584
static void
 
585
fprint_struct_v4l2_audio (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_audio *t)
 
586
{
 
587
fprintf (fp, "index=%lu ",
 
588
(unsigned long) t->index);
 
589
if (1 == rw) {
 
590
fprintf (fp, "name=\"%.*s\" "
 
591
"capability=",
 
592
32, (const char *) t->name);
 
593
fprint_symbolic (fp, 0, t->capability,
 
594
"STEREO", (unsigned long) V4L2_AUDCAP_STEREO,
 
595
"AVL", (unsigned long) V4L2_AUDCAP_AVL,
 
596
0);
 
597
fputs (" mode=", fp);
 
598
fprint_symbolic (fp, 0, t->mode,
 
599
"AVL", (unsigned long) V4L2_AUDMODE_AVL,
 
600
0);
 
601
fputs (" reserved[] ", fp);
 
602
}
 
603
}
 
604
 
 
605
static void
 
606
fprint_symbol_v4l2_buf_flag_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
607
{
 
608
fprint_symbolic (fp, 2, value,
 
609
"MAPPED", (unsigned long) V4L2_BUF_FLAG_MAPPED,
 
610
"QUEUED", (unsigned long) V4L2_BUF_FLAG_QUEUED,
 
611
"DONE", (unsigned long) V4L2_BUF_FLAG_DONE,
 
612
"KEYFRAME", (unsigned long) V4L2_BUF_FLAG_KEYFRAME,
 
613
"PFRAME", (unsigned long) V4L2_BUF_FLAG_PFRAME,
 
614
"BFRAME", (unsigned long) V4L2_BUF_FLAG_BFRAME,
 
615
"TIMECODE", (unsigned long) V4L2_BUF_FLAG_TIMECODE,
 
616
"INPUT", (unsigned long) V4L2_BUF_FLAG_INPUT,
 
617
0);
 
618
}
 
619
 
 
620
static void
 
621
fprint_symbol_v4l2_tc_type_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
622
{
 
623
fprint_symbolic (fp, 0, value,
 
624
"24FPS", (unsigned long) V4L2_TC_TYPE_24FPS,
 
625
"25FPS", (unsigned long) V4L2_TC_TYPE_25FPS,
 
626
"30FPS", (unsigned long) V4L2_TC_TYPE_30FPS,
 
627
"50FPS", (unsigned long) V4L2_TC_TYPE_50FPS,
 
628
"60FPS", (unsigned long) V4L2_TC_TYPE_60FPS,
 
629
0);
 
630
}
 
631
 
 
632
static void
 
633
fprint_struct_v4l2_timecode (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_timecode *t)
 
634
{
 
635
fputs ("type=", fp);
 
636
fprint_symbol_v4l2_tc_type_ (fp, rw, t->type);
 
637
fputs (" flags=", fp);
 
638
fprint_symbolic (fp, 2, t->flags,
 
639
"DROPFRAME", (unsigned long) V4L2_TC_FLAG_DROPFRAME,
 
640
"COLORFRAME", (unsigned long) V4L2_TC_FLAG_COLORFRAME,
 
641
0);
 
642
fprintf (fp, " frames=%lu "
 
643
"seconds=%lu "
 
644
"minutes=%lu "
 
645
"hours=%lu "
 
646
"userbits[]=? ",
 
647
(unsigned long) t->frames, 
 
648
(unsigned long) t->seconds, 
 
649
(unsigned long) t->minutes, 
 
650
(unsigned long) t->hours);
 
651
}
 
652
 
 
653
static void
 
654
fprint_struct_v4l2_buffer (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_buffer *t)
 
655
{
 
656
fprintf (fp, "index=%lu "
 
657
"type=",
 
658
(unsigned long) t->index);
 
659
fprint_enum_v4l2_buf_type (fp, rw, t->type);
 
660
fputs (" ", fp);
 
661
if (1 == rw) {
 
662
fprintf (fp, "bytesused=%lu ",
 
663
(unsigned long) t->bytesused);
 
664
}
 
665
fputs ("flags=", fp);
 
666
fprint_symbol_v4l2_buf_flag_ (fp, rw, t->flags);
 
667
fputs (" ", fp);
 
668
if (1 == rw) {
 
669
fputs ("field=", fp);
 
670
fprint_enum_v4l2_field (fp, rw, t->field);
 
671
fputs (" timestamp=? timecode={", fp);
 
672
fprint_struct_v4l2_timecode (fp, rw, &t->timecode);
 
673
fprintf (fp, "} sequence=%lu "
 
674
"memory=",
 
675
(unsigned long) t->sequence);
 
676
fprint_enum_v4l2_memory (fp, rw, t->memory);
 
677
fputs (" ", fp);
 
678
fputs ("m={", fp);
 
679
}
 
680
if (1 == rw && V4L2_MEMORY_MMAP == t->memory) {
 
681
fprintf (fp, "offset=%lu ",
 
682
(unsigned long) t->m.offset);
 
683
}
 
684
if (1 == rw && V4L2_MEMORY_USERPTR == t->memory) {
 
685
fprintf (fp, "userptr=%lu ",
 
686
(unsigned long) t->m.userptr);
 
687
}
 
688
if (1 == rw) {
 
689
fprintf (fp, "} length=%lu "
 
690
"input=%lu "
 
691
"reserved ",
 
692
(unsigned long) t->length, 
 
693
(unsigned long) t->input);
 
694
}
 
695
}
 
696
 
 
697
static void
 
698
fprint_struct_v4l2_captureparm (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_captureparm *t)
 
699
{
 
700
fputs ("capability=", fp);
 
701
fprint_symbol_v4l2_cap_ (fp, rw, t->capability);
 
702
fputs (" capturemode=", fp);
 
703
fprint_symbolic (fp, 0, t->capturemode,
 
704
"HIGHQUALITY", (unsigned long) V4L2_MODE_HIGHQUALITY,
 
705
0);
 
706
fputs (" timeperframe={", fp);
 
707
fprint_struct_v4l2_fract (fp, rw, &t->timeperframe);
 
708
fprintf (fp, "} extendedmode=%lu "
 
709
"readbuffers=%lu "
 
710
"reserved[] ",
 
711
(unsigned long) t->extendedmode, 
 
712
(unsigned long) t->readbuffers);
 
713
}
 
714
 
 
715
static void
 
716
fprint_struct_v4l2_outputparm (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_outputparm *t)
 
717
{
 
718
fprintf (fp, "capability=%lu "
 
719
"outputmode=%lu "
 
720
"timeperframe={",
 
721
(unsigned long) t->capability, 
 
722
(unsigned long) t->outputmode);
 
723
fprint_struct_v4l2_fract (fp, rw, &t->timeperframe);
 
724
fprintf (fp, "} extendedmode=%lu "
 
725
"writebuffers=%lu "
 
726
"reserved[] ",
 
727
(unsigned long) t->extendedmode, 
 
728
(unsigned long) t->writebuffers);
 
729
}
 
730
 
 
731
static void
 
732
fprint_struct_v4l2_streamparm (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_streamparm *t)
 
733
{
 
734
fputs ("type=", fp);
 
735
fprint_enum_v4l2_buf_type (fp, rw, t->type);
 
736
fputs (" ", fp);
 
737
fputs ("parm={capture={", fp);
 
738
fprint_struct_v4l2_captureparm (fp, rw, &t->parm.capture);
 
739
fputs ("} output={", fp);
 
740
fprint_struct_v4l2_outputparm (fp, rw, &t->parm.output);
 
741
fputs ("} raw_data[]=? ", fp);
 
742
fputs ("} ", fp);
 
743
}
 
744
 
 
745
static void
 
746
fprint_struct_v4l2_modulator (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_modulator *t)
 
747
{
 
748
fprintf (fp, "index=%lu "
 
749
"name=\"%.*s\" "
 
750
"capability=",
 
751
(unsigned long) t->index, 
 
752
32, (const char *) t->name);
 
753
fprint_symbol_v4l2_tuner_cap_ (fp, rw, t->capability);
 
754
fprintf (fp, " rangelow=%lu "
 
755
"rangehigh=%lu "
 
756
"txsubchans=",
 
757
(unsigned long) t->rangelow, 
 
758
(unsigned long) t->rangehigh);
 
759
fprint_symbol_v4l2_tuner_sub_ (fp, rw, t->txsubchans);
 
760
fputs (" reserved[] ", fp);
 
761
}
 
762
 
 
763
static void
 
764
fprint_struct_v4l2_output (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_output *t)
 
765
{
 
766
fprintf (fp, "index=%lu ",
 
767
(unsigned long) t->index);
 
768
if (1 == rw) {
 
769
fprintf (fp, "name=\"%.*s\" "
 
770
"type=",
 
771
32, (const char *) t->name);
 
772
fprint_symbolic (fp, 0, t->type,
 
773
"MODULATOR", (unsigned long) V4L2_OUTPUT_TYPE_MODULATOR,
 
774
"ANALOG", (unsigned long) V4L2_OUTPUT_TYPE_ANALOG,
 
775
"ANALOGVGAOVERLAY", (unsigned long) V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY,
 
776
0);
 
777
fprintf (fp, " audioset=%lu "
 
778
"modulator=%lu "
 
779
"std=",
 
780
(unsigned long) t->audioset, 
 
781
(unsigned long) t->modulator);
 
782
fprint_symbol_v4l2_std_ (fp, rw, t->std);
 
783
fputs (" reserved[] ", fp);
 
784
}
 
785
}
 
786
 
 
787
static void
 
788
fprint_struct_v4l2_frequency (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_frequency *t)
 
789
{
 
790
fprintf (fp, "tuner=%lu "
 
791
"type=",
 
792
(unsigned long) t->tuner);
 
793
fprint_enum_v4l2_tuner_type (fp, rw, t->type);
 
794
fprintf (fp, " frequency=%lu "
 
795
"reserved[] ",
 
796
(unsigned long) t->frequency);
 
797
}
 
798
 
 
799
static void
 
800
fprint_symbol_v4l2_in_st_ (FILE *fp, int rw __attribute__ ((unused)), unsigned long value)
 
801
{
 
802
fprint_symbolic (fp, 0, value,
 
803
"NO_POWER", (unsigned long) V4L2_IN_ST_NO_POWER,
 
804
"NO_SIGNAL", (unsigned long) V4L2_IN_ST_NO_SIGNAL,
 
805
"NO_COLOR", (unsigned long) V4L2_IN_ST_NO_COLOR,
 
806
"NO_H_LOCK", (unsigned long) V4L2_IN_ST_NO_H_LOCK,
 
807
"COLOR_KILL", (unsigned long) V4L2_IN_ST_COLOR_KILL,
 
808
"NO_SYNC", (unsigned long) V4L2_IN_ST_NO_SYNC,
 
809
"NO_EQU", (unsigned long) V4L2_IN_ST_NO_EQU,
 
810
"NO_CARRIER", (unsigned long) V4L2_IN_ST_NO_CARRIER,
 
811
"MACROVISION", (unsigned long) V4L2_IN_ST_MACROVISION,
 
812
"NO_ACCESS", (unsigned long) V4L2_IN_ST_NO_ACCESS,
 
813
"VTR", (unsigned long) V4L2_IN_ST_VTR,
 
814
0);
 
815
}
 
816
 
 
817
static void
 
818
fprint_struct_v4l2_input (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_input *t)
 
819
{
 
820
fprintf (fp, "index=%lu ",
 
821
(unsigned long) t->index);
 
822
if (1 == rw) {
 
823
fprintf (fp, "name=\"%.*s\" "
 
824
"type=",
 
825
32, (const char *) t->name);
 
826
fprint_symbolic (fp, 0, t->type,
 
827
"TUNER", (unsigned long) V4L2_INPUT_TYPE_TUNER,
 
828
"CAMERA", (unsigned long) V4L2_INPUT_TYPE_CAMERA,
 
829
0);
 
830
fprintf (fp, " audioset=%lu "
 
831
"tuner=%lu "
 
832
"std=",
 
833
(unsigned long) t->audioset, 
 
834
(unsigned long) t->tuner);
 
835
fprint_symbol_v4l2_std_ (fp, rw, t->std);
 
836
fputs (" status=", fp);
 
837
fprint_symbol_v4l2_in_st_ (fp, rw, t->status);
 
838
fputs (" reserved[] ", fp);
 
839
}
 
840
}
 
841
 
 
842
static void
 
843
fprint_struct_v4l2_audioout (FILE *fp, int rw __attribute__ ((unused)), const struct v4l2_audioout *t)
 
844
{
 
845
fprintf (fp, "index=%lu ",
 
846
(unsigned long) t->index);
 
847
if (1 == rw) {
 
848
fprintf (fp, "name=\"%.*s\" "
 
849
"capability=%lu "
 
850
"mode=%lu "
 
851
"reserved[] ",
 
852
32, (const char *) t->name, 
 
853
(unsigned long) t->capability, 
 
854
(unsigned long) t->mode);
 
855
}
 
856
}
 
857
 
 
858
static void
 
859
fprint_v4l25_ioctl_arg (FILE *fp, unsigned int cmd, int rw, void *arg)
 
860
{
 
861
switch (cmd) {
 
862
case VIDIOC_ENUMSTD:
 
863
if (!arg) { fputs ("VIDIOC_ENUMSTD", fp); return; }
 
864
 fprint_struct_v4l2_standard (fp, rw, arg);
 
865
break;
 
866
case VIDIOC_G_TUNER:
 
867
if (!arg) { fputs ("VIDIOC_G_TUNER", fp); return; }
 
868
case VIDIOC_S_TUNER:
 
869
if (!arg) { fputs ("VIDIOC_S_TUNER", fp); return; }
 
870
 fprint_struct_v4l2_tuner (fp, rw, arg);
 
871
break;
 
872
case VIDIOC_G_JPEGCOMP:
 
873
if (!arg) { fputs ("VIDIOC_G_JPEGCOMP", fp); return; }
 
874
case VIDIOC_S_JPEGCOMP:
 
875
if (!arg) { fputs ("VIDIOC_S_JPEGCOMP", fp); return; }
 
876
 fprint_struct_v4l2_jpegcompression (fp, rw, arg);
 
877
break;
 
878
case VIDIOC_QUERYMENU:
 
879
if (!arg) { fputs ("VIDIOC_QUERYMENU", fp); return; }
 
880
 fprint_struct_v4l2_querymenu (fp, rw, arg);
 
881
break;
 
882
case VIDIOC_QUERYCAP:
 
883
if (!arg) { fputs ("VIDIOC_QUERYCAP", fp); return; }
 
884
 fprint_struct_v4l2_capability (fp, rw, arg);
 
885
break;
 
886
case VIDIOC_REQBUFS:
 
887
if (!arg) { fputs ("VIDIOC_REQBUFS", fp); return; }
 
888
 fprint_struct_v4l2_requestbuffers (fp, rw, arg);
 
889
break;
 
890
case VIDIOC_G_FBUF:
 
891
if (!arg) { fputs ("VIDIOC_G_FBUF", fp); return; }
 
892
case VIDIOC_S_FBUF:
 
893
if (!arg) { fputs ("VIDIOC_S_FBUF", fp); return; }
 
894
 fprint_struct_v4l2_framebuffer (fp, rw, arg);
 
895
break;
 
896
case VIDIOC_G_CROP:
 
897
if (!arg) { fputs ("VIDIOC_G_CROP", fp); return; }
 
898
case VIDIOC_S_CROP:
 
899
if (!arg) { fputs ("VIDIOC_S_CROP", fp); return; }
 
900
 fprint_struct_v4l2_crop (fp, rw, arg);
 
901
break;
 
902
case VIDIOC_ENUM_FMT:
 
903
if (!arg) { fputs ("VIDIOC_ENUM_FMT", fp); return; }
 
904
 fprint_struct_v4l2_fmtdesc (fp, rw, arg);
 
905
break;
 
906
case VIDIOC_QUERYCTRL:
 
907
if (!arg) { fputs ("VIDIOC_QUERYCTRL", fp); return; }
 
908
 fprint_struct_v4l2_queryctrl (fp, rw, arg);
 
909
break;
 
910
case VIDIOC_G_FMT:
 
911
if (!arg) { fputs ("VIDIOC_G_FMT", fp); return; }
 
912
case VIDIOC_S_FMT:
 
913
if (!arg) { fputs ("VIDIOC_S_FMT", fp); return; }
 
914
case VIDIOC_TRY_FMT:
 
915
if (!arg) { fputs ("VIDIOC_TRY_FMT", fp); return; }
 
916
 fprint_struct_v4l2_format (fp, rw, arg);
 
917
break;
 
918
case VIDIOC_G_CTRL:
 
919
if (!arg) { fputs ("VIDIOC_G_CTRL", fp); return; }
 
920
case VIDIOC_S_CTRL:
 
921
if (!arg) { fputs ("VIDIOC_S_CTRL", fp); return; }
 
922
case VIDIOC_S_CTRL_OLD:
 
923
if (!arg) { fputs ("VIDIOC_S_CTRL_OLD", fp); return; }
 
924
 fprint_struct_v4l2_control (fp, rw, arg);
 
925
break;
 
926
case VIDIOC_CROPCAP:
 
927
if (!arg) { fputs ("VIDIOC_CROPCAP", fp); return; }
 
928
case VIDIOC_CROPCAP_OLD:
 
929
if (!arg) { fputs ("VIDIOC_CROPCAP_OLD", fp); return; }
 
930
 fprint_struct_v4l2_cropcap (fp, rw, arg);
 
931
break;
 
932
case VIDIOC_G_AUDIO:
 
933
if (!arg) { fputs ("VIDIOC_G_AUDIO", fp); return; }
 
934
case VIDIOC_S_AUDIO:
 
935
if (!arg) { fputs ("VIDIOC_S_AUDIO", fp); return; }
 
936
case VIDIOC_ENUMAUDIO:
 
937
if (!arg) { fputs ("VIDIOC_ENUMAUDIO", fp); return; }
 
938
case VIDIOC_G_AUDIO_OLD:
 
939
if (!arg) { fputs ("VIDIOC_G_AUDIO_OLD", fp); return; }
 
940
 fprint_struct_v4l2_audio (fp, rw, arg);
 
941
break;
 
942
case VIDIOC_QUERYBUF:
 
943
if (!arg) { fputs ("VIDIOC_QUERYBUF", fp); return; }
 
944
case VIDIOC_QBUF:
 
945
if (!arg) { fputs ("VIDIOC_QBUF", fp); return; }
 
946
case VIDIOC_DQBUF:
 
947
if (!arg) { fputs ("VIDIOC_DQBUF", fp); return; }
 
948
 fprint_struct_v4l2_buffer (fp, rw, arg);
 
949
break;
 
950
case VIDIOC_OVERLAY:
 
951
if (!arg) { fputs ("VIDIOC_OVERLAY", fp); return; }
 
952
case VIDIOC_STREAMON:
 
953
if (!arg) { fputs ("VIDIOC_STREAMON", fp); return; }
 
954
case VIDIOC_STREAMOFF:
 
955
if (!arg) { fputs ("VIDIOC_STREAMOFF", fp); return; }
 
956
case VIDIOC_G_INPUT:
 
957
if (!arg) { fputs ("VIDIOC_G_INPUT", fp); return; }
 
958
case VIDIOC_S_INPUT:
 
959
if (!arg) { fputs ("VIDIOC_S_INPUT", fp); return; }
 
960
case VIDIOC_G_OUTPUT:
 
961
if (!arg) { fputs ("VIDIOC_G_OUTPUT", fp); return; }
 
962
case VIDIOC_S_OUTPUT:
 
963
if (!arg) { fputs ("VIDIOC_S_OUTPUT", fp); return; }
 
964
case VIDIOC_OVERLAY_OLD:
 
965
if (!arg) { fputs ("VIDIOC_OVERLAY_OLD", fp); return; }
 
966
 fprintf (fp, "%ld", (long) * (int *) arg);
 
967
break;
 
968
case VIDIOC_G_PARM:
 
969
if (!arg) { fputs ("VIDIOC_G_PARM", fp); return; }
 
970
case VIDIOC_S_PARM:
 
971
if (!arg) { fputs ("VIDIOC_S_PARM", fp); return; }
 
972
case VIDIOC_S_PARM_OLD:
 
973
if (!arg) { fputs ("VIDIOC_S_PARM_OLD", fp); return; }
 
974
 fprint_struct_v4l2_streamparm (fp, rw, arg);
 
975
break;
 
976
case VIDIOC_G_MODULATOR:
 
977
if (!arg) { fputs ("VIDIOC_G_MODULATOR", fp); return; }
 
978
case VIDIOC_S_MODULATOR:
 
979
if (!arg) { fputs ("VIDIOC_S_MODULATOR", fp); return; }
 
980
 fprint_struct_v4l2_modulator (fp, rw, arg);
 
981
break;
 
982
case VIDIOC_ENUMOUTPUT:
 
983
if (!arg) { fputs ("VIDIOC_ENUMOUTPUT", fp); return; }
 
984
 fprint_struct_v4l2_output (fp, rw, arg);
 
985
break;
 
986
case VIDIOC_G_FREQUENCY:
 
987
if (!arg) { fputs ("VIDIOC_G_FREQUENCY", fp); return; }
 
988
case VIDIOC_S_FREQUENCY:
 
989
if (!arg) { fputs ("VIDIOC_S_FREQUENCY", fp); return; }
 
990
 fprint_struct_v4l2_frequency (fp, rw, arg);
 
991
break;
 
992
case VIDIOC_ENUMINPUT:
 
993
if (!arg) { fputs ("VIDIOC_ENUMINPUT", fp); return; }
 
994
 fprint_struct_v4l2_input (fp, rw, arg);
 
995
break;
 
996
case VIDIOC_G_AUDOUT:
 
997
if (!arg) { fputs ("VIDIOC_G_AUDOUT", fp); return; }
 
998
case VIDIOC_S_AUDOUT:
 
999
if (!arg) { fputs ("VIDIOC_S_AUDOUT", fp); return; }
 
1000
case VIDIOC_ENUMAUDOUT:
 
1001
if (!arg) { fputs ("VIDIOC_ENUMAUDOUT", fp); return; }
 
1002
case VIDIOC_G_AUDOUT_OLD:
 
1003
if (!arg) { fputs ("VIDIOC_G_AUDOUT_OLD", fp); return; }
 
1004
 fprint_struct_v4l2_audioout (fp, rw, arg);
 
1005
break;
 
1006
        default:
 
1007
                if (!arg) { fprint_unknown_ioctl (fp, cmd, arg); return; }
 
1008
                break;
 
1009
        }
 
1010
}
 
1011
 
 
1012
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_QUERYCAP (struct v4l2_capability *arg __attribute__ ((unused))) {}
 
1013
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_ENUM_FMT (struct v4l2_fmtdesc *arg __attribute__ ((unused))) {}
 
1014
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_FMT (struct v4l2_format *arg __attribute__ ((unused))) {}
 
1015
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_FMT (struct v4l2_format *arg __attribute__ ((unused))) {}
 
1016
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_REQBUFS (struct v4l2_requestbuffers *arg __attribute__ ((unused))) {}
 
1017
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_QUERYBUF (struct v4l2_buffer *arg __attribute__ ((unused))) {}
 
1018
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_FBUF (struct v4l2_framebuffer *arg __attribute__ ((unused))) {}
 
1019
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_FBUF (const struct v4l2_framebuffer *arg __attribute__ ((unused))) {}
 
1020
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_OVERLAY (const int *arg __attribute__ ((unused))) {}
 
1021
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_QBUF (struct v4l2_buffer *arg __attribute__ ((unused))) {}
 
1022
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_DQBUF (struct v4l2_buffer *arg __attribute__ ((unused))) {}
 
1023
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_STREAMON (const int *arg __attribute__ ((unused))) {}
 
1024
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_STREAMOFF (const int *arg __attribute__ ((unused))) {}
 
1025
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_PARM (struct v4l2_streamparm *arg __attribute__ ((unused))) {}
 
1026
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_PARM (struct v4l2_streamparm *arg __attribute__ ((unused))) {}
 
1027
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_STD (v4l2_std_id *arg __attribute__ ((unused))) {}
 
1028
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_STD (const v4l2_std_id *arg __attribute__ ((unused))) {}
 
1029
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_ENUMSTD (struct v4l2_standard *arg __attribute__ ((unused))) {}
 
1030
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_ENUMINPUT (struct v4l2_input *arg __attribute__ ((unused))) {}
 
1031
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_CTRL (struct v4l2_control *arg __attribute__ ((unused))) {}
 
1032
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_CTRL (struct v4l2_control *arg __attribute__ ((unused))) {}
 
1033
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_TUNER (struct v4l2_tuner *arg __attribute__ ((unused))) {}
 
1034
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_TUNER (const struct v4l2_tuner *arg __attribute__ ((unused))) {}
 
1035
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_AUDIO (struct v4l2_audio *arg __attribute__ ((unused))) {}
 
1036
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_AUDIO (const struct v4l2_audio *arg __attribute__ ((unused))) {}
 
1037
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_QUERYCTRL (struct v4l2_queryctrl *arg __attribute__ ((unused))) {}
 
1038
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_QUERYMENU (struct v4l2_querymenu *arg __attribute__ ((unused))) {}
 
1039
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_INPUT (int *arg __attribute__ ((unused))) {}
 
1040
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_INPUT (int *arg __attribute__ ((unused))) {}
 
1041
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_OUTPUT (int *arg __attribute__ ((unused))) {}
 
1042
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_OUTPUT (int *arg __attribute__ ((unused))) {}
 
1043
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_ENUMOUTPUT (struct v4l2_output *arg __attribute__ ((unused))) {}
 
1044
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_AUDOUT (struct v4l2_audioout *arg __attribute__ ((unused))) {}
 
1045
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_AUDOUT (const struct v4l2_audioout *arg __attribute__ ((unused))) {}
 
1046
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_MODULATOR (struct v4l2_modulator *arg __attribute__ ((unused))) {}
 
1047
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_MODULATOR (const struct v4l2_modulator *arg __attribute__ ((unused))) {}
 
1048
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_FREQUENCY (struct v4l2_frequency *arg __attribute__ ((unused))) {}
 
1049
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_FREQUENCY (const struct v4l2_frequency *arg __attribute__ ((unused))) {}
 
1050
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_CROPCAP (struct v4l2_cropcap *arg __attribute__ ((unused))) {}
 
1051
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_CROP (struct v4l2_crop *arg __attribute__ ((unused))) {}
 
1052
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_CROP (const struct v4l2_crop *arg __attribute__ ((unused))) {}
 
1053
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_JPEGCOMP (struct v4l2_jpegcompression *arg __attribute__ ((unused))) {}
 
1054
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_JPEGCOMP (const struct v4l2_jpegcompression *arg __attribute__ ((unused))) {}
 
1055
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_QUERYSTD (v4l2_std_id *arg __attribute__ ((unused))) {}
 
1056
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_TRY_FMT (struct v4l2_format *arg __attribute__ ((unused))) {}
 
1057
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_ENUMAUDIO (struct v4l2_audio *arg __attribute__ ((unused))) {}
 
1058
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_ENUMAUDOUT (struct v4l2_audioout *arg __attribute__ ((unused))) {}
 
1059
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_PRIORITY (enum v4l2_priority *arg __attribute__ ((unused))) {}
 
1060
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_PRIORITY (const enum v4l2_priority *arg __attribute__ ((unused))) {}
 
1061
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_OVERLAY_OLD (int *arg __attribute__ ((unused))) {}
 
1062
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_PARM_OLD (const struct v4l2_streamparm *arg __attribute__ ((unused))) {}
 
1063
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_S_CTRL_OLD (const struct v4l2_control *arg __attribute__ ((unused))) {}
 
1064
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_AUDIO_OLD (struct v4l2_audio *arg __attribute__ ((unused))) {}
 
1065
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_G_AUDOUT_OLD (struct v4l2_audioout *arg __attribute__ ((unused))) {}
 
1066
static __inline__ void IOCTL_ARG_TYPE_CHECK_VIDIOC_CROPCAP_OLD (struct v4l2_cropcap *arg __attribute__ ((unused))) {}
 
1067