jackio.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010-2012 Krzysztof Foltman
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include "config.h"
  20
  21 #if USE_JACK
  22
  23 #include "config-api.h"
  24 #include "errors.h"
  25 #include "hwcfg.h"
  26 #include "io.h"
  27 #include "meter.h"
  28 #include "midi.h"
  29 #include "mididest.h"
  30 #include "recsrc.h"
  31
  32 #include <errno.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <glib.h>
  36 #include <jack/ringbuffer.h>
  37 #include <jack/types.h>
  38 #include <jack/midiport.h>
  39 #include <jack/transport.h>
  40
  41 struct cbox_jack_io_impl
  42 {
  43     struct cbox_io_impl ioi;
  44
  45     jack_client_t *client;
  46     jack_port_t **inputs;
  47     jack_port_t **outputs;
  48     jack_port_t *midi;
  49     char *error_str; // set to non-NULL if client has been booted out by JACK
  50     char *client_name;
  51     gboolean enable_common_midi_input;
  52     jack_transport_state_t last_transport_state;
  53     gboolean debug_transport;
  54
  55     jack_ringbuffer_t *rb_autoconnect;
  56 };
  57
  58 ///////////////////////////////////////////////////////////////////////////////
  59
  60 struct cbox_jack_midi_input
  61 {
  62     struct cbox_midi_input hdr;
  63     gchar *autoconnect_spec;
  64     jack_port_t *port;
  65     struct cbox_jack_io_impl *jii;
  66 };
  67
  68 struct cbox_jack_midi_output
  69 {
  70     struct cbox_midi_output hdr;
  71     gchar *autoconnect_spec;
  72     jack_port_t *port;
  73     struct cbox_jack_io_impl *jii;
  74 };
  75
  76 static struct cbox_midi_input *cbox_jackio_create_midi_in(struct cbox_io_impl *impl, const char *name, GError **error);
  77 static struct cbox_midi_output *cbox_jackio_create_midi_out(struct cbox_io_impl *impl, const char *name, GError **error);
  78 static void cbox_jackio_destroy_midi_in(struct cbox_io_impl *ioi, struct cbox_midi_input *midiin);
  79 static void cbox_jackio_destroy_midi_out(struct cbox_io_impl *ioi, struct cbox_midi_output *midiout);
  80 static void cbox_jack_midi_output_set_autoconnect(struct cbox_jack_midi_output *jmo, const gchar *autoconnect_spec);
  81
  82 static const char *transport_state_names[] = {"Stopped", "Rolling", "Looping?", "Starting", "Unknown/invalid#4", "Unknown/invalid#5", "Unknown/invalid#6" };
  83
  84 void cbox_jack_midi_input_destroy(struct cbox_jack_midi_input *jmi)
  85 {
  86     if (jmi->port)
  87     {
  88         jack_port_unregister(jmi->jii->client, jmi->port);
  89         jmi->port = NULL;
  90     }
  91     g_free(jmi->hdr.name);
  92     g_free(jmi->autoconnect_spec);
  93     free(jmi);
  94 }
  95
  96 void cbox_jack_midi_output_destroy(struct cbox_jack_midi_output *jmo)
  97 {
  98     if (jmo->port)
  99     {
 100         jack_port_unregister(jmo->jii->client, jmo->port);
 101         jmo->port = NULL;
 102     }
 103     g_free(jmo->hdr.name);
 104     g_free(jmo->autoconnect_spec);
 105     free(jmo);
 106 }
 107
 108 ///////////////////////////////////////////////////////////////////////////////
 109
 110 static int copy_midi_data_to_buffer(jack_port_t *port, int buffer_size, struct cbox_midi_buffer *destination)
 111 {
 112     void *midi = jack_port_get_buffer(port, buffer_size);
 113     uint32_t event_count = jack_midi_get_event_count(midi);
 114
 115     cbox_midi_buffer_clear(destination);
 116     for (uint32_t i = 0; i < event_count; i++)
 117     {
 118         jack_midi_event_t event;
 119
 120         if (!jack_midi_event_get(&event, midi, i))
 121         {
 122             if (!cbox_midi_buffer_write_event(destination, event.time, event.buffer, event.size))
 123                 return -i;
 124         }
 125         else
 126             return -i;
 127     }
 128
 129     return event_count;
 130 }
 131
 132 ///////////////////////////////////////////////////////////////////////////////
 133
 134 static int process_cb(jack_nframes_t nframes, void *arg)
 135 {
 136     struct cbox_jack_io_impl *jii = arg;
 137     struct cbox_io *io = jii->ioi.pio;
 138     struct cbox_io_callbacks *cb = io->cb;
 139
 140     io->io_env.buffer_size = nframes;
 141     for (int i = 0; i < io->io_env.input_count; i++)
 142         io->input_buffers[i] = jack_port_get_buffer(jii->inputs[i], nframes);
 143     for (int i = 0; i < io->io_env.output_count; i++)
 144     {
 145         io->output_buffers[i] = jack_port_get_buffer(jii->outputs[i], nframes);
 146         for (int j = 0; j < nframes; j ++)
 147             io->output_buffers[i][j] = 0.f;
 148     }
 149     for (GSList *p = io->midi_inputs; p; p = p->next)
 150     {
 151         struct cbox_jack_midi_input *input = p->data;
 152         if (input->hdr.output_set || input->hdr.enable_appsink)
 153         {
 154             copy_midi_data_to_buffer(input->port, io->io_env.buffer_size, &input->hdr.buffer);
 155             if (input->hdr.enable_appsink)
 156                 cbox_midi_appsink_supply(&input->hdr.appsink, &input->hdr.buffer);
 157         }
 158         else
 159             cbox_midi_buffer_clear(&input->hdr.buffer);
 160     }
 161     if (cb->on_transport_sync)
 162     {
 163         jack_transport_state_t state = jack_transport_query(jii->client, NULL);
 164         if (state != jii->last_transport_state)
 165         {
 166             jack_position_t pos;
 167             jack_transport_query(jii->client, &pos);
 168             if (jii->debug_transport)
 169                 g_message("JACK transport: incoming state change, state = %s, last state = %s, pos = %d\n", transport_state_names[state], transport_state_names[(int)jii->last_transport_state], (int)pos.frame);
 170             if (state == JackTransportStopped)
 171             {
 172                 if (cb->on_transport_sync(cb->user_data, ts_stopping, pos.frame))
 173                     jii->last_transport_state = state;
 174             }
 175             else
 176             if (state == JackTransportRolling && jii->last_transport_state == JackTransportStarting)
 177             {
 178                 if (cb->on_transport_sync(cb->user_data, ts_rolling, pos.frame))
 179                     jii->last_transport_state = state;
 180             }
 181             else
 182                 jii->last_transport_state = state;
 183         }
 184     }
 185     cb->process(cb->user_data, io, nframes);
 186     for (int i = 0; i < io->io_env.input_count; i++)
 187         io->input_buffers[i] = NULL;
 188     for (int i = 0; i < io->io_env.output_count; i++)
 189         io->output_buffers[i] = NULL;
 190     for (GSList *p = io->midi_outputs; p; p = g_slist_next(p))
 191     {
 192         struct cbox_jack_midi_output *midiout = p->data;
 193
 194         void *pbuf = jack_port_get_buffer(midiout->port, nframes);
 195         jack_midi_clear_buffer(pbuf);
 196
 197         cbox_midi_merger_render(&midiout->hdr.merger);
 198         if (midiout->hdr.buffer.count)
 199         {
 200             uint8_t tmp_data[4];
 201             for (int i = 0; i < midiout->hdr.buffer.count; i++)
 202             {
 203                 const struct cbox_midi_event *event = cbox_midi_buffer_get_event(&midiout->hdr.buffer, i);
 204                 const uint8_t *pdata = cbox_midi_event_get_data(event);
 205                 if ((pdata[0] & 0xF0) == 0x90 && !pdata[2] && event->size == 3)
 206                 {
 207                     tmp_data[0] = pdata[0] & ~0x10;
 208                     tmp_data[1] = pdata[1];
 209                     tmp_data[2] = pdata[2];
 210                     pdata = tmp_data;
 211                 }
 212                 if (jack_midi_event_write(pbuf, event->time, pdata, event->size))
 213                 {
 214                     g_warning("MIDI buffer overflow on JACK output port '%s'", midiout->hdr.name);
 215                     break;
 216                 }
 217             }
 218         }
 219     }
 220     return 0;
 221 }
 222
 223 static void autoconnect_port(jack_client_t *client, const char *port, const char *use_name, int is_cbox_input, const jack_port_t *only_connect_port, struct cbox_command_target *fb)
 224 {
 225     int res;
 226     if (only_connect_port)
 227     {
 228         jack_port_t *right;
 229         right = jack_port_by_name(client, use_name);
 230         if (only_connect_port != right)
 231             return;
 232     }
 233
 234     const char *pfrom = is_cbox_input ? use_name : port;
 235     const char *pto = !is_cbox_input ? use_name : port;
 236
 237     res = jack_connect(client, pfrom, pto);
 238     if (res == EEXIST)
 239         res = 0;
 240     gboolean suppressed = FALSE;
 241     if (fb)
 242     {
 243         if (!res)
 244             suppressed = cbox_execute_on(fb, NULL, "/io/jack/connected", "ss", NULL, pfrom, pto);
 245         else
 246             suppressed = cbox_execute_on(fb, NULL, "/io/jack/connect_failed", "sss", NULL, pfrom, pto, (res == EEXIST ? "already connected" : "failed"));
 247     }
 248     if (!suppressed)
 249         g_message("Connect: %s %s %s (%s)", port, is_cbox_input ? "<-" : "->", use_name, res == 0 ? "success" : (res == EEXIST ? "already connected" : "failed"));
 250 }
 251
 252 static void autoconnect_by_spec(jack_client_t *client, const char *port, const char *orig_spec, int is_cbox_input, int is_midi, const jack_port_t *only_connect_port, struct cbox_command_target *fb)
 253 {
 254     char *name, *copy_spec, *dpos;
 255     const char *use_name;
 256
 257     copy_spec = g_strdup(orig_spec);
 258     name = copy_spec;
 259     do {
 260         dpos = strchr(name, ';');
 261         if (dpos)
 262             *dpos = '\0';
 263
 264         use_name = name;
 265         if (use_name[0] == '#')
 266         {
 267             char *endptr = NULL;
 268             long portidx = strtol(use_name + 1, &endptr, 10) - 1;
 269             if (endptr == use_name + strlen(use_name))
 270             {
 271                 const char **names = jack_get_ports(client, ".*", is_midi ? JACK_DEFAULT_MIDI_TYPE : JACK_DEFAULT_AUDIO_TYPE, is_cbox_input ? JackPortIsOutput : JackPortIsInput);
 272                 int i;
 273                 for (i = 0; i < portidx && names[i]; i++)
 274                     ;
 275
 276                 if (names[i])
 277                     autoconnect_port(client, port, names[i], is_cbox_input, only_connect_port, fb);
 278                 else
 279                     g_message("Connect: unmatched port index %d", (int)portidx);
 280
 281                 jack_free(names);
 282             }
 283         }
 284         else if (use_name[0] == '~' || use_name[0] == '*')
 285         {
 286             const char **names = jack_get_ports(client, use_name + 1, is_midi ? JACK_DEFAULT_MIDI_TYPE : JACK_DEFAULT_AUDIO_TYPE, is_cbox_input ? JackPortIsOutput : JackPortIsInput);
 287
 288             if (names && names[0])
 289             {
 290                 if (use_name[0] == '*')
 291                 {
 292                     int i;
 293                     for (i = 0; names[i]; i++)
 294                         autoconnect_port(client, port, names[i], is_cbox_input, only_connect_port, fb);
 295                 }
 296                 else
 297                     autoconnect_port(client, port, names[0], is_cbox_input, only_connect_port, fb);
 298             }
 299             else
 300                 g_message("Connect: unmatched port regexp %s", use_name);
 301             jack_free(names);
 302         }
 303         else
 304             autoconnect_port(client, port, use_name, is_cbox_input, only_connect_port, fb);
 305
 306         if (dpos)
 307             name = dpos + 1;
 308     } while(dpos);
 309     g_free(copy_spec);
 310 }
 311
 312 static void autoconnect_by_var(jack_client_t *client, const char *port, const char *config_var, int is_cbox_input, int is_midi, const jack_port_t *only_connect_port, struct cbox_command_target *fb)
 313 {
 314     const char *orig_spec = cbox_config_get_string(cbox_io_section, config_var);
 315     if (orig_spec)
 316         autoconnect_by_spec(client, port, orig_spec, is_cbox_input, is_midi, only_connect_port, fb);
 317 }
 318
 319 static void port_connect_cb(jack_port_id_t port, int registered, void *arg)
 320 {
 321     struct cbox_jack_io_impl *jii = arg;
 322     if (registered)
 323     {
 324         jack_port_t *portobj = jack_port_by_id(jii->client, port);
 325
 326         jack_ringbuffer_write(jii->rb_autoconnect, (char *)&portobj, sizeof(portobj));
 327     }
 328 }
 329
 330 static void port_autoconnect(struct cbox_jack_io_impl *jii, jack_port_t *portobj, struct cbox_command_target *fb)
 331 {
 332     struct cbox_io *io = jii->ioi.pio;
 333
 334     for (int i = 0; i < io->io_env.output_count; i++)
 335     {
 336         gchar *cbox_port = g_strdup_printf("%s:out_%d", jii->client_name, 1 + i);
 337         gchar *config_key = g_strdup_printf("out_%d", 1 + i);
 338         autoconnect_by_var(jii->client, cbox_port, config_key, 0, 0, portobj, fb);
 339         g_free(cbox_port);
 340         g_free(config_key);
 341     }
 342     for (int i = 0; i < io->io_env.input_count; i++)
 343     {
 344         gchar *cbox_port = g_strdup_printf("%s:in_%d", jii->client_name, 1 + i);
 345         gchar *config_key = g_strdup_printf("in_%d", 1 + i);
 346         autoconnect_by_var(jii->client, cbox_port, config_key, 1, 0, portobj, fb);
 347         g_free(cbox_port);
 348         g_free(config_key);
 349     }
 350     for (GSList *p = io->midi_outputs; p; p = g_slist_next(p))
 351     {
 352         struct cbox_jack_midi_output *midiout = p->data;
 353         if (midiout->autoconnect_spec)
 354         {
 355             gchar *cbox_port = g_strdup_printf("%s:%s", jii->client_name, midiout->hdr.name);
 356             autoconnect_by_spec(jii->client, cbox_port, midiout->autoconnect_spec, 0, 1, portobj, fb);
 357             g_free(cbox_port);
 358         }
 359     }
 360     for (GSList *p = io->midi_inputs; p; p = g_slist_next(p))
 361     {
 362         struct cbox_jack_midi_input *midiin = p->data;
 363         if (midiin->autoconnect_spec)
 364         {
 365             gchar *cbox_port = g_strdup_printf("%s:%s", jii->client_name, midiin->hdr.name);
 366             autoconnect_by_spec(jii->client, cbox_port, midiin->autoconnect_spec, 1, 1, portobj, fb);
 367             g_free(cbox_port);
 368         }
 369     }
 370     gchar *cbox_port = g_strdup_printf("%s:midi", jii->client_name);
 371     autoconnect_by_var(jii->client, cbox_port, "midi", 1, 1, portobj, fb);
 372     g_free(cbox_port);
 373 }
 374
 375 int cbox_jackio_get_sample_rate(struct cbox_io_impl *impl)
 376 {
 377     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 378
 379     return jack_get_sample_rate(jii->client);
 380 }
 381
 382 gboolean cbox_jackio_get_status(struct cbox_io_impl *impl, GError **error)
 383 {
 384     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 385     if (!jii->error_str)
 386         return TRUE;
 387     g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "%s", jii->error_str);
 388     return FALSE;
 389 }
 390
 391 static void client_shutdown_cb(jack_status_t code, const char *reason, void *arg)
 392 {
 393     struct cbox_jack_io_impl *jii = arg;
 394     struct cbox_io *io = jii->ioi.pio;
 395     jii->error_str = g_strdup(reason);
 396     if (io->cb && io->cb->on_disconnected)
 397         (io->cb->on_disconnected)(io->cb->user_data);
 398 }
 399
 400 static int sync_cb(jack_transport_state_t state, jack_position_t *pos, void *arg)
 401 {
 402     struct cbox_jack_io_impl *jii = arg;
 403     struct cbox_io *io = jii->ioi.pio;
 404     gboolean result = TRUE;
 405     int last_state = jii->last_transport_state;
 406     switch(state)
 407     {
 408         case JackTransportStopped:
 409             result = io->cb->on_transport_sync(io->cb->user_data, ts_stopped, pos->frame);
 410             break;
 411         case JackTransportStarting:
 412             jii->last_transport_state = JackTransportStarting;
 413             result = io->cb->on_transport_sync(io->cb->user_data, ts_starting, pos->frame);
 414             break;
 415         case JackTransportRolling:
 416             result = io->cb->on_transport_sync(io->cb->user_data, ts_rolling, pos->frame);
 417             break;
 418         default:
 419             // assume the client is ready
 420             result = TRUE;
 421     }
 422     if (jii->debug_transport)
 423         g_message("JACK transport: incoming sync callback, state = %s, last state = %s, pos = %d, result = %d\n", transport_state_names[state], transport_state_names[last_state], (int)pos->frame, result);
 424     return result;
 425 }
 426
 427 gboolean cbox_jackio_start(struct cbox_io_impl *impl, struct cbox_command_target *fb, GError **error)
 428 {
 429     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 430     struct cbox_io *io = jii->ioi.pio;
 431
 432     if (io->cb->on_transport_sync)
 433         jack_set_sync_callback(jii->client, sync_cb, jii);
 434     jack_set_process_callback(jii->client, process_cb, jii);
 435     jack_set_port_registration_callback(jii->client, port_connect_cb, jii);
 436     jack_on_info_shutdown(jii->client, client_shutdown_cb, jii);
 437
 438     if (io->cb->on_started)
 439         io->cb->on_started(io->cb->user_data);
 440
 441     jack_activate(jii->client);
 442
 443     if (cbox_config_has_section(cbox_io_section))
 444         port_autoconnect(jii, NULL, fb);
 445
 446     return TRUE;
 447 }
 448
 449 gboolean cbox_jackio_stop(struct cbox_io_impl *impl, GError **error)
 450 {
 451     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 452
 453     if (jii->error_str)
 454     {
 455         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "%s", jii->error_str);
 456         return FALSE;
 457     }
 458     jack_deactivate(jii->client);
 459     return TRUE;
 460 }
 461
 462 void cbox_jackio_poll_ports(struct cbox_io_impl *impl, struct cbox_command_target *fb)
 463 {
 464     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 465
 466     while (jack_ringbuffer_read_space(jii->rb_autoconnect) >= sizeof(jack_port_t *))
 467     {
 468         jack_port_t *portobj;
 469         jack_ringbuffer_read(jii->rb_autoconnect, (char *)&portobj, sizeof(portobj));
 470         port_autoconnect(jii, portobj, fb);
 471     }
 472 }
 473
 474 int cbox_jackio_get_midi_data(struct cbox_io_impl *impl, struct cbox_midi_buffer *destination)
 475 {
 476     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 477     if (!jii->enable_common_midi_input)
 478     {
 479         cbox_midi_buffer_clear(destination);
 480         return 1;
 481     }
 482
 483     return copy_midi_data_to_buffer(jii->midi, jii->ioi.pio->io_env.buffer_size, destination);
 484 }
 485
 486 void cbox_jackio_destroy(struct cbox_io_impl *impl)
 487 {
 488     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 489     struct cbox_io *io = impl->pio;
 490     if (jii->client)
 491     {
 492         if (jii->error_str)
 493         {
 494             g_free(jii->error_str);
 495             jii->error_str = NULL;
 496         }
 497         else
 498         {
 499             for (int i = 0; i < io->io_env.input_count; i++)
 500                 jack_port_unregister(jii->client, jii->inputs[i]);
 501             free(jii->inputs);
 502             for (int i = 0; i < io->io_env.output_count; i++)
 503                 jack_port_unregister(jii->client, jii->outputs[i]);
 504             free(jii->outputs);
 505             if (jii->midi)
 506                 jack_port_unregister(jii->client, jii->midi);
 507         }
 508         if (jii->client_name)
 509         {
 510             free(jii->client_name);
 511             jii->client_name = NULL;
 512         }
 513         cbox_io_destroy_all_midi_ports(io);
 514
 515         jack_ringbuffer_free(jii->rb_autoconnect);
 516         jack_client_close(jii->client);
 517     }
 518     free(jii);
 519 }
 520
 521 gboolean cbox_jackio_cycle(struct cbox_io_impl *impl, struct cbox_command_target *fb, GError **error)
 522 {
 523     struct cbox_io *io = impl->pio;
 524     struct cbox_io_callbacks *cb = io->cb;
 525     cbox_io_close(io);
 526
 527     // XXXKF use params structure some day
 528     if (!cbox_io_init_jack(io, NULL, fb, error))
 529         return FALSE;
 530
 531     cbox_io_start(io, cb, fb);
 532     if (cb->on_reconnected)
 533         (cb->on_reconnected)(cb->user_data);
 534     return TRUE;
 535 }
 536
 537
 538
 539 ///////////////////////////////////////////////////////////////////////////////
 540
 541 struct cbox_midi_input *cbox_jackio_create_midi_in(struct cbox_io_impl *impl, const char *name, GError **error)
 542 {
 543     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 544     jack_port_t *port = jack_port_register(jii->client, name, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
 545     if (!port)
 546     {
 547         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot create input MIDI port '%s'", name);
 548         return FALSE;
 549     }
 550     struct cbox_jack_midi_input *input = calloc(1, sizeof(struct cbox_jack_midi_input));
 551     input->hdr.name = g_strdup(name);
 552     input->hdr.removing = FALSE;
 553     input->port = port;
 554     input->jii = jii;
 555     cbox_uuid_generate(&input->hdr.uuid);
 556     cbox_midi_buffer_init(&input->hdr.buffer);
 557
 558     return (struct cbox_midi_input *)input;
 559 }
 560
 561 struct cbox_midi_output *cbox_jackio_create_midi_out(struct cbox_io_impl *impl, const char *name, GError **error)
 562 {
 563     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 564     jack_port_t *port = jack_port_register(jii->client, name, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
 565     if (!port)
 566     {
 567         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot create output MIDI port '%s'", name);
 568         return FALSE;
 569     }
 570     struct cbox_jack_midi_output *output = calloc(1, sizeof(struct cbox_jack_midi_output));
 571     output->hdr.name = g_strdup(name);
 572     output->hdr.removing = FALSE;
 573     output->port = port;
 574     output->jii = jii;
 575     cbox_uuid_generate(&output->hdr.uuid);
 576     cbox_midi_buffer_init(&output->hdr.buffer);
 577     cbox_midi_merger_init(&output->hdr.merger, &output->hdr.buffer);
 578
 579     return (struct cbox_midi_output *)output;
 580 }
 581
 582 void cbox_jack_midi_input_set_autoconnect(struct cbox_jack_midi_input *jmi, const gchar *autoconnect_spec)
 583 {
 584     if (jmi->autoconnect_spec)
 585         g_free(jmi->autoconnect_spec);
 586     jmi->autoconnect_spec = autoconnect_spec && *autoconnect_spec ? g_strdup(autoconnect_spec) : NULL;
 587     if (jmi->autoconnect_spec)
 588     {
 589         gchar *cbox_port = g_strdup_printf("%s:%s", jmi->jii->client_name, jmi->hdr.name);
 590         autoconnect_by_spec(jmi->jii->client, cbox_port, jmi->autoconnect_spec, 1, 1, NULL, NULL);
 591         g_free(cbox_port);
 592     }
 593 }
 594
 595 void cbox_jack_midi_output_set_autoconnect(struct cbox_jack_midi_output *jmo, const gchar *autoconnect_spec)
 596 {
 597     if (jmo->autoconnect_spec)
 598         g_free(jmo->autoconnect_spec);
 599     jmo->autoconnect_spec = autoconnect_spec && *autoconnect_spec ? g_strdup(autoconnect_spec) : NULL;
 600     if (jmo->autoconnect_spec)
 601     {
 602         gchar *cbox_port = g_strdup_printf("%s:%s", jmo->jii->client_name, jmo->hdr.name);
 603         autoconnect_by_spec(jmo->jii->client, cbox_port, jmo->autoconnect_spec, 0, 1, NULL, NULL);
 604         g_free(cbox_port);
 605     }
 606 }
 607
 608 void cbox_jackio_destroy_midi_in(struct cbox_io_impl *ioi, struct cbox_midi_input *midiin)
 609 {
 610     cbox_jack_midi_input_destroy((struct cbox_jack_midi_input *)midiin);
 611 }
 612
 613 void cbox_jackio_destroy_midi_out(struct cbox_io_impl *ioi, struct cbox_midi_output *midiout)
 614 {
 615     cbox_jack_midi_output_destroy((struct cbox_jack_midi_output *)midiout);
 616 }
 617
 618 static gboolean cbox_jack_io_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
 619 {
 620     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)ct->user_data;
 621     struct cbox_io *io = jii->ioi.pio;
 622     gboolean handled = FALSE;
 623     if (!strcmp(cmd->command, "/status") && !strcmp(cmd->arg_types, ""))
 624     {
 625         if (!cbox_check_fb_channel(fb, cmd->command, error))
 626             return FALSE;
 627         return cbox_execute_on(fb, NULL, "/client_type", "s", error, "JACK") &&
 628             cbox_execute_on(fb, NULL, "/client_name", "s", error, jii->client_name) &&
 629             cbox_io_process_cmd(io, fb, cmd, error, &handled);
 630     }
 631     else if (!strcmp(cmd->command, "/rename_midi_port") && !strcmp(cmd->arg_types, "ss"))
 632     {
 633         const char *uuidstr = CBOX_ARG_S(cmd, 0);
 634         const char *new_name = CBOX_ARG_S(cmd, 1);
 635         struct cbox_uuid uuid;
 636         if (!cbox_uuid_fromstring(&uuid, uuidstr, error))
 637             return FALSE;
 638         struct cbox_midi_input *midiin = cbox_io_get_midi_input(io, NULL, &uuid);
 639         struct cbox_midi_output *midiout = cbox_io_get_midi_output(io, NULL, &uuid);
 640         if (!midiout && !midiin)
 641         {
 642             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Port '%s' not found", uuidstr);
 643             return FALSE;
 644         }
 645         jack_port_t *port = midiout ? ((struct cbox_jack_midi_output *)midiout)->port
 646             : ((struct cbox_jack_midi_input *)midiin)->port;
 647         char **pname = midiout ? &midiout->name : &midiin->name;
 648         if (0 != jack_port_set_name(port, new_name))
 649         {
 650             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot set port name to '%s'", new_name);
 651             return FALSE;
 652         }
 653         g_free(*pname);
 654         *pname = g_strdup(new_name);
 655         return TRUE;
 656     }
 657     else if (!strcmp(cmd->command, "/autoconnect") && !strcmp(cmd->arg_types, "ss"))
 658     {
 659         const char *uuidstr = CBOX_ARG_S(cmd, 0);
 660         const char *spec = CBOX_ARG_S(cmd, 1);
 661         struct cbox_uuid uuid;
 662         if (!cbox_uuid_fromstring(&uuid, uuidstr, error))
 663             return FALSE;
 664         struct cbox_midi_output *midiout = cbox_io_get_midi_output(io, NULL, &uuid);
 665         if (midiout)
 666         {
 667             cbox_jack_midi_output_set_autoconnect((struct cbox_jack_midi_output *)midiout, spec);
 668             return TRUE;
 669         }
 670         struct cbox_midi_input *midiin = cbox_io_get_midi_input(io, NULL, &uuid);
 671         if (midiin)
 672         {
 673             cbox_jack_midi_input_set_autoconnect((struct cbox_jack_midi_input *)midiin, spec);
 674             return TRUE;
 675         }
 676         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Port '%s' not found", uuidstr);
 677         return FALSE;
 678     }
 679     else if (!strcmp(cmd->command, "/disconnect_midi_port") && !strcmp(cmd->arg_types, "s"))
 680     {
 681         const char *uuidstr = CBOX_ARG_S(cmd, 0);
 682         struct cbox_uuid uuid;
 683         if (!cbox_uuid_fromstring(&uuid, uuidstr, error))
 684             return FALSE;
 685         struct cbox_midi_input *midiin = cbox_io_get_midi_input(io, NULL, &uuid);
 686         struct cbox_midi_output *midiout = cbox_io_get_midi_output(io, NULL, &uuid);
 687         if (!midiout && !midiin)
 688         {
 689             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Port '%s' not found", uuidstr);
 690             return FALSE;
 691         }
 692         jack_port_t *port = midiout ? ((struct cbox_jack_midi_output *)midiout)->port
 693             : ((struct cbox_jack_midi_input *)midiin)->port;
 694         jack_port_disconnect(jii->client, port);
 695         return TRUE;
 696     }
 697     else if (!strcmp(cmd->command, "/port_connect") && !strcmp(cmd->arg_types, "ss"))
 698     {
 699         const char *port_from = CBOX_ARG_S(cmd, 0);
 700         const char *port_to = CBOX_ARG_S(cmd, 1);
 701         int res = jack_connect(jii->client, port_from, port_to);
 702         if (res == EEXIST)
 703             res = 0;
 704         if (res)
 705             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot connect port '%s' to '%s'", port_from, port_to);
 706         return res == 0;
 707     }
 708     else if (!strcmp(cmd->command, "/port_disconnect") && !strcmp(cmd->arg_types, "ss"))
 709     {
 710         const char *port_from = CBOX_ARG_S(cmd, 0);
 711         const char *port_to = CBOX_ARG_S(cmd, 1);
 712         int res = jack_disconnect(jii->client, port_from, port_to);
 713         if (res)
 714             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot disconnect port '%s' from '%s'", port_from, port_to);
 715         return res == 0;
 716     }
 717     else if (!strcmp(cmd->command, "/get_ports") && !strcmp(cmd->arg_types, "ssi"))
 718     {
 719         if (!cbox_check_fb_channel(fb, cmd->command, error))
 720             return FALSE;
 721         const char *mask = CBOX_ARG_S(cmd, 0);
 722         const char *type = CBOX_ARG_S(cmd, 1);
 723         uint32_t flags = CBOX_ARG_I(cmd, 2);
 724         const char** ports = jack_get_ports(jii->client, mask, type, flags);
 725         for (int i = 0; ports && ports[i]; i++)
 726         {
 727             if (!cbox_execute_on(fb, NULL, "/port", "s", error, ports[i]))
 728                 return FALSE;
 729
 730         }
 731         return TRUE;
 732     }
 733     else
 734     {
 735         gboolean result = cbox_io_process_cmd(io, fb, cmd, error, &handled);
 736         if (!handled)
 737             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Unknown combination of target path and argument: '%s', '%s'", cmd->command, cmd->arg_types);
 738         return result;
 739     }
 740 }
 741
 742 ///////////////////////////////////////////////////////////////////////////////
 743
 744 static void cbox_jackio_control_transport(struct cbox_io_impl *impl, gboolean roll, uint32_t pos)
 745 {
 746     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 747
 748     if (jii->debug_transport)
 749         g_message("JACK transport: control(op=%s, pos=%d)\n", roll ? "roll" : "stop", (int)pos);
 750
 751     jack_transport_state_t state = jack_transport_query(jii->client, NULL);
 752     if (roll && state == JackTransportStopped)
 753         jack_transport_start(jii->client);
 754     if (!roll && state != JackTransportStopped)
 755         jack_transport_stop(jii->client);
 756
 757     if (pos != (uint32_t)-1)
 758         jack_transport_locate(jii->client, pos);
 759 }
 760
 761 static gboolean cbox_jackio_get_sync_completed(struct cbox_io_impl *impl)
 762 {
 763     struct cbox_jack_io_impl *jii = (struct cbox_jack_io_impl *)impl;
 764     return jack_transport_query(jii->client, NULL) != JackTransportStarting;
 765 }
 766
 767 ///////////////////////////////////////////////////////////////////////////////
 768
 769 gboolean cbox_io_init_jack(struct cbox_io *io, struct cbox_open_params *const params, struct cbox_command_target *fb, GError **error)
 770 {
 771     const char *client_name = cbox_config_get_string_with_default("io", "client_name", "cbox");
 772
 773     jack_client_t *client = NULL;
 774     jack_status_t status = 0;
 775     client = jack_client_open(client_name, JackNoStartServer, &status);
 776     if (client == NULL)
 777     {
 778         if (!cbox_hwcfg_setup_jack())
 779         {
 780             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot set up JACK server configuration based on current hardware");
 781             return FALSE;
 782         }
 783
 784         status = 0;
 785         client = jack_client_open(client_name, 0, &status);
 786     }
 787     if (client == NULL)
 788     {
 789         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot create JACK instance");
 790         return FALSE;
 791     }
 792
 793     // XXXKF would use a callback instead
 794     io->io_env.buffer_size = jack_get_buffer_size(client);
 795     io->cb = NULL;
 796     io->io_env.input_count = cbox_config_get_int("io", "inputs", 0);
 797     io->input_buffers = malloc(sizeof(float *) * io->io_env.input_count);
 798     io->io_env.output_count = cbox_config_get_int("io", "outputs", 2);
 799     io->output_buffers = malloc(sizeof(float *) * io->io_env.output_count);
 800
 801     struct cbox_jack_io_impl *jii = malloc(sizeof(struct cbox_jack_io_impl));
 802     io->impl = &jii->ioi;
 803     jii->enable_common_midi_input = cbox_config_get_int("io", "enable_common_midi_input", 1);
 804     jii->debug_transport = cbox_config_get_int("debug", "jack_transport", 0);
 805     jii->last_transport_state = JackTransportStopped;
 806
 807     cbox_command_target_init(&io->cmd_target, cbox_jack_io_process_cmd, jii);
 808     jii->ioi.pio = io;
 809     jii->ioi.getsampleratefunc = cbox_jackio_get_sample_rate;
 810     jii->ioi.startfunc = cbox_jackio_start;
 811     jii->ioi.stopfunc = cbox_jackio_stop;
 812     jii->ioi.getstatusfunc = cbox_jackio_get_status;
 813     jii->ioi.pollfunc = cbox_jackio_poll_ports;
 814     jii->ioi.cyclefunc = cbox_jackio_cycle;
 815     jii->ioi.getmidifunc = cbox_jackio_get_midi_data;
 816     jii->ioi.createmidiinfunc = cbox_jackio_create_midi_in;
 817     jii->ioi.destroymidiinfunc = cbox_jackio_destroy_midi_in;
 818     jii->ioi.createmidioutfunc = cbox_jackio_create_midi_out;
 819     jii->ioi.destroymidioutfunc = cbox_jackio_destroy_midi_out;
 820     jii->ioi.updatemidiinroutingfunc = NULL;
 821     jii->ioi.controltransportfunc = cbox_jackio_control_transport;
 822     jii->ioi.getsynccompletedfunc = cbox_jackio_get_sync_completed;
 823     jii->ioi.destroyfunc = cbox_jackio_destroy;
 824
 825     jii->client_name = g_strdup(jack_get_client_name(client));
 826     jii->client = client;
 827     jii->rb_autoconnect = jack_ringbuffer_create(sizeof(jack_port_t *) * 128);
 828     jii->error_str = NULL;
 829     io->io_env.srate = jack_get_sample_rate(client);
 830
 831     jii->inputs = malloc(sizeof(jack_port_t *) * io->io_env.input_count);
 832     jii->outputs = malloc(sizeof(jack_port_t *) * io->io_env.output_count);
 833     for (int i = 0; i < io->io_env.input_count; i++)
 834         jii->inputs[i] = NULL;
 835     for (int i = 0; i < io->io_env.output_count; i++)
 836         jii->outputs[i] = NULL;
 837     for (int i = 0; i < io->io_env.input_count; i++)
 838     {
 839         gchar *name = g_strdup_printf("in_%d", 1 + i);
 840         jii->inputs[i] = jack_port_register(jii->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 841         if (!jii->inputs[i])
 842         {
 843             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot create input port %d (%s)", i, name);
 844             g_free(name);
 845             goto cleanup;
 846         }
 847         g_free(name);
 848     }
 849     for (int i = 0; i < io->io_env.output_count; i++)
 850     {
 851         gchar *name = g_strdup_printf("out_%d", 1 + i);
 852         jii->outputs[i] = jack_port_register(jii->client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 853         if (!jii->outputs[i])
 854         {
 855             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot create output port %d (%s)", i, name);
 856             g_free(name);
 857             goto cleanup;
 858         }
 859         g_free(name);
 860     }
 861     if (jii->enable_common_midi_input)
 862     {
 863         jii->midi = jack_port_register(jii->client, "midi", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
 864         if (!jii->midi)
 865         {
 866             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot create MIDI port");
 867             return FALSE;
 868         }
 869     }
 870     else
 871         jii->midi = NULL;
 872
 873     if (fb)
 874         cbox_execute_on(fb, NULL, "/io/jack_client_name", "s", NULL, jii->client_name);
 875
 876     cbox_io_poll_ports(io, fb);
 877
 878     return TRUE;
 879
 880 cleanup:
 881     if (jii->inputs)
 882     {
 883         for (int i = 0; i < io->io_env.input_count; i++)
 884             free(jii->inputs[i]);
 885         free(jii->inputs);
 886     }
 887     if (jii->outputs)
 888     {
 889         for (int i = 0; i < io->io_env.output_count; i++)
 890             free(jii->outputs[i]);
 891         free(jii->outputs);
 892     }
 893     cbox_io_destroy_all_midi_ports(io);
 894     if (jii->client_name)
 895         free(jii->client_name);
 896     jack_client_close(jii->client);
 897     free(jii);
 898     io->impl = NULL;
 899     return FALSE;
 900 };
 901
 902 #endif