diff --git a/audio_jack.c b/audio_jack.c index c8a8b9ee..7b00d1d2 100644 --- a/audio_jack.c +++ b/audio_jack.c @@ -1,6 +1,7 @@ /* * jack output driver. This file is part of Shairport Sync. - * Copyright (c) 2018 Mike Brady + * Copyright (c) 2019 Mike Brady , + * Jörn Nettingsmeier * * All rights reserved. * @@ -19,41 +20,28 @@ #include "audio.h" #include "common.h" -#include -#include -#include -#include -#include -#include #include +#include +#include +#include #include -#include #include -#include - -enum ift_type { - IFT_frame_left_sample = 0, - IFT_frame_right_sample, -} ift_type; +#include +// Two-channel, 16bit audio: +static const int bytes_per_frame = 4; // Four seconds buffer -- should be plenty -#define buffer_size 44100 * 4 * 2 * 2 +#define buffer_size (44100 * 4 * bytes_per_frame) static pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t client_mutex = PTHREAD_MUTEX_INITIALIZER; -char *audio_lmb, *audio_umb, *audio_toq, *audio_eoq; -size_t audio_occupancy; // this is in frames, not bytes. A frame is a left and - // right sample, each 16 bits, hence 4 bytes -pthread_t *open_client_if_necessary_thread = NULL; - int jack_init(int, char **); void jack_deinit(void); void jack_start(int, int); int play(void *, int); void jack_stop(void); -int jack_is_running(void); int jack_delay(long *); void jack_flush(void); @@ -62,8 +50,8 @@ audio_output audio_jack = {.name = "jack", .init = &jack_init, .deinit = &jack_deinit, .start = &jack_start, - .stop = &jack_stop, - .is_running = &jack_is_running, + .stop = NULL, + .is_running = NULL, .flush = &jack_flush, .delay = &jack_delay, .play = &play, @@ -71,366 +59,291 @@ audio_output audio_jack = {.name = "jack", .parameters = NULL, .mute = NULL}; -jack_port_t *left_port; -jack_port_t *right_port; +// This also affects deinterlacing. +// So make it exactly the number of incoming audio channels! +#define NPORTS 2 +static jack_port_t *port[NPORTS]; +static const char* port_name[NPORTS] = { "out_L", "out_R" }; -long offset = 0; +static jack_client_t *client; +static jack_nframes_t sample_rate; +static jack_nframes_t jack_latency; -int client_is_open; -jack_client_t *client; -jack_nframes_t sample_rate; -jack_nframes_t jack_latency; +static jack_ringbuffer_t *jackbuf; +static int flush_please = 0; -jack_latency_range_t latest_left_latency_range, latest_right_latency_range; -int64_t time_of_latest_transfer; +static jack_latency_range_t latest_latency_range[NPORTS]; +static int64_t time_of_latest_transfer; -int play(void *buf, int samples) { - // debug(1,"jack_play of %d samples.",samples); - // copy the samples into the queue - size_t bytes_to_transfer = samples * 2 * 2; - size_t space_to_end_of_buffer = audio_umb - audio_eoq; - if (space_to_end_of_buffer >= bytes_to_transfer) { - memcpy(audio_eoq, buf, bytes_to_transfer); - pthread_mutex_lock(&buffer_mutex); - audio_occupancy += samples; - audio_eoq += bytes_to_transfer; - pthread_mutex_unlock(&buffer_mutex); - } else { - memcpy(audio_eoq, buf, space_to_end_of_buffer); - buf += space_to_end_of_buffer; - memcpy(audio_lmb, buf, bytes_to_transfer - space_to_end_of_buffer); - pthread_mutex_lock(&buffer_mutex); - audio_occupancy += samples; - audio_eoq = audio_lmb + bytes_to_transfer - space_to_end_of_buffer; - pthread_mutex_unlock(&buffer_mutex); - } - return 0; + +static inline jack_default_audio_sample_t sample_conv(short sample) { + // It sounds correct, but I don't understand it. + // Zero int needs to be zero float. Check. + // Plus 32767 int is 1.0. Check. + // Minus 32767 int is -0.99997. And here my brain shuts down. + // In my head, it should be 1.0, and we should tolerate an overflow + // at minus 32768. But I'm sure there's a textbook explanation somewhere. + return ((sample < 0) ? (-1.0 * sample / SHRT_MIN) : (1.0 * sample / SHRT_MAX)); } -void deinterleave_and_convert_stream(const char *interleaved_frames, - const jack_default_audio_sample_t *jack_frame_buffer, - jack_nframes_t number_of_frames, enum ift_type side) { - jack_nframes_t i; - short *ifp = (short *)interleaved_frames; - jack_default_audio_sample_t *fp = (jack_default_audio_sample_t *)jack_frame_buffer; - if (side == IFT_frame_right_sample) - ifp++; - for (i = 0; i < number_of_frames; i++) { - short sample = *ifp; - jack_default_audio_sample_t converted_value; - if (sample >= 0) - converted_value = (1.0 * sample) / SHRT_MAX; - else - converted_value = -(1.0 * sample) / SHRT_MIN; - *fp = converted_value; - ifp++; - ifp++; - fp++; - } -} - -int jack_stream_write_cb(jack_nframes_t nframes, __attribute__((unused)) void *arg) { - - jack_default_audio_sample_t *left_buffer = - (jack_default_audio_sample_t *)jack_port_get_buffer(left_port, nframes); - jack_default_audio_sample_t *right_buffer = - (jack_default_audio_sample_t *)jack_port_get_buffer(right_port, nframes); - - size_t frames_we_can_transfer = nframes; - // lock - pthread_mutex_lock(&buffer_mutex); - if (audio_occupancy < frames_we_can_transfer) { - frames_we_can_transfer = audio_occupancy; - // This means we effectively have underflow from the Shairport Sync source. - // In fact, it may be that there is nothing at all coming from the source, - // but the Shairport Sync client is open and active, so it must continue to output something. - } - - if (frames_we_can_transfer * 2 * 2 <= (size_t)(audio_umb - audio_toq)) { - // the bytes are all in a row in the audio buffer - deinterleave_and_convert_stream(audio_toq, &left_buffer[0], frames_we_can_transfer, - IFT_frame_left_sample); - deinterleave_and_convert_stream(audio_toq, &right_buffer[0], frames_we_can_transfer, - IFT_frame_right_sample); - audio_toq += frames_we_can_transfer * 2 * 2; - } else { - // the bytes are in two places in the audio buffer - size_t first_portion_to_write = (audio_umb - audio_toq) / (2 * 2); - if (first_portion_to_write != 0) { - deinterleave_and_convert_stream(audio_toq, &left_buffer[0], first_portion_to_write, - IFT_frame_left_sample); - deinterleave_and_convert_stream(audio_toq, &right_buffer[0], first_portion_to_write, - IFT_frame_right_sample); +static void deinterleave_and_convert(const char *interleaved_input_buffer, + jack_default_audio_sample_t* jack_output_buffer[], + jack_nframes_t offset, + jack_nframes_t nframes) { + jack_nframes_t f; + // We're dealing with 16bit audio here: + short *ifp = (short *)interleaved_input_buffer; + // Zero-copy, we're working directly on the target and destination buffers, + // so deal with an offset for the second part of the input ringbuffer + for (f = offset; f < (nframes + offset); f++) { + for (int i = 0; i < NPORTS; i++) { + jack_output_buffer[i][f] = sample_conv(*ifp++); } - deinterleave_and_convert_stream(audio_lmb, &left_buffer[first_portion_to_write], - frames_we_can_transfer - first_portion_to_write, - IFT_frame_left_sample); - deinterleave_and_convert_stream(audio_lmb, &right_buffer[first_portion_to_write], - frames_we_can_transfer - first_portion_to_write, - IFT_frame_right_sample); - audio_toq = audio_lmb + (frames_we_can_transfer - first_portion_to_write) * 2 * 2; - } - // debug(1,"transferring %u frames",frames_we_can_transfer); - audio_occupancy -= frames_we_can_transfer; - jack_port_get_latency_range(left_port, JackPlaybackLatency, &latest_left_latency_range); - jack_port_get_latency_range(right_port, JackPlaybackLatency, &latest_right_latency_range); - time_of_latest_transfer = get_absolute_time_in_fp(); - pthread_mutex_unlock(&buffer_mutex); - // unlock - - // now, if there are any more frames to put into the buffer, fill them with - // silence - jack_nframes_t i; - for (i = frames_we_can_transfer; i < nframes; i++) { - left_buffer[i] = 0.0; - right_buffer[i] = 0.0; - } - return 0; -} - -void default_jack_error_callback(const char *desc) { debug(2, "jackd error: \"%s\"", desc); } - -void default_jack_info_callback(const char *desc) { inform("jackd information: \"%s\"", desc); } - -void default_jack_set_latency_callback(jack_latency_callback_mode_t mode, - __attribute__((unused)) void *arg) { - if (mode == JackPlaybackLatency) { - jack_latency_range_t left_latency_range, right_latency_range; - jack_port_get_latency_range(left_port, JackPlaybackLatency, &left_latency_range); - jack_port_get_latency_range(right_port, JackPlaybackLatency, &right_latency_range); - - jack_nframes_t b_latency = (left_latency_range.min + left_latency_range.max) / 2; - if (b_latency == 0) - b_latency = (right_latency_range.min + right_latency_range.max) / 2; - // jack_latency = b_latency; // actually, we are not interested in the latency of the jack - // devices connected... - jack_latency = 0; - debug(1, "playback latency callback: %" PRIu32 ".", jack_latency); } } -int jack_is_running() { - int reply = -1; // meaning jack is not running - // if the client is open and initialised, see if the status is "rolling" - if (client_is_open) { +// This is the JACK process callback. We don't decide when it runs. +// It must be hard-realtime safe (i.e. fully deterministic, with constant CPU +// usage. No calls to anything that could ever block: no syscalls, no screen +// output, no file access, no mutexes... +// The JACK ringbuffer we use to get the data in here is explicitly lock-free. +static int process(jack_nframes_t nframes, __attribute__((unused)) void *arg) { + jack_default_audio_sample_t *buffer[NPORTS]; + // Expect an array of two elements because of possible ringbuffer wrap-around: + jack_ringbuffer_data_t v[2] = { 0 }; + jack_nframes_t i, thisbuf; + int frames_written = 0; + int frames_required = 0; - // check if the ports have a zero latency -- if they both have, then it's disconnected. - - jack_latency_range_t left_latency_range, right_latency_range; - jack_port_get_latency_range(left_port, JackPlaybackLatency, &left_latency_range); - jack_port_get_latency_range(right_port, JackPlaybackLatency, &right_latency_range); - - // if ((left_latency_range.min == 0) && (left_latency_range.max == 0) && - // (right_latency_range.min == 0) && (right_latency_range.max == 0)) { - // reply = -2; // meaning Shairport Sync is not connected - // } else { - reply = 0; // meaning jack is open and Shairport Sync is connected to it - // } + for (i = 0; i < NPORTS; i++) { + buffer[i] = (jack_default_audio_sample_t *)jack_port_get_buffer(port[i], nframes); } - return reply; -} - -int jack_client_open_if_needed(void) { - pthread_mutex_lock(&client_mutex); - if (client_is_open == 0) { - jack_status_t status; - client = jack_client_open(config.jack_client_name, JackNoStartServer, &status); - if (client) { - jack_set_process_callback(client, jack_stream_write_cb, 0); - left_port = jack_port_register(client, config.jack_left_channel_name, JACK_DEFAULT_AUDIO_TYPE, - JackPortIsOutput, 0); - right_port = jack_port_register(client, config.jack_right_channel_name, - JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); - sample_rate = jack_get_sample_rate(client); - // debug(1, "jackaudio sample rate = %" PRId32 ".", sample_rate); - if (sample_rate == 44100) { - if (jack_set_latency_callback(client, default_jack_set_latency_callback, NULL) == 0) { - if (jack_activate(client)) { - debug(1, "jackaudio cannot activate client"); - } else { - debug(2, "jackaudio client opened."); - client_is_open = 1; - } - } else { - debug(1, "jackaudio cannot set latency callback"); - } - } else { - inform( - "jackaudio is running at the wrong speed (%d) for Shairport Sync, which must be 44100", - sample_rate); + if (flush_please) { + // We just move the read pointer ahead without doing anything with the data. + jack_ringbuffer_read_advance(jackbuf, jack_ringbuffer_read_space(jackbuf)); + flush_please = 0; + // Since we don't change nframes, the whole buffer will be zeroed later. + } else { + jack_ringbuffer_get_read_vector(jackbuf, v); + for (i = 0; i < 2; i++) { + thisbuf = v[i].len / bytes_per_frame; + if (thisbuf > nframes) { + frames_required = nframes; + } else { + frames_required = thisbuf; } + deinterleave_and_convert(v[i].buf, buffer, frames_written, frames_required); + frames_written += frames_required; + nframes -= frames_required; } + jack_ringbuffer_read_advance(jackbuf, frames_written * bytes_per_frame); } - pthread_mutex_unlock(&client_mutex); - return client_is_open; -} - -void jack_close(void) { - pthread_mutex_lock(&client_mutex); - if (client_is_open) { - if (jack_deactivate(client)) - debug(1, "Error deactivating jack client"); - if (jack_client_close(client)) - debug(1, "Error closing jack client"); - client_is_open = 0; - } - pthread_mutex_unlock(&client_mutex); -} - -void jack_deinit() { - jack_close(); - if (open_client_if_necessary_thread) { - pthread_cancel(*open_client_if_necessary_thread); - free((char *)open_client_if_necessary_thread); - } -} - -void *open_client_if_necessary_thread_function(void *arg) { - int *interval = (int *)arg; - while (*interval != 0) { - if (client_is_open == 0) { - debug(1, "Try to open the jack client"); - jack_client_open_if_needed(); + // If there are any more frames to put into the buffer, fill them with + // silence. This is a critical underflow situation. Let's at least keep the JACK + // graph humming along while preventing the motorboat sound of a repeating buffer. + while (nframes > 0) { + for (i = 0; i < NPORTS; i++) { + buffer[i][frames_written] = 0.0; } - sleep(*interval); + frames_written++; + nframes--; } - pthread_exit(NULL); + return 0; // Tell JACK that all is well. +} + +// This is the JACK graph reorder callback. Now we know some JACK connections +// have changed, so we recompute the latency. +static int graph(__attribute__((unused)) void * arg) { + int latency = 0; + debug(2, "JACK graph reorder callback called."); + for (int i=0; i 300)) - debug(1, - "Invalid jack auto_client_open_interval \"%sd\". It should be between 0 and 300, " - "default is %d.", - value, config.jack_auto_client_open_interval); - else - config.jack_auto_client_open_interval = value; - } - - /* See if we should close the client at then end of a play session. */ - config_set_lookup_bool(config.cfg, "jack.auto_client_disconnect", - &config.jack_auto_client_disconnect); } - if (config.jack_client_name == NULL) - config.jack_client_name = strdup("Shairport Sync"); - if (config.jack_left_channel_name == NULL) - config.jack_left_channel_name = strdup("left"); - if (config.jack_right_channel_name == NULL) - config.jack_right_channel_name = strdup("right"); + config.jack_client_name = strdup("shairport-sync"); - jack_set_error_function(default_jack_error_callback); - jack_set_info_function(default_jack_info_callback); - - // allocate space for the audio buffer - audio_lmb = malloc(buffer_size); - if (audio_lmb == NULL) - die("Can't allocate %d bytes for jackaudio buffer.", buffer_size); - audio_toq = audio_eoq = audio_lmb; - audio_umb = audio_lmb + buffer_size; - audio_occupancy = 0; // frames - - client_is_open = 0; - - // now, if selected, start a thread to automatically open a client when there is a server. - if (config.jack_auto_client_open_interval != 0) { - open_client_if_necessary_thread = malloc(sizeof(pthread_t)); - if (open_client_if_necessary_thread == NULL) { - debug(1, "Couldn't allocate space for jack server scanner thread"); - jack_client_open_if_needed(); - } else { - pthread_create(open_client_if_necessary_thread, NULL, - open_client_if_necessary_thread_function, - &config.jack_auto_client_open_interval); - } - } else { - jack_client_open_if_needed(); + jackbuf = jack_ringbuffer_create(buffer_size); + if (jackbuf == NULL) + die("Can't allocate %d bytes for the JACK ringbuffer.", buffer_size); + // Lock the ringbuffer into memory so that it never gets paged out, which would + // break realtime constraints. + jack_ringbuffer_mlock(jackbuf); + // This mutex should not be necessary, but removing it causes segfaults on + // shutdown. Apparently, there are multiple threads in the main program trying + // to do stuff. FIXME: Try to consolidate into one thread and get rid of this lock. + pthread_mutex_lock(&client_mutex); + jack_status_t status; + client = jack_client_open(config.jack_client_name, JackNoStartServer, &status); + if (!client) { + die("Could not start JACK server. JackStatus is %x", status); } + sample_rate = jack_get_sample_rate(client); + if (sample_rate != 44100) { + die("The JACK server is running at the wrong sample rate (%d) for Shairport Sync." + " Must be 44100 Hz.", sample_rate); + } + jack_set_process_callback(client, &process, NULL); + jack_set_graph_order_callback(client, &graph, NULL); + jack_set_error_function(&error); + jack_set_info_function(&info); + for (i=0; i < NPORTS; i++) { + port[i] = jack_port_register(client, port_name[i], JACK_DEFAULT_AUDIO_TYPE, + JackPortIsOutput, 0); + } + if (jack_activate(client)) { + die("Could not activate %s JACK client.", config.jack_client_name); + } else { + debug(2, "JACK client %s activated sucessfully.", config.jack_client_name); + } + if (config.jack_autoconnect_pattern != NULL) { + inform("config.jack_autoconnect_pattern is %s. If you see the program die after this," + "you made a syntax error.", config.jack_autoconnect_pattern); + // Sadly, this will throw a segfault if the user provides a syntactically incorrect regex. + // I've reported it to the jack-devel mailing list, they're in a better place to fix it. + const char** port_list = jack_get_ports(client, config.jack_autoconnect_pattern, + JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput); + if (port_list != NULL) { + for (i = 0; i < NPORTS ; i++) { + char* full_port_name[NPORTS]; + full_port_name[i] = malloc(sizeof(char) * jack_port_name_size()); + sprintf(full_port_name[i], "%s:%s", config.jack_client_name, port_name[i]); + if (port_list[i] != NULL) { + int err; + debug(2, "Connecting %s to %s.", full_port_name[i], port_list[i]); + err = jack_connect(client, full_port_name[i], port_list[i]); + switch (err) { + case EEXIST: + inform("The requested connection from %s to %s already exists.", + full_port_name[i], port_list[i]); + break; + case 0: + // success + break; + default: + warn("JACK error no. %d occured while trying to connect %s to %s.", + err, full_port_name[i], port_list[i]); + break; + } + } else { + inform("No matching port found in %s to connect %s to. You may not hear audio.", + config.jack_autoconnect_pattern, full_port_name[i]); + } + free(full_port_name[i]); + } + while (port_list[i++] != NULL) { + inform("Additional matching port %s found. Check that the connections are what you intended."); + } + jack_free(port_list); + } + } + pthread_mutex_unlock(&client_mutex); return 0; } +void jack_deinit() { + pthread_mutex_lock(&client_mutex); + if (jack_deactivate(client)) + warn("Error deactivating jack client"); + if (jack_client_close(client)) + warn("Error closing jack client"); + pthread_mutex_unlock(&client_mutex); + jack_ringbuffer_free(jackbuf); +} + void jack_start(__attribute__((unused)) int i_sample_rate, __attribute__((unused)) int i_sample_format) { - // debug(1, "jack start"); - // see if the client is running. If not, try to open and initialise it + // Nothing to do, JACK client has already been set up at jack_init(). + // Also, we have no say over the sample rate or sample format of JACK, + // We convert the 16bit samples to float, and die if the sample rate is != 44k1. + // FIXME: later, resampling would be nice. Fold into soxr if possible. +} - if (jack_client_open_if_needed() == 0) - debug(1, "cannot open a jack client for a play session"); +void jack_flush() { + debug(2, "Only the consumer can safely flush a lock-free ringbuffer. Asking the" + " process callback to do it..."); + flush_please = 1; } int jack_delay(long *the_delay) { - - // without the mutex, we could get the time of what is the last transfer of data to a jack buffer, - // but then a transfer could occur and we would get the buffer occupancy after another transfer - // had occurred - // so we could "lose" a full transfer (e.g. 1024 frames @ 44,100 fps ~ 23.2 milliseconds) + // Semantics change: we now look at the last transfer into the lock-free + // ringbuffer, not into the jack buffers directly (because locking those would + // violate real-time constraints). On average, that should lead to just a + // constant additional latency. + // Without the mutex, we could get the time of what is the last transfer of data + // to a jack buffer, but then a transfer could occur and we would get the buffer + // occupancy after another transfer had occurred, so we could "lose" a full transfer + // (e.g. 1024 frames @ 44,100 fps ~ 23.2 milliseconds) pthread_mutex_lock(&buffer_mutex); - int64_t time_now = get_absolute_time_in_fp(); - int64_t delta = time_now - time_of_latest_transfer; // this is the time back to the last time data - // was transferred into a jack buffer - size_t audio_occupancy_now = audio_occupancy; // this is the buffer occupancy before any - // subsequent transfer because transfer is blocked - // by the mutex + int64_t time_now = get_absolute_time_in_fp(); + int64_t delta = time_now - time_of_latest_transfer; + size_t audio_occupancy_now = jack_ringbuffer_read_space(jackbuf) / bytes_per_frame; + debug(2, "audio_occupancy_now is %d.", audio_occupancy_now); pthread_mutex_unlock(&buffer_mutex); int64_t frames_processed_since_latest_latency_check = (delta * 44100) >> 32; // debug(1,"delta: %" PRId64 " frames.",frames_processed_since_latest_latency_check); - jack_nframes_t base_latency = (latest_left_latency_range.min + latest_left_latency_range.max) / 2; - if (base_latency == 0) - base_latency = (latest_right_latency_range.min + latest_right_latency_range.max) / 2; - *the_delay = base_latency + audio_occupancy_now - frames_processed_since_latest_latency_check; + // jack_latency is set by the graph() callback, it's the average of the maximum + // latencies of all our output ports. Adjust this constant baseline delay according + // to the buffer fill level: + *the_delay = jack_latency + audio_occupancy_now - frames_processed_since_latest_latency_check; // debug(1,"reporting a delay of %d frames",*the_delay); - return 0; } -void jack_flush() { - // debug(1,"jack flush"); +int play(void *buf, int samples) { + // debug(1,"jack_play of %d samples.",samples); + // copy the samples into the queue + size_t bytes_to_transfer, bytes_transferred; + bytes_to_transfer = samples * bytes_per_frame; + // It's ok to lock here since we're not in the realtime callback: pthread_mutex_lock(&buffer_mutex); - audio_toq = audio_eoq = audio_lmb; - audio_umb = audio_lmb + buffer_size; - audio_occupancy = 0; // frames + bytes_transferred = jack_ringbuffer_write(jackbuf, buf, bytes_to_transfer); + time_of_latest_transfer = get_absolute_time_in_fp(); pthread_mutex_unlock(&buffer_mutex); -} - -void jack_stop(void) { - // debug(1, "jack stop"); - if (config.jack_auto_client_disconnect) - jack_close(); + if (bytes_transferred < bytes_to_transfer) { + warn("JACK ringbuffer overrun. Only wrote %d of %d bytes.", + bytes_transferred, bytes_to_transfer); + } + return 0; } diff --git a/common.h b/common.h index 9dceabb3..e3e02635 100644 --- a/common.h +++ b/common.h @@ -232,10 +232,8 @@ typedef struct { double diagnostic_drop_packet_fraction; // pseudo randomly drop this fraction of packets, for // debugging. Currently audio packets only... #ifdef CONFIG_JACK - char *jack_client_name, *jack_left_channel_name, *jack_right_channel_name; - int jack_auto_client_open_interval; // will try to open a client automatically every second - int jack_auto_client_disconnect; // will disconnect from the server on end of session if set, - // normally clear. + char *jack_client_name; + char *jack_autoconnect_pattern; #endif } shairport_cfg; diff --git a/scripts/shairport-sync.conf b/scripts/shairport-sync.conf index 52d3232f..c5d83eb5 100644 --- a/scripts/shairport-sync.conf +++ b/scripts/shairport-sync.conf @@ -108,11 +108,14 @@ pa = // Parameters for the "jack" JACK Audio Connection Kit backend. jack = { -// client_name = "Shairport Sync"; //Set this to the name of the client that should appear in "Connections" when Shairport Sync is active. -// left_channel_name = "left"; //Set this to the name of the left output port that should appear in "Connections" when Shairport Sync is active. -// right_channel_name = "right"; //Set this to the name of the right output port that should appear in "Connections" when Shairport Sync is active. -// auto_client_open_interval = 1; // Set this to the interval in seconds between automatic attempts to open a client on the jack server. Set to zero to disable this behaviour. -// auto_client_disconnect = "no"; // Set this to "yes" to close the jack client automatically at then end of a play session. Default is no -- the client stays connected. +// client_name = "shairport-sync"; // Set this to the name of the client that should appear in "Connections" when Shairport Sync is active. +// autoconnect_pattern = ""; // Set this to a POSIX regular expression pattern that describes the ports you would like to connect to +// automatically. Examples: +// "system:playback_[12]" +// "some_app_[0-9]*:in-[LR]" +// "jack_mixer:in_2[78]" +// Beware: if you make a syntax error, libjack might crash. In that case, fix it and start over. +// For a good overview, look here: https://www.ibm.com/support/knowledgecenter/SS8NLW_11.0.1/com.ibm.swg.im.infosphere.dataexpl.engine.doc/c_posix-regex-examples.html }; // Parameters for the "pipe" audio back end, a back end that directs raw CD-style audio output to a pipe. No interpolation is done.