cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/midi/bela-midi.h

@@ -0,0 +1,266 @@
+/************************** BEGIN bela-midi.h *****************************
+FAUST Architecture File
+Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+---------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+EXCEPTION : As a special exception, you may create a larger work
+that contains this FAUST architecture section and distribute
+that work under terms of your choice, so long as this FAUST
+architecture section is not modified.
+***************************************************************************/
+ 
+#ifndef __bela_midi__
+#define __bela_midi__ 
+  
+#include <iostream>
+#include <cstdlib>
+
+#include <libraries/Midi/Midi.h>
+#include "faust/midi/midi.h"
+
+class FAUST_API MapUI;
+
+/**
+ * MIDI handler for the Bela board: https://bela.io
+ */
+class bela_midi : public midi_handler {
+
+    private:
+    
+        Midi fBelaMidi;
+        
+        static void midiCallback(MidiChannelMessage message, void* arg)
+        {
+            bela_midi* midi = static_cast<bela_midi*>(arg);
+            int type = message.getType();       // which MIDI message, 128-255
+            int channel = message.getChannel(); // which MIDI channel, 1-16
+            double time = 0.;
+            
+            switch (type) {
+                case kmmNoteOff:
+                    midi->handleKeyOff(time, channel, message.getDataByte(0), message.getDataByte(1));
+                    break;
+                case kmmNoteOn:
+                    midi->handleKeyOn(time, channel, message.getDataByte(0), message.getDataByte(1));
+                    break;
+                case kmmPolyphonicKeyPressure:
+                    midi->handlePolyAfterTouch(time, channel, message.getDataByte(0), message.getDataByte(1));
+                    break;
+                case kmmControlChange:
+                    midi->handleCtrlChange(time, channel, message.getDataByte(0), message.getDataByte(1));
+                    break;
+                case kmmProgramChange:
+                    midi->handleProgChange(time, channel, message.getDataByte(0));
+                    break;
+                case kmmChannelPressure:
+                    midi->handleAfterTouch(time, channel, message.getDataByte(0));
+                    break;
+                case kmmPitchBend:
+                    midi->handlePitchWheel(time, channel, message.getDataByte(0), message.getDataByte(1));
+                    break;
+                case kmmSystem:
+                    {
+                        // We have to re-build the MIDI message:
+                        int status = message.getStatusByte();
+                        int systemRealtimeByte = channel | status;
+
+                        switch (systemRealtimeByte)
+                        {
+                            case MIDI_CLOCK:
+                                midi->handleClock(time);
+                                break;
+                            case MIDI_START:
+                            // We can consider start and continue as identical messages
+                            case MIDI_CONT:
+                                midi->handleStart(time);
+                                break;
+                            case MIDI_STOP:
+                                midi->handleStop(time);
+                                break;
+                            case MIDI_SYSEX_START:
+                        #if 0 // this is not implemented on Bela yet
+                                std::vector<unsigned char> sysex;
+                                for (unsigned int j = 0; j < message.getNumDataBytes(); j++) {
+                                    sysex.push_back(message.getDataByte(j));
+                                }
+                                // Would be nice to do this:
+                                // std::vector<unsigned char> sysex(message.getData(), message.getData() + message.getNumDataBytes());
+                                midi->handleSysex(time, sysex);
+                        #endif
+                                break;
+                            default:
+                                break;
+                        }
+                        break;
+                    }
+                case kmmNone:
+                case kmmAny:
+                default:
+                    break;
+            }
+        }
+    
+    public:
+    
+        bela_midi():midi_handler("bela")
+        {}
+    
+        virtual ~bela_midi()
+        {
+            stopMidi();
+        }
+    
+        bool startMidi()
+        {
+            if (fBelaMidi.readFrom(0) < 0) {
+                return false;
+            }
+            
+            if (fBelaMidi.writeTo(0) < 0) {
+                return false;
+            }
+            
+            fBelaMidi.enableParser(true);
+            fBelaMidi.setParserCallback(midiCallback, this);
+            return true;
+        }
+        
+        void stopMidi()
+        { 
+            // Nothing todo?
+        }
+        
+        MapUI* keyOn(int channel, int pitch, int velocity)
+        {
+            unsigned char buffer[3] 
+                = { static_cast<unsigned char>(MIDI_NOTE_ON + channel), 
+                    static_cast<unsigned char>(pitch), 
+                    static_cast<unsigned char>(velocity) };
+            fBelaMidi.writeOutput(buffer, 3);
+            return 0;
+        }
+        
+        void keyOff(int channel, int pitch, int velocity) 
+        {
+            unsigned char buffer[3] 
+                = { static_cast<unsigned char>(MIDI_NOTE_OFF + channel), 
+                    static_cast<unsigned char>(pitch), 
+                    static_cast<unsigned char>(velocity) };
+            fBelaMidi.writeOutput(buffer, 3);
+        }
+        
+        void ctrlChange(int channel, int ctrl, int val) 
+        {
+            unsigned char buffer[3] 
+                = { static_cast<unsigned char>(MIDI_CONTROL_CHANGE + channel), 
+                    static_cast<unsigned char>(ctrl), 
+                    static_cast<unsigned char>(val) };
+            fBelaMidi.writeOutput(buffer, 3);
+        }
+        
+        void chanPress(int channel, int press) 
+        {
+            unsigned char buffer[2] 
+                = { static_cast<unsigned char>(MIDI_AFTERTOUCH + channel), 
+                    static_cast<unsigned char>(press) };
+            fBelaMidi.writeOutput(buffer, 2);
+        }
+        
+        void progChange(int channel, int pgm) 
+        {
+            unsigned char buffer[2] 
+                = { static_cast<unsigned char>(MIDI_PROGRAM_CHANGE + channel), 
+                    static_cast<unsigned char>(pgm) };
+            fBelaMidi.writeOutput(buffer, 2);
+        }
+          
+        void keyPress(int channel, int pitch, int press) 
+        {
+            unsigned char buffer[3] 
+                = { static_cast<unsigned char>(MIDI_POLY_AFTERTOUCH + channel), 
+                    static_cast<unsigned char>(pitch), 
+                    static_cast<unsigned char>(press) };
+            fBelaMidi.writeOutput(buffer, 3);
+        }
+   
+        void pitchWheel(int channel, int wheel) 
+        {
+            unsigned char buffer[3] 
+                = { static_cast<unsigned char>(MIDI_PITCH_BEND + channel), 
+                    static_cast<unsigned char>(wheel & 0x7F), 
+                    static_cast<unsigned char>((wheel >> 7) & 0x7F) };
+            fBelaMidi.writeOutput(buffer, 3);
+        }
+        
+        void ctrlChange14bits(int channel, int ctrl, int value) {}
+         
+        void startSync(double date) 
+        {
+            unsigned char buffer[1] = { MIDI_START };
+            fBelaMidi.writeOutput(buffer, 1);
+        }
+       
+        void stopSync(double date)
+        {
+            unsigned char buffer[1] = { MIDI_STOP };
+            fBelaMidi.writeOutput(buffer, 1);
+        }
+        
+        void clock(double date) 
+        {
+            unsigned char buffer[1] = { MIDI_CLOCK };
+            fBelaMidi.writeOutput(buffer, 1);
+        }
+    
+        void sysEx(double date, std::vector<unsigned char>& message)
+        {
+            fBelaMidi.writeOutput(message.data(), message.size());
+        }
+    
+};
+
+#endif // __bela_midi__
+
+/*
+// Use case example 
+
+#include "faust/gui/MidiUI.h"
+#include "faust/midi/bela-midi.h"
+
+bela_midi fMIDI;
+MidiUI* fMidiUI;
+
+bool setup(BeagleRTContext *context, void *userData)
+{
+    ....
+    
+    // Setup a generic MidiUI to use bela_midi MIDI handler
+    fMidiUI = new MidiUI(&fMIDI);
+    // Add MidiUI control interface to DSP
+    fDSP.buildUserInterface(fMidiUI);
+    // And run it...
+    fMidiUI->run();
+    
+    ....
+}
+
+void cleanup(BeagleRTContext *context, void *userData)
+{
+    ....
+    delete fMidiUI;
+}
+*/
+/**************************  END  bela-midi.h **************************/

