static int process_info_connect_jack (process_info_t * procinfo, ui_t * ui) { _update_status ( _("Connecting to JACK server with client name '%s'"), jack_client_name ); #if HAVE_JACK_SESSION if (strlen (session_uuid->str)) procinfo->jack_client = jack_client_open (jack_client_name, JackSessionID, NULL, session_uuid->str); else #endif procinfo->jack_client = jack_client_open (jack_client_name, JackNullOption, NULL); if (!procinfo->jack_client) return -1; _update_status ( _status_cb_data, _("Connected to JACK server") ); jack_set_process_callback (procinfo->jack_client, process, procinfo); jack_on_shutdown (procinfo->jack_client, jack_shutdown_cb, ui); /* FIXME: need a generic callback for this, too */ #if HAVE_JACK_SESSION if( jack_set_session_callback ) jack_set_session_callback (procinfo->jack_client, jack_session_cb_aux, ui); #endif return 0; }
void open_jack(void ) { if (jack_client) { fprintf (stderr, "xjadeo is alredy connected to jack.\n"); return; } int i = 0; do { snprintf(jackid,16,"xjadeo-%i",i); #ifdef JACK_SESSION if (jack_uuid) jack_client = jack_client_open (jackid, JackUseExactName|JackSessionID, NULL, jack_uuid); else #endif jack_client = jack_client_open (jackid, JackUseExactName, NULL); } while (jack_client == 0 && i++<16); if (!jack_client) { fprintf(stderr, "could not connect to jack server.\n"); } else { #ifdef JACK_SESSION jack_set_session_callback (jack_client, jack_session_cb, NULL); #endif #ifndef HAVE_WINDOWS jack_on_shutdown (jack_client, jack_shutdown, 0); jack_activate(jack_client); #endif if (!want_quiet) fprintf(stdout, "connected as jack client '%s'\n",jackid); #ifdef HAVE_LASH lash_jack_client_name(lash_client, jackid); #endif } }
void open_client(std::string const & server_name, std::string const & name, uint32_t input_port_count, uint32_t output_port_count, uint32_t blocksize) { blocksize_ = blocksize; /* open client */ client = server_name.empty() ? jack_client_open(name.c_str(), JackNoStartServer, &status) : jack_client_open(name.c_str(), jack_options_t(JackNoStartServer | JackServerName), &status, server_name.c_str()); boost::atomic_thread_fence(boost::memory_order_release); // ensure visibility on other threads if (status & JackServerFailed) throw std::runtime_error("Unable to connect to JACK server"); if (status & JackNameNotUnique) { const char * client_name = jack_get_client_name(client); std::cout << "unique client name: " << client_name << std::endl; } /* initialize callbacks */ jack_set_thread_init_callback (client, jack_thread_init_callback, this); jack_set_process_callback (client, jack_process_callback, this); jack_set_xrun_callback(client, jack_xrun_callback, this); jack_on_info_shutdown(client, (JackInfoShutdownCallback)jack_on_info_shutdown_callback, NULL); /* register ports */ input_ports.clear(); for (uint32_t i = 0; i != input_port_count; ++i) { std::string portname ("input_"); portname += std::to_string(i+1); jack_port_t * port = jack_port_register(client, portname.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); input_ports.push_back(port); } input_channels = input_port_count; super::input_samples.resize(input_port_count); output_ports.clear(); for (uint32_t i = 0; i != output_port_count; ++i) { std::string portname ("output_"); portname += std::to_string(i+1); jack_port_t * port = jack_port_register(client, portname.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); output_ports.push_back(port); } output_channels = output_port_count; super::output_samples.resize(output_port_count); samplerate_ = jack_get_sample_rate(client); jack_frames = jack_get_buffer_size(client); if (jack_frames % blocksize_) throw std::runtime_error("Jack buffer size is not a multiple of blocksize"); }
JackLayer::JackLayer(const AudioPreference &p) : AudioLayer(p), captureClient_(nullptr), playbackClient_(nullptr), out_ports_(), in_ports_(), out_ringbuffers_(), in_ringbuffers_(), ringbuffer_thread_(), //workerAlive_(false), ringbuffer_thread_mutex_(), data_ready_(), playbackBuffer_(0, audioFormat_), playbackFloatBuffer_(), captureBuffer_(0, audioFormat_), captureFloatBuffer_(), hardwareBufferSize_(0), mainRingBuffer_(Manager::instance().getRingBufferPool().getRingBuffer(RingBufferPool::DEFAULT_ID)) { playbackClient_ = jack_client_open(PACKAGE_NAME, (jack_options_t) (JackNullOption | JackNoStartServer), NULL); if (!playbackClient_) throw std::runtime_error("Could not open JACK client"); captureClient_ = jack_client_open(PACKAGE_NAME, (jack_options_t) (JackNullOption | JackNoStartServer), NULL); if (!captureClient_) throw std::runtime_error("Could not open JACK client"); jack_set_process_callback(captureClient_, process_capture, this); jack_set_process_callback(playbackClient_, process_playback, this); createPorts(playbackClient_, out_ports_, true, out_ringbuffers_); createPorts(captureClient_, in_ports_, false, in_ringbuffers_); const auto playRate = jack_get_sample_rate(playbackClient_); const auto captureRate = jack_get_sample_rate(captureClient_); if (playRate != captureRate) RING_ERR("Mismatch between capture rate %u and playback rate %u", playRate, captureRate); hardwareBufferSize_ = jack_get_buffer_size(playbackClient_); auto update_buffer = [] (AudioBuffer &buf, size_t size, unsigned rate, unsigned nbChannels) { buf.setSampleRate(rate); buf.resize(size); buf.setChannelNum(nbChannels); }; update_buffer(playbackBuffer_, hardwareBufferSize_, playRate, out_ports_.size()); update_buffer(captureBuffer_, hardwareBufferSize_, captureRate, in_ports_.size()); jack_on_shutdown(playbackClient_, onShutdown, this); }
int main(int argc, char *argv[]) { int rc; parse_arguments(argc, argv); /* become a JACK client */ if ((client = jack_client_open(package, JackNullOption, NULL)) == 0) { fprintf(stderr, "JACK server not running?\n"); exit(1); } #ifndef WIN32 signal(SIGQUIT, signal_handler); signal(SIGHUP, signal_handler); #endif signal(SIGTERM, signal_handler); signal(SIGINT, signal_handler); jack_on_shutdown(client, jack_shutdown, 0); if (just_print_bufsize) { fprintf(stdout, "buffer size = %d sample rate = %d\n", jack_get_buffer_size(client), jack_get_sample_rate(client)); rc=0; } else { rc = jack_set_buffer_size(client, nframes); if (rc) fprintf(stderr, "jack_set_buffer_size(): %s\n", strerror(rc)); } jack_client_close(client); return rc; }
bool JackAudioInterface::open_jack_client() { // open a client connection to the JACK server jack_status_t status; m_client = jack_client_open(m_clientName, JackUseExactName, &status); if (m_client == NULL) { qWarning("JackAudioInterface::open_jack_client(): jack_client_open() failed, status = 0x%2.0x", status); if (status & JackServerFailed) { qWarning("JackAudioInterface::open_jack_client(): Unable to connect to JACK server"); } return false; } if (status & JackServerStarted) { qDebug("JackAudioInterface::open_jack_client(): Started new JACK server"); } if (status & JackNameNotUnique) { qWarning("JackAudioInterface::open_jack_client(): unique client name `%s' assigned", jack_get_client_name(m_client)); // TODO: this should actually be an error: since our client name includes our port #, we should already be unique } return true; }
DSP::DSP() { cout << "DSP()" << endl; // open the client client = jack_client_open ( "showcase-2", JackNullOption , 0 , 0 ); // register two output ports out_left = jack_port_register( client, "out_left", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); out_right = jack_port_register( client, "out_right", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); // register the static DSP callback jack_set_process_callback( client, static_process, static_cast<void*>(this) ); // sample counter for playback playbackIndex = 0; }
// ======================== // = INITIALIZE AUDIO I/O = // ======================== void initJackAudioIO() { // Create client: if((client = jack_client_open("xooky_nabox", JackNullOption, NULL)) == NULL) { std::cout << "jack server not running?\n"; exit(1); } // Register callbacks: jack_on_shutdown(client, jack_shutdown, 0); jack_set_process_callback(client, process, 0); // Register io ports: portO1 = jack_port_register(client, "out1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); portO2 = jack_port_register(client, "out2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); portI1 = jack_port_register(client, "in1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); portI2 = jack_port_register(client, "in2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); // Get sample rate from server sampleRate = jack_get_sample_rate(client); std::cout << "Sample rate:" << sampleRate << "\n"; //Go! if (jack_activate (client)) { std::cout << "Cannot activate client"; exit(1); } }
int main (int ac, char *av []) { float t; jack_status_t s; jack_handle = jack_client_open ("jack_delay", JackNoStartServer, &s); if (jack_handle == 0) { fprintf (stderr, "Can't connect to Jack, is the server running ?\n"); exit (1); } mtdm = mtdm_new(jack_get_sample_rate(jack_handle)); jack_set_process_callback (jack_handle, jack_callback, 0); if (jack_set_latency_callback) jack_set_latency_callback (jack_handle, latency_cb, 0); jack_capt = jack_port_register (jack_handle, "in", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); jack_play = jack_port_register (jack_handle, "out", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); t = 1000.0f / jack_get_sample_rate (jack_handle); if (jack_activate (jack_handle)) { fprintf(stderr, "Can't activate Jack"); return 1; } while (1) { #ifdef WIN32 Sleep (250); #else usleep (250000); #endif if (mtdm_resolve (mtdm) < 0) printf ("Signal below threshold...\n"); else { jack_nframes_t systemic_latency; if (mtdm->_err > 0.3) { mtdm_invert ( mtdm ); mtdm_resolve ( mtdm ); } systemic_latency = (jack_nframes_t) floor (mtdm->_del - (capture_latency.max + playback_latency.max)); printf ("%10.3lf frames %10.3lf ms total roundtrip latency\n\textra loopback latency: %u frames\n\tuse %u for the backend arguments -I and -O", mtdm->_del, mtdm->_del * t, systemic_latency, systemic_latency/2); if (mtdm->_err > 0.2) printf (" ??"); if (mtdm->_inv) printf (" Inv"); printf ("\n"); } } return 0; }
FXbool JackOutput::open() { jack = jack_client_open("gap",JackNoStartServer,NULL); if (jack==NULL) { return false; } return false; }
int main (int argc, char *argv[]) { parse_arguments (argc, argv); /* become a JACK client */ if ((client = jack_client_open ("freewheel", JackNullOption, NULL)) == 0) { fprintf (stderr, "JACK server not running?\n"); exit(1); } signal (SIGQUIT, signal_handler); signal (SIGTERM, signal_handler); signal (SIGHUP, signal_handler); signal (SIGINT, signal_handler); jack_on_shutdown (client, jack_shutdown, 0); if (jack_set_freewheel (client, onoff)) { fprintf (stderr, "failed to reset freewheel mode\n"); } jack_client_close(client); return 0; }
/* connect to jack server */ static int jack_transport_connect(jack_transport_t * x) { char port_name[80] = ""; static int client = 0; do { sprintf(port_name,"pure_data_jack_transport_%d",client); client++; } while (((x->x_jack_client = jack_client_open(port_name,0,0)) == 0) && client < 100); client = 0; if (!x->x_jack_client) { post("jack_transport: can't connect to jack server"); return 1; } post("jack_transport: connecting as %s", port_name); jack_activate(x->x_jack_client); return 0; }
// 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; }
int JackSimpleClient::setUp (int argc, char *argv[]) { LOGD("setUp argc %d", argc); for(int i = 0;i< argc; i++){ LOGD("setup argv %s", argv[i]); } // You have to use argv[0] as the jack client name like below. jackClient = jack_client_open (argv[0], JackNullOption, NULL, NULL); if (jackClient == NULL) { return APA_RETURN_ERROR; } bufferSize = jack_get_buffer_size(jackClient); // init the sine table for(int i=0; i<bufferSize; i++ ) { sineTable[i] = (float) sin( ((double)i*8/(double)bufferSize) * 2. * 3.14159265 ); } jack_set_process_callback (jackClient, processSine, this); outPort = jack_port_register (jackClient, "out", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); if(outPort == NULL){ return APA_RETURN_ERROR; } return APA_RETURN_SUCCESS; }
int main (int argc, char *argv[]) { jack_client_t *client; char *my_name = strrchr(argv[0], '/'); if (my_name == 0) { my_name = argv[0]; } else { my_name ++; } if (argc != 2) { fprintf (stderr, "Usage: %s client\n", my_name); return 1; } if ((client = jack_client_open ("input monitoring", JackNullOption, NULL)) == 0) { fprintf (stderr, "JACK server not running?\n"); return 1; } if (jack_port_request_monitor_by_name (client, argv[1], TRUE)) { fprintf (stderr, "could not enable monitoring for %s\n", argv[1]); jack_client_close (client); return 1; } sleep (30); if (jack_port_request_monitor_by_name (client, argv[1], FALSE)) { fprintf (stderr, "could not disable monitoring for %s\n", argv[1]); } jack_client_close (client); exit (0); }
JackAudioProvider(Synth *synth, const std::string &name) : synth_(synth) { SampleBufferAllocator::reset(); client_ = jack_client_open(name.c_str(), JackNoStartServer, 0); if (client_ == NULL) { throw JackClientOpenError(); } std::cout << "connected to jackd as client `" << name << "`\n"; sl::sampleRate(jack_get_sample_rate(client_)); jack_set_sample_rate_callback(client_, jackSampleRateCallback, 0); sl::bufferSize(jack_get_buffer_size(client_)); jack_set_buffer_size_callback(client_, jackBufferSizeCallback, 0); jack_set_process_callback(client_, jackProcessCallback, this); midiInPort_ = jack_port_register(client_, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0); std::cout << "registered midi port: midi_in\n"; char portName[64]; for (int i=0; i<Synth::InputBuffer::nChannels; i++) { snprintf(portName, sizeof(portName), "in_%u", i+1); inputPorts_[i] = jack_port_register(client_, portName, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); std::cout << "registered audio port: " << portName << "\n"; } for (int i=0; i<Synth::OutputBuffer::nChannels; i++) { snprintf(portName, sizeof(portName), "out_%u", i+1); outputPorts_[i] = jack_port_register(client_, portName, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); std::cout << "registered audio port: " << portName << "\n"; } for (int i=0; i<128; i++) { midiCtrlMap_[i] = i; } for (int i=11; i<=19; i++) { midiCtrlMap_[i] = i-10; } midiCtrlMap_[1] = 129; // modwheel }
// Device initialization method. bool qmidinetJackMidiDevice::open ( const QString& sClientName, int iNumPorts ) { // Close if already open. close(); // Open new JACK client... const QByteArray aClientName = sClientName.toLocal8Bit(); m_pJackClient = jack_client_open( aClientName.constData(), JackNullOption, NULL); if (m_pJackClient == NULL) return false; m_nports = iNumPorts; int i; // Create duplex ports. m_ppJackPortIn = new jack_port_t * [m_nports]; m_ppJackPortOut = new jack_port_t * [m_nports]; for (i = 0; i < m_nports; ++i) { m_ppJackPortIn[i] = NULL; m_ppJackPortOut[i] = NULL; } const QString sPortNameIn("in_%1"); const QString sPortNameOut("out_%1"); for (i = 0; i < m_nports; ++i) { m_ppJackPortIn[i] = jack_port_register(m_pJackClient, sPortNameIn.arg(i + 1).toLocal8Bit().constData(), JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0); m_ppJackPortOut[i] = jack_port_register(m_pJackClient, sPortNameOut.arg(i + 1).toLocal8Bit().constData(), JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0); } // Create transient buffers. m_pJackBufferIn = jack_ringbuffer_create(1024 * m_nports); m_pJackBufferOut = jack_ringbuffer_create(1024 * m_nports); // Prepare the queue sorter stuff... m_pQueueIn = new qmidinetJackMidiQueue(1024 * m_nports, 8); // Set and go usual callbacks... jack_set_process_callback(m_pJackClient, qmidinetJackMidiDevice_process, this); jack_on_shutdown(m_pJackClient, qmidinetJackMidiDevice_shutdown, this); jack_activate(m_pJackClient); // Start listener thread... m_pRecvThread = new qmidinetJackMidiThread(); m_pRecvThread->start(); // Done. return true; }
static int start_jack_client(void) { const char *server_name; jack_status_t status; client = jack_client_open("xwax", JackNullOption, &status, &server_name); if (client == NULL) { if (status & JackServerFailed) fprintf(stderr, "JACK: Failed to connect\n"); else fprintf(stderr, "jack_client_open: Failed (0x%x)\n", status); return -1; } if (jack_set_process_callback(client, process_callback, NULL) != 0) { fprintf(stderr, "JACK: Failed to set process callback\n"); return -1; } jack_on_shutdown(client, shutdown_callback, NULL); rate = jack_get_sample_rate(client); fprintf(stderr, "JACK: %dHz\n", rate); return 0; }
int main (int argc, char* argv[]) { jack_client_t* client; char const default_name[] = "connector"; // this is moderately retarded aliases[0] = (char *) malloc (jack_port_name_size()); aliases[1] = (char *) malloc (jack_port_name_size()); client = jack_client_open(default_name, JackNullOption, NULL); while (1) { const char **portnames; const char **orig; orig = portnames = jack_get_ports(client, "", "", 0); desired_connection *desired = desired_connections; while (desired->from_port) { ensure_connected(client, orig, desired); desired++; } printf("\n"); sleep(5); jack_free(orig); } }
int main (int argc, char *argv[]) { jack_client_t *client; char jack_client_name[] = "scope"; jack_status_t jack_status; jack_options_t jack_options = JackNullOption; if ((client = jack_client_open(jack_client_name, jack_options, &jack_status)) == 0) { fprintf (stderr, "jack server not running?\n"); return 1; } jack_set_process_callback (client, process, 0); jack_set_buffer_size_callback (client, bufsize, 0); jack_set_sample_rate_callback (client, srate, 0); jack_on_shutdown (client, jack_shutdown, 0); in_l = jack_port_register (client, "in_l", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); in_r = jack_port_register (client, "in_r", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); out_x = jack_port_register (client, "out_x", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); out_y = jack_port_register (client, "out_y", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); out_w = jack_port_register (client, "out_w", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); if (jack_activate (client)) { fprintf (stderr, "cannot activate client"); return 1; } while (1) sleep(1); jack_client_close (client); exit (0); }
static void rtJack_CopyDevParams(RtJackGlobals *p, char **devName, const csRtAudioParams *parm, int isOutput) { CSOUND *csound; char *s; size_t nBytes; csound = p->csound; *devName = (char*) NULL; if (parm->devNum != 1024) { jack_client_t *client_; int useTmpClient = 0; /* FIXME: a temporary JACK client is created if there is no */ /* connection yet; this is a somewhat hackish solution... */ if (p->client == (jack_client_t*) NULL) { useTmpClient = 1; client_ = jack_client_open(&(p->clientName[0]), JackNoStartServer, NULL); } else client_ = p->client; if (client_ != (jack_client_t*) NULL) { rtJack_ListPorts(csound, client_, &(p->clientName[0]), isOutput); if (useTmpClient) jack_client_close(client_); } rtJack_Error(csound, -1, Str("must specify a device name, not a number")); } if (parm->devName != NULL && parm->devName[0] != (char) 0) { /* NOTE: this assumes max. 999 channels (the current limit is 255) */ nBytes = strlen(parm->devName) + 4; if (UNLIKELY(nBytes > (size_t) jack_port_name_size())) rtJack_Error(csound, -1, Str("device name is too long")); s = (char*) malloc(nBytes+1); if (UNLIKELY(s == NULL)) rtJack_Error(csound, CSOUND_MEMORY, Str("memory allocation failure")); strcpy(s, parm->devName); *devName = s; } if (isOutput && p->inputEnabled) { /* full duplex audio I/O: check consistency of parameters */ if (UNLIKELY(p->nChannels != parm->nChannels || (unsigned int)p->bufSize != parm->bufSamp_SW)) rtJack_Error(csound, -1, Str("input and output parameters are not consistent")); if (UNLIKELY((unsigned int)((parm->bufSamp_SW / csound->GetKsmps(csound)) * csound->GetKsmps(csound)) != parm->bufSamp_SW)) rtJack_Error(csound, -1, Str("period size (-b) must be an integer multiple of ksmps")); } p->sampleRate = (int) parm->sampleRate; if (UNLIKELY((float) p->sampleRate != parm->sampleRate)) rtJack_Error(csound, -1, Str("sample rate must be an integer")); p->nChannels = parm->nChannels; p->bufSize = parm->bufSamp_SW; p->nBuffers = (parm->bufSamp_HW + parm->bufSamp_SW - 1) / parm->bufSamp_SW; }
static int start_jack(AVFormatContext *context, AVFormatParameters *params) { JackData *self = context->priv_data; jack_status_t status; int i, test; double o, period; /* Register as a JACK client, using the context filename as client name. */ self->client = jack_client_open(context->filename, JackNullOption, &status); if (!self->client) { av_log(context, AV_LOG_ERROR, "Unable to register as a JACK client\n"); return AVERROR(EIO); } sem_init(&self->packet_count, 0, 0); self->sample_rate = jack_get_sample_rate(self->client); self->nports = params->channels; self->ports = av_malloc(self->nports * sizeof(*self->ports)); self->buffer_size = jack_get_buffer_size(self->client); /* Register JACK ports */ for (i = 0; i < self->nports; i++) { char str[16]; snprintf(str, sizeof(str), "input_%d", i + 1); self->ports[i] = jack_port_register(self->client, str, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); if (!self->ports[i]) { av_log(context, AV_LOG_ERROR, "Unable to register port %s:%s\n", context->filename, str); jack_client_close(self->client); return AVERROR(EIO); } } /* Register JACK callbacks */ jack_set_process_callback(self->client, process_callback, self); jack_on_shutdown(self->client, shutdown_callback, self); jack_set_xrun_callback(self->client, xrun_callback, self); /* Create time filter */ period = (double) self->buffer_size / self->sample_rate; o = 2 * M_PI * 1.5 * period; /// bandwidth: 1.5Hz self->timefilter = ff_timefilter_new (1.0 / self->sample_rate, sqrt(2 * o), o * o); /* Create FIFO buffers */ self->filled_pkts = av_fifo_alloc(FIFO_PACKETS_NUM * sizeof(AVPacket)); /* New packets FIFO with one extra packet for safety against underruns */ self->new_pkts = av_fifo_alloc((FIFO_PACKETS_NUM + 1) * sizeof(AVPacket)); if ((test = supply_new_packets(self, context))) { jack_client_close(self->client); return test; } return 0; }
int_fast32_t jack_init(struct jack_data* data) { pthread_mutex_lock(&data->jack_mutex); if (data->jack_client != NULL) goto good; jack_options_t jack_option = data->start_jack_server ? JackNullOption : JackNoStartServer; data->jack_client = jack_client_open(data->device, jack_option, 0); if (data->jack_client == NULL) { blog(LOG_ERROR, "jack_client_open Error:" "Could not create JACK client! %s", data->device); goto error; } data->jack_ports = (jack_port_t**)bzalloc( sizeof(jack_port_t*) * data->channels); for (unsigned int i = 0; i < data->channels; ++i) { char port_name[10] = {'\0'}; snprintf(port_name, sizeof(port_name), "in_%d", i+1); data->jack_ports[i] = jack_port_register(data->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); if (data->jack_ports[i] == NULL) { blog(LOG_ERROR, "jack_port_register Error:" "Could not create JACK port! %s", port_name); goto error; } } if (jack_set_process_callback(data->jack_client, jack_process_callback, data) != 0) { blog(LOG_ERROR, "jack_set_process_callback Error"); goto error; } if (jack_activate(data->jack_client) != 0) { blog(LOG_ERROR, "jack_activate Error:" "Could not activate JACK client!"); goto error; } good: pthread_mutex_unlock(&data->jack_mutex); return 0; error: pthread_mutex_unlock(&data->jack_mutex); return 1; }
jack_client_t* init_jack(void) { jack_client_t *client; const char *client_name = "simple_talker"; const char *server_name = NULL; jack_options_t options = JackNullOption; jack_status_t status; client = jack_client_open (client_name, options, &status, server_name); if (NULL == client) { fprintf (stderr, "jack_client_open() failed\n "); exit (1); } if (status & JackServerStarted) { fprintf (stderr, "JACK server started\n"); } if (status & JackNameNotUnique) { client_name = jack_get_client_name(client); fprintf (stderr, "unique name `%s' assigned\n", client_name); } jack_set_process_callback(client, process, 0); jack_on_shutdown(client, jack_shutdown, 0); if (jack_activate (client)) fprintf (stderr, "cannot activate client"); inputports = (jack_port_t**) malloc (CHANNELS * sizeof (jack_port_t*)); in = (jack_default_audio_sample_t**) malloc (CHANNELS * sizeof (jack_default_audio_sample_t*)); ringbuffer = jack_ringbuffer_create (SAMPLE_SIZE * DEFAULT_RINGBUFFER_SIZE * CHANNELS); jack_ringbuffer_mlock(ringbuffer); memset(in, 0, sizeof (jack_default_audio_sample_t*)*CHANNELS); memset(ringbuffer->buf, 0, ringbuffer->size); for(int i = 0; i < CHANNELS; i++) { char* portName; if (asprintf(&portName, "input%d", i) < 0) { fprintf(stderr, "Could not create portname for port %d", i); exit(1); } inputports[i] = jack_port_register (client, portName, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); if (NULL == inputports[i]) { fprintf (stderr, "cannot register input port \"%d\"!\n", i); jack_client_close (client); exit (1); } } return client; }
JackCpp::AudioIO::AudioIO(std::string name, unsigned int inPorts, unsigned int outPorts, bool startServer) throw(std::runtime_error) : mCmdBuffer(256,true) { jack_options_t jack_open_options = JackNullOption; if(startServer == false) jack_open_options = JackNoStartServer; mJackState = notActive; //set the error callback jack_set_error_function (error_callback); /* try to become a client of the JACK server */ if ((mJackClient = jack_client_open (name.c_str(), jack_open_options, NULL)) == 0) { throw std::runtime_error("cannot create client jack server not running?"); } #ifdef __APPLE__ else { // because the mac version of jack is being totally LAME sleep(2); } #endif //set the shutdown callback jack_on_shutdown (mJackClient, shutdown_callback, this); //allocate ports if (inPorts > 0){ for(unsigned int i = 0; i < inPorts; i++){ std::string portname = "input"; portname.append(ToString(i)); mInputPorts.push_back( jack_port_register (mJackClient, portname.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0)); mPortNames.push_back(portname); } //reserve the data for the jack callback buffers for(unsigned int i = 0; i < mInputPorts.size(); i++) mJackInBuf.push_back(NULL); } if (outPorts > 0){ for(unsigned int i = 0; i < outPorts; i++){ std::string portname = "output"; portname.append(ToString(i)); mOutputPorts.push_back( jack_port_register (mJackClient, portname.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0)); mPortNames.push_back(portname); } //reserve the data for the jack callback buffers for(unsigned int i = 0; i < mOutputPorts.size(); i++) mJackOutBuf.push_back(NULL); } //set up the callback if(0 != jack_set_process_callback (mJackClient, JackCpp::AudioIO::jackProcessCallback, this)) throw std::runtime_error("cannot register process callback"); }
int main (int argc, char *argv[]) { jack_status_t status; /* parse and validate command arguments */ if (parse_args (argc, argv)) exit (1); /* invalid command line */ /* first, become a JACK client */ client = jack_client_open (client_name, JackServerName, &status, server_name); if (client == NULL) { fprintf (stderr, "jack_client_open() failed, " "status = 0x%2.0x\n", status); if (status & JackServerFailed) { fprintf (stderr, "Unable to connect to JACK server\n"); } exit (1); } /* then, load the internal client */ jack_internal_client_load (client, intclient_name, (JackLoadName|JackLoadInit), &status, intclient, load_name, load_init); if (status & JackNameNotUnique) { fprintf (stderr, "unique internal client name `%s' assigned\n", load_name); return 3; } if (status & JackFailure) { fprintf (stderr, "could not load %s, status = 0x%x\n", client_name, status); return 2; } fprintf (stdout, "%s is running.\n", load_name); if (wait_opt) { /* define a signal handler to unload the client, then * wait for it to exit */ signal (SIGQUIT, signal_handler); signal (SIGTERM, signal_handler); signal (SIGHUP, signal_handler); signal (SIGINT, signal_handler); while (1) { sleep (1); } } return 0; }
int main(int narg, char **args) { int i; jack_nframes_t nframes; if((narg<6) || ((narg-3)%3 !=0)) { usage(); exit(1); } if((client = jack_client_open (args[1], JackNullOption, NULL)) == 0) { fprintf (stderr, "JACK server not running?\n"); return 1; } jack_set_process_callback (client, process, 0); output_port = jack_port_register (client, "out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0); nframes = jack_get_buffer_size(client); loop_index = 0; num_notes = (narg - 3)/3; note_frqs = malloc(num_notes*sizeof(unsigned char)); note_starts = malloc(num_notes*sizeof(jack_nframes_t)); note_lengths = malloc(num_notes*sizeof(jack_nframes_t)); loop_nsamp = atoi(args[2]); for(i=0; i<num_notes; i++) { note_starts[i] = atoi(args[3 + 3*i]); note_frqs[i] = atoi(args[4 + 3*i]); note_lengths[i] = atoi(args[5 + 3*i]); } if (jack_activate(client)) { fprintf (stderr, "cannot activate client"); return 1; } /* install a signal handler to properly quits jack client */ #ifndef WIN32 signal(SIGQUIT, signal_handler); signal(SIGHUP, signal_handler); #endif signal(SIGTERM, signal_handler); signal(SIGINT, signal_handler); /* run until interrupted */ while (1) { #ifdef WIN32 Sleep(1*1000); #else sleep(1); #endif }; jack_client_close(client); exit (0); }
int JACKstart(HOR *hor_) { JackOUT=hor_; jackclient = jack_client_open("Horgand",options,&status,NULL);; if (jackclient == NULL) { fprintf (stderr, "Cannot make a jack client, back to Alsa\n"); return (2); }; JackOUT->SAMPLE_RATE=DSAMPLE_RATE; fprintf (stderr, "Internal SampleRate = %d\nJack Output SampleRate= %d\n", JackOUT->SAMPLE_RATE, jack_get_sample_rate (jackclient)); if ((unsigned int) jack_get_sample_rate (jackclient) != (unsigned int) JackOUT->SAMPLE_RATE) fprintf (stderr, "Adjusting SAMPLE_RATE to jackd.\n"); JackOUT->SAMPLE_RATE = jack_get_sample_rate(jackclient); JackOUT->PERIOD = jack_get_buffer_size (jackclient); JackOUT->Put_Period(); jack_set_process_callback (jackclient, jackprocess, 0); outport_left = jack_port_register (jackclient, "out_1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput | JackPortIsTerminal, 0); outport_right = jack_port_register (jackclient, "out_2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput | JackPortIsTerminal, 0); jack_midi_in = jack_port_register(jackclient, "in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0); if (jack_activate (jackclient)) { fprintf (stderr, "Cannot activate jack client, back to Alsa\n"); return (2); }; jack_connect (jackclient, jack_port_name (outport_left), "alsa_pcm:playback_1"); jack_connect (jackclient, jack_port_name (outport_right), "alsa_pcm:playback_2"); pthread_mutex_init (&jmutex, NULL); return 3; };
ezjack_bundle_t *ezjack_open(const char *client_name, int inputs, int outputs, int bufsize, float freq, ezjack_portflags_t flags) { int i; ezjack_bundle_t bun; char namebuf[16]; // Open client jack_status_t temperr = lasterr; bun.client = jack_client_open(client_name, JackNoStartServer, &temperr); lasterr = temperr; if(bun.client == NULL) return NULL; bun.freq = freq; bun.bufsize = bufsize; bun.fbuflen = 0; bun.fbuf = NULL; // Create some ports bun.portstack.incount = 0; bun.portstack.outcount = 0; #define HELPER_OPEN_PORTS(foo, fooputs, foocount, foorb, foobuf, foofmt, flags) \ for(i = 0; i < fooputs; i++) \ { \ snprintf(namebuf, 16, foofmt, i+1); \ bun.portstack.foo[i] = jack_port_register(bun.client, namebuf, JACK_DEFAULT_AUDIO_TYPE, flags, bufsize); \ if(bun.portstack.foo[i] == NULL) \ { \ lasterr = JackFailure; \ jack_client_close(bun.client); \ return NULL; \ } \ \ bun.portstack.foorb[i] = jack_ringbuffer_create(bufsize*sizeof(float)); \ bun.portstack.foobuf[i] = malloc(bufsize*sizeof(float)); \ \ bun.portstack.foocount++; \ } HELPER_OPEN_PORTS(in, inputs, incount, inrb, inbuf, "in_%i", JackPortIsInput); HELPER_OPEN_PORTS(out, outputs, outcount, outrb, outbuf, "out_%i", JackPortIsOutput); #undef HELPER_OPEN_PORTS // Prepare our bundle ezjack_bundle_t *ret = malloc(sizeof(ezjack_bundle_t)); memcpy(ret, &bun, sizeof(ezjack_bundle_t)); // Set callback // FIXME: error needs to be acted upon jack_set_process_callback(bun.client, ezjack_default_callback, ret); return ret; }
void jack_init(NextFrameCb nfc) { // connect to jack if (!(jack = jack_client_open("mousemidi", JackNoStartServer, NULL))) err(1, "unable to connect to jack"); // register callbacks jack_on_shutdown(jack, $(void, () { exit(0); }), NULL);