Mercurial > mplayer.hg
annotate libmpdemux/tvi_v4l.c @ 3220:b35b40ade7e9
update
author | alex |
---|---|
date | Fri, 30 Nov 2001 16:59:02 +0000 |
parents | 4307478ad922 |
children | 3bd16d4a94e2 |
rev | line source |
---|---|
2802 | 1 /* |
2 v4l interface for libmpemux/tvi | |
3 | |
4 (C) Alex Beregszaszi <alex@naxine.org> | |
5 | |
6 Some ideas are based on xawtv/libng's grab-v4l.c written by | |
7 Gerd Knorr <kraxel@bytesex.org> | |
8 | |
9 CODE IS UNDER DEVELOPMENT, NO FEATURE REQUESTS PLEASE! | |
10 */ | |
11 | |
2790 | 12 #include "config.h" |
13 | |
14 #ifdef USE_TV | |
15 | |
16 #include <stdio.h> | |
17 #include <errno.h> | |
18 #include <fcntl.h> | |
2802 | 19 #include <signal.h> |
2790 | 20 #include <sys/ioctl.h> |
21 #include <sys/types.h> | |
22 #include <linux/videodev.h> | |
23 #include <unistd.h> | |
24 #include <sys/mman.h> | |
2931 | 25 #include <stdlib.h> |
26 #include <string.h> | |
2790 | 27 |
2830 | 28 #include "mp_msg.h" |
29 #include "../libao2/afmt.h" | |
30 #include "../libvo/img_format.h" | |
31 #include "../libvo/fastmemcpy.h" | |
32 | |
2790 | 33 #include "tv.h" |
34 | |
35 static tvi_info_t info = { | |
36 "Video for Linux TV Input", | |
37 "v4l", | |
2802 | 38 "Alex Beregszaszi <alex@naxine.org>", |
39 "under development" | |
40 }; | |
41 | |
2790 | 42 typedef struct { |
2802 | 43 /* general */ |
2790 | 44 char *video_device; |
45 int fd; | |
46 struct video_capability capability; | |
47 struct video_channel *channels; | |
2841 | 48 int act_channel; |
2790 | 49 struct video_tuner tuner; |
2802 | 50 |
51 /* video */ | |
2790 | 52 struct video_picture picture; |
2802 | 53 int format; /* output format */ |
2790 | 54 int width; |
55 int height; | |
2802 | 56 int bytesperline; |
57 | |
58 struct video_mbuf mbuf; | |
59 unsigned char *mmap; | |
60 struct video_mmap *buf; | |
61 int nbuf; | |
62 int queue; | |
63 | |
64 /* audio */ | |
65 struct video_audio audio; | |
2790 | 66 } priv_t; |
67 | |
68 #include "tvi_def.h" | |
69 | |
2841 | 70 static const char *device_cap2name[] = { |
2790 | 71 "capture", "tuner", "teletext", "overlay", "chromakey", "clipping", |
2802 | 72 "frameram", "scales", "monochrome", "subcapture", "mpeg-decoder", |
73 "mpeg-encoder", "mjpeg-decoder", "mjpeg-encoder", NULL | |
74 }; | |
75 | |
2841 | 76 static const char *device_palette2name[] = { |
2802 | 77 "-", "grey", "hi240", "rgb16", "rgb24", "rgb32", "rgb15", "yuv422", |
78 "yuyv", "uyvy", "yuv420", "yuv411", "raw", "yuv422p", "yuv411p", | |
79 "yuv420p", "yuv410p", NULL | |
80 }; | |
81 #define PALETTE(x) ((x < sizeof(device_pal)/sizeof(char*)) ? device_pal[x] : "UNKNOWN") | |
82 | |
2841 | 83 static const char *audio_mode2name[] = { |
84 "unknown", "mono", "stereo", "language1", "language2", NULL | |
85 }; | |
86 | |
2802 | 87 static int palette2depth(int palette) |
88 { | |
2810 | 89 switch(palette) |
90 { | |
3220 | 91 /* component */ |
2810 | 92 case VIDEO_PALETTE_RGB555: |
93 return(15); | |
94 case VIDEO_PALETTE_RGB565: | |
95 return(16); | |
96 case VIDEO_PALETTE_RGB24: | |
97 return(24); | |
98 case VIDEO_PALETTE_RGB32: | |
99 return(32); | |
3220 | 100 /* planar */ |
101 case VIDEO_PALETTE_YUV422P: | |
102 case VIDEO_PALETTE_YUV411P: | |
2810 | 103 case VIDEO_PALETTE_YUV420P: |
3220 | 104 case VIDEO_PALETTE_YUV410P: |
2810 | 105 return(12); |
3220 | 106 /* packed */ |
2810 | 107 case VIDEO_PALETTE_YUV422: |
3220 | 108 case VIDEO_PALETTE_YUYV: |
2810 | 109 case VIDEO_PALETTE_UYVY: |
3220 | 110 case VIDEO_PALETTE_YUV420: |
111 case VIDEO_PALETTE_YUV411: | |
2810 | 112 return(16); |
113 } | |
114 return(-1); | |
2802 | 115 } |
116 | |
117 static int format2palette(int format) | |
118 { | |
2810 | 119 switch(format) |
120 { | |
121 case IMGFMT_RGB15: | |
122 return(VIDEO_PALETTE_RGB555); | |
123 case IMGFMT_RGB16: | |
124 return(VIDEO_PALETTE_RGB565); | |
125 case IMGFMT_RGB24: | |
126 return(VIDEO_PALETTE_RGB24); | |
127 case IMGFMT_RGB32: | |
128 return(VIDEO_PALETTE_RGB32); | |
129 case IMGFMT_YV12: | |
130 return(VIDEO_PALETTE_YUV420P); | |
131 case IMGFMT_UYVY: | |
132 return(VIDEO_PALETTE_YUV422); | |
133 } | |
134 return(-1); | |
2802 | 135 } |
136 | |
137 #if 0 | |
138 struct STRTAB { | |
139 long nr; | |
140 const char *str; | |
141 }; | |
142 | |
143 static struct STRTAB stereo[] = { | |
144 { 0, "auto" }, | |
145 { VIDEO_SOUND_MONO, "mono" }, | |
146 { VIDEO_SOUND_STEREO, "stereo" }, | |
147 { VIDEO_SOUND_LANG1, "lang1" }, | |
148 { VIDEO_SOUND_LANG2, "lang1" }, | |
149 { -1, NULL } | |
150 }; | |
151 | |
152 static struct STRTAB norms_v4l[] = { | |
153 { VIDEO_MODE_PAL, "PAL" }, | |
154 { VIDEO_MODE_NTSC, "NTSC" }, | |
155 { VIDEO_MODE_SECAM, "SECAM" }, | |
156 { VIDEO_MODE_AUTO, "AUTO" }, | |
157 { -1, NULL } | |
158 }; | |
159 | |
160 static struct STRTAB norms_bttv[] = { | |
161 { VIDEO_MODE_PAL, "PAL" }, | |
162 { VIDEO_MODE_NTSC, "NTSC" }, | |
163 { VIDEO_MODE_SECAM, "SECAM" }, | |
164 { 3, "PAL-NC" }, | |
165 { 4, "PAL-M" }, | |
166 { 5, "PAL-N" }, | |
167 { 6, "NTSC-JP" }, | |
168 { -1, NULL } | |
2790 | 169 }; |
170 | |
2802 | 171 static unsigned short _format2palette[VIDEO_FMT_COUNT] = { |
172 0, /* unused */ | |
173 VIDEO_PALETTE_HI240, /* RGB8 */ | |
174 VIDEO_PALETTE_GREY, | |
175 VIDEO_PALETTE_RGB555, | |
176 VIDEO_PALETTE_RGB565, | |
177 0, | |
178 0, | |
179 VIDEO_PALETTE_RGB24, | |
180 VIDEO_PALETTE_RGB32, | |
181 0, | |
182 0, | |
183 0, | |
184 0, | |
185 VIDEO_PALETTE_YUV422, | |
186 VIDEO_PALETTE_YUV422P, | |
187 VIDEO_PALETTE_YUV420P, | |
188 }; | |
189 #define FMT2PAL(fmt) ((fmt < sizeof(format2palette)/sizeof(unsigned short)) ? \ | |
190 format2palette[fmt] : 0); | |
191 | |
192 const unsigned int vfmt_to_depth[] = { | |
193 0, | |
194 8, | |
195 8, | |
196 16, | |
197 16, | |
198 16, | |
199 16, | |
200 24, | |
201 32, | |
202 24, | |
203 32, | |
204 16, | |
205 32, | |
206 16, | |
207 16, | |
208 12, | |
209 0, | |
210 0, | |
211 }; | |
212 #endif | |
213 | |
214 static int one = 1, zero = 0; | |
215 | |
2790 | 216 tvi_handle_t *tvi_init_v4l(char *device) |
217 { | |
218 tvi_handle_t *h; | |
219 priv_t *priv; | |
220 | |
221 h = new_handle(); | |
222 if (!h) | |
223 return(NULL); | |
224 | |
225 priv = h->priv; | |
226 | |
2802 | 227 /* set video device name */ |
2790 | 228 if (!device) |
229 { | |
2819
2e58962dc9fe
cleaned up some warnings, and tv_param_on moved out from #ifdef USE_TV
alex
parents:
2818
diff
changeset
|
230 priv->video_device = (char *)malloc(strlen("/dev/video0")); |
2802 | 231 sprintf(priv->video_device, "/dev/video0"); |
2790 | 232 } |
233 else | |
234 { | |
2819
2e58962dc9fe
cleaned up some warnings, and tv_param_on moved out from #ifdef USE_TV
alex
parents:
2818
diff
changeset
|
235 priv->video_device = (char *)malloc(strlen(device)); |
2790 | 236 strcpy(priv->video_device, device); |
237 } | |
238 | |
239 return(h); | |
240 } | |
241 | |
2802 | 242 static int init(priv_t *priv, tvi_param_t *params) |
2790 | 243 { |
244 int i; | |
245 | |
2810 | 246 priv->fd = open(priv->video_device, O_RDWR); |
2790 | 247 if (priv->fd == -1) |
248 { | |
2818 | 249 mp_msg(MSGT_TV, MSGL_ERR, "unable to open '%s': %s\n", |
2802 | 250 priv->video_device, strerror(errno)); |
2790 | 251 goto err; |
252 } | |
253 | |
2818 | 254 mp_msg(MSGT_TV, MSGL_V, "Video fd: %d\n", priv->fd); |
2790 | 255 |
2802 | 256 /* get capabilities (priv->capability is needed!) */ |
2790 | 257 if (ioctl(priv->fd, VIDIOCGCAP, &priv->capability) == -1) |
258 { | |
2818 | 259 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get capabilites failed: %s\n", strerror(errno)); |
2790 | 260 goto err; |
261 } | |
262 | |
263 fcntl(priv->fd, F_SETFD, FD_CLOEXEC); | |
2818 | 264 // siginit(); |
2802 | 265 |
266 #if 0 | |
267 for (i=0; params[i].opt; i++) | |
268 { | |
269 if (!strcmp(params[i].opt, "input")) | |
270 priv->input = (int)*(void **)params[i].value; | |
271 } | |
272 printf("priv->input: %d\n", priv->input); | |
273 #endif | |
274 | |
2818 | 275 mp_msg(MSGT_TV, MSGL_INFO, "Selected device: %s\n", priv->capability.name); |
276 mp_msg(MSGT_TV, MSGL_INFO, " Capabilites: "); | |
2841 | 277 for (i = 0; device_cap2name[i] != NULL; i++) |
2790 | 278 if (priv->capability.type & (1 << i)) |
2841 | 279 mp_msg(MSGT_TV, MSGL_INFO, "%s ", device_cap2name[i]); |
2818 | 280 mp_msg(MSGT_TV, MSGL_INFO, "\n"); |
281 mp_msg(MSGT_TV, MSGL_INFO, " Device type: %d\n", priv->capability.type); | |
282 mp_msg(MSGT_TV, MSGL_INFO, " Supported sizes: %dx%d => %dx%d\n", | |
2790 | 283 priv->capability.minwidth, priv->capability.minheight, |
284 priv->capability.maxwidth, priv->capability.maxheight); | |
285 priv->width = priv->capability.minwidth; | |
286 priv->height = priv->capability.minheight; | |
2818 | 287 mp_msg(MSGT_TV, MSGL_INFO, " Inputs: %d\n", priv->capability.channels); |
2790 | 288 |
2819
2e58962dc9fe
cleaned up some warnings, and tv_param_on moved out from #ifdef USE_TV
alex
parents:
2818
diff
changeset
|
289 priv->channels = (struct video_channel *)malloc(sizeof(struct video_channel)*priv->capability.channels); |
2790 | 290 memset(priv->channels, 0, sizeof(struct video_channel)*priv->capability.channels); |
291 for (i = 0; i < priv->capability.channels; i++) | |
292 { | |
293 priv->channels[i].channel = i; | |
2841 | 294 if (ioctl(priv->fd, VIDIOCGCHAN, &priv->channels[i]) == -1) |
295 { | |
296 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get channel failed: %s\n", strerror(errno)); | |
297 break; | |
298 } | |
2818 | 299 mp_msg(MSGT_TV, MSGL_INFO, " %d: %s: %s%s%s%s (tuner:%d, norm:%d)\n", i, |
2790 | 300 priv->channels[i].name, |
301 (priv->channels[i].flags & VIDEO_VC_TUNER) ? "tuner " : "", | |
302 (priv->channels[i].flags & VIDEO_VC_AUDIO) ? "audio " : "", | |
303 (priv->channels[i].flags & VIDEO_TYPE_TV) ? "tv " : "", | |
2802 | 304 (priv->channels[i].flags & VIDEO_TYPE_CAMERA) ? "camera " : "", |
305 priv->channels[i].tuners, | |
306 priv->channels[i].norm); | |
307 } | |
308 | |
2841 | 309 if (priv->capability.audios) |
310 { | |
311 mp_msg(MSGT_TV, MSGL_INFO, " Audio devices: %d\n", priv->capability.audios); | |
312 | |
313 for (i = 0; i < priv->capability.audios; i++) | |
314 { | |
315 priv->audio.audio = i; | |
316 if (ioctl(priv->fd, VIDIOCGAUDIO, &priv->audio) == -1) | |
317 { | |
318 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get audio failed: %s\n", strerror(errno)); | |
319 break; | |
320 } | |
321 | |
322 mp_msg(MSGT_TV, MSGL_V, " %d: %s: ", priv->audio.audio, | |
323 priv->audio.name); | |
324 if (priv->audio.flags & VIDEO_AUDIO_MUTABLE) | |
325 mp_msg(MSGT_TV, MSGL_V, "muted=%s ", | |
326 (priv->audio.flags & VIDEO_AUDIO_MUTE) ? "yes" : "no"); | |
327 mp_msg(MSGT_TV, MSGL_V, "volume=%d bass=%d treble=%d balance=%d mode=%s\n", | |
328 priv->audio.volume, priv->audio.bass, priv->audio.treble, | |
329 priv->audio.balance, audio_mode2name[priv->audio.mode]); | |
330 } | |
331 } | |
332 | |
2802 | 333 if (!(priv->capability.type & VID_TYPE_CAPTURE)) |
334 { | |
2818 | 335 mp_msg(MSGT_TV, MSGL_ERR, "Only grabbing supported (for overlay use another program)\n"); |
2802 | 336 goto err; |
337 } | |
338 | |
339 /* map grab buffer */ | |
340 if (ioctl(priv->fd, VIDIOCGMBUF, &priv->mbuf) == -1) | |
341 { | |
2818 | 342 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get mbuf failed: %s\n", strerror(errno)); |
2802 | 343 goto err; |
2790 | 344 } |
345 | |
2818 | 346 mp_msg(MSGT_TV, MSGL_V, "mbuf: size=%d, frames=%d\n", |
2802 | 347 priv->mbuf.size, priv->mbuf.frames); |
348 priv->mmap = mmap(0, priv->mbuf.size, PROT_READ|PROT_WRITE, | |
349 MAP_SHARED, priv->fd, 0); | |
2819
2e58962dc9fe
cleaned up some warnings, and tv_param_on moved out from #ifdef USE_TV
alex
parents:
2818
diff
changeset
|
350 if (priv->mmap == (unsigned char *)-1) |
2802 | 351 { |
2818 | 352 mp_msg(MSGT_TV, MSGL_ERR, "Unabel to map memory for buffers: %s\n", strerror(errno)); |
2802 | 353 goto err; |
354 } | |
2818 | 355 mp_msg(MSGT_TV, MSGL_DBG2, "our buffer: %p\n", priv->mmap); |
2790 | 356 |
2802 | 357 /* num of buffers */ |
358 priv->nbuf = priv->mbuf.frames; | |
2790 | 359 |
2802 | 360 /* video buffers */ |
2819
2e58962dc9fe
cleaned up some warnings, and tv_param_on moved out from #ifdef USE_TV
alex
parents:
2818
diff
changeset
|
361 priv->buf = (struct video_mmap *)malloc(priv->nbuf * sizeof(struct video_mmap)); |
2802 | 362 memset(priv->buf, 0, priv->nbuf * sizeof(struct video_mmap)); |
2790 | 363 |
364 return(1); | |
365 | |
366 err: | |
367 if (priv->fd != -1) | |
368 close(priv->fd); | |
369 return(0); | |
370 } | |
371 | |
2802 | 372 static int uninit(priv_t *priv) |
2790 | 373 { |
2837 | 374 close(priv->fd); |
2802 | 375 #warning "Implement uninit!" |
2931 | 376 |
377 return(1); | |
2790 | 378 } |
379 | |
2802 | 380 static int start(priv_t *priv) |
2790 | 381 { |
2802 | 382 int i; |
383 | |
384 | |
385 if (ioctl(priv->fd, VIDIOCGPICT, &priv->picture) == -1) | |
2790 | 386 { |
2818 | 387 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get picture failed: %s\n", strerror(errno)); |
2802 | 388 return(0); |
2790 | 389 } |
390 | |
2802 | 391 priv->picture.palette = format2palette(priv->format); |
392 priv->picture.depth = palette2depth(priv->picture.palette); | |
393 priv->bytesperline = priv->width * priv->picture.depth / 8; | |
394 | |
2818 | 395 mp_msg(MSGT_TV, MSGL_INFO, "Picture values:\n"); |
396 mp_msg(MSGT_TV, MSGL_INFO, " Depth: %d, Palette: %d (Format: %s)\n", priv->picture.depth, | |
2802 | 397 priv->picture.palette, vo_format_name(priv->format)); |
2818 | 398 mp_msg(MSGT_TV, MSGL_INFO, " Brightness: %d, Hue: %d, Colour: %d, Contrast: %d\n", |
2802 | 399 priv->picture.brightness, priv->picture.hue, |
400 priv->picture.colour, priv->picture.contrast); | |
401 | |
402 | |
403 if (ioctl(priv->fd, VIDIOCSPICT, &priv->picture) == -1) | |
2790 | 404 { |
2818 | 405 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set picture failed: %s\n", strerror(errno)); |
2802 | 406 return(0); |
2790 | 407 } |
408 | |
2802 | 409 priv->nbuf = priv->mbuf.frames; |
410 for (i=0; i < priv->nbuf; i++) | |
411 { | |
412 priv->buf[i].format = priv->picture.palette; | |
413 priv->buf[i].frame = i; | |
414 priv->buf[i].width = priv->width; | |
415 priv->buf[i].height = priv->height; | |
2818 | 416 mp_msg(MSGT_TV, MSGL_DBG2, "buffer: %d => %p\n", i, &priv->buf[i]); |
2802 | 417 } |
2837 | 418 |
2931 | 419 #if 0 |
420 { | |
421 struct video_play_mode pmode; | |
422 | |
423 pmode.mode = VID_PLAY_NORMAL; | |
424 pmode.p1 = 1; | |
425 pmode.p2 = 0; | |
426 if (ioctl(priv->fd, VIDIOCSPLAYMODE, &pmode) == -1) | |
427 { | |
428 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set play mode failed: %s\n", strerror(errno)); | |
429 // return(0); | |
430 } | |
431 } | |
432 #endif | |
2837 | 433 |
434 #if 0 | |
435 { | |
436 struct video_window win; | |
437 | |
438 win.x = 0; | |
439 win.y = 0; | |
440 win.width = priv->width; | |
441 win.height = priv->height; | |
442 win.chromakey = -1; | |
443 win.flags = 0; | |
444 | |
445 ioctl(priv->fd, VIDIOCSWIN, &win); | |
446 } | |
447 | |
2802 | 448 /* start capture */ |
449 if (ioctl(priv->fd, VIDIOCCAPTURE, &one) == -1) | |
450 { | |
2818 | 451 mp_msg(MSGT_TV, MSGL_ERR, "ioctl capture failed: %s\n", strerror(errno)); |
2802 | 452 return(0); |
453 } | |
2837 | 454 #endif |
455 | |
456 return(1); | |
2790 | 457 } |
458 | |
459 static int control(priv_t *priv, int cmd, void *arg) | |
460 { | |
2818 | 461 mp_msg(MSGT_TV, MSGL_DBG2, "debug: control(priv=%p, cmd=%d, arg=%p)\n", |
2802 | 462 priv, cmd, arg); |
2790 | 463 switch(cmd) |
464 { | |
2802 | 465 /* ========== GENERIC controls =========== */ |
466 case TVI_CONTROL_IS_VIDEO: | |
467 { | |
468 if (priv->capability.type & VID_TYPE_CAPTURE) | |
469 return(TVI_CONTROL_TRUE); | |
470 return(TVI_CONTROL_FALSE); | |
471 } | |
472 case TVI_CONTROL_IS_AUDIO: | |
2841 | 473 #if 0 /* also disable audio for as it's not working! */ |
474 if (priv->channels[priv->act_channel].flags & VIDEO_VC_AUDIO) | |
475 return(TVI_CONTROL_TRUE); | |
476 #endif | |
477 return(TVI_CONTROL_FALSE); | |
2802 | 478 case TVI_CONTROL_IS_TUNER: |
479 { | |
2841 | 480 // if (priv->capability.type & VID_TYPE_TUNER) |
481 if (priv->channels[priv->act_channel].flags & VIDEO_VC_TUNER) | |
2802 | 482 return(TVI_CONTROL_TRUE); |
483 return(TVI_CONTROL_FALSE); | |
484 } | |
485 | |
486 /* ========== VIDEO controls =========== */ | |
2790 | 487 case TVI_CONTROL_VID_GET_FORMAT: |
2802 | 488 { |
489 int output_fmt = -1; | |
490 | |
491 output_fmt = priv->format; | |
492 (int)*(void **)arg = output_fmt; | |
2818 | 493 mp_msg(MSGT_TV, MSGL_INFO, "Output format: %s\n", vo_format_name(output_fmt)); |
2802 | 494 return(TVI_CONTROL_TRUE); |
495 } | |
496 case TVI_CONTROL_VID_SET_FORMAT: | |
497 priv->format = (int)*(void **)arg; | |
2790 | 498 return(TVI_CONTROL_TRUE); |
499 case TVI_CONTROL_VID_GET_PLANES: | |
3220 | 500 (int)*(void **)arg = 1; /* FIXME, also not needed at this time */ |
2790 | 501 return(TVI_CONTROL_TRUE); |
502 case TVI_CONTROL_VID_GET_BITS: | |
2810 | 503 (int)*(void **)arg = palette2depth(format2palette(priv->format)); |
2790 | 504 return(TVI_CONTROL_TRUE); |
505 case TVI_CONTROL_VID_GET_WIDTH: | |
506 (int)*(void **)arg = priv->width; | |
507 return(TVI_CONTROL_TRUE); | |
508 case TVI_CONTROL_VID_CHK_WIDTH: | |
509 { | |
510 int req_width = (int)*(void **)arg; | |
511 | |
2818 | 512 mp_msg(MSGT_TV, MSGL_INFO, "Requested width: %d\n", req_width); |
2810 | 513 if ((req_width >= priv->capability.minwidth) && |
514 (req_width <= priv->capability.maxwidth)) | |
2790 | 515 return(TVI_CONTROL_TRUE); |
516 return(TVI_CONTROL_FALSE); | |
517 } | |
518 case TVI_CONTROL_VID_SET_WIDTH: | |
519 priv->width = (int)*(void **)arg; | |
520 return(TVI_CONTROL_TRUE); | |
521 case TVI_CONTROL_VID_GET_HEIGHT: | |
522 (int)*(void **)arg = priv->height; | |
523 return(TVI_CONTROL_TRUE); | |
524 case TVI_CONTROL_VID_CHK_HEIGHT: | |
525 { | |
526 int req_height = (int)*(void **)arg; | |
527 | |
2818 | 528 mp_msg(MSGT_TV, MSGL_INFO, "Requested height: %d\n", req_height); |
2810 | 529 if ((req_height >= priv->capability.minheight) && |
530 (req_height <= priv->capability.maxheight)) | |
2790 | 531 return(TVI_CONTROL_TRUE); |
532 return(TVI_CONTROL_FALSE); | |
533 } | |
534 case TVI_CONTROL_VID_SET_HEIGHT: | |
535 priv->height = (int)*(void **)arg; | |
536 return(TVI_CONTROL_TRUE); | |
2937 | 537 case TVI_CONTROL_VID_GET_PICTURE: |
538 if (ioctl(priv->fd, VIDIOCGPICT, &priv->picture) == -1) | |
539 { | |
540 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get picture failed: %s\n", strerror(errno)); | |
541 return(TVI_CONTROL_FALSE); | |
542 } | |
543 return(TVI_CONTROL_TRUE); | |
544 case TVI_CONTROL_VID_SET_PICTURE: | |
545 if (ioctl(priv->fd, VIDIOCSPICT, &priv->picture) == -1) | |
546 { | |
547 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get picture failed: %s\n", strerror(errno)); | |
548 return(TVI_CONTROL_FALSE); | |
549 } | |
550 return(TVI_CONTROL_TRUE); | |
551 case TVI_CONTROL_VID_SET_BRIGHTNESS: | |
552 priv->picture.brightness = (int)*(void **)arg; | |
553 control(priv, TVI_CONTROL_VID_SET_PICTURE, 0); | |
554 return(TVI_CONTROL_TRUE); | |
555 case TVI_CONTROL_VID_SET_HUE: | |
556 priv->picture.hue = (int)*(void **)arg; | |
557 control(priv, TVI_CONTROL_VID_SET_PICTURE, 0); | |
558 return(TVI_CONTROL_TRUE); | |
559 case TVI_CONTROL_VID_SET_SATURATION: | |
560 priv->picture.colour = (int)*(void **)arg; | |
561 control(priv, TVI_CONTROL_VID_SET_PICTURE, 0); | |
562 return(TVI_CONTROL_TRUE); | |
563 case TVI_CONTROL_VID_SET_CONTRAST: | |
564 priv->picture.contrast = (int)*(void **)arg; | |
565 control(priv, TVI_CONTROL_VID_SET_PICTURE, 0); | |
566 return(TVI_CONTROL_TRUE); | |
2790 | 567 |
2802 | 568 /* ========== TUNER controls =========== */ |
569 case TVI_CONTROL_TUN_GET_FREQ: | |
570 { | |
571 unsigned long freq; | |
572 | |
573 if (ioctl(priv->fd, VIDIOCGFREQ, &freq) == -1) | |
574 { | |
2818 | 575 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get freq failed: %s\n", strerror(errno)); |
2802 | 576 return(TVI_CONTROL_FALSE); |
577 } | |
578 | |
579 /* tuner uses khz not mhz ! */ | |
2837 | 580 // if (priv->tuner.flags & VIDEO_TUNER_LOW) |
581 // freq /= 1000; | |
2802 | 582 (unsigned long)*(void **)arg = freq; |
583 return(TVI_CONTROL_TRUE); | |
584 } | |
2790 | 585 case TVI_CONTROL_TUN_SET_FREQ: |
586 { | |
2802 | 587 /* argument is in MHz ! */ |
588 unsigned long freq = (unsigned long)*(void **)arg; | |
589 | |
2837 | 590 mp_msg(MSGT_TV, MSGL_V, "requested frequency: %.3f\n", (float)freq/16); |
2802 | 591 |
592 /* tuner uses khz not mhz ! */ | |
2837 | 593 // if (priv->tuner.flags & VIDEO_TUNER_LOW) |
594 // freq *= 1000; | |
595 // mp_msg(MSGT_TV, MSGL_V, " requesting from driver: freq=%.3f\n", (float)freq/16); | |
2802 | 596 if (ioctl(priv->fd, VIDIOCSFREQ, &freq) == -1) |
597 { | |
2818 | 598 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set freq failed: %s\n", strerror(errno)); |
2802 | 599 return(TVI_CONTROL_FALSE); |
600 } | |
601 return(TVI_CONTROL_TRUE); | |
602 } | |
603 case TVI_CONTROL_TUN_GET_TUNER: | |
604 { | |
605 if (ioctl(priv->fd, VIDIOCGTUNER, &priv->tuner) == -1) | |
606 { | |
2818 | 607 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get tuner failed: %s\n", strerror(errno)); |
2802 | 608 return(TVI_CONTROL_FALSE); |
609 } | |
610 | |
2818 | 611 mp_msg(MSGT_TV, MSGL_INFO, "Tuner (%s) range: %lu -> %lu\n", priv->tuner.name, |
2802 | 612 priv->tuner.rangelow, priv->tuner.rangehigh); |
613 return(TVI_CONTROL_TRUE); | |
614 } | |
615 case TVI_CONTROL_TUN_SET_TUNER: | |
616 { | |
617 if (ioctl(priv->fd, VIDIOCSTUNER, &priv->tuner) == -1) | |
618 { | |
2818 | 619 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get tuner failed: %s\n", strerror(errno)); |
2802 | 620 return(TVI_CONTROL_FALSE); |
621 } | |
622 return(TVI_CONTROL_TRUE); | |
623 } | |
624 case TVI_CONTROL_TUN_SET_NORM: | |
625 { | |
626 int req_mode = (int)*(void **)arg; | |
627 | |
628 if ((!(priv->tuner.flags & VIDEO_TUNER_NORM)) || | |
629 ((req_mode == VIDEO_MODE_PAL) && !(priv->tuner.flags & VIDEO_TUNER_PAL)) || | |
630 ((req_mode == VIDEO_MODE_NTSC) && !(priv->tuner.flags & VIDEO_TUNER_NTSC)) || | |
631 ((req_mode == VIDEO_MODE_SECAM) && !(priv->tuner.flags & VIDEO_TUNER_SECAM))) | |
632 { | |
2818 | 633 mp_msg(MSGT_TV, MSGL_ERR, "Tuner isn't capable to set norm!\n"); |
2802 | 634 return(TVI_CONTROL_FALSE); |
635 } | |
636 | |
637 priv->tuner.mode = req_mode; | |
2790 | 638 |
2802 | 639 if (control(priv->fd, TVI_CONTROL_TUN_SET_TUNER, &priv->tuner) != TVI_CONTROL_TRUE) |
640 return(TVI_CONTROL_FALSE); | |
641 return(TVI_CONTROL_TRUE); | |
642 } | |
643 case TVI_CONTROL_TUN_GET_NORM: | |
644 { | |
645 (int)*(void **)arg = priv->tuner.mode; | |
646 | |
647 return(TVI_CONTROL_TRUE); | |
648 } | |
649 | |
650 /* ========== AUDIO controls =========== */ | |
651 case TVI_CONTROL_AUD_GET_FORMAT: | |
652 { | |
653 (int)*(void **)arg = AFMT_S16_LE; | |
654 return(TVI_CONTROL_TRUE); | |
655 } | |
656 case TVI_CONTROL_AUD_GET_CHANNELS: | |
657 { | |
658 (int)*(void **)arg = 2; | |
659 return(TVI_CONTROL_TRUE); | |
660 } | |
661 case TVI_CONTROL_AUD_GET_SAMPLERATE: | |
662 { | |
663 (int)*(void **)arg = 44100; | |
664 return(TVI_CONTROL_TRUE); | |
665 } | |
666 case TVI_CONTROL_AUD_GET_SAMPLESIZE: | |
667 { | |
668 (int)*(void **)arg = 76000; | |
669 return(TVI_CONTROL_TRUE); | |
670 } | |
671 | |
672 /* ========== SPECIFIC controls =========== */ | |
673 case TVI_CONTROL_SPC_GET_INPUT: | |
674 { | |
675 int req_chan = (int)*(void **)arg; | |
676 int i; | |
677 | |
678 for (i = 0; i < priv->capability.channels; i++) | |
679 { | |
680 if (priv->channels[i].channel == req_chan) | |
681 break; | |
682 } | |
2841 | 683 |
684 priv->act_channel = i; | |
2802 | 685 |
686 if (ioctl(priv->fd, VIDIOCGCHAN, &priv->channels[i]) == -1) | |
687 { | |
2818 | 688 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get channel failed: %s\n", strerror(errno)); |
2802 | 689 return(TVI_CONTROL_FALSE); |
690 } | |
691 return(TVI_CONTROL_TRUE); | |
692 } | |
693 | |
694 case TVI_CONTROL_SPC_SET_INPUT: | |
695 { | |
696 struct video_channel chan; | |
697 int req_chan = (int)*(void **)arg; | |
698 int i; | |
699 | |
700 if (req_chan >= priv->capability.channels) | |
701 { | |
2818 | 702 mp_msg(MSGT_TV, MSGL_ERR, "Invalid input requested: %d, valid: 0-%d\n", |
2802 | 703 req_chan, priv->capability.channels); |
704 return(TVI_CONTROL_FALSE); | |
705 } | |
706 | |
707 for (i = 0; i < priv->capability.channels; i++) | |
708 { | |
709 if (priv->channels[i].channel == req_chan) | |
710 chan = priv->channels[i]; | |
711 } | |
712 | |
713 if (ioctl(priv->fd, VIDIOCSCHAN, &chan) == -1) | |
714 { | |
2818 | 715 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set chan failed: %s\n", strerror(errno)); |
2802 | 716 return(TVI_CONTROL_FALSE); |
717 } | |
2818 | 718 mp_msg(MSGT_TV, MSGL_INFO, "Using input '%s'\n", chan.name); |
2802 | 719 |
2841 | 720 priv->act_channel = i; |
721 | |
2802 | 722 /* update tuner state */ |
2841 | 723 // if (priv->capability.type & VID_TYPE_TUNER) |
724 if (priv->channels[priv->act_channel].flags & VIDEO_VC_TUNER) | |
2802 | 725 control(priv, TVI_CONTROL_TUN_GET_TUNER, 0); |
726 | |
727 /* update local channel list */ | |
728 control(priv, TVI_CONTROL_SPC_GET_INPUT, &req_chan); | |
729 return(TVI_CONTROL_TRUE); | |
2790 | 730 } |
731 } | |
732 | |
733 return(TVI_CONTROL_UNKNOWN); | |
734 } | |
735 | |
736 static int grab_video_frame(priv_t *priv, char *buffer, int len) | |
737 { | |
2802 | 738 int frame = priv->queue % priv->nbuf; |
2814 | 739 int nextframe = (priv->queue+1) % priv->nbuf; |
2802 | 740 |
2931 | 741 mp_dbg(MSGT_TV, MSGL_DBG2, "grab_video_frame(priv=%p, buffer=%p, len=%d\n", |
2802 | 742 priv, buffer, len); |
743 | |
2931 | 744 mp_dbg(MSGT_TV, MSGL_DBG3, "buf: %p + frame: %d => %p\n", |
2814 | 745 priv->buf, nextframe, &priv->buf[nextframe]); |
746 if (ioctl(priv->fd, VIDIOCMCAPTURE, &priv->buf[nextframe]) == -1) | |
2790 | 747 { |
2818 | 748 mp_msg(MSGT_TV, MSGL_ERR, "ioctl mcapture failed: %s\n", strerror(errno)); |
2802 | 749 return(0); |
2790 | 750 } |
751 | |
2814 | 752 if (ioctl(priv->fd, VIDIOCSYNC, &priv->buf[frame].frame) == -1) |
2818 | 753 mp_msg(MSGT_TV, MSGL_ERR, "ioctl sync failed: %s\n", strerror(errno)); |
2802 | 754 priv->queue++; |
755 | |
2931 | 756 mp_dbg(MSGT_TV, MSGL_DBG3, "mmap: %p + offset: %d => %p\n", |
2802 | 757 priv->mmap, priv->mbuf.offsets[frame], |
758 priv->mmap+priv->mbuf.offsets[frame]); | |
2931 | 759 |
760 /* XXX also directrendering would be nicer! */ | |
761 /* 3 times copying the same picture to other buffer :( */ | |
762 | |
763 /* copy the actual frame */ | |
2802 | 764 memcpy(buffer, priv->mmap+priv->mbuf.offsets[frame], len); |
765 | |
766 return(len); | |
2790 | 767 } |
768 | |
769 static int get_video_framesize(priv_t *priv) | |
770 { | |
2931 | 771 return(priv->bytesperline * priv->height); |
2790 | 772 } |
773 | |
774 static int grab_audio_frame(priv_t *priv, char *buffer, int len) | |
775 { | |
2931 | 776 return(65536); |
2790 | 777 } |
778 | |
779 static int get_audio_framesize(priv_t *priv) | |
780 { | |
2931 | 781 return(65536); |
2790 | 782 } |
783 | |
784 #endif /* USE_TV */ |