diff options
Diffstat (limited to 'libmpdemux')
| -rw-r--r-- | libmpdemux/Makefile | 2 | ||||
| -rw-r--r-- | libmpdemux/demuxer.c | 25 | ||||
| -rw-r--r-- | libmpdemux/tv.c | 52 | ||||
| -rw-r--r-- | libmpdemux/tv.h | 12 | ||||
| -rw-r--r-- | libmpdemux/tvi_v4l.c | 908 |
5 files changed, 729 insertions, 270 deletions
diff --git a/libmpdemux/Makefile b/libmpdemux/Makefile index 87ba120257..67e1c979f4 100644 --- a/libmpdemux/Makefile +++ b/libmpdemux/Makefile @@ -3,7 +3,7 @@ LIBNAME = libmpdemux.a include ../config.mak -SRCS = mp3_hdr.c video.c mpeg_hdr.c cache2.c asfheader.c aviheader.c aviprint.c aviwrite.c demux_asf.c demux_avi.c demux_mov.c parse_mp4.c demux_mpg.c demux_viv.c demuxer.c dvdauth.c dvdnav_stream.c open.c parse_es.c stream.c tv.c tvi_dummy.c tvi_v4l.c tvi_bsdbt848.c frequencies.c demux_fli.c demux_real.c demux_y4m.c yuv4mpeg.c yuv4mpeg_ratio.c demux_nuv.c demux_film.c demux_roq.c mf.c demux_mf.c demux_audio.c demux_demuxers.c opt-reg.c mpdemux.c demux_ogg.c demux_bmp.c cdda.c demux_rawaudio.c cddb.c demux_rawdv.c +SRCS = mp3_hdr.c video.c mpeg_hdr.c cache2.c asfheader.c aviheader.c aviprint.c aviwrite.c demux_asf.c demux_avi.c demux_mov.c parse_mp4.c demux_mpg.c demux_viv.c demuxer.c dvdauth.c dvdnav_stream.c open.c parse_es.c stream.c tv.c tvi_dummy.c tvi_v4l.c tvi_bsdbt848.c frequencies.c demux_fli.c demux_real.c demux_y4m.c yuv4mpeg.c yuv4mpeg_ratio.c demux_nuv.c demux_film.c demux_roq.c mf.c demux_mf.c demux_audio.c demux_demuxers.c opt-reg.c mpdemux.c demux_ogg.c demux_bmp.c cdda.c demux_rawaudio.c cddb.c demux_rawdv.c ai_alsa.c ai_oss.c audio_in.c ifeq ($(STREAMING),yes) SRCS += asf_streaming.c url.c http.c network.c asf_mmst_streaming.c ifeq ($(STREAMING_LIVE_DOT_COM),yes) diff --git a/libmpdemux/demuxer.c b/libmpdemux/demuxer.c index f8a2e8c1e1..22588cb115 100644 --- a/libmpdemux/demuxer.c +++ b/libmpdemux/demuxer.c @@ -155,6 +155,18 @@ extern void demux_close_demuxers(demuxer_t* demuxer); extern void demux_close_avi(demuxer_t *demuxer); extern void demux_close_rawdv(demuxer_t* demuxer); +#ifdef USE_TV +#include "tv.h" +extern tvi_handle_t *tv_handler; +extern int tv_param_on; + +extern int demux_tv_fill_buffer(demuxer_t *demux, demux_stream_t *ds, tvi_handle_t *tvh); +extern int demux_open_tv(demuxer_t *demuxer, tvi_handle_t *tvh); +#if defined(USE_TV) && defined(HAVE_TV_V4L) +extern void demux_close_tv(demuxer_t *demuxer, tvi_handle_t *tvh); +#endif +#endif + void free_demuxer(demuxer_t *demuxer){ int i; mp_msg(MSGT_DEMUXER,MSGL_V,"DEMUXER: freeing demuxer at %p \n",demuxer); @@ -177,6 +189,10 @@ void free_demuxer(demuxer_t *demuxer){ demux_close_fli(demuxer); break; case DEMUXER_TYPE_NUV: demux_close_nuv(demuxer); break; +#if defined(USE_TV) && defined(HAVE_TV_V4L) + case DEMUXER_TYPE_TV: + demux_close_tv(demuxer, tv_handler); break; +#endif #ifdef HAVE_LIBDV095 case DEMUXER_TYPE_RAWDV: demux_close_rawdv(demuxer); break; @@ -267,15 +283,6 @@ int demux_real_fill_buffer(demuxer_t *demuxer); int demux_nuv_fill_buffer(demuxer_t *demux); int demux_rtp_fill_buffer(demuxer_t *demux, demux_stream_t* ds); int demux_rawdv_fill_buffer(demuxer_t *demuxer); - -#ifdef USE_TV -#include "tv.h" -extern tvi_handle_t *tv_handler; -extern int tv_param_on; - -extern int demux_tv_fill_buffer(demuxer_t *demux, demux_stream_t *ds, tvi_handle_t *tvh); -extern int demux_open_tv(demuxer_t *demuxer, tvi_handle_t *tvh); -#endif int demux_y4m_fill_buffer(demuxer_t *demux); int demux_audio_fill_buffer(demux_stream_t *ds); extern int demux_demuxers_fill_buffer(demuxer_t *demux,demux_stream_t *ds); diff --git a/libmpdemux/tv.c b/libmpdemux/tv.c index 34f7d423fd..88c8fd2ccd 100644 --- a/libmpdemux/tv.c +++ b/libmpdemux/tv.c @@ -39,9 +39,7 @@ int tv_param_on = 0; /* some default values */ int tv_param_audiorate = 44100; int tv_param_noaudio = 0; -#ifdef HAVE_TV_BSDBT848 int tv_param_immediate = 0; -#endif char *tv_param_freq = NULL; char *tv_param_channel = NULL; char *tv_param_norm = "pal"; @@ -53,6 +51,14 @@ int tv_param_height = -1; int tv_param_input = 0; /* used in v4l and bttv */ char *tv_param_outfmt = "yv12"; float tv_param_fps = -1.0; +#ifdef HAVE_TV_V4L +int tv_param_mono = 0; +int tv_param_audio_id = 0; +#ifdef HAVE_ALSA9 +int tv_param_alsa = 0; +#endif +char* tv_param_adevice = NULL; +#endif /* ================== DEMUX_TV ===================== */ /* @@ -135,6 +141,21 @@ int stream_open_tv(stream_t *stream, tvi_handle_t *tvh) } funcs->control(tvh->priv, TVI_CONTROL_VID_SET_FORMAT, &picture_format); + /* set some params got from cmdline */ + funcs->control(tvh->priv, TVI_CONTROL_SPC_SET_INPUT, &tv_param_input); + + /* select video norm */ + if (!strcasecmp(tv_param_norm, "pal")) + tvh->norm = TV_NORM_PAL; + else if (!strcasecmp(tv_param_norm, "ntsc")) + tvh->norm = TV_NORM_NTSC; + else if (!strcasecmp(tv_param_norm, "secam")) + tvh->norm = TV_NORM_SECAM; + + mp_msg(MSGT_TV, MSGL_INFO, "Selected norm: %s\n", tv_param_norm); + funcs->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM, &tvh->norm); + + /* limits on w&h are norm-dependent -- JM */ /* set width */ if (tv_param_width != -1) { @@ -159,20 +180,6 @@ int stream_open_tv(stream_t *stream, tvi_handle_t *tvh) } } - /* set some params got from cmdline */ - funcs->control(tvh->priv, TVI_CONTROL_SPC_SET_INPUT, &tv_param_input); - - /* select video norm */ - if (!strcasecmp(tv_param_norm, "pal")) - tvh->norm = TV_NORM_PAL; - else if (!strcasecmp(tv_param_norm, "ntsc")) - tvh->norm = TV_NORM_NTSC; - else if (!strcasecmp(tv_param_norm, "secam")) - tvh->norm = TV_NORM_SECAM; - - mp_msg(MSGT_TV, MSGL_INFO, "Selected norm: %s\n", tv_param_norm); - funcs->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM, &tvh->norm); - if (funcs->control(tvh->priv, TVI_CONTROL_IS_TUNER, 0) != TVI_CONTROL_TRUE) { mp_msg(MSGT_TV, MSGL_WARN, "Selected input hasn't got a tuner!\n"); @@ -272,14 +279,12 @@ int demux_open_tv(demuxer_t *demuxer, tvi_handle_t *tvh) printf("fps: %f, frametime: %f\n", sh_video->fps, sh_video->frametime); -#ifdef HAVE_TV_BSDBT848 /* If playback only mode, go to immediate mode, fail silently */ if(tv_param_immediate == 1) { funcs->control(tvh->priv, TVI_CONTROL_IMMEDIATE, 0); tv_param_noaudio = 1; } -#endif /* set width */ funcs->control(tvh->priv, TVI_CONTROL_VID_GET_WIDTH, &sh_video->disp_w); @@ -371,9 +376,16 @@ no_audio: return(funcs->start(tvh->priv)); } +#if defined(USE_TV) && defined(HAVE_TV_V4L) +int demux_close_tv(demuxer_t *demuxer, tvi_handle_t *tvh) +{ + return(tvh->functions->uninit(tvh->priv)); +} +#endif + /* ================== STREAM_TV ===================== */ tvi_handle_t *tvi_init_dummy(char *device); -tvi_handle_t *tvi_init_v4l(char *device); +tvi_handle_t *tvi_init_v4l(char *device, char *adevice); tvi_handle_t *tvi_init_bsdbt848(char *device); tvi_handle_t *tv_begin(void) @@ -382,7 +394,7 @@ tvi_handle_t *tv_begin(void) return tvi_init_dummy(tv_param_device); #ifdef HAVE_TV_V4L if (!strcmp(tv_param_driver, "v4l")) - return tvi_init_v4l(tv_param_device); + return tvi_init_v4l(tv_param_device, tv_param_adevice); #endif #ifdef HAVE_TV_BSDBT848 if (!strcmp(tv_param_driver, "bsdbt848")) diff --git a/libmpdemux/tv.h b/libmpdemux/tv.h index 5893c8a46d..255ab4c064 100644 --- a/libmpdemux/tv.h +++ b/libmpdemux/tv.h @@ -23,6 +23,14 @@ extern float tv_param_fps; extern int tv_param_noaudio; extern int tv_param_immediate; extern int tv_param_audiorate; +#ifdef HAVE_TV_V4L +extern int tv_param_mono; +extern int tv_param_audio_id; +#ifdef HAVE_ALSA9 +extern int tv_param_alsa; +#endif +extern char* tv_param_adevice; +#endif typedef struct tvi_info_s { @@ -72,9 +80,7 @@ typedef struct tvi_handle_s { #define TVI_CONTROL_IS_AUDIO 0x1 #define TVI_CONTROL_IS_VIDEO 0x2 #define TVI_CONTROL_IS_TUNER 0x3 -#ifdef HAVE_TV_BSDBT848 -#define TVI_CONTROL_IMMEDIATE 0x4 -#endif +#define TVI_CONTROL_IMMEDIATE 0x4 /* VIDEO controls */ #define TVI_CONTROL_VID_GET_FPS 0x101 diff --git a/libmpdemux/tvi_v4l.c b/libmpdemux/tvi_v4l.c index 67a1f70346..7bbf7409dc 100644 --- a/libmpdemux/tvi_v4l.c +++ b/libmpdemux/tvi_v4l.c @@ -6,6 +6,9 @@ Some ideas are based on xawtv/libng's grab-v4l.c written by Gerd Knorr <kraxel@bytesex.org> + Multithreading, a/v sync and native ALSA support by + Jindrich Makovicka <makovick@kmlinux.fjfi.cvut.cz> + CODE IS UNDER DEVELOPMENT, NO FEATURE REQUESTS PLEASE! */ @@ -21,11 +24,14 @@ #include <sys/types.h> #include <sys/time.h> #include <linux/videodev.h> -#include <linux/soundcard.h> #include <unistd.h> #include <sys/mman.h> #include <stdlib.h> #include <string.h> +#include <pthread.h> +#ifdef HAVE_SYS_SYSINFO_H +#include <sys/sysinfo.h> +#endif #include "mp_msg.h" #include "../libao2/afmt.h" @@ -34,6 +40,8 @@ #include "tv.h" +#include "audio_in.h" + static tvi_info_t info = { "Video 4 Linux input", "v4l", @@ -41,12 +49,22 @@ static tvi_info_t info = { "under development" }; +#define PAL_WIDTH 768 +#define PAL_HEIGHT 576 +#define PAL_FPS 25 + +#define NTSC_WIDTH 640 +#define NTSC_HEIGHT 480 +#define NTSC_FPS 30 + #define MAX_AUDIO_CHANNELS 10 +#define VID_BUF_SIZE_IMMEDIATE 2 + typedef struct { /* general */ char *video_device; - int video_fd; + int video_fd; struct video_capability capability; struct video_channel *channels; int act_channel; @@ -61,24 +79,54 @@ typedef struct { int fps; struct video_mbuf mbuf; - unsigned char *mmap; + unsigned char *mmap; struct video_mmap *buf; int nbuf; - int queue; /* audio */ - int audio_id; char *audio_device; + audio_in_t audio_in; + + int audio_id; struct video_audio audio[MAX_AUDIO_CHANNELS]; - int audio_fd; int audio_channels[MAX_AUDIO_CHANNELS]; - int audio_format[MAX_AUDIO_CHANNELS]; - int audio_samplesize[MAX_AUDIO_CHANNELS]; - int audio_samplerate[MAX_AUDIO_CHANNELS]; - int audio_blocksize; - /* other */ - double starttime; + /* buffering stuff */ + int immediate_mode; + + int audio_buffer_size; + int aud_skew_cnt; + unsigned char *audio_ringbuffer; + double *audio_skew_buffer; + volatile int audio_head; + volatile int audio_tail; + volatile int audio_cnt; + volatile double audio_skew; + volatile double audio_skew_factor; + volatile double audio_skew_measure_time; + volatile int audio_drop; + + int first; + int video_buffer_size; + unsigned char *video_ringbuffer; + double *video_timebuffer; + volatile int video_head; + volatile int video_tail; + volatile int video_cnt; + + volatile int shutdown; + + pthread_t audio_grabber_thread; + pthread_t video_grabber_thread; + pthread_mutex_t audio_starter; + pthread_mutex_t skew_mutex; + + double starttime; + double audio_secs_per_block; + double audio_skew_total; + long audio_recv_blocks_total; + long audio_sent_blocks_total; + } priv_t; #include "tvi_def.h" @@ -100,6 +148,9 @@ static const char *audio_mode2name[] = { "unknown", "mono", "stereo", "language1", "language2", NULL }; +static void *audio_grabber(void *data); +static void *video_grabber(void *data); + static int palette2depth(int palette) { switch(palette) @@ -134,28 +185,47 @@ static int format2palette(int format) { switch(format) { - case IMGFMT_RGB15: + case IMGFMT_BGR15: return(VIDEO_PALETTE_RGB555); - case IMGFMT_RGB16: + case IMGFMT_BGR16: return(VIDEO_PALETTE_RGB565); - case IMGFMT_RGB24: + case IMGFMT_BGR24: return(VIDEO_PALETTE_RGB24); - case IMGFMT_RGB32: + case IMGFMT_BGR32: return(VIDEO_PALETTE_RGB32); case IMGFMT_YV12: case IMGFMT_I420: return(VIDEO_PALETTE_YUV420P); - case IMGFMT_UYVY: - return(VIDEO_PALETTE_YUV422); case IMGFMT_YUY2: - return(VIDEO_PALETTE_YUYV); + return(VIDEO_PALETTE_YUV422); } return(-1); } +// sets and sanitizes audio buffer/block sizes +static void setup_audio_buffer_sizes(priv_t *priv) +{ + int bytes_per_sample = priv->audio_in.bytes_per_sample; + + // make the audio buffer at least 5 seconds long + priv->audio_buffer_size = 1 + 5*priv->audio_in.samplerate + *priv->audio_in.channels + *bytes_per_sample/priv->audio_in.blocksize; + if (priv->audio_buffer_size < 256) priv->audio_buffer_size = 256; + + // make the skew buffer at least 1 second long + priv->aud_skew_cnt = 1 + 1*priv->audio_in.samplerate + *priv->audio_in.channels + *bytes_per_sample/priv->audio_in.blocksize; + if (priv->aud_skew_cnt < 16) priv->aud_skew_cnt = 16; + + mp_msg(MSGT_TV, MSGL_V, "Audio capture - buffer %d blocks of %d bytes, skew average from %d meas.\n", + priv->audio_buffer_size, priv->audio_in.blocksize, priv->aud_skew_cnt); +} + static int one = 1, zero = 0; -tvi_handle_t *tvi_init_v4l(char *device) +tvi_handle_t *tvi_init_v4l(char *device, char *adevice) { tvi_handle_t *h; priv_t *priv; @@ -172,22 +242,114 @@ tvi_handle_t *tvi_init_v4l(char *device) else priv->video_device = strdup(device); + /* set video device name */ + if (!adevice) + priv->audio_device = NULL; + else { + priv->audio_device = strdup(adevice); + } + /* allocation failed */ if (!priv->video_device) { free_handle(h); return(NULL); } - /* set audio device name */ - priv->audio_device = strdup("/dev/dsp"); - return(h); } +/* retrieves info about audio channels from the BTTV */ +static void init_v4l_audio(priv_t *priv) +{ + int i; + + if (!priv->capability.audios) return; + + /* audio chanlist */ + + mp_msg(MSGT_TV, MSGL_INFO, " Audio devices: %d\n", priv->capability.audios); + + for (i = 0; i < priv->capability.audios; i++) + { + if (i >= MAX_AUDIO_CHANNELS) + { + mp_msg(MSGT_TV, MSGL_ERR, "no space for more audio channels (increase in source!) (%d > %d)\n", + i, MAX_AUDIO_CHANNELS); + i = priv->capability.audios; + break; + } + + priv->audio[i].audio = i; + if (ioctl(priv->video_fd, VIDIOCGAUDIO, &priv->audio[i]) == -1) + { + mp_msg(MSGT_TV, MSGL_ERR, "ioctl get audio failed: %s\n", strerror(errno)); + break; + } + + /* mute all channels */ + priv->audio[i].volume = 0; + priv->audio[i].flags |= VIDEO_AUDIO_MUTE; + if (tv_param_mono) { + priv->audio[i].mode = VIDEO_SOUND_MONO; + ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[i]); + } else { + /* try to set stereo */ + priv->audio[i].mode = VIDEO_SOUND_STEREO; + ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[i]); + } + + priv->audio[i].audio = i; + if (ioctl(priv->video_fd, VIDIOCGAUDIO, &priv->audio[i]) == -1) + { + mp_msg(MSGT_TV, MSGL_ERR, "ioctl get audio failed: %s\n", strerror(errno)); + break; + } + + switch(priv->audio[i].mode) + { + case VIDEO_SOUND_MONO: + case VIDEO_SOUND_LANG1: + case VIDEO_SOUND_LANG2: + priv->audio_channels[i] = 1; + break; + case VIDEO_SOUND_STEREO: + priv->audio_channels[i] = 2; + break; + } + + /* display stuff */ + mp_msg(MSGT_TV, MSGL_V, " %d: %s: ", priv->audio[i].audio, + priv->audio[i].name); + if (priv->audio[i].flags & VIDEO_AUDIO_MUTABLE) { + mp_msg(MSGT_TV, MSGL_V, "muted=%s ", + (priv->audio[i].flags & VIDEO_AUDIO_MUTE) ? "yes" : "no"); + } + mp_msg(MSGT_TV, MSGL_V, "volume=%d bass=%d treble=%d balance=%d mode=%s\n", + priv->audio[i].volume, priv->audio[i].bass, priv->audio[i].treble, + priv->audio[i].balance, audio_mode2name[priv->audio[i].mode]); + mp_msg(MSGT_TV, MSGL_V, " channels: %d\n", priv->audio_channels[i]); + } +} + static int init(priv_t *priv) { int i; + if (tv_param_immediate == 1) + tv_param_noaudio = 1; + + if (!tv_param_noaudio) { + } + + if (priv->audio_device) { + audio_in_set_device(&priv->audio_in, priv->audio_device); + } + + priv->video_ringbuffer = NULL; + priv->video_timebuffer = NULL; + priv->audio_ringbuffer = NULL; + priv->audio_skew_buffer = NULL; + priv->video_fd = open(priv->video_device, O_RDWR); mp_msg(MSGT_TV, MSGL_DBG2, "Video fd: %d, %x\n", priv->video_fd, priv->video_device); @@ -198,7 +360,7 @@ static int init(priv_t *priv) goto err; } - priv->fps = 25; /* pal */ + priv->fps = PAL_FPS; /* pal */ /* get capabilities (priv->capability is needed!) */ if (ioctl(priv->video_fd, VIDIOCGCAP, &priv->capability) == -1) @@ -207,6 +369,25 @@ static int init(priv_t *priv) goto err; } + if (ioctl(priv->video_fd, VIDIOCGTUNER, &priv->tuner) == -1) + { + mp_msg(MSGT_TV, MSGL_ERR, "ioctl get tuner failed: %s\n", strerror(errno)); + goto err; + } + + switch (priv->tuner.mode) { + case VIDEO_MODE_PAL: + case VIDEO_MODE_SECAM: + priv->fps = PAL_FPS; + break; + case VIDEO_MODE_NTSC: + priv->fps = NTSC_FPS; + break; + default: + mp_msg(MSGT_TV, MSGL_ERR, "get tuner returned an unknown mode: %d\n", priv->tuner.mode); + goto err; + } + fcntl(priv->video_fd, F_SETFD, FD_CLOEXEC); mp_msg(MSGT_TV, MSGL_INFO, "Selected device: %s\n", priv->capability.name); @@ -245,66 +426,6 @@ static int init(priv_t *priv) priv->channels[i].norm); } - /* audio chanlist */ - if (priv->capability.audios) - { - mp_msg(MSGT_TV, MSGL_INFO, " Audio devices: %d\n", priv->capability.audios); - - for (i = 0; i < priv->capability.audios; i++) - { - if (i >= MAX_AUDIO_CHANNELS) - { - mp_msg(MSGT_TV, MSGL_ERR, "no space for more audio channels (incrase in source!) (%d > %d)\n", - i, MAX_AUDIO_CHANNELS); - i = priv->capability.audios; - break; - } - - priv->audio[i].audio = i; - if (ioctl(priv->video_fd, VIDIOCGAUDIO, &priv->audio[i]) == -1) - { - mp_msg(MSGT_TV, MSGL_ERR, "ioctl get audio failed: %s\n", strerror(errno)); - break; - } - - if (priv->audio[i].volume <= 0) - priv->audio[i].volume = 100; - priv->audio[i].flags &= ~VIDEO_AUDIO_MUTE; - ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[i]); - - switch(priv->audio[i].mode) - { - case VIDEO_SOUND_MONO: - case VIDEO_SOUND_LANG1: - case VIDEO_SOUND_LANG2: - priv->audio_channels[i] = 1; - break; - case VIDEO_SOUND_STEREO: - priv->audio_channels[i] = 2; - break; - } - - priv->audio_format[i] = AFMT_S16_LE; - priv->audio_samplerate[i] = 44100; - priv->audio_samplesize[i] = - priv->audio_samplerate[i]/8/priv->fps* - priv->audio_channels[i]; - - /* display stuff */ - mp_msg(MSGT_TV, MSGL_V, " %d: %s: ", priv->audio[i].audio, - priv->audio[i].name); - if (priv->audio[i].flags & VIDEO_AUDIO_MUTABLE) - mp_msg(MSGT_TV, MSGL_V, "muted=%s ", - (priv->audio[i].flags & VIDEO_AUDIO_MUTE) ? "yes" : "no"); - mp_msg(MSGT_TV, MSGL_V, "volume=%d bass=%d treble=%d balance=%d mode=%s\n", - priv->audio[i].volume, priv->audio[i].bass, priv->audio[i].treble, - priv->audio[i].balance, audio_mode2name[priv->audio[i].mode]); - mp_msg(MSGT_TV, MSGL_V, " channels: %d, samplerate: %d, samplesize: %d, format: %s\n", - priv->audio_channels[i], priv->audio_samplerate[i], priv->audio_samplesize[i], - audio_out_format_name(priv->audio_format[i])); - } - } - if (!(priv->capability.type & VID_TYPE_CAPTURE)) { mp_msg(MSGT_TV, MSGL_ERR, "Only grabbing supported (for overlay use another program)\n"); @@ -338,88 +459,35 @@ static int init(priv_t *priv) goto malloc_failed; memset(priv->buf, 0, priv->nbuf * sizeof(struct video_mmap)); - /* audio init */ -#if 1 - priv->audio_fd = open(priv->audio_device, O_RDONLY); - if (priv->audio_fd < 0) - { - mp_msg(MSGT_TV, MSGL_ERR, "unable to open '%s': %s\n", - priv->audio_device, strerror(errno)); - } - else - { - int ioctl_param; - - fcntl(priv->audio_fd, F_SETFL, O_NONBLOCK); + /* init v4l audio even when we don't capture */ + init_v4l_audio(priv); -#if 0 - ioctl_param = 0x7fff000d; /* 8k */ - printf("ioctl dsp setfragment: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_SETFRAGMENT, &ioctl_param)); -#endif + if (!priv->capability.audios) tv_param_noaudio = 1; - ioctl_param = 0 ; - printf("ioctl dsp getfmt: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_GETFMTS, &ioctl_param)); + /* audio init */ + if (!tv_param_noaudio) { + int err; - printf("Supported formats: %x\n", ioctl_param); - if (!(ioctl_param & priv->audio_format[priv->audio_id])) - printf("notsupported format\n"); - - ioctl_param = priv->audio_format[priv->audio_id]; - printf("ioctl dsp setfmt: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_SETFMT, &ioctl_param)); - -// ioctl(priv->audio_fd, SNDCTL_DSP_GETISPACE, &ioctl_param); -// printf("getispace: %d\n", ioctl_param); - - if (priv->audio_channels[priv->audio_id] > 2) - { - ioctl_param = priv->audio_channels[priv->audio_id]; - printf("ioctl dsp channels: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_CHANNELS, &ioctl_param)); - } +#ifdef HAVE_ALSA9 + if (tv_param_alsa) + audio_in_init(&priv->audio_in, AUDIO_IN_ALSA); else - { -// if (priv->audio_channels[priv->audio_id] == 2) -// ioctl_param = 1; -// else -// ioctl_param = 0; - - ioctl_param = (priv->audio_channels[priv->audio_id] == 2); - printf("ioctl dsp stereo: %d (req: %d)\n", - ioctl(priv->audio_fd, SNDCTL_DSP_STEREO, &ioctl_param), - ioctl_param); - } - - ioctl_param = priv->audio_samplerate[priv->audio_id]; - printf("ioctl dsp speed: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_SPEED, &ioctl_param)); - -#if 0 - ioctl_param = 0; - ioctl_param = ~PCM_ENABLE_INPUT; - printf("ioctl dsp trigger: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_SETTRIGGER, &ioctl_param)); - ioctl_param = PCM_ENABLE_INPUT; - printf("ioctl dsp trigger: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_SETTRIGGER, &ioctl_param)); + audio_in_init(&priv->audio_in, AUDIO_IN_OSS); +#else + audio_in_init(&priv->audio_in, AUDIO_IN_OSS); #endif - printf("ioctl dsp trigger: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_GETTRIGGER, &ioctl_param)); - printf("trigger: %x\n", ioctl_param); - ioctl_param = PCM_ENABLE_INPUT; - printf("ioctl dsp trigger: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_SETTRIGGER, &ioctl_param)); - - printf("ioctl dsp getblocksize: %d\n", - ioctl(priv->audio_fd, SNDCTL_DSP_GETBLKSIZE, &priv->audio_blocksize)); - printf("blocksize: %d\n", priv->audio_blocksize); + if (tv_param_audio_id < priv->capability.audios) + priv->audio_id = tv_param_audio_id; + else + priv->audio_id = 0; + audio_in_set_samplerate(&priv->audio_in, 44100); + audio_in_set_channels(&priv->audio_in, priv->audio_channels[priv->audio_id]); + if (audio_in_setup(&priv->audio_in) < 0) return 0; + setup_audio_buffer_sizes(priv); } -#endif - return(1); + return(1); malloc_failed: if (priv->channels) @@ -434,20 +502,68 @@ err: static int uninit(priv_t *priv) { - close(priv->video_fd); + priv->shutdown = 1; + + mp_msg(MSGT_TV, MSGL_INFO, "Waiting for threads to finish... "); + if (!tv_param_noaudio) { + pthread_join(priv->audio_grabber_thread, NULL); + pthread_mutex_destroy(&priv->audio_starter); + pthread_mutex_destroy(&priv->skew_mutex); + } + pthread_join(priv->video_grabber_thread, NULL); + mp_msg(MSGT_TV, MSGL_INFO, "done\n"); priv->audio[priv->audio_id].volume = 0; priv->audio[priv->audio_id].flags |= VIDEO_AUDIO_MUTE; ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[priv->audio_id]); - close(priv->audio_fd); + + close(priv->video_fd); + + audio_in_uninit(&priv->audio_in); + + if (priv->video_ringbuffer) + free(priv->video_ringbuffer); + if (priv->video_timebuffer) + free(priv->video_timebuffer); + if (!tv_param_noaudio) { + if (priv->audio_ringbuffer) + free(priv->audio_ringbuffer); + if (priv->audio_skew_buffer) + free(priv->audio_skew_buffer); + } return(1); } +static int get_capture_buffer_size(priv_t *priv) +{ + int bufsize, cnt; +#ifdef HAVE_SYS_SYSINFO_H + struct sysinfo si; + + sysinfo(&si); + if (si.totalram<2*1024*1024) { + bufsize = 1024*1024; + } else { + bufsize = si.totalram/2; + } +#else + bufsize = 16*1024*1024; +#endif + + cnt = bufsize/(priv->width*priv->bytesperline); + if (cnt < 2) cnt = 2; + + mp_msg(MSGT_TV, MSGL_INFO, "Allocating a ring buffer for %d frames, %d MB total size.\n", + cnt, cnt*priv->width*priv->bytesperline/(1024*1024)); + + return cnt; +} + static int start(priv_t *priv) { int i; - + int bytes_per_sample; if (ioctl(priv->video_fd, VIDIOCGPICT, &priv->picture) == -1) { @@ -457,14 +573,12 @@ static int start(priv_t *priv) priv->picture.palette = format2palette(priv->format); priv->picture.depth = palette2depth(priv->picture.palette); - priv->bytesperline = priv->width * priv->picture.depth / 8; -// if (IMGFMT_IS_BGR(priv->format) || IMGFMT_IS_RGB(priv->format)) -// priv->bytesperline = priv->width * priv->picture.depth / 8; -// if ((priv->format == IMGFMT_YV12) || (priv->format == IMGFMT_I420) || (priv->format == IMGFMT_IYUV)) -// priv->bytesperline = priv->width * 3 / 2; - printf("palette: %d, depth: %d, bytesperline: %d\n", - priv->picture.palette, priv->picture.depth, priv->bytesperline); + if (priv->format != IMGFMT_BGR15) { + priv->bytesperline = priv->width * priv->picture.depth / 8; + } else { + priv->bytesperline = priv->width * 2; + } mp_msg(MSGT_TV, MSGL_INFO, "Picture values:\n"); mp_msg(MSGT_TV, MSGL_INFO, " Depth: %d, Palette: %d (Format: %s)\n", priv->picture.depth, @@ -520,26 +634,94 @@ static int start(priv_t *priv) ioctl(priv->video_fd, VIDIOCSWIN, &win); } - /* start capture */ + // initialize video capture if (ioctl(priv->video_fd, VIDIOCCAPTURE, &one) == -1) { - mp_msg(MSGT_TV, MSGL_ERR, "ioctl capture failed: %s\n", strerror(errno)); + mp_msg(MSGT_TV, MSGL_ERR, "FATAL: ioctl ccapture failed: %s\n", strerror(errno)); return(0); } #endif - { - struct timeval curtime; - gettimeofday(&curtime, NULL); - priv->starttime=curtime.tv_sec + curtime.tv_usec*.000001; + /* setup audio parameters */ + if (!tv_param_noaudio) { + setup_audio_buffer_sizes(priv); + bytes_per_sample = priv->audio_in.bytes_per_sample; + priv->audio_skew_buffer = (double*)malloc(sizeof(double)*priv->aud_skew_cnt); + if (!priv->audio_skew_buffer) { + mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate skew buffer: %s\n", strerror(errno)); + return 0; + } + + priv->audio_ringbuffer = (unsigned char*)malloc(priv->audio_in.blocksize*priv->audio_buffer_size); + if (!priv->audio_ringbuffer) { + mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate audio buffer: %s\n", strerror(errno)); + return 0; + } + + priv->audio_secs_per_block = (double)priv->audio_in.blocksize/(priv->audio_in.samplerate + *priv->audio_in.channels + *bytes_per_sample); + priv->audio_head = 0; + priv->audio_tail = 0; + priv->audio_cnt = 0; + priv->audio_drop = 0; + priv->audio_skew = 0.0; + priv->audio_skew_total = 0.0; + priv->audio_recv_blocks_total = 0; + priv->audio_sent_blocks_total = 0; + } + + /* setup video parameters */ + if (priv->immediate_mode) { + priv->video_buffer_size = VID_BUF_SIZE_IMMEDIATE; + } else { + priv->video_buffer_size = get_capture_buffer_size(priv); + } + + if (!tv_param_noaudio) { + if (priv->video_buffer_size < 3.0*priv->fps*priv->audio_secs_per_block) { + mp_msg(MSGT_TV, MSGL_ERR, "Video buffer shorter than 3 times audio frame duration.\n" + "You will probably experience heavy framedrops.\n"); + } + } + + priv->video_ringbuffer = (unsigned char*)malloc(priv->bytesperline * priv->height * priv->video_buffer_size); + if (!priv->video_ringbuffer) { + mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate video buffer: %s\n", strerror(errno)); + return 0; + } + priv->video_timebuffer = (double*)malloc(sizeof(double) * priv->video_buffer_size); + if (!priv->video_timebuffer) { + mp_msg(MSGT_TV, MSGL_ERR, "cannot allocate time buffer: %s\n", strerror(errno)); + return 0; } + priv->video_head = 0; + priv->video_tail = 0; + priv->video_cnt = 0; + priv->first = 1; + + /* enable audio */ + if (priv->audio[priv->audio_id].volume <= 0) + priv->audio[priv->audio_id].volume = 100; + priv->audio[priv->audio_id].flags &= ~VIDEO_AUDIO_MUTE; + ioctl(priv->video_fd, VIDIOCSAUDIO, &priv->audio[priv->audio_id]); + + /* launch capture threads */ + priv->shutdown = 0; + if (!tv_param_noaudio) { + pthread_mutex_init(&priv->audio_starter, NULL); + pthread_mutex_init(&priv->skew_mutex, NULL); + pthread_mutex_lock(&priv->audio_starter); + pthread_create(&priv->audio_grabber_thread, NULL, audio_grabber, priv); + } + /* we'll launch the video capture later, when a first request for a frame arrives */ return(1); } static int control(priv_t *priv, int cmd, void *arg) { - mp_msg(MSGT_TV, MSGL_DBG2, "debug: control(priv=%p, cmd=%d, arg=%p)\n", + mp_msg(MSGT_TV, MSGL_DBG2, "\ndebug: control(priv=%p, cmd=%d, arg=%p)\n", priv, cmd, arg); switch(cmd) { @@ -576,6 +758,14 @@ static int control(priv_t *priv, int cmd, void *arg) } case TVI_CONTROL_VID_SET_FORMAT: priv->format = (int)*(void **)arg; + // !HACK! v4l uses BGR format instead of RGB + // and we have to correct this. Fortunately, + // tv.c reads later the format back so we + // can persuade it to use what we want. + if (IMGFMT_IS_RGB(priv->format)) { + priv->format &= ~IMGFMT_RGB_MASK; + priv->format |= IMGFMT_BGR; + } return(TVI_CONTROL_TRUE); case TVI_CONTROL_VID_GET_PLANES: (int)*(void **)arg = 1; /* FIXME, also not needed at this time */ @@ -682,6 +872,7 @@ static int control(priv_t *priv, int cmd, void *arg) mp_msg(MSGT_TV, MSGL_ERR, "ioctl set freq failed: %s\n", strerror(errno)); return(TVI_CONTROL_FALSE); } + usleep(100000); // wait to supress noise during switching return(TVI_CONTROL_TRUE); } case TVI_CONTROL_TUN_GET_TUNER: @@ -700,7 +891,7 @@ static int control(priv_t *priv, int cmd, void *arg) { if (ioctl(priv->video_fd, VIDIOCSTUNER, &priv->tuner) == -1) { - mp_msg(MSGT_TV, MSGL_ERR, "ioctl get tuner failed: %s\n", strerror(errno)); + mp_msg(MSGT_TV, MSGL_ERR, "ioctl set tuner failed: %s\n", strerror(errno)); return(TVI_CONTROL_FALSE); } return(TVI_CONTROL_TRUE); @@ -708,20 +899,57 @@ static int control(priv_t *priv, int cmd, void *arg) case TVI_CONTROL_TUN_SET_NORM: { int req_mode = (int)*(void **)arg; - - if ((!(priv->tuner.flags & VIDEO_TUNER_NORM)) || - ((req_mode == VIDEO_MODE_PAL) && !(priv->tuner.flags & VIDEO_TUNER_PAL)) || - ((req_mode == VIDEO_MODE_NTSC) && !(priv->tuner.flags & VIDEO_TUNER_NTSC)) || - ((req_mode == VIDEO_MODE_SECAM) && !(priv->tuner.flags & VIDEO_TUNER_SECAM))) + + if ((req_mode != TV_NORM_PAL) && (req_mode != TV_NORM_NTSC) && (req_mode != TV_NORM_SECAM)) { + mp_msg(MSGT_TV, MSGL_ERR, "Unknown norm!\n"); + return(TVI_CONTROL_FALSE); + } + + if (((req_mode == TV_NORM_PAL) && !(priv->tuner.flags & VIDEO_TUNER_PAL)) || + ((req_mode == TV_NORM_NTSC) && !(priv->tuner.flags & VIDEO_TUNER_NTSC)) || + ((req_mode == TV_NORM_SECAM) && !(priv->tuner.flags & VIDEO_TUNER_SECAM))) { mp_msg(MSGT_TV, MSGL_ERR, "Tuner isn't capable to set norm!\n"); return(TVI_CONTROL_FALSE); } - priv->tuner.mode = req_mode; + switch(req_mode) { + case TV_NORM_PAL: + priv->tuner.mode = VIDEO_MODE_PAL; + break; + case TV_NORM_NTSC: + priv->tuner.mode = VIDEO_MODE_NTSC; + break; + case TV_NORM_SECAM: + priv->tuner.mode = VIDEO_MODE_SECAM; + break; + } - if (control(priv, TVI_CONTROL_TUN_SET_TUNER, &priv->tuner) != TVI_CONTROL_TRUE) + if (control(priv, TVI_CONTROL_TUN_SET_TUNER, &priv->tuner) != TVI_CONTROL_TRUE) { return(TVI_CONTROL_FALSE); + } + + if (ioctl(priv->video_fd, VIDIOCGCAP, &priv->capability) == -1) { + mp_msg(MSGT_TV, MSGL_ERR, "ioctl get capabilites failed: %s\n", strerror(errno)); + return(TVI_CONTROL_FALSE); + } + + if(req_mode == TV_NORM_PAL || req_mode == TV_NORM_SECAM) { + priv->fps = PAL_FPS; + } + + if(req_mode == TV_NORM_NTSC) { + priv->fps = NTSC_FPS; + } + + if(priv->height > priv->capability.maxheight) { + priv->height = priv->capability.maxheight; + } + + if(priv->width > priv->capability.maxwidth) { + priv->width = priv->capability.maxwidth; + } + return(TVI_CONTROL_TRUE); } case TVI_CONTROL_TUN_GET_NORM: @@ -734,33 +962,28 @@ static int control(priv_t *priv, int cmd, void *arg) /* ========== AUDIO controls =========== */ case TVI_CONTROL_AUD_GET_FORMAT: { - (int)*(void **)arg = priv->audio_format[priv->audio_id]; + (int)*(void **)arg = AFMT_S16_LE; return(TVI_CONTROL_TRUE); } case TVI_CONTROL_AUD_GET_CHANNELS: { - (int)*(void **)arg = priv->audio_channels[priv->audio_id]; + (int)*(void **)arg = priv->audio_in.channels; return(TVI_CONTROL_TRUE); } case TVI_CONTROL_AUD_GET_SAMPLERATE: { - (int)*(void **)arg = priv->audio_samplerate[priv->audio_id]; + (int)*(void **)arg = priv->audio_in.samplerate; return(TVI_CONTROL_TRUE); } case TVI_CONTROL_AUD_GET_SAMPLESIZE: { - (int)*(void **)arg = priv->audio_samplesize[priv->audio_id]/8; + (int)*(void **)arg = priv->audio_in.bytes_per_sample; return(TVI_CONTROL_TRUE); } case TVI_CONTROL_AUD_SET_SAMPLERATE: { - int tmp = priv->audio_samplerate[priv->audio_id] = (int)*(void **)arg; - - if (ioctl(priv->audio_fd, SNDCTL_DSP_SPEED, &tmp) == -1) - return(TVI_CONTROL_FALSE); - priv->audio_samplesize[priv->audio_id] = - priv->audio_samplerate[priv->audio_id]/8/priv->fps* - priv->audio_channels[priv->audio_id]; + if (audio_in_set_samplerate(&priv->audio_in, (int)*(void **)arg) < 0) return TVI_CONTROL_FALSE; + setup_audio_buffer_sizes(priv); return(TVI_CONTROL_TRUE); } /* ========== SPECIFIC controls =========== */ @@ -821,50 +1044,189 @@ static int control(priv_t *priv, int cmd, void *arg) /* update local channel list */ control(priv, TVI_CONTROL_SPC_GET_INPUT, &req_chan); return(TVI_CONTROL_TRUE); + case TVI_CONTROL_IMMEDIATE: + priv->immediate_mode = 1; + return(TVI_CONTROL_TRUE); } } return(TVI_CONTROL_UNKNOWN); } -static double grab_video_frame(priv_t *priv, char *buffer, int len) +// copies a video frame +// for RGB (i.e. BGR in mplayer) flips the image upside down +// for YV12 swaps the 2nd and 3rd plane +static inline void copy_frame(priv_t *priv, unsigned char *dest, unsigned char *source) { + int i; + unsigned char *sptr; + + // YV12 uses VIDEO_PALETTE_YUV420P, but the planes are swapped + if (priv->format == IMGFMT_YV12) { + memcpy(dest, source, priv->width * priv->height); + memcpy(dest+priv->width * priv->height*5/4, source+priv->width * priv->height, priv->width * priv->height/4); + memcpy(dest+priv->width * priv->height, source+priv->width * priv->height*5/4, priv->width * priv->height/4); + return; + } + + switch (priv->picture.palette) { + case VIDEO_PALETTE_RGB24: + case VIDEO_PALETTE_RGB32: + case VIDEO_PALETTE_RGB555: + case VIDEO_PALETTE_RGB565: + sptr = source + (priv->height-1)*priv->bytesperline; + for (i = 0; i < priv->height; i++) { + memcpy(dest, sptr, priv->bytesperline); + dest += priv->bytesperline; + sptr -= priv->bytesperline; + } + break; + case VIDEO_PALETTE_UYVY: + case VIDEO_PALETTE_YUV420P: + default: + memcpy(dest, source, priv->bytesperline * priv->height); + } + +} + +// maximum skew change, in frames +#define MAX_SKEW_DELTA 0.6 +static void *video_grabber(void *data) +{ + priv_t *priv = (priv_t*)data; struct timeval curtime; - double timestamp; - int frame = priv->queue % priv->nbuf; - int nextframe = (priv->queue+1) % priv->nbuf; + double timestamp, skew, prev_skew, xskew, interval, prev_interval; + int frame, nextframe; + int fsize = priv->bytesperline * priv->height; + int i; + int first = 1; - mp_dbg(MSGT_TV, MSGL_DBG2, "grab_video_frame(priv=%p, buffer=%p, len=%d)\n", - priv, buffer, len); + int dropped = 0; + double dropped_time; + double drop_delta = 0.0; - mp_dbg(MSGT_TV, MSGL_DBG3, "buf: %p + frame: %d => %p\n", - priv->buf, nextframe, &priv->buf[nextframe]); - if (ioctl(priv->video_fd, VIDIOCMCAPTURE, &priv->buf[nextframe]) == -1) + /* start the capture process */ + if (ioctl(priv->video_fd, VIDIOCMCAPTURE, &priv->buf[0]) == -1) { - mp_msg(MSGT_TV, MSGL_ERR, "ioctl mcapture failed: %s\n", strerror(errno)); - return(0); + mp_msg(MSGT_TV, MSGL_ERR, "\nioctl mcapture failed: %s\n", strerror(errno)); } + while (ioctl(priv->video_fd, VIDIOCSYNC, &priv->buf[1].frame) < 0 && + (errno == EAGAIN || errno == EINTR)); + mp_dbg(MSGT_TV, MSGL_DBG3, "\npicture sync failed\n"); - while (ioctl(priv->video_fd, VIDIOCSYNC, &priv->buf[frame].frame) < 0 && - (errno == EAGAIN || errno == EINTR)); - mp_dbg(MSGT_TV, MSGL_DBG3, "picture sync failed\n"); + prev_interval = 0.0; + prev_skew = priv->audio_skew; - priv->queue++; - - gettimeofday(&curtime, NULL); - timestamp=curtime.tv_sec + curtime.tv_usec*.000001; + for (;!priv->shutdown;) + { + for (i = 0; i < priv->nbuf && !priv->shutdown; i++) { + frame = i; + nextframe = (i+1)%priv->nbuf; + + if (ioctl(priv->video_fd, VIDIOCMCAPTURE, &priv->buf[nextframe]) == -1) + { + mp_msg(MSGT_TV, MSGL_ERR, "\nioctl mcapture failed: %s\n", strerror(errno)); + continue; + } + + while (ioctl(priv->video_fd, VIDIOCSYNC, &priv->buf[frame].frame) < 0 && + (errno == EAGAIN || errno == EINTR)); + mp_dbg(MSGT_TV, MSGL_DBG3, "\npicture sync failed\n"); + + gettimeofday(&curtime, NULL); + if (first) { + // this was a first frame - let's launch the audio capture thread immediately + // before that, just initialize some variables + priv->starttime = curtime.tv_sec + curtime.tv_usec*.000001; + priv->audio_skew_measure_time = 0; + pthread_mutex_unlock(&priv->audio_starter); + first = 0; + } + + interval = curtime.tv_sec + curtime.tv_usec*.000001 - priv->starttime; + + if (!priv->immediate_mode && ( + ((interval - prev_interval < 1.0/priv->fps*0.85) && interval > 0.0001) + || (interval - prev_interval > 1.0/priv->fps*1.15) ) ) { + mp_msg(MSGT_TV, MSGL_V, "\nvideo capture thread: frame delta ~ %.1lf fps\n", + 1.0/(interval - prev_interval)); + } - mp_dbg(MSGT_TV, MSGL_DBG3, "mmap: %p + offset: %d => %p\n", - priv->mmap, priv->mbuf.offsets[frame], - priv->mmap+priv->mbuf.offsets[frame]); + // interpolate the skew in time + pthread_mutex_lock(&priv->skew_mutex); + xskew = priv->audio_skew + (interval - priv->audio_skew_measure_time)*priv->audio_skew_factor; + pthread_mutex_unlock(&priv->skew_mutex); + // correct extreme skew changes to avoid (especially) moving backwards in time + if (xskew - prev_skew > (interval - prev_interval)*MAX_SKEW_DELTA) { + skew = prev_skew + (interval - prev_interval)*MAX_SKEW_DELTA; + } else if (xskew - prev_skew < -(interval - prev_interval)*MAX_SKEW_DELTA) { + skew = prev_skew - (interval - prev_interval)*MAX_SKEW_DELTA; + } else { + skew = xskew; + } - /* XXX also directrendering would be nicer! */ - /* 3 times copying the same picture to other buffer :( */ + mp_msg(MSGT_TV, MSGL_DBG3, "\nfps = %lf, v_interval = %lf, a_skew = %f, corr_skew = %f\n", + 1.0/(interval - prev_interval), interval/2, xskew, skew); + mp_msg(MSGT_TV, MSGL_DBG3, "vcnt = %d, acnt = %d\n", priv->video_cnt, priv->audio_cnt); - /* copy the actual frame */ - memcpy(buffer, priv->mmap+priv->mbuf.offsets[frame], len); + prev_skew = skew; + prev_interval = interval; + + if ((priv->video_tail+1) % priv->video_buffer_size == priv->video_head) { + + if (!priv->immediate_mode) { + mp_msg(MSGT_TV, MSGL_ERR, "\nvideo buffer full - dropping frame\n"); + } else { + if (!dropped) { + dropped = 1; + dropped_time = interval - skew; + } + } + } else { + if (priv->immediate_mode) { + if (dropped) { + drop_delta += interval - skew - dropped_time; + dropped = 0; + } + // compensate for audio skew + // negative skew => there are more audio samples, increase interval + // positive skew => less samples, shorten the interval + + // for TV, we pretend that dropped frames never existed + // without this, mplayer gets confused after pressing pause + priv->video_timebuffer[priv->video_tail] = interval - skew - drop_delta; + } else { + priv->video_timebuffer[priv->video_tail] = interval - skew; + } + + copy_frame(priv, priv->video_ringbuffer+(priv->video_tail)*fsize, priv->mmap+priv->mbuf.offsets[frame]); + priv->video_tail = (priv->video_tail+1)%priv->video_buffer_size; + priv->video_cnt++; + } - return(timestamp-priv->starttime); + } + + } +} + +static double grab_video_frame(priv_t *priv, char *buffer, int len) +{ + double interval; + + if (priv->first) { + pthread_create(&priv->video_grabber_thread, NULL, video_grabber, priv); + priv->first = 0; + } + + while (priv->video_head == priv->video_tail) { + usleep(10000); + } + + interval = priv->video_timebuffer[priv->video_head]; + memcpy(buffer, priv->video_ringbuffer+priv->video_head*priv->bytesperline * priv->height, len); + priv->video_cnt--; + priv->video_head = (++priv->video_head)%priv->video_buffer_size; + return interval; } static int get_video_framesize(priv_t *priv) @@ -872,6 +1234,80 @@ static int get_video_framesize(priv_t *priv) return(priv->bytesperline * priv->height); } +static void *audio_grabber(void *data) +{ + priv_t *priv = (priv_t*)data; + struct timeval tv; + int ret; + int i, audio_skew_ptr = 0; + double tmp, current_time, current_skew, prev_skew = 0.0; + + pthread_mutex_lock(&priv->audio_starter); + + audio_in_start_capture(&priv->audio_in); + for (i = 0; i < priv->aud_skew_cnt; i++) + priv->audio_skew_buffer[i] = 0.0; + + for (; !priv->shutdown;) + { + if (audio_in_read_chunk(&priv->audio_in, priv->audio_ringbuffer+priv->audio_tail*priv->audio_in.blocksize) < 0) + continue; + + gettimeofday(&tv, NULL); + + priv->audio_recv_blocks_total++; + current_time = tv.tv_sec + tv.tv_usec*.000001 - priv->starttime; + + // compute the moving sum of the skews + if (priv->audio_recv_blocks_total % 1024 == 0) { + // recompute the moving sum to avoid truncation errors + priv->audio_skew_buffer[audio_skew_ptr] = current_time + - priv->audio_secs_per_block*priv->audio_recv_blocks_total; + audio_skew_ptr = (audio_skew_ptr+1) % priv->aud_skew_cnt; + for (i = 0, tmp = 0.0; i < priv->aud_skew_cnt; i++) + tmp += priv->audio_skew_buffer[i]; + priv->audio_skew_total = tmp; + } else { + priv->audio_skew_total -= priv->audio_skew_buffer[audio_skew_ptr]; + priv->audio_skew_buffer[audio_skew_ptr] = current_time + - priv->audio_secs_per_block*priv->audio_recv_blocks_total; + priv->audio_skew_total += priv->audio_skew_buffer[audio_skew_ptr]; + audio_skew_ptr = (audio_skew_ptr+1) % priv->aud_skew_cnt; + } + + pthread_mutex_lock(&priv->skew_mutex); + // linear interpolation - here we interpolate current skew value + // from the moving average, which we expect to be in the middle + // of the interval + if (priv->audio_recv_blocks_total > priv->aud_skew_cnt) { + priv->audio_skew = priv->audio_skew_total/priv->aud_skew_cnt; + priv->audio_skew += (priv->audio_skew*priv->aud_skew_cnt)/(2*priv->audio_recv_blocks_total-priv->aud_skew_cnt); + } else { +// priv->audio_skew = 2*priv->audio_skew_total/priv->aud_skew_cnt; + priv->audio_skew = (priv->aud_skew_cnt+priv->audio_recv_blocks_total)/priv->aud_skew_cnt*priv->audio_skew_total/priv->audio_recv_blocks_total; +// priv->audio_skew = current_time - priv->audio_secs_per_block*priv->audio_recv_blocks_total; + } + // current skew factor (assuming linearity) + // used for further interpolation in video_grabber + // probably overkill but seems to be necessary for + // stress testing by dropping half of the audio frames ;) + // especially when using ALSA with large block sizes + // where audio_skew remains a long while behind + priv->audio_skew_factor = (priv->audio_skew-prev_skew)/(current_time - priv->audio_skew_measure_time); + priv->audio_skew_measure_time = current_time; + prev_skew = priv->audio_skew; + pthread_mutex_unlock(&priv->skew_mutex); + + if ((priv->audio_tail+1) % priv->audio_buffer_size == priv->audio_head) { + mp_msg(MSGT_TV, MSGL_ERR, "\ntoo bad - dropping audio frame !\n"); + priv->audio_drop++; + } else { + priv->audio_tail = (++priv->audio_tail) % priv->audio_buffer_size; + priv->audio_cnt++; + } + } +} + static double grab_audio_frame(priv_t *priv, char *buffer, int len) { int in_len = 0; @@ -879,30 +1315,28 @@ static double grab_audio_frame(priv_t *priv, char *buffer, int len) mp_dbg(MSGT_TV, MSGL_DBG2, "grab_audio_frame(priv=%p, buffer=%p, len=%d)\n", priv, buffer, len); - - while (--max_tries > 0) -// for (;;) - { - in_len = read(priv->audio_fd, buffer, len); -// printf("in_len: %d\n", in_len); -// fflush(NULL); - if (in_len > 0) - break; - if (!((in_len == 0) || (in_len == -1 && (errno == EAGAIN || errno == EINTR)))) - { - in_len = 0; /* -EIO */ - break; - } + // compensate for dropped audio frames + if (priv->audio_drop && (priv->audio_head == priv->audio_tail)) { + priv->audio_drop--; + priv->audio_sent_blocks_total++; + memset(buffer, 0, len); + return (double)priv->audio_sent_blocks_total*priv->audio_secs_per_block; } - return 0; //(in_len); // FIXME! + while (priv->audio_head == priv->audio_tail) { + usleep(10000); + } + memcpy(buffer, priv->audio_ringbuffer+priv->audio_head*priv->audio_in.blocksize, len); + priv->audio_head = (++priv->audio_head) % priv->audio_buffer_size; + priv->audio_cnt--; + priv->audio_sent_blocks_total++; + return (double)priv->audio_sent_blocks_total*priv->audio_secs_per_block; } static int get_audio_framesize(priv_t *priv) { - return(priv->audio_blocksize); -// return(priv->audio_samplesize[priv->audio_id]); + return(priv->audio_in.blocksize); } #endif /* USE_TV */ |