Merge lp:~zequence/ubuntu/utopic/ardour3/fix-for-1450992 into lp:ubuntu/utopic/ardour3

[Kaj Ailomaa]

Fix for bug 1450992.

This is the last release of ardour3.

[Micah Gersten (micahg)]

Rejecting in favor of a backport SRU

review: Disapprove

Unmerged revisions

15. By Adrian Knoth on 2014-12-04

Fix MIDI data loss when editing (Closes: #772118)

14. By Adrian Knoth on 2014-10-03

Reupload with waf fixes from 3.5.380~dfsg-2 and -3

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2014-07-11 12:46:37 +0000
+++ .pc/applied-patches	2015-05-02 14:25:06 +0000
@@ -1,3 +1,4 @@
 waf.patch
 wscript.patch
 log-stdout.patch
+midi-data-loss.patch

=== added directory '.pc/midi-data-loss.patch'
=== added directory '.pc/midi-data-loss.patch/libs'
=== added directory '.pc/midi-data-loss.patch/libs/ardour'
=== added file '.pc/midi-data-loss.patch/libs/ardour/smf_source.cc'
--- .pc/midi-data-loss.patch/libs/ardour/smf_source.cc	1970-01-01 00:00:00 +0000
+++ .pc/midi-data-loss.patch/libs/ardour/smf_source.cc	2015-05-02 14:25:06 +0000
@@ -0,0 +1,764 @@
+/*
+    Copyright (C) 2006 Paul Davis
+    Author: David Robillard
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <vector>
+
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <regex.h>
+
+#include "pbd/pathscanner.h"
+#include "pbd/stl_delete.h"
+#include "pbd/strsplit.h"
+
+#include <glibmm/miscutils.h>
+#include <glibmm/fileutils.h>
+
+#include "evoral/Control.hpp"
+#include "evoral/evoral/SMF.hpp"
+
+#include "ardour/event_type_map.h"
+#include "ardour/midi_model.h"
+#include "ardour/midi_ring_buffer.h"
+#include "ardour/midi_state_tracker.h"
+#include "ardour/session.h"
+#include "ardour/smf_source.h"
+#include "ardour/debug.h"
+
+#include "i18n.h"
+
+using namespace ARDOUR;
+using namespace Glib;
+using namespace PBD;
+using namespace Evoral;
+
+/** Constructor used for new internal-to-session files.  File cannot exist. */
+SMFSource::SMFSource (Session& s, const string& path, Source::Flag flags)
+	: Source(s, DataType::MIDI, path, flags)
+	, MidiSource(s, path, flags)
+	, FileSource(s, DataType::MIDI, path, string(), flags)
+	, Evoral::SMF()
+	, _last_ev_time_beats(0.0)
+	, _last_ev_time_frames(0)
+	, _smf_last_read_end (0)
+	, _smf_last_read_time (0)
+{
+	/* note that origin remains empty */
+
+	if (init (_path, false)) {
+		throw failed_constructor ();
+	}
+ 
+        assert (!Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+	existence_check ();
+
+	_flags = Source::Flag (_flags | Empty);
+
+	/* file is not opened until write */
+
+	if (flags & Writable) {
+		return;
+	}
+
+	if (open (_path)) {
+		throw failed_constructor ();
+	}
+
+	_open = true;
+}
+
+/** Constructor used for external-to-session files.  File must exist. */
+SMFSource::SMFSource (Session& s, const string& path)
+	: Source(s, DataType::MIDI, path, Source::Flag (0))
+	, MidiSource(s, path, Source::Flag (0))
+	, FileSource(s, DataType::MIDI, path, string(), Source::Flag (0))
+	, Evoral::SMF()
+	, _last_ev_time_beats(0.0)
+	, _last_ev_time_frames(0)
+	, _smf_last_read_end (0)
+	, _smf_last_read_time (0)
+{
+	/* note that origin remains empty */
+
+	if (init (_path, true)) {
+		throw failed_constructor ();
+	}
+ 
+        assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+	existence_check ();
+
+	if (_flags & Writable) {
+		/* file is not opened until write */
+		return;
+	}
+
+	if (open (_path)) {
+		throw failed_constructor ();
+	}
+
+	_open = true;
+}
+
+/** Constructor used for existing internal-to-session files. */
+SMFSource::SMFSource (Session& s, const XMLNode& node, bool must_exist)
+	: Source(s, node)
+	, MidiSource(s, node)
+	, FileSource(s, node, must_exist)
+	, _last_ev_time_beats(0.0)
+	, _last_ev_time_frames(0)
+	, _smf_last_read_end (0)
+	, _smf_last_read_time (0)
+{
+	if (set_state(node, Stateful::loading_state_version)) {
+		throw failed_constructor ();
+	}
+
+	/* we expect the file to exist, but if no MIDI data was ever added
+	   it will have been removed at last session close. so, we don't
+	   require it to exist if it was marked Empty.
+	*/
+
+	try {
+
+		if (init (_path, true)) {
+			throw failed_constructor ();
+		}
+
+	} catch (MissingSource& err) {
+
+		if (_flags & Source::Empty) {
+			/* we don't care that the file was not found, because
+			   it was empty. But FileSource::init() will have
+			   failed to set our _path correctly, so we have to do
+			   this ourselves. Use the first entry in the search
+			   path for MIDI files, which is assumed to be the
+			   correct "main" location.
+			*/
+			std::vector<Glib::ustring> sdirs;
+			split (s.source_search_path (DataType::MIDI), sdirs, ':');
+			if (sdirs.empty()) {
+				fatal << _("Empty MIDI source search path!") << endmsg;
+				/*NOTREACHED*/
+			}
+			_path = Glib::build_filename (sdirs.front(), _path);
+			/* This might be important, too */
+			_file_is_new = true;
+		} else {
+			/* pass it on */
+			throw;
+		}
+	}
+
+	if (!(_flags & Source::Empty)) {
+		assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+		existence_check ();
+	} else {
+		assert (_flags & Source::Writable);
+		/* file will be opened on write */
+		return;
+	}
+
+	if (open(_path)) {
+		throw failed_constructor ();
+	}
+
+	_open = true;
+}
+
+SMFSource::~SMFSource ()
+{
+	if (removable()) {
+		unlink (_path.c_str());
+	}
+}
+
+int
+SMFSource::open_for_write ()
+{
+	if (create (_path)) {
+		return -1;
+	}
+	_open = true;
+	return 0;
+}
+
+/** All stamps in audio frames */
+framecnt_t
+SMFSource::read_unlocked (Evoral::EventSink<framepos_t>& destination,
+                          framepos_t const               source_start,
+                          framepos_t                     start,
+                          framecnt_t                     duration,
+                          MidiStateTracker*              tracker) const
+{
+	int      ret  = 0;
+	uint64_t time = 0; // in SMF ticks, 1 tick per _ppqn
+
+	if (writable() && !_open) {
+		/* nothing to read since nothing has ben written */
+		return duration;
+	}
+
+	DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: start %1 duration %2\n", start, duration));
+
+	// Output parameters for read_event (which will allocate scratch in buffer as needed)
+	uint32_t ev_delta_t = 0;
+	uint32_t ev_type    = 0;
+	uint32_t ev_size    = 0;
+	uint8_t* ev_buffer  = 0;
+
+	size_t scratch_size = 0; // keep track of scratch to minimize reallocs
+
+	BeatsFramesConverter converter(_session.tempo_map(), source_start);
+
+	const uint64_t start_ticks = (uint64_t)(converter.from(start) * ppqn());
+	DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: start in ticks %1\n", start_ticks));
+
+	if (_smf_last_read_end == 0 || start != _smf_last_read_end) {
+		DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: seek to %1\n", start));
+		Evoral::SMF::seek_to_start();
+		while (time < start_ticks) {
+			gint ignored;
+
+			ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
+			if (ret == -1) { // EOF
+				_smf_last_read_end = start + duration;
+				return duration;
+			}
+			time += ev_delta_t; // accumulate delta time
+		}
+	} else {
+		DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: set time to %1\n", _smf_last_read_time));
+		time = _smf_last_read_time;
+	}
+
+	_smf_last_read_end = start + duration;
+
+	while (true) {
+		gint ignored; /* XXX don't ignore note id's ??*/
+
+		ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
+		if (ret == -1) { // EOF
+			break;
+		}
+
+		time += ev_delta_t; // accumulate delta time
+		_smf_last_read_time = time;
+
+		if (ret == 0) { // meta-event (skipped, just accumulate time)
+			continue;
+		}
+
+		ev_type = EventTypeMap::instance().midi_event_type(ev_buffer[0]);
+
+		DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked delta %1, time %2, buf[0] %3, type %4\n",
+								  ev_delta_t, time, ev_buffer[0], ev_type));
+
+		assert(time >= start_ticks);
+
+		/* Note that we add on the source start time (in session frames) here so that ev_frame_time
+		   is in session frames.
+		*/
+		const framepos_t ev_frame_time = converter.to(time / (double)ppqn()) + source_start;
+
+		if (ev_frame_time < start + duration) {
+			destination.write (ev_frame_time, ev_type, ev_size, ev_buffer);
+
+			if (tracker) {
+				if (ev_buffer[0] & MIDI_CMD_NOTE_ON) {
+					tracker->add (ev_buffer[1], ev_buffer[0] & 0xf);
+				} else if (ev_buffer[0] & MIDI_CMD_NOTE_OFF) {
+					tracker->remove (ev_buffer[1], ev_buffer[0] & 0xf);
+				}
+			}
+		} else {
+			break;
+		}
+
+		if (ev_size > scratch_size) {
+			scratch_size = ev_size;
+		}
+		ev_size = scratch_size; // ensure read_event only allocates if necessary
+	}
+
+	return duration;
+}
+
+framecnt_t
+SMFSource::write_unlocked (MidiRingBuffer<framepos_t>& source,
+                           framepos_t                  position,
+                           framecnt_t                  cnt)
+{
+	if (!_writing) {
+		mark_streaming_write_started ();
+	}
+
+	framepos_t        time;
+	Evoral::EventType type;
+	uint32_t          size;
+
+	size_t   buf_capacity = 4;
+	uint8_t* buf          = (uint8_t*)malloc(buf_capacity);
+
+	if (_model && !_model->writing()) {
+		_model->start_write();
+	}
+
+	Evoral::MIDIEvent<framepos_t> ev;
+	while (true) {
+		/* Get the event time, in frames since session start but ignoring looping. */
+		bool ret;
+		if (!(ret = source.peek ((uint8_t*)&time, sizeof (time)))) {
+			/* Ring is empty, no more events. */
+			break;
+		}
+
+		if ((cnt != max_framecnt) &&
+		    (time > position + _capture_length + cnt)) {
+			/* The diskstream doesn't want us to write everything, and this
+			   event is past the end of this block, so we're done for now. */
+			break;
+		}
+
+		/* Read the time, type, and size of the event. */
+		if (!(ret = source.read_prefix (&time, &type, &size))) {
+			error << _("Unable to read event prefix, corrupt MIDI ring") << endmsg;
+			break;
+		}
+
+		/* Enlarge body buffer if necessary now that we know the size. */
+		if (size > buf_capacity) {
+			buf_capacity = size;
+			buf = (uint8_t*)realloc(buf, size);
+		}
+
+		/* Read the event body into buffer. */
+		ret = source.read_contents(size, buf);
+		if (!ret) {
+			error << _("Event has time and size but no body, corrupt MIDI ring") << endmsg;
+			break;
+		}
+
+		/* Convert event time from absolute to source relative. */
+		if (time < position) {
+			error << _("Event time is before MIDI source position") << endmsg;
+			break;
+		}
+		time -= position;
+			
+		ev.set(buf, size, time);
+		ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0]));
+		ev.set_id(Evoral::next_event_id());
+
+		if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
+			continue;
+		}
+
+		append_event_unlocked_frames(ev, position);
+	}
+
+	Evoral::SMF::flush ();
+	free (buf);
+
+	return cnt;
+}
+
+/** Append an event with a timestamp in beats (double) */
+void
+SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
+{
+	if (!_writing || ev.size() == 0)  {
+		return;
+	}
+
+	/*printf("SMFSource: %s - append_event_unlocked_beats ID = %d time = %lf, size = %u, data = ",
+               name().c_str(), ev.id(), ev.time(), ev.size());
+	       for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
+
+	if (ev.time() < _last_ev_time_beats) {
+		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
+		        << endmsg;
+		return;
+	}
+
+	Evoral::event_id_t event_id;
+
+	if (ev.id() < 0) {
+		event_id  = Evoral::next_event_id();
+	} else {
+		event_id = ev.id();
+	}
+
+	if (_model) {
+		_model->append (ev, event_id);
+	}
+
+	_length_beats = max(_length_beats, ev.time());
+
+	const double delta_time_beats   = ev.time() - _last_ev_time_beats;
+	const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
+
+	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
+	_last_ev_time_beats = ev.time();
+	_flags = Source::Flag (_flags & ~Empty);
+}
+
+/** Append an event with a timestamp in frames (framepos_t) */
+void
+SMFSource::append_event_unlocked_frames (const Evoral::Event<framepos_t>& ev, framepos_t position)
+{
+	if (!_writing || ev.size() == 0)  {
+		return;
+	}
+
+	// printf("SMFSource: %s - append_event_unlocked_frames ID = %d time = %u, size = %u, data = ",
+	// name().c_str(), ev.id(), ev.time(), ev.size());
+	// for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");
+
+	if (ev.time() < _last_ev_time_frames) {
+		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
+		        << endmsg;
+		return;
+	}
+
+	BeatsFramesConverter converter(_session.tempo_map(), position);
+	const double ev_time_beats = converter.from(ev.time());
+	Evoral::event_id_t event_id;
+
+	if (ev.id() < 0) {
+		event_id  = Evoral::next_event_id();
+	} else {
+		event_id = ev.id();
+	}
+
+	if (_model) {
+		const Evoral::Event<double> beat_ev (ev.event_type(),
+		                                     ev_time_beats,
+		                                     ev.size(),
+		                                     const_cast<uint8_t*>(ev.buffer()));
+		_model->append (beat_ev, event_id);
+	}
+
+	_length_beats = max(_length_beats, ev_time_beats);
+
+	const Evoral::MusicalTime last_time_beats  = converter.from (_last_ev_time_frames);
+	const Evoral::MusicalTime delta_time_beats = ev_time_beats - last_time_beats;
+	const uint32_t            delta_time_ticks = (uint32_t)(lrint(delta_time_beats * (double)ppqn()));
+
+	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
+	_last_ev_time_frames = ev.time();
+	_flags = Source::Flag (_flags & ~Empty);
+}
+
+XMLNode&
+SMFSource::get_state ()
+{
+	XMLNode& node = MidiSource::get_state();
+	node.add_property (X_("origin"), _origin);
+	return node;
+}
+
+int
+SMFSource::set_state (const XMLNode& node, int version)
+{
+	if (Source::set_state (node, version)) {
+		return -1;
+	}
+
+	if (MidiSource::set_state (node, version)) {
+		return -1;
+	}
+
+	if (FileSource::set_state (node, version)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+void
+SMFSource::mark_streaming_midi_write_started (NoteMode mode)
+{
+	/* CALLER MUST HOLD LOCK */
+
+	if (!_open && open_for_write()) {
+		error << string_compose (_("cannot open MIDI file %1 for write"), _path) << endmsg;
+		/* XXX should probably throw or return something */
+		return;
+	}
+
+	MidiSource::mark_streaming_midi_write_started (mode);
+	Evoral::SMF::begin_write ();
+	_last_ev_time_beats = 0.0;
+	_last_ev_time_frames = 0;
+}
+
+void
+SMFSource::mark_streaming_write_completed ()
+{
+	mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::DeleteStuckNotes);
+}
+
+void
+SMFSource::mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::StuckNoteOption stuck_notes_option, Evoral::MusicalTime when)
+{
+	Glib::Threads::Mutex::Lock lm (_lock);
+	MidiSource::mark_midi_streaming_write_completed (stuck_notes_option, when);
+
+	if (!writable()) {
+		warning << string_compose ("attempt to write to unwritable SMF file %1", _path) << endmsg;
+		return;
+	}
+
+	if (_model) {
+		_model->set_edited(false);
+	}
+
+	Evoral::SMF::end_write ();
+
+	/* data in the file now, not removable */
+
+	mark_nonremovable ();
+}
+
+bool
+SMFSource::valid_midi_file (const string& file)
+{
+	if (safe_midi_file_extension (file) ) {
+		return (SMF::test (file) );
+	}
+	return false;
+}
+
+bool
+SMFSource::safe_midi_file_extension (const string& file)
+{
+	static regex_t compiled_pattern;
+	static bool compile = true;
+	const int nmatches = 2;
+	regmatch_t matches[nmatches];
+	
+	if (Glib::file_test (file, Glib::FILE_TEST_EXISTS)) {
+		if (!Glib::file_test (file, Glib::FILE_TEST_IS_REGULAR)) {
+			/* exists but is not a regular file */
+			return false;
+		}
+	}
+
+	if (compile && regcomp (&compiled_pattern, "\\.[mM][iI][dD][iI]?$", REG_EXTENDED)) {
+		return false;
+	} else {
+		compile = false;
+	}
+	
+	if (regexec (&compiled_pattern, file.c_str(), nmatches, matches, 0)) {
+		return false;
+	}
+
+	return true;
+}
+
+static bool compare_eventlist (
+		const std::pair< Evoral::Event<double>*, gint >& a,
+		const std::pair< Evoral::Event<double>*, gint >& b) {
+	return ( a.first->time() < b.first->time() );
+}
+
+void
+SMFSource::load_model (bool lock, bool force_reload)
+{
+	if (_writing) {
+		return;
+	}
+
+	boost::shared_ptr<Glib::Threads::Mutex::Lock> lm;
+	if (lock)
+		lm = boost::shared_ptr<Glib::Threads::Mutex::Lock>(new Glib::Threads::Mutex::Lock(_lock));
+
+	if (_model && !force_reload) {
+		return;
+	}
+
+	if (!_model) {
+		_model = boost::shared_ptr<MidiModel> (new MidiModel (shared_from_this ()));
+	} else {
+		_model->clear();
+	}
+
+	if (writable() && !_open) {
+		return;
+	}
+
+	_model->start_write();
+	Evoral::SMF::seek_to_start();
+
+	uint64_t time = 0; /* in SMF ticks */
+	Evoral::Event<double> ev;
+
+	uint32_t scratch_size = 0; // keep track of scratch and minimize reallocs
+
+	uint32_t delta_t = 0;
+	uint32_t size    = 0;
+	uint8_t* buf     = NULL;
+	int ret;
+	gint event_id;
+	bool have_event_id;
+
+	// TODO simplify event allocation
+	std::list< std::pair< Evoral::Event<double>*, gint > > eventlist;
+
+	for (unsigned i = 1; i <= num_tracks(); ++i) {
+		if (seek_to_track(i)) continue;
+
+		time = 0;
+		have_event_id = false;
+
+		while ((ret = read_event (&delta_t, &size, &buf, &event_id)) >= 0) {
+
+			time += delta_t;
+
+			if (ret == 0) {
+				/* meta-event : did we get an event ID ?  */
+				if (event_id >= 0) {
+					have_event_id = true;
+				}
+				continue;
+			}
+
+			if (ret > 0) {
+				/* not a meta-event */
+
+				if (!have_event_id) {
+					event_id = Evoral::next_event_id();
+				}
+				uint32_t event_type = EventTypeMap::instance().midi_event_type(buf[0]);
+				double   event_time = time / (double) ppqn();
+#ifndef NDEBUG
+				std::string ss;
+
+				for (uint32_t xx = 0; xx < size; ++xx) {
+					char b[8];
+					snprintf (b, sizeof (b), "0x%x ", buf[xx]);
+					ss += b;
+				}
+
+				DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF %6 load model delta %1, time %2, size %3 buf %4, type %5\n",
+							delta_t, time, size, ss , event_type, name()));
+#endif
+
+				eventlist.push_back(make_pair (
+							new Evoral::Event<double> (
+								event_type, event_time,
+								size, buf, true)
+							, event_id));
+
+				// Set size to max capacity to minimize allocs in read_event
+				scratch_size = std::max(size, scratch_size);
+				size = scratch_size;
+
+				_length_beats = max(_length_beats, event_time);
+			}
+
+			/* event ID's must immediately precede the event they are for */
+			have_event_id = false;
+		}
+	}
+
+	eventlist.sort(compare_eventlist);
+
+	std::list< std::pair< Evoral::Event<double>*, gint > >::iterator it;
+	for (it=eventlist.begin(); it!=eventlist.end(); ++it) {
+		_model->append (*it->first, it->second);
+		delete it->first;
+	}
+
+	_model->end_write (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, _length_beats);
+	_model->set_edited (false);
+
+	_model_iter = _model->begin();
+
+	free(buf);
+}
+
+void
+SMFSource::destroy_model ()
+{
+	//cerr << _name << " destroying model " << _model.get() << endl;
+	_model.reset();
+}
+
+void
+SMFSource::flush_midi ()
+{
+	if (!writable() || _length_beats == 0.0) {
+		return;
+	}
+
+	ensure_disk_file ();
+
+	Evoral::SMF::end_write ();
+	/* data in the file means its no longer removable */
+	mark_nonremovable ();
+}
+
+void
+SMFSource::set_path (const string& p)
+{
+	FileSource::set_path (p);
+	SMF::set_path (_path);
+}
+
+/** Ensure that this source has some file on disk, even if it's just a SMF header */
+void
+SMFSource::ensure_disk_file ()
+{
+	if (!writable()) {
+		return;
+	}
+
+	if (_model) {
+		/* We have a model, so write it to disk; see MidiSource::session_saved
+		   for an explanation of what we are doing here.
+		*/
+		boost::shared_ptr<MidiModel> mm = _model;
+		_model.reset ();
+		mm->sync_to_source ();
+		_model = mm;
+	} else {
+		/* No model; if it's not already open, it's an empty source, so create
+		   and open it for writing.
+		*/
+		if (!_open) {
+			open_for_write ();
+		}
+	}
+}
+
+void
+SMFSource::prevent_deletion ()
+{
+	/* Unlike the audio case, the MIDI file remains mutable (because we can
+	   edit MIDI data)
+	*/
+  
+	_flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
+}
+

