cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

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

@@ -0,0 +1,475 @@
+/************************** BEGIN 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 __midi__
+#define __midi__
+
+#include <vector>
+#include <string>
+#include <string.h>
+#include <algorithm>
+#include <assert.h>
+
+#include "faust/export.h"
+
+class FAUST_API MapUI;
+
+/**
+ * A timestamped short MIDI message used with SOUL.
+ */
+
+// Force contiguous memory layout
+#pragma pack (push, 1)
+struct MIDIMessage
+{
+    uint32_t frameIndex;
+    uint8_t byte0, byte1, byte2;
+};
+#pragma pack (pop)
+
+/**
+ * For timestamped MIDI messages (in usec).
+ */
+struct DatedMessage {
+    
+    double fDate;
+    unsigned char fBuffer[3];
+    size_t fSize;
+    
+    DatedMessage(double date, unsigned char* buffer, size_t size)
+    :fDate(date), fSize(size)
+    {
+        assert(size <= 3);
+        memcpy(fBuffer, buffer, size);
+    }
+    
+    DatedMessage():fDate(0.0), fSize(0)
+    {}
+    
+};
+
+/**
+ * MIDI processor definition.
+ *
+ * MIDI input or output handling classes will implement this interface,
+ * so the same method names (keyOn, keyOff, ctrlChange...) will be used either
+ * when decoding MIDI input or encoding MIDI output events.
+ * MIDI channel is numbered in [0..15] in this layer.
+ */
+class midi {
+
+    public:
+
+        midi() {}
+        virtual ~midi() {}
+
+        // Additional time-stamped API for MIDI input
+        virtual MapUI* keyOn(double, int channel, int pitch, int velocity)
+        {
+            return keyOn(channel, pitch, velocity);
+        }
+        
+        virtual void keyOff(double, int channel, int pitch, int velocity = 0)
+        {
+            keyOff(channel, pitch, velocity);
+        }
+    
+        virtual void keyPress(double, int channel, int pitch, int press)
+        {
+            keyPress(channel, pitch, press);
+        }
+        
+        virtual void chanPress(double date, int channel, int press)
+        {
+            chanPress(channel, press);
+        }
+    
+        virtual void pitchWheel(double, int channel, int wheel)
+        {
+            pitchWheel(channel, wheel);
+        }
+           
+        virtual void ctrlChange(double, int channel, int ctrl, int value)
+        {
+            ctrlChange(channel, ctrl, value);
+        }
+    
+        virtual void ctrlChange14bits(double, int channel, int ctrl, int value)
+        {
+            ctrlChange14bits(channel, ctrl, value);
+        }
+    
+        virtual void rpn(double, int channel, int ctrl, int value)
+        {
+            rpn(channel, ctrl, value);
+        }
+
+        virtual void progChange(double, int channel, int pgm)
+        {
+            progChange(channel, pgm);
+        }
+    
+        virtual void sysEx(double, std::vector<unsigned char>& message)
+        {
+            sysEx(message);
+        }
+
+        // MIDI sync
+        virtual void startSync(double date)  {}
+        virtual void stopSync(double date)   {}
+        virtual void clock(double date)  {}
+
+        // Standard MIDI API
+        virtual MapUI* keyOn(int channel, int pitch, int velocity)      { return nullptr; }
+        virtual void keyOff(int channel, int pitch, int velocity)       {}
+        virtual void keyPress(int channel, int pitch, int press)        {}
+        virtual void chanPress(int channel, int press)                  {}
+        virtual void ctrlChange(int channel, int ctrl, int value)       {}
+        virtual void ctrlChange14bits(int channel, int ctrl, int value) {}
+        virtual void rpn(int channel, int ctrl, int value)              {}
+        virtual void pitchWheel(int channel, int wheel)                 {}
+        virtual void progChange(int channel, int pgm)                   {}
+        virtual void sysEx(std::vector<unsigned char>& message)         {}
+
+        enum MidiStatus {
+            // channel voice messages
+            MIDI_NOTE_OFF = 0x80,
+            MIDI_NOTE_ON = 0x90,
+            MIDI_CONTROL_CHANGE = 0xB0,
+            MIDI_PROGRAM_CHANGE = 0xC0,
+            MIDI_PITCH_BEND = 0xE0,
+            MIDI_AFTERTOUCH = 0xD0,         // aka channel pressure
+            MIDI_POLY_AFTERTOUCH = 0xA0,    // aka key pressure
+            MIDI_CLOCK = 0xF8,
+            MIDI_START = 0xFA,
+            MIDI_CONT = 0xFB,
+            MIDI_STOP = 0xFC,
+            MIDI_SYSEX_START = 0xF0,
+            MIDI_SYSEX_STOP = 0xF7
+        };
+
+        enum MidiCtrl {
+            ALL_NOTES_OFF = 123,
+            ALL_SOUND_OFF = 120
+        };
+    
+        enum MidiNPN {
+            PITCH_BEND_RANGE = 0
+        };
+
+};
+
+/**
+ * A class to decode NRPN and RPN messages, adapted from JUCE forum message:
+ * https://forum.juce.com/t/14bit-midi-controller-support/11517
+ */
+class MidiNRPN {
+    
+    private:
+    
+        bool ctrlnew;
+        int ctrlnum;
+        int ctrlval;
+        
+        int nrpn_lsb, nrpn_msb;
+        int data_lsb, data_msb;
+        
+        enum
+        {
+            midi_nrpn_lsb = 98,
+            midi_nrpn_msb = 99,
+            midi_rpn_lsb  = 100,
+            midi_rpn_msb  = 101,
+            midi_data_lsb = 38,
+            midi_data_msb = 6
+        };
+    
+    public:
+        
+        MidiNRPN(): ctrlnew(false), nrpn_lsb(-1), nrpn_msb(-1), data_lsb(-1), data_msb(-1)
+        {}
+        
+        // return true if the message has been filtered
+        bool process(int data1, int data2)
+        {
+            switch (data1)
+            {
+                case midi_nrpn_lsb: nrpn_lsb = data2; return true;
+                case midi_nrpn_msb: nrpn_msb = data2; return true;
+                case midi_rpn_lsb: {
+                    if (data2 == 127) {
+                        nrpn_lsb = data_lsb = -1;
+                    } else {
+                        nrpn_lsb = 0;
+                        data_lsb = -1;
+                    }
+                    return true;
+                }
+                case midi_rpn_msb: {
+                    if (data2 == 127) {
+                        nrpn_msb = data_msb = -1;
+                    } else {
+                        nrpn_msb = 0;
+                        data_msb = -1;
+                    }
+                    return true;
+                }
+                case midi_data_lsb:
+                case midi_data_msb:
+                {
+                    if (data1 == midi_data_msb) {
+                        if (nrpn_msb < 0) {
+                            return false;
+                        }
+                        data_msb = data2;
+                    } else { // midi_data_lsb
+                        if (nrpn_lsb < 0) {
+                            return false;
+                        }
+                        data_lsb = data2;
+                    }
+                    if (data_lsb >= 0 && data_msb >= 0) {
+                        ctrlnum = (nrpn_msb << 7) | nrpn_lsb;
+                        ctrlval = (data_msb << 7) | data_lsb;
+                        data_lsb = data_msb = -1;
+                        nrpn_msb = nrpn_lsb = -1;
+                        ctrlnew = true;
+                    }
+                    return true;
+                }
+                default: return false;
+            };
+        }
+        
+        bool hasNewNRPN() { bool res = ctrlnew; ctrlnew = false; return res; }
+        
+        // results in [0, 16383]
+        int getCtrl() const { return ctrlnum; }
+        int getVal() const { return ctrlval; }
+    
+};
+
+/**
+ * A pure interface for MIDI handlers that can send/receive MIDI messages to/from 'midi' objects.
+ */
+struct midi_interface {
+    virtual void addMidiIn(midi* midi_dsp)      = 0;
+    virtual void removeMidiIn(midi* midi_dsp)   = 0;
+    virtual ~midi_interface() {}
+};
+
+/****************************************************
+ * Base class for MIDI input handling.
+ *
+ * Shared common code used for input handling:
+ * - decoding Real-Time messages: handleSync
+ * - decoding one data byte messages: handleData1
+ * - decoding two data byte messages: handleData2
+ * - getting ready messages in polling mode
+ ****************************************************/
+class midi_handler : public midi, public midi_interface {
+
+    protected:
+
+        std::vector<midi*> fMidiInputs;
+        std::string fName;
+        MidiNRPN fNRPN;
+    
+        int range(int min, int max, int val) { return (val < min) ? min : ((val >= max) ? max : val); }
+  
+    public:
+
+        midi_handler(const std::string& name = "MIDIHandler"):midi_interface(), fName(name) {}
+        virtual ~midi_handler() {}
+
+        void addMidiIn(midi* midi_dsp) { if (midi_dsp) fMidiInputs.push_back(midi_dsp); }
+        void removeMidiIn(midi* midi_dsp)
+        {
+            std::vector<midi*>::iterator it = std::find(fMidiInputs.begin(), fMidiInputs.end(), midi_dsp);
+            if (it != fMidiInputs.end()) {
+                fMidiInputs.erase(it);
+            }
+        }
+
+        // Those 2 methods have to be implemented by subclasses
+        virtual bool startMidi() { return true; }
+        virtual void stopMidi() {}
+    
+        void setName(const std::string& name) { fName = name; }
+        std::string getName() { return fName; }
+    
+        // To be used in polling mode
+        virtual int recvMessages(std::vector<MIDIMessage>* message) { return 0; }
+        virtual void sendMessages(std::vector<MIDIMessage>* message, int count) {}
+    
+        // MIDI Real-Time
+        void handleClock(double time)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->clock(time);
+            }
+        }
+        
+        void handleStart(double time)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->startSync(time);
+            }
+        }
+        
+        void handleStop(double time)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->stopSync(time);
+            }
+        }
+    
+        void handleSync(double time, int type)
+        {
+            if (type == MIDI_CLOCK) {
+                handleClock(time);
+            // We can consider start and continue as identical messages
+            } else if ((type == MIDI_START) || (type == MIDI_CONT)) {
+                handleStart(time);
+            } else if (type == MIDI_STOP) {
+                handleStop(time);
+            }
+        }
+    
+        // MIDI 1 data
+        void handleProgChange(double time, int channel, int data1)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->progChange(time, channel, data1);
+            }
+        }
+    
+        void handleAfterTouch(double time, int channel, int data1)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->chanPress(time, channel, data1);
+            }
+        }
+
+        void handleData1(double time, int type, int channel, int data1)
+        {
+            if (type == MIDI_PROGRAM_CHANGE) {
+                handleProgChange(time, channel, data1);
+            } else if (type == MIDI_AFTERTOUCH) {
+                handleAfterTouch(time, channel, data1);
+            }
+        }
+    
+        // MIDI 2 datas
+        void handleKeyOff(double time, int channel, int data1, int data2)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->keyOff(time, channel, data1, data2);
+            }
+        }
+        
+        void handleKeyOn(double time, int channel, int data1, int data2)
+        {
+            if (data2 == 0) {
+                handleKeyOff(time, channel, data1, data2);
+            } else {
+                for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                    fMidiInputs[i]->keyOn(time, channel, data1, data2);
+                }
+            }
+        }
+    
+        void handleCtrlChange(double time, int channel, int data1, int data2)
+        {
+            // Special processing for NRPN and RPN
+            if (fNRPN.process(data1, data2)) {
+                if (fNRPN.hasNewNRPN()) {
+                    for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                        fMidiInputs[i]->rpn(time, channel, fNRPN.getCtrl(), fNRPN.getVal());
+                    }
+                }
+            } else {
+                for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                    fMidiInputs[i]->ctrlChange(time, channel, data1, data2);
+                }
+            }
+        }
+        
+        void handlePitchWheel(double time, int channel, int data1, int data2)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->pitchWheel(time, channel, (data2 << 7) + data1);
+            }
+        }
+    
+        void handlePitchWheel(double time, int channel, int bend)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->pitchWheel(time, channel, bend);
+            }
+        }
+        
+        void handlePolyAfterTouch(double time, int channel, int data1, int data2)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->keyPress(time, channel, data1, data2);
+            }
+        }
+  
+        void handleData2(double time, int type, int channel, int data1, int data2)
+        {
+            if (type == MIDI_NOTE_OFF) {
+                handleKeyOff(time, channel,  data1, data2);
+            } else if (type == MIDI_NOTE_ON) {
+                handleKeyOn(time, channel, data1, data2);
+            } else if (type == MIDI_CONTROL_CHANGE) {
+                handleCtrlChange(time, channel, data1, data2);
+            } else if (type == MIDI_PITCH_BEND) {
+                handlePitchWheel(time, channel, data1, data2);
+            } else if (type == MIDI_POLY_AFTERTOUCH) {
+                handlePolyAfterTouch(time, channel, data1, data2);
+            }
+        }
+    
+        // SysEx
+        void handleSysex(double time, std::vector<unsigned char>& message)
+        {
+            for (unsigned int i = 0; i < fMidiInputs.size(); i++) {
+                fMidiInputs[i]->sysEx(time, message);
+            }
+        }
+    
+        void handleMessage(double time, int type, std::vector<unsigned char>& message)
+        {
+            if (type == MIDI_SYSEX_START) {
+                handleSysex(time, message);
+            }
+        }
+  
+};
+
+#define ucast(v) static_cast<unsigned char>(v)
+
+#endif // __midi__
+/**************************  END  midi.h **************************/