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.
32 #include "pbd/error.h"
33 #include "pbd/basename.h"
34 #include <glibmm/thread.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/ardour.h"
42 #include "ardour/audioengine.h"
43 #include "ardour/butler.h"
44 #include "ardour/configuration.h"
45 #include "ardour/cycle_timer.h"
46 #include "ardour/debug.h"
47 #include "ardour/io.h"
48 #include "ardour/midi_diskstream.h"
49 #include "ardour/midi_playlist.h"
50 #include "ardour/midi_port.h"
51 #include "ardour/midi_region.h"
52 #include "ardour/playlist_factory.h"
53 #include "ardour/region_factory.h"
54 #include "ardour/send.h"
55 #include "ardour/session.h"
56 #include "ardour/smf_source.h"
57 #include "ardour/utils.h"
58 #include "ardour/session_playlists.h"
59 #include "ardour/route.h"
61 #include "midi++/types.h"
67 using namespace ARDOUR;
70 nframes_t MidiDiskstream::midi_readahead = 4096;
72 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
73 : Diskstream(sess, name, flag)
77 , _last_flush_frame(0)
78 , _note_mode(Sustained)
79 , _frames_written_to_ringbuffer(0)
80 , _frames_read_from_ringbuffer(0)
82 /* prevent any write sources from being created */
88 use_new_write_source (0);
92 assert(!destructive());
95 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
96 : Diskstream(sess, node)
100 , _last_flush_frame(0)
101 , _note_mode(Sustained)
102 , _frames_written_to_ringbuffer(0)
103 , _frames_read_from_ringbuffer(0)
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<nframes_t>(size);
132 _capture_buf = new MidiRingBuffer<nframes_t>(size);
134 _n_channels = ChanCount(DataType::MIDI, 1);
136 assert(recordable());
139 MidiDiskstream::~MidiDiskstream ()
141 Glib::Mutex::Lock lm (state_lock);
146 MidiDiskstream::non_realtime_locate (framepos_t position)
149 _write_source->set_timeline_position (position);
151 seek(position, false);
156 MidiDiskstream::non_realtime_input_change ()
159 Glib::Mutex::Lock lm (state_lock);
161 if (input_change_pending.type == IOChange::NoChange) {
165 if (input_change_pending.type & IOChange::ConfigurationChanged) {
166 if (_io->n_ports().n_midi() != _n_channels.n_midi()) {
167 error << "Can not feed IO " << _io->n_ports()
168 << " with diskstream " << _n_channels << endl;
172 get_input_sources ();
173 set_capture_offset ();
175 if (first_input_change) {
176 set_align_style (_persistent_alignment_style);
177 first_input_change = false;
179 set_align_style_from_io ();
182 input_change_pending.type = IOChange::NoChange;
184 /* implicit unlock */
187 /* unlike with audio, there is never any need to reset write sources
188 based on input configuration changes because ... a MIDI track
189 has just 1 MIDI port as input, always.
192 /* now refill channel buffers */
194 if (speed() != 1.0f || speed() != -1.0f) {
195 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
198 seek (_session.transport_frame());
201 _last_flush_frame = _session.transport_frame();
205 MidiDiskstream::get_input_sources ()
207 uint32_t ni = _io->n_ports().n_midi();
213 // This is all we do for now at least
216 _source_port = _io->midi(0);
222 MidiDiskstream::find_and_use_playlist (const string& name)
224 boost::shared_ptr<MidiPlaylist> playlist;
226 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
227 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
231 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
235 return use_playlist (playlist);
239 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
241 assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
243 Diskstream::use_playlist(playlist);
249 MidiDiskstream::use_new_playlist ()
252 boost::shared_ptr<MidiPlaylist> playlist;
254 if (!in_set_state && destructive()) {
259 newname = Playlist::bump_name (_playlist->name(), _session);
261 newname = Playlist::bump_name (_name, _session);
264 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
265 DataType::MIDI, _session, newname, hidden()))) != 0) {
267 playlist->set_orig_diskstream_id (id());
268 return use_playlist (playlist);
276 MidiDiskstream::use_copy_playlist ()
278 assert(midi_playlist());
284 if (_playlist == 0) {
285 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
290 boost::shared_ptr<MidiPlaylist> playlist;
292 newname = Playlist::bump_name (_playlist->name(), _session);
294 if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
295 playlist->set_orig_diskstream_id (id());
296 return use_playlist (playlist);
302 /** Overloaded from parent to die horribly
305 MidiDiskstream::set_destructive (bool yn)
307 assert( ! destructive());
313 MidiDiskstream::set_note_mode (NoteMode m)
316 midi_playlist()->set_note_mode(m);
317 if (_write_source && _write_source->model())
318 _write_source->model()->set_note_mode(m);
323 trace_midi (ostream& o, MIDI::byte *msg, size_t len)
325 using namespace MIDI;
327 const char trace_prefix = ':';
329 type = (eventType) (msg[0]&0xF0);
336 << " NoteOff NoteNum "
347 << " NoteOn NoteNum "
363 case MIDI::controller:
378 << " Program Change ProgNum "
387 << " Channel Pressure "
392 case MIDI::pitchbend:
397 << ((msg[2]<<7)|msg[1])
436 << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
442 << "System Exclusive (" << len << ") = [ " << hex;
443 for (unsigned int i = 0; i < len; ++i) {
444 o << (int) msg[i] << ' ';
446 o << dec << ']' << endl;
452 o << trace_prefix << "Song" << endl;
456 o << trace_prefix << "Tune" << endl;
460 o << trace_prefix << "End-of-System Exclusive" << endl;
464 o << trace_prefix << "Timing" << endl;
468 o << trace_prefix << "Start" << endl;
472 o << trace_prefix << "Stop" << endl;
476 o << trace_prefix << "Continue" << endl;
480 o << trace_prefix << "Active Sense" << endl;
484 o << trace_prefix << "Unrecognized MIDI message" << endl;
491 MidiDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
494 nframes_t rec_offset = 0;
495 nframes_t rec_nframes = 0;
496 bool nominally_recording;
497 bool re = record_enabled ();
499 playback_distance = 0;
501 check_record_status (transport_frame, can_record);
503 nominally_recording = (can_record && re);
509 Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
515 adjust_capture_position = 0;
517 if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
518 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
520 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
522 if (rec_nframes && !was_recording) {
523 capture_captured = 0;
524 was_recording = true;
529 if (can_record && !_last_capture_sources.empty()) {
530 _last_capture_sources.clear ();
533 if (nominally_recording || rec_nframes) {
535 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
536 MidiBuffer& buf = _source_port->get_midi_buffer(nframes);
537 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
538 const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
540 _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
543 if (buf.size() != 0) {
544 /* Make a copy of this data and emit it for the GUI to see */
545 boost::shared_ptr<MidiBuffer> copy (new MidiBuffer (buf.capacity ()));
546 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
547 copy->push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
550 DataRecorded (copy, _write_source); /* EMIT SIGNAL */
556 finish_capture (rec_monitors_input);
563 /* data will be written to disk */
565 if (rec_nframes == nframes && rec_offset == 0) {
566 playback_distance = nframes;
569 adjust_capture_position = rec_nframes;
571 } else if (nominally_recording) {
573 /* XXXX do this for MIDI !!!
574 can't do actual capture yet - waiting for latency effects to finish before we start
577 playback_distance = nframes;
583 if (commit (nframes)) {
591 MidiDiskstream::commit (nframes_t nframes)
593 bool need_butler = false;
595 if (_actual_speed < 0.0) {
596 playback_sample -= playback_distance;
598 playback_sample += playback_distance;
601 if (adjust_capture_position != 0) {
602 capture_captured += adjust_capture_position;
603 adjust_capture_position = 0;
606 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
607 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
608 if ((frames_written - frames_read) + nframes < midi_readahead) {
612 /*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
613 " = " << frames_written - frames_read
614 << " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
620 MidiDiskstream::set_pending_overwrite (bool yn)
622 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
624 _pending_overwrite = yn;
626 overwrite_frame = playback_sample;
630 MidiDiskstream::overwrite_existing_buffers ()
632 read (overwrite_frame, disk_io_chunk_frames, false);
633 overwrite_queued = false;
634 _pending_overwrite = false;
640 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
642 Glib::Mutex::Lock lm (state_lock);
645 _playback_buf->reset();
646 _capture_buf->reset();
647 g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
648 g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
650 playback_sample = frame;
653 if (complete_refill) {
654 while ((ret = do_refill_with_alloc ()) > 0) ;
656 ret = do_refill_with_alloc ();
663 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
665 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
666 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
667 return ((frames_written - frames_read) < distance);
671 MidiDiskstream::internal_playback_seek (framecnt_t distance)
673 first_recordable_frame += distance;
674 playback_sample += distance;
679 /** @a start is set to the new frame position (TIME) read up to */
681 MidiDiskstream::read (framepos_t& start, nframes_t dur, bool reversed)
683 nframes_t this_read = 0;
685 framepos_t loop_end = 0;
686 framepos_t loop_start = 0;
691 framecnt_t loop_length = 0;
693 /* Make the use of a Location atomic for this read operation.
695 Note: Locations don't get deleted, so all we care about
696 when I say "atomic" is that we are always pointing to
697 the same one and using a start/length values obtained
701 if ((loc = loop_location) != 0) {
702 loop_start = loc->start();
703 loop_end = loc->end();
704 loop_length = loop_end - loop_start;
707 /* if we are looping, ensure that the first frame we read is at the correct
708 position within the loop.
711 if (loc && (start >= loop_end)) {
712 //cerr << "start adjusted from " << start;
713 start = loop_start + ((start - loop_start) % loop_length);
714 //cerr << "to " << start << endl;
716 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
721 /* take any loop into account. we can't read past the end of the loop. */
723 if (loc && (loop_end - start < dur)) {
724 this_read = loop_end - start;
725 //cerr << "reloop true: thisread: " << this_read << " dur: " << dur << endl;
732 if (this_read == 0) {
736 this_read = min(dur,this_read);
738 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
739 error << string_compose(
740 _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
741 _id, this_read, start) << endmsg;
745 g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
747 _read_data_count = _playlist->read_data_count();
751 // Swap note ons with note offs here. etc?
752 // Fully reversing MIDI requires look-ahead (well, behind) to find previous
753 // CC values etc. hard.
757 /* if we read to the end of the loop, go back to the beginning */
760 // Synthesize LoopEvent here, because the next events
761 // written will have non-monotonic timestamps.
762 _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
770 //offset += this_read;
777 MidiDiskstream::do_refill_with_alloc ()
783 MidiDiskstream::do_refill ()
786 size_t write_space = _playback_buf->write_space();
787 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
789 if (write_space == 0) {
797 /* at end: nothing to do */
798 if (file_frame == max_framepos) {
802 // At this point we...
803 assert(_playback_buf->write_space() > 0); // ... have something to write to, and
804 assert(file_frame <= max_framepos); // ... something to write
806 // now calculate how much time is in the ringbuffer.
807 // and lets write as much as we need to get this to be midi_readahead;
808 uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
809 uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
810 if ((frames_written - frames_read) >= midi_readahead) {
811 //cout << "MDS Nothing to do. all fine" << endl;
815 nframes_t to_read = midi_readahead - (frames_written - frames_read);
817 //cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
818 // << frames_written - frames_read << endl;
820 to_read = (nframes_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
822 if (read (file_frame, to_read, reversed)) {
829 /** Flush pending data to disk.
831 * Important note: this function will write *AT MOST* disk_io_chunk_frames
832 * of data to disk. it will never write more than that. If it writes that
833 * much and there is more than that waiting to be written, it will return 1,
834 * otherwise 0 on success or -1 on failure.
836 * If there is less than disk_io_chunk_frames to be written, no data will be
837 * written at all unless @a force_flush is true.
840 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
846 _write_data_count = 0;
848 total = _session.transport_frame() - _last_flush_frame;
850 if (_last_flush_frame > _session.transport_frame() || _last_flush_frame < capture_start_frame) {
851 _last_flush_frame = _session.transport_frame();
854 if (total == 0 || _capture_buf->read_space() == 0
855 || (!force_flush && (total < disk_io_chunk_frames && was_recording))) {
859 /* if there are 2+ chunks of disk i/o possible for
860 this track, let the caller know so that it can arrange
861 for us to be called again, ASAP.
863 if we are forcing a flush, then if there is* any* extra
864 work, let the caller know.
866 if we are no longer recording and there is any extra work,
867 let the caller know too.
870 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
874 to_write = disk_io_chunk_frames;
876 assert(!destructive());
878 if (record_enabled() &&
879 ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) ||
881 if ((!_write_source) || _write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
882 error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
885 _last_flush_frame = _session.transport_frame();
894 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
896 bool more_work = true;
898 boost::shared_ptr<MidiRegion> region;
899 MidiRegion::SourceList srcs;
900 MidiRegion::SourceList::iterator src;
901 vector<CaptureInfo*>::iterator ci;
902 bool mark_write_completed = false;
904 finish_capture (true);
906 /* butler is already stopped, but there may be work to do
907 to flush remaining data to disk.
910 while (more_work && !err) {
911 switch (do_flush (TransportContext, true)) {
918 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
923 /* XXX is there anything we can do if err != 0 ? */
924 Glib::Mutex::Lock lm (capture_info_lock);
926 if (capture_info.empty()) {
934 _write_source->mark_for_remove ();
935 _write_source.reset();
938 /* new source set up in "out" below */
942 assert(_write_source);
944 nframes_t total_capture = 0;
945 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
946 total_capture += (*ci)->frames;
949 if (_write_source->length (capture_info.front()->start) != 0) {
951 /* phew, we have data */
953 /* figure out the name for this take */
955 srcs.push_back (_write_source);
957 _write_source->set_timeline_position (capture_info.front()->start);
958 _write_source->set_captured_for (_name);
960 /* flush to disk: this step differs from the audio path,
961 where all the data is already on disk.
964 _write_source->mark_streaming_write_completed ();
966 /* make it not a stub anymore */
968 _write_source->unstubify ();
970 /* we will want to be able to keep (over)writing the source
971 but we don't want it to be removable. this also differs
972 from the audio situation, where the source at this point
973 must be considered immutable. luckily, we can rely on
974 MidiSource::mark_streaming_write_completed() to have
975 already done the necessary work for that.
978 string whole_file_region_name;
979 whole_file_region_name = region_name_from_path (_write_source->name(), true);
981 /* Register a new region with the Session that
982 describes the entire source. Do this first
983 so that any sub-regions will obviously be
984 children of this one (later!)
990 plist.add (Properties::name, whole_file_region_name);
991 plist.add (Properties::whole_file, true);
992 plist.add (Properties::automatic, true);
993 plist.add (Properties::start, 0);
994 plist.add (Properties::length, total_capture);
995 plist.add (Properties::layer, 0);
997 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
999 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1000 region->special_set_position (capture_info.front()->start);
1004 catch (failed_constructor& err) {
1005 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1009 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1011 _playlist->clear_changes ();
1012 _playlist->freeze ();
1014 /* Session frame time of the initial capture in this pass, which is where the source starts */
1015 framepos_t initial_capture = 0;
1016 if (!capture_info.empty()) {
1017 initial_capture = capture_info.front()->start;
1020 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1024 RegionFactory::region_name (region_name, _write_source->name(), false);
1026 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1031 /* start of this region is the offset between the start of its capture and the start of the whole pass */
1032 plist.add (Properties::start, (*ci)->start - initial_capture);
1033 plist.add (Properties::length, (*ci)->frames);
1034 plist.add (Properties::name, region_name);
1036 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1037 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1040 catch (failed_constructor& err) {
1041 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1042 continue; /* XXX is this OK? */
1045 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1047 i_am_the_modifier++;
1048 _playlist->add_region (region, (*ci)->start);
1049 i_am_the_modifier--;
1053 _session.add_command (new StatefulDiffCommand(_playlist));
1056 mark_write_completed = true;
1059 use_new_write_source (0);
1061 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1066 midi_playlist()->clear_note_trackers ();
1069 capture_info.clear ();
1070 capture_start_frame = 0;
1074 MidiDiskstream::transport_looped (framepos_t transport_frame)
1076 if (was_recording) {
1078 // adjust the capture length knowing that the data will be recorded to disk
1079 // only necessary after the first loop where we're recording
1080 if (capture_info.size() == 0) {
1081 capture_captured += _capture_offset;
1083 if (_alignment_style == ExistingMaterial) {
1084 capture_captured += _session.worst_output_latency();
1086 capture_captured += _roll_delay;
1090 finish_capture (true);
1092 // the next region will start recording via the normal mechanism
1093 // we'll set the start position to the current transport pos
1094 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1095 capture_start_frame = transport_frame;
1096 first_recordable_frame = transport_frame; // mild lie
1097 last_recordable_frame = max_framepos;
1098 was_recording = true;
1103 MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
1105 was_recording = false;
1107 if (capture_captured == 0) {
1111 // Why must we destroy?
1112 assert(!destructive());
1114 CaptureInfo* ci = new CaptureInfo;
1116 ci->start = capture_start_frame;
1117 ci->frames = capture_captured;
1119 /* XXX theoretical race condition here. Need atomic exchange ?
1120 However, the circumstances when this is called right
1121 now (either on record-disable or transport_stopped)
1122 mean that no actual race exists. I think ...
1123 We now have a capture_info_lock, but it is only to be used
1124 to synchronize in the transport_stop and the capture info
1125 accessors, so that invalidation will not occur (both non-realtime).
1128 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1130 capture_info.push_back (ci);
1131 capture_captured = 0;
1135 MidiDiskstream::set_record_enabled (bool yn)
1137 if (!recordable() || !_session.record_enabling_legal()) {
1141 assert(!destructive());
1143 /* yes, i know that this not proof against race conditions, but its
1144 good enough. i think.
1147 if (record_enabled() != yn) {
1149 engage_record_enable ();
1151 disengage_record_enable ();
1157 MidiDiskstream::engage_record_enable ()
1159 bool const rolling = _session.transport_speed() != 0.0f;
1161 g_atomic_int_set (&_record_enabled, 1);
1163 if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1164 _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
1167 RecordEnableChanged (); /* EMIT SIGNAL */
1171 MidiDiskstream::disengage_record_enable ()
1173 g_atomic_int_set (&_record_enabled, 0);
1174 if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
1176 _source_port->request_monitor_input (false);
1180 RecordEnableChanged (); /* EMIT SIGNAL */
1184 MidiDiskstream::get_state ()
1186 XMLNode* node = new XMLNode ("Diskstream");
1188 LocaleGuard lg (X_("POSIX"));
1190 snprintf (buf, sizeof(buf), "0x%x", _flags);
1191 node->add_property ("flags", buf);
1193 node->add_property("channel-mode", enum_2_string(get_channel_mode()));
1195 snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1196 node->add_property("channel-mask", buf);
1198 node->add_property ("playlist", _playlist->name());
1200 snprintf (buf, sizeof(buf), "%f", _visible_speed);
1201 node->add_property ("speed", buf);
1203 node->add_property("name", _name);
1204 id().print(buf, sizeof(buf));
1205 node->add_property("id", buf);
1207 if (_write_source && _session.get_record_enabled()) {
1209 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1210 XMLNode* cs_grandchild;
1212 cs_grandchild = new XMLNode (X_("file"));
1213 cs_grandchild->add_property (X_("path"), _write_source->path());
1214 cs_child->add_child_nocopy (*cs_grandchild);
1216 /* store the location where capture will start */
1220 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1221 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1223 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1226 cs_child->add_property (X_("at"), buf);
1227 node->add_child_nocopy (*cs_child);
1231 node->add_child_copy (*_extra_xml);
1238 MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
1240 const XMLProperty* prop;
1241 XMLNodeList nlist = node.children();
1242 XMLNodeIterator niter;
1243 XMLNode* capture_pending_node = 0;
1244 LocaleGuard lg (X_("POSIX"));
1246 in_set_state = true;
1248 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1249 /*if ((*niter)->name() == IO::state_node_name) {
1250 deprecated_io_node = new XMLNode (**niter);
1252 assert ((*niter)->name() != IO::state_node_name);
1254 if ((*niter)->name() == X_("CapturingSources")) {
1255 capture_pending_node = *niter;
1259 /* prevent write sources from being created */
1261 in_set_state = true;
1263 if ((prop = node.property ("name")) != 0) {
1264 _name = prop->value();
1267 if ((prop = node.property ("id")) != 0) {
1268 _id = prop->value ();
1271 if ((prop = node.property ("flags")) != 0) {
1272 _flags = Flag (string_2_enum (prop->value(), _flags));
1275 ChannelMode channel_mode = AllChannels;
1276 if ((prop = node.property ("channel-mode")) != 0) {
1277 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1280 unsigned int channel_mask = 0xFFFF;
1281 if ((prop = node.property ("channel-mask")) != 0) {
1282 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1283 if (channel_mask & (~0xFFFF)) {
1284 warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1288 set_channel_mode(channel_mode, channel_mask);
1290 if ((prop = node.property ("playlist")) == 0) {
1295 bool had_playlist = (_playlist != 0);
1297 if (find_and_use_playlist (prop->value())) {
1301 if (!had_playlist) {
1302 _playlist->set_orig_diskstream_id (id());
1305 if (capture_pending_node) {
1306 use_pending_capture_data (*capture_pending_node);
1311 if ((prop = node.property ("speed")) != 0) {
1312 double sp = atof (prop->value().c_str());
1314 if (realtime_set_speed (sp, false)) {
1315 non_realtime_set_speed ();
1319 in_set_state = false;
1325 MidiDiskstream::use_new_write_source (uint32_t n)
1327 if (!_session.writable() || !recordable()) {
1333 _write_source.reset();
1336 /* file starts off as a stub file, it will be converted
1337 when we're done with a capture pass, or when "stolen"
1341 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1342 _session.create_midi_source_for_session (0, name (), true));
1344 if (!_write_source) {
1345 throw failed_constructor();
1349 catch (failed_constructor &err) {
1350 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1351 _write_source.reset();
1355 _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
1360 list<boost::shared_ptr<Source> >
1361 MidiDiskstream::steal_write_sources()
1363 list<boost::shared_ptr<Source> > ret;
1365 /* put some data on the disk, even if its just a header for an empty file.
1366 XXX should we not have a more direct method for doing this? Maybe not
1367 since we don't want to mess around with the model/disk relationship
1368 that the Source has to pay attention to.
1371 boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
1373 /* make it visible/present */
1374 _write_source->unstubify ();
1375 /* never let it go away */
1376 _write_source->mark_nonremovable ();
1378 ret.push_back (_write_source);
1382 use_new_write_source (0);
1388 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1390 if (!_session.writable() || !recordable()) {
1394 if (_write_source && mark_write_complete) {
1395 _write_source->mark_streaming_write_completed ();
1397 use_new_write_source (0);
1401 MidiDiskstream::rename_write_sources ()
1403 if (_write_source != 0) {
1404 _write_source->set_source_name (_name.val(), destructive());
1405 /* XXX what to do if this fails ? */
1411 MidiDiskstream::set_block_size (nframes_t /*nframes*/)
1416 MidiDiskstream::allocate_temporary_buffers ()
1421 MidiDiskstream::monitor_input (bool yn)
1424 _source_port->ensure_monitor_input (yn);
1428 MidiDiskstream::set_align_style_from_io ()
1430 bool have_physical = false;
1436 get_input_sources ();
1438 if (_source_port && _source_port->flags() & JackPortIsPhysical) {
1439 have_physical = true;
1442 if (have_physical) {
1443 set_align_style (ExistingMaterial);
1445 set_align_style (CaptureTime);
1451 MidiDiskstream::playback_buffer_load () const
1453 return (float) ((double) _playback_buf->read_space()/
1454 (double) _playback_buf->capacity());
1458 MidiDiskstream::capture_buffer_load () const
1460 return (float) ((double) _capture_buf->write_space()/
1461 (double) _capture_buf->capacity());
1465 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1470 /** Writes playback events in the given range to \a dst, translating time stamps
1471 * so that an event at \a start has time = 0
1474 MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
1477 assert(dst.size() == 0);
1479 // Reverse. ... We just don't do reverse, ok? Back off.
1484 // Translates stamps to be relative to start
1488 const size_t events_read = _playback_buf->read(dst, start, end);
1489 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
1490 _playback_buf->read_space(), _playback_buf->write_space()));
1492 _playback_buf->read(dst, start, end);
1495 gint32 frames_read = end - start;
1496 g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);