=== modified file 'debian/changelog'
--- debian/changelog	2014-07-11 12:46:37 +0000
+++ debian/changelog	2015-05-02 14:25:06 +0000
@@ -1,3 +1,23 @@
+ardour3 (3.5.403~dfsg-3) unstable; urgency=medium
+
+  * Fix MIDI data loss when editing (Closes: #772118)
+
+ -- Adrian Knoth <[e-mail]>  Thu, 04 Dec 2014 19:34:45 +0100
+
+ardour3 (3.5.403~dfsg-2) unstable; urgency=high
+
+  * Reupload with waf fixes from 3.5.380~dfsg-2 and -3 
+
+ -- Adrian Knoth <[e-mail]>  Fri, 03 Oct 2014 14:01:07 +0200
+
+ardour3 (3.5.403~dfsg-1) unstable; urgency=high
+
+  * Imported Upstream version 3.5.403~dfsg
+  * Critical bugfix release. All users are recommended to upgrade.
+  * Details: https://community.ardour.org/node/8457
+
+ -- Adrian Knoth <[e-mail]>  Fri, 03 Oct 2014 13:02:45 +0200
+
 ardour3 (3.5.380~dfsg-3) unstable; urgency=medium
 
   * Prevent build failures in slower architectures by

=== modified file 'debian/control'
--- debian/control	2014-01-24 16:31:54 +0000
+++ debian/control	2015-05-02 14:25:06 +0000
@@ -49,7 +49,7 @@
  python-isodate,
  libpcre3-dev,
  python-rdflib
-Standards-Version: 3.9.4
+Standards-Version: 3.9.6
 Homepage: http://www.ardour.org/
 Vcs-Git: git://anonscm.debian.org/pkg-multimedia/ardour3.git
 Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-multimedia/ardour3.git

=== modified file 'debian/control.in'
--- debian/control.in	2014-01-24 16:31:54 +0000
+++ debian/control.in	2015-05-02 14:25:06 +0000
@@ -7,7 +7,7 @@
  Jaromír Mikeš <[e-mail]>
 Build-Depends:
  @cdbs@
-Standards-Version: 3.9.4
+Standards-Version: 3.9.6
 Homepage: http://www.ardour.org/
 Vcs-Git: git://anonscm.debian.org/pkg-multimedia/ardour3.git
 Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-multimedia/ardour3.git

=== added file 'debian/patches/midi-data-loss.patch'
--- debian/patches/midi-data-loss.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/midi-data-loss.patch	2015-05-02 14:25:06 +0000
@@ -0,0 +1,62 @@
+From: David Robillard <[e-mail]>
+Description: Fix MIDI data loss when editing
+Forwarded: not-needed
+Last-Update: 2014-12-04
+Bug-Vendor: http://tracker.ardour.org/view.php?id=5669
+Applied-Upstream: 3.5.404; https://github.com/Ardour/ardour/commit/94954f852ead97bcda7afa548d543222733228ef
+--- ardour3.orig/libs/ardour/smf_source.cc
++++ ardour3/libs/ardour/smf_source.cc
+@@ -393,10 +393,22 @@ SMFSource::append_event_unlocked_beats (
+                name().c_str(), ev.id(), ev.time(), ev.size());
+ 	       for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
+ 
+-	if (ev.time() < _last_ev_time_beats) {
+-		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
+-		        << endmsg;
+-		return;
++	double time = ev.time();
++	if (time < _last_ev_time_beats) {
++		const double difference = _last_ev_time_beats - time;
++		if (difference / (double)ppqn() < 1.0) {
++			/* Close enough.  This problem occurs because Sequence is not
++			   actually ordered due to fuzzy time comparison.  I'm pretty sure
++			   this is inherently a bad idea which causes problems all over the
++			   place, but tolerate it here for now anyway. */
++			time = _last_ev_time_beats;
++		} else {
++			/* Out of order by more than a tick. */
++			warning << string_compose(_("Skipping event with unordered beat time %1 < %2 (off by %3 beats, %4 ticks)"),
++			                          ev.time(), _last_ev_time_beats, difference, difference / (double)ppqn())
++			        << endmsg;
++			return;
++		}
+ 	}
+ 
+ 	Evoral::event_id_t event_id;
+@@ -411,13 +423,13 @@ SMFSource::append_event_unlocked_beats (
+ 		_model->append (ev, event_id);
+ 	}
+ 
+-	_length_beats = max(_length_beats, ev.time());
++	_length_beats = max(_length_beats, time);
+ 
+-	const double delta_time_beats   = ev.time() - _last_ev_time_beats;
++	const double delta_time_beats   = time - _last_ev_time_beats;
+ 	const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
+ 
+ 	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
+-	_last_ev_time_beats = ev.time();
++	_last_ev_time_beats = time;
+ 	_flags = Source::Flag (_flags & ~Empty);
+ }
+ 
+@@ -434,7 +446,8 @@ SMFSource::append_event_unlocked_frames
+ 	// for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");
+ 
+ 	if (ev.time() < _last_ev_time_frames) {
+-		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
++		warning << string_compose(_("Skipping event with unordered frame time %1 < %2"),
++		                          ev.time(), _last_ev_time_frames)
+ 		        << endmsg;
+ 		return;
+ 	}

=== modified file 'debian/patches/series'
--- debian/patches/series	2014-07-11 12:46:37 +0000
+++ debian/patches/series	2015-05-02 14:25:06 +0000
@@ -1,3 +1,4 @@
 waf.patch
 wscript.patch
 log-stdout.patch
+midi-data-loss.patch

=== modified file 'gtk2_ardour/add_video_dialog.cc'
--- gtk2_ardour/add_video_dialog.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/add_video_dialog.cc	2015-05-02 14:25:06 +0000
@@ -258,7 +258,8 @@
 		".ogg"     , ".OGG"     ,
 		".ogv"     , ".OGV"     ,
 		".mpg"     , ".MPG"     ,
-		".mov"     , ".MOV"     ,
+		".mpeg"    , ".MPEG"    ,
+		".mts"     , ".MTS"    ,
 		".mp4"     , ".MP4"     ,
 		".mkv"     , ".MKV"     ,
 		".vob"     , ".VOB"     ,
@@ -272,6 +273,8 @@
 		".dv"      , ".DV"      ,
 		".dirac"   , ".DIRAC"   ,
 		".webm"    , ".WEBM"    ,
+		".wmv"     , ".wmv"     ,
+		".ts"      , ".ts"      ,
 	};
 
 	for (size_t n = 0; n < sizeof(suffixes)/sizeof(suffixes[0]); ++n) {

=== modified file 'gtk2_ardour/editor.h'
--- gtk2_ardour/editor.h	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/editor.h	2015-05-02 14:25:06 +0000
@@ -1262,7 +1262,7 @@
 			 int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&, bool add_channel_suffix);
 
 	int finish_bringing_in_material (boost::shared_ptr<ARDOUR::Region> region, uint32_t, uint32_t,  framepos_t& pos, Editing::ImportMode mode,
-				      boost::shared_ptr<ARDOUR::Track>& existing_track);
+					 boost::shared_ptr<ARDOUR::Track>& existing_track, const std::string& new_track_name);
 
 	boost::shared_ptr<ARDOUR::AudioTrack> get_nth_selected_audio_track (int nth) const;
 	boost::shared_ptr<ARDOUR::MidiTrack> get_nth_selected_midi_track (int nth) const;

