void
run_adding_Vibrato(LADSPA_Handle Instance,
unsigned long SampleCount) {
Vibrato * ptr = (Vibrato *)Instance;
LADSPA_Data freq = LIMIT(*(ptr->freq),0.0f,PM_FREQ);
LADSPA_Data depth =
LIMIT(LIMIT(*(ptr->depth),0.0f,20.0f) * ptr->sample_rate / 200.0f / M_PI / freq,
0, ptr->buflen / 2);
LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
LADSPA_Data * input = ptr->input;
LADSPA_Data * output = ptr->output;
unsigned long sample_index;
unsigned long sample_count = SampleCount;
LADSPA_Data in = 0.0f;
LADSPA_Data phase = 0.0f;
LADSPA_Data fpos = 0.0f;
LADSPA_Data n = 0.0f;
LADSPA_Data rem = 0.0f;
LADSPA_Data s_a, s_b;
if (freq == 0.0f)
depth = 0.0f;
for (sample_index = 0; sample_index < sample_count; sample_index++) {
in = *(input++);
phase = COS_TABLE_SIZE * freq * sample_index / ptr->sample_rate + ptr->phase;
while (phase >= COS_TABLE_SIZE)
phase -= COS_TABLE_SIZE;
push_buffer(in, ptr->ringbuffer, ptr->buflen, &(ptr->pos));
fpos = depth * (1.0f - cos_table[(unsigned long) phase]);
n = floorf(fpos);
rem = fpos - n;
s_a = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n);
s_b = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n + 1);
*(output++) += ptr->run_adding_gain * wetlevel * ((1 - rem) * s_a + rem * s_b) +
drylevel * read_buffer(ptr->ringbuffer, ptr->buflen,
ptr->pos, ptr->buflen / 2);
}
ptr->phase += COS_TABLE_SIZE * freq * sample_index / ptr->sample_rate;
while (ptr->phase >= COS_TABLE_SIZE)
ptr->phase -= COS_TABLE_SIZE;
*(ptr->latency) = ptr->buflen / 2;
}
void Compressor::process(int frames, float* ip, float *op)
{
const float ga = _attack < 2.0f ? 0.0f : as[f_round(_attack * 0.001f * (float)(A_TBL-1))];
const float gr = as[f_round(_release * 0.001f * (float)(A_TBL-1))];
const float rs = (_ratio - 1.0f) / _ratio;
const float mug = db2lin(_makeupGain);
const float knee_min = db2lin(_threshold - _knee);
const float knee_max = db2lin(_threshold + _knee);
const float ef_a = ga * 0.25f;
const float ef_ai = 1.0f - ef_a;
for (int pos = 0; pos < frames; pos++) {
const float la = fabs(ip[pos * 2]);
const float ra = fabs(ip[pos * 2 + 1]);
const float lev_in = f_max(la, ra);
sum += lev_in * lev_in;
if (amp > env_rms)
env_rms = env_rms * ga + amp * (1.0f - ga);
else
env_rms = env_rms * gr + amp * (1.0f - gr);
round_to_zero(&env_rms);
if (lev_in > env_peak)
env_peak = env_peak * ga + lev_in * (1.0f - ga);
else
env_peak = env_peak * gr + lev_in * (1.0f - gr);
round_to_zero(&env_peak);
if ((count++ & 3) == 3) {
amp = rms.process(sum * 0.25f);
sum = 0.0f;
if (qIsNaN(env_rms)) // This can happen sometimes, but I don't know why
env_rms = 0.0f;
env = LIN_INTERP(rms_peak, env_rms, env_peak);
if (env <= knee_min)
gain_t = 1.0f;
else if (env < knee_max) {
const float x = -(_threshold - _knee - lin2db(env)) / _knee;
gain_t = db2lin(-_knee * rs * x * x * 0.25f);
}
else
gain_t = db2lin((_threshold - lin2db(env)) * rs);
}
gain = gain * ef_a + gain_t * ef_ai;
op[pos * 2] = ip[pos * 2] * gain * mug;
op[pos * 2+1] = ip[pos * 2 + 1] * gain * mug;
}
// printf("gain %f\n", gain);
// amplitude = lin2db(env);
// gain_red = lin2db(gain);
}
void
run_adding_Tremolo(LADSPA_Handle Instance,
unsigned long SampleCount) {
LADSPA_Data * input;
LADSPA_Data * output;
LADSPA_Data freq;
LADSPA_Data depth;
LADSPA_Data gain;
Tremolo * ptr;
unsigned long sample_index;
LADSPA_Data phase = 0.0f;
ptr = (Tremolo *)Instance;
input = ptr->InputBuffer_1;
output = ptr->OutputBuffer_1;
freq = LIMIT(*(ptr->Control_Freq),0.0f,20.0f);
depth = LIMIT(*(ptr->Control_Depth),0.0f,100.0f);
gain = db2lin(LIMIT(*(ptr->Control_Gain),-70.0f,20.0f));
for (sample_index = 0; sample_index < SampleCount; sample_index++) {
phase = 1024.0f * freq * sample_index / ptr->SampleRate + ptr->Phase;
while (phase >= 1024.0f)
phase -= 1024.0f;
*(output++) += *(input++) * ptr->run_adding_gain * gain *
(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase]);
}
ptr->Phase = phase;
while (ptr->Phase >= 1024.0f)
ptr->Phase -= 1024.0f;
}
void
run_Tremolo(LV2_Handle Instance,
uint32_t SampleCount) {
float * input;
float * output;
float freq;
float depth;
float gain;
Tremolo * ptr;
double sample_index;
float phase = 0.0f;
ptr = (Tremolo *)Instance;
input = ptr->InputBuffer_1;
output = ptr->OutputBuffer_1;
freq = LIMIT(*(ptr->Control_Freq),0.0f,20.0f);
depth = LIMIT(*(ptr->Control_Depth),0.0f,100.0f);
gain = db2lin(LIMIT(*(ptr->Control_Gain),-70.0f,20.0f));
for (sample_index = 0; sample_index < SampleCount; sample_index++) {
phase = 1024.0f * freq * sample_index / ptr->SampleRate + ptr->Phase;
while (phase >= 1024.0f)
phase -= 1024.0f;
*(output++) = *(input++) * gain *
(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase]);
}
ptr->Phase = phase;
while (ptr->Phase >= 1024.0f)
ptr->Phase -= 1024.0f;
}
void
run_adding_AutoPan(LADSPA_Handle Instance,
unsigned long SampleCount) {
AutoPan * ptr = (AutoPan *)Instance;
LADSPA_Data * input_L = ptr->input_L;
LADSPA_Data * input_R = ptr->input_R;
LADSPA_Data * output_L = ptr->output_L;
LADSPA_Data * output_R = ptr->output_R;
LADSPA_Data freq = LIMIT(*(ptr->freq),0.0f,20.0f);
LADSPA_Data depth = LIMIT(*(ptr->depth),0.0f,100.0f);
LADSPA_Data gain = db2lin(LIMIT(*(ptr->gain),-70.0f,20.0f));
unsigned long sample_index;
LADSPA_Data phase_L = 0;
LADSPA_Data phase_R = 0;
for (sample_index = 0; sample_index < SampleCount; sample_index++) {
phase_L = 1024.0f * freq * sample_index / ptr->SampleRate + ptr->Phase;
while (phase_L >= 1024.0f)
phase_L -= 1024.0f;
phase_R = phase_L + 512.0f;
while (phase_R >= 1024.0f)
phase_R -= 1024.0f;
*(output_L++) += *(input_L++) * gain * ptr->run_adding_gain *
(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase_L]);
*(output_R++) += *(input_R++) * gain * ptr->run_adding_gain *
(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase_R]);
}
ptr->Phase = phase_L;
while (ptr->Phase >= 1024.0f)
ptr->Phase -= 1024.0f;
}
void
run_Pinknoise(LADSPA_Handle Instance,
unsigned long SampleCount) {
Pinknoise * ptr = (Pinknoise *)Instance;
LADSPA_Data * input = ptr->input;
LADSPA_Data * output = ptr->output;
LADSPA_Data hurst = LIMIT(*(ptr->hurst), 0.0f, 1.0f);
LADSPA_Data signal = db2lin(LIMIT(*(ptr->signal), -90.0f, 20.0f));
LADSPA_Data noise = db2lin(LIMIT(*(ptr->noise), -90.0f, 20.0f));
unsigned long sample_index;
for (sample_index = 0; sample_index < SampleCount; sample_index++) {
if (!ptr->pos)
fractal(ptr->ring, NOISE_LEN, hurst);
*(output++) = signal * *(input++) +
noise * push_buffer(0.0f, ptr->ring, ptr->buflen, &(ptr->pos));
}
}
void
run_Echo(LV2_Handle Instance,
uint32_t SampleCount) {
Echo * ptr;
unsigned long sample_index;
float delaytime_L;
float delaytime_R;
float feedback_L;
float feedback_R;
float strength_L;
float strength_R;
float drylevel;
float mode;
float haas;
float rev_outch;
float * input_L;
float * output_L;
float * input_R;
float * output_R;
unsigned long sample_rate;
unsigned long buflen_L;
unsigned long buflen_R;
float out_L = 0;
float out_R = 0;
float in_L = 0;
float in_R = 0;
ptr = (Echo *)Instance;
delaytime_L = LIMIT(*(ptr->delaytime_L),0.0f,2000.0f);
delaytime_R = LIMIT(*(ptr->delaytime_R),0.0f,2000.0f);
feedback_L = LIMIT(*(ptr->feedback_L) / 100.0, 0.0f, 100.0f);
feedback_R = LIMIT(*(ptr->feedback_R) / 100.0, 0.0f, 100.0f);
ptr->smoothstrength_L = (*(ptr->strength_L)+ptr->smoothstrength_L)*0.5; //smoothing
strength_L = db2lin(LIMIT(ptr->smoothstrength_L,-70.0f,10.0f)); //convert to db and influence the actual audiobuffer
ptr->smoothstrength_R = (*(ptr->strength_R)+ptr->smoothstrength_R)*0.5; //smoothing
strength_R = db2lin(LIMIT(ptr->smoothstrength_R,-70.0f,10.0f)); //convert to db and influence the actual audiobuffer
ptr->smoothdry = (*(ptr->drylevel)+ptr->smoothdry)*0.5; //smoothing
drylevel = db2lin(LIMIT(ptr->smoothdry,-70.0f,10.0f));//convert to db and influence the actual audiobuffer
mode = LIMIT(*(ptr->mode),-2.0f,2.0f);
haas = LIMIT(*(ptr->haas),-2.0f,2.0f);
rev_outch = LIMIT(*(ptr->rev_outch),-2.0f,2.0f);
input_L = ptr->input_L;
output_L = ptr->output_L;
input_R = ptr->input_R;
output_R = ptr->output_R;
sample_rate = ptr->sample_rate;
buflen_L = delaytime_L * sample_rate / 1000;
buflen_R = delaytime_R * sample_rate / 1000;
for (sample_index = 0; sample_index < SampleCount; sample_index++) {
in_L = *(input_L++);
in_R = *(input_R++);
out_L = in_L * drylevel + ptr->mpx_out_L * strength_L;
out_R = in_R * drylevel + ptr->mpx_out_R * strength_R;
if (haas > 0.0f)
in_R = 0.0f;
if (mode <= 0.0f) {
ptr->mpx_out_L =
M(push_buffer(in_L + ptr->mpx_out_L * feedback_L,
ptr->ringbuffer_L, buflen_L, ptr->buffer_pos_L));
ptr->mpx_out_R =
M(push_buffer(in_R + ptr->mpx_out_R * feedback_R,
ptr->ringbuffer_R, buflen_R, ptr->buffer_pos_R));
} else {
ptr->mpx_out_R =
M(push_buffer(in_L + ptr->mpx_out_L * feedback_L,
ptr->ringbuffer_L, buflen_L, ptr->buffer_pos_L));
ptr->mpx_out_L =
M(push_buffer(in_R + ptr->mpx_out_R * feedback_R,
ptr->ringbuffer_R, buflen_R, ptr->buffer_pos_R));
}
if (rev_outch <= 0.0f) {
*(output_L++) = out_L;
*(output_R++) = out_R;
} else {
*(output_L++) = out_R;
*(output_R++) = out_L;
}
}
}
int main(int argc, char *argv[])
{
unsigned int i;
int opt;
int help = 0;
int console = 0;
char port_name[32];
pthread_t dt;
#ifdef HAVE_LASH
lash_args_t *lash_args = lash_extract_args(&argc, &argv);
lash_event_t *event;
#endif
auto_begin_threshold = db2lin(DEFAULT_AUTO_BEGIN_THRESHOLD);
auto_end_threshold = db2lin(DEFAULT_AUTO_END_THRESHOLD);
while ((opt = getopt(argc, argv, "hic:t:n:p:f:sab:e:T:")) != -1) {
switch (opt) {
case 'h':
help = 1;
break;
case 'i':
console = 1;
break;
case 'c':
num_ports = atoi(optarg);
DEBUG(1, "ports: %d\n", num_ports);
break;
case 't':
buf_length = atoi(optarg);
DEBUG(1, "buffer: %ds\n", buf_length);
break;
case 'n':
client_name = optarg;
DEBUG(1, "client name: %s\n", client_name);
break;
case 'p':
prefix = optarg;
DEBUG(1, "prefix: %s\n", prefix);
break;
case 'f':
format_name = optarg;
break;
case 's':
safe_filename = 1;
break;
case 'a':
auto_record = 1;
break;
case 'b':
auto_begin_threshold = db2lin(atof(optarg));
break;
case 'e':
auto_end_threshold = db2lin(atof(optarg));
break;
case 'T':
auto_end_time = atoi(optarg);
break;
default:
num_ports = 0;
break;
}
}
if (optind != argc) {
num_ports = argc - optind;
}
if (num_ports < 1 || num_ports > MAX_PORTS || help) {
fprintf(stderr, "Usage %s: [-h] [-i] [-c channels] [-n jack-name]\n\t"
"[-t buffer-length] [-p file prefix] [-f format]\n\t"
"[-a] [-b begin-threshold] [-e end-threshold] [-T end-time]\n\t"
"[port-name ...]\n\n", argv[0]);
fprintf(stderr, "\t-h\tshow this help\n");
fprintf(stderr, "\t-i\tinteractive mode (console instead of X11) also enabled\n\t\tif DISPLAY is unset\n");
fprintf(stderr, "\t-c\tspecify number of recording channels\n");
fprintf(stderr, "\t-n\tspecify the JACK name timemachine will use\n");
fprintf(stderr, "\t-t\tspecify the pre-recording buffer length\n");
fprintf(stderr, "\t-p\tspecify the saved file prefix, may include path\n");
fprintf(stderr, "\t-s\tuse safer characters in filename (windows compatibility)\n");
fprintf(stderr, "\t-f\tspecify the saved file format\n");
fprintf(stderr, "\t-a\tenable automatic sound-triggered recording\n");
fprintf(stderr, "\t-b\tspecify threshold above which automatic recording will begin\n");
fprintf(stderr, "\t-e\tspecify threshold below which automatic recording will end\n");
fprintf(stderr, "\t-T\tspecify silence length before automatic recording ends\n");
fprintf(stderr, "\n");
fprintf(stderr, "\tchannels must be in the range 1-8, default %d\n",
DEFAULT_NUM_PORTS);
fprintf(stderr, "\tjack-name, default \"%s\"\n", DEFAULT_CLIENT_NAME);
fprintf(stderr, "\tfile-prefix, default \"%s\"\n", DEFAULT_PREFIX);
fprintf(stderr, "\tbuffer-length, default %d secs\n", DEFAULT_BUF_LENGTH);
fprintf(stderr, "\tformat, default '%s', options: wav, w64\n", DEFAULT_FORMAT);
fprintf(stderr, "\tbegin-threshold, default %.1f dB\n", DEFAULT_AUTO_BEGIN_THRESHOLD);
fprintf(stderr, "\tend-threshold, default %.1f dB\n", DEFAULT_AUTO_END_THRESHOLD);
fprintf(stderr, "\tend-time, default %d secs\n", DEFAULT_AUTO_END_TIME);
fprintf(stderr, "\n");
fprintf(stderr, "specifying port names to connect to on the command line overrides -c\n\n");
exit(1);
}
if (!strcasecmp(format_name, "wav")) {
format_sf = SF_FORMAT_WAV | SF_FORMAT_FLOAT;
}
#ifdef HAVE_W64
if (!strcasecmp(format_name, "w64")) {
format_sf = SF_FORMAT_W64 | SF_FORMAT_FLOAT;
}
#endif
if (format_sf == 0) {
fprintf(stderr, "Unknown format '%s'\n", format_name);
}
/* Register with jack */
if ((client = jack_client_open(client_name, 0, NULL)) == 0) {
DEBUG(0, "jack server not running?\n");
exit(1);
}
DEBUG(1, "registering as %s\n", client_name);
process_init(buf_length);
#ifdef HAVE_LASH
lash_client = lash_init (lash_args, "TimeMachine",
0, /* would be LASH_Config_Data_Set etc. */
LASH_PROTOCOL (2,0));
if (!lash_client) {
DEBUG(1, "could not initialise LASH\n");
}
event = lash_event_new_with_type(LASH_Client_Name);
lash_event_set_string(event, client_name);
lash_send_event(lash_client, event);
#endif
jack_set_process_callback(client, process, 0);
if (jack_activate(client)) {
DEBUG(0, "cannot activate JACK client");
exit(1);
}
#ifdef HAVE_LASH
lash_jack_client_name(lash_client, client_name);
#endif
/* Create the jack ports */
for (i = 0; i < num_ports; i++) {
jack_port_t *port;
snprintf(port_name, 31, "in_%d", i + 1);
ports[i] = jack_port_register(client, port_name,
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsInput, 0);
if (optind != argc) {
port = jack_port_by_name(client, argv[optind+i]);
if (port == NULL) {
fprintf(stderr, "Can't find port '%s'\n", port_name);
continue;
}
if (jack_connect(client, argv[optind+i], jack_port_name(ports[i]))) {
fprintf(stderr, "Cannot connect port '%s' to '%s'\n",
argv[optind+i], jack_port_name(ports[i]));
}
}
}
/* Start the disk thread */
pthread_create(&dt, NULL, (void *)&writer_thread, NULL);
#ifdef HAVE_LIBREADLINE
if (console || !getenv("DISPLAY") || getenv("DISPLAY")[0] == '\0') {
#ifdef HAVE_LIBLO
lo_server_thread st = lo_server_thread_new(OSC_PORT, NULL);
if (st) {
lo_server_thread_add_method(st, "/start", "", osc_handler_nox, (void *)1);
lo_server_thread_add_method(st, "/stop", "", osc_handler_nox, (void *)0);
lo_server_thread_start(st);
printf("Listening for OSC requests on osc.udp://localhost:%s\n",
OSC_PORT);
}
#endif
int done = 0;
while (!done) {
char *line = readline("TimeMachine> ");
if (!line) {
printf("EOF\n");
break;
}
if (line && *line) {
add_history(line);
if (strncmp(line, "q", 1) == 0) done = 1;
else if (strncmp(line, "start", 3) == 0) recording_start();
else if (strncmp(line, "stop", 3) == 0) recording_stop();
else if (strncmp(line, "help", 3) == 0) {
printf("Commands: start stop\n");
} else {
printf("Unknown command\n");
}
}
free(line);
}
} else
#endif
{
gtk_init(&argc, &argv);
add_pixmap_directory(PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
add_pixmap_directory("pixmaps");
add_pixmap_directory("../pixmaps");
img_on = create_pixbuf("on.png");
img_off = create_pixbuf("off.png");
img_busy = create_pixbuf("busy.png");
icon_on = create_pixbuf("on-icon.png");
icon_off = create_pixbuf("off-icon.png");
main_window = create_window(client_name);
gtk_window_set_icon(GTK_WINDOW(main_window), icon_off);
gtk_widget_show(main_window);
bind_meters();
g_timeout_add(100, meter_tick, NULL);
#ifdef HAVE_LIBLO
lo_server_thread st = lo_server_thread_new(OSC_PORT, NULL);
if (st) {
lo_server_thread_add_method(st, "/start", "", osc_handler, (void *)1);
lo_server_thread_add_method(st, "/stop", "", osc_handler, (void *)0);
lo_server_thread_start(st);
printf("Listening for OSC requests on osc.udp://localhost:%s\n",
OSC_PORT);
}
#endif
#ifdef HAVE_LASH
gtk_idle_add(idle_cb, lash_client);
#endif
gtk_main();
}
cleanup();
/* We can't ever get here, but it keeps gcc quiet */
return 0;
}
static void runSc3(LV2_Handle instance, uint32_t sample_count)
{
Sc3 *plugin_data = (Sc3 *)instance;
const float attack = *(plugin_data->attack);
const float release = *(plugin_data->release);
const float threshold = *(plugin_data->threshold);
const float ratio = *(plugin_data->ratio);
const float knee = *(plugin_data->knee);
const float makeup_gain = *(plugin_data->makeup_gain);
const float chain_bal = *(plugin_data->chain_bal);
const float * const sidechain = plugin_data->sidechain;
const float * const left_in = plugin_data->left_in;
const float * const right_in = plugin_data->right_in;
float * const left_out = plugin_data->left_out;
float * const right_out = plugin_data->right_out;
rms_env * rms = plugin_data->rms;
float * as = plugin_data->as;
float sum = plugin_data->sum;
float amp = plugin_data->amp;
float gain = plugin_data->gain;
float gain_t = plugin_data->gain_t;
float env = plugin_data->env;
unsigned int count = plugin_data->count;
unsigned long pos;
const float ga = as[f_round(attack * 0.001f * (float)(A_TBL-1))];
const float gr = as[f_round(release * 0.001f * (float)(A_TBL-1))];
const float rs = (ratio - 1.0f) / ratio;
const float mug = db2lin(makeup_gain);
const float knee_min = db2lin(threshold - knee);
const float knee_max = db2lin(threshold + knee);
const float chain_bali = 1.0f - chain_bal;
const float ef_a = ga * 0.25f;
const float ef_ai = 1.0f - ef_a;
for (pos = 0; pos < sample_count; pos++) {
const float lev_in = chain_bali * (left_in[pos] + right_in[pos]) * 0.5f
+ chain_bal * sidechain[pos];
sum += lev_in * lev_in;
if (amp > env) {
env = env * ga + amp * (1.0f - ga);
} else {
env = env * gr + amp * (1.0f - gr);
}
if (count++ % 4 == 3) {
amp = rms_env_process(rms, sum * 0.25f);
sum = 0.0f;
if (isnan(env)) {
// This can happen sometimes, but I dont know why
env = 0.0f;
} else if (env <= knee_min) {
gain_t = 1.0f;
} else if (env < knee_max) {
const float x = -(threshold - knee - lin2db(env)) / knee;
gain_t = db2lin(-knee * rs * x * x * 0.25f);
} else {
gain_t = db2lin((threshold - lin2db(env)) * rs);
}
}
gain = gain * ef_a + gain_t * ef_ai;
buffer_write(left_out[pos], left_in[pos] * gain * mug);
buffer_write(right_out[pos], right_in[pos] * gain * mug);
}
plugin_data->sum = sum;
plugin_data->amp = amp;
plugin_data->gain = gain;
plugin_data->gain_t = gain_t;
plugin_data->env = env;
plugin_data->count = count;
}
static void runAddingSc3(LADSPA_Handle instance, unsigned long sample_count) {
Sc3 *plugin_data = (Sc3 *)instance;
LADSPA_Data run_adding_gain = plugin_data->run_adding_gain;
/* Attack time (ms) (float value) */
const LADSPA_Data attack = *(plugin_data->attack);
/* Release time (ms) (float value) */
const LADSPA_Data release = *(plugin_data->release);
/* Threshold level (dB) (float value) */
const LADSPA_Data threshold = *(plugin_data->threshold);
/* Ratio (1:n) (float value) */
const LADSPA_Data ratio = *(plugin_data->ratio);
/* Knee radius (dB) (float value) */
const LADSPA_Data knee = *(plugin_data->knee);
/* Makeup gain (dB) (float value) */
const LADSPA_Data makeup_gain = *(plugin_data->makeup_gain);
/* Chain balance (float value) */
const LADSPA_Data chain_bal = *(plugin_data->chain_bal);
/* Sidechain (array of floats of length sample_count) */
const LADSPA_Data * const sidechain = plugin_data->sidechain;
/* Left input (array of floats of length sample_count) */
const LADSPA_Data * const left_in = plugin_data->left_in;
/* Right input (array of floats of length sample_count) */
const LADSPA_Data * const right_in = plugin_data->right_in;
/* Left output (array of floats of length sample_count) */
LADSPA_Data * const left_out = plugin_data->left_out;
/* Right output (array of floats of length sample_count) */
LADSPA_Data * const right_out = plugin_data->right_out;
float amp = plugin_data->amp;
float * as = plugin_data->as;
unsigned int count = plugin_data->count;
float env = plugin_data->env;
float gain = plugin_data->gain;
float gain_t = plugin_data->gain_t;
rms_env * rms = plugin_data->rms;
float sum = plugin_data->sum;
#line 49 "sc3_1427.xml"
unsigned long pos;
const float ga = as[f_round(attack * 0.001f * (float)(A_TBL-1))];
const float gr = as[f_round(release * 0.001f * (float)(A_TBL-1))];
const float rs = (ratio - 1.0f) / ratio;
const float mug = db2lin(makeup_gain);
const float knee_min = db2lin(threshold - knee);
const float knee_max = db2lin(threshold + knee);
const float chain_bali = 1.0f - chain_bal;
const float ef_a = ga * 0.25f;
const float ef_ai = 1.0f - ef_a;
for (pos = 0; pos < sample_count; pos++) {
const float lev_in = chain_bali * (left_in[pos] + right_in[pos]) * 0.5f
+ chain_bal * sidechain[pos];
sum += lev_in * lev_in;
if (amp > env) {
env = env * ga + amp * (1.0f - ga);
} else {
env = env * gr + amp * (1.0f - gr);
}
if (count++ % 4 == 3) {
amp = rms_env_process(rms, sum * 0.25f);
sum = 0.0f;
if (isnan(env)) {
// This can happen sometimes, but I dont know why
env = 0.0f;
} else if (env <= knee_min) {
gain_t = 1.0f;
} else if (env < knee_max) {
const float x = -(threshold - knee - lin2db(env)) / knee;
gain_t = db2lin(-knee * rs * x * x * 0.25f);
} else {
gain_t = db2lin((threshold - lin2db(env)) * rs);
}
}
gain = gain * ef_a + gain_t * ef_ai;
buffer_write(left_out[pos], left_in[pos] * gain * mug);
buffer_write(right_out[pos], right_in[pos] * gain * mug);
}
plugin_data->sum = sum;
plugin_data->amp = amp;
plugin_data->gain = gain;
plugin_data->gain_t = gain_t;
plugin_data->env = env;
plugin_data->count = count;
}
void
run_adding_gain_Reverb(LADSPA_Handle Instance,
unsigned long SampleCount) {
Reverb * ptr = (Reverb *)Instance;
unsigned long sample_index;
unsigned int i;
LADSPA_Data decay = LIMIT(*(ptr->decay),0.0f,10000.0f);
LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-70.0f,10.0f));
LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-70.0f,10.0f));
LADSPA_Data combs_en = LIMIT(*(ptr->combs_en),-2.0f,2.0f);
LADSPA_Data allps_en = LIMIT(*(ptr->allps_en),-2.0f,2.0f);
LADSPA_Data bandpass_en = LIMIT(*(ptr->bandpass_en),-2.0f,2.0f);
LADSPA_Data stereo_enh = LIMIT(*(ptr->stereo_enh),-2.0f,2.0f);
LADSPA_Data mode = LIMIT(*(ptr->mode),0,NUM_MODES-1);
LADSPA_Data * input_L = ptr->input_L;
LADSPA_Data * output_L = ptr->output_L;
LADSPA_Data * input_R = ptr->input_R;
LADSPA_Data * output_R = ptr->output_R;
rev_t out_L = 0;
rev_t out_R = 0;
rev_t in_L = 0;
rev_t in_R = 0;
rev_t combs_out_L = 0;
rev_t combs_out_R = 0;
/* see if the user changed any control since last run */
if ((ptr->old_decay != decay) ||
(ptr->old_stereo_enh != stereo_enh) ||
(ptr->old_mode != mode)) {
/* re-compute reverberator coefficients */
comp_coeffs(Instance);
/* save new values */
ptr->old_decay = decay;
ptr->old_stereo_enh = stereo_enh;
ptr->old_mode = mode;
}
for (sample_index = 0; sample_index < SampleCount; sample_index++) {
#ifdef REVERB_CALC_FLOAT
in_L = *(input_L++);
in_R = *(input_R++);
#else
in_L = (sample)((float)F2S * *(input_L++));
in_R = (sample)((float)F2S * *(input_R++));
#endif
combs_out_L = in_L;
combs_out_R = in_R;
/* process comb filters */
if (combs_en > 0.0f) {
for (i = 0; i < ptr->num_combs / 2; i++) {
combs_out_L +=
comb_run(in_L, ((COMB_FILTER *)(ptr->combs + 2*i)));
combs_out_R +=
comb_run(in_R, ((COMB_FILTER *)(ptr->combs + 2*i+1)));
}
}
/* process allpass filters */
if (allps_en > 0.0f) {
for (i = 0; i < ptr->num_allps / 2; i++) {
combs_out_L += allp_run(combs_out_L,
((ALLP_FILTER *)(ptr->allps + 2*i)));
combs_out_R += allp_run(combs_out_R,
((ALLP_FILTER *)(ptr->allps + 2*i+1)));
}
}
/* process bandpass filters */
if (bandpass_en > 0.0f) {
combs_out_L =
biquad_run(((biquad *)(ptr->low_pass)), combs_out_L);
combs_out_L =
biquad_run(((biquad *)(ptr->high_pass)), combs_out_L);
combs_out_R =
biquad_run(((biquad *)(ptr->low_pass + 1)), combs_out_R);
combs_out_R =
biquad_run(((biquad *)(ptr->high_pass + 1)), combs_out_R);
}
#ifdef REVERB_CALC_FLOAT
out_L = in_L * drylevel + combs_out_L * wetlevel;
out_R = in_R * drylevel + combs_out_R * wetlevel;
*(output_L++) += out_L * ptr->run_adding_gain;
*(output_R++) += out_R * ptr->run_adding_gain;
#else
out_L = (sample)((float)in_L * drylevel + (float)combs_out_L * wetlevel);
out_R = (sample)((float)in_R * drylevel + (float)combs_out_R * wetlevel);
*(output_L++) += (float)out_L * ptr->run_adding_gain / (float)F2S;
*(output_R++) += (float)out_R * ptr->run_adding_gain / (float)F2S;
#endif
}
}
void
run_adding_Reflector(LADSPA_Handle Instance,
unsigned long SampleCount) {
Reflector * ptr = (Reflector *)Instance;
LADSPA_Data * input = ptr->input;
LADSPA_Data * output = ptr->output;
LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
LADSPA_Data wetlevel = 0.333333f * db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
LADSPA_Data fragment = LIMIT(*(ptr->fragment),(float)MIN_FRAGMENT_LEN,(float)MAX_FRAGMENT_LEN);
unsigned long sample_index;
unsigned long sample_count = SampleCount;
LADSPA_Data in = 0.0f;
LADSPA_Data in1 = 0.0f;
LADSPA_Data in2 = 0.0f;
LADSPA_Data out_0 = 0.0f;
LADSPA_Data out_1 = 0.0f;
LADSPA_Data out_2 = 0.0f;
unsigned long fragment_pos1 = 0;
unsigned long fragment_pos2 = 0;
unsigned long arg_0 = 0;
LADSPA_Data am_0 = 0.0f;
unsigned long arg_1 = 0;
LADSPA_Data am_1 = 0.0f;
unsigned long arg_2 = 0;
LADSPA_Data am_2 = 0.0f;
ptr->buflen0 = 2 * fragment * ptr->sample_rate / 1000.0f;
ptr->buflen1 = ptr->buflen0;
ptr->buflen2 = ptr->buflen0;
ptr->delay_buflen1 = ptr->buflen0 / 3;
ptr->delay_buflen2 = 2 * ptr->buflen0 / 3;
for (sample_index = 0; sample_index < sample_count; sample_index++) {
in = *(input++);
in1 = push_buffer(in, ptr->delay1, ptr->delay_buflen1, &(ptr->delay_pos1));
in2 = push_buffer(in, ptr->delay2, ptr->delay_buflen2, &(ptr->delay_pos2));
push_buffer(in2, ptr->ring0, ptr->buflen0, &(ptr->pos0));
push_buffer(in1, ptr->ring1, ptr->buflen1, &(ptr->pos1));
push_buffer(in, ptr->ring2, ptr->buflen2, &(ptr->pos2));
fragment_pos1 = (ptr->fragment_pos + ptr->buflen0 / 3) % ptr->buflen0;
fragment_pos2 = (ptr->fragment_pos + 2 * ptr->buflen1 / 3) % ptr->buflen1;
out_0 = read_buffer(ptr->ring0, ptr->buflen0, ptr->pos0,
ptr->buflen0 - ptr->fragment_pos - 1);
out_1 = read_buffer(ptr->ring1, ptr->buflen1, ptr->pos1,
ptr->buflen1 - fragment_pos1 - 1);
out_2 = read_buffer(ptr->ring2, ptr->buflen2, ptr->pos2,
ptr->buflen2 - fragment_pos2 - 1);
ptr->fragment_pos += 2;
if (ptr->fragment_pos >= ptr->buflen0)
ptr->fragment_pos = 0;
arg_0 = (float)ptr->fragment_pos / (float)ptr->buflen0 * COS_TABLE_SIZE;
am_0 = 1.0f - cos_table[arg_0];
arg_1 = (float)fragment_pos1 / (float)ptr->buflen1 * COS_TABLE_SIZE;
am_1 = 1.0f - cos_table[arg_1];
arg_2 = (float)fragment_pos2 / (float)ptr->buflen2 * COS_TABLE_SIZE;
am_2 = 1.0f - cos_table[arg_2];
*(output++) += ptr->run_adding_gain *
(drylevel * in + wetlevel * (am_0 * out_0 + am_1 * out_1 + am_2 * out_2));
}
}
float
rva_from_multiple_volumes(int nlevels, float * volumes) {
int i, files_to_avg;
char * badlevels;
double sum, level, mean_level, variance, std_dev;
double level_difference, threshold;
if ((badlevels = (char *)calloc(nlevels, sizeof(char))) == NULL) {
fprintf(stderr, "rva_from_multiple_volumes() : calloc error\n");
return 0.0f;
}
sum = 0.0;
for (i = 0; i < nlevels; i++) {
sum += db2lin(volumes[i]);
}
mean_level = sum / nlevels;
if (!options.rva_use_linear_thresh) { /* use stddev_thresh */
sum = 0;
for (i = 0; i < nlevels; i++) {
double tmp = 20.0 * log10(db2lin(volumes[i]) / mean_level);
sum += tmp * tmp;
}
variance = sum / nlevels;
/* get standard deviation */
if (variance < EPSILON) {
std_dev = 0.0;
} else {
std_dev = sqrt(variance);
}
threshold = options.rva_avg_stddev_thresh * std_dev;
} else {
threshold = options.rva_avg_linear_thresh;
}
if (threshold > EPSILON && nlevels > 1) {
for (i = 0; i < nlevels; i++) {
level_difference = fabs(20.0 * log10(mean_level / db2lin(volumes[i])));
if (level_difference > threshold) {
badlevels[i] = 1;
}
}
}
/* throw out the levels marked as bad */
files_to_avg = 0;
sum = 0;
for (i = 0; i < nlevels; i++) {
if (!badlevels[i]) {
sum += db2lin(volumes[i]);
files_to_avg++;
}
}
free(badlevels);
if (files_to_avg == 0) {
fprintf(stderr,
"rva_from_multiple_volumes: all files ignored, using mean value.\n");
return rva_from_volume(20 * log10(mean_level));
}
level = sum / files_to_avg;
return rva_from_volume(20 * log10(level));
}
static void runAddingSc4m(LADSPA_Handle instance, unsigned long sample_count) {
Sc4m *plugin_data = (Sc4m *)instance;
LADSPA_Data run_adding_gain = plugin_data->run_adding_gain;
/* RMS/peak (float value) */
const LADSPA_Data rms_peak = *(plugin_data->rms_peak);
/* Attack time (ms) (float value) */
const LADSPA_Data attack = *(plugin_data->attack);
/* Release time (ms) (float value) */
const LADSPA_Data release = *(plugin_data->release);
/* Threshold level (dB) (float value) */
const LADSPA_Data threshold = *(plugin_data->threshold);
/* Ratio (1:n) (float value) */
const LADSPA_Data ratio = *(plugin_data->ratio);
/* Knee radius (dB) (float value) */
const LADSPA_Data knee = *(plugin_data->knee);
/* Makeup gain (dB) (float value) */
const LADSPA_Data makeup_gain = *(plugin_data->makeup_gain);
/* Input (array of floats of length sample_count) */
const LADSPA_Data * const input = plugin_data->input;
/* Output (array of floats of length sample_count) */
LADSPA_Data * const output = plugin_data->output;
float amp = plugin_data->amp;
float * as = plugin_data->as;
unsigned int count = plugin_data->count;
float env = plugin_data->env;
float env_peak = plugin_data->env_peak;
float env_rms = plugin_data->env_rms;
float gain = plugin_data->gain;
float gain_t = plugin_data->gain_t;
rms_env * rms = plugin_data->rms;
float sum = plugin_data->sum;
unsigned long pos;
const float ga = attack < 2.0f ? 0.0f : as[f_round(attack * 0.001f * (float)(A_TBL-1))];
const float gr = as[f_round(release * 0.001f * (float)(A_TBL-1))];
const float rs = (ratio - 1.0f) / ratio;
const float mug = db2lin(makeup_gain);
const float knee_min = db2lin(threshold - knee);
const float knee_max = db2lin(threshold + knee);
const float ef_a = ga * 0.25f;
const float ef_ai = 1.0f - ef_a;
for (pos = 0; pos < sample_count; pos++) {
const float lev_in = input[pos];
sum += lev_in * lev_in;
if (amp > env_rms) {
env_rms = env_rms * ga + amp * (1.0f - ga);
} else {
env_rms = env_rms * gr + amp * (1.0f - gr);
}
round_to_zero(&env_rms);
if (lev_in > env_peak) {
env_peak = env_peak * ga + lev_in * (1.0f - ga);
} else {
env_peak = env_peak * gr + lev_in * (1.0f - gr);
}
round_to_zero(&env_peak);
if ((count++ & 3) == 3) {
amp = rms_env_process(rms, sum * 0.25f);
sum = 0.0f;
env = LIN_INTERP(rms_peak, env_rms, env_peak);
if (env <= knee_min) {
gain_t = 1.0f;
} else if (env < knee_max) {
const float x = -(threshold - knee - lin2db(env)) / knee;
gain_t = db2lin(-knee * rs * x * x * 0.25f);
} else {
gain_t = db2lin((threshold - lin2db(env)) * rs);
}
}
gain = gain * ef_a + gain_t * ef_ai;
buffer_write(output[pos], input[pos] * gain * mug);
}
plugin_data->sum = sum;
plugin_data->amp = amp;
plugin_data->gain = gain;
plugin_data->gain_t = gain_t;
plugin_data->env = env;
plugin_data->env_rms = env_rms;
plugin_data->env_peak = env_peak;
plugin_data->count = count;
*(plugin_data->amplitude) = lin2db(env);
*(plugin_data->gain_red) = lin2db(gain);
}
void
run_adding_ChorusFlanger(LADSPA_Handle Instance,
unsigned long SampleCount) {
ChorusFlanger * ptr = (ChorusFlanger *)Instance;
LADSPA_Data freq = LIMIT(*(ptr->freq), 0.0f, MAX_FREQ);
LADSPA_Data phase = LIMIT(*(ptr->phase), 0.0f, 180.0f) / 180.0f;
LADSPA_Data depth = 100.0f * ptr->sample_rate / 44100.0f
* LIMIT(*(ptr->depth),0.0f,100.0f) / 100.0f;
LADSPA_Data delay = LIMIT(*(ptr->delay),0.0f,100.0f);
LADSPA_Data contour = LIMIT(*(ptr->contour), 20.0f, 20000.0f);
LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
LADSPA_Data * input_L = ptr->input_L;
LADSPA_Data * input_R = ptr->input_R;
LADSPA_Data * output_L = ptr->output_L;
LADSPA_Data * output_R = ptr->output_R;
unsigned long sample_index;
unsigned long sample_count = SampleCount;
LADSPA_Data in_L = 0.0f;
LADSPA_Data in_R = 0.0f;
LADSPA_Data d_L = 0.0f;
LADSPA_Data d_R = 0.0f;
LADSPA_Data f_L = 0.0f;
LADSPA_Data f_R = 0.0f;
LADSPA_Data out_L = 0.0f;
LADSPA_Data out_R = 0.0f;
float phase_L = 0.0f;
float phase_R = 0.0f;
float fpos_L = 0.0f;
float fpos_R = 0.0f;
float n_L = 0.0f;
float n_R = 0.0f;
float rem_L = 0.0f;
float rem_R = 0.0f;
float s_a_L, s_a_R, s_b_L, s_b_R;
float d_pos = 0.0f;
if (delay < 1.0f)
delay = 1.0f;
delay = 100.0f - delay;
hp_set_params(&ptr->highpass_L, contour, HP_BW, ptr->sample_rate);
hp_set_params(&ptr->highpass_R, contour, HP_BW, ptr->sample_rate);
for (sample_index = 0; sample_index < sample_count; sample_index++) {
in_L = *(input_L++);
in_R = *(input_R++);
push_buffer(in_L, ptr->ring_L, ptr->buflen_L, &(ptr->pos_L));
push_buffer(in_R, ptr->ring_R, ptr->buflen_R, &(ptr->pos_R));
ptr->cm_phase += freq / ptr->sample_rate * COS_TABLE_SIZE;
while (ptr->cm_phase >= COS_TABLE_SIZE)
ptr->cm_phase -= COS_TABLE_SIZE;
ptr->dm_phase = phase * COS_TABLE_SIZE / 2.0f;
phase_L = ptr->cm_phase;
phase_R = ptr->cm_phase + ptr->dm_phase;
while (phase_R >= COS_TABLE_SIZE)
phase_R -= COS_TABLE_SIZE;
d_pos = delay * ptr->sample_rate / 1000.0f;
fpos_L = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_L]);
fpos_R = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_R]);
n_L = floorf(fpos_L);
n_R = floorf(fpos_R);
rem_L = fpos_L - n_L;
rem_R = fpos_R - n_R;
s_a_L = read_buffer(ptr->ring_L, ptr->buflen_L,
ptr->pos_L, (unsigned long) n_L);
s_b_L = read_buffer(ptr->ring_L, ptr->buflen_L,
ptr->pos_L, (unsigned long) n_L + 1);
s_a_R = read_buffer(ptr->ring_R, ptr->buflen_R,
ptr->pos_R, (unsigned long) n_R);
s_b_R = read_buffer(ptr->ring_R, ptr->buflen_R,
ptr->pos_R, (unsigned long) n_R + 1);
d_L = ((1 - rem_L) * s_a_L + rem_L * s_b_L);
d_R = ((1 - rem_R) * s_a_R + rem_R * s_b_R);
f_L = biquad_run(&ptr->highpass_L, d_L);
f_R = biquad_run(&ptr->highpass_R, d_R);
out_L = drylevel * in_L + wetlevel * f_L;
out_R = drylevel * in_R + wetlevel * f_R;
*(output_L++) += ptr->run_adding_gain * out_L;
*(output_R++) += ptr->run_adding_gain * out_R;
}
}
static void runSc4(LADSPA_Handle instance, unsigned long sample_count) {
Sc4 *plugin_data = (Sc4 *)instance;
/* RMS/peak (float value) */
const LADSPA_Data rms_peak = *(plugin_data->rms_peak);
/* Attack time (ms) (float value) */
const LADSPA_Data attack = *(plugin_data->attack);
/* Release time (ms) (float value) */
const LADSPA_Data release = *(plugin_data->release);
/* Threshold level (dB) (float value) */
const LADSPA_Data threshold = *(plugin_data->threshold);
/* Ratio (1:n) (float value) */
const LADSPA_Data ratio = *(plugin_data->ratio);
/* Knee radius (dB) (float value) */
const LADSPA_Data knee = *(plugin_data->knee);
/* Makeup gain (dB) (float value) */
const LADSPA_Data makeup_gain = *(plugin_data->makeup_gain);
/* Left input (array of floats of length sample_count) */
const LADSPA_Data * const left_in = plugin_data->left_in;
/* Right input (array of floats of length sample_count) */
const LADSPA_Data * const right_in = plugin_data->right_in;
/* Left output (array of floats of length sample_count) */
LADSPA_Data * const left_out = plugin_data->left_out;
/* Right output (array of floats of length sample_count) */
LADSPA_Data * const right_out = plugin_data->right_out;
float amp = plugin_data->amp;
float * as = plugin_data->as;
unsigned int count = plugin_data->count;
float env = plugin_data->env;
float env_peak = plugin_data->env_peak;
float env_rms = plugin_data->env_rms;
float gain = plugin_data->gain;
float gain_t = plugin_data->gain_t;
rms_env * rms = plugin_data->rms;
float sum = plugin_data->sum;
#line 51 "sc4_1434.xml"
unsigned long pos;
const float ga = attack < 2.0f ? 0.0f : as[f_round(attack * 0.001f * (float)(A_TBL-1))];
const float gr = as[f_round(release * 0.001f * (float)(A_TBL-1))];
const float rs = (ratio - 1.0f) / ratio;
const float mug = db2lin(makeup_gain);
const float knee_min = db2lin(threshold - knee);
const float knee_max = db2lin(threshold + knee);
const float ef_a = ga * 0.25f;
const float ef_ai = 1.0f - ef_a;
for (pos = 0; pos < sample_count; pos++) {
const float la = fabs(left_in[pos]);
const float ra = fabs(right_in[pos]);
const float lev_in = f_max(la, ra);
sum += lev_in * lev_in;
if (amp > env_rms) {
env_rms = env_rms * ga + amp * (1.0f - ga);
} else {
env_rms = env_rms * gr + amp * (1.0f - gr);
}
if (lev_in > env_peak) {
env_peak = env_peak * ga + lev_in * (1.0f - ga);
} else {
env_peak = env_peak * gr + lev_in * (1.0f - gr);
}
if ((count++ & 3) == 3) {
amp = rms_env_process(rms, sum * 0.25f);
sum = 0.0f;
if (isnan(env_rms)) {
// This can happen sometimes, but I don't know why
env_rms = 0.0f;
}
env = LIN_INTERP(rms_peak, env_rms, env_peak);
if (env <= knee_min) {
gain_t = 1.0f;
} else if (env < knee_max) {
const float x = -(threshold - knee - lin2db(env)) / knee;
gain_t = db2lin(-knee * rs * x * x * 0.25f);
} else {
gain_t = db2lin((threshold - lin2db(env)) * rs);
}
}
gain = gain * ef_a + gain_t * ef_ai;
buffer_write(left_out[pos], left_in[pos] * gain * mug);
buffer_write(right_out[pos], right_in[pos] * gain * mug);
}
plugin_data->sum = sum;
plugin_data->amp = amp;
plugin_data->gain = gain;
plugin_data->gain_t = gain_t;
plugin_data->env = env;
plugin_data->env_rms = env_rms;
plugin_data->env_peak = env_peak;
plugin_data->count = count;
*(plugin_data->amplitude) = lin2db(env);
*(plugin_data->gain_red) = lin2db(gain);
}
void
run_ChorusFlanger(LV2_Handle Instance,
uint32_t SampleCount) {
ChorusFlanger * ptr = (ChorusFlanger *)Instance;
float freq = LIMIT(*(ptr->freq), 0.0f, MAX_FREQ);
float calcphase = (*(ptr->phase)+ptr->smoothphase)*0.5;
ptr->smoothphase=calcphase;
float phase = LIMIT(calcphase, 0.0f, 180.0f) / 180.0f;
float calcdepth = (*(ptr->depth)+ptr->smoothdepth)*0.5;
ptr->smoothdepth=calcdepth;
float depth = 100.0f * ptr->sample_rate / 44100.0f
* LIMIT(calcdepth,0.0f,100.0f) / 100.0f;
float calcdelay = (*(ptr->delay)+ptr->smoothdelay)*0.5;
ptr->smoothdelay=calcdelay;
float delay = LIMIT(calcdelay,0.0f,100.0f);
float contour = LIMIT(*(ptr->contour), 20.0f, 20000.0f);
float calcdry = (*(ptr->drylevel)+ptr->smoothdry)*0.5;
ptr->smoothdry=calcdry;
float drylevel = db2lin(LIMIT(calcdry,-90.0f,20.0f));
float calcwet = (*(ptr->wetlevel)+ptr->smoothwet)*0.5;
ptr->smoothwet=calcwet;
float wetlevel = db2lin(LIMIT(calcwet,-90.0f,20.0f));
float * input_L = ptr->input_L;
float * input_R = ptr->input_R;
float * output_L = ptr->output_L;
float * output_R = ptr->output_R;
unsigned long sample_index;
unsigned long sample_count = SampleCount;
float in_L = 0.0f;
float in_R = 0.0f;
float d_L = 0.0f;
float d_R = 0.0f;
float f_L = 0.0f;
float f_R = 0.0f;
float out_L = 0.0f;
float out_R = 0.0f;
float phase_L = 0.0f;
float phase_R = 0.0f;
float fpos_L = 0.0f;
float fpos_R = 0.0f;
float n_L = 0.0f;
float n_R = 0.0f;
float rem_L = 0.0f;
float rem_R = 0.0f;
float s_a_L, s_a_R, s_b_L, s_b_R;
float d_pos = 0.0f;
if (delay < 1.0f)
delay = 1.0f;
delay = 100.0f - delay;
hp_set_params(&ptr->highpass_L, contour, HP_BW, ptr->sample_rate);
hp_set_params(&ptr->highpass_R, contour, HP_BW, ptr->sample_rate);
for (sample_index = 0; sample_index < sample_count; sample_index++) {
in_L = *(input_L++);
in_R = *(input_R++);
push_buffer(in_L, ptr->ring_L, ptr->buflen_L, &(ptr->pos_L));
push_buffer(in_R, ptr->ring_R, ptr->buflen_R, &(ptr->pos_R));
ptr->cm_phase += freq / ptr->sample_rate * COS_TABLE_SIZE;
while (ptr->cm_phase >= COS_TABLE_SIZE)
ptr->cm_phase -= COS_TABLE_SIZE;
ptr->dm_phase = phase * COS_TABLE_SIZE / 2.0f;
phase_L = ptr->cm_phase;
phase_R = ptr->cm_phase + ptr->dm_phase;
while (phase_R >= COS_TABLE_SIZE)
phase_R -= COS_TABLE_SIZE;
d_pos = delay * ptr->sample_rate / 1000.0f;
fpos_L = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_L]);
fpos_R = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_R]);
n_L = floorf(fpos_L);
n_R = floorf(fpos_R);
rem_L = fpos_L - n_L;
rem_R = fpos_R - n_R;
s_a_L = read_buffer(ptr->ring_L, ptr->buflen_L,
ptr->pos_L, (unsigned long) n_L);
s_b_L = read_buffer(ptr->ring_L, ptr->buflen_L,
ptr->pos_L, (unsigned long) n_L + 1);
s_a_R = read_buffer(ptr->ring_R, ptr->buflen_R,
ptr->pos_R, (unsigned long) n_R);
s_b_R = read_buffer(ptr->ring_R, ptr->buflen_R,
ptr->pos_R, (unsigned long) n_R + 1);
d_L = ((1 - rem_L) * s_a_L + rem_L * s_b_L);
d_R = ((1 - rem_R) * s_a_R + rem_R * s_b_R);
f_L = biquad_run(&ptr->highpass_L, d_L);
f_R = biquad_run(&ptr->highpass_R, d_R);
out_L = drylevel * in_L + wetlevel * f_L;
out_R = drylevel * in_R + wetlevel * f_R;
*(output_L++) = out_L;
*(output_R++) = out_R;
}
}
void
run_Reflector(LV2_Handle Instance,
uint32_t SampleCount) {
Reflector * ptr = (Reflector *)Instance;
float * input = ptr->input;
float * output = ptr->output;
float drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
float wetlevel = 0.333333f * db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
float fragment = LIMIT(*(ptr->fragment),(float)MIN_FRAGMENT_LEN,(float)MAX_FRAGMENT_LEN);
unsigned long sample_index;
unsigned long sample_count = SampleCount;
float in = 0.0f;
float in1 = 0.0f;
float in2 = 0.0f;
float out_0 = 0.0f;
float out_1 = 0.0f;
float out_2 = 0.0f;
unsigned long fragment_pos1 = 0;
unsigned long fragment_pos2 = 0;
unsigned long arg_0 = 0;
float am_0 = 0.0f;
unsigned long arg_1 = 0;
float am_1 = 0.0f;
unsigned long arg_2 = 0;
float am_2 = 0.0f;
ptr->buflen0 = 2 * fragment * ptr->sample_rate / 1000.0f;
ptr->buflen1 = ptr->buflen0;
ptr->buflen2 = ptr->buflen0;
ptr->delay_buflen1 = ptr->buflen0 / 3;
ptr->delay_buflen2 = 2 * ptr->buflen0 / 3;
for (sample_index = 0; sample_index < sample_count; sample_index++) {
in = *(input++);
in1 = push_buffer(in, ptr->delay1, ptr->delay_buflen1, &(ptr->delay_pos1));
in2 = push_buffer(in, ptr->delay2, ptr->delay_buflen2, &(ptr->delay_pos2));
push_buffer(in2, ptr->ring0, ptr->buflen0, &(ptr->pos0));
push_buffer(in1, ptr->ring1, ptr->buflen1, &(ptr->pos1));
push_buffer(in, ptr->ring2, ptr->buflen2, &(ptr->pos2));
fragment_pos1 = (ptr->fragment_pos + ptr->buflen0 / 3) % ptr->buflen0;
fragment_pos2 = (ptr->fragment_pos + 2 * ptr->buflen1 / 3) % ptr->buflen1;
// printf("RING 0: %f, BUFLEN: %lu, POS0:%lu, CONTA:%lu \n", *(ptr->ring0), ptr->buflen0, ptr->pos0, ptr->buflen0 - ptr->fragment_pos - 1);
out_0 = read_buffer(ptr->ring0, ptr->buflen0, ptr->pos0,
ptr->buflen0 - ptr->fragment_pos - 1);
// printf("N PASSO\n");
out_1 = read_buffer(ptr->ring1, ptr->buflen1, ptr->pos1,
ptr->buflen1 - fragment_pos1 - 1);
out_2 = read_buffer(ptr->ring2, ptr->buflen2, ptr->pos2,
ptr->buflen2 - fragment_pos2 - 1);
ptr->fragment_pos += 2;
if (ptr->fragment_pos >= ptr->buflen0)
ptr->fragment_pos = 0;
arg_0 = (float)ptr->fragment_pos / (float)ptr->buflen0 * COS_TABLE_SIZE;
am_0 = 1.0f - cos_table[arg_0];
arg_1 = (float)fragment_pos1 / (float)ptr->buflen1 * COS_TABLE_SIZE;
am_1 = 1.0f - cos_table[arg_1];
arg_2 = (float)fragment_pos2 / (float)ptr->buflen2 * COS_TABLE_SIZE;
am_2 = 1.0f - cos_table[arg_2];
*(output++) = drylevel * in + wetlevel *
(am_0 * out_0 + am_1 * out_1 + am_2 * out_2);
}
}
void
run_adding_Limiter(LADSPA_Handle Instance,
unsigned long SampleCount) {
Limiter * ptr = (Limiter *)Instance;
LADSPA_Data * input = ptr->input;
LADSPA_Data * output = ptr->output;
LADSPA_Data limit_vol = db2lin(LIMIT(*(ptr->limit_vol),-30.0f,20.0f));
LADSPA_Data out_vol = db2lin(LIMIT(*(ptr->out_vol),-30.0f,20.0f));
unsigned long sample_index;
unsigned long sample_count = SampleCount;
unsigned long index_offs = 0;
unsigned long i;
LADSPA_Data max_value = 0;
LADSPA_Data section_gain = 0;
unsigned long run_length;
unsigned long total_length = 0;
while (total_length < sample_count) {
run_length = ptr->buflen;
if (total_length + run_length > sample_count)
run_length = sample_count - total_length;
while (ptr->ready_num < run_length) {
if (read_buffer(ptr->ringbuffer, ptr->buflen,
ptr->pos, ptr->ready_num) >= 0.0f) {
index_offs = 0;
while ((read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos,
ptr->ready_num + index_offs) >= 0.0f) &&
(ptr->ready_num + index_offs < run_length)) {
index_offs++;
}
} else {
index_offs = 0;
while ((read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos,
ptr->ready_num + index_offs) <= 0.0f) &&
(ptr->ready_num + index_offs < run_length)) {
index_offs++;
}
}
/* search for max value in scanned halfcycle */
max_value = 0;
for (i = ptr->ready_num; i < ptr->ready_num + index_offs; i++) {
if (fabs(read_buffer(ptr->ringbuffer, ptr->buflen,
ptr->pos, i)) > max_value)
max_value = fabs(read_buffer(ptr->ringbuffer,
ptr->buflen, ptr->pos, i));
}
section_gain = limit_vol / max_value;
if (max_value > limit_vol)
for (i = ptr->ready_num; i < ptr->ready_num + index_offs; i++) {
write_buffer(read_buffer(ptr->ringbuffer, ptr->buflen,
ptr->pos, i) * section_gain,
ptr->ringbuffer, ptr->buflen, ptr->pos, i);
}
ptr->ready_num += index_offs;
}
/* push run_length values out of ringbuffer, feed with input */
for (sample_index = 0; sample_index < run_length; sample_index++) {
*(output++) += ptr->run_adding_gain * out_vol *
push_buffer(*(input++), ptr->ringbuffer,
ptr->buflen, &(ptr->pos));
}
ptr->ready_num -= run_length;
total_length += run_length;
}
*(ptr->latency) = ptr->buflen;
}
void
run_adding_Pitch(LADSPA_Handle Instance,
unsigned long SampleCount) {
Pitch * ptr = (Pitch *)Instance;
LADSPA_Data * input = ptr->input;
LADSPA_Data * output = ptr->output;
LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
LADSPA_Data wetlevel = 0.333333f * db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
LADSPA_Data buflen = ptr->buflen / 2.0f;
LADSPA_Data semitone = LIMIT(*(ptr->semitone),-12.0f,12.0f);
LADSPA_Data rate;
LADSPA_Data r;
LADSPA_Data depth;
unsigned long sample_index;
unsigned long sample_count = SampleCount;
LADSPA_Data in = 0.0f;
LADSPA_Data sign = 1.0f;
LADSPA_Data phase_0 = 0.0f;
LADSPA_Data phase_am_0 = 0.0f;
LADSPA_Data phase_1 = 0.0f;
LADSPA_Data phase_am_1 = 0.0f;
LADSPA_Data phase_2 = 0.0f;
LADSPA_Data phase_am_2 = 0.0f;
LADSPA_Data fpos_0 = 0.0f, fpos_1 = 0.0f, fpos_2 = 0.0f;
LADSPA_Data n_0 = 0.0f, n_1 = 0.0f, n_2 = 0.0f;
LADSPA_Data rem_0 = 0.0f, rem_1 = 0.0f, rem_2 = 0.0f;
LADSPA_Data sa_0, sb_0, sa_1, sb_1, sa_2, sb_2;
if (semitone == 0.0f)
rate = LIMIT(*(ptr->rate),-50.0f,100.0f);
else
rate = 100.0f * (powf(ROOT_12_2,semitone) - 1.0f);
r = -1.0f * ABS(rate);
depth = buflen * LIMIT(ABS(r) / 100.0f, 0.0f, 1.0f);
if (rate > 0.0f)
sign = -1.0f;
for (sample_index = 0; sample_index < sample_count; sample_index++) {
in = *(input++);
phase_0 = COS_TABLE_SIZE * PM_FREQ * sample_index / ptr->sample_rate + ptr->phase;
while (phase_0 >= COS_TABLE_SIZE)
phase_0 -= COS_TABLE_SIZE;
phase_am_0 = phase_0 + COS_TABLE_SIZE/2;
while (phase_am_0 >= COS_TABLE_SIZE)
phase_am_0 -= COS_TABLE_SIZE;
phase_1 = phase_0 + COS_TABLE_SIZE/3.0f;
while (phase_1 >= COS_TABLE_SIZE)
phase_1 -= COS_TABLE_SIZE;
phase_am_1 = phase_1 + COS_TABLE_SIZE/2;
while (phase_am_1 >= COS_TABLE_SIZE)
phase_am_1 -= COS_TABLE_SIZE;
phase_2 = phase_0 + 2.0f*COS_TABLE_SIZE/3.0f;
while (phase_2 >= COS_TABLE_SIZE)
phase_2 -= COS_TABLE_SIZE;
phase_am_2 = phase_2 + COS_TABLE_SIZE/2;
while (phase_am_2 >= COS_TABLE_SIZE)
phase_am_2 -= COS_TABLE_SIZE;
push_buffer(in, ptr->ringbuffer, ptr->buflen, &(ptr->pos));
fpos_0 = depth * (1.0f - sign * (2.0f * phase_0 / COS_TABLE_SIZE - 1.0f));
n_0 = floorf(fpos_0);
rem_0 = fpos_0 - n_0;
fpos_1 = depth * (1.0f - sign * (2.0f * phase_1 / COS_TABLE_SIZE - 1.0f));
n_1 = floorf(fpos_1);
rem_1 = fpos_1 - n_1;
fpos_2 = depth * (1.0f - sign * (2.0f * phase_2 / COS_TABLE_SIZE - 1.0f));
n_2 = floorf(fpos_2);
rem_2 = fpos_2 - n_2;
sa_0 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_0);
sb_0 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_0 + 1);
sa_1 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_1);
sb_1 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_1 + 1);
sa_2 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_2);
sb_2 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_2 + 1);
*(output++) += ptr->run_adding_gain *
wetlevel *
((1.0f + cos_table[(unsigned long) phase_am_0]) *
((1 - rem_0) * sa_0 + rem_0 * sb_0) +
(1.0f + cos_table[(unsigned long) phase_am_1]) *
((1 - rem_1) * sa_1 + rem_1 * sb_1) +
(1.0f + cos_table[(unsigned long) phase_am_2]) *
((1 - rem_2) * sa_2 + rem_2 * sb_2)) +
drylevel *
read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) depth);
}
ptr->phase += COS_TABLE_SIZE * PM_FREQ * sample_index / ptr->sample_rate;
while (ptr->phase >= COS_TABLE_SIZE)
ptr->phase -= COS_TABLE_SIZE;
*(ptr->latency) = buflen - (unsigned long) depth;
}
void
run_adding_DeEsser(LADSPA_Handle Instance,
unsigned long SampleCount) {
DeEsser * ptr = (DeEsser *)Instance;
LADSPA_Data * input = ptr->input;
LADSPA_Data * output = ptr->output;
LADSPA_Data threshold = LIMIT(*(ptr->threshold),-50.0f,10.0f);
LADSPA_Data freq = LIMIT(*(ptr->freq),2000.0f,16000.0f);
LADSPA_Data sidechain = LIMIT(*(ptr->sidechain),0.0f,1.0f);
LADSPA_Data monitor = LIMIT(*(ptr->monitor),0.0f,1.0f);
unsigned long sample_index;
LADSPA_Data in = 0;
LADSPA_Data out = 0;
LADSPA_Data sidech = 0;
LADSPA_Data ampl_db = 0.0f;
LADSPA_Data attn = 0.0f;
LADSPA_Data max_attn = 0.0f;
if (ptr->old_freq != freq) {
lp_set_params(&ptr->sidech_lo_filter, freq, SIDECH_BW, ptr->sample_rate);
hp_set_params(&ptr->sidech_hi_filter, freq, SIDECH_BW, ptr->sample_rate);
ptr->old_freq = freq;
}
for (sample_index = 0; sample_index < SampleCount; sample_index++) {
in = *(input++);
/* process sidechain filters */
sidech = biquad_run(&ptr->sidech_hi_filter, in);
if (sidechain > 0.1f)
sidech = biquad_run(&ptr->sidech_lo_filter, sidech);
ampl_db = 20.0f * log10f(sidech);
if (ampl_db <= threshold)
attn = 0.0f;
else
attn = -0.5f * (ampl_db - threshold);
ptr->sum += attn;
ptr->sum -= push_buffer(attn, ptr->ringbuffer, ptr->buflen, &ptr->pos);
if (-1.0f * ptr->sum > max_attn)
max_attn = -0.01f * ptr->sum;
in *= db2lin(ptr->sum / 100.0f);
/* output selector */
if (monitor > 0.1f)
out = sidech;
else
out = in;
*(output++) += ptr->run_adding_gain * out;
*(ptr->attenuat) = LIMIT(max_attn,0,10);
}
}
void
run_adding_Doubler(LADSPA_Handle Instance,
unsigned long SampleCount) {
Doubler * ptr = (Doubler *)Instance;
LADSPA_Data pitch = LIMIT(*(ptr->pitch),0.0f,1.0f) + 0.75f;
LADSPA_Data depth = LIMIT(((1.0f - LIMIT(*(ptr->pitch),0.0f,1.0f)) * 1.75f + 0.25f) *
ptr->sample_rate / 6000.0f / M_PI,
0, ptr->buflen_L / 2);
LADSPA_Data time = LIMIT(*(ptr->time), 0.0f, 1.0f) + 0.5f;
LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
LADSPA_Data dryposl = 1.0f - LIMIT(*(ptr->dryposl), 0.0f, 1.0f);
LADSPA_Data dryposr = LIMIT(*(ptr->dryposr), 0.0f, 1.0f);
LADSPA_Data wetposl = 1.0f - LIMIT(*(ptr->wetposl), 0.0f, 1.0f);
LADSPA_Data wetposr = LIMIT(*(ptr->wetposr), 0.0f, 1.0f);
LADSPA_Data * input_L = ptr->input_L;
LADSPA_Data * input_R = ptr->input_R;
LADSPA_Data * output_L = ptr->output_L;
LADSPA_Data * output_R = ptr->output_R;
unsigned long sample_index;
unsigned long sample_count = SampleCount;
LADSPA_Data in_L = 0.0f;
LADSPA_Data in_R = 0.0f;
LADSPA_Data out_L = 0.0f;
LADSPA_Data out_R = 0.0f;
LADSPA_Data fpos = 0.0f;
LADSPA_Data n = 0.0f;
LADSPA_Data rem = 0.0f;
LADSPA_Data s_a_L, s_a_R, s_b_L, s_b_R;
LADSPA_Data prev_p_pitch = 0.0f;
LADSPA_Data prev_p_delay = 0.0f;
LADSPA_Data delay;
LADSPA_Data drystream_L = 0.0f;
LADSPA_Data drystream_R = 0.0f;
LADSPA_Data wetstream_L = 0.0f;
LADSPA_Data wetstream_R = 0.0f;
if (ptr->old_pitch != pitch) {
ptr->pitchmod = ptr->p_pitch;
prev_p_pitch = ptr->p_pitch;
fractal(ptr->ring_pnoise, NOISE_LEN, pitch);
ptr->pos_pnoise = 0;
ptr->p_pitch = push_buffer(0.0f, ptr->ring_pnoise,
ptr->buflen_pnoise, &(ptr->pos_pnoise));
ptr->d_pitch = (ptr->p_pitch - prev_p_pitch) / (float)(ptr->p_stretch);
ptr->n_pitch = 0;
ptr->old_pitch = pitch;
}
if (ptr->old_time != time) {
ptr->delay = ptr->p_delay;
prev_p_delay = ptr->p_delay;
fractal(ptr->ring_dnoise, NOISE_LEN, time);
ptr->pos_dnoise = 0;
ptr->p_delay = push_buffer(0.0f, ptr->ring_dnoise,
ptr->buflen_dnoise, &(ptr->pos_dnoise));
ptr->d_delay = (ptr->p_delay - prev_p_delay) / (float)(ptr->d_stretch);
ptr->n_delay = 0;
ptr->old_time = time;
}
for (sample_index = 0; sample_index < sample_count; sample_index++) {
in_L = *(input_L++);
in_R = *(input_R++);
push_buffer(in_L, ptr->ring_L, ptr->buflen_L, &(ptr->pos_L));
push_buffer(in_R, ptr->ring_R, ptr->buflen_R, &(ptr->pos_R));
if (ptr->n_pitch < ptr->p_stretch) {
ptr->pitchmod += ptr->d_pitch;
ptr->n_pitch++;
} else {
ptr->pitchmod = ptr->p_pitch;
prev_p_pitch = ptr->p_pitch;
if (!ptr->pos_pnoise) {
fractal(ptr->ring_pnoise, NOISE_LEN, pitch);
}
ptr->p_pitch = push_buffer(0.0f, ptr->ring_pnoise,
ptr->buflen_pnoise, &(ptr->pos_pnoise));
ptr->d_pitch = (ptr->p_pitch - prev_p_pitch) / (float)(ptr->p_stretch);
ptr->n_pitch = 0;
}
if (ptr->n_delay < ptr->d_stretch) {
ptr->delay += ptr->d_delay;
ptr->n_delay++;
} else {
ptr->delay = ptr->p_delay;
prev_p_delay = ptr->p_delay;
if (!ptr->pos_dnoise) {
fractal(ptr->ring_dnoise, NOISE_LEN, time);
}
ptr->p_delay = push_buffer(0.0f, ptr->ring_dnoise,
ptr->buflen_dnoise, &(ptr->pos_dnoise));
ptr->d_delay = (ptr->p_delay - prev_p_delay) / (float)(ptr->d_stretch);
ptr->n_delay = 0;
}
delay = (12.5f * ptr->delay + 37.5f) * ptr->sample_rate / 1000.0f;
fpos = ptr->buflen_L - depth * (1.0f - ptr->pitchmod) - delay - 1.0f;
n = floorf(fpos);
rem = fpos - n;
s_a_L = read_buffer(ptr->ring_L, ptr->buflen_L,
ptr->pos_L, (unsigned long) n);
s_b_L = read_buffer(ptr->ring_L, ptr->buflen_L,
ptr->pos_L, (unsigned long) n + 1);
s_a_R = read_buffer(ptr->ring_R, ptr->buflen_R,
ptr->pos_R, (unsigned long) n);
s_b_R = read_buffer(ptr->ring_R, ptr->buflen_R,
ptr->pos_R, (unsigned long) n + 1);
drystream_L = drylevel * in_L;
drystream_R = drylevel * in_R;
wetstream_L = wetlevel * ((1 - rem) * s_a_L + rem * s_b_L);
wetstream_R = wetlevel * ((1 - rem) * s_a_R + rem * s_b_R);
out_L = dryposl * drystream_L + (1.0f - dryposr) * drystream_R +
wetposl * wetstream_L + (1.0f - wetposr) * wetstream_R;
out_R = (1.0f - dryposl) * drystream_L + dryposr * drystream_R +
(1.0f - wetposl) * wetstream_L + wetposr * wetstream_R;
*(output_L++) += ptr->run_adding_gain * out_L;
*(output_R++) += ptr->run_adding_gain * out_R;
}
}
static void runSc2(LV2_Handle instance, uint32_t sample_count)
{
Sc2 *plugin_data = (Sc2 *)instance;
const float attack = *(plugin_data->attack);
const float release = *(plugin_data->release);
const float threshold = *(plugin_data->threshold);
const float ratio = *(plugin_data->ratio);
const float knee = *(plugin_data->knee);
const float makeup_gain = *(plugin_data->makeup_gain);
const float * const sidechain = plugin_data->sidechain;
const float * const input = plugin_data->input;
float * const output = plugin_data->output;
rms_env * rms = plugin_data->rms;
float * as = plugin_data->as;
float sum = plugin_data->sum;
float amp = plugin_data->amp;
float gain = plugin_data->gain;
float gain_t = plugin_data->gain_t;
float env = plugin_data->env;
unsigned int count = plugin_data->count;
unsigned long pos;
const float ga = as[f_round(attack * 0.001f * (float)(A_TBL-1))];
const float gr = as[f_round(release * 0.001f * (float)(A_TBL-1))];
const float rs = (ratio - 1.0f) / ratio;
const float mug = db2lin(makeup_gain);
const float knee_min = db2lin(threshold - knee);
const float knee_max = db2lin(threshold + knee);
const float ef_a = ga * 0.25f;
const float ef_ai = 1.0f - ef_a;
for (pos = 0; pos < sample_count; pos++) {
sum += sidechain[pos] * sidechain[pos];
if (amp > env) {
env = env * ga + amp * (1.0f - ga);
} else {
env = env * gr + amp * (1.0f - gr);
}
if (count++ % 4 == 3) {
amp = rms_env_process(rms, sum * 0.25f);
sum = 0.0f;
if (env <= knee_min) {
gain_t = 1.0f;
} else if (env < knee_max) {
const float x = -(threshold - knee - lin2db(env)) / knee;
gain_t = db2lin(-knee * rs * x * x * 0.25f);
} else {
gain_t = db2lin((threshold - lin2db(env)) * rs);
}
}
gain = gain * ef_a + gain_t * ef_ai;
buffer_write(output[pos], input[pos] * gain * mug);
}
plugin_data->sum = sum;
plugin_data->amp = amp;
plugin_data->gain = gain;
plugin_data->gain_t = gain_t;
plugin_data->env = env;
plugin_data->count = count;
}
