jack.c File Reference

#include <jack/jack.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "audio/audio_playback.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "debug.h"
#include "host.h"
#include "jack_common.h"
#include "lib_common.h"
#include "utils/audio_buffer.h"
#include "utils/macros.h"
#include "utils/ring_buffer.h"

Include dependency graph for jack.c:

Go to the source code of this file.

Classes
struct	state_jack_playback

Macros
#define	MOD_NAME   "[JACK playback] "

Enumerations
enum	{ DEFAULT_AUDIO_BUF_LEN_MS = 50 , MAX_LEN_MS = 1000 , MAX_PORTS = 64 }

Functions
static bool	audio_play_jack_ctl (void *state, int request, void *data, size_t *len)
static void	audio_play_jack_done (void *state)
static void	audio_play_jack_help (const char *client_name)
static void *	audio_play_jack_init (const char *cfg)
static void	audio_play_jack_probe (struct device_info **available_devices, int *count, void(**deleter)(void *))
static void	audio_play_jack_put_frame (void *state, const struct audio_frame *frame)
static bool	audio_play_jack_query_format (struct state_jack_playback *s, void *data, size_t *len)
static bool	audio_play_jack_reconfigure (void *state, struct audio_desc desc)
static int	jack_process_callback (jack_nframes_t nframes, void *arg)
static int	jack_samplerate_changed_callback (jack_nframes_t nframes, void *arg)
	REGISTER_MODULE (jack, &aplay_jack_info, LIBRARY_CLASS_AUDIO_PLAYBACK, AUDIO_PLAYBACK_ABI_VERSION)

Variables
static const struct audio_playback_info	aplay_jack_info

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file jack.c.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[JACK playback] "

Definition at line 54 of file jack.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
DEFAULT_AUDIO_BUF_LEN_MS
MAX_LEN_MS
MAX_PORTS

Definition at line 56 of file jack.c.

     {
        DEFAULT_AUDIO_BUF_LEN_MS = 50,
        MAX_LEN_MS               = 1000,
        MAX_PORTS                = 64,
};

Function Documentation

audio_play_jack_ctl()

static bool audio_play_jack_ctl ( void * state, int request, void * data, size_t * len )

static

Definition at line 282 of file jack.c.

{
        struct state_jack_playback *s = (struct state_jack_playback *) state;
 
        switch (request) {
        case AUDIO_PLAYBACK_CTL_QUERY_FORMAT:
                return audio_play_jack_query_format(s, data, len);
        default:
                return false;
        }
}

References audio_play_jack_query_format(), AUDIO_PLAYBACK_CTL_QUERY_FORMAT, state_jack_playback::data, len, and state.

Here is the call graph for this function:

audio_play_jack_done()

static void audio_play_jack_done ( void * state )

static

Definition at line 385 of file jack.c.

{
        struct state_jack_playback *s = (struct state_jack_playback *) state;
 
        s->libjack->client_close(s->client);
        free(s->tmp);
        free(s->converted);
        free(s->jack_ports_pattern);
        if (s->buffer_fns) {
                s->buffer_fns->destroy(s->data);
        }
 
        close_libjack(s->libjack);
 
        free(s);
}

References state_jack_playback::buffer_fns, state_jack_playback::client, libjack_connection::client_close, close_libjack(), state_jack_playback::converted, state_jack_playback::data, audio_buffer_api::destroy, state_jack_playback::jack_ports_pattern, state_jack_playback::libjack, state, and state_jack_playback::tmp.

Here is the call graph for this function:

audio_play_jack_help()

static void audio_play_jack_help ( const char * client_name )

static

Definition at line 132 of file jack.c.

{
        int count = 0;
        int i = 0;
        struct device_info *available_devices = audio_jack_probe(client_name, JackPortIsInput, &count);
        if(!available_devices)
                return;
 
        printf("Usage:\n");
        printf("\t-r jack[:first_channel=<f>][:name=<n>][:<device>]\n");
        printf("\twhere\n");
        printf("\t\t<f> - index of first channel to capture (default: 0)\n");
        printf("\t\t<n> - name of the JACK client (default: %s)\n", PACKAGE_NAME);
        printf("\n");
 
        printf("Available devices:\n");
        for(i = 0; i < count; i++){
                printf("\t%s\n", available_devices[i].name);
        }
        free(available_devices);
}

References audio_jack_probe(), count, and name.

Referenced by audio_play_jack_init().