=== modified file 'gtk2_ardour/editor_audio_import.cc'
--- gtk2_ardour/editor_audio_import.cc	2014-01-24 16:31:54 +0000
+++ gtk2_ardour/editor_audio_import.cc	2015-05-02 14:25:06 +0000
@@ -611,7 +611,7 @@
 
 				boost::shared_ptr<Source> s;
 
-				if ((s = _session->source_by_path_and_channel (path, n)) == 0) {
+				if ((s = _session->audio_source_by_path_and_channel (path, n)) == 0) {
 
 					source = boost::dynamic_pointer_cast<AudioFileSource> (
 						SourceFactory::createExternal (DataType::AUDIO, *_session,
@@ -657,7 +657,8 @@
 	uint32_t input_chan = 0;
 	uint32_t output_chan = 0;
 	bool use_timestamp;
-	
+	vector<string> track_names;
+
 	use_timestamp = (pos == -1);
 
 	// kludge (for MIDI we're abusing "channel" for "track" here)
@@ -694,6 +695,11 @@
 
 		regions.push_back (r);
 
+		/* if we're creating a new track, name it after the cleaned-up
+		 * and "merged" region name.
+		 */
+
+		track_names.push_back (region_name);
 
 	} else if (target_regions == -1 || target_regions > 1) {
 
@@ -724,29 +730,26 @@
 					region_name = (*x)->name();
 				}
 				
-				switch (sources.size()) {
-					/* zero and one channel handled
-					   by previous if() condition
-					*/
-				case 2:
+				if (sources.size() == 2) {
 					if (n == 0) {
 						region_name += "-L";
 					} else {
 						region_name += "-R";
 					}
-					break;
-				default:
-					region_name += (char) '-';
-					region_name += (char) ('1' + n);
-					break;
+				} else if (sources.size() > 2) {
+					region_name += string_compose ("-%1", n+1);
 				}
 				
+				track_names.push_back (region_name);
+				
 			} else {
 				if (fs) {
 					region_name = region_name_from_path (fs->path(), false, false, sources.size(), n);
-				} else{
+				} else {
 					region_name = (*x)->name();
 				}
+
+				track_names.push_back (PBD::basename_nosuffix (paths[n]));
 			}
 
 			PropertyList plist;
@@ -798,6 +801,12 @@
 	framepos_t rlen = 0;
 
 	begin_reversible_command (Operations::insert_file);
+
+	/* we only use tracks names when importing to new tracks, but we
+	 * require that one is defined for every region, just to keep
+	 * the API simpler.
+	 */
+	assert (regions.size() == track_names.size());
 	
 	for (vector<boost::shared_ptr<Region> >::iterator r = regions.begin(); r != regions.end(); ++r, ++n) {
 		boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (*r);
@@ -830,9 +839,8 @@
                                 pos = get_preferred_edit_position ();
                         }
                 }
-
-
-		finish_bringing_in_material (*r, input_chan, output_chan, pos, mode, track);
+		
+		finish_bringing_in_material (*r, input_chan, output_chan, pos, mode, track, track_names[n]);
 
 		rlen = (*r)->length();
 
@@ -859,7 +867,7 @@
 
 int
 Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t in_chans, uint32_t out_chans, framepos_t& pos,
-				     ImportMode mode, boost::shared_ptr<Track>& existing_track)
+				     ImportMode mode, boost::shared_ptr<Track>& existing_track, const string& new_track_name)
 {
 	boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
 	boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(region);
@@ -916,7 +924,11 @@
 				existing_track = mt.front();
 			}
 
-			existing_track->set_name (region->name());
+			if (!new_track_name.empty()) {
+				existing_track->set_name (new_track_name);
+			} else {
+				existing_track->set_name (region->name());
+			}
 		}
 
 		boost::shared_ptr<Playlist> playlist = existing_track->playlist();

=== modified file 'gtk2_ardour/editor_rulers.cc'
--- gtk2_ardour/editor_rulers.cc	2013-09-21 19:05:02 +0000
+++ gtk2_ardour/editor_rulers.cc	2015-05-02 14:25:06 +0000
@@ -1862,13 +1862,13 @@
 	long millisecs;
 
 	left = sample;
-	hrs = left / (sample_rate * 60 * 60);
-	left -= hrs * sample_rate * 60 * 60;
-	mins = left / (sample_rate * 60);
-	left -= mins * sample_rate * 60;
-	secs = left / sample_rate;
-	left -= secs * sample_rate;
-	millisecs = left * 1000 / sample_rate;
+	hrs = left / (sample_rate * 60 * 60 * 1000);
+	left -= hrs * sample_rate * 60 * 60 * 1000;
+	mins = left / (sample_rate * 60 * 1000);
+	left -= mins * sample_rate * 60 * 1000;
+	secs = left / (sample_rate * 1000);
+	left -= secs * sample_rate * 1000;
+	millisecs = left / sample_rate;
 
 	*millisecs_p = millisecs;
 	*secs_p = secs;
@@ -1888,7 +1888,7 @@
 		return;
 	}
 
-	fr = _session->frame_rate();
+	fr = _session->frame_rate() * 1000;
 
 	/* to prevent 'flashing' */
 	if (lower > (spacer = (framepos_t)(128 * Editor::get_current_zoom ()))) {
@@ -1897,7 +1897,7 @@
 		lower = 0;
 	}
 	upper += spacer;
-	framecnt_t const range = upper - lower;
+	framecnt_t const range = (upper - lower) * 1000;
 
 	if (range <  (fr / 50)) {
 		minsec_mark_interval =  fr / 1000; /* show 1/1000 seconds */
@@ -1997,7 +1997,7 @@
 	}
 
 	*marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * minsec_nmarks);
-	pos = ((((framepos_t) floor(lower)) + (minsec_mark_interval/2))/minsec_mark_interval) * minsec_mark_interval;
+	pos = (((1000 * (framepos_t) floor(lower)) + (minsec_mark_interval/2))/minsec_mark_interval) * minsec_mark_interval;
 	switch (minsec_ruler_scale) {
 	case minsec_show_seconds:
 		for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
@@ -2014,7 +2014,7 @@
 	                        (*marks)[n].style = GtkCustomRulerMarkMicro;
         	        }
                 	(*marks)[n].label = g_strdup (buf);
-              		(*marks)[n].position = pos;
+			(*marks)[n].position = pos/1000.0;
 		}
 	  break;
 	case minsec_show_minutes:
@@ -2032,7 +2032,7 @@
                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
                         }
                         (*marks)[n].label = g_strdup (buf);
-                        (*marks)[n].position = pos;
+                        (*marks)[n].position = pos/1000.0;
                 }
 	  break;
 	case minsec_show_hours:
@@ -2046,14 +2046,14 @@
                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
                         }
                         (*marks)[n].label = g_strdup (buf);
-                        (*marks)[n].position = pos;
+                        (*marks)[n].position = pos/1000.0;
                 }
 	      break;
 	case minsec_show_frames:
 		for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
 			sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
 			if (millisecs % minsec_mark_modulo == 0) {
-				if (secs == 0) {
+				if (millisecs == 0) {
 					(*marks)[n].style = GtkCustomRulerMarkMajor;
 				} else {
 					(*marks)[n].style = GtkCustomRulerMarkMinor;
@@ -2064,7 +2064,7 @@
 				(*marks)[n].style = GtkCustomRulerMarkMicro;
 			}
 			(*marks)[n].label = g_strdup (buf);
-			(*marks)[n].position = pos;
+			(*marks)[n].position = pos/1000.0;
 		}
 	  break;
 	}

=== modified file 'gtk2_ardour/midi_time_axis.cc'
--- gtk2_ardour/midi_time_axis.cc	2014-05-15 14:33:48 +0000
+++ gtk2_ardour/midi_time_axis.cc	2015-05-02 14:25:06 +0000
@@ -757,7 +757,7 @@
 			Evoral::Parameter fully_qualified_param (MidiCCAutomation, chn, ctl);
 			ctl_items.push_back (
 				CheckMenuElem (
-					string_compose ("<b>%1</b>: %2 [%3]", ctl, name, int (chn)),
+					string_compose ("<b>%1</b>: %2 [%3]", ctl, name, int (chn + 1)),
 					sigc::bind (
 						sigc::mem_fun (*this, &RouteTimeAxisView::toggle_automation_track),
 						fully_qualified_param)));