cyfaust/resources/architecture/faust/midi/daisy-midi.h

@@ -0,0 +1,116 @@
+/************************** BEGIN daisy-midi.h ****************************
+FAUST Architecture File
+Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+---------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+EXCEPTION : As a special exception, you may create a larger work
+that contains this FAUST architecture section and distribute
+that work under terms of your choice, so long as this FAUST
+architecture section is not modified.
+***************************************************************************/
+
+#ifndef __daisy_midi__
+#define __daisy_midi__
+
+#include <cstdlib>
+
+#include "daisysp.h"
+#include "faust/midi/midi.h"
+#include "faust/gui/GUI.h"
+
+class daisy_midi : public midi_handler {
+    
+    private:
+    
+        daisy::MidiHandler fMidi;
+    
+    public:
+    
+        daisy_midi():midi_handler("daisy")
+        {}
+    
+        virtual ~daisy_midi()
+        {
+            stopMidi();
+        }
+
+        bool startMidi()
+        {
+            fMidi.Init(daisy::MidiHandler::INPUT_MODE_UART1, daisy::MidiHandler::OUTPUT_MODE_NONE);
+            return true;
+        }
+
+        void stopMidi()
+        {}
+    
+        void processMidi()
+        {
+            fMidi.Listen();
+            while (fMidi.HasEvents()) {
+                
+                double time = 0.;
+                daisy::MidiEvent m = fMidi.PopEvent();
+                switch(m.type) {
+                        
+                    case daisy::MidiMessageType::NoteOff: {
+                        // TODO
+                        //NoteOff p = m.AsNoteOff();
+                        //handleKeyOff(time, p.channel, p.note, p.velocity);
+                        break;
+                    }
+                        
+                    case daisy::MidiMessageType::NoteOn: {
+                        daisy::NoteOnEvent p = m.AsNoteOn();
+                        handleKeyOn(time, p.channel, p.note, p.velocity);
+                        break;
+                    }
+                        
+                    case daisy::MidiMessageType::PolyphonicKeyPressure: {
+                        // TODO
+                        //handlePolyAfterTouch(time, m.channel, m.control_number, m.value);
+                        break;
+                    }
+                        
+                    case daisy::MidiMessageType::ControlChange: {
+                        daisy::ControlChangeEvent p = m.AsControlChange();
+                        handleCtrlChange(time, p.channel, p.control_number, p.value);
+                        break;
+                    }
+                        
+                    case daisy::MidiMessageType::ProgramChange: {
+                        // TODO
+                        //handleProgChange(time, p.channel, p.control_number, p.value);
+                        break;
+                    }
+                        
+                    case daisy::MidiMessageType::PitchBend: {
+                        // TODO
+                        //handlePitchWheel(time, p.channel, p.control_number, p.value);
+                        break;
+                    }
+                        
+                    default:
+                        break;
+                }
+            }
+            // Synchronize all GUI controllers
+            GUI::updateAllGuis();
+        }
+   
+};
+
+#endif
+/**************************  END  daisy-midi.h **************************/

