String open (const BigInteger& inputChannels, const BigInteger& outputChannels,
double /* sampleRate */, int /* bufferSizeSamples */)
{
jack_Log ("opening client");
lastError = client.open (KV_JACK_NAME, 0);
if (lastError.isNotEmpty())
{
jack_Log (lastError);
return lastError;
}
DBG("num inputs: " << inputChannels.getHighestBit());
DBG("num outputs: " << outputChannels.getHighestBit());
jack_on_shutdown (client, JackDevice::shutdownCallback, this);
jack_set_error_function (JackDevice::errorCallback);
jack_set_port_connect_callback (client, JackDevice::portConnectCallback, this);
jack_set_process_callback (client, JackDevice::processCallback, this);
jack_set_thread_init_callback (client, JackDevice::threadInitCallback, this);
jack_set_port_registration_callback (client, JackDevice::_portRegistration, this);
client.registerPort ("audio_1", Jack::audioPort, JackPortIsOutput);
client.registerPort ("audio_2", Jack::audioPort, JackPortIsOutput);
return lastError;
}
// Attempt to connect to the Jack server
static PyObject* attach(PyObject* self, PyObject* args)
{
char* cname;
if (! PyArg_ParseTuple(args, "s", &cname))
return NULL;
pyjack_client_t * client = self_or_global_client(self);
if(client->pjc != NULL) {
PyErr_SetString(JackUsageError, "A connection is already established.");
return NULL;
}
jack_status_t status;
client->pjc = jack_client_open(cname, JackNoStartServer, &status);
if(client->pjc == NULL) {
//TODO check status
PyErr_SetString(JackNotConnectedError, "Failed to connect to Jack audio server.");
return NULL;
}
jack_on_shutdown(client->pjc, pyjack_shutdown, client);
signal(SIGHUP, pyjack_hangup); // TODO: This just works with global clients
if(jack_set_process_callback(client->pjc, pyjack_process, client) != 0) {
PyErr_SetString(JackError, "Failed to set jack process callback.");
return NULL;
}
if(jack_set_buffer_size_callback(client->pjc, pyjack_buffer_size_changed, client) != 0) {
PyErr_SetString(JackError, "Failed to set jack buffer size callback.");
return NULL;
}
if(jack_set_sample_rate_callback(client->pjc, pyjack_sample_rate_changed, client) != 0) {
PyErr_SetString(JackError, "Failed to set jack sample rate callback.");
return NULL;
}
if(jack_set_port_registration_callback(client->pjc, pyjack_port_registration, client) != 0) {
PyErr_SetString(JackError, "Failed to set jack port registration callback.");
return NULL;
}
if(jack_set_graph_order_callback(client->pjc, pyjack_graph_order, client) != 0) {
PyErr_SetString(JackError, "Failed to set jack graph order callback.");
return NULL;
}
if(jack_set_xrun_callback(client->pjc, pyjack_xrun, client) != 0) {
PyErr_SetString(JackError, "Failed to set jack xrun callback.");
return NULL;
}
// Get buffer size
client->buffer_size = jack_get_buffer_size(client->pjc);
// Success!
Py_INCREF(Py_None);
return Py_None;
}
void gojack_generic_callback_sync_destroy(struct gojack_generic_callback_sync *sync) {
jack_set_freewheel_callback(sync->client, NULL, NULL);
jack_set_buffer_size_callback(sync->client, NULL, NULL);
jack_set_sample_rate_callback(sync->client, NULL, NULL);
jack_set_client_registration_callback(sync->client, NULL, NULL);
jack_set_port_registration_callback(sync->client, NULL, NULL);
jack_set_port_connect_callback(sync->client, NULL, NULL);
jack_set_port_rename_callback(sync->client, NULL, NULL);
jack_set_graph_order_callback(sync->client, NULL, NULL);
jack_set_xrun_callback(sync->client, NULL, NULL);
jack_set_latency_callback(sync->client, NULL, NULL);
cgo_callback_sync_destroy(sync->base);
pthread_mutex_destroy(&sync->lock);
free(sync);
}
int
main (int argc, char *argv[])
{
jack_client_t *client;
jack_options_t options = JackNullOption;
jack_status_t status;
if ((client = jack_client_open ("event-monitor", options, &status, NULL)) == 0) {
fprintf (stderr, "jack_client_open() failed, "
"status = 0x%2.0x\n", status);
if (status & JackServerFailed) {
fprintf (stderr, "Unable to connect to JACK server\n");
}
return 1;
}
if (jack_set_port_registration_callback (client, port_callback, NULL)) {
fprintf (stderr, "cannot set port registration callback\n");
return 1;
}
if (jack_set_port_connect_callback (client, connect_callback, NULL)) {
fprintf (stderr, "cannot set port connect callback\n");
return 1;
}
if (jack_set_client_registration_callback (client, client_callback, NULL)) {
fprintf (stderr, "cannot set client registration callback\n");
return 1;
}
if (jack_set_graph_order_callback (client, graph_callback, NULL)) {
fprintf (stderr, "cannot set graph order registration callback\n");
return 1;
}
if (jack_set_property_change_callback (client, (JackPropertyChangeCallback) propchange, 0)) {
fprintf (stderr, "cannot set property change callback\n");
return 1;
}
if (jack_activate (client)) {
fprintf (stderr, "cannot activate client");
return 1;
}
sleep (-1);
exit (0);
}
struct gojack_generic_callback_sync * gojack_generic_callback_sync_create(jack_client_t *client) {
struct gojack_generic_callback_sync *sync = (struct gojack_generic_callback_sync *) malloc(sizeof(struct gojack_generic_callback_sync));
void *arg = (void *) sync;
sync->base = cgo_callback_sync_create();
cgo_callback_sync_set_log_callback(sync->base, &handle_log, NULL);
pthread_mutex_init(&sync->lock, NULL);
sync->client = client;
jack_set_freewheel_callback(client, &handle_freewheel, arg);
jack_set_buffer_size_callback(client, &handle_buffer_size, arg);
//jack_set_sample_rate_callback(client, &handle_sample_rate, arg);
jack_set_client_registration_callback(client, &handle_client_registration, arg);
jack_set_port_registration_callback(client, &handle_port_registration, arg);
jack_set_port_connect_callback(client, &handle_port_connect, arg);
jack_set_port_rename_callback(client, &handle_port_rename, arg);
jack_set_graph_order_callback(client, &handle_graph_order, arg);
jack_set_xrun_callback(client, &handle_xrun, arg);
//jack_set_latency_callback(client, &handle_latency, arg);
return sync;
}
static SCM start_jack(void *data) {
int i;
char name[16];
jack_status_t jstatus;
jack_client = jack_client_open(client_name,
JackServerName,
&jstatus, server_name);
if (jack_client == 0) {
log_msg("JACK server not running?\n") ;
cleanup();
return SCM_UNSPECIFIED;
}
log_msg("JACK status: %04x\n", jstatus);
if (jstatus & JackServerStarted)
log_msg("\tserver started\n");
if (jstatus & JackServerFailed)
log_msg("\tcan't connect\n");
if (jstatus & JackInitFailure)
log_msg("\tcan't initialize client\n");
client_name = (const char *)jack_get_client_name(jack_client);
sampling_rate = jack_get_sample_rate(jack_client) ;
period_frames = jack_get_buffer_size(jack_client);
jack_set_error_function(jack_error);
jack_set_info_function(jack_info);
jack_set_xrun_callback(jack_client, jack_xrun, NULL);
jack_set_process_callback(jack_client, mixmaster, NULL);
jack_set_port_registration_callback(jack_client, check_ports, NULL);
jack_on_shutdown(jack_client, jack_shutdown, 0);
for (i = 0; i < QMX_CHANNELS; i++) {
sprintf(name, "out%02d", i + 1);
jack_cauldron[i] = jack_port_register(jack_client, name,
JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
}
if (jack_activate(jack_client)) {
log_msg("Cannot activate client.\n");
cleanup();
return SCM_UNSPECIFIED;
}
log_msg("JACK client activated: '%s'\n", client_name);
return SCM_UNSPECIFIED;
}
gboolean cbox_jackio_start(struct cbox_io_impl *impl, struct cbox_command_target *fb, GError **error)
{
struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
struct cbox_io *io = jii->ioi.pio;
if (io->cb->on_transport_sync)
jack_set_sync_callback(jii->client, sync_cb, jii);
jack_set_process_callback(jii->client, process_cb, jii);
jack_set_port_registration_callback(jii->client, port_connect_cb, jii);
jack_on_info_shutdown(jii->client, client_shutdown_cb, jii);
if (io->cb->on_started)
io->cb->on_started(io->cb->user_data);
jack_activate(jii->client);
if (cbox_config_has_section(cbox_io_section))
port_autoconnect(jii, NULL, fb);
return TRUE;
}
int
main (int argc, char *argv[])
{
// Make output unbuffered
setbuf(stdout, NULL);
setbuf(stderr, NULL);
if (argc >= 2 &&
( strcmp(argv[1],"-h")==0 || strcmp(argv[1],"--help")==0))
{
printf("send jack events as OSC message\n\n");
printf("syntax: jack_oscev <osc local port> <osc remote host> <osc remote port>\n\n");
printf("all params are optional. order matters.\n");
printf("default values: 6677 127.0.0.1 6678\n");
printf("example: jack_oscev 9988 10.10.10.42\n");
printf("test on .42: oscdump 6678\n\n");
printf("messages sent by jack_oscev (example content):\n");
printf(" /oscev/started\n");
printf(" /oscev/client/registered s \"meter\"\n");
printf(" /oscev/port/registered i 24\n");
printf(" /oscev/port/connected ii 2 24\n");
printf(" /oscev/port/disconnected ii 2 24\n");
printf(" /oscev/port/unregistered i 24\n");
printf(" /oscev/client/unregistered s \"meter\"\n\n");
//printf("");
printf("jack_oscev source at https://github.com/7890/jack_tools\n\n");
return(0);
}
//remote port
if (argc >= 4)
{
osc_send_to_port=argv[3];
}
if (argc >= 3)
{
osc_send_to_host=argv[2];
}
//local port
if (argc >= 2)
{
osc_my_server_port=argv[1];
}
//init osc
st = lo_server_thread_new(osc_my_server_port, error);
loa = lo_address_new(osc_send_to_host, osc_send_to_port);
lo_server_thread_start(st);
lo_message reply=lo_message_new();
lo_send_message (loa, "/oscev/started", reply);
lo_message_free (reply);
jack_options_t options = JackNullOption;
jack_status_t status;
if ((client = jack_client_open ("oscev", options, &status, NULL)) == 0) {
fprintf (stderr, "jack_client_open() failed, "
"status = 0x%2.0x\n", status);
if (status & JackServerFailed) {
fprintf (stderr, "Unable to connect to JACK server\n");
}
return 1;
}
if (jack_set_port_registration_callback (client, port_callback, NULL)) {
fprintf (stderr, "cannot set port registration callback\n");
return 1;
}
if (jack_set_port_connect_callback (client, connect_callback, NULL)) {
fprintf (stderr, "cannot set port connect callback\n");
return 1;
}
if (jack_set_client_registration_callback (client, client_callback, NULL)) {
fprintf (stderr, "cannot set client registration callback\n");
return 1;
}
/*
//don't register for now
if (jack_set_graph_order_callback (client, graph_callback, NULL)) {
fprintf (stderr, "cannot set graph order registration callback\n");
return 1;
}
*/
if (jack_activate (client)) {
fprintf (stderr, "cannot activate client");
return 1;
}
#ifndef WIN32
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGHUP, signal_handler);
#endif
signal(SIGABRT, signal_handler);
signal(SIGTERM, signal_handler);
#ifdef WIN32
Sleep(INFINITE);
#else
sleep (-1);
#endif
exit (0);
}
int soundio_jack_init(struct SoundIoPrivate *si) {
SoundIoJack *sij = &si->backend_data.jack;
SoundIo *soundio = &si->pub;
if (!global_msg_callback_flag.test_and_set()) {
if (soundio->jack_error_callback)
jack_set_error_function(soundio->jack_error_callback);
if (soundio->jack_info_callback)
jack_set_info_function(soundio->jack_info_callback);
global_msg_callback_flag.clear();
}
sij->mutex = soundio_os_mutex_create();
if (!sij->mutex) {
destroy_jack(si);
return SoundIoErrorNoMem;
}
sij->cond = soundio_os_cond_create();
if (!sij->cond) {
destroy_jack(si);
return SoundIoErrorNoMem;
}
// We pass JackNoStartServer due to
// https://github.com/jackaudio/jack2/issues/138
jack_status_t status;
sij->client = jack_client_open(soundio->app_name, JackNoStartServer, &status);
if (!sij->client) {
destroy_jack(si);
assert(!(status & JackInvalidOption));
if (status & JackShmFailure)
return SoundIoErrorSystemResources;
if (status & JackNoSuchClient)
return SoundIoErrorNoSuchClient;
return SoundIoErrorInitAudioBackend;
}
int err;
if ((err = jack_set_buffer_size_callback(sij->client, buffer_size_callback, si))) {
destroy_jack(si);
return SoundIoErrorInitAudioBackend;
}
if ((err = jack_set_sample_rate_callback(sij->client, sample_rate_callback, si))) {
destroy_jack(si);
return SoundIoErrorInitAudioBackend;
}
if ((err = jack_set_port_registration_callback(sij->client, port_registration_callback, si))) {
destroy_jack(si);
return SoundIoErrorInitAudioBackend;
}
if ((err = jack_set_port_rename_callback(sij->client, port_rename_calllback, si))) {
destroy_jack(si);
return SoundIoErrorInitAudioBackend;
}
jack_on_shutdown(sij->client, shutdown_callback, si);
sij->refresh_devices_flag.clear();
sij->period_size = jack_get_buffer_size(sij->client);
sij->sample_rate = jack_get_sample_rate(sij->client);
if ((err = jack_activate(sij->client))) {
destroy_jack(si);
return SoundIoErrorInitAudioBackend;
}
if ((err = refresh_devices(si))) {
destroy_jack(si);
return err;
}
si->destroy = destroy_jack;
si->flush_events = flush_events_jack;
si->wait_events = wait_events_jack;
si->wakeup = wakeup_jack;
si->force_device_scan = force_device_scan_jack;
si->outstream_open = outstream_open_jack;
si->outstream_destroy = outstream_destroy_jack;
si->outstream_start = outstream_start_jack;
si->outstream_begin_write = outstream_begin_write_jack;
si->outstream_end_write = outstream_end_write_jack;
si->outstream_clear_buffer = outstream_clear_buffer_jack;
si->outstream_pause = outstream_pause_jack;
si->outstream_get_latency = outstream_get_latency_jack;
si->instream_open = instream_open_jack;
si->instream_destroy = instream_destroy_jack;
si->instream_start = instream_start_jack;
si->instream_begin_read = instream_begin_read_jack;
si->instream_end_read = instream_end_read_jack;
si->instream_pause = instream_pause_jack;
si->instream_get_latency = instream_get_latency_jack;
return 0;
}
