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.
395 lines
14 KiB
395 lines
14 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/>.
|
|
*/
|
|
|
|
#ifndef CBOX_SAMPLER_H
|
|
#define CBOX_SAMPLER_H
|
|
|
|
#include "biquad-float.h"
|
|
#include "envelope.h"
|
|
#include "module.h"
|
|
#include "onepole-float.h"
|
|
#include "prefetch_pipe.h"
|
|
#include "sampler_layer.h"
|
|
#include "sampler_prg.h"
|
|
#include "wavebank.h"
|
|
#include <stdint.h>
|
|
|
|
#define MAX_SAMPLER_VOICES 128
|
|
#define MAX_SAMPLER_PREVOICES 128
|
|
#define SAMPLER_NO_LOOP ((uint32_t)-1)
|
|
|
|
#define CBOX_SAMPLER_ERROR cbox_sampler_error_quark()
|
|
|
|
enum CboxSamplerError
|
|
{
|
|
CBOX_SAMPLER_ERROR_FAILED,
|
|
CBOX_SAMPLER_ERROR_INVALID_LAYER,
|
|
CBOX_SAMPLER_ERROR_INVALID_WAVEFORM,
|
|
CBOX_SAMPLER_ERROR_NO_PROGRAMS
|
|
};
|
|
|
|
struct sampler_noteinitfunc;
|
|
struct sampler_voice;
|
|
struct sampler_prevoice;
|
|
|
|
#define GET_RT_FROM_sampler_channel(channel) ((channel)->module->module.rt)
|
|
|
|
#define MAX_KEYSWITCH_GROUPS 16
|
|
|
|
struct sampler_channel
|
|
{
|
|
struct sampler_module *module;
|
|
int pitchwheel;
|
|
uint32_t switchmask[4];
|
|
uint32_t sustainmask[4];
|
|
uint32_t sostenutomask[4];
|
|
int previous_note, first_note_vel;
|
|
struct sampler_program *program;
|
|
struct sampler_voice *voices_running;
|
|
int active_voices, active_prevoices;
|
|
uint8_t prev_note_velocity[128];
|
|
uint8_t poly_pressure[128];
|
|
uint32_t prev_note_start_time[128];
|
|
int channel_volume_cc, channel_pan_cc;
|
|
int output_shift;
|
|
uint32_t poly_pressure_mask;
|
|
uint8_t intcc[smsrc_perchan_count];
|
|
float floatcc[smsrc_perchan_count];
|
|
uint8_t last_polyaft, last_chanaft;
|
|
uint8_t keyswitch_state[MAX_KEYSWITCH_GROUPS];
|
|
uint8_t keyswitch_lastkey[MAX_KEYSWITCH_GROUPS];
|
|
};
|
|
|
|
struct sampler_lfo
|
|
{
|
|
uint32_t phase, delta, xdelta;
|
|
uint32_t age, delay, fade;
|
|
int32_t wave;
|
|
float random_value;
|
|
};
|
|
|
|
struct sampler_gen
|
|
{
|
|
enum sampler_player_type mode;
|
|
int16_t *sample_data;
|
|
int16_t *scratch;
|
|
|
|
uint64_t bigpos, bigdelta;
|
|
uint64_t virtpos, virtdelta;
|
|
uint32_t loop_start, loop_end;
|
|
uint32_t cur_sample_end;
|
|
float lgain, rgain;
|
|
float last_lgain, last_rgain;
|
|
float fadein_counter;
|
|
uint64_t fadein_pos;
|
|
|
|
// In-memory mode only
|
|
uint32_t loop_overlap;
|
|
float loop_overlap_step;
|
|
float stretching_jump;
|
|
float stretching_crossfade;
|
|
uint32_t play_count, loop_count;
|
|
int16_t scratch_bandlimited[2 * MAX_INTERPOLATION_ORDER * 2];
|
|
|
|
// Streaming mode only
|
|
int16_t *streaming_buffer;
|
|
uint32_t consumed, consumed_credit, streaming_buffer_frames;
|
|
gboolean prefetch_only_loop, in_streaming_buffer;
|
|
};
|
|
|
|
struct sampler_prevoice
|
|
{
|
|
struct sampler_prevoice *prev, *next;
|
|
struct sampler_layer_data *layer_data;
|
|
struct sampler_channel *channel;
|
|
int note, vel;
|
|
int age;
|
|
double sync_trigger_time, sync_initial_time, sync_beats;
|
|
float delay_computed;
|
|
};
|
|
|
|
struct sampler_filter
|
|
{
|
|
struct cbox_biquadf_coeffs filter_coeffs, filter_coeffs_extra;
|
|
struct cbox_biquadf_coeffs *second_filter;
|
|
struct cbox_biquadf_state filter_left[3], filter_right[3];
|
|
};
|
|
|
|
struct sampler_voice
|
|
{
|
|
struct sampler_voice *prev, *next;
|
|
struct sampler_layer_data *layer;
|
|
// Note: may be NULL when program is being deleted
|
|
struct sampler_program *program;
|
|
struct cbox_waveform *last_waveform;
|
|
struct sampler_gen gen;
|
|
struct cbox_prefetch_pipe *current_pipe;
|
|
int note;
|
|
int vel;
|
|
int released, released_with_sustain, released_with_sostenuto, captured_sostenuto;
|
|
int off_by;
|
|
int age;
|
|
float pitch_shift;
|
|
float cutoff_shift, cutoff2_shift;
|
|
float gain_shift, gain_fromvel;
|
|
struct sampler_filter filter, filter2;
|
|
struct cbox_onepolef_state onepole_left, onepole_right;
|
|
struct cbox_onepolef_coeffs onepole_coeffs;
|
|
struct sampler_channel *channel;
|
|
struct cbox_envelope amp_env, filter_env, pitch_env;
|
|
struct sampler_lfo amp_lfo, filter_lfo, pitch_lfo;
|
|
enum sampler_loop_mode loop_mode;
|
|
int output_pair_no;
|
|
int send1bus, send2bus;
|
|
float send1gain, send2gain;
|
|
int serial_no;
|
|
struct cbox_envelope_shape vel_envs[3], cc_envs[3]; // amp, filter, pitch
|
|
struct cbox_biquadf_state eq_left[3], eq_right[3];
|
|
struct cbox_biquadf_coeffs eq_coeffs[3];
|
|
gboolean layer_changed;
|
|
int last_level;
|
|
uint64_t last_level_min_rate;
|
|
uint32_t last_eq_bitmask;
|
|
float reloffset;
|
|
uint32_t offset;
|
|
int off_vel;
|
|
};
|
|
|
|
struct sampler_module
|
|
{
|
|
struct cbox_module module;
|
|
|
|
struct sampler_voice *voices_free, voices_all[MAX_SAMPLER_VOICES];
|
|
struct sampler_prevoice *prevoices_free, prevoices_all[MAX_SAMPLER_PREVOICES], *prevoices_running;
|
|
struct sampler_channel channels[16];
|
|
struct sampler_program **programs;
|
|
uint32_t program_count;
|
|
int active_voices, max_voices;
|
|
int active_prevoices;
|
|
int serial_no;
|
|
int output_pairs, aux_pairs;
|
|
uint32_t current_time;
|
|
gboolean deleting;
|
|
int disable_mixer_controls;
|
|
struct cbox_prefetch_stack *pipe_stack;
|
|
struct cbox_sincos sincos[12800];
|
|
};
|
|
|
|
#define MAX_RELEASED_GROUPS 16
|
|
|
|
struct sampler_released_groups
|
|
{
|
|
// Groups 1-32 use a bitmask
|
|
uint32_t low_groups;
|
|
int group_count;
|
|
int groups[MAX_RELEASED_GROUPS];
|
|
};
|
|
|
|
static inline void sampler_released_groups_init(struct sampler_released_groups *groups)
|
|
{
|
|
groups->low_groups = 0;
|
|
groups->group_count = 0;
|
|
}
|
|
|
|
static inline gboolean sampler_released_groups_check(struct sampler_released_groups *groups, int group)
|
|
{
|
|
if (group <= 32)
|
|
return (groups->low_groups >> (group - 1)) & 1;
|
|
for (int j = 0; j < groups->group_count; j++)
|
|
{
|
|
if (groups->groups[j] == group)
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static inline void sampler_released_groups_add(struct sampler_released_groups *groups, int group)
|
|
{
|
|
if (group <= 32)
|
|
{
|
|
groups->low_groups |= (1 << (group - 1));
|
|
return;
|
|
}
|
|
if (groups->group_count >= MAX_RELEASED_GROUPS)
|
|
return;
|
|
if (!sampler_released_groups_check(groups, group))
|
|
groups->groups[groups->group_count++] = group;
|
|
}
|
|
|
|
extern GQuark cbox_sampler_error_quark(void);
|
|
|
|
extern void sampler_register_program(struct sampler_module *m, struct sampler_program *pgm);
|
|
extern gboolean sampler_select_program(struct sampler_module *m, int channel, const gchar *preset, GError **error);
|
|
extern void sampler_unselect_program(struct sampler_module *m, struct sampler_program *prg);
|
|
extern double sampler_get_current_beat(struct sampler_module *m);
|
|
|
|
extern void sampler_channel_init(struct sampler_channel *c, struct sampler_module *m);
|
|
// This function may only be called from RT thread!
|
|
extern void sampler_channel_set_program_RT(struct sampler_channel *c, struct sampler_program *prg);
|
|
// ... and this one is RT-safe
|
|
extern void sampler_channel_set_program(struct sampler_channel *c, struct sampler_program *prg);
|
|
extern void sampler_channel_start_note(struct sampler_channel *c, int note, int vel, gboolean is_release_trigger);
|
|
extern void sampler_channel_stop_note(struct sampler_channel *c, int note, int vel, gboolean is_polyaft);
|
|
extern void sampler_channel_program_change(struct sampler_channel *c, int program);
|
|
extern void sampler_channel_stop_sustained(struct sampler_channel *c);
|
|
extern void sampler_channel_stop_sostenuto(struct sampler_channel *c);
|
|
extern void sampler_channel_capture_sostenuto(struct sampler_channel *c);
|
|
extern void sampler_channel_release_groups(struct sampler_channel *c, int note, struct sampler_released_groups *exgroups);
|
|
extern void sampler_channel_stop_all(struct sampler_channel *c);
|
|
extern void sampler_channel_process_cc(struct sampler_channel *c, int cc, int val);
|
|
extern void sampler_channel_reset_keyswitches(struct sampler_channel *c);
|
|
|
|
extern void sampler_voice_start(struct sampler_voice *v, struct sampler_channel *c, struct sampler_layer_data *l, int note, int vel, struct sampler_released_groups *exgroups);
|
|
extern void sampler_voice_start_silent(struct sampler_layer_data *l, struct sampler_released_groups *exgroups);
|
|
extern void sampler_voice_release(struct sampler_voice *v, gboolean is_polyaft);
|
|
extern void sampler_voice_process(struct sampler_voice *v, struct sampler_module *m, cbox_sample_t **outputs);
|
|
extern void sampler_voice_link(struct sampler_voice **pv, struct sampler_voice *v);
|
|
extern void sampler_voice_unlink(struct sampler_voice **pv, struct sampler_voice *v);
|
|
extern void sampler_voice_inactivate(struct sampler_voice *v, gboolean expect_active);
|
|
extern void sampler_voice_update_params_from_layer(struct sampler_voice *v);
|
|
extern float sampler_channel_get_expensive_cc(struct sampler_channel *c, struct sampler_voice *v, struct sampler_prevoice *pv, int cc_no);
|
|
|
|
extern void sampler_prevoice_start(struct sampler_prevoice *pv, struct sampler_channel *c, struct sampler_layer_data *l, int note, int vel);
|
|
extern int sampler_prevoice_process(struct sampler_prevoice *pv, struct sampler_module *m);
|
|
extern void sampler_prevoice_link(struct sampler_prevoice **pv, struct sampler_prevoice *v);
|
|
extern void sampler_prevoice_unlink(struct sampler_prevoice **pv, struct sampler_prevoice *v);
|
|
|
|
extern float sampler_sine_wave[2049];
|
|
|
|
static inline int sampler_channel_addcc(struct sampler_channel *c, int cc_no)
|
|
{
|
|
return (((int)c->intcc[cc_no]) << 7) + c->intcc[cc_no + 32];
|
|
}
|
|
|
|
static inline float sampler_channel_getcc(struct sampler_channel *c, struct sampler_voice *v, int cc_no)
|
|
{
|
|
if (cc_no < 128)
|
|
return c->floatcc[cc_no];
|
|
return sampler_channel_get_expensive_cc(c, v, NULL, cc_no);
|
|
}
|
|
|
|
static inline float sampler_program_get_curve_value(struct sampler_program *program, uint32_t curve_id, float val)
|
|
{
|
|
if (val < 0)
|
|
val = 0;
|
|
if (val > 1)
|
|
val = 1;
|
|
if (curve_id < MAX_MIDI_CURVES && program->interpolated_curves[curve_id])
|
|
{
|
|
float *curve = program->interpolated_curves[curve_id];
|
|
int vint = floorf(val * 127);
|
|
// Linear interpolation if within bounds
|
|
if (vint < 127)
|
|
{
|
|
float vfrac = val * 127 - vint;
|
|
val = curve[vint] + (curve[vint + 1] - curve[vint]) * vfrac;
|
|
}
|
|
else
|
|
val = curve[vint];
|
|
}
|
|
else
|
|
{
|
|
// possibly wrong implementation of built in curves
|
|
switch(curve_id)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
case 3:
|
|
// slightly fake bipolar, so that both 63 and 64 are 'neutral' (needs to be somewhat symmetric)
|
|
if (val < 63.f/127.f)
|
|
val = (curve_id == 3 ? -1 : 1) * -(63.f - 127 * val) / 63.f;
|
|
else if (val <= 64.f/127.f)
|
|
val = 0;
|
|
else
|
|
val = (curve_id == 3 ? -1 : 1) * (127 * val - 64) / 63.f;
|
|
break;
|
|
case 2:
|
|
val = 1 - val; break;
|
|
case 4:
|
|
val = val * val;
|
|
break; // maybe, or maybe it's inverted?
|
|
case 5: val = sqrtf(val);
|
|
break; // maybe
|
|
case 6: val = sqrtf(1-val);
|
|
break; // maybe
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
static inline float sampler_channel_getcc_mod(struct sampler_channel *c, struct sampler_voice *v, int cc_no, int curve_id, float step)
|
|
{
|
|
float val = (cc_no < 128) ? c->floatcc[cc_no] : sampler_channel_get_expensive_cc(c, v, NULL, cc_no);
|
|
if (step)
|
|
val = floorf(0.9999f * val * (step + 1)) / step;
|
|
if (curve_id || c->program->interpolated_curves[0])
|
|
val = sampler_program_get_curve_value(c->program, curve_id, val);
|
|
return val;
|
|
}
|
|
|
|
static inline int sampler_channel_getintcc(struct sampler_channel *c, struct sampler_voice *v, int cc_no)
|
|
{
|
|
if (cc_no < 128)
|
|
return c->intcc[cc_no];
|
|
return (int)127 * (sampler_channel_get_expensive_cc(c, v, NULL, cc_no));
|
|
}
|
|
|
|
static inline float sampler_channel_getcc_prevoice(struct sampler_channel *c, struct sampler_prevoice *pv, int cc_no, int curve_id, float step)
|
|
{
|
|
float val = (cc_no < 128) ? c->floatcc[cc_no] : sampler_channel_get_expensive_cc(c, NULL, pv, cc_no);
|
|
if (step)
|
|
val = floorf(0.9999f * val * (step + 1)) / step;
|
|
if (curve_id || c->program->interpolated_curves[0])
|
|
val = sampler_program_get_curve_value(c->program, curve_id, val);
|
|
return val;
|
|
}
|
|
|
|
static inline float sampler_channel_get_poly_pressure(struct sampler_channel *c, uint8_t note)
|
|
{
|
|
note &= 0x7F;
|
|
return (c->poly_pressure_mask & (1 << (note >> 2))) ? c->poly_pressure[note] * (1.f / 127.f) : 0;;
|
|
}
|
|
|
|
static inline gboolean sampler_cc_range_is_in(const struct sampler_cc_range *range, struct sampler_channel *c)
|
|
{
|
|
while(range)
|
|
{
|
|
int ccval = sampler_channel_getintcc(c, NULL, range->key.cc_number);
|
|
if (ccval < range->value.locc || ccval > range->value.hicc)
|
|
return FALSE;
|
|
range = range->next;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#define FOREACH_VOICE(var, p) \
|
|
for (struct sampler_voice *p = (var), *p##_next = NULL; p && (p##_next = p->next, TRUE); p = p##_next)
|
|
#define FOREACH_PREVOICE(var, p) \
|
|
for (struct sampler_prevoice *p = (var), *p##_next = NULL; p && (p##_next = p->next, TRUE); p = p##_next)
|
|
#define CANCEL_PREVOICE(var, p) \
|
|
{\
|
|
struct sampler_prevoice *_tmp = (p); \
|
|
if (_tmp->prev) \
|
|
_tmp->prev->next = _tmp->next; \
|
|
else \
|
|
var = _tmp->next; \
|
|
_tmp->prev = _tmp->next = NULL; \
|
|
}
|
|
|
|
#endif
|
|
|