@@ -1199,16 +1199,56 @@
 void
 MidiTimeAxisView::show_all_automation (bool apply_to_selection)
 {
+	using namespace MIDI::Name;
+
 	if (apply_to_selection) {
 		_editor.get_selection().tracks.foreach_midi_time_axis (
 			boost::bind (&MidiTimeAxisView::show_all_automation, _1, false));
 	} else {
 		if (midi_track()) {
+			// Show existing automation
 			const set<Evoral::Parameter> params = midi_track()->midi_playlist()->contained_automation();
 
 			for (set<Evoral::Parameter>::const_iterator i = params.begin(); i != params.end(); ++i) {
 				create_automation_child(*i, true);
 			}
+
+			// Show automation for all controllers named in midnam file
+			boost::shared_ptr<MasterDeviceNames> device_names = get_device_names();
+			if (gui_property (X_("midnam-model-name")) != "Generic" &&
+			     device_names && !device_names->controls().empty()) {
+				const std::string device_mode       = _midnam_custom_device_mode_selector.get_active_text();
+				const uint16_t    selected_channels = midi_track()->get_playback_channel_mask();
+				for (uint32_t chn = 0; chn < 16; ++chn) {
+					if ((selected_channels & (0x0001 << chn)) == 0) {
+						// Channel not in use
+						continue;
+					}
+
+					boost::shared_ptr<ChannelNameSet> chan_names = device_names->channel_name_set_by_channel(
+						device_mode, chn);
+					if (!chan_names) {
+						continue;
+					}
+
+					boost::shared_ptr<ControlNameList> control_names = device_names->control_name_list(
+						chan_names->control_list_name());
+					if (!control_names) {
+						continue;
+					}
+
+					for (ControlNameList::Controls::const_iterator c = control_names->controls().begin();
+					     c != control_names->controls().end();
+					     ++c) {
+						const uint16_t ctl = c->second->number();
+						if (ctl != MIDI_CTL_MSB_BANK && ctl != MIDI_CTL_LSB_BANK) {
+							/* Skip bank select controllers since they're handled specially */
+							const Evoral::Parameter param(MidiCCAutomation, chn, ctl);
+							create_automation_child(param, true);
+						}
+					}
+				}
+			}
 		}
 
 		RouteTimeAxisView::show_all_automation ();

=== modified file 'gtk2_ardour/mnemonic-us.bindings.in'
--- gtk2_ardour/mnemonic-us.bindings.in	2014-05-15 14:33:48 +0000
+++ gtk2_ardour/mnemonic-us.bindings.in	2015-05-02 14:25:06 +0000
@@ -339,7 +339,7 @@
 @trans|Transport/ToggleAutoPlay|5|toggle auto play
 @trans|Transport/ToggleAutoReturn|6|toggle auto return
 @trans|Transport/ToggleClick|7|toggle click (metronome)
-@ranges|Editor/set-tempo-from-region|9|set tempo (1 bar) from region(s)
+@ranges|Region/set-tempo-from-region|9|set tempo (1 bar) from region(s)
 @ranges|Editor/set-tempo-from-edit-range|0|set tempo (1 bar) from edit range
 
 ; mouse stuff

=== modified file 'gtk2_ardour/video_timeline.cc'
--- gtk2_ardour/video_timeline.cc	2014-05-15 14:33:48 +0000
+++ gtk2_ardour/video_timeline.cc	2015-05-02 14:25:06 +0000
@@ -39,6 +39,10 @@
 #include <pthread.h>
 #include <curl/curl.h>
 
+#ifdef PLATFORM_WINDOWS
+#include <windows.h>
+#endif
+
 #include "i18n.h"
 
 using namespace std;
@@ -718,20 +722,45 @@
 VideoTimeLine::find_xjadeo () {
 	std::string xjadeo_file_path;
 	if (getenv("XJREMOTE")) {
-		_xjadeo_bin = strdup(getenv("XJREMOTE")); // XXX TODO: free it?!
-	} else if (find_file_in_search_path (SearchPath(Glib::getenv("PATH")), X_("xjremote"), xjadeo_file_path)) {
-		_xjadeo_bin = xjadeo_file_path;
+		_xjadeo_bin = getenv("XJREMOTE");
+	}
+	else if (find_file_in_search_path (SearchPath(Glib::getenv("PATH")), X_("xjremote"), xjadeo_file_path)) {
+		_xjadeo_bin = xjadeo_file_path;
+	}
+	else if (find_file_in_search_path (SearchPath(Glib::getenv("PATH")), X_("xjadeo"), xjadeo_file_path)) {
+		_xjadeo_bin = xjadeo_file_path;
+	}
+#ifdef __APPLE__
+	else if (Glib::file_test(X_("/Applications/Xjadeo.app/Contents/MacOS/xjremote"), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_EXECUTABLE)) {
+		_xjadeo_bin = X_("/Applications/Xjadeo.app/Contents/MacOS/xjremote");
 	}
 	else if (Glib::file_test(X_("/Applications/Jadeo.app/Contents/MacOS/xjremote"), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_EXECUTABLE)) {
 		_xjadeo_bin = X_("/Applications/Jadeo.app/Contents/MacOS/xjremote");
 	}
-	/* TODO: win32: allow to configure PATH to xjremote */
+#endif
+#ifdef PLATFORM_WINDOWS
+	else {
+		HKEY key;
+		DWORD size = PATH_MAX;
+		char path[PATH_MAX+1];
+		xjadeo_file_path = X_("");
+		if (   (ERROR_SUCCESS == RegOpenKeyExA (HKEY_LOCAL_MACHINE, "Software\\RSS\\xjadeo", 0, KEY_READ, &key))
+		    && (ERROR_SUCCESS == RegQueryValueExA (key, "Install_Dir", 0, NULL, (LPBYTE)path, &size))
+		   )
+		{
+			xjadeo_file_path = g_build_filename(path, X_("xjadeo.exe"));
+		}
+	}
+	if (Glib::file_test(xjadeo_file_path, Glib::FILE_TEST_EXISTS)) {
+		_xjadeo_bin = xjadeo_file_path;
+	}
 	else if (Glib::file_test(X_("C:\\Program Files\\xjadeo\\xjremote.exe"), Glib::FILE_TEST_EXISTS)) {
 		_xjadeo_bin = X_("C:\\Program Files\\xjadeo\\xjremote.exe");
 	}
 	else if (Glib::file_test(X_("C:\\Program Files\\xjadeo\\xjremote.bat"), Glib::FILE_TEST_EXISTS)) {
 		_xjadeo_bin = X_("C:\\Program Files\\xjadeo\\xjremote.bat");
 	}
+#endif
 	else  {
 		_xjadeo_bin = X_("");
 		warning << _("Video-monitor 'xjadeo' was not found. Please install http://xjadeo.sf.net/ "

=== modified file 'libs/ardour/ardour/audiofilesource.h'
--- libs/ardour/ardour/audiofilesource.h	2014-05-15 14:33:48 +0000
+++ libs/ardour/ardour/audiofilesource.h	2015-05-02 14:25:06 +0000
@@ -93,6 +93,12 @@
 	/** Constructor to be called for existing in-session files */
 	AudioFileSource (Session&, const XMLNode&, bool must_exist = true);
 
+	/** Constructor to be called for crash recovery. Final argument is not
+	 * used but exists to differentiate from the external-to-session
+	 * constructor above.
+	 */
+	AudioFileSource (Session&, const std::string& path, Source::Flag flags, bool);
+
 	int init (const std::string& idstr, bool must_exist);
 
 	virtual void set_header_timeline_position () = 0;

=== modified file 'libs/ardour/ardour/file_source.h'
--- libs/ardour/ardour/file_source.h	2014-05-15 14:33:48 +0000
+++ libs/ardour/ardour/file_source.h	2015-05-02 14:25:06 +0000
@@ -85,6 +85,10 @@
 	void existence_check ();
 	virtual void prevent_deletion ();
 
+	/** Rename the file on disk referenced by this source to \param newname
+	 */
+	int rename (const std::string& name);
+
 protected:
 	FileSource (Session& session, DataType type,
 	            const std::string& path,

=== modified file 'libs/ardour/ardour/session.h'
--- libs/ardour/ardour/session.h	2014-05-15 14:33:48 +0000
+++ libs/ardour/ardour/session.h	2015-05-02 14:25:06 +0000
@@ -195,10 +195,10 @@
 	std::string peak_path (std::string) const;
 
 	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);
-	std::string new_midi_source_name (const std::string&);
-	std::string new_source_path_from_name (DataType type, const std::string&);
+	std::string new_audio_source_path (const std::string&, uint32_t nchans, uint32_t chan, bool destructive, bool take_required);
+	std::string new_midi_source_path (const std::string&);
         RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name);
+	std::vector<std::string> get_paths_for_new_sources (bool allow_replacing, const std::string& import_file_path, uint32_t channels);
 
 	void process (pframes_t nframes);
 
@@ -526,8 +526,6 @@
 
 	boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>) const;
 
-	std::string path_from_region_name (DataType type, std::string name, std::string identifier);
-
 	boost::shared_ptr<Region>      XMLRegionFactory (const XMLNode&, bool full);
 	boost::shared_ptr<AudioRegion> XMLAudioRegionFactory (const XMLNode&, bool full);
 	boost::shared_ptr<MidiRegion>  XMLMidiRegionFactory (const XMLNode&, bool full);
@@ -584,8 +582,8 @@
 	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<AudioFileSource> source_by_path_and_channel (const std::string&, uint16_t) const;
-	boost::shared_ptr<MidiSource> source_by_path (const std::string&) const;
+	boost::shared_ptr<AudioFileSource> audio_source_by_path_and_channel (const std::string&, uint16_t) const;
+	boost::shared_ptr<MidiSource> midi_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);
@@ -1433,7 +1431,7 @@
 
 	bool no_questions_about_missing_files;
 
-	std::string get_best_session_directory_for_new_source ();
+	std::string get_best_session_directory_for_new_audio ();
 
 	mutable gint _playback_load;
 	mutable gint _capture_load;

=== modified file 'libs/ardour/ardour/smf_source.h'
--- libs/ardour/ardour/smf_source.h	2014-05-15 14:33:48 +0000
+++ libs/ardour/ardour/smf_source.h	2015-05-02 14:25:06 +0000
@@ -47,15 +47,6 @@
 
 	virtual ~SMFSource ();
 
-	/** Rename the file on disk referenced by this source to \param newname
-	 *
-	 * This method exists only for MIDI file sources, not for audio, which 
-	 * can never be renamed. It exists for MIDI so that we can get
-	 * consistent and sane region/source numbering when regions are added
-	 * manually (which never happens with audio).
-	 */
-	int rename (const std::string& name);
-
         bool safe_file_extension (const std::string& path) const {
 		return safe_midi_file_extension(path);
 	}

=== modified file 'libs/ardour/ardour/sndfilesource.h'
--- libs/ardour/ardour/sndfilesource.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/sndfilesource.h	2015-05-02 14:25:06 +0000
@@ -38,7 +38,16 @@
 	               SampleFormat samp_format, HeaderFormat hdr_format, framecnt_t rate,
 	               Flag flags = SndFileSource::default_writable_flags);
 
-	/** Constructor to be called for existing in-session files */
+	/* Constructor to be called for recovering files being used for
+	 * capture. They are in-session, they already exist, they should not
+	 * be writable. They are an odd hybrid (from a constructor point of
+	 * view) of the previous two constructors.
+	 */
+	SndFileSource (Session&, const std::string& path, int chn);
+
+	/** Constructor to be called for existing in-session files during
+	 * session loading 
+	 */
 	SndFileSource (Session&, const XMLNode&);
 
 	~SndFileSource ();

=== modified file 'libs/ardour/ardour/source.h'
--- libs/ardour/ardour/source.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/source.h	2015-05-02 14:25:06 +0000
@@ -47,7 +47,8 @@
 		RemovableIfEmpty = 0x10,
 		RemoveAtDestroy = 0x20,
 		NoPeakFile = 0x40,
-		Destructive = 0x80
+		Destructive = 0x80,
+		Empty = 0x100, /* used for MIDI only */
 	};
 
 	Source (Session&, DataType type, const std::string& name, Flag flags=Flag(0));

=== modified file 'libs/ardour/ardour/source_factory.h'
--- libs/ardour/ardour/source_factory.h	2013-09-21 19:05:02 +0000
+++ libs/ardour/ardour/source_factory.h	2015-05-02 14:25:06 +0000
@@ -57,6 +57,9 @@
 		 bool destructive, framecnt_t rate, bool announce = true, bool async = false);
 
 
+	static boost::shared_ptr<Source> createForRecovery
+		(DataType type, Session&, const std::string& path, int chn);
+
 	static boost::shared_ptr<Source> createFromPlaylist
 		(DataType type, Session& s, boost::shared_ptr<Playlist> p, const PBD::ID& orig, const std::string& name,
 		 uint32_t chn, frameoffset_t start, framecnt_t len, bool copy, bool defer_peaks);

