use C++ for PortManager::make_port_name_relative()

[ardour.git] / libs / ardour / async_midi_port.cc

diff --git a/libs/ardour/async_midi_port.cc b/libs/ardour/async_midi_port.cc
index bd583328c30f1781a768d3268f27c1053bb64265..6c5625e716e7f623631a12e7d1f1bd42e69e23b3 100644 (file)
--- a/libs/ardour/async_midi_port.cc
+++ b/libs/ardour/async_midi_port.cc
@@ -1,6 +1,6 @@
 /*
     Copyright (C) 1998 Paul Barton-Davis
-    
+
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
@@ -37,10 +37,6 @@ using namespace ARDOUR;
 using namespace std;
 using namespace PBD;
 
-namespace Evoral {
-       template class EventRingBuffer<MIDI::timestamp_t>;
-}
-
 pthread_t AsyncMIDIPort::_process_thread;
 
 #define port_engine AudioEngine::instance()->port_engine()
@@ -50,11 +46,10 @@ AsyncMIDIPort::AsyncMIDIPort (string const & name, PortFlags flags)
        , MIDI::Port (name, MIDI::Port::Flags (0))
        , _currently_in_cycle (false)
        , _last_write_timestamp (0)
+       , have_timer (false)
        , output_fifo (512)
        , input_fifo (1024)
-#ifndef PLATFORM_WINDOWS
-       , xthread (true)
-#endif
+       , _xthread (true)
 {
 }
 
@@ -62,6 +57,13 @@ AsyncMIDIPort::~AsyncMIDIPort ()
 {
 }
 
+void
+AsyncMIDIPort::set_timer (boost::function<MIDI::framecnt_t (void)>& f)
+{
+       timer = f;
+       have_timer = true;
+}
+
 void
 AsyncMIDIPort::flush_output_fifo (MIDI::pframes_t nframes)
 {
@@ -71,15 +73,15 @@ AsyncMIDIPort::flush_output_fifo (MIDI::pframes_t nframes)
        output_fifo.get_read_vector (&vec);
 
        MidiBuffer& mb (get_midi_buffer (nframes));
-                       
+
        if (vec.len[0]) {
                Evoral::Event<double>* evp = vec.buf[0];
-               
+
                for (size_t n = 0; n < vec.len[0]; ++n, ++evp) {
                        mb.push_back (evp->time(), evp->size(), evp->buffer());
                }
        }
-       
+
        if (vec.len[1]) {
                Evoral::Event<double>* evp = vec.buf[1];
 
@@ -87,7 +89,7 @@ AsyncMIDIPort::flush_output_fifo (MIDI::pframes_t nframes)
                        mb.push_back (evp->time(), evp->size(), evp->buffer());
                }
        }
-       
+
        if ((written = vec.len[0] + vec.len[1]) != 0) {
                output_fifo.increment_read_idx (written);
        }
@@ -105,25 +107,32 @@ AsyncMIDIPort::cycle_start (MIDI::pframes_t nframes)
 
        if (ARDOUR::Port::sends_output()) {
                flush_output_fifo (nframes);
-       } 
-       
+       }
+
        /* copy incoming data from the port buffer into the input FIFO
           and if necessary wakeup the reader
        */
 
        if (ARDOUR::Port::receives_input()) {
                MidiBuffer& mb (get_midi_buffer (nframes));
-               pframes_t when = AudioEngine::instance()->sample_time_at_cycle_start();
+               framecnt_t when;
+
+               if (have_timer) {
+                       when = timer ();
+               } else {
+                       when = AudioEngine::instance()->sample_time_at_cycle_start();
+               }
 
                for (MidiBuffer::iterator b = mb.begin(); b != mb.end(); ++b) {
+                       if (!have_timer) {
+                               when += (*b).time();
+                       }
                        input_fifo.write (when, (Evoral::EventType) 0, (*b).size(), (*b).buffer());
                }
 
-#ifndef PLATFORM_WINDOWS
                if (!mb.empty()) {
-                       xthread.wakeup ();
+                       _xthread.wakeup ();
                }
-#endif
        }
 }
 
@@ -185,7 +194,7 @@ AsyncMIDIPort::write (const MIDI::byte * msg, size_t msglen, MIDI::timestamp_t t
                /* this is the best estimate of "when" this MIDI data is being
                 * delivered
                 */
-               
+
                _parser->set_timestamp (AudioEngine::instance()->sample_time() + timestamp);
                for (size_t n = 0; n < msglen; ++n) {
                        _parser->scanner (msg[n]);
@@ -193,7 +202,7 @@ AsyncMIDIPort::write (const MIDI::byte * msg, size_t msglen, MIDI::timestamp_t t
 
                Glib::Threads::Mutex::Lock lm (output_fifo_lock);
                RingBuffer< Evoral::Event<double> >::rw_vector vec = { { 0, 0 }, { 0, 0} };
-               
+
                output_fifo.get_write_vector (&vec);
 
                if (vec.len[0] + vec.len[1] < 1) {
@@ -214,7 +223,7 @@ AsyncMIDIPort::write (const MIDI::byte * msg, size_t msglen, MIDI::timestamp_t t
                }
 
                output_fifo.increment_write_idx (1);
-               
+
                ret = msglen;
 
        } else {
@@ -240,11 +249,11 @@ AsyncMIDIPort::write (const MIDI::byte * msg, size_t msglen, MIDI::timestamp_t t
                if (_currently_in_cycle) {
 
                        MidiBuffer& mb (get_midi_buffer (_cycle_nframes));
-                       
+
                        if (timestamp == 0) {
                                timestamp = _last_write_timestamp;
-                       } 
-                       
+                       }
+
                        if (mb.push_back (timestamp, msglen, msg)) {
                                ret = msglen;
                                _last_write_timestamp = timestamp;
@@ -270,7 +279,7 @@ AsyncMIDIPort::read (MIDI::byte *, size_t)
        if (!ARDOUR::Port::receives_input()) {
                return 0;
        }
-       
+
        timestamp_t time;
        Evoral::EventType type;
        uint32_t size;