sampler.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 "config-api.h"
  20 #include "dspmath.h"
  21 #include "errors.h"
  22 #include "midi.h"
  23 #include "module.h"
  24 #include "rt.h"
  25 #include "sampler.h"
  26 #include "sampler_impl.h"
  27 #include "sfzloader.h"
  28 #include "stm.h"
  29 #include <assert.h>
  30 #include <errno.h>
  31 #include <glib.h>
  32 #include <math.h>
  33 #include <memory.h>
  34 #include <sndfile.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37
  38 float sampler_sine_wave[2049];
  39
  40 GQuark cbox_sampler_error_quark()
  41 {
  42     return g_quark_from_string("cbox-sampler-error-quark");
  43 }
  44
  45 static void sampler_process_block(struct cbox_module *module, cbox_sample_t **inputs, cbox_sample_t **outputs);
  46 static void sampler_process_event(struct cbox_module *module, const uint8_t *data, uint32_t len);
  47 static void sampler_destroyfunc(struct cbox_module *module);
  48
  49 void sampler_steal_voice(struct sampler_module *m)
  50 {
  51     int max_age = 0;
  52     struct sampler_voice *voice_found = NULL;
  53     for (int i = 0; i < 16; i++)
  54     {
  55         FOREACH_VOICE(m->channels[i].voices_running, v)
  56         {
  57             if (v->amp_env.cur_stage == 15)
  58                 continue;
  59             int age = m->serial_no - v->serial_no;
  60             if (v->gen.loop_start == -1)
  61                 age += (int)((v->gen.bigpos >> 32) * 100.0 / v->gen.cur_sample_end);
  62             else
  63             if (v->released)
  64                 age += 10;
  65             if (age > max_age)
  66             {
  67                 max_age = age;
  68                 voice_found = v;
  69             }
  70         }
  71     }
  72     if (voice_found)
  73     {
  74         voice_found->released = 1;
  75         cbox_envelope_go_to(&voice_found->amp_env, 15);
  76     }
  77 }
  78
  79 static inline float clip01(float v)
  80 {
  81     if (v < 0.f)
  82         return 0;
  83     if (v > 1.f)
  84         return 1;
  85     return v;
  86 }
  87
  88 void sampler_process_block(struct cbox_module *module, cbox_sample_t **inputs, cbox_sample_t **outputs)
  89 {
  90     struct sampler_module *m = (struct sampler_module *)module;
  91
  92     //float channels[2][CBOX_BLOCK_SIZE];
  93
  94     for (int c = 0; c < m->output_pairs + m->aux_pairs; c++)
  95     {
  96         int oo = 2 * c;
  97         for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
  98             outputs[oo][i] = outputs[oo + 1][i] = 0.f;
  99     }
 100
 101     int vcount = 0, vrel = 0;
 102     for (int i = 0; i < 16; i++)
 103     {
 104         int cvcount = 0;
 105         FOREACH_VOICE(m->channels[i].voices_running, v)
 106         {
 107             sampler_voice_process(v, m, outputs);
 108
 109             if (v->amp_env.cur_stage == 15)
 110                 vrel++;
 111             cvcount++;
 112         }
 113         m->channels[i].active_voices = cvcount;
 114         vcount += cvcount;
 115     }
 116     m->active_voices = vcount;
 117     if (vcount - vrel > m->max_voices)
 118         sampler_steal_voice(m);
 119     m->serial_no++;
 120     m->current_time += CBOX_BLOCK_SIZE;
 121 }
 122
 123 void sampler_process_event(struct cbox_module *module, const uint8_t *data, uint32_t len)
 124 {
 125     struct sampler_module *m = (struct sampler_module *)module;
 126     if (len > 0)
 127     {
 128         int cmd = data[0] >> 4;
 129         int chn = data[0] & 15;
 130         struct sampler_channel *c = &m->channels[chn];
 131         switch(cmd)
 132         {
 133             case 8:
 134                 sampler_channel_stop_note(c, data[1], data[2], FALSE);
 135                 break;
 136
 137             case 9:
 138                 if (data[2] > 0)
 139                     sampler_channel_start_note(c, data[1], data[2], FALSE);
 140                 else
 141                     sampler_channel_stop_note(c, data[1], data[2], FALSE);
 142                 break;
 143
 144             case 10:
 145                 // handle chokeable one shot layers
 146                 if (data[2] == 127)
 147                     sampler_channel_stop_note(c, data[1], data[2], TRUE);
 148                 // polyphonic pressure not handled
 149                 break;
 150
 151             case 11:
 152                 sampler_channel_process_cc(c, data[1], data[2]);
 153                 break;
 154
 155             case 12:
 156                 sampler_channel_program_change(c, data[1]);
 157                 break;
 158
 159             case 13:
 160                 c->cc[smsrc_chanaft] = data[1];
 161                 break;
 162
 163             case 14:
 164                 c->pitchwheel = data[1] + 128 * data[2] - 8192;
 165                 break;
 166
 167             }
 168     }
 169 }
 170
 171 static int get_first_free_program_no(struct sampler_module *m)
 172 {
 173     int prog_no = -1;
 174     gboolean found;
 175
 176     // XXXKF this has a N-squared complexity - but I'm not seeing
 177     // this being used with more than 10 programs at the same time
 178     // in the near future
 179     do {
 180         prog_no++;
 181         found = FALSE;
 182         for (int i = 0; i < m->program_count; i++)
 183         {
 184             if (m->programs[i]->prog_no == prog_no)
 185             {
 186                 found = TRUE;
 187                 break;
 188             }
 189         }
 190     } while(found);
 191
 192     return prog_no;
 193 }
 194
 195 static int find_program(struct sampler_module *m, int prog_no)
 196 {
 197     for (int i = 0; i < m->program_count; i++)
 198     {
 199         if (m->programs[i]->prog_no == prog_no)
 200             return i;
 201     }
 202     return -1;
 203 }
 204
 205 struct release_program_voices_data
 206 {
 207     struct sampler_module *module;
 208
 209     struct sampler_program *old_pgm, *new_pgm;
 210     uint16_t channels_to_wait_for;
 211 };
 212
 213 static int release_program_voices_execute(void *data)
 214 {
 215     struct release_program_voices_data *rpv = data;
 216     struct sampler_module *m = rpv->module;
 217     int finished = 1;
 218
 219     for (int i = 0; i < 16; i++)
 220     {
 221         uint16_t mask = 1 << i;
 222         struct sampler_channel *c = &m->channels[i];
 223         if (c->program == rpv->old_pgm || c->program == NULL)
 224         {
 225             sampler_channel_set_program_RT(c, rpv->new_pgm);
 226             rpv->channels_to_wait_for |= mask;
 227         }
 228         if (rpv->channels_to_wait_for & mask)
 229         {
 230             FOREACH_VOICE(c->voices_running, v)
 231             {
 232                 if (m->deleting)
 233                 {
 234                     sampler_voice_inactivate(v, TRUE);
 235                     continue;
 236                 }
 237                 // This is a new voice, started after program change, so it
 238                 // should not be terminated and waited for.
 239                 if (v->program == rpv->new_pgm)
 240                     continue;
 241                 // The voice is still going, so repeat until it fades out
 242                 finished = 0;
 243                 // If not in final fadeout stage, force final fadeout.
 244                 if (v->amp_env.cur_stage != 15)
 245                 {
 246                     v->released = 1;
 247                     cbox_envelope_go_to(&v->amp_env, 15);
 248                 }
 249             }
 250         }
 251     }
 252
 253     return finished;
 254 }
 255
 256 static void swap_program(struct sampler_module *m, int index, struct sampler_program *pgm, gboolean delete_old)
 257 {
 258     static struct cbox_rt_cmd_definition release_program_voices = { NULL, release_program_voices_execute, NULL };
 259
 260     struct sampler_program *old_program = NULL;
 261     if (pgm)
 262         old_program = cbox_rt_swap_pointers(m->module.rt, (void **)&m->programs[index], pgm);
 263     else
 264         old_program = cbox_rt_array_remove(m->module.rt, (void ***)&m->programs, &m->program_count, index);
 265
 266     struct release_program_voices_data data = {m, old_program, pgm, 0};
 267
 268     cbox_rt_execute_cmd_sync(m->module.rt, &release_program_voices, &data);
 269
 270     if (delete_old && old_program)
 271         CBOX_DELETE(old_program);
 272 }
 273
 274 static void select_initial_program(struct sampler_module *m)
 275 {
 276     static struct cbox_rt_cmd_definition release_program_voices = { NULL, release_program_voices_execute, NULL };
 277     struct release_program_voices_data data = {m, NULL, m->programs[0], 0};
 278     cbox_rt_execute_cmd_sync(m->module.rt, &release_program_voices, &data);
 279 }
 280
 281 void sampler_register_program(struct sampler_module *m, struct sampler_program *pgm)
 282 {
 283     struct sampler_program **programs = malloc(sizeof(struct sampler_program *) * (m->program_count + 1));
 284     memcpy(programs, m->programs, sizeof(struct sampler_program *) * m->program_count);
 285     programs[m->program_count] = pgm;
 286     free(cbox_rt_swap_pointers_and_update_count(m->module.rt, (void **)&m->programs, programs, &m->program_count, m->program_count + 1));
 287     if (m->program_count == 1)
 288         select_initial_program(m);
 289 }
 290
 291 static gboolean load_program_at(struct sampler_module *m, const char *cfg_section, const char *name, int prog_no, struct sampler_program **ppgm, GError **error)
 292 {
 293     struct sampler_program *pgm = NULL;
 294     int index = find_program(m, prog_no);
 295     pgm = sampler_program_new_from_cfg(m, cfg_section, name, prog_no, error);
 296     if (!pgm)
 297         return FALSE;
 298
 299     if (index != -1)
 300     {
 301         swap_program(m, index, pgm, TRUE);
 302         return TRUE;
 303     }
 304
 305     sampler_register_program(m, pgm);
 306     if (ppgm)
 307         *ppgm = pgm;
 308     return TRUE;
 309 }
 310
 311 void sampler_unselect_program(struct sampler_module *m, struct sampler_program *prg)
 312 {
 313     // Ensure no new notes are played on that program
 314     prg->deleting = TRUE;
 315     // Remove from the list of available programs, so that it cannot be selected again
 316     for (int i = 0; i < m->program_count; i++)
 317     {
 318         if (m->programs[i] == prg)
 319             swap_program(m, i, NULL, FALSE);
 320     }
 321 }
 322
 323 static gboolean load_from_string(struct sampler_module *m, const char *sample_dir, const char *sfz_data, const char *name, int prog_no, struct sampler_program **ppgm, GError **error)
 324 {
 325     int index = find_program(m, prog_no);
 326     struct sampler_program *pgm = sampler_program_new(m, prog_no, name, NULL, sample_dir, error);
 327     if (!pgm)
 328         return FALSE;
 329     pgm->source_file = g_strdup("string");
 330     if (!sampler_module_load_program_sfz(m, pgm, sfz_data, TRUE, error))
 331     {
 332         free(pgm);
 333         return FALSE;
 334     }
 335
 336     if (index != -1)
 337     {
 338         swap_program(m, index, pgm, TRUE);
 339         if (ppgm)
 340             *ppgm = pgm;
 341         return TRUE;
 342     }
 343
 344     struct sampler_program **programs = calloc((m->program_count + 1), sizeof(struct sampler_program *));
 345     memcpy(programs, m->programs, sizeof(struct sampler_program *) * m->program_count);
 346     programs[m->program_count] = pgm;
 347     if (ppgm)
 348         *ppgm = pgm;
 349     free(cbox_rt_swap_pointers_and_update_count(m->module.rt, (void **)&m->programs, programs, &m->program_count, m->program_count + 1));
 350     if (m->program_count == 1)
 351         select_initial_program(m);
 352     return TRUE;
 353 }
 354
 355 gboolean sampler_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
 356 {
 357     struct sampler_module *m = (struct sampler_module *)ct->user_data;
 358
 359     if (!strcmp(cmd->command, "/status") && !strcmp(cmd->arg_types, ""))
 360     {
 361         if (!cbox_check_fb_channel(fb, cmd->command, error))
 362             return FALSE;
 363         for (int i = 0; i < 16; i++)
 364         {
 365             struct sampler_channel *channel = &m->channels[i];
 366             gboolean result;
 367             if (channel->program)
 368                 result = cbox_execute_on(fb, NULL, "/patch", "iis", error, i + 1, channel->program->prog_no, channel->program->name);
 369             else
 370                 result = cbox_execute_on(fb, NULL, "/patch", "iis", error, i + 1, -1, "");
 371             if (!result)
 372                 return FALSE;
 373             if (!(cbox_execute_on(fb, NULL, "/channel_voices", "ii", error, i + 1, channel->active_voices) &&
 374                 cbox_execute_on(fb, NULL, "/volume", "ii", error, i + 1, sampler_channel_addcc(channel, 7)) &&
 375                 cbox_execute_on(fb, NULL, "/pan", "ii", error, i + 1, sampler_channel_addcc(channel, 10))))
 376                 return FALSE;
 377         }
 378
 379         return cbox_execute_on(fb, NULL, "/active_voices", "i", error, m->active_voices) &&
 380             cbox_execute_on(fb, NULL, "/active_pipes", "i", error, cbox_prefetch_stack_get_active_pipe_count(m->pipe_stack)) &&
 381             cbox_execute_on(fb, NULL, "/polyphony", "i", error, MAX_SAMPLER_VOICES) &&
 382             CBOX_OBJECT_DEFAULT_STATUS(&m->module, fb, error);
 383     }
 384     else
 385     if (!strcmp(cmd->command, "/patches") && !strcmp(cmd->arg_types, ""))
 386     {
 387         if (!cbox_check_fb_channel(fb, cmd->command, error))
 388             return FALSE;
 389         for (int i = 0; i < m->program_count; i++)
 390         {
 391             struct sampler_program *prog = m->programs[i];
 392             if (!cbox_execute_on(fb, NULL, "/patch", "isoi", error, prog->prog_no, prog->name, prog, prog->in_use))
 393                 return FALSE;
 394         }
 395         return TRUE;
 396     }
 397     else if (!strcmp(cmd->command, "/polyphony") && !strcmp(cmd->arg_types, "i"))
 398     {
 399         int polyphony = CBOX_ARG_I(cmd, 0);
 400         if (polyphony < 1 || polyphony > MAX_SAMPLER_VOICES)
 401         {
 402             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Invalid polyphony %d (must be between 1 and %d)", polyphony, (int)MAX_SAMPLER_VOICES);
 403             return FALSE;
 404         }
 405         m->max_voices = polyphony;
 406         return TRUE;
 407     }
 408     else if (!strcmp(cmd->command, "/set_patch") && !strcmp(cmd->arg_types, "ii"))
 409     {
 410         int channel = CBOX_ARG_I(cmd, 0);
 411         if (channel < 1 || channel > 16)
 412         {
 413             g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Invalid channel %d", channel);
 414             return FALSE;
 415         }
 416         int value = CBOX_ARG_I(cmd, 1);
 417         struct sampler_program *pgm = NULL;
 418         for (int i = 0; i < m->program_count; i++)
 419         {
 420             if (m->programs[i]->prog_no == value)
 421             {
 422                 pgm = m->programs[i];
 423                 break;
 424             }
 425         }
 426         sampler_channel_set_program(&m->channels[channel - 1], pgm);
 427         return TRUE;
 428     }
 429     else if (!strcmp(cmd->command, "/load_patch") && !strcmp(cmd->arg_types, "iss"))
 430     {
 431         struct sampler_program *pgm = NULL;
 432         if (!load_program_at(m, CBOX_ARG_S(cmd, 1), CBOX_ARG_S(cmd, 2), CBOX_ARG_I(cmd, 0), &pgm, error))
 433             return FALSE;
 434         if (fb)
 435             return cbox_execute_on(fb, NULL, "/uuid", "o", error, pgm);
 436         return TRUE;
 437     }
 438     else if (!strcmp(cmd->command, "/load_patch_from_file") && !strcmp(cmd->arg_types, "iss"))
 439     {
 440         struct sampler_program *pgm = NULL;
 441         char *cfg_section = g_strdup_printf("spgm:!%s", CBOX_ARG_S(cmd, 1));
 442         gboolean res = load_program_at(m, cfg_section, CBOX_ARG_S(cmd, 2), CBOX_ARG_I(cmd, 0), &pgm, error);
 443         g_free(cfg_section);
 444         if (res && pgm && fb)
 445             return cbox_execute_on(fb, NULL, "/uuid", "o", error, pgm);
 446         return res;
 447     }
 448     else if (!strcmp(cmd->command, "/load_patch_from_string") && !strcmp(cmd->arg_types, "isss"))
 449     {
 450         struct sampler_program *pgm = NULL;
 451         if (!load_from_string(m, CBOX_ARG_S(cmd, 1), CBOX_ARG_S(cmd, 2), CBOX_ARG_S(cmd, 3), CBOX_ARG_I(cmd, 0), &pgm, error))
 452             return FALSE;
 453         if (fb && pgm)
 454             return cbox_execute_on(fb, NULL, "/uuid", "o", error, pgm);
 455         return TRUE;
 456     }
 457     else if (!strcmp(cmd->command, "/get_unused_program") && !strcmp(cmd->arg_types, ""))
 458     {
 459         if (!cbox_check_fb_channel(fb, cmd->command, error))
 460             return FALSE;
 461         return cbox_execute_on(fb, NULL, "/program_no", "i", error, get_first_free_program_no(m));
 462     }
 463     else
 464         return cbox_object_default_process_cmd(ct, fb, cmd, error);
 465     return TRUE;
 466 }
 467
 468 gboolean sampler_select_program(struct sampler_module *m, int channel, const gchar *preset, GError **error)
 469 {
 470     for (int i = 0; i < m->program_count; i++)
 471     {
 472         if (!strcmp(m->programs[i]->name, preset))
 473         {
 474             sampler_channel_set_program(&m->channels[channel], m->programs[i]);
 475             return TRUE;
 476         }
 477     }
 478     g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Preset not found: %s", preset);
 479     return FALSE;
 480 }
 481
 482 MODULE_CREATE_FUNCTION(sampler)
 483 {
 484     int i;
 485     static int inited = 0;
 486     if (!inited)
 487     {
 488         for (int i = 0; i < 2049; i++)
 489             sampler_sine_wave[i] = sin(i * M_PI / 1024.0);
 490         inited = 1;
 491     }
 492
 493     int max_voices = cbox_config_get_int(cfg_section, "polyphony", MAX_SAMPLER_VOICES);
 494     if (max_voices < 1 || max_voices > MAX_SAMPLER_VOICES)
 495     {
 496         g_set_error(error, CBOX_SAMPLER_ERROR, CBOX_SAMPLER_ERROR_INVALID_LAYER, "%s: invalid polyphony value", cfg_section);
 497         return NULL;
 498     }
 499     int output_pairs = cbox_config_get_int(cfg_section, "output_pairs", 1);
 500     if (output_pairs < 1 || output_pairs > 16)
 501     {
 502         g_set_error(error, CBOX_SAMPLER_ERROR, CBOX_SAMPLER_ERROR_INVALID_LAYER, "%s: invalid output pairs value", cfg_section);
 503         return NULL;
 504     }
 505     int aux_pairs = cbox_config_get_int(cfg_section, "aux_pairs", 0);
 506     if (aux_pairs < 0 || aux_pairs > 4)
 507     {
 508         g_set_error(error, CBOX_SAMPLER_ERROR, CBOX_SAMPLER_ERROR_INVALID_LAYER, "%s: invalid aux pairs value", cfg_section);
 509         return NULL;
 510     }
 511
 512     struct sampler_module *m = calloc(1, sizeof(struct sampler_module));
 513     CALL_MODULE_INIT(m, 0, (output_pairs + aux_pairs) * 2, sampler);
 514     m->output_pairs = output_pairs;
 515     m->aux_pairs = aux_pairs;
 516     m->module.aux_offset = m->output_pairs * 2;
 517     m->module.process_event = sampler_process_event;
 518     m->module.process_block = sampler_process_block;
 519     m->programs = NULL;
 520     m->max_voices = max_voices;
 521     m->serial_no = 0;
 522     m->deleting = FALSE;
 523     // XXXKF read defaults from some better place, like config
 524     // XXXKF allow dynamic change of the number of the pipes
 525     m->pipe_stack = cbox_prefetch_stack_new(MAX_SAMPLER_VOICES, cbox_config_get_int("streaming", "streambuf_size", 65536));
 526     m->disable_mixer_controls = cbox_config_get_int("sampler", "disable_mixer_controls", 0);
 527
 528     float srate = m->module.srate;
 529     for (i = 0; i < 12800; i++)
 530     {
 531         float freq = 440 * pow(2, (i - 5700) / 1200.0);
 532         if (freq < 20.0)
 533             freq = 20.0;
 534         if (freq > srate * 0.45)
 535             freq = srate * 0.45;
 536         float omega=(float)(2*M_PI*freq/srate);
 537         m->sincos[i].sine = sinf(omega);
 538         m->sincos[i].cosine = cosf(omega);
 539         m->sincos[i].prewarp = 2.0 * tan(hz2w(freq, srate) * 0.5f);
 540
 541     }
 542     for (i = 0; ; i++)
 543     {
 544         gchar *s = g_strdup_printf("program%d", i);
 545         char *p = cbox_config_get_string(cfg_section, s);
 546         g_free(s);
 547
 548         if (!p)
 549         {
 550             m->program_count = i;
 551             break;
 552         }
 553     }
 554     m->programs = calloc(m->program_count, sizeof(struct sampler_program *));
 555     int success = 1;
 556     for (i = 0; i < m->program_count; i++)
 557     {
 558         gchar *s = g_strdup_printf("program%d", i);
 559         char *pgm_section = NULL;
 560         int pgm_id = -1;
 561         const char *pgm_name = cbox_config_get_string(cfg_section, s);
 562         g_free(s);
 563         char *at = strchr(pgm_name, '@');
 564         if (at)
 565         {
 566             pgm_id = atoi(at + 1);
 567             s = g_strndup(pgm_name, at - pgm_name);
 568             pgm_section = g_strdup_printf("spgm:%s", s);
 569             g_free(s);
 570         }
 571         else
 572         {
 573             pgm_id = i;
 574             pgm_section = g_strdup_printf("spgm:%s", pgm_name);
 575         }
 576
 577         m->programs[i] = sampler_program_new_from_cfg(m, pgm_section, pgm_section + 5, pgm_id, error);
 578         g_free(pgm_section);
 579         if (!m->programs[i])
 580         {
 581             success = 0;
 582             break;
 583         }
 584     }
 585     if (!success)
 586     {
 587         // XXXKF free programs/layers, first ensuring that they're fully initialised
 588         free(m);
 589         return NULL;
 590     }
 591     m->voices_free = NULL;
 592     memset(m->voices_all, 0, sizeof(m->voices_all));
 593     for (i = 0; i < MAX_SAMPLER_VOICES; i++)
 594     {
 595         struct sampler_voice *v = &m->voices_all[i];
 596         v->gen.mode = spt_inactive;
 597         sampler_voice_link(&m->voices_free, v);
 598     }
 599     m->active_voices = 0;
 600
 601     for (i = 0; i < 16; i++)
 602         sampler_channel_init(&m->channels[i], m);
 603
 604     for (i = 0; i < 16; i++)
 605     {
 606         gchar *key = g_strdup_printf("channel%d", i + 1);
 607         gchar *preset = cbox_config_get_string(cfg_section, key);
 608         if (preset)
 609         {
 610             if (!sampler_select_program(m, i, preset, error))
 611             {
 612                 CBOX_DELETE(&m->module);
 613                 return NULL;
 614             }
 615         }
 616         g_free(key);
 617     }
 618
 619
 620     return &m->module;
 621 }
 622
 623 void sampler_destroyfunc(struct cbox_module *module)
 624 {
 625     struct sampler_module *m = (struct sampler_module *)module;
 626     int i;
 627     m->deleting = TRUE;
 628
 629     for (i = 0; i < m->program_count;)
 630     {
 631         if (m->programs[i])
 632             CBOX_DELETE(m->programs[i]);
 633         else
 634             i++;
 635     }
 636     for (i = 0; i < 16; i++)
 637     {
 638         assert (m->channels[i].voices_running == NULL);
 639     }
 640     cbox_prefetch_stack_destroy(m->pipe_stack);
 641     free(m->programs);
 642 }
 643
 644 #define MAKE_TO_STRING_CONTENT(name, v) \
 645     case v: return name;
 646
 647 #define MAKE_FROM_STRING_CONTENT(n, v) \
 648     if (!strcmp(name, n)) { *value = v; return TRUE; }
 649
 650 #define MAKE_FROM_TO_STRING(enumtype) \
 651     const char *enumtype##_to_string(enum enumtype value) \
 652     { \
 653         switch(value) { \
 654             ENUM_VALUES_##enumtype(MAKE_TO_STRING_CONTENT) \
 655             default: return NULL; \
 656         } \
 657     } \
 658     \
 659     gboolean enumtype##_from_string(const char *name, enum enumtype *value) \
 660     { \
 661         ENUM_VALUES_##enumtype(MAKE_FROM_STRING_CONTENT) \
 662         return FALSE; \
 663     }
 664
 665 ENUM_LIST(MAKE_FROM_TO_STRING)
 666
 667 //////////////////////////////////////////////////////////////////////////
 668 // Note initialisation functions
 669
 670 void sampler_nif_vel2pitch(struct sampler_noteinitfunc *nif, struct sampler_voice *v)
 671 {
 672     v->pitch_shift += nif->param * v->vel * (1.0 / 127.0);
 673 }
 674
 675 void sampler_nif_cc2delay(struct sampler_noteinitfunc *nif, struct sampler_voice *v)
 676 {
 677     v->delay += nif->param * v->channel->cc[nif->variant] * (1.0 / 127.0) * v->channel->module->module.srate;
 678 }
 679
 680 void sampler_nif_addrandom(struct sampler_noteinitfunc *nif, struct sampler_voice *v)
 681 {
 682     float rnd = rand() * 1.0 / RAND_MAX;
 683     switch(nif->variant)
 684     {
 685         case 0:
 686             v->gain_shift += rnd * nif->param;
 687             break;
 688         case 1:
 689             v->cutoff_shift += rnd * nif->param;
 690             break;
 691         case 2:
 692             v->pitch_shift += rnd * nif->param; // this is in cents
 693             break;
 694     }
 695 }
 696
 697 void sampler_nif_vel2env(struct sampler_noteinitfunc *nif, struct sampler_voice *v)
 698 {
 699     int env_type = (nif->variant) >> 4;
 700     struct cbox_envelope *env = NULL;
 701     switch(env_type)
 702     {
 703         case 0:
 704             env = &v->amp_env;
 705             break;
 706         case 1:
 707             env = &v->filter_env;
 708             break;
 709         case 2:
 710             env = &v->pitch_env;
 711             break;
 712         default:
 713             assert(0);
 714     }
 715     if (env->shape != &v->dyn_envs[env_type])
 716     {
 717         memcpy(&v->dyn_envs[env_type], env->shape, sizeof(struct cbox_envelope_shape));
 718         env->shape = &v->dyn_envs[env_type];
 719     }
 720     float param = nif->param * v->vel * (1.0 / 127.0);
 721     if ((nif->variant & 15) == 4)
 722         param *= 0.01;
 723     cbox_envelope_modify_dahdsr(env->shape, nif->variant & 15, param, v->channel->module->module.srate * (1.0 / CBOX_BLOCK_SIZE));
 724 }
 725
 726 //////////////////////////////////////////////////////////////////////////
 727
 728 struct cbox_module_livecontroller_metadata sampler_controllers[] = {
 729 };
 730
 731 struct cbox_module_keyrange_metadata sampler_keyranges[] = {
 732 };
 733
 734 DEFINE_MODULE(sampler, 0, 2)
 735