← Back to branch summary

~ubuntu-dev/mplayer/ubuntu-feisty

« back to all changes in this revision

Viewing changes to libmpdemux/tvi_v4l.c

  • Committer: Reinhard Tartler
  • Date: 2006-07-08 08:45:33 UTC
  • Revision ID: siretart@tauware.de-20060708084533-dbc155bde7122e78
imported mplayer_0.99+1.0pre7try2+cvs20060117

Show diffs side-by-side

added added

removed removed

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