jack.c File Reference

#include <jack/jack.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "audio/audio_capture.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "compat/platform_semaphore.h"
#include "debug.h"
#include "host.h"
#include "jack_common.h"
#include "lib_common.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_capture

Macros
#define	MOD_NAME   "[JACK capture] "

Enumerations
enum	{ MAX_PORTS = 64 }

Functions
static void	audio_cap_jack_done (void *state)
static void	audio_cap_jack_help (const char *client_name)
static void *	audio_cap_jack_init (struct module *parent, const char *cfg)
static void	audio_cap_jack_probe (struct device_info **available_devices, int *count, void(**deleter)(void *))
static struct audio_frame *	audio_cap_jack_read (void *state)
static void	audio_cap_jack_should_exit (void *state)
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, &acap_jack_info, LIBRARY_CLASS_AUDIO_CAPTURE, AUDIO_CAPTURE_ABI_VERSION)

Variables
static const struct audio_capture_info	acap_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 capture] "

Definition at line 54 of file jack.c.

Referenced by attach_input_ports(), audio_cap_jack_init(), audio_play_jack_init(), audio_play_jack_put_frame(), audio_play_jack_query_format(), audio_play_jack_reconfigure(), jack_process_callback(), jack_samplerate_changed_callback(), jack_start(), and reconfigure_send_ch_count().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MAX_PORTS

Definition at line 56 of file jack.c.

     {
        MAX_PORTS = 64,
};

Function Documentation

audio_cap_jack_done()

static void audio_cap_jack_done ( void * state )

static

Definition at line 304 of file jack.c.

{
        struct state_jack_capture *s = (struct state_jack_capture *) state;
 
        unregister_should_exit_callback(s->parent, audio_cap_jack_should_exit,
                                        s);
 
        s->libjack->client_close(s->client);
        free(s->tmp);
        ring_buffer_destroy(s->data);
        free(s->frame.data);
        platform_sem_destroy(&s->data_sem);
        close_libjack(s->libjack);
        free(s);
}

References audio_cap_jack_should_exit(), state_jack_capture::client, libjack_connection::client_close, close_libjack(), audio_frame::data, state_jack_capture::data, state_jack_capture::data_sem, state_jack_capture::frame, state_jack_capture::libjack, state_jack_capture::parent, platform_sem_destroy(), ring_buffer_destroy(), state, state_jack_capture::tmp, and unregister_should_exit_callback().

Here is the call graph for this function:

audio_cap_jack_help()

static void audio_cap_jack_help ( const char * client_name )

static

Definition at line 116 of file jack.c.

{
        int count = 0;
        int i = 0;
        struct device_info *available_devices = audio_jack_probe(client_name, JackPortIsOutput, &count);
 
        printf("Usage:\n");
        printf("\t-s 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");
 
        if(!available_devices)
                return;
 
        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_cap_jack_init().

Here is the call graph for this function:

audio_cap_jack_init()

static void * audio_cap_jack_init ( struct module * parent, const char * cfg )

static

Definition at line 146 of file jack.c.

{
        jack_status_t status;
        const char **ports;
        int i;
        char *client_name;
        const char *source_name = NULL;
 
        client_name = alloca(MAX(strlen(PACKAGE_NAME), strlen(cfg)) + 1);
        strcpy(client_name, PACKAGE_NAME);
 
        struct state_jack_capture *s = (struct state_jack_capture *) calloc(1, sizeof(struct state_jack_capture));
        if(!s) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to allocate memory.\n");
                return NULL;
        }
        s->parent = parent;
        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_cap_jack_help(client_name);
                        free(dup);
                        free(s);
                        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 { // this is the device name
                        source_name = cfg + (item - dup);
                        break;
                }
 
                tmp = NULL;
        }
        free(dup);
        dup = NULL;
 
        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;
        }
 
        ports = s->libjack->get_ports(s->client, source_name, NULL, JackPortIsOutput);
        if(ports == NULL) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to output ports matching \"%s\".\n", source_name);
                goto release_client;
        }
 
        i = 0;
        while(ports[i]) i++;
 
        s->frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
        if (i < s->frame.ch_count) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Requested channel count %d not found (matching pattern %s).\n",
                                s->frame.ch_count, cfg);
                goto release_client;
 
        }
 
        s->frame.bps = 4;
        if (audio_capture_sample_rate) {
                log_msg(LOG_LEVEL_WARNING, "[JACK capture] Ignoring user specified sample rate!\n");
        }
        s->frame.sample_rate = s->libjack->get_sample_rate (s->client);
        s->frame.max_size = s->frame.ch_count * s->frame.bps * s->frame.sample_rate;
        s->frame.data = malloc(s->frame.max_size);
 
        platform_sem_init(&s->data_sem, 0, 0);
 
        s->tmp = malloc(s->frame.max_size);
 
        s->data = ring_buffer_init(s->frame.max_size);
        
        if (s->libjack->set_sample_rate_callback(s->client, jack_samplerate_changed_callback, (void *) s)) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Registring 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;
        }
 
        if (s->libjack->activate(s->client)) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot activate client.\n");
                goto release_client;
        }
 
        {
                int port;
                char name[32];
 
                for(port = 0; port < s->frame.ch_count; port++) {
                        snprintf(name, 32, "capture_%02u", port);
                        s->input_ports[port] = s->libjack->port_register(s->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
                        /* attach ports */
                        if (s->libjack->connect(s->client, ports[port], s->libjack->port_name(s->input_ports[port]))) {
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot connect input ports.\n");
                        }
                }
        }
 
        free(ports);
        register_should_exit_callback(parent, audio_cap_jack_should_exit, s);
 
        s->can_process = true;
 
        return s;
 
release_client:
        s->libjack->client_close(s->client);
error:
        close_libjack(s->libjack);
        free(dup);
        free(s);
        return NULL;
}

