From e9751e62411b49af6823c4eab0411a4c9a2ab143 Mon Sep 17 00:00:00 2001 From: probonopd Date: Sat, 21 Dec 2024 21:24:45 +0100 Subject: [PATCH 1/9] retention-days: 3 # To not exceed the free MB/month quota so quickly [ci skip] --- .github/workflows/build.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a5cf9e84..43f6e6f3 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -96,6 +96,7 @@ jobs: with: name: ${{ env.artifactName }} # Exported above path: ./sdcard/* + retention-days: 3 # To not exceed the free MB/month quota so quickly - name: Upload to GitHub Releases (only when building from main branch) if: ${{ github.ref == 'refs/heads/main' }} run: | From f115270f68eacc79c1cfdbb7c1a7306a65d4d997 Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Tue, 26 Nov 2024 00:32:58 +0100 Subject: [PATCH 2/9] add MIDI Button actions --- src/config.cpp | 69 +++++++++++++++++++++++++++++++++++++++++++++++ src/config.h | 28 +++++++++++++++++++ src/minidexed.ini | 11 ++++++++ src/uibuttons.cpp | 21 +++++++++++---- src/uibuttons.h | 12 +++++++++ 5 files changed, 136 insertions(+), 5 deletions(-) diff --git a/src/config.cpp b/src/config.cpp index 482b2b28..7f5d0404 100644 --- a/src/config.cpp +++ b/src/config.cpp @@ -178,18 +178,32 @@ void CConfig::Load (void) m_nMIDIButtonCh = m_Properties.GetNumber ("MIDIButtonCh", 0); m_nMIDIButtonNotes = m_Properties.GetNumber ("MIDIButtonNotes", 0); + m_nMIDIButtonPrev = m_Properties.GetNumber ("MIDIButtonPrev", 0); m_nMIDIButtonNext = m_Properties.GetNumber ("MIDIButtonNext", 0); m_nMIDIButtonBack = m_Properties.GetNumber ("MIDIButtonBack", 0); m_nMIDIButtonSelect = m_Properties.GetNumber ("MIDIButtonSelect", 0); m_nMIDIButtonHome = m_Properties.GetNumber ("MIDIButtonHome", 0); + m_MIDIButtonActionPrev = m_Properties.GetString ("MIDIButtonActionPrev", ""); + m_MIDIButtonActionNext = m_Properties.GetString ("MIDIButtonActionNext", ""); + m_MIDIButtonActionBack = m_Properties.GetString ("MIDIButtonActionBack", ""); + m_MIDIButtonActionSelect = m_Properties.GetString ("MIDIButtonActionSelect", ""); + m_MIDIButtonActionHome = m_Properties.GetString ("MIDIButtonActionHome", ""); + m_nMIDIButtonPgmUp = m_Properties.GetNumber ("MIDIButtonPgmUp", 0); m_nMIDIButtonPgmDown = m_Properties.GetNumber ("MIDIButtonPgmDown", 0); m_nMIDIButtonBankUp = m_Properties.GetNumber ("MIDIButtonBankUp", 0); m_nMIDIButtonBankDown = m_Properties.GetNumber ("MIDIButtonBankDown", 0); m_nMIDIButtonTGUp = m_Properties.GetNumber ("MIDIButtonTGUp", 0); m_nMIDIButtonTGDown = m_Properties.GetNumber ("MIDIButtonTGDown", 0); + + m_MIDIButtonActionPgmUp = m_Properties.GetString ("MIDIButtonActionPgmUp", ""); + m_MIDIButtonActionPgmDown = m_Properties.GetString ("MIDIButtonActionPgmDown", ""); + m_MIDIButtonActionBankUp = m_Properties.GetString ("MIDIButtonActionBankUp", ""); + m_MIDIButtonActionBankDown = m_Properties.GetString ("MIDIButtonActionBankDown", ""); + m_MIDIButtonActionTGUp = m_Properties.GetString ("MIDIButtonActionTGUp", ""); + m_MIDIButtonActionTGDown = m_Properties.GetString ("MIDIButtonActionTGDown", ""); m_bEncoderEnabled = m_Properties.GetNumber ("EncoderEnabled", 0) != 0; m_nEncoderPinClock = m_Properties.GetNumber ("EncoderPinClock", 10); @@ -652,6 +666,31 @@ unsigned CConfig::GetMIDIButtonHome (void) const return m_nMIDIButtonHome; } +const char *CConfig::GetMIDIButtonActionPrev (void) const +{ + return m_MIDIButtonActionPrev.c_str(); +} + +const char *CConfig::GetMIDIButtonActionNext (void) const +{ + return m_MIDIButtonActionNext.c_str(); +} + +const char *CConfig::GetMIDIButtonActionBack (void) const +{ + return m_MIDIButtonActionBack.c_str(); +} + +const char *CConfig::GetMIDIButtonActionSelect (void) const +{ + return m_MIDIButtonActionSelect.c_str(); +} + +const char *CConfig::GetMIDIButtonActionHome (void) const +{ + return m_MIDIButtonActionHome.c_str(); +} + unsigned CConfig::GetMIDIButtonPgmUp (void) const { return m_nMIDIButtonPgmUp; @@ -682,6 +721,36 @@ unsigned CConfig::GetMIDIButtonTGDown (void) const return m_nMIDIButtonTGDown; } +const char *CConfig::GetMIDIButtonActionPgmUp (void) const +{ + return m_MIDIButtonActionPgmUp.c_str(); +} + +const char *CConfig::GetMIDIButtonActionPgmDown (void) const +{ + return m_MIDIButtonActionPgmDown.c_str(); +} + +const char *CConfig::GetMIDIButtonActionBankUp (void) const +{ + return m_MIDIButtonActionBankUp.c_str(); +} + +const char *CConfig::GetMIDIButtonActionBankDown (void) const +{ + return m_MIDIButtonActionBankDown.c_str(); +} + +const char *CConfig::GetMIDIButtonActionTGUp (void) const +{ + return m_MIDIButtonActionTGUp.c_str(); +} + +const char *CConfig::GetMIDIButtonActionTGDown (void) const +{ + return m_MIDIButtonActionTGDown.c_str(); +} + bool CConfig::GetEncoderEnabled (void) const { return m_bEncoderEnabled; diff --git a/src/config.h b/src/config.h index 5d0cbc15..f7da3efc 100644 --- a/src/config.h +++ b/src/config.h @@ -210,12 +210,20 @@ class CConfig // Configuration for MiniDexed // MIDI Button Navigation unsigned GetMIDIButtonCh (void) const; unsigned GetMIDIButtonNotes (void) const; + unsigned GetMIDIButtonPrev (void) const; unsigned GetMIDIButtonNext (void) const; unsigned GetMIDIButtonBack (void) const; unsigned GetMIDIButtonSelect (void) const; unsigned GetMIDIButtonHome (void) const; + // Action type for Midi buttons: "click", "doubleclick", "longpress", "" + const char *GetMIDIButtonActionPrev (void) const; + const char *GetMIDIButtonActionNext (void) const; + const char *GetMIDIButtonActionBack (void) const; + const char *GetMIDIButtonActionSelect (void) const; + const char *GetMIDIButtonActionHome (void) const; + // MIDI Button Program and TG Selection unsigned GetMIDIButtonPgmUp (void) const; unsigned GetMIDIButtonPgmDown (void) const; @@ -224,6 +232,14 @@ class CConfig // Configuration for MiniDexed unsigned GetMIDIButtonTGUp (void) const; unsigned GetMIDIButtonTGDown (void) const; + // Action type for buttons: "click", "doubleclick", "longpress", "" + const char *GetMIDIButtonActionPgmUp (void) const; + const char *GetMIDIButtonActionPgmDown (void) const; + const char *GetMIDIButtonActionBankUp (void) const; + const char *GetMIDIButtonActionBankDown (void) const; + const char *GetMIDIButtonActionTGUp (void) const; + const char *GetMIDIButtonActionTGDown (void) const; + // KY-040 Rotary Encoder // GPIO pin numbers are chip numbers, not header positions bool GetEncoderEnabled (void) const; @@ -326,6 +342,18 @@ class CConfig // Configuration for MiniDexed std::string m_ButtonActionTGUp; std::string m_ButtonActionTGDown; + std::string m_MIDIButtonActionPrev; + std::string m_MIDIButtonActionNext; + std::string m_MIDIButtonActionBack; + std::string m_MIDIButtonActionSelect; + std::string m_MIDIButtonActionHome; + std::string m_MIDIButtonActionPgmUp; + std::string m_MIDIButtonActionPgmDown; + std::string m_MIDIButtonActionBankUp; + std::string m_MIDIButtonActionBankDown; + std::string m_MIDIButtonActionTGUp; + std::string m_MIDIButtonActionTGDown; + unsigned m_nDoubleClickTimeout; unsigned m_nLongPressTimeout; diff --git a/src/minidexed.ini b/src/minidexed.ini index 5b6b13d8..57eac0f3 100644 --- a/src/minidexed.ini +++ b/src/minidexed.ini @@ -124,20 +124,31 @@ MIDIButtonCh=17 MIDIButtonNotes=0 # Arrow left MIDIButtonPrev=46 +MIDIButtonActionPrev=click # Arrow right MIDIButtonNext=47 +MIDIButtonActionNext=click # Arrow up MIDIButtonBack=48 +MIDIButtonActionBack=click # Arrow down MIDIButtonSelect=49 +MIDIButtonActionSelect=click # Home button MIDIButtonHome=50 +MIDIButtonActionHome=click MIDIButtonPgmUp=51 +MIDIButtonActionPgmUp=click MIDIButtonPgmDown=52 +MIDIButtonActionPgmDown=click MIDIButtonBankUp=53 +MIDIButtonActionBankUp=click MIDIButtonBankDown=54 +MIDIButtonActionBankDown=click MIDIButtonTGUp=55 +MIDIButtonActionTGUp=click MIDIButtonTGDown=56 +MIDIButtonActionTGDown=click # KY-040 Rotary Encoder EncoderEnabled=1 diff --git a/src/uibuttons.cpp b/src/uibuttons.cpp index ae206dcc..3df7f4ba 100644 --- a/src/uibuttons.cpp +++ b/src/uibuttons.cpp @@ -299,17 +299,28 @@ boolean CUIButtons::Initialize (void) m_TGDownAction = CUIButton::triggerTypeFromString( m_pConfig->GetButtonActionTGDown ()); m_notesMidi = ccToMidiPin( m_pConfig->GetMIDIButtonNotes ()); m_prevMidi = ccToMidiPin( m_pConfig->GetMIDIButtonPrev ()); + m_prevMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionPrev ()); m_nextMidi = ccToMidiPin( m_pConfig->GetMIDIButtonNext ()); + m_nextMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionNext ()); m_backMidi = ccToMidiPin( m_pConfig->GetMIDIButtonBack ()); + m_backMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionBack ()); m_selectMidi = ccToMidiPin( m_pConfig->GetMIDIButtonSelect ()); + m_selectMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionSelect ()); m_homeMidi = ccToMidiPin( m_pConfig->GetMIDIButtonHome ()); + m_homeMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionHome ()); m_pgmUpMidi = ccToMidiPin( m_pConfig->GetMIDIButtonPgmUp ()); + m_pgmUpMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionPgmUp ()); m_pgmDownMidi = ccToMidiPin( m_pConfig->GetMIDIButtonPgmDown ()); + m_pgmDownMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionPgmDown ()); m_BankUpMidi = ccToMidiPin( m_pConfig->GetMIDIButtonBankUp ()); + m_BankUpMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionBankUp ()); m_BankDownMidi = ccToMidiPin( m_pConfig->GetMIDIButtonBankDown ()); + m_BankDownMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionBankDown ()); m_TGUpMidi = ccToMidiPin( m_pConfig->GetMIDIButtonTGUp ()); + m_TGUpMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionTGUp ()); m_TGDownMidi = ccToMidiPin( m_pConfig->GetMIDIButtonTGDown ()); - + m_TGDownMidiAction = CUIButton::triggerTypeFromString( m_pConfig->GetMIDIButtonActionTGDown ()); + // First sanity check and convert the timeouts: // Internally values are in tenths of a millisecond, but config values // are in milliseconds @@ -328,7 +339,7 @@ boolean CUIButtons::Initialize (void) // Each normal button can be assigned up to 3 actions: click, doubleclick and // longpress. We may not initialise all of the buttons. - // MIDI buttons only support a single click. + // MIDI Buttons can be assigned to click, doubleclick, longpress unsigned pins[MAX_BUTTONS] = { m_prevPin, m_nextPin, m_backPin, m_selectPin, m_homePin, m_pgmUpPin, m_pgmDownPin, m_BankUpPin, m_BankDownPin, m_TGUpPin, m_TGDownPin, m_prevMidi, m_nextMidi, m_backMidi, m_selectMidi, m_homeMidi, m_pgmUpMidi, m_pgmDownMidi, m_BankUpMidi, m_BankDownMidi, m_TGUpMidi, m_TGDownMidi @@ -337,9 +348,9 @@ boolean CUIButtons::Initialize (void) // Normal buttons m_prevAction, m_nextAction, m_backAction, m_selectAction, m_homeAction, m_pgmUpAction, m_pgmDownAction, m_BankUpAction, m_BankDownAction, m_TGUpAction, m_TGDownAction, - // MIDI Buttons only support a single click (at present) - CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, - CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick, CUIButton::BtnTriggerClick + // MIDI buttons + m_prevMidiAction, m_nextMidiAction, m_backMidiAction, m_selectMidiAction, m_homeMidiAction, + m_pgmUpMidiAction, m_pgmDownMidiAction, m_BankUpMidiAction, m_BankDownMidiAction, m_TGUpMidiAction, m_TGDownMidiAction, }; CUIButton::BtnEvent events[MAX_BUTTONS] = { // Normal buttons diff --git a/src/uibuttons.h b/src/uibuttons.h index be179348..76febddf 100644 --- a/src/uibuttons.h +++ b/src/uibuttons.h @@ -165,18 +165,30 @@ class CUIButtons // MIDI button configuration unsigned m_notesMidi; + unsigned m_prevMidi; + CUIButton::BtnTrigger m_prevMidiAction; unsigned m_nextMidi; + CUIButton::BtnTrigger m_nextMidiAction; unsigned m_backMidi; + CUIButton::BtnTrigger m_backMidiAction; unsigned m_selectMidi; + CUIButton::BtnTrigger m_selectMidiAction; unsigned m_homeMidi; + CUIButton::BtnTrigger m_homeMidiAction; unsigned m_pgmUpMidi; + CUIButton::BtnTrigger m_pgmUpMidiAction; unsigned m_pgmDownMidi; + CUIButton::BtnTrigger m_pgmDownMidiAction; unsigned m_BankUpMidi; + CUIButton::BtnTrigger m_BankUpMidiAction; unsigned m_BankDownMidi; + CUIButton::BtnTrigger m_BankDownMidiAction; unsigned m_TGUpMidi; + CUIButton::BtnTrigger m_TGUpMidiAction; unsigned m_TGDownMidi; + CUIButton::BtnTrigger m_TGDownMidiAction; BtnEventHandler *m_eventHandler; void *m_eventParam; From 084a009ab053cbdf2f9101b917dda3dbb3c6fbd3 Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Tue, 26 Nov 2024 00:43:30 +0100 Subject: [PATCH 3/9] add dec and inc trigger modes to MIDI Buttons --- src/config.h | 4 ++-- src/midipin.cpp | 12 +++++++++++- src/midipin.h | 8 +++++++- src/minidexed.ini | 3 ++- src/uibuttons.cpp | 49 ++++++++++++++++++++++++++++++++++++++++++++++- src/uibuttons.h | 12 ++++++++++-- 6 files changed, 80 insertions(+), 8 deletions(-) diff --git a/src/config.h b/src/config.h index f7da3efc..97681d48 100644 --- a/src/config.h +++ b/src/config.h @@ -217,7 +217,7 @@ class CConfig // Configuration for MiniDexed unsigned GetMIDIButtonSelect (void) const; unsigned GetMIDIButtonHome (void) const; - // Action type for Midi buttons: "click", "doubleclick", "longpress", "" + // Action type for Midi buttons: "click", "doubleclick", "longpress", "dec", "inc", "" const char *GetMIDIButtonActionPrev (void) const; const char *GetMIDIButtonActionNext (void) const; const char *GetMIDIButtonActionBack (void) const; @@ -232,7 +232,7 @@ class CConfig // Configuration for MiniDexed unsigned GetMIDIButtonTGUp (void) const; unsigned GetMIDIButtonTGDown (void) const; - // Action type for buttons: "click", "doubleclick", "longpress", "" + // Action type for buttons: "click", "doubleclick", "longpress", "dec", "inc", "" const char *GetMIDIButtonActionPgmUp (void) const; const char *GetMIDIButtonActionPgmDown (void) const; const char *GetMIDIButtonActionBankUp (void) const; diff --git a/src/midipin.cpp b/src/midipin.cpp index d03d73aa..b63b79b4 100644 --- a/src/midipin.cpp +++ b/src/midipin.cpp @@ -25,7 +25,8 @@ LOGMODULE ("midipin"); CMIDIPin::CMIDIPin (unsigned nPinNumber) : m_nPinNumber (nPinNumber), - m_nValue (HIGH) + m_nValue (HIGH), + m_nRawValue (MIDIPIN_CENTER) { } @@ -38,6 +39,11 @@ unsigned CMIDIPin::Read (void) return m_nValue; } +unsigned CMIDIPin::ReadRaw (void) +{ + return m_nRawValue; +} + void CMIDIPin::Write (unsigned nValue) { // Takes values in the MIDI controller range 0 to 127 @@ -50,6 +56,10 @@ void CMIDIPin::Write (unsigned nValue) // "off" m_nValue = HIGH; } + + // Save the raw value for INC and DEC + m_nRawValue = nValue; + return; } diff --git a/src/midipin.h b/src/midipin.h index 7fa3f1db..0764966d 100644 --- a/src/midipin.h +++ b/src/midipin.h @@ -32,6 +32,8 @@ #define MidiPinToCC(p) (((p)>=MIDI_PINS)?((p)-MIDI_PINS):0) #define isMidiPin(p) (((p)>=MIDI_PINS)?1:0) +#define MIDIPIN_CENTER 64 + class CMIDIPin { public: @@ -42,7 +44,10 @@ class CMIDIPin // Should be treated as a PULLED UP IO pin // i.e. treated as "active low" (LOW) when pressed. unsigned Read (void); - + + // returns the raw CC value + unsigned ReadRaw (void); + // MIDI CC values >=64 will set the MIDI pin to LOW ("on") // MIDI CC values <= 63 will set the MIDI pin to HIGH ("off") void Write (unsigned nValue); @@ -50,6 +55,7 @@ class CMIDIPin private: unsigned m_nPinNumber; unsigned m_nValue; + unsigned m_nRawValue; }; #endif diff --git a/src/minidexed.ini b/src/minidexed.ini index 57eac0f3..9465ae1f 100644 --- a/src/minidexed.ini +++ b/src/minidexed.ini @@ -116,7 +116,8 @@ LongPressTimeout=400 # MIDI Button Navigation # Specify MIDI CC to act as a button (0 = ununsed, so don't use CC 0) -# NB: Off < 64 < ON +# NB: Off < 64 < ON for longpress / click / doubleclick actions +# DEC < 64 < INC for dec / inc actions # CC channel: 0=OFF; 1-16 MIDI Ch; >16 Omni # If MIDIButtonNotes>0 then treat MIDIButton numbers as MIDI # Note numbers, triggered with NoteOn/NoteOff, not CC numbers. diff --git a/src/uibuttons.cpp b/src/uibuttons.cpp index 3df7f4ba..90e2e1d3 100644 --- a/src/uibuttons.cpp +++ b/src/uibuttons.cpp @@ -36,6 +36,8 @@ CUIButton::CUIButton (void) m_clickEvent(BtnEventNone), m_doubleClickEvent(BtnEventNone), m_longPressEvent(BtnEventNone), + m_decEvent(BtnEventNone), + m_incEvent(BtnEventNone), m_doubleClickTimeout(0), m_longPressTimeout(0) { @@ -101,6 +103,16 @@ void CUIButton::setLongPressEvent(BtnEvent longPressEvent) m_longPressEvent = longPressEvent; } +void CUIButton::setDecEvent(BtnEvent decEvent) +{ + m_decEvent = decEvent; +} + +void CUIButton::setIncEvent(BtnEvent incEvent) +{ + m_incEvent = incEvent; +} + unsigned CUIButton::getPinNumber(void) { return m_pinNumber; @@ -109,6 +121,7 @@ unsigned CUIButton::getPinNumber(void) CUIButton::BtnTrigger CUIButton::ReadTrigger (void) { unsigned value; + unsigned raw = 0; if (isMidiPin(m_pinNumber)) { if (!m_midipin) @@ -117,6 +130,7 @@ CUIButton::BtnTrigger CUIButton::ReadTrigger (void) return BtnTriggerNone; } value = m_midipin->Read(); + raw = m_midipin->ReadRaw(); } else { @@ -128,6 +142,21 @@ CUIButton::BtnTrigger CUIButton::ReadTrigger (void) value = m_pin->Read(); } + if (m_decEvent && raw < MIDIPIN_CENTER) + { + reset(); + // reset value to trigger only once + m_midipin->Write(MIDIPIN_CENTER); + return BtnTriggerDec; + } + else if (m_incEvent && MIDIPIN_CENTER < raw) + { + reset(); + // reset value to trigger only once + m_midipin->Write(MIDIPIN_CENTER); + return BtnTriggerInc; + } + if (m_timer < m_longPressTimeout) { m_timer++; @@ -230,6 +259,12 @@ CUIButton::BtnEvent CUIButton::Read (void) { else if (trigger == BtnTriggerLongPress) { return m_longPressEvent; } + else if (trigger == BtnTriggerDec) { + return m_decEvent; + } + else if (trigger == BtnTriggerInc) { + return m_incEvent; + } assert (trigger == BtnTriggerNone); @@ -250,6 +285,12 @@ CUIButton::BtnTrigger CUIButton::triggerTypeFromString(const char* triggerString else if (strcmp(triggerString, "longpress") == 0) { return BtnTriggerLongPress; } + else if (strcmp(triggerString, "dec") == 0) { + return BtnTriggerDec; + } + else if (strcmp(triggerString, "inc") == 0) { + return BtnTriggerInc; + } LOGERR("Invalid action: %s", triggerString); @@ -339,7 +380,7 @@ boolean CUIButtons::Initialize (void) // Each normal button can be assigned up to 3 actions: click, doubleclick and // longpress. We may not initialise all of the buttons. - // MIDI Buttons can be assigned to click, doubleclick, longpress + // MIDI buttons can be assigned to click, doubleclick, longpress, dec ,inc unsigned pins[MAX_BUTTONS] = { m_prevPin, m_nextPin, m_backPin, m_selectPin, m_homePin, m_pgmUpPin, m_pgmDownPin, m_BankUpPin, m_BankDownPin, m_TGUpPin, m_TGDownPin, m_prevMidi, m_nextMidi, m_backMidi, m_selectMidi, m_homeMidi, m_pgmUpMidi, m_pgmDownMidi, m_BankUpMidi, m_BankDownMidi, m_TGUpMidi, m_TGDownMidi @@ -450,6 +491,12 @@ void CUIButtons::bindButton(unsigned pinNumber, CUIButton::BtnTrigger trigger, C else if (trigger == CUIButton::BtnTriggerLongPress) { m_buttons[i].setLongPressEvent(event); } + else if (trigger == CUIButton::BtnTriggerDec) { + m_buttons[i].setDecEvent(event); + } + else if (trigger == CUIButton::BtnTriggerInc) { + m_buttons[i].setIncEvent(event); + } else { assert (trigger == CUIButton::BtnTriggerNone); } diff --git a/src/uibuttons.h b/src/uibuttons.h index 76febddf..16f7b626 100644 --- a/src/uibuttons.h +++ b/src/uibuttons.h @@ -41,7 +41,9 @@ class CUIButton BtnTriggerNone = 0, BtnTriggerClick = 1, BtnTriggerDoubleClick = 2, - BtnTriggerLongPress = 3 + BtnTriggerLongPress = 3, + BtnTriggerDec = 4, + BtnTriggerInc = 5, }; enum BtnEvent @@ -70,6 +72,8 @@ class CUIButton void setClickEvent(BtnEvent clickEvent); void setDoubleClickEvent(BtnEvent doubleClickEvent); void setLongPressEvent(BtnEvent longPressEvent); + void setDecEvent(BtnEvent decEvent); + void setIncEvent(BtnEvent incEvent); unsigned getPinNumber(void); @@ -100,7 +104,11 @@ class CUIButton BtnEvent m_doubleClickEvent; // Event to fire on long press BtnEvent m_longPressEvent; - + // Event to fire on dec + BtnEvent m_decEvent; + // Event to fire on inc + BtnEvent m_incEvent; + // Timeout for double click in tenths of a millisecond unsigned m_doubleClickTimeout; // Timeout for long press in tenths of a millisecond From 6d029f6c0e63f7d8bbc9a84082b2bc12398fd641 Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Fri, 8 Nov 2024 16:05:49 +0100 Subject: [PATCH 4/9] use std::min and std::max in Compressor --- src/effect_compressor.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/effect_compressor.cpp b/src/effect_compressor.cpp index d2aaec7c..1b35c26d 100644 --- a/src/effect_compressor.cpp +++ b/src/effect_compressor.cpp @@ -12,6 +12,7 @@ MIT License. use at your own risk. */ +#include #include #include #include "effect_compressor.h" @@ -203,7 +204,7 @@ void Compressor::setPreGain_dB(float32_t gain_dB) void Compressor::setCompressionRatio(float32_t cr) { - comp_ratio = max(0.001f, cr); //limit to positive values + comp_ratio = std::max(0.001f, cr); //limit to positive values updateThresholdAndCompRatioConstants(); } @@ -213,7 +214,7 @@ void Compressor::setAttack_sec(float32_t a, float32_t fs_Hz) attack_const = expf(-1.0f / (attack_sec * fs_Hz)); //expf() is much faster than exp() //also update the time constant for the envelope extraction - setLevelTimeConst_sec(min(attack_sec,release_sec) / 5.0, fs_Hz); //make the level time-constant one-fifth the gain time constants + setLevelTimeConst_sec(std::min(attack_sec,release_sec) / 5.0, fs_Hz); //make the level time-constant one-fifth the gain time constants } void Compressor::setRelease_sec(float32_t r, float32_t fs_Hz) @@ -222,13 +223,13 @@ void Compressor::setRelease_sec(float32_t r, float32_t fs_Hz) release_const = expf(-1.0f / (release_sec * fs_Hz)); //expf() is much faster than exp() //also update the time constant for the envelope extraction - setLevelTimeConst_sec(min(attack_sec,release_sec) / 5.0, fs_Hz); //make the level time-constant one-fifth the gain time constants + setLevelTimeConst_sec(std::min(attack_sec,release_sec) / 5.0, fs_Hz); //make the level time-constant one-fifth the gain time constants } void Compressor::setLevelTimeConst_sec(float32_t t_sec, float32_t fs_Hz) { const float32_t min_t_sec = 0.002f; //this is the minimum allowed value - level_lp_sec = max(min_t_sec,t_sec); + level_lp_sec = std::max(min_t_sec,t_sec); level_lp_const = expf(-1.0f / (level_lp_sec * fs_Hz)); //expf() is much faster than exp() } From 3cad3bce8e2f9e016a11c3463d1ba57ca8f6265d Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Tue, 26 Nov 2024 01:27:34 +0100 Subject: [PATCH 5/9] handle Portamento MIDI CC-s --- src/mididevice.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/mididevice.cpp b/src/mididevice.cpp index 216b4663..75a15e48 100644 --- a/src/mididevice.cpp +++ b/src/mididevice.cpp @@ -40,10 +40,12 @@ LOGMODULE ("mididevice"); #define MIDI_CC_MODULATION 1 #define MIDI_CC_BREATH_CONTROLLER 2 #define MIDI_CC_FOOT_PEDAL 4 + #define MIDI_CC_PORTAMENTO_TIME 5 #define MIDI_CC_VOLUME 7 #define MIDI_CC_PAN_POSITION 10 #define MIDI_CC_BANK_SELECT_LSB 32 #define MIDI_CC_BANK_SUSTAIN 64 + #define MIDI_CC_PORTAMENTO 65 #define MIDI_CC_RESONANCE 71 #define MIDI_CC_FREQUENCY_CUTOFF 74 #define MIDI_CC_REVERB_LEVEL 91 @@ -385,6 +387,10 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign m_pSynthesizer->ControllersRefresh (nTG); break; + case MIDI_CC_PORTAMENTO_TIME: + m_pSynthesizer->setPortamentoTime (maplong (pMessage[2], 0, 127, 0, 99), nTG); + break; + case MIDI_CC_BREATH_CONTROLLER: m_pSynthesizer->setBreathController (pMessage[2], nTG); m_pSynthesizer->ControllersRefresh (nTG); @@ -410,6 +416,10 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign m_pSynthesizer->setSustain (pMessage[2] >= 64, nTG); break; + case MIDI_CC_PORTAMENTO: + m_pSynthesizer->setPortamentoMode (pMessage[2] >= 64, nTG); + break; + case MIDI_CC_RESONANCE: m_pSynthesizer->SetResonance (maplong (pMessage[2], 0, 127, 0, 99), nTG); break; From 6bf9b5cdb02d15755efcc79d7d881c564a107023 Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Tue, 26 Nov 2024 23:30:10 +0100 Subject: [PATCH 6/9] update Synth_Dexed to 26d9cadb7f --- submod.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/submod.sh b/submod.sh index f9524a32..cad03200 100755 --- a/submod.sh +++ b/submod.sh @@ -20,5 +20,5 @@ cd - # # Use fixed master branch of Synth_Dexed cd Synth_Dexed/ -git checkout c9f5274 +git checkout 26d9cadb7f cd - From 69bcfbf49dd74b024a8ba665c3afe28368798fa5 Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Thu, 7 Nov 2024 14:19:26 +0100 Subject: [PATCH 7/9] add sostenuto --- src/mididevice.cpp | 5 +++++ src/minidexed.cpp | 9 +++++++++ src/minidexed.h | 1 + 3 files changed, 15 insertions(+) diff --git a/src/mididevice.cpp b/src/mididevice.cpp index 75a15e48..b33fd728 100644 --- a/src/mididevice.cpp +++ b/src/mididevice.cpp @@ -46,6 +46,7 @@ LOGMODULE ("mididevice"); #define MIDI_CC_BANK_SELECT_LSB 32 #define MIDI_CC_BANK_SUSTAIN 64 #define MIDI_CC_PORTAMENTO 65 + #define MIDI_CC_SOSTENUTO 66 #define MIDI_CC_RESONANCE 71 #define MIDI_CC_FREQUENCY_CUTOFF 74 #define MIDI_CC_REVERB_LEVEL 91 @@ -415,6 +416,10 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign case MIDI_CC_BANK_SUSTAIN: m_pSynthesizer->setSustain (pMessage[2] >= 64, nTG); break; + + case MIDI_CC_SOSTENUTO: + m_pSynthesizer->setSostenuto (pMessage[2] >= 64, nTG); + break; case MIDI_CC_PORTAMENTO: m_pSynthesizer->setPortamentoMode (pMessage[2] >= 64, nTG); diff --git a/src/minidexed.cpp b/src/minidexed.cpp index 2e45f46b..9e144998 100644 --- a/src/minidexed.cpp +++ b/src/minidexed.cpp @@ -830,6 +830,15 @@ void CMiniDexed::setSustain(bool sustain, unsigned nTG) m_pTG[nTG]->setSustain (sustain); } +void CMiniDexed::setSostenuto(bool sostenuto, unsigned nTG) +{ + assert (nTG < CConfig::AllToneGenerators); + if (nTG >= m_nToneGenerators) return; // Not an active TG + + assert (m_pTG[nTG]); + m_pTG[nTG]->setSostenuto (sostenuto); +} + void CMiniDexed::panic(uint8_t value, unsigned nTG) { assert (nTG < CConfig::AllToneGenerators); diff --git a/src/minidexed.h b/src/minidexed.h index 69dcf9ce..cc625349 100644 --- a/src/minidexed.h +++ b/src/minidexed.h @@ -84,6 +84,7 @@ class CMiniDexed void keydown (int16_t pitch, uint8_t velocity, unsigned nTG); void setSustain (bool sustain, unsigned nTG); + void setSostenuto (bool sostenuto, unsigned nTG); void panic (uint8_t value, unsigned nTG); void notesOff (uint8_t value, unsigned nTG); void setModWheel (uint8_t value, unsigned nTG); From 586783a928881c74e6c6c54efe70f0976d379960 Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Tue, 10 Dec 2024 04:02:58 +0100 Subject: [PATCH 8/9] Add TGParameterEnabled --- src/mididevice.cpp | 3 +++ src/minidexed.cpp | 15 +++++++++++++++ src/minidexed.h | 8 ++++++-- src/uimenu.cpp | 2 ++ 4 files changed, 26 insertions(+), 2 deletions(-) diff --git a/src/mididevice.cpp b/src/mididevice.cpp index b33fd728..a4f37e48 100644 --- a/src/mididevice.cpp +++ b/src/mididevice.cpp @@ -318,6 +318,9 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign bool bSystemCCChecked = false; for (unsigned nTG = 0; nTG < m_pConfig->GetToneGenerators() && !bSystemCCHandled; nTG++) { + if (m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, nTG) == 0) + continue; + if (ucStatus == MIDI_SYSTEM_EXCLUSIVE_BEGIN) { // MIDI SYSEX per MIDI channel diff --git a/src/minidexed.cpp b/src/minidexed.cpp index 9e144998..0beea890 100644 --- a/src/minidexed.cpp +++ b/src/minidexed.cpp @@ -98,6 +98,8 @@ CMiniDexed::CMiniDexed (CConfig *pConfig, CInterruptSystem *pInterrupt, m_nReverbSend[i] = 0; + m_bEnabled[i] = 1; + // Active the required number of active TGs if (i= m_nToneGenerators) return; // Not an active TG + assert (m_pTG[nTG]); + + m_bEnabled[nTG] = enabled != 0; + + m_UI.ParameterChanged (); +} + void CMiniDexed::setPitchbendRange(uint8_t range, uint8_t nTG) { range = constrain (range, 0, 12); diff --git a/src/minidexed.h b/src/minidexed.h index cc625349..72f43c7f 100644 --- a/src/minidexed.h +++ b/src/minidexed.h @@ -98,6 +98,7 @@ class CMiniDexed void SetReverbSend (unsigned nReverbSend, unsigned nTG); // 0 .. 127 void setMonoMode(uint8_t mono, uint8_t nTG); + void setEnabled(uint8_t enabled, uint8_t nTG); void setPitchbendRange(uint8_t range, uint8_t nTG); void setPitchbendStep(uint8_t step, uint8_t nTG); void setPortamentoMode(uint8_t mode, uint8_t nTG); @@ -190,7 +191,9 @@ class CMiniDexed TGParameterPortamentoGlissando, TGParameterPortamentoTime, TGParameterMonoMode, - + + TGParameterEnabled, + TGParameterMWRange, TGParameterMWPitch, TGParameterMWAmplitude, @@ -273,7 +276,8 @@ class CMiniDexed unsigned m_nPortamentoGlissando[CConfig::AllToneGenerators]; unsigned m_nPortamentoTime[CConfig::AllToneGenerators]; bool m_bMonoMode[CConfig::AllToneGenerators]; - + bool m_bEnabled[CConfig::AllToneGenerators]; + unsigned m_nModulationWheelRange[CConfig::AllToneGenerators]; unsigned m_nModulationWheelTarget[CConfig::AllToneGenerators]; unsigned m_nFootControlRange[CConfig::AllToneGenerators]; diff --git a/src/uimenu.cpp b/src/uimenu.cpp index efaf21f6..bcef4237 100644 --- a/src/uimenu.cpp +++ b/src/uimenu.cpp @@ -82,6 +82,7 @@ const CUIMenu::TMenuItem CUIMenu::s_TGMenu[] = {"Pitch Bend", MenuHandler, s_EditPitchBendMenu}, {"Portamento", MenuHandler, s_EditPortamentoMenu}, {"Poly/Mono", EditTGParameter, 0, CMiniDexed::TGParameterMonoMode}, + {"Enabled", EditTGParameter, 0, CMiniDexed::TGParameterEnabled}, {"Modulation", MenuHandler, s_ModulationMenu}, {"Channel", EditTGParameter, 0, CMiniDexed::TGParameterMIDIChannel}, {"Edit Voice", MenuHandler, s_EditVoiceMenu}, @@ -248,6 +249,7 @@ const CUIMenu::TParameter CUIMenu::s_TGParameter[CMiniDexed::TGParameterUnknown] {0, 1, 1, ToPortaGlissando}, // TGParameterPortamentoGlissando {0, 99, 1}, // TGParameterPortamentoTime {0, 1, 1, ToPolyMono}, // TGParameterMonoMode + {0, 1, 1, ToOnOff}, // TGParameterEnabled {0, 99, 1}, //MW Range {0, 1, 1, ToOnOff}, //MW Pitch {0, 1, 1, ToOnOff}, //MW Amp From ea104bac4c825b606e23d5a54d4801d570294a35 Mon Sep 17 00:00:00 2001 From: Gergo Koteles Date: Tue, 5 Nov 2024 16:51:23 +0100 Subject: [PATCH 9/9] add DAW Controller support for various Arturia controllers MiniLab 3 Keylab Essential KeyLab Essential mk3 KeyLab mkII based on https://github.com/PrzemekBarski/arturia-keylab-essential-mk3-programming-guide Tested on a Arturia MiniLab 3 and KeyLab mkII Keylab Essential and Keylab Essential mk3 is not tested --- src/Makefile | 3 +- src/config.cpp | 64 ++- src/config.h | 42 +- src/dawcontroller.cpp | 1071 +++++++++++++++++++++++++++++++++++++++++ src/dawcontroller.h | 52 ++ src/mididevice.cpp | 171 ++++--- src/mididevice.h | 57 +++ src/midikeyboard.cpp | 40 +- src/midikeyboard.h | 11 + src/minidexed.cpp | 40 ++ src/minidexed.h | 5 + src/minidexed.ini | 3 + src/uibuttons.cpp | 16 +- src/uimenu.cpp | 32 +- src/userinterface.cpp | 26 +- src/userinterface.h | 2 + 16 files changed, 1519 insertions(+), 116 deletions(-) create mode 100644 src/dawcontroller.cpp create mode 100644 src/dawcontroller.h diff --git a/src/Makefile b/src/Makefile index 540ae684..a8a8ccad 100644 --- a/src/Makefile +++ b/src/Makefile @@ -9,7 +9,8 @@ CMSIS_DIR = ../CMSIS_5/CMSIS OBJS = main.o kernel.o minidexed.o config.o userinterface.o uimenu.o \ mididevice.o midikeyboard.o serialmididevice.o pckeyboard.o \ sysexfileloader.o performanceconfig.o perftimer.o \ - effect_compressor.o effect_platervbstereo.o uibuttons.o midipin.o + effect_compressor.o effect_platervbstereo.o uibuttons.o midipin.o \ + dawcontroller.o OPTIMIZE = -O3 diff --git a/src/config.cpp b/src/config.cpp index 7f5d0404..1f789a5d 100644 --- a/src/config.cpp +++ b/src/config.cpp @@ -204,7 +204,9 @@ void CConfig::Load (void) m_MIDIButtonActionBankDown = m_Properties.GetString ("MIDIButtonActionBankDown", ""); m_MIDIButtonActionTGUp = m_Properties.GetString ("MIDIButtonActionTGUp", ""); m_MIDIButtonActionTGDown = m_Properties.GetString ("MIDIButtonActionTGDown", ""); - + + m_bDAWControllerEnabled = m_Properties.GetNumber ("DAWControllerEnabled", 0) != 0; + m_bEncoderEnabled = m_Properties.GetNumber ("EncoderEnabled", 0) != 0; m_nEncoderPinClock = m_Properties.GetNumber ("EncoderPinClock", 10); m_nEncoderPinData = m_Properties.GetNumber ("EncoderPinData", 9); @@ -666,6 +668,36 @@ unsigned CConfig::GetMIDIButtonHome (void) const return m_nMIDIButtonHome; } +void CConfig::SetMIDIButtonCh (unsigned v) +{ + m_nMIDIButtonCh = v; +} + +void CConfig::SetMIDIButtonPrev (unsigned v) +{ + m_nMIDIButtonPrev = v; +} + +void CConfig::SetMIDIButtonNext (unsigned v) +{ + m_nMIDIButtonNext = v; +} + +void CConfig::SetMIDIButtonBack (unsigned v) +{ + m_nMIDIButtonBack = v; +} + +void CConfig::SetMIDIButtonSelect (unsigned v) +{ + m_nMIDIButtonSelect = v; +} + +void CConfig::SetMIDIButtonHome (unsigned v) +{ + m_nMIDIButtonHome = v; +} + const char *CConfig::GetMIDIButtonActionPrev (void) const { return m_MIDIButtonActionPrev.c_str(); @@ -691,6 +723,31 @@ const char *CConfig::GetMIDIButtonActionHome (void) const return m_MIDIButtonActionHome.c_str(); } +void CConfig::SetMIDIButtonActionPrev (const char *v) +{ + m_MIDIButtonActionPrev = v; +} + +void CConfig::SetMIDIButtonActionNext (const char *v) +{ + m_MIDIButtonActionNext = v; +} + +void CConfig::SetMIDIButtonActionBack (const char *v) +{ + m_MIDIButtonActionBack = v; +} + +void CConfig::SetMIDIButtonActionSelect (const char *v) +{ + m_MIDIButtonActionSelect = v; +} + +void CConfig::SetMIDIButtonActionHome (const char *v) +{ + m_MIDIButtonActionHome = v; +} + unsigned CConfig::GetMIDIButtonPgmUp (void) const { return m_nMIDIButtonPgmUp; @@ -751,6 +808,11 @@ const char *CConfig::GetMIDIButtonActionTGDown (void) const return m_MIDIButtonActionTGDown.c_str(); } +bool CConfig::GetDAWControllerEnabled (void) const +{ + return m_bDAWControllerEnabled; +} + bool CConfig::GetEncoderEnabled (void) const { return m_bEncoderEnabled; diff --git a/src/config.h b/src/config.h index 97681d48..f72c32f8 100644 --- a/src/config.h +++ b/src/config.h @@ -217,6 +217,14 @@ class CConfig // Configuration for MiniDexed unsigned GetMIDIButtonSelect (void) const; unsigned GetMIDIButtonHome (void) const; + void SetMIDIButtonCh (unsigned v); + + void SetMIDIButtonPrev (unsigned v); + void SetMIDIButtonNext (unsigned v); + void SetMIDIButtonBack (unsigned v); + void SetMIDIButtonSelect (unsigned v); + void SetMIDIButtonHome (unsigned v); + // Action type for Midi buttons: "click", "doubleclick", "longpress", "dec", "inc", "" const char *GetMIDIButtonActionPrev (void) const; const char *GetMIDIButtonActionNext (void) const; @@ -224,6 +232,12 @@ class CConfig // Configuration for MiniDexed const char *GetMIDIButtonActionSelect (void) const; const char *GetMIDIButtonActionHome (void) const; + void SetMIDIButtonActionPrev (const char *v); + void SetMIDIButtonActionNext (const char *v); + void SetMIDIButtonActionBack (const char *v); + void SetMIDIButtonActionSelect (const char *v); + void SetMIDIButtonActionHome (const char *v); + // MIDI Button Program and TG Selection unsigned GetMIDIButtonPgmUp (void) const; unsigned GetMIDIButtonPgmDown (void) const; @@ -240,6 +254,8 @@ class CConfig // Configuration for MiniDexed const char *GetMIDIButtonActionTGUp (void) const; const char *GetMIDIButtonActionTGDown (void) const; + bool GetDAWControllerEnabled (void) const; + // KY-040 Rotary Encoder // GPIO pin numbers are chip numbers, not header positions bool GetEncoderEnabled (void) const; @@ -341,18 +357,6 @@ class CConfig // Configuration for MiniDexed std::string m_ButtonActionBankDown; std::string m_ButtonActionTGUp; std::string m_ButtonActionTGDown; - - std::string m_MIDIButtonActionPrev; - std::string m_MIDIButtonActionNext; - std::string m_MIDIButtonActionBack; - std::string m_MIDIButtonActionSelect; - std::string m_MIDIButtonActionHome; - std::string m_MIDIButtonActionPgmUp; - std::string m_MIDIButtonActionPgmDown; - std::string m_MIDIButtonActionBankUp; - std::string m_MIDIButtonActionBankDown; - std::string m_MIDIButtonActionTGUp; - std::string m_MIDIButtonActionTGDown; unsigned m_nDoubleClickTimeout; unsigned m_nLongPressTimeout; @@ -371,6 +375,20 @@ class CConfig // Configuration for MiniDexed unsigned m_nMIDIButtonTGUp; unsigned m_nMIDIButtonTGDown; + std::string m_MIDIButtonActionPrev; + std::string m_MIDIButtonActionNext; + std::string m_MIDIButtonActionBack; + std::string m_MIDIButtonActionSelect; + std::string m_MIDIButtonActionHome; + std::string m_MIDIButtonActionPgmUp; + std::string m_MIDIButtonActionPgmDown; + std::string m_MIDIButtonActionBankUp; + std::string m_MIDIButtonActionBankDown; + std::string m_MIDIButtonActionTGUp; + std::string m_MIDIButtonActionTGDown; + + bool m_bDAWControllerEnabled; + bool m_bEncoderEnabled; unsigned m_nEncoderPinClock; unsigned m_nEncoderPinData; diff --git a/src/dawcontroller.cpp b/src/dawcontroller.cpp new file mode 100644 index 00000000..65a12af5 --- /dev/null +++ b/src/dawcontroller.cpp @@ -0,0 +1,1071 @@ +// MiniDexed - Dexed FM synthesizer for bare metal Raspberry Pi +// Copyright (C) 2024 The MiniDexed Team +// +// 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 +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +#include + +#include "dawcontroller.h" +#include "midikeyboard.h" +#include "minidexed.h" + +#define LINELEN 18 + +#define MIDI_DAW_CHANGE 0b10000 +#define MIDI_DAW_VOICE 1 +#define MIDI_DAW_ALGORITHM 2 +#define MIDI_DAW_TOGGLE_MONO 3 +#define MIDI_DAW_TOGGLE_PORTA_GLISS 4 +#define MIDI_DAW_TOGGLE_TG 5 +#define MIDI_DAW_SELECT_TG 6 + + +static void ArturiaDisplayWrite (CMIDIKeyboard *pKeyboard, const u8 *pHdr, const unsigned nHdrSize, + unsigned nLineMaxLen, const char *pMenu, const char *pParam, const char *pValue, + const bool bArrowLeft, const bool bArrowRight) +{ + CString line1 (pParam); + CString line2; + + if (strlen (pMenu)) + { + size_t nLen = strlen (pParam) + strlen (pMenu); + if (nLen < nLineMaxLen) + { + for (unsigned i = nLineMaxLen - nLen; i > 0; i--) + { + line1.Append (" "); + } + } + + line1.Append (pMenu); + } + + if (bArrowLeft) + line2.Append("< "); + + line2.Append(pValue); + + if (bArrowRight) { + size_t nLen = strlen (line2) + 2; + if (nLen < nLineMaxLen) + { + for (unsigned i = nLineMaxLen - nLen; i > 0; i--) + { + line2.Append (" "); + } + } + + line2.Append(" >"); + } + + int nLine1Len = strlen (line1); + int nLine2Len = strlen (line2); + int nOffset = 0; + + uint8_t pLines[nHdrSize + nLine1Len + 2 + nLine2Len + 2]; + + memcpy (pLines, pHdr, nHdrSize); + nOffset += nHdrSize; + + memcpy (&pLines[nOffset], line1, nLine1Len); + nOffset += nLine1Len; + + pLines[nOffset++] = 0x00; + pLines[nOffset++] = 0x02; + + memcpy (&pLines[nOffset], line2, nLine2Len); + nOffset += nLine2Len; + + pLines[nOffset++] = 0x00; + pLines[nOffset++] = 0xF7; + + // block character (0xFF) is not supported over MIDI, change to 0x7f + for (unsigned i = 0; i < sizeof pLines; ++i) + if (pLines[i] == 0xFF) + pLines[i] = 0x7F; + + pKeyboard->SendDebounce (pLines, nOffset, 0); +} + +enum ControlType +{ + CT_KNOB = 3, + CT_FADER, + CT_PAD, +}; + +static void ArturiaDisplayInfoWrite (CMIDIKeyboard *pKeyboard, const uint8_t pDisplayHdr[3], ControlType Type, u8 uValue, const char *pName, const char *pValue) +{ + const uint8_t pHdr[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, pDisplayHdr[0], pDisplayHdr[1], pDisplayHdr[2], 0x1F, Type, 0x02, uValue, 0x00, 0x00, 0x01}; + + int nLine1Len = strlen (pName); + int nLine2Len = strlen (pValue); + int nOffset = 0; + + uint8_t pLines[sizeof pHdr + nLine1Len + 2 + nLine2Len + 2]; + + memcpy (pLines, pHdr, sizeof pHdr); + nOffset += sizeof pHdr; + + memcpy (pLines + nOffset, pName, nLine1Len + 1); + nOffset += nLine1Len + 1; + + pLines[nOffset] = 0x02; + nOffset += 1; + + memcpy (pLines + nOffset, pValue, nLine2Len + 1); + nOffset += nLine2Len + 1; + + pLines[nOffset] = 0xf7; + nOffset += 1; + + pKeyboard->SendDebounce (pLines, nOffset, 0); +} + +static void ArturiaShowNewCCValue (CMIDIKeyboard *pKeyboard, const uint8_t pDisplayHdr[3], u8 ucCh, u8 ucCC, u8 ucValue) +{ + char line1[LINELEN]; + char line2[LINELEN]; + + switch (ucCC) + { + case MIDI_CC_PORTAMENTO_TIME: + snprintf(line2, LINELEN, "%ld%%", maplong(ucValue, 0, 127, 0, 99)); + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_KNOB, ucValue, "Portamento Time", line2); + break; + case MIDI_CC_VOLUME: + snprintf(line1, LINELEN, "Volume Ch %d", ucCh + 1); + snprintf(line2, LINELEN, "%ld%%", maplong(ucValue, 0, 127, 0, 100)); + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_FADER, ucValue, line1, line2); + break; + case MIDI_CC_FREQUENCY_CUTOFF: + snprintf(line2, LINELEN, "%ld%%", maplong(ucValue, 0, 127, 0, 99)); + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_KNOB, ucValue, "Cutoff", line2); + break; + case MIDI_CC_RESONANCE: + snprintf(line2, LINELEN, "%ld%%", maplong(ucValue, 0, 127, 0, 99)); + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_KNOB, ucValue, "Resonance", line2); + break; + case MIDI_CC_REVERB_LEVEL: + snprintf(line2, LINELEN, "%ld%%", maplong(ucValue, 0, 127, 0, 99)); + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_KNOB, ucValue, "Reverb", line2); + break; + case MIDI_CC_DETUNE_LEVEL: + snprintf(line2, LINELEN, "%ld", maplong(ucValue, 1, 127, -99, 99)); + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_KNOB, ucValue, "Detune", line2); + break; + case MIDI_CC_PAN_POSITION: + snprintf(line2, LINELEN, "%d", ucValue); + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_KNOB, ucValue, "Pan", line2); + break; + case MIDI_CC_BANK_SUSTAIN: + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_PAD, ucValue, "Sustain", ucValue > 64 ? "On" : "Off"); + break; + case MIDI_CC_PORTAMENTO: + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_PAD, ucValue, "Portamento", ucValue > 64 ? "On" : "Off"); + break; + case MIDI_CC_SOSTENUTO: + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_PAD, ucValue, "Sostenuto", ucValue > 64 ? "On" : "Off"); + break; + case MIDI_CC_ALL_SOUND_OFF: + ArturiaDisplayInfoWrite (pKeyboard, pDisplayHdr, CT_PAD, ucValue, "All Sound Off", ""); + break; + } +} + +class CDAWConnection +{ +public: + virtual void DisplayWrite (const char *pMenu, const char *pParam, + const char *pValue, bool bArrowDown, bool bArrowUp) = 0; + virtual void UpdateState () = 0; + virtual void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) = 0; + virtual ~CDAWConnection (void) = default; +}; + +struct CColor +{ + uint8_t r; + uint8_t g; + uint8_t b; +}; + +static CColor padColors[8] = { + {0x3F, 0x3F, 0x11}, + {0x11, 0x11, 0x3F}, + {0x3F, 0x11, 0x3F}, + {0x11, 0x3F, 0x11}, + {0x3F, 0x11, 0x11}, + {0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00}, +}; + +static CColor altPadColors[8] = { + {0x3F, 0x3F, 0x11}, + {0x11, 0x21, 0x3F}, + {0x3F, 0x11, 0x3F}, + {0x11, 0x3F, 0x11}, + {0x3F, 0x11, 0x11}, + {0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00}, +}; + +static CColor chColors[CMIDIDevice::TChannel::Disabled + 1] = { + {0x7F, 0x00, 0x00}, // 1 + {0x7F, 0x40, 0x00}, // 2 + {0x7F, 0x40, 0x40}, // 3 + {0x7F, 0x40, 0x7F}, // 4 + {0x7F, 0x7F, 0x00}, // 5 + {0x7F, 0x7F, 0x40}, // 6 + {0x7F, 0x7F, 0x7F}, // 7 + {0x40, 0x00, 0x40}, // 8 + {0x40, 0x40, 0x00}, // 9 + {0x40, 0x40, 0x40}, // 10 + {0x40, 0x40, 0x7F}, // 11 + {0x40, 0x7F, 0x00}, // 12 + {0x40, 0x7F, 0x40}, // 13 + {0x40, 0x7F, 0x7F}, // 14 + {0x00, 0x00, 0x40}, // 15 + {0x00, 0x40, 0x00}, // 16 + {0x7F, 0x7F, 0x7F}, // Omni + {0x00, 0x00, 0x00}, // Disabled +}; + +class CMiniLab3DawConnection : public CDAWConnection +{ +public: + CMiniLab3DawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI); + void DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) override; + void UpdateState () override; + void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) override; +private: + enum TPadID { + MonoPad = 0, + PortamentoPad = 1, + SostenutoPad = 2, + SustainPad = 3, + SoundOffPad = 4, + TBDPad6 = 5, + TBDPad7 = 6, + ATPad = 7, + }; + enum TBankID { + BankA = 0x34, + BankB = 0x44, + }; + + void UpdateEncoder (uint8_t ucEncID, uint8_t ucValue); + void UpdateTGColor (uint8_t nTG); + void UpdateMonoColor (); + void UpdatePortamentoColor (); + void UpdateATColor (u8 ucAT); + void UpdateVolumeFaders (); + + void SetPadColor (TBankID BankID, TPadID PadID, u8 state); + void SetPadColor (TBankID BankID, TPadID PadID, u8 state, u8 state2); + void SetPadColor (TBankID BankID, TPadID PadID, CColor color, u8 state); + void SetPadColor (TBankID BankID, TPadID PadID, CColor color); + + void SetChannelAT (u8 ucValue); + void SetVoice (u8 ucChannel, u8 ucVoice); + void SetAlgorithm (u8 ucChannel, u8 ucAlgorithm); + void ToggleMonoMode (u8 ucChannel); + void TogglePortamentoGlisssando (u8 ucChannel); + void ToggleTG (u8 ucTG); + void SelectTG (u8 ucTG); + + CMiniDexed *m_pSynthesizer; + CMIDIKeyboard *m_pKeyboard; + CConfig *m_pConfig; + + u8 m_ucFirstTG = 0; + + const uint8_t m_pEncoder[3] = {0x04, 0x02, 0x60}; + TMIDIRoute m_pRouteMap[55] = { + {0, 0, MIDI_CONTROL_CHANGE, 14, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader1 + {0, 0, MIDI_CONTROL_CHANGE, 15, 0xFF, 1, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader2 + {0, 0, MIDI_CONTROL_CHANGE, 30, 0xFF, 2, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader3 + {0, 0, MIDI_CONTROL_CHANGE, 31, 0xFF, 3, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader4 + + {0, 0, MIDI_CONTROL_CHANGE, 86, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_FREQUENCY_CUTOFF, 0xFF}, // Knob1 + {0, 0, MIDI_CONTROL_CHANGE, 87, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_RESONANCE, 0xFF}, // Knob2 + {0, 0, MIDI_CONTROL_CHANGE, 89, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_REVERB_LEVEL, 0xFF}, // Knob3 + {0, 0, MIDI_CONTROL_CHANGE, 90, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_DETUNE_LEVEL, 0xFF}, // Knob4 + {0, 0, MIDI_CONTROL_CHANGE, 110, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PORTAMENTO_TIME, 0xFF}, // Knob5 + {0, 0, MIDI_CONTROL_CHANGE, 111, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_VOICE, 0xFF}, // Knob6 + {0, 0, MIDI_CONTROL_CHANGE, 116, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_ALGORITHM, 0xFF}, // Knob7 + {0, 0, MIDI_CONTROL_CHANGE, 117, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob8 + + {0, 9, MIDI_NOTE_ON, 36, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_MONO, 0x7F}, // BankA Pad1 + {0, 9, MIDI_NOTE_OFF, 36, 0xFF, .bSkip=true}, + + {0, 9, MIDI_NOTE_ON, 37, 0xFF, .bSkip=true}, // BankA Pad2 + {0, 9, MIDI_NOTE_OFF, 37, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PORTAMENTO, 0x7F, .bToggle=true, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 37, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_PORTA_GLISS, 0x7F, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 38, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_SOSTENUTO, 0x7F, .bToggle=true}, // BankA Pad3 + {0, 9, MIDI_NOTE_OFF, 38, 0xFF, .bSkip=true}, + + {0, 9, MIDI_NOTE_ON, 39, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_BANK_SUSTAIN, 0x7F, .bToggle=true}, // BankA Pad4 + {0, 9, MIDI_NOTE_OFF, 39, 0xFF, .bSkip=true}, + + {0, 9, MIDI_NOTE_ON, 40, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_ALL_SOUND_OFF, 0x7F}, // BankA Pad5 + {0, 9, MIDI_NOTE_OFF, 40, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_ALL_SOUND_OFF, 0x00}, + + {0, 9, MIDI_NOTE_ON, 41, 0xFF, .bSkip=true}, // BankA Pad6 + {0, 9, MIDI_NOTE_OFF, 41, 0xFF, .bSkip=true}, + + {0, 9, MIDI_NOTE_ON, 42, 0xFF, .bSkip=true}, // BankA Pad7 + {0, 9, MIDI_NOTE_OFF, 42, 0xFF, .bSkip=true}, + + {0, 9, MIDI_NOTE_ON, 43, 0xFF, .bSkip=true}, // BankA Pad8 + {0, 9, MIDI_NOTE_OFF, 43, 0xFF, 0, MIDI_CHANNEL_AFTERTOUCH, 0x00, 0xFF}, + {0, 9, MIDI_AFTERTOUCH, 43, 0xFF, 0, MIDI_CHANNEL_AFTERTOUCH, TMIDIRoute::P2, 0xFF}, + + {0, 9, MIDI_NOTE_ON, 44, 0xFF, .bSkip=true}, // BankB Pad1 + {0, 9, MIDI_NOTE_OFF, 44, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 0, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 44, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 0, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 45, 0xFF, .bSkip=true}, // BankB Pad2 + {0, 9, MIDI_NOTE_OFF, 45, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 1, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 45, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 1, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 46, 0xFF, .bSkip=true}, // BankB Pad3 + {0, 9, MIDI_NOTE_OFF, 46, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 2, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 46, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 2, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 47, 0xFF, .bSkip=true}, // BankB Pad4 + {0, 9, MIDI_NOTE_OFF, 47, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 3, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 47, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 3, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 48, 0xFF, .bSkip=true}, // BankB Pad5 + {0, 9, MIDI_NOTE_OFF, 48, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 4, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 48, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 4, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 49, 0xFF, .bSkip=true}, // BankB Pad6 + {0, 9, MIDI_NOTE_OFF, 49, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 5, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 49, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 5, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 50, 0xFF, .bSkip=true}, // BankB Pad7 + {0, 9, MIDI_NOTE_OFF, 50, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 6, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 50, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 6, .bSkipHandled=true}, + + {0, 9, MIDI_NOTE_ON, 51, 0xFF, .bSkip=true}, // BankB Pad8 + {0, 9, MIDI_NOTE_OFF, 51, 0xFF, 0, MIDI_DAW_CHANGE, MIDI_DAW_TOGGLE_TG, 7, .bSkipHandled=true}, + {0, 9, MIDI_AFTERTOUCH, 51, 0x7F, 0, MIDI_DAW_CHANGE, MIDI_DAW_SELECT_TG, 7, .bSkipHandled=true}, + + {0xFF}, // Sentinel + }; +}; + +CMiniLab3DawConnection::CMiniLab3DawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI) + :m_pSynthesizer (pSynthesizer), m_pKeyboard (pKeyboard), m_pConfig (pConfig) +{ + static const uint8_t pInit[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x00, 0x40, 0x6A, 0x21, 0xF7}; + + m_pKeyboard->SetRouteMap (m_pRouteMap); + + m_pKeyboard->Send (pInit, sizeof pInit, 0); + DisplayWrite ("MiniDexed", "", "On MiniLab 3", 0, 0); + + SetPadColor (BankA, MonoPad, 0); + SetPadColor (BankA, PortamentoPad, 0); + SetPadColor (BankA, SostenutoPad, 0); + SetPadColor (BankA, SustainPad, 0); + SetPadColor (BankA, SoundOffPad, 0); + SetPadColor (BankA, TBDPad6, 0); + SetPadColor (BankA, TBDPad7, 0); + UpdateATColor (0); + + UpdateState (); + + pConfig->SetMIDIButtonCh (1); + pConfig->SetMIDIButtonPrev (28); + pConfig->SetMIDIButtonActionPrev("dec"); + pConfig->SetMIDIButtonNext (28); + pConfig->SetMIDIButtonActionNext("inc"); + pConfig->SetMIDIButtonBack (118); + pConfig->SetMIDIButtonActionBack("longpress"); + pConfig->SetMIDIButtonSelect (118); + pConfig->SetMIDIButtonActionSelect("click"); + pConfig->SetMIDIButtonHome (119); + pConfig->SetMIDIButtonActionHome("click"); + + pUI->InitButtonsWithConfig(pConfig); +} + +void CMiniLab3DawConnection::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) +{ + static const uint8_t pHdr[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x04, 0x02, 0x60, 0x1f, 0x07, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01}; + ArturiaDisplayWrite (m_pKeyboard, pHdr, sizeof pHdr, 18, pMenu, pParam, pValue, bArrowDown, bArrowUp); +} + +void CMiniLab3DawConnection::SetPadColor (TBankID BankID, TPadID PadID, u8 state) +{ + SetPadColor (BankID, PadID, padColors[PadID], state); +} + +void CMiniLab3DawConnection::SetPadColor (TBankID BankID, TPadID PadID, u8 state, u8 state2) +{ + SetPadColor (BankID, PadID, state2 ? altPadColors[PadID] : padColors[PadID], state); +} + +void CMiniLab3DawConnection::SetPadColor (TBankID BankID, TPadID PadID, CColor color, u8 state) +{ + if (state == 0) + { + color.r /= 32; + color.g /= 32; + color.b /= 32; + } + SetPadColor (BankID, PadID, color); +} + +void CMiniLab3DawConnection::SetPadColor (TBankID BankID, TPadID PadID, CColor color) +{ + const uint8_t pSetPadColor[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x02, 0x16, (uint8_t)(PadID + BankID), color.r, color.g, color.b, 0xF7}; + m_pKeyboard->Send (pSetPadColor, sizeof pSetPadColor, 0); +} + +void CMiniLab3DawConnection::UpdateEncoder (uint8_t ucEncID, uint8_t ucValue) +{ + uint8_t pUpdateEncoder[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x21, 0x10, 0x00, ucEncID+=7, 0x00, ucValue, 0xF7}; + m_pKeyboard->Send (pUpdateEncoder, sizeof pUpdateEncoder, 0); +} + +void CMiniLab3DawConnection::UpdateTGColor (uint8_t nTG) +{ + u8 ch = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterMIDIChannel, nTG); + u8 enabled = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, nTG); + SetPadColor (BankB, (TPadID)nTG, chColors[ch], enabled); +} + +void CMiniLab3DawConnection::UpdateMonoColor () +{ + SetPadColor (BankA, MonoPad, m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterMonoMode, m_ucFirstTG)); +} + +void CMiniLab3DawConnection::UpdatePortamentoColor () +{ + u8 mode = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterPortamentoMode, m_ucFirstTG); + u8 mode2 = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterPortamentoGlissando, m_ucFirstTG); + SetPadColor (BankA, PortamentoPad, mode, mode2); +} + +void CMiniLab3DawConnection::UpdateATColor (u8 ucAT) +{ + u8 c = ucAT ?: 1; + SetPadColor (BankA, ATPad, CColor {c, c, c}); +} + + +void CMiniLab3DawConnection::UpdateVolumeFaders () +{ + u8 chan_map[4] = { + CMIDIDevice::TChannel::Disabled, + CMIDIDevice::TChannel::Disabled, + CMIDIDevice::TChannel::Disabled, + CMIDIDevice::TChannel::Disabled, + }; + + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + { + int channel = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterMIDIChannel, i); + + if (channel == CMIDIDevice::ChannelUnknown || channel == CMIDIDevice::Disabled) + continue; + + if (channel == CMIDIDevice::OmniMode) + channel = 0; + + for (unsigned i = 0; i < sizeof chan_map; ++i) + { + if (chan_map[i] == channel) + break; + + if (chan_map[i] == CMIDIDevice::Disabled) { + chan_map[i] = channel; + break; + } + } + } + + for (unsigned i = 0; i < sizeof chan_map; ++i) + { + if (chan_map[i] == CMIDIDevice::Disabled) + m_pRouteMap[i].bSkip = true; + else { + m_pRouteMap[i].bSkip = false; + m_pRouteMap[i].ucDCh = chan_map[i]; + } + } +} + +void CMiniLab3DawConnection::UpdateState () +{ + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + if (m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, i)) { + u8 ucChannel = m_pKeyboard->GetChannel (i); + + if (ucChannel == CMIDIDevice::ChannelUnknown || ucChannel == CMIDIDevice::Disabled) + continue; + + if (ucChannel == CMIDIDevice::OmniMode) + ucChannel = 0; + + for (TMIDIRoute *r = m_pRouteMap; r->ucSCable != 0xFF; r++) + r->ucDCh = ucChannel; + + m_ucFirstTG = i; + + break; + } + + UpdateEncoder (0, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterCutoff, m_ucFirstTG), 0, 99, 0, 127)); + UpdateEncoder (1, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterResonance, m_ucFirstTG), 0, 99, 0, 127)); + UpdateEncoder (2, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterReverbSend, m_ucFirstTG), 0, 99, 0, 127)); + UpdateEncoder (3, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterMasterTune, m_ucFirstTG), -99, 99, 1, 127)); + UpdateEncoder (4, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterPortamentoTime, m_ucFirstTG), 0, 99, 0, 127)); + UpdateEncoder (5, m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterProgram, m_ucFirstTG)); + UpdateEncoder (6, maplong(m_pSynthesizer->GetVoiceParameter (DEXED_ALGORITHM, CMiniDexed::NoOP, m_ucFirstTG), 0, 31, 0, 127)); + UpdateEncoder (7, m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterPan, m_ucFirstTG)); + + UpdateMonoColor (); + // TODO change the MIDIRouteMap's value also + UpdatePortamentoColor (); + + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + UpdateTGColor (i); + + UpdateVolumeFaders (); +} + +void CMiniLab3DawConnection::MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) +{ + switch (ucType) + { + case MIDI_CONTROL_CHANGE: + ArturiaShowNewCCValue (m_pKeyboard, m_pEncoder, ucChannel, ucP1, ucP2); + + switch (ucP1) + { + case MIDI_CC_PORTAMENTO: + UpdatePortamentoColor (); + break; + case MIDI_CC_SOSTENUTO: + SetPadColor (BankA, SostenutoPad, ucP2); + break; + case MIDI_CC_BANK_SUSTAIN: + SetPadColor (BankA, SustainPad, ucP2); + break; + case MIDI_CC_ALL_SOUND_OFF: + SetPadColor (BankA, SoundOffPad, ucP2); + break; + } + break; + case MIDI_DAW_CHANGE: + switch (ucP1) + { + case MIDI_DAW_VOICE: + SetVoice (ucChannel, ucP2); + break; + case MIDI_DAW_ALGORITHM: + SetAlgorithm (ucChannel, ucP2); + break; + case MIDI_DAW_TOGGLE_MONO: + ToggleMonoMode (ucChannel); + break; + case MIDI_DAW_TOGGLE_PORTA_GLISS: + TogglePortamentoGlisssando (ucChannel); + break; + case MIDI_DAW_TOGGLE_TG: + ToggleTG (ucP2); + break; + case MIDI_DAW_SELECT_TG: + SelectTG (ucP2); + break; + } + break; + case MIDI_CHANNEL_AFTERTOUCH: + SetChannelAT (ucP1); + break; + } +} + +void CMiniLab3DawConnection::SetChannelAT (u8 ucValue) +{ + char line2[LINELEN]; + snprintf(line2, LINELEN, "%d", ucValue); + + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_PAD, ucValue, "Channel AT", line2); + + UpdateATColor (ucValue); +} + +void CMiniLab3DawConnection::SetVoice (u8 ucChannel, u8 ucVoice) +{ + std::string line2; + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + { + if (m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, i) == 0 || + (m_pKeyboard->GetChannel (i) != ucChannel && m_pKeyboard->GetChannel (i) != CMIDIDevice::OmniMode)) + continue; + m_pSynthesizer->ProgramChange (ucVoice, i); + if (line2.length() == 0) { + std::string sVoiceName = m_pSynthesizer->GetVoiceName (i); + if (sVoiceName.length() > 0) + line2 = std::to_string (ucVoice + 1) + "=" + sVoiceName; + } + } + + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_KNOB, ucVoice, "Voice", line2.c_str()); +} + +void CMiniLab3DawConnection::SetAlgorithm (u8 ucChannel, u8 ucAlgorithm) +{ + char line2[LINELEN]; + u8 algorithm = maplong (ucAlgorithm, 0, 127, 0, 31); + + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + { + if (m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, i) == 0 || + (m_pKeyboard->GetChannel (i) != ucChannel && m_pKeyboard->GetChannel (i) != CMIDIDevice::OmniMode)) + continue; + m_pSynthesizer->SetVoiceParameter (DEXED_ALGORITHM, algorithm, CMiniDexed::NoOP, i); + } + + snprintf(line2, LINELEN, "%d", algorithm + 1); + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_KNOB, ucAlgorithm, "Algorithm", line2); +} + +void CMiniLab3DawConnection::ToggleMonoMode (u8 ucChannel) +{ + u8 ucValue = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterMonoMode, m_ucFirstTG) ? 0x00 : 0x7F; + + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + { + if (m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, i) == 0 || + (m_pKeyboard->GetChannel (i) != ucChannel && m_pKeyboard->GetChannel (i) != CMIDIDevice::OmniMode)) + continue; + m_pSynthesizer->setMonoMode (ucValue, i); + } + + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_PAD, ucValue, "Mono Mode", ucValue > 64 ? "On" : "Off"); + UpdateMonoColor (); +} + +void CMiniLab3DawConnection::TogglePortamentoGlisssando (u8 ucChannel) +{ + u8 ucValue = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterPortamentoGlissando, m_ucFirstTG) ? 0x00 : 0x7F; + + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + { + if (m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, i) == 0 && + (m_pKeyboard->GetChannel (i) != ucChannel && m_pKeyboard->GetChannel (i) != CMIDIDevice::OmniMode)) + continue; + m_pSynthesizer->setPortamentoGlissando (ucValue, i); + } + + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_PAD, ucValue, "Porta Gliss", ucValue > 64 ? "On" : "Off"); + UpdatePortamentoColor (); +} + +void CMiniLab3DawConnection::ToggleTG (u8 ucTG) +{ + char line1[LINELEN]; + + u8 value = m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, ucTG) ? 0x00 : 0x7F; + + m_pSynthesizer->setEnabled (value, ucTG); + m_pSynthesizer->panic (value, ucTG); + + snprintf(line1, LINELEN, "TG %d", ucTG + 1); + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_PAD, value, line1, value > 64 ? "On" : "Off"); + UpdateTGColor (ucTG); + UpdateState(); +} + +void CMiniLab3DawConnection::SelectTG (u8 ucTG) +{ + char line1[LINELEN]; + + u8 enabledOne = true; + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) + { + if (i == ucTG) + continue; + + if (m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterEnabled, i)) { + enabledOne = false; + break; + } + } + + if (enabledOne) { + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) { + m_pSynthesizer->setEnabled (true, i); + UpdateTGColor (i); + } + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_PAD, 0x7F, "TG All", "On"); + } else { + for (unsigned i = 0; i < m_pConfig->GetToneGenerators(); ++i) { + if (i == ucTG) { + m_pSynthesizer->setEnabled (true, i); + } else { + m_pSynthesizer->setEnabled (false, i); + m_pSynthesizer->panic (false, ucTG); + } + UpdateTGColor (i); + } + snprintf(line1, LINELEN, "TG %d", ucTG + 1); + ArturiaDisplayInfoWrite (m_pKeyboard, m_pEncoder, CT_PAD, 0x7F, line1, "Selected"); + } + UpdateState(); +} + +class CKeyLabEs3DawConnection : public CDAWConnection +{ +public: + CKeyLabEs3DawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI); + void DisplayWrite ( const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) override; + void UpdateState () override; + void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) override; +private: + void UpdateEncoder (uint8_t ucEncID, uint8_t ucValue); + + CMiniDexed *m_pSynthesizer; + CMIDIKeyboard *m_pKeyboard; + const uint8_t m_pEncoder[3] = {0x04, 0x01, 0x60}; + TMIDIRoute m_pRouteMap[16] = { + {0, 0, MIDI_CONTROL_CHANGE, 105, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader1 + {0, 0, MIDI_CONTROL_CHANGE, 106, 0xFF, 1, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader2 + {0, 0, MIDI_CONTROL_CHANGE, 107, 0xFF, 2, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader3 + {0, 0, MIDI_CONTROL_CHANGE, 108, 0xFF, 3, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader4 + {0, 0, MIDI_CONTROL_CHANGE, 109, 0xFF, 4, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader5 + {0, 0, MIDI_CONTROL_CHANGE, 110, 0xFF, 5, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader6 + {0, 0, MIDI_CONTROL_CHANGE, 111, 0xFF, 6, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader7 + {0, 0, MIDI_CONTROL_CHANGE, 112, 0xFF, 7, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader8 + {0, 0, MIDI_CONTROL_CHANGE, 113, 0xFF, 8, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader9 + {0, 0, MIDI_CONTROL_CHANGE, 96, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_FREQUENCY_CUTOFF, 0xFF}, // Knob1 + {0, 0, MIDI_CONTROL_CHANGE, 97, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_RESONANCE, 0xFF}, // Knob2 + {0, 0, MIDI_CONTROL_CHANGE, 98, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_REVERB_LEVEL, 0xFF}, // Knob3 + {0, 0, MIDI_CONTROL_CHANGE, 99, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_DETUNE_LEVEL, 0xFF}, // Knob4 + {0, 0, MIDI_CONTROL_CHANGE, 100, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob5 + {0, 0, MIDI_CONTROL_CHANGE, 101, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PORTAMENTO_TIME, 0xFF}, // Knob6 + // {0, 0, MIDI_CONTROL_CHANGE, 102, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_DETUNE_LEVEL, 0xFF}, // Knob7 + // {0, 0, MIDI_CONTROL_CHANGE, 103, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob8 + // {0, 0, MIDI_CONTROL_CHANGE, 104, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob9 + {0xFF}, // Sentinel + }; +}; + +CKeyLabEs3DawConnection::CKeyLabEs3DawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI) + :m_pSynthesizer (pSynthesizer), m_pKeyboard (pKeyboard) +{ + static const uint8_t pInit[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x00, 0x40, 0x6A, 0x21, 0xF7}; + + m_pKeyboard->SetRouteMap (m_pRouteMap); + + m_pKeyboard->Send (pInit, sizeof pInit, 0); + DisplayWrite ("MiniDexed", "", "On KeyLab 3 Essential", 0, 0); + + UpdateState (); + + pConfig->SetMIDIButtonCh (1); + pConfig->SetMIDIButtonPrev (116); + pConfig->SetMIDIButtonActionPrev("dec"); + pConfig->SetMIDIButtonNext (116); + pConfig->SetMIDIButtonActionNext("inc"); + pConfig->SetMIDIButtonBack (117); + pConfig->SetMIDIButtonActionBack("longpress"); + pConfig->SetMIDIButtonSelect (117); + pConfig->SetMIDIButtonActionSelect("click"); + pConfig->SetMIDIButtonHome (44); + pConfig->SetMIDIButtonActionHome("click"); + + pUI->InitButtonsWithConfig(pConfig); +} + +void CKeyLabEs3DawConnection::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) +{ + static const uint8_t pHdr[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x04, 0x01, 0x60, 0x12, 0x01}; + ArturiaDisplayWrite (m_pKeyboard, pHdr, sizeof pHdr, 18, pMenu, pParam, pValue, bArrowDown, bArrowUp); +} + +void CKeyLabEs3DawConnection::UpdateEncoder (uint8_t ucEncID, uint8_t ucValue) +{ + uint8_t pUpdateEncoder[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x0F, 0x40, ucEncID += 3, ucValue, 0xF7}; + m_pKeyboard->Send (pUpdateEncoder, sizeof pUpdateEncoder, 0); +} + +void CKeyLabEs3DawConnection::UpdateState () +{ + UpdateEncoder (0, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterCutoff, 0), 0, 99, 0, 127)); + UpdateEncoder (1, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterResonance, 0), 0, 99, 0, 127)); + UpdateEncoder (2, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterReverbSend, 0), 0, 99, 0, 127)); + UpdateEncoder (3, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterMasterTune, 0), -99, 99, 1, 127)); + UpdateEncoder (4, m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterPan, 0)); + UpdateEncoder (5, maplong(m_pSynthesizer->GetTGParameter (CMiniDexed::TGParameterPortamentoTime, 0), 0, 99, 0, 127)); +} + +void CKeyLabEs3DawConnection::MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) +{ + switch (ucType) + { + case MIDI_CONTROL_CHANGE: + ArturiaShowNewCCValue (m_pKeyboard, m_pEncoder, ucChannel, ucP1, ucP2); + } +} + +class CKeyLab2DawConnection : public CDAWConnection +{ +public: + CKeyLab2DawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI); + void DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) override; + void UpdateState () override; + void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) override; +private: + CMiniDexed *m_pSynthesizer; + CMIDIKeyboard *m_pKeyboard; + TMIDIRoute m_pRouteMap[13] = { + {1, 0, MIDI_PITCH_BEND, 0xFF, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader1 + {1, 1, MIDI_PITCH_BEND, 0xFF, 0xFF, 1, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader2 + {1, 2, MIDI_PITCH_BEND, 0xFF, 0xFF, 2, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader3 + {1, 3, MIDI_PITCH_BEND, 0xFF, 0xFF, 3, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader4 + {1, 4, MIDI_PITCH_BEND, 0xFF, 0xFF, 4, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader5 + {1, 5, MIDI_PITCH_BEND, 0xFF, 0xFF, 5, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader6 + {1, 6, MIDI_PITCH_BEND, 0xFF, 0xFF, 6, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader7 + {1, 7, MIDI_PITCH_BEND, 0xFF, 0xFF, 7, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader8 + {1, 8, MIDI_PITCH_BEND, 0xFF, 0xFF, 8, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader9 + /*{0, 0, MIDI_CONTROL_CHANGE, 96, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_FREQUENCY_CUTOFF, 0xFF}, // Knob1 + {0, 0, MIDI_CONTROL_CHANGE, 97, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_RESONANCE, 0xFF}, // Knob2 + {0, 0, MIDI_CONTROL_CHANGE, 98, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_REVERB_LEVEL, 0xFF}, // Knob3 + {0, 0, MIDI_CONTROL_CHANGE, 99, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_DETUNE_LEVEL, 0xFF}, // Knob4 + {0, 0, MIDI_CONTROL_CHANGE, 100, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob5 + {0, 0, MIDI_CONTROL_CHANGE, 101, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PORTAMENTO_TIME, 0xFF}, // Knob6 + // {0, 0, MIDI_CONTROL_CHANGE, 102, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_DETUNE_LEVEL, 0xFF}, // Knob7 + // {0, 0, MIDI_CONTROL_CHANGE, 103, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob8 + // {0, 0, MIDI_CONTROL_CHANGE, 104, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob9*/ + {1, 0, MIDI_CONTROL_CHANGE, 0x3C, 0xFF, 0, MIDI_CONTROL_CHANGE, 60, 0xFF}, // Main rotate + {1, 0, MIDI_NOTE_ON, 0x54, 0xFF, 0, MIDI_CONTROL_CHANGE, 63, 0xFF}, // Main click + {1, 0xFF, 0xFF, 0xFF, 0xFF, .bSkip = true}, // skip other messages on DAW cable + {0xFF}, // Sentinel + }; +}; + +CKeyLab2DawConnection::CKeyLab2DawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI) + :m_pSynthesizer (pSynthesizer), m_pKeyboard (pKeyboard) +{ + static const uint8_t pInit[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x00, 0x40, 0x52, 0x00, 0xF7}; + m_pKeyboard->SetRouteMap (m_pRouteMap); + + m_pKeyboard->Send (pInit, sizeof pInit, 0); + DisplayWrite ("MiniDexed", "", "On KeyLab 2", 0, 0); + + UpdateState (); + + pConfig->SetMIDIButtonCh (1); + pConfig->SetMIDIButtonPrev (60); + pConfig->SetMIDIButtonActionPrev("inc"); + pConfig->SetMIDIButtonNext (60); + pConfig->SetMIDIButtonActionNext("dec"); + pConfig->SetMIDIButtonBack (63); + pConfig->SetMIDIButtonActionBack("longpress"); + pConfig->SetMIDIButtonSelect (63); + pConfig->SetMIDIButtonActionSelect("click"); + pConfig->SetMIDIButtonHome (63); + pConfig->SetMIDIButtonActionHome("doubleclick"); + + pUI->InitButtonsWithConfig(pConfig); +} + +void CKeyLab2DawConnection::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) +{ + static const uint8_t pHdr[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x04, 0x00, 0x60, 0x01}; + ArturiaDisplayWrite (m_pKeyboard, pHdr, sizeof pHdr, 16, pMenu, pParam, pValue, bArrowDown, bArrowUp); +} + +void CKeyLab2DawConnection::UpdateState () +{ +} + +void CKeyLab2DawConnection::MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) +{ + //static const uint8_t pEncoder[] = {0x04, 0x01, 0x60}; + //ArturiaShowNewCCValue (pKeyboard, pEncoder, ucCh, ucCC, ucValue); +} + +class CKeyLabEsDawConnection : public CDAWConnection +{ +public: + CKeyLabEsDawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI); + void DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) override; + void UpdateState () override; + void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) override; +private: + CMiniDexed *m_pSynthesizer; + CMIDIKeyboard *m_pKeyboard; + TMIDIRoute m_pRouteMap[13] = { + {1, 0, MIDI_PITCH_BEND, 0xFF, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader1 + {1, 1, MIDI_PITCH_BEND, 0xFF, 0xFF, 1, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader2 + {1, 2, MIDI_PITCH_BEND, 0xFF, 0xFF, 2, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader3 + {1, 3, MIDI_PITCH_BEND, 0xFF, 0xFF, 3, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader4 + {1, 4, MIDI_PITCH_BEND, 0xFF, 0xFF, 4, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader5 + {1, 5, MIDI_PITCH_BEND, 0xFF, 0xFF, 5, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader6 + {1, 6, MIDI_PITCH_BEND, 0xFF, 0xFF, 6, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader7 + {1, 7, MIDI_PITCH_BEND, 0xFF, 0xFF, 7, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader8 + {1, 8, MIDI_PITCH_BEND, 0xFF, 0xFF, 8, MIDI_CONTROL_CHANGE, MIDI_CC_VOLUME, 0xFF}, // Fader9 + /*{0, 0, MIDI_CONTROL_CHANGE, 96, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_FREQUENCY_CUTOFF, 0xFF}, // Knob1 + {0, 0, MIDI_CONTROL_CHANGE, 97, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_RESONANCE, 0xFF}, // Knob2 + {0, 0, MIDI_CONTROL_CHANGE, 98, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_REVERB_LEVEL, 0xFF}, // Knob3 + {0, 0, MIDI_CONTROL_CHANGE, 99, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_DETUNE_LEVEL, 0xFF}, // Knob4 + {0, 0, MIDI_CONTROL_CHANGE, 100, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob5 + {0, 0, MIDI_CONTROL_CHANGE, 101, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PORTAMENTO_TIME, 0xFF}, // Knob6 + // {0, 0, MIDI_CONTROL_CHANGE, 102, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_DETUNE_LEVEL, 0xFF}, // Knob7 + // {0, 0, MIDI_CONTROL_CHANGE, 103, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob8 + // {0, 0, MIDI_CONTROL_CHANGE, 104, 0xFF, 0, MIDI_CONTROL_CHANGE, MIDI_CC_PAN_POSITION, 0xFF}, // Knob9*/ + {1, 0, MIDI_CONTROL_CHANGE, 0x3C, 0xFF, 0, MIDI_CONTROL_CHANGE, 60, 0xFF}, // Main rotate + {1, 0, MIDI_NOTE_ON, 0x54, 0xFF, 0, MIDI_CONTROL_CHANGE, 63, 0xFF}, // Main click + {1, 0xFF, 0xFF, 0xFF, 0xFF, .bSkip = true}, // skip other messages on DAW cable + {0xFF}, // Sentinel + }; +}; + +CKeyLabEsDawConnection::CKeyLabEsDawConnection (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI) + :m_pSynthesizer (pSynthesizer), m_pKeyboard (pKeyboard) +{ + static const uint8_t pInit[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x00, 0x40, 0x51, 0x00, 0xF7}; // init DAW to Mackie mode + m_pKeyboard->SetRouteMap (m_pRouteMap); + + m_pKeyboard->Send (pInit, sizeof pInit, 0); + DisplayWrite ("MiniDexed", "", "On KeyLab Essential", 0, 0); + + UpdateState (); + + pConfig->SetMIDIButtonCh (1); + pConfig->SetMIDIButtonPrev (60); + pConfig->SetMIDIButtonActionPrev("inc"); + pConfig->SetMIDIButtonNext (60); + pConfig->SetMIDIButtonActionNext("dec"); + pConfig->SetMIDIButtonBack (63); + pConfig->SetMIDIButtonActionBack("longpress"); + pConfig->SetMIDIButtonSelect (63); + pConfig->SetMIDIButtonActionSelect("click"); + pConfig->SetMIDIButtonHome (63); + pConfig->SetMIDIButtonActionHome("doubleclick"); + + pUI->InitButtonsWithConfig(pConfig); +} + +void CKeyLabEsDawConnection::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, bool bArrowDown, bool bArrowUp) +{ + static const uint8_t pHdr[] = {0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x04, 0x00, 0x60, 0x01}; + ArturiaDisplayWrite (m_pKeyboard, pHdr, sizeof pHdr, 16, pMenu, pParam, pValue, bArrowDown, bArrowUp); +} + +void CKeyLabEsDawConnection::UpdateState () +{ +} + +void CKeyLabEsDawConnection::MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) +{ + //static const uint8_t pEncoder[] = {0x04, 0x01, 0x60}; + //ArturiaShowNewCCValue (pKeyboard, pEncoder, ucCh, ucCC, ucValue); +} + +CDAWController::CDAWController (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI) +: m_pSynthesizer (pSynthesizer), + m_pKeyboard (pKeyboard), + m_pConfig (pConfig), + m_pUI (pUI), + m_pDAWConnection (0) +{ +} + +CDAWController::~CDAWController (void) +{ + delete m_pDAWConnection; +} + +void CDAWController::OnConnect (void) +{ + static const uint8_t inquiry[] = {0xF0, 0x7E, 0x7F, 0x06, 0x01, 0xF7}; + + delete m_pDAWConnection; + m_pDAWConnection = 0; + + m_pKeyboard->Send (inquiry, sizeof inquiry, 0); +} + +void CDAWController::MIDISysexHandler (u8 *pPacket, unsigned nLength, unsigned nCable) +{ + static const uint8_t pMiniLab3[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x04, 0x04}; + static const uint8_t pKeyLabEs_49[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x52}; + static const uint8_t pKeyLabEs_61[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x54}; + static const uint8_t pKeyLabEs_88[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x58}; + static const uint8_t pKeyLab2_49[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x62}; + static const uint8_t pKeyLab2_61[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x64}; + static const uint8_t pKeyLab2_88[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x68}; + static const uint8_t pKeyLabEs3_49[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x72}; + static const uint8_t pKeyLabEs3_61[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x74}; + static const uint8_t pKeyLabEs3_88[] = {0xF0, 0x7E, 0x7F, 0x06, 0x02, 0x00, 0x20, 0x6B, 0x02, 0x00, 0x05, 0x78}; + + if (nLength > sizeof pMiniLab3 && memcmp (pPacket, pMiniLab3, sizeof pMiniLab3) == 0) + { + m_pDAWConnection = new CMiniLab3DawConnection (m_pSynthesizer, m_pKeyboard, m_pConfig, m_pUI); + } + else if (nLength > sizeof pKeyLabEs_49 && ( + memcmp (pPacket, pKeyLabEs_49, sizeof pKeyLabEs_49) == 0 || + memcmp (pPacket, pKeyLabEs_61, sizeof pKeyLabEs_61) == 0 || + memcmp (pPacket, pKeyLabEs_88, sizeof pKeyLabEs_88) == 0)) + { + m_pDAWConnection = new CKeyLabEsDawConnection (m_pSynthesizer, m_pKeyboard, m_pConfig, m_pUI); + } + else if (nLength > sizeof pKeyLab2_61 && ( + memcmp (pPacket, pKeyLab2_49, sizeof pKeyLab2_49) == 0 || + memcmp (pPacket, pKeyLab2_61, sizeof pKeyLab2_61) == 0 || + memcmp (pPacket, pKeyLab2_88, sizeof pKeyLab2_88) == 0)) + { + m_pDAWConnection = new CKeyLab2DawConnection (m_pSynthesizer, m_pKeyboard, m_pConfig, m_pUI); + } + else if (nLength > sizeof pKeyLabEs3_49 && ( + memcmp (pPacket, pKeyLabEs3_49, sizeof pKeyLabEs3_49) == 0 || + memcmp (pPacket, pKeyLabEs3_61, sizeof pKeyLabEs3_61) == 0 || + memcmp (pPacket, pKeyLabEs3_88, sizeof pKeyLabEs3_88) == 0)) + { + m_pDAWConnection = new CKeyLabEs3DawConnection (m_pSynthesizer, m_pKeyboard, m_pConfig, m_pUI); + } +} + +void CDAWController::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, + bool bArrowDown, bool bArrowUp) +{ + if (m_pDAWConnection) + m_pDAWConnection->DisplayWrite (pMenu, pParam, pValue, bArrowDown, bArrowUp); +} + +void CDAWController::UpdateState (void) +{ + if (m_pDAWConnection) + m_pDAWConnection->UpdateState (); +} + +void CDAWController::MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) +{ + if (m_pDAWConnection) + m_pDAWConnection->MIDIListener (ucCable, ucChannel, ucType, ucP1, ucP2); +} diff --git a/src/dawcontroller.h b/src/dawcontroller.h new file mode 100644 index 00000000..9e916ae4 --- /dev/null +++ b/src/dawcontroller.h @@ -0,0 +1,52 @@ +// MiniDexed - Dexed FM synthesizer for bare metal Raspberry Pi +// Copyright (C) 2024 The MiniDexed Team +// +// 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 +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +#ifndef _dawcontroller_h +#define _dawcontroller_h + +#include + +class CMIDIKeyboard; +class CMiniDexed; +class CDAWConnection; +class CConfig; +class CUserInterface; + +class CDAWController +{ +public: + CDAWController (CMiniDexed *pSynthesizer, CMIDIKeyboard *pKeyboard, CConfig *pConfig, CUserInterface *pUI); + ~CDAWController (void); + + void OnConnect (void); + void MIDISysexHandler (u8 *pPacket, unsigned nLength, unsigned nCable); + + void DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, + bool bArrowDown, bool bArrowUp); + + void UpdateState (void); + + void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2); + +private: + CMiniDexed *m_pSynthesizer; + CMIDIKeyboard *m_pKeyboard; + CConfig *m_pConfig; + CUserInterface *m_pUI; + CDAWConnection *m_pDAWConnection; +}; + +#endif diff --git a/src/mididevice.cpp b/src/mididevice.cpp index a4f37e48..4ce70d17 100644 --- a/src/mididevice.cpp +++ b/src/mididevice.cpp @@ -31,31 +31,6 @@ LOGMODULE ("mididevice"); -#define MIDI_NOTE_OFF 0b1000 -#define MIDI_NOTE_ON 0b1001 -#define MIDI_AFTERTOUCH 0b1010 // TODO -#define MIDI_CHANNEL_AFTERTOUCH 0b1101 // right now Synth_Dexed just manage Channel Aftertouch not Polyphonic AT -> 0b1010 -#define MIDI_CONTROL_CHANGE 0b1011 - #define MIDI_CC_BANK_SELECT_MSB 0 - #define MIDI_CC_MODULATION 1 - #define MIDI_CC_BREATH_CONTROLLER 2 - #define MIDI_CC_FOOT_PEDAL 4 - #define MIDI_CC_PORTAMENTO_TIME 5 - #define MIDI_CC_VOLUME 7 - #define MIDI_CC_PAN_POSITION 10 - #define MIDI_CC_BANK_SELECT_LSB 32 - #define MIDI_CC_BANK_SUSTAIN 64 - #define MIDI_CC_PORTAMENTO 65 - #define MIDI_CC_SOSTENUTO 66 - #define MIDI_CC_RESONANCE 71 - #define MIDI_CC_FREQUENCY_CUTOFF 74 - #define MIDI_CC_REVERB_LEVEL 91 - #define MIDI_CC_DETUNE_LEVEL 94 - #define MIDI_CC_ALL_SOUND_OFF 120 - #define MIDI_CC_ALL_NOTES_OFF 123 -#define MIDI_PROGRAM_CHANGE 0b1100 -#define MIDI_PITCH_BEND 0b1110 - // MIDI "System" level (i.e. all TG) custom CC maps // Note: Even if number of TGs is not 8, there are only 8 // available to be used in the mappings here. @@ -81,7 +56,8 @@ CMIDIDevice::TDeviceMap CMIDIDevice::s_DeviceMap; CMIDIDevice::CMIDIDevice (CMiniDexed *pSynthesizer, CConfig *pConfig, CUserInterface *pUI) : m_pSynthesizer (pSynthesizer), m_pConfig (pConfig), - m_pUI (pUI) + m_pUI (pUI), + m_pRouteMap () { for (unsigned nTG = 0; nTG < CConfig::AllToneGenerators; nTG++) { @@ -217,10 +193,21 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign m_MIDISpinLock.Acquire (); + u8 ucCable = nCable; u8 ucStatus = pMessage[0]; u8 ucChannel = ucStatus & 0x0F; u8 ucType = ucStatus >> 4; + u8 ucP1 = pMessage[1]; + u8 ucP2 = nLength >= 3 ? pMessage[2] : 0xFF; + bool bSkip = false; + + if (m_pRouteMap) + GetRoutedMIDI (m_pRouteMap, &ucCable, &ucChannel, &ucType, &ucP1, &ucP2, &bSkip); + if (bSkip) + { + // skip (and release mutex at the end) + } // GLOBAL MIDI SYSEX // // Master Volume is set using a MIDI SysEx message as follows: @@ -239,7 +226,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign // Need to scale the volume parameter to fit // a 14-bit value: 0..16383 // and then split into LSB/MSB. - if (nLength == 8 && + else if (nLength == 8 && pMessage[0] == MIDI_SYSTEM_EXCLUSIVE_BEGIN && pMessage[1] == 0x7F && pMessage[2] == 0x7F && @@ -268,13 +255,13 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign { if ((ucChannel == nPerfCh) || (nPerfCh == OmniMode)) { - if (pMessage[1] == MIDI_CC_BANK_SELECT_MSB) + if (ucP1 == MIDI_CC_BANK_SELECT_MSB) { - m_pSynthesizer->BankSelectMSBPerformance (pMessage[2]); + m_pSynthesizer->BankSelectMSBPerformance (ucP2); } - else if (pMessage[1] == MIDI_CC_BANK_SELECT_LSB) + else if (ucP1 == MIDI_CC_BANK_SELECT_LSB) { - m_pSynthesizer->BankSelectLSBPerformance (pMessage[2]); + m_pSynthesizer->BankSelectLSBPerformance (ucP2); } else { @@ -284,7 +271,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign } if (nLength == 3) { - m_pUI->UIMIDICmdHandler (ucChannel, ucStatus & 0xF0, pMessage[1], pMessage[2]); + m_pUI->UIMIDICmdHandler (ucChannel, ucType, ucP1, ucP2); } break; @@ -294,7 +281,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign { break; } - m_pUI->UIMIDICmdHandler (ucChannel, ucStatus & 0xF0, pMessage[1], pMessage[2]); + m_pUI->UIMIDICmdHandler (ucChannel, ucType, ucP1, ucP2); break; case MIDI_PROGRAM_CHANGE: @@ -306,7 +293,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign if ((ucChannel == nPerfCh) || (nPerfCh == OmniMode)) { //printf("Performance Select Channel %d\n", nPerfCh); - m_pSynthesizer->ProgramChangePerformance (pMessage[1]); + m_pSynthesizer->ProgramChangePerformance (ucP1); } } } @@ -344,17 +331,17 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign break; } - if (pMessage[2] > 0) + if (ucP2 > 0) { - if (pMessage[2] <= 127) + if (ucP2 <= 127) { - m_pSynthesizer->keydown (pMessage[1], - pMessage[2], nTG); + m_pSynthesizer->keydown (ucP1, + ucP2, nTG); } } else { - m_pSynthesizer->keyup (pMessage[1], nTG); + m_pSynthesizer->keyup (ucP1, nTG); } break; @@ -364,12 +351,12 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign break; } - m_pSynthesizer->keyup (pMessage[1], nTG); + m_pSynthesizer->keyup (ucP1, nTG); break; case MIDI_CHANNEL_AFTERTOUCH: - m_pSynthesizer->setAftertouch (pMessage[1], nTG); + m_pSynthesizer->setAftertouch (ucP1, nTG); m_pSynthesizer->ControllersRefresh (nTG); break; @@ -379,81 +366,81 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign break; } - switch (pMessage[1]) + switch (ucP1) { case MIDI_CC_MODULATION: - m_pSynthesizer->setModWheel (pMessage[2], nTG); + m_pSynthesizer->setModWheel (ucP2, nTG); m_pSynthesizer->ControllersRefresh (nTG); break; case MIDI_CC_FOOT_PEDAL: - m_pSynthesizer->setFootController (pMessage[2], nTG); + m_pSynthesizer->setFootController (ucP2, nTG); m_pSynthesizer->ControllersRefresh (nTG); break; case MIDI_CC_PORTAMENTO_TIME: - m_pSynthesizer->setPortamentoTime (maplong (pMessage[2], 0, 127, 0, 99), nTG); + m_pSynthesizer->setPortamentoTime (maplong (ucP2, 0, 127, 0, 99), nTG); break; case MIDI_CC_BREATH_CONTROLLER: - m_pSynthesizer->setBreathController (pMessage[2], nTG); + m_pSynthesizer->setBreathController (ucP2, nTG); m_pSynthesizer->ControllersRefresh (nTG); break; case MIDI_CC_VOLUME: - m_pSynthesizer->SetVolume (pMessage[2], nTG); + m_pSynthesizer->SetVolume (ucP2, nTG); break; case MIDI_CC_PAN_POSITION: - m_pSynthesizer->SetPan (pMessage[2], nTG); + m_pSynthesizer->SetPan (ucP2, nTG); break; case MIDI_CC_BANK_SELECT_MSB: - m_pSynthesizer->BankSelectMSB (pMessage[2], nTG); + m_pSynthesizer->BankSelectMSB (ucP2, nTG); break; case MIDI_CC_BANK_SELECT_LSB: - m_pSynthesizer->BankSelectLSB (pMessage[2], nTG); + m_pSynthesizer->BankSelectLSB (ucP2, nTG); break; case MIDI_CC_BANK_SUSTAIN: - m_pSynthesizer->setSustain (pMessage[2] >= 64, nTG); + m_pSynthesizer->setSustain (ucP2 >= 64, nTG); break; case MIDI_CC_SOSTENUTO: - m_pSynthesizer->setSostenuto (pMessage[2] >= 64, nTG); + m_pSynthesizer->setSostenuto (ucP2 >= 64, nTG); break; case MIDI_CC_PORTAMENTO: - m_pSynthesizer->setPortamentoMode (pMessage[2] >= 64, nTG); + m_pSynthesizer->setPortamentoMode (ucP2 >= 64, nTG); break; - + case MIDI_CC_RESONANCE: - m_pSynthesizer->SetResonance (maplong (pMessage[2], 0, 127, 0, 99), nTG); + m_pSynthesizer->SetResonance (maplong (ucP2, 0, 127, 0, 99), nTG); break; case MIDI_CC_FREQUENCY_CUTOFF: - m_pSynthesizer->SetCutoff (maplong (pMessage[2], 0, 127, 0, 99), nTG); + m_pSynthesizer->SetCutoff (maplong (ucP2, 0, 127, 0, 99), nTG); break; case MIDI_CC_REVERB_LEVEL: - m_pSynthesizer->SetReverbSend (maplong (pMessage[2], 0, 127, 0, 99), nTG); + m_pSynthesizer->SetReverbSend (maplong (ucP2, 0, 127, 0, 99), nTG); break; case MIDI_CC_DETUNE_LEVEL: - if (pMessage[2] == 0) + if (ucP2 == 0) { // "0 to 127, with 0 being no celeste (detune) effect applied at all." m_pSynthesizer->SetMasterTune (0, nTG); } else { - m_pSynthesizer->SetMasterTune (maplong (pMessage[2], 1, 127, -99, 99), nTG); + m_pSynthesizer->SetMasterTune (maplong (ucP2, 1, 127, -99, 99), nTG); } break; case MIDI_CC_ALL_SOUND_OFF: - m_pSynthesizer->panic (pMessage[2], nTG); + m_pSynthesizer->panic (ucP2, nTG); break; case MIDI_CC_ALL_NOTES_OFF: @@ -462,7 +449,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign // "Receivers should ignore an All Notes Off message while Omni is on (Modes 1 & 2)" if (!m_pConfig->GetIgnoreAllNotesOff () && m_ChannelMap[nTG] != OmniMode) { - m_pSynthesizer->notesOff (pMessage[2], nTG); + m_pSynthesizer->notesOff (ucP2, nTG); } break; @@ -472,7 +459,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign // so it is possible to break out of the main TG loop too. // Note: We handle this here so we get the TG MIDI channel checking. if (!bSystemCCChecked) { - bSystemCCHandled = HandleMIDISystemCC(pMessage[1], pMessage[2]); + bSystemCCHandled = HandleMIDISystemCC(ucP1, ucP2); bSystemCCChecked = true; } break; @@ -483,7 +470,7 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign // do program change only if enabled in config and not in "Performance Select Channel" mode if( m_pConfig->GetMIDIRXProgramChange() && ( m_pSynthesizer->GetPerformanceSelectChannel() == Disabled) ) { //printf("Program Change to %d (%d)\n", ucChannel, m_pSynthesizer->GetPerformanceSelectChannel()); - m_pSynthesizer->ProgramChange (pMessage[1], nTG); + m_pSynthesizer->ProgramChange (ucP1, nTG); } break; @@ -493,8 +480,8 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign break; } - s16 nValue = pMessage[1]; - nValue |= (s16) pMessage[2] << 7; + s16 nValue = ucP1; + nValue |= (s16) ucP2 << 7; nValue -= 0x2000; m_pSynthesizer->setPitchbend (nValue, nTG); @@ -506,6 +493,9 @@ void CMIDIDevice::MIDIMessageHandler (const u8 *pMessage, size_t nLength, unsign } } } + + if (m_pRouteMap) + MIDIListener(ucCable, ucChannel, ucType, ucP1, ucP2); } m_MIDISpinLock.Release (); } @@ -567,6 +557,11 @@ bool CMIDIDevice::HandleMIDISystemCC(const u8 ucCC, const u8 ucCCval) return false; } +void CMIDIDevice::SetRouteMap (TMIDIRoute *pRouteMap) +{ + m_pRouteMap = pRouteMap; +} + void CMIDIDevice::HandleSystemExclusive(const uint8_t* pMessage, const size_t nLength, const unsigned nCable, const uint8_t nTG) { int16_t sysex_return; @@ -695,6 +690,11 @@ void CMIDIDevice::HandleSystemExclusive(const uint8_t* pMessage, const size_t nL } } +void CMIDIDevice::MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) +{ +} + + void CMIDIDevice::SendSystemExclusiveVoice(uint8_t nVoice, const unsigned nCable, uint8_t nTG) { uint8_t voicedump[163]; @@ -711,3 +711,44 @@ void CMIDIDevice::SendSystemExclusiveVoice(uint8_t nVoice, const unsigned nCable // LOGDBG("Send SYSEX voice dump %u to \"%s\"",nVoice,Iterator->first.c_str()); } } + +void GetRoutedMIDI (TMIDIRoute *pMap, u8 *pCable, u8 *pCh, u8 *pType, u8 *pP1, u8 *pP2, bool *bSkip) +{ + assert (pMap); + for (TMIDIRoute *r = pMap; r->ucSCable != 0xFF ; r++) + { + if (r->ucSCable == *pCable && + (r->ucSCh == *pCh || r->ucSCh >= 16) && + (r->ucSType == *pType || r->ucSType >= 16) && + (r->ucSP1 == *pP1 || r->ucSP1 > 127) && + (r->ucSP2 == *pP2 || r->ucSP2 > 127)) + { + if (r->ucSType == MIDI_NOTE_ON) + r->bHandled = false; + + if (r->bSkip || + r->bSkipHandled && r->ucSType == MIDI_NOTE_OFF && (r-1)->bHandled || + r->bSkipHandled && r->ucSType == MIDI_AFTERTOUCH && (r-2)->bHandled) { + *bSkip = true; + return; + } + + if (r->bSkipHandled && r->ucSType == MIDI_NOTE_OFF) + (r-1)->bHandled = true; + if (r->bSkipHandled && r->ucSType == MIDI_AFTERTOUCH) + (r-2)->bHandled = true; + + *pCh = r->ucDCh; + *pType = r->ucDType; + if (r->ucDP1 <= 127) + *pP1 = r->ucDP1; + if (r->ucDP1 == TMIDIRoute::P2) + *pP1 = *pP2; + if (r->ucDP2 <= 127) + *pP2 = r->ucDP2; + if (r->bToggle) + r->ucDP2 = r->ucDP2 ? 0x0 : 0x7F; + return; + } + } +} diff --git a/src/mididevice.h b/src/mididevice.h index 44f16916..7eb13676 100644 --- a/src/mididevice.h +++ b/src/mididevice.h @@ -33,8 +33,57 @@ #define MAX_DX7_SYSEX_LENGTH 4104 #define MAX_MIDI_MESSAGE MAX_DX7_SYSEX_LENGTH +#define MIDI_NOTE_OFF 0b1000 +#define MIDI_NOTE_ON 0b1001 +#define MIDI_AFTERTOUCH 0b1010 // TODO +#define MIDI_CHANNEL_AFTERTOUCH 0b1101 // right now Synth_Dexed just manage Channel Aftertouch not Polyphonic AT -> 0b1010 +#define MIDI_CONTROL_CHANGE 0b1011 + #define MIDI_CC_BANK_SELECT_MSB 0 + #define MIDI_CC_MODULATION 1 + #define MIDI_CC_BREATH_CONTROLLER 2 + #define MIDI_CC_FOOT_PEDAL 4 + #define MIDI_CC_PORTAMENTO_TIME 5 + #define MIDI_CC_VOLUME 7 + #define MIDI_CC_PAN_POSITION 10 + #define MIDI_CC_BANK_SELECT_LSB 32 + #define MIDI_CC_BANK_SUSTAIN 64 + #define MIDI_CC_PORTAMENTO 65 + #define MIDI_CC_SOSTENUTO 66 + #define MIDI_CC_RESONANCE 71 + #define MIDI_CC_FREQUENCY_CUTOFF 74 + #define MIDI_CC_REVERB_LEVEL 91 + #define MIDI_CC_DETUNE_LEVEL 94 + #define MIDI_CC_ALL_SOUND_OFF 120 + #define MIDI_CC_ALL_NOTES_OFF 123 +#define MIDI_PROGRAM_CHANGE 0b1100 +#define MIDI_PITCH_BEND 0b1110 + class CMiniDexed; +struct TMIDIRoute +{ + enum TRouteOP + { + P2 = 0x82, + }; + + u8 ucSCable; + u8 ucSCh; + u8 ucSType; + u8 ucSP1; + u8 ucSP2; + u8 ucDCh; + u8 ucDType; + u8 ucDP1; + u8 ucDP2; + bool bSkip; + bool bToggle; + bool bHandled; + bool bSkipHandled; +}; + +void GetRoutedMIDI (TMIDIRoute *m_pRouteMap, u8 *pCable, u8 *pChannel, u8 *pType, u8 *pP1, u8 *pP2, bool *bSkip); + class CMIDIDevice { public: @@ -46,6 +95,8 @@ class CMIDIDevice ChannelUnknown }; + + public: CMIDIDevice (CMiniDexed *pSynthesizer, CConfig *pConfig, CUserInterface *pUI); virtual ~CMIDIDevice (void); @@ -53,6 +104,8 @@ class CMIDIDevice void SetChannel (u8 ucChannel, unsigned nTG); u8 GetChannel (unsigned nTG) const; + void SetRouteMap (TMIDIRoute *pRouteMap); + virtual void Send (const u8 *pMessage, size_t nLength, unsigned nCable = 0) {} virtual void SendSystemExclusiveVoice(uint8_t nVoice, const unsigned nCable, uint8_t nTG); @@ -61,6 +114,8 @@ class CMIDIDevice void AddDevice (const char *pDeviceName); void HandleSystemExclusive(const uint8_t* pMessage, const size_t nLength, const unsigned nCable, const uint8_t nTG); + virtual void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2); + private: bool HandleMIDISystemCC(const u8 ucCC, const u8 ucCCval); @@ -78,6 +133,8 @@ class CMIDIDevice std::string m_DeviceName; + TMIDIRoute *m_pRouteMap; + typedef std::unordered_map TDeviceMap; static TDeviceMap s_DeviceMap; diff --git a/src/midikeyboard.cpp b/src/midikeyboard.cpp index db71168d..300c61e8 100644 --- a/src/midikeyboard.cpp +++ b/src/midikeyboard.cpp @@ -29,15 +29,20 @@ CMIDIKeyboard::CMIDIKeyboard (CMiniDexed *pSynthesizer, CConfig *pConfig, CUserI : CMIDIDevice (pSynthesizer, pConfig, pUI), m_nSysExIdx (0), m_nInstance (nInstance), - m_pMIDIDevice (0) + m_pMIDIDevice (0), + m_pDAWController (0) { m_DeviceName.Format ("umidi%u", nInstance+1); AddDevice (m_DeviceName); + + if (pConfig->GetDAWControllerEnabled ()) + m_pDAWController = new CDAWController (pSynthesizer, this, pConfig, pUI); } CMIDIKeyboard::~CMIDIKeyboard (void) { + delete m_pDAWController; } void CMIDIKeyboard::Process (boolean bPlugAndPlayUpdated) @@ -69,6 +74,9 @@ void CMIDIKeyboard::Process (boolean bPlugAndPlayUpdated) m_pMIDIDevice->RegisterPacketHandler (MIDIPacketHandler, this); m_pMIDIDevice->RegisterRemovedHandler (DeviceRemovedHandler, this); + + if (m_pDAWController) + m_pDAWController->OnConnect(); } } } @@ -85,6 +93,13 @@ void CMIDIKeyboard::Send (const u8 *pMessage, size_t nLength, unsigned nCable) m_SendQueue.push (Entry); } +void CMIDIKeyboard::SendDebounce (const u8 *pMessage, size_t nLength, unsigned nCable) +{ + TSendQueueEntry Entry = m_SendQueue.back (); + if (Entry.nLength != nLength || Entry.nCable != nCable || memcmp (Entry.pMessage, pMessage, nLength) != 0) + Send (pMessage, nLength, nCable); +} + // Most packets will be passed straight onto the main MIDI message handler // but SysEx messages are multiple USB packets and so will need building up // before parsing. @@ -122,6 +137,10 @@ void CMIDIKeyboard::USBMIDIMessageHandler (u8 *pPacket, unsigned nLength, unsign m_SysEx[m_nSysExIdx++] = pPacket[i]; //printf ("SysEx End Idx=%d\n", m_nSysExIdx); MIDIMessageHandler (m_SysEx, m_nSysExIdx, nCable); + + if (m_pDAWController) + m_pDAWController->MIDISysexHandler (m_SysEx, m_nSysExIdx, nCable); + // Reset ready for next time m_nSysExIdx = 0; } @@ -160,3 +179,22 @@ void CMIDIKeyboard::DeviceRemovedHandler (CDevice *pDevice, void *pContext) pThis->m_pMIDIDevice = 0; } + +void CMIDIKeyboard::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, + bool bArrowDown, bool bArrowUp) +{ + if (m_pMIDIDevice && m_pDAWController) + m_pDAWController->DisplayWrite (pMenu, pParam, pValue, bArrowDown, bArrowUp); +} + +void CMIDIKeyboard::UpdateDAWState (void) +{ + if (m_pMIDIDevice && m_pDAWController) + m_pDAWController->UpdateState (); +} + +void CMIDIKeyboard::MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) +{ + if (m_pDAWController) + m_pDAWController->MIDIListener (ucCable, ucChannel, ucType, ucP1, ucP2); +} diff --git a/src/midikeyboard.h b/src/midikeyboard.h index bf626890..e5576c1f 100644 --- a/src/midikeyboard.h +++ b/src/midikeyboard.h @@ -25,6 +25,7 @@ #include "mididevice.h" #include "config.h" +#include "dawcontroller.h" #include #include #include @@ -44,6 +45,12 @@ class CMIDIKeyboard : public CMIDIDevice void Process (boolean bPlugAndPlayUpdated); void Send (const u8 *pMessage, size_t nLength, unsigned nCable = 0) override; + void SendDebounce (const u8 *pMessage, size_t nLength, unsigned nCable = 0); + + void DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, + bool bArrowDown, bool bArrowUp); + + void UpdateDAWState (void); private: static void MIDIPacketHandler (unsigned nCable, u8 *pPacket, unsigned nLength, unsigned nDevice, void *pParam); @@ -51,6 +58,8 @@ class CMIDIKeyboard : public CMIDIDevice void USBMIDIMessageHandler (u8 *pPacket, unsigned nLength, unsigned nCable, unsigned nDevice); + void MIDIListener (u8 ucCable, u8 ucChannel, u8 ucType, u8 ucP1, u8 ucP2) override; + private: struct TSendQueueEntry { @@ -68,6 +77,8 @@ class CMIDIKeyboard : public CMIDIDevice CUSBMIDIDevice * volatile m_pMIDIDevice; std::queue m_SendQueue; + + CDAWController *m_pDAWController; }; #endif diff --git a/src/minidexed.cpp b/src/minidexed.cpp index 0beea890..7d58292c 100644 --- a/src/minidexed.cpp +++ b/src/minidexed.cpp @@ -1059,6 +1059,24 @@ void CMiniDexed::SetTGParameter (TTGParameter Parameter, int nValue, unsigned nT assert (0); break; } + + switch (Parameter) + { + case TGParameterCutoff: + case TGParameterEnabled: + case TGParameterMasterTune: + case TGParameterMIDIChannel: + case TGParameterPan: + case TGParameterProgram: + case TGParameterResonance: + case TGParameterReverbSend: + case TGParameterPortamentoTime: + case TGParameterPortamentoMode: + UpdateDAWState (); + break; + default: + break; + } } int CMiniDexed::GetTGParameter (TTGParameter Parameter, unsigned nTG) @@ -1799,6 +1817,25 @@ void CMiniDexed::setMasterVolume (float32_t vol) nMasterVolume=vol; } +void CMiniDexed::DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, + bool bArrowDown, bool bArrowUp) +{ + m_UI.DisplayWrite (pMenu, pParam, pValue, bArrowDown, bArrowUp); + + for (unsigned i = 0; i < CConfig::MaxUSBMIDIDevices; i++) + { + m_pMIDIKeyboard[i]->DisplayWrite (pMenu, pParam, pValue, bArrowDown, bArrowUp); + } +} + +void CMiniDexed::UpdateDAWState () +{ + for (unsigned i = 0; i < CConfig::MaxUSBMIDIDevices; i++) + { + m_pMIDIKeyboard[i]->UpdateDAWState (); + } +} + std::string CMiniDexed::GetPerformanceFileName(unsigned nID) { return m_PerformanceConfig.GetPerformanceFileName(nID); @@ -1962,6 +1999,7 @@ void CMiniDexed::LoadPerformanceParameters(void) m_pTG[nTG]->loadVoiceParameters(tVoiceData); } setMonoMode(m_PerformanceConfig.GetMonoMode(nTG) ? 1 : 0, nTG); + setEnabled(1, nTG); SetReverbSend (m_PerformanceConfig.GetReverbSend (nTG), nTG); setModWheelRange (m_PerformanceConfig.GetModulationWheelRange (nTG), nTG); @@ -1985,6 +2023,8 @@ void CMiniDexed::LoadPerformanceParameters(void) SetParameter (ParameterReverbLowPass, m_PerformanceConfig.GetReverbLowPass ()); SetParameter (ParameterReverbDiffusion, m_PerformanceConfig.GetReverbDiffusion ()); SetParameter (ParameterReverbLevel, m_PerformanceConfig.GetReverbLevel ()); + + UpdateDAWState (); } std::string CMiniDexed::GetNewPerformanceDefaultName(void) diff --git a/src/minidexed.h b/src/minidexed.h index 72f43c7f..866bd032 100644 --- a/src/minidexed.h +++ b/src/minidexed.h @@ -232,6 +232,11 @@ class CMiniDexed void setMasterVolume (float32_t vol); + void DisplayWrite (const char *pMenu, const char *pParam, const char *pValue, + bool bArrowDown, bool bArrowUp); + + void UpdateDAWState (); + private: int16_t ApplyNoteLimits (int16_t pitch, unsigned nTG); // returns < 0 to ignore note uint8_t m_uchOPMask[CConfig::AllToneGenerators]; diff --git a/src/minidexed.ini b/src/minidexed.ini index 9465ae1f..2b409053 100644 --- a/src/minidexed.ini +++ b/src/minidexed.ini @@ -151,6 +151,9 @@ MIDIButtonActionTGUp=click MIDIButtonTGDown=56 MIDIButtonActionTGDown=click +# DAW Controller (Arturia MiniLab 3, KeyLab Essential, KeyLab Essential 3, Keylab mkII) +DAWControllerEnabled=0 + # KY-040 Rotary Encoder EncoderEnabled=1 EncoderPinClock=10 diff --git a/src/uibuttons.cpp b/src/uibuttons.cpp index 90e2e1d3..834da4e3 100644 --- a/src/uibuttons.cpp +++ b/src/uibuttons.cpp @@ -18,6 +18,7 @@ // along with this program. If not, see . // #include "uibuttons.h" +#include "mididevice.h" #include #include #include @@ -548,21 +549,20 @@ void CUIButtons::ResetButton (unsigned pinNumber) } } -void CUIButtons::BtnMIDICmdHandler (unsigned nMidiCmd, unsigned nMidiData1, unsigned nMidiData2) +void CUIButtons::BtnMIDICmdHandler (unsigned nMidiType, unsigned nMidiData1, unsigned nMidiData2) { if (m_notesMidi > 0) { -// LOGDBG("BtnMIDICmdHandler (notes): %x %x %x)", nMidiCmd, nMidiData1, nMidiData2); +// LOGDBG("BtnMIDICmdHandler (notes): %x %x %x)", nMidiType, nMidiData1, nMidiData2); // Using MIDI Note messages for MIDI buttons unsigned midiPin = ccToMidiPin(nMidiData1); for (unsigned i=0; im_pCurrentMenu) // if this is another menu? { bool bIsMainMenu = pUIMenu->m_pCurrentMenu == s_MainMenu; - pUIMenu->m_pUI->DisplayWrite ( + pUIMenu->m_pMiniDexed->DisplayWrite ( pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, "", pUIMenu->m_pCurrentMenu[pUIMenu->m_nCurrentSelection].Name, @@ -595,7 +595,7 @@ void CUIMenu::EditGlobalParameter (CUIMenu *pUIMenu, TMenuEvent Event) string Value = GetGlobalValueString (Param, pUIMenu->m_pMiniDexed->GetParameter (Param)); - pUIMenu->m_pUI->DisplayWrite (pMenuName, + pUIMenu->m_pMiniDexed->DisplayWrite (pMenuName, pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > rParam.Minimum, nValue < rParam.Maximum); @@ -639,7 +639,7 @@ void CUIMenu::EditVoiceBankNumber (CUIMenu *pUIMenu, TMenuEvent Event) string Value = to_string (nValue+1) + "=" + pUIMenu->m_pMiniDexed->GetSysExFileLoader ()->GetBankName (nValue); - pUIMenu->m_pUI->DisplayWrite (TG.c_str (), + pUIMenu->m_pMiniDexed->DisplayWrite (TG.c_str (), pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > 0, nValue < (int) CSysExFileLoader::MaxVoiceBankID); @@ -709,7 +709,7 @@ void CUIMenu::EditProgramNumber (CUIMenu *pUIMenu, TMenuEvent Event) string Value = to_string (nValue+1) + "=" + pUIMenu->m_pMiniDexed->GetVoiceName (nTG); - pUIMenu->m_pUI->DisplayWrite (TG.c_str (), + pUIMenu->m_pMiniDexed->DisplayWrite (TG.c_str (), pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > 0, nValue < (int) CSysExFileLoader::VoicesPerBank-1); @@ -762,7 +762,7 @@ void CUIMenu::EditTGParameter (CUIMenu *pUIMenu, TMenuEvent Event) string Value = GetTGValueString (Param, pUIMenu->m_pMiniDexed->GetTGParameter (Param, nTG)); - pUIMenu->m_pUI->DisplayWrite (TG.c_str (), + pUIMenu->m_pMiniDexed->DisplayWrite (TG.c_str (), pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > rParam.Minimum, nValue < rParam.Maximum); @@ -815,7 +815,7 @@ void CUIMenu::EditTGParameter2 (CUIMenu *pUIMenu, TMenuEvent Event) // second me string Value = GetTGValueString (Param, pUIMenu->m_pMiniDexed->GetTGParameter (Param, nTG)); - pUIMenu->m_pUI->DisplayWrite (TG.c_str (), + pUIMenu->m_pMiniDexed->DisplayWrite (TG.c_str (), pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > rParam.Minimum, nValue < rParam.Maximum); @@ -868,7 +868,7 @@ void CUIMenu::EditVoiceParameter (CUIMenu *pUIMenu, TMenuEvent Event) string Value = GetVoiceValueString (nParam, nValue); - pUIMenu->m_pUI->DisplayWrite (TG.c_str (), + pUIMenu->m_pMiniDexed->DisplayWrite (TG.c_str (), pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > rParam.Minimum, nValue < rParam.Maximum); @@ -971,7 +971,7 @@ void CUIMenu::EditOPParameter (CUIMenu *pUIMenu, TMenuEvent Event) Value = GetOPValueString (nParam, nValue); } - pUIMenu->m_pUI->DisplayWrite (OP.c_str (), + pUIMenu->m_pMiniDexed->DisplayWrite (OP.c_str (), pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > rParam.Minimum, nValue < rParam.Maximum); @@ -990,7 +990,7 @@ void CUIMenu::SavePerformance (CUIMenu *pUIMenu, TMenuEvent Event) pUIMenu->m_MenuStackParent[pUIMenu->m_nCurrentMenuDepth-1] [pUIMenu->m_nMenuStackItem[pUIMenu->m_nCurrentMenuDepth-1]].Name; - pUIMenu->m_pUI->DisplayWrite (pMenuName, + pUIMenu->m_pMiniDexed->DisplayWrite (pMenuName, pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, bOK ? "Completed" : "Error", false, false); @@ -1653,7 +1653,7 @@ void CUIMenu::PerformanceMenu (CUIMenu *pUIMenu, TMenuEvent Event) { pUIMenu->m_nSelectedPerformanceID = 0; pUIMenu->m_bConfirmDeletePerformance=false; - pUIMenu->m_pUI->DisplayWrite ("", "Delete", pUIMenu->m_pMiniDexed->DeletePerformance(nValue) ? "Completed" : "Error", false, false); + pUIMenu->m_pMiniDexed->DisplayWrite ("", "Delete", pUIMenu->m_pMiniDexed->DeletePerformance(nValue) ? "Completed" : "Error", false, false); pUIMenu->m_bSplashShow=true; CTimer::Get ()->StartKernelTimer (MSEC2HZ (1500), TimerHandlerNoBack, 0, pUIMenu); return; @@ -1686,13 +1686,13 @@ void CUIMenu::PerformanceMenu (CUIMenu *pUIMenu, TMenuEvent Event) nPSelected += " [L]"; } - pUIMenu->m_pUI->DisplayWrite (pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, nPSelected.c_str(), + pUIMenu->m_pMiniDexed->DisplayWrite (pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, nPSelected.c_str(), Value.c_str (), true, true); // (int) nValue > 0, (int) nValue < (int) pUIMenu->m_pMiniDexed->GetLastPerformance()); } else { - pUIMenu->m_pUI->DisplayWrite ("", "Delete?", pUIMenu->m_bConfirmDeletePerformance ? "Yes" : "No", false, false); + pUIMenu->m_pMiniDexed->DisplayWrite ("", "Delete?", pUIMenu->m_bConfirmDeletePerformance ? "Yes" : "No", false, false); } } @@ -1774,7 +1774,7 @@ void CUIMenu::EditPerformanceBankNumber (CUIMenu *pUIMenu, TMenuEvent Event) nPSelected += " [L]"; } - pUIMenu->m_pUI->DisplayWrite (pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, nPSelected.c_str(), + pUIMenu->m_pMiniDexed->DisplayWrite (pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, nPSelected.c_str(), Value.c_str (), nValue > 0, nValue < pUIMenu->m_pMiniDexed->GetLastPerformanceBank()-1); @@ -1887,7 +1887,7 @@ void CUIMenu::InputTxt (CUIMenu *pUIMenu, TMenuEvent Event) pUIMenu->m_pMiniDexed->SetNewPerformanceName(pUIMenu->m_InputText); bOK = pUIMenu->m_pMiniDexed->SavePerformanceNewFile (); MsgOk=bOK ? "Completed" : "Error"; - pUIMenu->m_pUI->DisplayWrite (OkTitleR.c_str(), OkTitleL.c_str(), MsgOk.c_str(), false, false); + pUIMenu->m_pMiniDexed->DisplayWrite (OkTitleR.c_str(), OkTitleL.c_str(), MsgOk.c_str(), false, false); CTimer::Get ()->StartKernelTimer (MSEC2HZ (1500), TimerHandler, 0, pUIMenu); return; } @@ -1938,7 +1938,7 @@ void CUIMenu::InputTxt (CUIMenu *pUIMenu, TMenuEvent Event) } Value = Value + " " + escCursor ; - pUIMenu->m_pUI->DisplayWrite (MenuTitleR.c_str(),MenuTitleL.c_str(), Value.c_str(), false, false); + pUIMenu->m_pMiniDexed->DisplayWrite (MenuTitleR.c_str(),MenuTitleL.c_str(), Value.c_str(), false, false); } @@ -1992,7 +1992,7 @@ void CUIMenu::EditTGParameterModulation (CUIMenu *pUIMenu, TMenuEvent Event) string Value = GetTGValueString (Param, pUIMenu->m_pMiniDexed->GetTGParameter (Param, nTG)); - pUIMenu->m_pUI->DisplayWrite (TG.c_str (), + pUIMenu->m_pMiniDexed->DisplayWrite (TG.c_str (), pUIMenu->m_pParentMenu[pUIMenu->m_nCurrentMenuItem].Name, Value.c_str (), nValue > rParam.Minimum, nValue < rParam.Maximum); diff --git a/src/userinterface.cpp b/src/userinterface.cpp index 32222a1f..7320caea 100644 --- a/src/userinterface.cpp +++ b/src/userinterface.cpp @@ -162,16 +162,7 @@ bool CUserInterface::Initialize (void) LOGDBG ("LCD initialized"); } - m_pUIButtons = new CUIButtons ( m_pConfig ); - assert (m_pUIButtons); - - if (!m_pUIButtons->Initialize ()) - { - return false; - } - - m_pUIButtons->RegisterEventHandler (UIButtonsEventStub, this); - UISetMIDIButtonChannel (m_pConfig->GetMIDIButtonCh ()); + InitButtonsWithConfig (m_pConfig); LOGDBG ("Button User Interface initialized"); @@ -198,6 +189,17 @@ bool CUserInterface::Initialize (void) return true; } +void CUserInterface::InitButtonsWithConfig (CConfig *pConfig) +{ + delete m_pUIButtons; + m_pUIButtons = new CUIButtons (pConfig); + assert (m_pUIButtons); + + m_pUIButtons->Initialize (); + m_pUIButtons->RegisterEventHandler (UIButtonsEventStub, this); + UISetMIDIButtonChannel (pConfig->GetMIDIButtonCh ()); +} + void CUserInterface::Process (void) { if (m_pLCDBuffered) @@ -396,7 +398,7 @@ void CUserInterface::UIButtonsEventStub (CUIButton::BtnEvent Event, void *pParam pThis->UIButtonsEventHandler (Event); } -void CUserInterface::UIMIDICmdHandler (unsigned nMidiCh, unsigned nMidiCmd, unsigned nMidiData1, unsigned nMidiData2) +void CUserInterface::UIMIDICmdHandler (unsigned nMidiCh, unsigned nMidiType, unsigned nMidiData1, unsigned nMidiData2) { if (m_nMIDIButtonCh == CMIDIDevice::Disabled) { @@ -411,7 +413,7 @@ void CUserInterface::UIMIDICmdHandler (unsigned nMidiCh, unsigned nMidiCmd, unsi if (m_pUIButtons) { - m_pUIButtons->BtnMIDICmdHandler (nMidiCmd, nMidiData1, nMidiData2); + m_pUIButtons->BtnMIDICmdHandler (nMidiType, nMidiData1, nMidiData2); } } diff --git a/src/userinterface.h b/src/userinterface.h index a8026db9..24f5763c 100644 --- a/src/userinterface.h +++ b/src/userinterface.h @@ -57,6 +57,8 @@ class CUserInterface // To be called from the MIDI device on reception of a MIDI CC message void UIMIDICmdHandler (unsigned nMidiCh, unsigned nMidiCmd, unsigned nMidiData1, unsigned nMidiData2); + void InitButtonsWithConfig (CConfig *pConfig); + private: void LCDWrite (const char *pString); // Print to optional HD44780 display