/************************** 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 .
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
#include
#include
#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() {}
virtual bool checkFile(const std::string& path_name)
{
try {
FileReader reader(path_name);
return true;
} catch (...) {
return false;
}
}
virtual void getParamsFile(const std::string& path_name, int& channels, int& length)
{
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);
}
virtual void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan)
{
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];
for (int chan = 0; chan < reader.fWave->num_channels; chan++) {
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 **************************/