cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

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

@@ -0,0 +1,315 @@
+/************************** BEGIN rt-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 __rt_midi__
+#define __rt_midi__ 
+ 
+#include <iostream>
+#include <cstdlib>
+
+#include "faust/midi/RtMidi.h"
+#include "faust/midi/midi.h"
+
+class MapUI;
+
+/**
+ *  MIDI input/output handling using RtMidi library: http://www.music.mcgill.ca/~gary/rtmidi/
+ */
+class rt_midi : public midi_handler {
+
+    private:
+    
+        std::vector<RtMidiIn*> fInput;
+        std::vector<RtMidiOut*> fOutput;
+        bool fIsVirtual;
+        bool fPolling;
+    
+        static void midiCallback(double time, std::vector<unsigned char>* message, void* arg)
+        {
+            rt_midi* midi = static_cast<rt_midi*>(arg);
+            size_t nBytes = message->size();
+            int type = (int)message->at(0) & 0xf0;
+            int channel = (int)message->at(0) & 0x0f;
+            
+            // MIDI sync
+            if (nBytes == 1) {
+                midi->handleSync(time, (int)message->at(0));
+            // One data byte messages
+            } else if (nBytes == 2) {
+                midi->handleData1(time, type, channel, (int)message->at(1));
+            // Two data bytes messages
+            } else if (nBytes == 3) {
+                midi->handleData2(time, type, channel, (int)message->at(1), (int)message->at(2));
+            } else {
+                midi->handleMessage(time, (int)message->at(0), *message);
+            }
+        }
+        
+        bool openMidiInputPorts()
+        {
+            // Get number of input ports
+            RtMidiIn midi_in;
+            unsigned nInPorts = midi_in.getPortCount();
+            if (nInPorts == 0) {
+                std::cout << "No input ports available!" << std::endl;
+                return false;
+            }
+    
+            // Then open all of them
+            for (unsigned int i = 0; i < nInPorts; i++) {
+                RtMidiIn* midi_in = new RtMidiIn();
+                midi_in->ignoreTypes(true, false, true);
+                fInput.push_back(midi_in);
+                midi_in->openPort(i);
+                if (!fPolling) {
+                    midi_in->setCallback(&midiCallback, this);
+                }
+                //std::cout << "Input port #" << i << ": " << midi_in->getPortName(i) << '\n';
+            }
+            return true;
+        }
+        
+        bool openMidiOutputPorts()
+        {
+            // Get number of output ports
+            RtMidiOut midi_out;
+            unsigned nOutPorts = midi_out.getPortCount();
+            if (nOutPorts == 0) {
+                std::cout << "No output ports available!" << std::endl;
+                return false;
+            }
+    
+            // Then open all of them
+            for (unsigned int i = 0; i < nOutPorts; i++) {
+                RtMidiOut* midi_out = new RtMidiOut();
+                fOutput.push_back(midi_out);
+                midi_out->openPort(i);
+                //std::cout << "Output port #" << i << ": " << midi_out->getPortName(i) << '\n';
+            }
+            return true;
+        }
+        
+        void chooseMidiInputPort(const std::string& name)
+        {
+            RtMidiIn* midi_in = new RtMidiIn();
+            midi_in->ignoreTypes(true, false, true);
+            fInput.push_back(midi_in);
+            if (!fPolling) {
+                midi_in->setCallback(&midiCallback, this);
+            }
+            midi_in->openVirtualPort(name);
+        }
+        
+        void chooseMidiOutPort(const std::string& name)
+        {
+            RtMidiOut* midi_out = new RtMidiOut();
+            fOutput.push_back(midi_out);
+            midi_out->openVirtualPort(name);
+        }
+        
+        void sendMessage(std::vector<unsigned char>& message)
+        {
+            for (const auto& it : fOutput) {
+                it->sendMessage(&message);
+            }
+        }
+    
+    public:
+    
+        rt_midi(const std::string& name = "RtMidi",
+                bool is_virtual = false,
+                bool is_polling = false)
+        :midi_handler(name), fIsVirtual(is_virtual), fPolling(is_polling)
+        {}
+        
+        virtual ~rt_midi()
+        {
+            stopMidi();
+        }
+        
+        bool startMidi()
+        {
+            try {
+            
+            #if TARGET_OS_IPHONE
+                if (!openMidiInputPorts())  { stopMidi(); return false; }
+                if (!openMidiOutputPorts()) { stopMidi(); return false; }
+            #else
+                if (fIsVirtual) {
+                    chooseMidiInputPort(fName);
+                    chooseMidiOutPort(fName);
+                } else {
+                    if (!openMidiInputPorts())  { stopMidi(); return false; }
+                    if (!openMidiOutputPorts()) { stopMidi(); return false; }
+                }
+            #endif
+                return true;
+                
+            } catch (RtMidiError &error) {
+                error.printMessage();
+                stopMidi();
+                return false;
+            }
+        }
+        
+        void stopMidi()
+        {
+            for (const auto& it1 : fInput) {
+                delete it1;
+            }
+            fInput.clear();
+            for (const auto& it2 : fOutput) {
+                delete it2;
+            }
+            fOutput.clear();
+        }
+    
+        // To be used in polling mode
+        int recvMessages(std::vector<MIDIMessage>* messages)
+        {
+            int count = 0;
+            double first_time_stamp = 0.;
+            for (const auto& it : fInput) {
+                std::vector<unsigned char> message;
+                double time_stamp = (uint32_t)it->getMessage(&message);
+                // Small messages
+                if (message.size() > 0) {
+                    if (count == 0) first_time_stamp = time_stamp;
+                    MIDIMessage& mes = messages->at(count++);
+                    mes.frameIndex = (uint32_t)(time_stamp - first_time_stamp);
+                    mes.byte0 = message[0];
+                    mes.byte1 = message[1];
+                    mes.byte2 = message[2];
+                }
+            }
+            return count;
+        }
+    
+        void sendMessages(std::vector<MIDIMessage>* messages, int count)
+        {
+            for (int i = 0; i < count; ++i) {
+                MIDIMessage mes1 = (*messages)[i];
+                std::vector<unsigned char> mes2;
+                mes2.push_back(mes1.byte0);
+                mes2.push_back(mes1.byte1);
+                mes2.push_back(mes1.byte2);
+                sendMessage(mes2);
+            }
+        }
+    
+        // MIDI output API
+        MapUI* keyOn(int channel, int pitch, int velocity)
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_NOTE_ON + channel);
+            message.push_back(pitch);
+            message.push_back(velocity);
+            sendMessage(message);
+            return nullptr;
+        }
+        
+        void keyOff(int channel, int pitch, int velocity) 
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_NOTE_OFF + channel);
+            message.push_back(pitch);
+            message.push_back(velocity);
+            sendMessage(message);
+        }
+        
+        void ctrlChange(int channel, int ctrl, int val) 
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_CONTROL_CHANGE + channel);
+            message.push_back(ctrl);
+            message.push_back(val);
+            sendMessage(message);
+        }
+        
+        void chanPress(int channel, int press) 
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_AFTERTOUCH + channel);
+            message.push_back(press);
+            sendMessage(message);
+        }
+        
+        void progChange(int channel, int pgm) 
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_PROGRAM_CHANGE + channel);
+            message.push_back(pgm);
+            sendMessage(message);
+        }
+          
+        void keyPress(int channel, int pitch, int press) 
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_POLY_AFTERTOUCH + channel);
+            message.push_back(pitch);
+            message.push_back(press);
+            sendMessage(message);
+        }
+   
+        void pitchWheel(int channel, int wheel) 
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_PITCH_BEND + channel);
+            message.push_back(wheel & 0x7F);		// lsb 7bit
+            message.push_back((wheel >> 7) & 0x7F);	// msb 7bit
+            sendMessage(message);
+        }
+        
+        void ctrlChange14bits(int channel, int ctrl, int value) {}
+         
+        void startSync(double date)
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_START);
+            sendMessage(message);
+        }
+       
+        void stopSync(double date)
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_STOP);
+            sendMessage(message);
+        }
+        
+        void clock(double date) 
+        {
+            std::vector<unsigned char> message;
+            message.push_back(MIDI_CLOCK);
+            sendMessage(message);
+        }
+    
+        void sysEx(double, std::vector<unsigned char>& message)
+        {
+            sendMessage(message);
+        }
+    
+};
+
+#endif // __rt_midi__
+/**************************  END  rt-midi.h **************************/

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

