SampleSplitter.h

#include "httplib/httplib.h"
#include "json/json.h"
#include <iostream>
#include <ctime>
#include <map>
#include <string>
#include <chrono>
#include "elma.h"
#include "client.h"
#include <stdlib.h>
#include <stdexcept>
#include <math.h>
#include <stdio.h>
#include "AudioFile.h"
#include "channel.h"
#include <fstream>
#include <vector>

using namespace std;
using namespace elma;

class SampleSplitter : public Process {

    public:
    SampleSplitter(double threshold, double grace_time, double updates_per_export_attempt):Process("sample splitter") {
        upea = updates_per_export_attempt;
        th = threshold;
        gt = grace_time;
        backlog.resize (2);
        live = true;
    };
    SampleSplitter(std::string filename):Process("sample splitter") 
    {
        audioFile.load (filename);
        live = false;
    };

    void init() {
        watch("set bit depth", [this](Event& e) {
            bit_depth = e.value();
        });
        watch("set sample rate", [this](Event& e) {
            sample_rate = e.value();
        });
    }
    void start() {}

    void update() {
        
        if ( channel("left audio").nonempty() && channel("right audio").nonempty() ) {

            read_data_packet(channel("left audio").latest(), channel("right audio").latest());
            
            if (backlog[0].size() > (int) (gt*sample_rate) && upea_counter > upea){
                attempt_live_export(th, gt);
                upea_counter = 0;
            }
            upea_counter++;
        }
    }
    void stop() {}
    
    void set_threshold(double threshold);

    void set_grace_time(double grace_time);

    // --------- non-live mode functions -------------------------------------------------

    double number_of_samples();

    double get_max();

    double get_min();

    void split_samples(double threshold, double grace_time);

    void export_sample(double sample_number, std::string file_name);

    void export_all_samples();

    void export_all_samples(vector<std::string> file_names);

    void split_and_export_samples(double threshold, double grace_time, bool export_files);

    //----------- live mode functions ----------------------------------------------------

    void read_data_packet(json left_data, json right_data);

    void attempt_live_export(double threshold, double grace_time);


    private:
    
    bool live;

    double bit_depth;

    double sample_rate;

    int upea;

    int upea_counter = 0;

    double th = 0;

    double gt = 0;

    AudioFile<double>::AudioBuffer backlog;

    AudioFile<double> audioFile;

    vector<AudioFile<double>::AudioBuffer> sample_list;

    int export_number = 1;
    
};



void SampleSplitter::set_threshold(double threshold){
    th = threshold;
}

void SampleSplitter::set_grace_time(double grace_time){
    gt = grace_time;
}

// --------- non-live mode functions -------------------------------------------------------------------
double SampleSplitter::number_of_samples(){
    if(live){
        std::cout << "Can't find number of samples in live mode." <<std::endl;
    } else{
        return sample_list.size();
    }
}

double SampleSplitter::get_max(){
    if(live){
        std::cout << "Can't find max in live mode." <<std::endl;
        return 0;
    } else {
        double max = -2;
        // Run through audio file
        for (int i = 0; i < audioFile.getNumSamplesPerChannel(); i++)
        {
            if (audioFile.samples[0][i]> max){
                max = audioFile.samples[0][i];
            }
        }
        return max;
    }
}
double SampleSplitter::get_min(){
    if(live){
        std::cout << "Can't find min in live mode." <<std::endl;
        return 0;
    } else {
        double min = 2;
        // Run through audio file
        for (int i = 0; i < audioFile.getNumSamplesPerChannel(); i++)
        {
            if (audioFile.samples[0][i]< min){
                min = audioFile.samples[0][i];
            }
        }
        return min;
    }
}

