/*
* PCM - USB_STREAM plugin
*
* Copyright (c) 2008, 2010 by Karsten Wiese <fzu@wemgehoertderstaat.de>
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define _GNU_SOURCE
#include <byteswap.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>
#include <alsa/asoundlib.h>
#include <alsa/pcm_external.h>
#include <alsa/hwdep.h>
#include "usb_stream.h"
#define DEBUG
#ifdef DEBUG
#define DBG(f, ...) \
fprintf(stderr, "%s:%i %i "f"\n", __FUNCTION__, __LINE__, getpid(), ## __VA_ARGS__);
#else
#define DBG(f, ...)
#endif
#ifdef VDEBUG
#define VDBG(f, ...) \
fprintf(stderr, "%s:%i %i "f"\n", __FUNCTION__, __LINE__, getpid(), ## __VA_ARGS__);
#else
#define VDBG(f, ...)
#endif
#define FRAME_SIZE 6
#define LCARD 32
struct user_usb_stream {
char card[LCARD];
unsigned use;
struct usb_stream *s;
void *write_area;
struct user_usb_stream *next;
};
typedef struct {
snd_pcm_ioplug_t io;
snd_hwdep_t *hwdep;
struct user_usb_stream *uus;
struct pollfd pfd;
unsigned int num_ports;
unsigned periods_start;
unsigned periods_done;
unsigned channels;
snd_pcm_uframes_t period_size;
unsigned int rate;
} snd_pcm_us_t;
static struct user_usb_stream *uus;
static pthread_mutex_t uus_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct user_usb_stream *get_uus(const char *card)
{
pthread_mutex_lock(&uus_mutex);
struct user_usb_stream **l_uus = &uus,
*r_uus = NULL;
while (*l_uus) {
if (strcmp((*l_uus)->card, card) == 0) {
r_uus = *l_uus;
r_uus->use++;
goto unlock;
}
l_uus = &(*l_uus)->next;
}
r_uus = calloc(1, sizeof(*r_uus));
if (r_uus) {
r_uus->use = 1;
strcpy(r_uus->card, card);
*l_uus = r_uus;
}
unlock:
pthread_mutex_unlock(&uus_mutex);
return r_uus;
}
static void uus_free(snd_pcm_us_t *us)
{
if (!us->uus)
return;
pthread_mutex_lock(&uus_mutex);
us->uus->use--;
if (!us->uus->use) {
struct user_usb_stream **n_uus = &uus,
*p_uus;
while (us->uus != *n_uus) {
p_uus = *n_uus;
n_uus = &p_uus->next;
}
*n_uus = us->uus->next;
if (us->uus->s) {
munmap(us->uus->write_area, us->uus->s->write_size);
munmap(us->uus->s, us->uus->s->read_size);
}
free(us->uus);
}
pthread_mutex_unlock(&uus_mutex);
}
static void us_free(snd_pcm_us_t *us)
{
uus_free(us);
free(us);
}
static int snd_pcm_us_close(snd_pcm_ioplug_t *io)
{
snd_pcm_us_t *us = io->private_data;
snd_hwdep_close(us->hwdep);
us_free(us);
return 0;
}
static snd_pcm_sframes_t snd_pcm_us_pointer(snd_pcm_ioplug_t *io)
{
snd_pcm_us_t *us = io->private_data;
struct usb_stream *s = us->uus->s;
snd_pcm_sframes_t hw_pointer;
switch (io->state) {
case SND_PCM_STATE_RUNNING:
VDBG("%u %u", s->periods_done, us->periods_done);
if (s->periods_done - us->periods_done <= 1)
hw_pointer =
(s->periods_done - us->periods_start) & 1 ?
io->period_size : 0;
else
hw_pointer = -EPIPE;
break;
case SND_PCM_STATE_XRUN:
hw_pointer = -EPIPE;
break;
default:
hw_pointer = 0;
break;
}
VDBG("%li", hw_pointer);
return hw_pointer;
}
static int snd_pcm_us_prepare(snd_pcm_ioplug_t *io)
{
struct usb_stream_config us_cfg;
snd_pcm_us_t *us = io->private_data;
struct user_usb_stream *uus = us->uus;
int ioctl_result, err;
VDBG("");
us_cfg.version = USB_STREAM_INTERFACE_VERSION;
us_cfg.frame_size = FRAME_SIZE;
us_cfg.sample_rate = io->rate;
us_cfg.period_frames = io->period_size;
ioctl_result = snd_hwdep_ioctl(us->hwdep, SNDRV_USB_STREAM_IOCTL_SET_PARAMS, &us_cfg);
if (ioctl_result < 0) {
perror("Couldn't configure usb_stream\n");
return ioctl_result;
}
if (ioctl_result && uus && uus->s) {
err = munmap(uus->write_area, uus->s->write_size);
if (err < 0)
return -errno;
err = munmap(uus->s, uus->s->read_size);
if (err < 0)
return -errno;
uus->s = NULL;
}
if (!uus->s) {
uus->s = mmap(NULL, sizeof(struct usb_stream),
PROT_READ,
MAP_SHARED, us->pfd.fd,
0);
if (MAP_FAILED == uus->s) {
perror("ALSA/USX2Y: mmap");
return -errno;
}
VDBG("%p %lx %i", uus->s, uus->s, uus->s->read_size);
if (memcmp(&uus->s->cfg, &us_cfg, sizeof(us_cfg))) {
perror("usb_stream Configuration error usb_stream\n");
return -EIO;
}
uus->s = mremap(uus->s, sizeof(struct usb_stream), uus->s->read_size, MREMAP_MAYMOVE);
if (MAP_FAILED == uus->s) {
perror("ALSA/USX2Y: mmap");
return -EPERM;
}
VDBG("%p %lx %i", uus->s, uus->s, uus->s->read_size);
uus->write_area = mmap(NULL, uus->s->write_size,
PROT_READ|PROT_WRITE,
MAP_SHARED, us->pfd.fd,
(uus->s->read_size + 4095) & ~4095);
if (MAP_FAILED == uus->write_area) {
perror("ALSA/USX2Y: mmap");
return -1;
}
VDBG("%p %i", uus->write_area, uus->s->write_size);
}
if (uus->s->state != usb_stream_ready)
return -EIO;
if (poll(&us->pfd, 1, 500000) < 0)
return -errno;
return 0;
}
static int snd_pcm_us_start(snd_pcm_ioplug_t *io)
{
snd_pcm_us_t *us = io->private_data;
VDBG("%u", us->uus->s->periods_done);
us->periods_start = us->periods_done = us->uus->s->periods_done;
return 0;
}
static int snd_pcm_us_stop(snd_pcm_ioplug_t *io)
{
snd_pcm_us_t *us = io->private_data;
if (!us->uus->s)
return 0;
VDBG("%u", us->uus->s->periods_done);
if (io->stream == SND_PCM_STREAM_PLAYBACK)
memset(us->uus->write_area, 0, us->uus->s->write_size);
return 0;
}
static snd_pcm_sframes_t snd_pcm_us_write(snd_pcm_ioplug_t *io,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size)
{
void *playback_addr;
snd_pcm_us_t *us = io->private_data;
struct user_usb_stream *uus = us->uus;
struct usb_stream *s = uus->s;
unsigned bytes;
void *src = areas->addr + offset * s->cfg.frame_size;
VDBG("%li %li %i %i", offset, size, areas->first, areas->step);
playback_addr = uus->write_area + s->outpacket[0].offset;
memcpy(playback_addr, src, s->outpacket[0].length);
bytes = size * s->cfg.frame_size;
if (bytes > s->outpacket[0].length) {
playback_addr = uus->write_area + s->outpacket[1].offset;
memcpy(playback_addr, src + s->outpacket[0].length,
bytes - s->outpacket[0].length);
}
us->periods_done++;
return size;
}
static int usb_stream_read(struct user_usb_stream *uus, void *to)
{
struct usb_stream *s = uus->s;
unsigned p = s->inpacket_split, l = 0;
void *i = (void *)s + s->inpacket[p].offset + s->inpacket_split_at;
unsigned il = s->inpacket[p].length - s->inpacket_split_at;
do {
if (l + il > s->period_size)
il = s->period_size - l;
memcpy(to + l, i, il);
l += il;
if (l >= s->period_size)
break;
p = (p + 1) % s->inpackets;
i = (void *)s + s->inpacket[p].offset;
il = s->inpacket[p].length;
} while (p != s->inpacket_split);
return l;
}
static snd_pcm_sframes_t snd_pcm_us_read(snd_pcm_ioplug_t *io,
const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size)
{
snd_pcm_us_t *us = io->private_data;
unsigned frame_size = us->uus->s->cfg.frame_size;
void *to = areas->addr + offset * frame_size;
snd_pcm_uframes_t red;
if (size) {
if (size != us->uus->s->cfg.period_frames) {
SNDERR("usb_stream plugin only supports period_size"
" long reads, sorry");
return -EINVAL;
}
if (us->uus->s->periods_done - us->periods_done == 1) {
red = usb_stream_read(us->uus, to) / frame_size;
us->periods_done++;
return red;
}
} else
if (io->state == SND_PCM_STATE_XRUN)
return -EPIPE;
return 0;
}
static snd_pcm_ioplug_callback_t us_playback_callback = {
.close = snd_pcm_us_close,
.start = snd_pcm_us_start,
.stop = snd_pcm_us_stop,
.transfer = snd_pcm_us_write,
.pointer = snd_pcm_us_pointer,
.prepare = snd_pcm_us_prepare,
};
static snd_pcm_ioplug_callback_t us_capture_callback = {
.close = snd_pcm_us_close,
.start = snd_pcm_us_start,
.stop = snd_pcm_us_stop,
.transfer = snd_pcm_us_read,
.pointer = snd_pcm_us_pointer,
.prepare = snd_pcm_us_prepare,
};
#define ARRAY_SIZE(ary) (sizeof(ary)/sizeof(ary[0]))
static int us_set_hw_constraint(snd_pcm_us_t *us)
{
unsigned access_list[] = {
SND_PCM_ACCESS_MMAP_INTERLEAVED,
};
unsigned format_list[] = {
SND_PCM_FORMAT_S24_3LE,
};
int err;
unsigned int rate_min = us->rate ? us->rate : 44100,
rate_max = us->rate ? us->rate : 96000,
period_bytes_min = us->period_size ? FRAME_SIZE * us->period_size : 128,
period_bytes_max = us->period_size ? FRAME_SIZE * us->period_size : 64*4096;
if ((err = snd_pcm_ioplug_set_param_list(&us->io, SND_PCM_IOPLUG_HW_ACCESS,
ARRAY_SIZE(access_list), access_list)) < 0 ||
(err = snd_pcm_ioplug_set_param_list(&us->io, SND_PCM_IOPLUG_HW_FORMAT,
ARRAY_SIZE(format_list), format_list)) < 0 ||
(err = snd_pcm_ioplug_set_param_minmax(&us->io, SND_PCM_IOPLUG_HW_CHANNELS,
us->channels, us->channels)) < 0 ||
(err = snd_pcm_ioplug_set_param_minmax(&us->io, SND_PCM_IOPLUG_HW_RATE,
rate_min, rate_max)) < 0 ||
(err = snd_pcm_ioplug_set_param_minmax(&us->io, SND_PCM_IOPLUG_HW_PERIOD_BYTES,
period_bytes_min, period_bytes_max)) < 0 ||
(err = snd_pcm_ioplug_set_param_minmax(&us->io, SND_PCM_IOPLUG_HW_PERIODS,
2, 2)) < 0)
return err;
return 0;
}
static int snd_pcm_us_open(snd_pcm_t **pcmp, const char *name,
const char *card,
snd_pcm_stream_t stream, int mode,
snd_pcm_uframes_t period_size,
unsigned int rate)
{
snd_pcm_us_t *us;
int err;
char us_name[32];
if (strlen(card) >= LCARD)
return -EINVAL;
assert(pcmp);
us = calloc(1, sizeof(*us));
if (!us)
return -ENOMEM;
if (snprintf(us_name, sizeof(us_name), "hw:%s", card)
>= (int)sizeof(us_name)) {
fprintf(stderr, "%s: WARNING: USB_STREAM client name '%s' truncated to %d characters, might not be unique\n",
__func__, us_name, (int)strlen(us_name));
}
VDBG("%i %s", stream, us_name);
us->uus = get_uus(card);
if (!us->uus) {
free(us);
return -ENOMEM;
}
err = snd_hwdep_open(&us->hwdep, us_name, O_RDWR);
if (err < 0) {
us_free(us);
return err;
}
snd_hwdep_poll_descriptors(us->hwdep, &us->pfd, 1);
us->channels = 2;
us->period_size = period_size;
us->rate = rate;
us->io.version = SND_PCM_IOPLUG_VERSION;
us->io.name = "ALSA <-> USB_STREAM PCM I/O Plugin";
us->io.callback = stream == SND_PCM_STREAM_PLAYBACK ?
&us_playback_callback : &us_capture_callback;
us->io.private_data = us;
us->io.mmap_rw = 0;
us->io.poll_fd = us->pfd.fd;
us->io.poll_events = stream == SND_PCM_STREAM_PLAYBACK ? POLLOUT : POLLIN;
err = snd_pcm_ioplug_create(&us->io, name, stream, mode);
if (err < 0) {
us_free(us);
return err;
}
err = us_set_hw_constraint(us);
if (err < 0) {
snd_pcm_ioplug_delete(&us->io);
return err;
}
VDBG("");
*pcmp = us->io.pcm;
return 0;
}
SND_PCM_PLUGIN_DEFINE_FUNC(usb_stream)
{
snd_config_iterator_t i, next;
const char *card;
int err;
long period_size = 0, rate = 0;
snd_config_for_each(i, next, conf) {
snd_config_t *n = snd_config_iterator_entry(i);
const char *id;
if (snd_config_get_id(n, &id) < 0)
continue;
if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0)
continue;
if (strcmp(id, "card") == 0) {
if (snd_config_get_type(n) != SND_CONFIG_TYPE_STRING) {
SNDERR("Invalid type for %s", id);
return -EINVAL;
}
snd_config_get_string(n, &card);
continue;
}
if (strcmp(id, "period_size") == 0) {
if (snd_config_get_type(n) != SND_CONFIG_TYPE_INTEGER) {
SNDERR("Invalid type for %s", id);
return -EINVAL;
}
snd_config_get_integer(n, &period_size);
continue;
}
if (strcmp(id, "rate") == 0) {
if (snd_config_get_type(n) != SND_CONFIG_TYPE_INTEGER) {
SNDERR("Invalid type for %s", id);
return -EINVAL;
}
snd_config_get_integer(n, &rate);
continue;
}
SNDERR("Unknown field %s", id);
return -EINVAL;
}
err = snd_pcm_us_open(pcmp, name, card, stream, mode, period_size, rate);
return err;
}
SND_PCM_PLUGIN_SYMBOL(usb_stream);