=== modified file 'libs/ardour/audio_diskstream.cc'
--- libs/ardour/audio_diskstream.cc	2014-05-15 14:33:48 +0000
+++ libs/ardour/audio_diskstream.cc	2015-05-02 14:25:06 +0000
@@ -2181,11 +2181,16 @@
 				continue;
 			}
 
+			/* XXX as of June 2014, we always record to mono
+			   files. Since this Source is being created as part of
+			   crash recovery, we know that we need the first
+			   channel (the final argument to the SourceFactory
+			   call below). If we ever support non-mono files for
+			   capture, this will need rethinking.
+			*/
+
 			try {
-				fs = boost::dynamic_pointer_cast<AudioFileSource> (
-					SourceFactory::createWritable (
-						DataType::AUDIO, _session,
-						prop->value(), false, _session.frame_rate()));
+				fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createForRecovery (DataType::AUDIO, _session, prop->value(), 0));
 			}
 
 			catch (failed_constructor& err) {
@@ -2216,21 +2221,31 @@
 		return -1;
 	}
 
-	boost::shared_ptr<AudioRegion> region;
-
 	try {
 
+		boost::shared_ptr<AudioRegion> wf_region;
+		boost::shared_ptr<AudioRegion> region;
+		
+		/* First create the whole file region */
+
 		PropertyList plist;
-
+		
 		plist.add (Properties::start, 0);
 		plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
 		plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
 
+		wf_region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
+
+		wf_region->set_automatic (true);
+		wf_region->set_whole_file (true);
+		wf_region->special_set_position (position);
+
+		/* Now create a region that isn't the whole file for adding to
+		 * the playlist */
+
 		region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
-
-		region->set_automatic (true);
-		region->set_whole_file (true);
-		region->special_set_position (0);
+		
+		_playlist->add_region (region, position);
 	}
 
 	catch (failed_constructor& err) {
@@ -2241,7 +2256,6 @@
 		return -1;
 	}
 
-	_playlist->add_region (region, position);
 
 	return 0;
 }

=== modified file 'libs/ardour/audiofilesource.cc'
--- libs/ardour/audiofilesource.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/audiofilesource.cc	2015-05-02 14:25:06 +0000
@@ -36,6 +36,7 @@
 #include "pbd/stl_delete.h"
 #include "pbd/strsplit.h"
 #include "pbd/shortpath.h"
+#include "pbd/stacktrace.h"
 #include "pbd/enumwriter.h"
 
 #include <sndfile.h>
@@ -114,6 +115,22 @@
 	}
 }
 
+/** Constructor used for existing internal-to-session files during crash
+ * recovery. File must exist
+ */
+AudioFileSource::AudioFileSource (Session& s, const string& path, Source::Flag flags, bool /* ignored-exists-for-prototype differentiation */)
+	: Source (s, DataType::AUDIO, path, flags)
+	, AudioSource (s, path)
+	, FileSource (s, DataType::AUDIO, path, string(), flags)
+{
+        /* note that origin remains empty */
+
+	if (init (_path, true)) {
+		throw failed_constructor ();
+	}
+}
+
+
 /** Constructor used for existing internal-to-session files via XML.  File must exist. */
 AudioFileSource::AudioFileSource (Session& s, const XMLNode& node, bool must_exist)
 	: Source (s, node)

=== modified file 'libs/ardour/diskstream.cc'
--- libs/ardour/diskstream.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/diskstream.cc	2015-05-02 14:25:06 +0000
@@ -739,4 +739,3 @@
 {
 	g_atomic_int_set (&_record_enabled, 0);
 }
-

=== modified file 'libs/ardour/enums.cc'
--- libs/ardour/enums.cc	2013-12-23 22:07:52 +0000
+++ libs/ardour/enums.cc	2015-05-02 14:25:06 +0000
@@ -447,6 +447,7 @@
 	REGISTER_CLASS_ENUM (Source, RemoveAtDestroy);
 	REGISTER_CLASS_ENUM (Source, NoPeakFile);
 	REGISTER_CLASS_ENUM (Source, Destructive);
+	REGISTER_CLASS_ENUM (Source, Empty);
 	REGISTER_BITS (_Source_Flag);
 
 	REGISTER_ENUM (FadeLinear);

=== modified file 'libs/ardour/file_source.cc'
--- libs/ardour/file_source.cc	2014-05-15 14:33:48 +0000
+++ libs/ardour/file_source.cc	2015-05-02 14:25:06 +0000
@@ -56,7 +56,7 @@
 FileSource::FileSource (Session& session, DataType type, const string& path, const string& origin, Source::Flag flag)
 	: Source(session, type, path, flag)
 	, _path (path)
-	, _file_is_new (!origin.empty()) // origin empty => new file VS. origin !empty => new file
+	, _file_is_new (!origin.empty()) // if origin is left unspecified (empty string) then file must exist
 	, _channel (0)
         , _origin (origin)
         , _open (false)
@@ -214,7 +214,7 @@
 
 	if (move_dependents_to_trash() != 0) {
 		/* try to back out */
-		rename (newpath.c_str(), _path.c_str());
+		::rename (newpath.c_str(), _path.c_str());
 		return -1;
 	}
 
@@ -256,8 +256,6 @@
 
                 split (search_path, dirs, ':');
 
-                hits.clear ();
-
                 for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
 
                         fullpath = Glib::build_filename (*i, path);
@@ -312,9 +310,9 @@
 			/* no match: error */
 
                         if (must_exist) {
-                                error << string_compose(
-                                        _("Filesource: cannot find required file (%1): while searching %2"),
-                                        path, search_path) << endmsg;
+				/* do not generate an error here, leave that to
+				   whoever deals with the false return value.
+				*/
                                 goto out;
                         } else {
                                 isnew = true;
@@ -325,16 +323,17 @@
 			
 			keeppath = de_duped_hits[0];
 		}
-						  
-        } else {
+						   
+       } else {
                 keeppath = path;
         }
 
         /* Current find() is unable to parse relative path names to yet non-existant
            sources. QuickFix(tm)
         */
-        if (keeppath == "") {
-                if (must_exist) {
+
+	if (keeppath.empty()) {
+		if (must_exist) {
                         error << "FileSource::find(), keeppath = \"\", but the file must exist" << endl;
                 } else {
                         keeppath = path;
@@ -581,3 +580,28 @@
 	return true;
 }
 		
+int
+FileSource::rename (const string& newpath)
+{
+	Glib::Threads::Mutex::Lock lm (_lock);
+	string oldpath = _path;
+
+	// Test whether newpath exists, if yes notify the user but continue.
+	if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
+		error << string_compose (_("Programming error! %1 tried to rename a file over another file! It's safe to continue working, but please report this to the developers."), PROGRAM_NAME) << endmsg;
+		return -1;
+	}
+
+	if (Glib::file_test (oldpath.c_str(), Glib::FILE_TEST_EXISTS)) { 
+		/* rename only needed if file exists on disk */
+		if (::rename (oldpath.c_str(), newpath.c_str()) != 0) {
+			error << string_compose (_("cannot rename file %1 to %2 (%3)"), oldpath, newpath, strerror(errno)) << endmsg;
+			return -1;
+		}
+	}
+
+	_name = Glib::path_get_basename (newpath);
+	_path = newpath;
+
+	return 0;
+}

=== modified file 'libs/ardour/filter.cc'
--- libs/ardour/filter.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/filter.cc	2015-05-02 14:25:06 +0000
@@ -59,10 +59,9 @@
 			}
 		}
 
-		string path = session.path_from_region_name (region->data_type(),
-				PBD::basename_nosuffix (names[i]), string (""));
+		string path = session.new_audio_source_path (name, region->n_channels(), i, false, false);
 
-		if (path.length() == 0) {
+		if (path.empty()) {
 			error << string_compose (_("filter: error creating name for new file based on %1"), region->name())
 			      << endmsg;
 			return -1;

=== modified file 'libs/ardour/import.cc'
--- libs/ardour/import.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/import.cc	2015-05-02 14:25:06 +0000
@@ -116,78 +116,31 @@
 	}
 }
 
