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
}
}
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;
}
void
init_jack (void)
{
int err;
#ifdef WITH_LASH
lash_event_t *event;
#endif
jack_client = jack_client_open(PROGRAM_NAME, JackNullOption, NULL);
if (jack_client == NULL)
{
g_critical("Could not connect to the JACK server; run jackd first?");
exit(EX_UNAVAILABLE);
}
#ifdef WITH_LASH
event = lash_event_new_with_type(LASH_Client_Name);
// assert(event); /* Documentation does not say anything about return value. */
lash_event_set_string(event, jack_get_client_name(jack_client));
lash_send_event(lash_client, event);
lash_jack_client_name(lash_client, jack_get_client_name(jack_client));
#endif
err = jack_set_process_callback(jack_client, process_callback, 0);
if (err)
{
g_critical("Could not register JACK process callback.");
exit(EX_UNAVAILABLE);
}
/*
* The above is pretty close to COMMON CODE.
*/
input_port = jack_port_register
(
jack_client, INPUT_PORT_NAME, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0
);
if (input_port == NULL)
{
g_critical("Could not register JACK input port.");
exit(EX_UNAVAILABLE);
}
if (jack_activate(jack_client)) {
g_critical("Cannot activate JACK client.");
exit(EX_UNAVAILABLE);
}
}
int lash_clinit(int argc, char** argv, jack_client_t *jack_client, snd_seq_t *alsa_handle)
{
lash_jackname = jack_get_client_name(jack_client);
lash_client = lash_init(lash_extract_args(&argc, &argv), lash_jackname, LASH_Config_File, LASH_PROTOCOL(2, 0));
if (lash_enabled(lash_client))
{
lash_jack_client_name(lash_client, lash_jackname);
lash_event_t *event = lash_event_new_with_type(LASH_Client_Name);
lash_event_set_string(event, lash_jackname);
lash_send_event(lash_client, event);
lash_alsaid = alsa_handle;
lash_alsa_client_id(lash_client, (unsigned char)snd_seq_client_id(alsa_handle));
return 0;
}
return -1;
}
bool
Lash::init ( int *argc, char ***argv, const char *jack_name )
{
MESSAGE( "Initializing LASH" );
if ( ! ( _client = lash_init( lash_extract_args( argc, argv ), APP_NAME,
LASH_Config_File, LASH_PROTOCOL( 2, 0 ) ) ) )
return false;
/* register name */
lash_jack_client_name( _client, jack_name );
lash_event_t *e = lash_event_new_with_type( LASH_Client_Name );
lash_event_set_string( e, APP_TITLE );
lash_send_event( _client, e );
return true;
}
int main(int argc, char *argv[])
{
unsigned int i;
int opt;
int help = 0;
int console = 0;
char port_name[32];
pthread_t dt;
#ifdef HAVE_LASH
lash_args_t *lash_args = lash_extract_args(&argc, &argv);
lash_event_t *event;
#endif
auto_begin_threshold = db2lin(DEFAULT_AUTO_BEGIN_THRESHOLD);
auto_end_threshold = db2lin(DEFAULT_AUTO_END_THRESHOLD);
while ((opt = getopt(argc, argv, "hic:t:n:p:f:sab:e:T:")) != -1) {
switch (opt) {
case 'h':
help = 1;
break;
case 'i':
console = 1;
break;
case 'c':
num_ports = atoi(optarg);
DEBUG(1, "ports: %d\n", num_ports);
break;
case 't':
buf_length = atoi(optarg);
DEBUG(1, "buffer: %ds\n", buf_length);
break;
case 'n':
client_name = optarg;
DEBUG(1, "client name: %s\n", client_name);
break;
case 'p':
prefix = optarg;
DEBUG(1, "prefix: %s\n", prefix);
break;
case 'f':
format_name = optarg;
break;
case 's':
safe_filename = 1;
break;
case 'a':
auto_record = 1;
break;
case 'b':
auto_begin_threshold = db2lin(atof(optarg));
break;
case 'e':
auto_end_threshold = db2lin(atof(optarg));
break;
case 'T':
auto_end_time = atoi(optarg);
break;
default:
num_ports = 0;
break;
}
}
if (optind != argc) {
num_ports = argc - optind;
}
if (num_ports < 1 || num_ports > MAX_PORTS || help) {
fprintf(stderr, "Usage %s: [-h] [-i] [-c channels] [-n jack-name]\n\t"
"[-t buffer-length] [-p file prefix] [-f format]\n\t"
"[-a] [-b begin-threshold] [-e end-threshold] [-T end-time]\n\t"
"[port-name ...]\n\n", argv[0]);
fprintf(stderr, "\t-h\tshow this help\n");
fprintf(stderr, "\t-i\tinteractive mode (console instead of X11) also enabled\n\t\tif DISPLAY is unset\n");
fprintf(stderr, "\t-c\tspecify number of recording channels\n");
fprintf(stderr, "\t-n\tspecify the JACK name timemachine will use\n");
fprintf(stderr, "\t-t\tspecify the pre-recording buffer length\n");
fprintf(stderr, "\t-p\tspecify the saved file prefix, may include path\n");
fprintf(stderr, "\t-s\tuse safer characters in filename (windows compatibility)\n");
fprintf(stderr, "\t-f\tspecify the saved file format\n");
fprintf(stderr, "\t-a\tenable automatic sound-triggered recording\n");
fprintf(stderr, "\t-b\tspecify threshold above which automatic recording will begin\n");
fprintf(stderr, "\t-e\tspecify threshold below which automatic recording will end\n");
fprintf(stderr, "\t-T\tspecify silence length before automatic recording ends\n");
fprintf(stderr, "\n");
fprintf(stderr, "\tchannels must be in the range 1-8, default %d\n",
DEFAULT_NUM_PORTS);
fprintf(stderr, "\tjack-name, default \"%s\"\n", DEFAULT_CLIENT_NAME);
fprintf(stderr, "\tfile-prefix, default \"%s\"\n", DEFAULT_PREFIX);
fprintf(stderr, "\tbuffer-length, default %d secs\n", DEFAULT_BUF_LENGTH);
fprintf(stderr, "\tformat, default '%s', options: wav, w64\n", DEFAULT_FORMAT);
fprintf(stderr, "\tbegin-threshold, default %.1f dB\n", DEFAULT_AUTO_BEGIN_THRESHOLD);
fprintf(stderr, "\tend-threshold, default %.1f dB\n", DEFAULT_AUTO_END_THRESHOLD);
fprintf(stderr, "\tend-time, default %d secs\n", DEFAULT_AUTO_END_TIME);
fprintf(stderr, "\n");
fprintf(stderr, "specifying port names to connect to on the command line overrides -c\n\n");
exit(1);
}
if (!strcasecmp(format_name, "wav")) {
format_sf = SF_FORMAT_WAV | SF_FORMAT_FLOAT;
}
#ifdef HAVE_W64
if (!strcasecmp(format_name, "w64")) {
format_sf = SF_FORMAT_W64 | SF_FORMAT_FLOAT;
}
#endif
if (format_sf == 0) {
fprintf(stderr, "Unknown format '%s'\n", format_name);
}
/* Register with jack */
if ((client = jack_client_open(client_name, 0, NULL)) == 0) {
DEBUG(0, "jack server not running?\n");
exit(1);
}
DEBUG(1, "registering as %s\n", client_name);
process_init(buf_length);
#ifdef HAVE_LASH
lash_client = lash_init (lash_args, "TimeMachine",
0, /* would be LASH_Config_Data_Set etc. */
LASH_PROTOCOL (2,0));
if (!lash_client) {
DEBUG(1, "could not initialise LASH\n");
}
event = lash_event_new_with_type(LASH_Client_Name);
lash_event_set_string(event, client_name);
lash_send_event(lash_client, event);
#endif
jack_set_process_callback(client, process, 0);
if (jack_activate(client)) {
DEBUG(0, "cannot activate JACK client");
exit(1);
}
#ifdef HAVE_LASH
lash_jack_client_name(lash_client, client_name);
#endif
/* Create the jack ports */
for (i = 0; i < num_ports; i++) {
jack_port_t *port;
snprintf(port_name, 31, "in_%d", i + 1);
ports[i] = jack_port_register(client, port_name,
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsInput, 0);
if (optind != argc) {
port = jack_port_by_name(client, argv[optind+i]);
if (port == NULL) {
fprintf(stderr, "Can't find port '%s'\n", port_name);
continue;
}
if (jack_connect(client, argv[optind+i], jack_port_name(ports[i]))) {
fprintf(stderr, "Cannot connect port '%s' to '%s'\n",
argv[optind+i], jack_port_name(ports[i]));
}
}
}
/* Start the disk thread */
pthread_create(&dt, NULL, (void *)&writer_thread, NULL);
#ifdef HAVE_LIBREADLINE
if (console || !getenv("DISPLAY") || getenv("DISPLAY")[0] == '\0') {
#ifdef HAVE_LIBLO
lo_server_thread st = lo_server_thread_new(OSC_PORT, NULL);
if (st) {
lo_server_thread_add_method(st, "/start", "", osc_handler_nox, (void *)1);
lo_server_thread_add_method(st, "/stop", "", osc_handler_nox, (void *)0);
lo_server_thread_start(st);
printf("Listening for OSC requests on osc.udp://localhost:%s\n",
OSC_PORT);
}
#endif
int done = 0;
while (!done) {
char *line = readline("TimeMachine> ");
if (!line) {
printf("EOF\n");
break;
}
if (line && *line) {
add_history(line);
if (strncmp(line, "q", 1) == 0) done = 1;
else if (strncmp(line, "start", 3) == 0) recording_start();
else if (strncmp(line, "stop", 3) == 0) recording_stop();
else if (strncmp(line, "help", 3) == 0) {
printf("Commands: start stop\n");
} else {
printf("Unknown command\n");
}
}
free(line);
}
} else
#endif
{
gtk_init(&argc, &argv);
add_pixmap_directory(PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
add_pixmap_directory("pixmaps");
add_pixmap_directory("../pixmaps");
img_on = create_pixbuf("on.png");
img_off = create_pixbuf("off.png");
img_busy = create_pixbuf("busy.png");
icon_on = create_pixbuf("on-icon.png");
icon_off = create_pixbuf("off-icon.png");
main_window = create_window(client_name);
gtk_window_set_icon(GTK_WINDOW(main_window), icon_off);
gtk_widget_show(main_window);
bind_meters();
g_timeout_add(100, meter_tick, NULL);
#ifdef HAVE_LIBLO
lo_server_thread st = lo_server_thread_new(OSC_PORT, NULL);
if (st) {
lo_server_thread_add_method(st, "/start", "", osc_handler, (void *)1);
lo_server_thread_add_method(st, "/stop", "", osc_handler, (void *)0);
lo_server_thread_start(st);
printf("Listening for OSC requests on osc.udp://localhost:%s\n",
OSC_PORT);
}
#endif
#ifdef HAVE_LASH
gtk_idle_add(idle_cb, lash_client);
#endif
gtk_main();
}
cleanup();
/* We can't ever get here, but it keeps gcc quiet */
return 0;
}
static void
init_jack(void)
{
int i, err;
#ifdef WITH_LASH
lash_event_t *event;
#endif
jack_client = jack_client_open(PROGRAM_NAME, JackNoStartServer, NULL);
if (jack_client == NULL) {
g_critical("Could not connect to the JACK server; run jackd first?");
exit(EX_UNAVAILABLE);
}
#ifdef WITH_LASH
event = lash_event_new_with_type(LASH_Client_Name);
assert (event); /* Documentation does not say anything about return value. */
lash_event_set_string(event, jack_get_client_name(jack_client));
lash_send_event(lash_client, event);
lash_jack_client_name(lash_client, jack_get_client_name(jack_client));
#endif
err = jack_set_process_callback(jack_client, process_callback, 0);
if (err) {
g_critical("Could not register JACK process callback.");
exit(EX_UNAVAILABLE);
}
if (use_transport) {
err = jack_set_sync_callback(jack_client, sync_callback, 0);
if (err) {
g_critical("Could not register JACK sync callback.");
exit(EX_UNAVAILABLE);
}
#if 0
err = jack_set_timebase_callback(jack_client, 1, timebase_callback, 0);
if (err) {
g_critical("Could not register JACK timebase callback.");
exit(EX_UNAVAILABLE);
}
#endif
}
jack_on_shutdown(jack_client, jack_shutdown, 0);
int number_of_tracks;
if (remote_control) {
number_of_tracks = 0; // TODO allow more ports
}
else {
assert(smf->number_of_tracks >= 1);
number_of_tracks = smf->number_of_tracks;
}
/* We are allocating number_of_tracks + 1 output ports. */
for (i = 0; i <= number_of_tracks; i++) {
char port_name[32];
if (i == 0)
snprintf(port_name, sizeof(port_name), "midi_out");
else
snprintf(port_name, sizeof(port_name), "track_%d_midi_out", i);
output_ports[i] = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
if (output_ports[i] == NULL) {
g_critical("Could not register JACK output port '%s'.", port_name);
exit(EX_UNAVAILABLE);
}
if (just_one_output)
break;
}
if (jack_activate(jack_client)) {
g_critical("Cannot activate JACK client.");
exit(EX_UNAVAILABLE);
}
}
