OscOutput.h

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

#ifndef OFXPDSPMIDI_PDSPOSCOUT_H_INCLUDED
#define OFXPDSPMIDI_PDSPOSCOUT_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"

namespace pdsp { namespace osc {

class Output : public pdsp::ExtSequencer, public pdsp::Preparable {

private:

    class ScheduledOscMessage{
    public:
        ScheduledOscMessage();
        ScheduledOscMessage(ofxOscMessage message, chrono::high_resolution_clock::time_point schedule);
        ScheduledOscMessage(const ScheduledOscMessage &other);
        ScheduledOscMessage& operator= (const ScheduledOscMessage &other);
        ~ScheduledOscMessage();
        
        ofxOscMessage message;
        chrono::high_resolution_clock::time_point   scheduledTime;
    };
    
    
    static bool scheduledSort(const ScheduledOscMessage &lhs, const ScheduledOscMessage &rhs );

public:
    Output();    
    ~Output();      
    

    void openPort(const std::string &hostname, int port );

    void close() override;



    bool isConnected() { return connected; }
    
    void setVerbose( bool verbose );


    pdsp::ExtSequencer& address( std::string oscAddress );

    void process( int bufferSize ) noexcept override;

    void linkToMessageBuffer(pdsp::MessageBuffer &messageBuffer) override;
    void unlinkMessageBuffer(pdsp::MessageBuffer &messageBuffer) override;
protected:
    void prepareToPlay( int expectedBufferSize, double sampleRate ) override;
    void releaseResources() override ;

private:

    ofxOscSender    sender;
    std::vector<std::string>    addresses;
    std::string                 selectedAddress;
    
        
    bool            connected;
    bool            verbose;
   
    
    std::vector<pdsp::MessageBuffer*>    inputs;

    std::vector<ScheduledOscMessage> messagesToSend;
    int     messageCount;


    //MIDI DAEMON MEMBERS---------------------------------------------------------------
    void                                                startDaemon();
    void                                                closeDaemon();
    void                                                daemonFunction() noexcept;
    static void                                         daemonFunctionWrapper(Output* parent);
    
    thread                                              daemonThread;
    std::atomic<bool>                                   runDaemon;
    
    //serial output processing members
    std::chrono::time_point<std::chrono::high_resolution_clock>   bufferChrono;   
    bool                                                chronoStarted;
    double                                              usecPerSample;
    std::vector<ScheduledOscMessage>                    circularBuffer;
   
    std::atomic<int>                                    writeindex;
    int                                                 send;

};

}}

#endif //OFXPDSPMIDI_PDSPOSCOUT_H_INCLUDED