?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote branch 'mplayer/master'
[mplayer/glamo.git] / stream / tvi_v4l.c
blobf5d4f08276aa41c92aca7f283524c30f294c0fb2
1 /*
2 Video 4 Linux input
3
4 (C) Alex Beregszaszi
5
6 Some ideas are based on xawtv/libng's grab-v4l.c written by
7 Gerd Knorr <kraxel@bytesex.org>
8
9 Multithreading, a/v sync and native ALSA support by
10 Jindrich Makovicka <makovick@gmail.com>
11
12 Mjpeg hardware encoding support by
13 Ivan Szanto <szivan@freemail.hu>
14
15 CODE IS UNDER DEVELOPMENT, NO FEATURE REQUESTS PLEASE!
16 */
17
18 #include "config.h"
19
20 #include <stdio.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <sys/ioctl.h>
24 #include <sys/types.h>
25 #include <sys/time.h>
26
27 /* Necessary to prevent collisions between <linux/time.h> and <sys/time.h> when V4L2 is installed. */
28 #define _LINUX_TIME_H
29
30 #include <linux/videodev.h>
31 #include <unistd.h>
32 #include <sys/mman.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <pthread.h>
36 #ifdef HAVE_SYS_SYSINFO_H
37 #include <sys/sysinfo.h>
38 #endif
39
40 #include "mp_msg.h"
41 #include "libaf/af_format.h"
42 #include "libmpcodecs/img_format.h"
43 #include "libmpcodecs/dec_teletext.h"
44 #include "libvo/fastmemcpy.h"
45 #include "libvo/videodev_mjpeg.h"
46
47 #include "tv.h"
48
49 #include "audio_in.h"
50
51 static tvi_handle_t *tvi_init_v4l(tv_param_t* tv_param);
52
53 const tvi_info_t tvi_info_v4l = {
54 tvi_init_v4l,
55 "Video 4 Linux input",
56 "v4l",
57 "Alex Beregszaszi",
58 "under development"
59 };
60
61 #define PAL_WIDTH 768
62 #define PAL_HEIGHT 576
63 #define PAL_FPS 25
64
65 #define NTSC_WIDTH 640
66 #define NTSC_HEIGHT 480
67 #define NTSC_FPS (30000.0/1001.0)
68
69 #define MAX_AUDIO_CHANNELS 10
70
71 #define VID_BUF_SIZE_IMMEDIATE 2
72 #define VIDEO_AVG_BUFFER_SIZE 600
73
74 typedef struct {
75 /* general */
76 char *video_device;
77 int video_fd;
78 struct video_capability capability;
79 struct video_channel *channels;
80 int act_channel;
81 struct video_tuner tuner;
82
83 /* video */
84 struct video_picture picture;
85 int format; /* output format */
86 int width;
87 int height;
88 int bytesperline;
89 float fps;
90
91 struct video_mbuf mbuf;
92 unsigned char *mmap;
93 struct video_mmap *buf;
94 int nbuf;
95
96 /* audio */
97 char *audio_device;
98 audio_in_t audio_in;
99
100 int audio_id;
101 struct video_audio audio[MAX_AUDIO_CHANNELS];
102 int audio_channels[MAX_AUDIO_CHANNELS];
103
104 /* buffering stuff */
105 int immediate_mode;
106
107 int audio_buffer_size;
108 int aud_skew_cnt;
109 unsigned char *audio_ringbuffer;
110 long long *audio_skew_buffer;
111 volatile int audio_head;
112 volatile int audio_tail;
113 volatile int audio_cnt;
114 volatile long long audio_skew;
115 volatile double audio_skew_factor;
116 volatile long long audio_skew_measure_time;
117 volatile int audio_drop;
118
119 int first;
120 int video_buffer_size_max;
121 volatile int video_buffer_size_current;
122 unsigned char **video_ringbuffer;
123 long long *video_timebuffer;
124 long long *video_avg_buffer;
125 int video_avg_ptr;
126 int video_interval_sum;
127 volatile int video_head;
128 volatile int video_tail;
129 volatile int video_cnt;
130
131 volatile int shutdown;
132
133 pthread_t audio_grabber_thread;
134 pthread_t video_grabber_thread;
135 pthread_mutex_t audio_starter;
136 pthread_mutex_t skew_mutex;
137 pthread_mutex_t video_buffer_mutex;
138
139 long long starttime;
140 double audio_secs_per_block;
141 long long audio_skew_total;
142 long audio_recv_blocks_total;
143 long audio_sent_blocks_total;
144 long mjpeg_bufsize;
145 char *vbi_dev;
146 int vbi_fd;
147 int vbi_bufsize;
148 int vbi_shutdown;
149 pthread_t vbi_grabber_thread;
150 void *priv_vbi;
151
152 tv_param_t *tv_param;
153 } priv_t;
154
155 #include "tvi_def.h"
156
157 static const char *device_cap2name[] = {
158 "capture", "tuner", "teletext", "overlay", "chromakey", "clipping",
159 "frameram", "scales", "monochrome", "subcapture", "mpeg-decoder",
160 "mpeg-encoder", "mjpeg-decoder", "mjpeg-encoder", NULL
161 };
162
163 static const char *device_palette2name[] = {
164 "-", "grey", "hi240", "rgb16", "rgb24", "rgb32", "rgb15", "yuv422",
165 "yuyv", "uyvy", "yuv420", "yuv411", "raw", "yuv422p", "yuv411p",
166 "yuv420p", "yuv410p"
167 };
168 #define PALETTE(x) ((x < sizeof(device_palette2name)/sizeof(char*)) ? device_palette2name[x] : "UNKNOWN")
169
170 static const struct {
171 char* name;
172 int normid;
173 int tuner_flags;
174 int tuner_mode;
175 int input_norm;
176 float fps;
177 } supported_norms[]={
178 {"pal", TV_NORM_PAL, VIDEO_TUNER_PAL, VIDEO_MODE_PAL, VIDEO_MODE_PAL, PAL_FPS },
179 {"ntsc", TV_NORM_NTSC, VIDEO_TUNER_NTSC, VIDEO_MODE_NTSC, VIDEO_MODE_NTSC, NTSC_FPS},
180 {"secam", TV_NORM_SECAM, VIDEO_TUNER_SECAM, VIDEO_MODE_SECAM,VIDEO_MODE_SECAM,PAL_FPS },
181 {"palnc", TV_NORM_PALNC, VIDEO_TUNER_PAL, VIDEO_MODE_PAL, 3, PAL_FPS },
182 {"palm", TV_NORM_PALM, VIDEO_TUNER_NTSC, VIDEO_MODE_NTSC, 4, NTSC_FPS},
183 {"paln", TV_NORM_PALN, VIDEO_TUNER_PAL, VIDEO_MODE_PAL, 5, PAL_FPS },
184 {"ntscjp",TV_NORM_NTSCJP, VIDEO_TUNER_NTSC, VIDEO_MODE_NTSC, 6, NTSC_FPS},
185 {"auto", -1, -1, -1, VIDEO_MODE_AUTO, -1 },
186 {NULL, -1, -1, -1, -1 }
187 };
188
189 static const char *norm2name(int mode)
190 {
191 int i;
192 for(i=0;supported_norms[i].name; i++)
193 if(supported_norms[i].input_norm==mode)
194 return supported_norms[i].name;
195 return "unknown";
196 };
197
198 static const char *audio_mode2name(int mode)
199 {
200 switch (mode) {
201 case VIDEO_SOUND_MONO:
202 return "mono";
203 case VIDEO_SOUND_STEREO:
204 return "stereo";
205 case VIDEO_SOUND_LANG1:
206 return "language1";
207 case VIDEO_SOUND_LANG2:
208 return "language2";
209 default:
210 return "unknown";
211 }
212 };
213
214 static void *audio_grabber(void *data);
215 static void *video_grabber(void *data);
216
217 static int palette2depth(int palette)
218 {
219 switch(palette)
220 {
221 /* component */
222 case VIDEO_PALETTE_RGB555:
223 return 15;
224 case VIDEO_PALETTE_RGB565:
225 return 16;
226 case VIDEO_PALETTE_RGB24:
227 return 24;
228 case VIDEO_PALETTE_RGB32:
229 return 32;
230 /* planar */
231 case VIDEO_PALETTE_YUV411P:
232 case VIDEO_PALETTE_YUV420P:
233 case VIDEO_PALETTE_YUV410P:
234 return 12;
235 /* packed */
236 case VIDEO_PALETTE_YUV422P:
237 case VIDEO_PALETTE_YUV422:
238 case VIDEO_PALETTE_YUYV:
239 case VIDEO_PALETTE_UYVY:
240 case VIDEO_PALETTE_YUV420:
241 case VIDEO_PALETTE_YUV411:
242 return 16;
243 }
244 return -1;
245 }
246
247 static int format2palette(int format)
248 {
249 switch(format)
250 {
251 case IMGFMT_BGR15:
252 return VIDEO_PALETTE_RGB555;
253 case IMGFMT_BGR16:
254 return VIDEO_PALETTE_RGB565;
255 case IMGFMT_BGR24:
256 return VIDEO_PALETTE_RGB24;
257 case IMGFMT_BGR32:
258 return VIDEO_PALETTE_RGB32;
259 case IMGFMT_YV12:
260 case IMGFMT_I420:
261 return VIDEO_PALETTE_YUV420P;
262 case IMGFMT_YUY2:
263 return VIDEO_PALETTE_YUV422;
264 case IMGFMT_UYVY:
265 return VIDEO_PALETTE_UYVY;
266 }
267 return -1;
268 }
269
270 // sets and sanitizes audio buffer/block sizes
271 static void setup_audio_buffer_sizes(priv_t *priv)
272 {
273 int bytes_per_sample = priv->audio_in.bytes_per_sample;
274
275 // make the audio buffer at least 5 seconds long
276 priv->audio_buffer_size = 1 + 5*priv->audio_in.samplerate
277 *priv->audio_in.channels
278 *bytes_per_sample/priv->audio_in.blocksize;
279 if (priv->audio_buffer_size < 256) priv->audio_buffer_size = 256;
280
281 // make the skew buffer at least 1 second long
282 priv->aud_skew_cnt = 1 + 1*priv->audio_in.samplerate
283 *priv->audio_in.channels
284 *bytes_per_sample/priv->audio_in.blocksize;
285 if (priv->aud_skew_cnt < 16) priv->aud_skew_cnt = 16;
286
287 mp_msg(MSGT_TV, MSGL_V, "Audio capture - buffer %d blocks of %d bytes, skew average from %d meas.\n",
288 priv->audio_buffer_size, priv->audio_in.blocksize, priv->aud_skew_cnt);
289 }
290
291 static tvi_handle_t *tvi_init_v4l(tv_param_t* tv_param)
292 {
293 tvi_handle_t *h;
294 priv_t *priv;
295
296 h = new_handle();
297 if (!h)
298 return NULL;
299
300 priv = h->priv;
301
302 /* set video device name */
303 if (!tv_param->device)
304 priv->video_device = strdup("/dev/video0");
305 else
306 priv->video_device = strdup(tv_param->device);
307
308 /* set video device name */
309 if (!tv_param->adevice)
310 priv->audio_device = NULL;
311 else {
312 priv->audio_device = strdup(tv_param->adevice);
313 }
314
315 /* allocation failed */
316 if (!priv->video_device) {
317 free_handle(h);
318 return NULL;
319 }
320
321 priv->tv_param=tv_param;
322 return h;
323 }
324
325 /* retrieves info about audio channels from the BTTV */
326 static void init_v4l_audio(priv_t *priv)
327 {
328 int i;
329 int reqmode;
330
331 if (!priv->capability.audios) return;
332
333 /* audio chanlist */
334
335 mp_msg(MSGT_TV, MSGL_V, " Audio devices: %d\n", priv->capability.audios);
336
337 mp_msg(MSGT_TV, MSGL_V, "Video capture card reports the audio setup as follows:\n");
338 for (i = 0; i < priv->capability.audios; i++)
339 {
340 if (i >= MAX_AUDIO_CHANNELS)
341 {
342 mp_msg(MSGT_TV, MSGL_ERR, "no space for more audio channels (increase in source!) (%d > %d)\n",
343 i, MAX_AUDIO_CHANNELS);
344 i = priv->capability.audios;
345 break;
346 }
347
348 priv->audio[i].audio = i;
349 if (ioctl(priv->video_fd, VIDIOCGAUDIO, &priv->audio[i]) == -1)
350 {
351 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get audio failed: %s\n", strerror(errno));
352 break;
353 }
354
355 /* mute all channels */
356 priv->audio[i].flags |= VIDEO_AUDIO_MUTE;
357 reqmode = -1;
358 if (priv->tv_param->amode >= 0) {
359 switch (priv->tv_param->amode) {
360 case 0:
361 reqmode = VIDEO_SOUND_MONO;
362 break;
363 case 1:
364 reqmode = VIDEO_SOUND_STEREO;
365 break;
366 case 2:
367 reqmode = VIDEO_SOUND_LANG1;
368 break;
369 case 3:
370 reqmode = VIDEO_SOUND_LANG2;
371 break;
372 default:
373 mp_msg(MSGT_TV, MSGL_ERR, "Unknown audio mode requested.\n");
374 break;
375 }
376 if (reqmode >= 0) priv->audio[i].mode = reqmode;
377 }
378 ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[i]);
379
380 // get the parameters back
381 if (ioctl(priv->video_fd, VIDIOCGAUDIO, &priv->audio[i]) == -1)
382 {
383 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get audio failed: %s\n", strerror(errno));
384 break;
385 }
386
387 switch(priv->audio[i].mode)
388 {
389 case VIDEO_SOUND_MONO:
390 case VIDEO_SOUND_LANG1:
391 case VIDEO_SOUND_LANG2:
392 priv->audio_channels[i] = 1;
393 break;
394 case VIDEO_SOUND_STEREO:
395 priv->audio_channels[i] = 2;
396 break;
397 default:
398 mp_msg(MSGT_TV, MSGL_ERR, "Card reports an unknown audio mode !\n");
399 mp_msg(MSGT_TV, MSGL_ERR, "Trying two channel audio. Use forcechan to override.\n");
400 priv->audio_channels[i] = 2;
401 break;
402 }
403
404 if (reqmode >= 0 && priv->audio[i].mode != reqmode) {
405 mp_msg(MSGT_TV, MSGL_ERR, "Audio mode setup warning!\n");
406 mp_msg(MSGT_TV, MSGL_ERR, "Requested mode was %s, but v4l still reports %s.\n",
407 audio_mode2name(reqmode), audio_mode2name(priv->audio[i].mode));
408 mp_msg(MSGT_TV, MSGL_ERR, "You may need \"forcechan\" option to force stereo/mono audio recording.\n");
409 }
410
411 /* display stuff */
412 mp_msg(MSGT_TV, MSGL_V, " %d: %s: ", priv->audio[i].audio,
413 priv->audio[i].name);
414 if (priv->audio[i].flags & VIDEO_AUDIO_MUTABLE) {
415 mp_msg(MSGT_TV, MSGL_V, "muted=%s ",
416 (priv->audio[i].flags & VIDEO_AUDIO_MUTE) ? "yes" : "no");
417 }
418 mp_msg(MSGT_TV, MSGL_V, "vol=%d bass=%d treble=%d balance=%d mode=%s",
419 priv->audio[i].volume, priv->audio[i].bass, priv->audio[i].treble,
420 priv->audio[i].balance, audio_mode2name(priv->audio[i].mode));
421 mp_msg(MSGT_TV, MSGL_V, " chan=%d\n", priv->audio_channels[i]);
422
423 if (priv->tv_param->forcechan >= 0)
424 priv->audio_channels[i] = priv->tv_param->forcechan;
425
426 // we'll call VIDIOCSAUDIO again when starting capture
427 // let's set audio mode to requested mode again for the case
428 // when VIDIOCGAUDIO just cannot report the mode correctly
429 if (reqmode >= 0) priv->audio[i].mode = reqmode;
430 }
431 }
432
433 #if !defined(__LINUX_VIDEODEV2_H) && !defined(VIDIOC_QUERYCAP)
434 struct v4l2_capability
435 {
436 __u8 driver[16]; /* i.e. "bttv" */
437 __u8 card[32]; /* i.e. "Hauppauge WinTV" */
438 __u8 bus_info[32]; /* "PCI:" + pci_dev->slot_name */
439 __u32 version; /* should use KERNEL_VERSION() */
440 __u32 capabilities; /* Device capabilities */
441 __u32 reserved[4];
442 };
443
444 #define VIDIOC_QUERYCAP _IOR ('V', 0, struct v4l2_capability)
445 #endif
446
447 static int init(priv_t *priv)
448 {
449 int i;
450
451 if (priv->tv_param->immediate == 1)
452 priv->tv_param->noaudio = 1;
453
454 priv->video_ringbuffer = NULL;
455 priv->video_timebuffer = NULL;
456 priv->video_avg_buffer = NULL;
457 priv->audio_ringbuffer = NULL;
458 priv->audio_skew_buffer = NULL;
459
460 priv->video_fd = open(priv->video_device, O_RDWR);
461 mp_msg(MSGT_TV, MSGL_DBG2, "Video fd: %d, %p\n", priv->video_fd,
462 priv->video_device);
463 if (priv->video_fd == -1)
464 {
465 mp_msg(MSGT_TV, MSGL_ERR, "unable to open '%s': %s\n",
466 priv->video_device, strerror(errno));
467 goto err;
468 }
469
470 /* check for v4l2 */
471 if (ioctl(priv->video_fd, VIDIOC_QUERYCAP, &priv->capability) == 0) {
472 mp_msg(MSGT_TV, MSGL_ERR, "=================================================================\n");
473 mp_msg(MSGT_TV, MSGL_ERR, " WARNING: YOU ARE USING V4L DEMUXER WITH V4L2 DRIVERS!!!\n");
474 mp_msg(MSGT_TV, MSGL_ERR, " As the V4L1 compatibility layer is broken, this may not work.\n");
475 mp_msg(MSGT_TV, MSGL_ERR, " If you encounter any problems, use driver=v4l2 instead.\n");
476 mp_msg(MSGT_TV, MSGL_ERR, " Bugreports on driver=v4l with v4l2 drivers will be ignored.\n");
477 mp_msg(MSGT_TV, MSGL_ERR, "=================================================================\n");
478 }
479
480 /* get capabilities (priv->capability is needed!) */
481 if (ioctl(priv->video_fd, VIDIOCGCAP, &priv->capability) == -1)
482 {
483 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get capabilites failed: %s\n", strerror(errno));
484 goto err;
485 }
486
487 fcntl(priv->video_fd, F_SETFD, FD_CLOEXEC);
488
489 mp_msg(MSGT_TV, MSGL_INFO, "Selected device: %s\n", priv->capability.name);
490 mp_msg(MSGT_TV, MSGL_INFO, " Capabilites: ");
491 for (i = 0; device_cap2name[i] != NULL; i++)
492 if (priv->capability.type & (1 << i))
493 mp_msg(MSGT_TV, MSGL_INFO, "%s ", device_cap2name[i]);
494 mp_msg(MSGT_TV, MSGL_INFO, "\n");
495 mp_msg(MSGT_TV, MSGL_INFO, " Device type: %d\n", priv->capability.type);
496 mp_msg(MSGT_TV, MSGL_INFO, " Supported sizes: %dx%d => %dx%d\n",
497 priv->capability.minwidth, priv->capability.minheight,
498 priv->capability.maxwidth, priv->capability.maxheight);
499 priv->width = priv->capability.minwidth;
500 priv->height = priv->capability.minheight;
501
502 /* somewhere here could disable priv->tv_param->mjpeg, if it is not a capability */
503
504 /* initialize if necessary */
505 if ( priv->tv_param->mjpeg )
506 {
507 struct mjpeg_params bparm;
508 struct mjpeg_requestbuffers breq; /* buffer requests */
509
510 if (ioctl(priv->video_fd, MJPIOC_G_PARAMS, &bparm) < 0)
511 {
512 mp_msg(MSGT_TV, MSGL_ERR,
513 " MJP: Error getting video parameters: %s\n", strerror(errno));
514 goto err;
515 }
516
517 mp_msg(MSGT_TV, MSGL_INFO,
518 " MJP: previous params: x: %d, y: %d, w: %d, h: %d, decim: %d, fields: %d,\n",
519 bparm.img_x, bparm.img_y, bparm.img_width, bparm.img_height,
520 bparm.decimation, bparm.field_per_buff);
521
522 mp_msg(MSGT_TV, MSGL_INFO,
523 " MJP: HorDcm: %d, VerDcm: %d, TmpDcm: %d\n",
524 bparm.HorDcm, bparm.VerDcm, bparm.TmpDcm);
525
526 bparm.input = priv->tv_param->input; /* tv */
527 if (!strcasecmp(priv->tv_param->norm, "pal"))
528 bparm.norm = 0; /* PAL */
529 else if (!strcasecmp(priv->tv_param->norm, "ntsc"))
530 bparm.norm = 1; /* NTSC */
531 else if (!strcasecmp(priv->tv_param->norm, "secam"))
532 bparm.norm = 2; /* SECAM */
533 bparm.quality = priv->tv_param->quality;
534 bparm.decimation = priv->tv_param->decimation;
535
536 mp_msg(MSGT_TV, MSGL_INFO, " MJP: setting params to decimation: %d, quality: %d\n",
537 bparm.decimation, bparm.quality);
538
539 if (ioctl(priv->video_fd, MJPIOC_S_PARAMS, &bparm) < 0)
540 {
541 mp_msg(MSGT_TV, MSGL_ERR,
542 " MJP: Error setting video parameters: %s\n", strerror(errno));
543 goto err;
544 }
545
546 if (ioctl(priv->video_fd, MJPIOC_G_PARAMS, &bparm) < 0)
547 {
548 mp_msg(MSGT_TV, MSGL_ERR,
549 " MJP: Error getting video parameters: %s\n", strerror(errno));
550 goto err;
551 }
552
553 mp_msg(MSGT_TV, MSGL_INFO,
554 " MJP: current params: x: %d, y: %d, w: %d, h: %d, decim: %d, fields: %d,\n",
555 bparm.img_x, bparm.img_y, bparm.img_width, bparm.img_height,
556 bparm.decimation, bparm.field_per_buff);
557
558 mp_msg(MSGT_TV, MSGL_INFO,
559 " MJP: HorDcm: %d, VerDcm: %d, TmpDcm: %d\n",
560 bparm.HorDcm, bparm.VerDcm, bparm.TmpDcm);
561
562
563 breq.count = 64;
564 priv -> nbuf = breq.count;
565 priv->mbuf.frames = priv -> nbuf;
566 priv->mjpeg_bufsize = 256*1024;
567 if (priv->tv_param->buffer_size >= 0)
568 priv->mjpeg_bufsize = priv->tv_param->buffer_size*1024;
569 breq.size = priv -> mjpeg_bufsize;
570 if (ioctl(priv->video_fd, MJPIOC_REQBUFS,&(breq)) < 0)
571 {
572 mp_msg (MSGT_TV, MSGL_ERR,
573 " MJP: Error requesting video buffers: %s\n", strerror(errno));
574 goto err;
575 }
576 mp_msg(MSGT_TV, MSGL_INFO,
577 " MJP: Got %ld buffers of size %ld KB\n",
578 breq.count, breq.size/1024);
579
580 priv -> mmap = mmap(0, breq.count * breq.size,
581 PROT_READ|PROT_WRITE, MAP_SHARED, priv->video_fd, 0);
582 if (priv -> mmap == MAP_FAILED)
583 {
584 mp_msg(MSGT_TV, MSGL_INFO,
585 " MJP: Error mapping video buffers: %s\n", strerror(errno));
586 goto err;
587 }
588 }
589
590 mp_msg(MSGT_TV, MSGL_INFO, " Inputs: %d\n", priv->capability.channels);
591 priv->channels = calloc(priv->capability.channels, sizeof(struct video_channel));
592 if (!priv->channels)
593 goto malloc_failed;
594 memset(priv->channels, 0, sizeof(struct video_channel)*priv->capability.channels);
595 for (i = 0; i < priv->capability.channels; i++)
596 {
597 priv->channels[i].channel = i;
598 if (ioctl(priv->video_fd, VIDIOCGCHAN, &priv->channels[i]) == -1)
599 {
600 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get channel failed: %s\n", strerror(errno));
601 break;
602 }
603 mp_msg(MSGT_TV, MSGL_INFO, " %d: %s: %s%s%s%s (tuner:%d, norm:%s)\n", i,
604 priv->channels[i].name,
605 (priv->channels[i].flags & VIDEO_VC_TUNER) ? "tuner " : "",
606 (priv->channels[i].flags & VIDEO_VC_AUDIO) ? "audio " : "",
607 (priv->channels[i].flags & VIDEO_TYPE_TV) ? "tv " : "",
608 (priv->channels[i].flags & VIDEO_TYPE_CAMERA) ? "camera " : "",
609 priv->channels[i].tuners,
610 norm2name(priv->channels[i].norm));
611 }
612 priv->act_channel = 0;
613
614 if (!(priv->capability.type & VID_TYPE_CAPTURE))
615 {
616 mp_msg(MSGT_TV, MSGL_ERR, "Only grabbing supported (for overlay use another program)\n");
617 goto err;
618 }
619
620
621 /* init v4l audio even when we don't capture */
622 init_v4l_audio(priv);
623
624 if (!priv->capability.audios && !priv->tv_param->force_audio) priv->tv_param->noaudio = 1;
625
626 /* audio init */
627 if (!priv->tv_param->noaudio) {
628
629 #ifdef CONFIG_ALSA
630 if (priv->tv_param->alsa)
631 audio_in_init(&priv->audio_in, AUDIO_IN_ALSA);
632 else
633 audio_in_init(&priv->audio_in, AUDIO_IN_OSS);
634 #else
635 audio_in_init(&priv->audio_in, AUDIO_IN_OSS);
636 #endif
637
638 if (priv->audio_device) {
639 audio_in_set_device(&priv->audio_in, priv->audio_device);
640 }
641
642 if (priv->tv_param->audio_id < priv->capability.audios)
643 priv->audio_id = priv->tv_param->audio_id;
644 else
645 priv->audio_id = 0;
646 audio_in_set_samplerate(&priv->audio_in, 44100);
647 if (priv->capability.audios) {
648 audio_in_set_channels(&priv->audio_in, priv->audio_channels[priv->audio_id]);
649 } else {
650 if (priv->tv_param->forcechan >= 0) {
651 audio_in_set_channels(&priv->audio_in, priv->tv_param->forcechan);
652 } else {
653 audio_in_set_channels(&priv->audio_in, 2);
654 }
655 }
656 if (audio_in_setup(&priv->audio_in) < 0) return 0;
657 setup_audio_buffer_sizes(priv);
658 }
659
660 return 1;
661
662 malloc_failed:
663 if (priv->channels)
664 free(priv->channels);
665 if (priv->buf)
666 free(priv->buf);
667 err:
668 if (priv->video_fd != -1)
669 close(priv->video_fd);
670 return 0;
671 }
672
673 static int uninit(priv_t *priv)
674 {
675 unsigned long num;
676
677 priv->vbi_shutdown=1;
678 if(priv->vbi_grabber_thread)
679 pthread_join(priv->vbi_grabber_thread, NULL);
680
681 teletext_control(priv->priv_vbi,TV_VBI_CONTROL_STOP,(void*)1);
682 priv->priv_vbi=NULL;
683
684 if(priv->vbi_fd){
685 close(priv->vbi_fd);
686 priv->vbi_fd=0;
687 }
688
689 if(priv->vbi_dev){
690 free(priv->vbi_dev);
691 priv->vbi_dev=0;
692 }
693
694 priv->shutdown = 1;
695
696 mp_msg(MSGT_TV, MSGL_V, "Waiting for threads to finish... ");
697 if (!priv->tv_param->noaudio) {
698 pthread_join(priv->audio_grabber_thread, NULL);
699 pthread_mutex_destroy(&priv->audio_starter);
700 pthread_mutex_destroy(&priv->skew_mutex);
701 }
702 pthread_mutex_destroy(&priv->video_buffer_mutex);
703 if(priv->video_grabber_thread)
704 pthread_join(priv->video_grabber_thread, NULL);
705
706 mp_msg(MSGT_TV, MSGL_V, "done\n");
707
708 if (priv->capability.audios) {
709 priv->audio[priv->audio_id].flags |= VIDEO_AUDIO_MUTE;
710 ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[priv->audio_id]);
711 }
712
713 if ( priv->tv_param->mjpeg )
714 {
715 num = -1;
716 if (ioctl(priv->video_fd, MJPIOC_QBUF_CAPT, &num) < 0)
717 mp_msg(MSGT_TV, MSGL_ERR, "\n MJP: ioctl MJPIOC_QBUF_CAPT failed: %s\n", strerror(errno));
718 }
719 else
720 {
721 // We need to munmap as close don't close mem mappings
722 if(munmap(priv->mmap,priv->mbuf.size))
723 mp_msg(MSGT_TV, MSGL_ERR, "Munmap failed: %s\n",strerror(errno));
724 }
725
726 if(close(priv->video_fd))
727 mp_msg(MSGT_TV, MSGL_ERR, "Close tv failed: %s\n",strerror(errno));
728
729 audio_in_uninit(&priv->audio_in);
730
731 if (priv->video_ringbuffer) {
732 int i;
733 for (i = 0; i < priv->video_buffer_size_current; i++) {
734 free(priv->video_ringbuffer[i]);
735 }
736 free(priv->video_ringbuffer);
737 }
738
739 if (priv->video_timebuffer)
740 free(priv->video_timebuffer);
741 if (priv->video_avg_buffer)
742 free(priv->video_avg_buffer);
743 if (!priv->tv_param->noaudio) {
744 if (priv->audio_ringbuffer)
745 free(priv->audio_ringbuffer);
746 if (priv->audio_skew_buffer)
747 free(priv->audio_skew_buffer);
748 }
749
750 return 1;
751 }
752
753 static int get_capture_buffer_size(priv_t *priv)
754 {
755 int bufsize, cnt;
756
757 if (priv->tv_param->buffer_size >= 0) {
758 bufsize = priv->tv_param->buffer_size*1024*1024;
759 } else {
760 #ifdef HAVE_SYS_SYSINFO_H
761 struct sysinfo si;
762
763 sysinfo(&si);
764 if (si.totalram<2*1024*1024) {
765 bufsize = 1024*1024;
766 } else {
767 bufsize = si.totalram/2;
768 }
769 #else
770 bufsize = 16*1024*1024;
771 #endif
772 }
773
774 cnt = bufsize/(priv->height*priv->bytesperline);
775 if (cnt < 2) cnt = 2;
776
777 return cnt;
778 }
779
780 static int vbi_init(priv_t* priv,char* device)
781 {
782 int vbi_fd=0;
783 struct video_capability cap;
784
785 if(!device)
786 return TVI_CONTROL_FALSE;
787
788 priv->vbi_dev=strdup(device);
789
790 vbi_fd=open(priv->vbi_dev,O_RDWR);
791 if(vbi_fd<0){
792 mp_msg(MSGT_TV,MSGL_ERR,"vbi: could not open device %s\n",priv->vbi_dev);
793 return TVI_CONTROL_FALSE;
794 }
795
796 if(ioctl(vbi_fd,VIDIOCGCAP,&cap)<0){
797 mp_msg(MSGT_TV,MSGL_ERR,"vbi: Query capatibilities failed for %s\n",priv->vbi_dev);
798 close(vbi_fd);
799 return TVI_CONTROL_FALSE;
800 }
801 if(!cap.type & VID_TYPE_CAPTURE){
802 mp_msg(MSGT_TV,MSGL_ERR,"vbi: %s is not capture device\n",priv->vbi_dev);
803 close(vbi_fd);
804 return TVI_CONTROL_FALSE;
805 }
806
807 priv->vbi_fd=vbi_fd;
808 mp_msg(MSGT_TV,MSGL_DBG3,"vbi: init ok\n");
809 return TVI_CONTROL_TRUE;
810 }
811
812 static int vbi_get_props(priv_t* priv,tt_stream_props* ptsp)
813 {
814 struct vbi_format fmt;
815 int res;
816 if(!priv || !ptsp)
817 return TVI_CONTROL_FALSE;
818
819 memset(&fmt,0,sizeof(struct vbi_format));
820 if((res=ioctl(priv->vbi_fd,VIDIOCGVBIFMT,&fmt))<0){
821 mp_msg(MSGT_TV,MSGL_ERR,"vbi_get_props: Query format failed: %x\n",res);
822 return TVI_CONTROL_FALSE;
823 }
824
825 ptsp->interlaced=(fmt.flags& VBI_INTERLACED?1:0);
826 if(fmt.start[1]>0 && fmt.count[1]){
827 if(fmt.start[1]>=286)
828 //625
829 ptsp->offset=10.2e-6*fmt.sampling_rate;
830 else
831 //525
832 ptsp->offset=9.2e-6*fmt.sampling_rate;
833 }else
834 ptsp->offset=9.7e-6*fmt.sampling_rate;
835
836 ptsp->sampling_rate=fmt.sampling_rate;
837 ptsp->samples_per_line=fmt.samples_per_line,
838
839 ptsp->count[0]=fmt.count[0];
840 ptsp->count[1]=fmt.count[1];
841 ptsp->bufsize = ptsp->samples_per_line * (ptsp->count[0] + ptsp->count[1]);
842
843 mp_msg(MSGT_TV,MSGL_V,"vbi_get_props: sampling_rate=%d,offset:%d,samples_per_line: %d\n interlaced:%s, count=[%d,%d]\n",
844 ptsp->sampling_rate,
845 ptsp->offset,
846 ptsp->samples_per_line,
847 ptsp->interlaced?"Yes":"No",
848 ptsp->count[0],
849 ptsp->count[1]);
850
851 return TVI_CONTROL_TRUE;
852 }
853
854 static void *vbi_grabber(void *data)
855 {
856 priv_t *priv = (priv_t *) data;
857 int bytes,seq,prev_seq;
858 unsigned char* buf;
859 tt_stream_props tsp;
860
861 if(!priv->priv_vbi){
862 mp_msg(MSGT_TV,MSGL_WARN,"vbi: vbi not initialized. stopping thread.\n");
863 return NULL;
864 }
865
866 if(vbi_get_props(priv,&tsp)!=TVI_CONTROL_TRUE)
867 return NULL;
868
869 buf=malloc(tsp.bufsize);
870 seq=0;
871 prev_seq=0;
872 mp_msg(MSGT_TV,MSGL_V,"vbi: vbi capture thread started.\n");
873
874 while (!priv->vbi_shutdown){
875 bytes=read(priv->vbi_fd,buf,tsp.bufsize);
876 if(bytes<0 && errno==EINTR)
877 continue;
878 if (bytes!=tsp.bufsize){
879 mp_msg(MSGT_TV,MSGL_WARN,"vbi: expecting bytes: %d, got: %d",tsp.bufsize,bytes);
880 break;
881 }
882 seq=*(int*)(buf+bytes-4);
883 if(seq<=1) continue;
884 if (prev_seq && seq!=prev_seq+1){
885 prev_seq=0;
886 seq=0;
887 }
888 prev_seq=seq;
889 teletext_control(priv->priv_vbi,TV_VBI_CONTROL_DECODE_PAGE,&buf);
890 mp_msg(MSGT_TV,MSGL_DBG3,"grabber: seq:%d\n",seq);
891 }
892 free(buf);
893 return NULL;
894 }
895
896 static int start(priv_t *priv)
897 {
898 int i;
899 int bytes_per_sample;
900 struct video_window win;
901
902 if (ioctl(priv->video_fd, VIDIOCGPICT, &priv->picture) == -1)
903 {
904 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get picture failed: %s\n", strerror(errno));
905 return 0;
906 }
907
908 priv->picture.palette = format2palette(priv->format);
909 priv->picture.depth = palette2depth(priv->picture.palette);
910
911 if (priv->format != IMGFMT_BGR15) {
912 priv->bytesperline = priv->width * priv->picture.depth / 8;
913 } else {
914 priv->bytesperline = priv->width * 2;
915 }
916
917 mp_msg(MSGT_TV, MSGL_V, "Picture values:\n");
918 mp_msg(MSGT_TV, MSGL_V, " Depth: %d, Palette: %s (Format: %s)\n", priv->picture.depth,
919 PALETTE(priv->picture.palette), vo_format_name(priv->format));
920 mp_msg(MSGT_TV, MSGL_V, " Brightness: %d, Hue: %d, Colour: %d, Contrast: %d\n",
921 priv->picture.brightness, priv->picture.hue,
922 priv->picture.colour, priv->picture.contrast);
923
924 if (ioctl(priv->video_fd, VIDIOCSPICT, &priv->picture) == -1)
925 {
926 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set picture failed: %s\n", strerror(errno));
927 mp_msg(MSGT_TV, MSGL_ERR, "The 'outfmt' of '%s' is likely not supported by your card\n",
928 vo_format_name(priv->format));
929 return 0;
930 }
931
932 /* Set capture size */
933 win.x = 0;
934 win.y = 0;
935 win.width = priv->width;
936 win.height = priv->height;
937 win.chromakey = -1;
938 win.flags = 0;
939 win.clipcount = 0;
940 if (ioctl(priv->video_fd, VIDIOCSWIN, &win) == -1)
941 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set window failed: %s\n", strerror(errno));
942
943 if ( !priv->tv_param->mjpeg )
944 {
945 /* map grab buffer */
946 if (ioctl(priv->video_fd, VIDIOCGMBUF, &priv->mbuf) == -1)
947 {
948 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get mbuf failed: %s\n", strerror(errno));
949 return 0;
950 }
951
952 mp_msg(MSGT_TV, MSGL_V, "mbuf: size=%d, frames=%d\n",
953 priv->mbuf.size, priv->mbuf.frames);
954 priv->mmap = mmap(0, priv->mbuf.size, PROT_READ|PROT_WRITE,
955 MAP_SHARED, priv->video_fd, 0);
956 if (priv->mmap == (unsigned char *)-1)
957 {
958 mp_msg(MSGT_TV, MSGL_ERR, "Unable to map memory for buffers: %s\n", strerror(errno));
959 return 0;
960 }
961 mp_msg(MSGT_TV, MSGL_DBG2, "our buffer: %p\n", priv->mmap);
962
963 /* num of buffers */
964 priv->nbuf = priv->mbuf.frames;
965
966 /* video buffers */
967 priv->buf = calloc(priv->nbuf, sizeof(struct video_mmap));
968 if (!priv->buf)
969 return 0;
970 memset(priv->buf, 0, priv->nbuf * sizeof(struct video_mmap));
971 }
972
973 if ( !priv->tv_param->mjpeg )
974 {
975 priv->nbuf = priv->mbuf.frames;
976 for (i=0; i < priv->nbuf; i++)
977 {
978 priv->buf[i].format = priv->picture.palette;
979 priv->buf[i].frame = i;
980 priv->buf[i].width = priv->width;
981 priv->buf[i].height = priv->height;
982 mp_msg(MSGT_TV, MSGL_DBG2, "buffer: %d => %p\n", i, &priv->buf[i]);
983 }
984 }
985
986 #if 0
987 {
988 struct video_play_mode pmode;
989
990 pmode.mode = VID_PLAY_NORMAL;
991 pmode.p1 = 1;
992 pmode.p2 = 0;
993 if (ioctl(priv->video_fd, VIDIOCSPLAYMODE, &pmode) == -1)
994 {
995 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set play mode failed: %s\n", strerror(errno));
996 // return 0;
997 }
998 }
999 #endif
1000
1001 #if 0
1002 // initialize video capture
1003 if (ioctl(priv->video_fd, VIDIOCCAPTURE, &one) == -1)
1004 {
1005 mp_msg(MSGT_TV, MSGL_ERR, "FATAL: ioctl ccapture failed: %s\n", strerror(errno));
1006 return 0;
1007 }
1008 #endif
1009
1010 /* setup audio parameters */
1011 if (!priv->tv_param->noaudio) {
1012 setup_audio_buffer_sizes(priv);
1013 bytes_per_sample = priv->audio_in.bytes_per_sample;
1014 priv->audio_skew_buffer = calloc(priv->aud_skew_cnt, sizeof(long long));
1015 if (!priv->audio_skew_buffer) {
1016 mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate skew buffer: %s\n", strerror(errno));
1017 return 0;
1018 }
1019
1020 priv->audio_ringbuffer = calloc(priv->audio_in.blocksize, priv->audio_buffer_size);
1021 if (!priv->audio_ringbuffer) {
1022 mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate audio buffer: %s\n", strerror(errno));
1023 return 0;
1024 }
1025
1026 priv->audio_secs_per_block = (double)priv->audio_in.blocksize/(priv->audio_in.samplerate
1027 *priv->audio_in.channels
1028 *bytes_per_sample);
1029 priv->audio_head = 0;
1030 priv->audio_tail = 0;
1031 priv->audio_cnt = 0;
1032 priv->audio_drop = 0;
1033 priv->audio_skew = 0;
1034 priv->audio_skew_total = 0;
1035 priv->audio_recv_blocks_total = 0;
1036 priv->audio_sent_blocks_total = 0;
1037 }
1038
1039 /* setup video parameters */
1040 if (priv->immediate_mode) {
1041 priv->video_buffer_size_max = VID_BUF_SIZE_IMMEDIATE;
1042 } else {
1043 priv->video_buffer_size_max = get_capture_buffer_size(priv);
1044 }
1045 priv->video_buffer_size_current = 0;
1046
1047 if (!priv->tv_param->noaudio) {
1048 if (priv->video_buffer_size_max < 3.0*priv->fps*priv->audio_secs_per_block) {
1049 mp_msg(MSGT_TV, MSGL_ERR, "Video buffer shorter than 3 times audio frame duration.\n"
1050 "You will probably experience heavy framedrops.\n");
1051 }
1052 }
1053
1054 mp_msg(MSGT_TV, MSGL_V, "Using a ring buffer for maximum %d frames, %d MB total size.\n",
1055 priv->video_buffer_size_max,
1056 priv->video_buffer_size_max*priv->height*priv->bytesperline/(1024*1024));
1057
1058 priv->video_ringbuffer = calloc(priv->video_buffer_size_max, sizeof(unsigned char*));
1059 if (!priv->video_ringbuffer) {
1060 mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate video buffer: %s\n", strerror(errno));
1061 return 0;
1062 }
1063 for (i = 0; i < priv->video_buffer_size_max; i++)
1064 priv->video_ringbuffer[i] = NULL;
1065
1066 priv->video_timebuffer = calloc(priv->video_buffer_size_max, sizeof(long long));
1067 if (!priv->video_timebuffer) {
1068 mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate time buffer: %s\n", strerror(errno));
1069 return 0;
1070 }
1071 priv->video_avg_buffer = malloc(sizeof(long long) * VIDEO_AVG_BUFFER_SIZE);
1072 if (!priv->video_avg_buffer) {
1073 mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate period buffer: %s\n", strerror(errno));
1074 return 0;
1075 }
1076 priv->video_interval_sum = (1e6/priv->fps)*VIDEO_AVG_BUFFER_SIZE;
1077 for (i = 0; i < VIDEO_AVG_BUFFER_SIZE; i++) {
1078 priv->video_avg_buffer[i] = 1e6/priv->fps;
1079 }
1080
1081 priv->video_avg_ptr = 0;
1082
1083 priv->video_head = 0;
1084 priv->video_tail = 0;
1085 priv->video_cnt = 0;
1086 priv->first = 1;
1087
1088 if (priv->capability.audios) {
1089 /* enable audio */
1090 if (priv->tv_param->volume >= 0)
1091 priv->audio[priv->audio_id].volume = priv->tv_param->volume;
1092 if (priv->tv_param->bass >= 0)
1093 priv->audio[priv->audio_id].bass = priv->tv_param->bass;
1094 if (priv->tv_param->treble >= 0)
1095 priv->audio[priv->audio_id].treble = priv->tv_param->treble;
1096 if (priv->tv_param->balance >= 0)
1097 priv->audio[priv->audio_id].balance = priv->tv_param->balance;
1098 priv->audio[priv->audio_id].flags &= ~VIDEO_AUDIO_MUTE;
1099 mp_msg(MSGT_TV, MSGL_V, "Enabling tv audio. Requested setup is:\n");
1100 mp_msg(MSGT_TV, MSGL_V, "id=%d vol=%d bass=%d treble=%d balance=%d mode=%s",
1101 priv->audio_id,
1102 priv->audio[priv->audio_id].volume, priv->audio[priv->audio_id].bass, priv->audio[priv->audio_id].treble,
1103 priv->audio[priv->audio_id].balance, audio_mode2name(priv->audio[priv->audio_id].mode));
1104 mp_msg(MSGT_TV, MSGL_V, " chan=%d\n", priv->audio_channels[priv->audio_id]);
1105 ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[priv->audio_id]);
1106 }
1107
1108 /* start vbi thread */
1109 if(priv->priv_vbi){
1110 priv->vbi_shutdown = 0;
1111 pthread_create(&priv->vbi_grabber_thread, NULL, vbi_grabber, priv);
1112 }
1113
1114 /* launch capture threads */
1115 priv->shutdown = 0;
1116 if (!priv->tv_param->noaudio) {
1117 pthread_mutex_init(&priv->audio_starter, NULL);
1118 pthread_mutex_init(&priv->skew_mutex, NULL);
1119 pthread_mutex_lock(&priv->audio_starter);
1120 pthread_create(&priv->audio_grabber_thread, NULL, audio_grabber, priv);
1121 }
1122 pthread_mutex_init(&priv->video_buffer_mutex, NULL);
1123 /* we'll launch the video capture later, when a first request for a frame arrives */
1124
1125 return 1;
1126 }
1127
1128
1129 static int control(priv_t *priv, int cmd, void *arg)
1130 {
1131 mp_msg(MSGT_TV, MSGL_DBG2, "\ndebug: control(priv=%p, cmd=%d, arg=%p)\n",
1132 priv, cmd, arg);
1133 switch(cmd)
1134 {
1135 /* ========== GENERIC controls =========== */
1136 case TVI_CONTROL_IS_VIDEO:
1137 {
1138 if (priv->capability.type & VID_TYPE_CAPTURE)
1139 return TVI_CONTROL_TRUE;
1140 return TVI_CONTROL_FALSE;
1141 }
1142 case TVI_CONTROL_IS_AUDIO:
1143 if (priv->tv_param->force_audio) return TVI_CONTROL_TRUE;
1144 if (priv->channels[priv->act_channel].flags & VIDEO_VC_AUDIO)
1145 {
1146 return TVI_CONTROL_TRUE;
1147 }
1148 return TVI_CONTROL_FALSE;
1149 case TVI_CONTROL_IS_TUNER:
1150 {
1151 // if (priv->capability.type & VID_TYPE_TUNER)
1152 if (priv->channels[priv->act_channel].flags & VIDEO_VC_TUNER)
1153 return TVI_CONTROL_TRUE;
1154 return TVI_CONTROL_FALSE;
1155 }
1156
1157 /* ========== VIDEO controls =========== */
1158 case TVI_CONTROL_VID_GET_FORMAT:
1159 {
1160 int output_fmt = -1;
1161
1162 output_fmt = priv->format;
1163 if ( priv->tv_param->mjpeg )
1164 {
1165 mp_msg(MSGT_TV, MSGL_INFO, " MJP: setting sh_video->format to mjpg\n");
1166 output_fmt = 0x47504a4d;
1167 output_fmt = 0x67706a6d;
1168 *(int *)arg = output_fmt;
1169 mp_msg(MSGT_TV, MSGL_V, "Output format: %s\n", "mjpg");
1170 }
1171 else
1172 {
1173 *(int *)arg = output_fmt;
1174 mp_msg(MSGT_TV, MSGL_V, "Output format: %s\n", vo_format_name(output_fmt));
1175 }
1176 return TVI_CONTROL_TRUE;
1177 }
1178 case TVI_CONTROL_VID_SET_FORMAT:
1179 priv->format = *(int *)arg;
1180 // !HACK! v4l uses BGR format instead of RGB
1181 // and we have to correct this. Fortunately,
1182 // tv.c reads later the format back so we
1183 // can persuade it to use what we want.
1184 if (IMGFMT_IS_RGB(priv->format)) {
1185 priv->format &= ~IMGFMT_RGB_MASK;
1186 priv->format |= IMGFMT_BGR;
1187 }
1188 return TVI_CONTROL_TRUE;
1189 case TVI_CONTROL_VID_GET_PLANES:
1190 *(int *)arg = 1; /* FIXME, also not needed at this time */
1191 return TVI_CONTROL_TRUE;
1192 case TVI_CONTROL_VID_GET_BITS:
1193 *(int *)arg = palette2depth(format2palette(priv->format));
1194 return TVI_CONTROL_TRUE;
1195 case TVI_CONTROL_VID_GET_WIDTH:
1196 *(int *)arg = priv->width;
1197 return TVI_CONTROL_TRUE;
1198 case TVI_CONTROL_VID_CHK_WIDTH:
1199 {
1200 int req_width = *(int *)arg;
1201
1202 mp_msg(MSGT_TV, MSGL_V, "Requested width: %d\n", req_width);
1203 if ((req_width >= priv->capability.minwidth) &&
1204 (req_width <= priv->capability.maxwidth))
1205 return TVI_CONTROL_TRUE;
1206 return TVI_CONTROL_FALSE;
1207 }
1208 case TVI_CONTROL_VID_SET_WIDTH:
1209 priv->width = *(int *)arg;
1210 return TVI_CONTROL_TRUE;
1211 case TVI_CONTROL_VID_GET_HEIGHT:
1212 *(int *)arg = priv->height;
1213 return TVI_CONTROL_TRUE;
1214 case TVI_CONTROL_VID_CHK_HEIGHT:
1215 {
1216 int req_height = *(int *)arg;
1217
1218 mp_msg(MSGT_TV, MSGL_V, "Requested height: %d\n", req_height);
1219 if ((req_height >= priv->capability.minheight) &&
1220 (req_height <= priv->capability.maxheight))
1221 return TVI_CONTROL_TRUE;
1222 return TVI_CONTROL_FALSE;
1223 }
1224 case TVI_CONTROL_VID_SET_HEIGHT:
1225 priv->height = *(int *)arg;
1226 return TVI_CONTROL_TRUE;
1227 case TVI_CONTROL_VID_GET_PICTURE:
1228 if (ioctl(priv->video_fd, VIDIOCGPICT, &priv->picture) == -1)
1229 {
1230 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get picture failed: %s\n", strerror(errno));
1231 return TVI_CONTROL_FALSE;
1232 }
1233 return TVI_CONTROL_TRUE;
1234 case TVI_CONTROL_VID_SET_PICTURE:
1235 if (ioctl(priv->video_fd, VIDIOCSPICT, &priv->picture) == -1)
1236 {
1237 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set picture failed: %s\n", strerror(errno));
1238 return TVI_CONTROL_FALSE;
1239 }
1240 return TVI_CONTROL_TRUE;
1241 case TVI_CONTROL_VID_SET_BRIGHTNESS:
1242 priv->picture.brightness = (327*(*(int *)arg+100)) + 68;
1243 return control(priv, TVI_CONTROL_VID_SET_PICTURE, 0);
1244 case TVI_CONTROL_VID_SET_HUE:
1245 priv->picture.hue = (327*(*(int *)arg+100)) + 68;
1246 return control(priv, TVI_CONTROL_VID_SET_PICTURE, 0);
1247 case TVI_CONTROL_VID_SET_SATURATION:
1248 priv->picture.colour = (327*(*(int *)arg+100)) + 68;
1249 return control(priv, TVI_CONTROL_VID_SET_PICTURE, 0);
1250 case TVI_CONTROL_VID_SET_CONTRAST:
1251 priv->picture.contrast = (327*(*(int *)arg+100)) + 68;
1252 return control(priv, TVI_CONTROL_VID_SET_PICTURE, 0);
1253 case TVI_CONTROL_VID_GET_BRIGHTNESS:
1254 if(!control(priv, TVI_CONTROL_VID_GET_PICTURE, 0)) return 0;
1255 *(int*)arg = ((int)priv->picture.brightness-68)/327-100;
1256 return 1;
1257 case TVI_CONTROL_VID_GET_HUE:
1258 if(!control(priv, TVI_CONTROL_VID_GET_PICTURE, 0)) return 0;
1259 *(int*)arg = ((int)priv->picture.hue-68)/327-100;
1260 return 1;
1261 case TVI_CONTROL_VID_GET_SATURATION:
1262 if(!control(priv, TVI_CONTROL_VID_GET_PICTURE, 0)) return 0;
1263 *(int*)arg = ((int)priv->picture.colour-68)/327-100;
1264 return 1;
1265 case TVI_CONTROL_VID_GET_CONTRAST:
1266 if(!control(priv, TVI_CONTROL_VID_GET_PICTURE, 0)) return 0;
1267 *(int*)arg = ((int)priv->picture.contrast-68)/327-100;
1268 return 1;
1269 case TVI_CONTROL_VID_GET_FPS:
1270 *(float *)arg=priv->fps;
1271 return TVI_CONTROL_TRUE;
1272
1273 /* ========== TUNER controls =========== */
1274 case TVI_CONTROL_TUN_GET_FREQ:
1275 {
1276 unsigned long freq;
1277
1278 if (ioctl(priv->video_fd, VIDIOCGFREQ, &freq) == -1)
1279 {
1280 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get freq failed: %s\n", strerror(errno));
1281 return TVI_CONTROL_FALSE;
1282 }
1283
1284 /* tuner uses khz not mhz ! */
1285 // if (priv->tuner.flags & VIDEO_TUNER_LOW)
1286 // freq /= 1000;
1287 *(unsigned long *)arg = freq;
1288 return TVI_CONTROL_TRUE;
1289 }
1290 case TVI_CONTROL_TUN_SET_FREQ:
1291 {
1292 /* argument is in MHz ! */
1293 unsigned long freq = *(unsigned long *)arg;
1294
1295 if (priv->capability.audios) {
1296 priv->audio[priv->audio_id].flags |= VIDEO_AUDIO_MUTE;
1297 ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[priv->audio_id]);
1298 }
1299
1300 mp_msg(MSGT_TV, MSGL_V, "requested frequency: %.3f\n", (float)freq/16);
1301
1302 /* tuner uses khz not mhz ! */
1303 // if (priv->tuner.flags & VIDEO_TUNER_LOW)
1304 // freq *= 1000;
1305 // mp_msg(MSGT_TV, MSGL_V, " requesting from driver: freq=%.3f\n", (float)freq/16);
1306 if (ioctl(priv->video_fd, VIDIOCSFREQ, &freq) == -1)
1307 {
1308 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set freq failed: %s\n", strerror(errno));
1309 return TVI_CONTROL_FALSE;
1310 }
1311 usleep(100000); // wait to suppress noise during switching
1312
1313 if (priv->capability.audios) {
1314 priv->audio[priv->audio_id].flags &= ~VIDEO_AUDIO_MUTE;
1315 ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[priv->audio_id]);
1316 }
1317
1318 return TVI_CONTROL_TRUE;
1319 }
1320 case TVI_CONTROL_TUN_GET_TUNER:
1321 {
1322 if (ioctl(priv->video_fd, VIDIOCGTUNER, &priv->tuner) == -1)
1323 {
1324 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get tuner failed: %s\n", strerror(errno));
1325 return TVI_CONTROL_FALSE;
1326 }
1327
1328 mp_msg(MSGT_TV, MSGL_V, "Tuner (%s) range: %lu -> %lu\n", priv->tuner.name,
1329 priv->tuner.rangelow, priv->tuner.rangehigh);
1330 return TVI_CONTROL_TRUE;
1331 }
1332 case TVI_CONTROL_TUN_SET_TUNER:
1333 {
1334 if (ioctl(priv->video_fd, VIDIOCSTUNER, &priv->tuner) == -1)
1335 {
1336 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set tuner failed: %s\n", strerror(errno));
1337 return TVI_CONTROL_FALSE;
1338 }
1339 return TVI_CONTROL_TRUE;
1340 }
1341 case TVI_CONTROL_TUN_SET_NORM:
1342 {
1343 int req_mode = *(int *)arg;
1344 int norm_index;
1345 for(norm_index=0;supported_norms[norm_index].name; norm_index++)
1346 if(req_mode==supported_norms[norm_index].normid)
1347 break;
1348
1349 if(!supported_norms[norm_index].name) {
1350 mp_msg(MSGT_TV, MSGL_ERR, "Unknown norm!\n");
1351 return TVI_CONTROL_FALSE;
1352 }
1353
1354 if (priv->channels[priv->act_channel].flags & VIDEO_VC_TUNER) {
1355 int prev_mode;
1356
1357 control(priv, TVI_CONTROL_TUN_GET_TUNER, 0);
1358 if(!(priv->tuner.flags & supported_norms[norm_index].tuner_flags))
1359 {
1360 mp_msg(MSGT_TV, MSGL_ERR, "Tuner isn't capable to set norm!\n");
1361 return TVI_CONTROL_FALSE;
1362 }
1363
1364 prev_mode = priv->tuner.mode;
1365
1366 priv->tuner.mode = supported_norms[norm_index].tuner_mode;
1367
1368 if (control(priv, TVI_CONTROL_TUN_SET_TUNER, &priv->tuner) != TVI_CONTROL_TRUE) {
1369 // norm setting failed, but maybe it's only because it's fixed
1370 if (priv->tuner.mode != prev_mode) return TVI_CONTROL_FALSE; // no it really failed
1371 }
1372
1373 }
1374
1375 priv->channels[priv->act_channel].norm = supported_norms[norm_index].input_norm;
1376
1377 if (ioctl(priv->video_fd, VIDIOCSCHAN, &priv->channels[priv->act_channel]) == -1)
1378 {
1379 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set chan failed: %s\n", strerror(errno));
1380 return TVI_CONTROL_FALSE;
1381 }
1382
1383 if (ioctl(priv->video_fd, VIDIOCGCAP, &priv->capability) == -1) {
1384 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get capabilites failed: %s\n", strerror(errno));
1385 return TVI_CONTROL_FALSE;
1386 }
1387
1388 priv->fps = supported_norms[norm_index].fps;
1389
1390 if(priv->height > priv->capability.maxheight) {
1391 priv->height = priv->capability.maxheight;
1392 }
1393
1394 if(priv->width > priv->capability.maxwidth) {
1395 priv->width = priv->capability.maxwidth;
1396 }
1397
1398 return TVI_CONTROL_TRUE;
1399 }
1400 case TVI_CONTROL_TUN_GET_NORM:
1401 {
1402 *(int *)arg = priv->tuner.mode;
1403
1404 return TVI_CONTROL_TRUE;
1405 }
1406 case TVI_CONTROL_TUN_GET_SIGNAL:
1407 {
1408 if (ioctl(priv->video_fd, VIDIOCGTUNER, &priv->tuner) == -1)
1409 {
1410 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get tuner failed: %s\n", strerror(errno));
1411 return TVI_CONTROL_FALSE;
1412 }
1413 *(int*)arg=100*(priv->tuner.signal>>8)/255;
1414 return TVI_CONTROL_TRUE;
1415 }
1416
1417 /* ========== AUDIO controls =========== */
1418 case TVI_CONTROL_AUD_GET_FORMAT:
1419 {
1420 *(int *)arg = AF_FORMAT_S16_LE;
1421 return TVI_CONTROL_TRUE;
1422 }
1423 case TVI_CONTROL_AUD_GET_CHANNELS:
1424 {
1425 *(int *)arg = priv->audio_in.channels;
1426 return TVI_CONTROL_TRUE;
1427 }
1428 case TVI_CONTROL_AUD_GET_SAMPLERATE:
1429 {
1430 *(int *)arg = priv->audio_in.samplerate;
1431 return TVI_CONTROL_TRUE;
1432 }
1433 case TVI_CONTROL_AUD_GET_SAMPLESIZE:
1434 {
1435 *(int *)arg = priv->audio_in.bytes_per_sample;
1436 return TVI_CONTROL_TRUE;
1437 }
1438 case TVI_CONTROL_AUD_SET_SAMPLERATE:
1439 {
1440 if (audio_in_set_samplerate(&priv->audio_in, *(int *)arg) < 0) return TVI_CONTROL_FALSE;
1441 setup_audio_buffer_sizes(priv);
1442 return TVI_CONTROL_TRUE;
1443 }
1444 /* ========== SPECIFIC controls =========== */
1445 case TVI_CONTROL_SPC_GET_INPUT:
1446 {
1447 int req_chan = *(int *)arg;
1448 int i;
1449
1450 for (i = 0; i < priv->capability.channels; i++)
1451 {
1452 if (priv->channels[i].channel == req_chan)
1453 break;
1454 }
1455
1456 priv->act_channel = i;
1457
1458 if (ioctl(priv->video_fd, VIDIOCGCHAN, &priv->channels[i]) == -1)
1459 {
1460 mp_msg(MSGT_TV, MSGL_ERR, "ioctl get channel failed: %s\n", strerror(errno));
1461 return TVI_CONTROL_FALSE;
1462 }
1463 return TVI_CONTROL_TRUE;
1464 }
1465
1466 case TVI_CONTROL_SPC_SET_INPUT:
1467 {
1468 struct video_channel chan;
1469 int req_chan = *(int *)arg;
1470 int i;
1471
1472 if (req_chan >= priv->capability.channels)
1473 {
1474 mp_msg(MSGT_TV, MSGL_ERR, "Invalid input requested: %d, valid: 0-%d\n",
1475 req_chan, priv->capability.channels - 1);
1476 return TVI_CONTROL_FALSE;
1477 }
1478
1479 for (i = 0; i < priv->capability.channels; i++)
1480 {
1481 if (priv->channels[i].channel == req_chan)
1482 chan = priv->channels[i];
1483 }
1484
1485 if (ioctl(priv->video_fd, VIDIOCSCHAN, &chan) == -1)
1486 {
1487 mp_msg(MSGT_TV, MSGL_ERR, "ioctl set chan failed: %s\n", strerror(errno));
1488 return TVI_CONTROL_FALSE;
1489 }
1490 mp_msg(MSGT_TV, MSGL_INFO, "Using input '%s'\n", chan.name);
1491
1492 priv->act_channel = i;
1493
1494 /* update tuner state */
1495 // if (priv->capability.type & VID_TYPE_TUNER)
1496 if (priv->channels[priv->act_channel].flags & VIDEO_VC_TUNER)
1497 control(priv, TVI_CONTROL_TUN_GET_TUNER, 0);
1498
1499 /* update local channel list */
1500 control(priv, TVI_CONTROL_SPC_GET_INPUT, &req_chan);
1501 return TVI_CONTROL_TRUE;
1502 case TVI_CONTROL_IMMEDIATE:
1503 priv->immediate_mode = 1;
1504 return TVI_CONTROL_TRUE;
1505 }
1506 case TVI_CONTROL_VBI_INIT:
1507 {
1508 void* ptr;
1509 tt_stream_props tsp;
1510
1511 if (vbi_init(priv,*(char**)arg)!=TVI_CONTROL_TRUE)
1512 return TVI_CONTROL_FALSE;
1513 if(vbi_get_props(priv,&tsp)==TVI_CONTROL_TRUE)
1514 {
1515 ptr=&tsp;
1516 if(teletext_control(NULL,TV_VBI_CONTROL_START,&ptr)==VBI_CONTROL_TRUE)
1517 priv->priv_vbi=ptr;
1518 else
1519 priv->priv_vbi=NULL;
1520 }
1521 return TVI_CONTROL_TRUE;
1522 }
1523 case TVI_CONTROL_GET_VBI_PTR:
1524 *(void **)arg=priv->priv_vbi;
1525 return TVI_CONTROL_TRUE;
1526 }
1527
1528 return TVI_CONTROL_UNKNOWN;
1529 }
1530
1531 static int set_mute(priv_t* priv,int value)
1532 {
1533 if (!priv->capability.audios) {
1534 return 0;
1535
1536 if(value)
1537 priv->audio[priv->audio_id].flags |=VIDEO_AUDIO_MUTE;
1538 else
1539 priv->audio[priv->audio_id].flags &= ~VIDEO_AUDIO_MUTE;
1540 }
1541 if(ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[priv->audio_id])<0)
1542 return 0;
1543 return 1;
1544 }
1545
1546 // copies a video frame
1547 // for YV12 swaps the 2nd and 3rd plane
1548 static inline void copy_frame(priv_t *priv, unsigned char *dest, unsigned char *source)
1549 {
1550 if(priv->tv_param->automute>0){
1551 if (ioctl(priv->video_fd, VIDIOCGTUNER, &priv->tuner) >= 0) {
1552 if(priv->tv_param->automute<<8>priv->tuner.signal){
1553 fill_blank_frame(dest,priv->bytesperline * priv->height,priv->format);
1554 set_mute(priv,1);
1555 return;
1556 }
1557 }
1558 set_mute(priv,0);
1559 }
1560 // YV12 uses VIDEO_PALETTE_YUV420P, but the planes are swapped
1561 if (priv->format == IMGFMT_YV12) {
1562 fast_memcpy(dest, source, priv->width * priv->height);
1563 fast_memcpy(dest+priv->width * priv->height*5/4, source+priv->width * priv->height, priv->width * priv->height/4);
1564 fast_memcpy(dest+priv->width * priv->height, source+priv->width * priv->height*5/4, priv->width * priv->height/4);
1565 return;
1566 }
1567
1568 fast_memcpy(dest, source, priv->bytesperline * priv->height);
1569 }
1570
1571 // maximum skew change, in frames
1572 #define MAX_SKEW_DELTA 0.6
1573 static void *video_grabber(void *data)
1574 {
1575 #define MAXTOL (priv->nbuf)
1576 priv_t *priv = (priv_t*)data;
1577 struct timeval curtime;
1578 long long skew, prev_skew, xskew, interval, prev_interval;
1579 int frame;
1580 int i;
1581 int framecount;
1582 int tolerance;
1583 unsigned long num;
1584
1585 /* start the capture process */
1586
1587 if ( priv->tv_param->mjpeg )
1588 {
1589 mp_msg(MSGT_TV, MSGL_INFO, " MJP: gonna capture ! \n");
1590 for (i=0; i < priv->nbuf; i++) {
1591 num = i;
1592 if (ioctl(priv->video_fd, MJPIOC_QBUF_CAPT, &num) < 0)
1593 mp_msg(MSGT_TV, MSGL_ERR,
1594 "\n MJP: ioctl MJPIOC_QBUF_CAPT b failed: %s\n", strerror(errno));
1595 }
1596 }
1597 else
1598 {
1599 for (i=0; i < priv->nbuf; i++) {
1600 if (ioctl(priv->video_fd, VIDIOCMCAPTURE, &priv->buf[i]) == -1)
1601 mp_msg(MSGT_TV, MSGL_ERR, "\nioctl mcapture failed: %s\n", strerror(errno));
1602 }
1603 }
1604
1605 gettimeofday(&curtime, NULL);
1606 priv->starttime = (long long)1e6*curtime.tv_sec + curtime.tv_usec;
1607 priv->audio_skew_measure_time = 0;
1608 pthread_mutex_unlock(&priv->audio_starter);
1609 xskew = 0;
1610 skew = 0;
1611 interval = 0;
1612
1613 prev_interval = 0;
1614 prev_skew = 0;
1615
1616 tolerance = MAXTOL;
1617
1618 for (framecount = 0; !priv->shutdown;)
1619 {
1620 for (i = 0; i < priv->nbuf && !priv->shutdown; i++, framecount++) {
1621
1622 if (priv->immediate_mode) {
1623 while (priv->video_cnt == priv->video_buffer_size_max) {
1624 usleep(10000);
1625 if (priv->shutdown) {
1626 return NULL;
1627 }
1628 }
1629 }
1630
1631 frame = i;
1632
1633 if ( priv->tv_param->mjpeg )
1634 {
1635 while (ioctl(priv->video_fd, MJPIOC_SYNC, &priv->buf[frame].frame) < 0 &&
1636 (errno == EAGAIN || errno == EINTR));
1637 }
1638 else
1639 {
1640 while (ioctl(priv->video_fd, VIDIOCSYNC, &priv->buf[frame].frame) < 0 &&
1641 (errno == EAGAIN || errno == EINTR));
1642 }
1643 mp_dbg(MSGT_TV, MSGL_DBG3, "\npicture sync failed\n");
1644
1645 gettimeofday(&curtime, NULL);
1646 if (!priv->immediate_mode) {
1647 interval = (long long)1e6*curtime.tv_sec + curtime.tv_usec - priv->starttime;
1648 } else {
1649 interval = (long long)1e6*framecount/priv->fps;
1650 }
1651
1652 if (!priv->immediate_mode) {
1653 long long period, orig_interval;
1654
1655 if (tolerance == 0) {
1656 if (interval - prev_interval == 0) {
1657 mp_msg(MSGT_TV, MSGL_V, "\nvideo capture thread: frame delta = 0\n");
1658 } else if ((interval - prev_interval < (long long)0.85e6/priv->fps)
1659 || (interval - prev_interval > (long long)1.15e6/priv->fps) ) {
1660 mp_msg(MSGT_TV, MSGL_V, "\nvideo capture thread: frame delta ~ %.1f fps\n",
1661 (double)1e6/(interval - prev_interval));
1662 }
1663 }
1664
1665 // correct the rate fluctuations on a small scale
1666 orig_interval = interval;
1667 period = priv->video_interval_sum/VIDEO_AVG_BUFFER_SIZE;
1668 if (interval - prev_interval > 105*period/100) {
1669 if (tolerance > 0) {
1670 mp_msg(MSGT_TV, MSGL_DBG3, "correcting timestamp\n");
1671 interval = prev_interval + priv->video_interval_sum/VIDEO_AVG_BUFFER_SIZE;
1672 tolerance--;
1673 } else {
1674 mp_msg(MSGT_TV, MSGL_DBG3, "bad - frames were dropped\n");
1675 tolerance = MAXTOL;
1676 }
1677 } else {
1678 if (tolerance < MAXTOL) {
1679 mp_msg(MSGT_TV, MSGL_DBG3, "fluctuation overcome\n");
1680 }
1681 tolerance = MAXTOL;
1682 }
1683
1684 priv->video_interval_sum -= priv->video_avg_buffer[priv->video_avg_ptr];
1685 priv->video_avg_buffer[priv->video_avg_ptr++] = orig_interval-prev_interval;
1686 priv->video_interval_sum += orig_interval-prev_interval;
1687 if (priv->video_avg_ptr >= VIDEO_AVG_BUFFER_SIZE) priv->video_avg_ptr = 0;
1688
1689 // fprintf(stderr, "fps: %lf\n", (double)1e6*VIDEO_AVG_BUFFER_SIZE/priv->video_interval_sum);
1690
1691 // interpolate the skew in time
1692 pthread_mutex_lock(&priv->skew_mutex);
1693 xskew = priv->audio_skew + (interval - priv->audio_skew_measure_time)*priv->audio_skew_factor;
1694 pthread_mutex_unlock(&priv->skew_mutex);
1695 // correct extreme skew changes to avoid (especially) moving backwards in time
1696 if (xskew - prev_skew > (interval - prev_interval)*MAX_SKEW_DELTA) {
1697 skew = prev_skew + (interval - prev_interval)*MAX_SKEW_DELTA;
1698 } else if (xskew - prev_skew < -(interval - prev_interval)*MAX_SKEW_DELTA) {
1699 skew = prev_skew - (interval - prev_interval)*MAX_SKEW_DELTA;
1700 } else {
1701 skew = xskew;
1702 }
1703 }
1704
1705 mp_msg(MSGT_TV, MSGL_DBG3, "\nfps = %f, interval = %f, a_skew = %f, corr_skew = %f\n",
1706 (interval != prev_interval) ? (double)1e6/(interval - prev_interval) : -1,
1707 (double)1e-6*interval, (double)1e-6*xskew, (double)1e-6*skew);
1708 mp_msg(MSGT_TV, MSGL_DBG3, "vcnt = %d, acnt = %d\n", priv->video_cnt, priv->audio_cnt);
1709
1710 prev_skew = skew;
1711 prev_interval = interval;
1712
1713 /* allocate a new buffer, if needed */
1714 pthread_mutex_lock(&priv->video_buffer_mutex);
1715 if (priv->video_buffer_size_current < priv->video_buffer_size_max) {
1716 if (priv->video_cnt == priv->video_buffer_size_current) {
1717 unsigned char *newbuf = calloc(priv->bytesperline, priv->height);
1718 if (newbuf) {
1719 memmove(priv->video_ringbuffer+priv->video_tail+1, priv->video_ringbuffer+priv->video_tail,
1720 (priv->video_buffer_size_current-priv->video_tail)*sizeof(unsigned char *));
1721 memmove(priv->video_timebuffer+priv->video_tail+1, priv->video_timebuffer+priv->video_tail,
1722 (priv->video_buffer_size_current-priv->video_tail)*sizeof(long long));
1723 priv->video_ringbuffer[priv->video_tail] = newbuf;
1724 if ((priv->video_head >= priv->video_tail) && (priv->video_cnt > 0)) priv->video_head++;
1725 priv->video_buffer_size_current++;
1726 }
1727 }
1728 }
1729 pthread_mutex_unlock(&priv->video_buffer_mutex);
1730
1731 if (priv->video_cnt == priv->video_buffer_size_current) {
1732 if (!priv->immediate_mode) {
1733 mp_msg(MSGT_TV, MSGL_ERR, "\nvideo buffer full - dropping frame\n");
1734 }
1735 } else {
1736 if (priv->immediate_mode) {
1737 priv->video_timebuffer[priv->video_tail] = interval;
1738 } else {
1739 // compensate for audio skew
1740 // negative skew => there are more audio samples, increase interval
1741 // positive skew => less samples, shorten the interval
1742 priv->video_timebuffer[priv->video_tail] = interval - skew;
1743 }
1744
1745 if ( priv->tv_param->mjpeg )
1746 copy_frame(priv, priv->video_ringbuffer[priv->video_tail],
1747 priv->mmap+(priv->mjpeg_bufsize)*i);
1748 else
1749 copy_frame(priv, priv->video_ringbuffer[priv->video_tail],
1750 priv->mmap+priv->mbuf.offsets[frame]);
1751 priv->video_tail = (priv->video_tail+1)%priv->video_buffer_size_current;
1752 priv->video_cnt++;
1753 }
1754
1755 if ( priv->tv_param->mjpeg )
1756 {
1757 num = frame;
1758 if (ioctl(priv->video_fd, MJPIOC_QBUF_CAPT, &num) < 0)
1759 {
1760 mp_msg(MSGT_TV, MSGL_ERR, "\n MJP: ioctl MJPIOC_QBUF_CAPT end failed: %s\n",
1761 strerror(errno));
1762 continue;
1763 }
1764 }
1765 else
1766 {
1767 if (ioctl(priv->video_fd, VIDIOCMCAPTURE, &priv->buf[frame]) == -1)
1768 {
1769 mp_msg(MSGT_TV, MSGL_ERR, "\nioctl mcapture failed: %s\n", strerror(errno));
1770 continue;
1771 }
1772 }
1773 }
1774 }
1775 mp_msg(MSGT_TV, MSGL_INFO, " MJP: returning! \n");
1776 return NULL;
1777 }
1778
1779 static double grab_video_frame(priv_t *priv, char *buffer, int len)
1780 {
1781 double interval;
1782
1783 if (priv->first) {
1784 pthread_create(&priv->video_grabber_thread, NULL, video_grabber, priv);
1785 priv->first = 0;
1786 }
1787
1788 while (priv->video_cnt == 0) {
1789 usleep(10000);
1790 }
1791
1792 pthread_mutex_lock(&priv->video_buffer_mutex);
1793 interval = (double)priv->video_timebuffer[priv->video_head]*1e-6;
1794 fast_memcpy(buffer, priv->video_ringbuffer[priv->video_head], len);
1795 priv->video_cnt--;
1796 priv->video_head = (priv->video_head+1)%priv->video_buffer_size_current;
1797 pthread_mutex_unlock(&priv->video_buffer_mutex);
1798
1799 return interval;
1800 }
1801
1802 static int get_video_framesize(priv_t *priv)
1803 {
1804 return priv->bytesperline * priv->height;
1805 }
1806
1807 static void *audio_grabber(void *data)
1808 {
1809 priv_t *priv = (priv_t*)data;
1810 struct timeval tv;
1811 int i, audio_skew_ptr = 0;
1812 long long current_time, prev_skew = 0;
1813
1814 pthread_mutex_lock(&priv->audio_starter);
1815
1816 audio_in_start_capture(&priv->audio_in);
1817 for (i = 0; i < priv->aud_skew_cnt; i++)
1818 priv->audio_skew_buffer[i] = 0;
1819
1820 for (; !priv->shutdown;)
1821 {
1822 if (audio_in_read_chunk(&priv->audio_in, priv->audio_ringbuffer+priv->audio_tail*priv->audio_in.blocksize) < 0)
1823 continue;
1824
1825 gettimeofday(&tv, NULL);
1826
1827 priv->audio_recv_blocks_total++;
1828 current_time = (long long)1e6*tv.tv_sec + tv.tv_usec - priv->starttime;
1829
1830 priv->audio_skew_total -= priv->audio_skew_buffer[audio_skew_ptr];
1831 priv->audio_skew_buffer[audio_skew_ptr] = current_time
1832 - 1e6*priv->audio_secs_per_block*priv->audio_recv_blocks_total;
1833 priv->audio_skew_total += priv->audio_skew_buffer[audio_skew_ptr];
1834 audio_skew_ptr = (audio_skew_ptr+1) % priv->aud_skew_cnt;
1835
1836 pthread_mutex_lock(&priv->skew_mutex);
1837 // linear interpolation - here we interpolate current skew value
1838 // from the moving average, which we expect to be in the middle
1839 // of the interval
1840 if (priv->audio_recv_blocks_total > priv->aud_skew_cnt) {
1841 priv->audio_skew = priv->audio_skew_total/priv->aud_skew_cnt;
1842 priv->audio_skew += (priv->audio_skew*priv->aud_skew_cnt)/(2*priv->audio_recv_blocks_total-priv->aud_skew_cnt);
1843 } else {
1844 // this smoothes the evolution of audio_skew at startup a bit
1845 priv->audio_skew = ((priv->aud_skew_cnt+priv->audio_recv_blocks_total)*priv->audio_skew_total)/(priv->aud_skew_cnt*priv->audio_recv_blocks_total);
1846 }
1847 // current skew factor (assuming linearity)
1848 // used for further interpolation in video_grabber
1849 // probably overkill but seems to be necessary for
1850 // stress testing by dropping half of the audio frames ;)
1851 // especially when using ALSA with large block sizes
1852 // where audio_skew remains a long while behind
1853 if ((priv->audio_skew_measure_time != 0) && (current_time - priv->audio_skew_measure_time != 0)) {
1854 priv->audio_skew_factor = (double)(priv->audio_skew-prev_skew)/(current_time - priv->audio_skew_measure_time);
1855 } else {
1856 priv->audio_skew_factor = 0.0;
1857 }
1858
1859 priv->audio_skew_measure_time = current_time;
1860 prev_skew = priv->audio_skew;
1861 pthread_mutex_unlock(&priv->skew_mutex);
1862
1863 if ((priv->audio_tail+1) % priv->audio_buffer_size == priv->audio_head) {
1864 mp_msg(MSGT_TV, MSGL_ERR, "\ntoo bad - dropping audio frame !\n");
1865 priv->audio_drop++;
1866 } else {
1867 priv->audio_tail = (priv->audio_tail+1) % priv->audio_buffer_size;
1868 priv->audio_cnt++;
1869 }
1870 }
1871 return NULL;
1872 }
1873
1874 static double grab_audio_frame(priv_t *priv, char *buffer, int len)
1875 {
1876 mp_dbg(MSGT_TV, MSGL_DBG2, "grab_audio_frame(priv=%p, buffer=%p, len=%d)\n",
1877 priv, buffer, len);
1878
1879 if (priv->first) {
1880 pthread_create(&priv->video_grabber_thread, NULL, video_grabber, priv);
1881 priv->first = 0;
1882 }
1883
1884 // compensate for dropped audio frames
1885 if (priv->audio_drop && (priv->audio_head == priv->audio_tail)) {
1886 priv->audio_drop--;
1887 priv->audio_sent_blocks_total++;
1888 memset(buffer, 0, len);
1889 return (double)priv->audio_sent_blocks_total*priv->audio_secs_per_block;
1890 }
1891
1892 while (priv->audio_head == priv->audio_tail) {
1893 usleep(10000);
1894 }
1895 fast_memcpy(buffer, priv->audio_ringbuffer+priv->audio_head*priv->audio_in.blocksize, len);
1896 priv->audio_head = (priv->audio_head+1) % priv->audio_buffer_size;
1897 priv->audio_cnt--;
1898 priv->audio_sent_blocks_total++;
1899 return (double)priv->audio_sent_blocks_total*priv->audio_secs_per_block;
1900 }
1901
1902 static int get_audio_framesize(priv_t *priv)
1903 {
1904 return priv->audio_in.blocksize;
1905 }
mplayer with SMedia Glamo drivers