void deactivate_audio(void) { if (is_active) { jack_deactivate(client); is_active = false; } }
PRIVATE void clock_handler(AClock *clock, AClockReason reason) { switch (reason) { case CLOCK_DISABLE: jack_deactivate( jack_client ); break; case CLOCK_ENABLE: jack_set_process_callback( jack_client, (JackProcessCallback) process_callback, NULL ); jack_on_shutdown (jack_client, jack_shutdown, 0); jack_activate( jack_client ); lash_event_t *event; if( lash_enabled( galan_lash_get_client() ) ) { event = lash_event_new_with_type(LASH_Jack_Client_Name); lash_event_set_string(event, jack_get_client_name( jack_client ) ); lash_send_event( galan_lash_get_client(), event); } break; default: g_message("Unreachable code reached (jack_output)... reason = %d", reason); break; } }
void process_info_destroy (process_info_t * procinfo) { jack_deactivate (procinfo->jack_client); jack_client_close (procinfo->jack_client); g_free (procinfo); }
void JackCpp::AudioIO::stop() throw(std::runtime_error) { if (jack_deactivate(mJackClient) != 0) throw std::runtime_error("cannot deactivate the client"); mJackState = notActive; }
static void ja_free(void *data) { int i; jack_t *jd = (jack_t*)data; jd->shutdown = true; if (jd->client != NULL) { jack_deactivate(jd->client); jack_client_close(jd->client); } for (i = 0; i < 2; i++) if (jd->buffer[i] != NULL) jack_ringbuffer_free(jd->buffer[i]); #ifdef HAVE_THREADS if (jd->cond_lock) slock_free(jd->cond_lock); if (jd->cond) scond_free(jd->cond); #endif free(jd); }
bool JackAudioInterface::stop() { if (m_client) { int result = jack_deactivate(m_client); if (result != 0) { qDebug("JackAudioInterface::~JackAudioInterface() couldn't deactivate jack client"); } } // free input ports if (m_inputPorts) { for (unsigned int ch = 0; ch < m_channels; ch++) { if (m_inputPorts[ch]) { jack_port_unregister(m_client, m_inputPorts[ch]); m_inputPorts[ch] = NULL; } } delete[] m_inputPorts; m_inputPorts = NULL; } if (!close_jack_client()) { qDebug() << "JackAudioInterface::~JackAudioInterface() couldn't close JACK client" << endl; } return true; }
static int instream_pause_jack(struct SoundIoPrivate *si, struct SoundIoInStreamPrivate *is, bool pause) { SoundIoInStreamJack *isj = &is->backend_data.jack; SoundIoInStream *instream = &is->pub; SoundIoJack *sij = &si->backend_data.jack; if (sij->is_shutdown) return SoundIoErrorBackendDisconnected; int err; if (pause) { if ((err = jack_deactivate(isj->client))) return SoundIoErrorStreaming; } else { if ((err = jack_activate(isj->client))) return SoundIoErrorStreaming; for (int ch = 0; ch < instream->layout.channel_count; ch += 1) { SoundIoInStreamJackPort *isjp = &isj->ports[ch]; const char *source_port_name = isjp->source_port_name; // allow unconnected ports if (!source_port_name) continue; const char *dest_port_name = jack_port_name(isjp->dest_port); if ((err = jack_connect(isj->client, source_port_name, dest_port_name))) return SoundIoErrorStreaming; } } return 0; }
static CS_NOINLINE void rtclose_(CSOUND *csound) { RtJackGlobals p; RtJackGlobals *pp; int i; pp = (RtJackGlobals*) csound->QueryGlobalVariable(csound, "_rtjackGlobals"); if (pp == NULL) return; *(csound->GetRtPlayUserData(csound)) = NULL; *(csound->GetRtRecordUserData(csound)) = NULL; memcpy(&p, pp, sizeof(RtJackGlobals)); /* free globals */ if (p.client != (jack_client_t*) NULL) { /* deactivate client */ //if (p.jackState != 2) { //if (p.jackState == 0) // csound->Sleep((size_t) // ((int) ((double) (p.bufSize * p.nBuffers) // * 1000.0 / (double) p.sampleRate + 0.999))); jack_deactivate(p.client); //} csound->Sleep((size_t) 50); /* unregister and free all ports */ if (p.inPorts != NULL) { for (i = 0; i < p.nChannels; i++) { if (p.inPorts[i] != NULL && p.jackState != 2) jack_port_unregister(p.client, p.inPorts[i]); } } if (p.outPorts != NULL) { for (i = 0; i < p.nChannels; i++) { if (p.outPorts[i] != NULL && p.jackState != 2) jack_port_unregister(p.client, p.outPorts[i]); } } /* close connection */ if (p.jackState != 2) { jack_client_close(p.client); } } /* free copy of input and output device name */ if (p.inDevName != NULL) free(p.inDevName); if (p.outDevName != NULL) free(p.outDevName); /* free ports and port buffer pointers */ if (p.inPorts != NULL) free(p.inPorts); if (p.inPortBufs != NULL) free(p.inPortBufs); if (p.outPorts != NULL) free(p.outPorts); if (p.outPortBufs != NULL) free(p.outPortBufs); /* free ring buffers */ rtJack_DeleteBuffers(&p); csound->DestroyGlobalVariable(csound, "_rtjackGlobals"); }
void ezjack_close(ezjack_bundle_t *bun) { int i; jack_deactivate(bun->client); for(i = 0; i < bun->portstack.incount; i++) { jack_ringbuffer_free(bun->portstack.inrb[i]); free(bun->portstack.inbuf[i]); } for(i = 0; i < bun->portstack.outcount; i++) { jack_ringbuffer_free(bun->portstack.outrb[i]); free(bun->portstack.outbuf[i]); } if(bun->fbuf != NULL) free(bun->fbuf); jack_client_close(bun->client); free(bun); }
JackAudioSystem::~JackAudioSystem() { QMutexLocker lock(&qmWait); if (client) { int err = 0; err = jack_deactivate(client); if (err != 0) { qWarning("JackAudioSystem: unable to remove client from the process graph - jack_deactivate() returned %i", err); } bActive = false; err = jack_client_close(client); if (err != 0) { qWarning("JackAudioSystem: unable to disconnect from the server - jack_client_close() returned %i", err); } delete [] output_buffer; output_buffer = NULL; client = NULL; } bJackIsGood = false; }
const char * Client::name ( const char *s ) { /* Because the JACK API does not provide a mechanism for renaming * clients, we have to save connections, destroy our client, * create a client with the new name, and restore our * connections. Lovely. */ freeze_ports(); jack_deactivate( _client ); jack_client_close( _client ); _client = NULL; _frozen.lock(); s = init( s ); thaw_ports(); _frozen.unlock(); return s; }
~PluginJack() { if (fClient == nullptr) return; jack_deactivate(fClient); #if DISTRHO_PLUGIN_IS_SYNTH jack_port_unregister(fClient, fPortMidiIn); fPortMidiIn = nullptr; #endif #if DISTRHO_PLUGIN_NUM_INPUTS > 0 for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i) { jack_port_unregister(fClient, fPortAudioIns[i]); fPortAudioIns[i] = nullptr; } #endif #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0 for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i) { jack_port_unregister(fClient, fPortAudioOuts[i]); fPortAudioOuts[i] = nullptr; } #endif jack_client_close(fClient); }
static void ja_terminate(void *arg) { (void) arg; if (ja_status != JA_STOPPED) { int i; ja_status = JA_STOPPED; if (client != NULL) { jack_deactivate(client); jack_client_close(client); client = NULL; } ja_free(ja_inputs); ja_free(ja_outputs); ja_free(input_ports); ja_free(output_ports); for (i = 0; i < ja_in_channels; i++) free(input_port_names[i]); ja_free(input_port_names); for (i = 0; i < ja_out_channels; i++) free(output_port_names[i]); ja_free(output_port_names); } }
void Jasmine::Impl::cleanup() { jack_deactivate(m_client); ports_destroy(m_ports_out); ports_destroy(m_ports_in); jack_client_close(m_client); }
MidiJack::~MidiJack() { if(jackClient()) { if( jack_port_unregister( jackClient(), m_input_port) != 0){ printf("Failed to unregister jack midi input\n"); } if( jack_port_unregister( jackClient(), m_output_port) != 0){ printf("Failed to unregister jack midi output\n"); } if(m_jackClient) { // an m_jackClient means we are handling the jack connection if( jack_deactivate(m_jackClient) != 0){ printf("Failed to deactivate jack midi client\n"); } if( jack_client_close(m_jackClient) != 0){ printf("Failed close jack midi client\n"); } } } if( isRunning() ) { m_quit = true; wait( 1000 ); terminate(); } }
void JackClosePlay(void *port){ int lokke; struct Jackplay *jackplay=(struct Jackplay *)port; while(jackplay->unread>0){ usleep(100); } for(lokke=0;lokke<jackplay->fftsound->samps_per_frame;lokke++){ jack_disconnect( jackplay->client, jack_port_name(jackplay->jpc[lokke].output_port), outportnames[lokke] ); jack_port_unregister( jackplay->client,jackplay->jpc[lokke].output_port ); } jack_deactivate(jackplay->client); // fprintf(stderr,"closing client\n"); // jack_client_close (jackplay->client); // globalclient=NULL; free(jackplay); }
//----------------------------------------------------------------------------------------- void JackVST::Close() { fStatus = kIsOff; list<JackVST*>::iterator it; printf("actually there are %ld instances.\n",JackVST::fPlugInList.size()); JackVST::fPlugInList.remove(this); printf("now there are %ld instances.\n",JackVST::fPlugInList.size()); for(int i = 0; i < fInPortsNum; i++) { RingBuffer_Flush(&fRingBufferIn[i]); free(fRBufferIn[i]); jack_port_unregister(JackVST::fJackClient,fInPorts[i]); printf("unregistering in port %d.\n",i); } free(fInPorts); for(int i = 0; i < fOutPortsNum; i++) { RingBuffer_Flush(&fRingBufferIn[i]); free(fRBufferOut[i]); jack_port_unregister(JackVST::fJackClient,fOutPorts[i]); printf("unregistering out port %d.\n",i); } free(fOutPorts); if(JackVST::fPlugInList.size() == 0) { printf("closing client.\n"); jack_deactivate(JackVST::fJackClient); jack_client_close(JackVST::fJackClient); JackVST::fJackClient = NULL; JackVST::fInstances = 0; } }
void cleanup() { if (j_client) { jack_deactivate(j_client); jack_client_close (j_client); } j_client=NULL; }
int JackProxyDriver::Stop() { if (fClient && (jack_deactivate(fClient) != 0)) { jack_error("Cannot deactivate jack client."); return -1; } return 0; }
/** Tell JACK to stop calling process callback. This MUST be called in * an inheriting class' destructor */ void Client::deactivate ( ) { if ( _active ) jack_deactivate( _client ); _active = false; }
void mfp_jack_shutdown(mfp_context * ctxt) { printf("jack_shutdown: closing client, good-bye!\n"); jack_deactivate(ctxt->info.jack->client); jack_client_close(ctxt->info.jack->client); ctxt->info.jack->client = NULL; }
int JackAudioSystem::deactivate(QString *err_msg) { int rv = 0; if(_client) { rv = jack_deactivate(_client); } return rv; }
int Server_jack_stop(Server *self) { PyoJackBackendData *be_data = (PyoJackBackendData *) self->audio_be_data; int ret = jack_deactivate(be_data->jack_client); if (ret) Server_error(self, "Jack error: cannot deactivate jack client.\n"); self->server_started = 0; return ret; }
bool Out_JACK::Stop() { // Stop! if(jack_deactivate(JackClient) != 0) {printf("ERROR: out_jack: Couldn't deactivate JACK client.\n"); return false; } jack_client_close(JackClient); return true; }
ExternalMetro::~ExternalMetro() { jack_deactivate(client); jack_port_unregister(client, input_port); jack_port_unregister(client, output_port); jack_client_close(client); free(amp); free(wave); }
void close_jack(void) { if (jack_client) { jack_client_t *b = jack_client; jack_client=NULL; jack_deactivate (b); jack_client_close (b); } jack_client=NULL; }
void dev_jack_shutdown(void *arg) { SoundDevice *dev = (SoundDevice*)arg; // close the jack channels dev->jack = false; jack_port_unregister(dev->get_jack_client(), dev->get_jack_in_port()); jack_port_unregister(dev->get_jack_client(), dev->get_jack_out_port()); jack_deactivate(dev->get_jack_client()); delete dev->get_jack_in_pipe(); delete dev->get_jack_out_pipe(); }
int engine_jack_stop(engine_t* engine){ if (jack_deactivate(client)) return -1; /*engine is now inactive*/ engine->state = ENGINE_STATE_INACTIVE; return 0; }
static void jack_shutdown (void *arg) { error("JACK: server shut down"); jack_deactivate (jack_client); //jack_client_close(jack_client); /* likely to hang if the server shut down */ jack_client = NULL; glob_audio_setapi(NULL, API_NONE); // set pd_whichapi 0 }
void jack_raw_output::start () { check_idle (); jack_activate (_client); auto grd_activate = base::make_guard ([&] { jack_deactivate (_client); }); connect_ports (); grd_activate.dismiss (); set_state (async_state::running); }