cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

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

@@ -0,0 +1,364 @@
+/************************** BEGIN WaveReader.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 __WaveReader__
+#define __WaveReader__
+
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include "faust/gui/Soundfile.h"
+
+// WAVE file description
+typedef struct {
+    
+    // The canonical WAVE format starts with the RIFF header
+    
+    /**
+     Variable: chunk_id
+     Contains the letters "RIFF" in ASCII form (0x52494646 big-endian form).
+     **/
+    int chunk_id;
+    
+    /**
+     Variable: chunk_size
+     36 + SubChunk2Size, or more precisely: 4 + (8 + SubChunk1Size) + (8 + SubChunk2Size)
+     This is the size of the rest of the chunk following this number.
+     This is the size of the entire file in bytes minus 8 bytes for the
+     two fields not included in this count: ChunkID and ChunkSize.
+     **/
+    int chunk_size;
+    
+    /**
+     Variable: format
+     Contains the letters "WAVE" (0x57415645 big-endian form).
+     **/
+    int format;
+    
+    // The "WAVE" format consists of two subchunks: "fmt " and "data":
+    // The "fmt " subchunk describes the sound data's format:
+    
+    /**
+     Variable: subchunk_1_id
+     Contains the letters "fmt " (0x666d7420 big-endian form).
+     **/
+    int subchunk_1_id;
+    
+    /**
+     Variable: subchunk_1_size
+     16 for PCM. This is the size of the rest of the Subchunk which follows this number.
+     **/
+    int subchunk_1_size;
+    
+    /**
+     Variable: audio_format
+     PCM = 1 (i.e. Linear quantization) Values other than 1 indicate some form of compression.
+     **/
+    short audio_format;
+    
+    /**
+     Variable: num_channels
+     Mono = 1, Stereo = 2, etc.
+     **/
+    short num_channels;
+    
+    /**
+     Variable: sample_rate
+     8000, 44100, etc.
+     **/
+    int sample_rate;
+    
+    /**
+     Variable: byte_rate
+     == SampleRate * NumChannels * BitsPerSample/8
+     **/
+    int byte_rate;
+    
+    /**
+     Variable: block_align
+     == NumChannels * BitsPerSample/8
+     The number of bytes for one sample including all channels. I wonder what happens
+     when this number isn't an integer?
+     **/
+    short block_align;
+    
+    /**
+     Variable: bits_per_sample
+     8 bits = 8, 16 bits = 16, etc.
+     **/
+    short bits_per_sample;
+    
+    /**
+     Here should come some extra parameters which i will avoid.
+     **/
+    
+    // The "data" subchunk contains the size of the data and the actual sound:
+    
+    /**
+     Variable: subchunk_2_id
+     Contains the letters "data" (0x64617461 big-endian form).
+     **/
+    int subchunk_2_id;
+    
+    /**
+     Variable: subchunk_2_size
+     == NumSamples * NumChannels * BitsPerSample/8
+     This is the number of bytes in the data. You can also think of this as the size
+     of the read of the subchunk following this number.
+     **/
+    int subchunk_2_size;
+    
+    /**
+     Variable: data
+     The actual sound data.
+     **/
+    char* data;
+    
+} wave_t;
+
+// Base reader
+struct Reader {
+    
+    wave_t* fWave;
+
+    inline int is_big_endian()
+    {
+        int a = 1;
+        return !((char*)&a)[0];
+    }
+    
+    inline int convert_to_int(char* buffer, int len)
+    {
+        int a = 0;
+        if (!is_big_endian()) {
+            for(int i = 0; i < len; i++) {
+                ((char*)&a)[i] = buffer[i];
+            }
+        } else {
+            for(int i = 0; i < len; i++) {
+                ((char*)&a)[3-i] = buffer[i];
+            }
+        }
+        return a;
+    }
+    
+    Reader()
+    {
+        fWave = (wave_t*)calloc(1, sizeof(wave_t));
+    }
+
+    virtual ~Reader()
+    {
+        free(fWave->data);
+        free(fWave);
+    }
+
+    bool load_wave_header()
+    {
+        char buffer[4];
+        
+        read(buffer, 4);
+        if (strncmp(buffer, "RIFF", 4) != 0) {
+            fprintf(stderr, "This is not valid WAV file!\n");
+            return false;
+        }
+        fWave->chunk_id = convert_to_int(buffer, 4);
+        
+        read(buffer, 4);
+        fWave->chunk_size = convert_to_int(buffer, 4);
+        
+        read(buffer, 4);
+        fWave->format = convert_to_int(buffer, 4);
+        
+        read(buffer, 4);
+        fWave->subchunk_1_id = convert_to_int(buffer, 4);
+        
+        read(buffer, 4);
+        fWave->subchunk_1_size = convert_to_int(buffer, 4);
+        
+        read(buffer, 2);
+        fWave->audio_format = convert_to_int(buffer, 2);
+        
+        read(buffer, 2);
+        fWave->num_channels = convert_to_int(buffer, 2);
+        
+        read(buffer, 4);
+        fWave->sample_rate = convert_to_int(buffer, 4);
+        
+        read(buffer, 4);
+        fWave->byte_rate = convert_to_int(buffer, 4);
+        
+        read(buffer, 2);
+        fWave->block_align = convert_to_int(buffer, 2);
+        
+        read(buffer, 2);
+        fWave->bits_per_sample = convert_to_int(buffer, 2);
+        
+        read(buffer, 4);
+        if (strncmp(buffer, "data", 4) != 0) {
+            read(buffer, 4);
+            int _extra_size = convert_to_int(buffer, 4);
+            char _extra_data[_extra_size];
+            read(_extra_data, _extra_size);
+            read(buffer, 4);
+            fWave->subchunk_2_id = convert_to_int(buffer, 4);
+        } else {
+            fWave->subchunk_2_id = convert_to_int(buffer, 4);
+        }
+        
+        read(buffer, 4);
+        fWave->subchunk_2_size = convert_to_int(buffer, 4);
+        return true;
+    }
+    
+    void load_wave()
+    {
+        // Read sound data
+        fWave->data = (char*)malloc(fWave->subchunk_2_size);
+        read(fWave->data, fWave->subchunk_2_size);
+    }
+
+    virtual void read(char* buffer, unsigned int size) = 0;
+   
+};
+
+struct FileReader : public Reader {
+    
+    FILE* fFile;
+    
+    FileReader(const std::string& file_path)
+    {
+        fFile = fopen(file_path.c_str(), "rb");
+        if (!fFile) {
+            fprintf(stderr, "FileReader : cannot open file!\n");
+            throw -1;
+        }
+        if (!load_wave_header()) {
+            fprintf(stderr, "FileReader : not a WAV file!\n");
+            throw -1;
+        }
+    }
+    
+    virtual ~FileReader()
+    {
+        fclose(fFile);
+    }
+    
+    void read(char* buffer, unsigned int size)
+    {
+        fread(buffer, 1, size, fFile);
+    }
+    
+};
+
+extern const uint8_t file_start[] asm("_binary_FILE_start");
+extern const uint8_t file_end[]   asm("_binary_FILE_end");
+
+struct MemoryReader : public Reader {
+    
+    int fPos;
+    const uint8_t* fStart;
+    const uint8_t* fEnd;
+    
+    MemoryReader(const uint8_t* start, const uint8_t* end):fPos(0)
+    {
+        fStart = start;
+        fEnd = end;
+        if (!load_wave_header()) {
+            fprintf(stderr, "MemoryReader : not a WAV file!\n");
+            throw -1;
+        }
+    }
+    
+    virtual ~MemoryReader()
+    {}
+    
+    void read(char* buffer, unsigned int size)
+    {
+        memcpy(buffer, fStart + fPos, size);
+        fPos += size;
+    }
+    
+};
+
+// Using a FileReader to implement SoundfileReader
+
+struct WaveReader : public SoundfileReader {
+    
+    WaveReader() {}
+    virtual ~WaveReader() {}
+    
+    bool checkFile(const std::string& path_name) override
+    {
+        try {
+            FileReader reader(path_name);
+            return true;
+        } catch (...)  {
+            return false;
+        }
+    }
+    
+    void getParamsFile(const std::string& path_name, int& channels, int& length) override
+    {
+        FileReader reader(path_name);
+        channels = reader.fWave->num_channels;
+        length = (reader.fWave->subchunk_2_size * 8) / (reader.fWave->num_channels * reader.fWave->bits_per_sample);
+    }
+    
+    void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) override
+    {
+        FileReader reader(path_name);
+        reader.load_wave();
+        
+        soundfile->fLength[part] = (reader.fWave->subchunk_2_size * 8) / (reader.fWave->num_channels * reader.fWave->bits_per_sample);
+        soundfile->fSR[part] = reader.fWave->sample_rate;
+        soundfile->fOffset[part] = offset;
+        
+        // Audio frames have to be written for each chan
+        if (reader.fWave->bits_per_sample == 16) {
+            float factor = 1.f/32767.f;
+            for (int sample = 0; sample < soundfile->fLength[part]; sample++) {
+                short* frame = (short*)&reader.fWave->data[reader.fWave->block_align * sample];
+                if (soundfile->fIsDouble) {
+                    for (int chan = 0; chan < reader.fWave->num_channels; chan++) {
+                        static_cast<double**>(soundfile->fBuffers)[chan][offset + sample] = frame[chan] * factor;
+                    }
+                } else {
+                    for (int chan = 0; chan < reader.fWave->num_channels; chan++) {
+                        static_cast<float**>(soundfile->fBuffers)[chan][offset + sample] = frame[chan] * factor;
+                    }
+                }
+            }
+        } else if (reader.fWave->bits_per_sample == 32) {
+            fprintf(stderr, "readFile : not implemented\n");
+        }
+        
+        // Update offset
+        offset += soundfile->fLength[part];
+    }
+};
+
+#endif
+/**************************  END  WaveReader.h **************************/

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

