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;
}
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 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
}
}
/* 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;
}
DspAudioJackOut::DspAudioJackOut( DspOutRtp *inrtp, const QString &name )
{
jack_clientName = name;
audio_stereo = false;
input = inrtp;
if ((jack_client = jack_client_new( jack_clientName )) == 0 ) {
printf( "CallAudioJackOut: Error, jack server not running?\n" );
return;
}
jack_thread_info_t thread_info;
thread_info.client = jack_client;
thread_info.channels = 1;
thread_info.ready = 0;
thread_info.running = 0;
jack_set_process_callback( jack_client, jack_callaudio_process, &thread_info );
jack_on_shutdown( jack_client, jack_callaudio_shutdown, &thread_info );
if (jack_activate( jack_client )) {
fprintf (stderr, "cannot activate client");
}
setup_port_out( 1, "alsa_pcm:playback_1", &thread_info);
}
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;
}
// ========================
// = 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);
}
}
// 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;
}
int cs_dsf_init(cs_dsf_t *self, const char *client_name, jack_options_t flags, char *server_name) {
int r = cs_synth_init((cs_synth_t *) self, client_name, flags, server_name);
if(r != 0) {
return r;
}
self->bright_port = jack_port_register(self->client, "bright", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
if(self->bright_port == NULL) {
cs_synth_destroy((cs_synth_t *) self);
return -1;
}
atomic_set(&self->scale, 0);
atomic_float_set(&self->bright, 0.5);
self->t = 0.0;
r = jack_set_process_callback(self->client, cs_dsf_process, self);
if(r != 0) {
cs_synth_destroy((cs_synth_t *) self);
return r;
}
r = jack_activate(self->client);
if(r != 0) {
cs_synth_destroy((cs_synth_t *) self);
return r;
}
return 0;
}
static PaError StartStream( PaStream *s )
{
PaError result = paNoError;
PaJackStream *stream = (PaJackStream*)s;
int i;
/* start the audio thread */
jack_activate( stream->jack_client );
/* connect the ports */
/* NOTE: I would rather use jack_port_connect which uses jack_port_t's
* instead of port names, but it is not implemented yet. */
if( stream->num_incoming_connections > 0 )
{
for( i = 0; i < stream->num_incoming_connections; i++ )
jack_connect( stream->jack_client,
jack_port_name(stream->remote_output_ports[i]),
jack_port_name(stream->local_input_ports[i] ) );
}
if( stream->num_outgoing_connections > 0 )
{
for( i = 0; i < stream->num_outgoing_connections; i++ )
jack_connect( stream->jack_client,
jack_port_name(stream->local_output_ports[i]),
jack_port_name(stream->remote_input_ports[i]) );
}
stream->is_running = TRUE;
stream->is_active = TRUE;
return result;
}
bool Out_JACK::Go()
{
SampleRate = 0;
// Create a new JACK client.
JackClient = jack_client_new("Sinospan");
if(JackClient == NULL) { printf("FATAL: out_jack: Couldn't make JACK client\n"); return false; }
// Associate our render function as the JACK process callback
if(jack_set_process_callback(JackClient, R_pRender, (void*) this) != 0) { printf("ERROR: out_jack: Couldn't register processing callback\n"); }
// Set our sample rate change handler
if(jack_set_sample_rate_callback(JackClient, R_pNewSrate, (void*) this) != 0) { printf("WARNING: out_jack: Couldn't register sample rate callback.\n"); }
// Make our output port
JackOut1 = jack_port_register(JackClient, "Out", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
if(JackOut1 == NULL) { printf("FATAL: out_jack: Couldn't register an output port.\n"); return false; }
// Get the sample rate from the JACK server.
R_pNewSrate(jack_get_sample_rate(JackClient), (void*) this);
// It's go-time!
if(jack_activate(JackClient) != 0) { printf("ERROR: out_jack: Couldn't activate JACK client.\n"); return false; }
return true;
}
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 int oss_driver_attach (oss_driver_t *driver, jack_engine_t *engine)
{
int port_flags;
unsigned int channel;
char channel_name[64];
jack_port_t *port;
jack_latency_range_t range;
driver->engine = engine;
set_period_size(driver, driver->period_size);
if (engine->set_buffer_size(engine, driver->period_size)) {
jack_error ("OSS: cannot set engine buffer size to %d (check MIDI)", driver->period_size);
return -1;
}
engine->set_sample_rate(engine, driver->sample_rate);
port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;
for (channel = 0; channel < driver->capture_channels; channel++)
{
snprintf(channel_name, sizeof(channel_name),
"capture_%u", channel + 1);
port = jack_port_register(driver->client, channel_name,
JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (port == NULL)
{
jack_error("OSS: cannot register port for %s: %s@%i",
channel_name, __FILE__, __LINE__);
break;
}
range.min = range.max = driver->period_size + driver->sys_in_latency;
jack_port_set_latency_range(port, JackCaptureLatency, &range);
driver->capture_ports =
jack_slist_append(driver->capture_ports, port);
}
port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;
for (channel = 0; channel < driver->playback_channels; channel++)
{
snprintf(channel_name, sizeof(channel_name),
"playback_%u", channel + 1);
port = jack_port_register(driver->client, channel_name,
JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (port == NULL)
{
jack_error("OSS: cannot register port for %s: %s@%i",
channel_name, __FILE__, __LINE__);
break;
}
range.min = range.max = driver->period_size + driver->sys_out_latency;
jack_port_set_latency_range(port, JackPlaybackLatency, &range);
driver->playback_ports =
jack_slist_append(driver->playback_ports, port);
}
jack_activate(driver->client);
return 0;
}
int JackSimpleClient::activate(){
jack_activate (jackClient);
LOGD("JackSimpleClient::activate");
jack_connect (jackClient, jack_port_name (outPort), "out:playback_1");
return APA_RETURN_SUCCESS;
}
//--------------------------------------------------------------
void
ofxJackClient::activate()
{
if ((clientImpl != NULL) && (jack_activate(clientImpl) == 0))
{}
else
std::cerr << name << ":: cannot activate JACK client" << std::endl;
}
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;
}
// return 0: ok
// return 1: cannot activate client
// return 2: cannot connect output port
// return 3: Jack server not running
// return 4: output port = NULL
int JackOutput::connect()
{
INFOLOG( "connect" );
if ( jack_activate ( client ) ) {
Hydrogen::get_instance()->raiseError( Hydrogen::JACK_CANNOT_ACTIVATE_CLIENT );
return 1;
}
bool connect_output_ports = m_bConnectOutFlag;
memset( track_output_ports_L, 0, sizeof(track_output_ports_L) );
memset( track_output_ports_R, 0, sizeof(track_output_ports_R) );
#ifdef H2CORE_HAVE_LASH
if ( Preferences::get_instance()->useLash() ){
LashClient* lashClient = LashClient::get_instance();
if (lashClient && lashClient->isConnected())
{
// infoLog("[LASH] Sending Jack client name to LASH server");
lashClient->sendJackClientName();
if (!lashClient->isNewProject())
{
connect_output_ports = false;
}
}
}
#endif
if ( connect_output_ports ) {
// if ( m_bConnectOutFlag ) {
// connect the ports
if ( jack_connect( client, jack_port_name( output_port_1 ), output_port_name_1.toLocal8Bit() ) == 0 &&
jack_connect ( client, jack_port_name( output_port_2 ), output_port_name_2.toLocal8Bit() ) == 0 ) {
return 0;
}
INFOLOG( "Could not connect so saved out-ports. Connecting to first pair of in-ports" );
const char ** portnames = jack_get_ports ( client, NULL, NULL, JackPortIsInput );
if ( !portnames || !portnames[0] || !portnames[1] ) {
ERRORLOG( "Could't locate two Jack input port" );
Hydrogen::get_instance()->raiseError( Hydrogen::JACK_CANNOT_CONNECT_OUTPUT_PORT );
return 2;
}
if ( jack_connect( client, jack_port_name( output_port_1 ), portnames[0] ) != 0 ||
jack_connect( client, jack_port_name( output_port_2 ), portnames[1] ) != 0 ) {
ERRORLOG( "Could't connect to first pair of Jack input ports" );
Hydrogen::get_instance()->raiseError( Hydrogen::JACK_CANNOT_CONNECT_OUTPUT_PORT );
return 2;
}
free( portnames );
}
return 0;
}
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;
}
int
jack_initialize (jack_client_t *client, const char* load_init)
{
struct a2j* self = calloc(1, sizeof(struct a2j));
if (!self) {
return -1;
}
self->jack_client = client;
self->input = 1;
self->ignore_hardware_ports = 0;
self->finishing = 0;
if (load_init) {
char* args = strdup (load_init);
char* token;
char* ptr = args;
char* savep;
while (1) {
if ((token = strtok_r (ptr, ", ", &savep)) == NULL) {
break;
}
if (strncasecmp (token, "in", 2) == 0) {
self->input = 1;
}
if (strncasecmp (token, "out", 2) == 0) {
self->input = 0;
}
if (strncasecmp (token, "hw", 2) == 0) {
self->ignore_hardware_ports = 0;
}
ptr = NULL;
}
free (args);
}
if (connect_to_alsa (self)) {
free (self);
return -1;
}
jack_set_process_callback (client, a2j_process, self);
jack_set_freewheel_callback (client, a2j_freewheel, NULL);
jack_on_shutdown (client, a2j_shutdown, NULL);
jack_activate (client);
return 0;
}
static int
dummy_driver_attach (dummy_driver_t *driver)
{
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if (driver->engine->set_buffer_size (driver->engine, driver->period_size)) {
jack_error ("dummy: cannot set engine buffer size to %d (check MIDI)", driver->period_size);
return -1;
}
driver->engine->set_sample_rate (driver->engine, driver->sample_rate);
port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->capture_channels; chn++)
{
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn+1);
port = jack_port_register (driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port)
{
jack_error ("DUMMY: cannot register port for %s", buf);
break;
}
driver->capture_ports =
jack_slist_append (driver->capture_ports, port);
}
port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->playback_channels; chn++)
{
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn+1);
port = jack_port_register (driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port)
{
jack_error ("DUMMY: cannot register port for %s", buf);
break;
}
driver->playback_ports =
jack_slist_append (driver->playback_ports, port);
}
jack_activate (driver->client);
return 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;
};
static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
{
JackData *self = context->priv_data;
struct timespec timeout = {0, 0};
int test;
/* Activate the JACK client on first packet read. Activating the JACK client
* means that process_callback() starts to get called at regular interval.
* If we activate it in audio_read_header(), we're actually reading audio data
* from the device before instructed to, and that may result in an overrun. */
if (!self->activated) {
if (!jack_activate(self->client)) {
self->activated = 1;
av_log(context, AV_LOG_INFO,
"JACK client registered and activated (rate=%dHz, buffer_size=%d frames)\n",
self->sample_rate, self->buffer_size);
} else {
av_log(context, AV_LOG_ERROR, "Unable to activate JACK client\n");
return AVERROR(EIO);
}
}
/* Wait for a packet comming back from process_callback(), if one isn't available yet */
timeout.tv_sec = av_gettime() / 1000000 + 2;
if (sem_timedwait(&self->packet_count, &timeout)) {
if (errno == ETIMEDOUT) {
av_log(context, AV_LOG_ERROR,
"Input error: timed out when waiting for JACK process callback output\n");
} else {
av_log(context, AV_LOG_ERROR, "Error while waiting for audio packet: %s\n",
strerror(errno));
}
if (!self->client)
av_log(context, AV_LOG_ERROR, "Input error: JACK server is gone\n");
return AVERROR(EIO);
}
if (self->pkt_xrun) {
av_log(context, AV_LOG_WARNING, "Audio packet xrun\n");
self->pkt_xrun = 0;
}
if (self->jack_xrun) {
av_log(context, AV_LOG_WARNING, "JACK xrun\n");
self->jack_xrun = 0;
}
/* Retrieve the packet filled with audio data by process_callback() */
av_fifo_generic_read(self->filled_pkts, pkt, sizeof(*pkt), NULL);
if ((test = supply_new_packets(self, context)))
return test;
return 0;
}
static int iio_driver_attach (iio_driver_t *driver, jack_engine_t *engine) {
printf("iio_driver_attach\n");
// create ports
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if (driver->engine->set_buffer_size (driver->engine, driver->period_size)) {
jack_error ("iio: cannot set engine buffer size to %d", driver->period_size);
return -1;
}
driver->engine->set_sample_rate (driver->engine, driver->sample_rate);
port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->capture_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn+1);
port = jack_port_register (driver->client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
jack_error ("iio: cannot register port for %s", buf);
break;
}
//cout<<"Registered port "<<buf<<endl;
jack_latency_range_t range;
range.min = range.max = 1024;
//cout<<"fix latencies, range currently set to "<<range.min<<", "<<range.max<<endl;
jack_port_set_latency_range (port, JackCaptureLatency, &range);
driver->capture_ports = jack_slist_append (driver->capture_ports, port);
}
port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->playback_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn+1);
port = jack_port_register (driver->client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
jack_error ("iio: cannot register port for %s", buf);
break;
}
//cout<<"Registered port "<<buf<<endl;
jack_latency_range_t range;
range.min = range.max = 1024;
//cout<<"fix latencies, range currently set to "<<range.min<<", "<<range.max<<endl;
jack_port_set_latency_range (port, JackCaptureLatency, &range);
driver->playback_ports = jack_slist_append (driver->playback_ports, port);
}
return jack_activate (driver->client);
}
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 rmdStartJackClient(JackData *jdata){
float ring_buffer_size=0.0;
int pid;
char pidbuf[8];
char rmd_client_name[32];
//construct the jack client name
//which is recordMyDesktop-pid
//in order to allow multiple
//instances of recordMyDesktop
//to connetc to a Jack Server
strcpy(rmd_client_name,"recordMyDesktop-");
pid=getpid();
snprintf( pidbuf, 8, "%d", pid );
strcat(rmd_client_name,pidbuf);
if ((jdata->client=(*jack_client_new)(rmd_client_name))==0){
fprintf(stderr,"Could not create new client!\n"
"Make sure that Jack server is running!\n");
return 15;
}
//in contrast to ALSA and OSS, Jack dictates frequency
//and buffersize to the values it was launched with.
//Supposedly jack_set_buffer_size can set the buffersize
//but that causes some kind of halt and keeps giving me
//zero buffers.
//recordMyDesktop cannot handle buffer size changes.
//FIXME
//There is a callback for buffer size changes that I should use.
//It will provide clean exits, instead of ?segfaults? .
//Continuing though is not possible, with the current layout
//(it might be in some cases, but it will certainly be the cause
//of unpredicted problems). A clean exit is preferable
//and any recording up to that point will be encoded and saved.
jdata->frequency=jack_get_sample_rate(jdata->client);
jdata->buffersize=jack_get_buffer_size(jdata->client);
ring_buffer_size=(jdata->ringbuffer_secs*
jdata->frequency*
sizeof(jack_default_audio_sample_t)*
jdata->nports);
jdata->sound_buffer=
(*jack_ringbuffer_create)((int)(ring_buffer_size+0.5));//round up
jack_set_process_callback(jdata->client,rmdJackCapture,jdata);
jack_on_shutdown(jdata->client,rmdJackShutdown,jdata);
if (jack_activate(jdata->client)) {
fprintf(stderr,"cannot activate client!\n");
return 16;
}
if(rmdSetupPorts(jdata)){
jack_client_close(jdata->client);
return 17;
}
return 0;
}
int engine_jack_start(engine_t* engine){
if (jack_activate(client))
return -1;
/*engine is now active*/
engine->state = ENGINE_STATE_ACTIVE;
return 0;
}
int main(int argc, char *argv[]) {
/* try to become a client of the JACK server */
int c;
while ((c = getopt(argc, argv, "a:p:f:")) != -1)
switch (c) {
case 'a':
udp_ip = optarg;
break;
case 'p':
udp_port = atoi(optarg);
break;
case 'f':
framerate_out=atoi(optarg);
break;
default:
abort();
break;
}
framerate_out_delay=(int)(((float)1/(float)framerate_out)*(float)1000000);
printf("Starting..\n");
if ((client = jack_client_open("showtime", JackNullOption, NULL)) == 0) {
fprintf(stderr, "JACK server not running?\n");
return 1;
}
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGHUP, signal_handler);
signal(SIGINT, signal_handler);
/* 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, jack_shutdown, 0);
/* tell the JACK server that we are ready to roll */
if (jack_activate(client)) {
fprintf(stderr, "cannot activate client");
return 1;
}
while (1) {
usleep(framerate_out_delay);
showtime();
}
jack_client_close(client);
exit(0);
}
int JackSapaProxy::Setup(jack_client_t* client)
{
jack_log("JackSapaProxy::Setup");
//refer to system ports and create sapaproxy ports
unsigned int i = 0, j = 0;
const char **ports_system_capture;
const char **ports_system_playback;
unsigned int ports_system_capture_cnt = 0;
unsigned int ports_system_playback_cnt = 0;
char port_name[JACK_PORT_NAME_SIZE] = {0,};
ports_system_capture = jack_get_ports(client, "system:.*", NULL, JackPortIsPhysical | JackPortIsOutput);
if (ports_system_capture != NULL) {
for (i = 0; i < fCapturePorts && ports_system_capture[i]; i++) {
sprintf(port_name, "__system_capture_%d", i + 1);
fInputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
sprintf(port_name, "capture_%d", i + 1);
fOutputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
ports_system_capture_cnt++;
}
jack_free(ports_system_capture);
}
ports_system_playback = jack_get_ports(client, "system:.*", NULL, JackPortIsPhysical | JackPortIsInput);
if (ports_system_playback != NULL) {
for (j = 0; j < fPlaybackPorts && ports_system_playback[j]; j++, i++) {
sprintf(port_name, "playback_%d", j + 1);
fInputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
sprintf(port_name, "__system_playback_%d", j + 1);
fOutputPorts[i] = jack_port_register(client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
ports_system_playback_cnt++;
}
jack_free(ports_system_playback);
}
//store actual number of system ports
fCapturePorts = ports_system_capture_cnt;
fPlaybackPorts = ports_system_playback_cnt;
jack_set_process_callback(client, Process, this);
jack_activate(client);
//conenct between sapaproxy and system ports
for (unsigned int i = 0; i < ports_system_capture_cnt; i++) {
sprintf(port_name, "system:capture_%d", i + 1);
jack_connect(client, port_name, jack_port_name(fInputPorts[i]));
}
for (unsigned int i = 0; i < ports_system_playback_cnt; i++) {
sprintf(port_name, "system:playback_%d", i + 1);
jack_connect(client, jack_port_name(fOutputPorts[ports_system_capture_cnt + i]), port_name);
}
return 0;
}
process_info_t *
process_info_new (ui_t* ui, unsigned long rack_channels)
{
process_info_t* procinfo;
int err;
procinfo = g_malloc (sizeof (process_info_t));
procinfo->chain = NULL;
procinfo->chain_end = NULL;
procinfo->jack_client = NULL;
procinfo->port_count = 0;
procinfo->jack_input_ports = NULL;
procinfo->jack_output_ports = NULL;
procinfo->channels = rack_channels;
procinfo->time_runs = time_runs;
/* sort out the client name */
jack_client_name = g_strdup ( client_name->str );
sanitize_client_name ( jack_client_name );
err = process_info_connect_jack (procinfo, ui);
if (err == -1)
{
g_free (jack_client_name);
g_free (procinfo);
return NULL;
}
err = process_info_set_port_count (procinfo, ui, rack_channels);
if (err)
return NULL;
sample_rate = jack_get_sample_rate (procinfo->jack_client);
buffer_size = jack_get_sample_rate (procinfo->jack_client);
jack_set_process_callback (procinfo->jack_client, process, procinfo);
jack_on_shutdown (procinfo->jack_client, jack_shutdown_cb, ui);
#if HAVE_JACK_SESSION
if( jack_set_session_callback )
jack_set_session_callback (procinfo->jack_client, jack_session_cb_aux, ui);
#endif
procinfo->ui_to_process = ui->ui_to_process;
procinfo->process_to_ui = ui->process_to_ui;
jack_activate (procinfo->jack_client);
#ifdef HAVE_LASH
/* sort out LASH stuff */
lash_jack_client_name (global_lash_client, jack_client_name);
#endif
return procinfo;
}
uint_t aubio_jack_activate(aubio_jack_t *jack_setup) {
/* get sample rate */
jack_setup->samplerate = jack_get_sample_rate (jack_setup->client);
/* actual jack process activation */
if (jack_activate (jack_setup->client))
{
AUBIO_ERR("jack client activation failed");
return 1;
}
return 0;
}
