Merge pull request #108 from pingdynasty/develop

Release v22.2

.github/workflows/c-cpp.yml

@@ -23,6 +23,10 @@ jobs:
       uses: mymindstorm/setup-emsdk@v7
       with:
         version: 2.0.10
+    - name: Setup python
+      uses: actions/setup-python@v2
+      with:
+        python-version: 2.7
     - name: make
       run: make
     - name: make check

.gitmodules

@@ -2,3 +2,7 @@
 	path = Libraries/DaisySP
 	url = https://github.com/electro-smith/DaisySP.git
 	branch = master
+[submodule "Tools/hvcc"]
+	path = Tools/hvcc
+	url = https://github.com/pingdynasty/hvcc.git
+	branch = develop

FaustCode/WaveReader.h

@@ -0,0 +1,256 @@
+/************************** BEGIN WaveReader.h **************************/
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2020 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This Architecture section is free software; you can redistribute it
+ and/or modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 3 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 General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program; If not, see <http://www.gnu.org/licenses/>.
+ 
+ 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__
+
+#undef min
+#undef max
+
+#include <string>
+#include "Resource.h"
+
+// WAVE file description
+class WaveFile {
+public:
+    // 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;
+
+};
+
+// Base reader
+class WaveReader {
+public:    
+    WaveFile* fWave;
+
+    WaveReader() {
+        fWave = new WaveFile();
+    }
+
+    virtual ~WaveReader() {
+        if (fWave->data != NULL)
+            delete[] fWave->data;
+        delete fWave;
+    }
+
+    bool loadWaveHeader() {
+        char buffer[4];
+
+        read(buffer, 4);
+        if (strncmp(buffer, "RIFF", 4) != 0) {
+            debugMessage("Not a valid WAV file!");
+            return false;
+        }
+
+        fWave->chunk_id = toInt(buffer, 4);
+
+        read(buffer, 4);
+        fWave->chunk_size = toInt(buffer, 4);
+
+        read(buffer, 4);
+        fWave->format = toInt(buffer, 4);
+
+        read(buffer, 4);
+        fWave->subchunk_1_id = toInt(buffer, 4);
+
+        read(buffer, 4);
+        fWave->subchunk_1_size = toInt(buffer, 4);
+
+        read(buffer, 2);
+        fWave->audio_format = toInt(buffer, 2);
+        read(buffer, 2);
+        fWave->num_channels = toInt(buffer, 2);
+
+        read(buffer, 4);
+        fWave->sample_rate = toInt(buffer, 4);
+
+        read(buffer, 4);
+        fWave->byte_rate = toInt(buffer, 4);
+
+        read(buffer, 2);
+        fWave->block_align = toInt(buffer, 2);
+        read(buffer, 2);
+        fWave->bits_per_sample = toInt(buffer, 2);
+
+        read(buffer, 4);
+        if (strncmp(buffer, "data", 4) != 0) {
+            read(buffer, 4);
+            int _extra_size = toInt(buffer, 4);
+            char _extra_data[_extra_size];
+            read(_extra_data, _extra_size);
+            read(buffer, 4);
+            fWave->subchunk_2_id = toInt(buffer, 4);
+        } else {
+            fWave->subchunk_2_id = toInt(buffer, 4);
+        }
+
+        read(buffer, 4);
+        fWave->subchunk_2_size = toInt(buffer, 4);
+        return true;
+    }
+
+    void loadWave()
+    {
+        // Read sound data
+        fWave->data = new char[fWave->subchunk_2_size];
+        read(fWave->data, fWave->subchunk_2_size);
+    }
+
+    virtual void read(char* buffer, unsigned int size) = 0;
+
+protected:
+    inline int toInt(char* buffer, int len)
+    {
+        int a = 0;
+        for(int i = 0; i < len; i++) {
+            ((char*)&a)[i] = buffer[i];
+        }
+        return a;
+    }   
+};
+
+/*
+ * WAV file reader that handles resource parser
+ */
+class WaveResourceReader : public WaveReader {
+public:
+    WaveResourceReader(const char* name) :
+        offset(0) {
+        resource = Resource::open(name);
+    };
+
+    ~WaveResourceReader() {
+        Resource::destroy(resource);
+    };
+
+    void read(char* buffer, unsigned int size) override {
+        size_t read_len = resource->read((void*)buffer, size, offset);
+        offset += read_len;
+    }
+private:
+    Resource* resource;
+    size_t offset;
+};
+
+#endif
+/**************************  END  WaveReader.h **************************/