2 Copyright (C) 2006 Paul Davis
3 Written by Dave Robillard, 2006
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.
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.
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.
31 #include <glibmm/fileutils.h>
33 #include "pbd/xml++.h"
34 #include "pbd/pthread_utils.h"
35 #include "pbd/basename.h"
37 #include "ardour/audioengine.h"
38 #include "ardour/debug.h"
39 #include "ardour/midi_model.h"
40 #include "ardour/midi_ring_buffer.h"
41 #include "ardour/midi_state_tracker.h"
42 #include "ardour/midi_source.h"
43 #include "ardour/session.h"
44 #include "ardour/session_directory.h"
45 #include "ardour/source_factory.h"
46 #include "ardour/tempo.h"
51 using namespace ARDOUR
;
54 PBD::Signal1
<void,MidiSource
*> MidiSource::MidiSourceCreated
;
56 MidiSource::MidiSource (Session
& s
, string name
, Source::Flag flags
)
57 : Source(s
, DataType::MIDI
, name
, flags
)
59 , _write_data_count(0)
61 , _model_iter_valid(false)
68 MidiSource::MidiSource (Session
& s
, const XMLNode
& node
)
71 , _write_data_count(0)
73 , _model_iter_valid(false)
79 _write_data_count
= 0;
81 if (set_state (node
, Stateful::loading_state_version
)) {
82 throw failed_constructor();
87 MidiSource::~MidiSource ()
92 MidiSource::get_state ()
94 XMLNode
& node (Source::get_state());
96 if (_captured_for
.length()) {
97 node
.add_property ("captured-for", _captured_for
);
100 for (InterpolationStyleMap::const_iterator i
= _interpolation_style
.begin(); i
!= _interpolation_style
.end(); ++i
) {
101 XMLNode
* child
= node
.add_child (X_("InterpolationStyle"));
102 child
->add_property (X_("parameter"), EventTypeMap::instance().to_symbol (i
->first
));
103 child
->add_property (X_("style"), enum_2_string (i
->second
));
106 for (AutomationStateMap::const_iterator i
= _automation_state
.begin(); i
!= _automation_state
.end(); ++i
) {
107 XMLNode
* child
= node
.add_child (X_("AutomationState"));
108 child
->add_property (X_("parameter"), EventTypeMap::instance().to_symbol (i
->first
));
109 child
->add_property (X_("state"), enum_2_string (i
->second
));
116 MidiSource::set_state (const XMLNode
& node
, int /*version*/)
118 const XMLProperty
* prop
;
120 if ((prop
= node
.property ("captured-for")) != 0) {
121 _captured_for
= prop
->value();
124 XMLNodeList children
= node
.children ();
125 for (XMLNodeConstIterator i
= children
.begin(); i
!= children
.end(); ++i
) {
126 if ((*i
)->name() == X_("InterpolationStyle")) {
129 if ((prop
= (*i
)->property (X_("parameter"))) == 0) {
130 error
<< _("Missing parameter property on InterpolationStyle") << endmsg
;
134 Evoral::Parameter p
= EventTypeMap::instance().new_parameter (prop
->value());
136 if ((prop
= (*i
)->property (X_("style"))) == 0) {
137 error
<< _("Missing style property on InterpolationStyle") << endmsg
;
141 Evoral::ControlList::InterpolationStyle s
= static_cast<Evoral::ControlList::InterpolationStyle
> (string_2_enum (prop
->value(), s
));
142 set_interpolation_of (p
, s
);
144 } else if ((*i
)->name() == X_("AutomationState")) {
148 if ((prop
= (*i
)->property (X_("parameter"))) == 0) {
149 error
<< _("Missing parameter property on AutomationState") << endmsg
;
153 Evoral::Parameter p
= EventTypeMap::instance().new_parameter (prop
->value());
155 if ((prop
= (*i
)->property (X_("state"))) == 0) {
156 error
<< _("Missing state property on AutomationState") << endmsg
;
160 AutoState s
= static_cast<AutoState
> (string_2_enum (prop
->value(), s
));
161 set_automation_state_of (p
, s
);
169 MidiSource::empty () const
171 return _length_beats
== 0;
175 MidiSource::length (framepos_t pos
) const
177 if (_length_beats
== 0) {
181 BeatsFramesConverter
converter(_session
.tempo_map(), pos
);
182 return converter
.to(_length_beats
);
186 MidiSource::update_length (framepos_t
/*pos*/, framecnt_t
/*cnt*/)
188 // You're not the boss of me!
192 MidiSource::invalidate ()
194 _model_iter_valid
= false;
195 _model_iter
.invalidate();
198 /** @param filtered A set of parameters whose MIDI messages will not be returned */
200 MidiSource::midi_read (Evoral::EventSink
<framepos_t
>& dst
, framepos_t source_start
,
201 framepos_t start
, framecnt_t cnt
,
202 MidiStateTracker
* tracker
,
203 std::set
<Evoral::Parameter
> const & filtered
) const
205 Glib::Mutex::Lock
lm (_lock
);
207 BeatsFramesConverter
converter(_session
.tempo_map(), source_start
);
210 Evoral::Sequence
<double>::const_iterator
& i
= _model_iter
;
212 // If the cached iterator is invalid, search for the first event past start
213 if (_last_read_end
== 0 || start
!= _last_read_end
|| !_model_iter_valid
) {
214 DEBUG_TRACE (DEBUG::MidiSourceIO
, string_compose ("*** %1 search for relevant iterator for %1 / %2\n", _name
, source_start
, start
));
215 for (i
= _model
->begin(0, false, filtered
); i
!= _model
->end(); ++i
) {
216 if (converter
.to(i
->time()) >= start
) {
220 _model_iter_valid
= true;
222 DEBUG_TRACE (DEBUG::MidiSourceIO
, string_compose ("*** %1 use cached iterator for %1 / %2\n", _name
, source_start
, start
));
225 _last_read_end
= start
+ cnt
;
227 // Read events up to end
228 for (; i
!= _model
->end(); ++i
) {
229 const framecnt_t time_frames
= converter
.to(i
->time());
230 if (time_frames
< start
+ cnt
) {
231 /* convert event times to session frames by adding on the source start position in session frames */
232 dst
.write (time_frames
+ source_start
, i
->event_type(), i
->size(), i
->buffer());
235 Evoral::MIDIEvent
<Evoral::MusicalTime
>& ev (*(Evoral::MIDIEvent
<Evoral::MusicalTime
>*) (&(*i
)));
236 if (ev
.is_note_on()) {
237 DEBUG_TRACE (DEBUG::MidiSourceIO
, string_compose ("\t%1 add note on %2 @ %3 velocity %4\n", _name
, ev
.note(), time_frames
, (int) ev
.velocity()));
238 tracker
->add (ev
.note(), ev
.channel());
239 } else if (ev
.is_note_off()) {
240 DEBUG_TRACE (DEBUG::MidiSourceIO
, string_compose ("\t%1 add note off %2 @ %3\n", _name
, ev
.note(), time_frames
));
241 tracker
->remove (ev
.note(), ev
.channel());
250 return read_unlocked (dst
, source_start
, start
, cnt
, tracker
);
254 /** Write data from a MidiRingBuffer to this source.
255 * @param source Source to read from.
256 * @param source_start This source's start position in session frames.
259 MidiSource::midi_write (MidiRingBuffer
<framepos_t
>& source
, framepos_t source_start
, framecnt_t duration
)
261 Glib::Mutex::Lock
lm (_lock
);
262 const framecnt_t ret
= write_unlocked (source
, source_start
, duration
);
263 _last_write_end
+= duration
;
268 MidiSource::mark_streaming_midi_write_started (NoteMode mode
)
271 _model
->set_note_mode (mode
);
272 _model
->start_write ();
279 MidiSource::mark_write_starting_now ()
281 /* I'm not sure if this is the best way to approach this, but
282 _last_write_end needs to be set up with the transport frame
283 when a record actually starts, as it is used by
284 SMFSource::write_unlocked to decide whether incoming notes
285 are within the correct time range.
286 mark_streaming_midi_write_started (perhaps a more logical
287 place to do this) is not called at exactly the time when
288 record starts, and I don't think it necessarily can be
289 because it is not RT-safe.
292 set_timeline_position (_session
.transport_frame ());
293 _last_write_end
= _session
.transport_frame ();
297 MidiSource::mark_streaming_write_started ()
299 NoteMode note_mode
= _model
? _model
->note_mode() : Sustained
;
300 mark_streaming_midi_write_started (note_mode
);
304 MidiSource::mark_streaming_write_completed ()
307 _model
->end_write(false);
313 boost::shared_ptr
<MidiSource
>
314 MidiSource::clone (Evoral::MusicalTime begin
, Evoral::MusicalTime end
)
316 string newname
= PBD::basename_nosuffix(_name
.val());
319 /* get a new name for the MIDI file we're going to write to
324 newname
= bump_name_once (newname
, '-');
325 /* XXX build path safely */
326 newpath
= _session
.session_directory().midi_path().to_string() +"/"+ newname
+ ".mid";
328 } while (Glib::file_test (newpath
, Glib::FILE_TEST_EXISTS
));
330 boost::shared_ptr
<MidiSource
> newsrc
= boost::dynamic_pointer_cast
<MidiSource
>(
331 SourceFactory::createWritable(DataType::MIDI
, _session
,
332 newpath
, string(), false, _session
.frame_rate()));
334 newsrc
->set_timeline_position(_timeline_position
);
335 newsrc
->copy_interpolation_from (this);
336 newsrc
->copy_automation_state_from (this);
339 if (begin
== Evoral::MinMusicalTime
&& end
== Evoral::MaxMusicalTime
) {
340 _model
->write_to (newsrc
);
342 _model
->write_section_to (newsrc
, begin
, end
);
345 error
<< string_compose (_("programming error: %1"), X_("no model for MidiSource during ::clone()"));
346 return boost::shared_ptr
<MidiSource
>();
349 newsrc
->flush_midi();
351 /* force a reload of the model if the range is partial */
353 if (begin
!= Evoral::MinMusicalTime
|| end
!= Evoral::MaxMusicalTime
) {
354 newsrc
->load_model (true, true);
356 newsrc
->set_model (_model
);
363 MidiSource::session_saved()
365 /* this writes a copy of the data to disk.
366 XXX do we need to do this every time?
369 if (_model
&& _model
->edited()) {
371 // if the model is edited, write its contents into
372 // the current source file (overwiting previous contents.
374 /* temporarily drop our reference to the model so that
375 as the model pushes its current state to us, we don't
379 boost::shared_ptr
<MidiModel
> mm
= _model
;
382 /* flush model contents to disk
385 mm
->sync_to_source ();
387 /* reacquire model */
397 MidiSource::set_note_mode(NoteMode mode
)
400 _model
->set_note_mode(mode
);
405 MidiSource::drop_model ()
408 ModelChanged (); /* EMIT SIGNAL */
412 MidiSource::set_model (boost::shared_ptr
<MidiModel
> m
)
415 ModelChanged (); /* EMIT SIGNAL */
418 /** @return Interpolation style that should be used for control parameter \a p */
419 Evoral::ControlList::InterpolationStyle
420 MidiSource::interpolation_of (Evoral::Parameter p
) const
422 InterpolationStyleMap::const_iterator i
= _interpolation_style
.find (p
);
423 if (i
== _interpolation_style
.end()) {
424 return EventTypeMap::instance().interpolation_of (p
);
431 MidiSource::automation_state_of (Evoral::Parameter p
) const
433 AutomationStateMap::const_iterator i
= _automation_state
.find (p
);
434 if (i
== _automation_state
.end()) {
435 /* default to `play', otherwise if MIDI is recorded /
436 imported with controllers etc. they are by default
437 not played back, which is a little surprising.
445 /** Set interpolation style to be used for a given parameter. This change will be
446 * propagated to anyone who needs to know.
449 MidiSource::set_interpolation_of (Evoral::Parameter p
, Evoral::ControlList::InterpolationStyle s
)
451 if (interpolation_of (p
) == s
) {
455 if (EventTypeMap::instance().interpolation_of (p
) == s
) {
456 /* interpolation type is being set to the default, so we don't need a note in our map */
457 _interpolation_style
.erase (p
);
459 _interpolation_style
[p
] = s
;
462 InterpolationChanged (p
, s
); /* EMIT SIGNAL */
466 MidiSource::set_automation_state_of (Evoral::Parameter p
, AutoState s
)
468 if (automation_state_of (p
) == s
) {
473 /* automation state is being set to the default, so we don't need a note in our map */
474 _automation_state
.erase (p
);
476 _automation_state
[p
] = s
;
479 AutomationStateChanged (p
, s
); /* EMIT SIGNAL */
483 MidiSource::copy_interpolation_from (boost::shared_ptr
<MidiSource
> s
)
485 copy_interpolation_from (s
.get ());
489 MidiSource::copy_automation_state_from (boost::shared_ptr
<MidiSource
> s
)
491 copy_automation_state_from (s
.get ());
495 MidiSource::copy_interpolation_from (MidiSource
* s
)
497 _interpolation_style
= s
->_interpolation_style
;
499 /* XXX: should probably emit signals here */
503 MidiSource::copy_automation_state_from (MidiSource
* s
)
505 _automation_state
= s
->_automation_state
;
507 /* XXX: should probably emit signals here */