← Back to branch summary

~ubuntu-branches/ubuntu/raring/muse/raring-proposed

« back to all changes in this revision

Viewing changes to synti/deicsonze/deicsonzeplugin.cpp

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2012-11-22 01:16:59 UTC
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: package-import@ubuntu.com-20121122011659-a2fwbf33ceqe1s0t
Tags: upstream-2.1~rc1
Import upstream version 2.1~rc1

Show diffs side-by-side

added added

removed removed

Lines of Context:
synti/deicsonze/deicsonzeplugin.cpp
27
27
// 02111-1301, USA or point your web browser to http://www.gnu.org.
28
28
//===========================================================================
29
29
 
 
30
#include "deicsonze.h"
30
31
#include "deicsonzeplugin.h"
31
32
#include "plugin.h"
32
33
///#include "plugingui.h"
46
47
void DeicsOnze::initPluginReverb(MusECore::Plugin* pluginReverb) {
47
48
  //init plugin
48
49
  if(_pluginIReverb) delete(_pluginIReverb);
49
 
  ///_pluginIReverb = new MusECore::PluginI(NULL);
50
50
  _pluginIReverb = new MusECore::PluginI();
51
51
 
52
52
  _pluginIReverb->initPluginInstance(pluginReverb, 2);
53
53
 
54
54
  //for(int i = 0; i < pluginReverb->parameter(); i++) {
55
 
  for(int i = 0; i < (int)pluginReverb->controlInPorts(); i++) {
56
 
    
 
55
  //for(int i = 0; i < (int)pluginReverb->controlInPorts(); i++) {
 
56
  for(int i = 0; i < (int)_pluginIReverb->parameters(); i++) {
 
57
 
 
58
 
 
59
// From DSSI host. Maybe use this to add automation controllers. Problems with this method.
 
60
//     // Support a special block for dssi synth ladspa controllers.
 
61
//     // Put the ID at a special block after plugins (far after).
 
62
//     //int id = MusECore::genACnum(MAX_PLUGINS, cip);
 
63
//     int id = MusECore::genACnum(MAX_PLUGINS, i);
 
64
 
57
65
// FIXME FIXME Tim
58
66
/*    Ctrl* c = new Ctrl();
59
67
    c->setCurVal((float)pluginReverb->defaultValue(i));
61
69
*/
62
70
    
63
71
    //setReverbParam(i, pluginReverb->defaultValue(i));
 
72
    //setReverbParam(i, _pluginIReverb->defaultValue(i));
 
73
    _pluginIReverb->putParam(i, _pluginIReverb->defaultValue(i));
64
74
  }
65
75
 
66
76
  //send build gui to the gui
72
82
 
73
83
void DeicsOnze::initPluginChorus(MusECore::Plugin* pluginChorus) {
74
84
  if(_pluginIChorus) delete(_pluginIChorus);
75
 
  ///_pluginIChorus = new MusECore::PluginI(NULL);
76
85
  _pluginIChorus = new MusECore::PluginI();
77
86
 
78
87
  _pluginIChorus->initPluginInstance(pluginChorus, 2);
79
88
 
80
89
  //for(int i = 0; i < pluginChorus->parameter(); i++) {
81
 
  for(int i = 0; i < (int)pluginChorus->controlInPorts(); i++) {
82
 
 
 
90
  for(int i = 0; i < (int)_pluginIChorus->parameters(); i++) {
 
91
  
83
92
// FIXME FIXME Tim
84
93
/*    
85
94
    Ctrl* c = new Ctrl();
88
97
*/    
89
98
    
90
99
    //setChorusParam(i, pluginChorus->defaultValue(i));
91
 
}
 
100
    //setChorusParam(i, _pluginIChorus->defaultValue(i));
 
101
    _pluginIChorus->putParam(i, _pluginIChorus->defaultValue(i));
 
102
  }
92
103
 
93
104
  //send build gui to the gui
94
105
  char data;
99
110
 
100
111
void DeicsOnze::initPluginDelay(MusECore::Plugin* pluginDelay) {
101
112
  if(_pluginIDelay) delete(_pluginIDelay);
102
 
  ///_pluginIDelay = new MusECore::PluginI(NULL);
103
113
  _pluginIDelay = new MusECore::PluginI();
104
114
 
105
115
  _pluginIDelay->initPluginInstance(pluginDelay, 2);
106
116
 
107
117
  //for(int i = 0; i < pluginDelay->parameter(); i++) { 
108
 
  for(int i = 0; i < (int)pluginDelay->controlInPorts(); i++) { 
109
 
 
 
118
  for(int i = 0; i < (int)_pluginIDelay->parameters(); i++) {
 
119
   
110
120
// FIXME FIXME Tim
111
121
/*    
112
122
    Ctrl* c = new Ctrl();
115
125
*/    
116
126
 
117
127
    //setChorusParam(i, pluginDelay->defaultValue(i));
 
128
    setDelayParam(i, _pluginIDelay->defaultValue(i));
118
129
  }
119
 
  setDelayDryWet(1);
 
130
 
 
131
  //setDelayDryWet(1);
 
132
  _pluginIDelay->putParam(5, 1.0);
120
133
  
121
134
  float f;
122
135
  char dataDelayBPM[sizeof(float)+1];
159
172
                                 (const unsigned char*)dataDelayLFODepth,
160
173
                                 sizeof(float)+1);
161
174
  _gui->writeEvent(evSysexDelayLFODepth); 
 
175
  char dataDelayWetDryMix[sizeof(float)+1];
 
176
  dataDelayWetDryMix[0] = SYSEX_DELAYWETDRYMIX;
 
177
  f = getDelayDryWet();
 
178
  memcpy(&dataDelayWetDryMix, &f, sizeof(float)+1);
 
179
  MusECore::MidiPlayEvent evSysexDelayWetDryMix(0, 0,MusECore::ME_SYSEX,
 
180
                                 (const unsigned char*)dataDelayWetDryMix,
 
181
                                 sizeof(float)+1);
 
182
  _gui->writeEvent(evSysexDelayWetDryMix);
162
183
}
163
184
 
164
 
void DeicsOnze::setReverbParam(int index, double val) {
 
185
void DeicsOnze::setReverbParam(int index, float val) {
165
186
  ///if(_pluginIReverb) _pluginIReverb->controller(index)->setCurVal((float)val);
166
187
  if(_pluginIReverb) _pluginIReverb->setParam(index, val);
167
188
  else printf("Warning : no DeicsOnze reverb loaded\n");
168
189
}
169
 
void DeicsOnze::setChorusParam(int index, double val) {
 
190
void DeicsOnze::setChorusParam(int index, float val) {
170
191
  ///if(_pluginIChorus) _pluginIChorus->controller(index)->setCurVal((float)val);
171
192
  if(_pluginIChorus) _pluginIChorus->setParam(index, val);
172
193
  else printf("Warning : no DeicsOnze chorus loaded\n");
173
194
}
 
195
void DeicsOnze::setDelayParam(int index, float val) {
 
196
  ///if(_pluginIDelay) _pluginIDelay->controller(index)->setCurVal((float)val);
 
197
  if(_pluginIDelay) _pluginIDelay->setParam(index, val);
 
198
  else printf("Warning : no DeicsOnze delay loaded\n");
 
199
}
174
200
 
175
 
double DeicsOnze::getReverbParam(int index) const {
 
201
float DeicsOnze::getReverbParam(int index) const {
176
202
  ///if(_pluginIReverb) return _pluginIReverb->controller(index)->curVal().f; 
177
203
  if(_pluginIReverb) return _pluginIReverb->param(index); 
178
204
  else {
181
207
  }
182
208
}
183
209
 
184
 
double DeicsOnze::getChorusParam(int index) const {
 
210
float DeicsOnze::getChorusParam(int index) const {
185
211
  ///if(_pluginIChorus) return _pluginIChorus->controller(index)->curVal().f;
186
212
  if(_pluginIChorus) return _pluginIChorus->param(index);
187
213
  else {
190
216
  }    
191
217
}
192
218
 
 
219
float DeicsOnze::getDelayParam(int index) const {
 
220
  ///if(_pluginIDelay) return _pluginIDelay->controller(index)->curVal().f;
 
221
  if(_pluginIDelay) return _pluginIDelay->param(index);
 
222
  else {
 
223
    return 0.0;
 
224
    printf("Warning : no DeicsOnze delay loaded\n");
 
225
  }
 
226
}
 
227
 
193
228
void DeicsOnzeGui::addPluginCheckBox(int index, QString text, bool toggled,
194
229
                                     QWidget* parent, QGridLayout* grid,
195
230
                                     bool isReverb) {
233
268
  QLabel* l = new QLabel(text, parent);
234
269
  grid->addWidget(l, index, 0);
235
270
  FloatEntry* f = new FloatEntry(parent);
 
271
  f->setId(index);
 
272
  f->setLog(isLog);
 
273
  f->setLogRange(min, max);
236
274
  f->setValue(val);
237
 
  f->setMinValue(min);
238
 
  f->setMaxValue(max);
239
275
  f->setMaximumWidth(72);
240
276
  grid->addWidget(f, index, 1);
241
277
  Slider* s = new Slider(parent);
299
335
  //build sliders                                         
300
336
  //for(int i = 0; i < plugI->plugin()->parameter(); i++) { 
301
337
  for(int i = 0; i < (int)plugI->plugin()->controlInPorts(); i++) { 
302
 
    ///double min, max, val;
303
 
    float min, max; //, val;
 
338
    float min, max, val;
304
339
    plugI->range(i, &min, &max);
305
340
 
306
 
// FIXME FIXME Tim
307
 
/*     
308
341
    val = _deicsOnze->getReverbParam(i);
309
 
     if(plugI->isBool(i))
310
 
      addPluginCheckBox(i, plugI->getParameterName(i), val > 0.0,
311
 
                        _reverbSuperWidget, grid, true);
312
 
    else if(plugI->isInt(i)) {
313
 
      addPluginIntSlider(i, plugI->getParameterName(i), rint(min), rint(max),
314
 
                         rint(val), _reverbSuperWidget, grid, true);
315
 
    }
316
 
    else {
317
 
      addPluginSlider(i, plugI->getParameterName(i), plugI->isLog(i),
318
 
                      min, max, val, _reverbSuperWidget, grid, true);
319
 
    }
320
 
*/    
321
 
    
 
342
     if(plugI->ctrlValueType(i) == MusECore::VAL_BOOL)
 
343
      addPluginCheckBox(i, plugI->paramName(i), val > 0.0,
 
344
                        _reverbSuperWidget, grid, true);
 
345
    else if(plugI->ctrlValueType(i) == MusECore::VAL_INT) 
 
346
      addPluginIntSlider(i, plugI->paramName(i), rint(min), rint(max),
 
347
                         rint(val), _reverbSuperWidget, grid, true);
 
348
    else 
 
349
      addPluginSlider(i, plugI->paramName(i), plugI->ctrlValueType(i) == MusECore::VAL_LOG,
 
350
                      min, max, val, _reverbSuperWidget, grid, true);
322
351
  }
323
352
  //update colors of the new sliders (and the whole gui actually)
324
353
  setEditTextColor(reinterpret_cast<const QColor &>(*etColor));
350
379
  //build sliders                              
351
380
  //for(int i = 0; i < plugI->plugin()->parameter(); i++) {
352
381
  for(int i = 0; i < (int)plugI->plugin()->controlInPorts(); i++) {
353
 
    ///double min, max, val;
354
 
    float min, max; //, val;
 
382
    float min, max, val;
355
383
    plugI->range(i, &min, &max);
356
384
    
357
 
// FIXME FIXME Tim
358
 
/*    
359
385
    val = _deicsOnze->getChorusParam(i);
360
 
    if(plugI->isBool(i))
361
 
      addPluginCheckBox(i, plugI->getParameterName(i), val > 0.0,
362
 
                        _chorusSuperWidget, grid, false);
363
 
    else if(plugI->isInt(i)) {
364
 
      addPluginIntSlider(i, plugI->getParameterName(i), rint(min), rint(max),
365
 
                         rint(val), _chorusSuperWidget, grid, false);
366
 
    }
367
 
    else {
368
 
      addPluginSlider(i, plugI->getParameterName(i), plugI->isLog(i),
369
 
                      min, max, val, _chorusSuperWidget, grid, false);
370
 
    }
371
 
*/    
372
 
    
 
386
    if(plugI->ctrlValueType(i) == MusECore::VAL_BOOL)
 
387
      addPluginCheckBox(i, plugI->paramName(i), val > 0.0,
 
388
                        _chorusSuperWidget, grid, false);
 
389
    else if(plugI->ctrlValueType(i) == MusECore::VAL_INT) 
 
390
      addPluginIntSlider(i, plugI->paramName(i), rint(min), rint(max),
 
391
                         rint(val), _chorusSuperWidget, grid, false);
 
392
    else 
 
393
      addPluginSlider(i, plugI->paramName(i), plugI->ctrlValueType(i) == MusECore::VAL_LOG,
 
394
                      min, max, val, _chorusSuperWidget, grid, false);
373
395
  }
374
396
  //update colors of the new sliders (and the whole gui actually)
375
397
  setEditTextColor(reinterpret_cast<const QColor &>(*etColor));
380
402
//of the parameter because it sends a double and does not
381
403
//change any thing
382
404
void DeicsOnzeGui::setReverbCheckBox(double v, int i) {
 
405
  if(i>=256) {
 
406
    printf("setReverbCheckBox Error : controller index >= 256\n");
 
407
    return;    
 
408
  }
383
409
  float f = (float)v;
384
 
  unsigned char* message = new unsigned char[2+sizeof(float)];
385
 
  message[0]=SYSEX_REVERBPARAM;
386
 
  if(i<256) {
387
 
    message[1]=(unsigned char)i;
388
 
    memcpy(&message[2], &f, sizeof(float));
389
 
    sendSysex(message, 2+sizeof(float));
390
 
  }
391
 
  else printf("setReverbCheckBox Error : cannot send controller upper than 225\n");
 
410
  unsigned char message[sizeof(float)+4];
 
411
  message[0]=MUSE_SYNTH_SYSEX_MFG_ID;
 
412
  message[1]=DEICSONZE_UNIQUE_ID;
 
413
  message[2]=SYSEX_REVERBPARAM;
 
414
  message[3]=(unsigned char)i;
 
415
  memcpy(&message[4], &f, sizeof(float));
 
416
  sendSysex(message, sizeof(float)+4);
392
417
}
393
418
 
394
419
//setChorusCheckBox is used, by the way, to send the value
395
420
//of the parameter because it sends a double and does not
396
421
//change any thing
397
422
void DeicsOnzeGui::setChorusCheckBox(double v, int i) {
 
423
  if(i>=256) {
 
424
    printf("setChorusCheckBox Error : controller index >= 256\n");
 
425
    return;
 
426
  }
398
427
  float f = (float)v;
399
 
  unsigned char* message = new unsigned char[2+sizeof(float)];
400
 
  message[0]=SYSEX_CHORUSPARAM;
401
 
  if(i<256) {
402
 
    message[1]=(unsigned char)i;
403
 
    memcpy(&message[2], &f, sizeof(float));
404
 
    sendSysex(message, 2+sizeof(float));
405
 
  }
406
 
  else printf("setChorusCheckBox Error : cannot send controller upper than 225\n");
407
 
}
408
 
 
409
 
void DeicsOnzeGui::setReverbFloatEntry(double /*v*/, int /*i*/) {
410
 
  if(_deicsOnze->_pluginIReverb) {
411
 
    
412
 
// FIXME FIXME Tim
413
 
/*    
414
 
    if(_deicsOnze->_pluginIReverb->isInt(i)) v = rint(v);
415
 
    updateReverbFloatEntry(v, i);  
416
 
    updateReverbSlider(v, i);
417
 
    setReverbCheckBox(v, i); //because this send the SYSEX
418
 
*/    
419
 
    
420
 
  }
421
 
  else printf("Warning : no DeicsOnze reverb loaded\n");
422
 
}
423
 
void DeicsOnzeGui::setReverbSlider(double /*v*/, int /*i*/) {
424
 
  if(_deicsOnze->_pluginIReverb) {
425
 
    
426
 
// FIXME FIXME Tim
427
 
/*
428
 
    if(_deicsOnze->_pluginIReverb->isInt(i)) v = rint(v);
429
 
    updateReverbFloatEntry(v, i);
430
 
    updateReverbSlider(v, i);
431
 
    setReverbCheckBox(v, i); //because this send the SYSEX
432
 
*/
433
 
    
434
 
  }
435
 
  else printf("Warning : no DeicsOnze reverb loaded\n");
436
 
}
437
 
void DeicsOnzeGui::setChorusFloatEntry(double /*v*/, int /*i*/) {
438
 
  if(_deicsOnze->_pluginIReverb) {
439
 
    
440
 
// FIXME FIXME Tim
441
 
/*
442
 
    if(_deicsOnze->_pluginIChorus->isInt(i)) v = rint(v);
 
428
  unsigned char message[sizeof(float)+4];
 
429
  message[0]=MUSE_SYNTH_SYSEX_MFG_ID;
 
430
  message[1]=DEICSONZE_UNIQUE_ID;
 
431
  message[2]=SYSEX_CHORUSPARAM;
 
432
  message[3]=(unsigned char)i;
 
433
  memcpy(&message[4], &f, sizeof(float));
 
434
  sendSysex(message, sizeof(float)+4);
 
435
}
 
436
 
 
437
void DeicsOnzeGui::setReverbFloatEntry(double v, int i) {
 
438
  if(_deicsOnze->_pluginIReverb) {
 
439
    
 
440
    if(_deicsOnze->_pluginIReverb->ctrlValueType(i) == MusECore::VAL_INT) v = rint(v);
 
441
    updateReverbFloatEntry(v, i);
 
442
    updateReverbSlider(v, i);
 
443
    setReverbCheckBox(v, i); //because this send the SYSEX
 
444
  }
 
445
  else printf("Warning : no DeicsOnze reverb loaded\n");
 
446
}
 
447
void DeicsOnzeGui::setReverbSlider(double v, int i) {
 
448
  if(_deicsOnze->_pluginIReverb) {
 
449
    
 
450
    if(_deicsOnze->_pluginIReverb->ctrlValueType(i) == MusECore::VAL_INT) v = rint(v);
 
451
    updateReverbFloatEntry(v, i);
 
452
    updateReverbSlider(v, i);
 
453
    setReverbCheckBox(v, i); //because this send the SYSEX
 
454
  }
 
455
  else printf("Warning : no DeicsOnze reverb loaded\n");
 
456
}
 
457
void DeicsOnzeGui::setChorusFloatEntry(double v, int i) {
 
458
  if(_deicsOnze->_pluginIReverb) {
 
459
 
 
460
    if(_deicsOnze->_pluginIChorus->ctrlValueType(i) == MusECore::VAL_INT) v = rint(v);
443
461
    updateChorusFloatEntry(v, i);
444
462
    updateChorusSlider(v, i);
445
463
    setChorusCheckBox(v, i); //because this send the SYSEX
446
 
*/
447
 
    
448
464
  }
449
465
  else printf("Warning : no DeicsOnze chorus loaded\n");
450
466
}
451
 
void DeicsOnzeGui::setChorusSlider(double /*v*/, int /*i*/) {
 
467
void DeicsOnzeGui::setChorusSlider(double v, int i) {
452
468
  if(_deicsOnze->_pluginIReverb) {  
453
 
    
454
 
// FIXME FIXME Tim
455
 
/*
456
 
    if(_deicsOnze->_pluginIChorus->isInt(i)) v = rint(v);
 
469
 
 
470
    if(_deicsOnze->_pluginIChorus->ctrlValueType(i) == MusECore::VAL_INT) v = rint(v);
457
471
    updateChorusSlider(v, i);
458
472
    updateChorusFloatEntry(v, i);
459
473
    setChorusCheckBox(v, i); //because this send the SYSEX
460
 
*/    
461
 
    
462
474
  }
463
475
  else printf("Warning : no DeicsOnze chorus loaded\n");
464
476
}
566
578
  if(_pluginIDelay) _pluginIDelay->setParam(5, val);
567
579
  else printf("Warning : no DeicsOnze delay loaded\n");
568
580
}
 
581
float DeicsOnze::getDelayDryWet() const {
 
582
  ///if(_pluginIDelay) return _pluginIDelay->controller(5)->curVal().f;
 
583
  if(_pluginIDelay) return _pluginIDelay->param(5);
 
584
  else {
 
585
    printf("Warning : no DeicsOnze delay loaded\n");
 
586
    return 0.0;
 
587
  }
 
588
}
 
589