/*
* PCM - JACK plugin
*
* Copyright (c) 2003 by Maarten de Boer <mdeboer@iua.upf.es>
* 2005 Takashi Iwai <tiwai@suse.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
*
*/
#include <stdbool.h>
#include <byteswap.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <jack/jack.h>
#include <alsa/asoundlib.h>
#include <alsa/pcm_external.h>
#define MAX_PERIODS_MULTIPLE 64
typedef struct snd_pcm_jack_port_list {
struct snd_pcm_jack_port_list *next;
/* will always be allocated with size of the string.
* See snd_pcm_jack_port_list_add().
*/
char name[0];
} snd_pcm_jack_port_list_t;
typedef struct {
snd_pcm_ioplug_t io;
int fd;
int activated; /* jack is activated? */
snd_pcm_jack_port_list_t **port_names;
unsigned int num_ports;
snd_pcm_uframes_t boundary;
snd_pcm_uframes_t hw_ptr;
unsigned int sample_bits;
snd_pcm_uframes_t min_avail;
snd_pcm_channel_area_t *areas;
jack_port_t **ports;
jack_client_t *client;
/* JACK thread -> ALSA thread */
bool xrun_detected;
} snd_pcm_jack_t;
/* snd_pcm_ioplug_avail() was introduced after alsa-lib 1.1.6 */
#if SND_LIB_VERSION < 0x10107
static snd_pcm_uframes_t snd_pcm_ioplug_avail(const snd_pcm_ioplug_t *io,
const snd_pcm_uframes_t hw_ptr,
const snd_pcm_uframes_t appl_ptr)
{
return io->buffer_size - snd_pcm_ioplug_hw_avail(io, hw_ptr, appl_ptr);
}
#endif
/* adds one element to the head of the list */
static int snd_pcm_jack_port_list_add(snd_pcm_jack_t *jack,
const unsigned int channel,
const char * const name)
{
const size_t name_size = strlen(name) + 1;
const size_t elem_size = sizeof(snd_pcm_jack_port_list_t) + name_size;
snd_pcm_jack_port_list_t * const elem = calloc(1, elem_size);
if (elem == NULL)
return -ENOMEM;
/* Above it is guaranteed that elem->name is big enough for the size of
* name because strlen(name) + 1 will be used to allocate the buffer.
*/
strcpy(elem->name, name);
elem->next = jack->port_names[channel];
jack->port_names[channel] = elem;
return 0;
}
static int pcm_poll_block_check(snd_pcm_ioplug_t *io)
{
static char buf[32];
snd_pcm_uframes_t avail;
snd_pcm_jack_t *jack = io->private_data;
if (io->state == SND_PCM_STATE_RUNNING ||
io->state == SND_PCM_STATE_DRAINING ||
(io->state == SND_PCM_STATE_PREPARED && io->stream == SND_PCM_STREAM_CAPTURE)) {
avail = snd_pcm_ioplug_avail(io, jack->hw_ptr, io->appl_ptr);
if (avail < jack->min_avail) {
while (read(io->poll_fd, &buf, sizeof(buf)) == sizeof(buf))
;
return 1;
}
}
return 0;
}
static int pcm_poll_unblock_check(snd_pcm_ioplug_t *io)
{
static char buf[1];
snd_pcm_uframes_t avail;
snd_pcm_jack_t *jack = io->private_data;
avail = snd_pcm_ioplug_avail(io, jack->hw_ptr, io->appl_ptr);
/* In draining state poll_fd is used to wait
* till all pending frames are played.
* Therefore it has to be guarantee that a poll event is also generated
* if the buffer contains less than min_avail frames
*/
if (avail >= jack->min_avail || io->state == SND_PCM_STATE_DRAINING) {
write(jack->fd, &buf, 1);
return 1;
}
return 0;
}
static void snd_pcm_jack_free(snd_pcm_jack_t *jack)
{
if (jack == NULL)
return;
if (jack->client)
jack_client_close(jack->client);
if (jack->port_names) {
unsigned int i;
for (i = 0; i < jack->num_ports; i++) {
snd_pcm_jack_port_list_t *port_elem =
jack->port_names[i];
while (port_elem != NULL) {
snd_pcm_jack_port_list_t *next_port_elem =
port_elem->next;
free(port_elem);
port_elem = next_port_elem;
}
}
free(jack->port_names);
jack->port_names = NULL;
}
if (jack->fd >= 0)
close(jack->fd);
if (jack->io.poll_fd >= 0)
close(jack->io.poll_fd);
free(jack->areas);
free(jack->ports);
free(jack);
}
static int snd_pcm_jack_close(snd_pcm_ioplug_t *io)
{
snd_pcm_jack_t *jack = io->private_data;
snd_pcm_jack_free(jack);
return 0;
}
static int snd_pcm_jack_poll_revents(snd_pcm_ioplug_t *io,
struct pollfd *pfds, unsigned int nfds,
unsigned short *revents)
{
assert(pfds && nfds == 1 && revents);
*revents = pfds[0].revents & ~(POLLIN | POLLOUT);
if (pfds[0].revents & POLLIN && !pcm_poll_block_check(io))
*revents |= (io->stream == SND_PCM_STREAM_PLAYBACK) ? POLLOUT : POLLIN;
return 0;
}
static snd_pcm_sframes_t snd_pcm_jack_pointer(snd_pcm_ioplug_t *io)
{
snd_pcm_jack_t *jack = io->private_data;
if (jack->xrun_detected)
return -EPIPE;
#ifdef SND_PCM_IOPLUG_FLAG_BOUNDARY_WA
return jack->hw_ptr;
#else
return jack->hw_ptr % io->buffer_size;
#endif
}
static int
snd_pcm_jack_process_cb(jack_nframes_t nframes, snd_pcm_ioplug_t *io)
{
snd_pcm_jack_t *jack = io->private_data;
snd_pcm_uframes_t xfer = 0;
unsigned int channel;
for (channel = 0; channel < io->channels; channel++) {
jack->areas[channel].addr =
jack_port_get_buffer (jack->ports[channel], nframes);
jack->areas[channel].first = 0;
jack->areas[channel].step = jack->sample_bits;
}
if (io->state == SND_PCM_STATE_RUNNING ||
io->state == SND_PCM_STATE_DRAINING) {
snd_pcm_uframes_t hw_ptr = jack->hw_ptr;
const snd_pcm_uframes_t hw_avail = snd_pcm_ioplug_hw_avail(io, hw_ptr,
io->appl_ptr);
if (hw_avail > 0) {
const snd_pcm_channel_area_t *areas = snd_pcm_ioplug_mmap_areas(io);
const snd_pcm_uframes_t offset = hw_ptr % io->buffer_size;
xfer = nframes;
if (xfer > hw_avail)
xfer = hw_avail;
if (io->stream == SND_PCM_STREAM_PLAYBACK)
snd_pcm_areas_copy_wrap(jack->areas, 0, nframes,
areas, offset,
io->buffer_size,
io->channels, xfer,
io->format);
else
snd_pcm_areas_copy_wrap(areas, offset,
io->buffer_size,
jack->areas, 0, nframes,
io->channels, xfer,
io->format);
hw_ptr += xfer;
if (hw_ptr >= jack->boundary)
hw_ptr -= jack->boundary;
jack->hw_ptr = hw_ptr;
}
}
/* check if requested frames were copied */
if (xfer < nframes) {
/* always fill the not yet written JACK buffer with silence */
if (io->stream == SND_PCM_STREAM_PLAYBACK) {
const snd_pcm_uframes_t frames = nframes - xfer;
snd_pcm_areas_silence(jack->areas, xfer, io->channels,
frames, io->format);
}
if (io->state == SND_PCM_STATE_RUNNING ||
io->state == SND_PCM_STATE_DRAINING) {
/* report Xrun to user application */
jack->xrun_detected = true;
}
}
pcm_poll_unblock_check(io); /* unblock socket for polling if needed */
return 0;
}
static void jack_allocate_and_register_ports(snd_pcm_ioplug_t *io)
{
snd_pcm_jack_t *jack = io->private_data;
unsigned int i;
jack->ports = calloc(io->channels, sizeof(jack_port_t *));
for (i = 0; i < io->channels; i++) {
char port_name[32];
if (io->stream == SND_PCM_STREAM_PLAYBACK) {
sprintf(port_name, "out_%03d", i);
jack->ports[i] = jack_port_register(jack->client, port_name,
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, 0);
} else {
sprintf(port_name, "in_%03d", i);
jack->ports[i] = jack_port_register(jack->client, port_name,
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsInput, 0);
}
}
}
static int snd_pcm_jack_prepare(snd_pcm_ioplug_t *io)
{
snd_pcm_jack_t *jack = io->private_data;
unsigned int i;
snd_pcm_sw_params_t *swparams;
int err;
if (io->channels != jack->num_ports) {
SNDERR("Channel count %d not equal to no. of ports %d in JACK",
io->channels, jack->num_ports);
return -EINVAL;
}
jack->hw_ptr = 0;
jack->xrun_detected = false;
jack->min_avail = io->period_size;
snd_pcm_sw_params_alloca(&swparams);
err = snd_pcm_sw_params_current(io->pcm, swparams);
if (err == 0) {
snd_pcm_sw_params_get_avail_min(swparams, &jack->min_avail);
/* get boundary for available calulation */
snd_pcm_sw_params_get_boundary(swparams, &jack->boundary);
}
if (io->stream == SND_PCM_STREAM_PLAYBACK)
pcm_poll_unblock_check(io); /* playback pcm initially accepts writes */
else
pcm_poll_block_check(io); /* block capture pcm if that's XRUN recovery */
if (!jack->ports) {
jack_allocate_and_register_ports(io);
jack_set_process_callback(jack->client,
(JackProcessCallback)snd_pcm_jack_process_cb, io);
}
if (jack->activated)
return 0;
if (jack_activate(jack->client))
return -EIO;
jack->activated = 1;
for (i = 0; i < io->channels && i < jack->num_ports; i++) {
const char * const own_port = jack_port_name(jack->ports[i]);
snd_pcm_jack_port_list_t *port_elem;
for (port_elem = jack->port_names[i]; port_elem != NULL;
port_elem = port_elem->next) {
const char *src, *dst;
if (io->stream == SND_PCM_STREAM_PLAYBACK) {
src = own_port;
dst = port_elem->name;
} else {
src = port_elem->name;
dst = own_port;
}
if (jack_connect(jack->client, src, dst)) {
fprintf(stderr, "cannot connect %s to %s\n",
src, dst);
return -EIO;
}
}
}
return 0;
}
static int snd_pcm_jack_start(snd_pcm_ioplug_t *io)
{
(void)io;
/*
* Since the processing of jack_activate() and jack_connect() take a
* while longer, snd_pcm_jack_start() was blocked.
* Consider a usecase of reading the data from capture device and
* writing to a playback device, since the capture device is
* already started and the starting of playback device is blocked,
* it leads to XRUNs for capture device.
* Therefore these calls are moved to snd_pcm_jack_prepare(),
* So that the capture and playback devices can be prepared in advance
* and starting of the device doesn't take too long.
*/
return 0;
}
static int snd_pcm_jack_stop(snd_pcm_ioplug_t *io)
{
(void)io;
return 0;
}
static int snd_pcm_jack_hw_free(snd_pcm_ioplug_t *io)
{
snd_pcm_jack_t *jack = io->private_data;
if (jack->activated) {
jack_deactivate(jack->client);
jack->activated = 0;
}
#if 0
unsigned i;
for (i = 0; i < io->channels; i++) {
if (jack->ports[i]) {
jack_port_unregister(jack->client, jack->ports[i]);
jack->ports[i] = NULL;
}
}
#endif
return 0;
}
static snd_pcm_ioplug_callback_t jack_pcm_callback = {
.close = snd_pcm_jack_close,
.start = snd_pcm_jack_start,
.stop = snd_pcm_jack_stop,
.pointer = snd_pcm_jack_pointer,
.hw_free = snd_pcm_jack_hw_free,
.prepare = snd_pcm_jack_prepare,
.poll_revents = snd_pcm_jack_poll_revents,
};
#define ARRAY_SIZE(ary) (sizeof(ary)/sizeof(ary[0]))
static int jack_set_hw_constraint(snd_pcm_jack_t *jack)
{
unsigned int access_list[] = {
SND_PCM_ACCESS_MMAP_INTERLEAVED,
SND_PCM_ACCESS_MMAP_NONINTERLEAVED,
SND_PCM_ACCESS_RW_INTERLEAVED,
SND_PCM_ACCESS_RW_NONINTERLEAVED
};
unsigned int format = SND_PCM_FORMAT_FLOAT;
unsigned int rate = jack_get_sample_rate(jack->client);
unsigned int psize_list[MAX_PERIODS_MULTIPLE];
unsigned int nframes = jack_get_buffer_size(jack->client);
unsigned int jack_buffer_bytes = (snd_pcm_format_size(format, nframes) *
jack->num_ports);
unsigned int i;
int err;
if (!jack_buffer_bytes) {
SNDERR("Buffer size is zero");
return -EINVAL;
}
for (i = 1; i <= ARRAY_SIZE(psize_list); i++)
psize_list[i-1] = jack_buffer_bytes * i;
jack->sample_bits = snd_pcm_format_physical_width(format);
if ((err = snd_pcm_ioplug_set_param_list(&jack->io, SND_PCM_IOPLUG_HW_ACCESS,
ARRAY_SIZE(access_list), access_list)) < 0 ||
(err = snd_pcm_ioplug_set_param_list(&jack->io, SND_PCM_IOPLUG_HW_FORMAT,
1, &format)) < 0 ||
(err = snd_pcm_ioplug_set_param_minmax(&jack->io, SND_PCM_IOPLUG_HW_CHANNELS,
jack->num_ports, jack->num_ports)) < 0 ||
(err = snd_pcm_ioplug_set_param_minmax(&jack->io, SND_PCM_IOPLUG_HW_RATE,
rate, rate)) < 0 ||
(err = snd_pcm_ioplug_set_param_list(&jack->io, SND_PCM_IOPLUG_HW_PERIOD_BYTES,
ARRAY_SIZE(psize_list), psize_list)) < 0 ||
(err = snd_pcm_ioplug_set_param_minmax(&jack->io, SND_PCM_IOPLUG_HW_PERIODS,
2, 64)) < 0)
return err;
return 0;
}
static int parse_ports(snd_pcm_jack_t *jack, snd_config_t *conf)
{
snd_config_iterator_t i, next;
snd_pcm_jack_port_list_t **ports = NULL;
unsigned int cnt = 0;
unsigned int channel;
if (conf == NULL)
return 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;
cnt++;
}
jack->port_names = ports = calloc(cnt, sizeof(jack->port_names[0]));
if (ports == NULL)
return -ENOMEM;
jack->num_ports = cnt;
snd_config_for_each(i, next, conf) {
snd_config_t *n = snd_config_iterator_entry(i);
const char *id;
const char *port;
int err;
if (snd_config_get_id(n, &id) < 0)
continue;
channel = atoi(id);
if (snd_config_get_string(n, &port) >= 0) {
err = snd_pcm_jack_port_list_add(jack, channel, port);
if (err < 0)
return err;
} else if (snd_config_get_type(n) == SND_CONFIG_TYPE_COMPOUND) {
snd_config_iterator_t k, next_k;
snd_config_for_each(k, next_k, n) {
snd_config_t *m = snd_config_iterator_entry(k);
if (snd_config_get_string(m, &port) < 0)
continue;
err = snd_pcm_jack_port_list_add(jack, channel,
port);
if (err < 0)
return err;
}
} else {
continue;
}
}
return 0;
}
static int make_nonblock(int fd)
{
int fl;
if ((fl = fcntl(fd, F_GETFL)) < 0)
return fl;
if (fl & O_NONBLOCK)
return 0;
return fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}
static int snd_pcm_jack_open(snd_pcm_t **pcmp, const char *name,
const char *client_name,
snd_config_t *playback_conf,
snd_config_t *capture_conf,
snd_pcm_stream_t stream, int mode)
{
snd_pcm_jack_t *jack;
int err;
int fd[2];
static unsigned int num = 0;
char jack_client_name[32];
assert(pcmp);
jack = calloc(1, sizeof(*jack));
if (!jack)
return -ENOMEM;
jack->fd = -1;
jack->io.poll_fd = -1;
err = parse_ports(jack, stream == SND_PCM_STREAM_PLAYBACK ?
playback_conf : capture_conf);
if (err) {
snd_pcm_jack_free(jack);
return err;
}
if (jack->num_ports == 0) {
SNDERR("define the %s_ports section",
stream == SND_PCM_STREAM_PLAYBACK ? "playback" : "capture");
snd_pcm_jack_free(jack);
return -EINVAL;
}
if (client_name == NULL)
err = snprintf(jack_client_name, sizeof(jack_client_name),
"alsa-jack.%s%s.%d.%d", name,
stream == SND_PCM_STREAM_PLAYBACK ? "P" : "C",
getpid(), num++);
else
err = snprintf(jack_client_name, sizeof(jack_client_name),
"%s", client_name);
if (err >= (int)sizeof(jack_client_name)) {
fprintf(stderr, "%s: WARNING: JACK client name '%s' truncated to %d characters, might not be unique\n",
__func__, jack_client_name, (int)strlen(jack_client_name));
}
jack->client = jack_client_open(jack_client_name, JackNoStartServer, NULL);
if (jack->client == 0) {
snd_pcm_jack_free(jack);
return -ENOENT;
}
jack->areas = calloc(jack->num_ports, sizeof(snd_pcm_channel_area_t));
if (! jack->areas) {
snd_pcm_jack_free(jack);
return -ENOMEM;
}
socketpair(AF_LOCAL, SOCK_STREAM, 0, fd);
make_nonblock(fd[0]);
make_nonblock(fd[1]);
jack->fd = fd[0];
jack->io.version = SND_PCM_IOPLUG_VERSION;
jack->io.name = "ALSA <-> JACK PCM I/O Plugin";
jack->io.callback = &jack_pcm_callback;
jack->io.private_data = jack;
jack->io.poll_fd = fd[1];
jack->io.poll_events = POLLIN;
jack->io.mmap_rw = 1;
#ifdef SND_PCM_IOPLUG_FLAG_BOUNDARY_WA
jack->io.flags = SND_PCM_IOPLUG_FLAG_BOUNDARY_WA;
#else
#warning hw_ptr updates of buffer_size will not be recognized by the ALSA library. Consider to update your ALSA library.
#endif
err = snd_pcm_ioplug_create(&jack->io, name, stream, mode);
if (err < 0) {
snd_pcm_jack_free(jack);
return err;
}
err = jack_set_hw_constraint(jack);
if (err < 0) {
snd_pcm_ioplug_delete(&jack->io);
return err;
}
*pcmp = jack->io.pcm;
return 0;
}
SND_PCM_PLUGIN_DEFINE_FUNC(jack)
{
snd_config_iterator_t i, next;
snd_config_t *playback_conf = NULL;
snd_config_t *capture_conf = NULL;
const char *client_name = NULL;
int err;
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 || strcmp(id, "hint") == 0)
continue;
if (strcmp(id, "name") == 0) {
snd_config_get_string(n, &client_name);
continue;
}
if (strcmp(id, "playback_ports") == 0) {
if (snd_config_get_type(n) != SND_CONFIG_TYPE_COMPOUND) {
SNDERR("Invalid type for %s", id);
return -EINVAL;
}
playback_conf = n;
continue;
}
if (strcmp(id, "capture_ports") == 0) {
if (snd_config_get_type(n) != SND_CONFIG_TYPE_COMPOUND) {
SNDERR("Invalid type for %s", id);
return -EINVAL;
}
capture_conf = n;
continue;
}
SNDERR("Unknown field %s", id);
return -EINVAL;
}
err = snd_pcm_jack_open(pcmp, name, client_name, playback_conf, capture_conf, stream, mode);
return err;
}
SND_PCM_PLUGIN_SYMBOL(jack);