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);
138 interpolation.add_channel_to (0,0);
141 MidiDiskstream::~MidiDiskstream ()
143 Glib::Threads::Mutex::Lock lm (state_lock);
144 delete _playback_buf;
150 MidiDiskstream::non_realtime_locate (framepos_t position)
153 _write_source->set_timeline_position (position);
155 seek (position, false);
160 MidiDiskstream::non_realtime_input_change ()
163 Glib::Threads::Mutex::Lock lm (state_lock);
165 if (input_change_pending.type == IOChange::NoChange) {
169 if (input_change_pending.type & IOChange::ConfigurationChanged) {
170 uint32_t ni = _io->n_ports().n_midi();
172 if (ni != _n_channels.n_midi()) {
173 error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
176 _n_channels, input_change_pending.type)
181 _source_port.reset ();
183 _source_port = _io->midi(0);
187 if (input_change_pending.type & IOChange::ConnectionsChanged) {
188 set_capture_offset ();
189 set_align_style_from_io ();
192 input_change_pending.type = IOChange::NoChange;
194 /* implicit unlock */
197 /* unlike with audio, there is never any need to reset write sources
198 based on input configuration changes because ... a MIDI track
199 has just 1 MIDI port as input, always.
202 /* now refill channel buffers */
204 if (speed() != 1.0f || speed() != -1.0f) {
205 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
208 seek (_session.transport_frame());
211 g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
212 g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
216 MidiDiskstream::find_and_use_playlist (const string& name)
218 boost::shared_ptr<MidiPlaylist> playlist;
220 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
221 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
225 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't a midi playlist"), name) << endmsg;
229 return use_playlist (playlist);
233 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
235 if (boost::dynamic_pointer_cast<MidiPlaylist>(playlist)) {
236 Diskstream::use_playlist(playlist);
243 MidiDiskstream::use_new_playlist ()
246 boost::shared_ptr<MidiPlaylist> playlist;
248 if (!in_set_state && destructive()) {
253 newname = Playlist::bump_name (_playlist->name(), _session);
255 newname = Playlist::bump_name (_name, _session);
258 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
259 DataType::MIDI, _session, newname, hidden()))) != 0) {
261 return use_playlist (playlist);
269 MidiDiskstream::use_copy_playlist ()
275 if (_playlist == 0) {
276 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
281 boost::shared_ptr<MidiPlaylist> playlist;
283 newname = Playlist::bump_name (_playlist->name(), _session);
285 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
286 return use_playlist (playlist);
292 /** Overloaded from parent to die horribly
295 MidiDiskstream::set_destructive (bool yn)
301 MidiDiskstream::set_note_mode (NoteMode m)
304 midi_playlist()->set_note_mode(m);
305 if (_write_source && _write_source->model())
306 _write_source->model()->set_note_mode(m);
309 /** Get the start, end, and length of a location "atomically".
311 * Note: Locations don't get deleted, so all we care about when I say "atomic"
312 * is that we are always pointing to the same one and using start/length values
313 * obtained just once. Use this function to achieve this since location being
314 * a parameter achieves this.
317 get_location_times(const Location* location,
323 *start = location->start();
324 *end = location->end();
325 *length = *end - *start;
330 MidiDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
332 framecnt_t rec_offset = 0;
333 framecnt_t rec_nframes = 0;
334 bool nominally_recording;
335 bool re = record_enabled ();
336 bool can_record = _session.actively_recording ();
338 playback_distance = 0;
340 check_record_status (transport_frame, can_record);
342 nominally_recording = (can_record && re);
348 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
354 Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK);
360 const Location* const loop_loc = loop_location;
361 framepos_t loop_start = 0;
362 framepos_t loop_end = 0;
363 framepos_t loop_length = 0;
364 get_location_times(loop_loc, &loop_start, &loop_end, &loop_length);
366 adjust_capture_position = 0;
368 if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
369 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
370 // XXX should this be transport_frame + nframes - 1 ? coverage() expects its parameter ranges to include their end points
372 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
373 /* For audio: not writing frames to the capture ringbuffer offsets
374 * the recording. For midi: we need to keep track of the record range
375 * and subtract the accumulated difference from the event time.
378 _accumulated_capture_offset += rec_offset;
380 _accumulated_capture_offset += nframes;
383 if (rec_nframes && !was_recording) {
385 /* Loop recording, so pretend the capture started at the loop
386 start rgardless of what time it is now, so the source starts
387 at the loop start and can handle time wrapping around.
388 Otherwise, start the source right now as usual.
390 capture_captured = transport_frame - loop_start;
391 capture_start_frame = loop_start;
393 _write_source->mark_write_starting_now(
394 capture_start_frame, capture_captured, loop_length);
395 g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
396 g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
397 was_recording = true;
401 if (can_record && !_last_capture_sources.empty()) {
402 _last_capture_sources.clear ();
405 if (nominally_recording || rec_nframes) {
406 // Pump entire port buffer into the ring buffer (TODO: split cycles?)
407 MidiBuffer& buf = sp->get_midi_buffer(nframes);
408 MidiTrack* mt = dynamic_cast<MidiTrack*>(_track);
409 MidiChannelFilter* filter = mt ? &mt->capture_filter() : NULL;
411 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
412 Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
413 if (ev.time() + rec_offset > rec_nframes) {
417 if (DEBUG_ENABLED(DEBUG::MidiIO)) {
418 const uint8_t* __data = ev.buffer();
420 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), transport_frame, ev.size()));
421 for (size_t i=0; i < ev.size(); ++i) {
422 DEBUG_STR_APPEND(a,hex);
423 DEBUG_STR_APPEND(a,"0x");
424 DEBUG_STR_APPEND(a,(int)__data[i]);
425 DEBUG_STR_APPEND(a,' ');
427 DEBUG_STR_APPEND(a,'\n');
428 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
431 /* Write events to the capture buffer in frames from session start,
432 but ignoring looping so event time progresses monotonically.
433 The source knows the loop length so it knows exactly where the
434 event occurs in the series of recorded loops and can implement
435 any desirable behaviour. We don't want to send event with
436 transport time here since that way the source can not
437 reconstruct their actual time; future clever MIDI looping should
438 probably be implemented in the source instead of here.
440 const framecnt_t loop_offset = _num_captured_loops * loop_length;
441 const framepos_t event_time = transport_frame + loop_offset - _accumulated_capture_offset + ev.time();
442 if (event_time < 0 || event_time < first_recordable_frame) {
443 /* Event out of range, skip */
447 if (!filter || !filter->filter(ev.buffer(), ev.size())) {
448 _capture_buf->write(event_time, ev.type(), ev.size(), ev.buffer());
451 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
453 if (buf.size() != 0) {
454 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
457 /* Copy this data into our GUI feed buffer and tell the GUI
458 that it can read it if it likes.
460 _gui_feed_buffer.clear ();
462 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
463 /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
464 the end of the world if it does.
466 _gui_feed_buffer.push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
470 DataRecorded (_write_source); /* EMIT SIGNAL */
478 _accumulated_capture_offset = 0;
484 /* data will be written to disk */
486 if (rec_nframes == nframes && rec_offset == 0) {
487 playback_distance = nframes;
490 adjust_capture_position = rec_nframes;
492 } else if (nominally_recording) {
494 /* XXXX do this for MIDI !!!
495 can't do actual capture yet - waiting for latency effects to finish before we start
498 playback_distance = nframes;
500 } else if (_actual_speed != 1.0f && _target_speed > 0) {
502 interpolation.set_speed (_target_speed);
504 playback_distance = interpolation.distance (nframes);
507 playback_distance = nframes;
510 if (need_disk_signal) {
511 /* copy the diskstream data to all output buffers */
513 MidiBuffer& mbuf (bufs.get_midi (0));
514 get_playback (mbuf, playback_distance);
516 /* leave the audio count alone */
517 ChanCount cnt (DataType::MIDI, 1);
518 cnt.set (DataType::AUDIO, bufs.count().n_audio());
519 bufs.set_count (cnt);
522 if (_target_speed > 0 && _actual_speed != 1.0f) {
523 MidiBuffer& mbuf (bufs.get_midi (0));
524 for (MidiBuffer::iterator i = mbuf.begin(); i != mbuf.end(); ++i) {
525 MidiBuffer::TimeType *tme = i.timeptr();
526 *tme = (*tme) * nframes / playback_distance;
535 MidiDiskstream::calculate_playback_distance (pframes_t nframes)
537 frameoffset_t playback_distance = nframes;
539 if (!record_enabled() && _actual_speed != 1.0f && _actual_speed > 0.f) {
540 interpolation.set_speed (_target_speed);
541 playback_distance = interpolation.distance (nframes, false);
544 if (_actual_speed < 0.0) {
545 return -playback_distance;
547 return playback_distance;
552 MidiDiskstream::commit (framecnt_t playback_distance)
554 bool need_butler = false;
556 if (!_io || !_io->active()) {
560 if (_actual_speed < 0.0) {
561 playback_sample -= playback_distance;
563 playback_sample += playback_distance;
566 if (adjust_capture_position != 0) {
567 capture_captured += adjust_capture_position;
568 adjust_capture_position = 0;
571 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
572 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
575 cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
576 " = " << frames_written - frames_read
577 << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
580 /* frames_read will generally be less than frames_written, but
581 * immediately after an overwrite, we can end up having read some data
582 * before we've written any. we don't need to trip an assert() on this,
583 * but we do need to check so that the decision on whether or not we
584 * need the butler is done correctly.
589 * Doing heavy GUI operations[1] can stall also the butler.
590 * The RT-thread meanwhile will happily continue and
591 * ‘frames_read’ (from buffer to output) will become larger
592 * than ‘frames_written’ (from disk to buffer).
594 * The disk-stream is now behind..
596 * In those cases the butler needs to be summed to refill the buffer (done now)
597 * AND we need to skip (frames_read - frames_written). ie remove old events
598 * before playback_sample from the rinbuffer.
600 * [1] one way to do so is described at #6170.
601 * For me just popping up the context-menu on a MIDI-track header
602 * of a track with a large (think beethoven :) midi-region also did the
603 * trick. The playhead stalls for 2 or 3 sec, until the context-menu shows.
605 * In both cases the root cause is that redrawing MIDI regions on the GUI is still very slow
608 if (frames_read <= frames_written) {
609 if ((frames_written - frames_read) + playback_distance < midi_readahead) {
621 MidiDiskstream::set_pending_overwrite (bool yn)
623 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
625 _pending_overwrite = yn;
626 overwrite_frame = playback_sample;
630 MidiDiskstream::overwrite_existing_buffers ()
632 /* Clear the playback buffer contents. This is safe as long as the butler
633 thread is suspended, which it should be. */
634 _playback_buf->reset ();
635 _playback_buf->reset_tracker ();
637 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
638 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
640 /* Resolve all currently active notes in the playlist. This is more
641 aggressive than it needs to be: ideally we would only resolve what is
642 absolutely necessary, but this seems difficult and/or impossible without
643 having the old data or knowing what change caused the overwrite. */
644 midi_playlist()->resolve_note_trackers (*_playback_buf, overwrite_frame);
646 read (overwrite_frame, disk_read_chunk_frames, false);
647 file_frame = overwrite_frame; // it was adjusted by ::read()
648 overwrite_queued = false;
649 _pending_overwrite = false;
655 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
657 Glib::Threads::Mutex::Lock lm (state_lock);
660 if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
661 /* we haven't read anything since the last seek,
662 so flush all note trackers to prevent
668 _playback_buf->reset();
669 _capture_buf->reset();
670 g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
671 g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
673 playback_sample = frame;
676 if (complete_refill) {
677 while ((ret = do_refill_with_alloc ()) > 0) ;
679 ret = do_refill_with_alloc ();
686 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
688 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
689 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
690 return ((frames_written - frames_read) < distance);
694 MidiDiskstream::internal_playback_seek (framecnt_t distance)
696 first_recordable_frame += distance;
697 playback_sample += distance;
702 /** @a start is set to the new frame position (TIME) read up to */
704 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
706 framecnt_t this_read = 0;
708 framepos_t loop_end = 0;
709 framepos_t loop_start = 0;
710 framecnt_t loop_length = 0;
713 MidiTrack* mt = dynamic_cast<MidiTrack*>(_track);
714 MidiChannelFilter* filter = mt ? &mt->playback_filter() : NULL;
719 get_location_times(loc, &loop_start, &loop_end, &loop_length);
721 /* if we are looping, ensure that the first frame we read is at the correct
722 position within the loop.
725 if (loc && (start >= loop_end)) {
726 //cerr << "start adjusted from " << start;
727 start = loop_start + ((start - loop_start) % loop_length);
728 //cerr << "to " << start << endl;
730 // cerr << "start is " << start << " end " << start+dur << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
735 /* take any loop into account. we can't read past the end of the loop. */
737 if (loc && (loop_end - start <= dur)) {
738 this_read = loop_end - start;
739 // cerr << "reloop true: thisread: " << this_read << " dur: " << dur << endl;
746 if (this_read == 0) {
750 this_read = min(dur,this_read);
752 if (midi_playlist()->read (*_playback_buf, start, this_read, 0, filter) != this_read) {
753 error << string_compose(
754 _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
755 id(), this_read, start) << endmsg;
759 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
763 // Swap note ons with note offs here. etc?
764 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
765 // CC values etc. hard.
769 /* if we read to the end of the loop, go back to the beginning */
771 // Synthesize LoopEvent here, because the next events
772 // written will have non-monotonic timestamps.
780 //offset += this_read;
787 MidiDiskstream::do_refill_with_alloc ()
793 MidiDiskstream::do_refill ()
796 size_t write_space = _playback_buf->write_space();
797 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
799 if (write_space == 0) {
807 /* at end: nothing to do */
808 if (file_frame == max_framepos) {
812 /* no space to write */
813 if (_playback_buf->write_space() == 0) {
817 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
818 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
819 if ((frames_read < frames_written) && (frames_written - frames_read) >= midi_readahead) {
823 framecnt_t to_read = midi_readahead - ((framecnt_t)frames_written - (framecnt_t)frames_read);
825 //cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
826 // << frames_written - frames_read << endl;
828 to_read = min (to_read, (framecnt_t) (max_framepos - file_frame));
829 to_read = min (to_read, (framecnt_t) write_space);
831 if (read (file_frame, to_read, reversed)) {
838 /** Flush pending data to disk.
840 * Important note: this function will write *AT MOST* disk_write_chunk_frames
841 * of data to disk. it will never write more than that. If it writes that
842 * much and there is more than that waiting to be written, it will return 1,
843 * otherwise 0 on success or -1 on failure.
845 * If there is less than disk_write_chunk_frames to be written, no data will be
846 * written at all unless @a force_flush is true.
849 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
854 if (!_write_source) {
858 const framecnt_t total = g_atomic_int_get(const_cast<gint*> (&_frames_pending_write));
861 _capture_buf->read_space() == 0 ||
862 (!force_flush && (total < disk_write_chunk_frames) && was_recording)) {
866 /* if there are 2+ chunks of disk i/o possible for
867 this track), let the caller know so that it can arrange
868 for us to be called again, ASAP.
870 if we are forcing a flush, then if there is* any* extra
871 work, let the caller know.
873 if we are no longer recording and there is any extra work,
874 let the caller know too.
877 if (total >= 2 * disk_write_chunk_frames || ((force_flush || !was_recording) && total > disk_write_chunk_frames)) {
882 /* push out everything we have, right now */
883 to_write = max_framecnt;
885 to_write = disk_write_chunk_frames;
888 if (record_enabled() && ((total > disk_write_chunk_frames) || force_flush)) {
889 Source::Lock lm(_write_source->mutex());
890 if (_write_source->midi_write (lm, *_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
891 error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
894 g_atomic_int_add(const_cast<gint*> (&_frames_pending_write), -to_write);
902 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
904 bool more_work = true;
906 boost::shared_ptr<MidiRegion> region;
907 MidiRegion::SourceList srcs;
908 MidiRegion::SourceList::iterator src;
909 vector<CaptureInfo*>::iterator ci;
913 /* butler is already stopped, but there may be work to do
914 to flush remaining data to disk.
917 while (more_work && !err) {
918 switch (do_flush (TransportContext, true)) {
925 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
930 /* XXX is there anything we can do if err != 0 ? */
931 Glib::Threads::Mutex::Lock lm (capture_info_lock);
933 if (capture_info.empty()) {
934 goto no_capture_stuff_to_do;
940 _write_source->mark_for_remove ();
941 _write_source->drop_references ();
942 _write_source.reset();
945 /* new source set up in "out" below */
949 framecnt_t total_capture = 0;
950 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
951 total_capture += (*ci)->frames;
954 if (_write_source->length (capture_info.front()->start) != 0) {
956 /* phew, we have data */
958 Source::Lock source_lock(_write_source->mutex());
960 /* figure out the name for this take */
962 srcs.push_back (_write_source);
964 _write_source->set_timeline_position (capture_info.front()->start);
965 _write_source->set_captured_for (_name);
967 /* set length in beats to entire capture length */
969 BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
970 const Evoral::Beats total_capture_beats = converter.from (total_capture);
971 _write_source->set_length_beats (total_capture_beats);
973 /* flush to disk: this step differs from the audio path,
974 where all the data is already on disk.
977 _write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, total_capture_beats);
979 /* we will want to be able to keep (over)writing the source
980 but we don't want it to be removable. this also differs
981 from the audio situation, where the source at this point
982 must be considered immutable. luckily, we can rely on
983 MidiSource::mark_streaming_write_completed() to have
984 already done the necessary work for that.
987 string whole_file_region_name;
988 whole_file_region_name = region_name_from_path (_write_source->name(), true);
990 /* Register a new region with the Session that
991 describes the entire source. Do this first
992 so that any sub-regions will obviously be
993 children of this one (later!)
999 plist.add (Properties::name, whole_file_region_name);
1000 plist.add (Properties::whole_file, true);
1001 plist.add (Properties::automatic, true);
1002 plist.add (Properties::start, 0);
1003 plist.add (Properties::length, total_capture);
1004 plist.add (Properties::layer, 0);
1006 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1008 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1009 region->special_set_position (capture_info.front()->start);
1013 catch (failed_constructor& err) {
1014 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1018 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1020 _playlist->clear_changes ();
1021 _playlist->freeze ();
1023 /* Session frame time of the initial capture in this pass, which is where the source starts */
1024 framepos_t initial_capture = 0;
1025 if (!capture_info.empty()) {
1026 initial_capture = capture_info.front()->start;
1029 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1033 RegionFactory::region_name (region_name, _write_source->name(), false);
1035 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1036 _name, (*ci)->start, (*ci)->frames, region_name));
1039 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1044 /* start of this region is the offset between the start of its capture and the start of the whole pass */
1045 plist.add (Properties::start, (*ci)->start - initial_capture);
1046 plist.add (Properties::length, (*ci)->frames);
1047 plist.add (Properties::length_beats, converter.from((*ci)->frames));
1048 plist.add (Properties::name, region_name);
1050 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1051 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1054 catch (failed_constructor& err) {
1055 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1056 continue; /* XXX is this OK? */
1059 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1061 i_am_the_modifier++;
1062 _playlist->add_region (region, (*ci)->start);
1063 i_am_the_modifier--;
1067 _session.add_command (new StatefulDiffCommand(_playlist));
1071 /* No data was recorded, so this capture will
1072 effectively be aborted; do the same as we
1073 do for an explicit abort.
1076 if (_write_source) {
1077 _write_source->mark_for_remove ();
1078 _write_source->drop_references ();
1079 _write_source.reset();
1085 use_new_write_source (0);
1087 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1091 capture_info.clear ();
1092 capture_start_frame = 0;
1094 no_capture_stuff_to_do:
1100 MidiDiskstream::transport_looped (framepos_t)
1102 /* Here we only keep track of the number of captured loops so monotonic
1103 event times can be delivered to the write source in process(). Trying
1104 to be clever here is a world of trouble, it is better to simply record
1105 the input in a straightforward non-destructive way. In the future when
1106 we want to implement more clever MIDI looping modes it should be done in
1107 the Source and/or entirely after the capture is finished.
1109 if (was_recording) {
1110 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1115 MidiDiskstream::finish_capture ()
1117 was_recording = false;
1119 if (capture_captured == 0) {
1123 CaptureInfo* ci = new CaptureInfo;
1125 ci->start = capture_start_frame;
1126 ci->frames = capture_captured;
1128 /* XXX theoretical race condition here. Need atomic exchange ?
1129 However, the circumstances when this is called right
1130 now (either on record-disable or transport_stopped)
1131 mean that no actual race exists. I think ...
1132 We now have a capture_info_lock, but it is only to be used
1133 to synchronize in the transport_stop and the capture info
1134 accessors, so that invalidation will not occur (both non-realtime).
1137 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1139 capture_info.push_back (ci);
1140 capture_captured = 0;
1144 MidiDiskstream::set_record_enabled (bool yn)
1146 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1150 /* yes, i know that this not proof against race conditions, but its
1151 good enough. i think.
1154 if (record_enabled() != yn) {
1156 engage_record_enable ();
1158 disengage_record_enable ();
1161 RecordEnableChanged (); /* EMIT SIGNAL */
1166 MidiDiskstream::prep_record_enable ()
1168 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1172 bool const rolling = _session.transport_speed() != 0.0f;
1174 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1176 if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1177 sp->request_input_monitoring (!(_session.config.get_auto_input() && rolling));
1184 MidiDiskstream::prep_record_disable ()
1191 MidiDiskstream::get_state ()
1193 XMLNode& node (Diskstream::get_state());
1195 LocaleGuard lg (X_("C"));
1197 if (_write_source && _session.get_record_enabled()) {
1199 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1200 XMLNode* cs_grandchild;
1202 cs_grandchild = new XMLNode (X_("file"));
1203 cs_grandchild->add_property (X_("path"), _write_source->path());
1204 cs_child->add_child_nocopy (*cs_grandchild);
1206 /* store the location where capture will start */
1210 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1211 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1213 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1216 cs_child->add_property (X_("at"), buf);
1217 node.add_child_nocopy (*cs_child);
1224 MidiDiskstream::set_state (const XMLNode& node, int version)
1226 XMLNodeList nlist = node.children();
1227 XMLNodeIterator niter;
1228 XMLNode* capture_pending_node = 0;
1229 LocaleGuard lg (X_("C"));
1231 /* prevent write sources from being created */
1233 in_set_state = true;
1235 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1236 if ((*niter)->name() == X_("CapturingSources")) {
1237 capture_pending_node = *niter;
1241 if (Diskstream::set_state (node, version)) {
1245 if (capture_pending_node) {
1246 use_pending_capture_data (*capture_pending_node);
1249 in_set_state = false;
1255 MidiDiskstream::use_new_write_source (uint32_t n)
1257 if (!_session.writable() || !recordable()) {
1261 _accumulated_capture_offset = 0;
1262 _write_source.reset();
1265 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1266 _session.create_midi_source_for_session (write_source_name ()));
1268 if (!_write_source) {
1269 throw failed_constructor();
1273 catch (failed_constructor &err) {
1274 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1275 _write_source.reset();
1282 * We want to use the name of the existing write source (the one that will be
1283 * used by the next capture) for another purpose. So change the name of the
1284 * current source, and return its current name.
1286 * Return an empty string if the change cannot be accomplished.
1289 MidiDiskstream::steal_write_source_name ()
1291 string our_old_name = _write_source->name();
1293 /* this will bump the name of the current write source to the next one
1294 * (e.g. "MIDI 1-1" gets renamed to "MIDI 1-2"), thus leaving the
1295 * current write source name (e.g. "MIDI 1-1" available). See the
1296 * comments in Session::create_midi_source_by_stealing_name() about why
1301 string new_path = _session.new_midi_source_path (name());
1303 if (_write_source->rename (new_path)) {
1310 return our_old_name;
1314 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1316 if (!_session.writable() || !recordable()) {
1320 if (_write_source && mark_write_complete) {
1321 Source::Lock lm(_write_source->mutex());
1322 _write_source->mark_streaming_write_completed (lm);
1324 use_new_write_source (0);
1328 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1333 MidiDiskstream::allocate_temporary_buffers ()
1338 MidiDiskstream::ensure_input_monitoring (bool yn)
1340 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1343 sp->ensure_input_monitoring (yn);
1348 MidiDiskstream::set_align_style_from_io ()
1350 if (_alignment_choice != Automatic) {
1354 /* XXX Not sure what, if anything we can do with MIDI
1355 as far as capture alignment etc.
1358 set_align_style (ExistingMaterial);
1363 MidiDiskstream::playback_buffer_load () const
1365 /* For MIDI it's not trivial to differentiate the following two cases:
1367 1. The playback buffer is empty because the system has run out of time to fill it.
1368 2. The playback buffer is empty because there is no more data on the playlist.
1370 If we use a simple buffer load computation, we will report that the MIDI diskstream
1371 cannot keep up when #2 happens, when in fact it can. Since MIDI data rates
1372 are so low compared to audio, just give a pretend answer here.
1379 MidiDiskstream::capture_buffer_load () const
1381 /* We don't report playback buffer load, so don't report capture load either */
1387 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1393 MidiDiskstream::flush_playback (framepos_t start, framepos_t end)
1395 _playback_buf->flush (start, end);
1396 g_atomic_int_add (&_frames_read_from_ringbuffer, end - start);
1399 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1400 * so that an event at playback_sample has time = 0
1403 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1407 Location* loc = loop_location;
1409 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1410 "%1 MDS pre-read read %8 @ %4..%5 from %2 write to %3, LOOPED ? %6-%7\n", _name,
1411 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1412 (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes));
1414 // cerr << "================\n";
1415 // _playback_buf->dump (cerr);
1416 // cerr << "----------------\n";
1418 size_t events_read = 0;
1421 framepos_t effective_start;
1423 if (playback_sample >= loc->end()) {
1424 effective_start = loc->start() + ((playback_sample - loc->end()) % loc->length());
1426 effective_start = playback_sample;
1429 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1431 if (effective_start == loc->start()) {
1432 /* We need to turn off notes that may extend
1433 beyond the loop end.
1436 _playback_buf->resolve_tracker (dst, 0);
1439 _playback_buf->skip_to (effective_start);
1441 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1442 /* end of loop is within the range we are reading, so
1443 split the read in two, and lie about the location
1446 framecnt_t first, second;
1448 first = loc->end() - effective_start;
1449 second = nframes - first;
1451 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4\n",
1452 effective_start, loc->end(), first, second));
1455 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1456 effective_start, first));
1457 events_read = _playback_buf->read (dst, effective_start, first);
1461 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1462 loc->start(), second));
1463 events_read += _playback_buf->read (dst, loc->start(), second);
1467 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1468 effective_start, nframes));
1469 events_read = _playback_buf->read (dst, effective_start, effective_start + nframes);
1472 _playback_buf->skip_to (playback_sample);
1473 events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1476 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1477 "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1478 _name, events_read, playback_sample, playback_sample + nframes,
1479 _playback_buf->read_space(), _playback_buf->write_space(),
1480 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1482 g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1486 MidiDiskstream::set_name (string const & name)
1488 if (_name == name) {
1491 Diskstream::set_name (name);
1493 /* get a new write source so that its name reflects the new diskstream name */
1494 use_new_write_source (0);
1500 MidiDiskstream::set_write_source_name (const std::string& str) {
1501 if (_write_source_name == str) {
1504 Diskstream::set_write_source_name (str);
1505 if (_write_source_name == name()) {
1508 use_new_write_source (0);
1512 boost::shared_ptr<MidiBuffer>
1513 MidiDiskstream::get_gui_feed_buffer () const
1515 boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1517 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1518 b->copy (_gui_feed_buffer);
1523 MidiDiskstream::reset_tracker ()
1525 _playback_buf->reset_tracker ();
1527 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1530 mp->reset_note_trackers ();
1535 MidiDiskstream::resolve_tracker (Evoral::EventSink<framepos_t>& buffer, framepos_t time)
1537 _playback_buf->resolve_tracker(buffer, time);
1539 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1542 mp->reset_note_trackers ();
1547 boost::shared_ptr<MidiPlaylist>
1548 MidiDiskstream::midi_playlist ()
1550 return boost::dynamic_pointer_cast<MidiPlaylist>(_playlist);