Wave.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <fstream>
#include <string>
 
#include "../Types.h"
#include "../Audio/Basic.h"
#include "../IO/Stream.h"
 
namespace Gorgon {
    namespace Containers {
 
        class Wave {
        public:
            
            class Sample {
                friend class Wave;
            public:
                Sample() { }
                
                float &Channel(unsigned channel) { 
#ifndef NDEBUG
                    if(channel >= channels) {
                        throw std::runtime_error("Index out of bounds");
                    }
#endif
 
                    return current[channel]; 
                }
                
                float Channel(unsigned channel) const { 
#ifndef NDEBUG
                    if(channel >= channels) {
                        throw std::runtime_error("Index out of bounds");
                    }
#endif
 
                    return current[channel];
                }
                
                float &operator[](unsigned channel) { 
                    return Channel(channel);
                }
                
                float operator[](unsigned channel) const { 
                    return Channel(channel);
                }
                
            private:
                Sample(float *current, unsigned channels) : current(current), channels(channels) { }
                
                float *current = nullptr;
                unsigned channels = 0;
            };
        
            class Iterator {
                friend class Wave;
            public:
                
                typedef unsigned long difference_type;
                typedef Sample value_type;
                typedef Sample& reference;
                typedef Sample* pointer;
                typedef std::random_access_iterator_tag iterator_category;
 
                
                Iterator() = default;
                
                Iterator& operator=(const Iterator&) = default;
                
                Iterator& operator++() {
                    current += channels;
                    
                    return *this;
                }
                
                Iterator operator++(int) {
                    auto temp = *this;
                    
                    current += channels;
                    
                    return temp;
                }
                
                Iterator& operator--() {
                    current -= channels;
                    
                    return *this;
                }
                
                Iterator operator--(int) {
                    auto temp = *this;
                    
                    current -= channels;
                    
                    return temp;
                }
                
                Sample operator*() const {
                    return {current, channels};
                }
                
                bool operator< (const Iterator &r) {
                    return current<r.current;
                }
                
                bool operator> (const Iterator &r) {
                    return current>r.current;
                }
                
                bool operator<=(const Iterator &r) {
                    return current<=r.current;
                }
                
                bool operator>=(const Iterator &r) {
                    return current>=r.current;
                }
                
                bool operator==(const Iterator &r) {
                    return current==r.current;
                }
                
                bool operator!=(const Iterator &r) {
                    return current!=r.current;
                }
                
                Sample operator[](unsigned long pos) const {
                    return {current, channels};
                }
                
                Iterator& operator+=(unsigned long diff) {
                    current+=diff*channels;
                    return *this;
                }
                
                Iterator  operator+(unsigned long diff) const {
                    auto temp=*this;
                    temp.current+=diff*channels;
                    
                    return temp;
                }
                
                Iterator& operator-=(unsigned long diff) {
                    current-=diff*channels;
                    return *this;
                }
                
                Iterator  operator-(unsigned long diff) const {
                    auto temp=*this;
                    temp.current-=diff*channels;
                    
                    return temp;
                }
 
                unsigned long operator-(const Iterator &r) const {
                    return (unsigned long)((current-r.current)/channels);
                }
                
            private:
                Iterator(float *current, unsigned channels) : current(current), channels(channels) {}
                    
                float *current;
                unsigned channels;
            };
 
            Wave() {
 
            }
 
            explicit Wave(unsigned long size, unsigned samplerate, std::vector<Audio::Channel> channels = {Audio::Channel::Mono}): size(size), samplerate(samplerate), channels(channels) {
                data = (float*)malloc(size * channels.size() * sizeof(float));
            }
 
            Wave(const Wave &) = delete;
 
            Wave(Wave &&data): Wave() {
                Swap(data);
            }
 
            Wave &operator=(const Wave &) = delete;
 
            Wave &operator=(Wave &&other) {
                Destroy();
                Swap(other);
                
                return *this;
            }
 
            ~Wave() {
                Destroy();
            }
 
            Wave Duplicate() const {
                Wave data;
                data.Assign(this->data, size, channels);
 
                data.samplerate=samplerate;
 
                return data;
            }
 
            void Resize(unsigned long size, std::vector<Audio::Channel> channels) {
                
                this->channels = std::move(channels);
 
                this->size = size;
 
                if(data) {
                    free(data);
                }
                data = (float*)malloc(size * this->channels.size() * sizeof(float));
            }
 