-static std::string
-get_non_existent_filename (HeaderFormat hf, DataType type, const bool allow_replacing, const std::string& destdir, const std::string& basename, uint channel, uint channels)
-{
-	char buf[PATH_MAX+1];
-	bool goodfile = false;
-	string base = basename;
-	string ext = native_header_format_extension (hf, type);
-	uint32_t cnt = 1;
-
-	do {
-
-		if (type == DataType::AUDIO && channels == 2) {
-			if (channel == 0) {
-				if (cnt == 1) {
-					snprintf (buf, sizeof(buf), "%s-L%s", base.c_str(), ext.c_str());
-				} else {
-					snprintf (buf, sizeof(buf), "%s-%d-L%s", base.c_str(), cnt, ext.c_str());
-				}
-			} else {
-				if (cnt == 1) {
-					snprintf (buf, sizeof(buf), "%s-R%s", base.c_str(), ext.c_str());
-				} else {
-					snprintf (buf, sizeof(buf), "%s-%d-R%s", base.c_str(), cnt, ext.c_str());
-				}
-			}
-		} else if (channels > 1) {
-			if (cnt == 1) {
-				snprintf (buf, sizeof(buf), "%s-c%d%s", base.c_str(), channel, ext.c_str());
-			} else {
-				snprintf (buf, sizeof(buf), "%s-%d-c%d%s", base.c_str(), cnt, channel, ext.c_str());
-			}
-		} else {
-			if (cnt == 1) {
-				snprintf (buf, sizeof(buf), "%s%s", base.c_str(), ext.c_str());
-			} else {
-				snprintf (buf, sizeof(buf), "%s-%d%s", base.c_str(), cnt, ext.c_str());
-			}
-		}
-
-		string tempname = destdir + "/" + buf;
-
-		if (!allow_replacing && Glib::file_test (tempname, Glib::FILE_TEST_EXISTS)) {
-
-			cnt++;
-
-		} else {
-
-			goodfile = true;
-		}
-
-	} while (!goodfile);
-
-	return buf;
-}
-
-static vector<string>
-get_paths_for_new_sources (HeaderFormat hf, const bool allow_replacing, const string& import_file_path, const string& session_dir, uint channels)
+vector<string>
+Session::get_paths_for_new_sources (bool /*allow_replacing*/, const string& import_file_path, uint32_t channels)
 {
 	vector<string> new_paths;
 	const string basename = basename_nosuffix (import_file_path);
 
-	SessionDirectory sdir(session_dir);
-
 	for (uint n = 0; n < channels; ++n) {
 
 		const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO;
-
-		std::string filepath = (type == DataType::MIDI)
-			? sdir.midi_path() : sdir.sound_path();
-
-		filepath = Glib::build_filename (filepath,
-		                                 get_non_existent_filename (hf, type, allow_replacing, filepath, basename, n, channels));
+		string filepath;
+
+		switch (type) {
+		  case DataType::MIDI:
+			filepath = new_midi_source_path (basename);
+			break;
+		case DataType::AUDIO:
+			filepath = new_audio_source_path (basename, channels, n, false, false);
+			break;
+		}
+
+		if (filepath.empty()) {
+			error << string_compose (_("Cannot find new filename for imported file %1"), import_file_path) << endmsg;
+			return vector<string>();
+		}
+
 		new_paths.push_back (filepath);
 	}
 
@@ -201,7 +154,7 @@
 	for (vector<string>::const_iterator i = new_paths.begin();
 	     i != new_paths.end(); ++i)
 	{
-		boost::shared_ptr<Source> source = session->source_by_path_and_channel(*i, 0);
+		boost::shared_ptr<Source> source = session->audio_source_by_path_and_channel(*i, 0);
 
 		if (source == 0) {
 			error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl;
@@ -274,12 +227,12 @@
 {
 	const framecnt_t nframes = ResampledImportableSource::blocksize;
 	boost::shared_ptr<AudioFileSource> afs;
-	uint channels = source->channels();
+	uint32_t channels = source->channels();
 
 	boost::scoped_array<float> data(new float[nframes * channels]);
 	vector<boost::shared_array<Sample> > channel_data;
 
-	for (uint n = 0; n < channels; ++n) {
+	for (uint32_t n = 0; n < channels; ++n) {
 		channel_data.push_back(boost::shared_array<Sample>(new Sample[nframes]));
 	}
 
@@ -323,14 +276,14 @@
 		progress_multiplier = 0.5;
 		progress_base = 0.5;
 	}
-
-	uint read_count = 0;
+	
+	framecnt_t read_count = 0;
 
 	while (!status.cancel) {
 
 		framecnt_t nread, nfread;
-		uint x;
-		uint chn;
+		uint32_t x;
+		uint32_t chn;
 
 		if ((nread = source->read (data.get(), nframes)) == 0) {
 			break;
@@ -513,10 +466,7 @@
 			}
 		}
 
-		vector<string> new_paths = get_paths_for_new_sources (config.get_native_file_header_format(),
-		                                                      status.replace_existing_source, *p,
-		                                                      get_best_session_directory_for_new_source (),
-		                                                      channels);
+		vector<string> new_paths = get_paths_for_new_sources (status.replace_existing_source, *p, channels);
 		Sources newfiles;
 		framepos_t natural_position = source ? source->natural_position() : 0;
 

=== modified file 'libs/ardour/midi_diskstream.cc'
--- libs/ardour/midi_diskstream.cc	2014-05-15 14:33:48 +0000
+++ libs/ardour/midi_diskstream.cc	2015-05-02 14:25:06 +0000
@@ -1234,9 +1234,9 @@
 	 */
 
 	try {
-		string new_name = _session.new_midi_source_name (name());
+		string new_path = _session.new_midi_source_path (name());
 		
-		if (_write_source->rename (new_name)) {
+		if (_write_source->rename (new_path)) {
 			return string();
 		}
 	} catch (...) {

=== modified file 'libs/ardour/session.cc'
--- libs/ardour/session.cc	2014-05-15 14:33:48 +0000
+++ libs/ardour/session.cc	2015-05-02 14:25:06 +0000
@@ -36,6 +36,7 @@
 
 #include <boost/algorithm/string/erase.hpp>
 
+#include "pbd/convert.h"
 #include "pbd/error.h"
 #include "pbd/boost_debug.h"
 #include "pbd/pathscanner.h"
@@ -3305,7 +3306,7 @@
 }
 
 boost::shared_ptr<AudioFileSource>
-Session::source_by_path_and_channel (const string& path, uint16_t chn) const
+Session::audio_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.
@@ -3326,7 +3327,7 @@
 }
 
 boost::shared_ptr<MidiSource>
-Session::source_by_path (const std::string& path) const
+Session::midi_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.
@@ -3366,30 +3367,6 @@
 	return cnt;
 }
 
-/** Return the full path (in some session directory) for a new within-session source.
- * \a name must be a session-unique name that does not contain slashes
- *         (e.g. as returned by new_*_source_name)
- */
-string
-Session::new_source_path_from_name (DataType type, const string& name)
-{
-	assert(name.find("/") == string::npos);
-
-	SessionDirectory sdir(get_best_session_directory_for_new_source());
-
-	std::string p;
-	if (type == DataType::AUDIO) {
-		p = sdir.sound_path();
-	} else if (type == DataType::MIDI) {
-		p = sdir.midi_path();
-	} else {
-		error << "Unknown source type, unable to create file path" << endmsg;
-		return "";
-	}
-
-	return Glib::build_filename (p, name);
-}
-
 string
 Session::peak_path (string base) const
 {
@@ -3398,18 +3375,20 @@
 
 /** Return a unique name based on \a base for a new internal audio source */
 string
-Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
+Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
 {
 	uint32_t cnt;
-	char buf[PATH_MAX+1];
-	const uint32_t limit = 10000;
+	string possible_name;
+	const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
 	string legalized;
 	string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
+	bool some_related_source_name_exists = false;
 
-	buf[0] = '\0';
+	possible_name[0] = '\0';
 	legalized = legalize_for_path (base);
 
 	// Find a "version" of the base name that doesn't exist in any of the possible directories.
+
 	for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
 
 		vector<space_and_path>::iterator i;
@@ -3417,47 +3396,37 @@
 
 		for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
 
+			ostringstream sstr;
+
 			if (destructive) {
-
-				if (nchan < 2) {
-					snprintf (buf, sizeof(buf), "T%04d-%s%s",
-					          cnt, legalized.c_str(), ext.c_str());
-				} else if (nchan == 2) {
-					if (chan == 0) {
-						snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
-						          cnt, legalized.c_str(), ext.c_str());
-					} else {
-						snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
-						          cnt, legalized.c_str(), ext.c_str());
-					}
-				} else if (nchan < 26) {
-					snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
-					          cnt, legalized.c_str(), 'a' + chan, ext.c_str());
-				} else {
-					snprintf (buf, sizeof(buf), "T%04d-%s%s",
-					          cnt, legalized.c_str(), ext.c_str());
-				}
-
+				sstr << 'T';
+				sstr << setfill ('0') << setw (4) << cnt;
+				sstr << legalized;
 			} else {
-
-				if (nchan < 2) {
-					snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
-				} else if (nchan == 2) {
-					if (chan == 0) {
-						snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
-					} else {
-						snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
-					}
-				} else if (nchan < 26) {
-					snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
-				} else {
-					snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
+				sstr << legalized;
+				
+				if (take_required || some_related_source_name_exists) {
+					sstr << '-';
+					sstr << cnt;
 				}
 			}
-
+			
+			if (nchan == 2) {
+				if (chan == 0) {
+					sstr << "%L";
+				} else {
+					sstr << "%R";
+				}
+			} else if (nchan > 2 && nchan < 26) {
+				sstr << '%';
+				sstr << 'a' + chan;
+			} 
+
+			sstr << ext;
+
+			possible_name = sstr.str();
 			SessionDirectory sdir((*i).path);
-
-			string spath = sdir.sound_path();
+			const string spath = sdir.sound_path();
 
 			/* note that we search *without* the extension so that
 			   we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
@@ -3465,7 +3434,7 @@
 			   a file format change.
 			*/
 
-			if (matching_unsuffixed_filename_exists_in (spath, buf)) {
+			if (matching_unsuffixed_filename_exists_in (spath, possible_name)) {
 				existing++;
 				break;
 			}
@@ -3479,9 +3448,9 @@
 			 * notions of their removability.
 			 */
 
-			string possible_path = Glib::build_filename (spath, buf);
+			string possible_path = Glib::build_filename (spath, possible_name);
 
-			if (source_by_path (possible_path)) {
+			if (audio_source_by_path_and_channel (possible_path, chan)) {
 				existing++;
 				break;
 			}
@@ -3491,6 +3460,8 @@
 			break;
 		}
 
+		some_related_source_name_exists = true;
+
 		if (cnt > limit) {
 			error << string_compose(
 					_("There are already %1 recordings for %2, which I consider too many."),
@@ -3500,32 +3471,31 @@
 		}
 	}
 
-	return Glib::path_get_basename (buf);
-}
-
-/** Create a new within-session audio source */
-boost::shared_ptr<AudioFileSource>
-Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
-{
-	const string name    = new_audio_source_name (n, n_chans, chan, destructive);
-	const string path    = new_source_path_from_name(DataType::AUDIO, name);
-
-	return boost::dynamic_pointer_cast<AudioFileSource> (
-		SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
+	/* We've established that the new name does not exist in any session
+	 * directory, so now find out which one we should use for this new
+	 * audio source.
+	 */
+
+	SessionDirectory sdir (get_best_session_directory_for_new_audio());
+
+	std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
+
+	return s;
 }
 
 /** Return a unique name based on \a owner_name for a new internal MIDI source */
 string
-Session::new_midi_source_name (const string& owner_name)
+Session::new_midi_source_path (const string& base)
 {
 	uint32_t cnt;
 	char buf[PATH_MAX+1];
 	const uint32_t limit = 10000;
 	string legalized;
+	string possible_path;
 	string possible_name;
 
 	buf[0] = '\0';
-	legalized = legalize_for_path (owner_name);
+	legalized = legalize_for_path (base);
 
 	// Find a "version" of the file name that doesn't exist in any of the possible directories.
 
@@ -3533,7 +3503,7 @@
 
 		vector<space_and_path>::iterator i;
 		uint32_t existing = 0;
-
+		
 		for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
 
 			SessionDirectory sdir((*i).path);
@@ -3541,13 +3511,13 @@
 			snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
 			possible_name = buf;
 
-			std::string possible_path = Glib::build_filename (sdir.midi_path(), possible_name);
+			possible_path = Glib::build_filename (sdir.midi_path(), possible_name);
 			
 			if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
 				existing++;
 			}
 
-			if (source_by_path (possible_path)) {
+			if (midi_source_by_path (possible_path)) {
 				existing++;
 			}
 		}
@@ -3559,31 +3529,47 @@
 		if (cnt > limit) {
 			error << string_compose(
 					_("There are already %1 recordings for %2, which I consider too many."),
-					limit, owner_name) << endmsg;
+					limit, base) << endmsg;
 			destroy ();
-			throw failed_constructor();
+			return 0;
 		}
 	}
 
-	return possible_name;
-}
-
+	/* No need to "find best location" for software/app-based RAID, because
+	   MIDI is so small that we always put it in the same place.
+	*/
+
+	return possible_path;
+}
+
+
+/** Create a new within-session audio source */
+boost::shared_ptr<AudioFileSource>
+Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
+{
+	const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
+
+	if (!path.empty()) {
+		return boost::dynamic_pointer_cast<AudioFileSource> (
+			SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
+	} else {
+		throw failed_constructor ();
+	}
+}
 
 /** Create a new within-session MIDI source */
 boost::shared_ptr<MidiSource>
 Session::create_midi_source_for_session (string const & basic_name)
 {
-	std::string name;
-
-	if (name.empty()) {
-		name = new_midi_source_name (basic_name);
+	const string path = new_midi_source_path (basic_name);
+	
+	if (!path.empty()) {
+		return boost::dynamic_pointer_cast<SMFSource> (
+			SourceFactory::createWritable (
+				DataType::MIDI, *this, path, false, frame_rate()));
+	} else {
+		throw failed_constructor ();
 	}
-
-	const string path = new_source_path_from_name (DataType::MIDI, name);
-
-	return boost::dynamic_pointer_cast<SMFSource> (
-		SourceFactory::createWritable (
-			DataType::MIDI, *this, path, false, frame_rate()));
 }
 
 /** Create a new within-session MIDI source */
@@ -3617,7 +3603,13 @@
 		return boost::shared_ptr<MidiSource>();
 	}
 
-	const string path = new_source_path_from_name (DataType::MIDI, name);
+	/* MIDI files are small, just put them in the first location of the
+	   session source search path.
+	*/
+	vector<string> dirs;
+
+	split (source_search_path(DataType::MIDI), dirs, ':');
+	const string path = Glib::build_filename (dirs.front(), name);
 
 	return boost::dynamic_pointer_cast<SMFSource> (
 		SourceFactory::createWritable (
@@ -4123,18 +4115,13 @@
 	boost::shared_ptr<Region> result;
 	boost::shared_ptr<Playlist> playlist;
 	boost::shared_ptr<AudioFileSource> fsource;
-	uint32_t x;
-	char buf[PATH_MAX+1];
 	ChanCount diskstream_channels (track.n_channels());
 	framepos_t position;
 	framecnt_t this_chunk;
 	framepos_t to_do;
 	BufferSet buffers;
-	SessionDirectory sdir(get_best_session_directory_for_new_source ());
-	const string sound_dir = sdir.sound_path();
 	framepos_t len = end - start;
 	bool need_block_size_reset = false;
-	string ext;
 	ChanCount const max_proc = track.max_processor_streams ();
 
 	if (end <= start) {
@@ -4155,29 +4142,22 @@
 		goto out;
 	}
 
-	ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
-
 	for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
 
-		for (x = 0; x < 99999; ++x) {
-			snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 "%s", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1, ext.c_str());
-			if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
-				break;
-			}
-		}
-
-		if (x == 99999) {
-			error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
+		string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
+		string path = new_audio_source_path (base_name, diskstream_channels.n_audio(), chan_n, false, true);
+		
+		if (path.empty()) {
 			goto out;
 		}
 
 		try {
 			fsource = boost::dynamic_pointer_cast<AudioFileSource> (
-				SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
+				SourceFactory::createWritable (DataType::AUDIO, *this, path, false, frame_rate()));
 		}
 
 		catch (failed_constructor& err) {
-			error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
+			error << string_compose (_("cannot create new audio file \"%1\" for %2"), path, track.name()) << endmsg;
 			goto out;
 		}
 

=== modified file 'libs/ardour/session_state.cc'
--- libs/ardour/session_state.cc	2014-02-25 14:13:18 +0000
+++ libs/ardour/session_state.cc	2015-05-02 14:25:06 +0000
@@ -74,6 +74,7 @@
 #include "pbd/stacktrace.h"
 #include "pbd/convert.h"
 #include "pbd/clear_dir.h"
+#include "pbd/strsplit.h"
 
 #include "ardour/amp.h"
 #include "ardour/audio_diskstream.h"
@@ -1830,47 +1831,15 @@
 	return *node;
 }
 
-string
-Session::path_from_region_name (DataType type, string name, string identifier)
-{
-	char buf[PATH_MAX+1];
-	uint32_t n;
-	SessionDirectory sdir(get_best_session_directory_for_new_source());
-	std::string source_dir = ((type == DataType::AUDIO)
-		? sdir.sound_path() : sdir.midi_path());
-
-        string ext = native_header_format_extension (config.get_native_file_header_format(), type);
-
-	for (n = 0; n < 999999; ++n) {
-		if (identifier.length()) {
-			snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(),
-				  identifier.c_str(), n, ext.c_str());
-		} else {
-			snprintf (buf, sizeof(buf), "%s-%" PRIu32 "%s", name.c_str(),
-					n, ext.c_str());
-		}
-
-		std::string source_path = Glib::build_filename (source_dir, buf);
-
-		if (!Glib::file_test (source_path, Glib::FILE_TEST_EXISTS)) {
-			return source_path;
-		}
-	}
-
-	error << string_compose (_("cannot create new file from region name \"%1\" with ident = \"%2\": too many existing files with similar names"),
-				 name, identifier)
-	      << endmsg;
-
-	return "";
-}
-
-
 int
 Session::load_sources (const XMLNode& node)
 {
 	XMLNodeList nlist;
 	XMLNodeConstIterator niter;
-	boost::shared_ptr<Source> source;
+	boost::shared_ptr<Source> source; /* don't need this but it stops some
+					   * versions of gcc complaining about
+					   * discarded return values.
+					   */
 
 	nlist = node.children();
 
@@ -1887,9 +1856,15 @@
 
                         int user_choice;
 
+			if (err.type == DataType::MIDI && Glib::path_is_absolute (err.path)) {
+				error << string_compose (_("A external MIDI file is missing. %1 cannot currently recover from missing external MIDI files"),
+							 PROGRAM_NAME) << endmsg;
+				return -1;
+			}
+
                         if (!no_questions_about_missing_files) {
-                                user_choice = MissingFile (this, err.path, err.type).get_value_or (-1);
-                        } else {
+				user_choice = MissingFile (this, err.path, err.type).get_value_or (-1);
+			} else {
                                 user_choice = -2;
                         }
 
@@ -1914,8 +1889,41 @@
 
                         case -1:
                         default:
-                                warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
-                                source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
+				switch (err.type) {
+
+				case DataType::AUDIO:
+					source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
+					break;
+
+				case DataType::MIDI:
+					/* The MIDI file is actually missing so
+					 * just create a new one in the same
+					 * location. Do not announce its
+					 */
+					string fullpath;
+
+					if (!Glib::path_is_absolute (err.path)) {
+						vector<Glib::ustring> sdirs;
+						split (source_search_path (DataType::MIDI), sdirs, ':');
+						if (sdirs.empty()) {
+							fatal << _("Empty MIDI source search path!") << endmsg;
+							/*NOTREACHED*/
+						}
+						fullpath = Glib::build_filename (sdirs.front(), err.path);
+					} else {
+						/* this should be an unrecoverable error: we would be creating a MIDI file outside
+						   the session tree.
+						*/
+						return -1;
+					}
+					/* Note that we do not announce the source just yet - we need to reset its ID before we do that */
+					source = SourceFactory::createWritable (DataType::MIDI, *this, fullpath, false, _current_frame_rate, false, false);
+					/* reset ID to match the missing one */
+					source->set_id (**niter);
+					/* Now we can announce it */
+					SourceFactory::SourceCreated (source);
+					break;
+				}
                                 break;
                         }
 		}
