Carla/source/modules/native-plugins/nekobi/nekobee-src/nekobee_voice_render.c

/* nekobee DSSI software synthesizer plugin
 */

#define _BSD_SOURCE    1
#define _SVID_SOURCE   1
#define _ISOC99_SOURCE 1

#include <math.h>

#include "nekobee.h"
#include "nekobee_synth.h"
#include "nekobee_voice.h"

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#define M_2PI_F (2.0f * (float)M_PI)
#define M_PI_F (float)M_PI

#define VCF_FREQ_MAX  (0.825f)    /* original filters only stable to this frequency */

static int   tables_initialized = 0;

float        nekobee_pitch[128];

#define pitch_ref_note 69

#define volume_to_amplitude_scale 128

static float volume_to_amplitude_table[4 + volume_to_amplitude_scale + 2];

static float velocity_to_attenuation[128];

static float qdB_to_amplitude_table[4 + 256 + 0];

void
nekobee_init_tables(void)
{
    int i;
    float pexp;
    float volume, volume_exponent;
    float ol, amp;

    if (tables_initialized)
        return;

    /* MIDI note to pitch */
    for (i = 0; i < 128; ++i) {
        pexp = (float)(i - pitch_ref_note) / 12.0f;
        nekobee_pitch[i] = powf(2.0f, pexp);
    }

    /* volume to amplitude
     *
     * This generates a curve which is:
     *  volume_to_amplitude_table[128 + 4] = 0.25 * 3.16...   ~=  -2dB
     *  volume_to_amplitude_table[64 + 4]  = 0.25 * 1.0       ~= -12dB
     *  volume_to_amplitude_table[32 + 4]  = 0.25 * 0.316...  ~= -22dB
     *  volume_to_amplitude_table[16 + 4]  = 0.25 * 0.1       ~= -32dB
     *   etc.
     */
    volume_exponent = 1.0f / (2.0f * log10f(2.0f));
    for (i = 0; i <= volume_to_amplitude_scale; i++) {
        volume = (float)i / (float)volume_to_amplitude_scale;
        volume_to_amplitude_table[i + 4] = powf(2.0f * volume, volume_exponent) / 4.0f;
    }
    volume_to_amplitude_table[ -1 + 4] = 0.0f;
    volume_to_amplitude_table[129 + 4] = volume_to_amplitude_table[128 + 4];

    /* velocity to attenuation
     *
     * Creates the velocity to attenuation lookup table, for converting
     * velocities [1, 127] to full-velocity-sensitivity attenuation in
     * quarter decibels.  Modeled after my TX-7's velocity response.*/
    velocity_to_attenuation[0] = 253.9999f;
    for (i = 1; i < 127; i++) {
        if (i >= 10) {
            ol = (powf(((float)i / 127.0f), 0.32f) - 1.0f) * 100.0f;
            amp = powf(2.0f, ol / 8.0f);
        } else {
            ol = (powf(((float)10 / 127.0f), 0.32f) - 1.0f) * 100.0f;
            amp = powf(2.0f, ol / 8.0f) * (float)i / 10.0f;
        }
        velocity_to_attenuation[i] = log10f(amp) * -80.0f;
    }
    velocity_to_attenuation[127] = 0.0f;

    /* quarter-decibel attenuation to amplitude */
    qdB_to_amplitude_table[-1 + 4] = 1.0f;
    for (i = 0; i <= 255; i++) {
        qdB_to_amplitude_table[i + 4] = powf(10.0f, (float)i / -80.0f);
    }

    tables_initialized = 1;
}

static inline float
volume(float level)
{
    unsigned char segment;
    float fract;

    level *= (float)volume_to_amplitude_scale;
    segment = lrintf(level - 0.5f);
    fract = level - (float)segment;

    return volume_to_amplitude_table[segment + 4] + fract *
               (volume_to_amplitude_table[segment + 5] -
                volume_to_amplitude_table[segment + 4]);
}

static inline float
qdB_to_amplitude(float qdB)
{
    int i = lrintf(qdB - 0.5f);
    float f = qdB - (float)i;
    return qdB_to_amplitude_table[i + 4] + f *
           (qdB_to_amplitude_table[i + 5] -
            qdB_to_amplitude_table[i + 4]);
}

void blosc_place_step_dd(float *buffer, int index, float phase, float w, float scale){
    float r;
    int i;

    r = MINBLEP_PHASES * phase / w;
    i = lrintf(r - 0.5f);
    r -= (float)i;
    i &= MINBLEP_PHASE_MASK;  /* port changes can cause i to be out-of-range */
    /* This would be better than the above, but more expensive:
     *  while (i < 0) {
     *    i += MINBLEP_PHASES;
     *    index++;
     *  }
     */

    while (i < MINBLEP_PHASES * STEP_DD_PULSE_LENGTH) {
        buffer[index] += scale * (step_dd_table[i].value + r * step_dd_table[i].delta);
        i += MINBLEP_PHASES;
        index++;
    }
}


void vco(unsigned long sample_count, nekobee_voice_t *voice, struct blosc *osc,
                int index, float w)

