AudioClip.h

Go to the documentation of this file.

#include "Bridges.h"
#include "AudioChannel.h"
#include <math.h>
#include "rapidjson/stringbuffer.h"
#include "base64.h"
#include <string>
#include <fstream>

#include <iostream>
using namespace std;

namespace bridges {

    // WAVE file header format
    struct WaveHeader {
        unsigned char *riff;                // RIFF string
        unsigned int overall_size   ;       // overall size of file in bytes
        unsigned char *wave;                // WAVE string
        unsigned char *fmt_chunk_marker;    // fmt string with trailing null char
        unsigned int length_of_fmt;         // length of the format data
        unsigned int format_type;           // format type. 1-PCM, 3- IEEE float, 6 - 8bit A law, 7 - 8bit mu law
        unsigned int channels;              // no.of channels
        unsigned int sample_rate;           // sampling rate (blocks per second)
        unsigned int byterate;              // SampleRate * NumChannels * BitsPerSample/8
        unsigned int block_align;           // NumChannels * BitsPerSample/8
        unsigned int bits_per_sample;       // bits per sample, 8- 8bits, 16- 16 bits etc
        unsigned char *data_chunk_header;   // DATA string or FLLR string
        unsigned int data_size;             // NumSamples * NumChannels *
        // BitsPerSample/8 - size of the
        // next chunk that will be read


        WaveHeader() {
            riff = new unsigned char[4];
            wave = new unsigned char[4];
            fmt_chunk_marker = new unsigned char[4];
            data_chunk_header = new unsigned char[4];
        }

        ~WaveHeader() {
            delete[] riff;
            delete[] wave;
            delete[] fmt_chunk_marker;
            delete[] data_chunk_header;
        }
    };

    namespace datastructure {
        class AudioClip : public DataStructure {
            private:
                int sampleCount;
                int numChannels;
                int sampleRate;
                int sampleBits;
                vector<AudioChannel *> channels;

                union ShortByteUnion {
                    signed short asShort;
                    unsigned char asBytes[2];
                };

            public:
                AudioClip(int sampleCount, int numChannels, int sampleBits, int sampleRate) {
                    if (sampleCount > 1000000000) {
                        throw "sampleCount must be less than 1 million";
                    }


                    if (sampleBits != 8 && sampleBits != 16 && sampleBits != 24 && sampleBits != 32) {
                        throw "sampleBits must be either 8, 16, 24, or 32";
                    }

                    if (numChannels <= 0) {
                        throw "numChannels should be positive";
                    }

                    if (sampleRate <= 0) {
                        throw "sampleRate should be positive";
                    }



                    this->sampleCount = sampleCount;
                    this->numChannels = numChannels;
                    this->channels = vector<AudioChannel *>(numChannels);

                    for (int i = 0; i < numChannels; i++) {
                        this->channels[i] = new AudioChannel(sampleCount);

                        for (int j = 0; j < sampleCount; j++) {
                            this->channels[i]->setSample(j, 0);
                        }
                    }

                    this->sampleRate = sampleRate;
                    this->sampleBits = sampleBits;
                }

                virtual const string getDStype() const override {
                    return "Audio";
                }

                AudioClip(string wave_file) {
                    parseWaveFile (wave_file);

                }

                virtual ~AudioClip () {
                    for (int i = 0; i < numChannels; i++) {
                        delete channels[i];
                        channels[i] = nullptr;
                    }
                }

