OscInput.h

// OscInput.h
// ofxPDSP
// Nicola Pisanti, MIT License, 2016

#ifndef OFXPDSPMIDI_PDSPOSCINPUT_H_INCLUDED
#define OFXPDSPMIDI_PDSPOSCINPUT_H_INCLUDED

#include "ofMain.h"
#include <chrono>
#include <algorithm>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include "../DSP/pdspCore.h"
#include "../sequencer/SequencerSection.h"
#include "ofxOsc.h"
#include "helper/OscParser.h"

typedef osc::ReceivedMessage _PDSPOscReceivedMessage_t;
typedef osc::IpEndpointName _PDSPIpEndpointName_t;
typedef osc::osc_bundle_element_size_t _PDSPosc_bundle_element_size_t;
namespace pdsp {
class Engine;
}

namespace pdsp{ namespace osc {

class Input : public pdsp::Preparable {
    friend class pdsp::Engine;

private:
    
    class _PositionedOscMessage {
    public:
        _PositionedOscMessage(){ sample = -1; };
        _PositionedOscMessage(ofxOscMessage message, int sample) : message(message), sample(sample){};
        
        
        std::chrono::time_point<std::chrono::high_resolution_clock> timepoint;
        ofxOscMessage message;
        int sample;
    };

    class CustomOscReceiver : public ofxOscReceiver {
    public:
        std::vector<_PositionedOscMessage> * circularBuffer;
        std::atomic<int> * index;
    protected:
        void ProcessMessage(const _PDSPOscReceivedMessage_t &m, const _PDSPIpEndpointName_t &remoteEndpoint) override;
    };

public:
    Input();    
    ~Input();      
    

    void openPort( int port );

    void close();


    bool isConnected() { return connected; }
    
    void setVerbose( bool verbose );
    
    void linkTempo( string oscAddress, int argument=0 );

    pdsp::SequencerGateOutput& out_trig( string oscAddress, int argument=0 );

    pdsp::SequencerValueOutput& out_value( string oscAddress, int argument=0  );

    std::function<float(float)> & parser( string oscAddress, int argument=0 );
    
    void initTo( string oscAddress, int argument, float value  );

    void clearAll();

    void processOsc( int bufferSize ) noexcept;
    bool hasTempoChange(); 
    double getTempo();
protected:
    void prepareToPlay( int expectedBufferSize, double sampleRate ) override;
    void releaseResources() override;    

private:
    CustomOscReceiver receiver;
    
    std::vector<OscParser*> parsers;    
    
    bool            connected;
    bool            verbose;    
    
    bool    sendClearMessages; 
    
    std::atomic<int> index;
    int lastread;
    std::vector<_PositionedOscMessage>    circularBuffer;
    std::vector<_PositionedOscMessage>    readVector;

    double oneSlashMicrosecForSample;

    chrono::time_point<chrono::high_resolution_clock>   bufferChrono;   

    
    bool        tempoLinked;
    std::string tempoAddress;
    int         tempoArgument;
    double      tempo;
    bool        tempoChanged;
    
    void pushToReadVector( _PositionedOscMessage & message );
    int checkParser( std::string oscAddress );

    static std::vector<Input*> instances;
};

}}

#endif // OFXPDSPMIDI_PDSPOSCINPUT_H_INCLUDED