new v4l capture patch by Jindrich Makovicka <makovick@kmlinux.fjfi.cvut.cz>:

- multithreaded audio/video buffering (I know mplayer crew hates threads
  but it seems to me as the only way of doing reliable a/v capture)
- a/v timebase synchronization (sample count vs. gettimeofday)
- "immediate" mode support for mplayer
- fixed colorspace stuff - RGB?? and YUY2 modes now work as expected
- native ALSA audio capture
- separated audio input layer


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@7061 b3059339-0415-0410-9bf9-f77b7e298cf2

5 files changed, 629 insertions, 0 deletions

diff --git a/libmpdemux/ai_alsa.c b/libmpdemux/ai_alsa.c
new file mode 100644
index 0000000000..52253b8da7
--- /dev/null
+++ b/libmpdemux/ai_alsa.c
@@ -0,0 +1,123 @@
+#include "config.h"
+
+#ifdef HAVE_ALSA9
+#include <alsa/asoundlib.h>
+#include "audio_in.h"
+#include "mp_msg.h"
+
+int ai_alsa_setup(audio_in_t *ai)
+{
+    snd_pcm_hw_params_t *params;
+    snd_pcm_sw_params_t *swparams;
+    size_t buffer_size;
+    int err;
+    size_t n;
+    unsigned int rate;
+    snd_pcm_uframes_t start_threshold, stop_threshold;
+
+    snd_pcm_hw_params_alloca(&params);
+    snd_pcm_sw_params_alloca(&swparams);
+
+    err = snd_pcm_hw_params_any(ai->alsa.handle, params);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Broken configuration for this PCM: no configurations available\n");
+	return -1;
+    }
+    err = snd_pcm_hw_params_set_access(ai->alsa.handle, params,
+				       SND_PCM_ACCESS_RW_INTERLEAVED);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Access type not available\n");
+	return -1;
+    }
+    err = snd_pcm_hw_params_set_format(ai->alsa.handle, params, SND_PCM_FORMAT_S16_LE);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Sample format not available\n");
+	return -1;
+    }
+    err = snd_pcm_hw_params_set_channels(ai->alsa.handle, params, ai->req_channels);
+    if (err < 0) {
+	ai->channels = snd_pcm_hw_params_get_channels(params);
+	mp_msg(MSGT_TV, MSGL_ERR, "Channel count not available - reverting to default: %d\n",
+	       ai->channels);
+    } else {
+	ai->channels = ai->req_channels;
+    }
+
+    err = snd_pcm_hw_params_set_rate_near(ai->alsa.handle, params, ai->req_samplerate, 0);
+    assert(err >= 0);
+    rate = err;
+    ai->samplerate = rate;
+
+    ai->alsa.buffer_time = 1000000;
+    ai->alsa.buffer_time = snd_pcm_hw_params_set_buffer_time_near(ai->alsa.handle, params,
+							       ai->alsa.buffer_time, 0);
+    assert(ai->alsa.buffer_time >= 0);
+    ai->alsa.period_time = ai->alsa.buffer_time / 4;
+    ai->alsa.period_time = snd_pcm_hw_params_set_period_time_near(ai->alsa.handle, params,
+							       ai->alsa.period_time, 0);
+    assert(ai->alsa.period_time >= 0);
+    err = snd_pcm_hw_params(ai->alsa.handle, params);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Unable to install hw params:");
+	snd_pcm_hw_params_dump(params, ai->alsa.log);
+	return -1;
+    }
+    ai->alsa.chunk_size = snd_pcm_hw_params_get_period_size(params, 0);
+    buffer_size = snd_pcm_hw_params_get_buffer_size(params);
+    if (ai->alsa.chunk_size == buffer_size) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Can't use period equal to buffer size (%u == %lu)\n", ai->alsa.chunk_size, (long)buffer_size);
+	return -1;
+    }
+    snd_pcm_sw_params_current(ai->alsa.handle, swparams);
+    err = snd_pcm_sw_params_set_sleep_min(ai->alsa.handle, swparams,0);
+    assert(err >= 0);
+    err = snd_pcm_sw_params_set_avail_min(ai->alsa.handle, swparams, ai->alsa.chunk_size);
+    assert(err >= 0);
+
+    err = snd_pcm_sw_params_set_start_threshold(ai->alsa.handle, swparams, 0);
+    assert(err >= 0);
+    err = snd_pcm_sw_params_set_stop_threshold(ai->alsa.handle, swparams, buffer_size);
+    assert(err >= 0);
+
+    assert(err >= 0);
+    if (snd_pcm_sw_params(ai->alsa.handle, swparams) < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "unable to install sw params:\n");
+	snd_pcm_sw_params_dump(swparams, ai->alsa.log);
+	return -1;
+    }
+
+    if (mp_msg_test(MSGT_TV, MSGL_V)) {
+	snd_pcm_dump(ai->alsa.handle, ai->alsa.log);
+    }
+
+    ai->alsa.bits_per_sample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);
+    ai->alsa.bits_per_frame = ai->alsa.bits_per_sample * ai->channels;
+    ai->blocksize = ai->alsa.chunk_size * ai->alsa.bits_per_frame / 8;
+    ai->samplesize = ai->alsa.bits_per_sample;
+    ai->bytes_per_sample = ai->alsa.bits_per_sample/8;
+
+    return 0;
+}
+
+int ai_alsa_init(audio_in_t *ai)
+{
+    int err;
+    
+    err = snd_pcm_open(&ai->alsa.handle, ai->alsa.device, SND_PCM_STREAM_CAPTURE, 0);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Error opening audio");
+	return -1;
+    }
+    
+    err = snd_output_stdio_attach(&ai->alsa.log, stderr, 0);
+    
+    if (err < 0) {
+	return -1;
+    }
+    
+    err = ai_alsa_setup(ai);
+
+    return err;
+}
+
+#endif /* HAVE_ALSA9 */
diff --git a/libmpdemux/ai_alsa1x.c b/libmpdemux/ai_alsa1x.c
new file mode 100644
index 0000000000..52253b8da7
--- /dev/null
+++ b/libmpdemux/ai_alsa1x.c
@@ -0,0 +1,123 @@
+#include "config.h"
+
+#ifdef HAVE_ALSA9
+#include <alsa/asoundlib.h>
+#include "audio_in.h"
+#include "mp_msg.h"
+
+int ai_alsa_setup(audio_in_t *ai)
+{
+    snd_pcm_hw_params_t *params;
+    snd_pcm_sw_params_t *swparams;
+    size_t buffer_size;
+    int err;
+    size_t n;
+    unsigned int rate;
+    snd_pcm_uframes_t start_threshold, stop_threshold;
+
+    snd_pcm_hw_params_alloca(&params);
+    snd_pcm_sw_params_alloca(&swparams);
+
+    err = snd_pcm_hw_params_any(ai->alsa.handle, params);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Broken configuration for this PCM: no configurations available\n");
+	return -1;
+    }
+    err = snd_pcm_hw_params_set_access(ai->alsa.handle, params,
+				       SND_PCM_ACCESS_RW_INTERLEAVED);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Access type not available\n");
+	return -1;
+    }
+    err = snd_pcm_hw_params_set_format(ai->alsa.handle, params, SND_PCM_FORMAT_S16_LE);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Sample format not available\n");
+	return -1;
+    }
+    err = snd_pcm_hw_params_set_channels(ai->alsa.handle, params, ai->req_channels);
+    if (err < 0) {
+	ai->channels = snd_pcm_hw_params_get_channels(params);
+	mp_msg(MSGT_TV, MSGL_ERR, "Channel count not available - reverting to default: %d\n",
+	       ai->channels);
+    } else {
+	ai->channels = ai->req_channels;
+    }
+
+    err = snd_pcm_hw_params_set_rate_near(ai->alsa.handle, params, ai->req_samplerate, 0);
+    assert(err >= 0);
+    rate = err;
+    ai->samplerate = rate;
+
+    ai->alsa.buffer_time = 1000000;
+    ai->alsa.buffer_time = snd_pcm_hw_params_set_buffer_time_near(ai->alsa.handle, params,
+							       ai->alsa.buffer_time, 0);
+    assert(ai->alsa.buffer_time >= 0);
+    ai->alsa.period_time = ai->alsa.buffer_time / 4;
+    ai->alsa.period_time = snd_pcm_hw_params_set_period_time_near(ai->alsa.handle, params,
+							       ai->alsa.period_time, 0);
+    assert(ai->alsa.period_time >= 0);
+    err = snd_pcm_hw_params(ai->alsa.handle, params);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Unable to install hw params:");
+	snd_pcm_hw_params_dump(params, ai->alsa.log);
+	return -1;
+    }
+    ai->alsa.chunk_size = snd_pcm_hw_params_get_period_size(params, 0);
+    buffer_size = snd_pcm_hw_params_get_buffer_size(params);
+    if (ai->alsa.chunk_size == buffer_size) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Can't use period equal to buffer size (%u == %lu)\n", ai->alsa.chunk_size, (long)buffer_size);
+	return -1;
+    }
+    snd_pcm_sw_params_current(ai->alsa.handle, swparams);
+    err = snd_pcm_sw_params_set_sleep_min(ai->alsa.handle, swparams,0);
+    assert(err >= 0);
+    err = snd_pcm_sw_params_set_avail_min(ai->alsa.handle, swparams, ai->alsa.chunk_size);
+    assert(err >= 0);
+
+    err = snd_pcm_sw_params_set_start_threshold(ai->alsa.handle, swparams, 0);
+    assert(err >= 0);
+    err = snd_pcm_sw_params_set_stop_threshold(ai->alsa.handle, swparams, buffer_size);
+    assert(err >= 0);
+
+    assert(err >= 0);
+    if (snd_pcm_sw_params(ai->alsa.handle, swparams) < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "unable to install sw params:\n");
+	snd_pcm_sw_params_dump(swparams, ai->alsa.log);
+	return -1;
+    }
+
+    if (mp_msg_test(MSGT_TV, MSGL_V)) {
+	snd_pcm_dump(ai->alsa.handle, ai->alsa.log);
+    }
+
+    ai->alsa.bits_per_sample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);
+    ai->alsa.bits_per_frame = ai->alsa.bits_per_sample * ai->channels;
+    ai->blocksize = ai->alsa.chunk_size * ai->alsa.bits_per_frame / 8;
+    ai->samplesize = ai->alsa.bits_per_sample;
+    ai->bytes_per_sample = ai->alsa.bits_per_sample/8;
+
+    return 0;
+}
+
+int ai_alsa_init(audio_in_t *ai)
+{
+    int err;
+    
+    err = snd_pcm_open(&ai->alsa.handle, ai->alsa.device, SND_PCM_STREAM_CAPTURE, 0);
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Error opening audio");
+	return -1;
+    }
+    
+    err = snd_output_stdio_attach(&ai->alsa.log, stderr, 0);
+    
+    if (err < 0) {
+	return -1;
+    }
+    
+    err = ai_alsa_setup(ai);
+
+    return err;
+}
+
+#endif /* HAVE_ALSA9 */
diff --git a/libmpdemux/ai_oss.c b/libmpdemux/ai_oss.c
new file mode 100644
index 0000000000..54cf50b643
--- /dev/null
+++ b/libmpdemux/ai_oss.c
@@ -0,0 +1,123 @@
+#include "config.h"
+#include <linux/soundcard.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "audio_in.h"
+#include "mp_msg.h"
+
+int ai_oss_set_samplerate(audio_in_t *ai)
+{
+    int tmp = ai->req_samplerate;
+    if (ioctl(ai->oss.audio_fd, SNDCTL_DSP_SPEED, &tmp) == -1) return -1;
+    ai->samplerate = ai->req_samplerate;
+    return 0;
+}
+
+int ai_oss_set_channels(audio_in_t *ai)
+{
+    int err;
+    int ioctl_param;
+
+    if (ai->req_channels > 2)
+    {
+	ioctl_param = ai->req_channels;
+	mp_msg(MSGT_TV, MSGL_V, "ioctl dsp channels: %d\n",
+	       err = ioctl(ai->oss.audio_fd, SNDCTL_DSP_CHANNELS, &ioctl_param));
+	if (err < 0) {
+	    mp_msg(MSGT_TV, MSGL_ERR, "Unable to set channel count: %d\n",
+		   ai->req_channels);
+	    return -1;
+	}
+    }
+    else
+    {
+	ioctl_param = (ai->req_channels == 2);
+	mp_msg(MSGT_TV, MSGL_V, "ioctl dsp stereo: %d (req: %d)\n",
+	       err = ioctl(ai->oss.audio_fd, SNDCTL_DSP_STEREO, &ioctl_param),
+	       ioctl_param);
+	if (err < 0) {
+	    mp_msg(MSGT_TV, MSGL_ERR, "Unable to set stereo: %d\n",
+		   ai->req_channels == 2);
+	    return -1;
+	}
+    }
+    ai->channels = ai->req_channels;
+    return 0;
+}
+
+int ai_oss_init(audio_in_t *ai)
+{
+    int err;
+    int ioctl_param;
+
+    ai->oss.audio_fd = open(ai->oss.device, O_RDONLY);
+    if (ai->oss.audio_fd < 0)
+    {
+	mp_msg(MSGT_TV, MSGL_ERR, "unable to open '%s': %s\n",
+	       ai->oss.device, strerror(errno));
+	return -1;
+    }
+	
+    ioctl_param = 0 ;
+    mp_msg(MSGT_TV, MSGL_V, "ioctl dsp getfmt: %d\n",
+	   ioctl(ai->oss.audio_fd, SNDCTL_DSP_GETFMTS, &ioctl_param));
+	
+    mp_msg(MSGT_TV, MSGL_V, "Supported formats: %x\n", ioctl_param);
+    if (!(ioctl_param & AFMT_S16_LE))
+	mp_msg(MSGT_TV, MSGL_ERR, "notsupported format\n");
+
+    ioctl_param = AFMT_S16_LE;
+    mp_msg(MSGT_TV, MSGL_V, "ioctl dsp setfmt: %d\n",
+	   err = ioctl(ai->oss.audio_fd, SNDCTL_DSP_SETFMT, &ioctl_param));
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Unable to set audio format.");
+	return -1;
+    }
+
+    if (ai_oss_set_channels(ai) < 0) return -1;
+	
+    ioctl_param = ai->req_samplerate;
+    mp_msg(MSGT_TV, MSGL_V, "ioctl dsp speed: %d\n",
+	   err = ioctl(ai->oss.audio_fd, SNDCTL_DSP_SPEED, &ioctl_param));
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Unable to set samplerate: %d\n",
+	       ai->req_samplerate);
+	return -1;
+    }
+    ai->samplerate = ai->req_samplerate;
+
+    mp_msg(MSGT_TV, MSGL_V, "ioctl dsp trigger: %d\n",
+	   ioctl(ai->oss.audio_fd, SNDCTL_DSP_GETTRIGGER, &ioctl_param));
+    mp_msg(MSGT_TV, MSGL_V, "trigger: %x\n", ioctl_param);
+    ioctl_param = PCM_ENABLE_INPUT;
+    mp_msg(MSGT_TV, MSGL_V, "ioctl dsp trigger: %d\n",
+	   err = ioctl(ai->oss.audio_fd, SNDCTL_DSP_SETTRIGGER, &ioctl_param));
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Unable to set trigger: %d\n",
+	       PCM_ENABLE_INPUT);
+	return -1;
+    }
+
+    ai->blocksize = 0;
+    mp_msg(MSGT_TV, MSGL_V, "ioctl dsp getblocksize: %d\n",
+	   err = ioctl(ai->oss.audio_fd, SNDCTL_DSP_GETBLKSIZE, &ai->blocksize));
+    if (err < 0) {
+	mp_msg(MSGT_TV, MSGL_ERR, "Unable to get block size!\n");
+    }
+    mp_msg(MSGT_TV, MSGL_V, "blocksize: %d\n", ai->blocksize);
+
+    // correct the blocksize to a reasonable value
+    if (ai->blocksize <= 0) {
+	ai->blocksize = 4096*ai->channels*2;
+	mp_msg(MSGT_TV, MSGL_ERR, "audio block size is zero, setting to %d!\n", ai->blocksize);
+    } else if (ai->blocksize < 4096*ai->channels*2) {
+	ai->blocksize *= 4096*ai->channels*2/ai->blocksize;
+	mp_msg(MSGT_TV, MSGL_ERR, "audio block size too low, setting to %d!\n", ai->blocksize);
+    }
+
+    ai->samplesize = 16;
+    ai->bytes_per_sample = 2;
+
+    return 0;
+}
diff --git a/libmpdemux/audio_in.c b/libmpdemux/audio_in.c
new file mode 100644
index 0000000000..c662bfab0f
--- /dev/null
+++ b/libmpdemux/audio_in.c
@@ -0,0 +1,192 @@
+#include "config.h"
+#include "audio_in.h"
+#include "mp_msg.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+// sanitizes ai structure before calling other functions
+int audio_in_init(audio_in_t *ai, int type)
+{
+    ai->type = type;
+    ai->setup = 0;
+
+    ai->channels = -1;
+    ai->samplerate = -1;
+    ai->blocksize = -1;
+    ai->bytes_per_sample = -1;
+    ai->samplesize = -1;
+
+    switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+    case AUDIO_IN_ALSA:
+	ai->alsa.handle = NULL;
+	ai->alsa.log = NULL;
+	ai->alsa.device = strdup("default");
+	return 0;
+#endif
+    case AUDIO_IN_OSS:
+	ai->oss.audio_fd = -1;
+	ai->oss.device = strdup("/dev/dsp");
+	return 0;
+    default:
+	return -1;
+    }
+}
+
+int audio_in_setup(audio_in_t *ai)
+{
+    int err;
+    
+    switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+    case AUDIO_IN_ALSA:
+	if (ai_alsa_init(ai) < 0) return -1;
+	ai->setup = 1;
+	return 0;
+#endif
+    case AUDIO_IN_OSS:
+	if (ai_oss_init(ai) < 0) return -1;
+	ai->setup = 1;
+	return 0;
+    default:
+	return -1;
+    }
+}
+
+int audio_in_set_samplerate(audio_in_t *ai, int rate)
+{
+    switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+    case AUDIO_IN_ALSA:
+	ai->req_samplerate = rate;
+	if (!ai->setup) return 0;
+	if (ai_alsa_setup(ai) < 0) return -1;
+	return ai->samplerate;
+#endif
+    case AUDIO_IN_OSS:
+	ai->req_samplerate = rate;
+	if (!ai->setup) return 0;
+	if (ai_oss_set_samplerate(ai) < 0) return -1;
+	return ai->samplerate;
+    default:
+	return -1;
+    }
+}
+
+int audio_in_set_channels(audio_in_t *ai, int channels)
+{
+    switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+    case AUDIO_IN_ALSA:
+	ai->req_channels = channels;
+	if (!ai->setup) return 0;
+	if (ai_alsa_setup(ai) < 0) return -1;
+	return ai->channels;
+#endif
+    case AUDIO_IN_OSS:
+	ai->req_channels = channels;
+	if (!ai->setup) return 0;
+	if (ai_oss_set_channels(ai) < 0) return -1;
+	return ai->channels;
+    default:
+	return -1;
+    }
+}
+
+int audio_in_set_device(audio_in_t *ai, char *device)
+{
+    int i;
+    if (ai->setup) return -1;
+    switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+    case AUDIO_IN_ALSA:
+	if (ai->alsa.device) free(ai->alsa.device);
+	ai->alsa.device = strdup(device);
+	/* mplayer cannot handle colons in arguments */
+	for (i = 0; i < strlen(ai->alsa.device); i++) {
+	    if (ai->alsa.device[i] == ',') ai->alsa.device[i] = ':';
+	}
+	return 0;
+#endif
+    case AUDIO_IN_OSS:
+	if (ai->oss.device) free(ai->oss.device);
+	ai->oss.device = strdup(device);
+	return 0;
+    default:
+	return -1;
+    }
+}
+
+int audio_in_uninit(audio_in_t *ai)
+{
+    if (ai->setup) {
+	switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+	case AUDIO_IN_ALSA:
+	    if (ai->alsa.log)
+		snd_output_close(ai->alsa.log);
+	    if (ai->alsa.handle) {
+		snd_pcm_close(ai->alsa.handle);
+	    }
+	    ai->setup = 0;
+	    return 0;
+#endif
+	case AUDIO_IN_OSS:
+	    close(ai->oss.audio_fd);
+	    ai->setup = 0;
+	    return 0;
+	default:
+	    return -1;
+	}
+    }
+}
+
+int audio_in_start_capture(audio_in_t *ai)
+{
+    switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+    case AUDIO_IN_ALSA:
+	return snd_pcm_start(ai->alsa.handle);
+#endif
+    case AUDIO_IN_OSS:
+	return 0;
+    default:
+	return -1;
+    }
+}
+
+int audio_in_read_chunk(audio_in_t *ai, unsigned char *buffer)
+{
+    int ret;
+    
+    switch (ai->type) {
+#ifdef HAVE_ALSA9	  
+    case AUDIO_IN_ALSA:
+	ret = snd_pcm_readi(ai->alsa.handle, buffer, ai->alsa.chunk_size);
+	if (ret != ai->alsa.chunk_size) {
+	    if (ret < 0) {
+		mp_msg(MSGT_TV, MSGL_ERR, "\nerror reading audio: %s\n", snd_strerror(ret));
+	    } else {
+		mp_msg(MSGT_TV, MSGL_ERR, "\nnot enough audio samples!\n");
+	    }
+	    return -1;
+	}
+	return ret;
+#endif
+    case AUDIO_IN_OSS:
+	ret = read(ai->oss.audio_fd, buffer, ai->blocksize);
+	if (ret != ai->blocksize) {
+	    if (ret < 0) {
+		mp_msg(MSGT_TV, MSGL_ERR, "\nerror reading audio: %s\n", strerror(errno));
+	    } else {
+		mp_msg(MSGT_TV, MSGL_ERR, "\nnot enough audio samples!\n");
+	    }
+	    return -1;
+	}
+	return ret;
+    default:
+	return -1;
+    }
+}
diff --git a/libmpdemux/audio_in.h b/libmpdemux/audio_in.h
new file mode 100644
index 0000000000..51c5b0fe7e
--- /dev/null
+++ b/libmpdemux/audio_in.h
@@ -0,0 +1,68 @@
+#ifndef _audio_in_h 
+#define _audio_in_h 
+
+#define AUDIO_IN_ALSA 1
+#define AUDIO_IN_OSS 2
+
+#include "config.h"
+
+#ifdef HAVE_ALSA9
+#include <alsa/asoundlib.h>
+
+typedef struct {
+    char *device;
+
+    snd_pcm_t *handle;
+    snd_output_t *log;
+    int buffer_time, period_time, chunk_size;
+    size_t bits_per_sample, bits_per_frame;
+} ai_alsa_t;
+#endif
+
+typedef struct {
+    char *device;
+
+    int audio_fd;
+} ai_oss_t;
+
+typedef struct 
+{
+    int type;
+    int setup;
+    
+    /* requested values */
+    int req_channels;
+    int req_samplerate;
+
+    /* real values read-only */
+    int channels;
+    int samplerate;
+    int blocksize;
+    int bytes_per_sample;
+    int samplesize;
+    
+#ifdef HAVE_ALSA9
+    ai_alsa_t alsa;
+#endif
+    ai_oss_t oss;
+} audio_in_t;
+
+int audio_in_init(audio_in_t *ai, int type);
+int audio_in_setup(audio_in_t *ai);
+int audio_in_set_device(audio_in_t *ai, char *device);
+int audio_in_set_samplerate(audio_in_t *ai, int rate);
+int audio_in_set_channels(audio_in_t *ai, int channels);
+int audio_in_uninit(audio_in_t *ai);
+int audio_in_start_capture(audio_in_t *ai);
+int audio_in_read_chunk(audio_in_t *ai, unsigned char *buffer);
+
+#ifdef HAVE_ALSA9
+int ai_alsa_setup(audio_in_t *ai);
+int ai_alsa_init(audio_in_t *ai);
+#endif
+
+int ai_oss_set_samplerate(audio_in_t *ai);
+int ai_oss_set_channels(audio_in_t *ai);
+int ai_oss_init(audio_in_t *ai);
+
+#endif /* _audio_in_h */