cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/gui/SoundUI.h

@@ -0,0 +1,217 @@
+/************************** BEGIN SoundUI.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 __SoundUI_H__
+#define __SoundUI_H__
+
+#include <map>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <memory>
+
+#include "faust/gui/SimpleParser.h"
+#include "faust/gui/DecoratorUI.h"
+
+#if defined(__APPLE__) && !defined(__VCVRACK__) && !defined(JUCE_32BIT) && !defined(JUCE_64BIT)
+#include <CoreFoundation/CFBundle.h>
+#endif
+
+// Always included otherwise -i mode later on will not always include it (with the conditional includes)
+#include "faust/gui/Soundfile.h"
+
+#if defined(JUCE_32BIT) || defined(JUCE_64BIT)
+#include "faust/gui/JuceReader.h"
+static JuceReader gReader;
+#elif defined(DAISY) || defined(SUPERCOLLIDER)
+#include "faust/gui/WaveReader.h"
+static WaveReader gReader;
+#elif defined(ESP32)
+#include "faust/gui/Esp32Reader.h"
+static Esp32Reader gReader;
+#elif defined(MEMORY_READER)
+#include "faust/gui/MemoryReader.h"
+static MemoryReader gReader;
+#else
+#include "faust/gui/LibsndfileReader.h"
+static LibsndfileReader gReader;
+#endif
+
+// To be used by DSP code if no SoundUI is used
+static std::vector<std::string> gPathNameList;
+static Soundfile* defaultsound = nullptr;
+
+class SoundUI : public SoundUIInterface
+{
+		
+    protected:
+    
+        // The soundfile directories
+        Soundfile::Directories fSoundfileDir;
+        // Map to share loaded soundfiles
+        std::map<std::string, std::shared_ptr<Soundfile>> fSoundfileMap;
+        // The soundfile reader
+        std::shared_ptr<SoundfileReader> fSoundReader;
+        bool fIsDouble;
+
+     public:
+    
+        /**
+         * Create a soundfile loader which will typically use a concrete SoundfileReader like LibsndfileReader or JuceReader to load soundfiles.
+         *
+         * @param sound_directory - the base directory to look for files, which paths will be relative to this one
+         * @param sample_rate - the audio driver SR which may be different from the file SR, to possibly resample files
+         * @param reader - an alternative soundfile reader
+         * @param is_double - whether Faust code has been compiled in -double mode and soundfile buffers have to be in double
+         *
+         * @return the soundfile loader.
+         */
+        SoundUI(const std::string& sound_directory = "", int sample_rate = -1, SoundfileReader* reader = nullptr, bool is_double = false)
+        {
+            fSoundfileDir.push_back(sound_directory);
+            fSoundReader = (reader)
+                ? std::shared_ptr<SoundfileReader>(reader)
+                // the static gReader should not be deleted, so use an empty destructor
+                : std::shared_ptr<SoundfileReader>(std::shared_ptr<SoundfileReader>{}, &gReader);
+            fSoundReader->setSampleRate(sample_rate);
+            fIsDouble = is_double;
+            if (!defaultsound) defaultsound = gReader.createSoundfile(gPathNameList, MAX_CHAN, is_double);
+        }
+    
+        /**
+         * Create a soundfile loader which will typically use a concrete SoundfileReader like LibsndfileReader or JuceReader to load soundfiles.
+         *
+         * @param sound_directories - a vector of base directories to look for files, which paths will be relative to these ones
+         * @param sample_rate - the audio driver SR which may be different from the file SR, to possibly resample files
+         * @param reader - an alternative soundfile reader
+         * @param is_double - whether Faust code has been compiled in -double mode and soundfile buffers have to be in double
+         *
+         * @return the soundfile loader.
+         */
+        SoundUI(const Soundfile::Directories& sound_directories, int sample_rate = -1, SoundfileReader* reader = nullptr, bool is_double = false)
+        :fSoundfileDir(sound_directories)
+        {
+            fSoundReader = (reader)
+                ? std::shared_ptr<SoundfileReader>(reader)
+                // the static gReader should not be deleted, so use an empty destructor
+                : std::shared_ptr<SoundfileReader>(std::shared_ptr<SoundfileReader>{}, &gReader);
+            fSoundReader->setSampleRate(sample_rate);
+            fIsDouble = is_double;
+            if (!defaultsound) defaultsound = gReader.createSoundfile(gPathNameList, MAX_CHAN, is_double);
+        }
+    
+        virtual ~SoundUI()
+        {}
+
+        // -- soundfiles
+        virtual void addSoundfile(const char* label, const char* url, Soundfile** sf_zone)
+        {
+            const char* saved_url = url; // 'url' is consumed by parseMenuList2
+            std::vector<std::string> file_name_list;
+            
+            bool menu = parseMenuList2(url, file_name_list, true);
+            // If not a list, we have as single file
+            if (!menu) { file_name_list.push_back(saved_url); }
+            
+            // Parse the possible list
+            std::string saved_url_real = std::string(saved_url) + "_" + std::to_string(fIsDouble); // fIsDouble is used in the key
+            if (fSoundfileMap.find(saved_url_real) == fSoundfileMap.end()) {
+                // Check all files and get their complete path
+                std::vector<std::string> path_name_list = fSoundReader->checkFiles(fSoundfileDir, file_name_list);
+                // Read them and create the Soundfile
+                Soundfile* sound_file = fSoundReader->createSoundfile(path_name_list, MAX_CHAN, fIsDouble);
+                if (sound_file) {
+                    fSoundfileMap[saved_url_real] = std::shared_ptr<Soundfile>(sound_file);
+                } else {
+                    // If failure, use 'defaultsound'
+                    std::cerr << "addSoundfile : soundfile for " << saved_url << " cannot be created !" << std::endl;
+                    *sf_zone = defaultsound;
+                    return;
+                }
+            }
+            
+            // Get the soundfile pointer
+            *sf_zone = fSoundfileMap[saved_url_real].get();
+        }
+    
+        /**
+         * An OS dependant function to get the path of the running executable or plugin.
+         * This will typically be used when creating a SoundUI soundfile loader, like new SoundUI(SoundUI::getBinaryPath());
+         *
+         * @return the running executable or plugin path.
+         */
+        static std::string getBinaryPath()
+        {
+            std::string bundle_path_str;
+        #if defined(__APPLE__) && !defined(__VCVRACK__) && !defined(JUCE_32BIT) && !defined(JUCE_64BIT)
+            CFURLRef bundle_ref = CFBundleCopyBundleURL(CFBundleGetMainBundle());
+            if (!bundle_ref) { std::cerr << "getBinaryPath CFBundleCopyBundleURL error\n"; return ""; }
+      
+            UInt8 bundle_path[1024];
+            if (CFURLGetFileSystemRepresentation(bundle_ref, true, bundle_path, 1024)) {
+                bundle_path_str = std::string((char*)bundle_path);
+            } else {
+                std::cerr << "getBinaryPath CFURLGetFileSystemRepresentation error\n";
+            }
+        #endif
+        #ifdef ANDROID_DRIVER
+            bundle_path_str = "/data/data/__CURRENT_ANDROID_PACKAGE__/files";
+        #endif
+            return bundle_path_str;
+        }
+    
+        /**
+         * An OS dependant function to get the path of the running executable or plugin.
+         * This will typically be used when creating a SoundUI soundfile loader, like new SoundUI(SoundUI::getBinaryPathFrom());
+         *
+         * @param path - entry point to start getting the path of the running executable or plugin.
+         *
+         * @return the running executable or plugin path.
+         */
+        static std::string getBinaryPathFrom(const std::string& path)
+        {
+            std::string bundle_path_str;
+        #if defined(__APPLE__) && !defined(__VCVRACK__) && !defined(JUCE_32BIT) && !defined(JUCE_64BIT)
+            CFBundleRef bundle = CFBundleGetBundleWithIdentifier(CFStringCreateWithCString(kCFAllocatorDefault, path.c_str(), CFStringGetSystemEncoding()));
+            if (!bundle) { std::cerr << "getBinaryPathFrom CFBundleGetBundleWithIdentifier error '" << path << "'" << std::endl; return ""; }
+         
+            CFURLRef bundle_ref = CFBundleCopyBundleURL(bundle);
+            if (!bundle_ref) { std::cerr << "getBinaryPathFrom CFBundleCopyBundleURL error\n"; return ""; }
+            
+            UInt8 bundle_path[1024];
+            if (CFURLGetFileSystemRepresentation(bundle_ref, true, bundle_path, 1024)) {
+                bundle_path_str = std::string((char*)bundle_path);
+            } else {
+                std::cerr << "getBinaryPathFrom CFURLGetFileSystemRepresentation error\n";
+            }
+        #endif
+        #ifdef ANDROID_DRIVER
+            bundle_path_str = "/data/data/__CURRENT_ANDROID_PACKAGE__/files";
+        #endif
+            return bundle_path_str;
+        }
+};
+
+#endif
+/**************************  END  SoundUI.h **************************/

