move mdaPiano::noteOn to mdaPianoVoice::on
[software/lv2-mdametapiano.git] / src / mdaPiano.cpp
1 /* ==================================================
2 * LV2 port of the famous mda Piano VSTi
3 * ==================================================
4 *
5 * Port
6 * Author: Ricardo Wurmus (rekado)
7 * Based on: mda-vst-src-2010-02-14.zip
8 *
9 * mda Piano v1.0
10 * Copyright(c)1999-2000 Paul Kellett (maxim digital audio)
11 * Based on VST2 SDK (c)1996-1999 Steinberg Soft und Hardware GmbH, All Rights Reserved
12 *
13 * ==================================================
14 */
15
16 #include "mdaPianoCommon.h"
17 #include "mdaPiano.h"
18
19 #include <stdio.h>
20 #include <math.h>
21
22 #define STRING_BUF 2048
23 static const char* sample_file = "samples.raw";
24
25
26 mdaPiano::mdaPiano(double rate)
27 : LV2::Synth<mdaPianoVoice, mdaPiano>(p_n_ports, p_midi) {
28
29 cmax = 0x7F; //just in case...
30
31 load_samples(&waves);
32 load_kgrp(kgrp);
33
34 notes[0] = EVENTS_DONE;
35 cpos = sustain = activevoices = 0;
36 comb = new float[256];
37
38 update();
39 suspend();
40 }
41
42
43 void mdaPiano::update() //parameter change
44 {
45 float * param = programs[curProgram].param;
46 size = (uint32_t)(12.0f * param[2] - 6.0f);
47 sizevel = 0.12f * param[3];
48 muffvel = param[5] * param[5] * 5.0f;
49
50 velsens = 1.0f + param[6] + param[6];
51 if(param[6] < 0.25f) velsens -= 0.75f - 3.0f * param[6];
52
53 fine = param[9] - 0.5f;
54 random = 0.077f * param[10] * param[10];
55 stretch = 0.000434f * (param[11] - 0.5f);
56
57 cdep = param[7] * param[7];
58 trim = 1.50f - 0.79f * cdep;
59 width = 0.04f * param[7]; if(width > 0.03f) width = 0.03f;
60
61 poly = 8 + (uint32_t)(24.9f * param[8]);
62 }
63
64
65 void mdaPiano::resume()
66 {
67 Fs = getSampleRate();
68 iFs = 1.0f / Fs;
69 if(Fs > 64000.0f) cmax = 0xFF; else cmax = 0x7F;
70 memset(comb, 0, sizeof(float) * 256);
71 }
72
73
74 void mdaPiano::setParameter(uint32_t index, float value)
75 {
76 programs[curProgram].param[index] = value;
77 update();
78 }
79
80
81 void mdaPiano::process(float **inputs, float **outputs, uint32_t sampleFrames)
82 {
83 float* out0 = outputs[0];
84 float* out1 = outputs[1];
85 uint32_t event=0, frame=0, frames, v;
86 float x, l, r;
87 uint32_t i;
88
89 while(frame<sampleFrames)
90 {
91 frames = notes[event++];
92 if(frames>sampleFrames) frames = sampleFrames;
93 frames -= frame;
94 frame += frames;
95
96 while(--frames>=0)
97 {
98 VOICE *V = voice;
99 l = r = 0.0f;
100
101 for(v=0; v<activevoices; v++)
102 {
103 V->frac += V->delta; //integer-based linear interpolation
104 V->pos += V->frac >> 16;
105 V->frac &= 0xFFFF;
106 if(V->pos > V->end) V->pos -= V->loop;
107 i = waves[V->pos];
108 i = (i << 7) + (V->frac >> 9) * (waves[V->pos + 1] - i) + 0x40400000;
109 x = V->env * (*(float *)&i - 3.0f); //fast int->float
110
111 V->env = V->env * V->dec; //envelope
112 V->f0 += V->ff * (x + V->f1 - V->f0); //muffle filter
113 V->f1 = x;
114
115 l += V->outl * V->f0;
116 r += V->outr * V->f0;
117
118 V++;
119 }
120 comb[cpos] = l + r;
121 ++cpos &= cmax;
122 x = cdep * comb[cpos]; //stereo simulator
123
124 *out0++ += l + x;
125 *out1++ += r - x;
126 }
127
128 if(frame<sampleFrames)
129 {
130 uint32_t note = notes[event++];
131 uint32_t vel = notes[event++];
132 noteOn(note, vel);
133 }
134 }
135 for(v=0; v<activevoices; v++) if(voice[v].env < SILENCE) voice[v] = voice[--activevoices];
136 notes[0] = EVENTS_DONE; //mark events buffer as done
137 }
138
139
140 void mdaPiano::processReplacing(float **inputs, float **outputs, uint32_t sampleFrames)
141 {
142 float* out0 = outputs[0];
143 float* out1 = outputs[1];
144 uint32_t event=0, frame=0, frames, v;
145 float x, l, r;
146 uint32_t i;
147
148 while(frame<sampleFrames)
149 {
150 frames = notes[event++];
151 if(frames>sampleFrames) frames = sampleFrames;
152 frames -= frame;
153 frame += frames;
154
155 while(--frames>=0)
156 {
157 VOICE *V = voice;
158 l = r = 0.0f;
159
160 for(v=0; v<activevoices; v++)
161 {
162 V->frac += V->delta; //integer-based linear interpolation
163 V->pos += V->frac >> 16;
164 V->frac &= 0xFFFF;
165 if(V->pos > V->end) V->pos -= V->loop;
166 //i = (i << 7) + (V->frac >> 9) * (waves[V->pos + 1] - i) + 0x40400000; //not working on intel mac !?!
167 i = waves[V->pos] + ((V->frac * (waves[V->pos + 1] - waves[V->pos])) >> 16);
168 x = V->env * (float)i / 32768.0f;
169 //x = V->env * (*(float *)&i - 3.0f); //fast int->float
170
171 V->env = V->env * V->dec; //envelope
172 V->f0 += V->ff * (x + V->f1 - V->f0); //muffle filter
173 V->f1 = x;
174
175 l += V->outl * V->f0;
176 r += V->outr * V->f0;
177
178 if(!(l > -2.0f) || !(l < 2.0f))
179 {
180 printf("what is this shit? %d, %f, %f\n", i, x, V->f0);
181 l = 0.0f;
182 }
183 if(!(r > -2.0f) || !(r < 2.0f))
184 {
185 r = 0.0f;
186 }
187
188 V++;
189 }
190 comb[cpos] = l + r;
191 ++cpos &= cmax;
192 x = cdep * comb[cpos]; //stereo simulator
193
194 *out0++ = l + x;
195 *out1++ = r - x;
196 }
197
198 if(frame<sampleFrames)
199 {
200 uint32_t note = notes[event++];
201 uint32_t vel = notes[event++];
202 noteOn(note, vel);
203 }
204 }
205 for(v=0; v<activevoices; v++) if(voice[v].env < SILENCE) voice[v] = voice[--activevoices];
206 notes[0] = EVENTS_DONE; //mark events buffer as done
207 }
208
209
210 uint32_t mdaPiano::processEvents(VstEvents* ev)
211 {
212 uint32_t npos=0;
213
214 for (uint32_t i=0; i<ev->numEvents; i++)
215 {
216 if((ev->events[i])->type != kVstMidiType) continue;
217 VstMidiEvent* event = (VstMidiEvent*)ev->events[i];
218 char* midiData = event->midiData;
219
220 switch(midiData[0] & 0xf0) //status byte (all channels)
221 {
222 case 0x80: //note off
223 notes[npos++] = event->deltaFrames; //delta
224 notes[npos++] = midiData[1] & 0x7F; //note
225 notes[npos++] = 0; //vel
226 break;
227
228 case 0x90: //note on
229 notes[npos++] = event->deltaFrames; //delta
230 notes[npos++] = midiData[1] & 0x7F; //note
231 notes[npos++] = midiData[2] & 0x7F; //vel
232 break;
233
234 case 0xB0: //controller
235 switch(midiData[1])
236 {
237 case 0x01: //mod wheel
238 case 0x43: //soft pedal
239 muff = 0.01f * (float)((127 - midiData[2]) * (127 - midiData[2]));
240 break;
241
242 case 0x07: //volume
243 volume = 0.00002f * (float)(midiData[2] * midiData[2]);
244 break;
245
246 case 0x40: //sustain pedal
247 case 0x42: //sustenuto pedal
248 sustain = midiData[2] & 0x40;
249 if(sustain==0)
250 {
251 notes[npos++] = event->deltaFrames;
252 notes[npos++] = SUSTAIN; //end all sustained notes
253 notes[npos++] = 0;
254 }
255 break;
256
257 default: //all notes off
258 if(midiData[1]>0x7A)
259 {
260 for(uint32_t v=0; v<NVOICES; v++) voice[v].dec=0.99f;
261 sustain = 0;
262 muff = 160.0f;
263 }
264 break;
265 }
266 break;
267
268 default: break;
269 }
270
271 if(npos>EVENTBUFFER) npos -= 3; //discard events if buffer full!!
272 event++; //?
273 }
274 notes[npos] = EVENTS_DONE;
275 return 1;
276 }
277
278
279 // TODO: load this from a file
280 void mdaPiano::load_kgrp(KGRP *kgrp)
281 {
282 //Waveform data and keymapping is hard-wired in *this* version
283 kgrp[ 0].root = 36; kgrp[ 0].high = 37; kgrp[ 0].pos = 0; kgrp[ 0].end = 36275; kgrp[ 0].loop = 14774;
284 kgrp[ 1].root = 40; kgrp[ 1].high = 41; kgrp[ 1].pos = 36278; kgrp[ 1].end = 83135; kgrp[ 1].loop = 16268;
285 kgrp[ 2].root = 43; kgrp[ 2].high = 45; kgrp[ 2].pos = 83137; kgrp[ 2].end = 146756; kgrp[ 2].loop = 33541;
286 kgrp[ 3].root = 48; kgrp[ 3].high = 49; kgrp[ 3].pos = 146758; kgrp[ 3].end = 204997; kgrp[ 3].loop = 21156;
287 kgrp[ 4].root = 52; kgrp[ 4].high = 53; kgrp[ 4].pos = 204999; kgrp[ 4].end = 244908; kgrp[ 4].loop = 17191;
288 kgrp[ 5].root = 55; kgrp[ 5].high = 57; kgrp[ 5].pos = 244910; kgrp[ 5].end = 290978; kgrp[ 5].loop = 23286;
289 kgrp[ 6].root = 60; kgrp[ 6].high = 61; kgrp[ 6].pos = 290980; kgrp[ 6].end = 342948; kgrp[ 6].loop = 18002;
290 kgrp[ 7].root = 64; kgrp[ 7].high = 65; kgrp[ 7].pos = 342950; kgrp[ 7].end = 391750; kgrp[ 7].loop = 19746;
291 kgrp[ 8].root = 67; kgrp[ 8].high = 69; kgrp[ 8].pos = 391752; kgrp[ 8].end = 436915; kgrp[ 8].loop = 22253;
292 kgrp[ 9].root = 72; kgrp[ 9].high = 73; kgrp[ 9].pos = 436917; kgrp[ 9].end = 468807; kgrp[ 9].loop = 8852;
293 kgrp[10].root = 76; kgrp[10].high = 77; kgrp[10].pos = 468809; kgrp[10].end = 492772; kgrp[10].loop = 9693;
294 kgrp[11].root = 79; kgrp[11].high = 81; kgrp[11].pos = 492774; kgrp[11].end = 532293; kgrp[11].loop = 10596;
295 kgrp[12].root = 84; kgrp[12].high = 85; kgrp[12].pos = 532295; kgrp[12].end = 560192; kgrp[12].loop = 6011;
296 kgrp[13].root = 88; kgrp[13].high = 89; kgrp[13].pos = 560194; kgrp[13].end = 574121; kgrp[13].loop = 3414;
297 kgrp[14].root = 93; kgrp[14].high = 999; kgrp[14].pos = 574123; kgrp[14].end = 586343; kgrp[14].loop = 2399;
298 }
299
300
301 void mdaPiano::load_samples(short **buffer)
302 {
303 FILE *f;
304 long num, size;
305 char filepath[STRING_BUF];
306
307 strncpy(filepath, bundle_path(), STRING_BUF);
308 strncat(filepath,
309 sample_file,
310 STRING_BUF - strlen(filepath));
311 f = fopen(filepath, "rb");
312 if (f == NULL) {
313 fputs("File error", stderr);
314 exit(1);
315 }
316
317 // obtain file size
318 fseek(f, 0, SEEK_END);
319 size = ftell(f);
320 rewind(f);
321
322 // allocate memory to contain the whole file
323 *buffer = (short*) malloc (sizeof(short)*size);
324 if (*buffer == NULL) {
325 fputs("Memory error", stderr);
326 exit(2);
327 }
328
329 // copy the file into the buffer
330 num = fread(*buffer, 1, size, f);
331 if (num != size) {
332 fputs ("Reading error", stderr);
333 exit (3);
334 }
335 fclose (f);
336 return;
337 }