@@ -0,0 +1,89 @@
+/************************** BEGIN teensy-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 __teensy_midi__
+#define __teensy_midi__
+
+#include <cstdlib>
+
+#include "Arduino.h"
+#include "faust/midi/midi.h"
+
+extern usb_midi_class gUSBMIDI;
+
+/**
+ *  MIDI input/output handling for the Teensy: https://www.pjrc.com/teensy/
+ */
+class teensy_midi : public midi_handler {
+    
+    public:
+        
+        void processMidi()
+        {
+            while (gUSBMIDI.read()) {
+                
+                int type = gUSBMIDI.getType();       // which MIDI message, 128-255
+                int channel = gUSBMIDI.getChannel(); // which MIDI channel, 0-15
+                double time = (double)gUSBMIDI.Clock;
+                
+                switch(type) {
+                    case gUSBMIDI.Clock:
+                        handleClock(time);
+                        break;
+                    case usbMIDI.Start:
+                    // We can consider start and continue as identical messages
+                    case usbMIDI.Continue:
+                        handleStart(time);
+                        break;
+                    case gUSBMIDI.Stop:
+                        handleStop(time);
+                        break;
+                    case gUSBMIDI.ProgramChange:
+                        handleProgChange(time, channel, gUSBMIDI.getData1());
+                        break;
+                    case gUSBMIDI.AfterTouchChannel:
+                        handleAfterTouch(time, channel, gUSBMIDI.getData1());
+                        break;
+                    case gUSBMIDI.NoteOff:
+                        handleKeyOff(time, channel, gUSBMIDI.getData1(), gUSBMIDI.getData2());
+                        break;
+                    case gUSBMIDI.NoteOn:
+                        handleKeyOn(time, channel, gUSBMIDI.getData1(), gUSBMIDI.getData2());
+                        break;
+                    case gUSBMIDI.ControlChange:
+                        handleCtrlChange(time, channel, gUSBMIDI.getData1(), gUSBMIDI.getData2());
+                        break;
+                    case gUSBMIDI.PitchBend:
+                        handlePitchWheel(time, channel, gUSBMIDI.getData1(), gUSBMIDI.getData2());
+                        break;
+                    case gUSBMIDI.AfterTouchPoly:
+                        handlePolyAfterTouch(time, channel, gUSBMIDI.getData1(), gUSBMIDI.getData2());
+                        break;
+                }
+            }
+        }
+};
+
+#endif
+/**************************  END  teensy-midi.h **************************/

