diff --git a/libs/plugins/reasonablesynth.lv2/rsynth.c b/libs/plugins/reasonablesynth.lv2/rsynth.c index 6f8c845145..36b5cda704 100644 --- a/libs/plugins/reasonablesynth.lv2/rsynth.c +++ b/libs/plugins/reasonablesynth.lv2/rsynth.c @@ -22,9 +22,9 @@ #endif #include +#include #include #include -#include #ifndef COMPILER_MSVC #include @@ -37,12 +37,12 @@ #endif #ifndef MIN -#define MIN(A, B) ( (A) < (B) ? (A) : (B) ) +#define MIN(A, B) ((A) < (B) ? (A) : (B)) #endif /* internal MIDI event abstraction */ enum RMIDI_EV_TYPE { - INVALID=0, + INVALID = 0, NOTE_ON, NOTE_OFF, PROGRAM_CHANGE, @@ -71,29 +71,29 @@ typedef struct { } ADSRcfg; typedef struct _RSSynthChannel { - uint32_t keycomp; - uint32_t adsr_cnt[128]; - float adsr_amp[128]; - float phase[128]; // various use, zero'ed on note-on - int8_t miditable[128]; // internal, note-on/off velocity - int8_t midimsgs [128]; // internal, note-off + on in same cycle, sustained-off - int8_t sustain; // sustain pedal pressed - ADSRcfg adsr; - void (*synthesize) (struct _RSSynthChannel* sc, - const uint8_t note, const float vol, const float pc, - const size_t n_samples, float* left, float* right); + uint32_t keycomp; + uint32_t adsr_cnt[128]; + float adsr_amp[128]; + float phase[128]; // various use, zero'ed on note-on + int8_t miditable[128]; // internal, note-on/off velocity + int8_t midimsgs[128]; // internal, note-off + on in same cycle, sustained-off + int8_t sustain; // sustain pedal pressed + ADSRcfg adsr; + void (*synthesize) (struct _RSSynthChannel* sc, + const uint8_t note, const float vol, const float pc, + const size_t n_samples, float* left, float* right); } RSSynthChannel; typedef void (*SynthFunction) (RSSynthChannel* sc, - const uint8_t note, - const float vol, - const float pc, - const size_t n_samples, + const uint8_t note, + const float vol, + const float pc, + const size_t n_samples, float* left, float* right); typedef struct { uint32_t boffset; - float buf [2][BUFFER_SIZE_SAMPLES]; + float buf[2][BUFFER_SIZE_SAMPLES]; RSSynthChannel sc[16]; float freqs[128]; float kcgain; @@ -113,7 +113,7 @@ typedef struct { * @param svol sustain volume level [0..1] */ static void -init_adsr (ADSRcfg *adsr, const double rate, +init_adsr (ADSRcfg* adsr, const double rate, const uint32_t a, const uint32_t d, const uint32_t r, const float avol, const float svol) { @@ -123,11 +123,11 @@ init_adsr (ADSRcfg *adsr, const double rate, adsr->tme[1] = d * rate / 1000.0; adsr->tme[2] = r * rate / 1000.0; - assert(adsr->tme[0] > 32); - assert(adsr->tme[1] > 32); - assert(adsr->tme[2] > 32); - assert(adsr->vol[0] >=0 && adsr->vol[1] <= 1.0); - assert(adsr->vol[1] >=0 && adsr->vol[1] <= 1.0); + assert (adsr->tme[0] > 32); + assert (adsr->tme[1] > 32); + assert (adsr->tme[2] > 32); + assert (adsr->vol[0] >= 0 && adsr->vol[1] <= 1.0); + assert (adsr->vol[1] >= 0 && adsr->vol[1] <= 1.0); adsr->off[0] = adsr->tme[0]; adsr->off[1] = adsr->tme[1] + adsr->off[0]; @@ -136,7 +136,7 @@ init_adsr (ADSRcfg *adsr, const double rate, /* calculate per-sample, per-key envelope */ static inline float -adsr_env(RSSynthChannel *sc, const uint8_t note) +adsr_env (RSSynthChannel* sc, const uint8_t note) { if (sc->adsr_cnt[note] < sc->adsr.off[0]) { // attack @@ -146,10 +146,9 @@ adsr_env(RSSynthChannel *sc, const uint8_t note) return sc->adsr.vol[0]; } else { const float d = sc->adsr.vol[0] - sc->adsr_amp[note]; - return sc->adsr_amp[note] + (p / (float) sc->adsr.tme[0]) * d; + return sc->adsr_amp[note] + (p / (float)sc->adsr.tme[0]) * d; } - } - else if (sc->adsr_cnt[note] < sc->adsr.off[1]) { + } else if (sc->adsr_cnt[note] < sc->adsr.off[1]) { // decay const uint32_t p = ++sc->adsr_cnt[note] - sc->adsr.off[0]; if (p == sc->adsr.tme[1]) { @@ -157,14 +156,12 @@ adsr_env(RSSynthChannel *sc, const uint8_t note) return sc->adsr.vol[1]; } else { const float d = sc->adsr.vol[1] - sc->adsr_amp[note]; - return sc->adsr_amp[note] + (p / (float) sc->adsr.tme[1]) * d; + return sc->adsr_amp[note] + (p / (float)sc->adsr.tme[1]) * d; } - } - else if (sc->adsr_cnt[note] == sc->adsr.off[1]) { + } else if (sc->adsr_cnt[note] == sc->adsr.off[1]) { // sustain return sc->adsr.vol[1]; - } - else if (sc->adsr_cnt[note] < sc->adsr.off[2]) { + } else if (sc->adsr_cnt[note] < sc->adsr.off[2]) { // release const uint32_t p = ++sc->adsr_cnt[note] - sc->adsr.off[1]; if (p == sc->adsr.tme[2]) { @@ -172,10 +169,9 @@ adsr_env(RSSynthChannel *sc, const uint8_t note) return 0; } else { const float d = 0 - sc->adsr_amp[note]; - return sc->adsr_amp[note] + (p / (float) sc->adsr.tme[2]) * d; + return sc->adsr_amp[note] + (p / (float)sc->adsr.tme[2]) * d; } - } - else { + } else { sc->adsr_cnt[note] = 0; return 0; } @@ -189,109 +185,107 @@ synthesize_sineP (RSSynthChannel* sc, const size_t n_samples, float* left, float* right) { size_t i; - float phase = sc->phase[note]; + float phase = sc->phase[note]; - for (i=0; i < n_samples; ++i) { - float env = adsr_env(sc, note); - if (sc->adsr_cnt[note] == 0) break; + for (i = 0; i < n_samples; ++i) { + float env = adsr_env (sc, note); + if (sc->adsr_cnt[note] == 0) { + break; + } const float amp = vol * env; if (amp > 1e-10) { - left[i] += amp * sinf(2.0 * M_PI * phase); - left[i] += .300 * amp * sinf(2.0 * M_PI * phase * 2.0); - left[i] += .150 * amp * sinf(2.0 * M_PI * phase * 3.0); - left[i] += .080 * amp * sinf(2.0 * M_PI * phase * 4.0); - //left[i] -= .007 * amp * sinf(2.0 * M_PI * phase * 5.0); - //left[i] += .010 * amp * sinf(2.0 * M_PI * phase * 6.0); - left[i] += .020 * amp * sinf(2.0 * M_PI * phase * 7.0); + left[i] += amp * sinf (2.0 * M_PI * phase); + left[i] += .300 * amp * sinf (2.0 * M_PI * phase * 2.0); + left[i] += .150 * amp * sinf (2.0 * M_PI * phase * 3.0); + left[i] += .080 * amp * sinf (2.0 * M_PI * phase * 4.0); + //left[i] -= .007 * amp * sinf(2.0 * M_PI * phase * 5.0); + //left[i] += .010 * amp * sinf(2.0 * M_PI * phase * 6.0); + left[i] += .020 * amp * sinf (2.0 * M_PI * phase * 7.0); phase += fq; - right[i] += amp * sinf(2.0 * M_PI * phase); - right[i] += .300 * amp * sinf(2.0 * M_PI * phase * 2.0); - right[i] += .150 * amp * sinf(2.0 * M_PI * phase * 3.0); - right[i] -= .080 * amp * sinf(2.0 * M_PI * phase * 4.0); + right[i] += amp * sinf (2.0 * M_PI * phase); + right[i] += .300 * amp * sinf (2.0 * M_PI * phase * 2.0); + right[i] += .150 * amp * sinf (2.0 * M_PI * phase * 3.0); + right[i] -= .080 * amp * sinf (2.0 * M_PI * phase * 4.0); //right[i] += .007 * amp * sinf(2.0 * M_PI * phase * 5.0); //right[i] += .010 * amp * sinf(2.0 * M_PI * phase * 6.0); - right[i] -= .020 * amp * sinf(2.0 * M_PI * phase * 7.0); + right[i] -= .020 * amp * sinf (2.0 * M_PI * phase * 7.0); } else { phase += fq; } - if (phase > 1.0) phase -= 2.0; + if (phase > 1.0) + phase -= 2.0; } sc->phase[note] = phase; } -static const ADSRcfg piano_adsr = {{ 5, 800, 100}, { 1.0, 0.0}, {0, 0, 0}}; +static const ADSRcfg piano_adsr = { { 5, 800, 100 }, { 1.0, 0.0 }, { 0, 0, 0 } }; /*****************************************************************************/ - /* process note - move through ADSR states, count active keys,.. */ static void -process_key (void *synth, +process_key (void* synth, const uint8_t chn, const uint8_t note, const size_t n_samples, - float *left, float *right) + float* left, float* right) { - RSSynthesizer* rs = (RSSynthesizer*)synth; - RSSynthChannel* sc = &rs->sc[chn]; - const int8_t vel = sc->miditable[note]; - const int8_t msg = sc->midimsgs[note]; - const float vol = /* master_volume */ 0.1f * abs(vel) / 127.f; - const float phase = sc->phase[note]; - const int8_t sus = sc->sustain; + RSSynthesizer* rs = (RSSynthesizer*)synth; + RSSynthChannel* sc = &rs->sc[chn]; + const int8_t vel = sc->miditable[note]; + const int8_t msg = sc->midimsgs[note]; + const float vol = /* master_volume */ 0.1f * abs (vel) / 127.f; + const float phase = sc->phase[note]; + const int8_t sus = sc->sustain; sc->midimsgs[note] &= ~3; if (phase == -10 && vel > 0) { // new note on sc->midimsgs[note] &= ~4; - assert(sc->adsr_cnt[note] == 0); + assert (sc->adsr_cnt[note] == 0); sc->adsr_amp[note] = 0; sc->adsr_cnt[note] = 0; - sc->phase[note] = 0; + sc->phase[note] = 0; sc->keycomp++; //printf("[On] Now %d keys active on chn %d\n", sc->keycomp, chn); - } - else if (phase >= -1.0 && phase <= 1.0 && vel > 0) { + } else if (phase >= -1.0 && phase <= 1.0 && vel > 0) { // sustain note or re-start note while adsr in progress: if (sc->adsr_cnt[note] > sc->adsr.off[1] || msg == 3 || msg == 5 || msg == 7) { sc->midimsgs[note] &= ~4; // x-fade to attack - sc->adsr_amp[note] = adsr_env(sc, note); + sc->adsr_amp[note] = adsr_env (sc, note); sc->adsr_cnt[note] = 0; } - } - else if (phase >= -1.0 && phase <= 1.0 && vel < 0) { + } else if (phase >= -1.0 && phase <= 1.0 && vel < 0) { sc->midimsgs[note] |= 4; // note off if (sc->adsr_cnt[note] <= sc->adsr.off[1] && !sus) { if (sc->adsr_cnt[note] != sc->adsr.off[1]) { // x-fade to release - sc->adsr_amp[note] = adsr_env(sc, note); + sc->adsr_amp[note] = adsr_env (sc, note); } sc->adsr_cnt[note] = sc->adsr.off[1] + 1; - } - else if (sus && sc->adsr_cnt[note] == sc->adsr.off[1]) { + } else if (sus && sc->adsr_cnt[note] == sc->adsr.off[1]) { sc->adsr_cnt[note] = sc->adsr.off[1] + 1; } - } - else { + } else { //printf("FORCE NOTE OFF: %d %d\n", vel, sus); /* note-on + off in same cycle */ sc->miditable[note] = 0; - sc->adsr_cnt[note] = 0; - sc->phase[note] = -10; + sc->adsr_cnt[note] = 0; + sc->phase[note] = -10; return; } //printf("NOTE: %d (%d %d %d)\n", sc->adsr_cnt[note], sc->adsr.off[0], sc->adsr.off[1], sc->adsr.off[2]); // synthesize actual sound - sc->synthesize(sc, note, vol, rs->freqs[note], n_samples, left, right); + sc->synthesize (sc, note, vol, rs->freqs[note], n_samples, left, right); if (sc->adsr_cnt[note] == 0) { //printf("Note %d,%d released\n", chn, note); - sc->midimsgs[note] = 0; + sc->midimsgs[note] = 0; sc->miditable[note] = 0; - sc->adsr_amp[note] = 0; - sc->phase[note] = -10; + sc->adsr_amp[note] = 0; + sc->phase[note] = -10; sc->keycomp--; //printf("[off] Now %d keys active on chn %d\n", sc->keycomp, chn); } @@ -299,29 +293,32 @@ process_key (void *synth, /* synthesize a BUFFER_SIZE_SAMPLES's of audio-data */ static void -synth_fragment (void *synth, const size_t n_samples, float *left, float *right) +synth_fragment (void* synth, const size_t n_samples, float* left, float* right) { RSSynthesizer* rs = (RSSynthesizer*)synth; - memset (left, 0, n_samples * sizeof(float)); - memset (right, 0, n_samples * sizeof(float)); + memset (left, 0, n_samples * sizeof (float)); + memset (right, 0, n_samples * sizeof (float)); uint8_t keycomp = 0; - int c,k; - size_t i; + int c, k; + size_t i; - for (c=0; c < 16; ++c) { - for (k=0; k < 128; ++k) { - if (rs->sc[c].miditable[k] == 0) continue; - process_key(synth, c, k, n_samples, left, right); + for (c = 0; c < 16; ++c) { + for (k = 0; k < 128; ++k) { + if (rs->sc[c].miditable[k] == 0) { + continue; + } + process_key (synth, c, k, n_samples, left, right); } keycomp += rs->sc[c].keycomp; } #if 1 // key-compression float kctgt = 8.0 / (float)(keycomp + 7.0); - if (kctgt < .5) kctgt = .5; + if (kctgt < .5) kctgt = .5; if (kctgt > 1.0) kctgt = 1.0; + const float _w = rs->kcfilt; - for (i=0; i < n_samples; ++i) { + for (i = 0; i < n_samples; ++i) { rs->kcgain += _w * (kctgt - rs->kcgain); left[i] *= rs->kcgain; right[i] *= rs->kcgain; @@ -331,7 +328,7 @@ synth_fragment (void *synth, const size_t n_samples, float *left, float *right) } static void -synth_reset_channel(RSSynthChannel* sc) +synth_reset_channel (RSSynthChannel* sc) { int k; for (k = 0; k < 128; ++k) { @@ -345,25 +342,25 @@ synth_reset_channel(RSSynthChannel* sc) } static void -synth_reset(void *synth) +synth_reset (void* synth) { RSSynthesizer* rs = (RSSynthesizer*)synth; - int c; - for (c=0; c < 16; ++c) { - synth_reset_channel(&(rs->sc[c])); + int c; + for (c = 0; c < 16; ++c) { + synth_reset_channel (&(rs->sc[c])); } rs->kcgain = 0; } static void -synth_load (RSSynthChannel *sc, const double rate, - SynthFunction synthesize, - ADSRcfg const * const adsr) +synth_load (RSSynthChannel* sc, const double rate, + SynthFunction synthesize, + ADSRcfg const* const adsr) { - synth_reset_channel(sc); - init_adsr(&sc->adsr, rate, - adsr->tme[0], adsr->tme[1], adsr->tme[2], - adsr->vol[0], adsr->vol[1]); + synth_reset_channel (sc); + init_adsr (&sc->adsr, rate, + adsr->tme[0], adsr->tme[1], adsr->tme[2], + adsr->vol[0], adsr->vol[1]); sc->synthesize = synthesize; } @@ -371,10 +368,10 @@ synth_load (RSSynthChannel *sc, const double rate, * internal abstraction of MIDI data handling */ static void -synth_process_midi_event(void *synth, struct rmidi_event_t *ev) +synth_process_midi_event (void* synth, struct rmidi_event_t* ev) { RSSynthesizer* rs = (RSSynthesizer*)synth; - switch(ev->type) { + switch (ev->type) { case NOTE_ON: rs->sc[ev->channel].midimsgs[ev->d.tone.note] |= 1; if (rs->sc[ev->channel].miditable[ev->d.tone.note] <= 0) @@ -392,12 +389,12 @@ synth_process_midi_event(void *synth, struct rmidi_event_t *ev) /* 0x00 and 0x20 are used for BANK select */ } else if (ev->d.control.param == 64) { /* damper pedal*/ - rs->sc[ev->channel].sustain = ev->d.control.value < 64 ? 0: 1; + rs->sc[ev->channel].sustain = ev->d.control.value < 64 ? 0 : 1; } else if (ev->d.control.param == 121) { /* reset all controllers */ } else if (ev->d.control.param == 120 || ev->d.control.param == 123) { /* Midi panic: 120: all sound off, 123: all notes off*/ - synth_reset_channel(&(rs->sc[ev->channel])); + synth_reset_channel (&(rs->sc[ev->channel])); } else if (ev->d.control.param >= 120) { /* params 122-127 are reserved - skip them. */ } @@ -422,23 +419,23 @@ synth_process_midi_event(void *synth, struct rmidi_event_t *ev) * @return end of buffer (written + nframes) */ static uint32_t -synth_sound (void *synth, uint32_t written, const uint32_t nframes, float **out) +synth_sound (void* synth, uint32_t written, const uint32_t nframes, float** out) { RSSynthesizer* rs = (RSSynthesizer*)synth; while (written < nframes) { uint32_t nremain = nframes - written; - if (rs->boffset >= BUFFER_SIZE_SAMPLES) { - const uint32_t tosynth = MIN(BUFFER_SIZE_SAMPLES, nremain); - rs->boffset = BUFFER_SIZE_SAMPLES - tosynth; - synth_fragment(rs, tosynth, &(rs->buf[0][rs->boffset]), &(rs->buf[1][rs->boffset])); + if (rs->boffset >= BUFFER_SIZE_SAMPLES) { + const uint32_t tosynth = MIN (BUFFER_SIZE_SAMPLES, nremain); + rs->boffset = BUFFER_SIZE_SAMPLES - tosynth; + synth_fragment (rs, tosynth, &(rs->buf[0][rs->boffset]), &(rs->buf[1][rs->boffset])); } - uint32_t nread = MIN(nremain, (BUFFER_SIZE_SAMPLES - rs->boffset)); + uint32_t nread = MIN (nremain, (BUFFER_SIZE_SAMPLES - rs->boffset)); - memcpy(&out[0][written], &rs->buf[0][rs->boffset], nread*sizeof(float)); - memcpy(&out[1][written], &rs->buf[1][rs->boffset], nread*sizeof(float)); + memcpy (&out[0][written], &rs->buf[0][rs->boffset], nread * sizeof (float)); + memcpy (&out[1][written], &rs->buf[1][rs->boffset], nread * sizeof (float)); written += nread; rs->boffset += nread; @@ -454,83 +451,89 @@ synth_sound (void *synth, uint32_t written, const uint32_t nframes, float **out) * @param size number of bytes in the midi-message */ static void -synth_parse_midi (void *synth, const uint8_t *data, const size_t size) +synth_parse_midi (void* synth, const uint8_t* data, const size_t size) { - if (size < 2 || size > 3) return; + if (size < 2 || size > 3) + return; // All messages need to be 3 bytes; except program-changes: 2bytes. - if (size == 2 && (data[0] & 0xf0) != 0xC0) return; + if (size == 2 && (data[0] & 0xf0) != 0xC0) + return; struct rmidi_event_t ev; - ev.channel = data[0]&0x0f; + ev.channel = data[0] & 0x0f; switch (data[0] & 0xf0) { case 0x80: - ev.type=NOTE_OFF; - ev.d.tone.note=data[1]&0x7f; - ev.d.tone.velocity=data[2]&0x7f; + ev.type = NOTE_OFF; + ev.d.tone.note = data[1] & 0x7f; + ev.d.tone.velocity = data[2] & 0x7f; break; case 0x90: - ev.type=NOTE_ON; - ev.d.tone.note=data[1]&0x7f; - ev.d.tone.velocity=data[2]&0x7f; + ev.type = NOTE_ON; + ev.d.tone.note = data[1] & 0x7f; + ev.d.tone.velocity = data[2] & 0x7f; if (ev.d.tone.velocity == 0) { - ev.type=NOTE_OFF; + ev.type = NOTE_OFF; } break; case 0xB0: - ev.type=CONTROL_CHANGE; - ev.d.control.param=data[1]&0x7f; - ev.d.control.value=data[2]&0x7f; + ev.type = CONTROL_CHANGE; + ev.d.control.param = data[1] & 0x7f; + ev.d.control.value = data[2] & 0x7f; break; case 0xC0: - ev.type=PROGRAM_CHANGE; - ev.d.control.value=data[1]&0x7f; + ev.type = PROGRAM_CHANGE; + ev.d.control.value = data[1] & 0x7f; break; default: return; } - synth_process_midi_event(synth, &ev); + synth_process_midi_event (synth, &ev); } -static const uint8_t jingle[] = { 71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,71 ,69 ,69 ,71 ,69 ,74 ,71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,74 ,74 ,72 ,69 ,67 ,62 ,62 ,71 ,69 ,67 ,62 ,62 ,62 ,62 ,71 ,69 ,67 ,64 ,64 ,64 ,72 ,71 ,69 ,66 ,74 ,76 ,74 ,72 ,69 ,71 ,62 ,62 ,71 ,69 ,67 ,62 ,62 ,62 ,62 ,71 ,69 ,67 ,64 ,64 ,64 ,72 ,71 ,69 ,74 ,74 ,74 ,74 ,76 ,74 ,72 ,69 ,67 ,74 ,71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,71 ,69 ,69 ,71 ,69 ,74 ,71 ,71 ,71 ,71 ,71 ,71 ,71 ,74 ,67 ,69 ,71 ,72 ,72 ,72 ,72 ,72 ,71 ,71 ,71 ,71 ,74 ,74 ,72 ,69 ,67 }; +static const uint8_t jingle[] = { 71, 71, 71, 71, 71, 71, 71, 74, 67, 69, 71, 72, 72, 72, 72, 72, 71, 71, 71, 71, 71, 69, 69, 71, 69, 74, 71, 71, 71, 71, 71, 71, 71, 74, 67, 69, 71, 72, 72, 72, 72, 72, 71, 71, 71, 71, 74, 74, 72, 69, 67, 62, 62, 71, 69, 67, 62, 62, 62, 62, 71, 69, 67, 64, 64, 64, 72, 71, 69, 66, 74, 76, 74, 72, 69, 71, 62, 62, 71, 69, 67, 62, 62, 62, 62, 71, 69, 67, 64, 64, 64, 72, 71, 69, 74, 74, 74, 74, 76, 74, 72, 69, 67, 74, 71, 71, 71, 71, 71, 71, 71, 74, 67, 69, 71, 72, 72, 72, 72, 72, 71, 71, 71, 71, 71, 69, 69, 71, 69, 74, 71, 71, 71, 71, 71, 71, 71, 74, 67, 69, 71, 72, 72, 72, 72, 72, 71, 71, 71, 71, 74, 74, 72, 69, 67 }; static void -synth_parse_xmas(void *synth, const uint8_t *data, const size_t size) +synth_parse_xmas (void* synth, const uint8_t* data, const size_t size) { RSSynthesizer* rs = (RSSynthesizer*)synth; - if (size < 2 || size > 3) return; + if (size < 2 || size > 3) + return; // All messages need to be 3 bytes; except program-changes: 2bytes. - if (size == 2 && (data[0] & 0xf0) != 0xC0) return; + if (size == 2 && (data[0] & 0xf0) != 0xC0) + return; struct rmidi_event_t ev; - ev.channel = data[0]&0x0f; + ev.channel = data[0] & 0x0f; switch (data[0] & 0xf0) { case 0x80: - ev.type=NOTE_OFF; - ev.d.tone.note=jingle[rs->xmas_off++]; - ev.d.tone.velocity=data[2]&0x7f; - if (rs->xmas_off >= sizeof(jingle)) rs->xmas_off = 0; + ev.type = NOTE_OFF; + ev.d.tone.note = jingle[rs->xmas_off++]; + ev.d.tone.velocity = data[2] & 0x7f; + if (rs->xmas_off >= sizeof (jingle)) + rs->xmas_off = 0; break; case 0x90: - ev.type=NOTE_ON; - ev.d.tone.note=jingle[rs->xmas_on++]; - ev.d.tone.velocity=data[2]&0x7f; - if (rs->xmas_on >= sizeof(jingle)) rs->xmas_on = 0; + ev.type = NOTE_ON; + ev.d.tone.note = jingle[rs->xmas_on++]; + ev.d.tone.velocity = data[2] & 0x7f; + if (rs->xmas_on >= sizeof (jingle)) + rs->xmas_on = 0; break; case 0xB0: - ev.type=CONTROL_CHANGE; - ev.d.control.param=data[1]&0x7f; - ev.d.control.value=data[2]&0x7f; + ev.type = CONTROL_CHANGE; + ev.d.control.param = data[1] & 0x7f; + ev.d.control.value = data[2] & 0x7f; break; case 0xC0: - ev.type=PROGRAM_CHANGE; - ev.d.control.value=data[1]&0x7f; + ev.type = PROGRAM_CHANGE; + ev.d.control.value = data[1] & 0x7f; break; default: return; } - synth_process_midi_event(synth, &ev); + synth_process_midi_event (synth, &ev); } /** * initialize the synth @@ -541,23 +544,24 @@ synth_parse_xmas(void *synth, const uint8_t *data, const size_t size) * @param rate sample-rate */ static void -synth_init(void* synth, double rate) { - RSSynthesizer* rs = (RSSynthesizer*)synth; - rs->rate = rate; - rs->boffset = BUFFER_SIZE_SAMPLES; +synth_init (void* synth, double rate) +{ + RSSynthesizer* rs = (RSSynthesizer*)synth; + rs->rate = rate; + rs->boffset = BUFFER_SIZE_SAMPLES; const float tuning = 440; - int c,k; - for (k=0; k < 128; k++) { - rs->freqs[k] = (tuning / 32.0f) * powf(2, (k - 9.0) / 12.0) / rate; - assert(rs->freqs[k] < M_PI/2); // otherwise spatialization may phase out.. + int c, k; + for (k = 0; k < 128; k++) { + rs->freqs[k] = (tuning / 32.0f) * powf (2, (k - 9.0) / 12.0) / rate; + assert (rs->freqs[k] < M_PI / 2); // otherwise spatialization may phase out.. } rs->kcfilt = 12.0 / rate; - synth_reset(synth); + synth_reset (synth); - for (c=0; c < 16; c++) { - synth_load(&rs->sc[c], rate, &synthesize_sineP, &piano_adsr); + for (c = 0; c < 16; c++) { + synth_load (&rs->sc[c], rate, &synthesize_sineP, &piano_adsr); } - rs->xmas_on = 0; + rs->xmas_on = 0; rs->xmas_off = 0; } @@ -572,9 +576,9 @@ synth_init(void* synth, double rate) { * @return synth-handle */ static void* -synth_alloc(void) +synth_alloc (void) { - return calloc(1, sizeof(RSSynthesizer)); + return calloc (1, sizeof (RSSynthesizer)); } /** @@ -582,7 +586,7 @@ synth_alloc(void) * @param synth synth-handle */ static void -synth_free(void *synth) +synth_free (void* synth) { - free(synth); + free (synth); }