{
	unsigned long sample;
	float pos = osc->pos;
	float pw, gain, halfgain, out;
	pw=0.46f;
	gain=1.0f;
	halfgain=gain*0.5f;
	int   bp_high = osc->bp_high;
	out=(bp_high ? halfgain : -halfgain);

		switch (osc->waveform)
		{
		default:
		case 0: {

			for (sample = 0; sample < sample_count; sample++) {
		pos += w;
        if (bp_high) {
            if (pos >= pw) {
                blosc_place_step_dd(voice->osc_audio, index, pos - pw, w, -gain);
                bp_high = 0;
                out = -halfgain;
            }
            if (pos >= 1.0f) {
                pos -= 1.0f;
                blosc_place_step_dd(voice->osc_audio, index, pos, w, gain);
                bp_high = 1;
                out = halfgain;
            }
			} else {
            if (pos >= 1.0f) {
                pos -= 1.0f;
                blosc_place_step_dd(voice->osc_audio, index, pos, w, gain);
                bp_high = 1;
                out = halfgain;
            }

            if (bp_high && pos >= pw) {
                blosc_place_step_dd(voice->osc_audio, index, pos - pw, w, -gain);
                bp_high = 0;
                out = -halfgain;
            }
        }

        voice->osc_audio[index + DD_SAMPLE_DELAY] += out;

        index++;
    }

    osc->pos = pos;
    osc->bp_high = bp_high;
		break;
	  }
		case 1:   			// sawtooth wave
		{
			  for (sample=0; sample < sample_count; sample++) {
        	  pos += w;
              if (pos >= 1.0f) {
				  pos -= 1.0f;
				 blosc_place_step_dd(voice->osc_audio, index, pos, w, gain);
			  }
              voice->osc_audio[index + DD_SAMPLE_DELAY] += gain * (0.5f - pos);

			  index++;
		  }

		  break;
	  }

	}

        osc->pos=pos;
}

static inline void
vcf_4pole(nekobee_voice_t *voice, unsigned long sample_count,
          float *in, float *out, float *cutoff, float qres, float *amp)
{
    unsigned long sample;
    float freqcut, freqcut2, highpass,
          delay1 = voice->delay1,
          delay2 = voice->delay2,
          delay3 = voice->delay3,
          delay4 = voice->delay4;

    qres = 2.0f - qres * 1.995f;

    for (sample = 0; sample < sample_count; sample++) {

        /* Hal Chamberlin's state variable filter */

        freqcut = cutoff[sample] * 2.0f;
        freqcut2 = cutoff[sample] * 4.0f;


        if (freqcut > VCF_FREQ_MAX) freqcut = VCF_FREQ_MAX;
        if (freqcut2 > VCF_FREQ_MAX) freqcut2 = VCF_FREQ_MAX;

        delay2 = delay2 + freqcut * delay1;             /* delay2/4 = lowpass output */
        highpass = in[sample] - delay2 - qres * delay1;
        delay1 = freqcut * highpass + delay1;           /* delay1/3 = bandpass output */

        delay4 = delay4 + freqcut2 * delay3;
        highpass = delay2 - delay4 - qres * delay3;
        delay3 = freqcut2 * highpass + delay3;

        /* mix filter output into output buffer */
        out[sample] += 0.1*atan(3*delay4 * amp[sample]);
    }

    voice->delay1 = delay1;
    voice->delay2 = delay2;
    voice->delay3 = delay3;
    voice->delay4 = delay4;
    voice->c5 = 0.0f;
}


/*
 * nekobee_voice_render
 *
 * generate the actual sound data for this voice
 */
