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/playlist_factory.h"
51 #include "ardour/region_factory.h"
52 #include "ardour/session.h"
53 #include "ardour/session_playlists.h"
54 #include "ardour/smf_source.h"
55 #include "ardour/types.h"
56 #include "ardour/utils.h"
58 #include "midi++/types.h"
64 using namespace ARDOUR;
67 framecnt_t MidiDiskstream::midi_readahead = 4096;
69 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
70 : Diskstream(sess, name, flag)
73 , _note_mode(Sustained)
74 , _frames_written_to_ringbuffer(0)
75 , _frames_read_from_ringbuffer(0)
76 , _frames_pending_write(0)
77 , _num_captured_loops(0)
78 , _accumulated_capture_offset(0)
79 , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
85 use_new_write_source (0);
90 throw failed_constructor();
94 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
95 : Diskstream(sess, node)
98 , _note_mode(Sustained)
99 , _frames_written_to_ringbuffer(0)
100 , _frames_read_from_ringbuffer(0)
101 , _frames_pending_write(0)
102 , _num_captured_loops(0)
103 , _accumulated_capture_offset(0)
104 , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
110 if (set_state (node, Stateful::loading_state_version)) {
111 in_set_state = false;
112 throw failed_constructor();
115 use_new_write_source (0);
117 in_set_state = false;
121 MidiDiskstream::init ()
123 /* there are no channels at this point, so these
124 two calls just get speed_buffer_size and wrap_buffer
125 size setup without duplicating their code.
128 set_block_size (_session.get_block_size());
129 allocate_temporary_buffers ();
131 const size_t size = _session.butler()->midi_diskstream_buffer_size();
132 _playback_buf = new MidiRingBuffer<framepos_t>(size);
133 _capture_buf = new MidiRingBuffer<framepos_t>(size);
135 _n_channels = ChanCount(DataType::MIDI, 1);
138 MidiDiskstream::~MidiDiskstream ()
140 Glib::Threads::Mutex::Lock lm (state_lock);
145 MidiDiskstream::non_realtime_locate (framepos_t position)
148 _write_source->set_timeline_position (position);
150 seek (position, false);
155 MidiDiskstream::non_realtime_input_change ()
158 Glib::Threads::Mutex::Lock lm (state_lock);
160 if (input_change_pending.type == IOChange::NoChange) {
164 if (input_change_pending.type & IOChange::ConfigurationChanged) {
165 uint32_t ni = _io->n_ports().n_midi();
167 if (ni != _n_channels.n_midi()) {
168 error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
171 _n_channels, input_change_pending.type)
176 _source_port.reset ();
178 _source_port = _io->midi(0);
182 if (input_change_pending.type & IOChange::ConnectionsChanged) {
183 set_capture_offset ();
184 set_align_style_from_io ();
187 input_change_pending.type = IOChange::NoChange;
189 /* implicit unlock */
192 /* unlike with audio, there is never any need to reset write sources
193 based on input configuration changes because ... a MIDI track
194 has just 1 MIDI port as input, always.
197 /* now refill channel buffers */
199 if (speed() != 1.0f || speed() != -1.0f) {
200 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
203 seek (_session.transport_frame());
206 g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
207 g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
211 MidiDiskstream::find_and_use_playlist (const string& name)
213 boost::shared_ptr<MidiPlaylist> playlist;
215 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
216 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
220 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't a midi playlist"), name) << endmsg;
224 return use_playlist (playlist);
228 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
230 if (boost::dynamic_pointer_cast<MidiPlaylist>(playlist)) {
231 Diskstream::use_playlist(playlist);
238 MidiDiskstream::use_new_playlist ()
241 boost::shared_ptr<MidiPlaylist> playlist;
243 if (!in_set_state && destructive()) {
248 newname = Playlist::bump_name (_playlist->name(), _session);
250 newname = Playlist::bump_name (_name, _session);
253 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
254 DataType::MIDI, _session, newname, hidden()))) != 0) {
256 return use_playlist (playlist);
264 MidiDiskstream::use_copy_playlist ()
270 if (_playlist == 0) {
271 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
276 boost::shared_ptr<MidiPlaylist> playlist;
278 newname = Playlist::bump_name (_playlist->name(), _session);
280 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
281 return use_playlist (playlist);
287 /** Overloaded from parent to die horribly
290 MidiDiskstream::set_destructive (bool yn)
296 MidiDiskstream::set_note_mode (NoteMode m)
299 midi_playlist()->set_note_mode(m);
300 if (_write_source && _write_source->model())
301 _write_source->model()->set_note_mode(m);
304 /** Get the start, end, and length of a location "atomically".
306 * Note: Locations don't get deleted, so all we care about when I say "atomic"
307 * is that we are always pointing to the same one and using start/length values
308 * obtained just once. Use this function to achieve this since location being
309 * a parameter achieves this.
312 get_location_times(const Location* location,
318 *start = location->start();
319 *end = location->end();
320 *length = *end - *start;
325 MidiDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
327 framecnt_t rec_offset = 0;
328 framecnt_t rec_nframes = 0;
329 bool nominally_recording;
330 bool re = record_enabled ();
331 bool can_record = _session.actively_recording ();
333 playback_distance = 0;
335 check_record_status (transport_frame, can_record);
337 nominally_recording = (can_record && re);
343 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
349 Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK);
355 const Location* const loop_loc = loop_location;
356 framepos_t loop_start = 0;
357 framepos_t loop_end = 0;
358 framepos_t loop_length = 0;
359 get_location_times(loop_loc, &loop_start, &loop_end, &loop_length);
361 adjust_capture_position = 0;
363 if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
364 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
366 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
367 /* For audio: not writing frames to the capture ringbuffer offsets
368 * the recording. For midi: we need to keep track of the record range
369 * and subtract the accumulated difference from the event time.
372 _accumulated_capture_offset += rec_offset;
374 _accumulated_capture_offset += nframes;
377 if (rec_nframes && !was_recording) {
379 /* Loop recording, so pretend the capture started at the loop
380 start rgardless of what time it is now, so the source starts
381 at the loop start and can handle time wrapping around.
382 Otherwise, start the source right now as usual.
384 capture_captured = transport_frame - loop_start;
385 capture_start_frame = loop_start;
387 _write_source->mark_write_starting_now(
388 capture_start_frame, capture_captured, loop_length);
389 g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
390 g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
391 was_recording = true;
395 if (can_record && !_last_capture_sources.empty()) {
396 _last_capture_sources.clear ();
399 if (nominally_recording || rec_nframes) {
401 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
402 MidiBuffer& buf = sp->get_midi_buffer(nframes);
403 ChannelMode mode = AllChannels; // _track->get_capture_channel_mode ();
404 uint32_t mask = 0xffff; // _track->get_capture_channel_mask ();
406 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
407 Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
408 if (ev.time() + rec_offset > rec_nframes) {
412 if (DEBUG::MidiIO & PBD::debug_bits) {
413 const uint8_t* __data = ev.buffer();
415 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), transport_frame, ev.size()));
416 for (size_t i=0; i < ev.size(); ++i) {
417 DEBUG_STR_APPEND(a,hex);
418 DEBUG_STR_APPEND(a,"0x");
419 DEBUG_STR_APPEND(a,(int)__data[i]);
420 DEBUG_STR_APPEND(a,' ');
422 DEBUG_STR_APPEND(a,'\n');
423 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
426 /* Write events to the capture buffer in frames from session start,
427 but ignoring looping so event time progresses monotonically.
428 The source knows the loop length so it knows exactly where the
429 event occurs in the series of recorded loops and can implement
430 any desirable behaviour. We don't want to send event with
431 transport time here since that way the source can not
432 reconstruct their actual time; future clever MIDI looping should
433 probably be implemented in the source instead of here.
435 const framecnt_t loop_offset = _num_captured_loops * loop_length;
436 const framepos_t event_time = transport_frame + loop_offset - _accumulated_capture_offset + ev.time();
437 if (event_time < 0 || event_time < first_recordable_frame) {
442 _capture_buf->write(event_time,
443 ev.type(), ev.size(), ev.buffer());
446 if (ev.is_channel_event()) {
447 if ((1<<ev.channel()) & mask) {
448 _capture_buf->write(event_time,
449 ev.type(), ev.size(), ev.buffer());
452 _capture_buf->write(event_time,
453 ev.type(), ev.size(), ev.buffer());
457 if (ev.is_channel_event()) {
458 ev.set_channel (PBD::ffs(mask) - 1);
460 _capture_buf->write(event_time,
461 ev.type(), ev.size(), ev.buffer());
465 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
467 if (buf.size() != 0) {
468 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
471 /* Copy this data into our GUI feed buffer and tell the GUI
472 that it can read it if it likes.
474 _gui_feed_buffer.clear ();
476 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
477 /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
478 the end of the world if it does.
480 _gui_feed_buffer.push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
484 DataRecorded (_write_source); /* EMIT SIGNAL */
492 _accumulated_capture_offset = 0;
498 /* data will be written to disk */
500 if (rec_nframes == nframes && rec_offset == 0) {
501 playback_distance = nframes;
504 adjust_capture_position = rec_nframes;
506 } else if (nominally_recording) {
508 /* XXXX do this for MIDI !!!
509 can't do actual capture yet - waiting for latency effects to finish before we start
512 playback_distance = nframes;
516 /* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
518 playback_distance = nframes;
522 if (need_disk_signal) {
523 /* copy the diskstream data to all output buffers */
525 MidiBuffer& mbuf (bufs.get_midi (0));
526 get_playback (mbuf, nframes);
528 /* leave the audio count alone */
529 ChanCount cnt (DataType::MIDI, 1);
530 cnt.set (DataType::AUDIO, bufs.count().n_audio());
531 bufs.set_count (cnt);
538 MidiDiskstream::calculate_playback_distance (pframes_t nframes)
540 frameoffset_t playback_distance = nframes;
542 /* XXX: should be doing varispeed stuff once it's implemented in ::process() above */
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 (_actual_speed < 0.0) {
557 playback_sample -= playback_distance;
559 playback_sample += playback_distance;
562 if (adjust_capture_position != 0) {
563 capture_captured += adjust_capture_position;
564 adjust_capture_position = 0;
567 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
568 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
571 cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
572 " = " << frames_written - frames_read
573 << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
576 /* frames_read will generally be less than frames_written, but
577 * immediately after an overwrite, we can end up having read some data
578 * before we've written any. we don't need to trip an assert() on this,
579 * but we do need to check so that the decision on whether or not we
580 * need the butler is done correctly.
583 if (frames_read <= frames_written) {
584 if ((frames_written - frames_read) + playback_distance < midi_readahead) {
594 MidiDiskstream::set_pending_overwrite (bool yn)
596 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
598 _pending_overwrite = yn;
599 overwrite_frame = playback_sample;
603 MidiDiskstream::overwrite_existing_buffers ()
605 /* This is safe as long as the butler thread is suspended, which it should be */
606 _playback_buf->reset ();
608 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
609 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
611 read (overwrite_frame, disk_io_chunk_frames, false);
612 file_frame = overwrite_frame; // it was adjusted by ::read()
613 overwrite_queued = false;
614 _pending_overwrite = false;
620 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
622 Glib::Threads::Mutex::Lock lm (state_lock);
625 if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
626 /* we haven't read anything since the last seek,
627 so flush all note trackers to prevent
633 _playback_buf->reset();
634 _capture_buf->reset();
635 g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
636 g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
638 playback_sample = frame;
641 if (complete_refill) {
642 while ((ret = do_refill_with_alloc ()) > 0) ;
644 ret = do_refill_with_alloc ();
651 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
653 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
654 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
655 return ((frames_written - frames_read) < distance);
659 MidiDiskstream::internal_playback_seek (framecnt_t distance)
661 first_recordable_frame += distance;
662 playback_sample += distance;
667 /** @a start is set to the new frame position (TIME) read up to */
669 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
671 framecnt_t this_read = 0;
673 framepos_t loop_end = 0;
674 framepos_t loop_start = 0;
675 framecnt_t loop_length = 0;
681 get_location_times(loc, &loop_start, &loop_end, &loop_length);
683 /* if we are looping, ensure that the first frame we read is at the correct
684 position within the loop.
687 if (loc && (start >= loop_end)) {
688 //cerr << "start adjusted from " << start;
689 start = loop_start + ((start - loop_start) % loop_length);
690 //cerr << "to " << start << endl;
692 // cerr << "start is " << start << " end " << start+dur << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
697 /* take any loop into account. we can't read past the end of the loop. */
699 if (loc && (loop_end - start <= dur)) {
700 this_read = loop_end - start;
701 // cerr << "reloop true: thisread: " << this_read << " dur: " << dur << endl;
708 if (this_read == 0) {
712 this_read = min(dur,this_read);
714 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
715 error << string_compose(
716 _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
717 id(), this_read, start) << endmsg;
721 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
725 // Swap note ons with note offs here. etc?
726 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
727 // CC values etc. hard.
731 /* if we read to the end of the loop, go back to the beginning */
733 // Synthesize LoopEvent here, because the next events
734 // written will have non-monotonic timestamps.
742 //offset += this_read;
749 MidiDiskstream::do_refill_with_alloc ()
755 MidiDiskstream::do_refill ()
758 size_t write_space = _playback_buf->write_space();
759 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
761 if (write_space == 0) {
769 /* at end: nothing to do */
770 if (file_frame == max_framepos) {
774 /* no space to write */
775 if (_playback_buf->write_space() == 0) {
779 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
780 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
781 if ((frames_written - frames_read) >= midi_readahead) {
785 framecnt_t to_read = midi_readahead - (frames_written - frames_read);
787 //cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
788 // << frames_written - frames_read << endl;
790 to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
792 if (read (file_frame, to_read, reversed)) {
799 /** Flush pending data to disk.
801 * Important note: this function will write *AT MOST* disk_io_chunk_frames
802 * of data to disk. it will never write more than that. If it writes that
803 * much and there is more than that waiting to be written, it will return 1,
804 * otherwise 0 on success or -1 on failure.
806 * If there is less than disk_io_chunk_frames to be written, no data will be
807 * written at all unless @a force_flush is true.
810 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
815 if (!_write_source) {
819 const framecnt_t total = g_atomic_int_get(const_cast<gint*> (&_frames_pending_write));
822 _capture_buf->read_space() == 0 ||
823 (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
827 /* if there are 2+ chunks of disk i/o possible for
828 this track), let the caller know so that it can arrange
829 for us to be called again, ASAP.
831 if we are forcing a flush, then if there is* any* extra
832 work, let the caller know.
834 if we are no longer recording and there is any extra work,
835 let the caller know too.
838 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
843 /* push out everything we have, right now */
844 to_write = max_framecnt;
846 to_write = disk_io_chunk_frames;
849 if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
850 if (_write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
851 error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
854 g_atomic_int_add(const_cast<gint*> (&_frames_pending_write), -to_write);
862 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
864 bool more_work = true;
866 boost::shared_ptr<MidiRegion> region;
867 MidiRegion::SourceList srcs;
868 MidiRegion::SourceList::iterator src;
869 vector<CaptureInfo*>::iterator ci;
873 /* butler is already stopped, but there may be work to do
874 to flush remaining data to disk.
877 while (more_work && !err) {
878 switch (do_flush (TransportContext, true)) {
885 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
890 /* XXX is there anything we can do if err != 0 ? */
891 Glib::Threads::Mutex::Lock lm (capture_info_lock);
893 if (capture_info.empty()) {
894 goto no_capture_stuff_to_do;
900 _write_source->mark_for_remove ();
901 _write_source->drop_references ();
902 _write_source.reset();
905 /* new source set up in "out" below */
909 framecnt_t total_capture = 0;
910 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
911 total_capture += (*ci)->frames;
914 if (_write_source->length (capture_info.front()->start) != 0) {
916 /* phew, we have data */
918 /* figure out the name for this take */
920 srcs.push_back (_write_source);
922 _write_source->set_timeline_position (capture_info.front()->start);
923 _write_source->set_captured_for (_name);
925 /* set length in beats to entire capture length */
927 BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
928 const double total_capture_beats = converter.from (total_capture);
929 _write_source->set_length_beats (total_capture_beats);
931 /* flush to disk: this step differs from the audio path,
932 where all the data is already on disk.
935 _write_source->mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, total_capture_beats);
937 /* we will want to be able to keep (over)writing the source
938 but we don't want it to be removable. this also differs
939 from the audio situation, where the source at this point
940 must be considered immutable. luckily, we can rely on
941 MidiSource::mark_streaming_write_completed() to have
942 already done the necessary work for that.
945 string whole_file_region_name;
946 whole_file_region_name = region_name_from_path (_write_source->name(), true);
948 /* Register a new region with the Session that
949 describes the entire source. Do this first
950 so that any sub-regions will obviously be
951 children of this one (later!)
957 plist.add (Properties::name, whole_file_region_name);
958 plist.add (Properties::whole_file, true);
959 plist.add (Properties::automatic, true);
960 plist.add (Properties::start, 0);
961 plist.add (Properties::length, total_capture);
962 plist.add (Properties::layer, 0);
964 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
966 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
967 region->special_set_position (capture_info.front()->start);
971 catch (failed_constructor& err) {
972 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
976 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
978 _playlist->clear_changes ();
979 _playlist->freeze ();
981 /* Session frame time of the initial capture in this pass, which is where the source starts */
982 framepos_t initial_capture = 0;
983 if (!capture_info.empty()) {
984 initial_capture = capture_info.front()->start;
987 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
991 RegionFactory::region_name (region_name, _write_source->name(), false);
993 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
994 _name, (*ci)->start, (*ci)->frames, region_name));
997 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1002 /* start of this region is the offset between the start of its capture and the start of the whole pass */
1003 plist.add (Properties::start, (*ci)->start - initial_capture);
1004 plist.add (Properties::length, (*ci)->frames);
1005 plist.add (Properties::length_beats, converter.from((*ci)->frames));
1006 plist.add (Properties::name, region_name);
1008 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1009 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1012 catch (failed_constructor& err) {
1013 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1014 continue; /* XXX is this OK? */
1017 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1019 i_am_the_modifier++;
1020 _playlist->add_region (region, (*ci)->start);
1021 i_am_the_modifier--;
1025 _session.add_command (new StatefulDiffCommand(_playlist));
1029 /* No data was recorded, so this capture will
1030 effectively be aborted; do the same as we
1031 do for an explicit abort.
1034 if (_write_source) {
1035 _write_source->mark_for_remove ();
1036 _write_source->drop_references ();
1037 _write_source.reset();
1043 use_new_write_source (0);
1045 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1049 capture_info.clear ();
1050 capture_start_frame = 0;
1052 no_capture_stuff_to_do:
1058 MidiDiskstream::transport_looped (framepos_t)
1060 /* Here we only keep track of the number of captured loops so monotonic
1061 event times can be delivered to the write source in process(). Trying
1062 to be clever here is a world of trouble, it is better to simply record
1063 the input in a straightforward non-destructive way. In the future when
1064 we want to implement more clever MIDI looping modes it should be done in
1065 the Source and/or entirely after the capture is finished.
1067 if (was_recording) {
1068 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1073 MidiDiskstream::finish_capture ()
1075 was_recording = false;
1077 if (capture_captured == 0) {
1081 CaptureInfo* ci = new CaptureInfo;
1083 ci->start = capture_start_frame;
1084 ci->frames = capture_captured;
1086 /* XXX theoretical race condition here. Need atomic exchange ?
1087 However, the circumstances when this is called right
1088 now (either on record-disable or transport_stopped)
1089 mean that no actual race exists. I think ...
1090 We now have a capture_info_lock, but it is only to be used
1091 to synchronize in the transport_stop and the capture info
1092 accessors, so that invalidation will not occur (both non-realtime).
1095 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1097 capture_info.push_back (ci);
1098 capture_captured = 0;
1102 MidiDiskstream::set_record_enabled (bool yn)
1104 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1108 /* yes, i know that this not proof against race conditions, but its
1109 good enough. i think.
1112 if (record_enabled() != yn) {
1114 engage_record_enable ();
1116 disengage_record_enable ();
1119 RecordEnableChanged (); /* EMIT SIGNAL */
1124 MidiDiskstream::prep_record_enable ()
1126 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1130 bool const rolling = _session.transport_speed() != 0.0f;
1132 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1134 if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1135 sp->request_input_monitoring (!(_session.config.get_auto_input() && rolling));
1142 MidiDiskstream::prep_record_disable ()
1149 MidiDiskstream::get_state ()
1151 XMLNode& node (Diskstream::get_state());
1153 LocaleGuard lg (X_("POSIX"));
1155 if (_write_source && _session.get_record_enabled()) {
1157 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1158 XMLNode* cs_grandchild;
1160 cs_grandchild = new XMLNode (X_("file"));
1161 cs_grandchild->add_property (X_("path"), _write_source->path());
1162 cs_child->add_child_nocopy (*cs_grandchild);
1164 /* store the location where capture will start */
1168 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1169 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1171 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1174 cs_child->add_property (X_("at"), buf);
1175 node.add_child_nocopy (*cs_child);
1182 MidiDiskstream::set_state (const XMLNode& node, int version)
1184 XMLNodeList nlist = node.children();
1185 XMLNodeIterator niter;
1186 XMLNode* capture_pending_node = 0;
1187 LocaleGuard lg (X_("POSIX"));
1189 /* prevent write sources from being created */
1191 in_set_state = true;
1193 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1194 if ((*niter)->name() == X_("CapturingSources")) {
1195 capture_pending_node = *niter;
1199 if (Diskstream::set_state (node, version)) {
1203 if (capture_pending_node) {
1204 use_pending_capture_data (*capture_pending_node);
1207 in_set_state = false;
1213 MidiDiskstream::use_new_write_source (uint32_t n)
1215 if (!_session.writable() || !recordable()) {
1219 _accumulated_capture_offset = 0;
1220 _write_source.reset();
1223 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1224 _session.create_midi_source_for_session (name ()));
1226 if (!_write_source) {
1227 throw failed_constructor();
1231 catch (failed_constructor &err) {
1232 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1233 _write_source.reset();
1240 * We want to use the name of the existing write source (the one that will be
1241 * used by the next capture) for another purpose. So change the name of the
1242 * current source, and return its current name.
1244 * Return an empty string if the change cannot be accomplished.
1247 MidiDiskstream::steal_write_source_name ()
1249 string our_old_name = _write_source->name();
1251 /* this will bump the name of the current write source to the next one
1252 * (e.g. "MIDI 1-1" gets renamed to "MIDI 1-2"), thus leaving the
1253 * current write source name (e.g. "MIDI 1-1" available). See the
1254 * comments in Session::create_midi_source_by_stealing_name() about why
1259 string new_name = _session.new_midi_source_name (name());
1261 if (_write_source->rename (new_name)) {
1268 return our_old_name;
1272 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1274 if (!_session.writable() || !recordable()) {
1278 if (_write_source && mark_write_complete) {
1279 _write_source->mark_streaming_write_completed ();
1281 use_new_write_source (0);
1285 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1290 MidiDiskstream::allocate_temporary_buffers ()
1295 MidiDiskstream::ensure_input_monitoring (bool yn)
1297 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1300 sp->ensure_input_monitoring (yn);
1305 MidiDiskstream::set_align_style_from_io ()
1307 if (_alignment_choice != Automatic) {
1311 /* XXX Not sure what, if anything we can do with MIDI
1312 as far as capture alignment etc.
1315 set_align_style (ExistingMaterial);
1320 MidiDiskstream::playback_buffer_load () const
1322 /* For MIDI it's not trivial to differentiate the following two cases:
1324 1. The playback buffer is empty because the system has run out of time to fill it.
1325 2. The playback buffer is empty because there is no more data on the playlist.
1327 If we use a simple buffer load computation, we will report that the MIDI diskstream
1328 cannot keep up when #2 happens, when in fact it can. Since MIDI data rates
1329 are so low compared to audio, just give a pretend answer here.
1336 MidiDiskstream::capture_buffer_load () const
1338 /* We don't report playback buffer load, so don't report capture load either */
1344 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1350 MidiDiskstream::flush_playback (framepos_t start, framepos_t end)
1352 _playback_buf->flush (start, end);
1353 g_atomic_int_add (&_frames_read_from_ringbuffer, end - start);
1356 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1357 * so that an event at playback_sample has time = 0
1360 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1364 Location* loc = loop_location;
1366 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1367 "%1 MDS pre-read read %8 @ %4..%5 from %2 write to %3, LOOPED ? %6-%7\n", _name,
1368 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1369 (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes));
1371 // cerr << "================\n";
1372 // _playback_buf->dump (cerr);
1373 // cerr << "----------------\n";
1375 size_t events_read = 0;
1378 framepos_t effective_start;
1380 if (playback_sample >= loc->end()) {
1381 effective_start = loc->start() + ((playback_sample - loc->end()) % loc->length());
1383 effective_start = playback_sample;
1386 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1388 if (effective_start == loc->start()) {
1389 /* We need to turn off notes that may extend
1390 beyond the loop end.
1393 _playback_buf->loop_resolve (dst, 0);
1396 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1397 /* end of loop is within the range we are reading, so
1398 split the read in two, and lie about the location
1401 framecnt_t first, second;
1403 first = loc->end() - effective_start;
1404 second = nframes - first;
1406 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4\n",
1407 effective_start, loc->end(), first, second));
1410 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1411 effective_start, first));
1412 events_read = _playback_buf->read (dst, effective_start, first);
1416 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1417 loc->start(), second));
1418 events_read += _playback_buf->read (dst, loc->start(), second);
1422 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1423 effective_start, nframes));
1424 events_read = _playback_buf->read (dst, effective_start, effective_start + nframes);
1427 events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1430 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1431 "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1432 _name, events_read, playback_sample, playback_sample + nframes,
1433 _playback_buf->read_space(), _playback_buf->write_space(),
1434 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1436 g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1440 MidiDiskstream::set_name (string const & name)
1442 Diskstream::set_name (name);
1444 /* get a new write source so that its name reflects the new diskstream name */
1445 use_new_write_source (0);
1450 boost::shared_ptr<MidiBuffer>
1451 MidiDiskstream::get_gui_feed_buffer () const
1453 boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1455 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1456 b->copy (_gui_feed_buffer);
1461 MidiDiskstream::reset_tracker ()
1463 _playback_buf->reset_tracker ();
1465 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1468 mp->clear_note_trackers ();