X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_diskstream.cc;h=0ec17bc3aad0a2ccb7970b588dc563f9b1e946a5;hb=0bee288b5d6c6ca1fb33b8bc3b584c6d2c3d3364;hp=e916fef263b9986de441286772e69d5a885723bf;hpb=10bdce85a0e7381d1b5db38e3640600c6fd3ec79;p=ardour.git diff --git a/libs/ardour/midi_diskstream.cc b/libs/ardour/midi_diskstream.cc index e916fef263..0ec17bc3aa 100644 --- a/libs/ardour/midi_diskstream.cc +++ b/libs/ardour/midi_diskstream.cc @@ -67,7 +67,7 @@ using namespace std; using namespace ARDOUR; using namespace PBD; -nframes_t MidiDiskstream::midi_readahead = 4096; +framecnt_t MidiDiskstream::midi_readahead = 4096; MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag) : Diskstream(sess, name, flag) @@ -85,7 +85,7 @@ MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::F init (); use_new_playlist (); - use_new_write_source (0); + use_new_write_source (0); in_set_state = false; @@ -111,7 +111,7 @@ MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node) throw failed_constructor(); } - use_new_write_source (0); + use_new_write_source (0); in_set_state = false; } @@ -128,8 +128,8 @@ MidiDiskstream::init () allocate_temporary_buffers (); const size_t size = _session.butler()->midi_diskstream_buffer_size(); - _playback_buf = new MidiRingBuffer(size); - _capture_buf = new MidiRingBuffer(size); + _playback_buf = new MidiRingBuffer(size); + _capture_buf = new MidiRingBuffer(size); _n_channels = ChanCount(DataType::MIDI, 1); @@ -184,10 +184,10 @@ MidiDiskstream::non_realtime_input_change () /* implicit unlock */ } - /* unlike with audio, there is never any need to reset write sources - based on input configuration changes because ... a MIDI track - has just 1 MIDI port as input, always. - */ + /* unlike with audio, there is never any need to reset write sources + based on input configuration changes because ... a MIDI track + has just 1 MIDI port as input, always. + */ /* now refill channel buffers */ @@ -488,17 +488,17 @@ trace_midi (ostream& o, MIDI::byte *msg, size_t len) #endif int -MidiDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler) +MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler) { int ret = -1; - nframes_t rec_offset = 0; - nframes_t rec_nframes = 0; + framecnt_t rec_offset = 0; + framecnt_t rec_nframes = 0; bool nominally_recording; bool re = record_enabled (); - playback_distance = 0; + playback_distance = 0; - check_record_status (transport_frame, nframes, can_record); + check_record_status (transport_frame, can_record); nominally_recording = (can_record && re); @@ -506,9 +506,9 @@ MidiDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can return 0; } - Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK); + Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK); - if (!sm.locked()) { + if (!sm.locked()) { return 1; } @@ -540,6 +540,16 @@ MidiDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer()); } + if (buf.size() != 0) { + /* Make a copy of this data and emit it for the GUI to see */ + boost::shared_ptr copy (new MidiBuffer (buf.capacity ())); + for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) { + copy->push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer()); + } + + DataRecorded (copy, _write_source); /* EMIT SIGNAL */ + } + } else { if (was_recording) { @@ -570,15 +580,15 @@ MidiDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can ret = 0; - if (commit (nframes)) { - need_butler = true; - } + if (commit (nframes)) { + need_butler = true; + } return ret; } bool -MidiDiskstream::commit (nframes_t nframes) +MidiDiskstream::commit (framecnt_t nframes) { bool need_butler = false; @@ -619,6 +629,12 @@ MidiDiskstream::set_pending_overwrite (bool yn) int MidiDiskstream::overwrite_existing_buffers () { + /* This is safe as long as the butler thread is suspended, which it should be */ + _playback_buf->reset (); + + g_atomic_int_set (&_frames_read_from_ringbuffer, 0); + g_atomic_int_set (&_frames_written_to_ringbuffer, 0); + read (overwrite_frame, disk_io_chunk_frames, false); overwrite_queued = false; _pending_overwrite = false; @@ -668,9 +684,9 @@ MidiDiskstream::internal_playback_seek (framecnt_t distance) /** @a start is set to the new frame position (TIME) read up to */ int -MidiDiskstream::read (framepos_t& start, nframes_t dur, bool reversed) +MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed) { - nframes_t this_read = 0; + framecnt_t this_read = 0; bool reloop = false; framepos_t loop_end = 0; framepos_t loop_start = 0; @@ -750,9 +766,6 @@ MidiDiskstream::read (framepos_t& start, nframes_t dur, bool reversed) // Synthesize LoopEvent here, because the next events // written will have non-monotonic timestamps. _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start); - cout << "Pushing LoopEvent ts=" << loop_end-1 - << " start+this_read " << start+this_read << endl; - start = loop_start; } else { start += this_read; @@ -805,12 +818,12 @@ MidiDiskstream::do_refill () return 0; } - nframes_t to_read = midi_readahead - (frames_written - frames_read); + framecnt_t to_read = midi_readahead - (frames_written - frames_read); //cout << "MDS read for midi_readahead " << to_read << " rb_contains: " // << frames_written - frames_read << endl; - to_read = (nframes_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame)); + to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame)); if (read (file_frame, to_read, reversed)) { ret = -1; @@ -834,14 +847,13 @@ MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush) { uint32_t to_write; int32_t ret = 0; - nframes_t total; + framecnt_t total; _write_data_count = 0; total = _session.transport_frame() - _last_flush_frame; - if (_last_flush_frame > _session.transport_frame() - || _last_flush_frame < capture_start_frame) { + if (_last_flush_frame > _session.transport_frame() || _last_flush_frame < capture_start_frame) { _last_flush_frame = _session.transport_frame(); } @@ -869,10 +881,10 @@ MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush) assert(!destructive()); - if (record_enabled() && - ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) || + if (record_enabled() && + ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) || force_flush)) { - if ((!_write_source) || _write_source->midi_write (*_capture_buf, capture_start_frame, to_write) != to_write) { + if ((!_write_source) || _write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) { error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg; return -1; } else { @@ -903,14 +915,14 @@ MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen while (more_work && !err) { switch (do_flush (TransportContext, true)) { - case 0: - more_work = false; - break; - case 1: - break; - case -1: - error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg; - err++; + case 0: + more_work = false; + break; + case 1: + break; + case -1: + error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg; + err++; } } @@ -924,7 +936,6 @@ MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen if (abort_capture) { if (_write_source) { - _write_source->mark_for_remove (); _write_source.reset(); } @@ -935,118 +946,129 @@ MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen assert(_write_source); - nframes_t total_capture = 0; + framecnt_t total_capture = 0; for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) { total_capture += (*ci)->frames; } - if (_write_source->length (capture_info.front()->start) != 0) { - - /* phew, we have data */ - - /* figure out the name for this take */ - - srcs.push_back (_write_source); + if (_write_source->length (capture_info.front()->start) != 0) { - _write_source->set_timeline_position (capture_info.front()->start); - _write_source->set_captured_for (_name); + /* phew, we have data */ - /* flush to disk: this step differs from the audio path, - where all the data is already on disk. - */ + /* figure out the name for this take */ - _write_source->mark_streaming_write_completed (); - - /* make it not a stub anymore */ + srcs.push_back (_write_source); - _write_source->unstubify (); + _write_source->set_timeline_position (capture_info.front()->start); + _write_source->set_captured_for (_name); - /* we will want to be able to keep (over)writing the source - but we don't want it to be removable. this also differs - from the audio situation, where the source at this point - must be considered immutable. luckily, we can rely on - MidiSource::mark_streaming_write_completed() to have - already done the necessary work for that. - */ + /* flush to disk: this step differs from the audio path, + where all the data is already on disk. + */ - string whole_file_region_name; - whole_file_region_name = region_name_from_path (_write_source->name(), true); - - /* Register a new region with the Session that - describes the entire source. Do this first - so that any sub-regions will obviously be - children of this one (later!) - */ - - try { - PropertyList plist; + _write_source->mark_streaming_write_completed (); - plist.add (Properties::name, whole_file_region_name); - plist.add (Properties::whole_file, true); - plist.add (Properties::automatic, true); - plist.add (Properties::start, 0); - plist.add (Properties::length, total_capture); - plist.add (Properties::layer, 0); + /* set length in beats to entire capture length */ - boost::shared_ptr rx (RegionFactory::create (srcs, plist)); + BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start); + const double total_capture_beats = converter.from(total_capture); + _write_source->set_length_beats(total_capture_beats); - region = boost::dynamic_pointer_cast (rx); - region->special_set_position (capture_info.front()->start); - } + /* make it not a stub anymore */ + _write_source->unstubify (); - catch (failed_constructor& err) { - error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg; - /* XXX what now? */ - } + /* we will want to be able to keep (over)writing the source + but we don't want it to be removable. this also differs + from the audio situation, where the source at this point + must be considered immutable. luckily, we can rely on + MidiSource::mark_streaming_write_completed() to have + already done the necessary work for that. + */ - _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end()); + string whole_file_region_name; + whole_file_region_name = region_name_from_path (_write_source->name(), true); - _playlist->clear_changes (); - _playlist->freeze (); + /* Register a new region with the Session that + describes the entire source. Do this first + so that any sub-regions will obviously be + children of this one (later!) + */ - uint32_t buffer_position = 0; - for (buffer_position = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) { + try { + PropertyList plist; - string region_name; + plist.add (Properties::name, whole_file_region_name); + plist.add (Properties::whole_file, true); + plist.add (Properties::automatic, true); + plist.add (Properties::start, 0); + plist.add (Properties::length, total_capture); + plist.add (Properties::layer, 0); - RegionFactory::region_name (region_name, _write_source->name(), false); + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); + + region = boost::dynamic_pointer_cast (rx); + region->special_set_position (capture_info.front()->start); + } - // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n"; - try { - PropertyList plist; - - plist.add (Properties::start, buffer_position); - plist.add (Properties::length, (*ci)->frames); - plist.add (Properties::name, region_name); - - boost::shared_ptr rx (RegionFactory::create (srcs, plist)); - region = boost::dynamic_pointer_cast (rx); - } + catch (failed_constructor& err) { + error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg; + /* XXX what now? */ + } - catch (failed_constructor& err) { - error << _("MidiDiskstream: could not create region for captured midi!") << endmsg; - continue; /* XXX is this OK? */ - } + _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end()); - // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl; + _playlist->clear_changes (); + _playlist->freeze (); - i_am_the_modifier++; - _playlist->add_region (region, (*ci)->start); - i_am_the_modifier--; + /* Session frame time of the initial capture in this pass, which is where the source starts */ + framepos_t initial_capture = 0; + if (!capture_info.empty()) { + initial_capture = capture_info.front()->start; + } - buffer_position += (*ci)->frames; - } + for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) { - _playlist->thaw (); - _session.add_command (new StatefulDiffCommand(_playlist)); - } + string region_name; - mark_write_completed = true; + RegionFactory::region_name (region_name, _write_source->name(), false); + + // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n"; + + try { + PropertyList plist; + + /* start of this region is the offset between the start of its capture and the start of the whole pass */ + plist.add (Properties::start, (*ci)->start - initial_capture); + plist.add (Properties::length, (*ci)->frames); + plist.add (Properties::length_beats, converter.from((*ci)->frames)); + plist.add (Properties::name, region_name); + + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); + region = boost::dynamic_pointer_cast (rx); + } + + catch (failed_constructor& err) { + error << _("MidiDiskstream: could not create region for captured midi!") << endmsg; + continue; /* XXX is this OK? */ + } + + // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl; + + i_am_the_modifier++; + _playlist->add_region (region, (*ci)->start); + i_am_the_modifier--; + } + + _playlist->thaw (); + _session.add_command (new StatefulDiffCommand(_playlist)); + } + + mark_write_completed = true; } - use_new_write_source (0); + use_new_write_source (0); for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) { delete *ci; @@ -1146,7 +1168,7 @@ MidiDiskstream::set_record_enabled (bool yn) void MidiDiskstream::engage_record_enable () { - bool rolling = _session.transport_speed() != 0.0f; + bool const rolling = _session.transport_speed() != 0.0f; g_atomic_int_set (&_record_enabled, 1); @@ -1154,8 +1176,6 @@ MidiDiskstream::engage_record_enable () _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling)); } - _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame()); - RecordEnableChanged (); /* EMIT SIGNAL */ } @@ -1322,16 +1342,16 @@ MidiDiskstream::use_new_write_source (uint32_t n) assert(n == 0); - _write_source.reset(); + _write_source.reset(); try { - /* file starts off as a stub file, it will be converted - when we're done with a capture pass, or when "stolen" - by the GUI. - */ + /* file starts off as a stub file, it will be converted + when we're done with a capture pass, or when "stolen" + by the GUI. + */ _write_source = boost::dynamic_pointer_cast( - _session.create_midi_source_for_session (0, name (), true)); + _session.create_midi_source_for_session (0, name (), true)); if (!_write_source) { throw failed_constructor(); @@ -1349,31 +1369,31 @@ MidiDiskstream::use_new_write_source (uint32_t n) return 0; } -list > +list > MidiDiskstream::steal_write_sources() { - list > ret; + list > ret; - /* put some data on the disk, even if its just a header for an empty file. - XXX should we not have a more direct method for doing this? Maybe not - since we don't want to mess around with the model/disk relationship - that the Source has to pay attention to. - */ - - boost::dynamic_pointer_cast(_write_source)->session_saved (); + /* put some data on the disk, even if its just a header for an empty file. + XXX should we not have a more direct method for doing this? Maybe not + since we don't want to mess around with the model/disk relationship + that the Source has to pay attention to. + */ + + boost::dynamic_pointer_cast(_write_source)->session_saved (); - /* make it visible/present */ - _write_source->unstubify (); - /* never let it go away */ - _write_source->mark_nonremovable (); + /* make it visible/present */ + _write_source->unstubify (); + /* never let it go away */ + _write_source->mark_nonremovable (); - ret.push_back (_write_source); + ret.push_back (_write_source); - /* get a new one */ + /* get a new one */ - use_new_write_source (0); + use_new_write_source (0); - return ret; + return ret; } void @@ -1385,8 +1405,8 @@ MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/) if (_write_source && mark_write_complete) { _write_source->mark_streaming_write_completed (); - } - use_new_write_source (0); + } + use_new_write_source (0); } int @@ -1400,7 +1420,7 @@ MidiDiskstream::rename_write_sources () } void -MidiDiskstream::set_block_size (nframes_t /*nframes*/) +MidiDiskstream::set_block_size (pframes_t /*nframes*/) { }