void
nekobee_voice_render(nekobee_synth_t *synth, nekobee_voice_t *voice,
                    float *out, unsigned long sample_count,
                    int do_control_update)
{
    unsigned long sample;

    /* state variables saved in voice */
    float         lfo_pos      = voice->lfo_pos,
                  vca_eg       = voice->vca_eg,
                  vcf_eg       = voice->vcf_eg;
    unsigned char vca_eg_phase = voice->vca_eg_phase,
                  vcf_eg_phase = voice->vcf_eg_phase;
    int           osc_index    = voice->osc_index;

    /* temporary variables used in calculating voice */
    float fund_pitch;
    float deltat = synth->deltat;
    float freq, cutoff, vcf_amt;
    float vcf_acc_amt;

    /* set up synthesis variables from patch */
    float         omega;
    float         vca_eg_amp = qdB_to_amplitude(velocity_to_attenuation[voice->velocity] * 0);

    float         vca_eg_rate_level[3], vca_eg_one_rate[3];
    float         vcf_eg_amp = qdB_to_amplitude(velocity_to_attenuation[voice->velocity] * 0);

    float         vcf_eg_rate_level[3], vcf_eg_one_rate[3];
    float         qres = synth->resonance;
    float         vol_out = volume(synth->volume);

    float velocity = (voice->velocity);

    float vcf_egdecay = synth->decay;

    fund_pitch = 0.1f*voice->target_pitch  +0.9 * voice->prev_pitch;    /* glide */

    if (do_control_update) {
        voice->prev_pitch = fund_pitch; /* save pitch for next time */
    }

    fund_pitch *= 440.0f;

    omega = synth->tuning * fund_pitch;

    // if we have triggered ACCENT
    // we need a shorter decay
    // we should probably have something like this in the note on code
    // that could trigger an ACCENT light
    if (velocity>90) {
            vcf_egdecay=.0005;
    }

    // VCA - In a real 303, it is set for around 2 seconds
    vca_eg_rate_level[0] = 0.1f * vca_eg_amp;	// instant on attack
    vca_eg_one_rate[0] = 0.9f;					// very fast
    vca_eg_rate_level[1] = 0.0f; 					// sustain is zero
    vca_eg_one_rate[1] = 1.0f - 0.00001f;		// decay time is very slow
    vca_eg_rate_level[2] = 0.0f;				// decays to zero
    vca_eg_one_rate[2] =  0.975f; 					// very fast release

    // VCF - funny things go on with the accent

    vcf_eg_rate_level[0] = 0.1f * vcf_eg_amp;
    vcf_eg_one_rate[0] = 1-0.1f; //0.9f;
    vcf_eg_rate_level[1] = 0.0f; // vcf_egdecay * *(synth->vcf_eg_sustain_level) * vcf_eg_amp;
    vcf_eg_one_rate[1] = 1.0f - vcf_egdecay;
    vcf_eg_rate_level[2] = 0.0f;
    vcf_eg_one_rate[2] = 0.9995f; // 1.0f - *(synth->vcf_eg_release_time);

    vca_eg_amp *= 0.99f;
    vcf_eg_amp *= 0.99f;

    freq = M_PI_F * deltat * fund_pitch * synth->mod_wheel;  /* now (0 to 1) * pi */

    cutoff = 0.008f * synth->cutoff;

    // 303 always has slight VCF mod
    vcf_amt = 0.05f+(synth->envmod*0.75);

    /* copy some things so oscillator functions can see them */
    voice->osc1.waveform = lrintf(synth->waveform);

    // work out how much the accent will affect the filter
    vcf_acc_amt=.333f+ (synth->resonance/1.5f);

    for (sample = 0; sample < sample_count; sample++) {
        vca_eg = vca_eg_rate_level[vca_eg_phase] + vca_eg_one_rate[vca_eg_phase] * vca_eg;
        vcf_eg = vcf_eg_rate_level[vcf_eg_phase] + vcf_eg_one_rate[vcf_eg_phase] * vcf_eg;

        voice->freqcut_buf[sample] = (cutoff + (vcf_amt * vcf_eg/2.0f)  + (synth->vcf_accent * synth->accent*0.5f));

        voice->vca_buf[sample] = vca_eg * vol_out*(1.0f + synth->accent*synth->vca_accent);

        if (!vca_eg_phase && vca_eg > vca_eg_amp) vca_eg_phase = 1;  /* flip from attack to decay */
        if (!vcf_eg_phase && vcf_eg > vcf_eg_amp) vcf_eg_phase = 1;  /* flip from attack to decay */
    }

    // oscillator
    vco(sample_count, voice, &voice->osc1, osc_index, deltat * omega);

    // VCF and VCA
    vcf_4pole(voice, sample_count, voice->osc_audio + osc_index, out, voice->freqcut_buf, qres, voice->vca_buf);

    osc_index += sample_count;

    if (do_control_update) {
        /* do those things should be done only once per control-calculation
         * interval ("nugget"), such as voice check-for-dead, pitch envelope
         * calculations, volume envelope phase transition checks, etc. */
        /* check if we've decayed to nothing, turn off voice if so */
        if (vca_eg_phase == 2 && voice->vca_buf[sample_count - 1] < 6.26e-6f) {
            // sound has completed its release phase (>96dB below volume '5' max)
            XDB_MESSAGE(XDB_NOTE, " nekobee_voice_render check for dead: killing note id %d\n", voice->note_id);
            nekobee_voice_off(voice);
            return; // we're dead now, so return
        }

        /* already saved prev_pitch above */

        /* check oscillator audio buffer index, shift buffer if necessary */
        if (osc_index > MINBLEP_BUFFER_LENGTH - (XSYNTH_NUGGET_SIZE + LONGEST_DD_PULSE_LENGTH)) {
            memcpy(voice->osc_audio, voice->osc_audio + osc_index,
                   LONGEST_DD_PULSE_LENGTH * sizeof (float));
            memset(voice->osc_audio + LONGEST_DD_PULSE_LENGTH, 0,
                   (MINBLEP_BUFFER_LENGTH - LONGEST_DD_PULSE_LENGTH) * sizeof (float));
            osc_index = 0;
        }
    }

    /* save things for next time around */
    voice->lfo_pos      = lfo_pos;
    voice->vca_eg       = vca_eg;
    voice->vca_eg_phase = vca_eg_phase;
    voice->vcf_eg       = vcf_eg;
    voice->vcf_eg_phase = vcf_eg_phase;
    voice->osc_index    = osc_index;

    return;
    (void)freq;
    (void)vcf_acc_amt;
}