detectorbank.h

#ifndef _DETECTORBANK_H_
#define _DETECTORBANK_H_


#include <complex>
#include <utility>
#include <memory>
#include <vector>
#include <string>
#include <map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <cereal/access.hpp>

#include "detectortypes.h"
#include "thread_pool.h"

class AbstractDetector;
class ProfileManager;

class DetectorBank {
    
public:
    static constexpr int solverMask { 0xff };
    static constexpr int freqNormalizationMask { 0xff << 8 };
    static constexpr int ampNormalizationMask { 0xff << 16 };
    enum Features {
        
        // Choose numerical method
        central_difference = 1,        
        runge_kutta        = 2,        
        // Frequency normalisation
        freq_unnormalized  = 1 << 8,   
        search_normalized  = 2 << 8,   
        // Amplitude normalisation
        amp_unnormalized   = 1 << 16,  
        amp_normalized     = 2 << 16,  
        // Vanilla
        defaults            = runge_kutta | freq_unnormalized | amp_normalized
        
    };
    DetectorBank(const std::string& profile,
                 const inputSample_t* inputBuffer,
                 const std::size_t inputBufferSize);

    DetectorBank(const parameter_t sr,
                 const inputSample_t* inputBuffer,
                 const std::size_t inputBufferSize,
                 std::size_t numThreads,
                 const parameter_t* freqs = EDO12_pf, 
                 parameter_t* bw = nullptr,
                 const std::size_t numDetectors = EDO12_pf_size,
                 Features features = Features::defaults,
                 parameter_t damping = 0.0001,
                 const parameter_t gain = 25.0);

    virtual ~DetectorBank();
    
    // Maybe want to reuse the object on a different input buffer
    void setInputBuffer(const inputSample_t* inputBuffer,
                        const std::size_t inputBufferSize);
    // Get some frames of z-values from the discriminators
    // Repeated calls progressively traverse the audio input buffer.
    // Returns the number of frames actually processed
    // (0 at end of input)
    int getZ(discriminator_t* frames,
             std::size_t chans, std::size_t numFrames,
             const std::size_t startChan = 0);
    result_t absZ(result_t* absFrames,
                  std::size_t absChans,
                  const std::size_t absNumFrames,
                  discriminator_t* frames,
                  std::size_t maxThreads = 0
                 ) const;
    bool seek(long int offset);
    
    // ACCESS FUNCTIONS
                  
    std::size_t tell(void) const { return currentSample; };
    parameter_t getSR(void) const { return sr; };
    std::size_t getChans(void) const { return detectors.size(); };
    std::size_t getBuflen(void) const { return inBufSize; };
    parameter_t getW(std::size_t ch) const;
    
    parameter_t getFreqIn(std::size_t ch) const;
        
    std::string toXML(void) const;
    void fromXML(std::string xml);
    void saveProfile(std::string name);
    
        
protected:    
    void amplify(const inputSample_t*& signal,
                 std::size_t signalSize,
                 const parameter_t gain);
    
    void worker(int id);
    
    typedef struct {
        std::size_t firstChannel;     
    std::size_t numChannels;      
        discriminator_t* frames;      
        std::size_t framesPerChannel; 
        std::size_t numFrames;        
    } GetZ_params;
    
    void getZDelegate(void* args);

    typedef struct {
        std::size_t start, end;
        result_t& mx;
    } AbsZ_params;

    static const std::map<int, std::string> featuresToStringMap;
    void stringToFeatures(const std::string& desc);
    const std::string featuresToString(void) const;

    friend class cereal::access;
    template<class Archive> void save(Archive& archive) const;
    template<class Archive> void load(Archive& archive);
    
    std::vector<std::unique_ptr<AbstractDetector>> detectors;
    std::size_t inBufSize;        
    const inputSample_t* inBuf;   
    std::unique_ptr<ThreadPool> threadPool;
    std::size_t currentSample;    
    parameter_t d;                
    parameter_t sr;               
    Features features;            
    parameter_t* bw;              
    parameter_t gain;             
    std::unique_ptr<inputSample_t[]> gainBuf;
    
    static const parameter_t EDO12_pf[];
    static const int EDO12_pf_size;
    
    static ProfileManager profileManager;
    
    struct detector_components {
        const parameter_t f_in;      
        const parameter_t f_actual;  
        const inputSample_t* signal; 
        const parameter_t bandwidth; 
    };
    
    std::vector<detector_components> dbComponents;
    
    void setDBComponents(const parameter_t* frequencies, 
                           const parameter_t* bandwidths,
                           const std::size_t numDetectors);
        
    parameter_t modF;  
private:
    void makeDetectors(const std::size_t numDetectors,
                       const parameter_t mu,
                       const parameter_t d,
                       const parameter_t sr,
                       const Features features,
                       //const parameter_t b,
                       const parameter_t gain);
    
    std::map<int, std::unique_ptr<inputSample_t[]>> input_pool;
    
    bool auto_bw;
};

#endif