Sampled Instrument Player with static and monolithic design. All instruments are built-in.
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.

356 lines
11 KiB

/*
Calf Box, an open source musical instrument.
Copyright (C) 2010-2011 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.h"
#include "config-api.h"
#include "dspmath.h"
#include "module.h"
#include "onepole-float.h"
#include <glib.h>
#include <malloc.h>
#include <math.h>
#include <memory.h>
#include <sndfile.h>
#include <stdio.h>
#include <stdlib.h>
// The reverb structure is based on this article:
// http://www.spinsemi.com/knowledge_base/effects.html#Reverberation
#define DELAY_BUFFER 1024
#define ALLPASS_BUFFER 2048
struct allpass_param
{
int delay;
float diffusion;
};
struct cbox_reverb_leg_params
{
int delay_length;
int allpass_units;
struct allpass_param allpasses[0];
};
struct cbox_reverb_leg
{
struct cbox_reverb_leg_params *params;
float (*allpass_storage)[ALLPASS_BUFFER];
float delay_storage[DELAY_BUFFER];
struct cbox_onepolef_state filter_state;
float buffer[CBOX_BLOCK_SIZE];
};
static struct cbox_reverb_leg_params *leg_params_new(int delay_length, int allpasses, const struct allpass_param *allpass_params)
{
struct cbox_reverb_leg_params *p = malloc(sizeof(struct cbox_reverb_leg_params) + sizeof(struct allpass_param) * allpasses);
p->delay_length = delay_length;
p->allpass_units = allpasses;
if (allpass_params)
{
for (int i = 0; i < allpasses; i++)
memcpy(&p->allpasses[i], &allpass_params[i], sizeof(struct allpass_param));
}
return p;
}
static void cbox_reverb_leg_reset(struct cbox_reverb_leg *leg)
{
cbox_onepolef_reset(&leg->filter_state);
int i;
for (int a = 0; a < leg->params->allpass_units; a++)
for (i = 0; i < ALLPASS_BUFFER; i++)
leg->allpass_storage[a][i] = 0.f;
for (i = 0; i < DELAY_BUFFER; i++)
leg->delay_storage[i] = 0.f;
}
static void cbox_reverb_leg_init(struct cbox_reverb_leg *leg)
{
leg->allpass_storage = malloc(leg->params->allpass_units * ALLPASS_BUFFER * sizeof(float));
cbox_reverb_leg_reset(leg);
}
static void cbox_reverb_leg_cleanup(struct cbox_reverb_leg *leg)
{
free(leg->params);
free(leg->allpass_storage);
}
#define MODULE_PARAMS reverb_params
struct reverb_params
{
float decay_time;
float wetamt;
float dryamt;
float lowpass, highpass;
};
struct reverb_state
{
struct cbox_reverb_leg *legs;
int leg_count;
int total_time;
};
struct reverb_module
{
struct cbox_module module;
struct cbox_onepolef_coeffs filter_coeffs[2];
struct reverb_params *params, *old_params;
struct reverb_state *state;
float gain;
int pos;
};
gboolean reverb_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
{
struct reverb_module *m = (struct reverb_module *)ct->user_data;
EFFECT_PARAM("/wet_amt", "f", wetamt, double, dB2gain_simple, -100, 100) else
EFFECT_PARAM("/dry_amt", "f", dryamt, double, dB2gain_simple, -100, 100) else
EFFECT_PARAM("/decay_time", "f", decay_time, double, , 500, 5000) else
EFFECT_PARAM("/lowpass", "f", lowpass, double, , 30, 20000) else
EFFECT_PARAM("/highpass", "f", highpass, double, , 30, 20000) else
if (!strcmp(cmd->command, "/status") && !strcmp(cmd->arg_types, ""))
{
if (!cbox_check_fb_channel(fb, cmd->command, error))
return FALSE;
return cbox_execute_on(fb, NULL, "/wet_amt", "f", error, gain2dB_simple(m->params->wetamt)) &&
cbox_execute_on(fb, NULL, "/dry_amt", "f", error, gain2dB_simple(m->params->dryamt)) &&
cbox_execute_on(fb, NULL, "/decay_time", "f", error, m->params->decay_time) &&
cbox_execute_on(fb, NULL, "/lowpass", "f", error, m->params->lowpass) &&
cbox_execute_on(fb, NULL, "/highpass", "f", error, m->params->highpass) &&
CBOX_OBJECT_DEFAULT_STATUS(&m->module, fb, error);
}
else
return cbox_object_default_process_cmd(ct, fb, cmd, error);
return TRUE;
}
void reverb_process_event(struct cbox_module *module, const uint8_t *data, uint32_t len)
{
// struct reverb_module *m = (struct reverb_module *)module;
}
static void cbox_reverb_process_leg(struct reverb_module *m, int u)
{
int pos;
int dv;
float *storage;
struct reverb_state *state = m->state;
struct cbox_reverb_leg *b = &state->legs[u];
int uprev = u ? (u - 1) : (state->leg_count - 1);
struct cbox_reverb_leg *bprev = &state->legs[uprev];
float gain = m->gain;
pos = m->pos;
storage = bprev->delay_storage;
float *buf = b->buffer;
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
{
buf[i] += cbox_onepolef_process_sample(&b->filter_state, &m->filter_coeffs[u&1], storage[pos & (DELAY_BUFFER - 1)] * gain);
pos++;
}
int units = b->params->allpass_units;
for (int a = 0; a < units; a++)
{
pos = m->pos;
storage = b->allpass_storage[a];
dv = b->params->allpasses[a].delay;
float w = b->params->allpasses[a].diffusion;
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
{
float dry = buf[i];
float out = dry;
float delayed = storage[pos & (ALLPASS_BUFFER - 1)];
float feedback = sanef(out - w * delayed);
buf[i] = sanef(feedback * w + delayed);
storage[(pos + dv) & (ALLPASS_BUFFER - 1)] = feedback;
pos++;
}
}
pos = m->pos;
storage = b->delay_storage;
dv = b->params->delay_length - (u == 0 ? CBOX_BLOCK_SIZE : 0);
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
{
storage[(pos + dv) & (DELAY_BUFFER - 1)] = buf[i];
pos++;
}
}
void reverb_process_block(struct cbox_module *module, cbox_sample_t **inputs, cbox_sample_t **outputs)
{
struct reverb_module *m = (struct reverb_module *)module;
struct reverb_params *p = m->params;
float dryamt = p->dryamt;
float wetamt = p->wetamt;
struct reverb_state *s = m->state;
if (p != m->old_params)
{
float tpdsr = 2.f * M_PI * m->module.srate_inv;
cbox_onepolef_set_lowpass(&m->filter_coeffs[0], p->lowpass * tpdsr);
cbox_onepolef_set_highpass(&m->filter_coeffs[1], p->highpass * tpdsr);
float rv = p->decay_time * m->module.srate / 1000;
m->gain = pow(0.001, s->total_time / (rv * s->leg_count / 2));
m->old_params = p;
}
int mid = s->leg_count >> 1;
memcpy(s->legs[0].buffer, inputs[0], CBOX_BLOCK_SIZE * sizeof(float));
memcpy(s->legs[mid].buffer, inputs[1], CBOX_BLOCK_SIZE * sizeof(float));
for (int u = 1; u < mid; u++)
{
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
s->legs[u].buffer[i] = 0.f;
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
s->legs[u + mid].buffer[i] = 0.f;
}
for (int u = 0; u < s->leg_count; u++)
cbox_reverb_process_leg(m, u);
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
outputs[0][i] = inputs[0][i] * dryamt + s->legs[mid - 1].buffer[i] * wetamt;
for (int i = 0; i < CBOX_BLOCK_SIZE; i++)
outputs[1][i] = inputs[1][i] * dryamt + s->legs[s->leg_count - 1].buffer[i] * wetamt;
m->pos += CBOX_BLOCK_SIZE;
}
static void reverb_destroyfunc(struct cbox_module *module_)
{
struct reverb_module *m = (struct reverb_module *)module_;
free(m->params);
for (int i = 0; i < m->state->leg_count; i++)
cbox_reverb_leg_cleanup(&m->state->legs[i]);
free(m->state->legs);
free(m->state);
}
static struct reverb_state *create_reverb_state(int leg_count, ...)
{
struct reverb_state *state = malloc(sizeof(struct reverb_state));
state->leg_count = leg_count;
state->legs = malloc(state->leg_count * sizeof(struct cbox_reverb_leg));
va_list va;
va_start(va, leg_count);
state->total_time = 0;
for (int u = 0; u < state->leg_count; u++)
{
int delay_length = va_arg(va, int);
int allpasses = va_arg(va, int);
state->total_time += delay_length;
state->legs[u].params = leg_params_new(delay_length, allpasses, NULL);
for (int i = 0; i < allpasses; i++)
{
struct allpass_param *ap = &state->legs[u].params->allpasses[i];
ap->delay = va_arg(va, int);
ap->diffusion = va_arg(va, double);
state->total_time += ap->delay * ap->diffusion; // very rough approximation
}
}
va_end(va);
for (int u = 0; u < state->leg_count; u++)
cbox_reverb_leg_init(&state->legs[u]);
return state;
}
MODULE_CREATE_FUNCTION(reverb)
{
static int inited = 0;
if (!inited)
{
inited = 1;
}
struct reverb_module *m = malloc(sizeof(struct reverb_module));
CALL_MODULE_INIT(m, 2, 2, reverb);
m->module.process_event = reverb_process_event;
m->module.process_block = reverb_process_block;
m->pos = 0;
m->old_params = NULL;
m->params = malloc(sizeof(struct reverb_params));
m->params->decay_time = cbox_config_get_float(cfg_section, "decay_time", 1000);
m->params->dryamt = cbox_config_get_gain_db(cfg_section, "dry_gain", 0.f);
m->params->wetamt = cbox_config_get_gain_db(cfg_section, "wet_gain", -6.f);
m->state = create_reverb_state(4,
133, 3,
731, 0.45,
873, 0.5,
1215, 0.55,
461, 3,
1054, 0.5,
1519, 0.5,
973, 0.5,
251, 3,
617, 0.45,
941, 0.5,
1277, 0.55,
379, 3,
1119, 0.5,
1477, 0.5,
933, 0.5);
#if 0
m->state = create_reverb_state(2,
133, 6,
1573, 0.35,
587, 0.35,
921, 0.45,
605, 0.5,
1051, 0.45,
397, 0.5,
251, 6,
1561, 0.35,
594, 0.35,
927, 0.55,
611, 0.5,
1147, 0.55,
393, 0.5);
#endif
m->params->lowpass = cbox_config_get_float(cfg_section, "lowpass", 8000.f);
m->params->highpass = cbox_config_get_float(cfg_section, "highpass", 35.f);
return &m->module;
}
struct cbox_module_keyrange_metadata reverb_keyranges[] = {
};
struct cbox_module_livecontroller_metadata reverb_controllers[] = {
};
DEFINE_MODULE(reverb, 2, 2)