cyfaust/resources/architecture/faust/misc.h

@@ -0,0 +1,106 @@
+/************************** BEGIN misc.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 __misc__
+#define __misc__
+
+#include <algorithm>
+#include <map>
+#include <cstdlib>
+#include <string.h>
+#include <fstream>
+#include <string>
+
+#include "faust/gui/meta.h"
+
+struct MY_Meta : Meta, std::map<const char*, const char*>
+{
+    void declare(const char* key, const char* value) { (*this)[key] = value; }
+};
+
+static int lsr(int x, int n) { return int(((unsigned int)x) >> n); }
+
+static int int2pow2(int x) { int r = 0; while ((1<<r) < x) r++; return r; }
+
+static long lopt(char* argv[], const char* name, long def)
+{
+    for (int i = 0; argv[i]; i++) if (!strcmp(argv[i], name)) return std::atoi(argv[i+1]);
+    return def;
+}
+
+static long lopt1(int argc, char* argv[], const char* longname, const char* shortname, long def)
+{
+    for (int i = 2; i < argc; i++) {
+        if (strcmp(argv[i-1], shortname) == 0 || strcmp(argv[i-1], longname) == 0) {
+            return atoi(argv[i]);
+        }
+    }
+    return def;
+}
+
+static const char* lopts(char* argv[], const char* name, const char* def)
+{
+    for (int i = 0; argv[i]; i++) if (!strcmp(argv[i], name)) return argv[i+1];
+    return def;
+}
+
+static const char* lopts1(int argc, char* argv[], const char* longname, const char* shortname, const char* def)
+{
+    for (int i = 2; i < argc; i++) {
+        if (strcmp(argv[i-1], shortname) == 0 || strcmp(argv[i-1], longname) == 0) {
+            return argv[i];
+        }
+    }
+    return def;
+}
+
+static bool isopt(char* argv[], const char* name)
+{
+    for (int i = 0; argv[i]; i++) if (!strcmp(argv[i], name)) return true;
+    return false;
+}
+
+static std::string pathToContent(const std::string& path)
+{
+    std::ifstream file(path.c_str(), std::ifstream::binary);
+    
+    file.seekg(0, file.end);
+    int size = int(file.tellg());
+    file.seekg(0, file.beg);
+    
+    // And allocate buffer to that a single line can be read...
+    char* buffer = new char[size + 1];
+    file.read(buffer, size);
+    
+    // Terminate the string
+    buffer[size] = 0;
+    std::string result = buffer;
+    file.close();
+    delete [] buffer;
+    return result;
+}
+
+#endif
+
+/**************************  END  misc.h **************************/