void SampleSplitter::split_and_export_samples(double threshold, double grace_time, bool export_files){
    if(live){
        std::cout << "Can't manually split and export samples in live mode" << std::endl;
    } else {
        // Make buffer
        AudioFile<double>::AudioBuffer buffer;
        buffer.resize (2);
        bool recording = false;     // Is the buffer recording?
        int grace_sample_num = (int) (audioFile.getSampleRate()*grace_time);
        int grace_period = 0; // grace samples to be counted down
        int file_number = 1; 
        std::string file_name;
        AudioFile<double> output_file;
        output_file.setBitDepth (audioFile.getBitDepth());
        output_file.setSampleRate (audioFile.getSampleRate());
        // Run through audio file
        for (int i = 0; i < audioFile.getNumSamplesPerChannel(); i++)
        {

            if ((audioFile.samples[0][i]>threshold || audioFile.samples[1][i]>threshold)
                && grace_period <= 0 && !recording){
                recording = true;
                grace_period = grace_sample_num;
            } else if ((audioFile.samples[0][i]>threshold || audioFile.samples[1][i]>threshold)
                && grace_period <= 0 && recording){
                    if(export_files){
                        file_name = "sample_" + std::to_string(file_number) + ".wav";
                        output_file.setAudioBuffer (buffer);
                        output_file.save (file_name);
                        buffer.clear();
                        buffer.resize (2);
                    }
                file_number++;
                grace_period = grace_sample_num;
            } 

            if(recording){

            buffer[0].push_back(audioFile.samples[0][i]);
            buffer[1].push_back(audioFile.samples[1][i]);

            }
            grace_period--;
        }

        // Export last sample
        if(export_files){
            file_name = "sample_" + std::to_string(file_number) + ".wav";
            output_file.setAudioBuffer (buffer);
            output_file.save (file_name);
            buffer.clear();
            buffer.resize (2);
        }

        if (export_files){
            std::cout << "Exported " << (file_number) << " sample files." << std::endl;
        } else {
            std::cout << "Would have exported " << (file_number) << " sample files." << std::endl;
        }
    }
}

void SampleSplitter::split_samples(double threshold, double grace_time){
    if(live){
        std::cout << "Can't manually split samples in live mode" << std::endl;
    } else {
        // Make buffer
        AudioFile<double>::AudioBuffer buffer;
        buffer.resize (2);
        bool recording = false;     // Is the buffer recording?
        int grace_sample_num = (int) (audioFile.getSampleRate()*grace_time);
        int grace_period = 0; // grace samples to be counted down
        int file_number = 1; 
        std::string file_name;
        // Run through audio file
        for (int i = 0; i < audioFile.getNumSamplesPerChannel(); i++)
        {

            if ((audioFile.samples[0][i]>threshold || audioFile.samples[1][i]>threshold)
                && grace_period <= 0 && !recording){
                recording = true;
                grace_period = grace_sample_num;
            } else if ((audioFile.samples[0][i]>threshold || audioFile.samples[1][i]>threshold)
                && grace_period <= 0 && recording){

                file_name = "sample_" + std::to_string(file_number) + ".wav";
                sample_list.push_back(buffer);
                buffer.clear();
                buffer.resize (2);

                file_number++;
                grace_period = grace_sample_num;
            } 

            if(recording){

            buffer[0].push_back(audioFile.samples[0][i]);
            buffer[1].push_back(audioFile.samples[1][i]);

            }
            grace_period--;
        }
        // Export last sample

        file_name = "sample_" + std::to_string(file_number) + ".wav";
        sample_list.push_back(buffer);
        buffer.clear();
        buffer.resize (2);

        std::cout << "Split " << (file_number) << " sample files." << std::endl;
    }


}

void SampleSplitter::export_sample(double sample_number, std::string file_name){
    if (live){
        std::cout << "Can't export a specific samples in live mode" << std::endl;
        std::cout << "No samples were exported" << std::endl;
    } else {
        if (sample_list.size() == 0){
            std::cout << "No samples to export" << std::endl;
            std::cout << "Did you split the original file into samples first?" << std::endl;

        } else if(sample_number > 0 && sample_number <= sample_list.size()){
            AudioFile<double> output_file;
            output_file.setBitDepth (audioFile.getBitDepth());
            output_file.setSampleRate (audioFile.getSampleRate());
            output_file.setAudioBuffer (sample_list.at(sample_number-1));
            output_file.save (file_name);
            std::cout << file_name << " was exported." << std::endl;
        } else{
            std::cout << "There are " << sample_list.size() << " samples." << std::endl;
            std::cout << "You asked for sample number " << sample_number << std::endl;
            std::cout << "No sample was exported" << std::endl;
        }
    }
}