References libjack_connection::activate, audio_cap_jack_help(), audio_cap_jack_should_exit(), audio_capture_channels, audio_capture_sample_rate, audio_frame::bps, state_jack_capture::can_process, audio_frame::ch_count, state_jack_capture::client, libjack_connection::client_close, libjack_connection::client_open, close_libjack(), libjack_connection::connect, audio_frame::data, state_jack_capture::data, state_jack_capture::data_sem, DEFAULT_AUDIO_CAPTURE_CHANNELS, state_jack_capture::first_channel, frame, state_jack_capture::frame, libjack_connection::get_ports, libjack_connection::get_sample_rate, INIT_NOERR, state_jack_capture::input_ports, jack_process_callback(), jack_samplerate_changed_callback(), state_jack_capture::libjack, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), MAX, audio_frame::max_size, MOD_NAME, name, open_libjack(), parent, state_jack_capture::parent, platform_sem_init(), libjack_connection::port_name, libjack_connection::port_register, register_should_exit_callback(), ring_buffer_init(), audio_frame::sample_rate, libjack_connection::set_process_callback, libjack_connection::set_sample_rate_callback, state_jack_capture::tmp, and val.

Here is the call graph for this function:

audio_cap_jack_probe()

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

static

Definition at line 110 of file jack.c.

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

References audio_jack_probe(), count, and deleter.

Here is the call graph for this function:

audio_cap_jack_read()

static struct audio_frame * audio_cap_jack_read ( void * state )

static

Definition at line 281 of file jack.c.

{
        struct state_jack_capture *s = (struct state_jack_capture *) state;
 
        platform_sem_wait(&s->data_sem);
 
        int read_avail = ring_get_current_size(s->data);
        s->frame.data_len = ring_buffer_read(s->data, s->frame.data, s->frame.max_size);
        if(read_avail > s->frame.data_len){
                /* We didn't read all available data in ring buffer, so we
                 * increment the semaphore back up, so we don't wait needlessly
                 * on the next call */
                platform_sem_post(&s->data_sem);
        }
 
        float2int((char *) s->frame.data, (char *) s->frame.data, s->frame.max_size);
 
        if(!s->frame.data_len)
                return NULL;
 
        return &s->frame;
}

References audio_frame::data, state_jack_capture::data, audio_frame::data_len, state_jack_capture::data_sem, float2int(), state_jack_capture::frame, audio_frame::max_size, platform_sem_post(), platform_sem_wait(), ring_buffer_read(), ring_get_current_size(), and state.

Here is the call graph for this function:

audio_cap_jack_should_exit()

static void audio_cap_jack_should_exit ( void * state )

static

Definition at line 139 of file jack.c.

{
        struct state_jack_capture *s = state;
        s->should_exit = true;
        platform_sem_post(&s->data_sem);
}

References state_jack_capture::data_sem, platform_sem_post(), state_jack_capture::should_exit, and state.

Referenced by audio_cap_jack_done(), and audio_cap_jack_init().

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 89 of file jack.c.

{
        struct state_jack_capture *s = (struct state_jack_capture *) arg;
        int i;
        int channel_size = nframes * sizeof(int32_t);
 
        if (!s->can_process) {
                return 0;
        }
 
        for (i = 0; i < s->frame.ch_count; ++i) {
                jack_default_audio_sample_t *in = s->libjack->port_get_buffer(s->input_ports[i], nframes);
                mux_channel(s->tmp, (char *) in, sizeof(int32_t), channel_size, s->frame.ch_count, i, 1.0);
        }
 
        ring_buffer_write(s->data, s->tmp, channel_size * s->frame.ch_count);
        platform_sem_post(&s->data_sem);
 
        return 0;
}

References state_jack_capture::can_process, audio_frame::ch_count, state_jack_capture::data, state_jack_capture::data_sem, state_jack_capture::frame, state_jack_capture::input_ports, state_jack_capture::libjack, mux_channel(), platform_sem_post(), libjack_connection::port_get_buffer, ring_buffer_write(), and state_jack_capture::tmp.

Referenced by audio_cap_jack_init(), audio_play_jack_init(), and jack_start().

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 80 of file jack.c.

{
        struct state_jack_capture *s = (struct state_jack_capture *) arg;
 
        s->frame.sample_rate = nframes;
 
        return 0;
}

References state_jack_capture::frame, and audio_frame::sample_rate.

Referenced by audio_cap_jack_init(), audio_play_jack_init(), and jack_start().

REGISTER_MODULE()

REGISTER_MODULE	(	jack	,
		&	acap_jack_info,
		LIBRARY_CLASS_AUDIO_CAPTURE	,
		AUDIO_CAPTURE_ABI_VERSION	)

Variable Documentation

acap_jack_info

const struct audio_capture_info acap_jack_info

static

Initial value:

= {
        audio_cap_jack_probe,
        audio_cap_jack_init,
        audio_cap_jack_read,
        audio_cap_jack_done
}

Definition at line 320 of file jack.c.

                                                        {
        audio_cap_jack_probe,
        audio_cap_jack_init,
        audio_cap_jack_read,
        audio_cap_jack_done
};