                virtual const string getDataStructureRepresentation() const override final {
                    using bridges::JSONUtil::JSONencode;

                    int len = numChannels * sampleCount * (sampleBits / 8);
                    std::vector<BYTE> byteBuff;

                    int checkSampleBits = sampleBits;

                    for (int i = 0; i < sampleCount; i++) {
                        for (int c = 0; c < numChannels; c++) {
                            int num = getSample(c, i);
                            //uint32_t s = ((num>>24)&0xff) | ((num<<8)&0xff0000) | ((num>>8)&0xff00) | ((num<<24)&0xff000000);
                            if (this->sampleBits == 8) {
                                byteBuff.push_back(num & 0x000000FF);
                            }
                            else if (this->sampleBits == 16) {
                                ShortByteUnion sbu;
                                sbu.asShort = (uint16_t)num;
                                byteBuff.push_back(sbu.asBytes[0]);
                                byteBuff.push_back(sbu.asBytes[1]);
                            }
                            else if (this->sampleBits == 32 || this->sampleBits == 24) {
                                // Some browsers cannot play 32 bit audio files so use 16
                                int minmax = (int)((pow(2, sampleBits) / 2) - 1);
                                int minmax16 = (int)((pow(2, 16) / 2) - 1);

                                num = (int)((num / (float)minmax) * minmax16) & 0xFFFF;

                                ShortByteUnion sbu;
                                sbu.asShort = (uint16_t)num;
                                byteBuff.push_back(sbu.asBytes[0]);
                                byteBuff.push_back(sbu.asBytes[1]);
                                checkSampleBits = 16;
                            }
                        }
                    }

                    string b64str = base64::encode(&(byteBuff[0]), byteBuff.size());

                    string jsonString = QUOTE + "encoding" + QUOTE + COLON + QUOTE + "RAW" + QUOTE + COMMA +
                        QUOTE + "numChannels" + QUOTE + COLON + JSONencode(this->numChannels) + COMMA +
                        QUOTE + "sampleRate" + QUOTE + COLON + JSONencode(this->sampleRate) + COMMA +
                        QUOTE + "bitsPerSample" + QUOTE + COLON + JSONencode(checkSampleBits) + COMMA +
                        QUOTE + "numSamples" + QUOTE + COLON + JSONencode(this->sampleCount) + COMMA +
                        QUOTE + "samples" + QUOTE + COLON + QUOTE + b64str + QUOTE + CLOSE_CURLY;

                    return jsonString;
                }

                int getNumChannels() const {
                    return this->numChannels;
                }
                int getSampleRate() const {
                    return this->sampleRate;
                }

                int getSampleCount() const {
                    return this->sampleCount;
                }


                int getSampleBits() const {
                    return this->sampleBits;
                }

