SerialOut.h

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

#ifndef OFXPDSPMIDI_PDSPSERIALOUT_H_INCLUDED
#define OFXPDSPMIDI_PDSPSERIALOUT_H_INCLUDED

#include "ofMain.h"

#ifndef TARGET_OF_IOS
#ifndef __ANDROID__

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

namespace pdsp{ namespace serial {

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

private:

    class ScheduledSerialMessage{
    public:
        ScheduledSerialMessage();
        ScheduledSerialMessage(int channel, float message, chrono::high_resolution_clock::time_point schedule);
        ScheduledSerialMessage(const ScheduledSerialMessage &other);
        ScheduledSerialMessage& operator= (const ScheduledSerialMessage &other);
        ~ScheduledSerialMessage();
        
        signed char channel;
        signed char message;
        chrono::high_resolution_clock::time_point   scheduledTime;
    };
    
    
    static bool scheduledSort(const ScheduledSerialMessage &lhs, const ScheduledSerialMessage &rhs );

public:
    Output();    
    ~Output();      
    
    void openPort(int index, int baudRate=250000);

    void openPort(string name, int baudRate=250000);

    void close() override;

    void listPorts();

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


    pdsp::ExtSequencer& channel(int channelNumber);

    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:

    ofSerial        serial;
    
    bool            connected;
    bool            verbose;
   
    std::vector<ScheduledSerialMessage> messagesToSend;
    
    std:: vector<pdsp::MessageBuffer*>    inputs;
    std::vector<int>                     channels;
    
    int     selectedChannel;
    int     messageCount;


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

};

}} // end namespaces

#endif // __ANDROID__
#endif // TARGET_OF_IOS

#endif //OFXPDSPMIDI_PDSPSERIALOUT_H_INCLUDED