@@ -2053,7 +2061,7 @@
 }
 
 string
-Session::get_best_session_directory_for_new_source ()
+Session::get_best_session_directory_for_new_audio ()
 {
 	vector<space_and_path>::iterator i;
 	string result = _session_dir->root_path();

=== modified file 'libs/ardour/smf_source.cc'
--- libs/ardour/smf_source.cc	2014-05-15 14:33:48 +0000
+++ libs/ardour/smf_source.cc	2015-05-02 14:25:06 +0000
@@ -71,6 +71,8 @@
         assert (!Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
 	existence_check ();
 
+	_flags = Source::Flag (_flags | Empty);
+
 	/* file is not opened until write */
 
 	if (flags & Writable) {
@@ -97,16 +99,15 @@
 {
 	/* note that origin remains empty */
 
-	if (init (_path, false)) {
+	if (init (_path, true)) {
 		throw failed_constructor ();
 	}
  
         assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
 	existence_check ();
 
-	/* file is not opened until write */
-
 	if (_flags & Writable) {
+		/* file is not opened until write */
 		return;
 	}
 
@@ -131,12 +132,50 @@
 		throw failed_constructor ();
 	}
 
-	if (init (_path, true)) {
-		throw failed_constructor ();
-	}
-
-        assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
-	existence_check ();
+	/* we expect the file to exist, but if no MIDI data was ever added
+	   it will have been removed at last session close. so, we don't
+	   require it to exist if it was marked Empty.
+	*/
+
+	try {
+
+		if (init (_path, true)) {
+			throw failed_constructor ();
+		}
+
+	} catch (MissingSource& err) {
+
+		if (_flags & Source::Empty) {
+			/* we don't care that the file was not found, because
+			   it was empty. But FileSource::init() will have
+			   failed to set our _path correctly, so we have to do
+			   this ourselves. Use the first entry in the search
+			   path for MIDI files, which is assumed to be the
+			   correct "main" location.
+			*/
+			std::vector<Glib::ustring> sdirs;
+			split (s.source_search_path (DataType::MIDI), sdirs, ':');
+			if (sdirs.empty()) {
+				fatal << _("Empty MIDI source search path!") << endmsg;
+				/*NOTREACHED*/
+			}
+			_path = Glib::build_filename (sdirs.front(), _path);
+			/* This might be important, too */
+			_file_is_new = true;
+		} else {
+			/* pass it on */
+			throw;
+		}
+	}
+
+	if (!(_flags & Source::Empty)) {
+		assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+		existence_check ();
+	} else {
+		assert (_flags & Source::Writable);
+		/* file will be opened on write */
+		return;
+	}
 
 	if (open(_path)) {
 		throw failed_constructor ();
@@ -354,10 +393,22 @@
                name().c_str(), ev.id(), ev.time(), ev.size());
 	       for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
 
-	if (ev.time() < _last_ev_time_beats) {
-		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
-		        << endmsg;
-		return;
+	double time = ev.time();
+	if (time < _last_ev_time_beats) {
+		const double difference = _last_ev_time_beats - time;
+		if (difference / (double)ppqn() < 1.0) {
+			/* Close enough.  This problem occurs because Sequence is not
+			   actually ordered due to fuzzy time comparison.  I'm pretty sure
+			   this is inherently a bad idea which causes problems all over the
+			   place, but tolerate it here for now anyway. */
+			time = _last_ev_time_beats;
+		} else {
+			/* Out of order by more than a tick. */
+			warning << string_compose(_("Skipping event with unordered beat time %1 < %2 (off by %3 beats, %4 ticks)"),
+			                          ev.time(), _last_ev_time_beats, difference, difference / (double)ppqn())
+			        << endmsg;
+			return;
+		}
 	}
 
 	Evoral::event_id_t event_id;
@@ -372,13 +423,14 @@
 		_model->append (ev, event_id);
 	}
 
-	_length_beats = max(_length_beats, ev.time());
+	_length_beats = max(_length_beats, time);
 
-	const double delta_time_beats   = ev.time() - _last_ev_time_beats;
+	const double delta_time_beats   = time - _last_ev_time_beats;
 	const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
 
 	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
-	_last_ev_time_beats = ev.time();
+	_last_ev_time_beats = time;
+	_flags = Source::Flag (_flags & ~Empty);
 }
 
 /** Append an event with a timestamp in frames (framepos_t) */
@@ -394,7 +446,8 @@
 	// for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");
 
 	if (ev.time() < _last_ev_time_frames) {
-		warning << string_compose(_("Skipping event with unordered time %1"), ev.time())
+		warning << string_compose(_("Skipping event with unordered frame time %1 < %2"),
+		                          ev.time(), _last_ev_time_frames)
 		        << endmsg;
 		return;
 	}
@@ -425,6 +478,7 @@
 
 	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
 	_last_ev_time_frames = ev.time();
+	_flags = Source::Flag (_flags & ~Empty);
 }
 
 XMLNode&
@@ -667,10 +721,12 @@
 void
 SMFSource::flush_midi ()
 {
-	if (!writable() || (writable() && !_open)) {
+	if (!writable() || _length_beats == 0.0) {
 		return;
 	}
 
+	ensure_disk_file ();
+
 	Evoral::SMF::end_write ();
 	/* data in the file means its no longer removable */
 	mark_nonremovable ();
@@ -687,6 +743,10 @@
 void
 SMFSource::ensure_disk_file ()
 {
+	if (!writable()) {
+		return;
+	}
+
 	if (_model) {
 		/* We have a model, so write it to disk; see MidiSource::session_saved
 		   for an explanation of what we are doing here.
@@ -702,9 +762,6 @@
 		if (!_open) {
 			open_for_write ();
 		}
-
-		/* Flush, which will definitely put something on disk */
-		flush_midi ();
 	}
 }
 
@@ -718,34 +775,3 @@
 	_flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
 }
 
-int
-SMFSource::rename (const string& newname)
-{
-	Glib::Threads::Mutex::Lock lm (_lock);
-	string oldpath = _path;
-	string newpath = _session.new_source_path_from_name (DataType::MIDI, newname);
-
-	if (newpath.empty()) {
-		error << string_compose (_("programming error: %1"), "cannot generate a changed file path") << endmsg;
-		return -1;
-	}
-
-	// Test whether newpath exists, if yes notify the user but continue.
-	if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
-		error << string_compose (_("Programming error! %1 tried to rename a file over another file! It's safe to continue working, but please report this to the developers."), PROGRAM_NAME) << endmsg;
-		return -1;
-	}
-
-	if (Glib::file_test (oldpath.c_str(), Glib::FILE_TEST_EXISTS)) { 
-		/* rename only needed if file exists on disk */
-		if (::rename (oldpath.c_str(), newpath.c_str()) != 0) {
-			error << string_compose (_("cannot rename file %1 to %2 (%3)"), oldpath, newpath, strerror(errno)) << endmsg;
-			return -1;
-		}
-	}
-
-	_name = Glib::path_get_basename (newpath);
-	_path = newpath;
-
-	return 0;
-}

=== modified file 'libs/ardour/sndfilesource.cc'
--- libs/ardour/sndfilesource.cc	2014-05-15 14:33:48 +0000
+++ libs/ardour/sndfilesource.cc	2015-05-02 14:25:06 +0000
@@ -183,6 +183,34 @@
 	}
 }
 
+/** Constructor to be called for recovering files being used for
+ * capture. They are in-session, they already exist, they should not
+ * be writable. They are an odd hybrid (from a constructor point of
+ * view) of the previous two constructors.
+ */
+SndFileSource::SndFileSource (Session& s, const string& path, int chn)
+	: Source (s, DataType::AUDIO, path, Flag (0))
+	  /* the final boolean argument is not used, its value is irrelevant. see audiofilesource.h for explanation */
+	, AudioFileSource (s, path, Flag (0))
+	, _descriptor (0)
+	, _broadcast_info (0)
+	, _capture_start (false)
+	, _capture_end (false)
+	, file_pos (0)
+	, xfade_buf (0)
+{
+	_channel = chn;
+
+	init_sndfile ();
+
+        assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
+	existence_check ();
+
+	if (open()) {
+		throw failed_constructor ();
+	}
+}
+
 void
 SndFileSource::init_sndfile ()
 {
@@ -256,6 +284,14 @@
 		delete _broadcast_info;
 		_broadcast_info = 0;
 		_flags = Flag (_flags & ~Broadcast);
+	} 
+
+	/* Set the broadcast flag if the BWF info is already there. We need
+	 * this when recovering or using existing files.
+	 */
+	
+	if (bwf_info_exists) {
+		_flags = Flag (_flags | Broadcast);
 	}
 
 	if (writable()) {

=== modified file 'libs/ardour/source_factory.cc'
--- libs/ardour/source_factory.cc	2014-05-15 14:33:48 +0000
+++ libs/ardour/source_factory.cc	2015-05-02 14:25:06 +0000
@@ -342,6 +342,39 @@
 }
 
 boost::shared_ptr<Source>
