assert() to help find some possible causes of #2991. Fix some confusion with GTK...

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

diff --git a/libs/ardour/midi_port.cc b/libs/ardour/midi_port.cc
index 77e20d59b8174ce9f1ba7c894e7597f49eaca905..8dddc39fe3d2aca0af32e8c66788c1f05df43052 100644 (file)
--- a/libs/ardour/midi_port.cc
+++ b/libs/ardour/midi_port.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2006 Paul Davis 
+    Copyright (C) 2006 Paul 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
@@ -19,19 +19,18 @@
 #include <cassert>
 #include <iostream>
 
-#include <ardour/midi_port.h>
-#include <ardour/data_type.h>
+#include "ardour/midi_port.h"
+#include "ardour/data_type.h"
 
 using namespace ARDOUR;
 using namespace std;
 
 MidiPort::MidiPort (const std::string& name, Flags flags)
-        : Port (name, DataType::MIDI, flags)
+       : Port (name, DataType::MIDI, flags)
        , _has_been_mixed_down (false)
+       , _resolve_in_process (false)
 {
-       // FIXME: size kludge (see BufferSet::ensure_buffers)
-       // Jack needs to tell us this
-       _buffer = new MidiBuffer (1024 * 32);
+       _buffer = new MidiBuffer (raw_buffer_size(0));
 }
 
 MidiPort::~MidiPort()
@@ -39,13 +38,12 @@ MidiPort::~MidiPort()
        delete _buffer;
 }
 
-
 void
-MidiPort::cycle_start (nframes_t nframes, nframes_t offset)
+MidiPort::cycle_start (nframes_t nframes)
 {
        _buffer->clear ();
        assert (_buffer->size () == 0);
-       
+
        if (sends_output ()) {
                jack_midi_clear_buffer (jack_port_get_buffer (_jack_port, nframes));
        }
@@ -55,35 +53,41 @@ MidiBuffer &
 MidiPort::get_midi_buffer (nframes_t nframes, nframes_t offset)
 {
        if (_has_been_mixed_down) {
-           return *_buffer;
+               return *_buffer;
        }
 
        if (receives_input ()) {
-                       
+
                void* jack_buffer = jack_port_get_buffer (_jack_port, nframes);
                const nframes_t event_count = jack_midi_get_event_count(jack_buffer);
-               
+
                assert (event_count < _buffer->capacity());
-               
-               jack_midi_event_t ev;
-               
+
+               /* suck all relevant MIDI events from the JACK MIDI port buffer
+                  into our MidiBuffer
+               */
+
+               nframes_t off = offset + _port_offset;
+
                for (nframes_t i = 0; i < event_count; ++i) {
-                       
+
+                       jack_midi_event_t ev;
+
                        jack_midi_event_get (&ev, jack_buffer, i);
-                       
-                       // i guess this should do but i leave it off to test the rest first.
-                       //if (ev.time > offset && ev.time < offset+nframes)
-                       _buffer->push_back (ev);
+
+                       if (ev.time > off && ev.time < off+nframes) {
+                               _buffer->push_back (ev);
+                       }
                }
-               
+
                if (nframes) {
                        _has_been_mixed_down = true;
                }
-               
+
        } else {
-               _buffer->silence (nframes, offset);
+               _buffer->silence (nframes);
        }
-       
+
        if (nframes) {
                _has_been_mixed_down = true;
        }
@@ -91,53 +95,63 @@ MidiPort::get_midi_buffer (nframes_t nframes, nframes_t offset)
        return *_buffer;
 }
 
-       
+
 void
-MidiPort::cycle_end (nframes_t nframes, nframes_t offset)
+MidiPort::cycle_end (nframes_t /*nframes*/)
 {
-#if 0
-
-       if (sends_output ()) {
-               /* FIXME: offset */
-
-               // We're an output - copy events from source buffer to Jack buffer
-               
-               void* jack_buffer = jack_port_get_buffer (_jack_port, nframes);
-               
-               jack_midi_clear_buffer (jack_buffer);
-               
-               for (MidiBuffer::iterator i = _buffer->begin(); i != _buffer->end(); ++i) {
-                       const Evoral::Event& ev = *i;
-
-                       // event times should be frames, relative to cycle start
-                       assert(ev.time() >= 0);
-                       assert(ev.time() < nframes);
-                       jack_midi_event_write (jack_buffer, (jack_nframes_t) ev.time(), ev.buffer(), ev.size());
-               }
-       }
-#endif
+       _has_been_mixed_down = false;
+}
 
+void
+MidiPort::cycle_split ()
+{
        _has_been_mixed_down = false;
 }
 
 void
-MidiPort::flush_buffers (nframes_t nframes, nframes_t offset)
+MidiPort::flush_buffers (nframes_t nframes, nframes64_t time, nframes_t offset)
 {
-       /* FIXME: offset */
-       
        if (sends_output ()) {
-               
+
                void* jack_buffer = jack_port_get_buffer (_jack_port, nframes);
 
+               // Feed the data through the MidiStateTracker
+               bool did_loop;
+
+               _midi_state_tracker.track (_buffer->begin(), _buffer->end(), did_loop);
+
+               if (did_loop || _resolve_in_process) {
+                       /* add necessary note offs */
+                       _midi_state_tracker.resolve_notes (*_buffer, time);
+               }
+
+               _resolve_in_process = false;
+
                for (MidiBuffer::iterator i = _buffer->begin(); i != _buffer->end(); ++i) {
                        const Evoral::Event<nframes_t>& ev = *i;
-                       // event times should be frames, relative to cycle start
-                       assert(ev.time() >= 0);
-                       assert(ev.time() < (nframes+offset));
-                       if (ev.time() >= offset) {
+
+                       // event times are in frames, relative to cycle start
+
+                       // XXX split cycle start or cycle start?
+
+                       assert(ev.time() < (nframes+offset+_port_offset));
+
+                       if (ev.time() >= offset + _port_offset) {
                                jack_midi_event_write (jack_buffer, (jack_nframes_t) ev.time(), ev.buffer(), ev.size());
                        }
                }
        }
 }
 
+void
+MidiPort::transport_stopped ()
+{
+       _resolve_in_process = true;
+}
+
+size_t
+MidiPort::raw_buffer_size (nframes_t nframes) const
+{
+       return jack_midi_max_event_size(jack_port_get_buffer(_jack_port, nframes));
+}
+