@@ -0,0 +1,322 @@
+/************************** BEGIN console.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 __faustconsole__
+#define __faustconsole__
+
+#include <stack>
+#include <string>
+#include <map>
+#include <vector>
+#include <iostream>
+#include <cstdlib>
+#include <unistd.h>
+#include <string.h>
+#include <thread>
+#include <atomic>
+#include <stdio.h>
+
+#include "faust/gui/GUI.h"
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ USER INTERFACE
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+#define NO_FILE             0
+#define OUTPUT_FILE         1
+#define INPUT_OUTPUT_FILE   2
+
+class CMDUI : public UI
+{
+    private:
+    
+        std::thread* fThread;
+        std::atomic<bool> fRun;
+    
+        struct param {
+            FAUSTFLOAT* fZone; FAUSTFLOAT fMin; FAUSTFLOAT fMax;
+            param(FAUSTFLOAT* z, FAUSTFLOAT init, FAUSTFLOAT a, FAUSTFLOAT b) : fZone(z), fMin(a), fMax(b) { *z = init; }
+        };
+    
+        int                           fArgc;
+        char**                        fArgv;
+        std::vector<char*>            fFiles;
+        std::stack<std::string>       fPrefix;
+        std::map<std::string, param>  fKeyParam;
+        bool                          fIgnoreParam;
+    
+        void openAnyBox(const char* label)
+        {
+            std::string prefix;
+            
+            if (label && label[0]) {
+                prefix = fPrefix.top() + "-" + label;
+            } else {
+                prefix = fPrefix.top();
+            }
+            fPrefix.push(prefix);
+        }
+    
+        std::string simplify(const std::string& src)
+        {
+            int i = 0;
+            int level = 0;
+            std::string dst;
+            
+            while (src[i]) {
+                
+                switch (level) {
+                        
+                    case 0 :
+                    case 1 :
+                    case 2 :
+                        // Skip the begin of the label "--foo-" until 3 '-' have been read
+                        if (src[i] == '-') { level++; }
+                        break;
+                        
+                    case 3 :
+                        // copy the content, but skip non alphanum and content in parenthesis
+                        switch (src[i]) {
+                            case '(' :
+                            case '[' :
+                                level++;
+                                break;
+                            case '-' :
+                                dst += '-';
+                                break;
+                            default :
+                                if (isalnum(src[i])) {
+                                    dst+= tolower(src[i]);
+                                }
+                        }
+                        break;
+                        
+                    default :
+                        // here we are inside parenthesis and we skip the content until we are back to level 3
+                        switch (src[i]) {
+                            case '(' :
+                            case '[' :
+                                level++;
+                                break;
+                            case ')' :
+                            case ']' :
+                                level--;
+                                break;
+                            default :
+                                break;
+                        }
+                }
+                i++;
+            }
+            return dst;
+        }
+    
+    public:
+    
+        CMDUI(int argc, char* argv[], bool ignore_param = false)
+        : UI(), fThread(nullptr), fRun(true),
+        fArgc(argc), fArgv(argv),
+        fIgnoreParam(ignore_param)
+        {
+            fPrefix.push("-");
+        }
+    
+        virtual ~CMDUI() { delete fThread; }
+    
+        // Can be used as public method
+        void addOption(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max)
+        {
+            std::string fullname = "-" + simplify(fPrefix.top() + "-" + label);
+            fKeyParam.insert(make_pair(fullname, param(zone, init, min, max)));
+        }
+    
+        virtual void openTabBox(const char* label) { openAnyBox(label); }
+        virtual void openHorizontalBox(const char* label) { openAnyBox(label); }
+        virtual void openVerticalBox(const char* label) { openAnyBox(label); }
+        virtual void closeBox() { fPrefix.pop(); }
+    
+        virtual void addButton(const char* label, FAUSTFLOAT* zone)
+        {
+            addOption(label, zone, 0, 0, 1);
+        }
+    
+        virtual void addCheckButton(const char* label, FAUSTFLOAT* zone)
+        {
+            addOption(label, zone, 0, 0, 1);
+        }
+    
+        virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addOption(label, zone, init, min, max);
+        }
+    
+        virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addOption(label, zone, init, min, max);
+        }
+    
+        virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addOption(label, zone, init, min, max);
+        }
+    
+        // -- passive widgets
+    
+        virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) {}
+        virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) {}
+    
+        // -- soundfiles
+    
+        virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
+    
+        static void update_gui(CMDUI* ui)
+        {
+            while (ui->fRun) {
+                usleep(40 * 1000); // 25Hz
+                GUI::updateAllGuis();
+            }
+        }
+    
+        virtual bool run()
+        {
+            fThread = new std::thread(update_gui, this);
+            std::cout << "Type 'q' to quit\n";
+            char c;
+            while ((c = getchar()) && (c != 'q')) {
+                usleep(100 * 1000); 
+            }
+            fRun = false;
+            fThread->join();
+            return true;
+        }
+    
+        void printhelp_command(int file_mode = NO_FILE)
+        {
+            if ((file_mode == OUTPUT_FILE && files() < 1)
+                || (file_mode == INPUT_OUTPUT_FILE && files() < 2)) {
+                std::cout << fArgv[0] << " ";
+                for (const auto& i : fKeyParam) {
+                    std::cout << "[ " << i.first << " " << i.second.fMin << ".." << i.second.fMax <<" ] ";
+                }
+                if (file_mode == INPUT_OUTPUT_FILE) {
+                    std::cout << "infile outfile\n";
+                } else if (file_mode == OUTPUT_FILE) {
+                    std::cout << "outfile\n";
+                }
+                exit(1);
+            }
+        }
+    
+        void printhelp_init()
+        {
+            std::cout << fArgv[0] << " option list : ";
+            for (const auto& i : fKeyParam) {
+                std::cout << "[ " << i.first << " " << i.second.fMin << ".." << i.second.fMax <<" ] ";
+            }
+            std::cout << std::endl;
+            exit(1);
+        }
+    
+        void process_command(int file_mode = NO_FILE)
+        {
+            std::map<std::string, param>::iterator p;
+            for (int i = 1; i < fArgc; i++) {
+                if (fArgv[i][0] == '-') {
+                    if ((strcmp(fArgv[i], "-help") == 0) || (strcmp(fArgv[i], "-h") == 0)) {
+                        printhelp_command(file_mode);
+                    }
+                    p = fKeyParam.find(fArgv[i]);
+                    if (p == fKeyParam.end()) {
+                        if (!fIgnoreParam) {
+                            std::cout << fArgv[0] << " : unrecognized option " << fArgv[i] << "\n";
+                            printhelp_command(file_mode);
+                        } else {
+                            // Argument with a value, so also ignore the value
+                            if ((i+1 < fArgc) && (fArgv[i+1][0] != '-')) i++;
+                        }
+                    } else {
+                        char* end;
+                        *(p->second.fZone) = FAUSTFLOAT(std::strtod(fArgv[i+1], &end));
+                        i++;
+                    }
+                } else {
+                    fFiles.push_back(fArgv[i]);
+                }
+            }
+        }
+    
+        void process_init()
+        {
+            std::map<std::string, param>::iterator p;
+            for (int i = 1; i < fArgc; i++) {
+                if (fArgv[i][0] == '-') {
+                    if ((strcmp(fArgv[i], "-help") == 0)
+                        || (strcmp(fArgv[i], "-h") == 0)
+                        || (strcmp(fArgv[i], "--help") == 0)) {
+                        printhelp_init();
+                    }
+                    p = fKeyParam.find(fArgv[i]);
+                    if (p == fKeyParam.end()) {
+                        std::cout << fArgv[0] << " : unrecognized option " << fArgv[i] << "\n";
+                        printhelp_init();
+                    }
+                    char* end;
+                    *(p->second.fZone) = FAUSTFLOAT(std::strtod(fArgv[i+1], &end));
+                    i++;
+                }
+            }
+        }
+    
+        // check if exist and process one single parameter
+        void process_one_init(const char* param1)
+        {
+            for (int i = 1; i < fArgc; i++) {
+                if (fArgv[i][0] == '-') {
+                    std::map<std::string, param>::iterator p = fKeyParam.find(fArgv[i]);
+                    if ((p != fKeyParam.end()) && (strcmp(fArgv[i], param1) == 0)) {
+                        char* end;
+                        *(p->second.fZone) = FAUSTFLOAT(std::strtod(fArgv[i+1], &end));
+                        break;
+                    }
+                    i++;
+                }
+            }
+        }
+    
+        unsigned long files() { return fFiles.size(); }
+        char* file(int n) { return fFiles[n]; }
+    
+        char* input_file() { return fFiles[0]; }
+        char* output_file() { return fFiles[1]; }
+    
+};
+
+#endif
+
+/**************************  END  console.h **************************/