+SourceFactory::createForRecovery (DataType type, Session& s, const std::string& path, int chn)
+{
+	/* this might throw failed_constructor(), which is OK */
+
+	if (type == DataType::AUDIO) {
+		Source* src = new SndFileSource (s, path, chn);
+
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+		// boost_debug_shared_ptr_mark_interesting (src, "Source");
+#endif
+		boost::shared_ptr<Source> ret (src);
+
+		if (setup_peakfile (ret, false)) {
+			return boost::shared_ptr<Source>();
+		}
+
+		// no analysis data - this is still basically a new file (we
+		// crashed while recording.
+
+		// always announce these files
+
+		SourceCreated (ret);
+
+		return ret;
+
+	} else if (type == DataType::MIDI) {
+		error << _("Recovery attempted on a MIDI file - not implemented") << endmsg;
+	}
+
+	return boost::shared_ptr<Source> ();
+}
+
+boost::shared_ptr<Source>
 SourceFactory::createFromPlaylist (DataType type, Session& s, boost::shared_ptr<Playlist> p, const PBD::ID& orig, const std::string& name,
 				   uint32_t chn, frameoffset_t start, framecnt_t len, bool copy, bool defer_peaks)
 {

=== modified file 'libs/ardour/tempo.cc'
--- libs/ardour/tempo.cc	2013-09-21 19:05:02 +0000
+++ libs/ardour/tempo.cc	2015-05-02 14:25:06 +0000
@@ -884,6 +884,7 @@
 	TempoSection* ts;
 	MeterSection* ms;
 	double beat_frames;
+	double current_frame_exact;
 	framepos_t bar_start_frame;
 
 	DEBUG_TRACE (DEBUG::TempoMath, string_compose ("Extend map to %1 from %2 = %3\n", end, current, current_frame));
@@ -895,11 +896,13 @@
 	}
 
 	beat_frames = meter->frames_per_grid (*tempo,_frame_rate);
+	current_frame_exact = current_frame;
 
 	while (current_frame < end) {
 
 		current.beats++;
-		current_frame += beat_frames;
+		current_frame_exact += beat_frames;
+		current_frame = llrint(current_frame_exact);
 
 		if (current.beats > meter->divisions_per_bar()) {
 			current.bars++;
@@ -942,7 +945,8 @@
 						                                               tempo->start(), current_frame, tempo->bar_offset()));
 						
 						/* back up to previous beat */
-						current_frame -= beat_frames;
+						current_frame_exact -= beat_frames;
+						current_frame = llrint(current_frame_exact);
 
 						/* set tempo section location
 						 * based on offset from last
@@ -963,7 +967,8 @@
 
 						double offset_within_old_beat = (tempo->frame() - current_frame) / beat_frames;
 
-						current_frame += (offset_within_old_beat * beat_frames) + ((1.0 - offset_within_old_beat) * next_beat_frames);
+						current_frame_exact += (offset_within_old_beat * beat_frames) + ((1.0 - offset_within_old_beat) * next_beat_frames);
+						current_frame = llrint(current_frame_exact);
 
 						/* next metric doesn't have to
 						 * match this precisely to
@@ -1012,11 +1017,11 @@
 
 		if (current.beats == 1) {
 			DEBUG_TRACE (DEBUG::TempoMath, string_compose ("Add Bar at %1|1 @ %2\n", current.bars, current_frame));
-			_map.push_back (BBTPoint (*meter, *tempo,(framepos_t) llrint(current_frame), current.bars, 1));
+			_map.push_back (BBTPoint (*meter, *tempo, current_frame, current.bars, 1));
 			bar_start_frame = current_frame;
 		} else {
 			DEBUG_TRACE (DEBUG::TempoMath, string_compose ("Add Beat at %1|%2 @ %3\n", current.bars, current.beats, current_frame));
-			_map.push_back (BBTPoint (*meter, *tempo, (framepos_t) llrint(current_frame), current.bars, current.beats));
+			_map.push_back (BBTPoint (*meter, *tempo, current_frame, current.bars, current.beats));
 		}
 
 		if (next_metric == metrics.end()) {

=== modified file 'libs/midi++2/midnam_patch.cc'
--- libs/midi++2/midnam_patch.cc	2014-01-24 16:31:54 +0000
+++ libs/midi++2/midnam_patch.cc	2015-05-02 14:25:06 +0000
@@ -724,14 +724,13 @@
 		return "";
 	}
 
+	boost::shared_ptr<const NoteNameList> note_names;
 	boost::shared_ptr<const Patch> patch(
 		find_patch(mode_name, channel, PatchPrimaryKey(program, bank)));
-	if (!patch) {
-		return "";
+	if (patch) {
+		note_names = note_name_list(patch->note_list_name());
 	}
 
-	boost::shared_ptr<const NoteNameList> note_names(
-		note_name_list(patch->note_list_name()));
 	if (!note_names) {
 		/* No note names specific to this patch, check the ChannelNameSet */
 		boost::shared_ptr<ChannelNameSet> chan_names = channel_name_set_by_channel(

=== added file 'patchfiles/Korg_Volca_Bass.midnam'
--- patchfiles/Korg_Volca_Bass.midnam	1970-01-01 00:00:00 +0000
+++ patchfiles/Korg_Volca_Bass.midnam	2015-05-02 14:25:06 +0000
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE MIDINameDocument PUBLIC "-//MIDI Manufacturers Association//DTD MIDINameDocument 1.0//EN" "http://www.midi.org/dtds/MIDINameDocument10.dtd">
+<MIDINameDocument>
+  <Author>David Robillard</Author>
+  <MasterDeviceNames>
+    <Manufacturer>Korg</Manufacturer>
+    <Model>Volca Bass</Model>
+    <CustomDeviceMode Name="Default">
+      <ChannelNameSetAssignments>
+        <ChannelNameSetAssign Channel="1" NameSet="Names"/>
+      </ChannelNameSetAssignments>
+    </CustomDeviceMode>
+    <ChannelNameSet Name="Names">
+      <AvailableForChannels>
+        <AvailableChannel Channel="1" Available="true"/>
+      </AvailableForChannels>
+      <UsesControlNameList Name="Controls"/>
+      <PatchBank Name="User Patches">
+        <PatchNameList Name="User Patches"/>
+      </PatchBank>
+    </ChannelNameSet>
+    <ControlNameList Name="Controls">
+      <Control Type="7bit" Number="5" Name="Slide Time"/>
+      <Control Type="7bit" Number="11" Name="Expression"/>
+      <Control Type="7bit" Number="40" Name="Octave"/>
+      <Control Type="7bit" Number="41" Name="LFO Rate"/>
+      <Control Type="7bit" Number="42" Name="LFO Int"/>
+      <Control Type="7bit" Number="43" Name="VCO Pitch 1"/>
+      <Control Type="7bit" Number="44" Name="VCO Pitch 2"/>
+      <Control Type="7bit" Number="45" Name="VCO Pitch 3"/>
+      <Control Type="7bit" Number="46" Name="EG Attack"/>
+      <Control Type="7bit" Number="47" Name="EG Decay/Release"/>
+      <Control Type="7bit" Number="48" Name="Cutoff EG Int"/>
+      <Control Type="7bit" Number="49" Name="Gate Time"/>
+    </ControlNameList>
+  </MasterDeviceNames>
+</MIDINameDocument>

=== added file 'patchfiles/Korg_Volca_Beats.midnam'
--- patchfiles/Korg_Volca_Beats.midnam	1970-01-01 00:00:00 +0000
+++ patchfiles/Korg_Volca_Beats.midnam	2015-05-02 14:25:06 +0000
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE MIDINameDocument PUBLIC "-//MIDI Manufacturers Association//DTD MIDINameDocument 1.0//EN" "http://www.midi.org/dtds/MIDINameDocument10.dtd">
+<MIDINameDocument>
+  <Author>David Robillard</Author>
+  <MasterDeviceNames>
+    <Manufacturer>Korg</Manufacturer>
+    <Model>Volca Beats</Model>
+    <CustomDeviceMode Name="Default">
+      <ChannelNameSetAssignments>
+        <ChannelNameSetAssign Channel="10" NameSet="Names"/>
+      </ChannelNameSetAssignments>
+    </CustomDeviceMode>
+    <ChannelNameSet Name="Names">
+      <AvailableForChannels>
+        <AvailableChannel Channel="10" Available="true"/>
+      </AvailableForChannels>
+      <UsesNoteNameList Name="Notes"/>
+      <UsesControlNameList Name="Controls"/>
+      <PatchBank Name="User Patches">
+        <PatchNameList Name="User Patches"/>
+      </PatchBank>
+    </ChannelNameSet>
+    <NoteNameList Name="Notes">
+      <Note Number="37" Name="Kick"/>
+      <Note Number="39" Name="Snare"/>
+      <Note Number="40" Name="Clap"/>
+      <Note Number="43" Name="Closed Hi-hat"/>
+      <Note Number="44" Name="Low Tom"/>
+      <Note Number="47" Name="Open Hi-hat"/>
+      <Note Number="50" Name="Crash Cymbal"/>
+      <Note Number="51" Name="High Tom"/>
+      <Note Number="68" Name="Agogô"/>
+      <Note Number="76" Name="Claves"/>
+    </NoteNameList>
+    <ControlNameList Name="Controls">
+      <Control Type="7bit" Number="40" Name="Kick Level"/>
+      <Control Type="7bit" Number="41" Name="Snare Level"/>
+      <Control Type="7bit" Number="42" Name="Low Tom Level"/>
+      <Control Type="7bit" Number="43" Name="High Tom Level"/>
+      <Control Type="7bit" Number="44" Name="Closed Hat Level"/>
+      <Control Type="7bit" Number="45" Name="Open Hat Level"/>
+      <Control Type="7bit" Number="46" Name="Clap Level"/>
+      <Control Type="7bit" Number="47" Name="Claves Level"/>
+      <Control Type="7bit" Number="48" Name="Agogo Level"/>
+      <Control Type="7bit" Number="49" Name="Crash Level"/>
+      <Control Type="7bit" Number="50" Name="Clap PCM Speed"/>
+      <Control Type="7bit" Number="51" Name="Claves PCM Speed"/>
+      <Control Type="7bit" Number="52" Name="Agogo PCM Speed"/>
+      <Control Type="7bit" Number="53" Name="Crash PCM Speed"/>
+      <Control Type="7bit" Number="54" Name="Stutter Time"/>
+      <Control Type="7bit" Number="55" Name="Stutter Depth"/>
+      <Control Type="7bit" Number="56" Name="Tom Decay"/>
+      <Control Type="7bit" Number="57" Name="Closed Hat Decay"/>
+      <Control Type="7bit" Number="58" Name="Open Hat Decay"/>
+      <Control Type="7bit" Number="59" Name="Hat Grain"/>
+    </ControlNameList>
+  </MasterDeviceNames>
+</MIDINameDocument>

=== added file 'patchfiles/Korg_Volca_Keys.midnam'
--- patchfiles/Korg_Volca_Keys.midnam	1970-01-01 00:00:00 +0000
+++ patchfiles/Korg_Volca_Keys.midnam	2015-05-02 14:25:06 +0000
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE MIDINameDocument PUBLIC "-//MIDI Manufacturers Association//DTD MIDINameDocument 1.0//EN" "http://www.midi.org/dtds/MIDINameDocument10.dtd">
+<MIDINameDocument>
+  <Author>David Robillard</Author>
+  <MasterDeviceNames>
+    <Manufacturer>Korg</Manufacturer>
+    <Model>Volca Keys</Model>
+    <CustomDeviceMode Name="Default">
+      <ChannelNameSetAssignments>
+        <ChannelNameSetAssign Channel="1" NameSet="Names"/>
+      </ChannelNameSetAssignments>
+    </CustomDeviceMode>
+    <ChannelNameSet Name="Names">
+      <AvailableForChannels>
+        <AvailableChannel Channel="1" Available="true"/>
+      </AvailableForChannels>
+      <UsesControlNameList Name="Controls"/>
+      <PatchBank Name="User Patches">
+        <PatchNameList Name="User Patches"/>
+      </PatchBank>
+    </ChannelNameSet>
+    <ControlNameList Name="Controls">
+      <Control Type="7bit" Number="5" Name="Portamento"/>
+      <Control Type="7bit" Number="11" Name="Expression"/>
+      <Control Type="7bit" Number="40" Name="Voice"/>
+      <Control Type="7bit" Number="41" Name="Octave"/>
+      <Control Type="7bit" Number="42" Name="Detune"/>
+      <Control Type="7bit" Number="43" Name="VCO EG Int"/>
+      <Control Type="7bit" Number="44" Name="Cutoff"/>
+      <Control Type="7bit" Number="45" Name="VCF EG Int"/>
+      <Control Type="7bit" Number="46" Name="LFO Rate"/>
+      <Control Type="7bit" Number="47" Name="LFO Pitch Int"/>
+      <Control Type="7bit" Number="48" Name="LFO Cutoff Int"/>
+      <Control Type="7bit" Number="49" Name="EG Attack"/>
+      <Control Type="7bit" Number="50" Name="EG Decay/Release"/>
+      <Control Type="7bit" Number="51" Name="EG Sustain"/>
+      <Control Type="7bit" Number="52" Name="Delay Time"/>
+      <Control Type="7bit" Number="53" Name="Delay Feedback"/>
+    </ControlNameList>
+  </MasterDeviceNames>
+</MIDINameDocument>