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.
29 #include <strings.h> // for ffs(3)
33 #include "pbd/error.h"
34 #include "pbd/basename.h"
35 #include <glibmm/threads.h>
36 #include "pbd/xml++.h"
37 #include "pbd/memento_command.h"
38 #include "pbd/enumwriter.h"
39 #include "pbd/stateful_diff_command.h"
40 #include "pbd/stacktrace.h"
42 #include "ardour/audioengine.h"
43 #include "ardour/butler.h"
44 #include "ardour/debug.h"
45 #include "ardour/io.h"
46 #include "ardour/midi_diskstream.h"
47 #include "ardour/midi_model.h"
48 #include "ardour/midi_playlist.h"
49 #include "ardour/midi_port.h"
50 #include "ardour/midi_region.h"
51 #include "ardour/playlist_factory.h"
52 #include "ardour/region_factory.h"
53 #include "ardour/session.h"
54 #include "ardour/session_playlists.h"
55 #include "ardour/smf_source.h"
56 #include "ardour/types.h"
57 #include "ardour/utils.h"
59 #include "midi++/types.h"
65 using namespace ARDOUR;
68 framecnt_t MidiDiskstream::midi_readahead = 4096;
70 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
71 : Diskstream(sess, name, flag)
74 , _note_mode(Sustained)
75 , _frames_written_to_ringbuffer(0)
76 , _frames_read_from_ringbuffer(0)
77 , _frames_pending_write(0)
78 , _num_captured_loops(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 , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
109 if (set_state (node, Stateful::loading_state_version)) {
110 in_set_state = false;
111 throw failed_constructor();
114 use_new_write_source (0);
116 in_set_state = false;
120 MidiDiskstream::init ()
122 /* there are no channels at this point, so these
123 two calls just get speed_buffer_size and wrap_buffer
124 size setup without duplicating their code.
127 set_block_size (_session.get_block_size());
128 allocate_temporary_buffers ();
130 const size_t size = _session.butler()->midi_diskstream_buffer_size();
131 _playback_buf = new MidiRingBuffer<framepos_t>(size);
132 _capture_buf = new MidiRingBuffer<framepos_t>(size);
134 _n_channels = ChanCount(DataType::MIDI, 1);
137 MidiDiskstream::~MidiDiskstream ()
139 Glib::Threads::Mutex::Lock lm (state_lock);
144 MidiDiskstream::non_realtime_locate (framepos_t position)
147 _write_source->set_timeline_position (position);
149 seek (position, false);
154 MidiDiskstream::non_realtime_input_change ()
157 Glib::Threads::Mutex::Lock lm (state_lock);
159 if (input_change_pending.type == IOChange::NoChange) {
163 if (input_change_pending.type & IOChange::ConfigurationChanged) {
164 uint32_t ni = _io->n_ports().n_midi();
166 if (ni != _n_channels.n_midi()) {
167 error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
170 _n_channels, input_change_pending.type)
175 _source_port.reset ();
177 _source_port = _io->midi(0);
181 if (input_change_pending.type & IOChange::ConnectionsChanged) {
182 set_capture_offset ();
183 set_align_style_from_io ();
186 input_change_pending.type = IOChange::NoChange;
188 /* implicit unlock */
191 /* unlike with audio, there is never any need to reset write sources
192 based on input configuration changes because ... a MIDI track
193 has just 1 MIDI port as input, always.
196 /* now refill channel buffers */
198 if (speed() != 1.0f || speed() != -1.0f) {
199 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
202 seek (_session.transport_frame());
205 g_atomic_int_set(const_cast<gint*>(&_frames_pending_write), 0);
206 g_atomic_int_set(const_cast<gint*>(&_num_captured_loops), 0);
210 MidiDiskstream::find_and_use_playlist (const string& name)
212 boost::shared_ptr<MidiPlaylist> playlist;
214 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
215 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
219 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't a midi playlist"), name) << endmsg;
223 return use_playlist (playlist);
227 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
229 if (boost::dynamic_pointer_cast<MidiPlaylist>(playlist)) {
230 Diskstream::use_playlist(playlist);
237 MidiDiskstream::use_new_playlist ()
240 boost::shared_ptr<MidiPlaylist> playlist;
242 if (!in_set_state && destructive()) {
247 newname = Playlist::bump_name (_playlist->name(), _session);
249 newname = Playlist::bump_name (_name, _session);
252 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
253 DataType::MIDI, _session, newname, hidden()))) != 0) {
255 return use_playlist (playlist);
263 MidiDiskstream::use_copy_playlist ()
269 if (_playlist == 0) {
270 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
275 boost::shared_ptr<MidiPlaylist> playlist;
277 newname = Playlist::bump_name (_playlist->name(), _session);
279 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
280 return use_playlist (playlist);
286 /** Overloaded from parent to die horribly
289 MidiDiskstream::set_destructive (bool yn)
295 MidiDiskstream::set_note_mode (NoteMode m)
298 midi_playlist()->set_note_mode(m);
299 if (_write_source && _write_source->model())
300 _write_source->model()->set_note_mode(m);
303 /** Get the start, end, and length of a location "atomically".
305 * Note: Locations don't get deleted, so all we care about when I say "atomic"
306 * is that we are always pointing to the same one and using start/length values
307 * obtained just once. Use this function to achieve this since location being
308 * a parameter achieves this.
311 get_location_times(const Location* location,
317 *start = location->start();
318 *end = location->end();
319 *length = *end - *start;
324 MidiDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
326 framecnt_t rec_offset = 0;
327 framecnt_t rec_nframes = 0;
328 bool nominally_recording;
329 bool re = record_enabled ();
330 bool can_record = _session.actively_recording ();
332 playback_distance = 0;
334 check_record_status (transport_frame, can_record);
336 nominally_recording = (can_record && re);
342 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
348 Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK);
354 const Location* const loop_loc = loop_location;
355 framepos_t loop_start = 0;
356 framepos_t loop_end = 0;
357 framepos_t loop_length = 0;
358 get_location_times(loop_loc, &loop_start, &loop_end, &loop_length);
360 adjust_capture_position = 0;
362 if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
363 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
365 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
367 if (rec_nframes && !was_recording) {
369 /* Loop recording, so pretend the capture started at the loop
370 start rgardless of what time it is now, so the source starts
371 at the loop start and can handle time wrapping around.
372 Otherwise, start the source right now as usual.
374 capture_captured = transport_frame - loop_start;
375 capture_start_frame = loop_start;
377 _write_source->mark_write_starting_now(
378 capture_start_frame, capture_captured, loop_length);
379 g_atomic_int_set(const_cast<gint*>(&_frames_pending_write), 0);
380 g_atomic_int_set(const_cast<gint*>(&_num_captured_loops), 0);
381 was_recording = true;
385 if (can_record && !_last_capture_sources.empty()) {
386 _last_capture_sources.clear ();
389 if (nominally_recording || rec_nframes) {
391 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
392 MidiBuffer& buf = sp->get_midi_buffer(nframes);
393 ChannelMode mode = AllChannels; // _track->get_capture_channel_mode ();
394 uint32_t mask = 0xffff; // _track->get_capture_channel_mask ();
396 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
397 Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
399 if (DEBUG::MidiIO & PBD::debug_bits) {
400 const uint8_t* __data = ev.buffer();
402 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), transport_frame, ev.size()));
403 for (size_t i=0; i < ev.size(); ++i) {
404 DEBUG_STR_APPEND(a,hex);
405 DEBUG_STR_APPEND(a,"0x");
406 DEBUG_STR_APPEND(a,(int)__data[i]);
407 DEBUG_STR_APPEND(a,' ');
409 DEBUG_STR_APPEND(a,'\n');
410 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
413 /* Write events to the capture buffer in frames from session start,
414 but ignoring looping so event time progresses monotonically.
415 The source knows the loop length so it knows exactly where the
416 event occurs in the series of recorded loops and can implement
417 any desirable behaviour. We don't want to send event with
418 transport time here since that way the source can not
419 reconstruct their actual time; future clever MIDI looping should
420 probabl be implemented in the source instead of here.
422 const framecnt_t loop_offset = _num_captured_loops * loop_length;
426 _capture_buf->write(transport_frame + loop_offset + ev.time(),
427 ev.type(), ev.size(), ev.buffer());
430 if (ev.is_channel_event()) {
431 if ((1<<ev.channel()) & mask) {
432 _capture_buf->write(transport_frame + loop_offset + ev.time(),
433 ev.type(), ev.size(), ev.buffer());
436 _capture_buf->write(transport_frame + loop_offset + ev.time(),
437 ev.type(), ev.size(), ev.buffer());
441 if (ev.is_channel_event()) {
442 ev.set_channel (ffs(mask) - 1);
444 _capture_buf->write(transport_frame + loop_offset + ev.time(),
445 ev.type(), ev.size(), ev.buffer());
449 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
451 if (buf.size() != 0) {
452 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
455 /* Copy this data into our GUI feed buffer and tell the GUI
456 that it can read it if it likes.
458 _gui_feed_buffer.clear ();
460 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
461 /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
462 the end of the world if it does.
464 _gui_feed_buffer.push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
468 DataRecorded (_write_source); /* EMIT SIGNAL */
481 /* data will be written to disk */
483 if (rec_nframes == nframes && rec_offset == 0) {
484 playback_distance = nframes;
487 adjust_capture_position = rec_nframes;
489 } else if (nominally_recording) {
491 /* XXXX do this for MIDI !!!
492 can't do actual capture yet - waiting for latency effects to finish before we start
495 playback_distance = nframes;
499 /* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
501 playback_distance = nframes;
505 if (need_disk_signal) {
506 /* copy the diskstream data to all output buffers */
508 MidiBuffer& mbuf (bufs.get_midi (0));
509 get_playback (mbuf, nframes);
511 /* leave the audio count alone */
512 ChanCount cnt (DataType::MIDI, 1);
513 cnt.set (DataType::AUDIO, bufs.count().n_audio());
514 bufs.set_count (cnt);
521 MidiDiskstream::commit (framecnt_t playback_distance)
523 bool need_butler = false;
525 if (_actual_speed < 0.0) {
526 playback_sample -= playback_distance;
528 playback_sample += playback_distance;
531 if (adjust_capture_position != 0) {
532 capture_captured += adjust_capture_position;
533 adjust_capture_position = 0;
536 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
537 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
540 cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
541 " = " << frames_written - frames_read
542 << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
545 /* frames_read will generally be less than frames_written, but
546 * immediately after an overwrite, we can end up having read some data
547 * before we've written any. we don't need to trip an assert() on this,
548 * but we do need to check so that the decision on whether or not we
549 * need the butler is done correctly.
552 if (frames_read <= frames_written) {
553 if ((frames_written - frames_read) + playback_distance < midi_readahead) {
563 MidiDiskstream::set_pending_overwrite (bool yn)
565 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
567 _pending_overwrite = yn;
568 overwrite_frame = playback_sample;
572 MidiDiskstream::overwrite_existing_buffers ()
574 /* This is safe as long as the butler thread is suspended, which it should be */
575 _playback_buf->reset ();
577 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
578 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
580 read (overwrite_frame, disk_io_chunk_frames, false);
581 file_frame = overwrite_frame; // it was adjusted by ::read()
582 overwrite_queued = false;
583 _pending_overwrite = false;
589 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
591 Glib::Threads::Mutex::Lock lm (state_lock);
594 if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
595 /* we haven't read anything since the last seek,
596 so flush all note trackers to prevent
602 _playback_buf->reset();
603 _capture_buf->reset();
604 g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
605 g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
607 playback_sample = frame;
610 if (complete_refill) {
611 while ((ret = do_refill_with_alloc ()) > 0) ;
613 ret = do_refill_with_alloc ();
620 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
622 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
623 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
624 return ((frames_written - frames_read) < distance);
628 MidiDiskstream::internal_playback_seek (framecnt_t distance)
630 first_recordable_frame += distance;
631 playback_sample += distance;
636 /** @a start is set to the new frame position (TIME) read up to */
638 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
640 framecnt_t this_read = 0;
642 framepos_t loop_end = 0;
643 framepos_t loop_start = 0;
644 framecnt_t loop_length = 0;
650 get_location_times(loc, &loop_start, &loop_end, &loop_length);
652 /* if we are looping, ensure that the first frame we read is at the correct
653 position within the loop.
656 if (loc && (start >= loop_end)) {
657 //cerr << "start adjusted from " << start;
658 start = loop_start + ((start - loop_start) % loop_length);
659 //cerr << "to " << start << endl;
661 // cerr << "start is " << start << " end " << start+dur << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
666 /* take any loop into account. we can't read past the end of the loop. */
668 if (loc && (loop_end - start <= dur)) {
669 this_read = loop_end - start;
670 // cerr << "reloop true: thisread: " << this_read << " dur: " << dur << endl;
677 if (this_read == 0) {
681 this_read = min(dur,this_read);
683 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
684 error << string_compose(
685 _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
686 id(), this_read, start) << endmsg;
690 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
694 // Swap note ons with note offs here. etc?
695 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
696 // CC values etc. hard.
700 /* if we read to the end of the loop, go back to the beginning */
702 // Synthesize LoopEvent here, because the next events
703 // written will have non-monotonic timestamps.
711 //offset += this_read;
718 MidiDiskstream::do_refill_with_alloc ()
724 MidiDiskstream::do_refill ()
727 size_t write_space = _playback_buf->write_space();
728 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
730 if (write_space == 0) {
738 /* at end: nothing to do */
739 if (file_frame == max_framepos) {
743 /* no space to write */
744 if (_playback_buf->write_space() == 0) {
748 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
749 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
750 if ((frames_written - frames_read) >= midi_readahead) {
754 framecnt_t to_read = midi_readahead - (frames_written - frames_read);
756 //cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
757 // << frames_written - frames_read << endl;
759 to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
761 if (read (file_frame, to_read, reversed)) {
768 /** Flush pending data to disk.
770 * Important note: this function will write *AT MOST* disk_io_chunk_frames
771 * of data to disk. it will never write more than that. If it writes that
772 * much and there is more than that waiting to be written, it will return 1,
773 * otherwise 0 on success or -1 on failure.
775 * If there is less than disk_io_chunk_frames to be written, no data will be
776 * written at all unless @a force_flush is true.
779 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
784 if (!_write_source) {
788 const framecnt_t total = g_atomic_int_get(const_cast<gint*>(&_frames_pending_write));
791 _capture_buf->read_space() == 0 ||
792 (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
796 /* if there are 2+ chunks of disk i/o possible for
797 this track), let the caller know so that it can arrange
798 for us to be called again, ASAP.
800 if we are forcing a flush, then if there is* any* extra
801 work, let the caller know.
803 if we are no longer recording and there is any extra work,
804 let the caller know too.
807 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
812 /* push out everything we have, right now */
813 to_write = max_framecnt;
815 to_write = disk_io_chunk_frames;
818 if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
819 if (_write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
820 error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
823 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), -to_write);
831 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
833 bool more_work = true;
835 boost::shared_ptr<MidiRegion> region;
836 MidiRegion::SourceList srcs;
837 MidiRegion::SourceList::iterator src;
838 vector<CaptureInfo*>::iterator ci;
842 /* butler is already stopped, but there may be work to do
843 to flush remaining data to disk.
846 while (more_work && !err) {
847 switch (do_flush (TransportContext, true)) {
854 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
859 /* XXX is there anything we can do if err != 0 ? */
860 Glib::Threads::Mutex::Lock lm (capture_info_lock);
862 if (capture_info.empty()) {
863 goto no_capture_stuff_to_do;
869 _write_source->mark_for_remove ();
870 _write_source->drop_references ();
871 _write_source.reset();
874 /* new source set up in "out" below */
878 framecnt_t total_capture = 0;
879 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
880 total_capture += (*ci)->frames;
883 if (_write_source->length (capture_info.front()->start) != 0) {
885 /* phew, we have data */
887 /* figure out the name for this take */
889 srcs.push_back (_write_source);
891 _write_source->set_timeline_position (capture_info.front()->start);
892 _write_source->set_captured_for (_name);
894 /* set length in beats to entire capture length */
896 BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
897 const double total_capture_beats = converter.from (total_capture);
898 _write_source->set_length_beats (total_capture_beats);
900 /* flush to disk: this step differs from the audio path,
901 where all the data is already on disk.
904 _write_source->mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, total_capture_beats);
906 /* we will want to be able to keep (over)writing the source
907 but we don't want it to be removable. this also differs
908 from the audio situation, where the source at this point
909 must be considered immutable. luckily, we can rely on
910 MidiSource::mark_streaming_write_completed() to have
911 already done the necessary work for that.
914 string whole_file_region_name;
915 whole_file_region_name = region_name_from_path (_write_source->name(), true);
917 /* Register a new region with the Session that
918 describes the entire source. Do this first
919 so that any sub-regions will obviously be
920 children of this one (later!)
926 plist.add (Properties::name, whole_file_region_name);
927 plist.add (Properties::whole_file, true);
928 plist.add (Properties::automatic, true);
929 plist.add (Properties::start, 0);
930 plist.add (Properties::length, total_capture);
931 plist.add (Properties::layer, 0);
933 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
935 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
936 region->special_set_position (capture_info.front()->start);
940 catch (failed_constructor& err) {
941 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
945 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
947 _playlist->clear_changes ();
948 _playlist->freeze ();
950 /* Session frame time of the initial capture in this pass, which is where the source starts */
951 framepos_t initial_capture = 0;
952 if (!capture_info.empty()) {
953 initial_capture = capture_info.front()->start;
956 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
960 RegionFactory::region_name (region_name, _write_source->name(), false);
962 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
967 /* start of this region is the offset between the start of its capture and the start of the whole pass */
968 plist.add (Properties::start, (*ci)->start - initial_capture);
969 plist.add (Properties::length, (*ci)->frames);
970 plist.add (Properties::length_beats, converter.from((*ci)->frames));
971 plist.add (Properties::name, region_name);
973 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
974 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
977 catch (failed_constructor& err) {
978 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
979 continue; /* XXX is this OK? */
982 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
985 _playlist->add_region (region, (*ci)->start);
990 _session.add_command (new StatefulDiffCommand(_playlist));
994 /* No data was recorded, so this capture will
995 effectively be aborted; do the same as we
996 do for an explicit abort.
1000 _write_source->mark_for_remove ();
1001 _write_source->drop_references ();
1002 _write_source.reset();
1008 use_new_write_source (0);
1010 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1014 capture_info.clear ();
1015 capture_start_frame = 0;
1017 no_capture_stuff_to_do:
1023 MidiDiskstream::transport_looped (framepos_t)
1025 /* Here we only keep track of the number of captured loops so monotonic
1026 event times can be delivered to the write source in process(). Trying
1027 to be clever here is a world of trouble, it is better to simply record
1028 the input in a straightforward non-destructive way. In the future when
1029 we want to implement more clever MIDI looping modes it should be done in
1030 the Source and/or entirely after the capture is finished.
1032 if (was_recording) {
1033 g_atomic_int_add(const_cast<gint*>(&_num_captured_loops), 1);
1038 MidiDiskstream::finish_capture ()
1040 was_recording = false;
1042 if (capture_captured == 0) {
1046 CaptureInfo* ci = new CaptureInfo;
1048 ci->start = capture_start_frame;
1049 ci->frames = capture_captured;
1051 /* XXX theoretical race condition here. Need atomic exchange ?
1052 However, the circumstances when this is called right
1053 now (either on record-disable or transport_stopped)
1054 mean that no actual race exists. I think ...
1055 We now have a capture_info_lock, but it is only to be used
1056 to synchronize in the transport_stop and the capture info
1057 accessors, so that invalidation will not occur (both non-realtime).
1060 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1062 capture_info.push_back (ci);
1063 capture_captured = 0;
1067 MidiDiskstream::set_record_enabled (bool yn)
1069 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1073 /* yes, i know that this not proof against race conditions, but its
1074 good enough. i think.
1077 if (record_enabled() != yn) {
1079 engage_record_enable ();
1081 disengage_record_enable ();
1084 RecordEnableChanged (); /* EMIT SIGNAL */
1089 MidiDiskstream::prep_record_enable ()
1091 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1095 bool const rolling = _session.transport_speed() != 0.0f;
1097 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1099 if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1100 sp->request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
1107 MidiDiskstream::prep_record_disable ()
1114 MidiDiskstream::get_state ()
1116 XMLNode& node (Diskstream::get_state());
1118 LocaleGuard lg (X_("POSIX"));
1120 if (_write_source && _session.get_record_enabled()) {
1122 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1123 XMLNode* cs_grandchild;
1125 cs_grandchild = new XMLNode (X_("file"));
1126 cs_grandchild->add_property (X_("path"), _write_source->path());
1127 cs_child->add_child_nocopy (*cs_grandchild);
1129 /* store the location where capture will start */
1133 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1134 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1136 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1139 cs_child->add_property (X_("at"), buf);
1140 node.add_child_nocopy (*cs_child);
1147 MidiDiskstream::set_state (const XMLNode& node, int version)
1149 XMLNodeList nlist = node.children();
1150 XMLNodeIterator niter;
1151 XMLNode* capture_pending_node = 0;
1152 LocaleGuard lg (X_("POSIX"));
1154 /* prevent write sources from being created */
1156 in_set_state = true;
1158 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1159 if ((*niter)->name() == X_("CapturingSources")) {
1160 capture_pending_node = *niter;
1164 if (Diskstream::set_state (node, version)) {
1168 if (capture_pending_node) {
1169 use_pending_capture_data (*capture_pending_node);
1172 in_set_state = false;
1178 MidiDiskstream::use_new_write_source (uint32_t n)
1180 if (!_session.writable() || !recordable()) {
1184 _write_source.reset();
1187 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1188 _session.create_midi_source_for_session (0, name ()));
1190 if (!_write_source) {
1191 throw failed_constructor();
1195 catch (failed_constructor &err) {
1196 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1197 _write_source.reset();
1204 list<boost::shared_ptr<Source> >
1205 MidiDiskstream::steal_write_sources()
1207 list<boost::shared_ptr<Source> > ret;
1209 /* put some data on the disk, even if its just a header for an empty file */
1210 boost::dynamic_pointer_cast<SMFSource> (_write_source)->ensure_disk_file ();
1212 /* never let it go away */
1213 _write_source->mark_nonremovable ();
1215 ret.push_back (_write_source);
1219 use_new_write_source (0);
1225 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1227 if (!_session.writable() || !recordable()) {
1231 if (_write_source && mark_write_complete) {
1232 _write_source->mark_streaming_write_completed ();
1234 use_new_write_source (0);
1238 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1243 MidiDiskstream::allocate_temporary_buffers ()
1248 MidiDiskstream::ensure_jack_monitors_input (bool yn)
1250 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1253 sp->ensure_jack_monitors_input (yn);
1258 MidiDiskstream::set_align_style_from_io ()
1260 if (_alignment_choice != Automatic) {
1264 /* XXX Not sure what, if anything we can do with MIDI
1265 as far as capture alignment etc.
1268 set_align_style (ExistingMaterial);
1273 MidiDiskstream::playback_buffer_load () const
1275 /* For MIDI it's not trivial to differentiate the following two cases:
1277 1. The playback buffer is empty because the system has run out of time to fill it.
1278 2. The playback buffer is empty because there is no more data on the playlist.
1280 If we use a simple buffer load computation, we will report that the MIDI diskstream
1281 cannot keep up when #2 happens, when in fact it can. Since MIDI data rates
1282 are so low compared to audio, just give a pretend answer here.
1289 MidiDiskstream::capture_buffer_load () const
1291 /* We don't report playback buffer load, so don't report capture load either */
1297 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1303 MidiDiskstream::flush_playback (framepos_t start, framepos_t end)
1305 _playback_buf->flush (start, end);
1306 g_atomic_int_add (&_frames_read_from_ringbuffer, end - start);
1309 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1310 * so that an event at playback_sample has time = 0
1313 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1317 Location* loc = loop_location;
1319 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1320 "%1 MDS pre-read read %8 @ %4..%5 from %2 write to %3, LOOPED ? %6-%7\n", _name,
1321 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1322 (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes));
1324 // cerr << "================\n";
1325 // _playback_buf->dump (cerr);
1326 // cerr << "----------------\n";
1328 size_t events_read = 0;
1331 framepos_t effective_start;
1333 if (playback_sample >= loc->end()) {
1334 effective_start = loc->start() + ((playback_sample - loc->end()) % loc->length());
1336 effective_start = playback_sample;
1339 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1341 if (effective_start == loc->start()) {
1342 /* We need to turn off notes that may extend
1343 beyond the loop end.
1346 _playback_buf->loop_resolve (dst, 0);
1349 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1350 /* end of loop is within the range we are reading, so
1351 split the read in two, and lie about the location
1354 framecnt_t first, second;
1356 first = loc->end() - effective_start;
1357 second = nframes - first;
1359 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4\n",
1360 effective_start, loc->end(), first, second));
1363 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1364 effective_start, first));
1365 events_read = _playback_buf->read (dst, effective_start, first);
1369 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1370 loc->start(), second));
1371 events_read += _playback_buf->read (dst, loc->start(), second);
1375 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1376 effective_start, nframes));
1377 events_read = _playback_buf->read (dst, effective_start, effective_start + nframes);
1380 events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1383 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1384 "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1385 _name, events_read, playback_sample, playback_sample + nframes,
1386 _playback_buf->read_space(), _playback_buf->write_space(),
1387 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1389 g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1393 MidiDiskstream::set_name (string const & name)
1395 Diskstream::set_name (name);
1397 /* get a new write source so that its name reflects the new diskstream name */
1398 use_new_write_source (0);
1403 boost::shared_ptr<MidiBuffer>
1404 MidiDiskstream::get_gui_feed_buffer () const
1406 boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1408 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1409 b->copy (_gui_feed_buffer);
1414 MidiDiskstream::reset_tracker ()
1416 _playback_buf->reset_tracker ();
1418 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1421 mp->clear_note_trackers ();