Here is the call graph for this function:

audio_play_jack_init()

static void * audio_play_jack_init ( const char * cfg )

static

Definition at line 154 of file jack.c.

{
        struct state_jack_playback *s;
        const char **ports;
        jack_status_t status;
        char *client_name;
        const char *source_name = "";
 
        client_name = alloca(MAX(strlen(PACKAGE_NAME), strlen(cfg)) + 1);
        strcpy(client_name, PACKAGE_NAME);
 
        s = calloc(1, sizeof(struct state_jack_playback));
        if(!s) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to allocate memory.\n");
                return NULL;
        }
 
        s->libjack = open_libjack();
        if (s->libjack == NULL) {
                free(s);
                return NULL;
        }
 
        char *dup = strdup(cfg);
        assert(dup != NULL);
        char *tmp = dup, *item, *save_ptr;
        while ((item = strtok_r(tmp, ":", &save_ptr)) != NULL) {
                if (strcmp(item, "help") == 0) {
                        audio_play_jack_help(client_name);
                        free(s);
                        free(dup);
                        return INIT_NOERR;
                } else if (strstr(item, "first_channel=") == item) {
                        char *endptr;
                        char *val = item + strlen("first_channel=");
                        errno = 0;
                        s->first_channel = strtol(val, &endptr, 0);
                        if (errno == ERANGE || *endptr != '\0' || s->first_channel < 0) {
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Wrong value '%s'.\n", val);
                                goto error;
                        }
                } else if (strstr(item, "name=") == item) {
                        strcpy(client_name, item + strlen("name="));
                } else { // the rest is the device name
                        source_name = cfg + (item - dup);
                        break;
                }
                tmp = NULL;
        }
        free(dup);
        dup = NULL;
 
        s->jack_ports_pattern = strdup(source_name);
 
        s->client = s->libjack->client_open(client_name, JackNullOption, &status);
        if(status & JackFailure) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Opening JACK client failed.\n");
                goto error;
        }
 
        if (s->libjack->set_sample_rate_callback(s->client, jack_samplerate_changed_callback, (void *) s)) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Registering callback problem.\n");
                goto release_client;
        }
 
 
        if (s->libjack->set_process_callback(s->client, jack_process_callback, (void *) s) != 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Process callback registration problem.\n");
                goto release_client;
        }
 
        s->jack_sample_rate = s->libjack->get_sample_rate (s->client);
        log_msg(LOG_LEVEL_INFO, "JACK sample rate: %d\n", s->jack_sample_rate);
 
 
        ports = s->libjack->get_ports(s->client, s->jack_ports_pattern, NULL, JackPortIsInput);
        if(ports == NULL) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to input ports matching %s.\n", s->jack_ports_pattern);
                goto release_client;
        }
 
        s->jack_ports_count = 0;
        while(ports[s->jack_ports_count]) s->jack_ports_count++;
        free(ports);
 
        {
                char name[30];
                int i;
                
                for(i = 0; i < MAX_PORTS; ++i) {
                        snprintf(name, 30, "playback_%02u", i);
                        s->output_port[i] = s->libjack->port_register (s->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
                }
        }
                
 
        return s;
 
release_client:
        s->libjack->client_close(s->client);
error:
        close_libjack(s->libjack);
        free(dup);
        free(s);
        return NULL;
}

References audio_play_jack_help(), state_jack_playback::client, libjack_connection::client_close, libjack_connection::client_open, close_libjack(), state_jack_playback::first_channel, libjack_connection::get_ports, libjack_connection::get_sample_rate, INIT_NOERR, state_jack_playback::jack_ports_count, state_jack_playback::jack_ports_pattern, jack_process_callback(), state_jack_playback::jack_sample_rate, jack_samplerate_changed_callback(), state_jack_playback::libjack, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, log_msg(), MAX, MAX_PORTS, MOD_NAME, name, open_libjack(), state_jack_playback::output_port, libjack_connection::port_register, libjack_connection::set_process_callback, libjack_connection::set_sample_rate_callback, state_jack_playback::tmp, and val.

Here is the call graph for this function:

audio_play_jack_probe()

static void audio_play_jack_probe ( struct device_info ** available_devices, int * count, void(** deleter )(void *) )

static

Definition at line 126 of file jack.c.

{
        *deleter = free;
        *available_devices = audio_jack_probe(PACKAGE_STRING, JackPortIsInput, count);
}

References audio_jack_probe(), count, and deleter.

