rt.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010-2013 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 "dom.h"
  20 #include "engine.h"
  21 #include "io.h"
  22 #include "midi.h"
  23 #include "module.h"
  24 #include "rt.h"
  25 #include "stm.h"
  26 #include <assert.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29
  30 CBOX_CLASS_DEFINITION_ROOT(cbox_rt)
  31
  32 static void cbox_rt_process(void *user_data, struct cbox_io *io, uint32_t nframes);
  33
  34 struct cbox_rt_cmd_instance
  35 {
  36     struct cbox_rt_cmd_definition *definition;
  37     void *user_data;
  38     int is_async;
  39 };
  40
  41 static gboolean cbox_rt_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
  42 {
  43     struct cbox_rt *rt = ct->user_data;
  44     if (!strcmp(cmd->command, "/status") && !strcmp(cmd->arg_types, ""))
  45     {
  46         if (!cbox_check_fb_channel(fb, cmd->command, error))
  47             return FALSE;
  48         if (rt->io)
  49         {
  50             GError *cerror = NULL;
  51             if (cbox_io_get_disconnect_status(rt->io, &cerror))
  52             {
  53                 return cbox_execute_on(fb, NULL, "/audio_channels", "ii", error, rt->io->io_env.input_count, rt->io->io_env.output_count) &&
  54                     cbox_execute_on(fb, NULL, "/state", "is", error, 1, "OK") &&
  55                     CBOX_OBJECT_DEFAULT_STATUS(rt, fb, error);
  56             }
  57             else
  58             {
  59                 return cbox_execute_on(fb, NULL, "/audio_channels", "ii", error, rt->io->io_env.input_count, rt->io->io_env.output_count) &&
  60                     cbox_execute_on(fb, NULL, "/state", "is", error, -1, cerror ? cerror->message : "Unknown error") &&
  61                     CBOX_OBJECT_DEFAULT_STATUS(rt, fb, error);
  62             }
  63         }
  64         else
  65             return cbox_execute_on(fb, NULL, "/audio_channels", "ii", error, 0, 2) &&
  66                 cbox_execute_on(fb, NULL, "/state", "is", error, 0, "Offline") &&
  67                 CBOX_OBJECT_DEFAULT_STATUS(rt, fb, error);
  68     }
  69     else if (!strcmp(cmd->command, "/cycle") && !strcmp(cmd->arg_types, ""))
  70     {
  71         if (rt->io && !cbox_io_get_disconnect_status(rt->io, NULL))
  72         {
  73             return cbox_io_cycle(rt->io, fb, error);
  74         }
  75         else
  76         {
  77             if (rt->io)
  78                 g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Already connected");
  79             else
  80                 g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot cycle connection in off-line mode");
  81             return FALSE;
  82         }
  83     }
  84     else if (!strncmp(cmd->command, "/engine/", 8))
  85         return cbox_execute_sub(&rt->engine->cmd_target, fb, cmd, cmd->command + 7, error);
  86     else
  87         return cbox_object_default_process_cmd(ct, fb, cmd, error);
  88 }
  89
  90 struct cbox_rt *cbox_rt_new(struct cbox_document *doc)
  91 {
  92     struct cbox_rt *rt = malloc(sizeof(struct cbox_rt));
  93     CBOX_OBJECT_HEADER_INIT(rt, cbox_rt, doc);
  94     rt->rb_execute = cbox_fifo_new(sizeof(struct cbox_rt_cmd_instance) * RT_CMD_QUEUE_ITEMS);
  95     rt->rb_cleanup = cbox_fifo_new(sizeof(struct cbox_rt_cmd_instance) * RT_CMD_QUEUE_ITEMS * 2);
  96     rt->io = NULL;
  97     rt->engine = NULL;
  98     rt->started = FALSE;
  99     rt->disconnected = FALSE;
 100     rt->io_env.srate = 0;
 101     rt->io_env.buffer_size = 0;
 102
 103     cbox_command_target_init(&rt->cmd_target, cbox_rt_process_cmd, rt);
 104     CBOX_OBJECT_REGISTER(rt);
 105     cbox_document_set_service(doc, "rt", &rt->_obj_hdr);
 106
 107     return rt;
 108 }
 109
 110 struct cbox_objhdr *cbox_rt_newfunc(struct cbox_class *class_ptr, struct cbox_document *doc)
 111 {
 112     return NULL;
 113 }
 114
 115 void cbox_rt_destroyfunc(struct cbox_objhdr *obj_ptr)
 116 {
 117     struct cbox_rt *rt = (void *)obj_ptr;
 118     cbox_fifo_destroy(rt->rb_execute);
 119     cbox_fifo_destroy(rt->rb_cleanup);
 120
 121     free(rt);
 122 }
 123
 124 static void cbox_rt_on_disconnected(void *user_data)
 125 {
 126     struct cbox_rt *rt = user_data;
 127     rt->disconnected = TRUE;
 128 }
 129
 130 static void cbox_rt_on_reconnected(void *user_data)
 131 {
 132     struct cbox_rt *rt = user_data;
 133     rt->disconnected = FALSE;
 134 }
 135
 136 static void cbox_rt_on_midi_outputs_changed(void *user_data)
 137 {
 138     struct cbox_rt *rt = user_data;
 139     if (rt->engine)
 140         cbox_engine_update_song_playback(rt->engine);
 141 }
 142
 143 static void cbox_rt_on_midi_inputs_changed(void *user_data)
 144 {
 145     struct cbox_rt *rt = user_data;
 146     if (rt->engine)
 147         cbox_engine_update_input_connections(rt->engine);
 148 }
 149
 150 void cbox_rt_on_update_io_env(struct cbox_rt *rt)
 151 {
 152     if (rt->engine)
 153     {
 154         cbox_io_env_copy(&rt->engine->io_env, &rt->io_env);
 155         cbox_master_set_sample_rate(rt->engine->master, rt->io_env.srate);
 156     }
 157 }
 158
 159 void cbox_rt_set_io(struct cbox_rt *rt, struct cbox_io *io)
 160 {
 161     assert(!rt->started);
 162     rt->io = io;
 163     if (io)
 164     {
 165         cbox_io_env_copy(&rt->io_env, &io->io_env);
 166         cbox_rt_on_update_io_env(rt);
 167     }
 168     else
 169     {
 170         cbox_io_env_clear(&rt->io_env);
 171     }
 172 }
 173
 174 void cbox_rt_set_offline(struct cbox_rt *rt, int sample_rate, int buffer_size)
 175 {
 176     assert(!rt->started);
 177     rt->io = NULL;
 178     rt->io_env.srate = sample_rate;
 179     rt->io_env.buffer_size = buffer_size;
 180     rt->io_env.input_count = 0;
 181     rt->io_env.output_count = 2;
 182     cbox_rt_on_update_io_env(rt);
 183 }
 184
 185 void cbox_rt_on_started(void *user_data)
 186 {
 187     struct cbox_rt *rt = user_data;
 188     rt->started = 1;
 189 }
 190
 191 void cbox_rt_on_stopped(void *user_data)
 192 {
 193     struct cbox_rt *rt = user_data;
 194     rt->started = 0;
 195 }
 196
 197 gboolean cbox_rt_on_transport_sync(void *user_data, enum cbox_transport_state state, uint32_t frame)
 198 {
 199     struct cbox_rt *rt = user_data;
 200     if (!rt->engine)
 201         return TRUE;
 202     return cbox_engine_on_transport_sync(rt->engine, state, frame);
 203 }
 204
 205 void cbox_rt_start(struct cbox_rt *rt, struct cbox_command_target *fb)
 206 {
 207     if (rt->io)
 208     {
 209         rt->cbs = calloc(1, sizeof(struct cbox_io_callbacks));
 210         rt->cbs->user_data = rt;
 211         rt->cbs->process = cbox_rt_process;
 212         rt->cbs->on_started = cbox_rt_on_started;
 213         rt->cbs->on_stopped = cbox_rt_on_stopped;
 214         rt->cbs->on_disconnected = cbox_rt_on_disconnected;
 215         rt->cbs->on_reconnected = cbox_rt_on_reconnected;
 216         rt->cbs->on_midi_inputs_changed = cbox_rt_on_midi_inputs_changed;
 217         rt->cbs->on_midi_outputs_changed = cbox_rt_on_midi_outputs_changed;
 218         rt->cbs->on_transport_sync = cbox_rt_on_transport_sync;
 219
 220         assert(!rt->started);
 221         cbox_io_start(rt->io, rt->cbs, fb);
 222         assert(rt->started);
 223     }
 224 }
 225
 226 void cbox_rt_stop(struct cbox_rt *rt)
 227 {
 228     if (rt->io)
 229     {
 230         assert(rt->started);
 231         cbox_io_stop(rt->io);
 232         free(rt->cbs);
 233         rt->cbs = NULL;
 234         assert(!rt->started);
 235     }
 236 }
 237
 238 void cbox_rt_handle_cmd_queue(struct cbox_rt *rt)
 239 {
 240     struct cbox_rt_cmd_instance cmd;
 241
 242     while(cbox_fifo_read_atomic(rt->rb_cleanup, &cmd, sizeof(cmd)))
 243     {
 244         cmd.definition->cleanup(cmd.user_data);
 245     }
 246 }
 247
 248 static void wait_write_space(struct cbox_fifo *rb)
 249 {
 250     int t = 0;
 251     while (cbox_fifo_writespace(rb) < sizeof(struct cbox_rt_cmd_instance))
 252     {
 253         // wait until some space frees up in the execute queue
 254         usleep(1000);
 255         t++;
 256         if (t >= 1000)
 257         {
 258             fprintf(stderr, "Execute queue full, waiting...\n");
 259             t = 0;
 260         }
 261     }
 262 }
 263
 264 void cbox_rt_execute_cmd_sync(struct cbox_rt *rt, struct cbox_rt_cmd_definition *def, void *user_data)
 265 {
 266     struct cbox_rt_cmd_instance cmd;
 267
 268     if (def->prepare)
 269         if (def->prepare(user_data))
 270             return;
 271
 272     // No realtime thread - do it all in the main thread
 273     if (!rt || !rt->started || rt->disconnected)
 274     {
 275         while (!def->execute(user_data))
 276             ;
 277         if (def->cleanup)
 278             def->cleanup(user_data);
 279         return;
 280     }
 281
 282     memset(&cmd, 0, sizeof(cmd));
 283     cmd.definition = def;
 284     cmd.user_data = user_data;
 285     cmd.is_async = 0;
 286
 287     wait_write_space(rt->rb_execute);
 288     cbox_fifo_write_atomic(rt->rb_execute, &cmd, sizeof(cmd));
 289     do
 290     {
 291         struct cbox_rt_cmd_instance cmd2;
 292
 293         if (!cbox_fifo_read_atomic(rt->rb_cleanup, &cmd2, sizeof(cmd2)))
 294         {
 295             // still no result in cleanup queue - wait
 296             usleep(10000);
 297             continue;
 298         }
 299         if (!memcmp(&cmd, &cmd2, sizeof(cmd)))
 300         {
 301             if (def->cleanup)
 302                 def->cleanup(user_data);
 303             break;
 304         }
 305         // async command - clean it up
 306         if (cmd2.definition->cleanup)
 307             cmd2.definition->cleanup(cmd2.user_data);
 308     } while(1);
 309 }
 310
 311 void cbox_rt_execute_cmd_async(struct cbox_rt *rt, struct cbox_rt_cmd_definition *def, void *user_data)
 312 {
 313     struct cbox_rt_cmd_instance cmd = { def, user_data, 1 };
 314
 315     if (def->prepare)
 316     {
 317         if (def->prepare(user_data))
 318             return;
 319     }
 320     // No realtime thread - do it all in the main thread
 321     if (!rt || !rt->started || rt->disconnected)
 322     {
 323         while (!def->execute(user_data))
 324             ;
 325         if (def->cleanup)
 326             def->cleanup(user_data);
 327         return;
 328     }
 329
 330     wait_write_space(rt->rb_execute);
 331     cbox_fifo_write_atomic(rt->rb_execute, &cmd, sizeof(cmd));
 332
 333     // will be cleaned up by next sync call or by cbox_rt_cmd_handle_queue
 334 }
 335
 336 ////////////////////////////////////////////////////////////////////////////////////////
 337
 338 void cbox_rt_process(void *user_data, struct cbox_io *io, uint32_t nframes)
 339 {
 340     struct cbox_rt *rt = user_data;
 341     if (rt->engine)
 342         cbox_engine_process(rt->engine, io, nframes, io->output_buffers);
 343     else
 344         cbox_rt_handle_rt_commands(rt);
 345 }
 346
 347 ////////////////////////////////////////////////////////////////////////////////////////
 348
 349 void cbox_rt_handle_rt_commands(struct cbox_rt *rt)
 350 {
 351     struct cbox_rt_cmd_instance cmd;
 352
 353     // Process command queue, needs engine's MIDI aux buf to be initialised to work
 354     int cost = 0;
 355     while(cost < RT_MAX_COST_PER_CALL && cbox_fifo_peek(rt->rb_execute, &cmd, sizeof(cmd)))
 356     {
 357         int result = (cmd.definition->execute)(cmd.user_data);
 358         if (!result)
 359             break;
 360         cost += result;
 361         cbox_fifo_consume(rt->rb_execute, sizeof(cmd));
 362         if (cmd.definition->cleanup || !cmd.is_async)
 363         {
 364             gboolean success = cbox_fifo_write_atomic(rt->rb_cleanup, (const char *)&cmd, sizeof(cmd));
 365             if (!success)
 366                 g_error("Clean-up FIFO full. Main thread deadlock?");
 367         }
 368     }
 369 }
 370
 371 ////////////////////////////////////////////////////////////////////////////////////////
 372
 373 #define cbox_rt_swap_pointers_args(ARG) ARG(void **, ptr) ARG(void *, new_value)
 374
 375 DEFINE_RT_FUNC(void *, cbox_rt, rt, cbox_rt_swap_pointers)
 376 {
 377     void *old_value = *ptr;
 378     *ptr = new_value;
 379     return old_value;
 380 }
 381
 382 #define cbox_rt_swap_pointers_and_update_count_args(ARG) ARG(void **, ptr) ARG(void *, new_value) ARG(int *, pcount) ARG(int, new_count)
 383
 384 DEFINE_RT_FUNC(void *, cbox_rt, rt, cbox_rt_swap_pointers_and_update_count)
 385 {
 386     void *old_value = *ptr;
 387     *ptr = new_value;
 388     if (pcount)
 389         *pcount = new_count;
 390     return old_value;
 391 }
 392
 393 void cbox_rt_array_insert(struct cbox_rt *rt, void ***ptr, int *pcount, int index, void *new_value)
 394 {
 395     assert(index >= -1);
 396     assert(index <= *pcount);
 397     assert(*pcount >= 0);
 398     void **new_array = stm_array_clone_insert(*ptr, *pcount, index, new_value);
 399     free(cbox_rt_swap_pointers_and_update_count(rt, (void **)ptr, new_array, pcount, *pcount + 1));
 400 }
 401
 402 void *cbox_rt_array_remove(struct cbox_rt *rt, void ***ptr, int *pcount, int index)
 403 {
 404     if (index == -1)
 405         index = *pcount - 1;
 406     assert(index >= 0);
 407     assert(index < *pcount);
 408     assert(*pcount > 0);
 409     void *p = (*ptr)[index];
 410     void **new_array = stm_array_clone_remove(*ptr, *pcount, index);
 411     free(cbox_rt_swap_pointers_and_update_count(rt, (void **)ptr, new_array, pcount, *pcount - 1));
 412     return p;
 413 }
 414
 415 gboolean cbox_rt_array_remove_by_value(struct cbox_rt *rt, void ***ptr, int *pcount, void *value_to_remove)
 416 {
 417     for (int i = 0; i < *pcount; i++)
 418     {
 419         if ((*ptr)[i] == value_to_remove)
 420         {
 421             cbox_rt_array_remove(rt, ptr, pcount, i);
 422             return TRUE;
 423         }
 424     }
 425     return FALSE;
 426 }
 427
 428 ////////////////////////////////////////////////////////////////////////////////////////
 429
 430 struct cbox_midi_merger *cbox_rt_get_midi_output(struct cbox_rt *rt, struct cbox_uuid *uuid)
 431 {
 432     if (rt->engine)
 433     {
 434         struct cbox_midi_merger *merger = cbox_engine_get_midi_output(rt->engine, uuid);
 435         if (merger)
 436             return merger;
 437     }
 438     if (!rt->io)
 439         return NULL;
 440
 441     struct cbox_midi_output *midiout = cbox_io_get_midi_output(rt->io, NULL, uuid);
 442     return midiout ? &midiout->merger : NULL;
 443 }
 444
 445 ////////////////////////////////////////////////////////////////////////////////////////
 446