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::calculate_playback_distance (pframes_t nframes)
523 frameoffset_t playback_distance = nframes;
525 /* XXX: should be doing varispeed stuff once it's implemented in ::process() above */
527 if (_actual_speed < 0.0) {
528 return -playback_distance;
530 return playback_distance;
535 MidiDiskstream::commit (framecnt_t playback_distance)
537 bool need_butler = false;
539 if (_actual_speed < 0.0) {
540 playback_sample -= playback_distance;
542 playback_sample += playback_distance;
545 if (adjust_capture_position != 0) {
546 capture_captured += adjust_capture_position;
547 adjust_capture_position = 0;
550 uint32_t frames_read = g_atomic_int_get(const_cast<gint*>(&_frames_read_from_ringbuffer));
551 uint32_t frames_written = g_atomic_int_get(const_cast<gint*>(&_frames_written_to_ringbuffer));
554 cerr << name() << " MDS written: " << frames_written << " - read: " << frames_read <<
555 " = " << frames_written - frames_read
556 << " + " << playback_distance << " < " << midi_readahead << " = " << need_butler << ")" << endl;
559 /* frames_read will generally be less than frames_written, but
560 * immediately after an overwrite, we can end up having read some data
561 * before we've written any. we don't need to trip an assert() on this,
562 * but we do need to check so that the decision on whether or not we
563 * need the butler is done correctly.
566 if (frames_read <= frames_written) {
567 if ((frames_written - frames_read) + playback_distance < midi_readahead) {
577 MidiDiskstream::set_pending_overwrite (bool yn)
579 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
581 _pending_overwrite = yn;
582 overwrite_frame = playback_sample;
586 MidiDiskstream::overwrite_existing_buffers ()
588 /* This is safe as long as the butler thread is suspended, which it should be */
589 _playback_buf->reset ();
591 g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
592 g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
594 read (overwrite_frame, disk_io_chunk_frames, false);
595 file_frame = overwrite_frame; // it was adjusted by ::read()
596 overwrite_queued = false;
597 _pending_overwrite = false;
603 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
605 Glib::Threads::Mutex::Lock lm (state_lock);
608 if (g_atomic_int_get (&_frames_read_from_ringbuffer) == 0) {
609 /* we haven't read anything since the last seek,
610 so flush all note trackers to prevent
616 _playback_buf->reset();
617 _capture_buf->reset();
618 g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
619 g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
621 playback_sample = frame;
624 if (complete_refill) {
625 while ((ret = do_refill_with_alloc ()) > 0) ;
627 ret = do_refill_with_alloc ();
634 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
636 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
637 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
638 return ((frames_written - frames_read) < distance);
642 MidiDiskstream::internal_playback_seek (framecnt_t distance)
644 first_recordable_frame += distance;
645 playback_sample += distance;
650 /** @a start is set to the new frame position (TIME) read up to */
652 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
654 framecnt_t this_read = 0;
656 framepos_t loop_end = 0;
657 framepos_t loop_start = 0;
658 framecnt_t loop_length = 0;
664 get_location_times(loc, &loop_start, &loop_end, &loop_length);
666 /* if we are looping, ensure that the first frame we read is at the correct
667 position within the loop.
670 if (loc && (start >= loop_end)) {
671 //cerr << "start adjusted from " << start;
672 start = loop_start + ((start - loop_start) % loop_length);
673 //cerr << "to " << start << endl;
675 // cerr << "start is " << start << " end " << start+dur << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
680 /* take any loop into account. we can't read past the end of the loop. */
682 if (loc && (loop_end - start <= dur)) {
683 this_read = loop_end - start;
684 // cerr << "reloop true: thisread: " << this_read << " dur: " << dur << endl;
691 if (this_read == 0) {
695 this_read = min(dur,this_read);
697 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
698 error << string_compose(
699 _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
700 id(), this_read, start) << endmsg;
704 g_atomic_int_add (&_frames_written_to_ringbuffer, this_read);
708 // Swap note ons with note offs here. etc?
709 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
710 // CC values etc. hard.
714 /* if we read to the end of the loop, go back to the beginning */
716 // Synthesize LoopEvent here, because the next events
717 // written will have non-monotonic timestamps.
725 //offset += this_read;
732 MidiDiskstream::do_refill_with_alloc ()
738 MidiDiskstream::do_refill ()
741 size_t write_space = _playback_buf->write_space();
742 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
744 if (write_space == 0) {
752 /* at end: nothing to do */
753 if (file_frame == max_framepos) {
757 /* no space to write */
758 if (_playback_buf->write_space() == 0) {
762 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
763 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
764 if ((frames_written - frames_read) >= midi_readahead) {
768 framecnt_t to_read = midi_readahead - (frames_written - frames_read);
770 //cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
771 // << frames_written - frames_read << endl;
773 to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
775 if (read (file_frame, to_read, reversed)) {
782 /** Flush pending data to disk.
784 * Important note: this function will write *AT MOST* disk_io_chunk_frames
785 * of data to disk. it will never write more than that. If it writes that
786 * much and there is more than that waiting to be written, it will return 1,
787 * otherwise 0 on success or -1 on failure.
789 * If there is less than disk_io_chunk_frames to be written, no data will be
790 * written at all unless @a force_flush is true.
793 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
798 if (!_write_source) {
802 const framecnt_t total = g_atomic_int_get(const_cast<gint*> (&_frames_pending_write));
805 _capture_buf->read_space() == 0 ||
806 (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
810 /* if there are 2+ chunks of disk i/o possible for
811 this track, let the caller know so that it can arrange
812 for us to be called again, ASAP.
814 if we are forcing a flush, then if there is* any* extra
815 work, let the caller know.
817 if we are no longer recording and there is any extra work,
818 let the caller know too.
821 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
826 /* push out everything we have, right now */
827 to_write = max_framecnt;
829 to_write = disk_io_chunk_frames;
832 if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
833 if (_write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
834 error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
837 g_atomic_int_add(const_cast<gint*> (&_frames_pending_write), -to_write);
845 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
847 bool more_work = true;
849 boost::shared_ptr<MidiRegion> region;
850 MidiRegion::SourceList srcs;
851 MidiRegion::SourceList::iterator src;
852 vector<CaptureInfo*>::iterator ci;
856 /* butler is already stopped, but there may be work to do
857 to flush remaining data to disk.
860 while (more_work && !err) {
861 switch (do_flush (TransportContext, true)) {
868 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
873 /* XXX is there anything we can do if err != 0 ? */
874 Glib::Threads::Mutex::Lock lm (capture_info_lock);
876 if (capture_info.empty()) {
877 goto no_capture_stuff_to_do;
883 _write_source->mark_for_remove ();
884 _write_source->drop_references ();
885 _write_source.reset();
888 /* new source set up in "out" below */
892 framecnt_t total_capture = 0;
893 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
894 total_capture += (*ci)->frames;
897 if (_write_source->length (capture_info.front()->start) != 0) {
899 /* phew, we have data */
901 /* figure out the name for this take */
903 srcs.push_back (_write_source);
905 _write_source->set_timeline_position (capture_info.front()->start);
906 _write_source->set_captured_for (_name);
908 /* set length in beats to entire capture length */
910 BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
911 const double total_capture_beats = converter.from (total_capture);
912 _write_source->set_length_beats (total_capture_beats);
914 /* flush to disk: this step differs from the audio path,
915 where all the data is already on disk.
918 _write_source->mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, total_capture_beats);
920 /* we will want to be able to keep (over)writing the source
921 but we don't want it to be removable. this also differs
922 from the audio situation, where the source at this point
923 must be considered immutable. luckily, we can rely on
924 MidiSource::mark_streaming_write_completed() to have
925 already done the necessary work for that.
928 string whole_file_region_name;
929 whole_file_region_name = region_name_from_path (_write_source->name(), true);
931 /* Register a new region with the Session that
932 describes the entire source. Do this first
933 so that any sub-regions will obviously be
934 children of this one (later!)
940 plist.add (Properties::name, whole_file_region_name);
941 plist.add (Properties::whole_file, true);
942 plist.add (Properties::automatic, true);
943 plist.add (Properties::start, 0);
944 plist.add (Properties::length, total_capture);
945 plist.add (Properties::layer, 0);
947 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
949 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
950 region->special_set_position (capture_info.front()->start);
954 catch (failed_constructor& err) {
955 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
959 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
961 _playlist->clear_changes ();
962 _playlist->freeze ();
964 /* Session frame time of the initial capture in this pass, which is where the source starts */
965 framepos_t initial_capture = 0;
966 if (!capture_info.empty()) {
967 initial_capture = capture_info.front()->start;
970 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
974 RegionFactory::region_name (region_name, _write_source->name(), false);
976 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
981 /* start of this region is the offset between the start of its capture and the start of the whole pass */
982 plist.add (Properties::start, (*ci)->start - initial_capture);
983 plist.add (Properties::length, (*ci)->frames);
984 plist.add (Properties::length_beats, converter.from((*ci)->frames));
985 plist.add (Properties::name, region_name);
987 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
988 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
991 catch (failed_constructor& err) {
992 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
993 continue; /* XXX is this OK? */
996 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
999 _playlist->add_region (region, (*ci)->start);
1000 i_am_the_modifier--;
1004 _session.add_command (new StatefulDiffCommand(_playlist));
1008 /* No data was recorded, so this capture will
1009 effectively be aborted; do the same as we
1010 do for an explicit abort.
1013 if (_write_source) {
1014 _write_source->mark_for_remove ();
1015 _write_source->drop_references ();
1016 _write_source.reset();
1022 use_new_write_source (0);
1024 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1028 capture_info.clear ();
1029 capture_start_frame = 0;
1031 no_capture_stuff_to_do:
1037 MidiDiskstream::transport_looped (framepos_t)
1039 /* Here we only keep track of the number of captured loops so monotonic
1040 event times can be delivered to the write source in process(). Trying
1041 to be clever here is a world of trouble, it is better to simply record
1042 the input in a straightforward non-destructive way. In the future when
1043 we want to implement more clever MIDI looping modes it should be done in
1044 the Source and/or entirely after the capture is finished.
1046 if (was_recording) {
1047 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1052 MidiDiskstream::finish_capture ()
1054 was_recording = false;
1056 if (capture_captured == 0) {
1060 CaptureInfo* ci = new CaptureInfo;
1062 ci->start = capture_start_frame;
1063 ci->frames = capture_captured;
1065 /* XXX theoretical race condition here. Need atomic exchange ?
1066 However, the circumstances when this is called right
1067 now (either on record-disable or transport_stopped)
1068 mean that no actual race exists. I think ...
1069 We now have a capture_info_lock, but it is only to be used
1070 to synchronize in the transport_stop and the capture info
1071 accessors, so that invalidation will not occur (both non-realtime).
1074 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1076 capture_info.push_back (ci);
1077 capture_captured = 0;
1081 MidiDiskstream::set_record_enabled (bool yn)
1083 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1087 /* yes, i know that this not proof against race conditions, but its
1088 good enough. i think.
1091 if (record_enabled() != yn) {
1093 engage_record_enable ();
1095 disengage_record_enable ();
1098 RecordEnableChanged (); /* EMIT SIGNAL */
1103 MidiDiskstream::prep_record_enable ()
1105 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_midi() == 0) {
1109 bool const rolling = _session.transport_speed() != 0.0f;
1111 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1113 if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1114 sp->request_input_monitoring (!(_session.config.get_auto_input() && rolling));
1121 MidiDiskstream::prep_record_disable ()
1128 MidiDiskstream::get_state ()
1130 XMLNode& node (Diskstream::get_state());
1132 LocaleGuard lg (X_("POSIX"));
1134 if (_write_source && _session.get_record_enabled()) {
1136 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1137 XMLNode* cs_grandchild;
1139 cs_grandchild = new XMLNode (X_("file"));
1140 cs_grandchild->add_property (X_("path"), _write_source->path());
1141 cs_child->add_child_nocopy (*cs_grandchild);
1143 /* store the location where capture will start */
1147 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1148 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1150 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1153 cs_child->add_property (X_("at"), buf);
1154 node.add_child_nocopy (*cs_child);
1161 MidiDiskstream::set_state (const XMLNode& node, int version)
1163 XMLNodeList nlist = node.children();
1164 XMLNodeIterator niter;
1165 XMLNode* capture_pending_node = 0;
1166 LocaleGuard lg (X_("POSIX"));
1168 /* prevent write sources from being created */
1170 in_set_state = true;
1172 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1173 if ((*niter)->name() == X_("CapturingSources")) {
1174 capture_pending_node = *niter;
1178 if (Diskstream::set_state (node, version)) {
1182 if (capture_pending_node) {
1183 use_pending_capture_data (*capture_pending_node);
1186 in_set_state = false;
1192 MidiDiskstream::use_new_write_source (uint32_t n)
1194 if (!_session.writable() || !recordable()) {
1198 _write_source.reset();
1201 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1202 _session.create_midi_source_for_session (0, name ()));
1204 if (!_write_source) {
1205 throw failed_constructor();
1209 catch (failed_constructor &err) {
1210 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1211 _write_source.reset();
1218 list<boost::shared_ptr<Source> >
1219 MidiDiskstream::steal_write_sources()
1221 list<boost::shared_ptr<Source> > ret;
1223 /* put some data on the disk, even if its just a header for an empty file */
1224 boost::dynamic_pointer_cast<SMFSource> (_write_source)->ensure_disk_file ();
1226 /* never let it go away */
1227 _write_source->mark_nonremovable ();
1229 ret.push_back (_write_source);
1233 use_new_write_source (0);
1239 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1241 if (!_session.writable() || !recordable()) {
1245 if (_write_source && mark_write_complete) {
1246 _write_source->mark_streaming_write_completed ();
1248 use_new_write_source (0);
1252 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1257 MidiDiskstream::allocate_temporary_buffers ()
1262 MidiDiskstream::ensure_input_monitoring (bool yn)
1264 boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1267 sp->ensure_input_monitoring (yn);
1272 MidiDiskstream::set_align_style_from_io ()
1274 if (_alignment_choice != Automatic) {
1278 /* XXX Not sure what, if anything we can do with MIDI
1279 as far as capture alignment etc.
1282 set_align_style (ExistingMaterial);
1287 MidiDiskstream::playback_buffer_load () const
1289 /* For MIDI it's not trivial to differentiate the following two cases:
1291 1. The playback buffer is empty because the system has run out of time to fill it.
1292 2. The playback buffer is empty because there is no more data on the playlist.
1294 If we use a simple buffer load computation, we will report that the MIDI diskstream
1295 cannot keep up when #2 happens, when in fact it can. Since MIDI data rates
1296 are so low compared to audio, just give a pretend answer here.
1303 MidiDiskstream::capture_buffer_load () const
1305 /* We don't report playback buffer load, so don't report capture load either */
1311 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1317 MidiDiskstream::flush_playback (framepos_t start, framepos_t end)
1319 _playback_buf->flush (start, end);
1320 g_atomic_int_add (&_frames_read_from_ringbuffer, end - start);
1323 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1324 * so that an event at playback_sample has time = 0
1327 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1331 Location* loc = loop_location;
1333 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1334 "%1 MDS pre-read read %8 @ %4..%5 from %2 write to %3, LOOPED ? %6-%7\n", _name,
1335 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
1336 (loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes));
1338 // cerr << "================\n";
1339 // _playback_buf->dump (cerr);
1340 // cerr << "----------------\n";
1342 size_t events_read = 0;
1345 framepos_t effective_start;
1347 if (playback_sample >= loc->end()) {
1348 effective_start = loc->start() + ((playback_sample - loc->end()) % loc->length());
1350 effective_start = playback_sample;
1353 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("looped, effective start adjusted to %1\n", effective_start));
1355 if (effective_start == loc->start()) {
1356 /* We need to turn off notes that may extend
1357 beyond the loop end.
1360 _playback_buf->loop_resolve (dst, 0);
1363 if (loc->end() >= effective_start && loc->end() < effective_start + nframes) {
1364 /* end of loop is within the range we are reading, so
1365 split the read in two, and lie about the location
1368 framecnt_t first, second;
1370 first = loc->end() - effective_start;
1371 second = nframes - first;
1373 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read for eff %1 end %2: %3 and %4\n",
1374 effective_start, loc->end(), first, second));
1377 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
1378 effective_start, first));
1379 events_read = _playback_buf->read (dst, effective_start, first);
1383 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
1384 loc->start(), second));
1385 events_read += _playback_buf->read (dst, loc->start(), second);
1389 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
1390 effective_start, nframes));
1391 events_read = _playback_buf->read (dst, effective_start, effective_start + nframes);
1394 events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1397 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1398 "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1399 _name, events_read, playback_sample, playback_sample + nframes,
1400 _playback_buf->read_space(), _playback_buf->write_space(),
1401 _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1403 g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1407 MidiDiskstream::set_name (string const & name)
1409 Diskstream::set_name (name);
1411 /* get a new write source so that its name reflects the new diskstream name */
1412 use_new_write_source (0);
1417 boost::shared_ptr<MidiBuffer>
1418 MidiDiskstream::get_gui_feed_buffer () const
1420 boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1422 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
1423 b->copy (_gui_feed_buffer);
1428 MidiDiskstream::reset_tracker ()
1430 _playback_buf->reset_tracker ();
1432 boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1435 mp->clear_note_trackers ();