Here is the call graph for this function:

audio_play_jack_put_frame()

static void audio_play_jack_put_frame ( void * state, const struct audio_frame * frame )

static

Definition at line 370 of file jack.c.

{
        struct state_jack_playback *s = (struct state_jack_playback *) state;
        assert(frame->bps == 4);
        int len = frame->data_len;
 
        if (len >= s->max_channel_len * frame->ch_count) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Long frame: %d!\n", frame->data_len);
                len = s->max_channel_len * frame->ch_count;
        }
 
        int2float((char *) s->converted, frame->data, len);
        s->buffer_fns->write(s->data, (char *) s->converted, len);
}

References state_jack_playback::buffer_fns, state_jack_playback::converted, state_jack_playback::data, frame, int2float(), len, LOG_LEVEL_WARNING, log_msg(), state_jack_playback::max_channel_len, MOD_NAME, state, and audio_buffer_api::write.

Here is the call graph for this function:

audio_play_jack_query_format()

static bool audio_play_jack_query_format ( struct state_jack_playback * s, void * data, size_t * len )

static

Definition at line 261 of file jack.c.

{
        struct audio_desc desc;
        if (*len < sizeof desc) {
                return false;
        } else {
                memcpy(&desc, data, sizeof desc);
        }
 
        if (s->jack_sample_rate <= 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Wrong JACK sample rate detected: %d!",
                                s->jack_sample_rate);
                return false;
        }
        desc = (struct audio_desc){4, s->jack_sample_rate, MIN(s->jack_ports_count, desc.ch_count), AC_PCM};
 
        memcpy(data, &desc, sizeof desc);
        *len = sizeof desc;
        return true;
}

References AC_PCM, desc, state_jack_playback::jack_ports_count, state_jack_playback::jack_sample_rate, len, LOG_LEVEL_ERROR, log_msg(), MIN, and MOD_NAME.

Referenced by audio_play_jack_ctl().

Here is the call graph for this function:

audio_play_jack_reconfigure()

static bool audio_play_jack_reconfigure ( void * state, struct audio_desc desc )

static

Definition at line 294 of file jack.c.

{
        struct state_jack_playback *s = (struct state_jack_playback *) state;
        const char **ports;
        int i;
 
        assert(desc.bps == 4 && desc.sample_rate == s->jack_sample_rate && desc.codec == AC_PCM);
 
        s->libjack->deactivate(s->client);
 
        ports = s->libjack->get_ports(s->client, s->jack_ports_pattern, NULL, JackPortIsInput);
        if(ports == NULL) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to input ports matching %s.\n", s->jack_ports_pattern);
                return false;
        }
 
        if(desc.ch_count > s->jack_ports_count) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: received %d audio channels, JACK can process only %d.", desc.ch_count, s->jack_ports_count);
        }
 
        if (s->buffer_fns) {
                s->buffer_fns->destroy(s->data);
                s->buffer_fns = NULL;
                s->data = NULL;
        }
 
        {
                int buf_len_ms = DEFAULT_AUDIO_BUF_LEN_MS;
                if (get_commandline_param("low-latency-audio")) {
                        buf_len_ms = 5;
                }
                if (get_commandline_param("audio-buffer-len")) {
                        buf_len_ms = atoi(get_commandline_param("audio-buffer-len"));
                        assert(buf_len_ms > 0 && buf_len_ms < MAX_LEN_MS);
                }
                if (get_commandline_param("audio-disable-adaptive-buffer")) {
                        int buf_len = desc.bps * desc.ch_count * (desc.sample_rate * buf_len_ms / 1000);
                        s->data = ring_buffer_init(buf_len);
                        s->buffer_fns = &ring_buffer_fns;
                } else {
                        s->data = audio_buffer_init(desc.sample_rate, desc.bps, desc.ch_count, buf_len_ms);
                        s->buffer_fns = &audio_buffer_fns;
                }
        }
 
        /* for all channels previously connected */
        for(i = 0; i < desc.ch_count; ++i) {
                s->libjack->disconnect(s->client, s->libjack->port_name (s->output_port[i]), ports[i]);
                log_msg(LOG_LEVEL_INFO, MOD_NAME "Port %d: %s\n", i, ports[i]);
        }
        free(s->tmp);
        free(s->converted);
        s->desc.bps = desc.bps;
        s->desc.ch_count = desc.ch_count;
        s->desc.sample_rate = desc.sample_rate;
 
        s->max_channel_len = (desc.sample_rate / 1000) * MAX_LEN_MS * sizeof(float);
        s->tmp = malloc(s->max_channel_len);
        s->converted = malloc(desc.ch_count * s->max_channel_len);
 
        if (s->libjack->activate(s->client)) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot activate client.\n");
                return false;
        }
 
        for(i = 0; i < desc.ch_count; ++i) {
                if (s->libjack->connect (s->client, s->libjack->port_name (s->output_port[i]), ports[i])) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot connect output port: %d.\n", i);
                        return false;
                }
        }
        free(ports);
 
        return true;
}