            void Resize(unsigned long size) {
 
                // Check if resize is really necessary
                if(this->size == size)
                    return;
 
                this->size = size;
 
                if(data) {
                    free(data);
                }
                data = (float*)malloc(size * channels.size() * sizeof(float));
            }
 
            void Assign(float *newdata, unsigned long size) {
                this->size = size;
 
                if(data) {
                    free(data);
                }
                if(size > 0) {
                    data = (float*)malloc(size * channels.size() * sizeof(float));
                    memcpy(data, newdata, size * channels.size() * sizeof(float));
                }
                else {
                    data = nullptr;
                }
            }
            
            void Assign(float *newdata, unsigned long size, std::vector<Audio::Channel> channels) {
                this->size = size;
                
                this->channels = std::move(channels);
 
                if(data) {
                    free(data);
                }
                if(size > 0) {
                    data = (float*)malloc(size * this->channels.size() * sizeof(float));
                    memcpy(data, newdata, size * this->channels.size() * sizeof(float));
                }
                else {
                    data = nullptr;
                }
            }
 
            void Assign(float *newdata) {
                memcpy(data, newdata, size * channels.size() * sizeof(float));
            }
 
            void Assume(float *newdata, unsigned long size) {
                this->size = size;
 
                if(data && newdata!=data) {
                    free(data);
                }
                data = newdata;
            }
 
            void Assume(float *newdata, unsigned long size, std::vector<Audio::Channel> channels) {
                this->size = size;
                this->channels = std::move(channels);
 
                if(data && newdata!=data) {
                    free(data);
                }
                data = newdata;
            }
 
            void Assume(float *newdata) {
                if(data && newdata!=data) {
                    free(data);
                }
                
                data = newdata;
            }
 
            float *Release() {
                auto temp = data;
                data = nullptr;
                Destroy();
 
                return temp;
            }
 
            void Clear() {
                memset(data, 0, size * channels.size() * sizeof(float));
            }
 
            void Destroy() {
                if(data) {
                    free(data);
                    data = nullptr;
                }
                size = 0;
            }
 
            void Swap(Wave &other) {
                using std::swap;
 
                swap(size, other.size);
                swap(channels, other.channels);
                swap(data, other.data);
                swap(samplerate, other.samplerate);
            }
 
            float *RawData() {
                return data;
            }
 
            const float *RawData() const {
                return data;
            }
 
            float &operator()(unsigned long p, unsigned ch) {
#ifndef NDEBUG
                if(p >= size || ch >= channels.size()) {
                    throw std::runtime_error("Index out of bounds");
                }
#endif
                return data[p*channels.size()+ch];
            }
 
            float operator()(unsigned long p, unsigned ch) const {
#ifndef NDEBUG
                if(p >= size || ch >= channels.size()) {
                    throw std::runtime_error("Index out of bounds");
                }
#endif
                return data[p*channels.size()+ch];
            }
 
            float Get(unsigned long p, unsigned ch) const {
#ifndef NDEBUG
                if(p >= size || ch >= channels.size()) {
                    throw std::runtime_error("Index out of bounds");
                }
#endif
                return data[p*channels.size() + ch];
            }
 
            unsigned long GetSize() const {
                return size;
            }
 
            unsigned long GetBytes() const {
                return (unsigned int)(size * channels.size() * sizeof(float));
            }
 
            float GetLength() const {
                return float((double)size/samplerate);
            }
            
            unsigned GetChannelCount() const {
                return (unsigned int)channels.size();
            }
 
            Audio::Channel GetChannelType(int channel) const {
                if(channel<0 || channel>=(int)channels.size())
                    return Audio::Channel::Unknown;
                
                return channels[channel];
            }
            
            void SetChannels(std::vector<Audio::Channel> channels) {
                if(channels.size() != this->channels.size() && size)
                    throw std::runtime_error("Number of channels does not match");
 
                this->channels = std::move(channels);
            }
 
            int FindChannel(Audio::Channel channel) const {
                for(int i=0; i<(int)channels.size(); i++)  {
                    if(channels[i] == channel) return i;
                }
                
                return -1;
            }
 
            unsigned GetSampleRate() const {
                return samplerate;
            }
            
            void SetSampleRate(unsigned rate) {
                samplerate = rate;
            }
            
            bool ImportWav(const std::string &filename, std::vector<Audio::Channel> channels = {}) {
                std::ifstream file(filename, std::ios::binary);
                
                if(!file.is_open()) return false;
 
                return ImportWav(file, std::move(channels));
            }
 
