driver.h

Go to the documentation of this file.

/*
 *   NiCMidi - A C++ Class Library for MIDI
 *
 *   Copyright (C) 2004  J.D. Koftinoff Software, Ltd.
 *   www.jdkoftinoff.com jeffk@jdkoftinoff.com
 *   Copyright (C) 2021, 2022  Nicola Cassetta
 *   https://github.com/ncassetta/NiCMidi
 *
 *   This file is part of NiCMidi.
 *
 *   NiCMidi is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation, either version 3 of
 *   the License, or (at your option) any later version.
 *
 *   NiCMidi is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with NiCMidi. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 
 
#ifndef _NICMIDI_DRIVER_H
#define _NICMIDI_DRIVER_H
 
#include "msg.h"
#include "processor.h"
#include "timer.h"
 
 
#include "../rtmidi-4.0.0/RtMidi.h"
 
#include <vector>
#include <string>
#include <mutex>
//#include <atomic>
 
 
// TODO: implements RtMidi functions (error callback, selection of input, etc.)
 
 
 
#define DRIVER_USES_MIDIMATRIX 0
#if DRIVER_USES_MIDIMATRIX
   #include "matrix.h"
#endif // DRIVER_USES_MIDIMATRIX
 
 
 
struct MIDIRawMessage {
                                        MIDIRawMessage() : timestamp(0), port(0) {}
                                        MIDIRawMessage(const MIDIMessage& m, tMsecs t, int p) :
                                                        msg(m), timestamp(t), port(p) {}
        MIDIMessage                     msg;        
        tMsecs                          timestamp;  
        int                             port;       
};
 
 
// EXCLUDED FROM DOCUMENTATION BECAUSE UNDOCUMENTED
// This is a queue of MIDIRawMessage
class MIDIRawMessageQueue {
    public:
        // The constructor creates a queue of the given size. When the queue is full, older messages
        // are pulled from the queue.
 
                                        MIDIRawMessageQueue(unsigned int size) :
                                                                    next_in(0), next_out(0), buffer(size) {}
        // The destructor deletes all the MIDIRawMessage objects actually contained in the queue.
        virtual                         ~MIDIRawMessageQueue()      {}
        // Empties the queue and turns into a NoOp all the messages contained.
        void                            Reset();
        // Quickly empties the queue acting only on in and out indexes.
        void                            Flush()                     { next_out = next_in; }
        // Adds the given MIDIRawMessage as the last element in the queue. If the queue was full
        // the first message is pulled out.
        void                            PutMessage(const MIDIRawMessage& msg);
        // Gets the first MIDIRawMessage in the queue, pulling it out. It returns a reference
        // to a static copy, which is valid until the next call to the function.
        MIDIRawMessage&                 GetMessage();
        // Gets the n-th MIDIRawMessage in the queue, without pulling it out. It returns a
        // direct reference to the message (and it's so faster than GetMessage(), which copies it)
        // which is valid until an operation on the queue is done. If the queue has an actual
        // size lesser than _n_, returns a NoOp message.
        MIDIRawMessage&                 ReadMessage(unsigned int n);
        // Returns *true* is the queue is empty.
        bool                            IsEmpty() const             { return next_in == next_out; }
        // Returns *true* if the queue has reached its max size (you can however add other messages,
        // deleting the older ones.
        bool                            IsFull() const              { return ((next_in + 1) % buffer.size()) == next_out; }
        // Returns the actual length of the queue.
        unsigned int                    GetLength() const           { return (next_in - next_out) % buffer.size(); }
 
    protected:
        unsigned int                    next_in;
        unsigned int                    next_out;
        std::vector<MIDIRawMessage>     buffer;
};
 
 
class MIDIOutDriver {
    public:
                                MIDIOutDriver (int id);
        virtual                 ~MIDIOutDriver();
 
        virtual void            Reset();
 
        int                     GetPortId() const               { return port_id; }
        std::string             GetPortName()                   { return port->getPortName(port_id); }
        bool                    IsPortOpen() const              { return port->isPortOpen(); }
        MIDIProcessor*          GetOutProcessor()               { return processor; }
        const MIDIProcessor*    GetOutProcessor() const         { return processor; }
 
        virtual void            SetOutProcessor(MIDIProcessor* proc)
                                                                { processor = proc; }
 
        virtual void            OpenPort();
        virtual void            ClosePort();
        virtual void            AllNotesOff(int chan = -1);
            // TODO: actually it writes to cerr, Should we raise an exception?
        virtual void            OutputMessage(const MIDITimedMessage& msg);
 
    protected:
        static const int        DRIVER_MAX_RETRIES = 100;
        static const int        DRIVER_WAIT_AFTER_SYSEX = 20;
        virtual void            HardwareMsgOut(const MIDIMessage &msg);
 
        MIDIProcessor*          processor;  // The out processor
        RtMidiOut*              port;       // The hardware port
        const int               port_id;    // The id of the port
        int                     num_open;   // Counts the number of OpenPort() calls
        std::recursive_mutex    out_mutex;  // Used internally for thread safe operating
 
#if DRIVER_USES_MIDIMATRIX
        MIDIMatrix              out_matrix; // To keep track of notes on going to MIDI out
#endif // DRIVER_USES_MIDIMATRIX
 
    private:
        // this vector is used by HardwareMsgOut to feed the port
        std::vector<unsigned char>      msg_bytes;
};
 
 
 
 
class MIDIInDriver {
    public:
                                MIDIInDriver(int id, unsigned int queue_size = DEFAULT_QUEUE_SIZE);
        virtual                 ~MIDIInDriver();
        virtual void            Reset();
 
        int                     GetPortId() const               { return port_id; }
        std::string             GetPortName()                   { return port->getPortName(port_id); }
        bool                    IsPortOpen() const              { return port->isPortOpen(); }
        bool                    CanGet() const                  { return in_queue.GetLength() > 0; }
        unsigned int            GetQueueSize() const            { return in_queue.GetLength(); }
        MIDIProcessor*          GetProcessor()                  { return processor; }
        const MIDIProcessor*    GetProcessor() const            { return processor; }
 
        virtual void            SetProcessor(MIDIProcessor* proc);
 
        virtual void            OpenPort();
        virtual void            ClosePort();
        void                    LockQueue()                     { in_mutex.lock(); }
        void                    UnlockQueue()                   { in_mutex.unlock(); }
        void                    FlushQueue();
        virtual bool            InputMessage(MIDIRawMessage& msg);
        virtual bool            ReadMessage(MIDIRawMessage& msg, unsigned int n);
 
protected:
 
        static void             HardwareMsgIn(double time,
                                              std::vector<unsigned char>* msg_bytes,
                                              void* p);
 
        // This is the default queue size.
        static const unsigned int       DEFAULT_QUEUE_SIZE = 256;
 
        MIDIProcessor*          processor;      // The in processor
        RtMidiIn*               port;           // The hardware port
        const int               port_id;        // The id of the port
        int                     num_open;       // Counts the number of OpenPort() calls
 
        MIDIRawMessageQueue     in_queue;       // The incoming message queue (see MIDIRawMessage)
        std::recursive_mutex    in_mutex;       // Locks/unlocks the queue
};
 
 
#endif // _JDKMIDI_DRIVER_H