int JackOutput::init( unsigned /*nBufferSize*/ ) { Preferences* pref = Preferences::get_instance(); output_port_name_1 = pref->m_sJackPortName1; output_port_name_2 = pref->m_sJackPortName2; QString sClientName = "Hydrogen"; #ifdef H2CORE_HAVE_NSMSESSION QString nsmClientId = pref->getNsmClientId(); if(!nsmClientId.isEmpty()){ sClientName = nsmClientId; } #endif jack_status_t status; int tries = 2; // Sometimes jackd doesn't stop and start fast enough. while ( tries > 0 ) { --tries; #ifdef H2CORE_HAVE_JACKSESSION if (pref->getJackSessionUUID().isEmpty()){ client = jack_client_open( sClientName.toLocal8Bit(), JackNullOption, &status); } else { const QByteArray uuid = pref->getJackSessionUUID().toLocal8Bit(); client = jack_client_open( sClientName.toLocal8Bit(), JackSessionID, &status, uuid.constData()); } #else client = jack_client_open( sClientName.toLocal8Bit(), JackNullOption, &status); #endif switch(status) { case JackFailure: CLIENT_FAILURE("unknown error"); break; case JackInvalidOption: CLIENT_FAILURE("invalid option"); break; case JackNameNotUnique: if (client) { sClientName = jack_get_client_name(client); CLIENT_SUCCESS(QString("Jack assigned the client name '%1'").arg(sClientName)); } else { CLIENT_FAILURE("name not unique"); } break; case JackServerStarted: CLIENT_SUCCESS("JACK Server started for Hydrogen."); break; case JackServerFailed: CLIENT_FAILURE("unable to connect"); break; case JackServerError: CLIENT_FAILURE("communication error"); break; case JackNoSuchClient: CLIENT_FAILURE("unknown client type"); break; case JackLoadFailure: CLIENT_FAILURE("can't load internal client"); break; case JackInitFailure: CLIENT_FAILURE("can't initialize client"); break; case JackShmFailure: CLIENT_FAILURE("unable to access shared memory"); break; case JackVersionError: CLIENT_FAILURE("client/server protocol version mismatch"); default: if (status) { ERRORLOG("Unknown status with JACK server."); if (client) { CLIENT_SUCCESS("Client pointer is *not* null..." " assuming we're OK"); } } else { CLIENT_SUCCESS("Connected to JACK server"); } } } if (client == 0) return -1; // Here, client should either be valid, or NULL. jack_server_sampleRate = jack_get_sample_rate ( client ); jack_server_bufferSize = jack_get_buffer_size ( client ); pref->m_nSampleRate = jack_server_sampleRate; pref->m_nBufferSize = jack_server_bufferSize; /* tell the JACK server to call `process()' whenever there is work to be done. */ jack_set_process_callback ( client, this->processCallback, 0 ); /* tell the JACK server to call `srate()' whenever the sample rate of the system changes. */ jack_set_sample_rate_callback ( client, jackDriverSampleRate, this ); /* tell JACK server to update us if the buffer size (frames per process cycle) changes. */ jack_set_buffer_size_callback ( client, jackDriverBufferSize, 0 ); /* tell the JACK server to call `jack_shutdown()' if it ever shuts down, either entirely, or if it just decides to stop calling us. */ jack_on_shutdown ( client, jackDriverShutdown, 0 ); /* create two ports */ output_port_1 = jack_port_register ( client, "out_L", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); output_port_2 = jack_port_register ( client, "out_R", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); Hydrogen *H = Hydrogen::get_instance(); if ( ( output_port_1 == NULL ) || ( output_port_2 == NULL ) ) { H->raiseError( Hydrogen::JACK_ERROR_IN_PORT_REGISTER ); return 4; } // clear buffers // jack_default_audio_sample_t *out_L = (jack_default_audio_sample_t *) jack_port_get_buffer (output_port_1, jack_server_bufferSize); // jack_default_audio_sample_t *out_R = (jack_default_audio_sample_t *) jack_port_get_buffer (output_port_2, jack_server_bufferSize); // memset( out_L, 0, nBufferSize * sizeof( float ) ); // memset( out_R, 0, nBufferSize * sizeof( float ) ); #ifdef H2CORE_HAVE_LASH if ( pref->useLash() ){ LashClient* lashClient = LashClient::get_instance(); if (lashClient->isConnected()) { lashClient->setJackClientName(sClientName.toLocal8Bit().constData()); } } #endif #ifdef H2CORE_HAVE_JACKSESSION jack_set_session_callback (client, jack_session_callback, (void*)this); #endif if ( pref->m_bJackMasterMode == Preferences::USE_JACK_TIME_MASTER ) initTimeMaster(); return 0; }
int JackAudioDriver::init( unsigned bufferSize ) { // Destination ports the output of Hydrogen will be connected // to. Preferences* pPref = Preferences::get_instance(); output_port_name_1 = pPref->m_sJackPortName1; output_port_name_2 = pPref->m_sJackPortName2; QString sClientName = "Hydrogen"; #ifdef H2CORE_HAVE_OSC QString sNsmClientId = pPref->getNsmClientId(); if(!sNsmClientId.isEmpty()){ sClientName = sNsmClientId; } #endif // The address of the status object will be used by JACK to // return information from the open operation. jack_status_t status; // Sometimes jackd doesn't stop and start fast enough. int nTries = 2; while ( nTries > 0 ) { --nTries; // Open an external client session with the JACK // server. The `jack_client_open' function is defined // in the jack/jack.h header. With it, clients may // choose which of several servers to connect, and // control whether and how to start the server // automatically, if it was not already running. Its // first argument _client_name_ of is at most // jack_client_name_size() characters. The name scope // is local to each server. Unless forbidden by the // JackUseExactName option, the server will modify // this name to create a unique variant, if // needed. The second argument _options_ is formed by // OR-ing together JackOptions bits. Only the // JackOpenOptions bits are allowed. _status_ (if // non-NULL) is an address for JACK to return // information from the open operation. This status // word is formed by OR-ing together the relevant // JackStatus bits. Depending on the _status_, an // optional argument _server_name_ selects from among // several possible concurrent server // instances. Server names are unique to each user. It // returns an opaque client handle if successful. If // this is NULL, the open operation failed, *status // includes JackFailure and the caller is not a JACK // client. #ifdef H2CORE_HAVE_JACKSESSION if (pPref->getJackSessionUUID().isEmpty()){ m_pClient = jack_client_open( sClientName.toLocal8Bit(), JackNullOption, &status); } else { // Unique name of the JACK server used within // the JACK session. const QByteArray uuid = pPref->getJackSessionUUID().toLocal8Bit(); // Using the JackSessionID option and the // supplied SessionID Token the sessionmanager // is able to identify the client again. m_pClient = jack_client_open( sClientName.toLocal8Bit(), JackSessionID, &status, uuid.constData()); } #else m_pClient = jack_client_open( sClientName.toLocal8Bit(), JackNullOption, &status); #endif // Check what did happen during the opening of the // client. CLIENT_SUCCESS sets the nTries variable // to 0 while CLIENT_FAILURE resets m_pClient to the // nullptr. switch(status) { case JackFailure: CLIENT_FAILURE("unknown error"); break; case JackInvalidOption: CLIENT_FAILURE("invalid option"); break; case JackNameNotUnique: if (m_pClient) { sClientName = jack_get_client_name(m_pClient); CLIENT_SUCCESS(QString("Jack assigned the client name '%1'").arg(sClientName)); } else { CLIENT_FAILURE("name not unique"); } break; case JackServerStarted: CLIENT_SUCCESS("JACK Server started for Hydrogen."); break; case JackServerFailed: CLIENT_FAILURE("unable to connect"); break; case JackServerError: CLIENT_FAILURE("communication error"); break; case JackNoSuchClient: CLIENT_FAILURE("unknown client type"); break; case JackLoadFailure: CLIENT_FAILURE("can't load internal client"); break; case JackInitFailure: CLIENT_FAILURE("can't initialize client"); break; case JackShmFailure: CLIENT_FAILURE("unable to access shared memory"); break; case JackVersionError: CLIENT_FAILURE("client/server protocol version mismatch"); break; default: if (status) { ERRORLOG("Unknown status with JACK server."); if (m_pClient) { CLIENT_SUCCESS("Client pointer is *not* null..." " assuming we're OK"); } } else { CLIENT_SUCCESS("Connected to JACK server"); } } } if (m_pClient == 0) return -1; // Here, client should either be valid, or NULL. jack_server_sampleRate = jack_get_sample_rate( m_pClient ); jack_server_bufferSize = jack_get_buffer_size( m_pClient ); pPref->m_nSampleRate = jack_server_sampleRate; pPref->m_nBufferSize = jack_server_bufferSize; /* tell the JACK server to call `process()' whenever there is work to be done. */ jack_set_process_callback( m_pClient, this->processCallback, 0 ); /* tell the JACK server to call `srate()' whenever the sample rate of the system changes. */ jack_set_sample_rate_callback( m_pClient, jackDriverSampleRate, this ); /* tell JACK server to update us if the buffer size (frames per process cycle) changes. */ jack_set_buffer_size_callback( m_pClient, jackDriverBufferSize, 0 ); /* tell the JACK server to call `jack_shutdown()' if it ever shuts down, either entirely, or if it just decides to stop calling us. */ jack_on_shutdown( m_pClient, jackDriverShutdown, 0 ); // Create two new ports for Hydrogen's client. These are // objects used for moving data of any type in or out of the // client. Ports may be connected in various ways. The // function `jack_port_register' (jack/jack.h) is called like // jack_port_register( jack_client_t *client, // const char *port_name, // const char *port_type, // unsigned long flags, // unsigned long buffer_size) // // All ports have a type, which may be any non-NULL and non-zero // length string, passed as an argument. Some port types are built // into the JACK API, currently only JACK_DEFAULT_AUDIO_TYPE. // It returns a _jack_port_t_ pointer on success, otherwise NULL. output_port_1 = jack_port_register( m_pClient, "out_L", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); output_port_2 = jack_port_register( m_pClient, "out_R", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 ); Hydrogen *pEngine = Hydrogen::get_instance(); if ( ( output_port_1 == NULL ) || ( output_port_2 == NULL ) ) { pEngine->raiseError( Hydrogen::JACK_ERROR_IN_PORT_REGISTER ); return 4; } #ifdef H2CORE_HAVE_LASH if ( pPref->useLash() ){ LashClient* lashClient = LashClient::get_instance(); if (lashClient->isConnected()) { lashClient->setJackClientName(sClientName.toLocal8Bit().constData()); } } #endif #ifdef H2CORE_HAVE_JACKSESSION jack_set_session_callback(m_pClient, jack_session_callback, (void*)this); #endif if ( pPref->m_bJackMasterMode == Preferences::USE_JACK_TIME_MASTER ){ // Make Hydrogen the timebase master, regardless if there // is already a timebase master present. m_nJackConditionalTakeOver = 0; // Make Hydrogen the JACK timebase master. initTimeMaster(); } return 0; }