jack.c File Reference

#include <jack/jack.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "audio/jack.h"
#include "audio/types.h"
#include "jack_common.h"
#include "pthread.h"
#include "rtp/pbuf.h"
#include "rtp/rtp.h"

Include dependency graph for jack.c:

Go to the source code of this file.

Classes
struct	state_jack

Macros
#define	BUFF_ELEM   (1<<16)
#define	BUFF_SIZE   (BUFF_ELEM * sizeof(float))
#define	CLIENT_NAME   "UltraGrid Transport"
#define	MAX_PORTS   8
#define	MOD_NAME   "[JACK trans.] "

Functions
static int	attach_input_ports (struct state_jack *s)
int	is_jack_receiver (void *state)
int	is_jack_sender (void *state)
int	jack_process_callback (jack_nframes_t nframes, void *arg)
bool	jack_receive (void *state, void *data)
	Receives data from JACK.
int	jack_samplerate_changed_callback (jack_nframes_t nframes, void *arg)
void	jack_send (void *state, struct audio_frame *frame)
void *	jack_start (const char *cfg)
void	reconfigure_send_ch_count (struct state_jack *s, int ch_count)
static int	settings_init (struct state_jack *s, char *cfg)

Detailed Description

Author

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

Todo

It looks like there is no jack_stop()?

Definition in file jack.c.

Macro Definition Documentation

BUFF_ELEM

#define BUFF_ELEM   (1<<16)

Definition at line 57 of file jack.c.

BUFF_SIZE

#define BUFF_SIZE   (BUFF_ELEM * sizeof(float))

Definition at line 58 of file jack.c.

Referenced by jack_process_callback(), jack_receive(), jack_send(), jack_start(), and reconfigure_send_ch_count().

CLIENT_NAME

#define CLIENT_NAME   "UltraGrid Transport"

Definition at line 56 of file jack.c.

Referenced by jack_start().

MAX_PORTS

#define MAX_PORTS   8

Definition at line 59 of file jack.c.

MOD_NAME

#define MOD_NAME   "[JACK trans.] "

Definition at line 60 of file jack.c.

Function Documentation

attach_input_ports()

static int attach_input_ports ( struct state_jack * s )

static

Definition at line 237 of file jack.c.

{
        int i = 0;
        const char **ports;
        if ((ports = s->libjack->get_ports (s->client, s->in_port_pattern, NULL, JackPortIsOutput)) == NULL) {
                 log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot find any ports matching pattern '%s'\n", s->in_port_pattern);
                 return FALSE;
         }
         
         while (ports[i]) ++i;
         if(i < s->record.ch_count) {
                 log_msg(LOG_LEVEL_ERROR, MOD_NAME "Not enought input ports found matching pattern '%s': "
                                 "%d requested, %d found\n", s->in_port_pattern, s->record.ch_count, i);
                 log_msg(LOG_LEVEL_ERROR, MOD_NAME "Reducing port count to %d\n", i);
                 s->record.ch_count = i;
         }
         
         for(i = 0; i < s->in_ch_count; ++i) {
                 if (s->libjack->connect (s->client, ports[i], s->libjack->port_name (s->input_port[i]))) {
                         fprintf (stderr, "cannot connect input ports\n");
                 }
         }
 
         free (ports);
         return TRUE;
}

References audio_frame::ch_count, state_jack::client, libjack_connection::connect, FALSE, libjack_connection::get_ports, state_jack::in_ch_count, state_jack::in_port_pattern, state_jack::input_port, state_jack::libjack, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, libjack_connection::port_name, state_jack::record, and TRUE.

Referenced by jack_start().

Here is the call graph for this function:

is_jack_receiver()

int is_jack_receiver

(

void *

state

)

Definition at line 426 of file jack.c.

{
        return ((struct state_jack *) state)->receiver;
}

References state.

Referenced by audio_start().

is_jack_sender()

int is_jack_sender

(

void *

state

)

Definition at line 421 of file jack.c.

{
        return ((struct state_jack *) state)->sender;
}

References state.

Referenced by audio_start().

jack_process_callback()

static int jack_process_callback	(	jack_nframes_t	nframes,
		void *	arg )