                int getSample(int channelIndex, int sampleIndex) const {
                    return channels.at(channelIndex)->getSample(sampleIndex);
                }
                void setSample(int channelIndex, int sampleIndex, int value) {
                    if (value >= pow(2, getSampleBits() - 1) ||
                        value <  -pow(2, getSampleBits() - 1))
                        throw "Audio value Out of Bound";

                    channels[channelIndex]->setSample(sampleIndex, value);
                }
            private:
                void parseWaveFile (string wave_file) {
                    // Read and parse an audio file in WAVE format

                    // open file
                    ifstream infile;
                    infile.open (wave_file.c_str(), ios::binary | ios::in);
                    if (infile.fail()) {
                        cout << "Couldnt open " << wave_file << endl;
                        return;
                    }

                    // read the header data of the input WAVE file
                    WaveHeader wave_header = readWaveHeader(infile);

                    long size_of_each_sample = (wave_header.channels *
                            wave_header.bits_per_sample) / 8;

                    // read the audio data
                    if (this->sampleCount > 1000000000) {
                        throw "sampleCount must be less than 1 million";
                    }

                    // create storage for the audio data
                    this->channels.resize(this->numChannels);
                    for (int i = 0; i < numChannels; i++) {
                        this->channels[i] = new AudioChannel(this->sampleCount);
                    }

                    // read sample data by chunks, if PCM
                    if (wave_header.format_type == 1) { // Only PCM handled
                        long i = 0;
                        char data_buffer[size_of_each_sample];
                        int  size_is_correct = true;

                        // make sure that the bytes-per-sample is completely divisible
                        // by num.of channels
                        long bytes_in_each_channel = (size_of_each_sample / wave_header.channels);
                        if ((bytes_in_each_channel * wave_header.channels) != size_of_each_sample) {
                            cout << "Error: Incorrect chunk size.. " <<  bytes_in_each_channel
                                << ", " <<  wave_header.channels << ", " <<  size_of_each_sample << "\n";
                            size_is_correct = false;
                        }

                        if (size_is_correct) {
                            // the valid amplitude range for values based on the bits per sample
                            long low_limit = 0l;
                            long high_limit = 0l;

                            switch (wave_header.bits_per_sample) {
                                case 8:
                                    low_limit = -128;
                                    high_limit = 127;
                                    break;
                                case 16:
                                    low_limit = -32768;
                                    high_limit = 32767;
                                    break;
                                case 24:
                                    low_limit = -16777216;
                                    high_limit = 16777215;
                                    break;
                                case 32:
                                    low_limit = -2147483648;
                                    high_limit = 2147483647;
                                    break;
                            }
                            for (int sample = 0; sample < this->sampleCount;
                                sample++) {
                                int amplitude;
                                if (!infile.fail()) {
                                    for (int ch = 0; ch < wave_header.channels;
                                        ch++ ) {
                                        // read signal amplitude
                                        infile.read(data_buffer, bytes_in_each_channel);
                                        // convert data from big endian to little
                                        // endian based on bytes in each channel sample
                                        switch (bytes_in_each_channel) {
                                            case 1:
                                                amplitude = data_buffer[0] & 0x00ff;
                                                amplitude -= 128; //in wave, 8-bit are unsigned, so shifting to signed
                                                break;
                                            case 2:
                                                amplitude =
                                                    (data_buffer[0] & 0x00ff) |
                                                    (data_buffer[1] << 8);
                                                break;
                                            case 3:
                                                amplitude =
                                                    (data_buffer[0] & 0x00ff) |
                                                    ((data_buffer[1] & 0x00ff) << 8) |
                                                    (data_buffer[2] << 16);
                                                break;
                                            case 4:
                                                amplitude =
                                                    (data_buffer[0] & 0x00ff) |
                                                    ((data_buffer[1] & 0x00ff) << 8) |
                                                    ((data_buffer[2] & 0x00ff) << 16) |
                                                    (data_buffer[3] << 24);
                                                break;
                                        }
                                        this->setSample(ch, sample, amplitude);
                                    }
                                }
                                else {
                                    cout << "Error reading file\n.";
                                    break;
                                }
                            }
                        }
                    }
                    infile.close();
                }
                WaveHeader readWaveHeader(ifstream& infile) {

                    // read file header
                    WaveHeader  wave_header;

                    infile.read ((char *)wave_header.riff, 4);

                    unsigned char *buffer = new  unsigned char[4];
                    infile.read ((char*) buffer,  4);

                    // convert little endian to big endian 4 byte int
                    wave_header.overall_size  = buffer[0] | (buffer[1] << 8) |
                        (buffer[2] << 16) | (buffer[3] << 24);


                    infile.read ((char*) wave_header.wave,  4);

                    infile.read ((char*) wave_header.fmt_chunk_marker,  4);
                    infile.read ((char *) buffer, 4);
                    wave_header.length_of_fmt = buffer[0] | (buffer[1] << 8) |
                        (buffer[2] << 16) | (buffer[3] << 24);

                    char *buffer2 = new  char[2];
                    infile.read (buffer2, 2);
                    wave_header.format_type = buffer2[0] | (buffer2[1] << 8);

                    string format_name = "";
                    switch (wave_header.format_type) {
                        case 1 :
                            format_name = "PCM";
                            break;
                        case 6 :
                            format_name = "A-law";
                            break;
                        case 7 :
                            format_name = "Mu-law";
                            break;
                    }

                    infile.read (buffer2, 2);
                    wave_header.channels = buffer2[0] | (buffer2[1] << 8);
                    this->numChannels = wave_header.channels;

                    infile.read ((char *) buffer, 4);
                    wave_header.sample_rate = buffer[0] | (buffer[1] << 8) |
                        (buffer[2] << 16) | (buffer[3] << 24);
                    this->sampleRate = wave_header.sample_rate;

                    infile.read ((char *) buffer, 4);
                    wave_header.byterate = buffer[0] | (buffer[1] << 8) |
                        (buffer[2] << 16) | (buffer[3] << 24);

                    infile.read (buffer2, 2);
                    wave_header.block_align = buffer2[0] | (buffer2[1] << 8);

                    infile.read (buffer2, 2);
                    wave_header.bits_per_sample = buffer2[0] | (buffer2[1] << 8);

                    this->sampleBits = wave_header.bits_per_sample;

                    infile.read ((char *)wave_header.data_chunk_header, 4);

                    infile.read ((char *) buffer, 4);
                    wave_header.data_size = buffer[0] | (buffer[1] << 8) |
                        (buffer[2] << 16) | (buffer[3] << 24);

                    // calculate no.of samples
                    long num_samples = (8 * wave_header.data_size) /
                        (wave_header.channels * wave_header.bits_per_sample);
                    this->sampleCount = num_samples;

                    long size_of_each_sample = (wave_header.channels *
                            wave_header.bits_per_sample) / 8;

                    delete[] buffer;
                    delete[] buffer2;


                    return wave_header;
                }
        };
    }
}