void SampleSplitter::export_all_samples(){
    if(live){
        std::cout << "Can't export all samples in live mode" << std::endl;
        std::cout << "No samples were exported" << std::endl;
    } else {
        if (sample_list.size() == 0){
            std::cout << "No samples to export" << std::endl;
            std::cout << "Did you split the original file into samples first?" << std::endl;
            std::cout << "No samples were exported" << std::endl;
        } else{
            std::string file_name;
            for (int i = 1; i <= sample_list.size(); i++){
                file_name = "sample_" + std::to_string(i) + ".wav";
                export_sample(i,file_name);
            }
        }
    }
}

void SampleSplitter::export_all_samples(vector<std::string> file_names){
    if(live){
        std::cout << "Can't manually export all samples in live mode" << std::endl;
        std::cout << "No samples were exported" << std::endl;
    } else{
        if (sample_list.size() == 0){
            std::cout << "No samples to export" << std::endl;
            std::cout << "Did you split the original file into samples first?" << std::endl;
            std::cout << "No samples were exported" << std::endl;
        } else if(sample_list.size() != file_names.size()){
            std::cout << "The number of file names does not match the number of samples." << std::endl;
            std::cout << "No samples were exported" << std::endl;
        } else {
            for (int i = 1; i <= sample_list.size(); i++){
                export_sample(i,file_names.at(i-1));
            }
        }
    }
}

// --------- live mode functions ------------------------------------------------------------------------

void SampleSplitter::attempt_live_export(double threshold, double grace_time){
    if(live){
        // Make buffer
        AudioFile<double>::AudioBuffer buffer;
        buffer.resize (2);
        bool recording = false;     // Is the buffer recording?
        int grace_sample_num = (int) (sample_rate*grace_time);
        int grace_period = 0; // grace samples to be counted down
        int file_number = 1; 
        std::string file_name;
        AudioFile<double> output_file;
        output_file.setBitDepth (bit_depth);
        output_file.setSampleRate (sample_rate);
        // Run through backlog 
        for (int i = 0; i < backlog[0].size(); i++)
        {

            if ((backlog[0][i]>threshold || backlog[1][i]>threshold)
                && grace_period <= 0 && !recording){
                recording = true;
                grace_period = grace_sample_num;
            } else if ((backlog[0][i]>threshold || backlog[1][i]>threshold)
                && grace_period <= 0 && recording){

                file_name = "sample_" + std::to_string(export_number) + ".wav";
                output_file.setAudioBuffer (buffer);
                output_file.save (file_name);
                std::cout << "Exported " << file_name << std::endl;
                buffer.clear();
                buffer.resize (2);

                export_number++;
                grace_period = grace_sample_num;
            } 

            if(recording){

            buffer[0].push_back(backlog[0][i]);
            buffer[1].push_back(backlog[1][i]);

            }
            grace_period--;
        }

        // The last "sample" becomes the new backlog
        // I do this so that I don't export incomplete samples
        // The result is that the last sample won't export until another sample recording has been triggered
        // Thus to make sure your last sample exports make a loud noise to trigger the end of that sample.
        backlog.clear();
        backlog.resize (2);
        for(int i = 0; i < buffer[0].size(); i++){
            backlog[0].push_back(buffer[0][i]);
            backlog[1].push_back(buffer[1][i]);
        }
    } else {
        std::cout << "attempt_live_export is a live mode exclusive function" << std::endl;        
    }
}

void SampleSplitter::read_data_packet(json left_data, json right_data){
    if(live){
        for (int i = 0; i < left_data.size(); i++){
            backlog[0].push_back(left_data[i]);
            backlog[1].push_back(right_data[i]);
        }
    } else {
        std::cout << "read_data_packet is a live mode exclusive function" << std::endl;    
    }
}