            bool ImportWav(std::istream &file, std::vector<Audio::Channel> channels = {}) {
                
                if(IO::ReadString(file, 4) != "RIFF") return false;
                
                if(IO::ReadInt32(file) <= 36) return false;
                
                if(IO::ReadString(file, 4) != "WAVE") return false;
               
                if(IO::ReadString(file, 4) != "fmt ") return false;
                
                if(IO::ReadInt32(file) != 16) return false;
                
                if(IO::ReadInt16(file) != 1) return false; //must be PCM
                
                int channelcnt = IO::ReadInt16(file);
                samplerate     = IO::ReadInt32(file);                
                int byterate   = IO::ReadInt32(file);                
                int blocksize  = IO::ReadInt16(file);                
                int samplesize = IO::ReadInt16(file);
                
                if(samplesize != 8 && samplesize !=16) return false;
                
                if(byterate != samplerate*channelcnt*samplesize/8) return false;
                
                if(blocksize == 0) blocksize = byterate;
                
                if(channels.size() == 0) {
                    channels = Audio::StandardChannels(channelcnt);
                }
                else if(channels.size() != channelcnt) 
                    return false;
                
                if(IO::ReadString(file, 4) != "data") return false;
 
                int skip = blocksize - byterate / samplerate;
                
                int size = IO::ReadInt32(file);
 
                Resize(size / blocksize, channels);
                
                auto target = file.tellg() + size;
                
                float *ptr = data;
                
                if(!file) return false;
                        
                while(!file.eof() && file.tellg() < target) {
                    for(int c = 0; c<channelcnt; c++) {
                        if(samplesize == 8) {
                            *ptr++ = (IO::ReadUInt8(file) / 255.f) * 2.f - 1.f;
                        }
                        else {
                            *ptr++ = IO::ReadInt16(file) / 32767.f;
                        }
 
                        if(!file) return false;
                    }
                    
                    if(skip != 0)
                        file.seekg(skip, std::ios::cur);
                }
                
                if((long)file.tellg() != target) return false;
 
                this->channels = std::move(channels);
                
                return true;
            }
 
            bool ExportWav(const std::string &filename, int bits = 16) {
                std::ofstream file(filename, std::ios::binary);
 
                if(!file.is_open()) return false;
 
                return ExportWav(file, bits);
            }
 
            bool ExportWav(std::ostream &file, int bits = 16) {
                using namespace IO;
 
                int hs = 44, ds;
                if(bits == 8) {
                    ds = GetSize() * GetChannelCount();
                }
                else if(bits == 16) {
                    ds = GetSize() * GetChannelCount() * 2;
                }
                else {
                    throw std::runtime_error("Invalid number of bits for wav file");
                }
 
                WriteString(file, "RIFF");
                WriteInt32(file, hs+ds-8);
 
                WriteString(file, "WAVEfmt ");
                WriteInt32(file, 16);
                WriteInt16(file, 1);
 
                WriteInt16(file, GetChannelCount());
                WriteInt32(file, GetSampleRate());
                WriteInt32(file, GetSampleRate() * bits * GetChannelCount() / 8);
                WriteInt16(file, bits * GetChannelCount());
                WriteInt16(file, bits);
 
                WriteString(file, "data");
                WriteInt32(file, ds);
 
                float *ptr = data;
                float *end = data + GetChannelCount() * GetSize();
                if(bits == 8) {
                    while(ptr<end) {
                        WriteUInt8(file, (Byte)std::round((((*ptr) + 1) / 2) * 255) );
 
                        ++ptr;
                    }
                }
                else {
                    int16_t multiplier = (1<<(bits-1))-1;
                    while(ptr<end) {
                        WriteInt16(file, (int)std::round((*ptr) * multiplier));
 
                        ++ptr;
                    }
                }
 
                return true;
            }
 
            Iterator begin() {
                return Iterator(data, (unsigned int)channels.size());
            }
            
            Iterator end() {
                return Iterator(data+size*channels.size(), (unsigned int)channels.size());
            }
 
        protected:
            float *data = nullptr;
 
            unsigned long size = 0;
 
            std::vector<Audio::Channel> channels;
 
            unsigned samplerate = 0;
        };
 
        inline void swap(Wave &l, Wave &r) {
            l.Swap(r);
        }
 
    }
}