cyfaust/resources/architecture/faust/sound-file.h

@@ -0,0 +1,132 @@
+/************************** BEGIN sound-file.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 __SoundFileReader__
+#define __SoundFileReader__
+
+#include <sndfile.h>
+#include <stdlib.h>
+
+#define BUFFER_SIZE 1024
+
+#ifndef FAUSTFLOAT
+#define READ_SAMPLE sf_readf_float
+#define FAUSTFLOAT float
+#else
+#define READ_SAMPLE sf_readf_double
+#define FAUSTFLOAT double
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SoundFileReader {
+    FAUSTFLOAT** fBuffer;
+    SNDFILE* fSoundFile;
+    int fChannels;
+    int fFramesNum;
+} SoundFileReader;
+    
+inline static SoundFileReader* createSFR(const char* name)
+{
+    SoundFileReader* reader = (SoundFileReader*)calloc(1, sizeof(SoundFileReader));
+    if (!reader) return NULL;
+
+    {
+        SF_INFO	snd_info;
+        snd_info.format = 0;
+        reader->fSoundFile = sf_open(name, SFM_READ, &snd_info);
+        
+        if (!reader->fSoundFile) {
+            printf("soundfile '%s' cannot be opened\n", name);
+            goto error;
+        }
+        
+        reader->fChannels = snd_info.channels;
+        reader->fFramesNum = snd_info.frames;
+
+        reader->fBuffer = (FAUSTFLOAT**)malloc(reader->fChannels * sizeof(FAUSTFLOAT*));
+        if (!reader) goto error;
+        
+        for (int i = 0; i < reader->fChannels; i++) {
+            reader->fBuffer[i] = (FAUSTFLOAT*)malloc(reader->fFramesNum * sizeof(FAUSTFLOAT));
+            if (!reader->fBuffer[i]) goto error;
+        }
+        
+        // Read file in memory
+        int nbf, cur_index = 0;
+        FAUSTFLOAT buffer[BUFFER_SIZE * reader->fChannels];
+        do {
+            nbf = READ_SAMPLE(reader->fSoundFile, buffer, BUFFER_SIZE);
+            for (int sample = 0; sample < nbf; sample++) {
+                for (int chan = 0; chan < reader->fChannels; chan++) {
+                    reader->fBuffer[chan][cur_index + sample] = buffer[sample * reader->fChannels + chan];
+                }
+            }
+            cur_index += nbf;
+        } while (nbf == BUFFER_SIZE);
+        
+        return reader;
+    }
+    
+error:
+    if (reader->fBuffer) free(reader->fBuffer);
+    if (reader) free(reader);
+    return NULL;
+}
+
+inline static void destroySFR(SoundFileReader* reader)
+{
+    if (reader) {
+        sf_close(reader->fSoundFile);
+        for (int i = 0; i < reader->fChannels; i++) {
+            free(reader->fBuffer[i]);
+        }
+        free(reader->fBuffer);
+        free(reader);
+    }
+}
+
+inline static int sizeSFR(SoundFileReader* reader)
+{
+    return (reader) ? reader->fFramesNum : 1; 
+}
+
+inline static int channelsSFR(SoundFileReader* reader)
+{
+    return (reader) ? reader->fChannels : 1; 
+}
+
+inline static FAUSTFLOAT sampleSFR(SoundFileReader* reader, int channel, int index)
+{   
+    return (reader) ? reader->fBuffer[channel][index] : 0.f;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/**************************  END  sound-file.h **************************/