cyfaust/resources/architecture/faust/gui/Soundfile.h

@@ -0,0 +1,342 @@
+/************************** BEGIN Soundfile.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 __Soundfile__
+#define __Soundfile__
+
+#include <string.h>
+#include <string>
+#include <vector>
+
+#ifndef FAUSTFLOAT
+#define FAUSTFLOAT float
+#endif
+
+#define BUFFER_SIZE 1024
+#define SAMPLE_RATE 44100
+#define MAX_CHAN 64
+#define MAX_SOUNDFILE_PARTS 256
+
+#ifdef _MSC_VER
+#define PRE_PACKED_STRUCTURE __pragma(pack(push, 1))
+#define POST_PACKED_STRUCTURE \
+    ;                         \
+    __pragma(pack(pop))
+#else
+#define PRE_PACKED_STRUCTURE
+#define POST_PACKED_STRUCTURE __attribute__((__packed__))
+#endif
+
+/*
+ The soundfile structure to be used by the DSP code. Soundfile has a MAX_SOUNDFILE_PARTS parts 
+ (even a single soundfile or an empty soundfile). 
+ The fLength, fOffset and fSR fields are filled accordingly by repeating the actual parts if needed.
+ The fBuffers contains MAX_CHAN non-interleaved arrays of samples.
+ 
+ It has to be 'packed' to that the LLVM backend can correctly access it.
+
+ Index computation:
+    - p is the current part number [0..MAX_SOUNDFILE_PARTS-1] (must be proved by the type system)
+    - i is the current position in the part. It will be constrained between [0..length]
+    - idx(p,i) = fOffset[p] + max(0, min(i, fLength[p]));
+*/
+
+PRE_PACKED_STRUCTURE
+struct Soundfile {
+    void* fBuffers; // will correspond to a double** or float** pointer chosen at runtime
+    int* fLength;   // length of each part (so fLength[P] contains the length in frames of part P)
+    int* fSR;       // sample rate of each part (so fSR[P] contains the SR of part P)
+    int* fOffset;   // offset of each part in the global buffer (so fOffset[P] contains the offset in frames of part P)
+    int fChannels;  // max number of channels of all concatenated files
+    int fParts;     // the total number of loaded parts
+    bool fIsDouble; // keep the sample format (float or double)
+
+    Soundfile(int cur_chan, int length, int max_chan, int total_parts, bool is_double)
+    {
+        fLength   = new int[MAX_SOUNDFILE_PARTS];
+        fSR       = new int[MAX_SOUNDFILE_PARTS];
+        fOffset   = new int[MAX_SOUNDFILE_PARTS];
+        fIsDouble = is_double;
+        fChannels = cur_chan;
+        fParts    = total_parts;
+        if (fIsDouble) {
+            fBuffers = allocBufferReal<double>(cur_chan, length, max_chan);
+        } else {
+            fBuffers = allocBufferReal<float>(cur_chan, length, max_chan);
+        }
+    }
+    
+    template <typename REAL>
+    void* allocBufferReal(int cur_chan, int length, int max_chan)
+    {
+        REAL** buffers = new REAL*[max_chan];
+        for (int chan = 0; chan < cur_chan; chan++) {
+            buffers[chan] = new REAL[length];
+            memset(buffers[chan], 0, sizeof(REAL) * length);
+        }
+        return buffers;
+    }
+    
+    void copyToOut(int size, int channels, int max_channels, int offset, void* buffer)
+    {
+        if (fIsDouble) {
+            copyToOutReal<double>(size, channels, max_channels, offset, buffer);
+       } else {
+            copyToOutReal<float>(size, channels, max_channels, offset, buffer);
+        }
+    }
+    
+    void shareBuffers(int cur_chan, int max_chan)
+    {
+        // Share the same buffers for all other channels so that we have max_chan channels available
+        if (fIsDouble) {
+            for (int chan = cur_chan; chan < max_chan; chan++) {
+                static_cast<double**>(fBuffers)[chan] = static_cast<double**>(fBuffers)[chan % cur_chan];
+            }
+        } else {
+            for (int chan = cur_chan; chan < max_chan; chan++) {
+                static_cast<float**>(fBuffers)[chan] = static_cast<float**>(fBuffers)[chan % cur_chan];
+            }
+        }
+    }
+    
+    template <typename REAL>
+    void copyToOutReal(int size, int channels, int max_channels, int offset, void* buffer)
+    {
+        for (int sample = 0; sample < size; sample++) {
+            for (int chan = 0; chan < channels; chan++) {
+                static_cast<REAL**>(fBuffers)[chan][offset + sample] = static_cast<REAL*>(buffer)[sample * max_channels + chan];
+            }
+        }
+    }
+    
+    template <typename REAL>
+    void getBuffersOffsetReal(void* buffers, int offset)
+    {
+        for (int chan = 0; chan < fChannels; chan++) {
+            static_cast<REAL**>(buffers)[chan] = &(static_cast<REAL**>(fBuffers))[chan][offset];
+        }
+    }
+    
+    void emptyFile(int part, int& offset)
+    {
+        fLength[part] = BUFFER_SIZE;
+        fSR[part] = SAMPLE_RATE;
+        fOffset[part] = offset;
+        // Update offset
+        offset += fLength[part];
+    }
+ 
+    ~Soundfile()
+    {
+        // Free the real channels only
+        if (fIsDouble) {
+            for (int chan = 0; chan < fChannels; chan++) {
+                delete[] static_cast<double**>(fBuffers)[chan];
+            }
+            delete[] static_cast<double**>(fBuffers);
+        } else {
+            for (int chan = 0; chan < fChannels; chan++) {
+                delete[] static_cast<float**>(fBuffers)[chan];
+            }
+            delete[] static_cast<float**>(fBuffers);
+        }
+        delete[] fLength;
+        delete[] fSR;
+        delete[] fOffset;
+    }
+
+    typedef std::vector<std::string> Directories;
+    
+} POST_PACKED_STRUCTURE;
+
+/*
+ The generic soundfile reader.
+ */
+
+class SoundfileReader {
+    
+   protected:
+    
+    int fDriverSR;
+   
+    // Check if a soundfile exists and return its real path_name
+    std::string checkFile(const Soundfile::Directories& sound_directories, const std::string& file_name)
+    {
+        if (checkFile(file_name)) {
+            return file_name;
+        } else {
+            for (size_t i = 0; i < sound_directories.size(); i++) {
+                std::string path_name = sound_directories[i] + "/" + file_name;
+                if (checkFile(path_name)) { return path_name; }
+            }
+            return "";
+        }
+    }
+    
+    bool isResampling(int sample_rate) { return (fDriverSR > 0 && fDriverSR != sample_rate); }
+ 
+    // To be implemented by subclasses
+
+    /**
+     * Check the availability of a sound resource.
+     *
+     * @param path_name - the name of the file, or sound resource identified this way
+     *
+     * @return true if the sound resource is available, false otherwise.
+     */
+    virtual bool checkFile(const std::string& path_name) = 0;
+    
+    /**
+     * Check the availability of a sound resource.
+     *
+     * @param buffer - the sound buffer
+     * @param size - the sound buffer length
+     *
+     * @return true if the sound resource is available, false otherwise.
+     */
+
+    virtual bool checkFile(unsigned char* buffer, size_t size) { return true; }
+
+    /**
+     * Get the channels and length values of the given sound resource.
+     *
+     * @param path_name - the name of the file, or sound resource identified this way
+     * @param channels - the channels value to be filled with the sound resource number of channels
+     * @param length - the length value to be filled with the sound resource length in frames
+     *
+     */
+    virtual void getParamsFile(const std::string& path_name, int& channels, int& length) = 0;
+    
+    /**
+     * Get the channels and length values of the given sound resource.
+     *
+     * @param buffer - the sound buffer
+     * @param size - the sound buffer length
+     * @param channels - the channels value to be filled with the sound resource number of channels
+     * @param length - the length value to be filled with the sound resource length in frames
+     *
+     */
+    virtual void getParamsFile(unsigned char* buffer, size_t size, int& channels, int& length) {}
+
+    /**
+     * Read one sound resource and fill the 'soundfile' structure accordingly
+     *
+     * @param soundfile - the soundfile to be filled
+     * @param path_name - the name of the file, or sound resource identified this way
+     * @param part - the part number to be filled in the soundfile
+     * @param offset - the offset value to be incremented with the actual sound resource length in frames
+     * @param max_chan - the maximum number of mono channels to fill
+     *
+     */
+    virtual void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) = 0;
+    
+    /**
+     * Read one sound resource and fill the 'soundfile' structure accordingly
+     *
+     * @param soundfile - the soundfile to be filled
+     * @param buffer - the sound buffer
+     * @param size - the sound buffer length
+     * @param part - the part number to be filled in the soundfile
+     * @param offset - the offset value to be incremented with the actual sound resource length in frames
+     * @param max_chan - the maximum number of mono channels to fill
+     *
+     */
+    virtual void readFile(Soundfile* soundfile, unsigned char* buffer, size_t size, int part, int& offset, int max_chan) {}
+
+  public:
+    
+    SoundfileReader() {}
+    virtual ~SoundfileReader() {}
+    
+    void setSampleRate(int sample_rate) { fDriverSR = sample_rate; }
+   
+    Soundfile* createSoundfile(const std::vector<std::string>& path_name_list, int max_chan, bool is_double)
+    {
+        try {
+            int cur_chan = 1; // At least one channel
+            int total_length = 0;
+            
+            // Compute total length and channels max of all files
+            for (size_t i = 0; i < path_name_list.size(); i++) {
+                int chan, length;
+                if (path_name_list[i] == "__empty_sound__") {
+                    length = BUFFER_SIZE;
+                    chan = 1;
+                } else {
+                    getParamsFile(path_name_list[i], chan, length);
+                }
+                cur_chan = std::max<int>(cur_chan, chan);
+                total_length += length;
+            }
+           
+            // Complete with empty parts
+            total_length += (MAX_SOUNDFILE_PARTS - path_name_list.size()) * BUFFER_SIZE;
+            
+            // Create the soundfile
+            Soundfile* soundfile = new Soundfile(cur_chan, total_length, max_chan, path_name_list.size(), is_double);
+            
+            // Init offset
+            int offset = 0;
+            
+            // Read all files
+            for (size_t i = 0; i < path_name_list.size(); i++) {
+                if (path_name_list[i] == "__empty_sound__") {
+                    soundfile->emptyFile(i, offset);
+                } else {
+                    readFile(soundfile, path_name_list[i], i, offset, max_chan);
+                }
+            }
+            
+            // Complete with empty parts
+            for (size_t i = path_name_list.size(); i < MAX_SOUNDFILE_PARTS; i++) {
+                soundfile->emptyFile(i, offset);
+            }
+            
+            // Share the same buffers for all other channels so that we have max_chan channels available
+            soundfile->shareBuffers(cur_chan, max_chan);
+            return soundfile;
+            
+        } catch (...) {
+            return nullptr;
+        }
+    }
+
+    // Check if all soundfiles exist and return their real path_name
+    std::vector<std::string> checkFiles(const Soundfile::Directories& sound_directories,
+                                        const std::vector<std::string>& file_name_list)
+    {
+        std::vector<std::string> path_name_list;
+        for (size_t i = 0; i < file_name_list.size(); i++) {
+            std::string path_name = checkFile(sound_directories, file_name_list[i]);
+            // If 'path_name' is not found, it is replaced by an empty sound (= silence)
+            path_name_list.push_back((path_name == "") ? "__empty_sound__" : path_name);
+        }
+        return path_name_list;
+    }
+
+};
+
+#endif
+/**************************  END  Soundfile.h **************************/

cyfaust/resources/architecture/faust/gui/Styles/Blue.qrc

@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+<file>Blue.qss</file>
+</qresource>
+</RCC>