fix all manner of wrongness with port buffer offsets
[ardour.git] / libs / ardour / midi_port.cc
1 /*
2     Copyright (C) 2006 Paul Davis
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19 #include <cassert>
20 #include <iostream>
21
22 #include "ardour/midi_port.h"
23 #include "ardour/data_type.h"
24
25 using namespace ARDOUR;
26 using namespace std;
27
28 MidiPort::MidiPort (const std::string& name, Flags flags)
29         : Port (name, DataType::MIDI, flags)
30         , _has_been_mixed_down (false)
31         , _resolve_in_process (false)
32 {
33         _buffer = new MidiBuffer (raw_buffer_size(0));
34 }
35
36 MidiPort::~MidiPort()
37 {
38         delete _buffer;
39 }
40
41 void
42 MidiPort::cycle_start (pframes_t nframes)
43 {
44         _buffer->clear ();
45         assert (_buffer->size () == 0);
46
47         if (sends_output ()) {
48                 jack_midi_clear_buffer (jack_port_get_buffer (_jack_port, nframes));
49         }
50 }
51
52 MidiBuffer &
53 MidiPort::get_midi_buffer (framecnt_t nframes)
54 {
55         if (_has_been_mixed_down) {
56                 return *_buffer;
57         }
58
59         if (receives_input ()) {
60
61                 void* jack_buffer = jack_port_get_buffer (_jack_port, nframes);
62                 const pframes_t event_count = jack_midi_get_event_count(jack_buffer);
63
64                 assert (event_count < _buffer->capacity());
65
66                 /* suck all relevant MIDI events from the JACK MIDI port buffer
67                    into our MidiBuffer
68                 */
69
70                 for (pframes_t i = 0; i < event_count; ++i) {
71
72                         jack_midi_event_t ev;
73
74                         jack_midi_event_get (&ev, jack_buffer, i);
75
76                         if (ev.buffer[0] == 0xfe) {
77                                 /* throw away active sensing */
78                                 continue;
79                         }
80
81                         if (ev.time >= _port_offset && ev.time < (_port_offset + nframes)) {
82                                 _buffer->push_back (ev);
83                         } else {
84                                 cerr << "Dropping incoming MIDI at time " << ev.time << "; offset=" << _port_offset << " limit=" << (_port_offset + nframes) << "\n";
85                         }
86                 }
87
88                 if (nframes) {
89                         _has_been_mixed_down = true;
90                 }
91
92         } else {
93                 _buffer->silence (nframes);
94         }
95
96         if (nframes) {
97                 _has_been_mixed_down = true;
98         }
99
100         return *_buffer;
101 }
102
103
104 void
105 MidiPort::cycle_end (pframes_t /*nframes*/)
106 {
107         _has_been_mixed_down = false;
108 }
109
110 void
111 MidiPort::cycle_split ()
112 {
113         _has_been_mixed_down = false;
114 }
115
116 void
117 MidiPort::flush_buffers (pframes_t nframes, framepos_t time)
118 {
119         if (sends_output ()) {
120
121                 void* jack_buffer = jack_port_get_buffer (_jack_port, nframes);
122
123                 // Feed the data through the MidiStateTracker
124                 bool did_loop;
125
126                 _midi_state_tracker.track (_buffer->begin(), _buffer->end(), did_loop);
127
128                 if (did_loop || _resolve_in_process) {
129                         /* add necessary note offs */
130                         _midi_state_tracker.resolve_notes (*_buffer, time);
131                 }
132
133                 _resolve_in_process = false;
134
135                 for (MidiBuffer::iterator i = _buffer->begin(); i != _buffer->end(); ++i) {
136                         const Evoral::Event<framepos_t>& ev = *i;
137
138                         // event times are in frames, relative to cycle start
139
140                         assert (ev.time() < (nframes + _port_offset));
141
142                         if (ev.time() >= _port_offset) {
143                                 if (jack_midi_event_write (jack_buffer, (jack_nframes_t) ev.time(), ev.buffer(), ev.size()) != 0) {
144                                         cerr << "write failed, drop flushed note off on the floor, time " << ev.time() << " > " << _port_offset << endl;
145                                 }
146                         } else {
147                                 cerr << "drop flushed event on the floor, time " << ev.time() << " < " << _port_offset << endl;
148                         }
149                 }
150         }
151 }
152
153 void
154 MidiPort::transport_stopped ()
155 {
156         _resolve_in_process = true;
157 }
158
159 size_t
160 MidiPort::raw_buffer_size (pframes_t nframes) const
161 {
162         return jack_midi_max_event_size (jack_port_get_buffer (_jack_port, nframes));
163 }
164