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; }