« back to all changes in this revision
Viewing changes to synti/deicsonze/deicsonze.cpp
- browse files at revision 1.2.1
- compare with another revision
- download diff
- download tarball
- view history from revision 1.2.1
- Committer: Bazaar Package Importer
- Author(s): Alessio Treglia
- Date: 2011-08-12 11:16:41 UTC
- mto: (1.1.9) (10.1.6 sid)
- mto: This revision was merged to the branch mainline in revision 26.
- Revision ID: james.westby@ubuntu.com-20110812111641-72iatqb9jomjejko
Import upstream version 2.0~beta2
- files added:
- .muse.prcs_aux
- al
- awl
- cmake
- man
- muse/remote
- plugins/doublechorus
- plugins/pandelay
- share/pybridge
- share/pybridge/examples
- share/pybridge/parter
- share/scoreglyphs
- share/scoreglyphs/feta-original
- share/scripts
- synti/deicsonze/pics
- synti/simpledrums2
- utils
- files removed:
- INSTALL
- lib
- lib/plugins
- lib/synthi
- m4
- files modified:
- AUTHORS
added
removed
synti/deicsonze/deicsonze.cpp
2
2
//
3
3
// DeicsOnze an emulator of the YAMAHA DX11 synthesizer
4
4
//
5
// Version 0.2.2
6
//
7
//
8
//
9
//
10
// Copyright (c) 2004 Nil Geisweiller
5
// Version 0.5.5
6
//
7
//
8
//
9
//
10
// Copyright (c) 2004-2006 Nil Geisweiller
11
11
//
12
12
//
13
13
//
27
27
// 02111-1307, USA or point your web browser to http://www.gnu.org.
28
28
//===========================================================================
29
29
30
#include <cmath>
30
// #include <cmath>
31
31
#include <list>
32
32
33
#include <stdio.h>
34
33
// #include <stdio.h>
34
35
#include <QDomDocument>
36
#include <QTemporaryFile>
37
38
#include "muse/midi.h"
35
39
#include "libsynti/mess.h"
40
#include "deicsonze.h"
41
42
#include "plugin.h"
43
36
44
#include "muse/midictrl.h"
37
#include "deicsonze.h"
38
39
#include "deicsonzegui.h"
45
//#include "deicsonze.h"
46
#include "config.h"
40
47
41
48
#define ABS(x) (x>=0?x:-x)
42
49
48
55
// DeicsOnze
49
56
//---------------------------------------------------------
50
57
51
DeicsOnze::DeicsOnze() : Mess(1)
52
{
53
if (useCount++ == 0) {
54
// create sinus wave table, W1
55
for(int i = 0; i < RESOLUTION; i++)
56
waveTable[W1][i] =
57
(float)(sin((i * 2.0 * M_PI) / (double)RESOLUTION));
58
// create sinus*abs(sinus) wave table, W2
59
for(int i = 0; i < RESOLUTION; i++){
60
double t = (i * 2.0 * M_PI) / (double)RESOLUTION;
61
waveTable[W2][i] = (float)(ABS(sin(t))*sin(t));}
62
// create halfsinus_ wave table, W3
63
for(int i = 0; i < RESOLUTION; i++)
64
waveTable[W3][i] = (float)
65
(i<RESOLUTION/2?sin((i*2.0*M_PI)/(double)RESOLUTION):0.0);
66
// create halfsinus*abs(sinus)_ wave table, W4
67
for(int i = 0; i < RESOLUTION; i++){
68
double t = (i * 2.0 * M_PI) / (double)RESOLUTION;
69
waveTable[W4][i] = (float)(i<RESOLUTION/2?ABS(sin(t))*sin(t):0.0);}
70
// create sinus_ wave table, W5
71
for(int i = 0; i < RESOLUTION; i++)
72
waveTable[W5][i] = (float)
73
(i<RESOLUTION/2?sin((i*4.0*M_PI) / (double)RESOLUTION):0.0);
74
// create sinus*abs(sinus)_ wave table, W6
75
for(int i = 0; i < RESOLUTION; i++){
76
double t = (i*4.0*M_PI) / (double)RESOLUTION;
77
waveTable[W6][i] = (float)(i<RESOLUTION/2?ABS(sin(t))*sin(t):0.0);}
58
DeicsOnze::DeicsOnze() : Mess(2) {
59
if (useCount++ == 0) {
60
// create sinus wave table, W1
61
for(int i = 0; i < RESOLUTION; i++)
62
waveTable[W1][i] =
63
(float)(sin((i * 2.0 * M_PI) / (double)RESOLUTION));
64
// create sinus*abs(sinus) wave table, W2
65
for(int i = 0; i < RESOLUTION; i++){
66
double t = (i * 2.0 * M_PI) / (double)RESOLUTION;
67
waveTable[W2][i] = (float)(ABS(sin(t))*sin(t));}
68
// create halfsinus_ wave table, W3
69
for(int i = 0; i < RESOLUTION; i++)
70
waveTable[W3][i] = (float)
71
(i<RESOLUTION/2?sin((i*2.0*M_PI)/(double)RESOLUTION):0.0);
72
// create halfsinus*abs(sinus)_ wave table, W4
73
for(int i = 0; i < RESOLUTION; i++){
74
double t = (i * 2.0 * M_PI) / (double)RESOLUTION;
75
waveTable[W4][i] = (float)(i<RESOLUTION/2?ABS(sin(t))*sin(t):0.0);}
76
// create sinus_ wave table, W5
77
for(int i = 0; i < RESOLUTION; i++)
78
waveTable[W5][i] = (float)
79
(i<RESOLUTION/2?sin((i*4.0*M_PI) / (double)RESOLUTION):0.0);
80
// create sinus*abs(sinus)_ wave table, W6
81
for(int i = 0; i < RESOLUTION; i++){
82
double t = (i*4.0*M_PI) / (double)RESOLUTION;
83
waveTable[W6][i] = (float)(i<RESOLUTION/2?ABS(sin(t))*sin(t):0.0);}
78
84
// create 2halfsinus_ wave table, W7
79
for(int i = 0; i < RESOLUTION; i++)
80
waveTable[W7][i] = (float)
81
(i<RESOLUTION/2?ABS(sin((i*4.0*M_PI)/(double)RESOLUTION)):0.0);
82
// create 2halfsinus*abs(sinus)_ wave table, W8
83
for(int i = 0; i < RESOLUTION; i++){
84
double t = (i * 4.0 * M_PI) / (double)RESOLUTION;
85
waveTable[W8][i] = (float)(i<RESOLUTION/2?sin(t)*sin(t):0.0);}
86
}
87
88
85
for(int i = 0; i < RESOLUTION; i++)
86
waveTable[W7][i] = (float)
87
(i<RESOLUTION/2?ABS(sin((i*4.0*M_PI)/(double)RESOLUTION)):0.0);
88
// create 2halfsinus*abs(sinus)_ wave table, W8
89
for(int i = 0; i < RESOLUTION; i++){
90
double t = (i * 4.0 * M_PI) / (double)RESOLUTION;
91
waveTable[W8][i] = (float)(i<RESOLUTION/2?sin(t)*sin(t):0.0);}
92
}
93
94
//alloc temp buffers chorus and reverb
95
tempInputChorus = (float**) malloc(sizeof(float*)*NBRFXINPUTS);
96
for(int i = 0; i < NBRFXINPUTS; i++)
97
tempInputChorus[i] = (float*) malloc(sizeof(float*)*MAXFXBUFFERSIZE);
98
tempOutputChorus = (float**) malloc(sizeof(float*)*NBRFXOUTPUTS);
99
for(int i = 0; i < NBRFXOUTPUTS; i++)
100
tempOutputChorus[i] = (float*) malloc(sizeof(float*)*MAXFXBUFFERSIZE);
101
tempInputReverb = (float**) malloc(sizeof(float*)*NBRFXINPUTS);
102
for(int i = 0; i < NBRFXINPUTS; i++)
103
tempInputReverb[i] = (float*) malloc(sizeof(float*)*MAXFXBUFFERSIZE);
104
tempOutputReverb = (float**) malloc(sizeof(float*)*NBRFXOUTPUTS);
105
for(int i = 0; i < NBRFXOUTPUTS; i++)
106
tempOutputReverb[i] = (float*) malloc(sizeof(float*)*MAXFXBUFFERSIZE);
107
tempInputDelay = (float**) malloc(sizeof(float*)*NBRFXINPUTS);
108
for(int i = 0; i < NBRFXINPUTS; i++)
109
tempInputDelay[i] = (float*) malloc(sizeof(float*)*MAXFXBUFFERSIZE);
110
tempOutputDelay = (float**) malloc(sizeof(float*)*NBRFXOUTPUTS);
111
for(int i = 0; i < NBRFXOUTPUTS; i++)
112
tempOutputDelay[i] = (float*) malloc(sizeof(float*)*MAXFXBUFFERSIZE);
89
113
90
114
srand(time(0)); // initialize random number generator
91
115
92
loadSutulaPresets();
93
116
initCtrls();
94
117
initGlobal();
95
initVoices();
96
_preset = new Preset();
97
_preset->initPreset();
98
99
setPreset();
100
118
119
_numPatchProg = 0;
120
_saveOnlyUsed = true;
121
_saveConfig = true;
122
_isInitSet = true; //false if an initial bank must be download
123
124
QString sharePath(museGlobalShare);
125
_initSetPath = sharePath + QString("/presets/deicsonze/SutulaBank.dei");
126
127
128
//TODO
129
//INSTPREFIX + "/share/" + PACKAGEVERSION + "/presets/deicsonze/ARCH_ALIN";
130
_isBackgroundPix = true; //false if an initial bank must be download
131
132
//"/usr/local/share/muse-1.0pre1/wallpapers/abstractdeicsonze1.jpg";
133
_backgroundPixPath = sharePath + QString("/wallpapers/paper2.jpg"); // Tim.
134
135
136
//initialization GUI
101
137
_gui = new DeicsOnzeGui(this);
102
_gui->setCaption(QString("DeicsOnze"));
103
_gui->show();
138
_gui->hide(); // to avoid flicker during MusE startup
139
_gui->setWindowTitle(QString("DeicsOnze"));
140
141
//FX
142
Plugin* p;
143
p = plugins.find("freeverb", "freeverb1");
144
_pluginIReverb = NULL;
145
if(p) initPluginReverb(p);
146
_pluginIChorus = NULL;
147
p = plugins.find("doublechorus", "doublechorus1");
148
if(p) initPluginChorus(p);
149
_pluginIDelay = NULL;
150
p = plugins.find("pandelay", "pandelay");
151
if(p) initPluginDelay(p);
152
153
//Filter
154
_dryFilter = new LowFilter();
155
_chorusFilter = new LowFilter();
156
_reverbFilter = new LowFilter();
157
_delayFilter = new LowFilter();
158
159
// Moved here from below due to crash - _preset not initialized when loadConfiguration called. Tim.
160
_initialPreset = new
161
Preset(new Subcategory(new Category(NULL, "NONE", 0), "NONE", 0), 0);
162
for(int c = 0; c < NBRCHANNELS; c++) {
163
_preset[c]=_initialPreset;
164
setPreset(c);
165
}
166
167
//Load configuration
168
QString defaultConf =
169
(configPath + QString("/" DEICSONZESTR ".dco"));
170
FILE* f;
171
f = fopen(defaultConf.toAscii().data(), "r");
172
if(f) {
173
fclose(f);
174
loadConfiguration(defaultConf);
175
}
176
177
//load Set
178
_set=new Set("Initial Bank");
179
if(_isInitSet) loadSet(_initSetPath);
180
181
//loadSutulaPresets();
182
183
// Moved above due to crash - _preset not initialized when loadConfiguration called. Tim.
184
//_initialPreset = new
185
// Preset(new Subcategory(new Category(NULL, "NONE", 0), "NONE", 0), 0);
186
//for(int c = 0; c < NBRCHANNELS; c++) {
187
// _preset[c]=_initialPreset;
188
// setPreset(c);
189
//}
190
191
//update display gui
192
//update mastervol
193
unsigned char dataMasterVol[2];
194
dataMasterVol[0]=SYSEX_MASTERVOL;
195
dataMasterVol[1]=getMasterVol();
196
MidiPlayEvent evSysexMasterVol(0, 0, ME_SYSEX,
197
(const unsigned char*)dataMasterVol,
198
2);
199
_gui->writeEvent(evSysexMasterVol);
200
//update return fx
201
unsigned char *dataReverbRet = new unsigned char[2];
202
dataReverbRet[0]=SYSEX_REVERBRETURN;
203
dataReverbRet[1]=(unsigned char)getReverbReturn();
204
MidiPlayEvent evReverbRet(0, 0, ME_SYSEX,(const unsigned char*)dataReverbRet, 2);
205
_gui->writeEvent(evReverbRet);
206
unsigned char *dataChorusRet = new unsigned char[2];
207
dataChorusRet[0]=SYSEX_CHORUSRETURN;
208
dataChorusRet[1]=(unsigned char)getChorusReturn();
209
MidiPlayEvent evChorusRet(0, 0, ME_SYSEX,(const unsigned char*)dataChorusRet, 2);
210
_gui->writeEvent(evChorusRet);
211
unsigned char *dataDelayRet = new unsigned char[2];
212
dataDelayRet[0]=SYSEX_DELAYRETURN;
213
dataDelayRet[1]=(unsigned char)getDelayReturn();
214
//printf("DELAY RET = %d, REVERB RET = %d\n",
215
//getDelayReturn(), getReverbReturn());
216
MidiPlayEvent evDelayRet(0, 0, ME_SYSEX,(const unsigned char*)dataDelayRet, 2);
217
_gui->writeEvent(evDelayRet);
218
//update font size
219
unsigned char *dataFontSize = new unsigned char[2];
220
dataFontSize[0]=SYSEX_FONTSIZE;
221
dataFontSize[1]=(unsigned char)_global.fontSize;
222
MidiPlayEvent evFontSize(0, 0, ME_SYSEX, (const unsigned char*)dataFontSize, 2);
223
_gui->writeEvent(evFontSize);
224
//display load preset
225
unsigned char dataUpdateGuiSet[1];
226
dataUpdateGuiSet[0]=SYSEX_UPDATESETGUI;
227
MidiPlayEvent evSysexUpdateGuiSet(0, 0, ME_SYSEX,
228
(const unsigned char*)dataUpdateGuiSet,
229
1);
230
_gui->writeEvent(evSysexUpdateGuiSet);
104
231
}
105
232
106
233
//---------------------------------------------------------
109
236
110
237
DeicsOnze::~DeicsOnze()
111
238
{
112
//if (--useCount == 0)
113
//delete[] sine_table;
239
//if (--useCount == 0)
240
//delete[] sine_table;
241
//dealloc temp buffers chorus and reverb
242
for(int i = 0; i < NBRFXINPUTS; i++) free(tempInputChorus[i]);
243
free(tempInputChorus);
244
for(int i = 0; i < NBRFXOUTPUTS; i++) free(tempOutputChorus[i]);
245
free(tempOutputChorus);
246
for(int i = 0; i < NBRFXINPUTS; i++) free(tempInputReverb[i]);
247
free(tempInputReverb);
248
for(int i = 0; i < NBRFXOUTPUTS; i++) free(tempOutputReverb[i]);
249
free(tempOutputReverb);
250
for(int i = 0; i < NBRFXINPUTS; i++) free(tempInputDelay[i]);
251
free(tempInputDelay);
252
for(int i = 0; i < NBRFXOUTPUTS; i++) free(tempOutputDelay[i]);
253
free(tempOutputDelay);
254
}
255
256
//---------------------------------------------------------
257
// getSinusWaveTable
258
//---------------------------------------------------------
259
float* DeicsOnze::getSinusWaveTable() {
260
return waveTable[W1];
114
261
}
115
262
116
263
//---------------------------------------------------------
117
264
// guiVisible
118
265
//---------------------------------------------------------
119
bool DeicsOnze::guiVisible() const
266
bool DeicsOnze::nativeGuiVisible() const
120
267
{
121
268
return _gui->isVisible();
122
269
}
124
271
//---------------------------------------------------------
125
272
// showGui
126
273
//---------------------------------------------------------
127
void DeicsOnze::showGui(bool val)
274
void DeicsOnze::showNativeGui(bool val)
128
275
{
129
_gui->setShown(val);
130
}
131
132
//---------------------------------------------------------
133
// getGeometry
134
//---------------------------------------------------------
135
136
void DeicsOnze::getGeometry(int* x, int* y, int* w, int* h) const {
137
QPoint pos(_gui->pos());
138
QSize size(_gui->size());
139
*x = pos.x();
140
*y = pos.y();
141
*w = size.width();
142
*h = size.height();
143
}
144
145
//---------------------------------------------------------
146
// setGeometry
147
//---------------------------------------------------------
148
149
void DeicsOnze::setGeometry(int x, int y, int w, int h) {
276
_gui->setVisible(val);
277
}
278
279
//---------------------------------------------------------
280
// getNativeGeometry
281
//---------------------------------------------------------
282
283
void DeicsOnze::getNativeGeometry(int* x, int* y, int* w, int* h) const {
284
QPoint pos(_gui->pos());
285
QSize size(_gui->size());
286
*x = pos.x();
287
*y = pos.y();
288
*w = size.width();
289
*h = size.height();
290
}
291
292
void DeicsOnze::setSampleRate(int sr) {
293
Mess::setSampleRate(sr);
294
_dryFilter->setSamplerate(sr);
295
_chorusFilter->setSamplerate(sr);
296
_reverbFilter->setSamplerate(sr);
297
_delayFilter->setSamplerate(sr);
298
setQuality(_global.quality);
299
}
300
301
//---------------------------------------------------------
302
// setNativeGeometry
303
//---------------------------------------------------------
304
305
void DeicsOnze::setNativeGeometry(int x, int y, int w, int h) {
150
306
_gui->resize(QSize(w, h));
151
307
_gui->move(QPoint(x, y));
152
308
}
153
309
154
310
//---------------------------------------------------------
311
// initCtrls
312
//---------------------------------------------------------
313
void DeicsOnze::initCtrls() {
314
int i=0;
315
for(int k=0; k<NBROP; k++) {
316
_ctrl[i].name=(QString(ARSTR)+QString::number(k+1)).toAscii().data();
317
_ctrl[i].num=CTRL_AR+k*DECAPAR1;
318
_ctrl[i].min=0;
319
_ctrl[i++].max=MAXAR;
320
_ctrl[i].name=(QString(D1RSTR)+QString::number(k+1)).toAscii().data();
321
_ctrl[i].num=CTRL_D1R+k*DECAPAR1;
322
_ctrl[i].min=0;
323
_ctrl[i++].max=MAXD1R;
324
_ctrl[i].name=(QString(D2RSTR)+QString::number(k+1)).toAscii().data();
325
_ctrl[i].num=CTRL_D2R+k*DECAPAR1;
326
_ctrl[i].min=0;
327
_ctrl[i++].max=MAXD2R;
328
_ctrl[i].name=(QString(RRSTR)+QString::number(k+1)).toAscii().data();
329
_ctrl[i].num=CTRL_RR+k*DECAPAR1;
330
_ctrl[i].min=0;
331
_ctrl[i++].max=MAXRR;
332
_ctrl[i].name=(QString(D1LSTR)+QString::number(k+1)).toAscii().data();
333
_ctrl[i].num=CTRL_D1L+k*DECAPAR1;
334
_ctrl[i].min=0;
335
_ctrl[i++].max=MAXD1L;
336
_ctrl[i].name=(QString(LSSTR)+QString::number(k+1)).toAscii().data();
337
_ctrl[i].num=CTRL_LS+k*DECAPAR1;
338
_ctrl[i].min=0;
339
_ctrl[i++].max=MAXLS;
340
_ctrl[i].name=(QString(RSSTR)+QString::number(k+1)).toAscii().data();
341
_ctrl[i].num=CTRL_RS+k*DECAPAR1;
342
_ctrl[i].min=0;
343
_ctrl[i++].max=MAXRS;
344
_ctrl[i].name=(QString(EBSSTR)+QString::number(k+1)).toAscii().data();
345
_ctrl[i].num=CTRL_EBS+k*DECAPAR1;
346
_ctrl[i].min=0;
347
_ctrl[i++].max=MAXEBS;
348
_ctrl[i].name=(QString(AMESTR)+QString::number(k+1)).toAscii().data();
349
_ctrl[i].num=CTRL_AME+k*DECAPAR1;
350
_ctrl[i].min=0;
351
_ctrl[i++].max=1;
352
_ctrl[i].name=(QString(KVSSTR)+QString::number(k+1)).toAscii().data();
353
_ctrl[i].num=CTRL_KVS+k*DECAPAR1;
354
_ctrl[i].min=0;
355
_ctrl[i++].max=MAXKVS;
356
_ctrl[i].name=(QString(OUTSTR)+QString::number(k+1)).toAscii().data();
357
_ctrl[i].num=CTRL_OUT+k*DECAPAR1;
358
_ctrl[i].min=0;
359
_ctrl[i++].max=MAXOUT;
360
_ctrl[i].name=(QString("Centi")+QString(RATIOLONGSTR)+QString::number(k+1))
361
.toAscii().data();
362
_ctrl[i].num=CTRL_RATIO+k*DECAPAR1;
363
_ctrl[i].min=0;
364
_ctrl[i++].max=MAXRATIO*100;
365
_ctrl[i].name=(QString(DETSTR)+QString::number(k+1)).toAscii().data();
366
_ctrl[i].num=CTRL_DET+k*DECAPAR1;
367
_ctrl[i].min=-MAXDET;
368
_ctrl[i++].max=MAXDET;
369
}
370
_ctrl[i].name=ALGSTR;
371
_ctrl[i].num=CTRL_ALG;
372
_ctrl[i].min=0;
373
_ctrl[i++].max=MAXALG;
374
_ctrl[i].name=FEEDBACKSTR;
375
_ctrl[i].num=CTRL_FEEDBACK;
376
_ctrl[i].min=0;
377
_ctrl[i++].max=MAXFEEDBACK;
378
_ctrl[i].name=SPEEDSTR;
379
_ctrl[i].num=CTRL_SPEED;
380
_ctrl[i].min=0;
381
_ctrl[i++].max=MAXSPEED;
382
_ctrl[i].name=DELAYSTR;
383
_ctrl[i].num=CTRL_DELAY;
384
_ctrl[i].min=0;
385
_ctrl[i++].max=MAXDELAY;
386
_ctrl[i].name=PMODDEPTHSTR;
387
_ctrl[i].num=CTRL_PMODDEPTH;
388
_ctrl[i].min=0;
389
_ctrl[i++].max=MAXPMODDEPTH;
390
_ctrl[i].name=AMODDEPTHSTR;
391
_ctrl[i].num=CTRL_AMODDEPTH;
392
_ctrl[i].min=0;
393
_ctrl[i++].max=MAXAMODDEPTH;
394
_ctrl[i].name=SYNCSTR;
395
_ctrl[i].num=CTRL_SYNC;
396
_ctrl[i].min=0;
397
_ctrl[i++].max=1;
398
_ctrl[i].name=WAVESTR;
399
_ctrl[i].num=CTRL_WAVE;
400
_ctrl[i].min=0;
401
_ctrl[i++].max=MAXWAVE;
402
_ctrl[i].name=PMODSENSSTR;
403
_ctrl[i].num=CTRL_PMODSENS;
404
_ctrl[i].min=0;
405
_ctrl[i++].max=MAXPMODSENS;
406
_ctrl[i].name=AMSSTR;
407
_ctrl[i].num=CTRL_AMS;
408
_ctrl[i].min=0;
409
_ctrl[i++].max=MAXAMS;
410
_ctrl[i].name=TRANSPOSESTR;
411
_ctrl[i].num=CTRL_TRANSPOSE;
412
_ctrl[i].min=0;
413
_ctrl[i++].max=MAXTRANSPOSE;
414
_ctrl[i].name=POLYMODESTR;
415
_ctrl[i].num=CTRL_POLYMODE;
416
_ctrl[i].min=0;
417
_ctrl[i++].max=1;
418
_ctrl[i].name=PBENDRANGESTR;
419
_ctrl[i].num=CTRL_PBENDRANGE;
420
_ctrl[i].min=0;
421
_ctrl[i++].max=MAXPBENDRANGE;
422
_ctrl[i].name=PORTAMODESTR;
423
_ctrl[i].num=CTRL_PORTAMODE;
424
_ctrl[i].min=0;
425
_ctrl[i++].max=1;
426
_ctrl[i].name=PORTATIMESTR;
427
_ctrl[i].num=CTRL_PORTATIME;
428
_ctrl[i].min=0;
429
_ctrl[i++].max=MAXPROTATIME;
430
_ctrl[i].name=FCVOLUMESTR;
431
_ctrl[i].num=CTRL_FCVOLUME;
432
_ctrl[i].min=0;
433
_ctrl[i++].max=MAXFCVOLUME;
434
_ctrl[i].name=FSWSTR;
435
_ctrl[i].num=CTRL_FSW;
436
_ctrl[i].min=0;
437
_ctrl[i++].max=MAXFSW;
438
_ctrl[i].name=MWPITCHSTR;
439
_ctrl[i].num=CTRL_MWPITCH;
440
_ctrl[i].min=0;
441
_ctrl[i++].max=MAXMWPITCH;
442
_ctrl[i].name=MWAMPLITUDESTR;
443
_ctrl[i].num=CTRL_MWAMPLITUDE;
444
_ctrl[i].min=0;
445
_ctrl[i++].max=MAXMWAMPLITUDE;
446
_ctrl[i].name=BCPITCHSTR;
447
_ctrl[i].num=CTRL_BCPITCH;
448
_ctrl[i].min=0;
449
_ctrl[i++].max=MAXBCPITCH;
450
_ctrl[i].name=BCAMPLITUDESTR;
451
_ctrl[i].num=CTRL_BCAMPLITUDE;
452
_ctrl[i].min=0;
453
_ctrl[i++].max=MAXBCAMPLITUDE;
454
_ctrl[i].name=BCPITCHBIASSTR;
455
_ctrl[i].num=CTRL_BCPITCHBIAS;
456
_ctrl[i].min=-MAXBCPITCHBIAS;
457
_ctrl[i++].max=MAXBCPITCHBIAS;
458
_ctrl[i].name=BCEGBIASSTR;
459
_ctrl[i].num=CTRL_BCEGBIAS;
460
_ctrl[i].min=0;
461
_ctrl[i++].max=MAXBCEGBIAS;
462
_ctrl[i].name=ATPITCHSTR;
463
_ctrl[i].num=CTRL_ATPITCH;
464
_ctrl[i].min=0;
465
_ctrl[i++].max=MAXATPITCH;
466
_ctrl[i].name=ATAMPLITUDESTR;
467
_ctrl[i].num=CTRL_ATAMPLITUDE;
468
_ctrl[i].min=0;
469
_ctrl[i++].max=MAXATAMPLITUDE;
470
_ctrl[i].name=ATPITCHBIASSTR;
471
_ctrl[i].num=CTRL_ATPITCHBIAS;
472
_ctrl[i].min=-MAXATPITCHBIAS;
473
_ctrl[i++].max=MAXATPITCHBIAS;
474
_ctrl[i].name=ATEGBIASSTR;
475
_ctrl[i].num=CTRL_ATEGBIAS;
476
_ctrl[i].min=0;
477
_ctrl[i++].max=MAXATEGBIAS;
478
_ctrl[i].name=PR1STR;
479
_ctrl[i].num=CTRL_PR1;
480
_ctrl[i].min=0;
481
_ctrl[i++].max=MAXPR;
482
_ctrl[i].name=PR2STR;
483
_ctrl[i].num=CTRL_PR2;
484
_ctrl[i].min=0;
485
_ctrl[i++].max=MAXPR;
486
_ctrl[i].name=PR3STR;
487
_ctrl[i].num=CTRL_PR3;
488
_ctrl[i].min=0;
489
_ctrl[i++].max=MAXPR;
490
_ctrl[i].name=PL1STR;
491
_ctrl[i].num=CTRL_PL1;
492
_ctrl[i].min=0;
493
_ctrl[i++].max=MAXPL;
494
_ctrl[i].name=PL2STR;
495
_ctrl[i].num=CTRL_PL2;
496
_ctrl[i].min=0;
497
_ctrl[i++].max=MAXPL;
498
_ctrl[i].name=PL3STR;
499
_ctrl[i].num=CTRL_PL3;
500
_ctrl[i].min=0;
501
_ctrl[i++].max=MAXPL;
502
for(int k=0; k<NBROP; k++) {
503
_ctrl[i].name=(QString(FIXSTR)+QString::number(k+1)).toAscii().data();
504
_ctrl[i].num=CTRL_FIX+k*DECAPAR2;
505
_ctrl[i].min=0;
506
_ctrl[i++].max=1;
507
_ctrl[i].name=(QString("Centi")+QString(FIXRANGESTR)
508
+QString::number(k+1)).toAscii().data();
509
_ctrl[i].num=CTRL_FIXRANGE+k*DECAPAR2;
510
_ctrl[i].min=0;
511
_ctrl[i++].max=MAXFIXRANGE*100;
512
_ctrl[i].name=(QString(OSWSTR)+QString::number(k+1)).toAscii().data();
513
_ctrl[i].num=CTRL_OSW+k*DECAPAR2;
514
_ctrl[i].min=0;
515
_ctrl[i++].max=MAXOSW;
516
_ctrl[i].name=(QString(SHFTSTR)+QString::number(k+1)).toAscii().data();
517
_ctrl[i].num=CTRL_SHFT+k*DECAPAR2;
518
_ctrl[i].min=0;
519
_ctrl[i++].max=MAXSHFT;
520
}
521
_ctrl[i].name=REVERBRATESTR;
522
_ctrl[i].num=CTRL_REVERBRATE;
523
_ctrl[i].min=0;
524
_ctrl[i++].max=7;
525
_ctrl[i].name=FCPITCHSTR;
526
_ctrl[i].num=CTRL_FCPITCH;
527
_ctrl[i].min=0;
528
_ctrl[i++].max=MAXFCPITCH;
529
_ctrl[i].name=FCAMPLITUDESTR;
530
_ctrl[i].num=CTRL_FCAMPLITUDE;
531
_ctrl[i].min=0;
532
_ctrl[i++].max=MAXFCAMPLITUDE;
533
_ctrl[i].name=CHANNELPANSTR;
534
_ctrl[i].num=CTRL_CHANNELPAN;
535
_ctrl[i].min=-MAXCHANNELPAN;
536
_ctrl[i++].max=MAXCHANNELPAN;
537
_ctrl[i].name=CHANNELDETUNESTR;
538
_ctrl[i].num=CTRL_CHANNELDETUNE;
539
_ctrl[i].min=-MAXCHANNELDETUNE;
540
_ctrl[i++].max=MAXCHANNELDETUNE;
541
_ctrl[i].name=CHANNELVOLUMESTR;
542
_ctrl[i].num=CTRL_CHANNELVOLUME;
543
_ctrl[i].min=0;
544
_ctrl[i++].max=MAXCHANNELVOLUME;
545
_ctrl[i].name=FINEBRIGHTNESSSTR;
546
_ctrl[i].num=CTRL_FINEBRIGHTNESS;
547
_ctrl[i].min=0;
548
_ctrl[i++].max=MAXFINEBRIGHTNESS;
549
_ctrl[i].name=NBRVOICESSTR;
550
_ctrl[i].num=CTRL_NBRVOICES;
551
_ctrl[i].min=0;
552
_ctrl[i++].max=MAXNBRVOICES;
553
nbrCtrl=i;
554
}
555
556
//---------------------------------------------------------
155
557
// initGlobal
156
558
//---------------------------------------------------------
157
559
void DeicsOnze::initGlobal() {
158
_global.amp=1.0/(double)NBRVOICES;
159
_global.sustain=false;
160
_global.pitchBendCoef=1.0;
161
_global.lfoIndex=0;
162
_numPatch=0;
163
}
164
560
setMasterVol(INITMASTERVOL);
561
_global.quality = high;
562
setFilter(false);
563
_global.fontSize = 9;
564
_global.isChorusActivated = false;
565
_global.chorusReturn = level2amp(INITFXRETURN);
566
_global.isReverbActivated = false;
567
_global.reverbReturn = level2amp(INITFXRETURN);
568
_global.isDelayActivated = false;
569
_global.delayReturn = level2amp(INITFXRETURN);
570
initChannels();
571
}
572
573
void DeicsOnze::initChannels() {
574
for(int c=0; c<NBRCHANNELS; c++) initChannel(c);
575
_global.channel[0].isEnable = true; //the first one is enable
576
}
577
578
void DeicsOnze::initChannel(int c) {
579
_global.channel[c].isEnable = false;
580
_global.channel[c].sustain = false;
581
_global.channel[c].volume = DEFAULTVOL;
582
_global.channel[c].pan = 0;
583
_global.channel[c].modulation = 0;
584
_global.channel[c].detune = 0;
585
_global.channel[c].brightness = MIDFINEBRIGHTNESS;
586
_global.channel[c].attack = MIDATTACK;
587
_global.channel[c].release = MIDRELEASE;
588
_global.channel[c].pitchBendCoef = 1.0;
589
_global.channel[c].lfoIndex = 0;
590
_global.channel[c].nbrVoices = 8;
591
_global.channel[c].isLastNote = false;
592
_global.channel[c].chorusAmount = 0.0;
593
_global.channel[c].reverbAmount = 0.0;
594
_global.channel[c].delayAmount = 0.0;
595
applyChannelAmp(c);
596
initVoices(c);
597
}
598
599
//---------------------------------------------------------
600
// resetVoices
601
//---------------------------------------------------------
602
void DeicsOnze::resetVoices() {
603
for(int c = 0; c<NBRCHANNELS; c++) initVoices(c);
604
//take care of this if initVoices() changes
605
}
606
607
//---------------------------------------------------------
608
// initVoice
609
//---------------------------------------------------------
610
void DeicsOnze::initVoice(int c /*channel*/, int v) {
611
_global.channel[c].voices[v].hasAttractor = false;
612
_global.channel[c].voices[v].isOn = false;
613
_global.channel[c].voices[v].keyOn = false;
614
_global.channel[c].voices[v].isSustained = false;
615
_global.channel[c].voices[v].pitchEnvCoefInct = 1.0;
616
_global.channel[c].voices[v].pitchEnvCoefInctInct = 1.0;
617
_global.channel[c].voices[v].pitchEnvState = OFF_PE;
618
619
}
165
620
//---------------------------------------------------------
166
621
// initVoices
167
622
//---------------------------------------------------------
168
void DeicsOnze::initVoices() {
169
for(int i=0; i<NBRVOICES; i++) {
170
_voices[i].isOn=false;
171
_voices[i].isSustained=false;
172
}
173
}
174
175
//---------------------------------------------------------
176
// initPreset
177
// put the preset in the initial state as defined by YAMAHA
178
//---------------------------------------------------------
179
void Preset::initPreset() {
180
//algorithm
181
algorithm=FIRST;
182
//feedeback
183
feedback=0;
184
//lfo
185
lfo.wave=TRIANGL;
186
lfo.speed=35;
187
lfo.delay=0;
188
lfo.pModDepth=0;
189
lfo.aModDepth=0;
190
lfo.sync=false;
191
//sensitivity
192
sensitivity.pitch=6;
193
sensitivity.amplitude=0;
194
sensitivity.ampOn[0]=false;
195
sensitivity.ampOn[1]=false;
196
sensitivity.ampOn[2]=false;
197
sensitivity.ampOn[3]=false;
198
sensitivity.egBias[0]=0;
199
sensitivity.egBias[1]=0;
200
sensitivity.egBias[2]=0;
201
sensitivity.egBias[3]=0;
202
sensitivity.keyVelocity[0]=0;
203
sensitivity.keyVelocity[1]=0;
204
sensitivity.keyVelocity[2]=0;
205
sensitivity.keyVelocity[3]=0;
206
//frequency
207
frequency[0].ratio=1.0;
208
frequency[1].ratio=1.0;
209
frequency[2].ratio=1.0;
210
frequency[3].ratio=1.0;
211
frequency[0].isFix=false;
212
frequency[1].isFix=false;
213
frequency[2].isFix=false;
214
frequency[3].isFix=false;
215
frequency[0].freq=255.0;
216
frequency[1].freq=255.0;
217
frequency[2].freq=255.0;
218
frequency[3].freq=255.0;
219
//oscWave
220
oscWave[0]=W1;
221
oscWave[1]=W1;
222
oscWave[2]=W1;
223
oscWave[3]=W1;
224
//detune
225
detune[0]=0;
226
detune[1]=0;
227
detune[2]=0;
228
detune[3]=0;
229
//eg
230
eg[0].ar=31;
231
eg[1].ar=31;
232
eg[2].ar=31;
233
eg[3].ar=31;
234
eg[0].d1r=31;
235
eg[1].d1r=31;
236
eg[2].d1r=31;
237
eg[3].d1r=31;
238
eg[0].d1l=15;
239
eg[1].d1l=15;
240
eg[2].d1l=15;
241
eg[3].d1l=15;
242
eg[0].d2r=0;
243
eg[1].d2r=0;
244
eg[2].d2r=0;
245
eg[3].d2r=0;
246
eg[0].rr=15;
247
eg[1].rr=15;
248
eg[2].rr=15;
249
eg[3].rr=15;
250
eg[0].egShift=VOF;
251
eg[1].egShift=VOF;
252
eg[2].egShift=VOF;
253
eg[3].egShift=VOF;
254
//pitchEg
255
pitchEg.pr1=99;
256
pitchEg.pr2=99;
257
pitchEg.pr3=99;
258
pitchEg.pl1=50;
259
pitchEg.pl2=50;
260
pitchEg.pl3=50;
261
//outLevel
262
outLevel[0]=90;
263
outLevel[1]=0;
264
outLevel[2]=0;
265
outLevel[3]=0;
266
//scaling
267
scaling.rate[0]=0;
268
scaling.rate[1]=0;
269
scaling.rate[2]=0;
270
scaling.rate[3]=0;
271
scaling.level[0]=0;
272
scaling.level[1]=0;
273
scaling.level[2]=0;
274
scaling.level[3]=0;
275
//function
276
function.transpose=0;
277
function.mode=POLY;
278
function.pBendRange=4;
279
function.portamento=FULL;
280
function.portamentoTime=0;
281
function.fcVolume=40;
282
function.fcPitch=0;
283
function.fcAmplitude=0;
284
function.mwPitch=50;
285
function.mwAmplitude=0;
286
function.bcPitch=0;
287
function.bcAmplitude=0;
288
function.bcPitchBias=0;
289
function.bcEgBias=0;
290
function.atPitch=0;
291
function.atAmplitude=0;
292
function.atPitchBias=0;
293
function.atEgBias=0;
294
function.reverbRate=0;
295
globalDetune=0;
296
//Name
297
name="INIT VOICE";
298
//Subcategory
299
subcategory="NONE";
300
//Category
301
category="NONE";
302
}
303
304
305
//---------------------------------------------------------
306
// findPreset
307
// return the first preset corresponding of lbank and prog
308
//---------------------------------------------------------
309
Preset* presetSet::findPreset(int lbank, int prog) {
310
std::vector<Preset*>::iterator pvi;
311
for(pvi=_presetVector.begin(); pvi!=_presetVector.end(); pvi++)
312
if((*pvi)->bank==lbank && (*pvi)->prog==prog) {
313
return(*pvi);
314
}
315
return NULL;
316
}
317
Preset* subcategorySet::findPreset(int lbank, int prog) {
318
Preset* p_preset;
319
std::vector<presetSet*>::iterator psvi;
320
for(psvi=_subcategoryVector.begin();psvi!=_subcategoryVector.end(); psvi++)
321
{
322
p_preset=(*psvi)->findPreset(lbank, prog);
323
if(p_preset) return p_preset;
324
}
325
return NULL;
326
}
327
Preset* categorySet::findPreset(int lbank, int prog) {
328
Preset* p_preset;
329
std::vector<subcategorySet*>::iterator ssvi;
330
for(ssvi=_categoryVector.begin(); ssvi!=_categoryVector.end(); ssvi++)
331
{
332
p_preset=(*ssvi)->findPreset(lbank, prog);
333
if(p_preset) return p_preset;
334
}
335
return NULL;
336
}
337
Preset* DeicsOnze::findPreset(int lbank, int prog) {
338
return _categorySet->findPreset(lbank, prog);
339
}
340
341
//---------------------------------------------------------
342
// findSubcategorySet
343
// take string of a category and return the subcategorySet
344
//---------------------------------------------------------
345
subcategorySet* categorySet::findSubcategorySet(std::string s) {
346
std::vector<subcategorySet*>::iterator ssvi=_categoryVector.begin();
347
while(ssvi!=_categoryVector.end() && s!=(*ssvi)->_categoryName) ssvi++;
348
return(*ssvi);
349
}
350
//---------------------------------------------------------
351
// findPresetSet
352
// take string of a subcategory and return the presetSet
353
//---------------------------------------------------------
354
presetSet* subcategorySet::findPresetSet(std::string s) {
355
std::vector<presetSet*>::iterator pvi=_subcategoryVector.begin();
356
while(pvi!=_subcategoryVector.end() && s!=(*pvi)->_subcategoryName) pvi++;
357
//if (pvi==NULL) printf("presetSet %s doesn't exist!", s);
358
return(*pvi);
623
void DeicsOnze::initVoices(int c) {
624
for(int v=0; v<MAXNBRVOICES; v++) {
625
initVoice(c, v);
626
_global.channel[c].lastVoiceKeyOn.clear();
627
}
628
}
629
630
//--------------------------------------------------------
631
// findPreset findSubcategory findCategory
632
//--------------------------------------------------------
633
Preset* DeicsOnze::findPreset(int hbank, int lbank, int prog) const {
634
return _set->findPreset(hbank, lbank, prog);
635
}
636
Subcategory* DeicsOnze::findSubcategory(int hbank, int lbank) const {
637
return _set->findSubcategory(hbank, lbank);
638
}
639
Category* DeicsOnze::findCategory(int hbank) const {
640
return _set->findCategory(hbank);
641
}
642
//---------------------------------------------------------
643
// isPitchEnv
644
// return true iff all levels are in the middle
645
//---------------------------------------------------------
646
inline bool isPitchEnv(PitchEg* pe) {
647
return(pe->pl1 != 50 || pe->pl2 != 50 || pe->pl3 != 50);
648
}
649
//---------------------------------------------------------
650
// getPitchEnvCoefInct
651
// returns the coefInct according to level pl
652
//---------------------------------------------------------
653
inline double getPitchEnvCoefInct(int pl) {
654
/*
655
pl = 0 <--> -4oct, pl = 50 <--> 0oct, pl = 100 <--> 4oct
656
657
y = a * exp((pl - 50)/b)
658
1.0 = a*exp(0) ==> a = 1.0
659
8.0 = exp(50/b) ==> log 8.0 = 50/b ==> b = 50/log(8.0)
660
*/
661
double b = 50.0/log(8.0);
662
return exp((pl-50.0)/b);
663
}
664
665
//---------------------------------------------------------
666
// getPitchEnvCoefInctInct
667
//---------------------------------------------------------
668
inline double getPitchEnvCoefInctInct(int pl1, int pl2, int pr, double sr) {
669
//TODO : depending on the sampleRate
670
int a = pr;
671
double c = 1.0 + COEFPITCHENV*((double)(a*a)+1.0);
672
double inctInct = exp(log(c)*48000.0/sr);
673
if(pl1<pl2) return(inctInct);
674
else if(pl1>pl2)
675
return(1.0/inctInct);
676
else return 1.0;
677
}
678
679
//---------------------------------------------------------
680
// existsKeyOn
681
//---------------------------------------------------------
682
bool DeicsOnze::existsKeyOn(int ch) {
683
return !_global.channel[ch].lastVoiceKeyOn.empty();
359
684
}
360
685
361
686
//---------------------------------------------------------
373
698
// delay2Time
374
699
// return the time in second corresponding to the LFO delay parameter
375
700
//---------------------------------------------------------
376
inline double delay2Time(int d)
377
{
378
double t;
379
//fitting
380
t=0.07617*(double)d-0.002695*(double)(d*d)+4.214e-05*(double)(d*d*d);
381
//printf("delay2Time : %f\n", t);
382
return(t);
701
inline double delay2Time(int d) {
702
double t;
703
//fitting
704
t=0.07617*(double)d-0.002695*(double)(d*d)+4.214e-05*(double)(d*d*d);
705
//printf("delay2Time : %f\n", t);
706
return(t);
383
707
}
384
708
709
//----------------------------------------------------------------
710
// setNbrVoices
711
//----------------------------------------------------------------
712
void DeicsOnze::setNbrVoices(int c, int nv) {
713
nv=(nv>MAXNBRVOICES?MAXNBRVOICES:(nv<1?1:nv));
714
//we assume that any voices
715
//that is not included in the active voices is properly initialized
716
for(int v=nv; v<_global.channel[c].nbrVoices; v++)
717
initVoice(c, v);
718
_global.channel[c].nbrVoices=nv;
719
}
385
720
386
721
//----------------------------------------------------------------
387
722
// setMasterVol
388
723
//----------------------------------------------------------------
389
void DeicsOnze::setMasterVol(int mv)
390
{
391
_global.amp=(double)mv/(double)MAXMASTERVOL;
392
}
393
724
void DeicsOnze::setMasterVol(int mv) {
725
_global.masterVolume=level2amp(mv); //watch out that MAXMASTERVOLUME==255
726
}
727
//----------------------------------------------------------------
728
// setChannelEnable
729
//----------------------------------------------------------------
730
void DeicsOnze::setChannelEnable(int c, bool e) {
731
_global.channel[c].isEnable = e;
732
setLfo(c);
733
}
734
735
//----------------------------------------------------------------
736
// setChannelVol
737
//----------------------------------------------------------------
738
void DeicsOnze::setChannelVol(int c, int v) {
739
_global.channel[c].volume = v;
740
}
741
742
void DeicsOnze::applyChannelAmp(int c) {
743
_global.channel[c].ampLeft =
744
level2amp(_global.channel[c].volume)
745
* ((double)(MAXCHANNELPAN - _global.channel[c].pan)
746
/(double)(2*MAXCHANNELPAN));
747
_global.channel[c].ampRight =
748
level2amp(_global.channel[c].volume)
749
* ((double)(MAXCHANNELPAN + _global.channel[c].pan)
750
/(double)(2*MAXCHANNELPAN));
751
}
752
753
//----------------------------------------------------------------
754
// setChannelPan
755
//----------------------------------------------------------------
756
void DeicsOnze::setChannelPan(int c, int p) {
757
_global.channel[c].pan = p;
758
}
759
//----------------------------------------------------------------
760
// setChannelDetune
761
//----------------------------------------------------------------
762
void DeicsOnze::setChannelDetune(int c, int p) {
763
_global.channel[c].detune = p;
764
}
765
//----------------------------------------------------------------
766
// setChannelBrightness
767
//----------------------------------------------------------------
768
void DeicsOnze::setChannelBrightness(int c, int b) {
769
_global.channel[c].brightness = b;
770
}
771
//----------------------------------------------------------------
772
// setChannelModulation
773
//----------------------------------------------------------------
774
void DeicsOnze::setChannelModulation(int c, int m) {
775
_global.channel[c].modulation = m;
776
}
777
//----------------------------------------------------------------
778
// setChannelAttack
779
//----------------------------------------------------------------
780
void DeicsOnze::setChannelAttack(int c, int a) {
781
_global.channel[c].attack = a;
782
}
783
//----------------------------------------------------------------
784
// setChannelRelease
785
//----------------------------------------------------------------
786
void DeicsOnze::setChannelRelease(int c, int r) {
787
_global.channel[c].release = r;
788
}
789
//----------------------------------------------------------------
790
// setChannelReverb
791
//----------------------------------------------------------------
792
void DeicsOnze::setChannelReverb(int c, int r) {
793
_global.channel[c].reverbAmount = (float)lowlevel2amp(r);
794
}
795
//----------------------------------------------------------------
796
// setChannelChorus
797
//----------------------------------------------------------------
798
void DeicsOnze::setChannelChorus(int c, int val) {
799
_global.channel[c].chorusAmount = (float)lowlevel2amp(val);
800
}
801
//----------------------------------------------------------------
802
// setChannelDelay
803
//----------------------------------------------------------------
804
void DeicsOnze::setChannelDelay(int c, int val) {
805
_global.channel[c].delayAmount = (float)lowlevel2amp(val);
806
}
807
808
//----------------------------------------------------------------
809
// setChorusReturn
810
//----------------------------------------------------------------
811
void DeicsOnze::setChorusReturn(int val) {
812
_global.chorusReturn = 2.0*(float)level2amp(val); //beware MAXFXRETURN==255
813
}
814
815
//----------------------------------------------------------------
816
// setReverbReturn
817
//----------------------------------------------------------------
818
void DeicsOnze::setReverbReturn(int val) {
819
_global.reverbReturn = 2.0*(float)level2amp(val); //beware MAXFXRETURN==255
820
}
821
822
//----------------------------------------------------------------
823
// setDelayReturn
824
//----------------------------------------------------------------
825
void DeicsOnze::setDelayReturn(int val) {
826
_global.delayReturn = 2.0*(float)level2amp(val); //beware MAXFXRETURN==255
827
}
828
829
//----------------------------------------------------------------
830
// getNbrVoices
831
//----------------------------------------------------------------
832
int DeicsOnze::getNbrVoices(int c) const {
833
return(_global.channel[c].nbrVoices);
834
}
394
835
//----------------------------------------------------------------
395
836
// getMasterVol
396
837
//----------------------------------------------------------------
397
int DeicsOnze::getMasterVol()
398
{
399
return((int)(_global.amp*(double)MAXMASTERVOL));
838
int DeicsOnze::getMasterVol(void) const {
839
return(amp2level(_global.masterVolume));
840
}
841
//----------------------------------------------------------------
842
// getFilter
843
//----------------------------------------------------------------
844
bool DeicsOnze::getFilter(void) const {
845
return _global.filter;
846
}
847
//----------------------------------------------------------------
848
// getChannelEnable
849
//----------------------------------------------------------------
850
bool DeicsOnze::getChannelEnable(int c) const {
851
return _global.channel[c].isEnable;
852
}
853
854
//----------------------------------------------------------------
855
// getChannelVol
856
//----------------------------------------------------------------
857
int DeicsOnze::getChannelVol(int c) const { //TODO : to see if correct
858
//return((int)(MAX(_global.channel[c].ampLeft, _global.channel[c].ampRight)
859
//*(double)MAXCHANNELVOLUME));
860
return(_global.channel[c].volume);
861
}
862
//----------------------------------------------------------------
863
// getChannelPan
864
//----------------------------------------------------------------
865
int DeicsOnze::getChannelPan(int c) const {
866
return(_global.channel[c].pan);
867
}
868
//----------------------------------------------------------------
869
// setChannelDetune
870
//----------------------------------------------------------------
871
int DeicsOnze::getChannelDetune(int c) const {
872
return _global.channel[c].detune;
873
}
874
//----------------------------------------------------------------
875
// getChannelBrightness
876
//----------------------------------------------------------------
877
int DeicsOnze::getChannelBrightness(int c) const {
878
return(_global.channel[c].brightness);
879
}
880
//----------------------------------------------------------------
881
// getChannelModulation
882
//----------------------------------------------------------------
883
int DeicsOnze::getChannelModulation(int c) const {
884
return(_global.channel[c].modulation);
885
}
886
//----------------------------------------------------------------
887
// getChannelAttack
888
//----------------------------------------------------------------
889
int DeicsOnze::getChannelAttack(int c) const {
890
return(_global.channel[c].attack);
891
}
892
//----------------------------------------------------------------
893
// getChannelRelease
894
//----------------------------------------------------------------
895
int DeicsOnze::getChannelRelease(int c) const {
896
return(_global.channel[c].release);
897
}
898
//----------------------------------------------------------------
899
// getChannelReverb
900
//----------------------------------------------------------------
901
int DeicsOnze::getChannelReverb(int c) const {
902
return(amp2lowlevel(_global.channel[c].reverbAmount));
903
}
904
//----------------------------------------------------------------
905
// getChannelChorus
906
//----------------------------------------------------------------
907
int DeicsOnze::getChannelChorus(int c) const {
908
return(amp2lowlevel(_global.channel[c].chorusAmount));
909
}
910
//----------------------------------------------------------------
911
// getChannelDelay
912
//----------------------------------------------------------------
913
int DeicsOnze::getChannelDelay(int c) const {
914
return(amp2lowlevel(_global.channel[c].delayAmount));
915
}
916
//----------------------------------------------------------------
917
// getChorusReturn
918
//----------------------------------------------------------------
919
int DeicsOnze::getChorusReturn() const {
920
return(amp2level(_global.chorusReturn/2.0));
921
}
922
//----------------------------------------------------------------
923
// getReverbReturn
924
//----------------------------------------------------------------
925
int DeicsOnze::getReverbReturn() const {
926
return(amp2level(_global.reverbReturn/2.0));
927
}
928
//----------------------------------------------------------------
929
// getReverbReturn
930
//----------------------------------------------------------------
931
int DeicsOnze::getDelayReturn() const {
932
return(amp2level(_global.delayReturn/2.0));
400
933
}
401
934
402
935
//----------------------------------------------------------------
403
936
// setLfo
404
937
//----------------------------------------------------------------
405
406
void DeicsOnze::setLfo()
938
void DeicsOnze::setLfo(int c/*channel*/)
407
939
{
408
940
double x;
409
x=(double)_preset->lfo.speed;
941
x=(double)_preset[c]->lfo.speed;
410
942
// lfoSpeed to Hz, obtained by fitting the actual curve by a polynomial
411
_global.lfoFreq=-1.9389e-08*x*x*x*x*x+2.8826e-06*x*x*x*x-9.0316e-05*x*x*x
412
+4.7453e-03*x*x-1.2295e-02*x+7.0347e-02;//a revoir
943
_global.channel[c].lfoFreq =
944
-1.9389e-08*x*x*x*x*x+2.8826e-06*x*x*x*x-9.0316e-05*x*x*x
945
+4.7453e-03*x*x-1.2295e-02*x+7.0347e-02;//a revoir
413
946
//Pitch LFO
414
_global.lfoMaxIndex=(_global.lfoFreq==0?0:(int)((1.0/_global.lfoFreq)
415
*(double)sampleRate()));
416
_global.lfoPitch=(((double)_preset->lfo.pModDepth/(double)MAXPMODDEPTH)
417
*(COEFPLFO(_preset->sensitivity.pitch)));
947
_global.channel[c].lfoMaxIndex =
948
(_global.channel[c].lfoFreq==0?0:(int)((1.0/_global.channel[c].lfoFreq)
949
*(double)_global.deiSampleRate));
950
double totalpDepth =
951
((double)_preset[c]->lfo.pModDepth +
952
(((double)_global.channel[c].modulation)/127.0)
953
* ((double)(MAXPMODDEPTH - _preset[c]->lfo.pModDepth))
954
)/(double)MAXPMODDEPTH;
955
_global.channel[c].lfoPitch =
956
totalpDepth * (COEFPLFO(_preset[c]->sensitivity.pitch));
418
957
//Amplitude LFO
419
_global.lfoMaxAmp=(((double)_preset->lfo.aModDepth/(double)MAXAMODDEPTH)
420
*(COEFALFO(_preset->sensitivity.amplitude)));
421
//index is concidered on the frequency of the delay
422
_global.lfoDelayMaxIndex=delay2Time(_preset->lfo.delay)*_global.lfoFreq;
423
_global.lfoDelayInct=(double)(RESOLUTION/4)/_global.lfoDelayMaxIndex;
424
}
425
958
double totalaDepth =
959
((double)_preset[c]->lfo.aModDepth +
960
(((double)_global.channel[c].modulation)/127.0)
961
* ((double)(MAXAMODDEPTH - _preset[c]->lfo.aModDepth))
962
)/(double)MAXAMODDEPTH;
963
_global.channel[c].lfoMaxAmp =
964
totalaDepth * (COEFALFO(_preset[c]->sensitivity.amplitude));
965
//index is concidered on the half of the frequency of the LFO
966
_global.channel[c].lfoDelayMaxIndex =
967
delay2Time(_preset[c]->lfo.delay)*_global.channel[c].lfoFreq*2;
968
_global.channel[c].lfoDelayInct =
969
(double)(RESOLUTION/4)/_global.channel[c].lfoDelayMaxIndex;
970
971
//update the actuall values controlling the modulation now
972
if(_global.channel[c].lfoDelayIndex<(double)(RESOLUTION/4)) {
973
double delayCoef =
974
(double)waveTable[W2][(int)_global.channel[c].lfoDelayIndex];
975
_global.channel[c].lfoMaxCoefInct =
976
exp((log(2.0)/12.0)*_global.channel[c].lfoPitch*delayCoef);
977
_global.channel[c].lfoCoefInctInct =
978
exp((log(2.0)/12.0)*((2*_global.channel[c].lfoPitch*delayCoef)
979
/_global.channel[c].lfoMaxIndex));
980
_global.channel[c].lfoMaxDAmp = delayCoef*_global.channel[c].lfoMaxAmp;
981
}
982
else
983
if(_global.channel[c].delayPassed) {
984
_global.channel[c].lfoMaxCoefInct =
985
exp((log(2.0)/12.0)*_global.channel[c].lfoPitch);
986
_global.channel[c].lfoCoefInctInct=
987
exp((log(2.0)/12.0)*((2*_global.channel[c].lfoPitch)
988
/_global.channel[c].lfoMaxIndex));
989
_global.channel[c].lfoMaxDAmp=_global.channel[c].lfoMaxAmp;
990
}
991
}
992
993
//-----------------------------------------------------------------
994
// setOutLevel
995
//-----------------------------------------------------------------
996
void DeicsOnze::setOutLevel(int c, int k) {
997
for(int v=0; v<_global.channel[c].nbrVoices; v++) {
998
if(_global.channel[c].voices[v].op[k].envState!=OFF) {
999
_global.channel[c].voices[v].op[k].amp =
1000
outLevel2Amp(_preset[c]->outLevel[k])
1001
* _global.channel[c].voices[v].op[k].ampVeloNote
1002
* brightness2Amp(c, k);
1003
}
1004
}
1005
}
1006
void DeicsOnze::setOutLevel(int c) {
1007
for(int k=0; k<NBROP; k++) {
1008
setOutLevel(c, k);
1009
}
1010
}
1011
//-----------------------------------------------------------------
1012
// setEnvAttack
1013
//-----------------------------------------------------------------
1014
void DeicsOnze::setEnvAttack(int c, int v, int k) {
1015
if(_global.channel[c].voices[v].op[k].envState==ATTACK)
1016
_global.channel[c].voices[v].op[k].envInct=
1017
(_preset[c]->eg[k].ar==0?0:
1018
(double)(RESOLUTION/4)/(envAR2s(_preset[c]->eg[k].ar)
1019
*_global.deiSampleRate))
1020
*coefAttack(_global.channel[c].attack);
1021
}
1022
void DeicsOnze::setEnvAttack(int c, int k) {
1023
for(int v=0; v<_global.channel[c].nbrVoices; v++) setEnvAttack(c, v, k);
1024
}
1025
void DeicsOnze::setEnvAttack(int c) {
1026
for(int k=0; k<NBROP; k++) setEnvAttack(c, k);
1027
}
1028
//-----------------------------------------------------------------
1029
// setEnvRelease
1030
//-----------------------------------------------------------------
1031
void DeicsOnze::setEnvRelease(int c, int v, int k) {
1032
if(_global.channel[c].voices[v].op[k].envState==RELEASE)
1033
_global.channel[c].voices[v].op[k].coefVLevel =
1034
envRR2coef(_preset[c]->eg[k].rr, _global.deiSampleRate,
1035
_global.channel[c].release);
1036
}
1037
void DeicsOnze::setEnvRelease(int c, int k) {
1038
for(int v=0; v<_global.channel[c].nbrVoices; v++) setEnvRelease(c, v, k);
1039
}
1040
void DeicsOnze::setEnvRelease(int c) {
1041
for(int k=0; k<NBROP; k++) setEnvRelease(c, k);
1042
}
1043
//-----------------------------------------------------------------
1044
// setPitchEnvRelease
1045
//-----------------------------------------------------------------
1046
void DeicsOnze::setPitchEnvRelease(int c, int v) {
1047
if(isPitchEnv(&_preset[c]->pitchEg)) {
1048
if(_global.channel[c].voices[v].pitchEnvCoefInct
1049
> _global.channel[c].voices[v].pitchEnvCoefInctPhase1) {
1050
_global.channel[c].voices[v].pitchEnvCoefInctInct =
1051
getPitchEnvCoefInctInct(1, 0, _preset[c]->pitchEg.pr3,
1052
_global.deiSampleRate);
1053
_global.channel[c].voices[v].pitchEnvState = RELEASE_PE;
1054
}
1055
else if(_global.channel[c].voices[v].pitchEnvCoefInct
1056
< _global.channel[c].voices[v].pitchEnvCoefInctPhase1) {
1057
_global.channel[c].voices[v].pitchEnvCoefInctInct =
1058
getPitchEnvCoefInctInct(0, 1, _preset[c]->pitchEg.pr3,
1059
_global.deiSampleRate);
1060
_global.channel[c].voices[v].pitchEnvState = RELEASE_PE;
1061
}
1062
else {
1063
_global.channel[c].voices[v].pitchEnvCoefInctInct = 1.0;
1064
_global.channel[c].voices[v].pitchEnvState = OFF_PE;
1065
}
1066
}
1067
}
1068
1069
//-----------------------------------------------------------------
1070
// setQuality
1071
//-----------------------------------------------------------------
1072
void DeicsOnze::setQuality(Quality q) {
1073
_global.quality = q;
1074
switch(q) {
1075
case high :
1076
_global.qualityCounterTop = 1;
1077
break;
1078
case middle :
1079
_global.qualityCounterTop = 2;
1080
break;
1081
case low :
1082
_global.qualityCounterTop = 4;
1083
break;
1084
case ultralow :
1085
_global.qualityCounterTop = 6;
1086
break;
1087
default : printf("Error switch setQuality : out of value\n");
1088
break;
1089
}
1090
//calculate _global.deiSampleRate
1091
_global.deiSampleRate = (double)sampleRate()
1092
/ (double)_global.qualityCounterTop;
1093
_global.qualityCounter = 0;
1094
//update lfo to consider the new samplerate
1095
for(int c = 0; c < 16; c++) if(_global.channel[c].isEnable) setLfo(c);
1096
//update the cutoffs of the filters
1097
_dryFilter->setCutoff(_global.deiSampleRate/4.0);
1098
_reverbFilter->setCutoff(_global.deiSampleRate/4.0);
1099
_chorusFilter->setCutoff(_global.deiSampleRate/4.0);
1100
_delayFilter->setCutoff(_global.deiSampleRate/4.0);
1101
}
1102
1103
//-----------------------------------------------------------------
1104
// setFilter
1105
//-----------------------------------------------------------------
1106
void DeicsOnze::setFilter(bool f) {
1107
_global.filter = f;
1108
}
1109
//-----------------------------------------------------------------
1110
// brightness2Amp
1111
//-----------------------------------------------------------------
1112
double DeicsOnze::brightness2Amp(int c, int k) {
1113
if(
1114
(k==1 && (_preset[c]->algorithm!=SIXTH || _preset[c]->algorithm!=SEVENTH
1115
|| _preset[c]->algorithm!=EIGHTH))
1116
||
1117
(k==2 && (_preset[c]->algorithm==FIRST || _preset[c]->algorithm==SECOND
1118
|| _preset[c]->algorithm==THIRD || _preset[c]->algorithm==FOURTH))
1119
||
1120
(k==3 && (_preset[c]->algorithm!=EIGHTH))
1121
) {
1122
double x = 2.0*(double)_global.channel[c].brightness
1123
/ (double)MAXFINEBRIGHTNESS;
1124
double square_x = x*x;
1125
return(square_x*x);
1126
}
1127
else return(1.0);
1128
}
426
1129
//-----------------------------------------------------------------
427
1130
// setFeedback
428
1131
//-----------------------------------------------------------------
429
void DeicsOnze::setFeedback() {
430
_global.feedbackAmp=COEFFEEDBACK*exp(log(2)*(double)(_preset->feedback
431
-MAXFEEDBACK));
1132
void DeicsOnze::setFeedback(int c) {
1133
_global.channel[c].feedbackAmp =
1134
COEFFEEDBACK*exp(log(2)*(double)(_preset[c]->feedback-MAXFEEDBACK));
432
1135
}
433
1136
434
1137
//-----------------------------------------------------------------
435
1138
// setPreset
436
1139
//-----------------------------------------------------------------
437
1140
438
void DeicsOnze::setPreset() {
439
setFeedback();
440
setLfo();
441
}
442
443
//---------------------------------------------------------
444
// printPreset
445
//---------------------------------------------------------
446
447
inline void printPreset(Preset* p)
448
{
449
printf("\n");
450
printf("Algorithm : %d, Feedback : %d\n", p->algorithm, p->feedback);
451
printf("LFO : ");
452
switch(p->lfo.wave)
453
{
454
case(SAWUP) : printf("SAWUP ,"); break;
455
case(SQUARE) : printf("SQUARE ,"); break;
456
case(TRIANGL) : printf("TRIANGL ,"); break;
457
case(SHOLD) : printf("SHOLD ,"); break;
458
default : printf("No defined, "); break;
459
}
460
printf("Speed : %d, Delay : %d, PModD : %d, AModD : %d, ",
461
p->lfo.speed, p->lfo.delay, p->lfo.pModDepth, p->lfo.aModDepth);
462
if(p->lfo.sync) printf("Sync\n"); else printf("Not Sync\n");
463
printf("LFO Pitch Sensitivity : %d, LFO Amplitude Sensitivity : %d\n",
464
p->sensitivity.pitch, p->sensitivity.amplitude);
465
for(int i=0; i<NBROP; i++)
466
{
467
printf("amp%d ",i+1);
468
if(p->sensitivity.ampOn) printf("ON "); else printf("OFF ");
469
}
470
printf("\n");
471
for(int i=0; i<NBROP; i++)
472
printf("EgBias%d : %d ",i+1, p->sensitivity.egBias[i]);
473
printf("\n");
474
for(int i=0; i<NBROP; i++)
475
printf("KVS%d : %d ",i+1, p->sensitivity.keyVelocity[i]);
476
printf("\n");
477
for(int i=0; i<NBROP; i++)
478
{
479
if(p->frequency[i].isFix)
480
printf("Freq%d : %f ",i+1, p->frequency[i].ratio);
481
else printf("Ratio%d : %f ",i+1, p->frequency[i].ratio);
482
}
483
printf("\n");
484
for(int i=0; i<NBROP; i++)
485
{
486
printf("OscWave%d ", i+1);
487
switch(p->oscWave[i])
488
{
489
case(W1) : printf("W1 "); break;
490
case(W2) : printf("W2 "); break;
491
case(W3) : printf("W3 "); break;
492
case(W4) : printf("W4 "); break;
493
case(W5) : printf("W5 "); break;
494
case(W6) : printf("W6 "); break;
495
case(W7) : printf("W7 "); break;
496
case(W8) : printf("W8 "); break;
497
default : printf("No defined "); break;
498
}
499
}
500
printf("\n");
501
for(int i=0; i<NBROP; i++)
502
printf("Detune%d : %d ",i+1, p->detune[i]);
503
printf("\n");
504
for(int i=0; i<NBROP; i++)
505
{
506
printf("AR%d : %d, D1R%d : %d, D1L%d : %d, D2R%d : %d, RR%d : %d, EgShift%d : ",
507
i+1, p->eg[i].ar, i+1, p->eg[i].d1r,
508
i+1, p->eg[i].d1l, i+1, p->eg[i].d2r, i+1, p->eg[i].rr, i+1);
509
switch(p->eg[i].egShift)
510
{
511
case(VOF) : printf("VOF");
512
case(V48) : printf("48");
513
case(V24) : printf("24");
514
case(V12) : printf("12");
515
}
516
printf("\n");
517
}
518
printf("PitchEg pr1 : %d, pr2 : %d, pr3 : %d, pl1 : %d, pl2 : %d, pl3 : %d"
519
, p->pitchEg.pr1, p->pitchEg.pr2, p->pitchEg.pr3,
520
p->pitchEg.pl1, p->pitchEg.pl2, p->pitchEg.pl3);
521
printf("\n");
522
for(int i=0; i<NBROP; i++)
523
printf("OutLevel%d : %d ",i+1, p->outLevel[i]);
524
printf("\n");
525
printf("Name : %s\n", p->name.c_str());
526
}
527
528
void presetSet::printSubcategory() {
529
std::cout << " " << _subcategoryName << "\n";
530
for(unsigned int i=0; i<_presetVector.size(); i++)
531
printPreset(_presetVector[i]);
532
}
533
534
void subcategorySet::printCategory() {
535
std::cout << " " << _categoryName << "\n";
536
for(unsigned int i=0; i<_subcategoryVector.size(); i++)
537
_subcategoryVector[i]->printSubcategory();
538
}
539
540
void categorySet::printBank() {
541
std::cout << _bankName << "\n";
542
for(unsigned int i=0; i<_categoryVector.size(); i++)
543
_categoryVector[i]->printCategory();
544
}
545
546
inline double coarseFine2Ratio(int c,int f)
547
{
548
double tab[64][16]=
549
{
550
{0.50,0.56,0.62,0.68,0.75,0.81,0.87,0.93,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
551
{0.71,0.79,0.88,0.96,1.05,1.14,1.23,1.32,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
552
{0.78,0.88,0.98,1.07,1.17,1.27,1.37,1.47,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
553
{0.87,0.97,1.08,1.18,1.29,1.40,1.51,1.62,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
554
{1.00,1.06,1.12,1.18,1.25,1.31,1.37,1.43,1.50,1.56,1.62,1.68,1.75,1.81,1.87,1.93},
555
{1.41,1.49,1.58,1.67,1.76,1.85,1.93,2.02,2.11,2.20,2.29,2.37,2.46,2.55,2.64,2.73},
556
{1.57,1.66,1.76,1.86,1.96,2.06,2.15,2.25,2.35,2.45,2.55,2.64,2.74,2.84,2.94,3.04},
557
{1.73,1.83,1.94,2.05,2.16,2.27,2.37,2.48,2.59,2.70,2.81,2.91,3.02,3.13,3.24,3.35},
558
{2.00,2.06,2.12,2.18,2.25,2.31,2.37,2.43,2.50,2.56,2.62,2.68,2.75,2.81,2.87,2.93},
559
{2.82,2.90,2.99,3.08,3.17,3.26,3.34,3.43,3.52,3.61,3.70,3.78,3.87,3.96,4.05,3.14},
560
{3.00,3.06,3.12,3.18,3.25,3.31,3.37,3.43,3.50,3.56,3.62,3.68,3.75,3.81,3.87,3.93} ,
561
{3.14,3.23,3.33,3.43,3.53,3.63,3.72,3.82,3.92,4.02,4.12,4.21,4.31,4.41,4.51,4.61},
562
{3.46,3.56,3.67,3.78,3.89,4.00,4.10,4.21,4.32,4.43,4.54,4.64,4.75,4.86,4.97,5.08},
563
{4.00,4.06,4.12,4.18,4.25,4.31,4.37,4.43,4.50,4.56,4.62,4.68,4.75,4.81,4.87,4.93},
564
{4.24,4.31,4.40,4.49,4.58,4.67,4.75,4.84,4.93,5.02,5.11,5.19,5.28,5.37,5.46,5.55},
565
{4.71,4.80,4.90,5.00,5.10,5.20,5.29,5.39,5.49,5.59,5.69,5.78,5.88,5.98,6.08,6.18},
566
{5.00,5.06,5.12,5.18,5.25,5.31,5.37,5.43,5.50,5.56,5.62,5.68,5.75,5.81,5.87,5.93},
567
{5.19,5.29,5.40,5.51,5.62,5.73,5.83,5.94,6.05,6.16,6.27,6.37,6.48,6.59,6.70,6.81},
568
{5.65,5.72,5.81,5.90,5.99,6.08,6.16,6.25,6.34,6.43,6.52,6.60,6.69,6.78,6.87,6.96},
569
{6.00,6.06,6.12,6.18,6.25,6.31,6.37,6.43,6.50,6.56,6.62,6.68,6.75,6.81,6.87,6.93},
570
{6.28,6.37,6.47,6.57,6.67,6.77,6.86,6.96,7.06,7.16,7.26,7.35,7.45,7.55,7.65,7.75},
571
{6.92,7.02,7.13,7.24,7.35,7.46,7.56,7.67,7.78,7.89,8.00,8.10,8.21,8.32,8.43,8.54},
572
{7.00,7.06,7.12,7.18,7.25,7.31,7.37,7.43,7.50,7.56,7.62,7.68,7.75,7.81,7.87,7.93},
573
{7.07,7.13,7.22,7.31,7.40,7.49,7.57,7.66,7.75,7.84,7.93,8.01,8.10,8.19,8.28,8.37},
574
{7.85,7.94,8.04,8.14,8.24,8.34,8.43,8.53,8.63,8.73,8.83,8.92,9.02,9.12,9.22,9.32},
575
{8.00,8.06,8.12,8.18,8.25,8.31,8.37,8.43,8.50,8.56,8.62,8.68,8.75,8.81,8.87,8.93},
576
{8.48,8.54,8.63,8.72,8.81,8.90,8.98,9.07,9.16,9.25,9.34,9.42,9.51,9.60,9.69,9.78},
577
{8.65,8.75,8.86,8.97,9.08,9.19,9.29,9.40,9.51,9.62,9.73,9.83,9.94,10.05,10.16,10.27},
578
{9.00,9.06,9.12,9.18,9.25,9.31,9.37,9.43,9.50,9.56,9.62,9.68,9.75,9.81,9.87,9.93},
579
{9.42,9.51,9.61,9.71,9.81,9.91,10.00,10.10,10.20,10.30,10.40,10.49,10.59,10.69,10.79,10.89},
580
{9.89,9.95,10.04,10.13,10.22,10.31,10.39,10.48,10.57,10.66,10.75,10.83,10.92,11.01,11.10,11.19},
581
{10.00,10.06,10.12,10.18,10.25,10.31,10.37,10.43,10.50,10.56,10.62,10.68,10.75,10.81,10.87,10.93},
582
{10.38,10.48,10.59,10.70,10.81,10.92,11.02,11.13,11.24,11.35,11.46,11.56,11.67,11.78,11.89,12.00},
583
{10.99,11.08,11.18,11.28,11.38,11.48,11.57,11.67,11.77,11.87,11.97,12.06,12.16,12.26,12.36,12.46},
584
{11.00,11.06,11.12,11.18,11.25,11.31,11.37,11.43,11.50,11.56,11.62,11.68,11.75,11.81,11.87,11.93},
585
{11.30,11.36,11.45,11.54,11.63,11.72,11.80,11.89,11.98,12.07,12.16,12.24,12.33,12.42,12.51,12.60},
586
{12.00,12.06,12.12,12.18,12.25,12.31,12.37,12.43,12.50,12.56,12.62,12.68,12.75,12.81,12.87,12.93},
587
{12.11,12.21,12.32,12.43,12.54,12.65,12.75,12.86,12.97,13.08,13.19,13.29,13.40,13.51,13.62,13.73},
588
{12.56,12.65,12.75,12.85,12.95,13.05,13.14,13.24,13.34,13.44,13.54,13.63,13.73,13.83,13.93,14.03},
589
{12.72,12.77,12.86,12.95,13.04,13.13,13.21,13.30,13.39,13.48,13.57,13.65,13.74,13.83,13.92,14.01},
590
{13.00,13.06,13.12,13.18,13.25,13.31,13.37,13.43,13.50,13.56,13.62,13.68,13.75,13.81,13.87,13.93},
591
{13.84,13.94,14.05,14.16,14.27,14.38,14.48,14.59,14.70,14.81,14.92,15.02,15.13,15.24,15.35,15.46},
592
{14.00,14.06,14.12,14.18,14.25,14.31,14.37,14.43,14.50,14.56,14.62,14.68,14.75,14.81,14.87,14.93},
593
{14.10,14.18,14.27,14.36,14.45,14.54,14.62,14.71,14.80,14.89,14.98,15.06,15.15,15.24,15.33,15.42},
594
{14.13,14.22,14.32,14.42,14.52,14.62,14.71,14.81,14.91,15.01,15.11,15.20,15.30,15.40,15.50,15.60},
595
{15.00,15.06,15.12,15.18,15.25,15.31,15.37,15.43,15.50,15.56,15.62,15.68,15.75,15.81,15.87,15.93},
596
{15.55,15.59,15.68,15.77,15.86,15.95,16.03,16.12,16.21,16.30,16.39,16.47,16.56,16.65,16.74,16.83},
597
{15.57,15.67,15.78,15.89,16.00,16.11,16.21,16.32,16.43,16.54,16.65,16.75,16.86,16.97,17.08,17.19},
598
{15.70,15.79,15.89,15.99,16.09,16.19,16.28,16.38,16.48,16.58,16.68,16.77,16.87,16.97,17.07,17.17},
599
{16.96,17.00,17.09,17.18,17.27,17.36,17.44,17.53,17.62,17.71,17.80,17.88,17.97,18.06,18.15,18.24},
600
{17.27,17.36,17.46,17.56,17.66,17.76,17.85,17.95,18.05,18.15,18.25,18.34,18.44,18.54,18.64,18.74},
601
{17.30,17.40,17.51,17.62,17.73,17.84,17.94,18.05,18.16,18.27,18.38,18.48,18.59,18.70,18.81,18.92},
602
{18.37,18.41,18.50,18.59,18.68,18.77,18.85,18.94,19.03,19.12,19.21,19.29,19.38,19.47,19.56,19.65},
603
{18.84,18.93,19.03,19.13,19.23,19.33,19.42,19.52,19.62,19.72,19.82,19.91,20.01,20.11,20.21,20.31},
604
{19.03,19.13,19.24,19.35,19.46,19.57,19.67,19.78,19.89,20.00,20.11,20.21,20.32,20.43,20.54,20.65},
605
{19.78,19.82,19.91,20.00,20.09,20.18,20.26,20.35,20.44,20.53,20.62,20.70,20.79,20.88,20.97,21.06},
606
{20.41,20.50,20.60,20.70,20.80,20.90,20.99,21.09,21.19,21.29,21.39,21.48,21.58,21.68,21.78,21.88},
607
{20.76,20.86,20.97,21.08,21.19,21.30,21.40,21.51,21.62,21.73,21.84,21.94,22.05,22.16,22.27,22.38},
608
{21.20,21.23,21.32,21.41,21.50,21.59,21.67,21.76,21.85,21.94,22.03,22.11,22.20,22.29,22.38,22.47},
609
{21.98,22.07,22.17,22.17,22.37,22.47,22.56,22.66,22.76,22.86,22.96,23.05,23.15,23.25,23.35,23.45},
610
{22.49,22.59,22.70,22.81,22.92,23.03,23.13,13.24,13.35,13.46,13.57,13.67,13.78,13.89,24.00,24.11},
611
{23.55,23.64,23.74,23.84,23.94,24.04,24.13,24.23,24.33,24.43,24.53,24.62,24.72,24.82,24.92,25.02},
612
{24.22,24.32,24.43,24.54,24.65,24.76,24.86,24.97,25.08,25.19,25.30,25.40,25.51,25.62,25.73,25.84},
613
{25.95,26.05,26.16,26.27,26.38,26.49,26.59,26.70,26.81,26.92,27.03,27.13,27.24,27.35,27.46,27.57}
614
};
615
return(tab[c][f]);
616
}
617
1141
void DeicsOnze::setPreset(int c) {
1142
setFeedback(c);
1143
setLfo(c);
1144
setEnvAttack(c);
1145
setEnvRelease(c);
1146
setOutLevel(c);
1147
}
1148
1149
1150
inline double coarseFine2Ratio(int c,int f) {
1151
double tab[64][16]=
1152
{
1153
{0.50,0.56,0.62,0.68,0.75,0.81,0.87,0.93,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
1154
{0.71,0.79,0.88,0.96,1.05,1.14,1.23,1.32,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
1155
{0.78,0.88,0.98,1.07,1.17,1.27,1.37,1.47,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
1156
{0.87,0.97,1.08,1.18,1.29,1.40,1.51,1.62,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
1157
{1.00,1.06,1.12,1.18,1.25,1.31,1.37,1.43,1.50,1.56,1.62,1.68,1.75,1.81,1.87,1.93},
1158
{1.41,1.49,1.58,1.67,1.76,1.85,1.93,2.02,2.11,2.20,2.29,2.37,2.46,2.55,2.64,2.73},
1159
{1.57,1.66,1.76,1.86,1.96,2.06,2.15,2.25,2.35,2.45,2.55,2.64,2.74,2.84,2.94,3.04},
1160
{1.73,1.83,1.94,2.05,2.16,2.27,2.37,2.48,2.59,2.70,2.81,2.91,3.02,3.13,3.24,3.35},
1161
{2.00,2.06,2.12,2.18,2.25,2.31,2.37,2.43,2.50,2.56,2.62,2.68,2.75,2.81,2.87,2.93},
1162
{2.82,2.90,2.99,3.08,3.17,3.26,3.34,3.43,3.52,3.61,3.70,3.78,3.87,3.96,4.05,3.14},
1163
{3.00,3.06,3.12,3.18,3.25,3.31,3.37,3.43,3.50,3.56,3.62,3.68,3.75,3.81,3.87,3.93} ,
1164
{3.14,3.23,3.33,3.43,3.53,3.63,3.72,3.82,3.92,4.02,4.12,4.21,4.31,4.41,4.51,4.61},
1165
{3.46,3.56,3.67,3.78,3.89,4.00,4.10,4.21,4.32,4.43,4.54,4.64,4.75,4.86,4.97,5.08},
1166
{4.00,4.06,4.12,4.18,4.25,4.31,4.37,4.43,4.50,4.56,4.62,4.68,4.75,4.81,4.87,4.93},
1167
{4.24,4.31,4.40,4.49,4.58,4.67,4.75,4.84,4.93,5.02,5.11,5.19,5.28,5.37,5.46,5.55},
1168
{4.71,4.80,4.90,5.00,5.10,5.20,5.29,5.39,5.49,5.59,5.69,5.78,5.88,5.98,6.08,6.18},
1169
{5.00,5.06,5.12,5.18,5.25,5.31,5.37,5.43,5.50,5.56,5.62,5.68,5.75,5.81,5.87,5.93},
1170
{5.19,5.29,5.40,5.51,5.62,5.73,5.83,5.94,6.05,6.16,6.27,6.37,6.48,6.59,6.70,6.81},
1171
{5.65,5.72,5.81,5.90,5.99,6.08,6.16,6.25,6.34,6.43,6.52,6.60,6.69,6.78,6.87,6.96},
1172
{6.00,6.06,6.12,6.18,6.25,6.31,6.37,6.43,6.50,6.56,6.62,6.68,6.75,6.81,6.87,6.93},
1173
{6.28,6.37,6.47,6.57,6.67,6.77,6.86,6.96,7.06,7.16,7.26,7.35,7.45,7.55,7.65,7.75},
1174
{6.92,7.02,7.13,7.24,7.35,7.46,7.56,7.67,7.78,7.89,8.00,8.10,8.21,8.32,8.43,8.54},
1175
{7.00,7.06,7.12,7.18,7.25,7.31,7.37,7.43,7.50,7.56,7.62,7.68,7.75,7.81,7.87,7.93},
1176
{7.07,7.13,7.22,7.31,7.40,7.49,7.57,7.66,7.75,7.84,7.93,8.01,8.10,8.19,8.28,8.37},
1177
{7.85,7.94,8.04,8.14,8.24,8.34,8.43,8.53,8.63,8.73,8.83,8.92,9.02,9.12,9.22,9.32},
1178
{8.00,8.06,8.12,8.18,8.25,8.31,8.37,8.43,8.50,8.56,8.62,8.68,8.75,8.81,8.87,8.93},
1179
{8.48,8.54,8.63,8.72,8.81,8.90,8.98,9.07,9.16,9.25,9.34,9.42,9.51,9.60,9.69,9.78},
1180
{8.65,8.75,8.86,8.97,9.08,9.19,9.29,9.40,9.51,9.62,9.73,9.83,9.94,10.05,10.16,10.27},
1181
{9.00,9.06,9.12,9.18,9.25,9.31,9.37,9.43,9.50,9.56,9.62,9.68,9.75,9.81,9.87,9.93},
1182
{9.42,9.51,9.61,9.71,9.81,9.91,10.00,10.10,10.20,10.30,10.40,10.49,10.59,10.69,10.79,10.89},
1183
{9.89,9.95,10.04,10.13,10.22,10.31,10.39,10.48,10.57,10.66,10.75,10.83,10.92,11.01,11.10,11.19},
1184
{10.00,10.06,10.12,10.18,10.25,10.31,10.37,10.43,10.50,10.56,10.62,10.68,10.75,10.81,10.87,10.93},
1185
{10.38,10.48,10.59,10.70,10.81,10.92,11.02,11.13,11.24,11.35,11.46,11.56,11.67,11.78,11.89,12.00},
1186
{10.99,11.08,11.18,11.28,11.38,11.48,11.57,11.67,11.77,11.87,11.97,12.06,12.16,12.26,12.36,12.46},
1187
{11.00,11.06,11.12,11.18,11.25,11.31,11.37,11.43,11.50,11.56,11.62,11.68,11.75,11.81,11.87,11.93},
1188
{11.30,11.36,11.45,11.54,11.63,11.72,11.80,11.89,11.98,12.07,12.16,12.24,12.33,12.42,12.51,12.60},
1189
{12.00,12.06,12.12,12.18,12.25,12.31,12.37,12.43,12.50,12.56,12.62,12.68,12.75,12.81,12.87,12.93},
1190
{12.11,12.21,12.32,12.43,12.54,12.65,12.75,12.86,12.97,13.08,13.19,13.29,13.40,13.51,13.62,13.73},
1191
{12.56,12.65,12.75,12.85,12.95,13.05,13.14,13.24,13.34,13.44,13.54,13.63,13.73,13.83,13.93,14.03},
1192
{12.72,12.77,12.86,12.95,13.04,13.13,13.21,13.30,13.39,13.48,13.57,13.65,13.74,13.83,13.92,14.01},
1193
{13.00,13.06,13.12,13.18,13.25,13.31,13.37,13.43,13.50,13.56,13.62,13.68,13.75,13.81,13.87,13.93},
1194
{13.84,13.94,14.05,14.16,14.27,14.38,14.48,14.59,14.70,14.81,14.92,15.02,15.13,15.24,15.35,15.46},
1195
{14.00,14.06,14.12,14.18,14.25,14.31,14.37,14.43,14.50,14.56,14.62,14.68,14.75,14.81,14.87,14.93},
1196
{14.10,14.18,14.27,14.36,14.45,14.54,14.62,14.71,14.80,14.89,14.98,15.06,15.15,15.24,15.33,15.42},
1197
{14.13,14.22,14.32,14.42,14.52,14.62,14.71,14.81,14.91,15.01,15.11,15.20,15.30,15.40,15.50,15.60},
1198
{15.00,15.06,15.12,15.18,15.25,15.31,15.37,15.43,15.50,15.56,15.62,15.68,15.75,15.81,15.87,15.93},
1199
{15.55,15.59,15.68,15.77,15.86,15.95,16.03,16.12,16.21,16.30,16.39,16.47,16.56,16.65,16.74,16.83},
1200
{15.57,15.67,15.78,15.89,16.00,16.11,16.21,16.32,16.43,16.54,16.65,16.75,16.86,16.97,17.08,17.19},
1201
{15.70,15.79,15.89,15.99,16.09,16.19,16.28,16.38,16.48,16.58,16.68,16.77,16.87,16.97,17.07,17.17},
1202
{16.96,17.00,17.09,17.18,17.27,17.36,17.44,17.53,17.62,17.71,17.80,17.88,17.97,18.06,18.15,18.24},
1203
{17.27,17.36,17.46,17.56,17.66,17.76,17.85,17.95,18.05,18.15,18.25,18.34,18.44,18.54,18.64,18.74},
1204
{17.30,17.40,17.51,17.62,17.73,17.84,17.94,18.05,18.16,18.27,18.38,18.48,18.59,18.70,18.81,18.92},
1205
{18.37,18.41,18.50,18.59,18.68,18.77,18.85,18.94,19.03,19.12,19.21,19.29,19.38,19.47,19.56,19.65},
1206
{18.84,18.93,19.03,19.13,19.23,19.33,19.42,19.52,19.62,19.72,19.82,19.91,20.01,20.11,20.21,20.31},
1207
{19.03,19.13,19.24,19.35,19.46,19.57,19.67,19.78,19.89,20.00,20.11,20.21,20.32,20.43,20.54,20.65},
1208
{19.78,19.82,19.91,20.00,20.09,20.18,20.26,20.35,20.44,20.53,20.62,20.70,20.79,20.88,20.97,21.06},
1209
{20.41,20.50,20.60,20.70,20.80,20.90,20.99,21.09,21.19,21.29,21.39,21.48,21.58,21.68,21.78,21.88},
1210
{20.76,20.86,20.97,21.08,21.19,21.30,21.40,21.51,21.62,21.73,21.84,21.94,22.05,22.16,22.27,22.38},
1211
{21.20,21.23,21.32,21.41,21.50,21.59,21.67,21.76,21.85,21.94,22.03,22.11,22.20,22.29,22.38,22.47},
1212
{21.98,22.07,22.17,22.17,22.37,22.47,22.56,22.66,22.76,22.86,22.96,23.05,23.15,23.25,23.35,23.45},
1213
{22.49,22.59,22.70,22.81,22.92,23.03,23.13,13.24,13.35,13.46,13.57,13.67,13.78,13.89,24.00,24.11},
1214
{23.55,23.64,23.74,23.84,23.94,24.04,24.13,24.23,24.33,24.43,24.53,24.62,24.72,24.82,24.92,25.02},
1215
{24.22,24.32,24.43,24.54,24.65,24.76,24.86,24.97,25.08,25.19,25.30,25.40,25.51,25.62,25.73,25.84},
1216
{25.95,26.05,26.16,26.27,26.38,26.49,26.59,26.70,26.81,26.92,27.03,27.13,27.24,27.35,27.46,27.57}
1217
};
1218
return(tab[c][f]);
1219
}
1220
1221
//---------------------------------------------------------------
1222
// loadSet
1223
//---------------------------------------------------------------
1224
void DeicsOnze::loadSet(QString fileName) {
1225
// read the XML file and create DOM tree
1226
if(!fileName.isEmpty()) {
1227
QFile deicsonzeFile(fileName);
1228
if(!deicsonzeFile.open(QIODevice::ReadOnly)) {
1229
printf("Critical Error Cannot open file %s\n",
1230
fileName.toAscii().data());
1231
return;
1232
}
1233
QDomDocument domTree;
1234
if (!domTree.setContent(&deicsonzeFile )) {
1235
printf("Critical Error Parsing error for file %s\n",
1236
fileName.toAscii().data());
1237
deicsonzeFile.close();
1238
return;
1239
}
1240
deicsonzeFile.close();
1241
1242
QDomNode node = domTree.documentElement();
1243
while (!node.isNull()) {
1244
QDomElement e = node.toElement();
1245
if (e.isNull())
1246
continue;
1247
if (e.tagName() == "deicsOnzeSet") {
1248
QString version = e.attribute(QString("version"));
1249
if (version == "1.0") {
1250
for(int c = 0; c<NBRCHANNELS; c++) _preset[c]=_initialPreset;
1251
while(!_set->_categoryVector.empty())
1252
delete(*_set->_categoryVector.begin());
1253
_set->readSet(node.firstChild());
1254
//display load preset
1255
unsigned char dataUpdateGuiSet[1];
1256
dataUpdateGuiSet[0]=SYSEX_UPDATESETGUI;
1257
MidiPlayEvent evSysexUpdateGuiSet(0, 0, ME_SYSEX,
1258
(const unsigned char*)dataUpdateGuiSet,
1259
1);
1260
_gui->writeEvent(evSysexUpdateGuiSet);
1261
}
1262
else printf("unsupported *.dei file version %s\n",
1263
version.toLatin1().constData());
1264
}
1265
else printf("DeicsOnze: %s not supported\n",
1266
e.tagName().toLatin1().constData());
1267
node = node.nextSibling();
1268
}
1269
}
1270
}
618
1271
//---------------------------------------------------------------
619
1272
// loadSutulaPreset
620
1273
//---------------------------------------------------------------
629
1282
char scategory[LENGTHCATEGORY+1];
630
1283
char ssubcategory[LENGTHSUBCATEGORY+1];
631
1284
int k;
632
int nBank, nPreset;
633
634
_categorySet=new categorySet("Sutula Bank");
1285
int nhBank, nlBank, nPreset;
635
1286
Preset* presetTemp;
636
637
nBank=0;
1287
Subcategory* subcategoryTemp = NULL;
1288
Category* categoryTemp = NULL;
1289
1290
if(!_set) _set=new Set("Sutula Bank");
1291
1292
nhBank=0;
1293
nlBank=0;
638
1294
nPreset=0;
639
1295
640
QString presetPath(INSTPREFIX);
641
presetPath += "/share/muse/presets/deicsonze/ARCH_ALIN";
642
643
file = fopen (presetPath.latin1(), "rt");
1296
//QString presetPath(INSTPREFIX);
1297
//presetPath += "/share/" PACKAGEVERSION "/presets/deicsonze/ARCH_ALIN";
1298
1299
QString presetPath("/home/a-lin/sources/svnMusEDev/lmuse/muse/synti/deicsonze/ARCH_ALIN");
1300
1301
file = fopen (presetPath.toLatin1().constData(), "rt");
644
1302
if (file == NULL) {
645
1303
printf("can't open ");
646
printf(presetPath.latin1());
1304
printf(presetPath.toLatin1().constData());
647
1305
printf("\n");
648
1306
}
649
1307
else
653
1311
if (strstr(s,"* CATEGORY"))
654
1312
{
655
1313
sscanf(s, "* CATEGORY %s", scategory);
656
_categorySet->_categoryVector
657
.push_back(new subcategorySet(scategory));
1314
categoryTemp=new Category(_set, scategory,0);
658
1315
}
659
1316
if (strstr(s,"* SUBCATEGORY"))
660
1317
{
661
1318
sscanf(s, "* SUBCATEGORY %s", ssubcategory);
662
_categorySet->_categoryVector.back()->_subcategoryVector
663
.push_back(new presetSet(ssubcategory));
1319
subcategoryTemp=new Subcategory(categoryTemp,ssubcategory,0);
1320
nlBank++;
664
1321
}
665
1322
}
666
1323
while(!feof(file))
667
1324
{
668
_categorySet->_categoryVector.back()->_subcategoryVector.back()
669
->_presetVector.push_back(new Preset);
670
presetTemp=_categorySet->_categoryVector.back()
671
->_subcategoryVector.back()->_presetVector.back();
672
/************* Fill the preset *****************/
1325
1326
presetTemp=new Preset(subcategoryTemp);
1327
// Fill the preset
673
1328
//OP.4 to OP.1
674
1329
for(int kaka=(NBROP-1); kaka>=0; kaka--)
675
1330
{
780
1435
781
1436
fscanf(file, "%x", &v);//73, 75, 77, 79
782
1437
presetTemp->frequency[k].isFix=(v & 0x8)>>3;
783
presetTemp->frequency[k].freq=(v & 0x7);
1438
presetTemp->frequency[k].freq=((v & 0x7)==0?8:(v & 0x7)*16);
784
1439
presetTemp->eg[k].egShift=
785
1440
(((v & 0x30)>>4)==0?VOF:
786
1441
(((v & 0x30)>>4)==1?V48:
787
1442
(((v & 0x30)>>4)==2?V24:V12)));
788
1443
fscanf(file, "%x", &v);//74, 76, 78, 80
789
1444
fin[k]=v & 0xF;
1445
presetTemp->frequency[k].freq+=fin[k];
790
1446
presetTemp->frequency[k].ratio=
791
1447
coarseFine2Ratio(crs[k],fin[k]);
792
1448
presetTemp->oscWave[k]=
804
1460
presetTemp->function.fcPitch=v;
805
1461
fscanf(file, "%x", &v);//83
806
1462
presetTemp->function.fcAmplitude=v;
807
presetTemp->globalDetune=0;
808
809
presetTemp->subcategory=ssubcategory;
810
presetTemp->category=scategory;
811
presetTemp->bank=nBank;
1463
//presetTemp->globalDetune=0;
812
1464
presetTemp->prog=nPreset;
813
/******************** End of filling the preset ********/
1465
// End of filling the preset
814
1466
815
1467
nPreset++;
816
1468
while(fgets(s, 500, file) && !strstr(s, "** Source:"))
818
1470
if (strstr(s,"* CATEGORY"))
819
1471
{
820
1472
sscanf(s, "* CATEGORY %s", scategory);
821
_categorySet->_categoryVector
822
.push_back(new subcategorySet(scategory));
1473
nhBank++;
1474
categoryTemp=new Category(_set,scategory,nhBank);
1475
nlBank=0;
823
1476
}
824
1477
if (strstr(s,"* SUBCATEGORY"))
825
1478
{
826
sscanf(s, "* SUBCATEGORY %s", ssubcategory);
827
_categorySet->_categoryVector.back()
828
->_subcategoryVector
829
.push_back(new presetSet(ssubcategory));
830
}
831
if(strstr(s, "--Bank"))
832
{
833
nBank++;
1479
sscanf(s, "* SUBCATEGORY %s", ssubcategory);
1480
subcategoryTemp=new
1481
Subcategory(categoryTemp,ssubcategory,nlBank);
1482
nlBank++;
834
1483
nPreset=0;
835
1484
}
836
1485
}
837
1486
}
838
1487
}
839
//_categorySet->printBank();
840
1488
fclose(file);
841
1489
}
842
1490
845
1493
// return the number of the voice which is the least aloud
846
1494
// and is not is the ATTACK state
847
1495
//---------------------------------------------------------
848
int DeicsOnze::minVolu2Voice()
849
{
1496
int DeicsOnze::minVolu2Voice(int c) {
850
1497
int minVoice=0;
851
1498
double min=MAXVOLUME;
852
for(int i=0; i<NBRVOICES; i++)
1499
for(int i=0; i<_global.channel[c].nbrVoices; i++)
853
1500
{
854
min=((min>_voices[i].volume
855
&& _voices[i].op[0].envState!=ATTACK
856
&& _voices[i].op[1].envState!=ATTACK
857
&& _voices[i].op[2].envState!=ATTACK
858
&& _voices[i].op[3].envState!=ATTACK)?_voices[i].volume:min);
859
minVoice=(min==_voices[i].volume?i:minVoice);
1501
min=((min>_global.channel[c].voices[i].volume
1502
&& _global.channel[c].voices[i].op[0].envState!=ATTACK
1503
&& _global.channel[c].voices[i].op[1].envState!=ATTACK
1504
&& _global.channel[c].voices[i].op[2].envState!=ATTACK
1505
&& _global.channel[c].voices[i].op[3].envState!=ATTACK)?
1506
_global.channel[c].voices[i].volume:min);
1507
minVoice=(min==_global.channel[c].voices[i].volume?i:minVoice);
860
1508
}
861
1509
return minVoice;
862
1510
}
863
1511
864
1512
//---------------------------------------------------------
865
1513
// noteOff2Voice
866
// return the number of the voice off, NBRVOICES otherwise
1514
// return the number of one off voice, MAXNBRVOICES otherwise
867
1515
//---------------------------------------------------------
868
int DeicsOnze::noteOff2Voice()
869
{
870
int offVoice=NBRVOICES;
871
for(int i=0; i<NBRVOICES; i++) offVoice=(_voices[i].isOn?offVoice:i);
1516
int DeicsOnze::noteOff2Voice(int c) {
1517
int offVoice=MAXNBRVOICES;
1518
for(int i=0; i<_global.channel[c].nbrVoices; i++)
1519
offVoice = (_global.channel[c].voices[i].isOn
1520
|| _global.channel[c].voices[i].keyOn?
1521
offVoice:i);
872
1522
return offVoice;
873
1523
}
874
1524
875
1525
//---------------------------------------------------------
876
1526
// pitchOn2Voice
877
1527
// return the number of the voice which has the input
878
// pitch and is On and not release, NBRVOICES otherwise
1528
// pitch and is keyOn
879
1529
//---------------------------------------------------------
880
int DeicsOnze::pitchOn2Voice(int pitch)
881
{
882
int pitchVoice=NBRVOICES;
883
for(int i=0; i<NBRVOICES; i++)
884
pitchVoice=((_voices[i].pitch==pitch
885
&& _voices[i].isOn
886
&& (_voices[i].op[0].envState==ATTACK
887
|| _voices[i].op[0].envState==DECAY
888
|| _voices[i].op[0].envState==SUSTAIN)
889
&& !_voices[i].isSustained)?
890
i:pitchVoice);
1530
int DeicsOnze::pitchOn2Voice(int c, int pitch) {
1531
int pitchVoice=MAXNBRVOICES;
1532
for(int i=0; i<_global.channel[c].nbrVoices; i++) {
1533
if(_global.channel[c].voices[i].pitch==
1534
pitch && _global.channel[c].voices[i].keyOn
1535
&& !_global.channel[c].voices[i].isSustained) {
1536
pitchVoice = i;
1537
return pitchVoice;
1538
}
1539
}
891
1540
return pitchVoice;
892
1541
}
893
1542
1543
//---------------------------------------------------------
1544
// getAttractor
1545
//---------------------------------------------------------
1546
inline double getAttractor(int portamentoTime, double sr) {
1547
/* some explanations
1548
1549
c(48000) = c > 1
1550
1551
f_sr(0) = 1000, f_sr(t) = 2000
1552
1553
f_sr*2(0) = 1000, f_sr*2(t*2) = 2000
1554
1555
f_sr(t) = exp(t*ln(c(sr))) * 1000
1556
1557
2000 = exp(t*ln(c(48000))) * 1000
1558
1559
2000 = exp(t*2*ln(c(48000*2))) * 1000
1560
1561
t*ln(c(48000)) = t*2*ln(c(48000*2))
1562
1563
c(48000*m) = exp(ln(c)/m)
1564
1565
sr = 48000*m
1566
*/
1567
double c;
1568
c = 1.0 + COEFPORTA/(double)(portamentoTime*portamentoTime);
1569
return(exp(log(c)*48000.0/sr));
1570
}
894
1571
895
1572
//---------------------------------------------------------
896
1573
// pitch2freq
897
1574
//---------------------------------------------------------
898
inline double pitch2freq(double p)
899
{
900
return(LOWERNOTEFREQ*exp(p*log(2.0)/12.0));
1575
inline double pitch2freq(double p) {
1576
return(LOWERNOTEFREQ*exp(p*log(2.0)/12.0));
901
1577
}
902
1578
903
1579
//---------------------------------------------------------
904
1580
// lfoUpdate
905
// update the coefficent which multiplies the current inct in order to
1581
// update the coefficent which multiplies the current inct
1582
// in order to
906
1583
// get the right current frequency with respect to the lfo
907
1584
// update the coefficent which multiplies the amplitude.
908
1585
//---------------------------------------------------------
909
inline void lfoUpdate(Preset* p, Global* p_g, float* wt)
910
{
911
double delayCoef;
912
913
if(p_g->lfoIndex==0)
914
{
915
if(p_g->lfoDelayIndex<(double)(RESOLUTION/4))
916
{
917
delayCoef=(double)wt[(int)p_g->lfoDelayIndex];
918
p_g->lfoMaxCoefInct=exp((log(2.0)/12.0)*p_g->lfoPitch*delayCoef);
919
p_g->lfoCoefInctInct=
920
exp((log(2.0)/12.0)*((2*p_g->lfoPitch*delayCoef)
921
/p_g->lfoMaxIndex));
922
p_g->lfoDelayIndex+=p_g->lfoDelayInct;
923
p_g->lfoMaxDAmp=delayCoef*p_g->lfoMaxAmp;
924
}
925
else
926
if(!p_g->delayPassed)
927
{
928
p_g->lfoMaxCoefInct=exp((log(2.0)/12.0)*p_g->lfoPitch);
929
p_g->lfoCoefInctInct=
930
exp((log(2.0)/12.0)*((2*p_g->lfoPitch)/p_g->lfoMaxIndex));
931
p_g->delayPassed=true;
932
p_g->lfoMaxDAmp=p_g->lfoMaxDAmp;
933
}
934
}
935
936
switch(p->lfo.wave)
937
{
938
case SAWUP :
939
if(p_g->lfoIndex==0)
940
{
941
p_g->lfoCoefInct=1.0/(p_g->lfoMaxCoefInct);
942
p_g->lfoCoefAmp=p_g->lfoMaxDAmp/(double)p_g->lfoMaxIndex;
943
p_g->lfoAmp=1.0;
944
}
945
else
946
{
947
p_g->lfoCoefInct*=p_g->lfoCoefInctInct;
948
p_g->lfoAmp-=p_g->lfoCoefAmp;
949
}
950
break;
951
case SQUARE :
952
if(p_g->lfoIndex==0)
953
{
954
p_g->lfoCoefInct=p_g->lfoMaxCoefInct;
955
p_g->lfoAmp=1.0;
956
}
957
if(p_g->lfoIndex==(p_g->lfoMaxIndex/2))
958
{
959
p_g->lfoCoefInct=1.0/p_g->lfoMaxCoefInct;
960
p_g->lfoAmp=1.0-p_g->lfoMaxDAmp;
961
}
962
break;
963
case TRIANGL :
964
if(p_g->lfoIndex==0)
965
{
966
p_g->lfoCoefInct=1.0;
967
p_g->lfoCoefAmp=p_g->lfoMaxDAmp
968
/(double)(p_g->lfoMaxIndex/2);
969
p_g->lfoAmp=1.0-p_g->lfoMaxDAmp/2.0;
970
}
971
else if(p_g->lfoIndex<(p_g->lfoMaxIndex/4))
972
{
973
p_g->lfoCoefInct*=p_g->lfoCoefInctInct;
974
p_g->lfoAmp-=p_g->lfoCoefAmp;
975
}
976
else if(p_g->lfoIndex<((3*p_g->lfoMaxIndex)/4))
977
{
978
p_g->lfoCoefInct/=p_g->lfoCoefInctInct;
979
p_g->lfoAmp+=p_g->lfoCoefAmp;
980
}
981
else if(p_g->lfoIndex<p_g->lfoMaxIndex)
982
{
983
p_g->lfoCoefInct*=p_g->lfoCoefInctInct;
984
p_g->lfoAmp-=p_g->lfoCoefAmp;
985
}
986
break;
987
case SHOLD :
988
if(p_g->lfoIndex==0||p_g->lfoIndex==(p_g->lfoMaxIndex/2))
989
{
990
double r;//uniform random between -1.0 and 1.0
991
r = (double)(2*rand()-RAND_MAX)/(double)RAND_MAX;
992
p_g->lfoCoefInct=(r>=0.0?1.0+r*(p_g->lfoMaxCoefInct-1.0)
993
:1.0/(1.0-r*(p_g->lfoMaxCoefInct-1.0)));
994
p_g->lfoAmp=1.0-(r/2.0+0.5)*p_g->lfoMaxDAmp;
995
}
996
break;
997
default : printf("Error : flo wave does not exist");
998
break;
999
}
1000
p_g->lfoIndex=(p_g->lfoIndex<p_g->lfoMaxIndex?p_g->lfoIndex+1:0);
1001
//printf("indexLfo : %d\n",p_g->indexLfo);
1586
inline void lfoUpdate(Preset* p, Channel* p_c, float* wt) {
1587
double delayCoef;
1588
1589
//Manage LFO delay
1590
if(!p_c->delayPassed) {
1591
if(p_c->lfoIndex==0 || p_c->lfoIndex==p_c->lfoMaxIndex/2) {
1592
if(p_c->lfoDelayIndex<(double)(RESOLUTION/4)) {
1593
delayCoef=(double)wt[(int)p_c->lfoDelayIndex];
1594
p_c->lfoMaxCoefInct=exp((log(2.0)/12.0)*p_c->lfoPitch*delayCoef);
1595
p_c->lfoCoefInctInct=
1596
exp((log(2.0)/12.0)*((2*p_c->lfoPitch*delayCoef)/p_c->lfoMaxIndex));
1597
p_c->lfoDelayIndex+=p_c->lfoDelayInct;
1598
p_c->lfoMaxDAmp=delayCoef*p_c->lfoMaxAmp;
1599
}
1600
else {
1601
p_c->lfoMaxCoefInct=exp((log(2.0)/12.0)*p_c->lfoPitch);
1602
p_c->lfoCoefInctInct=
1603
exp((log(2.0)/12.0)*((2*p_c->lfoPitch)/p_c->lfoMaxIndex));
1604
p_c->delayPassed=true;
1605
p_c->lfoMaxDAmp=p_c->lfoMaxAmp;
1606
}
1607
}
1608
}
1609
switch(p->lfo.wave) {
1610
case SAWUP :
1611
if(p_c->lfoIndex==0) {
1612
p_c->lfoCoefInct=1.0/(p_c->lfoMaxCoefInct);
1613
p_c->lfoCoefAmp=p_c->lfoMaxDAmp/(double)p_c->lfoMaxIndex;
1614
p_c->lfoAmp=1.0;
1615
}
1616
else {
1617
p_c->lfoCoefInct*=p_c->lfoCoefInctInct;
1618
p_c->lfoAmp-=p_c->lfoCoefAmp;
1619
}
1620
break;
1621
case SQUARE :
1622
if(p_c->lfoIndex==0) {
1623
p_c->lfoCoefInct=p_c->lfoMaxCoefInct;
1624
p_c->lfoAmp=1.0;
1625
}
1626
if(p_c->lfoIndex==(p_c->lfoMaxIndex/2)) {
1627
p_c->lfoCoefInct=1.0/p_c->lfoMaxCoefInct;
1628
p_c->lfoAmp=1.0-p_c->lfoMaxDAmp;
1629
}
1630
break;
1631
case TRIANGL :
1632
if(p_c->lfoIndex==0) {
1633
p_c->lfoCoefInct=1.0;
1634
p_c->lfoCoefAmp=p_c->lfoMaxDAmp
1635
/(double)(p_c->lfoMaxIndex/2);
1636
p_c->lfoAmp=1.0-p_c->lfoMaxDAmp/2.0;
1637
}
1638
else if(p_c->lfoIndex<(p_c->lfoMaxIndex/4)) {
1639
p_c->lfoCoefInct*=p_c->lfoCoefInctInct;
1640
p_c->lfoAmp-=p_c->lfoCoefAmp;
1641
}
1642
else if(p_c->lfoIndex<((3*p_c->lfoMaxIndex)/4)) {
1643
p_c->lfoCoefInct/=p_c->lfoCoefInctInct;
1644
p_c->lfoAmp+=p_c->lfoCoefAmp;
1645
}
1646
else if(p_c->lfoIndex<p_c->lfoMaxIndex) {
1647
p_c->lfoCoefInct*=p_c->lfoCoefInctInct;
1648
p_c->lfoAmp-=p_c->lfoCoefAmp;
1649
}
1650
break;
1651
case SHOLD :
1652
if(p_c->lfoIndex==0||p_c->lfoIndex==(p_c->lfoMaxIndex/2)) {
1653
double r;//uniform random between -1.0 and 1.0
1654
r = (double)(2*rand()-RAND_MAX)/(double)RAND_MAX;
1655
p_c->lfoCoefInct=(r>=0.0?1.0+r*(p_c->lfoMaxCoefInct-1.0)
1656
:1.0/(1.0-r*(p_c->lfoMaxCoefInct-1.0)));
1657
p_c->lfoAmp=1.0-(r/2.0+0.5)*p_c->lfoMaxDAmp;
1658
}
1659
break;
1660
default : printf("Error : lfo wave does not exist\n");
1661
break;
1662
}
1663
p_c->lfoIndex=(p_c->lfoIndex<p_c->lfoMaxIndex?p_c->lfoIndex+1:0);
1664
}
1665
1666
//---------------------------------------------------------
1667
// portamento update
1668
//---------------------------------------------------------
1669
inline void portamentoUpdate(Channel* p_c, Voice* p_v) {
1670
double inctTemp;
1671
bool allTargetReached;
1672
if(p_v->hasAttractor) {
1673
allTargetReached = true;
1674
for(int k = 0; k<NBROP; k++) {
1675
if(p_v->op[k].inct < p_v->op[k].targetInct) {
1676
inctTemp = p_v->op[k].inct * p_v->attractor;
1677
if(inctTemp < p_v->op[k].targetInct) {
1678
allTargetReached = false;
1679
p_v->op[k].inct = inctTemp;
1680
}
1681
else p_v->op[k].inct = p_v->op[k].targetInct;
1682
}
1683
else if(p_v->op[k].inct > p_v->op[k].targetInct) {
1684
inctTemp = p_v->op[k].inct / p_v->attractor;
1685
if(inctTemp > p_v->op[k].targetInct) {
1686
allTargetReached = false;
1687
p_v->op[k].inct = inctTemp;
1688
}
1689
else p_v->op[k].inct = p_v->op[k].targetInct;
1690
}
1691
p_c->lastInc[k] = p_v->op[k].inct;
1692
}
1693
if(allTargetReached) p_v->hasAttractor = false;
1694
}
1695
}
1696
1697
1698
//---------------------------------------------------------
1699
// pitchEnvelopeUpdate
1700
//---------------------------------------------------------
1701
inline void pitchEnvelopeUpdate(Voice* v, PitchEg* pe, double sr) {
1702
if(v->pitchEnvState != OFF_PE) {
1703
switch(v->pitchEnvState) {
1704
case PHASE1 :
1705
if( //change to phase2
1706
(v->pitchEnvCoefInctInct == 1.0)
1707
|| (v->pitchEnvCoefInctInct > 1.0 &&
1708
v->pitchEnvCoefInct > v->pitchEnvCoefInctPhase2)
1709
|| (v->pitchEnvCoefInctInct < 1.0 &&
1710
v->pitchEnvCoefInct < v->pitchEnvCoefInctPhase2)
1711
) {
1712
v->pitchEnvState = PHASE2;
1713
v->pitchEnvCoefInct = getPitchEnvCoefInct(pe->pl2);
1714
v->pitchEnvCoefInctInct =
1715
getPitchEnvCoefInctInct(pe->pl2, pe->pl3, pe->pr2, sr);
1716
}
1717
else v->pitchEnvCoefInct *= v->pitchEnvCoefInctInct;
1718
break;
1719
case PHASE2 :
1720
if( //change to off (temporarely)
1721
(v->pitchEnvCoefInctInct == 1.0)
1722
|| (v->pitchEnvCoefInctInct > 1.0 &&
1723
v->pitchEnvCoefInct > v->pitchEnvCoefInctPhase3)
1724
|| (v->pitchEnvCoefInctInct < 1.0 &&
1725
v->pitchEnvCoefInct < v->pitchEnvCoefInctPhase3)
1726
) {
1727
v->pitchEnvState = OFF_PE;
1728
v->pitchEnvCoefInct = getPitchEnvCoefInct(pe->pl3);
1729
v->pitchEnvCoefInctInct = 1.0;
1730
}
1731
else v->pitchEnvCoefInct *= v->pitchEnvCoefInctInct;
1732
break;
1733
case RELEASE_PE :
1734
if( //change to release2
1735
(v->pitchEnvCoefInctInct == 1.0)
1736
|| (v->pitchEnvCoefInctInct > 1.0 &&
1737
v->pitchEnvCoefInct > v->pitchEnvCoefInctPhase1)
1738
|| (v->pitchEnvCoefInctInct < 1.0 &&
1739
v->pitchEnvCoefInct < v->pitchEnvCoefInctPhase1)
1740
) {
1741
v->pitchEnvState = OFF_PE;
1742
v->pitchEnvCoefInct = getPitchEnvCoefInct(pe->pl1);
1743
v->pitchEnvCoefInctInct = 1.0;
1744
}
1745
else v->pitchEnvCoefInct *= v->pitchEnvCoefInctInct;
1746
break;
1747
case OFF_PE :
1748
//do nothing, should not appear anyway
1749
break;
1750
default :
1751
printf("Error switch pitchEnvelopeUpdate, no such case\n");
1752
break;
1753
}
1754
}
1002
1755
}
1003
1756
1004
1757
//---------------------------------------------------------
1005
1758
// outLevel2Amp, Amp for amplitude //between 0.0 and 2.0 or more
1006
1759
// 100->2.0, 90->1.0, 80->0.5 ...
1007
1760
//---------------------------------------------------------
1008
inline double outLevel2Amp(int ol)
1009
{
1010
double a;
1011
double b;
1012
a = log(2)/10.0;
1013
b = -a*DB0LEVEL;
1014
return exp(a*(double)ol+b);
1761
inline double outLevel2Amp(int ol) {
1762
double a;
1763
double b;
1764
a = log(2)/10.0;
1765
b = -a*DB0LEVEL;
1766
return exp(a*(double)ol+b);
1767
}
1768
1769
//---------------------------------------------------------
1770
// lowlevel2amp,
1771
// 127->0dB->1.0, 0->-25dB->0
1772
//---------------------------------------------------------
1773
inline double lowlevel2amp(int l) {
1774
double a, b, c, db;
1775
if(l==0) return 0.0;
1776
else {
1777
a = DB_MIN/127.0;
1778
b = -DB_MIN;
1779
db = a*l+b;
1780
c = -log(2)/3;
1781
return exp(-c*db);
1782
}
1783
}
1784
1785
//---------------------------------------------------------
1786
// level2amp,
1787
// 255->0dB->1.0, 0->-25dB->0
1788
//---------------------------------------------------------
1789
inline double level2amp(int l) {
1790
double a, b, c, db;
1791
if(l==0) return 0.0;
1792
else {
1793
a = DB_MIN/255.0;
1794
b = -DB_MIN;
1795
db = a*l+b;
1796
c = -log(2.0)/3.0;
1797
return exp(-c*db);
1798
}
1799
}
1800
1801
//---------------------------------------------------------
1802
// amp2level
1803
// 1.0->0dB->255, 0->-25dB->0
1804
//---------------------------------------------------------
1805
inline int amp2level(double amp){
1806
double a, b, c;
1807
a = 255.0/DB_MIN;
1808
b = 255.0;
1809
c = log(2.0)/3.0;
1810
return (int)(a*(log(amp)/c)+b);
1811
}
1812
1813
//---------------------------------------------------------
1814
// amp2lowlevel
1815
// 1.0->0dB->127, 0->-25dB->0
1816
//---------------------------------------------------------
1817
inline int amp2lowlevel(double amp){
1818
double a, b, c;
1819
a = 127.0/DB_MIN;
1820
b = 127.0;
1821
c = log(2.0)/3.0;
1822
return (int)(a*(log(amp)/c)+b);
1015
1823
}
1016
1824
1017
1825
//---------------------------------------------------------
1018
1826
// velo2RAmp, AmpR between 0.0 and 1.0
1019
1827
// return an amplitude ratio with respect to _preset->sensitivity.keyVelocity
1020
1828
//---------------------------------------------------------
1021
inline double velo2AmpR(int velo, int kvs)
1022
{
1829
inline double velo2AmpR(int velo, int kvs) {
1023
1830
double lev;
1024
1831
lev = exp(-log(2)*kvs);
1025
1832
return (lev+(1.0-lev)*((double)velo/(double)MAXVELO));
1029
1836
// envAR2s
1030
1837
// return the time in second of the ATTACK duration
1031
1838
//---------------------------------------------------------
1032
inline double envAR2s(int ar)
1033
{
1034
//determined using the fitting feature of gnuplot
1035
return 10.4423*exp(-0.353767*ar);
1839
inline double envAR2s(int ar) {
1840
//determined using the fitting feature of gnuplot
1841
return 10.4423*exp(-0.353767*ar);
1036
1842
}
1037
1843
1038
1844
//---------------------------------------------------------
1040
1846
// return the coefficient for the exponential decrease
1041
1847
// with respect to d1r and sampleRate, sr
1042
1848
//---------------------------------------------------------
1043
inline double envD1R2coef(int d1r, int sr)
1044
{
1849
inline double envD1R2coef(int d1r, double sr) {
1045
1850
double dt;//such that amp(t+dt)=amp(t)/2
1046
1851
double alpha;//such that amp(t)=exp(alpha*t)
1047
1852
1048
1853
if(d1r==0) return 1.0;
1049
1854
else
1050
{
1855
{
1051
1856
//dt has been determined with the fitting function of gnuplot
1052
1857
dt=9.80715*exp(-0.356053*(double)d1r);
1053
1858
1057
1862
//amp(t+mt)
1058
1863
//following the above equational system we found :
1059
1864
alpha=-log(2)/dt;
1060
return exp(alpha/(double)sr);
1061
}
1865
return exp(alpha/sr);
1866
}
1867
}
1868
1869
//---------------------------------------------------------
1870
// coefRelease
1871
// convert the release value to a coef for coefVLevel
1872
//---------------------------------------------------------
1873
inline double coefRelease(unsigned char release) {
1874
double x = COEFGRELEASE*(double)release/(double)MIDRELEASE+1.0-COEFGRELEASE;
1875
double square_x = x*x;
1876
return(1.0/(square_x*x));
1062
1877
}
1063
1878
1064
1879
//---------------------------------------------------------
1066
1881
// return the coefficient for the exponential decrease
1067
1882
// with respect to rr and sampleRate, sr
1068
1883
//---------------------------------------------------------
1069
inline double envRR2coef(int rr, int sr)
1070
{
1884
inline double envRR2coef(int rr, double sr, unsigned char release) {
1071
1885
double dt;//such that amp(t+dt)=amp(t)/2
1072
1886
double alpha;//such that amp(t)=exp(alpha*t)
1073
1887
1074
//dt has been determined with the fitting function of gnuplot
1888
//dt has been determined with the fitting function of gnuplot
1075
1889
dt=7.06636*exp(-0.697606*(double)rr);
1076
1890
1891
dt*=coefRelease(release);
1892
//printf("demi life = %e\n", dt);
1077
1893
//amp(0)=1
1078
1894
//amp(t+dt)=amp(t)/2
1079
1895
//amp(t)=exp(alpha*t)
1080
1896
//amp(t+mt)
1081
1897
//following the above equational system we found :
1082
1898
alpha=-log(2)/dt;
1083
return exp(alpha/(double)sr);
1899
return exp(alpha/sr);
1084
1900
}
1085
1901
1902
//---------------------------------------------------------
1903
// coefAttack
1904
// convert the attack value to a coef for envInct
1905
//---------------------------------------------------------
1906
inline double coefAttack(unsigned char attack) {
1907
double x = COEFGATTACK*(double)attack/(double)MIDATTACK + 1.0-COEFGATTACK;
1908
double square_x = x*x;
1909
return(square_x*square_x*x);
1910
}
1086
1911
1087
1912
//---------------------------------------------------------
1088
1913
// env2RAmp
1090
1915
// envelope state, making evoluate the envelope
1091
1916
// sr is the sample rate and st the sine_table
1092
1917
//---------------------------------------------------------
1093
inline double env2AmpR(int sr, float* wt, Eg eg, OpVoice* p_opVoice)
1094
{
1095
switch(p_opVoice->envState)
1096
{
1097
case ATTACK:
1098
p_opVoice->envIndex+=p_opVoice->envInct;
1099
if (p_opVoice->envIndex<(RESOLUTION/4))
1100
{
1101
p_opVoice->envLevel=wt[(int)p_opVoice->envIndex];
1102
}
1103
else
1104
{
1105
//printf("DECAY\n");
1106
p_opVoice->envState=DECAY;
1107
p_opVoice->envLevel=1.0;
1108
p_opVoice->coefVLevel=envD1R2coef(eg.d1r, sr);
1109
}
1110
return p_opVoice->envLevel;
1111
break;
1112
case DECAY:
1113
if (p_opVoice->envLevel>((double)eg.d1l/(double)MAXD1L)+COEFERRDECSUS)
1114
{
1115
p_opVoice->envLevel*=p_opVoice->coefVLevel;
1116
}
1117
else
1118
{
1119
//printf("SUSTAIN\n");
1120
p_opVoice->envState=SUSTAIN;
1121
p_opVoice->envLevel=((double)eg.d1l/(double)MAXD1L);
1122
p_opVoice->coefVLevel=envD1R2coef(eg.d2r, sr);//probably the same
1123
}
1124
return p_opVoice->envLevel;
1125
break;
1126
case SUSTAIN:
1127
if (p_opVoice->envLevel>COEFERRSUSREL)
1128
{
1129
p_opVoice->envLevel*=p_opVoice->coefVLevel;
1130
}
1131
else
1132
{
1133
//printf("OFF\n");
1134
p_opVoice->envState=OFF;
1135
p_opVoice->envLevel=0.0;
1136
}
1137
return p_opVoice->envLevel;
1138
break;
1139
case RELEASE:
1140
if (p_opVoice->envLevel > COEFERRSUSREL)
1141
{
1142
p_opVoice->envLevel*=p_opVoice->coefVLevel;
1143
}
1144
else
1145
{
1146
p_opVoice->envState=OFF;
1147
p_opVoice->envLevel=0.0;
1148
}
1149
return p_opVoice->envLevel;
1150
break;
1151
case OFF: return 0.0;
1152
break;
1153
default: printf("Error case envelopeState");
1154
break;
1155
}
1918
inline double env2AmpR(double sr, float* wt, Eg eg, OpVoice* p_opVoice) {
1919
switch(p_opVoice->envState) {
1920
case ATTACK:
1921
p_opVoice->envIndex+=p_opVoice->envInct;
1922
if (p_opVoice->envIndex<(RESOLUTION/4)) {
1923
p_opVoice->envLevel=wt[(int)p_opVoice->envIndex];
1924
}
1925
else {
1926
p_opVoice->envState=DECAY;
1927
p_opVoice->envLevel=1.0;
1928
p_opVoice->coefVLevel=envD1R2coef(eg.d1r, sr);
1929
}
1930
return p_opVoice->envLevel;
1931
break;
1932
case DECAY:
1933
if (p_opVoice->envLevel>((double)eg.d1l/(double)MAXD1L)+COEFERRDECSUS) {
1934
p_opVoice->envLevel*=p_opVoice->coefVLevel;
1935
}
1936
else {
1937
p_opVoice->envState=SUSTAIN;
1938
p_opVoice->envLevel=((double)eg.d1l/(double)MAXD1L);
1939
p_opVoice->coefVLevel=envD1R2coef(eg.d2r, sr);//probably the same
1940
}
1941
return p_opVoice->envLevel;
1942
break;
1943
case SUSTAIN:
1944
if (p_opVoice->envLevel>COEFERRSUSREL) {
1945
p_opVoice->envLevel*=p_opVoice->coefVLevel;
1946
}
1947
else {
1948
p_opVoice->envState=OFF;
1949
p_opVoice->envLevel=0.0;
1950
}
1951
return p_opVoice->envLevel;
1952
break;
1953
case RELEASE:
1954
if (p_opVoice->envLevel > COEFERRSUSREL) {
1955
p_opVoice->envLevel*=p_opVoice->coefVLevel;
1956
}
1957
else {
1958
p_opVoice->envState=OFF;
1959
p_opVoice->envLevel=0.0;
1960
}
1961
return p_opVoice->envLevel;
1962
break;
1963
case OFF: return 0.0;
1964
break;
1965
default: printf("Error case envelopeState");
1966
break;
1967
}
1968
return p_opVoice->envLevel;
1156
1969
}
1157
1970
1158
1971
//---------------------------------------------------------
1159
1972
// programSelect
1160
1973
//---------------------------------------------------------
1161
1974
1162
void DeicsOnze::programSelect(int /*ch*/, int lbank, int prog) {
1163
Preset* p_preset;
1164
p_preset=findPreset(lbank, prog);
1165
if (p_preset) _preset=p_preset;
1166
else _preset->initPreset();
1167
setPreset();
1975
void DeicsOnze::programSelect(int c, int hbank, int lbank, int prog) {
1976
Preset* foundPreset;
1977
foundPreset=findPreset(hbank, lbank, prog);
1978
if (foundPreset) _preset[c]=foundPreset;
1979
else {
1980
_preset[c]=_initialPreset;
1981
_preset[c]->prog=prog;
1982
_preset[c]->_subcategory->_lbank=lbank; //TODO : real link
1983
_preset[c]->_subcategory->_category->_hbank=hbank;
1984
}
1985
setPreset(c);
1168
1986
}
1169
1987
1170
1988
//---------------------------------------------------------
1989
// setModulation
1990
//---------------------------------------------------------
1991
void DeicsOnze::setModulation(int c, int val) {
1992
_global.channel[c].modulation = (unsigned char) val;
1993
setLfo(c);
1994
}
1995
//---------------------------------------------------------
1171
1996
// setPitchBendCoef
1172
1997
//---------------------------------------------------------
1173
1174
void DeicsOnze::setPitchBendCoef(int /*ch*/, int val) {
1175
_global.pitchBendCoef=exp(log(2)
1176
*((double)_preset->function.pBendRange
1177
/(double)MAXPBENDRANGE)
1178
*((double)val/(double)MAXPITCHBENDVALUE));
1998
void DeicsOnze::setPitchBendCoef(int c, int val) {
1999
_global.channel[c].pitchBendCoef =
2000
exp(log(2)*((double)_preset[c]->function.pBendRange
2001
/(double)MAXPBENDRANGE)
2002
*((double)val/(double)MAXPITCHBENDVALUE));
1179
2003
}
1180
2004
1181
2005
//---------------------------------------------------------
1182
2006
// setSustain
1183
2007
//---------------------------------------------------------
1184
void DeicsOnze::setSustain(int /*ch*/, int val) {
1185
_global.sustain=(val>64);
1186
if(!_global.sustain)
1187
for(int i=0; i<NBRVOICES; i++)
1188
if(_voices[i].isSustained) {
1189
for(int j=0; j<NBROP; j++) {
1190
_voices[i].op[j].envState=RELEASE;
1191
_voices[i].op[j].coefVLevel=envRR2coef(_preset->eg[j].rr
1192
,sampleRate());
1193
}
1194
_voices[i].isSustained=false;
1195
}
1196
}
1197
2008
void DeicsOnze::setSustain(int c, int val) {
2009
_global.channel[c].sustain=(val>64);
2010
if(!_global.channel[c].sustain)
2011
for(int i=0; i<_global.channel[c].nbrVoices; i++)
2012
if(_global.channel[c].voices[i].isSustained) {
2013
for(int j=0; j<NBROP; j++) {
2014
_global.channel[c].voices[i].op[j].envState = RELEASE;
2015
setEnvRelease(c, i, j);
2016
}
2017
setPitchEnvRelease(c, i);
2018
_global.channel[c].voices[i].isSustained = false;
2019
_global.channel[c].voices[i].keyOn = false;
2020
}
2021
}
2022
2023
//---------------------------------------------------------
2024
// readColor
2025
//---------------------------------------------------------
2026
QColor readColor(QDomNode node)
2027
{
2028
QDomElement e = node.toElement();
2029
int r = e.attribute("r","0").toInt();
2030
int g = e.attribute("g","0").toInt();
2031
int b = e.attribute("b","0").toInt();
2032
return QColor(r, g, b);
2033
}
2034
2035
//---------------------------------------------------------
2036
// readConfiguration
2037
//---------------------------------------------------------
2038
void DeicsOnze::readConfiguration(QDomNode qdn) {
2039
QColor textColor, backgroundColor, editTextColor, editBackgroundColor;
2040
while(!qdn.isNull()) {
2041
QDomElement qdEl = qdn.toElement();
2042
if(qdEl.isNull())
2043
continue;
2044
//nbrVoices
2045
//question? does the configurqtion has to save the number of
2046
//voices for each channel or not?
2047
//temporarly or definitly under comments
2048
/*
2049
if(qdEl.tagName()==NBRVOICESSTR) {
2050
setNbrVoices(qdEl.text().toInt());
2051
MidiPlayEvent evNbrVoices(0, 0, 0, ME_CONTROLLER,
2052
CTRL_NBRVOICES, _global.nbrVoices);
2053
_gui->writeEvent(evNbrVoices);
2054
}*/
2055
//channelNum
2056
/*
2057
if(qdEl.tagName()==CHANNELNUMSTR) {
2058
_global.channelNum = (qdEl.text()==ALLSTR?-1:qdEl.text().toInt()-1);
2059
unsigned char *dataChannelNum = new unsigned char[2];
2060
dataChannelNum[0]=SYSEX_CHANNELNUM;
2061
dataChannelNum[1]=(unsigned char)_global.channelNum;
2062
MidiPlayEvent
2063
evChannelNum(0, 0, ME_SYSEX, (const unsigned char*)dataChannelNum, 2);
2064
_gui->writeEvent(evChannelNum);
2065
}*/
2066
//quality
2067
if(qdEl.tagName()==QUALITYSTR) {
2068
_global.quality = (qdEl.text()==HIGHSTR?high:
2069
(qdEl.text()==MIDDLESTR?middle:
2070
(qdEl.text()==LOWSTR?low:ultralow)));
2071
setQuality(_global.quality);
2072
unsigned char *dataQuality = new unsigned char[2];
2073
dataQuality[0]=SYSEX_QUALITY;
2074
dataQuality[1]=(unsigned char)_global.quality;
2075
MidiPlayEvent evQuality(0, 0, ME_SYSEX, (const unsigned char*)dataQuality, 2);
2076
_gui->writeEvent(evQuality);
2077
}
2078
//filter
2079
if(qdEl.tagName()==FILTERSTR) {
2080
setFilter(qdEl.text()==YESSTRDEI?true:false);
2081
unsigned char *dataFilter = new unsigned char[2];
2082
dataFilter[0]=SYSEX_FILTER;
2083
dataFilter[1]=(unsigned char)getFilter();
2084
MidiPlayEvent evFilter(0, 0, ME_SYSEX, (const unsigned char*)dataFilter, 2);
2085
_gui->writeEvent(evFilter);
2086
}
2087
//font size
2088
if(qdEl.tagName()==FONTSIZESTR) {
2089
_global.fontSize = qdEl.text().toInt();
2090
unsigned char *dataFontSize = new unsigned char[2];
2091
dataFontSize[0]=SYSEX_FONTSIZE;
2092
dataFontSize[1]=(unsigned char)_global.fontSize;
2093
MidiPlayEvent evFontSize(0, 0, ME_SYSEX, (const unsigned char*)dataFontSize, 2);
2094
_gui->writeEvent(evFontSize);
2095
}
2096
//saveConfig
2097
if(qdEl.tagName()==SAVECONFIGSTR) {
2098
_saveConfig = (qdEl.text()==YESSTRDEI?true:false);
2099
unsigned char *dataSaveConfig = new unsigned char[2];
2100
dataSaveConfig[0]=SYSEX_SAVECONFIG;
2101
dataSaveConfig[1]=(unsigned char)_saveConfig;
2102
MidiPlayEvent
2103
evSaveConfig(0, 0, ME_SYSEX, (const unsigned char*)dataSaveConfig, 2);
2104
_gui->writeEvent(evSaveConfig);
2105
}
2106
//saveOnlyUsed
2107
if(qdEl.tagName()==SAVEONLYUSEDSTR) {
2108
_saveOnlyUsed = (qdEl.text()==YESSTRDEI?true:false);
2109
unsigned char *dataSaveOnlyUsed = new unsigned char[2];
2110
dataSaveOnlyUsed[0]=SYSEX_SAVEONLYUSED;
2111
dataSaveOnlyUsed[1]=(unsigned char)_saveOnlyUsed;
2112
MidiPlayEvent
2113
evSaveOnlyUsed(0, 0, ME_SYSEX, (const unsigned char*)dataSaveOnlyUsed, 2);
2114
_gui->writeEvent(evSaveOnlyUsed);
2115
}
2116
//colors
2117
if(qdEl.tagName()==TEXTCOLORSTR) textColor = readColor(qdn);
2118
if(qdEl.tagName()==BACKGROUNDCOLORSTR) backgroundColor = readColor(qdn);
2119
if(qdEl.tagName()==EDITTEXTCOLORSTR) editTextColor = readColor(qdn);
2120
if(qdEl.tagName()==EDITBACKGROUNDCOLORSTR)
2121
editBackgroundColor = readColor(qdn);
2122
2123
//must insert load image, later
2124
2125
//load init set
2126
if(qdEl.tagName()==ISINITSETSTR) {
2127
_isInitSet = (qdEl.text()==YESSTRDEI?true:false);
2128
unsigned char *dataIsInitSet = new unsigned char[2];
2129
dataIsInitSet[0]=SYSEX_ISINITSET;
2130
dataIsInitSet[1]=(unsigned char)_isInitSet;
2131
MidiPlayEvent
2132
evIsInitSet(0, 0, ME_SYSEX, (const unsigned char*)dataIsInitSet, 2);
2133
_gui->writeEvent(evIsInitSet);
2134
}
2135
if(qdEl.tagName()==INITSETPATHSTR) {
2136
_initSetPath = qdEl.text();
2137
unsigned char *dataInitSetPath =
2138
new unsigned char[1+MAXSTRLENGTHINITSETPATH];
2139
dataInitSetPath[0]=SYSEX_INITSETPATH;
2140
strncpy((char*)&dataInitSetPath[1], _initSetPath.toLatin1().constData(),
2141
MAXSTRLENGTHINITSETPATH);
2142
MidiPlayEvent
2143
evInitSetPath(0, 0, ME_SYSEX, (const unsigned char*)dataInitSetPath,
2144
1+MAXSTRLENGTHINITSETPATH);
2145
_gui->writeEvent(evInitSetPath);
2146
}
2147
//load background pix
2148
if(qdEl.tagName()==ISBACKGROUNDPIXSTR) {
2149
_isBackgroundPix = (qdEl.text()==YESSTRDEI?true:false);
2150
unsigned char *dataIsBackgroundPix = new unsigned char[2];
2151
dataIsBackgroundPix[0]=SYSEX_ISBACKGROUNDPIX;
2152
dataIsBackgroundPix[1]=(unsigned char)_isBackgroundPix;
2153
MidiPlayEvent
2154
evIsBackgroundPix(0, 0, ME_SYSEX,
2155
(const unsigned char*)dataIsBackgroundPix, 2);
2156
_gui->writeEvent(evIsBackgroundPix);
2157
}
2158
if(qdEl.tagName()==BACKGROUNDPIXPATHSTR) {
2159
_backgroundPixPath = qdEl.text();
2160
unsigned char *dataBackgroundPixPath =
2161
new unsigned char[1+MAXSTRLENGTHBACKGROUNDPIXPATH];
2162
dataBackgroundPixPath[0]=SYSEX_BACKGROUNDPIXPATH;
2163
strncpy((char*)&dataBackgroundPixPath[1],
2164
_backgroundPixPath.toLatin1().constData(),
2165
MAXSTRLENGTHBACKGROUNDPIXPATH);
2166
MidiPlayEvent
2167
evBackgroundPixPath(0, 0, ME_SYSEX,
2168
(const unsigned char*)dataBackgroundPixPath,
2169
1+MAXSTRLENGTHBACKGROUNDPIXPATH);
2170
_gui->writeEvent(evBackgroundPixPath);
2171
}
2172
qdn = qdn.nextSibling();
2173
}
2174
//send colors
2175
unsigned char dataColorGui[COLORSYSEXLENGTH+1];
2176
dataColorGui[0]=SYSEX_COLORGUI;
2177
dataColorGui[1]=(unsigned char)textColor.red();
2178
dataColorGui[2]=(unsigned char)textColor.green();
2179
dataColorGui[3]=(unsigned char)textColor.blue();
2180
dataColorGui[4]=(unsigned char)backgroundColor.red();
2181
dataColorGui[5]=(unsigned char)backgroundColor.green();
2182
dataColorGui[6]=(unsigned char)backgroundColor.blue();
2183
dataColorGui[7]=(unsigned char)editTextColor.red();
2184
dataColorGui[8]=(unsigned char)editTextColor.green();
2185
dataColorGui[9]=(unsigned char)editTextColor.blue();
2186
dataColorGui[10]=(unsigned char)editBackgroundColor.red();
2187
dataColorGui[11]=(unsigned char)editBackgroundColor.green();
2188
dataColorGui[12]=(unsigned char)editBackgroundColor.blue();
2189
MidiPlayEvent evSysexColor(0, 0, ME_SYSEX, (const unsigned char*)dataColorGui,
2190
COLORSYSEXLENGTH+1);
2191
_gui->writeEvent(evSysexColor);
2192
}
2193
2194
//-----------------------------------------------------------
2195
// loadConfiguration
2196
//-----------------------------------------------------------
2197
void DeicsOnze::loadConfiguration(QString fileName) {
2198
// read the XML file and create DOM tree
2199
if(!fileName.isEmpty()) {
2200
QFile confFile(fileName);
2201
if(!confFile.open(QIODevice::ReadOnly)) {
2202
printf("Critical Error. Cannot open file %s\n",
2203
fileName.toAscii().data());
2204
return;
2205
}
2206
QDomDocument domTree;
2207
if (!domTree.setContent(&confFile )) {
2208
printf("Critical Error. Parsing error for file %s\n",
2209
fileName.toAscii().data());
2210
confFile.close();
2211
return;
2212
}
2213
2214
confFile.close();
2215
2216
QDomNode node = domTree.documentElement();
2217
while (!node.isNull()) {
2218
QDomElement e = node.toElement();
2219
if (e.isNull())
2220
continue;
2221
if (e.tagName() == DEICSONZECONFIGURATIONSTR) {
2222
QString version = e.attribute(QString("version"));
2223
if (version == "1.0") {
2224
readConfiguration(node.firstChild());
2225
}
2226
else printf("unsupported *.dco file version %s\n",
2227
version.toLatin1().constData());
2228
}
2229
else printf("DeicsOnze: %s not supported\n",
2230
e.tagName().toLatin1().constData());
2231
node = node.nextSibling();
2232
}
2233
}
2234
}
2235
2236
//---------------------------------------------------------
2237
// writeConfiguration
2238
//---------------------------------------------------------
2239
void DeicsOnze::writeConfiguration(AL::Xml* xml) {
2240
QString str;
2241
xml->stag("deicsOnzeConfiguation version=\"1.0\"");
2242
//xml->intTag(NBRVOICESSTR, (int)_global.nbrVoices);
2243
//xml->strTag(CHANNELNUMSTR, (_global.channelNum==-1?ALLSTR:
2244
// str.setNum(_global.channelNum+1)));
2245
xml->tag(QUALITYSTR, QString((_global.quality==high?HIGHSTR:
2246
(_global.quality==middle?MIDDLESTR:
2247
(_global.quality==low?LOWSTR:ULTRALOWSTR)))));
2248
xml->tag(FILTERSTR, QString(getFilter()==true?YESSTRDEI:NOSTRDEI));
2249
xml->tag(FONTSIZESTR, _global.fontSize);
2250
xml->tag(SAVECONFIGSTR, QString((_saveConfig?YESSTRDEI:NOSTRDEI)));
2251
xml->tag(SAVEONLYUSEDSTR, QString((_saveOnlyUsed?YESSTRDEI:NOSTRDEI)));
2252
xml->tag(TEXTCOLORSTR,
2253
reinterpret_cast<const QColor &>(*_gui->tColor));
2254
xml->tag(BACKGROUNDCOLORSTR,
2255
reinterpret_cast<const QColor &>(*_gui->bColor));
2256
xml->tag(EDITTEXTCOLORSTR,
2257
reinterpret_cast<const QColor &>(*_gui->etColor));
2258
xml->tag(EDITBACKGROUNDCOLORSTR,
2259
reinterpret_cast<const QColor &>(*_gui->ebColor));
2260
xml->tag(ISINITSETSTR, QString((_isInitSet?YESSTRDEI:NOSTRDEI)));
2261
xml->tag(INITSETPATHSTR, QString(_initSetPath));
2262
xml->tag(ISBACKGROUNDPIXSTR, QString((_isBackgroundPix?YESSTRDEI:NOSTRDEI)));
2263
xml->tag(BACKGROUNDPIXPATHSTR, _backgroundPixPath);
2264
2265
xml->etag(DEICSONZECONFIGURATIONSTR);
2266
}
2267
2268
//---------------------------------------------------------
2269
// getInitData
2270
//---------------------------------------------------------
2271
void DeicsOnze::getInitData(int* length, const unsigned char** data) const {
2272
//write the set in a temporary file and in a QByteArray
2273
QTemporaryFile file;
2274
file.open();
2275
AL::Xml* xml=new AL::Xml(&file);
2276
xml->header();
2277
_set->writeSet(xml, _saveOnlyUsed);
2278
file.reset(); //seek the start of the file
2279
QByteArray ba = file.readAll();
2280
file.close();
2281
2282
//compress the QByteArray at default rate
2283
QByteArray baComp = qCompress(ba);
2284
2285
//save the set
2286
*length = NUM_CONFIGLENGTH
2287
///+ (_pluginIReverb?sizeof(float)*_pluginIReverb->plugin()->parameter():0)
2288
+ (_pluginIReverb?sizeof(float)*_pluginIReverb->plugin()->controlInPorts():0)
2289
///+ (_pluginIChorus?sizeof(float)*_pluginIChorus->plugin()->parameter():0)
2290
+ (_pluginIChorus?sizeof(float)*_pluginIChorus->plugin()->controlInPorts():0)
2291
+ baComp.size();
2292
2293
unsigned char* buffer = new unsigned char[*length];
2294
//save init data
2295
buffer[0]=SYSEX_INIT_DATA;
2296
buffer[1]=SYSEX_INIT_DATA_VERSION;
2297
//save global data
2298
buffer[NUM_MASTERVOL] = (unsigned char) getMasterVol();
2299
for(int c = 0; c < NBRCHANNELS; c++) {
2300
buffer[NUM_CHANNEL_ENABLE + c] = (unsigned char) getChannelEnable(c);
2301
buffer[NUM_CHANNEL_VOL + c] = (unsigned char) getChannelVol(c);
2302
buffer[NUM_CHANNEL_PAN + c] = (unsigned char) getChannelPan(c);
2303
int b = getChannelBrightness(c);
2304
buffer[NUM_CHANNEL_BRIGHTNESS + 2*c] = (unsigned char) (b%256);
2305
buffer[NUM_CHANNEL_BRIGHTNESS + 2*c + 1] = (unsigned char) (b/256);
2306
buffer[NUM_CHANNEL_MODULATION + c] =
2307
(unsigned char) getChannelModulation(c);
2308
buffer[NUM_CHANNEL_DETUNE + c] =
2309
(unsigned char) getChannelDetune(c) + MAXCHANNELDETUNE;
2310
buffer[NUM_CHANNEL_ATTACK + c] = (unsigned char) getChannelAttack(c);
2311
buffer[NUM_CHANNEL_RELEASE + c] = (unsigned char) getChannelRelease(c);
2312
buffer[NUM_CHANNEL_REVERB + c] = (unsigned char) getChannelReverb(c);
2313
buffer[NUM_CHANNEL_CHORUS + c] = (unsigned char) getChannelChorus(c);
2314
buffer[NUM_CHANNEL_DELAY + c] = (unsigned char) getChannelDelay(c);
2315
buffer[NUM_CURRENTPROG + c] = (unsigned char) _preset[c]->prog;
2316
buffer[NUM_CURRENTLBANK + c] =
2317
(unsigned char) _preset[c]->_subcategory->_lbank;
2318
buffer[NUM_CURRENTHBANK + c] =
2319
(unsigned char) _preset[c]->_subcategory->_category->_hbank;
2320
buffer[NUM_NBRVOICES + c] = (unsigned char) getNbrVoices(c);
2321
}
2322
buffer[NUM_SAVEONLYUSED]=(unsigned char) _saveOnlyUsed;
2323
buffer[NUM_SAVECONFIG]=(unsigned char) _saveConfig;
2324
//save config data
2325
if(_saveConfig) {
2326
buffer[NUM_QUALITY]=(unsigned char)_global.quality;
2327
buffer[NUM_FILTER]=(unsigned char)getFilter();
2328
buffer[NUM_FONTSIZE]=(unsigned char)_global.fontSize;
2329
buffer[NUM_RED_TEXT]=(unsigned char)_gui->tColor->red();
2330
buffer[NUM_GREEN_TEXT]=(unsigned char)_gui->tColor->green();
2331
buffer[NUM_BLUE_TEXT]=(unsigned char)_gui->tColor->blue();
2332
buffer[NUM_RED_BACKGROUND]=(unsigned char)_gui->bColor->red();
2333
buffer[NUM_GREEN_BACKGROUND]=(unsigned char)_gui->bColor->green();
2334
buffer[NUM_BLUE_BACKGROUND]=(unsigned char)_gui->bColor->blue();
2335
buffer[NUM_RED_EDITTEXT]=(unsigned char)_gui->etColor->red();
2336
buffer[NUM_GREEN_EDITTEXT]=(unsigned char)_gui->etColor->green();
2337
buffer[NUM_BLUE_EDITTEXT]=(unsigned char)_gui->etColor->blue();
2338
buffer[NUM_RED_EDITBACKGROUND]=(unsigned char)_gui->ebColor->red();
2339
buffer[NUM_GREEN_EDITBACKGROUND]=(unsigned char)_gui->ebColor->green();
2340
buffer[NUM_BLUE_EDITBACKGROUND]=(unsigned char)_gui->ebColor->blue();
2341
buffer[NUM_ISINITSET]=(unsigned char)_isInitSet;
2342
strncpy((char*)&buffer[NUM_INITSETPATH],
2343
_initSetPath.toLatin1().constData(), MAXSTRLENGTHINITSETPATH);
2344
buffer[NUM_ISBACKGROUNDPIX]=(unsigned char)_isBackgroundPix;
2345
strncpy((char*)&buffer[NUM_BACKGROUNDPIXPATH],
2346
_backgroundPixPath.toLatin1().constData(),
2347
MAXSTRLENGTHBACKGROUNDPIXPATH);
2348
}
2349
//FX
2350
//reverb
2351
buffer[NUM_IS_REVERB_ON]=(unsigned char)_global.isReverbActivated;
2352
buffer[NUM_REVERB_RETURN]=(unsigned char)getReverbReturn();
2353
buffer[NUM_REVERB_PARAM_NBR]=
2354
///(_pluginIReverb?(unsigned char)_pluginIReverb->plugin()->parameter() : 0);
2355
(_pluginIReverb?(unsigned char)_pluginIReverb->plugin()->controlInPorts() : 0);
2356
strncpy((char*)&buffer[NUM_REVERB_LIB],
2357
(_pluginIReverb?
2358
_pluginIReverb->plugin()->lib().toLatin1().constData() : "\0"),
2359
MAXSTRLENGTHFXLIB);
2360
strncpy((char*)&buffer[NUM_REVERB_LABEL],
2361
(_pluginIReverb?
2362
_pluginIReverb->plugin()->label().toLatin1().constData() : "\0"),
2363
MAXSTRLENGTHFXLABEL);
2364
//chorus
2365
buffer[NUM_IS_CHORUS_ON]=(unsigned char)_global.isChorusActivated;
2366
buffer[NUM_CHORUS_RETURN]=(unsigned char)getChorusReturn();
2367
buffer[NUM_CHORUS_PARAM_NBR]=
2368
///(_pluginIChorus?(unsigned char)_pluginIChorus->plugin()->parameter() : 0);
2369
(_pluginIChorus?(unsigned char)_pluginIChorus->plugin()->controlInPorts() : 0);
2370
strncpy((char*)&buffer[NUM_CHORUS_LIB],
2371
(_pluginIChorus?
2372
_pluginIChorus->plugin()->lib().toLatin1().constData() : "\0"),
2373
MAXSTRLENGTHFXLIB);
2374
strncpy((char*)&buffer[NUM_CHORUS_LABEL],
2375
(_pluginIChorus?
2376
_pluginIChorus->plugin()->label().toLatin1().constData() : "\0"),
2377
MAXSTRLENGTHFXLABEL);
2378
//delay
2379
buffer[NUM_IS_DELAY_ON]=(unsigned char)_global.isDelayActivated;
2380
buffer[NUM_DELAY_RETURN]=(unsigned char)getDelayReturn();
2381
//save FX parameters
2382
//reverb
2383
for(int i = 0; i < (int)buffer[NUM_REVERB_PARAM_NBR]; i++) {
2384
float val = (float)getReverbParam(i);
2385
memcpy(&buffer[NUM_CONFIGLENGTH + sizeof(float)*i], &val, sizeof(float));
2386
}
2387
//chorus
2388
for(int i = 0; i < (int)buffer[NUM_CHORUS_PARAM_NBR]; i++) {
2389
float val = (float)getChorusParam(i);
2390
memcpy(&buffer[NUM_CONFIGLENGTH
2391
+ sizeof(float)*(int)buffer[NUM_REVERB_PARAM_NBR]
2392
+ sizeof(float)*i], &val, sizeof(float));
2393
}
2394
//delay
2395
float delayfloat;
2396
delayfloat = getDelayBPM();
2397
memcpy(&buffer[NUM_DELAY_BPM], &delayfloat, 4);
2398
delayfloat = getDelayBeatRatio();
2399
memcpy(&buffer[NUM_DELAY_BEATRATIO], &delayfloat, sizeof(float));
2400
delayfloat = getDelayFeedback();
2401
memcpy(&buffer[NUM_DELAY_FEEDBACK], &delayfloat, sizeof(float));
2402
delayfloat = getDelayLFOFreq();
2403
memcpy(&buffer[NUM_DELAY_LFO_FREQ], &delayfloat, sizeof(float));
2404
delayfloat = getDelayLFODepth();
2405
memcpy(&buffer[NUM_DELAY_LFO_DEPTH], &delayfloat, sizeof(float));
2406
2407
//save set data
2408
int offset =
2409
NUM_CONFIGLENGTH
2410
+ sizeof(float)*(int)buffer[NUM_REVERB_PARAM_NBR]
2411
+ sizeof(float)*(int)buffer[NUM_CHORUS_PARAM_NBR];
2412
for(int i = offset; i < *length; i++)
2413
buffer[i]=(unsigned char)baComp.at(i - offset);
2414
2415
*data=buffer;
2416
}
2417
//---------------------------------------------------------
2418
// parseInitData
2419
//---------------------------------------------------------
2420
void DeicsOnze::parseInitData(int length, const unsigned char* data) {
2421
if(data[1]==SYSEX_INIT_DATA_VERSION) {
2422
//load global parameters
2423
//master volume
2424
setMasterVol(data[NUM_MASTERVOL]);
2425
unsigned char *dataMasterVol = new unsigned char[2];
2426
dataMasterVol[0]=SYSEX_MASTERVOL;
2427
dataMasterVol[1]=(unsigned char) getMasterVol();
2428
MidiPlayEvent
2429
evMasterVol(0, 0, ME_SYSEX, (const unsigned char*)dataMasterVol, 2);
2430
_gui->writeEvent(evMasterVol);
2431
//channel configuration
2432
for(int c = 0; c < NBRCHANNELS; c++) {
2433
//isEnable
2434
setChannelEnable(c, data[NUM_CHANNEL_ENABLE + c]);
2435
MidiPlayEvent
2436
evChEnable(0, 0, c, ME_CONTROLLER,
2437
CTRL_CHANNELENABLE, data[NUM_CHANNEL_ENABLE + c]);
2438
_gui->writeEvent(evChEnable);
2439
//nbrVoices
2440
setNbrVoices(c, data[NUM_NBRVOICES + c]);
2441
MidiPlayEvent
2442
evNbrVoices(0, 0, c,ME_CONTROLLER,CTRL_NBRVOICES, data[NUM_NBRVOICES + c]);
2443
_gui->writeEvent(evNbrVoices);
2444
//channel volume
2445
setChannelVol(c, data[NUM_CHANNEL_VOL + c]);
2446
MidiPlayEvent
2447
evChVol(0, 0, c, ME_CONTROLLER,
2448
CTRL_CHANNELVOLUME, data[NUM_CHANNEL_VOL + c]);
2449
_gui->writeEvent(evChVol);
2450
//channel pan
2451
setChannelPan(c, data[NUM_CHANNEL_PAN + c]);
2452
MidiPlayEvent
2453
evChPan(0, 0, c, ME_CONTROLLER, CTRL_CHANNELPAN,
2454
data[NUM_CHANNEL_PAN + c]);
2455
_gui->writeEvent(evChPan);
2456
if(getChannelEnable(c)) applyChannelAmp(c);
2457
//channel detune
2458
setChannelDetune(c, data[NUM_CHANNEL_DETUNE + c]-MAXCHANNELDETUNE);
2459
MidiPlayEvent
2460
evChDetune(0, 0, c, ME_CONTROLLER, CTRL_CHANNELDETUNE,
2461
data[NUM_CHANNEL_DETUNE + c]-MAXCHANNELDETUNE);
2462
_gui->writeEvent(evChDetune);
2463
//channel brightness
2464
setChannelBrightness(c,
2465
data[NUM_CHANNEL_BRIGHTNESS + 2*c]
2466
+ data[NUM_CHANNEL_BRIGHTNESS + 2*c + 1] * 256);
2467
MidiPlayEvent
2468
evChBrightness(0, 0, c, ME_CONTROLLER,
2469
CTRL_FINEBRIGHTNESS, getChannelBrightness(c));
2470
_gui->writeEvent(evChBrightness);
2471
//channel modulation
2472
setChannelModulation(c, data[NUM_CHANNEL_MODULATION + c]);
2473
MidiPlayEvent
2474
evChMod(0, 0, c, ME_CONTROLLER,
2475
CTRL_MODULATION, data[NUM_CHANNEL_MODULATION + c]);
2476
_gui->writeEvent(evChMod);
2477
//channel attack
2478
setChannelAttack(c, data[NUM_CHANNEL_ATTACK + c]);
2479
MidiPlayEvent
2480
evChAttack(0, 0, c, ME_CONTROLLER,
2481
CTRL_ATTACK_TIME, data[NUM_CHANNEL_ATTACK + c]);
2482
_gui->writeEvent(evChAttack);
2483
//channel release
2484
setChannelRelease(c, data[NUM_CHANNEL_RELEASE + c]);
2485
MidiPlayEvent
2486
evChRelease(0, 0, c, ME_CONTROLLER,
2487
CTRL_RELEASE_TIME, data[NUM_CHANNEL_RELEASE + c]);
2488
_gui->writeEvent(evChRelease);
2489
//channel reverb
2490
setChannelReverb(c, data[NUM_CHANNEL_REVERB + c]);
2491
MidiPlayEvent
2492
evChReverb(0, 0, c, ME_CONTROLLER,
2493
CTRL_REVERB_SEND, data[NUM_CHANNEL_REVERB + c]);
2494
_gui->writeEvent(evChReverb);
2495
//channel chorus
2496
setChannelChorus(c, data[NUM_CHANNEL_CHORUS + c]);
2497
MidiPlayEvent
2498
evChChorus(0, 0, c, ME_CONTROLLER,
2499
CTRL_CHORUS_SEND, data[NUM_CHANNEL_CHORUS + c]);
2500
_gui->writeEvent(evChChorus);
2501
//channel delay
2502
setChannelDelay(c, data[NUM_CHANNEL_DELAY + c]);
2503
MidiPlayEvent
2504
evChDelay(0, 0, c, ME_CONTROLLER,
2505
CTRL_VARIATION_SEND, data[NUM_CHANNEL_DELAY + c]);
2506
_gui->writeEvent(evChDelay);
2507
}
2508
//load configuration
2509
_saveConfig = (bool)data[NUM_SAVECONFIG];
2510
unsigned char *dataSaveConfig = new unsigned char[2];
2511
dataSaveConfig[0]=SYSEX_SAVECONFIG;
2512
dataSaveConfig[1]=(unsigned char)_saveConfig;
2513
MidiPlayEvent
2514
evSaveConfig(0, 0, ME_SYSEX, (const unsigned char*)dataSaveConfig, 2);
2515
_gui->writeEvent(evSaveConfig);
2516
if(_saveConfig) {
2517
//saveOnlyUsed
2518
_saveOnlyUsed = (bool)data[NUM_SAVEONLYUSED];
2519
unsigned char *dataSaveOnlyUsed = new unsigned char[2];
2520
dataSaveOnlyUsed[0]=SYSEX_SAVEONLYUSED;
2521
dataSaveOnlyUsed[1]=(unsigned char)_saveOnlyUsed;
2522
MidiPlayEvent
2523
evSaveOnlyUsed(0, 0, ME_SYSEX, (const unsigned char*)dataSaveOnlyUsed, 2);
2524
_gui->writeEvent(evSaveOnlyUsed);
2525
//colors
2526
unsigned char dataColorGui[COLORSYSEXLENGTH+1];
2527
dataColorGui[0]=SYSEX_COLORGUI;
2528
for (int i=0; i<COLORSYSEXLENGTH; i++)
2529
dataColorGui[i+1]=data[NUM_RED_TEXT+i];
2530
MidiPlayEvent evSysexColor(0, 0, ME_SYSEX, (const unsigned char*)dataColorGui,
2531
COLORSYSEXLENGTH+1);
2532
_gui->writeEvent(evSysexColor);
2533
//quality
2534
unsigned char dataQuality[2];
2535
dataQuality[0]=SYSEX_QUALITY;
2536
dataQuality[1]=data[NUM_QUALITY];
2537
setQuality((Quality)data[NUM_QUALITY]);
2538
MidiPlayEvent evQuality(0, 0, ME_SYSEX, (const unsigned char*)dataQuality, 2);
2539
_gui->writeEvent(evQuality);
2540
//filter
2541
unsigned char dataFilter[2];
2542
dataFilter[0]=SYSEX_FILTER;
2543
dataFilter[1]=data[NUM_FILTER];
2544
setFilter((bool)data[NUM_FILTER]);
2545
MidiPlayEvent evFilter(0, 0, ME_SYSEX, (const unsigned char*)dataFilter, 2);
2546
_gui->writeEvent(evFilter);
2547
//font size
2548
unsigned char dataFontSize[2];
2549
dataFontSize[0]=SYSEX_FONTSIZE;
2550
dataFontSize[1]=data[NUM_FONTSIZE];
2551
MidiPlayEvent evFontSize(0, 0, ME_SYSEX, (const unsigned char*)dataFontSize, 2);
2552
_gui->writeEvent(evFontSize);
2553
//load init set
2554
unsigned char dataIsInitSet[2];
2555
dataIsInitSet[0]=SYSEX_ISINITSET;
2556
dataIsInitSet[1]=data[NUM_ISINITSET];
2557
MidiPlayEvent evIsInitSet(0, 0, ME_SYSEX,
2558
(const unsigned char*)dataIsInitSet, 2);
2559
_gui->writeEvent(evIsInitSet);
2560
unsigned char dataInitSetPath[1+MAXSTRLENGTHINITSETPATH];
2561
dataInitSetPath[0]=SYSEX_INITSETPATH;
2562
for(int a = 0; a < MAXSTRLENGTHINITSETPATH; a++)
2563
dataInitSetPath[a+1] = data[a+NUM_INITSETPATH];
2564
MidiPlayEvent evInitSetPath(0, 0, ME_SYSEX,(const unsigned char*)dataInitSetPath,
2565
1+MAXSTRLENGTHINITSETPATH);
2566
_gui->writeEvent(evInitSetPath);
2567
//load background pix
2568
unsigned char dataIsBackgroundPix[2];
2569
dataIsBackgroundPix[0]=SYSEX_ISBACKGROUNDPIX;
2570
dataIsBackgroundPix[1]=data[NUM_ISBACKGROUNDPIX];
2571
MidiPlayEvent evIsBackgroundPix(0, 0, ME_SYSEX,
2572
(const unsigned char*)dataIsBackgroundPix, 2);
2573
_gui->writeEvent(evIsBackgroundPix);
2574
unsigned char dataBackgroundPixPath[1+MAXSTRLENGTHBACKGROUNDPIXPATH];
2575
dataBackgroundPixPath[0]=SYSEX_BACKGROUNDPIXPATH;
2576
for(int a = 0; a < MAXSTRLENGTHBACKGROUNDPIXPATH; a++)
2577
dataBackgroundPixPath[a+1] = data[a+NUM_BACKGROUNDPIXPATH];
2578
MidiPlayEvent evBackgroundPixPath(0, 0, ME_SYSEX,
2579
(const unsigned char*)dataBackgroundPixPath,
2580
1+MAXSTRLENGTHBACKGROUNDPIXPATH);
2581
_gui->writeEvent(evBackgroundPixPath);
2582
}
2583
else _gui->saveConfigCheckBox->setChecked(false);
2584
//load FX
2585
//reverb
2586
_global.isReverbActivated = (bool)data[NUM_IS_REVERB_ON];
2587
unsigned char *dataReverbAct = new unsigned char[2];
2588
dataReverbAct[0]=SYSEX_REVERBACTIV;
2589
dataReverbAct[1]=(unsigned char)_global.isReverbActivated;
2590
MidiPlayEvent evReverbAct(0, 0, ME_SYSEX,(const unsigned char*)dataReverbAct, 2);
2591
_gui->writeEvent(evReverbAct);
2592
setReverbReturn((int)data[NUM_REVERB_RETURN]);
2593
unsigned char *dataReverbRet = new unsigned char[2];
2594
dataReverbRet[0]=SYSEX_REVERBRETURN;
2595
dataReverbRet[1]=(unsigned char)getReverbReturn();
2596
MidiPlayEvent evReverbRet(0, 0, ME_SYSEX,(const unsigned char*)dataReverbRet, 2);
2597
_gui->writeEvent(evReverbRet);
2598
Plugin* p;
2599
p = plugins.find((const char*)&data[NUM_REVERB_LIB],
2600
(const char*)&data[NUM_REVERB_LABEL]);
2601
if(p) {
2602
initPluginReverb(p);
2603
//for(int i = 0; i < _pluginIReverb->plugin()->parameter(); i++) {
2604
for(int i = 0; i < (int)_pluginIReverb->plugin()->controlInPorts(); i++) {
2605
float val;
2606
memcpy(&val, &data[NUM_CONFIGLENGTH + sizeof(float)*i], sizeof(float));
2607
setReverbParam(i, (double)val);
2608
}
2609
char dataBuildRev;
2610
dataBuildRev = SYSEX_BUILDGUIREVERB;
2611
MidiPlayEvent evSysexBuildRev(0, 0, ME_SYSEX,
2612
(const unsigned char*)&dataBuildRev, 1);
2613
_gui->writeEvent(evSysexBuildRev);
2614
}
2615
else _pluginIReverb = NULL;
2616
//chorus
2617
_global.isChorusActivated = (bool)data[NUM_IS_CHORUS_ON];
2618
unsigned char *dataChorusAct = new unsigned char[2];
2619
dataChorusAct[0]=SYSEX_CHORUSACTIV;
2620
dataChorusAct[1]=(unsigned char)_global.isChorusActivated;
2621
MidiPlayEvent evChorusAct(0, 0, ME_SYSEX,(const unsigned char*)dataChorusAct, 2);
2622
_gui->writeEvent(evChorusAct);
2623
setChorusReturn((int)data[NUM_CHORUS_RETURN]);
2624
unsigned char *dataChorusRet = new unsigned char[2];
2625
dataChorusRet[0]=SYSEX_CHORUSRETURN;
2626
dataChorusRet[1]=(unsigned char)getChorusReturn();
2627
MidiPlayEvent evChorusRet(0, 0, ME_SYSEX,(const unsigned char*)dataChorusRet, 2);
2628
_gui->writeEvent(evChorusRet);
2629
p = plugins.find((const char*)&data[NUM_CHORUS_LIB],
2630
(const char*)&data[NUM_CHORUS_LABEL]);
2631
if(p) {
2632
initPluginChorus(p);
2633
//for(int i = 0; i < _pluginIChorus->plugin()->parameter(); i++) {
2634
for(int i = 0; i < (int)_pluginIChorus->plugin()->controlInPorts(); i++) {
2635
float val;
2636
memcpy(&val, &data[NUM_CONFIGLENGTH
2637
+ sizeof(float)*(int)data[NUM_REVERB_PARAM_NBR]
2638
+ sizeof(float)*i],
2639
sizeof(float));
2640
setChorusParam(i, (double)val);
2641
}
2642
char dataBuildCho;
2643
dataBuildCho = SYSEX_BUILDGUICHORUS;
2644
MidiPlayEvent evSysexBuildCho(0, 0, ME_SYSEX,
2645
(const unsigned char*)&dataBuildCho, 1);
2646
_gui->writeEvent(evSysexBuildCho);
2647
}
2648
else _pluginIChorus = NULL;
2649
//delay
2650
_global.isDelayActivated = (bool)data[NUM_IS_DELAY_ON];
2651
unsigned char *dataDelayAct = new unsigned char[2];
2652
dataDelayAct[0]=SYSEX_DELAYACTIV;
2653
dataDelayAct[1]=(unsigned char)_global.isDelayActivated;
2654
MidiPlayEvent evDelayAct(0, 0, ME_SYSEX,(const unsigned char*)dataDelayAct, 2);
2655
_gui->writeEvent(evDelayAct);
2656
setDelayReturn((int)data[NUM_DELAY_RETURN]);
2657
unsigned char *dataDelayRet = new unsigned char[2];
2658
dataDelayRet[0]=SYSEX_DELAYRETURN;
2659
dataDelayRet[1]=(unsigned char)getDelayReturn();
2660
MidiPlayEvent evDelayRet(0, 0, ME_SYSEX,(const unsigned char*)dataDelayRet, 2);
2661
_gui->writeEvent(evDelayRet);
2662
//initPluginDelay(plugins.find("pandelay", "pandelay"));
2663
float delayfloat;
2664
memcpy(&delayfloat, &data[NUM_DELAY_BPM], sizeof(float));
2665
setDelayBPM(delayfloat);
2666
char dataDelayBPM[sizeof(float)+1];
2667
dataDelayBPM[0] = SYSEX_DELAYBPM;
2668
memcpy(&dataDelayBPM[1], &delayfloat, sizeof(float));
2669
MidiPlayEvent evSysexDelayBPM(0, 0, ME_SYSEX,
2670
(const unsigned char*)dataDelayBPM,
2671
sizeof(float)+1);
2672
_gui->writeEvent(evSysexDelayBPM);
2673
memcpy(&delayfloat, &data[NUM_DELAY_BEATRATIO], sizeof(float));
2674
setDelayBeatRatio(delayfloat);
2675
char dataDelayBeatRatio[sizeof(float)+1];
2676
dataDelayBeatRatio[0] = SYSEX_DELAYBEATRATIO;
2677
memcpy(&dataDelayBeatRatio[1], &delayfloat, sizeof(float));
2678
MidiPlayEvent evSysexDelayBeatRatio(0, 0, ME_SYSEX,
2679
(const unsigned char*)dataDelayBeatRatio,
2680
sizeof(float)+1);
2681
_gui->writeEvent(evSysexDelayBeatRatio);
2682
memcpy(&delayfloat, &data[NUM_DELAY_FEEDBACK], sizeof(float));
2683
setDelayFeedback(delayfloat);
2684
char dataDelayFeedback[sizeof(float)+1];
2685
dataDelayFeedback[0] = SYSEX_DELAYFEEDBACK;
2686
memcpy(&dataDelayFeedback[1], &delayfloat, sizeof(float));
2687
MidiPlayEvent evSysexDelayFeedback(0, 0, ME_SYSEX,
2688
(const unsigned char*)dataDelayFeedback,
2689
sizeof(float)+1);
2690
_gui->writeEvent(evSysexDelayFeedback);
2691
memcpy(&delayfloat, &data[NUM_DELAY_LFO_FREQ], sizeof(float));
2692
setDelayLFOFreq(delayfloat);
2693
char dataDelayLFOFreq[sizeof(float)+1];
2694
dataDelayLFOFreq[0] = SYSEX_DELAYLFOFREQ;
2695
memcpy(&dataDelayLFOFreq[1], &delayfloat, sizeof(float));
2696
MidiPlayEvent evSysexDelayLFOFreq(0, 0, ME_SYSEX,
2697
(const unsigned char*)dataDelayLFOFreq,
2698
sizeof(float)+1);
2699
_gui->writeEvent(evSysexDelayLFOFreq);
2700
memcpy(&delayfloat, &data[NUM_DELAY_LFO_DEPTH], sizeof(float));
2701
setDelayLFODepth(delayfloat);
2702
char dataDelayLFODepth[sizeof(float)+1];
2703
dataDelayLFODepth[0] = SYSEX_DELAYLFODEPTH;
2704
memcpy(&dataDelayLFODepth[1], &delayfloat, sizeof(float));
2705
MidiPlayEvent evSysexDelayLFODepth(0, 0, ME_SYSEX,
2706
(const unsigned char*)dataDelayLFODepth,
2707
sizeof(float)+1);
2708
_gui->writeEvent(evSysexDelayLFODepth);
2709
2710
//load the set compressed
2711
int offset =
2712
NUM_CONFIGLENGTH
2713
+ sizeof(float)*(int)data[NUM_REVERB_PARAM_NBR]
2714
+ sizeof(float)*(int)data[NUM_CHORUS_PARAM_NBR];
2715
QByteArray baComp = QByteArray((const char*)&data[offset], length-offset);
2716
2717
//uncompress the set
2718
QByteArray baUncomp = qUncompress(baComp);
2719
2720
//save the set in a temporary file and
2721
// read the XML file and create DOM tree
2722
QTemporaryFile file;
2723
file.open();
2724
file.write(baUncomp);
2725
QDomDocument domTree;
2726
file.reset(); //seek the start of the file
2727
domTree.setContent(&file);
2728
file.close();
2729
QDomNode node = domTree.documentElement();
2730
2731
while (!node.isNull()) {
2732
QDomElement e = node.toElement();
2733
if (e.isNull())
2734
continue;
2735
if (e.tagName() == "deicsOnzeSet") {
2736
QString version = e.attribute(QString("version"));
2737
if (version == "1.0") {
2738
for(int c = 0; c < NBRCHANNELS; c++) _preset[c]=_initialPreset;
2739
//read the set
2740
if((bool)data[NUM_SAVEONLYUSED]) {
2741
//printf("Mini\n");
2742
//updateSaveOnlyUsed(true);
2743
}
2744
else {
2745
//printf("Huge\n");
2746
while(!_set->_categoryVector.empty())
2747
delete(*_set->_categoryVector.begin());
2748
//updateSaveOnlyUsed(false);
2749
}
2750
_set->readSet(node.firstChild());
2751
//display load preset
2752
//setSet();
2753
}
2754
else printf("Wrong set version : %s\n",
2755
version.toLatin1().constData());
2756
}
2757
node = node.nextSibling();
2758
}
2759
//send sysex to the gui to load the set (actually not because it doesn't
2760
//work -the code is just zapped in the middle???-, so it is done above
2761
//int dL=2+baUncomp.size();
2762
int dL = 2;
2763
char dataSend[dL];
2764
dataSend[0]=SYSEX_LOADSET;
2765
dataSend[1]=data[NUM_SAVEONLYUSED];
2766
//for(int i=2; i<dL; i++) dataSend[i]=baUncop.at(i-2);
2767
MidiPlayEvent evSysex(0, 0, ME_SYSEX,(const unsigned char*)dataSend, dL);
2768
_gui->writeEvent(evSysex);
2769
2770
//select programs per channel
2771
for(int c = 0; c < NBRCHANNELS; c++) {
2772
int hbank=(int)data[NUM_CURRENTHBANK+c];
2773
int lbank=(int)data[NUM_CURRENTLBANK+c];
2774
int prog=(int)data[NUM_CURRENTPROG+c];
2775
programSelect(c, hbank, lbank, prog);
2776
int val=prog+(lbank<<8)+(hbank<<16);
2777
MidiPlayEvent evProgSel(0, 0, c, ME_CONTROLLER, CTRL_PROGRAM, val);
2778
_gui->writeEvent(evProgSel);
2779
}
2780
2781
}
2782
}
2783
//---------------------------------------------------------
2784
// sysex
2785
//---------------------------------------------------------
2786
bool DeicsOnze::sysex(int length, const unsigned char* data) {
2787
sysex(length, data, false);
2788
return false;
2789
}
2790
bool DeicsOnze::sysex(int length, const unsigned char* data, bool fromGui) {
2791
int cmd=data[0];
2792
int index;
2793
float f;
2794
switch(cmd) {
2795
case SYSEX_INIT_DATA:
2796
parseInitData(length, data);
2797
break;
2798
case SYSEX_MASTERVOL:
2799
setMasterVol((int)data[1]);
2800
if(!fromGui) {
2801
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2802
_gui->writeEvent(evSysex);
2803
}
2804
break;
2805
//case SYSEX_CHANNELNUM:
2806
//_global.channelNum = (char)data[1];
2807
//if(!fromGui) {
2808
// MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2809
// _gui->writeEvent(evSysex);
2810
//}
2811
//break;
2812
case SYSEX_QUALITY:
2813
setQuality((Quality)data[1]);
2814
if(!fromGui) {
2815
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2816
_gui->writeEvent(evSysex);
2817
}
2818
break;
2819
case SYSEX_FILTER:
2820
setFilter((bool)data[1]);
2821
if(!fromGui) {
2822
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2823
_gui->writeEvent(evSysex);
2824
}
2825
break;
2826
case SYSEX_FONTSIZE:
2827
_global.fontSize = (int)data[1];
2828
if(!fromGui) {
2829
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2830
_gui->writeEvent(evSysex);
2831
}
2832
break;
2833
case SYSEX_SAVECONFIG:
2834
_saveConfig = (bool)data[1];
2835
if(!fromGui) {
2836
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2837
_gui->writeEvent(evSysex);
2838
}
2839
break;
2840
case SYSEX_SAVEONLYUSED:
2841
_saveOnlyUsed = (bool)data[1];
2842
if(!fromGui) {
2843
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2844
_gui->writeEvent(evSysex);
2845
}
2846
break;
2847
case SYSEX_ISINITSET:
2848
_isInitSet = (bool)data[1];
2849
if(!fromGui) {
2850
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2851
_gui->writeEvent(evSysex);
2852
}
2853
break;
2854
case SYSEX_INITSETPATH:
2855
_initSetPath = (char*)&data[1];
2856
if(!fromGui) {
2857
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2858
_gui->writeEvent(evSysex);
2859
}
2860
break;
2861
case SYSEX_ISBACKGROUNDPIX:
2862
_isBackgroundPix = (bool)data[1];
2863
if(!fromGui) {
2864
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2865
_gui->writeEvent(evSysex);
2866
}
2867
break;
2868
case SYSEX_BACKGROUNDPIXPATH:
2869
_backgroundPixPath = (char*)&data[1];
2870
if(!fromGui) {
2871
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2872
_gui->writeEvent(evSysex);
2873
}
2874
break;
2875
case SYSEX_PANIC:
2876
resetVoices();
2877
break;
2878
case SYSEX_CHORUSACTIV:
2879
_global.isChorusActivated = (bool)data[1];
2880
if(!fromGui) {
2881
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2882
_gui->writeEvent(evSysex);
2883
}
2884
break;
2885
case SYSEX_CHORUSPARAM:
2886
index = (int)data[1];
2887
memcpy(&f, &data[2], sizeof(float));
2888
setChorusParam(index, (double)f);
2889
if(!fromGui) {
2890
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2891
_gui->writeEvent(evSysex);
2892
}
2893
break;
2894
case SYSEX_REVERBACTIV:
2895
_global.isReverbActivated = (bool)data[1];
2896
if(!fromGui) {
2897
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2898
_gui->writeEvent(evSysex);
2899
}
2900
break;
2901
case SYSEX_REVERBPARAM:
2902
index = (int)data[1];
2903
memcpy(&f, &data[2], sizeof(float));
2904
setReverbParam(index, (double)f);
2905
if(!fromGui) {
2906
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2907
_gui->writeEvent(evSysex);
2908
}
2909
break;
2910
case SYSEX_DELAYACTIV:
2911
_global.isDelayActivated = (bool)data[1];
2912
if(!fromGui) {
2913
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2914
_gui->writeEvent(evSysex);
2915
}
2916
break;
2917
case SYSEX_CHORUSRETURN:
2918
setChorusReturn((int)data[1]);
2919
if(!fromGui) {
2920
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2921
_gui->writeEvent(evSysex);
2922
}
2923
break;
2924
case SYSEX_REVERBRETURN:
2925
setReverbReturn((int)data[1]);
2926
if(!fromGui) {
2927
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2928
_gui->writeEvent(evSysex);
2929
}
2930
break;
2931
case SYSEX_DELAYRETURN:
2932
setDelayReturn((int)data[1]);
2933
if(!fromGui) {
2934
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2935
_gui->writeEvent(evSysex);
2936
}
2937
break;
2938
case SYSEX_SELECTREVERB:
2939
Plugin* pluginReverb;
2940
memcpy(&pluginReverb, &data[1], sizeof(Plugin*));
2941
initPluginReverb(pluginReverb);
2942
break;
2943
case SYSEX_SELECTCHORUS:
2944
Plugin* pluginChorus;
2945
memcpy(&pluginChorus, &data[1], sizeof(Plugin*));
2946
initPluginChorus(pluginChorus);
2947
break;
2948
case SYSEX_DELAYBPM:
2949
memcpy(&f, &data[1], sizeof(float));
2950
setDelayBPM(f);
2951
if(!fromGui) {
2952
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2953
_gui->writeEvent(evSysex);
2954
}
2955
break;
2956
case SYSEX_DELAYBEATRATIO:
2957
memcpy(&f, &data[1], sizeof(float));
2958
setDelayBeatRatio(f);
2959
if(!fromGui) {
2960
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2961
_gui->writeEvent(evSysex);
2962
}
2963
break;
2964
case SYSEX_DELAYFEEDBACK:
2965
memcpy(&f, &data[1], sizeof(float));
2966
setDelayFeedback(f);
2967
if(!fromGui) {
2968
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2969
_gui->writeEvent(evSysex);
2970
}
2971
break;
2972
case SYSEX_DELAYLFOFREQ:
2973
memcpy(&f, &data[1], sizeof(float));
2974
setDelayLFOFreq(f);
2975
if(!fromGui) {
2976
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2977
_gui->writeEvent(evSysex);
2978
}
2979
break;
2980
case SYSEX_DELAYLFODEPTH:
2981
memcpy(&f, &data[1], sizeof(float));
2982
setDelayLFODepth(f);
2983
if(!fromGui) {
2984
MidiPlayEvent evSysex(0, 0, ME_SYSEX, data, length);
2985
_gui->writeEvent(evSysex);
2986
}
2987
break;
2988
default:
2989
break;
2990
}
2991
return false;
2992
}
1198
2993
//---------------------------------------------------------
1199
2994
// setController
1200
2995
//---------------------------------------------------------
1201
1202
bool DeicsOnze::setController(int ch, int ctrl, int val)
1203
{
2996
bool DeicsOnze::setController(int channel, int id, int val) {
2997
setController(channel, id, val, false);
2998
return false;
2999
}
3000
bool DeicsOnze::setController(int ch, int ctrl, int val, bool fromGui) {
3001
int deiPan, k=0;
3002
if(_global.channel[ch].isEnable || ctrl==CTRL_CHANNELENABLE) {
3003
if(ctrl>=CTRL_AR && ctrl<CTRL_ALG) {
3004
k=(ctrl-CTRLOFFSET)/DECAPAR1;
3005
ctrl=ctrl-DECAPAR1*k;
3006
}
3007
else if(ctrl>CTRL_PL3 && ctrl<CTRL_REVERBRATE) {
3008
k=(ctrl-CTRLOFFSET-100)/DECAPAR2;
3009
ctrl=ctrl-DECAPAR2*k;
3010
}
1204
3011
switch(ctrl) {
1205
case CTRL_PROGRAM:
1206
{
1207
int hbank = (val & 0xff0000) >> 16;
1208
int lbank = (val & 0xff00) >> 8;
1209
if (hbank > 127) // map "dont care" to 0
1210
hbank = 0;
1211
if (lbank > 127)
1212
lbank = 0;
1213
if (lbank == 127 || ch == 9) // drum HACK
1214
lbank = 128;
1215
int prog = val & 0x7f;
1216
programSelect(ch, lbank, prog);
1217
_gui->updatePreset();
1218
}
1219
break;
1220
case CTRL_PITCH:
1221
printf("CONTROLE PITCH %d\n",val);
1222
setPitchBendCoef(ch, val);
1223
break;
1224
case CTRL_SUSTAIN:
1225
setSustain(ch, val);
1226
break;
1227
default:
1228
break;
3012
case CTRL_AR:
3013
_preset[ch]->setIsUsed(true);
3014
_preset[ch]->eg[k].ar=val;
3015
if(!fromGui) {
3016
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_AR+k*DECAPAR1,val);
3017
_gui->writeEvent(ev);
3018
}
3019
break;
3020
case CTRL_D1R:
3021
_preset[ch]->setIsUsed(true);
3022
_preset[ch]->eg[k].d1r=val;
3023
if(!fromGui) {
3024
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_D1R+k*DECAPAR1,val);
3025
_gui->writeEvent(ev);
3026
}
3027
break;
3028
case CTRL_D2R:
3029
_preset[ch]->setIsUsed(true);
3030
_preset[ch]->eg[k].d2r=val;
3031
if(!fromGui) {
3032
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_D2R+k*DECAPAR1,val);
3033
_gui->writeEvent(ev);
3034
}
3035
break;
3036
case CTRL_RR:
3037
_preset[ch]->setIsUsed(true);
3038
_preset[ch]->eg[k].rr=val;
3039
if(!fromGui) {
3040
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_RR+k*DECAPAR1,val);
3041
_gui->writeEvent(ev);
3042
}
3043
break;
3044
case CTRL_D1L:
3045
_preset[ch]->setIsUsed(true);
3046
_preset[ch]->eg[k].d1l=val;
3047
if(!fromGui) {
3048
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_D1L+k*DECAPAR1,val);
3049
_gui->writeEvent(ev);
3050
}
3051
break;
3052
case CTRL_LS:
3053
_preset[ch]->setIsUsed(true);
3054
_preset[ch]->scaling.level[k]=val;
3055
if(!fromGui) {
3056
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_LS+k*DECAPAR1,val);
3057
_gui->writeEvent(ev);
3058
}
3059
break;
3060
case CTRL_RS:
3061
_preset[ch]->setIsUsed(true);
3062
_preset[ch]->scaling.rate[k]=val;
3063
if(!fromGui) {
3064
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_RS+k*DECAPAR1,val);
3065
_gui->writeEvent(ev);
3066
}
3067
break;
3068
case CTRL_EBS:
3069
_preset[ch]->setIsUsed(true);
3070
_preset[ch]->sensitivity.egBias[k]=val;
3071
if(!fromGui) {
3072
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_EBS+k*DECAPAR1,val);
3073
_gui->writeEvent(ev);
3074
}
3075
break;
3076
case CTRL_AME:
3077
_preset[ch]->setIsUsed(true);
3078
_preset[ch]->sensitivity.ampOn[k]=val==1;
3079
if(!fromGui) {
3080
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_AME+k*DECAPAR1,val);
3081
_gui->writeEvent(ev);
3082
}
3083
break;
3084
case CTRL_KVS:
3085
_preset[ch]->setIsUsed(true);
3086
_preset[ch]->sensitivity.keyVelocity[k]=val;
3087
if(!fromGui) {
3088
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_KVS+k*DECAPAR1,val);
3089
_gui->writeEvent(ev);
3090
}
3091
break;
3092
case CTRL_OUT:
3093
_preset[ch]->setIsUsed(true);
3094
_preset[ch]->outLevel[k]=val;
3095
setOutLevel(k);
3096
if(!fromGui) {
3097
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_OUT+k*DECAPAR1,val);
3098
_gui->writeEvent(ev);
3099
}
3100
break;
3101
case CTRL_RATIO:
3102
_preset[ch]->setIsUsed(true);
3103
_preset[ch]->frequency[k].ratio=((double)val)/100.0;
3104
if(!fromGui) {
3105
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,
3106
CTRL_RATIO+k*DECAPAR1,val);
3107
_gui->writeEvent(ev);
3108
}
3109
break;
3110
case CTRL_DET:
3111
_preset[ch]->setIsUsed(true);
3112
_preset[ch]->detune[k]=val;
3113
if(!fromGui) {
3114
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_DET+k*DECAPAR1,val);
3115
_gui->writeEvent(ev);
3116
}
3117
break;
3118
case CTRL_ALG:
3119
_preset[ch]->setIsUsed(true);
3120
_preset[ch]->algorithm=(Algorithm)val;
3121
if(!fromGui) {
3122
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_ALG,val);
3123
_gui->writeEvent(ev);
3124
}
3125
break;
3126
case CTRL_FEEDBACK:
3127
_preset[ch]->setIsUsed(true);
3128
_preset[ch]->feedback=val;
3129
setFeedback(ch);
3130
if(!fromGui) {
3131
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_FEEDBACK,val);
3132
_gui->writeEvent(ev);
3133
}
3134
break;
3135
case CTRL_SPEED:
3136
_preset[ch]->setIsUsed(true);
3137
_preset[ch]->lfo.speed=val;
3138
setLfo(ch);
3139
if(!fromGui) {
3140
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_SPEED,val);
3141
_gui->writeEvent(ev);
3142
}
3143
break;
3144
case CTRL_DELAY:
3145
_preset[ch]->setIsUsed(true);
3146
_preset[ch]->lfo.delay=val;
3147
setLfo(ch);
3148
if(!fromGui) {
3149
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_DELAY,val);
3150
_gui->writeEvent(ev);
3151
}
3152
break;
3153
case CTRL_PMODDEPTH:
3154
_preset[ch]->setIsUsed(true);
3155
_preset[ch]->lfo.pModDepth=val;
3156
setLfo(ch);
3157
if(!fromGui) {
3158
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PMODDEPTH,val);
3159
_gui->writeEvent(ev);
3160
}
3161
break;
3162
case CTRL_AMODDEPTH:
3163
_preset[ch]->setIsUsed(true);
3164
_preset[ch]->lfo.aModDepth=val;
3165
setLfo(ch);
3166
if(!fromGui) {
3167
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_AMODDEPTH,val);
3168
_gui->writeEvent(ev);
3169
}
3170
break;
3171
case CTRL_SYNC:
3172
_preset[ch]->setIsUsed(true);
3173
_preset[ch]->lfo.sync=val==1;
3174
setLfo(ch);
3175
if(!fromGui) {
3176
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_SYNC,val);
3177
_gui->writeEvent(ev);
3178
}
3179
break;
3180
case CTRL_WAVE:
3181
_preset[ch]->setIsUsed(true);
3182
_preset[ch]->lfo.wave=(Wave)val;
3183
setLfo(ch);
3184
if(!fromGui) {
3185
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_WAVE,val);
3186
_gui->writeEvent(ev);
3187
}
3188
break;
3189
case CTRL_PMODSENS:
3190
_preset[ch]->setIsUsed(true);
3191
_preset[ch]->sensitivity.pitch=val;
3192
setLfo(ch);
3193
if(!fromGui) {
3194
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PMODSENS,val);
3195
_gui->writeEvent(ev);
3196
}
3197
break;
3198
case CTRL_AMS:
3199
_preset[ch]->setIsUsed(true);
3200
_preset[ch]->sensitivity.amplitude=val;
3201
setLfo(ch);
3202
if(!fromGui) {
3203
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_AMS,val);
3204
_gui->writeEvent(ev);
3205
}
3206
break;
3207
case CTRL_TRANSPOSE:
3208
_preset[ch]->setIsUsed(true);
3209
_preset[ch]->function.transpose=val;
3210
if(!fromGui) {
3211
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_TRANSPOSE,val);
3212
_gui->writeEvent(ev);
3213
}
3214
break;
3215
case CTRL_POLYMODE:
3216
_preset[ch]->setIsUsed(true);
3217
_preset[ch]->function.mode=(Mode)val;
3218
if(!fromGui) {
3219
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_POLYMODE,val);
3220
_gui->writeEvent(ev);
3221
}
3222
break;
3223
case CTRL_PBENDRANGE:
3224
_preset[ch]->setIsUsed(true);
3225
_preset[ch]->function.pBendRange=val;
3226
if(!fromGui) {
3227
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PBENDRANGE,val);
3228
_gui->writeEvent(ev);
3229
}
3230
break;
3231
case CTRL_PORTAMODE:
3232
_preset[ch]->setIsUsed(true);
3233
_preset[ch]->function.portamento=(Portamento)val;
3234
if(!fromGui) {
3235
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PORTAMODE,val);
3236
_gui->writeEvent(ev);
3237
}
3238
break;
3239
case CTRL_PORTATIME:
3240
_preset[ch]->setIsUsed(true);
3241
_preset[ch]->function.portamentoTime=val;
3242
if(!fromGui) {
3243
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PORTATIME,val);
3244
_gui->writeEvent(ev);
3245
}
3246
break;
3247
case CTRL_FCVOLUME:
3248
_preset[ch]->setIsUsed(true);
3249
_preset[ch]->function.fcVolume=val;
3250
if(!fromGui) {
3251
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_FCVOLUME,val);
3252
_gui->writeEvent(ev);
3253
}
3254
break;
3255
case CTRL_FSW:
3256
_preset[ch]->setIsUsed(true);
3257
_preset[ch]->function.footSw=(FootSw)val;
3258
if(!fromGui) {
3259
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_FSW,val);
3260
_gui->writeEvent(ev);
3261
}
3262
break;
3263
case CTRL_MWPITCH:
3264
_preset[ch]->setIsUsed(true);
3265
_preset[ch]->function.mwPitch=val;
3266
if(!fromGui) {
3267
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_MWPITCH,val);
3268
_gui->writeEvent(ev);
3269
}
3270
break;
3271
case CTRL_MWAMPLITUDE:
3272
_preset[ch]->setIsUsed(true);
3273
_preset[ch]->function.mwAmplitude=val;
3274
if(!fromGui) {
3275
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_MWAMPLITUDE,val);
3276
_gui->writeEvent(ev);
3277
}
3278
break;
3279
case CTRL_BCPITCH:
3280
_preset[ch]->setIsUsed(true);
3281
_preset[ch]->function.bcPitch=val;
3282
if(!fromGui) {
3283
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_BCPITCH,val);
3284
_gui->writeEvent(ev);
3285
}
3286
break;
3287
case CTRL_BCAMPLITUDE:
3288
_preset[ch]->setIsUsed(true);
3289
_preset[ch]->function.bcAmplitude=val;
3290
if(!fromGui) {
3291
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_BCAMPLITUDE,val);
3292
_gui->writeEvent(ev);
3293
}
3294
break;
3295
case CTRL_BCPITCHBIAS:
3296
_preset[ch]->setIsUsed(true);
3297
_preset[ch]->function.bcPitchBias=val;
3298
if(!fromGui) {
3299
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_BCPITCHBIAS,val);
3300
_gui->writeEvent(ev);
3301
}
3302
break;
3303
case CTRL_BCEGBIAS:
3304
_preset[ch]->setIsUsed(true);
3305
_preset[ch]->function.bcEgBias=val;
3306
if(!fromGui) {
3307
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_BCEGBIAS,val);
3308
_gui->writeEvent(ev);
3309
}
3310
break;
3311
case CTRL_ATPITCH:
3312
_preset[ch]->setIsUsed(true);
3313
_preset[ch]->function.atPitch=val;
3314
if(!fromGui) {
3315
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_ATPITCH,val);
3316
_gui->writeEvent(ev);
3317
}
3318
break;
3319
case CTRL_ATAMPLITUDE:
3320
_preset[ch]->setIsUsed(true);
3321
_preset[ch]->function.atAmplitude=val;
3322
if(!fromGui) {
3323
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_ATAMPLITUDE,val);
3324
_gui->writeEvent(ev);
3325
}
3326
break;
3327
case CTRL_ATPITCHBIAS:
3328
_preset[ch]->setIsUsed(true);
3329
_preset[ch]->function.atPitchBias=val;
3330
if(!fromGui) {
3331
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_ATPITCHBIAS,val);
3332
_gui->writeEvent(ev);
3333
}
3334
break;
3335
case CTRL_ATEGBIAS:
3336
_preset[ch]->setIsUsed(true);
3337
_preset[ch]->function.atEgBias=val;
3338
if(!fromGui) {
3339
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_ATEGBIAS,val);
3340
_gui->writeEvent(ev);
3341
}
3342
break;
3343
case CTRL_PR1:
3344
_preset[ch]->setIsUsed(true);
3345
_preset[ch]->pitchEg.pr1=val;
3346
if(!fromGui) {
3347
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PR1,val);
3348
_gui->writeEvent(ev);
3349
}
3350
break;
3351
case CTRL_PR2:
3352
_preset[ch]->setIsUsed(true);
3353
_preset[ch]->pitchEg.pr2=val;
3354
if(!fromGui) {
3355
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PR2,val);
3356
_gui->writeEvent(ev);
3357
}
3358
break;
3359
case CTRL_PR3:
3360
_preset[ch]->setIsUsed(true);
3361
_preset[ch]->pitchEg.pr3=val;
3362
if(!fromGui) {
3363
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PR3,val);
3364
_gui->writeEvent(ev);
3365
}
3366
break;
3367
case CTRL_PL1:
3368
_preset[ch]->setIsUsed(true);
3369
_preset[ch]->pitchEg.pl1=val;
3370
if(!fromGui) {
3371
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PL1,val);
3372
_gui->writeEvent(ev);
3373
}
3374
break;
3375
case CTRL_PL2:
3376
_preset[ch]->setIsUsed(true);
3377
_preset[ch]->pitchEg.pl2=val;
3378
if(!fromGui) {
3379
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PL2,val);
3380
_gui->writeEvent(ev);
3381
}
3382
break;
3383
case CTRL_PL3:
3384
_preset[ch]->setIsUsed(true);
3385
_preset[ch]->pitchEg.pl3=val;
3386
if(!fromGui) {
3387
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_PL3,val);
3388
_gui->writeEvent(ev);
3389
}
3390
break;
3391
case CTRL_FIX:
3392
_preset[ch]->setIsUsed(true);
3393
_preset[ch]->frequency[k].isFix=val==1;
3394
if(!fromGui) {
3395
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_FIX+k*DECAPAR2,val);
3396
_gui->writeEvent(ev);
3397
}
3398
break;
3399
case CTRL_FIXRANGE:
3400
_preset[ch]->setIsUsed(true);
3401
_preset[ch]->frequency[k].freq=((double)val)/100.0;
3402
if(!fromGui) {
3403
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,
3404
CTRL_FIXRANGE+k*DECAPAR2,val);
3405
_gui->writeEvent(ev);
3406
}
3407
break;
3408
case CTRL_OSW:
3409
_preset[ch]->setIsUsed(true);
3410
_preset[ch]->oscWave[k]=(OscWave)val;
3411
if(!fromGui) {
3412
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_OSW+k*DECAPAR2,val);
3413
_gui->writeEvent(ev);
3414
}
3415
break;
3416
case CTRL_SHFT:
3417
_preset[ch]->setIsUsed(true);
3418
_preset[ch]->eg[k].egShift=(egShiftValue)val;
3419
if(!fromGui) {
3420
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_SHFT+k*DECAPAR2,val);
3421
_gui->writeEvent(ev);
3422
}
3423
break;
3424
case CTRL_REVERBRATE:
3425
_preset[ch]->setIsUsed(true);
3426
_preset[ch]->function.reverbRate=val;
3427
if(!fromGui) {
3428
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_REVERBRATE,val);
3429
_gui->writeEvent(ev);
3430
}
3431
break;
3432
case CTRL_FCPITCH:
3433
_preset[ch]->setIsUsed(true);
3434
_preset[ch]->function.fcPitch=val;
3435
if(!fromGui) {
3436
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_FCPITCH,val);
3437
_gui->writeEvent(ev);
3438
}
3439
break;
3440
case CTRL_FCAMPLITUDE:
3441
_preset[ch]->setIsUsed(true);
3442
_preset[ch]->function.fcAmplitude=val;
3443
if(!fromGui) {
3444
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_FCAMPLITUDE,val);
3445
_gui->writeEvent(ev);
3446
}
3447
break;
3448
case CTRL_CHANNELENABLE:
3449
setChannelEnable(ch, (bool)val);
3450
if(!fromGui) {
3451
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_CHANNELENABLE,val);
3452
_gui->writeEvent(ev);
3453
}
3454
break;
3455
case CTRL_CHANNELDETUNE:
3456
_preset[ch]->setIsUsed(true);
3457
setChannelDetune(ch, val);
3458
if(!fromGui) {
3459
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_CHANNELDETUNE,val);
3460
_gui->writeEvent(ev);
3461
}
3462
break;
3463
case CTRL_CHANNELVOLUME:
3464
setChannelVol(ch, val);
3465
applyChannelAmp(ch);
3466
if(!fromGui) {
3467
MidiPlayEvent ev(0, 0, ch,ME_CONTROLLER,CTRL_CHANNELVOLUME,val);
3468
_gui->writeEvent(ev);
3469
}
3470
break;
3471
case CTRL_NBRVOICES:
3472
setNbrVoices(ch, val);
3473
if(!fromGui) {
3474
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_NBRVOICES, val);
3475
_gui->writeEvent(ev);
3476
}
3477
break;
3478
case CTRL_PROGRAM: {
3479
int hbank = (val & 0xff0000) >> 16;
3480
int lbank = (val & 0xff00) >> 8;
3481
int prog = val & 0x7f;
3482
if (hbank > 127) // map "dont care" to 0
3483
hbank = 0;
3484
if (lbank > 127)
3485
lbank = 0;
3486
programSelect(ch, hbank, lbank, prog);
3487
_preset[ch]->setIsUsed(true);//TODO : not sure to put that
3488
if(!fromGui) {
3489
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_PROGRAM, val);
3490
_gui->writeEvent(ev);
3491
}
3492
} break;
3493
case CTRL_MODULATION:
3494
setModulation(ch, val);
3495
if(!fromGui) {
3496
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_MODULATION, val);
3497
_gui->writeEvent(ev);
3498
}
3499
break;
3500
case CTRL_PITCH:
3501
setPitchBendCoef(ch, val);
3502
break;
3503
case CTRL_PANPOT:
3504
_preset[ch]->setIsUsed(true);
3505
deiPan = val*2*MAXCHANNELPAN/127-MAXCHANNELPAN;
3506
setChannelPan(ch, deiPan);
3507
applyChannelAmp(ch);
3508
if(!fromGui) {
3509
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_CHANNELPAN, deiPan);
3510
_gui->writeEvent(ev);
3511
}
3512
break;
3513
case CTRL_CHANNELPAN:
3514
_preset[ch]->setIsUsed(true);
3515
setChannelPan(ch, val);
3516
applyChannelAmp(ch);
3517
if(!fromGui) {
3518
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_CHANNELPAN, val);
3519
_gui->writeEvent(ev);
3520
}
3521
break;
3522
case CTRL_FINEBRIGHTNESS:
3523
_preset[ch]->setIsUsed(true);
3524
setChannelBrightness(ch, val);
3525
setOutLevel(ch);
3526
if(!fromGui) {
3527
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_FINEBRIGHTNESS, val);
3528
_gui->writeEvent(ev);
3529
}
3530
break;
3531
case CTRL_BRIGHTNESS:
3532
_preset[ch]->setIsUsed(true);
3533
setChannelBrightness(ch, val*(MIDFINEBRIGHTNESS/MIDBRIGHTNESS));
3534
setOutLevel(ch);
3535
if(!fromGui) {
3536
MidiPlayEvent
3537
ev(0, 0, ch,ME_CONTROLLER,CTRL_FINEBRIGHTNESS,getChannelBrightness(ch));
3538
_gui->writeEvent(ev);
3539
}
3540
break;
3541
case CTRL_ATTACK_TIME:
3542
_preset[ch]->setIsUsed(true);
3543
setChannelAttack(ch, val);
3544
setEnvAttack(ch);
3545
if(!fromGui) {
3546
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_ATTACK_TIME, val);
3547
_gui->writeEvent(ev);
3548
}
3549
break;
3550
case CTRL_RELEASE_TIME:
3551
_preset[ch]->setIsUsed(true);
3552
setChannelRelease(ch, val);
3553
setEnvRelease(ch);
3554
if(!fromGui) {
3555
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_RELEASE_TIME, val);
3556
_gui->writeEvent(ev);
3557
}
3558
break;
3559
case CTRL_REVERB_SEND:
3560
setChannelReverb(ch, val);
3561
if(!fromGui) {
3562
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_REVERB_SEND, val);
3563
_gui->writeEvent(ev);
3564
}
3565
break;
3566
case CTRL_CHORUS_SEND:
3567
setChannelChorus(ch, val);
3568
if(!fromGui) {
3569
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_CHORUS_SEND, val);
3570
_gui->writeEvent(ev);
3571
}
3572
break;
3573
case CTRL_VARIATION_SEND:
3574
setChannelDelay(ch, val);
3575
if(!fromGui) {
3576
MidiPlayEvent ev(0, 0, ch, ME_CONTROLLER, CTRL_VARIATION_SEND, val);
3577
_gui->writeEvent(ev);
3578
}
3579
break;
3580
case CTRL_SUSTAIN:
3581
setSustain(ch, val);
3582
break;
3583
case CTRL_VOLUME:
3584
setChannelVol(ch, val*(MAXCHANNELVOLUME/127));
3585
applyChannelAmp(ch);
3586
if(!fromGui) {
3587
MidiPlayEvent
3588
ev(0, 0, ch, ME_CONTROLLER, CTRL_CHANNELVOLUME, getChannelVol(ch));
3589
_gui->writeEvent(ev);
3590
}
3591
break;
3592
case CTRL_ALL_SOUNDS_OFF:
3593
resetVoices();
3594
default:
3595
break;
1229
3596
}
1230
return false;
3597
}
3598
return false;
1231
3599
}
1232
3600
1233
3601
//---------------------------------------------------------
1234
3602
// getPatchName
1235
3603
//---------------------------------------------------------
1236
3604
1237
const char* DeicsOnze::getPatchName(int /*ch*/, int val, int) const
1238
{
3605
const char* DeicsOnze::getPatchName(int ch, int val, int) const {
3606
if(_global.channel[ch].isEnable) {
1239
3607
Preset* p_preset;
1240
3608
int hbank = (val & 0xff0000) >> 16;
1241
3609
int lbank = (val & 0xff00) >> 8;
1242
3610
if (hbank > 127)
1243
hbank = 0;
3611
hbank = 0;
1244
3612
if (lbank > 127)
1245
lbank = 0;
3613
lbank = 0;
1246
3614
if (lbank == 127) // drum HACK
1247
lbank = 128;
3615
lbank = 128;
1248
3616
int prog = val & 0x7f;
1249
char* name="---";
1250
p_preset=_categorySet->findPreset(lbank, prog);
1251
if (p_preset) name=const_cast<char *>(p_preset->name.c_str());
1252
return name;
3617
const char* tempName="INITVOICE";
3618
p_preset=_set->findPreset(hbank, lbank, prog);
3619
if (p_preset) tempName=const_cast<char *>(p_preset->name.c_str());
3620
return tempName;
3621
}
3622
return " ";
1253
3623
}
1254
3624
1255
1256
3625
//---------------------------------------------------------
1257
3626
// getPatchInfo
1258
3627
//---------------------------------------------------------
3628
const MidiPatch* DeicsOnze::getPatchInfo(int /*ch*/, const MidiPatch* p) const {
3629
Preset* preset = NULL;
3630
Subcategory* sub = NULL;
3631
Category* cat = NULL;
3632
if(p) {
3633
_patch.hbank = p->hbank;
3634
_patch.lbank = p->lbank;
3635
_patch.prog = p->prog;
3636
switch(p->typ) {
3637
case MP_TYPE_HBANK :
3638
sub = findSubcategory(_patch.hbank, _patch.lbank);
3639
if(sub) {
3640
_patch.name = sub->_subcategoryName.c_str();
3641
_patch.typ = MP_TYPE_LBANK;
3642
return &_patch;
3643
}
3644
else {
3645
if(_patch.lbank + 1 < LBANK_NBR) {
3646
_patch.lbank++;
3647
return getPatchInfo(0, &_patch);
3648
}
3649
else {
3650
_patch.prog = PROG_NBR - 1; //hack to go faster
3651
_patch.typ = 0;
3652
return getPatchInfo(0, &_patch);
3653
}
3654
}
3655
break;
3656
case MP_TYPE_LBANK :
3657
preset = findPreset(_patch.hbank, _patch.lbank, _patch.prog);
3658
_patch.typ = 0;
3659
if(preset) {
3660
_patch.name = preset->name.c_str();
3661
return &_patch;
3662
}
3663
else return getPatchInfo(0, &_patch);
3664
break;
3665
default :
3666
if(_patch.prog + 1 < PROG_NBR) {
3667
_patch.prog++;
3668
preset = findPreset(_patch.hbank, _patch.lbank, _patch.prog);
3669
if(preset) {
3670
_patch.name = preset->name.c_str();
3671
return &_patch;
3672
}
3673
else return getPatchInfo(0, &_patch);
3674
}
3675
else {
3676
_patch.prog = 0;
3677
if(_patch.lbank + 1 < LBANK_NBR) {
3678
_patch.lbank++;
3679
_patch.typ = MP_TYPE_HBANK;
3680
return getPatchInfo(0, &_patch);
3681
}
3682
else {
3683
_patch.lbank = 0;
3684
if(_patch.hbank + 1 < HBANK_NBR) {
3685
_patch.hbank++;
3686
_patch.typ = MP_TYPE_HBANK;
3687
cat = findCategory(_patch.hbank);
3688
if(cat) {
3689
_patch.name = cat->_categoryName.c_str();
3690
return &_patch;
3691
}
3692
return getPatchInfo(0, &_patch);
3693
}
3694
else return NULL;
3695
}
3696
}
3697
}
3698
}
3699
else {
3700
_patch.typ = MP_TYPE_HBANK;
3701
_patch.hbank = 0;
3702
_patch.lbank = 0;
3703
_patch.prog = 0;
3704
cat = findCategory(_patch.hbank);
3705
if(cat) {
3706
_patch.name = cat->_categoryName.c_str();
3707
return &_patch;
3708
}
3709
else {
3710
_patch.hbank++;
3711
return getPatchInfo(0, &_patch);
3712
}
3713
}
3714
}
1259
3715
1260
const MidiPatch* DeicsOnze::getPatchInfo(int /*ch*/, const MidiPatch* /*p*/) const
3716
//---------------------------------------------------------
3717
// getControllerInfo
3718
/*!
3719
\fn SimpleSynth::getControllerInfo
3720
\brief Called from host to collect info about which controllers
3721
the synth supports
3722
\param index current controller number
3723
\param name pointer where name is stored
3724
\param controller int pointer where muse controller number is stored
3725
\param min int pointer where controller min value is stored
3726
\param max int pointer where controller max value is stored
3727
\return 0 when done, otherwise return next desired controller index
3728
*/
3729
//---------------------------------------------------------
3730
int DeicsOnze::getControllerInfo(int index, const char** name,
3731
int* controller, int* min, int* max)
1261
3732
{
1262
/*if(_numPatch<NBRBANKPRESETS)
1263
{
1264
_patch.typ = 0;
1265
_patch.name = bankA[_numPatch].name;
1266
_patch.lbank = 1;
1267
_patch.prog = _numPatch;
1268
return &_patch;
1269
}*/
1270
return 0;
3733
if (index >= nbrCtrl) {
3734
return 0;
3735
}
3736
3737
*name = _ctrl[index].name.c_str();
3738
*controller = _ctrl[index].num;
3739
*min = _ctrl[index].min;
3740
*max = _ctrl[index].max;
3741
return (index +1);
1271
3742
}
1272
3743
1273
1274
3744
//---------------------------------------------------------
1275
3745
// playNote
1276
3746
// process note on
1277
3747
//---------------------------------------------------------
1278
1279
bool DeicsOnze::playNote(int /*channel*/, int pitch, int velo)
1280
{
3748
bool DeicsOnze::playNote(int ch, int pitch, int velo) {
1281
3749
int newVoice;
1282
3750
int nO2V;
1283
3751
int p2V;
1284
1285
p2V=pitchOn2Voice(pitch);
1286
1287
if(velo==0) {//Note off
1288
if(p2V<NBRVOICES)
1289
{
1290
if(_global.sustain) _voices[p2V].isSustained=true;
1291
else
1292
for(int i=0; i<NBROP; i++)
1293
{
1294
_voices[p2V].op[i].envState=RELEASE;
1295
_voices[p2V].op[i].coefVLevel=envRR2coef(_preset->eg[i].rr
1296
,sampleRate());
1297
}
1298
return false;}
3752
double tempTargetFreq;
3753
if(_global.channel[ch].isEnable) {
3754
if(velo==0) {//Note off
3755
p2V=pitchOn2Voice(ch, pitch);
3756
//printf("Note Off : pitchOn2Voice = %d\n", p2V);
3757
if(p2V<_global.channel[ch].nbrVoices) {
3758
if(_global.channel[ch].sustain)
3759
_global.channel[ch].voices[p2V].isSustained = true;
3760
else {
3761
_global.channel[ch].voices[p2V].keyOn = false;
3762
_global.channel[ch].lastVoiceKeyOff = p2V;
3763
_global.channel[ch].lastVoiceKeyOn.remove(p2V);
3764
if(_preset[ch]->function.mode == MONO && existsKeyOn(ch)
3765
&& _global.channel[ch].voices[p2V].isOn) {
3766
newVoice = _global.channel[ch].lastVoiceKeyOn.back();
3767
//portamento
3768
if(_preset[ch]->function.portamentoTime!=0) {
3769
_global.channel[ch].voices[newVoice].hasAttractor = true;
3770
_global.channel[ch].voices[newVoice].attractor =
3771
getAttractor(_preset[ch]->function.portamentoTime,
3772
_global.deiSampleRate);
3773
}
3774
else _global.channel[ch].voices[newVoice].hasAttractor = false;
3775
//feedback
3776
_global.channel[ch].voices[newVoice].sampleFeedback =
3777
_global.channel[ch].voices[p2V].sampleFeedback;
3778
//on/off
3779
_global.channel[ch].voices[p2V].isOn = false;
3780
_global.channel[ch].voices[newVoice].isOn = true;
3781
//per op
3782
for(int i = 0; i < NBROP; i++) {
3783
_global.channel[ch].voices[newVoice].op[i].index =
3784
_global.channel[ch].voices[p2V].op[i].index;
3785
_global.channel[ch].voices[newVoice].op[i].envState =
3786
_global.channel[ch].voices[p2V].op[i].envState;
3787
_global.channel[ch].voices[newVoice].op[i].envIndex =
3788
_global.channel[ch].voices[p2V].op[i].envIndex;
3789
_global.channel[ch].voices[newVoice].op[i].envInct =
3790
_global.channel[ch].voices[p2V].op[i].envInct;
3791
_global.channel[ch].voices[newVoice].op[i].envLevel =
3792
_global.channel[ch].voices[p2V].op[i].envLevel;
3793
_global.channel[ch].voices[newVoice].op[i].coefVLevel =
3794
_global.channel[ch].voices[p2V].op[i].coefVLevel;
3795
if(_global.channel[ch].voices[newVoice].hasAttractor)
3796
_global.channel[ch].voices[newVoice].op[i].inct =
3797
_global.channel[ch].voices[p2V].op[i].inct;
3798
}
3799
}
3800
else {
3801
setPitchEnvRelease(ch, p2V);
3802
for(int i=0; i<NBROP; i++) {
3803
_global.channel[ch].voices[p2V].op[i].envState = RELEASE;
3804
setEnvRelease(ch, p2V, i);
3805
}
3806
}
3807
}
3808
return false;
3809
}
1299
3810
//else printf("error over NBRVOICES\n");
3811
}
3812
else //Note on
3813
{
3814
nO2V=noteOff2Voice(ch);
3815
newVoice=((nO2V==MAXNBRVOICES)?minVolu2Voice(ch):nO2V);
3816
//printf("Note On : ch = %d, v = %d, p = %d\n", ch, newVoice, pitch);
3817
3818
//----------
3819
//portamento
3820
//----------
3821
//if there is no previous note there is no portamento
3822
if(_preset[ch]->function.portamentoTime!=0
3823
&& _global.channel[ch].isLastNote &&
3824
((_preset[ch]->function.portamento==FULL) ||
3825
(_preset[ch]->function.portamento==FINGER && existsKeyOn(ch)))) {
3826
_global.channel[ch].voices[newVoice].hasAttractor = true;
3827
_global.channel[ch].voices[newVoice].attractor =
3828
getAttractor(_preset[ch]->function.portamentoTime,
3829
_global.deiSampleRate);
3830
}
3831
else _global.channel[ch].voices[newVoice].hasAttractor = false;
3832
3833
if(_preset[ch]->lfo.sync) _global.channel[ch].lfoIndex=0;
3834
3835
_global.channel[ch].lfoDelayIndex =
3836
(_preset[ch]->lfo.delay==0?(double)(RESOLUTION/4):0.0);
3837
_global.channel[ch].delayPassed = false;
3838
3839
//--------------
3840
//PITCH ENVELOPE
3841
//--------------
3842
if(isPitchEnv(&_preset[ch]->pitchEg)) {
3843
_global.channel[ch].voices[newVoice].pitchEnvState = PHASE1;
3844
_global.channel[ch].voices[newVoice].pitchEnvCoefInctPhase1 =
3845
getPitchEnvCoefInct(_preset[ch]->pitchEg.pl1);
3846
_global.channel[ch].voices[newVoice].pitchEnvCoefInctPhase2 =
3847
getPitchEnvCoefInct(_preset[ch]->pitchEg.pl2);
3848
_global.channel[ch].voices[newVoice].pitchEnvCoefInctPhase3 =
3849
getPitchEnvCoefInct(_preset[ch]->pitchEg.pl3);
3850
_global.channel[ch].voices[newVoice].pitchEnvCoefInct =
3851
_global.channel[ch].voices[newVoice].pitchEnvCoefInctPhase1;
3852
_global.channel[ch].voices[newVoice].pitchEnvCoefInctInct =
3853
getPitchEnvCoefInctInct(_preset[ch]->pitchEg.pl1,
3854
_preset[ch]->pitchEg.pl2,
3855
_preset[ch]->pitchEg.pr1,
3856
_global.deiSampleRate);
3857
}
3858
else {
3859
_global.channel[ch].voices[newVoice].pitchEnvState = OFF_PE;
3860
_global.channel[ch].voices[newVoice].pitchEnvCoefInct = 1.0;
3861
}
3862
//per operator
3863
for(int i=0; i<NBROP; i++) {
3864
//------
3865
//VOLUME
3866
//------
3867
_global.channel[ch].voices[newVoice].op[i].ampVeloNote =
3868
velo2AmpR(velo, _preset[ch]->sensitivity.keyVelocity[i])
3869
*note2Amp((double) (pitch+_preset[ch]->function.transpose),
3870
_preset[ch]->scaling.level[i]);
3871
_global.channel[ch].voices[newVoice].op[i].amp =
3872
outLevel2Amp(_preset[ch]->outLevel[i])
3873
*_global.channel[ch].voices[newVoice].op[i].ampVeloNote
3874
* brightness2Amp(ch, i);
3875
//----------------
3876
//INDEX & ENVELOPE
3877
//----------------
3878
//if index get 0.0, it means that the offset is 0
3879
if(existsKeyOn(ch)) {
3880
int lastVoice = _global.channel[ch].lastVoiceKeyOn.back();
3881
if(_preset[ch]->function.mode == MONO) {
3882
_global.channel[ch].voices[newVoice].op[i].index =
3883
_global.channel[ch].voices[lastVoice].op[i].index;
3884
_global.channel[ch].voices[newVoice].sampleFeedback =
3885
_global.channel[ch].voices[lastVoice].sampleFeedback;
3886
_global.channel[ch].voices[newVoice].op[i].envState =
3887
_global.channel[ch].voices[lastVoice].op[i].envState;
3888
_global.channel[ch].voices[newVoice].op[i].envIndex =
3889
_global.channel[ch].voices[lastVoice].op[i].envIndex;
3890
_global.channel[ch].voices[newVoice].op[i].envInct =
3891
_global.channel[ch].voices[lastVoice].op[i].envInct;
3892
_global.channel[ch].voices[newVoice].op[i].envLevel =
3893
_global.channel[ch].voices[lastVoice].op[i].envLevel;
3894
_global.channel[ch].voices[newVoice].op[i].coefVLevel =
3895
_global.channel[ch].voices[lastVoice].op[i].coefVLevel;
3896
_global.channel[ch].voices[lastVoice].isOn = false;
3897
}
3898
else {
3899
_global.channel[ch].voices[newVoice].op[i].index = 0.0;
3900
_global.channel[ch].voices[newVoice].sampleFeedback = 0.0;
3901
_global.channel[ch].voices[newVoice].op[i].envState = ATTACK;
3902
_global.channel[ch].voices[newVoice].op[i].envIndex = 0.0;
3903
setEnvAttack(ch, newVoice, i);
3904
}
3905
}
3906
else {
3907
_global.channel[ch].voices[newVoice].op[i].index = 0.0;
3908
_global.channel[ch].voices[newVoice].sampleFeedback = 0.0;
3909
_global.channel[ch].voices[newVoice].op[i].envState = ATTACK;
3910
_global.channel[ch].voices[newVoice].op[i].envIndex = 0.0;
3911
setEnvAttack(ch, newVoice, i);
3912
if(_preset[ch]->function.mode == MONO &&
3913
_global.channel[ch].isLastNote) {
3914
_global.channel[ch].voices[_global.channel[ch].lastVoiceKeyOff]
3915
.isOn = false;
3916
}
3917
}
3918
3919
//----
3920
//FREQ
3921
//----
3922
//the frequence for each operator is calculated
3923
//and is used later to calculate inct
3924
tempTargetFreq =
3925
(pitch2freq((double)getChannelDetune(ch)
3926
/(double)MAXCHANNELDETUNE)
3927
/LOWERNOTEFREQ)*
3928
(_preset[ch]->frequency[i].isFix?
3929
_preset[ch]->frequency[i].freq:
3930
(_preset[ch]->frequency[i].ratio
3931
*pitch2freq((double)(pitch+_preset[ch]->function.transpose)
3932
+(double)_preset[ch]->detune[i]*COEFDETUNE)));
3933
//----
3934
//INCT
3935
//----
3936
//compute inct
3937
_global.channel[ch].voices[newVoice].op[i].targetInct =
3938
(double)RESOLUTION / ( _global.deiSampleRate / tempTargetFreq );
3939
if(_global.channel[ch].voices[newVoice].hasAttractor &&
3940
!_preset[ch]->frequency[i].isFix)
3941
_global.channel[ch].voices[newVoice].op[i].inct =
3942
_global.channel[ch].lastInc[i];
3943
else _global.channel[ch].voices[newVoice].op[i].inct =
3944
_global.channel[ch].voices[newVoice].op[i].targetInct;
3945
}
3946
//--------------------
3947
//some initializations
3948
//--------------------
3949
_global.channel[ch].voices[newVoice].keyOn = true;
3950
_global.channel[ch].voices[newVoice].isSustained = false;
3951
_global.channel[ch].voices[newVoice].isOn = true;
3952
_global.channel[ch].voices[newVoice].pitch = pitch;
3953
_global.channel[ch].isLastNote = true;
3954
_global.channel[ch].lastVoiceKeyOn.push_back(newVoice);
3955
for(int k = 0; k < NBROP; k++)
3956
_global.channel[ch].lastInc[k] =
3957
_global.channel[ch].voices[newVoice].op[k].inct;
3958
return false;
3959
}
1300
3960
}
1301
else //Note on
1302
{
1303
nO2V=noteOff2Voice();
1304
newVoice=((nO2V==NBRVOICES)?minVolu2Voice():nO2V);
1305
1306
_voices[newVoice].isOn=true;
1307
_voices[newVoice].sampleFeedback=0.0;
1308
_voices[newVoice].pitch=pitch;
1309
1310
/*if(_preset->lfo.sync)*/ _global.lfoIndex=0;//a revoir
1311
_global.lfoDelayIndex=0.0;
1312
_global.delayPassed=false;
1313
1314
for(int i=0; i<NBROP; i++)
1315
{
1316
_voices[newVoice].op[i].amp=outLevel2Amp(_preset->outLevel[i])
1317
*velo2AmpR(velo, _preset->sensitivity.keyVelocity[i])
1318
*note2Amp((double)(pitch+_preset->function.transpose),
1319
_preset->scaling.level[i]);
1320
_voices[newVoice].op[i].index=0.0;
1321
_voices[newVoice].op[i].freq=
1322
(pitch2freq((double)_preset->globalDetune
1323
/(double)MAXGLOBALDETUNE)
1324
/LOWERNOTEFREQ)*
1325
(_preset->frequency[i].isFix?
1326
_preset->frequency[i].freq:
1327
(_preset->frequency[i].ratio
1328
*pitch2freq((double)(pitch+_preset->function.transpose)
1329
+(double)_preset->detune[i]*COEFDETUNE)));
1330
_voices[newVoice].op[i].inct=(double)RESOLUTION
1331
/((double)sampleRate()/_voices[newVoice].op[i].freq);
1332
_voices[newVoice].op[i].envState=ATTACK;
1333
_voices[newVoice].op[i].envIndex=0.0;
1334
_voices[newVoice].op[i].envInct=(_preset->eg[i].ar==0?0:
1335
(double)(RESOLUTION/4)
1336
/(envAR2s(_preset->eg[i].ar)
1337
*(double)sampleRate()));
1338
}
1339
return false;
1340
}
1341
3961
return false;
1342
3962
}
1343
3963
1344
3964
//---------------------------------------------------------
1345
3965
// plusMod
1346
// add two doubles modulo SINRESOLUTION
3966
// add two doubles modulo RESOLUTION
1347
3967
//---------------------------------------------------------
1348
inline double plusMod(double x, double y)
1349
{
3968
inline double plusMod(double x, double y) {
1350
3969
double res;
1351
3970
res=x+y;
1352
3971
if (res>=0) while (res >= (double)RESOLUTION) res-=(double)RESOLUTION;
1359
3978
// write
1360
3979
// synthesize n samples into buffer+offset
1361
3980
//---------------------------------------------------------
3981
void DeicsOnze::process(float** buffer, int offset, int n) {
3982
//Process messages from the gui
3983
while (_gui->fifoSize()) {
3984
MidiPlayEvent ev = _gui->readEvent();
3985
if (ev.type() == ME_SYSEX) {
3986
sysex(ev.len(), ev.data(), true);
3987
sendEvent(ev);
3988
}
3989
else if (ev.type() == ME_CONTROLLER) {
3990
setController(ev.channel(), ev.dataA(), ev.dataB(), true);
3991
sendEvent(ev);
3992
}
3993
}
3994
float* leftOutput = buffer[0] + offset;
3995
float* rightOutput = buffer[1] + offset;
1362
3996
1363
void DeicsOnze::process(float** buffer, int offset, int n)
1364
{
1365
float* p = buffer[0] + offset;
1366
float sample[NBRVOICES];
1367
float resSample;
3997
float sample[MAXNBRVOICES];
3998
float tempLeftOutput;
3999
float tempRightOutput;
4000
float tempChannelOutput;
4001
float tempChannelLeftOutput;
4002
float tempChannelRightOutput;
4003
float tempIncChannel; //for optimization
1368
4004
float sampleOp[NBROP];
4005
for(int i = 0; i < NBROP; i++) sampleOp[i] = 0.0;
1369
4006
float ampOp[NBROP];
1370
for(int i = 0; i < n; i++)
1371
{
1372
resSample = 0;
1373
//stepProcess return the result to resSample
1374
1375
//Global
1376
lfoUpdate(_preset, &_global, waveTable[W2]);
1377
1378
//per voice
1379
for(int j=0; j<NBRVOICES; j++)
1380
{
1381
if (_voices[j].isOn)
1382
{
1383
for(int k=0; k<NBROP; k++)
1384
{
1385
_voices[j].op[k].index=
1386
plusMod(_voices[j].op[k].index,
1387
_global.lfoCoefInct*_voices[j].op[k].inct
1388
*_global.pitchBendCoef);
1389
1390
ampOp[k]=_voices[j].op[k].amp*COEFLEVEL
1391
*(_preset->sensitivity.ampOn[k]?_global.lfoAmp:1.0)
1392
*env2AmpR(sampleRate(), waveTable[W2],
1393
_preset->eg[k], &_voices[j].op[k]);
1394
}
1395
1396
switch(_preset->algorithm)
1397
{
1398
case FIRST :
1399
sampleOp[3]=ampOp[3]
1400
*waveTable[_preset->oscWave[3]]
1401
[(int)plusMod(_voices[j].op[3].index,
1402
(float)RESOLUTION
1403
*_voices[j].sampleFeedback)];
1404
sampleOp[2]=ampOp[2]
1405
*waveTable[_preset->oscWave[2]]
1406
[(int)plusMod(_voices[j].op[2].index,
1407
(float)RESOLUTION*sampleOp[3])];
1408
sampleOp[1]=ampOp[1]
1409
*waveTable[_preset->oscWave[1]]
1410
[(int)plusMod(_voices[j].op[1].index,
1411
(float)RESOLUTION*sampleOp[2])];
1412
sampleOp[0]=ampOp[0]
1413
*waveTable[_preset->oscWave[0]]
1414
[(int)plusMod(_voices[j].op[0].index,
1415
(float)RESOLUTION*sampleOp[1])];
1416
1417
sample[j]=sampleOp[0];///COEFLEVEL;
1418
1419
_voices[j].isOn=(_voices[j].op[0].envState!=OFF);
1420
break;
1421
case SECOND :
1422
sampleOp[3]=ampOp[3]
1423
*waveTable[_preset->oscWave[3]]
1424
[(int)plusMod(_voices[j].op[3].index,
1425
(float)RESOLUTION
1426
*_voices[j].sampleFeedback)];
1427
sampleOp[2]=ampOp[2]
1428
*waveTable[_preset->oscWave[2]]
1429
[(int)_voices[j].op[2].index];
1430
sampleOp[1]=ampOp[1]
1431
*waveTable[_preset->oscWave[1]]
1432
[(int)plusMod(_voices[j].op[1].index,
1433
(float)RESOLUTION
1434
*(sampleOp[2]+sampleOp[3])/2.0)];
1435
sampleOp[0]=ampOp[0]
1436
*waveTable[_preset->oscWave[0]]
1437
[(int)plusMod(_voices[j].op[0].index,
1438
(float)RESOLUTION
1439
*sampleOp[1])];
1440
1441
sample[j]=sampleOp[0];///COEFLEVEL;
1442
1443
_voices[j].isOn=(_voices[j].op[0].envState!=OFF);
1444
break;
1445
case THIRD :
1446
sampleOp[3]=ampOp[3]
1447
*waveTable[_preset->oscWave[3]]
1448
[(int)plusMod(_voices[j].op[3].index,
1449
(float)RESOLUTION
1450
*_voices[j].sampleFeedback)];
1451
sampleOp[2]=ampOp[2]
1452
*waveTable[_preset->oscWave[2]]
1453
[(int)_voices[j].op[2].index];
1454
sampleOp[1]=ampOp[1]
1455
*waveTable[_preset->oscWave[1]]
1456
[(int)plusMod(_voices[j].op[1].index,
1457
(float)RESOLUTION*sampleOp[2])];
1458
sampleOp[0]=ampOp[0]
1459
*waveTable[_preset->oscWave[0]]
1460
[(int)plusMod(_voices[j].op[0].index,
1461
(float)RESOLUTION
1462
*(sampleOp[3]+sampleOp[1])/2.0)];
1463
1464
sample[j]=sampleOp[0];///COEFLEVEL;
1465
1466
_voices[j].isOn=(_voices[j].op[0].envState!=OFF);
1467
break;
1468
case FOURTH :
1469
sampleOp[3]=ampOp[3]
1470
*waveTable[_preset->oscWave[3]]
1471
[(int)plusMod(_voices[j].op[3].index,
1472
(float)RESOLUTION
1473
*_voices[j].sampleFeedback)];
1474
sampleOp[2]=ampOp[2]
1475
*waveTable[_preset->oscWave[2]]
1476
[(int)plusMod(_voices[j].op[2].index,
1477
(float)RESOLUTION
1478
*sampleOp[3])];
1479
sampleOp[1]=ampOp[1]
1480
*waveTable[_preset->oscWave[1]]
1481
[(int)_voices[j].op[1].index];
1482
sampleOp[0]=ampOp[0]
1483
*waveTable[_preset->oscWave[0]]
1484
[(int)plusMod(_voices[j].op[0].index,
1485
(float)RESOLUTION
1486
*(sampleOp[1]+sampleOp[2])/2.0)];
1487
1488
sample[j]=sampleOp[0];///COEFLEVEL;
1489
1490
_voices[j].isOn=(_voices[j].op[0].envState!=OFF);
1491
break;
1492
case FIFTH :
1493
sampleOp[3]=ampOp[3]
1494
*waveTable[_preset->oscWave[3]]
1495
[(int)plusMod(_voices[j].op[3].index,
1496
(float)RESOLUTION
1497
*_voices[j].sampleFeedback)];
1498
sampleOp[2]=ampOp[2]
1499
*waveTable[_preset->oscWave[2]]
1500
[(int)plusMod(_voices[j].op[2].index,
1501
(float)RESOLUTION*sampleOp[3])];
1502
sampleOp[1]=ampOp[1]
1503
*waveTable[_preset->oscWave[1]]
1504
[(int)_voices[j].op[1].index];
1505
sampleOp[0]=ampOp[0]
1506
*waveTable[_preset->oscWave[0]]
1507
[(int)plusMod(_voices[j].op[0].index,
1508
(float)RESOLUTION*sampleOp[1])];
1509
1510
sample[j]=(sampleOp[0]+sampleOp[2])/2.0;///COEFLEVEL;
1511
1512
_voices[j].isOn=(_voices[j].op[0].envState!=OFF
1513
||_voices[j].op[2].envState!=OFF);
1514
break;
1515
case SIXTH :
1516
sampleOp[3]=ampOp[3]
1517
*waveTable[_preset->oscWave[3]]
1518
[(int)plusMod(_voices[j].op[3].index,
1519
(float)RESOLUTION
1520
*_voices[j].sampleFeedback)];
1521
sampleOp[2]=ampOp[2]
1522
*waveTable[_preset->oscWave[2]]
1523
[(int)plusMod(_voices[j].op[2].index,
1524
(float)RESOLUTION*sampleOp[3])];
1525
sampleOp[1]=ampOp[1]
1526
*waveTable[_preset->oscWave[1]]
1527
[(int)plusMod(_voices[j].op[1].index,
1528
(float)RESOLUTION*sampleOp[3])];
1529
sampleOp[0]=ampOp[0]
1530
*waveTable[_preset->oscWave[0]]
1531
[(int)plusMod(_voices[j].op[0].index,
1532
(float)RESOLUTION*sampleOp[3])];
1533
1534
sample[j]=(sampleOp[0]+sampleOp[1]+sampleOp[2])/3.0;
1535
1536
_voices[j].isOn=(_voices[j].op[0].envState!=OFF);
1537
break;
1538
case SEVENTH :
1539
sampleOp[3]=ampOp[3]
1540
*waveTable[_preset->oscWave[3]]
1541
[(int)plusMod(_voices[j].op[3].index,
1542
(float)RESOLUTION
1543
*_voices[j].sampleFeedback)];
1544
sampleOp[2]=ampOp[2]
1545
*waveTable[_preset->oscWave[2]]
1546
[(int)plusMod(_voices[j].op[2].index,
1547
(float)RESOLUTION*sampleOp[3])];
1548
sampleOp[1]=ampOp[1]
1549
*waveTable[_preset->oscWave[1]]
1550
[(int)_voices[j].op[1].index];
1551
sampleOp[0]=ampOp[0]*waveTable[_preset->oscWave[3]]
1552
[(int)_voices[j].op[0].index];
1553
1554
sample[j]=(sampleOp[0]+sampleOp[1]+sampleOp[2])/3.0;
1555
1556
_voices[j].isOn=(_voices[j].op[0].envState!=OFF);
1557
break;
1558
case EIGHTH :
1559
sampleOp[3]=ampOp[3]
1560
*waveTable[_preset->oscWave[3]]
1561
[(int)plusMod(_voices[j].op[3].index,
1562
(float)RESOLUTION
1563
*_voices[j].sampleFeedback)];
1564
sampleOp[2]=ampOp[2]
1565
*waveTable[_preset->oscWave[3]]
1566
[(int)_voices[j].op[2].index];
1567
sampleOp[1]=ampOp[1]
1568
*waveTable[_preset->oscWave[3]]
1569
[(int)_voices[j].op[1].index];
1570
sampleOp[0]=ampOp[0]
1571
*waveTable[_preset->oscWave[3]]
1572
[(int)_voices[j].op[0].index];
1573
1574
sample[j]=
1575
(sampleOp[0]+sampleOp[1]+sampleOp[2]+sampleOp[3])
1576
/4.0;
1577
1578
_voices[j].isOn=(_voices[j].op[0].envState!=OFF
1579
|| _voices[j].op[1].envState!=OFF
1580
|| _voices[j].op[2].envState!=OFF
1581
|| _voices[j].op[3].envState!=OFF);
1582
break;
1583
default : printf("Error : No algorithm");
1584
break;
1585
}
1586
1587
_voices[j].volume=
1588
ampOp[0]+ampOp[1]+ampOp[2]+ampOp[3];
1589
1590
_voices[j].sampleFeedback=sampleOp[3]*_global.feedbackAmp;
1591
1592
resSample += sample[j];
4007
for(int i = 0; i < n; i++) {
4008
if(_global.qualityCounter == 0) {
4009
tempLeftOutput = 0.0;
4010
tempRightOutput = 0.0;
4011
_global.lastInputLeftChorusSample = 0.0;
4012
_global.lastInputRightChorusSample = 0.0;
4013
_global.lastInputLeftReverbSample = 0.0;
4014
_global.lastInputRightReverbSample = 0.0;
4015
_global.lastInputLeftDelaySample = 0.0;
4016
_global.lastInputRightDelaySample = 0.0;
4017
//per channel
4018
for(int c = 0; c < NBRCHANNELS; c++) {
4019
tempChannelOutput = 0.0;
4020
if(_global.channel[c].isEnable) {
4021
//lfo, trick : we use the first quater of the wave W2
4022
lfoUpdate(_preset[c], &_global.channel[c], waveTable[W2]);
4023
4024
//optimization
4025
tempIncChannel =
4026
_global.channel[c].lfoCoefInct * _global.channel[c].pitchBendCoef;
4027
4028
//per voice
4029
for(int j=0; j<_global.channel[c].nbrVoices; j++) {
4030
if (_global.channel[c].voices[j].isOn) {
4031
//portamento
4032
portamentoUpdate(&_global.channel[c],
4033
&_global.channel[c].voices[j]);
4034
//pitch envelope
4035
pitchEnvelopeUpdate(&_global.channel[c].voices[j],
4036
&_preset[c]->pitchEg, _global.deiSampleRate);
4037
//per op
4038
for(int k=0; k<NBROP; k++) {
4039
//compute the next index on the wavetable,
4040
//without taking account of the feedback and FM modulation
4041
_global.channel[c].voices[j].op[k].index=
4042
plusMod(_global.channel[c].voices[j].op[k].index,
4043
_global.channel[c].voices[j].op[k].inct
4044
* tempIncChannel
4045
* _global.channel[c].voices[j].pitchEnvCoefInct);
4046
4047
ampOp[k]=_global.channel[c].voices[j].op[k].amp*COEFLEVEL
4048
*(_preset[c]->sensitivity.ampOn[k]?
4049
_global.channel[c].lfoAmp:1.0)
4050
*env2AmpR(_global.deiSampleRate, waveTable[W2],
4051
_preset[c]->eg[k],
4052
&_global.channel[c].voices[j].op[k]);
4053
}
4054
switch(_preset[c]->algorithm) {
4055
case FIRST :
4056
sampleOp[3]=ampOp[3]
4057
*waveTable[_preset[c]->oscWave[3]]
4058
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4059
(float)RESOLUTION
4060
*_global.channel[c].voices[j].sampleFeedback)];
4061
sampleOp[2]=ampOp[2]
4062
*waveTable[_preset[c]->oscWave[2]]
4063
[(int)plusMod(_global.channel[c].voices[j].op[2].index,
4064
(float)RESOLUTION*sampleOp[3])];
4065
sampleOp[1]=ampOp[1]
4066
*waveTable[_preset[c]->oscWave[1]]
4067
[(int)plusMod(_global.channel[c].voices[j].op[1].index,
4068
(float)RESOLUTION*sampleOp[2])];
4069
sampleOp[0]=ampOp[0]
4070
*waveTable[_preset[c]->oscWave[0]]
4071
[(int)plusMod(_global.channel[c].voices[j].op[0].index,
4072
(float)RESOLUTION*sampleOp[1])];
4073
4074
sample[j]=sampleOp[0];///COEFLEVEL;
4075
4076
_global.channel[c].voices[j].isOn =
4077
(_global.channel[c].voices[j].op[0].envState!=OFF);
4078
break;
4079
case SECOND :
4080
sampleOp[3]=ampOp[3]
4081
*waveTable[_preset[c]->oscWave[3]]
4082
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4083
(float)RESOLUTION
4084
*_global.channel[c].voices[j].sampleFeedback)];
4085
sampleOp[2]=ampOp[2]
4086
*waveTable[_preset[c]->oscWave[2]]
4087
[(int)_global.channel[c].voices[j].op[2].index];
4088
sampleOp[1]=ampOp[1]
4089
*waveTable[_preset[c]->oscWave[1]]
4090
[(int)plusMod(_global.channel[c].voices[j].op[1].index,
4091
(float)RESOLUTION
4092
*(sampleOp[2]+sampleOp[3])/2.0)];
4093
sampleOp[0]=ampOp[0]
4094
*waveTable[_preset[c]->oscWave[0]]
4095
[(int)plusMod(_global.channel[c].voices[j].op[0].index,
4096
(float)RESOLUTION
4097
*sampleOp[1])];
4098
4099
sample[j]=sampleOp[0];///COEFLEVEL;
4100
4101
_global.channel[c].voices[j].isOn =
4102
(_global.channel[c].voices[j].op[0].envState!=OFF);
4103
break;
4104
case THIRD :
4105
sampleOp[3]=ampOp[3]
4106
*waveTable[_preset[c]->oscWave[3]]
4107
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4108
(float)RESOLUTION
4109
*_global.channel[c].voices[j].sampleFeedback)];
4110
sampleOp[2]=ampOp[2]
4111
*waveTable[_preset[c]->oscWave[2]]
4112
[(int)_global.channel[c].voices[j].op[2].index];
4113
sampleOp[1]=ampOp[1]
4114
*waveTable[_preset[c]->oscWave[1]]
4115
[(int)plusMod(_global.channel[c].voices[j].op[1].index,
4116
(float)RESOLUTION*sampleOp[2])];
4117
sampleOp[0]=ampOp[0]
4118
*waveTable[_preset[c]->oscWave[0]]
4119
[(int)plusMod(_global.channel[c].voices[j].op[0].index,
4120
(float)RESOLUTION
4121
*(sampleOp[3]+sampleOp[1])/2.0)];
4122
4123
sample[j]=sampleOp[0];///COEFLEVEL;
4124
4125
_global.channel[c].voices[j].isOn =
4126
(_global.channel[c].voices[j].op[0].envState!=OFF);
4127
break;
4128
case FOURTH :
4129
sampleOp[3]=ampOp[3]
4130
*waveTable[_preset[c]->oscWave[3]]
4131
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4132
(float)RESOLUTION
4133
*_global.channel[c].voices[j].sampleFeedback)];
4134
sampleOp[2]=ampOp[2]
4135
*waveTable[_preset[c]->oscWave[2]]
4136
[(int)plusMod(_global.channel[c].voices[j].op[2].index,
4137
(float)RESOLUTION
4138
*sampleOp[3])];
4139
sampleOp[1]=ampOp[1]
4140
*waveTable[_preset[c]->oscWave[1]]
4141
[(int)_global.channel[c].voices[j].op[1].index];
4142
sampleOp[0]=ampOp[0]
4143
*waveTable[_preset[c]->oscWave[0]]
4144
[(int)plusMod(_global.channel[c].voices[j].op[0].index,
4145
(float)RESOLUTION
4146
*(sampleOp[1]+sampleOp[2])/2.0)];
4147
4148
sample[j]=sampleOp[0];///COEFLEVEL;
4149
4150
_global.channel[c].voices[j].isOn =
4151
(_global.channel[c].voices[j].op[0].envState!=OFF);
4152
break;
4153
case FIFTH :
4154
sampleOp[3]=ampOp[3]
4155
*waveTable[_preset[c]->oscWave[3]]
4156
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4157
(float)RESOLUTION
4158
*_global.channel[c].voices[j].sampleFeedback)];
4159
sampleOp[2]=ampOp[2]
4160
*waveTable[_preset[c]->oscWave[2]]
4161
[(int)plusMod(_global.channel[c].voices[j].op[2].index,
4162
(float)RESOLUTION*sampleOp[3])];
4163
sampleOp[1]=ampOp[1]
4164
*waveTable[_preset[c]->oscWave[1]]
4165
[(int)_global.channel[c].voices[j].op[1].index];
4166
sampleOp[0]=ampOp[0]
4167
*waveTable[_preset[c]->oscWave[0]]
4168
[(int)plusMod(_global.channel[c].voices[j].op[0].index,
4169
(float)RESOLUTION*sampleOp[1])];
4170
4171
sample[j]=(sampleOp[0]+sampleOp[2])/2.0;///COEFLEVEL;
4172
4173
_global.channel[c].voices[j].isOn =
4174
(_global.channel[c].voices[j].op[0].envState!=OFF
4175
||_global.channel[c].voices[j].op[2].envState!=OFF);
4176
break;
4177
case SIXTH :
4178
sampleOp[3]=ampOp[3]
4179
*waveTable[_preset[c]->oscWave[3]]
4180
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4181
(float)RESOLUTION
4182
*_global.channel[c].voices[j].sampleFeedback)];
4183
sampleOp[2]=ampOp[2]
4184
*waveTable[_preset[c]->oscWave[2]]
4185
[(int)plusMod(_global.channel[c].voices[j].op[2].index,
4186
(float)RESOLUTION*sampleOp[3])];
4187
sampleOp[1]=ampOp[1]
4188
*waveTable[_preset[c]->oscWave[1]]
4189
[(int)plusMod(_global.channel[c].voices[j].op[1].index,
4190
(float)RESOLUTION*sampleOp[3])];
4191
sampleOp[0]=ampOp[0]
4192
*waveTable[_preset[c]->oscWave[0]]
4193
[(int)plusMod(_global.channel[c].voices[j].op[0].index,
4194
(float)RESOLUTION*sampleOp[3])];
4195
4196
sample[j]=(sampleOp[0]+sampleOp[1]+sampleOp[2])/3.0;
4197
4198
_global.channel[c].voices[j].isOn =
4199
(_global.channel[c].voices[j].op[0].envState!=OFF);
4200
break;
4201
case SEVENTH :
4202
sampleOp[3]=ampOp[3]
4203
*waveTable[_preset[c]->oscWave[3]]
4204
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4205
(float)RESOLUTION
4206
*_global.channel[c].voices[j].sampleFeedback)];
4207
sampleOp[2]=ampOp[2]
4208
*waveTable[_preset[c]->oscWave[2]]
4209
[(int)plusMod(_global.channel[c].voices[j].op[2].index,
4210
(float)RESOLUTION*sampleOp[3])];
4211
sampleOp[1]=ampOp[1]
4212
*waveTable[_preset[c]->oscWave[1]]
4213
[(int)_global.channel[c].voices[j].op[1].index];
4214
sampleOp[0]=ampOp[0]*waveTable[_preset[c]->oscWave[0]]
4215
[(int)_global.channel[c].voices[j].op[0].index];
4216
4217
sample[j]=(sampleOp[0]+sampleOp[1]+sampleOp[2])/3.0;
4218
4219
_global.channel[c].voices[j].isOn =
4220
(_global.channel[c].voices[j].op[0].envState!=OFF);
4221
break;
4222
case EIGHTH :
4223
sampleOp[3]=ampOp[3]
4224
*waveTable[_preset[c]->oscWave[3]]
4225
[(int)plusMod(_global.channel[c].voices[j].op[3].index,
4226
(float)RESOLUTION
4227
*_global.channel[c].voices[j].sampleFeedback)];
4228
sampleOp[2]=ampOp[2]
4229
*waveTable[_preset[c]->oscWave[2]]
4230
[(int)_global.channel[c].voices[j].op[2].index];
4231
sampleOp[1]=ampOp[1]
4232
*waveTable[_preset[c]->oscWave[1]]
4233
[(int)_global.channel[c].voices[j].op[1].index];
4234
sampleOp[0]=ampOp[0]
4235
*waveTable[_preset[c]->oscWave[0]]
4236
[(int)_global.channel[c].voices[j].op[0].index];
4237
4238
sample[j]=
4239
(sampleOp[0]+sampleOp[1]+sampleOp[2]+sampleOp[3])
4240
/4.0;
4241
4242
_global.channel[c].voices[j].isOn =
4243
(_global.channel[c].voices[j].op[0].envState!=OFF
4244
|| _global.channel[c].voices[j].op[1].envState!=OFF
4245
|| _global.channel[c].voices[j].op[2].envState!=OFF
4246
|| _global.channel[c].voices[j].op[3].envState!=OFF);
4247
break;
4248
default : printf("Error : No algorithm");
4249
break;
4250
}
4251
4252
_global.channel[c].voices[j].volume=
4253
ampOp[0]+ampOp[1]+ampOp[2]+ampOp[3];
4254
4255
_global.channel[c].voices[j].sampleFeedback =
4256
sampleOp[3]*_global.channel[c].feedbackAmp;
4257
4258
tempChannelOutput += sample[j];
1593
4259
}
4260
}
4261
//printf("left out = %f, temp out = %f, left amp = %f\n",
4262
//tempLeftOutput, tempChannelOutput, _global.channel[c].ampLeft);
4263
4264
tempChannelLeftOutput = tempChannelOutput*_global.channel[c].ampLeft;
4265
tempChannelRightOutput=tempChannelOutput*_global.channel[c].ampRight;
4266
4267
if(_global.isChorusActivated) {
4268
_global.lastInputLeftChorusSample += tempChannelLeftOutput *
4269
_global.channel[c].chorusAmount;
4270
_global.lastInputRightChorusSample += tempChannelRightOutput *
4271
_global.channel[c].chorusAmount;
4272
}
4273
if(_global.isReverbActivated) {
4274
_global.lastInputLeftReverbSample += tempChannelLeftOutput *
4275
_global.channel[c].reverbAmount;
4276
_global.lastInputRightReverbSample += tempChannelRightOutput *
4277
_global.channel[c].reverbAmount;
4278
}
4279
if(_global.isDelayActivated) {
4280
_global.lastInputLeftDelaySample += tempChannelLeftOutput *
4281
_global.channel[c].delayAmount;
4282
_global.lastInputRightDelaySample += tempChannelRightOutput *
4283
_global.channel[c].delayAmount;
4284
}
4285
tempLeftOutput += tempChannelLeftOutput;
4286
tempRightOutput += tempChannelRightOutput;
1594
4287
}
1595
p[i] += resSample*_global.amp;
1596
}
4288
}
4289
_global.lastLeftSample = tempLeftOutput * _global.masterVolume;
4290
_global.lastRightSample = tempRightOutput * _global.masterVolume;
4291
}
4292
leftOutput[i] += _global.lastLeftSample;
4293
rightOutput[i] += _global.lastRightSample;
4294
4295
if(_global.isChorusActivated) {
4296
tempInputChorus[0][i] = _global.lastInputLeftChorusSample;
4297
tempInputChorus[1][i] = _global.lastInputRightChorusSample;
4298
}
4299
if(_global.isReverbActivated) {
4300
tempInputReverb[0][i] = _global.lastInputLeftReverbSample;
4301
tempInputReverb[1][i] = _global.lastInputRightReverbSample;
4302
}
4303
if(_global.isDelayActivated) {
4304
tempInputDelay[0][i] = _global.lastInputLeftDelaySample;
4305
tempInputDelay[1][i] = _global.lastInputRightDelaySample;
4306
}
4307
4308
_global.qualityCounter++;
4309
_global.qualityCounter %= _global.qualityCounterTop;
4310
}
4311
//apply Filter
4312
if(_global.filter) _dryFilter->process(leftOutput, rightOutput, n);
4313
//Chorus
4314
if(_pluginIChorus && _global.isChorusActivated) {
4315
//apply Filter
4316
if(_global.filter) _chorusFilter->process(tempOutputChorus[0],
4317
tempOutputChorus[1], n);
4318
//apply Chorus
4319
_pluginIChorus->apply(n, 2, tempInputChorus, tempOutputChorus);
4320
for(int i = 0; i < n; i++) {
4321
leftOutput[i] +=
4322
tempOutputChorus[0][i] * _global.chorusReturn * _global.masterVolume;
4323
rightOutput[i] +=
4324
tempOutputChorus[1][i] * _global.chorusReturn * _global.masterVolume;
4325
}
4326
}
4327
//Reverb
4328
if(_pluginIReverb && _global.isReverbActivated) {
4329
//apply Filter
4330
if(_global.filter) _reverbFilter->process(tempOutputReverb[0],
4331
tempOutputReverb[1], n);
4332
//apply Reverb
4333
_pluginIReverb->apply(n, 2, tempInputReverb, tempOutputReverb);
4334
for(int i = 0; i < n; i++) {
4335
leftOutput[i] +=
4336
tempOutputReverb[0][i] * _global.reverbReturn * _global.masterVolume;
4337
rightOutput[i] +=
4338
tempOutputReverb[1][i] * _global.reverbReturn * _global.masterVolume;
4339
}
4340
}
4341
//Delay
4342
if(_pluginIDelay && _global.isDelayActivated) {
4343
//apply Filter
4344
if(_global.filter) _delayFilter->process(tempOutputDelay[0],
4345
tempOutputDelay[1], n);
4346
//apply Delay
4347
_pluginIDelay->apply(n, 2, tempInputDelay, tempOutputDelay);
4348
for(int i = 0; i < n; i++) {
4349
leftOutput[i] +=
4350
tempOutputDelay[0][i] * _global.delayReturn * _global.masterVolume;
4351
rightOutput[i] +=
4352
tempOutputDelay[1][i] * _global.delayReturn * _global.masterVolume;
4353
}
4354
}
1597
4355
}
1598
4356
1599
4357
1603
4361
1604
4362
class QWidget;
1605
4363
1606
static Mess* instantiate(int sr, QWidget*, const char*)
4364
///static Mess* instantiate(int sr, const char*)
4365
static Mess* instantiate(int sr, QWidget*, QString* /* projectPathPtr */, const char*)
1607
4366
{
1608
4367
DeicsOnze* deicsonze = new DeicsOnze();
1609
4368
deicsonze->setSampleRate(sr);
1613
4372
extern "C" {
1614
4373
static MESS descriptor = {
1615
4374
"DeicsOnze",
1616
"DeicsOnze FM DX11 emulator",
1617
"0.2.2", // version string
4375
"DeicsOnze FM DX11/TX81Z emulator",
4376
"0.5.5", // version string
1618
4377
MESS_MAJOR_VERSION, MESS_MINOR_VERSION,
1619
4378
instantiate
1620
4379
};
4380
// We must compile with -fvisibility=hidden to avoid namespace
4381
// conflicts with global variables.
4382
// Only visible symbol is "mess_descriptor".
4383
// (TODO: all plugins should be compiled this way)
1621
4384
4385
__attribute__ ((visibility("default")))
1622
4386
const MESS* mess_descriptor() { return &descriptor; }
1623
4387
}
1624
4388
Loggerhead is a web-based interface for Breezy
Version: 2.0.1