2 Copyright (C) 2000-2003 Paul Davis
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.
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.
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.
31 #include "pbd/error.h"
33 #include "pbd/basename.h"
34 #include <glibmm/threads.h>
35 #include "pbd/xml++.h"
36 #include "pbd/memento_command.h"
37 #include "pbd/enumwriter.h"
38 #include "pbd/stateful_diff_command.h"
39 #include "pbd/stacktrace.h"
41 #include "ardour/audioengine.h"
42 #include "ardour/butler.h"
43 #include "ardour/debug.h"
44 #include "ardour/io.h"
45 #include "ardour/midi_diskstream.h"
46 #include "ardour/midi_model.h"
47 #include "ardour/midi_playlist.h"
48 #include "ardour/midi_port.h"
49 #include "ardour/midi_region.h"
50 #include "ardour/midi_ring_buffer.h"
51 #include "ardour/midi_track.h"
52 #include "ardour/playlist_factory.h"
53 #include "ardour/region_factory.h"
54 #include "ardour/session.h"
55 #include "ardour/session_playlists.h"
56 #include "ardour/smf_source.h"
57 #include "ardour/types.h"
58 #include "ardour/utils.h"
60 #include "midi++/types.h"
66 using namespace ARDOUR;
69 framecnt_t MidiDiskstream::midi_readahead = 4096;
71 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
72 : Diskstream(sess, name, flag)
75 , _note_mode(Sustained)
76 , _frames_written_to_ringbuffer(0)
77 , _frames_read_from_ringbuffer(0)
78 , _frames_pending_write(0)
79 , _num_captured_loops(0)
80 , _accumulated_capture_offset(0)
81 , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
87 use_new_write_source (0);
92 throw failed_constructor();
96 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
97 : Diskstream(sess, node)
100 , _note_mode(Sustained)
101 , _frames_written_to_ringbuffer(0)
102 , _frames_read_from_ringbuffer(0)
103 , _frames_pending_write(0)
104 , _num_captured_loops(0)
105 , _accumulated_capture_offset(0)
106 , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
112 if (set_state (node, Stateful::loading_state_version)) {
113 in_set_state = false;
114 throw failed_constructor();
117 use_new_write_source (0);
119 in_set_state = false;
123 MidiDiskstream::init ()
125 /* there are no channels at this point, so these
126 two calls just get speed_buffer_size and wrap_buffer
127 size setup without duplicating their code.
130 set_block_size (_session.get_block_size());
131 allocate_temporary_buffers ();
133 const size_t size = _session.butler()->midi_diskstream_buffer_size();
134 _playback_buf = new MidiRingBuffer<framepos_t>(size);
135 _capture_buf = new MidiRingBuffer<framepos_t>(size);
137 _n_channels = ChanCount(DataType::MIDI, 1);
140 MidiDiskstream::~MidiDiskstream ()
142 Glib::Threads::Mutex::Lock lm (state_lock);
143 delete _playback_buf;
149 MidiDiskstream::non_realtime_locate (framepos_t position)
152 _write_source->set_timeline_position (position);
154 seek (position, false);
159 MidiDiskstream::non_realtime_input_change ()
162 Glib::Threads::Mutex::Lock lm (state_lock);
164 if (input_change_pending.type == IOChange::NoChange) {
168 if (input_change_pending.type & IOChange::ConfigurationChanged) {
169 uint32_t ni = _io->n_ports().n_midi();
171 if (ni != _n_channels.n_midi()) {
172 error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
175 _n_channels, input_change_pending.type)
180 _source_port.reset ();
182 _source_port = _io->midi(0);
186 if (input_change_pending.type & IOChange::ConnectionsChanged) {
187 set_capture_offset ();
188 set_align_style_from_io ();
191 input_change_pending.type = IOChange::NoChange;
193 /* implicit unlock */
196 /* unlike with audio, there is never any need to reset write sources
197 based on input configuration changes because ... a MIDI track
198 has just 1 MIDI port as input, always.
201 /* now refill channel buffers */
203 if (speed() != 1.0f || speed() != -1.0f) {
204 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
207 seek (_session.transport_frame());
210 g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
211 g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
215 MidiDiskstream::find_and_use_playlist (const string& name)
217 boost::shared_ptr<MidiPlaylist> playlist;
219 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
220 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
224 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't a midi playlist"), name) << endmsg;
228 return use_playlist (playlist);
232 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
234 if (boost::dynamic_pointer_cast<MidiPlaylist>(playlist)) {
235 Diskstream::use_playlist(playlist);
242 MidiDiskstream::use_new_playlist ()
245 boost::shared_ptr<MidiPlaylist> playlist;
247 if (!in_set_state && destructive()) {
252 newname = Playlist::bump_name (_playlist->name(), _session);
254 newname = Playlist::bump_name (_name, _session);
257 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
258 DataType::MIDI, _session, newname, hidden()))) != 0) {
260 return use_playlist (playlist);
268 MidiDiskstream::use_copy_playlist ()
274 if (_playlist == 0) {
275 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
280 boost::shared_ptr<MidiPlaylist> playlist;
282 newname = Playlist::bump_name (_playlist->name(), _session);
284 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
285 return use_playlist (playlist);
291 /** Overloaded from parent to die horribly
294 MidiDiskstream::set_destructive (bool yn)
300 MidiDiskstream::set_note_mode (NoteMode m)
303 midi_playlist()->set_note_mode(m);
304 if (_write_source && _write_source->model())
305 _write_source->model()->set_note_mode(m);
308 /** Get the start, end, and length of a location "atomically".
310 * Note: Locations don't get deleted, so all we care about when I say "atomic"
311 * is that we are always pointing to the same one and using start/length values
312 * obtained just once. Use this function to achieve this since location being
313 * a parameter achieves this.
316 get_location_times(const Location* location,
322 *start = location->start();
323 *end = location->end();
324 *length = *end - *start;
329 MidiDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
331 framecnt_t rec_offset = 0;
332 framecnt_t rec_nframes = 0;
333 bool nominally_recording;
334 bool re = record_enabled ();
335 bool can_record = _session.actively_recording ();
337 playback_distance = 0;
339 check_record_status (transport_frame, can_record);
341 nominally_recording = (can_record && re);
347 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
353 Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK);
359 const Location* const loop_loc = loop_location;
360 framepos_t loop_start = 0;
361 framepos_t loop_end = 0;
362 framepos_t loop_length = 0;
363 get_location_times(loop_loc, &loop_start, &loop_end, &loop_length);
365 adjust_capture_position = 0;
367 if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
368 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
369 // XXX should this be transport_frame + nframes - 1 ? coverage() expects its parameter ranges to include their end points
371 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
372 /* For audio: not writing frames to the capture ringbuffer offsets
373 * the recording. For midi: we need to keep track of the record range
374 * and subtract the accumulated difference from the event time.
377 _accumulated_capture_offset += rec_offset;
379 _accumulated_capture_offset += nframes;
382 if (rec_nframes && !was_recording) {
384 /* Loop recording, so pretend the capture started at the loop
385 start rgardless of what time it is now, so the source starts
386 at the loop start and can handle time wrapping around.
387 Otherwise, start the source right now as usual.
389 capture_captured = transport_frame - loop_start;
390 capture_start_frame = loop_start;
392 _write_source->mark_write_starting_now(
393 capture_start_frame, capture_captured, loop_length);
394 g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
395 g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
396 was_recording = true;
400 if (can_record && !_last_capture_sources.empty()) {
401 _last_capture_sources.clear ();
404 if (nominally_recording || rec_nframes) {
406 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
407 MidiBuffer& buf = sp->get_midi_buffer(nframes);
408 ChannelMode mode = AllChannels;
409 uint32_t mask = 0xffff;
411 MidiTrack * mt = dynamic_cast<MidiTrack*> (_track);
413 mode = mt->get_capture_channel_mode ();
414 mask = mt->get_capture_channel_mask ();
417 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
418 Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
419 if (ev.time() + rec_offset > rec_nframes) {
423 if (DEBUG::MidiIO & PBD::debug_bits) {
424 const uint8_t* __data = ev.buffer();
426 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), transport_frame, ev.size()));
427 for (size_t i=0; i < ev.size(); ++i) {
428 DEBUG_STR_APPEND(a,hex);
429 DEBUG_STR_APPEND(a,"0x");
430 DEBUG_STR_APPEND(a,(int)__data[i]);
431 DEBUG_STR_APPEND(a,' ');
433 DEBUG_STR_APPEND(a,'\n');
434 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
437 /* Write events to the capture buffer in frames from session start,
438 but ignoring looping so event time progresses monotonically.
439 The source knows the loop length so it knows exactly where the
440 event occurs in the series of recorded loops and can implement
441 any desirable behaviour. We don't want to send event with
442 transport time here since that way the source can not
443 reconstruct their actual time; future clever MIDI looping should
444 probably be implemented in the source instead of here.
446 const framecnt_t loop_offset = _num_captured_loops * loop_length;
447 const framepos_t event_time = transport_frame + loop_offset - _accumulated_capture_offset + ev.time();
448 if (event_time < 0 || event_time < first_recordable_frame) {
453 _capture_buf->write(event_time,
454 ev.type(), ev.size(), ev.buffer());
457 if (ev.is_channel_event()) {
458 if ((1<<ev.channel()) & mask) {
459 _capture_buf->write(event_time,
460 ev.type(), ev.size(), ev.buffer());
463 _capture_buf->write(event_time,
464 ev.type(), ev.size(), ev.buffer());
468 if (ev.is_channel_event()) {
469 ev.set_channel (PBD::ffs(mask) - 1);
471 _capture_buf->write(event_time,
472 ev.type(), ev.size(), ev.buffer());
476 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
478 if (buf.size() != 0) {
479 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
482 /* Copy this data into our GUI feed buffer and tell the GUI
483 that it can read it if it likes.
485 _gui_feed_buffer.clear ();
487 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
488 /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
489 the end of the world if it does.
491 _gui_feed_buffer.push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
495 DataRecorded (_write_source); /* EMIT SIGNAL */
503 _accumulated_capture_offset = 0;
509 /* data will be written to disk */
511 if (rec_nframes == nframes && rec_offset == 0) {
512 playback_distance = nframes;
515 adjust_capture_position = rec_nframes;
517 } else if (nominally_recording) {
519 /* XXXX do this for MIDI !!!
520 can't do actual capture yet - waiting for latency effects to finish before we start
523 playback_distance = nframes;
527 /* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
529 playback_distance = nframes;
531 #ifndef NO_SIMPLE_MIDI_VARISPEED
532 if (_target_speed > 0) {
533 playback_distance = nframes * _target_speed;
539 if (need_disk_signal) {
540 /* copy the diskstream data to all output buffers */
542 MidiBuffer& mbuf (bufs.get_midi (0));
543 #ifndef NO_SIMPLE_MIDI_VARISPEED
544 get_playback (mbuf, nframes * _target_speed);
546 get_playback (mbuf, nframes);
549 /* leave the audio count alone */
550 ChanCount cnt (DataType::MIDI, 1);
551 cnt.set (DataType::AUDIO, bufs.count().n_audio());
552 bufs.set_count (cnt);
554 #ifndef NO_SIMPLE_MIDI_VARISPEED
555 if (_target_speed > 0 && playback_distance != nframes) {
556 MidiBuffer& mbuf (bufs.get_midi (0));
557 for (MidiBuffer::iterator i = mbuf.begin(); i != mbuf.end(); ++i) {
558 MidiBuffer::TimeType *tme = i.timeptr();
559 *tme = (*tme) / _target_speed;
569 MidiDiskstream::calculate_playback_distance (pframes_t nframes)
571 #ifndef NO_SIMPLE_MIDI_VARISPEED
572 frameoffset_t playback_distance = nframes * _target_speed;
574 frameoffset_t playback_distance = nframes;
576 /* XXX: should be doing varispeed stuff once it's implemented in ::process() above */
579 if (_actual_speed < 0.0) {
580 return -playback_distance;
582 return playback_distance;
587 MidiDiskstream::commit (framecnt_t playback_distance)
589 bool need_butler = false;
591 if (_actual_speed < 0.0) {
592 playback_sample -= playback_distance;
594 playback_sample += playback_distance;
597 if (adjust_capture_position != 0) {
598 capture_captured += adjust_capture_position;
599 adjust_capture_position = 0;
602 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
603 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
606 cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
607 " = " << frames_written - frames_read
608 << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
611 /* frames_read will generally be less than frames_written, but
612 * immediately after an overwrite, we can end up having read some data
613 * before we've written any. we don't need to trip an assert() on this,
614 * but we do need to check so that the decision on whether or not we
615 * need the butler is done correctly.
618 if (frames_read <= frames_written) {
619 if ((frames_written - frames_read) + playback_distance < midi_readahead) {
629 MidiDiskstream::set_pending_overwrite (bool yn)
631 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
633 _pending_overwrite = yn;
634 overwrite_frame = playback_sample;
638 MidiDiskstream::overwrite_existing_buffers ()
640 /* Clear the playback buffer contents. This is safe as long as the butler
641 thread is suspended, which it should be. */
642 _playback_buf->reset ();
643 _playback_buf->reset_tracker ();
645 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
646 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
648 /* Resolve all currently active notes in the playlist. This is more
649 aggressive than it needs to be: ideally we would only resolve what is
650 absolutely necessary, but this seems difficult and/or impossible without
651 having the old data or knowing what change caused the overwrite. */
652 midi_playlist()->resolve_note_trackers (*_playback_buf, overwrite_frame);
654 read (overwrite_frame, disk_read_chunk_frames, false);
655 file_frame = overwrite_frame; // it was adjusted by ::read()
656 overwrite_queued = false;
657 _pending_overwrite = false;
663 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
665 Glib::Threads::Mutex::Lock lm (state_lock);
668 if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
669 /* we haven't read anything since the last seek,
670 so flush all note trackers to prevent
676 _playback_buf->reset();
677 _capture_buf->reset();
678 g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
679 g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
681 playback_sample = frame;
684 if (complete_refill) {
685 while ((ret = do_refill_with_alloc ()) > 0) ;
687 ret = do_refill_with_alloc ();
694 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
696 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
697 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
698 return ((frames_written - frames_read) < distance);
702 MidiDiskstream::internal_playback_seek (framecnt_t distance)
704 first_recordable_frame += distance;
705 playback_sample += distance;
710 /** @a start is set to the new frame position (TIME) read up to */
712 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
714 framecnt_t this_read = 0;
716 framepos_t loop_end = 0;
717 framepos_t loop_start = 0;
718 framecnt_t loop_length = 0;
724 get_location_times(loc, &loop_start, &loop_end, &loop_length);
726 /* if we are looping, ensure that the first frame we read is at the correct
727 position within the loop.
730 if (loc && (start >= loop_end)) {
731 //cerr << "start adjusted from " << start;
732 start = loop_start + ((start - loop_start) % loop_length);
733 //cerr << "to " << start << endl;
735 // cerr << "start is " << start << " end " << start+dur << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
740 /* take any loop into account. we can't read past the end of the loop. */
742 if (loc && (loop_end - start <= dur)) {
743 this_read = loop_end - start;
744 // cerr << "reloop true: thisread: " << this_read << " dur: " << dur << endl;
751 if (this_read == 0) {
755 this_read = min(dur,this_read);
757 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
758 error << string_compose(
759 _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
760 id(), this_read, start) << endmsg;
764 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
768 // Swap note ons with note offs here. etc?
769 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
770 // CC values etc. hard.
774 /* if we read to the end of the loop, go back to the beginning */
776 // Synthesize LoopEvent here, because the next events
777 // written will have non-monotonic timestamps.
785 //offset += this_read;
792 MidiDiskstream::do_refill_with_alloc ()
798 MidiDiskstream::do_refill ()
801 size_t write_space = _playback_buf->write_space();
802 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
804 if (write_space == 0) {
812 /* at end: nothing to do */
813 if (file_frame == max_framepos) {
817 /* no space to write */
818 if (_playback_buf->write_space() == 0) {
822 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
823 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
824 if ((frames_written - frames_read) >= midi_readahead) {
828 framecnt_t to_read = midi_readahead - (frames_written - frames_read);
830 //cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
831 // << frames_written - frames_read << endl;
833 to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
835 if (read (file_frame, to_read, reversed)) {
842 /** Flush pending data to disk.
844 * Important note: this function will write *AT MOST* disk_write_chunk_frames
845 * of data to disk. it will never write more than that. If it writes that
846 * much and there is more than that waiting to be written, it will return 1,
847 * otherwise 0 on success or -1 on failure.
849 * If there is less than disk_write_chunk_frames to be written, no data will be
850 * written at all unless @a force_flush is true.
853 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
858 if (!_write_source) {
862 const framecnt_t total = g_atomic_int_get(const_cast<gint*> (&_frames_pending_write));
865 _capture_buf->read_space() == 0 ||
866 (!force_flush && (total < disk_write_chunk_frames) && was_recording)) {
870 /* if there are 2+ chunks of disk i/o possible for
871 this track), let the caller know so that it can arrange
872 for us to be called again, ASAP.
874 if we are forcing a flush, then if there is* any* extra
875 work, let the caller know.
877 if we are no longer recording and there is any extra work,
878 let the caller know too.
881 if (total >= 2 * disk_write_chunk_frames || ((force_flush || !was_recording) && total > disk_write_chunk_frames)) {
886 /* push out everything we have, right now */
887 to_write = max_framecnt;
889 to_write = disk_write_chunk_frames;
892 if (record_enabled() && ((total > disk_write_chunk_frames) || force_flush)) {
893 Source::Lock lm(_write_source->mutex());
894 if (_write_source->midi_write (lm, *_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
895 error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
898 g_atomic_int_add(const_cast<gint*> (&_frames_pending_write), -to_write);
906 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
908 bool more_work = true;
910 boost::shared_ptr<MidiRegion> region;
911 MidiRegion::SourceList srcs;
912 MidiRegion::SourceList::iterator src;
913 vector<CaptureInfo*>::iterator ci;
917 /* butler is already stopped, but there may be work to do
918 to flush remaining data to disk.
921 while (more_work && !err) {
922 switch (do_flush (TransportContext, true)) {
929 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
934 /* XXX is there anything we can do if err != 0 ? */
935 Glib::Threads::Mutex::Lock lm (capture_info_lock);
937 if (capture_info.empty()) {
938 goto no_capture_stuff_to_do;
944 _write_source->mark_for_remove ();
945 _write_source->drop_references ();
946 _write_source.reset();
949 /* new source set up in "out" below */
953 framecnt_t total_capture = 0;
954 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
955 total_capture += (*ci)->frames;
958 if (_write_source->length (capture_info.front()->start) != 0) {
960 /* phew, we have data */
962 Source::Lock source_lock(_write_source->mutex());
964 /* figure out the name for this take */
966 srcs.push_back (_write_source);
968 _write_source->set_timeline_position (capture_info.front()->start);
969 _write_source->set_captured_for (_name);
971 /* set length in beats to entire capture length */
973 BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
974 const Evoral::Beats total_capture_beats = converter.from (total_capture);
975 _write_source->set_length_beats (total_capture_beats);
977 /* flush to disk: this step differs from the audio path,
978 where all the data is already on disk.
981 _write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, total_capture_beats);
983 /* we will want to be able to keep (over)writing the source
984 but we don't want it to be removable. this also differs
985 from the audio situation, where the source at this point
986 must be considered immutable. luckily, we can rely on
987 MidiSource::mark_streaming_write_completed() to have
988 already done the necessary work for that.
991 string whole_file_region_name;
992 whole_file_region_name = region_name_from_path (_write_source->name(), true);
994 /* Register a new region with the Session that
995 describes the entire source. Do this first
996 so that any sub-regions will obviously be
997 children of this one (later!)
1003 plist.add (Properties::name, whole_file_region_name);
1004 plist.add (Properties::whole_file, true);
1005 plist.add (Properties::automatic, true);
1006 plist.add (Properties::start, 0);
1007 plist.add (Properties::length, total_capture);
1008 plist.add (Properties::layer, 0);
1010 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1012 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1013 region->special_set_position (capture_info.front()->start);
1017 catch (failed_constructor& err) {
1018 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1022 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1024 _playlist->clear_changes ();
1025 _playlist->freeze ();
1027 /* Session frame time of the initial capture in this pass, which is where the source starts */
1028 framepos_t initial_capture = 0;
1029 if (!capture_info.empty()) {
1030 initial_capture = capture_info.front()->start;
1033 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1037 RegionFactory::region_name (region_name, _write_source->name(), false);
1039 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1040 _name, (*ci)->start, (*ci)->frames, region_name));
1043 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1048 /* start of this region is the offset between the start of its capture and the start of the whole pass */
1049 plist.add (Properties::start, (*ci)->start - initial_capture);
1050 plist.add (Properties::length, (*ci)->frames);
1051 plist.add (Properties::length_beats, converter.from((*ci)->frames));
1052 plist.add (Properties::name, region_name);
1054 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1055 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1058 catch (failed_constructor& err) {
1059 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1060 continue; /* XXX is this OK? */
1063 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1065 i_am_the_modifier++;
1066 _playlist->add_region (region, (*ci)->start);
1067 i_am_the_modifier--;
1071 _session.add_command (new StatefulDiffCommand(_playlist));
1075 /* No data was recorded, so this capture will
1076 effectively be aborted; do the same as we
1077 do for an explicit abort.
1080 if (_write_source) {
1081 _write_source->mark_for_remove ();
1082 _write_source->drop_references ();
1083 _write_source.reset();
1089 use_new_write_source (0);
1091 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1095 capture_info.clear ();
1096 capture_start_frame = 0;
1098 no_capture_stuff_to_do:
1104 MidiDiskstream::transport_looped (framepos_t)
1106 /* Here we only keep track of the number of captured loops so monotonic
1107 event times can be delivered to the write source in process(). Trying
1108 to be clever here is a world of trouble, it is better to simply record
1109 the input in a straightforward non-destructive way. In the future when
1110 we want to implement more clever MIDI looping modes it should be done in
1111 the Source and/or entirely after the capture is finished.
1113 if (was_recording) {
1114 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1119 MidiDiskstream::finish_capture ()
1121 was_recording = false;
1123 if (capture_captured == 0) {
1127 CaptureInfo* ci = new CaptureInfo;
1129 ci->start = capture_start_frame;
1130 ci->frames = capture_captured;
1132 /* XXX theoretical race condition here. Need atomic exchange ?
1133 However, the circumstances when this is called right
1134 now (either on record-disable or transport_stopped)
1135 mean that no actual race exists. I think ...
1136 We now have a capture_info_lock, but it is only to be used
1137 to synchronize in the transport_stop and the capture info
1138 accessors, so that invalidation will not occur (both non-realtime).
1141 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1143 capture_info.push_back (ci);
1144 capture_captured = 0;
1148 MidiDiskstream::set_record_enabled (bool yn)
1150 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1154 /* yes, i know that this not proof against race conditions, but its
1155 good enough. i think.
1158 if (record_enabled() != yn) {
1160 engage_record_enable ();
1162 disengage_record_enable ();
1165 RecordEnableChanged (); /* EMIT SIGNAL */
1170 MidiDiskstream::prep_record_enable ()
1172 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1176 bool const rolling = _session.transport_speed() != 0.0f;
1178 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1180 if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1181 sp->request_input_monitoring (!(_session.config.get_auto_input() && rolling));
1188 MidiDiskstream::prep_record_disable ()
1195 MidiDiskstream::get_state ()
1197 XMLNode& node (Diskstream::get_state());
1199 LocaleGuard lg (X_("C"));
1201 if (_write_source && _session.get_record_enabled()) {
1203 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1204 XMLNode* cs_grandchild;
1206 cs_grandchild = new XMLNode (X_("file"));
1207 cs_grandchild->add_property (X_("path"), _write_source->path());
1208 cs_child->add_child_nocopy (*cs_grandchild);
1210 /* store the location where capture will start */
1214 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1215 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1217 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1220 cs_child->add_property (X_("at"), buf);
1221 node.add_child_nocopy (*cs_child);
1228 MidiDiskstream::set_state (const XMLNode& node, int version)
1230 XMLNodeList nlist = node.children();
1231 XMLNodeIterator niter;
1232 XMLNode* capture_pending_node = 0;
1233 LocaleGuard lg (X_("C"));
1235 /* prevent write sources from being created */
1237 in_set_state = true;
1239 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1240 if ((*niter)->name() == X_("CapturingSources")) {
1241 capture_pending_node = *niter;
1245 if (Diskstream::set_state (node, version)) {
1249 if (capture_pending_node) {
1250 use_pending_capture_data (*capture_pending_node);
1253 in_set_state = false;
1259 MidiDiskstream::use_new_write_source (uint32_t n)
1261 if (!_session.writable() || !recordable()) {
1265 _accumulated_capture_offset = 0;
1266 _write_source.reset();
1269 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1270 _session.create_midi_source_for_session (write_source_name ()));
1272 if (!_write_source) {
1273 throw failed_constructor();
1277 catch (failed_constructor &err) {
1278 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1279 _write_source.reset();
1286 * We want to use the name of the existing write source (the one that will be
1287 * used by the next capture) for another purpose. So change the name of the
1288 * current source, and return its current name.
1290 * Return an empty string if the change cannot be accomplished.
1293 MidiDiskstream::steal_write_source_name ()
1295 string our_old_name = _write_source->name();
1297 /* this will bump the name of the current write source to the next one
1298 * (e.g. "MIDI 1-1" gets renamed to "MIDI 1-2"), thus leaving the
1299 * current write source name (e.g. "MIDI 1-1" available). See the
1300 * comments in Session::create_midi_source_by_stealing_name() about why
1305 string new_path = _session.new_midi_source_path (name());
1307 if (_write_source->rename (new_path)) {
1314 return our_old_name;
1318 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1320 if (!_session.writable() || !recordable()) {
1324 if (_write_source && mark_write_complete) {
1325 Source::Lock lm(_write_source->mutex());
1326 _write_source->mark_streaming_write_completed (lm);
1328 use_new_write_source (0);
1332 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1337 MidiDiskstream::allocate_temporary_buffers ()
1342 MidiDiskstream::ensure_input_monitoring (bool yn)
1344 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1347 sp->ensure_input_monitoring (yn);
1352 MidiDiskstream::set_align_style_from_io ()
1354 if (_alignment_choice != Automatic) {
1358 /* XXX Not sure what, if anything we can do with MIDI
1359 as far as capture alignment etc.
1362 set_align_style (ExistingMaterial);
1367 MidiDiskstream::playback_buffer_load () const
1369 /* For MIDI it's not trivial to differentiate the following two cases:
1371 1. The playback buffer is empty because the system has run out of time to fill it.
1372 2. The playback buffer is empty because there is no more data on the playlist.
1374 If we use a simple buffer load computation, we will report that the MIDI diskstream
1375 cannot keep up when #2 happens, when in fact it can. Since MIDI data rates
1376 are so low compared to audio, just give a pretend answer here.
1383 MidiDiskstream::capture_buffer_load () const
1385 /* We don't report playback buffer load, so don't report capture load either */
1391 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1397 MidiDiskstream::flush_playback (framepos_t start, framepos_t end)
1399 _playback_buf->flush (start, end);
1400 g_atomic_int_add (&_frames_read_from_ringbuffer, end - start);
1403 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1404 * so that an event at playback_sample has time = 0
1407 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1411 Location* loc = loop_location;
1413 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1414 "%1 MDS pre-read read %8 @ %4..%5 from %2 write to %3, LOOPED ? %6-%7\n", _name,
1415 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1416 (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes));
1418 // cerr << "================\n";
1419 // _playback_buf->dump (cerr);
1420 // cerr << "----------------\n";
1422 size_t events_read = 0;
1425 framepos_t effective_start;
1427 if (playback_sample >= loc->end()) {
1428 effective_start = loc->start() + ((playback_sample - loc->end()) % loc->length());
1430 effective_start = playback_sample;
1433 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1435 if (effective_start == loc->start()) {
1436 /* We need to turn off notes that may extend
1437 beyond the loop end.
1440 _playback_buf->resolve_tracker (dst, 0);
1443 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1444 /* end of loop is within the range we are reading, so
1445 split the read in two, and lie about the location
1448 framecnt_t first, second;
1450 first = loc->end() - effective_start;
1451 second = nframes - first;
1453 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4\n",
1454 effective_start, loc->end(), first, second));
1457 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1458 effective_start, first));
1459 events_read = _playback_buf->read (dst, effective_start, first);
1463 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1464 loc->start(), second));
1465 events_read += _playback_buf->read (dst, loc->start(), second);
1469 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1470 effective_start, nframes));
1471 events_read = _playback_buf->read (dst, effective_start, effective_start + nframes);
1474 events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1477 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1478 "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1479 _name, events_read, playback_sample, playback_sample + nframes,
1480 _playback_buf->read_space(), _playback_buf->write_space(),
1481 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1483 g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1487 MidiDiskstream::set_name (string const & name)
1489 if (_name == name) {
1492 Diskstream::set_name (name);
1494 /* get a new write source so that its name reflects the new diskstream name */
1495 use_new_write_source (0);
1501 MidiDiskstream::set_write_source_name (const std::string& str) {
1502 if (_write_source_name == str) {
1505 Diskstream::set_write_source_name (str);
1506 if (_write_source_name == name()) {
1509 use_new_write_source (0);
1513 boost::shared_ptr<MidiBuffer>
1514 MidiDiskstream::get_gui_feed_buffer () const
1516 boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1518 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1519 b->copy (_gui_feed_buffer);
1524 MidiDiskstream::reset_tracker ()
1526 _playback_buf->reset_tracker ();
1528 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1531 mp->reset_note_trackers ();
1535 boost::shared_ptr<MidiPlaylist>
1536 MidiDiskstream::midi_playlist ()
1538 return boost::dynamic_pointer_cast<MidiPlaylist>(_playlist);