static int read_stream_open(struct ausrc_st *st, const struct ausrc_prm *prm,
unsigned int dev)
{
WAVEFORMATEX wfmt;
MMRESULT res;
uint32_t sampc;
unsigned format;
int i, err = 0;
st->sampsz = aufmt_sample_size(prm->fmt);
format = winwave_get_format(prm->fmt);
if (format == WAVE_FORMAT_UNKNOWN) {
warning("winwave: source: unsupported sample format (%s)\n",
aufmt_name(prm->fmt));
return ENOTSUP;
}
/* Open an audio INPUT stream. */
st->wavein = NULL;
st->pos = 0;
st->rdy = false;
sampc = prm->srate * prm->ch * prm->ptime / 1000;
for (i = 0; i < READ_BUFFERS; i++) {
memset(&st->bufs[i].wh, 0, sizeof(WAVEHDR));
st->bufs[i].mb = mbuf_alloc(st->sampsz * sampc);
if (!st->bufs[i].mb)
return ENOMEM;
}
wfmt.wFormatTag = format;
wfmt.nChannels = prm->ch;
wfmt.nSamplesPerSec = prm->srate;
wfmt.wBitsPerSample = (WORD)(st->sampsz * 8);
wfmt.nBlockAlign = (prm->ch * wfmt.wBitsPerSample) / 8;
wfmt.nAvgBytesPerSec = wfmt.nSamplesPerSec * wfmt.nBlockAlign;
wfmt.cbSize = 0;
res = waveInOpen(&st->wavein, dev, &wfmt,
(DWORD_PTR) waveInCallback,
(DWORD_PTR) st,
CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT);
if (res != MMSYSERR_NOERROR) {
warning("winwave: waveInOpen: failed res=%d\n", res);
return EINVAL;
}
/* Prepare enough IN buffers to suite at least 50ms of data */
for (i = 0; i < READ_BUFFERS; i++)
err |= add_wave_in(st);
waveInStart(st->wavein);
return err;
}
static void write_handler(void *sampv, size_t sampc, void *arg)
{
struct audio_loop *al = arg;
size_t num_bytes = sampc * aufmt_sample_size(al->fmt);
al->n_write += sampc;
/* read from beginning */
aubuf_read(al->aubuf, sampv, num_bytes);
}
static void read_handler(const void *sampv, size_t sampc, void *arg)
{
struct audio_loop *al = arg;
size_t num_bytes = sampc * aufmt_sample_size(al->fmt);
int err;
al->n_read += sampc;
err = aubuf_write(al->aubuf, sampv, num_bytes);
if (err) {
warning("auloop: aubuf_write: %m\n", err);
}
}
static int decode(struct aufilt_dec_st *st, void *sampv, size_t *sampc)
{
struct sndfile_dec *sf = (struct sndfile_dec *)st;
size_t num_bytes;
if (!st || !sampv || !sampc)
return EINVAL;
num_bytes = *sampc * aufmt_sample_size(sf->fmt);
sf_write_raw(sf->dec, sampv, num_bytes);
return 0;
}
int alsa_src_alloc(struct ausrc_st **stp, const struct ausrc *as,
struct media_ctx **ctx,
struct ausrc_prm *prm, const char *device,
ausrc_read_h *rh, ausrc_error_h *errh, void *arg)
{
struct ausrc_st *st;
snd_pcm_format_t pcmfmt;
int num_frames;
int err;
(void)ctx;
(void)errh;
if (!stp || !as || !prm || !rh)
return EINVAL;
if (!str_isset(device))
device = alsa_dev;
st = mem_zalloc(sizeof(*st), ausrc_destructor);
if (!st)
return ENOMEM;
err = str_dup(&st->device, device);
if (err)
goto out;
st->prm = *prm;
st->as = as;
st->rh = rh;
st->arg = arg;
st->aufmt = alsa_sample_format;
st->sampc = prm->srate * prm->ch * prm->ptime / 1000;
num_frames = st->prm.srate * st->prm.ptime / 1000;
st->sampv = mem_alloc(2 * st->sampc, NULL);
if (!st->sampv) {
err = ENOMEM;
goto out;
}
if (st->aufmt != AUFMT_S16LE) {
size_t sz = aufmt_sample_size(st->aufmt) * st->sampc;
st->xsampv = mem_alloc(sz, NULL);
if (!st->xsampv) {
err = ENOMEM;
goto out;
}
}
err = snd_pcm_open(&st->read, st->device, SND_PCM_STREAM_CAPTURE, 0);
if (err < 0) {
warning("alsa: could not open ausrc device '%s' (%s)\n",
st->device, snd_strerror(err));
goto out;
}
pcmfmt = aufmt_to_alsaformat(st->aufmt);
if (pcmfmt == SND_PCM_FORMAT_UNKNOWN) {
warning("alsa: unknown sample format '%s'\n",
aufmt_name(st->aufmt));
err = EINVAL;
goto out;
}
err = alsa_reset(st->read, st->prm.srate, st->prm.ch, num_frames,
pcmfmt);
if (err) {
warning("alsa: could not reset source '%s' (%s)\n",
st->device, snd_strerror(err));
goto out;
}
st->run = true;
err = pthread_create(&st->thread, NULL, read_thread, st);
if (err) {
st->run = false;
goto out;
}
debug("alsa: recording started (%s)\n", st->device);
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}
int alsa_play_alloc(struct auplay_st **stp, const struct auplay *ap,
struct auplay_prm *prm, const char *device,
auplay_write_h *wh, void *arg)
{
struct auplay_st *st;
snd_pcm_format_t pcmfmt;
int num_frames;
int err;
if (!stp || !ap || !prm || !wh)
return EINVAL;
if (!str_isset(device))
device = alsa_dev;
st = mem_zalloc(sizeof(*st), auplay_destructor);
if (!st)
return ENOMEM;
err = str_dup(&st->device, device);
if (err)
goto out;
st->prm = *prm;
st->ap = ap;
st->wh = wh;
st->arg = arg;
st->aufmt = alsa_sample_format;
st->sampc = prm->srate * prm->ch * prm->ptime / 1000;
num_frames = st->prm.srate * st->prm.ptime / 1000;
st->sampv = mem_alloc(2 * st->sampc, NULL);
if (!st->sampv) {
err = ENOMEM;
goto out;
}
if (st->aufmt != AUFMT_S16LE) {
size_t sz = aufmt_sample_size(st->aufmt) * st->sampc;
st->xsampv = mem_alloc(sz, NULL);
if (!st->xsampv) {
err = ENOMEM;
goto out;
}
}
err = snd_pcm_open(&st->write, st->device, SND_PCM_STREAM_PLAYBACK, 0);
if (err < 0) {
warning("alsa: could not open auplay device '%s' (%s)\n",
st->device, snd_strerror(err));
goto out;
}
pcmfmt = aufmt_to_alsaformat(st->aufmt);
if (pcmfmt == SND_PCM_FORMAT_UNKNOWN) {
warning("alsa: unknown sample format '%s'\n",
aufmt_name(st->aufmt));
err = EINVAL;
goto out;
}
err = alsa_reset(st->write, st->prm.srate, st->prm.ch, num_frames,
pcmfmt);
if (err) {
warning("alsa: could not reset player '%s' (%s)\n",
st->device, snd_strerror(err));
goto out;
}
st->run = true;
err = pthread_create(&st->thread, NULL, write_thread, st);
if (err) {
st->run = false;
goto out;
}
debug("alsa: playback started (%s)\n", st->device);
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}
static int alloc_handler(struct ausrc_st **stp, const struct ausrc *as,
struct media_ctx **ctx,
struct ausrc_prm *prm, const char *dev,
ausrc_read_h *rh, ausrc_error_h *errh, void *arg)
{
struct ausrc_st *st;
int err;
if (!stp || !as || !prm || !rh)
return EINVAL;
st = mem_zalloc(sizeof(*st), destructor);
if (!st)
return ENOMEM;
st->as = as;
st->rh = rh;
st->errh = errh;
st->arg = arg;
st->mp3 = mpg123_new(NULL, &err);
if (!st->mp3) {
err = ENODEV;
goto out;
}
err = mpg123_open_feed(st->mp3);
if (err != MPG123_OK) {
warning("rst: mpg123_open_feed: %s\n",
mpg123_strerror(st->mp3));
err = ENODEV;
goto out;
}
/* Set wanted output format */
mpg123_format_none(st->mp3);
mpg123_format(st->mp3, prm->srate, prm->ch,
aufmt_to_encoding(prm->fmt));
mpg123_volume(st->mp3, 0.3);
st->sampc = prm->srate * prm->ch * prm->ptime / 1000;
st->sampsz = aufmt_sample_size(prm->fmt);
st->ptime = prm->ptime;
info("rst: audio ptime=%u sampc=%zu aubuf=[%u:%u]\n",
st->ptime, st->sampc,
prm->srate * prm->ch * 2,
prm->srate * prm->ch * 40);
/* 1 - 20 seconds of audio */
err = aubuf_alloc(&st->aubuf,
prm->srate * prm->ch * st->sampsz,
prm->srate * prm->ch * st->sampsz * 20);
if (err)
goto out;
if (ctx && *ctx && (*ctx)->id && !strcmp((*ctx)->id, "rst")) {
st->rst = mem_ref(*ctx);
}
else {
err = rst_alloc(&st->rst, dev);
if (err)
goto out;
if (ctx)
*ctx = (struct media_ctx *)st->rst;
}
rst_set_audio(st->rst, st);
st->run = true;
err = pthread_create(&st->thread, NULL, play_thread, st);
if (err) {
st->run = false;
goto out;
}
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}
