You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
783 lines
26 KiB
783 lines
26 KiB
/*
|
|
Calf Box, an open source musical instrument.
|
|
Copyright (C) 2010-2013 Krzysztof Foltman
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config-api.h"
|
|
#include "dspmath.h"
|
|
#include "engine.h"
|
|
#include "errors.h"
|
|
#include "midi.h"
|
|
#include "module.h"
|
|
#include "rt.h"
|
|
#include "sampler.h"
|
|
#include "sampler_impl.h"
|
|
#include "sfzloader.h"
|
|
#include "stm.h"
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <glib.h>
|
|
#include <math.h>
|
|
#include <memory.h>
|
|
#include <sndfile.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
float sampler_sine_wave[2049];
|
|
|
|
GQuark cbox_sampler_error_quark()
|
|
{
|
|
return g_quark_from_string("cbox-sampler-error-quark");
|
|
}
|
|
|
|
static void sampler_process_block(struct cbox_module *module, cbox_sample_t **inputs, cbox_sample_t **outputs);
|
|
static void sampler_process_event(struct cbox_module *module, const uint8_t *data, uint32_t len);
|
|
static void sampler_destroyfunc(struct cbox_module *module);
|
|
|
|
void sampler_steal_voice(struct sampler_module *m)
|
|
{
|
|
int max_age = 0;
|
|
struct sampler_voice *voice_found = NULL;
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
FOREACH_VOICE(m->channels[i].voices_running, v)
|
|
{
|
|
if (v->amp_env.cur_stage == 15)
|
|
continue;
|
|
int age = m->serial_no - v->serial_no;
|
|
if (v->gen.loop_start == (uint32_t)-1)
|
|
age += (int)((v->gen.bigpos >> 32) * 100.0 / v->gen.cur_sample_end);
|
|
else
|
|
if (v->released)
|
|
age += 10;
|
|
if (age > max_age)
|
|
{
|
|
max_age = age;
|
|
voice_found = v;
|
|
}
|
|
}
|
|
}
|
|
if (voice_found)
|
|
{
|
|
voice_found->released = 1;
|
|
cbox_envelope_go_to(&voice_found->amp_env, 15);
|
|
}
|
|
}
|
|
|
|
static inline float clip01(float v)
|
|
{
|
|
if (v < 0.f)
|
|
return 0;
|
|
if (v > 1.f)
|
|
return 1;
|
|
return v;
|
|
}
|
|
|
|
void sampler_create_voice_from_prevoice(struct sampler_module *m, struct sampler_prevoice *pv)
|
|
{
|
|
if (!m->voices_free)
|
|
return;
|
|
struct sampler_released_groups exgroups;
|
|
sampler_released_groups_init(&exgroups);
|
|
sampler_voice_start(m->voices_free, pv->channel, pv->layer_data, pv->note, pv->vel, &exgroups);
|
|
if (exgroups.low_groups || exgroups.group_count)
|
|
sampler_channel_release_groups(pv->channel, pv->note, &exgroups);
|
|
}
|
|
|
|
void sampler_process_block(struct cbox_module *module, cbox_sample_t **inputs, cbox_sample_t **outputs)
|
|
{
|
|
struct sampler_module *m = (struct sampler_module *)module;
|
|
|
|
int active_prevoices[16];
|
|
uint32_t active_prevoices_mask = 0;
|
|
FOREACH_PREVOICE(m->prevoices_running, pv)
|
|
{
|
|
uint32_t c = pv->channel - m->channels;
|
|
active_prevoices[c] = (active_prevoices_mask >> c) & 1 ? 1 + active_prevoices[c] : 1;
|
|
active_prevoices_mask |= 1 << c;
|
|
if (sampler_prevoice_process(pv, m))
|
|
{
|
|
sampler_prevoice_unlink(&m->prevoices_running, pv);
|
|
sampler_create_voice_from_prevoice(m, pv);
|
|
sampler_prevoice_link(&m->prevoices_free, pv);
|
|
}
|
|
}
|
|
|
|
for (int c = 0; c < m->output_pairs + m->aux_pairs; c++)
|
|
{
|
|
int oo = 2 * c;
|
|
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
|
|
outputs[oo][i] = outputs[oo + 1][i] = 0.f;
|
|
}
|
|
|
|
int vcount = 0, vrel = 0, pvcount = 0;
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
int cvcount = 0;
|
|
FOREACH_VOICE(m->channels[i].voices_running, v)
|
|
{
|
|
sampler_voice_process(v, m, outputs);
|
|
|
|
if (v->amp_env.cur_stage == 15)
|
|
vrel++;
|
|
cvcount++;
|
|
}
|
|
int cpvcount = (active_prevoices_mask >> i) & 1 ? active_prevoices[i] : 0;
|
|
m->channels[i].active_voices = cvcount;
|
|
m->channels[i].active_prevoices = cpvcount;
|
|
vcount += cvcount;
|
|
pvcount += cpvcount;
|
|
}
|
|
m->active_voices = vcount;
|
|
m->active_prevoices = pvcount;
|
|
if(vcount - vrel > m->max_voices + 1)
|
|
sampler_steal_voice(m);
|
|
if(vcount - vrel > m->max_voices)
|
|
sampler_steal_voice(m);
|
|
m->serial_no++;
|
|
m->current_time += CBOX_BLOCK_SIZE;
|
|
}
|
|
|
|
void sampler_process_event(struct cbox_module *module, const uint8_t *data, uint32_t len)
|
|
{
|
|
struct sampler_module *m = (struct sampler_module *)module;
|
|
if (len > 0)
|
|
{
|
|
int cmd = data[0] >> 4;
|
|
int chn = data[0] & 15;
|
|
struct sampler_channel *c = &m->channels[chn];
|
|
switch(cmd)
|
|
{
|
|
case 8:
|
|
sampler_channel_stop_note(c, data[1], data[2], FALSE);
|
|
break;
|
|
|
|
case 9:
|
|
if (data[2] > 0)
|
|
sampler_channel_start_note(c, data[1], data[2], FALSE);
|
|
else
|
|
sampler_channel_stop_note(c, data[1], data[2], FALSE);
|
|
break;
|
|
|
|
case 10:
|
|
c->last_polyaft = data[2];
|
|
// Lazy clearing
|
|
if (!(c->poly_pressure_mask & (1 << (data[1] >> 2))))
|
|
{
|
|
// Clear the group of 4
|
|
memset(c->poly_pressure + (data[1] & ~3), 0, 4);
|
|
c->poly_pressure_mask |= 1 << (data[1] >> 2);
|
|
}
|
|
c->poly_pressure[data[1]] = data[2];
|
|
// XXXKF add a new opcode for cymbal chokes via poly pressure
|
|
// if (data[2] == 127)
|
|
// sampler_channel_stop_note(c, data[1], data[2], TRUE);
|
|
break;
|
|
|
|
case 11:
|
|
sampler_channel_process_cc(c, data[1], data[2]);
|
|
break;
|
|
|
|
case 12:
|
|
sampler_channel_program_change(c, data[1]);
|
|
break;
|
|
|
|
case 13:
|
|
c->last_chanaft = data[1];
|
|
break;
|
|
|
|
case 14:
|
|
c->pitchwheel = data[1] + 128 * data[2] - 8192;
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
static int get_first_free_program_no(struct sampler_module *m)
|
|
{
|
|
int prog_no = -1;
|
|
gboolean found;
|
|
|
|
// XXXKF this has a N-squared complexity - but I'm not seeing
|
|
// this being used with more than 10 programs at the same time
|
|
// in the near future
|
|
do {
|
|
prog_no++;
|
|
found = FALSE;
|
|
for (uint32_t i = 0; i < m->program_count; i++)
|
|
{
|
|
if (m->programs[i]->prog_no == prog_no)
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
} while(found);
|
|
|
|
return prog_no;
|
|
}
|
|
|
|
static int find_program(struct sampler_module *m, int prog_no)
|
|
{
|
|
for (uint32_t i = 0; i < m->program_count; i++)
|
|
{
|
|
if (m->programs[i]->prog_no == prog_no)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
struct release_program_voices_data
|
|
{
|
|
struct sampler_module *module;
|
|
|
|
struct sampler_program *old_pgm, *new_pgm;
|
|
uint16_t channels_to_wait_for;
|
|
};
|
|
|
|
static int release_program_voices_execute(void *data)
|
|
{
|
|
struct release_program_voices_data *rpv = data;
|
|
struct sampler_module *m = rpv->module;
|
|
int finished = 1;
|
|
|
|
FOREACH_PREVOICE(m->prevoices_running, pv)
|
|
{
|
|
if (pv->channel->program == rpv->old_pgm)
|
|
{
|
|
sampler_prevoice_unlink(&m->prevoices_running, pv);
|
|
sampler_prevoice_link(&m->prevoices_free, pv);
|
|
}
|
|
}
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
uint16_t mask = 1 << i;
|
|
struct sampler_channel *c = &m->channels[i];
|
|
if (c->program == rpv->old_pgm || c->program == NULL)
|
|
{
|
|
sampler_channel_set_program_RT(c, rpv->new_pgm);
|
|
rpv->channels_to_wait_for |= mask;
|
|
}
|
|
if (rpv->channels_to_wait_for & mask)
|
|
{
|
|
FOREACH_VOICE(c->voices_running, v)
|
|
{
|
|
if (m->deleting || !m->module.rt)
|
|
{
|
|
sampler_voice_inactivate(v, TRUE);
|
|
continue;
|
|
}
|
|
// This is a new voice, started after program change, so it
|
|
// should not be terminated and waited for.
|
|
if (v->program == rpv->new_pgm)
|
|
continue;
|
|
// The voice is still going, so repeat until it fades out
|
|
finished = 0;
|
|
// If not in final fadeout stage, force final fadeout.
|
|
if (v->amp_env.cur_stage != 15)
|
|
{
|
|
v->released = 1;
|
|
cbox_envelope_go_to(&v->amp_env, 15);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return finished;
|
|
}
|
|
|
|
static void swap_program(struct sampler_module *m, int index, struct sampler_program *pgm, gboolean delete_old)
|
|
{
|
|
static struct cbox_rt_cmd_definition release_program_voices = { NULL, release_program_voices_execute, NULL };
|
|
|
|
struct sampler_program *old_program = NULL;
|
|
if (pgm)
|
|
old_program = cbox_rt_swap_pointers(m->module.rt, (void **)&m->programs[index], pgm);
|
|
else
|
|
old_program = cbox_rt_array_remove(m->module.rt, (void ***)&m->programs, &m->program_count, index);
|
|
|
|
struct release_program_voices_data data = {m, old_program, pgm, 0};
|
|
|
|
cbox_rt_execute_cmd_sync(m->module.rt, &release_program_voices, &data);
|
|
|
|
if (delete_old && old_program)
|
|
CBOX_DELETE(old_program);
|
|
}
|
|
|
|
static void select_initial_program(struct sampler_module *m)
|
|
{
|
|
static struct cbox_rt_cmd_definition release_program_voices = { NULL, release_program_voices_execute, NULL };
|
|
struct release_program_voices_data data = {m, NULL, m->programs[0], 0};
|
|
cbox_rt_execute_cmd_sync(m->module.rt, &release_program_voices, &data);
|
|
}
|
|
|
|
void sampler_register_program(struct sampler_module *m, struct sampler_program *pgm)
|
|
{
|
|
struct sampler_program **programs = malloc(sizeof(struct sampler_program *) * (m->program_count + 1));
|
|
memcpy(programs, m->programs, sizeof(struct sampler_program *) * m->program_count);
|
|
programs[m->program_count] = pgm;
|
|
free(cbox_rt_swap_pointers_and_update_count(m->module.rt, (void **)&m->programs, programs, &m->program_count, m->program_count + 1));
|
|
if (m->program_count == 1U)
|
|
select_initial_program(m);
|
|
}
|
|
|
|
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)
|
|
{
|
|
struct sampler_program *pgm = NULL;
|
|
int index = find_program(m, prog_no);
|
|
pgm = sampler_program_new_from_cfg(m, cfg_section, name, prog_no, error);
|
|
if (!pgm)
|
|
return FALSE;
|
|
|
|
if (index != -1)
|
|
{
|
|
swap_program(m, index, pgm, TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
sampler_register_program(m, pgm);
|
|
if (ppgm)
|
|
*ppgm = pgm;
|
|
return TRUE;
|
|
}
|
|
|
|
void sampler_unselect_program(struct sampler_module *m, struct sampler_program *prg)
|
|
{
|
|
// Ensure no new notes are played on that program
|
|
prg->deleting = TRUE;
|
|
// Remove from the list of available programs, so that it cannot be selected again
|
|
for (uint32_t i = 0; i < m->program_count; i++)
|
|
{
|
|
if (m->programs[i] == prg)
|
|
swap_program(m, i, NULL, FALSE);
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
int index = find_program(m, prog_no);
|
|
struct sampler_program *pgm = sampler_program_new(m, prog_no, name, NULL, sample_dir, error);
|
|
if (!pgm)
|
|
return FALSE;
|
|
pgm->source_file = g_strdup("string");
|
|
if (!sampler_module_load_program_sfz(m, pgm, sfz_data, TRUE, error))
|
|
{
|
|
free(pgm);
|
|
return FALSE;
|
|
}
|
|
|
|
if (index != -1)
|
|
{
|
|
swap_program(m, index, pgm, TRUE);
|
|
if (ppgm)
|
|
*ppgm = pgm;
|
|
return TRUE;
|
|
}
|
|
|
|
struct sampler_program **programs = calloc((m->program_count + 1), sizeof(struct sampler_program *));
|
|
memcpy(programs, m->programs, sizeof(struct sampler_program *) * m->program_count);
|
|
programs[m->program_count] = pgm;
|
|
if (ppgm)
|
|
*ppgm = pgm;
|
|
free(cbox_rt_swap_pointers_and_update_count(m->module.rt, (void **)&m->programs, programs, &m->program_count, m->program_count + 1));
|
|
if (m->program_count == 1)
|
|
select_initial_program(m);
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean sampler_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
|
|
{
|
|
struct sampler_module *m = (struct sampler_module *)ct->user_data;
|
|
|
|
if (!strcmp(cmd->command, "/status") && !strcmp(cmd->arg_types, ""))
|
|
{
|
|
if (!cbox_check_fb_channel(fb, cmd->command, error))
|
|
return FALSE;
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
struct sampler_channel *channel = &m->channels[i];
|
|
gboolean result;
|
|
if (channel->program)
|
|
result = cbox_execute_on(fb, NULL, "/patch", "iis", error, i + 1, channel->program->prog_no, channel->program->name);
|
|
else
|
|
result = cbox_execute_on(fb, NULL, "/patch", "iis", error, i + 1, -1, "");
|
|
if (!result)
|
|
return FALSE;
|
|
if (!(cbox_execute_on(fb, NULL, "/channel_voices", "ii", error, i + 1, channel->active_voices) &&
|
|
cbox_execute_on(fb, NULL, "/channel_prevoices", "ii", error, i + 1, channel->active_prevoices) &&
|
|
cbox_execute_on(fb, NULL, "/output", "ii", error, i + 1, channel->output_shift) &&
|
|
cbox_execute_on(fb, NULL, "/volume", "ii", error, i + 1, sampler_channel_addcc(channel, 7)) &&
|
|
cbox_execute_on(fb, NULL, "/pan", "ii", error, i + 1, sampler_channel_addcc(channel, 10))))
|
|
return FALSE;
|
|
}
|
|
|
|
return cbox_execute_on(fb, NULL, "/active_voices", "i", error, m->active_voices) &&
|
|
cbox_execute_on(fb, NULL, "/active_prevoices", "i", error, m->active_prevoices) &&
|
|
cbox_execute_on(fb, NULL, "/active_pipes", "i", error, cbox_prefetch_stack_get_active_pipe_count(m->pipe_stack)) &&
|
|
cbox_execute_on(fb, NULL, "/polyphony", "i", error, m->max_voices) &&
|
|
CBOX_OBJECT_DEFAULT_STATUS(&m->module, fb, error);
|
|
}
|
|
else
|
|
if (!strcmp(cmd->command, "/keyswitch_state") && !strcmp(cmd->arg_types, "ii"))
|
|
{
|
|
int channel = CBOX_ARG_I(cmd, 0);
|
|
if (channel < 1 || channel > 16)
|
|
{
|
|
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Invalid channel %d", channel);
|
|
return FALSE;
|
|
}
|
|
int group = CBOX_ARG_I(cmd, 1);
|
|
if (group < 0 || group >= MAX_KEYSWITCH_GROUPS)
|
|
{
|
|
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Invalid keyswitch group %d", group);
|
|
return FALSE;
|
|
}
|
|
if (!cbox_execute_on(fb, NULL, "/last_key", "i", error, m->channels[channel - 1].keyswitch_lastkey[group]))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
else
|
|
if (!strcmp(cmd->command, "/patches") && !strcmp(cmd->arg_types, ""))
|
|
{
|
|
if (!cbox_check_fb_channel(fb, cmd->command, error))
|
|
return FALSE;
|
|
for (uint32_t i = 0; i < m->program_count; i++)
|
|
{
|
|
struct sampler_program *prog = m->programs[i];
|
|
if (!cbox_execute_on(fb, NULL, "/patch", "isoi", error, prog->prog_no, prog->name, prog, prog->in_use))
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else if (!strcmp(cmd->command, "/polyphony") && !strcmp(cmd->arg_types, "i"))
|
|
{
|
|
int polyphony = CBOX_ARG_I(cmd, 0);
|
|
if (polyphony < 1 || polyphony > MAX_SAMPLER_VOICES)
|
|
{
|
|
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);
|
|
return FALSE;
|
|
}
|
|
m->max_voices = polyphony;
|
|
return TRUE;
|
|
}
|
|
else if (!strcmp(cmd->command, "/set_patch") && !strcmp(cmd->arg_types, "ii"))
|
|
{
|
|
int channel = CBOX_ARG_I(cmd, 0);
|
|
if (channel < 1 || channel > 16)
|
|
{
|
|
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Invalid channel %d", channel);
|
|
return FALSE;
|
|
}
|
|
int value = CBOX_ARG_I(cmd, 1);
|
|
struct sampler_program *pgm = NULL;
|
|
for (uint32_t i = 0; i < m->program_count; i++)
|
|
{
|
|
if (m->programs[i]->prog_no == value)
|
|
{
|
|
pgm = m->programs[i];
|
|
break;
|
|
}
|
|
}
|
|
sampler_channel_set_program(&m->channels[channel - 1], pgm);
|
|
return TRUE;
|
|
}
|
|
else if (!strcmp(cmd->command, "/set_output") && !strcmp(cmd->arg_types, "ii"))
|
|
{
|
|
int channel = CBOX_ARG_I(cmd, 0);
|
|
int output = CBOX_ARG_I(cmd, 1);
|
|
if (channel < 1 || channel > 16)
|
|
{
|
|
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Invalid channel %d", channel);
|
|
return FALSE;
|
|
}
|
|
if (output < 0 || output >= m->output_pairs)
|
|
{
|
|
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Invalid output %d", output);
|
|
return FALSE;
|
|
}
|
|
m->channels[channel - 1].output_shift = output;
|
|
return TRUE;
|
|
}
|
|
else if (!strcmp(cmd->command, "/load_patch") && !strcmp(cmd->arg_types, "iss"))
|
|
{
|
|
struct sampler_program *pgm = NULL;
|
|
if (!load_program_at(m, CBOX_ARG_S(cmd, 1), CBOX_ARG_S(cmd, 2), CBOX_ARG_I(cmd, 0), &pgm, error))
|
|
return FALSE;
|
|
if (fb)
|
|
return cbox_execute_on(fb, NULL, "/uuid", "o", error, pgm);
|
|
return TRUE;
|
|
}
|
|
else if (!strcmp(cmd->command, "/load_patch_from_file") && !strcmp(cmd->arg_types, "iss"))
|
|
{
|
|
struct sampler_program *pgm = NULL;
|
|
char *cfg_section = g_strdup_printf("spgm:!%s", CBOX_ARG_S(cmd, 1));
|
|
gboolean res = load_program_at(m, cfg_section, CBOX_ARG_S(cmd, 2), CBOX_ARG_I(cmd, 0), &pgm, error);
|
|
g_free(cfg_section);
|
|
if (res && pgm && fb)
|
|
return cbox_execute_on(fb, NULL, "/uuid", "o", error, pgm);
|
|
return res;
|
|
}
|
|
else if (!strcmp(cmd->command, "/load_patch_from_string") && !strcmp(cmd->arg_types, "isss"))
|
|
{
|
|
struct sampler_program *pgm = NULL;
|
|
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))
|
|
return FALSE;
|
|
if (fb && pgm)
|
|
return cbox_execute_on(fb, NULL, "/uuid", "o", error, pgm);
|
|
return TRUE;
|
|
}
|
|
else if (!strcmp(cmd->command, "/get_unused_program") && !strcmp(cmd->arg_types, ""))
|
|
{
|
|
if (!cbox_check_fb_channel(fb, cmd->command, error))
|
|
return FALSE;
|
|
return cbox_execute_on(fb, NULL, "/program_no", "i", error, get_first_free_program_no(m));
|
|
}
|
|
else
|
|
return cbox_object_default_process_cmd(ct, fb, cmd, error);
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean sampler_select_program(struct sampler_module *m, int channel, const gchar *preset, GError **error)
|
|
{
|
|
for (uint32_t i = 0; i < m->program_count; i++)
|
|
{
|
|
if (!strcmp(m->programs[i]->name, preset))
|
|
{
|
|
sampler_channel_set_program(&m->channels[channel], m->programs[i]);
|
|
return TRUE;
|
|
}
|
|
}
|
|
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Preset not found: %s", preset);
|
|
return FALSE;
|
|
}
|
|
|
|
double sampler_get_current_beat(struct sampler_module *m)
|
|
{
|
|
uint32_t song_pos_samples = cbox_engine_current_pos_samples(m->module.engine);
|
|
double tempo_bpm = m->module.engine->master->tempo;
|
|
double song_pos_sec = song_pos_samples * 1.0 / m->module.srate;
|
|
return song_pos_sec * tempo_bpm / 60;
|
|
}
|
|
|
|
MODULE_CREATE_FUNCTION(sampler)
|
|
{
|
|
int i;
|
|
static int inited = 0;
|
|
if (!inited)
|
|
{
|
|
for (int i = 0; i < 2049; i++)
|
|
sampler_sine_wave[i] = sin(i * M_PI / 1024.0);
|
|
inited = 1;
|
|
}
|
|
|
|
int max_voices = cbox_config_get_int(cfg_section, "polyphony", MAX_SAMPLER_VOICES);
|
|
if (max_voices < 1 || max_voices > MAX_SAMPLER_VOICES)
|
|
{
|
|
g_set_error(error, CBOX_SAMPLER_ERROR, CBOX_SAMPLER_ERROR_INVALID_LAYER, "%s: invalid polyphony value", cfg_section);
|
|
return NULL;
|
|
}
|
|
int output_pairs = cbox_config_get_int(cfg_section, "output_pairs", 1);
|
|
if (output_pairs < 1 || output_pairs > 16)
|
|
{
|
|
g_set_error(error, CBOX_SAMPLER_ERROR, CBOX_SAMPLER_ERROR_INVALID_LAYER, "%s: invalid output pairs value", cfg_section);
|
|
return NULL;
|
|
}
|
|
int aux_pairs = cbox_config_get_int(cfg_section, "aux_pairs", 0);
|
|
if (aux_pairs < 0 || aux_pairs > 4)
|
|
{
|
|
g_set_error(error, CBOX_SAMPLER_ERROR, CBOX_SAMPLER_ERROR_INVALID_LAYER, "%s: invalid aux pairs value", cfg_section);
|
|
return NULL;
|
|
}
|
|
|
|
struct sampler_module *m = calloc(1, sizeof(struct sampler_module));
|
|
CALL_MODULE_INIT(m, 0, (output_pairs + aux_pairs) * 2, sampler);
|
|
m->output_pairs = output_pairs;
|
|
m->aux_pairs = aux_pairs;
|
|
m->module.aux_offset = m->output_pairs * 2;
|
|
m->module.process_event = sampler_process_event;
|
|
m->module.process_block = sampler_process_block;
|
|
m->programs = NULL;
|
|
m->max_voices = max_voices;
|
|
m->serial_no = 0;
|
|
m->deleting = FALSE;
|
|
// XXXKF read defaults from some better place, like config
|
|
// XXXKF allow dynamic change of the number of the pipes
|
|
m->pipe_stack = cbox_prefetch_stack_new(MAX_SAMPLER_VOICES, cbox_config_get_int("streaming", "streambuf_size", 65536), cbox_config_get_int("streaming", "min_buf_frames", PIPE_MIN_PREFETCH_SIZE_FRAMES));
|
|
m->disable_mixer_controls = cbox_config_get_int("sampler", "disable_mixer_controls", 0);
|
|
|
|
float srate = m->module.srate;
|
|
for (i = 0; i < 12800; i++)
|
|
{
|
|
float freq = 440 * pow(2, (i - 5700) / 1200.0);
|
|
if (freq < 20.0)
|
|
freq = 20.0;
|
|
if (freq > srate * 0.45)
|
|
freq = srate * 0.45;
|
|
float omega=(float)(2*M_PI*freq/srate);
|
|
m->sincos[i].sine = sinf(omega);
|
|
m->sincos[i].cosine = cosf(omega);
|
|
m->sincos[i].prewarp = 2.0 * tan(hz2w(freq, srate) * 0.5f);
|
|
m->sincos[i].prewarp2 = 1.0 / (1.0 + m->sincos[i].prewarp);
|
|
|
|
}
|
|
for (i = 0; ; i++)
|
|
{
|
|
gchar *s = g_strdup_printf("program%d", i);
|
|
char *p = cbox_config_get_string(cfg_section, s);
|
|
g_free(s);
|
|
|
|
if (!p)
|
|
{
|
|
m->program_count = i;
|
|
break;
|
|
}
|
|
}
|
|
m->programs = calloc(m->program_count, sizeof(struct sampler_program *));
|
|
int success = 1;
|
|
for (i = 0; i < (int)m->program_count; i++)
|
|
{
|
|
gchar *s = g_strdup_printf("program%d", i);
|
|
char *pgm_section = NULL;
|
|
int pgm_id = -1;
|
|
const char *pgm_name = cbox_config_get_string(cfg_section, s);
|
|
g_free(s);
|
|
char *at = strchr(pgm_name, '@');
|
|
if (at)
|
|
{
|
|
pgm_id = atoi(at + 1);
|
|
s = g_strndup(pgm_name, at - pgm_name);
|
|
pgm_section = g_strdup_printf("spgm:%s", s);
|
|
g_free(s);
|
|
}
|
|
else
|
|
{
|
|
pgm_id = i;
|
|
pgm_section = g_strdup_printf("spgm:%s", pgm_name);
|
|
}
|
|
|
|
m->programs[i] = sampler_program_new_from_cfg(m, pgm_section, pgm_section + 5, pgm_id, error);
|
|
g_free(pgm_section);
|
|
if (!m->programs[i])
|
|
{
|
|
success = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (!success)
|
|
{
|
|
// XXXKF free programs/layers, first ensuring that they're fully initialised
|
|
free(m);
|
|
return NULL;
|
|
}
|
|
m->voices_free = NULL;
|
|
memset(m->voices_all, 0, sizeof(m->voices_all));
|
|
for (i = 0; i < MAX_SAMPLER_VOICES; i++)
|
|
{
|
|
struct sampler_voice *v = &m->voices_all[i];
|
|
v->gen.mode = spt_inactive;
|
|
sampler_voice_link(&m->voices_free, v);
|
|
}
|
|
m->active_voices = 0;
|
|
m->active_prevoices = 0;
|
|
|
|
m->prevoices_free = NULL;
|
|
memset(m->prevoices_all, 0, sizeof(m->prevoices_all));
|
|
for (i = 0; i < MAX_SAMPLER_PREVOICES; i++)
|
|
{
|
|
struct sampler_prevoice *v = &m->prevoices_all[i];
|
|
sampler_prevoice_link(&m->prevoices_free, v);
|
|
}
|
|
|
|
for (i = 0; i < 16; i++)
|
|
sampler_channel_init(&m->channels[i], m);
|
|
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
gchar *key = g_strdup_printf("channel%d", i + 1);
|
|
gchar *preset = cbox_config_get_string(cfg_section, key);
|
|
if (preset)
|
|
{
|
|
if (!sampler_select_program(m, i, preset, error))
|
|
{
|
|
CBOX_DELETE(&m->module);
|
|
return NULL;
|
|
}
|
|
}
|
|
g_free(key);
|
|
key = g_strdup_printf("channel%d_output", i + 1);
|
|
m->channels[i].output_shift = cbox_config_get_int(cfg_section, key, 1) - 1;
|
|
g_free(key);
|
|
}
|
|
|
|
|
|
return &m->module;
|
|
}
|
|
|
|
void sampler_destroyfunc(struct cbox_module *module)
|
|
{
|
|
struct sampler_module *m = (struct sampler_module *)module;
|
|
uint32_t i;
|
|
m->deleting = TRUE;
|
|
|
|
for (i = 0; i < m->program_count;)
|
|
{
|
|
if (m->programs[i])
|
|
CBOX_DELETE(m->programs[i]);
|
|
else
|
|
i++;
|
|
}
|
|
for (i = 0; i < 16U; i++)
|
|
{
|
|
assert (m->channels[i].voices_running == NULL);
|
|
}
|
|
cbox_prefetch_stack_destroy(m->pipe_stack);
|
|
free(m->programs);
|
|
}
|
|
|
|
#define MAKE_TO_STRING_CONTENT(name, v) \
|
|
case v: return name;
|
|
|
|
#define MAKE_FROM_STRING_CONTENT(n, v) \
|
|
if (!strcmp(name, n)) { *value = v; return TRUE; }
|
|
|
|
#define MAKE_FROM_TO_STRING(enumtype) \
|
|
const char *enumtype##_to_string(enum enumtype value) \
|
|
{ \
|
|
switch(value) { \
|
|
ENUM_VALUES_##enumtype(MAKE_TO_STRING_CONTENT) \
|
|
default: return NULL; \
|
|
} \
|
|
} \
|
|
\
|
|
gboolean enumtype##_from_string(const char *name, enum enumtype *value) \
|
|
{ \
|
|
ENUM_VALUES_##enumtype(MAKE_FROM_STRING_CONTENT) \
|
|
return FALSE; \
|
|
}
|
|
|
|
ENUM_LIST(MAKE_FROM_TO_STRING)
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
struct cbox_module_livecontroller_metadata sampler_controllers[] = {
|
|
};
|
|
|
|
struct cbox_module_keyrange_metadata sampler_keyranges[] = {
|
|
};
|
|
|
|
DEFINE_MODULE(sampler, 0, 2)
|
|
|
|
|