ofxPDSP/src/ofx/OscOutput.h at 6a1d0d22d8cb89292912e9e8db0dd8ccbb3e7826 · npisanti/ofxPDSP · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// 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"

/*!
@brief utility class manage OSC output from the sequencer
*/

namespace pdsp { namespace osc {

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

private:

    /*!
        @cond HIDDEN_SYMBOLS
    */


    class ScheduledOscMessage{
    public:
        ScheduledOscMessage();
        ScheduledOscMessage(ofxOscMessage message, std::chrono::high_resolution_clock::time_point schedule);
        ScheduledOscMessage(const ScheduledOscMessage &other);
        ScheduledOscMessage& operator= (const ScheduledOscMessage &other);
        ~ScheduledOscMessage();

        ofxOscMessage message;
		std::chrono::high_resolution_clock::time_point   scheduledTime;
    };


    static bool scheduledSort(const ScheduledOscMessage &lhs, const ScheduledOscMessage &rhs );

    /*!
        @endcond
    */


public:
    Output();
    ~Output();


    /*!
    @brief open the port with the given index
    @param[in] hostname OSC hostname
    @param[in] port OSC port
    */
    void openPort(const std::string &hostname, int port );

    /*!
    @brief shuts down the output
    */
    void close() override;


    /*!
    @brief return true if the port has been sucessfully opened
    */
    bool isConnected() { return connected; }

    /*!
    @brief enable or disable diagnostic messages
    @param[in] verbose true for enabling, false for disabling
    */
    void setVerbose( bool verbose );


    /*!
    @brief patch a pdsp::ScoreSection::out_message() method to the result of this method for message to the serial out

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

/*!
    @cond HIDDEN_SYMBOLS
*/
    void process( int bufferSize ) noexcept override;

    void linkToMessageBuffer(pdsp::MessageBuffer &messageBuffer) override;
    void unlinkMessageBuffer(pdsp::MessageBuffer &messageBuffer) override;
/*!
    @endcond
*/
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);

	std::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