sampler_prg.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 "app.h"
  20 #include "rt.h"
  21 #include "sampler.h"
  22 #include "sampler_prg.h"
  23 #include "sfzloader.h"
  24 #include "tarfile.h"
  25
  26 #include <assert.h>
  27
  28 CBOX_CLASS_DEFINITION_ROOT(sampler_program)
  29
  30 GSList *sampler_program_get_next_layer(struct sampler_program *prg, struct sampler_channel *c, GSList *next_layer, int note, int vel, float random, gboolean is_first)
  31 {
  32     int ch = (c - c->module->channels) + 1;
  33     for(;next_layer;next_layer = g_slist_next(next_layer))
  34     {
  35         struct sampler_layer *lr = next_layer->data;
  36         struct sampler_layer_data *l = lr->runtime;
  37         if (!l->eff_waveform)
  38             continue;
  39         if ((l->trigger == stm_first && !is_first) ||
  40             (l->trigger == stm_legato && is_first))
  41             continue;
  42         if (l->sw_last != -1)
  43         {
  44             if (note >= l->sw_lokey && note <= l->sw_hikey)
  45                 lr->last_key = note;
  46         }
  47         if (note >= l->lokey && note <= l->hikey && vel >= l->lovel && vel <= l->hivel && ch >= l->lochan && ch <= l->hichan && random >= l->lorand && random < l->hirand &&
  48             (l->cc_number == -1 || (c->cc[l->cc_number] >= l->locc && c->cc[l->cc_number] <= l->hicc)))
  49         {
  50             if (!l->eff_use_keyswitch ||
  51                 ((l->sw_last == -1 || l->sw_last == lr->last_key) &&
  52                  (l->sw_down == -1 || (c->switchmask[l->sw_down >> 5] & (1 << (l->sw_down & 31)))) &&
  53                  (l->sw_up == -1 || !(c->switchmask[l->sw_up >> 5] & (1 << (l->sw_up & 31)))) &&
  54                  (l->sw_previous == -1 || l->sw_previous == c->previous_note)))
  55             {
  56                 gboolean play = lr->current_seq_position == 1;
  57                 lr->current_seq_position++;
  58                 if (lr->current_seq_position >= l->seq_length)
  59                     lr->current_seq_position = 1;
  60                 if (play)
  61                     return next_layer;
  62             }
  63         }
  64     }
  65     return NULL;
  66 }
  67
  68 static gboolean return_layers(GSList *layers, const char *keyword, struct cbox_command_target *fb, GError **error)
  69 {
  70     for (GSList *p = layers; p; p = g_slist_next(p))
  71     {
  72         if (!cbox_execute_on(fb, NULL, keyword, "o", error, p->data))
  73             return FALSE;
  74     }
  75     return TRUE;
  76 }
  77
  78 static gboolean sampler_program_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
  79 {
  80     struct sampler_program *program = ct->user_data;
  81     if (!strcmp(cmd->command, "/status") && !strcmp(cmd->arg_types, ""))
  82     {
  83         if (!cbox_check_fb_channel(fb, cmd->command, error))
  84             return FALSE;
  85
  86         if (!((!program->name || cbox_execute_on(fb, NULL, "/name", "s", error, program->name)) &&
  87             cbox_execute_on(fb, NULL, "/sample_dir", "s", error, program->sample_dir) &&
  88             cbox_execute_on(fb, NULL, "/source_file", "s", error, program->source_file) &&
  89             cbox_execute_on(fb, NULL, "/program_no", "i", error, program->prog_no) &&
  90             cbox_execute_on(fb, NULL, "/in_use", "i", error, program->in_use) &&
  91             CBOX_OBJECT_DEFAULT_STATUS(program, fb, error)))
  92             return FALSE;
  93         return TRUE;
  94     }
  95     if (!strcmp(cmd->command, "/regions") && !strcmp(cmd->arg_types, ""))
  96     {
  97         if (!cbox_check_fb_channel(fb, cmd->command, error))
  98             return FALSE;
  99         return return_layers(program->all_layers, "/region", fb, error);
 100     }
 101     if (!strcmp(cmd->command, "/groups") && !strcmp(cmd->arg_types, ""))
 102     {
 103         if (!cbox_check_fb_channel(fb, cmd->command, error))
 104             return FALSE;
 105         if (!cbox_execute_on(fb, NULL, "/default_group", "o", error, program->default_group))
 106             return FALSE;
 107         return return_layers(program->groups, "/group", fb, error);
 108     }
 109     if (!strcmp(cmd->command, "/control_inits") && !strcmp(cmd->arg_types, ""))
 110     {
 111         if (!cbox_check_fb_channel(fb, cmd->command, error))
 112             return FALSE;
 113         for (GSList *p = program->ctrl_init_list; p; p = p->next)
 114         {
 115             const struct sampler_ctrlinit *cin = (const struct sampler_ctrlinit *)&p->data;
 116             if (!cbox_execute_on(fb, NULL, "/control_init", "ii", error, (int)cin->controller, (int)cin->value))
 117                 return FALSE;
 118         }
 119         return TRUE;
 120     }
 121     if (!strcmp(cmd->command, "/add_control_init") && !strcmp(cmd->arg_types, "ii"))
 122     {
 123         sampler_program_add_controller_init(program, CBOX_ARG_I(cmd, 0), CBOX_ARG_I(cmd, 1));
 124         return TRUE;
 125     }
 126     if (!strcmp(cmd->command, "/delete_control_init") && !strcmp(cmd->arg_types, "ii"))
 127     {
 128         sampler_program_remove_controller_init(program, CBOX_ARG_I(cmd, 0), CBOX_ARG_I(cmd, 1));
 129         return TRUE;
 130     }
 131     if (!strcmp(cmd->command, "/new_group") && !strcmp(cmd->arg_types, ""))
 132     {
 133         struct sampler_layer *l = sampler_layer_new(program->module, program, NULL);
 134         sampler_program_add_group(program, l);
 135         return cbox_execute_on(fb, NULL, "/uuid", "o", error, l);
 136     }
 137     return cbox_object_default_process_cmd(ct, fb, cmd, error);
 138 }
 139
 140 struct sampler_program *sampler_program_new(struct sampler_module *m, int prog_no, const char *name, struct cbox_tarfile *tarfile, const char *sample_dir, GError **error)
 141 {
 142     gchar *perm_sample_dir = g_strdup(sample_dir);
 143     if (!perm_sample_dir)
 144         return NULL;
 145
 146     struct cbox_document *doc = CBOX_GET_DOCUMENT(&m->module);
 147     struct sampler_program *prg = malloc(sizeof(struct sampler_program));
 148     if (!prg)
 149     {
 150         g_free(perm_sample_dir);
 151         return NULL;
 152     }
 153     memset(prg, 0, sizeof(*prg));
 154     CBOX_OBJECT_HEADER_INIT(prg, sampler_program, doc);
 155     cbox_command_target_init(&prg->cmd_target, sampler_program_process_cmd, prg);
 156
 157     prg->module = m;
 158     prg->prog_no = prog_no;
 159     prg->name = g_strdup(name);
 160     prg->tarfile = tarfile;
 161     prg->source_file = NULL;
 162     prg->sample_dir = perm_sample_dir;
 163     prg->all_layers = NULL;
 164     prg->rll = NULL;
 165     prg->groups = NULL;
 166     prg->ctrl_init_list = NULL;
 167     prg->default_group = sampler_layer_new(m, prg, NULL);
 168     prg->deleting = FALSE;
 169     prg->in_use = 0;
 170     CBOX_OBJECT_REGISTER(prg);
 171     return prg;
 172 }
 173
 174 struct sampler_program *sampler_program_new_from_cfg(struct sampler_module *m, const char *cfg_section, const char *name, int pgm_id, GError **error)
 175 {
 176     int i;
 177
 178     char *name2 = NULL, *sfz_path = NULL, *spath = NULL, *tar_name = NULL;
 179     const char *sfz = NULL;
 180     struct cbox_tarfile *tarfile = NULL;
 181
 182     g_clear_error(error);
 183     tar_name = cbox_config_get_string(cfg_section, "tar");
 184     if (!strncmp(cfg_section, "spgm:!", 6))
 185     {
 186         sfz = cfg_section + 6;
 187         if (!strncmp(sfz, "sbtar:", 6))
 188         {
 189             sfz_path = ".";
 190             gchar *p = strchr(sfz + 6, ':');
 191             if (p)
 192             {
 193                 char *tmp = g_strndup(sfz + 6, p - sfz - 6);
 194                 tarfile = cbox_tarpool_get_tarfile(app.tarpool, tmp, error);
 195                 g_free(tmp);
 196                 if (!tarfile)
 197                     return NULL;
 198                 sfz = p + 1;
 199                 name2 = p + 1;
 200             }
 201             else
 202             {
 203                 g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot load sampler program '%s' from section '%s': missing name of a file inside a tar archive", name, cfg_section);
 204                 return NULL;
 205             }
 206         }
 207         else
 208         {
 209             name2 = strrchr(name, '/');
 210             if (name2)
 211                 name2++;
 212         }
 213     }
 214     else
 215     {
 216         if (tar_name)
 217         {
 218             tarfile = cbox_tarpool_get_tarfile(app.tarpool, tar_name, error);
 219             if (!tarfile)
 220                 return NULL;
 221         }
 222         if (!sfz && !cbox_config_has_section(cfg_section))
 223         {
 224             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot load sampler program '%s' from section '%s': section not found", name, cfg_section);
 225             return FALSE;
 226         }
 227         name2 = cbox_config_get_string(cfg_section, "name");
 228
 229         sfz_path = cbox_config_get_string(cfg_section, "sfz_path");
 230         spath = cbox_config_get_string(cfg_section, "sample_path");
 231         sfz = cbox_config_get_string(cfg_section, "sfz");
 232         if (tarfile && !sfz_path)
 233             sfz_path = ".";
 234     }
 235
 236     if (sfz && !sfz_path && !spath && !tarfile)
 237     {
 238         char *lastslash = strrchr(sfz, '/');
 239         if (lastslash && !sfz_path && !spath)
 240         {
 241             char *tmp = g_strndup(sfz, lastslash - sfz);
 242             sfz_path = cbox_config_permify(tmp);
 243             g_free(tmp);
 244             sfz = lastslash + 1;
 245         }
 246     }
 247
 248     struct sampler_program *prg = sampler_program_new(
 249         m,
 250         pgm_id != -1 ? pgm_id : cbox_config_get_int(cfg_section, "program", 0),
 251         name2 ? name2 : name,
 252         tarfile,
 253         spath ? spath : (sfz_path ? sfz_path : ""),
 254         error
 255     );
 256     if (!prg)
 257         return NULL;
 258
 259     if (sfz)
 260     {
 261         if (sfz_path)
 262             prg->source_file = g_build_filename(sfz_path, sfz, NULL);
 263         else
 264         {
 265             prg->source_file = g_strdup(sfz);
 266         }
 267
 268         if (sampler_module_load_program_sfz(m, prg, prg->source_file, FALSE, error))
 269             return prg;
 270         CBOX_DELETE(prg);
 271         return NULL;
 272     }
 273
 274     for (i = 0; ; i++)
 275     {
 276         char *where = NULL;
 277         gchar *s = g_strdup_printf("layer%d", 1 + i);
 278         const char *layer_section = cbox_config_get_string(cfg_section, s);
 279         g_free(s);
 280         if (!layer_section)
 281             break;
 282         where = g_strdup_printf("slayer:%s", layer_section);
 283
 284         prg->source_file = g_strdup_printf("config:%s", cfg_section);
 285         struct sampler_layer *l = sampler_layer_new_from_section(m, prg, where);
 286         if (!l)
 287             g_warning("Sample layer '%s' cannot be created - skipping", layer_section);
 288         else
 289         {
 290             sampler_layer_update(l);
 291             if (!l->data.eff_waveform)
 292                 g_warning("Sample layer '%s' does not have a waveform - skipping", layer_section);
 293             else
 294                 sampler_program_add_layer(prg, l);
 295         }
 296         g_free(where);
 297     }
 298     prg->all_layers = g_slist_reverse(prg->all_layers);
 299     sampler_program_update_layers(prg);
 300     return prg;
 301 }
 302
 303 void sampler_program_add_layer(struct sampler_program *prg, struct sampler_layer *l)
 304 {
 305     // Always call sampler_update_layer before sampler_program_add_layer.
 306     assert(l->runtime);
 307     prg->all_layers = g_slist_prepend(prg->all_layers, l);
 308 }
 309
 310 void sampler_program_delete_layer(struct sampler_program *prg, struct sampler_layer *l)
 311 {
 312     prg->all_layers = g_slist_remove(prg->all_layers, l);
 313 }
 314
 315
 316 void sampler_program_add_group(struct sampler_program *prg, struct sampler_layer *l)
 317 {
 318     prg->groups = g_slist_prepend(prg->groups, l);
 319 }
 320
 321 void sampler_program_add_controller_init(struct sampler_program *prg, uint8_t controller, uint8_t value)
 322 {
 323     union sampler_ctrlinit_union u;
 324     u.ptr = NULL;
 325     u.cinit.controller = controller;
 326     u.cinit.value = value;
 327     prg->ctrl_init_list = g_slist_append(prg->ctrl_init_list, u.ptr);
 328 }
 329
 330 void sampler_program_remove_controller_init(struct sampler_program *prg, uint8_t controller, int which)
 331 {
 332     for (GSList **p = &prg->ctrl_init_list; *p; )
 333     {
 334         const struct sampler_ctrlinit *cin = (const struct sampler_ctrlinit *)&(*p)->data;
 335         if (cin->controller != controller)
 336         {
 337             p = &((*p)->next);
 338             continue;
 339         }
 340         if (which > 0)
 341             which--;
 342         GSList *q = (GSList *)cbox_rt_swap_pointers(prg->module->module.rt, (void **)p, (*p)->next);
 343         g_slist_free1(q);
 344         if (which == 0)
 345             break;
 346     }
 347 }
 348
 349 void sampler_program_destroyfunc(struct cbox_objhdr *hdr_ptr)
 350 {
 351     struct sampler_program *prg = CBOX_H2O(hdr_ptr);
 352     sampler_unselect_program(prg->module, prg);
 353     if (prg->rll)
 354     {
 355         sampler_rll_destroy(prg->rll);
 356         prg->rll = NULL;
 357     }
 358     for (GSList *p = prg->all_layers; p; p = g_slist_next(p))
 359         CBOX_DELETE((struct sampler_layer *)p->data);
 360     for (GSList *p = prg->groups; p; p = g_slist_next(p))
 361         CBOX_DELETE((struct sampler_layer *)p->data);
 362     CBOX_DELETE(prg->default_group);
 363
 364     g_free(prg->name);
 365     g_free(prg->sample_dir);
 366     g_free(prg->source_file);
 367     g_slist_free(prg->all_layers);
 368     g_slist_free(prg->ctrl_init_list);
 369     free(prg);
 370 }
 371
 372 void sampler_program_update_layers(struct sampler_program *prg)
 373 {
 374     struct sampler_module *m = prg->module;
 375     struct sampler_rll *new_rll = sampler_rll_new_from_program(prg);
 376     struct sampler_rll *old_rll = cbox_rt_swap_pointers(m->module.rt, (void **)&prg->rll, new_rll);
 377     if (old_rll)
 378         sampler_rll_destroy(old_rll);
 379 }
 380
 381 /////////////////////////////////////////////////////////////////////////////////
 382
 383 struct sampler_rll *sampler_rll_new_from_program(struct sampler_program *prg)
 384 {
 385     struct sampler_rll *rll = malloc(sizeof(struct sampler_rll));
 386     rll->layers = NULL;
 387     rll->layers_release = NULL;
 388     rll->layers_oncc = NULL;
 389     for (int i = 0; i < 4; i++)
 390         rll->cc_trigger_bitmask[i] = 0;
 391
 392     for (GSList *p = prg->all_layers; p; p = g_slist_next(p))
 393     {
 394         struct sampler_layer *l = p->data;
 395         int cc = l->data.on_cc_number;
 396         if (cc != -1)
 397         {
 398             rll->layers_oncc = g_slist_prepend(rll->layers_oncc, l);
 399             rll->cc_trigger_bitmask[cc >> 5] |= 1 << (cc & 31);
 400         }
 401         else if (l->data.trigger == stm_release)
 402             rll->layers_release = g_slist_prepend(rll->layers_release, l);
 403         else
 404             rll->layers = g_slist_prepend(rll->layers, l);
 405     }
 406     return rll;
 407 }
 408
 409 void sampler_rll_destroy(struct sampler_rll *rll)
 410 {
 411     g_slist_free(rll->layers);
 412     g_slist_free(rll->layers_release);
 413     g_slist_free(rll->layers_oncc);
 414     free(rll);
 415 }