Definition at line 94 of file jack.c.

                                                             {
        struct state_jack *s = (struct state_jack *) arg;
        int send_b;
        int i;
        
        send_b = s->play_buffer_end - s->play_buffer_start;
        if(send_b < 0) send_b += BUFF_SIZE;
        if(send_b > (int) (sizeof (jack_default_audio_sample_t) * nframes))
                send_b = sizeof (jack_default_audio_sample_t) * nframes;
 
        for (i = 0; i < s->out_channel_count; ++i) {
                
                int to_end = BUFF_SIZE - s->play_buffer_start;
                jack_default_audio_sample_t *out =
                        s->libjack->port_get_buffer (s->output_port[i], nframes);
                if(to_end > send_b) {
                        memcpy (out, s->play_buffer[i] + s->play_buffer_start,
                                send_b);
                } else {
                        memcpy (out, s->play_buffer[i] + s->play_buffer_start,
                                to_end);
                        memcpy (out + to_end, s->play_buffer[i],
                                send_b - to_end);
                }
                
        }
        s->play_buffer_start = (s->play_buffer_start + send_b) % BUFF_SIZE;
 
        const float int_max_flt = nexttowardf((float) INT_MAX, INT_MAX); // max int representable as float
        
        for(i = 0; i < s->record.ch_count; ++i) {
                int j;
                jack_default_audio_sample_t *in =
                        s->libjack->port_get_buffer (s->input_port[i], nframes);
                for(j = 0; j < (int) nframes; ++j) {
                        *(int *)(void *)(s->rec_buffer + ((s->rec_buffer_end + (j * s->record.ch_count + i) * sizeof(int32_t)) % BUFF_SIZE)) =
                                        in[j] * int_max_flt;
                }
        }
        s->rec_buffer_end = (s->rec_buffer_end + nframes * s->record.ch_count * sizeof(int32_t)) % BUFF_SIZE;
        
        //fprintf(stderr, ".%d.", nframes);
        
        return 0;
}

References BUFF_SIZE, audio_frame::ch_count, state_jack::input_port, state_jack::libjack, state_jack::out_channel_count, state_jack::output_port, state_jack::play_buffer, state_jack::play_buffer_end, state_jack::play_buffer_start, libjack_connection::port_get_buffer, state_jack::rec_buffer, state_jack::rec_buffer_end, and state_jack::record.

jack_receive()

bool jack_receive	(	void *	state,
		void *	data )

Receives data from JACK.

Parameters

[in]	state	state returned by jack_init()
[out]	data	pbuf_audio_data

Return values

true	if some data are receied
false	if no data were receied

Todo

repair this

Definition at line 387 of file jack.c.

{
        struct state_jack *s = (struct state_jack *) state;
        struct pbuf_audio_data *audio_data = (struct pbuf_audio_data *) data;
        struct audio_frame *buffer = &audio_data->buffer;
        
        while(s->rec_buffer_start == s->rec_buffer_end);
        //fprintf(stderr, "%d ", s->record.data_len);
        int end = s->rec_buffer_end;
             
        buffer->ch_count = s->record.ch_count;
        buffer->bps = s->record.bps;
        buffer->sample_rate = s->record.sample_rate;
        
        buffer->data_len = end - s->rec_buffer_start;
        if (buffer->data_len < 0) buffer->data_len += BUFF_SIZE;
        buffer->data = (char *) malloc(buffer->data_len);
 
        if (s->rec_buffer_start < end) {
                memcpy(buffer->data, s->rec_buffer + s->rec_buffer_start, 
                                buffer->data_len);
        } else {
                memcpy(buffer->data, s->rec_buffer + s->rec_buffer_start, 
                                BUFF_SIZE - s->rec_buffer_start);
                memcpy(buffer->data + BUFF_SIZE - s->rec_buffer_start,
                                s->rec_buffer, 
                                buffer->data_len + BUFF_SIZE - s->rec_buffer_start);
        }
        s->rec_buffer_start = (s->rec_buffer_start + buffer->data_len) % BUFF_SIZE;
 
        return true;
}

References audio_frame::bps, BUFF_SIZE, pbuf_audio_data::buffer, audio_frame::ch_count, audio_frame::data, audio_frame::data_len, state_jack::rec_buffer, state_jack::rec_buffer_end, state_jack::rec_buffer_start, state_jack::record, audio_frame::sample_rate, and state.

Referenced by audio_receiver_thread().

jack_samplerate_changed_callback()

static int jack_samplerate_changed_callback	(	jack_nframes_t	nframes,
		void *	arg )

Definition at line 140 of file jack.c.

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

References state_jack::record, and audio_frame::sample_rate.

jack_send()

void jack_send	(	void *	state,
		struct audio_frame *	frame )

Definition at line 355 of file jack.c.

