Existing code would cause data loss due to creation of two Source objects referring the same path, one with removable flags and one without. Careful code review suggested a variety of thinkos, function naming problems and other confusion that caused this. I have tried ot extensively comment what is going on with these operations, because it is one key area in which MIDI differs from audio: with audio, capture is the only way to add a new audio region, but for MIDI there are GUI input events that can add a new region.
MidiRegionView* const mrv = dynamic_cast<MidiRegionView*>(*r);
if (mrv) {
- boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
- boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone ();
-
- playlist->clear_changes ();
- playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
- _session->add_command(new StatefulDiffCommand (playlist));
+ try {
+ boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
+ boost::shared_ptr<MidiSource> new_source = _session->create_midi_source_by_stealing_name (mrv->midi_view()->track());
+ boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone (new_source);
+
+ playlist->clear_changes ();
+ playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
+ _session->add_command(new StatefulDiffCommand (playlist));
+ } catch (...) {
+ error << string_compose (_("Could not unlink %1"), mrv->region()->name()) << endmsg;
+ }
}
r = tmp;
real_editor->snap_to (pos, 0);
- boost::shared_ptr<Source> src = _session->create_midi_source_for_session (
- view()->trackview().track().get(), view()->trackview().track()->name());
+ boost::shared_ptr<Source> src = _session->create_midi_source_by_stealing_name (view()->trackview().track());
PropertyList plist;
plist.add (ARDOUR::Properties::start, 0);
public:
virtual ~AudioFileSource ();
- bool set_name (const std::string& newname) {
- return (set_source_name(newname, destructive()) == 0);
- }
-
std::string peak_path (std::string audio_path);
std::string find_broken_peakfile (std::string missing_peak_path,
std::string audio_path);
~MidiRegion();
boost::shared_ptr<MidiRegion> clone (std::string path = std::string()) const;
+ boost::shared_ptr<MidiRegion> clone (boost::shared_ptr<MidiSource>) const;
boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
MidiSource (Session& session, const XMLNode&);
virtual ~MidiSource ();
- boost::shared_ptr<MidiSource> clone (const std::string& path,
- Evoral::MusicalTime begin = Evoral::MinMusicalTime,
- Evoral::MusicalTime end = Evoral::MaxMusicalTime);
+ /** Write the data in the given time range to another MidiSource
+ * \param newsrc MidiSource to which data will be written. Should be a
+ * new, empty source. If it already has contents, the results are
+ * undefined. Source must be writable.
+ *
+ * \param begin time of earliest event that can be written.
+ * \param end time of latest event that can be written.
+ *
+ * Returns zero on success, non-zero if the write failed for any
+ * reason.
+ *
+ */
+ int write_to (boost::shared_ptr<MidiSource> newsrc,
+ Evoral::MusicalTime begin = Evoral::MinMusicalTime,
+ Evoral::MusicalTime end = Evoral::MaxMusicalTime);
/** Read the data in a given time range from the MIDI source.
* All time stamps in parameters are in audio frames (even if the source has tempo time).
std::string peak_path (std::string) const;
- std::string change_source_path_by_name (std::string oldpath, std::string oldname, std::string newname, bool destructive);
+ std::string generate_new_source_path_from_name (std::string oldpath, std::string oldname, std::string newname, bool destructive);
std::string peak_path_from_audio_path (std::string) const;
std::string new_audio_source_name (const std::string&, uint32_t nchans, uint32_t chan, bool destructive);
boost::shared_ptr<AudioFileSource> create_audio_source_for_session (
size_t, std::string const &, uint32_t, bool destructive);
- boost::shared_ptr<MidiSource> create_midi_source_for_session (
- Track*, std::string const &);
+ boost::shared_ptr<MidiSource> create_midi_source_for_session (std::string const &);
+ boost::shared_ptr<MidiSource> create_midi_source_by_stealing_name (boost::shared_ptr<Track>);
boost::shared_ptr<Source> source_by_id (const PBD::ID&);
- boost::shared_ptr<Source> source_by_path_and_channel (const std::string&, uint16_t);
+ boost::shared_ptr<AudioFileSource> source_by_path_and_channel (const std::string&, uint16_t) const;
+ boost::shared_ptr<MidiSource> source_by_path (const std::string&) const;
uint32_t count_sources_by_origin (const std::string&);
void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
return safe_midi_file_extension(path);
}
- bool set_name (const std::string& newname) { return (set_source_name(newname, false) == 0); }
-
void append_event_unlocked_beats (const Evoral::Event<Evoral::MusicalTime>& ev);
void append_event_unlocked_frames (const Evoral::Event<framepos_t>& ev, framepos_t source_start);
{
Glib::Threads::Mutex::Lock lm (_lock);
string oldpath = _path;
- string newpath = _session.change_source_path_by_name (oldpath, _name, newname, destructive);
+ string newpath = _session.generate_new_source_path_from_name (oldpath, _name, newname, destructive);
if (newpath.empty()) {
error << string_compose (_("programming error: %1"), "cannot generate a changed file path") << endmsg;
try {
_write_source = boost::dynamic_pointer_cast<SMFSource>(
- _session.create_midi_source_for_session (0, name ()));
+ _session.create_midi_source_for_session (name ()));
if (!_write_source) {
throw failed_constructor();
std::string
MidiDiskstream::steal_write_source_name ()
{
- std::string our_new_name = _session.new_midi_source_name (_write_source->name());
- std::string our_old_name = _write_source->name();
-
- if (_write_source->set_source_name (our_new_name, false)) {
+ string our_old_name = _write_source->name();
+
+ /* this will bump the name of the current write source to the next one
+ * (e.g. "MIDI 1-1" gets renamed to "MIDI 1-2"), thus leaving the
+ * current write source name (e.g. "MIDI 1-1" available). See the
+ * comments in Session::create_midi_source_for_track() about why we do
+ * this.
+ */
+
+ if (_write_source->set_source_name (name(), false)) {
return string();
}
-
+
return our_old_name;
}
#include <set>
#include <glibmm/threads.h>
+#include <glibmm/fileutils.h>
+#include <glibmm/miscutils.h>
#include "pbd/xml++.h"
#include "pbd/basename.h"
#include "ardour/midi_source.h"
#include "ardour/region_factory.h"
#include "ardour/session.h"
+#include "ardour/source_factory.h"
#include "ardour/tempo.h"
#include "ardour/types.h"
*/
boost::shared_ptr<MidiRegion>
MidiRegion::clone (string path) const
+{
+ boost::shared_ptr<MidiSource> newsrc;
+
+ /* caller must check for pre-existing file */
+ assert (!Glib::file_test (path, Glib::FILE_TEST_EXISTS));
+ newsrc = boost::dynamic_pointer_cast<MidiSource>(
+ SourceFactory::createWritable(DataType::MIDI, _session,
+ path, false, _session.frame_rate()));
+ return clone (newsrc);
+}
+
+boost::shared_ptr<MidiRegion>
+MidiRegion::clone (boost::shared_ptr<MidiSource> newsrc) const
{
BeatsFramesConverter bfc (_session.tempo_map(), _position);
Evoral::MusicalTime const bbegin = bfc.from (_start);
Evoral::MusicalTime const bend = bfc.from (_start + _length);
- boost::shared_ptr<MidiSource> ms = midi_source(0)->clone (path, bbegin, bend);
+ if (midi_source(0)->write_to (newsrc, bbegin, bend)) {
+ return boost::shared_ptr<MidiRegion> ();
+ }
PropertyList plist;
- plist.add (Properties::name, PBD::basename_nosuffix (ms->name()));
+ plist.add (Properties::name, PBD::basename_nosuffix (newsrc->name()));
plist.add (Properties::whole_file, true);
plist.add (Properties::start, _start);
plist.add (Properties::start_beats, _start_beats);
plist.add (Properties::length_beats, _length_beats);
plist.add (Properties::layer, 0);
- return boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (ms, plist, true));
+ return boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (newsrc, plist, true));
}
void
mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::DeleteStuckNotes);
}
-boost::shared_ptr<MidiSource>
-MidiSource::clone (const string& path, Evoral::MusicalTime begin, Evoral::MusicalTime end)
+int
+MidiSource::write_to (boost::shared_ptr<MidiSource> newsrc, Evoral::MusicalTime begin, Evoral::MusicalTime end)
{
- string newpath;
-
- /* get a new name for the MIDI file we're going to write to
- */
-
- if (path.empty()) {
- string newname = PBD::basename_nosuffix(_name.val());
- newname = bump_name_once (newname, '-');
- newname += ".mid";
- newpath = _session.new_source_path_from_name (DataType::MIDI, newname);
- } else {
- /* caller must check for pre-existing file */
- assert (!Glib::file_test (path, Glib::FILE_TEST_EXISTS));
- newpath = path;
- }
-
- boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
- SourceFactory::createWritable(DataType::MIDI, _session,
- newpath, false, _session.frame_rate()));
-
newsrc->set_timeline_position(_timeline_position);
newsrc->copy_interpolation_from (this);
newsrc->copy_automation_state_from (this);
}
} else {
error << string_compose (_("programming error: %1"), X_("no model for MidiSource during ::clone()"));
- return boost::shared_ptr<MidiSource>();
+ return -1;
}
newsrc->flush_midi();
boost::dynamic_pointer_cast<FileSource> (newsrc)->prevent_deletion ();
- return newsrc;
+ return 0;
}
void
return source;
}
-boost::shared_ptr<Source>
-Session::source_by_path_and_channel (const string& path, uint16_t chn)
+boost::shared_ptr<AudioFileSource>
+Session::source_by_path_and_channel (const string& path, uint16_t chn) const
{
+ /* Restricted to audio files because only audio sources have channel
+ as a property.
+ */
+
Glib::Threads::Mutex::Lock lm (source_lock);
- for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
+ for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
boost::shared_ptr<AudioFileSource> afs
= boost::dynamic_pointer_cast<AudioFileSource>(i->second);
return afs;
}
}
- return boost::shared_ptr<Source>();
+
+ return boost::shared_ptr<AudioFileSource>();
+}
+
+boost::shared_ptr<MidiSource>
+Session::source_by_path (const std::string& path) const
+{
+ /* Restricted to MIDI files because audio sources require a channel
+ for unique identification, in addition to a path.
+ */
+
+ Glib::Threads::Mutex::Lock lm (source_lock);
+
+ for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
+ boost::shared_ptr<MidiSource> ms
+ = boost::dynamic_pointer_cast<MidiSource>(s->second);
+ boost::shared_ptr<FileSource> fs
+ = boost::dynamic_pointer_cast<FileSource>(s->second);
+
+ if (ms && fs && fs->path() == path) {
+ return ms;
+ }
+ }
+
+ return boost::shared_ptr<MidiSource>();
}
uint32_t
return cnt;
}
-
string
-Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
+Session::generate_new_source_path_from_name (string path, string oldname, string newname, bool destructive)
{
string look_for;
string old_basename = PBD::basename_nosuffix (oldname);
if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
path = Glib::build_filename (dir, buf);
- break;
+ if (!source_by_path (path)) {
+ break;
+ }
}
path = "";
SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
}
-/** Return a unique name based on \a base for a new internal MIDI source */
+/** Return a unique name based on \a owner_name for a new internal MIDI source */
string
-Session::new_midi_source_name (const string& base)
+Session::new_midi_source_name (const string& owner_name)
{
uint32_t cnt;
char buf[PATH_MAX+1];
const uint32_t limit = 10000;
string legalized;
+ string possible_name;
buf[0] = '\0';
- legalized = legalize_for_path (base);
+ legalized = legalize_for_path (owner_name);
// Find a "version" of the file name that doesn't exist in any of the possible directories.
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
SessionDirectory sdir((*i).path);
+
+ snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
+ possible_name = buf;
- std::string p = Glib::build_filename (sdir.midi_path(), legalized);
-
- snprintf (buf, sizeof(buf), "%s-%u.mid", p.c_str(), cnt);
+ std::string possible_path = Glib::build_filename (sdir.midi_path(), possible_name);
+
+ if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
+ existing++;
+ }
- if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
+ if (source_by_path (possible_path)) {
existing++;
}
}
if (cnt > limit) {
error << string_compose(
_("There are already %1 recordings for %2, which I consider too many."),
- limit, base) << endmsg;
+ limit, owner_name) << endmsg;
destroy ();
throw failed_constructor();
}
}
- return Glib::path_get_basename(buf);
+ return possible_name;
}
/** Create a new within-session MIDI source */
boost::shared_ptr<MidiSource>
-Session::create_midi_source_for_session (Track* track, string const & n)
+Session::create_midi_source_for_session (string const & basic_name)
{
std::string name;
- if (track) {
- /* the caller passes in the track the source will be used in,
- so that we can keep the numbering sane.
-
- Rationale: a track with the name "Foo" that has had N
- captures carried out so far will already have a write source
- named "Foo-N+1.mid" waiting to be used for the next capture.
-
- If we call new_midi_source_name() we will get "Foo-N+2". But
- there is no region corresponding to "Foo-N+1", so when
- "Foo-N+2" appears in the track, the gap presents the user
- with odd behaviour - why did it skip past Foo-N+1?
+ if (name.empty()) {
+ name = new_midi_source_name (basic_name);
+ }
- We could explain this to the user in some odd way, but
- instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
- use "Foo-N+1" here.
+ const string path = new_source_path_from_name (DataType::MIDI, name);
- If that attempted rename fails, we get "Foo-N+2.mid" anyway.
- */
+ return boost::dynamic_pointer_cast<SMFSource> (
+ SourceFactory::createWritable (
+ DataType::MIDI, *this, path, false, frame_rate()));
+}
- MidiTrack* mt = dynamic_cast<MidiTrack*> (track);
- assert (mt);
- name = track->steal_write_source_name ();
- }
+/** Create a new within-session MIDI source */
+boost::shared_ptr<MidiSource>
+Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
+{
+ /* the caller passes in the track the source will be used in,
+ so that we can keep the numbering sane.
+
+ Rationale: a track with the name "Foo" that has had N
+ captures carried out so far will ALREADY have a write source
+ named "Foo-N+1.mid" waiting to be used for the next capture.
+
+ If we call new_midi_source_name() we will get "Foo-N+2". But
+ there is no region corresponding to "Foo-N+1", so when
+ "Foo-N+2" appears in the track, the gap presents the user
+ with odd behaviour - why did it skip past Foo-N+1?
+
+ We could explain this to the user in some odd way, but
+ instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
+ use "Foo-N+1" here.
+
+ If that attempted rename fails, we get "Foo-N+2.mid" anyway.
+ */
+
+ boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
+ assert (mt);
+ std::string name = track->steal_write_source_name ();
if (name.empty()) {
- name = new_midi_source_name (n);
+ return boost::shared_ptr<MidiSource>();
}
const string path = new_source_path_from_name (DataType::MIDI, name);
projects / ardour.git / commitdiff