fix --disable-plugins (bypass ‘em all)
[ardour.git] / libs / ardour / midi_source.cc
1 /*
2     Copyright (C) 2006 Paul Davis
3     Author: David Robillard
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 #include <sys/stat.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <float.h>
24 #include <cerrno>
25 #include <ctime>
26 #include <cmath>
27 #include <iomanip>
28 #include <algorithm>
29
30 #include <glibmm/fileutils.h>
31 #include <glibmm/miscutils.h>
32
33 #include "pbd/xml++.h"
34 #include "pbd/pthread_utils.h"
35 #include "pbd/basename.h"
36
37 #include "evoral/Control.hpp"
38 #include "evoral/EventSink.hpp"
39
40 #include "ardour/debug.h"
41 #include "ardour/midi_model.h"
42 #include "ardour/midi_state_tracker.h"
43 #include "ardour/midi_source.h"
44 #include "ardour/file_source.h"
45 #include "ardour/session.h"
46 #include "ardour/session_directory.h"
47 #include "ardour/source_factory.h"
48
49 #include "i18n.h"
50
51 namespace ARDOUR { template <typename T> class MidiRingBuffer; }
52
53 using namespace std;
54 using namespace ARDOUR;
55 using namespace PBD;
56
57 PBD::Signal1<void,MidiSource*> MidiSource::MidiSourceCreated;
58
59 MidiSource::MidiSource (Session& s, string name, Source::Flag flags)
60         : Source(s, DataType::MIDI, name, flags)
61         , _writing(false)
62         , _model_iter_valid(false)
63         , _length_beats(0.0)
64         , _last_read_end(0)
65         , _capture_length(0)
66         , _capture_loop_length(0)
67 {
68 }
69
70 MidiSource::MidiSource (Session& s, const XMLNode& node)
71         : Source(s, node)
72         , _writing(false)
73         , _model_iter_valid(false)
74         , _length_beats(0.0)
75         , _last_read_end(0)
76         , _capture_length(0)
77         , _capture_loop_length(0)
78 {
79         if (set_state (node, Stateful::loading_state_version)) {
80                 throw failed_constructor();
81         }
82 }
83
84 MidiSource::~MidiSource ()
85 {
86 }
87
88 XMLNode&
89 MidiSource::get_state ()
90 {
91         XMLNode& node (Source::get_state());
92
93         if (_captured_for.length()) {
94                 node.add_property ("captured-for", _captured_for);
95         }
96
97         for (InterpolationStyleMap::const_iterator i = _interpolation_style.begin(); i != _interpolation_style.end(); ++i) {
98                 XMLNode* child = node.add_child (X_("InterpolationStyle"));
99                 child->add_property (X_("parameter"), EventTypeMap::instance().to_symbol (i->first));
100                 child->add_property (X_("style"), enum_2_string (i->second));
101         }
102
103         for (AutomationStateMap::const_iterator i = _automation_state.begin(); i != _automation_state.end(); ++i) {
104                 XMLNode* child = node.add_child (X_("AutomationState"));
105                 child->add_property (X_("parameter"), EventTypeMap::instance().to_symbol (i->first));
106                 child->add_property (X_("state"), enum_2_string (i->second));
107         }
108
109         return node;
110 }
111
112 int
113 MidiSource::set_state (const XMLNode& node, int /*version*/)
114 {
115         const XMLProperty* prop;
116         if ((prop = node.property ("captured-for")) != 0) {
117                 _captured_for = prop->value();
118         }
119
120         XMLNodeList children = node.children ();
121         for (XMLNodeConstIterator i = children.begin(); i != children.end(); ++i) {
122                 if ((*i)->name() == X_("InterpolationStyle")) {
123                         if ((prop = (*i)->property (X_("parameter"))) == 0) {
124                                 error << _("Missing parameter property on InterpolationStyle") << endmsg;
125                                 return -1;
126                         }
127                         Evoral::Parameter p = EventTypeMap::instance().from_symbol (prop->value());
128
129                         if ((prop = (*i)->property (X_("style"))) == 0) {
130                                 error << _("Missing style property on InterpolationStyle") << endmsg;
131                                 return -1;
132                         }
133                         Evoral::ControlList::InterpolationStyle s = static_cast<Evoral::ControlList::InterpolationStyle>(
134                                 string_2_enum (prop->value(), s));
135                         set_interpolation_of (p, s);
136
137                 } else if ((*i)->name() == X_("AutomationState")) {
138                         if ((prop = (*i)->property (X_("parameter"))) == 0) {
139                                 error << _("Missing parameter property on AutomationState") << endmsg;
140                                 return -1;
141                         }
142                         Evoral::Parameter p = EventTypeMap::instance().from_symbol (prop->value());
143
144                         if ((prop = (*i)->property (X_("state"))) == 0) {
145                                 error << _("Missing state property on AutomationState") << endmsg;
146                                 return -1;
147                         }
148                         AutoState s = static_cast<AutoState> (string_2_enum (prop->value(), s));
149                         set_automation_state_of (p, s);
150                 }
151         }
152
153         return 0;
154 }
155
156 bool
157 MidiSource::empty () const
158 {
159         return !_length_beats;
160 }
161
162 framecnt_t
163 MidiSource::length (framepos_t pos) const
164 {
165         if (!_length_beats) {
166                 return 0;
167         }
168
169         BeatsFramesConverter converter(_session.tempo_map(), pos);
170         return converter.to(_length_beats);
171 }
172
173 void
174 MidiSource::update_length (framecnt_t)
175 {
176         // You're not the boss of me!
177 }
178
179 void
180 MidiSource::invalidate (const Lock& lock, std::set<Evoral::Sequence<Evoral::Beats>::WeakNotePtr>* notes)
181 {
182         _model_iter_valid = false;
183         _model_iter.invalidate(notes);
184 }
185
186 framecnt_t
187 MidiSource::midi_read (const Lock&                        lm,
188                        Evoral::EventSink<framepos_t>&     dst,
189                        framepos_t                         source_start,
190                        framepos_t                         start,
191                        framecnt_t                         cnt,
192                        MidiStateTracker*                  tracker,
193                        const std::set<Evoral::Parameter>& filtered) const
194 {
195         BeatsFramesConverter converter(_session.tempo_map(), source_start);
196
197         DEBUG_TRACE (DEBUG::MidiSourceIO,
198                      string_compose ("MidiSource::midi_read() %5 sstart %1 start %2 cnt %3 tracker %4\n",
199                                      source_start, start, cnt, tracker, name()));
200
201         if (_model) {
202                 // Find appropriate model iterator
203                 Evoral::Sequence<Evoral::Beats>::const_iterator& i = _model_iter;
204                 const bool linear_read = _last_read_end != 0 && start == _last_read_end;
205                 if (!linear_read || !_model_iter_valid) {
206                         // Cached iterator is invalid, search for the first event past start
207                         i = _model->begin(converter.from(start), false, filtered,
208                                           linear_read ? &_model->active_notes() : NULL);
209                         _model_iter_valid = true;
210                         if (!linear_read) {
211                                 _model->active_notes().clear();
212                         }
213                 }
214
215                 _last_read_end = start + cnt;
216
217                 // Copy events in [start, start + cnt) into dst
218                 for (; i != _model->end(); ++i) {
219                         const framecnt_t time_frames = converter.to(i->time());
220                         if (time_frames < start + cnt) {
221                                 // Offset by source start to convert event time to session time
222                                 dst.write (time_frames + source_start, i->event_type(), i->size(), i->buffer());
223
224                                 DEBUG_TRACE (DEBUG::MidiSourceIO,
225                                              string_compose ("%1: add event @ %2 type %3 size %4\n",
226                                                              _name, time_frames + source_start, i->event_type(), i->size()));
227
228                                 if (tracker) {
229                                         tracker->track (*i);
230                                 }
231                         } else {
232                                 DEBUG_TRACE (DEBUG::MidiSourceIO,
233                                              string_compose ("%1: reached end with event @ %2 vs. %3\n",
234                                                              _name, time_frames, start+cnt));
235                                 break;
236                         }
237                 }
238                 return cnt;
239         } else {
240                 return read_unlocked (lm, dst, source_start, start, cnt, tracker);
241         }
242 }
243
244 framecnt_t
245 MidiSource::midi_write (const Lock&                 lm,
246                         MidiRingBuffer<framepos_t>& source,
247                         framepos_t                  source_start,
248                         framecnt_t                  cnt)
249 {
250         const framecnt_t ret = write_unlocked (lm, source, source_start, cnt);
251
252         if (cnt == max_framecnt) {
253                 _last_read_end = 0;
254                 invalidate(lm);
255         } else {
256                 _capture_length += cnt;
257         }
258
259         return ret;
260 }
261
262 void
263 MidiSource::mark_streaming_midi_write_started (const Lock& lock, NoteMode mode)
264 {
265         if (_model) {
266                 _model->set_note_mode (mode);
267                 _model->start_write ();
268         }
269
270         _writing = true;
271 }
272
273 void
274 MidiSource::mark_write_starting_now (framecnt_t position,
275                                      framecnt_t capture_length,
276                                      framecnt_t loop_length)
277 {
278         /* I'm not sure if this is the best way to approach this, but
279            _capture_length needs to be set up with the transport frame
280            when a record actually starts, as it is used by
281            SMFSource::write_unlocked to decide whether incoming notes
282            are within the correct time range.
283            mark_streaming_midi_write_started (perhaps a more logical
284            place to do this) is not called at exactly the time when
285            record starts, and I don't think it necessarily can be
286            because it is not RT-safe.
287         */
288
289         set_timeline_position(position);
290         _capture_length      = capture_length;
291         _capture_loop_length = loop_length;
292
293         BeatsFramesConverter converter(_session.tempo_map(), position);
294         _length_beats = converter.from(capture_length);
295 }
296
297 void
298 MidiSource::mark_streaming_write_started (const Lock& lock)
299 {
300         NoteMode note_mode = _model ? _model->note_mode() : Sustained;
301         mark_streaming_midi_write_started (lock, note_mode);
302 }
303
304 void
305 MidiSource::mark_midi_streaming_write_completed (const Lock&                                      lock,
306                                                  Evoral::Sequence<Evoral::Beats>::StuckNoteOption option,
307                                                  Evoral::Beats                                    end)
308 {
309         if (_model) {
310                 _model->end_write (option, end);
311
312                 /* Make captured controls discrete to play back user input exactly. */
313                 for (MidiModel::Controls::iterator i = _model->controls().begin(); i != _model->controls().end(); ++i) {
314                         if (i->second->list()) {
315                                 i->second->list()->set_interpolation(Evoral::ControlList::Discrete);
316                                 _interpolation_style.insert(std::make_pair(i->second->parameter(), Evoral::ControlList::Discrete));
317                         }
318                 }
319         }
320
321         invalidate(lock);
322         _writing = false;
323 }
324
325 void
326 MidiSource::mark_streaming_write_completed (const Lock& lock)
327 {
328         mark_midi_streaming_write_completed (lock, Evoral::Sequence<Evoral::Beats>::DeleteStuckNotes);
329 }
330
331 int
332 MidiSource::write_to (const Lock& lock, boost::shared_ptr<MidiSource> newsrc, Evoral::Beats begin, Evoral::Beats end)
333 {
334         Lock newsrc_lock (newsrc->mutex ());
335
336         newsrc->set_timeline_position (_timeline_position);
337         newsrc->copy_interpolation_from (this);
338         newsrc->copy_automation_state_from (this);
339
340         if (_model) {
341                 if (begin == Evoral::MinBeats && end == Evoral::MaxBeats) {
342                         _model->write_to (newsrc, newsrc_lock);
343                 } else {
344                         _model->write_section_to (newsrc, newsrc_lock, begin, end);
345                 }
346         } else {
347                 error << string_compose (_("programming error: %1"), X_("no model for MidiSource during ::clone()"));
348                 return -1;
349         }
350
351         newsrc->flush_midi(newsrc_lock);
352
353         /* force a reload of the model if the range is partial */
354
355         if (begin != Evoral::MinBeats || end != Evoral::MaxBeats) {
356                 newsrc->load_model (newsrc_lock, true);
357         } else {
358                 newsrc->set_model (newsrc_lock, _model);
359         }
360
361         /* this file is not removable (but since it is MIDI, it is mutable) */
362
363         boost::dynamic_pointer_cast<FileSource> (newsrc)->prevent_deletion ();
364
365         return 0;
366 }
367
368 void
369 MidiSource::session_saved()
370 {
371         Lock lm (_lock);
372
373         /* this writes a copy of the data to disk.
374            XXX do we need to do this every time?
375         */
376
377         if (_model && _model->edited()) {
378                 /* The model is edited, write its contents into the current source
379                    file (overwiting previous contents). */
380
381                 /* Temporarily drop our reference to the model so that as the model
382                    pushes its current state to us, we don't try to update it. */
383                 boost::shared_ptr<MidiModel> mm = _model;
384                 _model.reset ();
385
386                 /* Flush model contents to disk. */
387                 mm->sync_to_source (lm);
388
389                 /* Reacquire model. */
390                 _model = mm;
391
392         } else {
393                 flush_midi(lm);
394         }
395 }
396
397 void
398 MidiSource::set_note_mode(const Lock& lock, NoteMode mode)
399 {
400         if (_model) {
401                 _model->set_note_mode(mode);
402         }
403 }
404
405 void
406 MidiSource::drop_model (const Lock& lock)
407 {
408         _model.reset();
409         invalidate(lock);
410         ModelChanged (); /* EMIT SIGNAL */
411 }
412
413 void
414 MidiSource::set_model (const Lock& lock, boost::shared_ptr<MidiModel> m)
415 {
416         _model = m;
417         invalidate(lock);
418         ModelChanged (); /* EMIT SIGNAL */
419 }
420
421 Evoral::ControlList::InterpolationStyle
422 MidiSource::interpolation_of (Evoral::Parameter p) const
423 {
424         InterpolationStyleMap::const_iterator i = _interpolation_style.find (p);
425         if (i == _interpolation_style.end()) {
426                 return EventTypeMap::instance().interpolation_of (p);
427         }
428
429         return i->second;
430 }
431
432 AutoState
433 MidiSource::automation_state_of (Evoral::Parameter p) const
434 {
435         AutomationStateMap::const_iterator i = _automation_state.find (p);
436         if (i == _automation_state.end()) {
437                 /* default to `play', otherwise if MIDI is recorded /
438                    imported with controllers etc. they are by default
439                    not played back, which is a little surprising.
440                 */
441                 return Play;
442         }
443
444         return i->second;
445 }
446
447 /** Set interpolation style to be used for a given parameter.  This change will be
448  *  propagated to anyone who needs to know.
449  */
450 void
451 MidiSource::set_interpolation_of (Evoral::Parameter p, Evoral::ControlList::InterpolationStyle s)
452 {
453         if (interpolation_of (p) == s) {
454                 return;
455         }
456
457         if (EventTypeMap::instance().interpolation_of (p) == s) {
458                 /* interpolation type is being set to the default, so we don't need a note in our map */
459                 _interpolation_style.erase (p);
460         } else {
461                 _interpolation_style[p] = s;
462         }
463
464         InterpolationChanged (p, s); /* EMIT SIGNAL */
465 }
466
467 void
468 MidiSource::set_automation_state_of (Evoral::Parameter p, AutoState s)
469 {
470         if (automation_state_of (p) == s) {
471                 return;
472         }
473
474         if (s == Play) {
475                 /* automation state is being set to the default, so we don't need a note in our map */
476                 _automation_state.erase (p);
477         } else {
478                 _automation_state[p] = s;
479         }
480
481         AutomationStateChanged (p, s); /* EMIT SIGNAL */
482 }
483
484 void
485 MidiSource::copy_interpolation_from (boost::shared_ptr<MidiSource> s)
486 {
487         copy_interpolation_from (s.get ());
488 }
489
490 void
491 MidiSource::copy_automation_state_from (boost::shared_ptr<MidiSource> s)
492 {
493         copy_automation_state_from (s.get ());
494 }
495
496 void
497 MidiSource::copy_interpolation_from (MidiSource* s)
498 {
499         _interpolation_style = s->_interpolation_style;
500
501         /* XXX: should probably emit signals here */
502 }
503
504 void
505 MidiSource::copy_automation_state_from (MidiSource* s)
506 {
507         _automation_state = s->_automation_state;
508
509         /* XXX: should probably emit signals here */
510 }