{
        //float *tmp = (char *) s->play_buffer + s->play_buffer_end;
        struct state_jack *s = (struct state_jack *) state;
        char *in_ptr = frame->data;
        
        int i;
        
        if(s->out_channel_count != frame->ch_count)
                reconfigure_send_ch_count(s, frame->ch_count);
                
        for(i = 0; i < frame->data_len; i+= frame->bps * frame->ch_count) {
                int channels;
                for (channels = 0; channels < s->out_channel_count; ++channels) {
                        float *pos = (float *)(void *) &s->play_buffer[channels][(s->play_buffer_end + i * 4
                                        / (frame->ch_count * frame->bps)) % BUFF_SIZE];
                        *pos = (*((int *)(void *) (in_ptr + channels * frame->bps)) << (32 - frame->bps * 8)) / (float) INT_MAX;
                }
                
                in_ptr += frame->bps * frame->ch_count;
        }
        s->play_buffer_end = (s->play_buffer_end + frame->data_len / (frame->bps * frame->ch_count) * sizeof(float)) % BUFF_SIZE;
}

References BUFF_SIZE, channels, frame, state_jack::out_channel_count, state_jack::play_buffer, state_jack::play_buffer_end, reconfigure_send_ch_count(), and state.

Referenced by audio_sender_thread().

Here is the call graph for this function:

jack_start()

void * jack_start

(

const char *

cfg

)

Definition at line 264 of file jack.c.

{
        struct state_jack *s;
         
        s = (struct state_jack *) malloc(sizeof(struct state_jack));
        assert (s != NULL);
        s->libjack = open_libjack();
        if (s->libjack == NULL) {
                free(s);
                return NULL;
        }
        
        s->in_port_pattern = NULL;
        s->out_port_pattern = NULL;
        s->in_ch_count = 1;
        s->play_buffer_start = s->play_buffer_end = 0;
        s->rec_buffer_start = s->rec_buffer_end = 0;
        s->sender = FALSE;
        s->receiver = FALSE;
        s->out_channel_count = 0;
        
        char *cfg_copy = strdup(cfg);
        int ret = settings_init(s, cfg_copy);
        free(cfg_copy);
        if (ret != 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Setting JACK failed. Check configuration ('-j' option).\n");
                goto error;
        }
        
        if(!s->sender && !s->receiver) {
                goto error;
        }
        
        s->client = s->libjack->client_open(CLIENT_NAME, JackNullOption, NULL);
        if(s->libjack->set_process_callback(s->client, jack_process_callback, (void *) s)  != 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Callback initialization problem.\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 "Sample rate callback initialization problem.\n");
                        goto error;
        }
        
        //jack_on_shutdown (client, jack_shutdown, 0);
        
        if(s->sender) {
                char name[30];
                int i;
                
                for(i = 0; i < MAX_PORTS; ++i) {
                        snprintf(name, 30, "out_%02u", i);
                        s->output_port[i] = s->libjack->port_register (s->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
                }
                
                s->out_channel_count = s->out_channel_count_req = 0;
        }
        
        if(s->receiver) {
                char name[30];
                int i;
                
                for(i = 0; i < s->in_ch_count; ++i) {
                        snprintf(name, 30, "in_%02u", i);
                        s->input_port[i] = s->libjack->port_register (s->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
                }
                
                s->record.sample_rate = s->libjack->get_sample_rate (s->client);
                s->record.bps = sizeof(int32_t);
                s->record.ch_count = s->in_ch_count;
                s->rec_buffer = s->record.data = (void *) malloc(BUFF_SIZE);
        }
        
        if (s->libjack->activate (s->client)) {
                 fprintf (stderr, "cannot activate client");
                 goto error;
        }
         
        if(s->receiver) {
                if(!attach_input_ports(s))
                        goto error;
         }
        
        return s;
error:
        close_libjack(s->libjack);
        free(s);
        return NULL;
}

References libjack_connection::activate, attach_input_ports(), audio_frame::bps, BUFF_SIZE, audio_frame::ch_count, state_jack::client, CLIENT_NAME, libjack_connection::client_open, close_libjack(), audio_frame::data, FALSE, libjack_connection::get_sample_rate, state_jack::in_ch_count, state_jack::in_port_pattern, state_jack::input_port, jack_process_callback(), jack_samplerate_changed_callback(), state_jack::libjack, LOG_LEVEL_ERROR, log_msg(), MAX_PORTS, MOD_NAME, name, open_libjack(), state_jack::out_channel_count, state_jack::out_channel_count_req, state_jack::out_port_pattern, state_jack::output_port, state_jack::play_buffer_end, state_jack::play_buffer_start, libjack_connection::port_register, state_jack::rec_buffer, state_jack::rec_buffer_end, state_jack::rec_buffer_start, state_jack::receiver, state_jack::record, audio_frame::sample_rate, state_jack::sender, libjack_connection::set_process_callback, libjack_connection::set_sample_rate_callback, and settings_init().

Referenced by audio_start().

Here is the call graph for this function:

reconfigure_send_ch_count()

void reconfigure_send_ch_count	(	struct state_jack *	s,
		int	ch_count )

Definition at line 147 of file jack.c.

{
        const char **ports;
        int i;
 
        s->out_channel_count = s->out_channel_count_req = ch_count;
 
        if ((ports = s->libjack->get_ports (s->client, s->out_port_pattern, NULL, JackPortIsInput)) == NULL) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot find any ports matching pattern '%s'\n", s->out_port_pattern);
                s->out_channel_count = 0;
                return;
        }
        for (i = 0; i < s->record.ch_count; ++i) {
                s->libjack->disconnect(s->client, s->libjack->port_name (s->output_port[i]), ports[i]);
                free(s->play_buffer[i]);
        }
 
        i = 0;
        while (ports[i]) ++i;
 
        if(i < s->out_channel_count) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Not enought output ports found matching pattern '%s': "
                                "%d requested, %d found\n", s->out_port_pattern, s->record.ch_count, i);
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Reducing port count to %d\n", i);
                s->out_channel_count = i;
        }
         
        for(i = 0; i < s->out_channel_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 ports: %s\n", ports[i]);
                }
                s->play_buffer[i] = malloc(BUFF_SIZE);
        }
        
        log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Sending %d output audio streams (ports).\n", s->out_channel_count);
 
        free (ports);
}

