Optimize plugin-processing for non-automated params

[ardour.git] / libs / ardour / ardour / midi_buffer.h

diff --git a/libs/ardour/ardour/midi_buffer.h b/libs/ardour/ardour/midi_buffer.h
index 2e2cbf65042cc958bba8eae9ee5659be78e0ef79..7793f7e0bd83946564f3e1925793398b1414faaa 100644 (file)
--- a/libs/ardour/ardour/midi_buffer.h
+++ b/libs/ardour/ardour/midi_buffer.h
@@ -20,30 +20,37 @@
 #ifndef __ardour_midi_buffer_h__
 #define __ardour_midi_buffer_h__
 
+#include "evoral/EventSink.hpp"
 #include "evoral/midi_util.h"
+#include "evoral/types.hpp"
+
 #include "midi++/event.h"
+
 #include "ardour/buffer.h"
-#include "ardour/event_type_map.h"
+#include "ardour/parameter_types.h"
 
 namespace ARDOUR {
 
 
 /** Buffer containing 8-bit unsigned char (MIDI) data. */
-class LIBARDOUR_API MidiBuffer : public Buffer
+class LIBARDOUR_API MidiBuffer : public Buffer, public Evoral::EventSink<samplepos_t>
 {
 public:
-       typedef framepos_t TimeType;
+       typedef samplepos_t TimeType;
 
        MidiBuffer(size_t capacity);
        ~MidiBuffer();
 
-       void silence (framecnt_t nframes, framecnt_t offset = 0);
-       void read_from (const Buffer& src, framecnt_t nframes, framecnt_t dst_offset = 0, framecnt_t src_offset = 0);
-       void merge_from (const Buffer& src, framecnt_t nframes, framecnt_t dst_offset = 0, framecnt_t src_offset = 0);
+       void silence (samplecnt_t nframes, samplecnt_t offset = 0);
+       void read_from (const Buffer& src, samplecnt_t nframes, sampleoffset_t dst_offset = 0, sampleoffset_t src_offset = 0);
+       void merge_from (const Buffer& src, samplecnt_t nframes, sampleoffset_t dst_offset = 0, sampleoffset_t src_offset = 0);
 
        void copy(const MidiBuffer& copy);
+       void copy(MidiBuffer const * const);
+
+       void skip_to (TimeType when);
 
-       bool     push_back(const Evoral::MIDIEvent<TimeType>& event);
+       bool     push_back(const Evoral::Event<TimeType>& event);
        bool     push_back(TimeType time, size_t size, const uint8_t* data);
 
        uint8_t* reserve(TimeType time, size_t size);
@@ -52,14 +59,17 @@ public:
        size_t size() const { return _size; }
        bool empty() const { return _size == 0; }
 
-       bool insert_event(const Evoral::MIDIEvent<TimeType>& event);
+       bool insert_event(const Evoral::Event<TimeType>& event);
        bool merge_in_place(const MidiBuffer &other);
 
+       /** EventSink interface for non-RT use (export, bounce). */
+       uint32_t write(TimeType time, Evoral::EventType type, uint32_t size, const uint8_t* buf);
+
        template<typename BufferType, typename EventType>
                class iterator_base
        {
        public:
-               iterator_base<BufferType, EventType>(BufferType& b, framecnt_t o)
+               iterator_base<BufferType, EventType>(BufferType& b, samplecnt_t o)
                        : buffer(&b), offset(o) {}
 
                iterator_base<BufferType, EventType>(const iterator_base<BufferType,EventType>& o)
@@ -77,7 +87,7 @@ public:
                        uint8_t* ev_start = buffer->_data + offset + sizeof(TimeType);
                        int event_size = Evoral::midi_event_size(ev_start);
                        assert(event_size >= 0);
-                       return EventType(EventTypeMap::instance().midi_event_type(*ev_start),
+                       return EventType(midi_parameter_type(*ev_start),
                                        *((TimeType*)(buffer->_data + offset)),
                                        event_size, ev_start);
                }
@@ -86,13 +96,13 @@ public:
                        uint8_t* ev_start = buffer->_data + offset + sizeof(TimeType);
                        int event_size = Evoral::midi_event_size(ev_start);
                        assert(event_size >= 0);
-                       return EventType(EventTypeMap::instance().midi_event_type(*ev_start),
-                                       *((TimeType*)(buffer->_data + offset)),
+                       return EventType(Evoral::MIDI_EVENT,
+                                       *(reinterpret_cast<TimeType*>((uintptr_t)(buffer->_data + offset))),
                                        event_size, ev_start);
                }
 
                inline TimeType * timeptr() {
-                       return ((TimeType*)(buffer->_data + offset));
+                       return reinterpret_cast<TimeType*>((uintptr_t)(buffer->_data + offset));
                }
 
                inline iterator_base<BufferType, EventType>& operator++() {
@@ -115,8 +125,8 @@ public:
                size_t          offset;
        };
 
-       typedef iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> >             iterator;
-       typedef iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> > const_iterator;
+       typedef iterator_base< MidiBuffer, Evoral::Event<TimeType> >             iterator;
+       typedef iterator_base< const MidiBuffer, const Evoral::Event<TimeType> > const_iterator;
 
        iterator begin() { return iterator(*this, 0); }
        iterator end()   { return iterator(*this, _size); }
@@ -159,8 +169,6 @@ public:
                return iterator (*this, i.offset);
        }
 
-       uint8_t* data() const { return _data; }
-
        /**
         * returns true if the message with the second argument as its MIDI
         * status byte should preceed the message with the first argument as
@@ -169,8 +177,8 @@ public:
        static bool second_simultaneous_midi_byte_is_first (uint8_t, uint8_t);
 
 private:
-       friend class iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> >;
-       friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> >;
+       friend class iterator_base< MidiBuffer, Evoral::Event<TimeType> >;
+       friend class iterator_base< const MidiBuffer, const Evoral::Event<TimeType> >;
 
        uint8_t* _data; ///< timestamp, event, timestamp, event, ...
        pframes_t _size;