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; }