static void runGate(LADSPA_Handle instance, unsigned long sample_count) { Gate *plugin_data = (Gate *)instance; /* LF key filter (Hz) (float value) */ const LADSPA_Data lf_fc = *(plugin_data->lf_fc); /* HF key filter (Hz) (float value) */ const LADSPA_Data hf_fc = *(plugin_data->hf_fc); /* Threshold (dB) (float value) */ const LADSPA_Data threshold = *(plugin_data->threshold); /* Attack (ms) (float value) */ const LADSPA_Data attack = *(plugin_data->attack); /* Hold (ms) (float value) */ const LADSPA_Data hold = *(plugin_data->hold); /* Decay (ms) (float value) */ const LADSPA_Data decay = *(plugin_data->decay); /* Range (dB) (float value) */ const LADSPA_Data range = *(plugin_data->range); /* Output select (-1 = key listen, 0 = gate, 1 = bypass) (float value) */ const LADSPA_Data select = *(plugin_data->select); /* 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 env = plugin_data->env; float fs = plugin_data->fs; float gate = plugin_data->gate; biquad * hf = plugin_data->hf; int hold_count = plugin_data->hold_count; biquad * lf = plugin_data->lf; int state = plugin_data->state; #line 55 "gate_1410.xml" unsigned long pos; float cut = DB_CO(range); float t_level = DB_CO(threshold); float a_rate = 1000.0f / (attack * fs); float d_rate = 1000.0f / (decay * fs); float post_filter, apost_filter; int op = f_round(select); ls_set_params(lf, lf_fc, -40.0f, 0.6f, fs); hs_set_params(hf, hf_fc, -50.0f, 0.6f, fs); for (pos = 0; pos < sample_count; pos++) { post_filter = biquad_run(lf, input[pos]); post_filter = biquad_run(hf, post_filter); apost_filter = fabs(post_filter); if (apost_filter > env) { env = apost_filter; } else { env = apost_filter * ENV_TR + env * (1.0f - ENV_TR); } if (state == CLOSED) { if (env >= t_level) { state = OPENING; } } else if (state == OPENING) { gate += a_rate; if (gate >= 1.0f) { gate = 1.0f; state = OPEN; hold_count = f_round(hold * fs * 0.001f); plugin_data->hold_count = hold_count; } } else if (state == OPEN) { if (hold_count <= 0) { if (env < t_level) { state = CLOSING; } } else { hold_count--; } } else if (state == CLOSING) { gate -= d_rate; if (env >= t_level) { state = OPENING; } else if (gate <= 0.0f) { gate = 0.0f; state = CLOSED; } } if (op == 0) { buffer_write(output[pos], input[pos] * (cut * (1.0f - gate) + gate)); } else if (op == -1) { buffer_write(output[pos], post_filter); } else { buffer_write(output[pos], input[pos]); } } plugin_data->env = env; plugin_data->gate = gate; plugin_data->state = state; plugin_data->hold_count = hold_count; }
static void runAddingGsm(LADSPA_Handle instance, unsigned long sample_count) { Gsm *plugin_data = (Gsm *)instance; LADSPA_Data run_adding_gain = plugin_data->run_adding_gain; /* Dry/wet mix (float value) */ const LADSPA_Data drywet = *(plugin_data->drywet); /* Number of passes (float value) */ const LADSPA_Data passes = *(plugin_data->passes); /* Error rate (bits/block) (float value) */ const LADSPA_Data error = *(plugin_data->error); /* 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; biquad * blf = plugin_data->blf; int count = plugin_data->count; LADSPA_Data * dry = plugin_data->dry; gsm_signal * dst = plugin_data->dst; float fs = plugin_data->fs; gsm handle = plugin_data->handle; int resamp = plugin_data->resamp; float rsf = plugin_data->rsf; gsm_signal * src = plugin_data->src; unsigned long pos; gsm_frame frame; int samp; float part; int error_rate = f_round(error); int num_passes = f_round(passes); fs = fs; // So gcc doesn't think it's unused for (pos = 0; pos < sample_count; pos++) { // oversample into buffer down to aprox 8kHz, 13bit src[count / resamp] += f_round(biquad_run(blf, input[pos]) * rsf); // interpolate output, so it doesn't sound totaly awful samp = count / resamp; part = (float)count / (float)resamp - (float)samp; buffer_write(output[pos], cube_interp(part, dst[samp], dst[samp+1], dst[samp+2], dst[samp+3]) * SCALE_R * drywet + dry[count] * (1.0f - drywet)); // Maintain delayed, dry buffer. dry[count] = input[pos]; count++; // If we have a full, downsampled buffer then run the encode + // decode process. if (count >= 160 * resamp) { int i, j; gsm_signal *in; count = 0; dst[0] = dst[160]; dst[1] = dst[161]; dst[2] = dst[162]; in = src; for (j=0; j<num_passes; j++) { gsm_encode(handle, in, frame); for (i=0; i < error_rate; i++) { frame[1 + (rand() % 32)] ^= bits[rand() % 8]; } gsm_decode(handle, frame, dst+3); in = dst+3; } if (num_passes == 0) { for (j=0; j < 160; j++) { dst[j + 3] = src[j]; } } memset(src, 0, sizeof(gsm_signal) * 160); } } plugin_data->count = count; *(plugin_data->latency) = 160 * resamp; }
static void run_adding_eq(LADSPA_Handle instance, unsigned long sample_count) { eq * ptr = (eq *)instance; const LADSPA_Data ch0f = LIMIT(*(ptr->ch0f),40.0f,280.0f); const LADSPA_Data ch0g = LIMIT(*(ptr->ch0g),-50.0f,20.0f); const LADSPA_Data ch0b = LIMIT(*(ptr->ch0b),0.1f,5.0f); const LADSPA_Data ch1f = LIMIT(*(ptr->ch1f),100.0f,500.0f); const LADSPA_Data ch1g = LIMIT(*(ptr->ch1g),-50.0f,20.0f); const LADSPA_Data ch1b = LIMIT(*(ptr->ch1b),0.1f,5.0f); const LADSPA_Data ch2f = LIMIT(*(ptr->ch2f),200.0f,1000.0f); const LADSPA_Data ch2g = LIMIT(*(ptr->ch2g),-50.0f,20.0f); const LADSPA_Data ch2b = LIMIT(*(ptr->ch2b),0.1f,5.0f); const LADSPA_Data ch3f = LIMIT(*(ptr->ch3f),400.0f,2800.0f); const LADSPA_Data ch3g = LIMIT(*(ptr->ch3g),-50.0f,20.0f); const LADSPA_Data ch3b = LIMIT(*(ptr->ch3b),0.1f,5.0f); const LADSPA_Data ch4f = LIMIT(*(ptr->ch4f),1000.0f,5000.0f); const LADSPA_Data ch4g = LIMIT(*(ptr->ch4g),-50.0f,20.0f); const LADSPA_Data ch4b = LIMIT(*(ptr->ch4b),0.1f,5.0f); const LADSPA_Data ch5f = LIMIT(*(ptr->ch5f),3000.0f,9000.0f); const LADSPA_Data ch5g = LIMIT(*(ptr->ch5g),-50.0f,20.0f); const LADSPA_Data ch5b = LIMIT(*(ptr->ch5b),0.1f,5.0f); const LADSPA_Data ch6f = LIMIT(*(ptr->ch6f),6000.0f,18000.0f); const LADSPA_Data ch6g = LIMIT(*(ptr->ch6g),-50.0f,20.0f); const LADSPA_Data ch6b = LIMIT(*(ptr->ch6b),0.1f,5.0f); const LADSPA_Data ch7f = LIMIT(*(ptr->ch7f),10000.0f,20000.0f); const LADSPA_Data ch7g = LIMIT(*(ptr->ch7g),-50.0f,20.0f); const LADSPA_Data ch7b = LIMIT(*(ptr->ch7b),0.1f,5.0f); const LADSPA_Data * input = ptr->input; LADSPA_Data * output = ptr->output; biquad * filters = ptr->filters; float fs = ptr->fs; unsigned long pos; float samp; if ((ch0f != ptr->old_ch0f) || (ch0g != ptr->old_ch0g) || (ch0b != ptr->old_ch0b)) { ptr->old_ch0f = ch0f; ptr->old_ch0g = ch0g; ptr->old_ch0b = ch0b; eq_set_params(&filters[0], ch0f, ch0g, ch0b, fs); } if ((ch1f != ptr->old_ch1f) || (ch1g != ptr->old_ch1g) || (ch1b != ptr->old_ch1b)) { ptr->old_ch1f = ch1f; ptr->old_ch1g = ch1g; ptr->old_ch1b = ch1b; eq_set_params(&filters[1], ch1f, ch1g, ch1b, fs); } if ((ch2f != ptr->old_ch2f) || (ch2g != ptr->old_ch2g) || (ch2b != ptr->old_ch2b)) { ptr->old_ch2f = ch2f; ptr->old_ch2g = ch2g; ptr->old_ch2b = ch2b; eq_set_params(&filters[2], ch2f, ch2g, ch2b, fs); } if ((ch3f != ptr->old_ch3f) || (ch3g != ptr->old_ch3g) || (ch3b != ptr->old_ch3b)) { ptr->old_ch3f = ch3f; ptr->old_ch3g = ch3g; ptr->old_ch3b = ch3b; eq_set_params(&filters[3], ch3f, ch3g, ch3b, fs); } if ((ch4f != ptr->old_ch4f) || (ch4g != ptr->old_ch4g) || (ch4b != ptr->old_ch4b)) { ptr->old_ch4f = ch4f; ptr->old_ch4g = ch4g; ptr->old_ch4b = ch4b; eq_set_params(&filters[4], ch4f, ch4g, ch4b, fs); } if ((ch5f != ptr->old_ch5f) || (ch5g != ptr->old_ch5g) || (ch5b != ptr->old_ch5b)) { ptr->old_ch5f = ch5f; ptr->old_ch5g = ch5g; ptr->old_ch5b = ch5b; eq_set_params(&filters[5], ch5f, ch5g, ch5b, fs); } if ((ch6f != ptr->old_ch6f) || (ch6g != ptr->old_ch6g) || (ch6b != ptr->old_ch6b)) { ptr->old_ch6f = ch6f; ptr->old_ch6g = ch6g; ptr->old_ch6b = ch6b; eq_set_params(&filters[6], ch6f, ch6g, ch6b, fs); } if ((ch7f != ptr->old_ch7f) || (ch7g != ptr->old_ch7g) || (ch7b != ptr->old_ch7b)) { ptr->old_ch7f = ch7f; ptr->old_ch7g = ch7g; ptr->old_ch7b = ch7b; eq_set_params(&filters[7], ch7f, ch7g, ch7b, fs); } for (pos = 0; pos < sample_count; pos++) { samp = input[pos]; if (ch0g != 0.0f) samp = biquad_run(&filters[0], samp); if (ch1g != 0.0f) samp = biquad_run(&filters[1], samp); if (ch2g != 0.0f) samp = biquad_run(&filters[2], samp); if (ch3g != 0.0f) samp = biquad_run(&filters[3], samp); if (ch4g != 0.0f) samp = biquad_run(&filters[4], samp); if (ch5g != 0.0f) samp = biquad_run(&filters[5], samp); if (ch6g != 0.0f) samp = biquad_run(&filters[6], samp); if (ch7g != 0.0f) samp = biquad_run(&filters[7], samp); output[pos] += ptr->run_adding_gain * samp; } }
static void runVynil(LV2_Handle instance, uint32_t sample_count) { Vynil *plugin_data = (Vynil *)instance; const float year = *(plugin_data->year); const float rpm = *(plugin_data->rpm); const float warp = *(plugin_data->warp); const float click = *(plugin_data->click); const float wear = *(plugin_data->wear); const float * const in_l = plugin_data->in_l; const float * const in_r = plugin_data->in_r; float * const out_l = plugin_data->out_l; float * const out_r = plugin_data->out_r; float fs = plugin_data->fs; float * buffer_m = plugin_data->buffer_m; float * buffer_s = plugin_data->buffer_s; unsigned int buffer_mask = plugin_data->buffer_mask; unsigned int buffer_pos = plugin_data->buffer_pos; float * click_buffer = plugin_data->click_buffer; fixp16 click_buffer_pos = plugin_data->click_buffer_pos; fixp16 click_buffer_omega = plugin_data->click_buffer_omega; float click_gain = plugin_data->click_gain; float phi = plugin_data->phi; unsigned int sample_cnt = plugin_data->sample_cnt; float def = plugin_data->def; float def_target = plugin_data->def_target; biquad * lowp_m = plugin_data->lowp_m; biquad * lowp_s = plugin_data->lowp_s; biquad * noise_filt = plugin_data->noise_filt; biquad * highp = plugin_data->highp; unsigned long pos; float deflec = def; float deflec_target = def_target; float src_m, src_s; /* angular velocity of platter * 16 */ const float omega = 960.0f / (rpm * fs); const float age = (2000 - year) * 0.01f; const unsigned int click_prob = (age*age*(float)RAND_MAX)/10 + click * 0.02 * RAND_MAX; const float noise_amp = (click + wear * 0.3f) * 0.12f + (1993.0f - year) * 0.0031f; const float bandwidth = (year - 1880.0f) * (rpm * 1.9f); const float noise_bandwidth = bandwidth * (0.25 - wear * 0.02) + click * 200.0 + 300.0; const float stereo = f_clamp((year - 1940.0f) * 0.02f, 0.0f, 1.0f); const float wrap_gain = age * 3.1f + 0.05f; const float wrap_bias = age * 0.1f; lp_set_params(lowp_m, bandwidth * (1.0 - wear * 0.86), 2.0, fs); lp_set_params(lowp_s, bandwidth * (1.0 - wear * 0.89), 2.0, fs); hp_set_params(highp, (2000-year) * 8.0, 1.5, fs); lp_set_params(noise_filt, noise_bandwidth, 4.0 + wear * 2.0, fs); for (pos = 0; pos < sample_count; pos++) { unsigned int o1, o2; float ofs; if ((sample_cnt & 15) == 0) { const float ang = phi * 2.0f * M_PI; const float w = warp * (2000.0f - year) * 0.01f; deflec_target = w*df(ang)*0.5f + w*w*df(2.0f*ang)*0.31f + w*w*w*df(3.0f*ang)*0.129f; phi += omega; while (phi > 1.0f) { phi -= 1.0f; } if ((unsigned int)rand() < click_prob) { click_buffer_omega.all = ((rand() >> 6) + 1000) * rpm; click_gain = noise_amp * 5.0f * noise(); } } deflec = deflec * 0.1f + deflec_target * 0.9f; /* matrix into mid_side representation (this is roughly what stereo * LPs do) */ buffer_m[buffer_pos] = in_l[pos] + in_r[pos]; buffer_s[buffer_pos] = in_l[pos] - in_r[pos]; /* cacluate the effects of the surface warping */ ofs = fs * 0.009f * deflec; o1 = f_round(floorf(ofs)); o2 = f_round(ceilf(ofs)); ofs -= o1; src_m = LIN_INTERP(ofs, buffer_m[(buffer_pos - o1 - 1) & buffer_mask], buffer_m[(buffer_pos - o2 - 1) & buffer_mask]); src_s = LIN_INTERP(ofs, buffer_s[(buffer_pos - o1 - 1) & buffer_mask], buffer_s[(buffer_pos - o2 - 1) & buffer_mask]); src_m = biquad_run(lowp_m, src_m + click_buffer[click_buffer_pos.part.in & (CLICK_BUF_SIZE - 1)] * click_gain); /* waveshaper */ src_m = LIN_INTERP(age, src_m, sinf(src_m * wrap_gain + wrap_bias)); /* output highpass */ src_m = biquad_run(highp, src_m) + biquad_run(noise_filt, noise()) * noise_amp + click_buffer[click_buffer_pos.part.in & (CLICK_BUF_SIZE - 1)] * click_gain * 0.5f; /* stereo seperation filter */ src_s = biquad_run(lowp_s, src_s) * stereo; buffer_write(out_l[pos], (src_s + src_m) * 0.5f); buffer_write(out_r[pos], (src_m - src_s) * 0.5f); /* roll buffer indexes */ buffer_pos = (buffer_pos + 1) & buffer_mask; click_buffer_pos.all += click_buffer_omega.all; if (click_buffer_pos.part.in >= CLICK_BUF_SIZE) { click_buffer_pos.all = 0; click_buffer_omega.all = 0; } sample_cnt++; }