References AC_PCM, libjack_connection::activate, audio_buffer_fns, audio_buffer_init(), audio_desc::bps, state_jack_playback::buffer_fns, audio_desc::ch_count, state_jack_playback::client, libjack_connection::connect, state_jack_playback::converted, state_jack_playback::data, libjack_connection::deactivate, DEFAULT_AUDIO_BUF_LEN_MS, desc, state_jack_playback::desc, audio_buffer_api::destroy, libjack_connection::disconnect, get_commandline_param(), libjack_connection::get_ports, state_jack_playback::jack_ports_count, state_jack_playback::jack_ports_pattern, state_jack_playback::jack_sample_rate, state_jack_playback::libjack, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), state_jack_playback::max_channel_len, MAX_LEN_MS, MOD_NAME, state_jack_playback::output_port, libjack_connection::port_name, ring_buffer_fns, ring_buffer_init(), audio_desc::sample_rate, state, and state_jack_playback::tmp.

Here is the call graph for this function:

jack_process_callback()

static int jack_process_callback ( jack_nframes_t nframes, void * arg )

static

Definition at line 103 of file jack.c.

{
        struct state_jack_playback *s = (struct state_jack_playback *) arg;
        int len;
        int req_len = s->desc.ch_count * nframes * sizeof(float);
        int nframes_available = nframes;
 
        len = s->buffer_fns->read(s->data, s->tmp, req_len);
        if (len != req_len) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Buffer underflow detected.\n");
                nframes_available = len / s->desc.ch_count / sizeof(float);
        }
 
        for (int i = 0; i < s->desc.ch_count; ++i) {
                jack_default_audio_sample_t *out =
                        s->libjack->port_get_buffer (s->output_port[i], nframes_available);
                assert(out != NULL);
                demux_channel((char *) out, s->tmp, sizeof(float), len, s->desc.ch_count, i);
        }
 
        return 0;
}

References state_jack_playback::buffer_fns, audio_desc::ch_count, state_jack_playback::data, demux_channel(), state_jack_playback::desc, len, state_jack_playback::libjack, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, state_jack_playback::output_port, libjack_connection::port_get_buffer, audio_buffer_api::read, and state_jack_playback::tmp.

Here is the call graph for this function:

jack_samplerate_changed_callback()

static int jack_samplerate_changed_callback ( jack_nframes_t nframes, void * arg )

static

Definition at line 84 of file jack.c.

{
        struct state_jack_playback *s = (struct state_jack_playback *) arg;
 
        if (s->jack_sample_rate != 0) {
                bug_msg(LOG_LEVEL_WARNING, "JACK sample rate changed from %d to %d. "
                                "Runtime change is not supported in UG and will likely "
                                "cause malfunctioning. ",
                                s->jack_sample_rate, nframes);
        } else {
                log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Sample rate changed to: %d\n",
                                nframes);
        }
 
        s->jack_sample_rate = nframes;
 
        return 0;
}

References bug_msg(), state_jack_playback::jack_sample_rate, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, log_msg(), and MOD_NAME.

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	jack	,
		&	aplay_jack_info,
		LIBRARY_CLASS_AUDIO_PLAYBACK	,
		AUDIO_PLAYBACK_ABI_VERSION	)

Variable Documentation

aplay_jack_info

const struct audio_playback_info aplay_jack_info

static

Initial value:

= {
        audio_play_jack_probe,
        audio_play_jack_init,
        audio_play_jack_put_frame,
        audio_play_jack_ctl,
        audio_play_jack_reconfigure,
        audio_play_jack_done
}

Definition at line 402 of file jack.c.

                                                          {
        audio_play_jack_probe,
        audio_play_jack_init,
        audio_play_jack_put_frame,
        audio_play_jack_ctl,
        audio_play_jack_reconfigure,
        audio_play_jack_done
};