|
|
@ -1,22 +1,22 @@ |
|
|
|
/**
|
|
|
|
/**
|
|
|
|
* |
|
|
|
|
|
|
|
* Copyright (c) 2016-2017 Holger Wirtz <dcoredump@googlemail.com> |
|
|
|
Copyright (c) 2016-2017 Holger Wirtz <dcoredump@googlemail.com> |
|
|
|
* |
|
|
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify |
|
|
|
This program is free software; you can redistribute it and/or modify |
|
|
|
* it under the terms of the GNU General Public License as published by |
|
|
|
it under the terms of the GNU General Public License as published by |
|
|
|
* the Free Software Foundation; either version 3 of the License, or |
|
|
|
the Free Software Foundation; either version 3 of the License, or |
|
|
|
* (at your option) any later version. |
|
|
|
(at your option) any later version. |
|
|
|
* |
|
|
|
|
|
|
|
* This program is distributed in the hope that it will be useful, |
|
|
|
This program is distributed in the hope that it will be useful, |
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
|
* GNU General Public License for more details. |
|
|
|
GNU General Public License for more details. |
|
|
|
* |
|
|
|
|
|
|
|
* You should have received a copy of the GNU General Public License |
|
|
|
You should have received a copy of the GNU General Public License |
|
|
|
* along with this program; if not, write to the Free Software Foundation, |
|
|
|
along with this program; if not, write to the Free Software Foundation, |
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
|
|
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
|
|
* |
|
|
|
|
|
|
|
*/ |
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
#include "dexed.h" |
|
|
|
#include "dexed.h" |
|
|
|
#include "EngineMkI.h" |
|
|
|
#include "EngineMkI.h" |
|
|
@ -39,7 +39,7 @@ Dexed::Dexed(double num_samples) |
|
|
|
Tanh::init(); |
|
|
|
Tanh::init(); |
|
|
|
Sin::init(); |
|
|
|
Sin::init(); |
|
|
|
|
|
|
|
|
|
|
|
_rate=num_samples; |
|
|
|
_rate = num_samples; |
|
|
|
|
|
|
|
|
|
|
|
Freqlut::init(_rate); |
|
|
|
Freqlut::init(_rate); |
|
|
|
Lfo::init(_rate); |
|
|
|
Lfo::init(_rate); |
|
|
@ -47,18 +47,18 @@ Dexed::Dexed(double num_samples) |
|
|
|
Env::init_sr(_rate); |
|
|
|
Env::init_sr(_rate); |
|
|
|
//fx.init(_rate);
|
|
|
|
//fx.init(_rate);
|
|
|
|
|
|
|
|
|
|
|
|
engineMkI=new EngineMkI; |
|
|
|
engineMkI = new EngineMkI; |
|
|
|
engineOpl=new EngineOpl; |
|
|
|
engineOpl = new EngineOpl; |
|
|
|
engineMsfa=new FmCore; |
|
|
|
engineMsfa = new FmCore; |
|
|
|
|
|
|
|
|
|
|
|
for(i=0; i<MAX_ACTIVE_NOTES; i++) { |
|
|
|
for (i = 0; i < MAX_ACTIVE_NOTES; i++) { |
|
|
|
voices[i].dx7_note = new Dx7Note; |
|
|
|
voices[i].dx7_note = new Dx7Note; |
|
|
|
voices[i].keydown = false; |
|
|
|
voices[i].keydown = false; |
|
|
|
voices[i].sustained = false; |
|
|
|
voices[i].sustained = false; |
|
|
|
voices[i].live = false; |
|
|
|
voices[i].live = false; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
max_notes=16; |
|
|
|
max_notes = 16; |
|
|
|
currentNote = 0; |
|
|
|
currentNote = 0; |
|
|
|
controllers.values_[kControllerPitch] = 0x2000; |
|
|
|
controllers.values_[kControllerPitch] = 0x2000; |
|
|
|
controllers.values_[kControllerPitchRange] = 0; |
|
|
|
controllers.values_[kControllerPitchRange] = 0; |
|
|
@ -67,10 +67,10 @@ Dexed::Dexed(double num_samples) |
|
|
|
controllers.foot_cc = 0; |
|
|
|
controllers.foot_cc = 0; |
|
|
|
controllers.breath_cc = 0; |
|
|
|
controllers.breath_cc = 0; |
|
|
|
controllers.aftertouch_cc = 0; |
|
|
|
controllers.aftertouch_cc = 0; |
|
|
|
controllers.masterTune=0; |
|
|
|
controllers.masterTune = 0; |
|
|
|
controllers.opSwitch=0x3f; // enable all operators
|
|
|
|
controllers.opSwitch = 0x3f; // enable all operators
|
|
|
|
|
|
|
|
|
|
|
|
lfo.reset(data+137); |
|
|
|
lfo.reset(data + 137); |
|
|
|
|
|
|
|
|
|
|
|
setMonoMode(false); |
|
|
|
setMonoMode(false); |
|
|
|
|
|
|
|
|
|
|
@ -97,11 +97,11 @@ Dexed::~Dexed() |
|
|
|
voices[note].live = false; |
|
|
|
voices[note].live = false; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if(engineMsfa) |
|
|
|
if (engineMsfa) |
|
|
|
delete(engineMkI); |
|
|
|
delete(engineMkI); |
|
|
|
if(engineOpl) |
|
|
|
if (engineOpl) |
|
|
|
delete(engineMkI); |
|
|
|
delete(engineMkI); |
|
|
|
if(engineMkI) |
|
|
|
if (engineMkI) |
|
|
|
delete(engineMkI); |
|
|
|
delete(engineMkI); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
@ -118,8 +118,8 @@ void Dexed::deactivate(void) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
void Dexed::set_params(void) |
|
|
|
void Dexed::set_params(void) |
|
|
|
{ |
|
|
|
{ |
|
|
|
_param_change_counter=0; |
|
|
|
_param_change_counter=0; |
|
|
|
|
|
|
|
|
|
|
|
bool polymono=bool(*p(p_polymono)); |
|
|
|
bool polymono=bool(*p(p_polymono)); |
|
|
@ -334,11 +334,11 @@ void Dexed::set_params(void) |
|
|
|
panic(); |
|
|
|
panic(); |
|
|
|
controllers.refresh(); |
|
|
|
controllers.refresh(); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
/*void Dexed::run (uint8_t* midi_data)
|
|
|
|
/*void Dexed::run (uint8_t* midi_data)
|
|
|
|
{ |
|
|
|
{ |
|
|
|
static int16_t buffer; |
|
|
|
static int16_t buffer; |
|
|
|
|
|
|
|
|
|
|
|
ProcessMidiMessage(midi_data); |
|
|
|
ProcessMidiMessage(midi_data); |
|
|
@ -347,18 +347,18 @@ void Dexed::set_params(void) |
|
|
|
GetSamples(&buffer); |
|
|
|
GetSamples(&buffer); |
|
|
|
|
|
|
|
|
|
|
|
//fx.process(&buffer,_rate);
|
|
|
|
//fx.process(&buffer,_rate);
|
|
|
|
}*/ |
|
|
|
}*/ |
|
|
|
|
|
|
|
|
|
|
|
void Dexed::GetSamples(int16_t* buffer) |
|
|
|
void Dexed::GetSamples(int16_t* buffer) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t i=0; |
|
|
|
uint32_t i = 0; |
|
|
|
|
|
|
|
|
|
|
|
if(refreshVoice) { |
|
|
|
if (refreshVoice) { |
|
|
|
for(i=0;i < max_notes;i++) { |
|
|
|
for (i = 0; i < max_notes; i++) { |
|
|
|
if ( voices[i].live ) |
|
|
|
if ( voices[i].live ) |
|
|
|
voices[i].dx7_note->update(data, voices[i].midi_note, voices[i].velocity); |
|
|
|
voices[i].dx7_note->update(data, voices[i].midi_note, voices[i].velocity); |
|
|
|
} |
|
|
|
} |
|
|
|
lfo.reset(data+137); |
|
|
|
lfo.reset(data + 137); |
|
|
|
refreshVoice = false; |
|
|
|
refreshVoice = false; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
@ -378,15 +378,15 @@ void Dexed::GetSamples(int16_t* buffer) |
|
|
|
for (uint8_t note = 0; note < max_notes; ++note) { |
|
|
|
for (uint8_t note = 0; note < max_notes; ++note) { |
|
|
|
if (voices[note].live) { |
|
|
|
if (voices[note].live) { |
|
|
|
voices[note].dx7_note->compute(audiobuf.get(), lfovalue, lfodelay, &controllers); |
|
|
|
voices[note].dx7_note->compute(audiobuf.get(), lfovalue, lfodelay, &controllers); |
|
|
|
for (uint32_t j=0; j < _N_; ++j) { |
|
|
|
for (uint32_t j = 0; j < _N_; ++j) { |
|
|
|
int32_t val = audiobuf.get()[j]; |
|
|
|
int32_t val = audiobuf.get()[j]; |
|
|
|
val = val >> 4; |
|
|
|
val = val >> 4; |
|
|
|
int32_t clip_val = val < -(1 << 24) ? 0x8000 : val >= (1 << 24) ? 0x7fff : val >> 9; |
|
|
|
int32_t clip_val = val < -(1 << 24) ? 0x8000 : val >= (1 << 24) ? 0x7fff : val >> 9; |
|
|
|
float f = static_cast<float>(clip_val>>1)/0x8000; |
|
|
|
float f = static_cast<float>(clip_val >> 1) / 0x8000; |
|
|
|
if(f>1) f=1; |
|
|
|
if (f > 1) f = 1; |
|
|
|
if(f<-1) f=-1; |
|
|
|
if (f < -1) f = -1; |
|
|
|
sumbuf[j]+=f; |
|
|
|
sumbuf[j] += f; |
|
|
|
audiobuf.get()[j]=0; |
|
|
|
audiobuf.get()[j] = 0; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
@ -395,59 +395,59 @@ void Dexed::GetSamples(int16_t* buffer) |
|
|
|
buffer[i + j] = sumbuf[j]; |
|
|
|
buffer[i + j] = sumbuf[j]; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if(++_k_rate_counter%32 && !monoMode) |
|
|
|
if (++_k_rate_counter % 32 && !monoMode) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint8_t op_carrier=controllers.core->get_carrier_operators(data[134]); // look for carriers
|
|
|
|
uint8_t op_carrier = controllers.core->get_carrier_operators(data[134]); // look for carriers
|
|
|
|
|
|
|
|
|
|
|
|
for(i=0;i < max_notes;i++) |
|
|
|
for (i = 0; i < max_notes; i++) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if(voices[i].live==true) |
|
|
|
if (voices[i].live == true) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint8_t op_amp=0; |
|
|
|
uint8_t op_amp = 0; |
|
|
|
uint8_t op_carrier_num=0; |
|
|
|
uint8_t op_carrier_num = 0; |
|
|
|
|
|
|
|
|
|
|
|
voices[i].dx7_note->peekVoiceStatus(voiceStatus); |
|
|
|
voices[i].dx7_note->peekVoiceStatus(voiceStatus); |
|
|
|
|
|
|
|
|
|
|
|
for(uint8_t op=0;op<6;op++) |
|
|
|
for (uint8_t op = 0; op < 6; op++) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint8_t op_bit=pow(2,op); |
|
|
|
uint8_t op_bit = pow(2, op); |
|
|
|
|
|
|
|
|
|
|
|
if((op_carrier&op_bit)>0) |
|
|
|
if ((op_carrier & op_bit) > 0) |
|
|
|
{ |
|
|
|
{ |
|
|
|
// this voice is a carrier!
|
|
|
|
// this voice is a carrier!
|
|
|
|
op_carrier_num++; |
|
|
|
op_carrier_num++; |
|
|
|
|
|
|
|
|
|
|
|
if(voiceStatus.amp[op]<=1069 && voiceStatus.ampStep[op]==4) // this voice produces no audio output
|
|
|
|
if (voiceStatus.amp[op] <= 1069 && voiceStatus.ampStep[op] == 4) // this voice produces no audio output
|
|
|
|
op_amp++; |
|
|
|
op_amp++; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
if(op_amp==op_carrier_num) |
|
|
|
if (op_amp == op_carrier_num) |
|
|
|
{ |
|
|
|
{ |
|
|
|
// all carrier-operators are silent -> disable the voice
|
|
|
|
// all carrier-operators are silent -> disable the voice
|
|
|
|
voices[i].live=false; |
|
|
|
voices[i].live = false; |
|
|
|
voices[i].sustained=false; |
|
|
|
voices[i].sustained = false; |
|
|
|
voices[i].keydown=false; |
|
|
|
voices[i].keydown = false; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
bool Dexed::ProcessMidiMessage(uint8_t cmd,uint8_t data1,uint8_t data2) |
|
|
|
bool Dexed::ProcessMidiMessage(uint8_t cmd, uint8_t data1, uint8_t data2) |
|
|
|
{ |
|
|
|
{ |
|
|
|
switch(cmd & 0xf0) { |
|
|
|
switch (cmd & 0xf0) { |
|
|
|
case 0x80 : |
|
|
|
case 0x80 : |
|
|
|
// TRACE("MIDI keyup event: %d",buf[1]);
|
|
|
|
// TRACE("MIDI keyup event: %d",buf[1]);
|
|
|
|
keyup(data1); |
|
|
|
keyup(data1); |
|
|
|
return(false); |
|
|
|
return (false); |
|
|
|
break; |
|
|
|
break; |
|
|
|
case 0x90 : |
|
|
|
case 0x90 : |
|
|
|
// TRACE("MIDI keydown event: %d %d",buf[1],buf[2]);
|
|
|
|
// TRACE("MIDI keydown event: %d %d",buf[1],buf[2]);
|
|
|
|
keydown(data1, data2); |
|
|
|
keydown(data1, data2); |
|
|
|
return(false); |
|
|
|
return (false); |
|
|
|
break; |
|
|
|
break; |
|
|
|
case 0xb0 : { |
|
|
|
case 0xb0 : { |
|
|
|
switch(data1) { |
|
|
|
switch (data1) { |
|
|
|
case 1: |
|
|
|
case 1: |
|
|
|
// TRACE("MIDI modwheel event: %d %d",ctrl,value);
|
|
|
|
// TRACE("MIDI modwheel event: %d %d",ctrl,value);
|
|
|
|
controllers.modwheel_cc = data2; |
|
|
|
controllers.modwheel_cc = data2; |
|
|
@ -478,20 +478,20 @@ bool Dexed::ProcessMidiMessage(uint8_t cmd,uint8_t data1,uint8_t data2) |
|
|
|
case 120: |
|
|
|
case 120: |
|
|
|
// TRACE("MIDI all-sound-off: %d %d",ctrl,value);
|
|
|
|
// TRACE("MIDI all-sound-off: %d %d",ctrl,value);
|
|
|
|
panic(); |
|
|
|
panic(); |
|
|
|
return(true); |
|
|
|
return (true); |
|
|
|
break; |
|
|
|
break; |
|
|
|
case 123: |
|
|
|
case 123: |
|
|
|
// TRACE("MIDI all-notes-off: %d %d",ctrl,value);
|
|
|
|
// TRACE("MIDI all-notes-off: %d %d",ctrl,value);
|
|
|
|
notes_off(); |
|
|
|
notes_off(); |
|
|
|
return(true); |
|
|
|
return (true); |
|
|
|
break; |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
break; |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// case 0xc0 :
|
|
|
|
// case 0xc0 :
|
|
|
|
// setCurrentProgram(data1);
|
|
|
|
// setCurrentProgram(data1);
|
|
|
|
// break;
|
|
|
|
// break;
|
|
|
|
|
|
|
|
|
|
|
|
// channel aftertouch
|
|
|
|
// channel aftertouch
|
|
|
|
case 0xd0 : |
|
|
|
case 0xd0 : |
|
|
@ -507,7 +507,7 @@ bool Dexed::ProcessMidiMessage(uint8_t cmd,uint8_t data1,uint8_t data2) |
|
|
|
break; |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
return(false); |
|
|
|
return (false); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void Dexed::keydown(uint8_t pitch, uint8_t velo) { |
|
|
|
void Dexed::keydown(uint8_t pitch, uint8_t velo) { |
|
|
@ -519,9 +519,9 @@ void Dexed::keydown(uint8_t pitch, uint8_t velo) { |
|
|
|
pitch += data[144] - 24; |
|
|
|
pitch += data[144] - 24; |
|
|
|
|
|
|
|
|
|
|
|
uint8_t note = currentNote; |
|
|
|
uint8_t note = currentNote; |
|
|
|
uint8_t keydown_counter=0; |
|
|
|
uint8_t keydown_counter = 0; |
|
|
|
|
|
|
|
|
|
|
|
for (uint8_t i=0; i<max_notes; i++) { |
|
|
|
for (uint8_t i = 0; i < max_notes; i++) { |
|
|
|
if (!voices[note].keydown) { |
|
|
|
if (!voices[note].keydown) { |
|
|
|
currentNote = (note + 1) % max_notes; |
|
|
|
currentNote = (note + 1) % max_notes; |
|
|
|
voices[note].midi_note = pitch; |
|
|
|
voices[note].midi_note = pitch; |
|
|
@ -539,10 +539,10 @@ void Dexed::keydown(uint8_t pitch, uint8_t velo) { |
|
|
|
note = (note + 1) % max_notes; |
|
|
|
note = (note + 1) % max_notes; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if(keydown_counter==0) |
|
|
|
if (keydown_counter == 0) |
|
|
|
lfo.keydown(); |
|
|
|
lfo.keydown(); |
|
|
|
if ( monoMode ) { |
|
|
|
if ( monoMode ) { |
|
|
|
for(uint8_t i=0; i<max_notes; i++) {
|
|
|
|
for (uint8_t i = 0; i < max_notes; i++) { |
|
|
|
if ( voices[i].live ) { |
|
|
|
if ( voices[i].live ) { |
|
|
|
// all keys are up, only transfer signal
|
|
|
|
// all keys are up, only transfer signal
|
|
|
|
if ( ! voices[i].keydown ) { |
|
|
|
if ( ! voices[i].keydown ) { |
|
|
@ -567,7 +567,7 @@ void Dexed::keyup(uint8_t pitch) { |
|
|
|
pitch += data[144] - 24; |
|
|
|
pitch += data[144] - 24; |
|
|
|
|
|
|
|
|
|
|
|
uint8_t note; |
|
|
|
uint8_t note; |
|
|
|
for (note=0; note<max_notes; ++note) { |
|
|
|
for (note = 0; note < max_notes; ++note) { |
|
|
|
if ( voices[note].midi_note == pitch && voices[note].keydown ) { |
|
|
|
if ( voices[note].midi_note == pitch && voices[note].keydown ) { |
|
|
|
voices[note].keydown = false; |
|
|
|
voices[note].keydown = false; |
|
|
|
break; |
|
|
|
break; |
|
|
@ -582,7 +582,7 @@ void Dexed::keyup(uint8_t pitch) { |
|
|
|
if ( monoMode ) { |
|
|
|
if ( monoMode ) { |
|
|
|
int8_t highNote = -1; |
|
|
|
int8_t highNote = -1; |
|
|
|
int8_t target = 0; |
|
|
|
int8_t target = 0; |
|
|
|
for (int8_t i=0; i<max_notes;i++) { |
|
|
|
for (int8_t i = 0; i < max_notes; i++) { |
|
|
|
if ( voices[i].keydown && voices[i].midi_note > highNote ) { |
|
|
|
if ( voices[i].keydown && voices[i].midi_note > highNote ) { |
|
|
|
target = i; |
|
|
|
target = i; |
|
|
|
highNote = voices[i].midi_note; |
|
|
|
highNote = voices[i].midi_note; |
|
|
@ -604,7 +604,7 @@ void Dexed::keyup(uint8_t pitch) { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*void Dexed::onParam(uint8_t param_num,float param_val)
|
|
|
|
/*void Dexed::onParam(uint8_t param_num,float param_val)
|
|
|
|
{ |
|
|
|
{ |
|
|
|
int32_t tune; |
|
|
|
int32_t tune; |
|
|
|
|
|
|
|
|
|
|
|
if(param_val!=data_float[param_num]) |
|
|
|
if(param_val!=data_float[param_num]) |
|
|
@ -668,7 +668,7 @@ void Dexed::keyup(uint8_t pitch) { |
|
|
|
break; |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
uint8_t Dexed::getEngineType() { |
|
|
|
uint8_t Dexed::getEngineType() { |
|
|
@ -676,7 +676,7 @@ uint8_t Dexed::getEngineType() { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void Dexed::setEngineType(uint8_t tp) { |
|
|
|
void Dexed::setEngineType(uint8_t tp) { |
|
|
|
if(engineType==tp && controllers.core!=NULL) |
|
|
|
if (engineType == tp && controllers.core != NULL) |
|
|
|
return; |
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
switch (tp) { |
|
|
|
switch (tp) { |
|
|
@ -688,7 +688,7 @@ void Dexed::setEngineType(uint8_t tp) { |
|
|
|
break; |
|
|
|
break; |
|
|
|
default: |
|
|
|
default: |
|
|
|
controllers.core = engineMsfa; |
|
|
|
controllers.core = engineMsfa; |
|
|
|
tp=DEXED_ENGINE_MODERN; |
|
|
|
tp = DEXED_ENGINE_MODERN; |
|
|
|
break; |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
engineType = tp; |
|
|
|
engineType = tp; |
|
|
@ -701,16 +701,16 @@ bool Dexed::isMonoMode(void) { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void Dexed::setMonoMode(bool mode) { |
|
|
|
void Dexed::setMonoMode(bool mode) { |
|
|
|
if(monoMode==mode) |
|
|
|
if (monoMode == mode) |
|
|
|
return; |
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
monoMode = mode; |
|
|
|
monoMode = mode; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void Dexed::panic(void) { |
|
|
|
void Dexed::panic(void) { |
|
|
|
for(uint8_t i=0;i<MAX_ACTIVE_NOTES;i++) |
|
|
|
for (uint8_t i = 0; i < MAX_ACTIVE_NOTES; i++) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if(voices[i].live == true) { |
|
|
|
if (voices[i].live == true) { |
|
|
|
voices[i].keydown = false; |
|
|
|
voices[i].keydown = false; |
|
|
|
voices[i].live = false; |
|
|
|
voices[i].live = false; |
|
|
|
voices[i].sustained = false; |
|
|
|
voices[i].sustained = false; |
|
|
@ -722,9 +722,9 @@ void Dexed::panic(void) { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void Dexed::notes_off(void) { |
|
|
|
void Dexed::notes_off(void) { |
|
|
|
for(uint8_t i=0;i<MAX_ACTIVE_NOTES;i++) { |
|
|
|
for (uint8_t i = 0; i < MAX_ACTIVE_NOTES; i++) { |
|
|
|
if(voices[i].live==true&&voices[i].keydown==true) { |
|
|
|
if (voices[i].live == true && voices[i].keydown == true) { |
|
|
|
voices[i].keydown=false; |
|
|
|
voices[i].keydown = false; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|