cyfaust/resources/architecture/faust/midi/esp32-midi.h

@@ -0,0 +1,185 @@
+/************************** BEGIN esp32-midi.h ****************************
+FAUST Architecture File
+Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+---------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+EXCEPTION : As a special exception, you may create a larger work
+that contains this FAUST architecture section and distribute
+that work under terms of your choice, so long as this FAUST
+architecture section is not modified.
+***************************************************************************/
+
+#ifndef __esp32_midi__
+#define __esp32_midi__
+
+#include <cstdlib>
+
+#include "driver/uart.h"
+
+#include "jdksmidi/world.h"
+#include "jdksmidi/midi.h"
+#include "jdksmidi/msg.h"
+#include "jdksmidi/sysex.h"
+#include "jdksmidi/parser.h"
+
+#include "faust/midi/midi.h"
+
+using namespace jdksmidi;
+
+#ifndef RX1
+#define RX1 GPIO_NUM_5
+#endif
+
+#ifndef TX1
+#define TX1 GPIO_NUM_19
+#endif
+
+#define PORT_NUM UART_NUM_1
+#define RX_BUF_SIZE 1024
+
+/**
+ * MIDI handler for the ESP32 boards.
+ */
+class esp32_midi : public midi_handler {
+    
+    private:
+    
+        TaskHandle_t fProcessMidiHandle;
+    
+        void processMidi()
+        {
+            double time = 0;
+            uint8_t data[RX_BUF_SIZE];
+            MIDIParser parser;
+            jdksMIDIMessage message;
+            
+            while (true) {
+                int rxBytes = uart_read_bytes(UART_NUM_1, data, RX_BUF_SIZE, 1);
+                if (rxBytes > 0) {
+                    for (int i = 0; i < rxBytes; i++) {
+                        if (parser.Parse((uchar)data[i], &message)) {
+                            unsigned char status = message.GetStatus();
+                            if (status < 0xF0)
+                            { // channel/system message discriminator.
+                                unsigned char type = message.GetType();
+                                switch (type)
+                                {
+                                case 0x80: // Note Off
+                                    handleKeyOff(time, message.GetChannel(), message.GetNote(), message.GetVelocity());
+                                    break;
+                                case 0x90: // Note On
+                                    handleKeyOn(time, message.GetChannel(), message.GetNote(), message.GetVelocity());
+                                    break;
+                                case 0xA0: // Poly Key Pressure
+                                    handlePolyAfterTouch(time, message.GetChannel(), message.GetNote(), message.GetByte2());
+                                    break;
+                                case 0xB0: // Control Change
+                                    handleCtrlChange(time, message.GetChannel(), message.GetController(), message.GetControllerValue());
+                                    break;
+                                case 0xC0: // Program Change // No Bank Select in faust?
+                                    handleProgChange(time, message.GetChannel(), message.GetPGValue());
+                                    break;
+                                case 0xD0: // Channel Pressure
+                                    handleAfterTouch(time, message.GetChannel(), message.GetChannelPressure());
+                                    break;
+                                case 0xE0: // Pitch Bend
+                                    handlePitchWheel(time, message.GetChannel(), message.GetByte1(), message.GetByte2());
+                                    break;
+                                default:
+                                    break;
+                                }
+                            }
+                            else
+                            {
+                                switch (status)
+                                {
+                                case 0xF8: // Timing Clock
+                                    handleClock(time);
+                                    break;
+                                // We can consider start and continue as identical messages.
+                                case 0xFA: // Start
+                                case 0xFB: // Continue
+                                    handleStart(time);
+                                    break;
+                                case 0xFC: // Stop
+                                    handleStop(time);
+                                    break;
+                                case 0xF0: // SysEx Start
+                                    // TODO
+                                    break;
+                                case 0xF7: // SysEx Stop
+                                    // TODO
+                                    break;
+                                default:
+                                    break;
+                                }
+                            }
+                        }
+                        // Synchronize all GUI controllers
+                        GUI::updateAllGuis();
+                    }
+                }
+            }
+        }
+  
+        static void processMidiHandler(void* arg)
+        {
+            static_cast<esp32_midi*>(arg)->processMidi();
+        }
+    
+    public:
+    
+        esp32_midi():midi_handler("esp32"),fProcessMidiHandle(NULL)
+        {
+            // Setup UART for MIDI
+            const uart_config_t uart_config = {
+                .baud_rate = 31250,
+                .data_bits = UART_DATA_8_BITS,
+                .parity = UART_PARITY_DISABLE,
+                .stop_bits = UART_STOP_BITS_1,
+                .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
+                .rx_flow_ctrl_thresh = 122,
+                .use_ref_tick = false
+            };
+            uart_param_config(PORT_NUM, &uart_config);
+            uart_set_pin(PORT_NUM, TX1, RX1, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+            // We won't use a buffer for sending data.
+            uart_driver_install(PORT_NUM, RX_BUF_SIZE * 2, 0, 0, NULL, 0);
+        }
+    
+        virtual ~esp32_midi()
+        {
+            stopMidi();
+        }
+
+        bool startMidi()
+        {
+            // Start MIDI receive task
+            return (xTaskCreatePinnedToCore(processMidiHandler, "Faust MIDI Task", 4096, (void*)this, 5, &fProcessMidiHandle, 1) == pdPASS);
+        }
+
+        void stopMidi()
+        {
+            if (fProcessMidiHandle != nullptr) {
+                vTaskDelete(fProcessMidiHandle);
+                fProcessMidiHandle = nullptr;
+            }
+        }
+   
+};
+
+#endif
+/**************************  END  esp32-midi.h **************************/

cyfaust/resources/architecture/faust/midi/gramophone-midi.h

@@ -0,0 +1,107 @@
+/************************** BEGIN gramophone-midi.h ***********************
+FAUST Architecture File
+Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+---------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+EXCEPTION : As a special exception, you may create a larger work
+that contains this FAUST architecture section and distribute
+that work under terms of your choice, so long as this FAUST
+architecture section is not modified.
+***************************************************************************/
+
+#ifndef __gramophone_midi__
+#define __gramophone_midi__
+
+#include "blemidi.h"
+#include "esp_log.h"
+#include "faust/gui/meta.h"
+
+struct bt_meta : Meta
+{
+    // default values
+    std::string localName = "Gramophone";
+    std::string remoteName = "";
+    void declare(const char* key, const char* value)
+    {
+        if (strstr(key,"btmidi_device_name") != NULL) {
+            localName = value;
+        }
+        else if (strstr(key,"btmidi_remote_name") != NULL) {
+            remoteName = value;
+        }
+    }
+};
+
+#define GMH_TAG "GramoMidiHandler"
+
+class gramophone_midi : public midi_handler {
+    
+    private:
+    
+        bt_meta fBTMeta;
+    
+        static void callback_midi_message_received(uint8_t blemidi_port,
+                                                   uint16_t timestamp,
+                                                   uint8_t midi_status,
+                                                   uint8_t* remaining_message,
+                                                   size_t len,
+                                                   size_t continued_sysex_pos,
+                                                   void* arg)
+        {
+            gramophone_midi* midi = static_cast<gramophone_midi*>(arg);
+            if (len == 1) {
+                midi->handleData1(timestamp,(int)midi_status,0,
+                                  (int)remaining_message[0]);
+            } else if (len == 2) {
+                midi->handleData2(timestamp,(int)midi_status,0,
+                                  (int)remaining_message[0],
+                                  (int)remaining_message[1]);
+            }
+        }
+    
+    public:
+    
+        gramophone_midi(bt_meta& btMeta) : midi_handler("gramophone")
+        {
+            fBTMeta = btMeta;
+        }
+    
+        virtual ~gramophone_midi()
+        {
+            stopMidi();
+        }
+    
+        bool startMidi()
+        {
+            int status = blemidi_init((void*)callback_midi_message_received, fBTMeta.localName.c_str(), fBTMeta.remoteName.c_str(), (void*)this);
+            if (status < 0) {
+                ESP_LOGE(GMH_TAG, "BLE MIDI Driver returned status=%d", status);
+                return false;
+            } else {
+                ESP_LOGI(GMH_TAG, "BLE MIDI Driver initialized successfully");
+                return true;
+            }
+        }
+    
+        void stopMidi()
+        {
+            // This should probably implemented eventually but it can remaind as is for now
+        }
+    
+};
+
+#endif
+/**************************  END  gramophone-midi.h **************************/