References BUFF_SIZE, audio_frame::ch_count, state_jack::client, libjack_connection::connect, libjack_connection::disconnect, libjack_connection::get_ports, state_jack::libjack, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, state_jack::out_channel_count, state_jack::out_channel_count_req, state_jack::out_port_pattern, state_jack::output_port, state_jack::play_buffer, libjack_connection::port_name, and state_jack::record.

Referenced by jack_send().

Here is the call graph for this function:

settings_init()

static int settings_init ( struct state_jack * s, char * cfg )

static

Definition at line 186 of file jack.c.

{
        char * save_ptr = NULL,
                *tok;
 
        if (!cfg || cfg[0] == '\0' || strncmp(cfg, "help", strlen("help")) == 0)
        {
                printf("JACK config:\n"
                        "\t--audio-protocol JACK:({tok1|tok2...tokn-1},)*{tokn}\n\n"
                        "\tTokens:\n"
                        "\t\tpi[=<name>]\t\treceive sound from JACK instead of from RTP (optionally select port)\n"
                        "\n"
                        "\t\tpo[=<name>]\t\tsend sound output via JACK with (optional) port name.\n"
                        "\t\t\t\t\tIf name not specified, let Jack select (probably system output!)\n"
                        "\n"
                        "\t\tch=<count>\t\tcount of input (!) JACK ports to listen at (matching RE above)\n"
                        "\t\t\t\t\tYou should set it for input, otherwise the count defaults to 0.\n"
                        );
                exit(0);
        }
        while((tok = strtok_r(cfg, ",", &save_ptr)) != NULL)
        {
                switch (tok[0]) {
                        case 'p':
                                if(tok[1] != 'i' && tok[1] != 'o')
                                        return -1;
                                if(tok[1] == 'i') {
                                        s->receiver = TRUE;
                                        if(tok[2] == '=')
                                                s->in_port_pattern = strdup(&tok[3]);
                                }
                                if(tok[1] == 'o') {
                                        s->sender = TRUE;
                                        if(tok[2] == '=')
                                                s->out_port_pattern = strdup(&tok[3]);
                                }
                                break;
                        case 'c':
                                if(strncmp(tok, "ch=", 3))
                                        return -1;
                                else
                                        s->in_ch_count = atoi(tok + 3);
                                break;        
                        default:
                                return -1;
                }
                cfg = NULL;
        }
        return 0;
}

References state_jack::in_ch_count, state_jack::in_port_pattern, state_jack::out_port_pattern, state_jack::receiver, state_jack::sender, and TRUE.

Referenced by display_decklink_init(), and jack_start().