X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_audio_import.cc;h=119ea3bc5127f337887da759a03aa0646b8c1c15;hb=061a85191c301ac18f2e8ca59d43127a4499ba96;hp=6254cadab673c7f6998c519c36ce89c5cd5a3882;hpb=40937e619fd962bda85dc73cbce2b9820c956ed8;p=ardour.git

diff --git a/gtk2_ardour/editor_audio_import.cc b/gtk2_ardour/editor_audio_import.cc
index 6254cadab6..119ea3bc51 100644
--- a/gtk2_ardour/editor_audio_import.cc
+++ b/gtk2_ardour/editor_audio_import.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000-2006 Paul Davis 
+    Copyright (C) 2000-2006 Paul Davis
 
     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
@@ -19,42 +19,52 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/time.h>
 #include <errno.h>
 #include <unistd.h>
+#include <algorithm>
 
-#include <pbd/pthread_utils.h>
-#include <pbd/basename.h>
-#include <pbd/shortpath.h>
+#include <sndfile.h>
+
+#include "pbd/pthread_utils.h"
+#include "pbd/basename.h"
+#include "pbd/shortpath.h"
+#include "pbd/stateful_diff_command.h"
 
 #include <gtkmm2ext/choice.h>
-#include <gtkmm2ext/window_title.h>
-
-#include <ardour/session.h>
-#include <ardour/session_directory.h>
-#include <ardour/audioplaylist.h>
-#include <ardour/audioregion.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/utils.h>
-#include <ardour/audio_track.h>
-#include <ardour/audioplaylist.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/region_factory.h>
-#include <ardour/source_factory.h>
-#include <pbd/memento_command.h>
+
+#include "ardour/session.h"
+#include "ardour/session_directory.h"
+#include "ardour/audioplaylist.h"
+#include "ardour/audioregion.h"
+#include "ardour/audio_diskstream.h"
+#include "ardour/midi_track.h"
+#include "ardour/midi_region.h"
+#include "ardour/utils.h"
+#include "ardour/audio_track.h"
+#include "ardour/audioplaylist.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/region_factory.h"
+#include "ardour/source_factory.h"
+#include "ardour/session.h"
+#include "pbd/memento_command.h"
 
 #include "ardour_ui.h"
 #include "editor.h"
 #include "sfdb_ui.h"
 #include "editing.h"
 #include "audio_time_axis.h"
+#include "midi_time_axis.h"
+#include "session_import_dialog.h"
 #include "utils.h"
+#include "gui_thread.h"
+#include "interthread_progress_window.h"
 
 #include "i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
-using namespace sigc;
 using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace Editing;
@@ -63,296 +73,557 @@ using Glib::ustring;
 /* Functions supporting the incorporation of external (non-captured) audio material into ardour */
 
 void
-Editor::add_external_audio_action (ImportMode mode)
+Editor::add_external_audio_action (ImportMode mode_hint)
 {
-	nframes_t& pos = edit_cursor->current_frame;
-	boost::shared_ptr<AudioTrack> track;
-
-	if (!selection->tracks.empty()) {
-		AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(selection->tracks.front());
-		if (atv) {
-			track = atv->audio_track();
-		}
+	if (_session == 0) {
+		MessageDialog msg (_("You can't import or embed an audiofile until you have a session loaded."));
+		msg.run ();
+		return;
+	}
+	
+	if (sfbrowser == 0) {
+		sfbrowser = new SoundFileOmega (*this, _("Add Existing Media"), _session, 0, true, mode_hint);
+	} else {
+		sfbrowser->set_mode (mode_hint);
 	}
 
-	bring_in_external_audio (mode, track.get(), pos, false);
+	external_audio_dialog ();
 }
 
 void
-Editor::bring_in_external_audio (ImportMode mode, AudioTrack* track, nframes_t& pos, bool prompt)
+Editor::external_audio_dialog ()
 {
-	if (session == 0) {
-		MessageDialog msg (0, _("You can't import or embed an audiofile until you have a session loaded."));
+	vector<Glib::ustring> paths;
+	uint32_t track_cnt;
+
+	if (_session == 0) {
+		MessageDialog msg (_("You can't import or embed an audiofile until you have a session loaded."));
 		msg.run ();
 		return;
 	}
 
-	SoundFileOmega sfdb (_("Add existing audio to session"), session);
-	sfdb.set_mode (mode);
+	track_cnt = 0;
 
-	switch (sfdb.run()) {
-	case SoundFileOmega::ResponseImport:
-		do_import (sfdb.get_paths(), sfdb.get_split(), sfdb.get_mode(), track, pos, prompt);
-		break;
-		
-	case SoundFileOmega::ResponseEmbed:
-		do_embed (sfdb.get_paths(), sfdb.get_split(), sfdb.get_mode(), track, pos, prompt);
-		break;
+	for (TrackSelection::iterator x = selection->tracks.begin(); x != selection->tracks.end(); ++x) {
+		AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(*x);
 
-	default:
-		break;
+		if (!atv) {
+			continue;
+		} else if (atv->is_audio_track()) {
+			track_cnt++;
+		}
 	}
+
+	if (sfbrowser == 0) {
+		sfbrowser = new SoundFileOmega (*this, _("Add Existing Media"), _session, track_cnt, true);
+	} else {
+		sfbrowser->reset (track_cnt);
+	}
+
+	sfbrowser->show_all ();
+
+
+	bool keepRunning;
+
+	do {
+		keepRunning = false;
+
+		int response = sfbrowser->run ();
+
+		switch (response) {
+			case RESPONSE_APPLY:
+				// leave the dialog open
+				break;
+
+			case RESPONSE_OK:
+				sfbrowser->hide ();
+				break;
+
+			default:
+				// cancel from the browser - we are done
+				sfbrowser->hide ();
+				return;
+		}
+
+		/* lets do it */
+
+		paths = sfbrowser->get_paths ();
+
+		ImportPosition pos = sfbrowser->get_position ();
+		ImportMode mode = sfbrowser->get_mode ();
+		ImportDisposition chns = sfbrowser->get_channel_disposition ();
+		nframes64_t where;
+
+		switch (pos) {
+			case ImportAtEditPoint:
+				where = get_preferred_edit_position ();
+				break;
+			case ImportAtTimestamp:
+				where = -1;
+				break;
+			case ImportAtPlayhead:
+				where = playhead_cursor->current_frame;
+				break;
+			case ImportAtStart:
+				where = _session->current_start_frame();
+				break;
+		}
+
+		SrcQuality quality = sfbrowser->get_src_quality();
+
+
+		if (sfbrowser->copy_files_btn.get_active()) {
+			do_import (paths, chns, mode, quality, where);
+		} else {
+			do_embed (paths, chns, mode, where);
+		}
+
+		if (response == RESPONSE_APPLY) {
+			sfbrowser->clear_selection ();
+			keepRunning = true;
+		}
+
+	} while (keepRunning);
 }
 
 void
-Editor::do_import (vector<ustring> paths, bool split, ImportMode mode, AudioTrack* track, nframes_t& pos, bool prompt)
+Editor::session_import_dialog ()
 {
-	/* SFDB sets "multichan" to true to indicate "split channels"
-	   so reverse the setting to match the way libardour
-	   interprets it.
-	*/
-	
-	import_status.multichan = !split;
+	SessionImportDialog dialog (_session);
+	ensure_float (dialog);
+	dialog.run ();
+}
 
-	if (interthread_progress_window == 0) {
-		build_interthread_progress_window ();
+typedef std::map<PBD::ID,boost::shared_ptr<ARDOUR::Source> > SourceMap;
+
+/**
+ * Updating is still disabled, see note in libs/ardour/import.cc Session::import_audiofiles()
+ *
+ * all_or_nothing:
+ *   true  = show "Update", "Import" and "Skip"
+ *   false = show "Import", and "Cancel"
+ *
+ * Returns:
+ *     0  To update an existing source of the same name
+ *     1  To import/embed the file normally (make sure the new name will be unique)
+ *     2  If the user wants to skip this file
+ **/
+int
+Editor::check_whether_and_how_to_import(string path, bool all_or_nothing)
+{
+	string wave_name (Glib::path_get_basename(path));
+
+	SourceMap all_sources = _session->get_sources();
+	bool wave_name_exists = false;
+
+	for (SourceMap::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
+		string tmp (Glib::path_get_basename (i->second->path()));
+		if (tmp == wave_name) {
+			wave_name_exists = true;
+			break;
+		}
 	}
 
-	vector<ustring> to_import;
+	int function = 1;
 
-	for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+	if (wave_name_exists) {
+		string message;
+		if (all_or_nothing) {
+			// updating is still disabled
+			//message = string_compose(_("The session already contains a source file named %1. Do you want to update that file (and thus all regions using the file) or import this file as a new file?"),wave_name);
+			message = string_compose (_("The session already contains a source file named %1.  Do you want to import %1 as a new file, or skip it?"), wave_name);
+		} else {
+			message = string_compose (_("The session already contains a source file named %1.  Do you want to import %2 as a new source, or skip it?"), wave_name, wave_name);
 
-		to_import.clear ();
-		to_import.push_back (*a);
+		}
+		MessageDialog dialog(message, false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE, true);
 
-		import_sndfile (to_import, mode, track, pos);
+		if (all_or_nothing) {
+			// disabled
+			//dialog.add_button("Update", 0);
+			dialog.add_button("Import", 1);
+			dialog.add_button("Skip",   2);
+		} else {
+			dialog.add_button("Import", 1);
+			dialog.add_button("Cancel", 2);
+		}
+
+		//dialog.add_button("Skip all", 4); // All or rest?
+
+		dialog.show();
+
+		function = dialog.run ();
+
+		dialog.hide();
 	}
 
-	interthread_progress_window->hide_all ();
+	return function;
 }
 
-void
-Editor::do_embed (vector<ustring> paths, bool split, ImportMode mode, AudioTrack* track, nframes_t& pos, bool prompt)
+boost::shared_ptr<AudioTrack>
+Editor::get_nth_selected_audio_track (int nth) const
 {
-	bool multiple_files = paths.size() > 1;
-	bool check_sample_rate = true;
-	vector<ustring>::iterator a;
+	AudioTimeAxisView* atv;
+	TrackSelection::iterator x;
 
-	for (a = paths.begin(); a != paths.end(); ) {
+	for (x = selection->tracks.begin(); nth > 0 && x != selection->tracks.end(); ++x) {
 
-		cerr << "Considering embed of " << (*a) << endl;
-	
-		Glib::ustring path = *a;
-		Glib::ustring pair_base;
-		vector<ustring> to_embed;
+		atv = dynamic_cast<AudioTimeAxisView*>(*x);
 
-		to_embed.push_back (path);
-		a = paths.erase (a);
+		if (!atv) {
+			continue;
+		} else if (atv->is_audio_track()) {
+			--nth;
+		}
+	}
 
-		if (path_is_paired (path, pair_base)) {
+	if (x == selection->tracks.end()) {
+		atv = dynamic_cast<AudioTimeAxisView*>(selection->tracks.back());
+	} else {
+		atv = dynamic_cast<AudioTimeAxisView*>(*x);
+	}
 
-			ustring::size_type len = pair_base.length();
+	if (!atv || !atv->is_audio_track()) {
+		return boost::shared_ptr<AudioTrack>();
+	}
 
-			for (vector<Glib::ustring>::iterator b = paths.begin(); b != paths.end(); ) {
+	return atv->audio_track();
+}
 
-				if (((*b).substr (0, len) == pair_base) && ((*b).length() == path.length())) {
+boost::shared_ptr<MidiTrack>
+Editor::get_nth_selected_midi_track (int nth) const
+{
+	MidiTimeAxisView* mtv;
+	TrackSelection::iterator x;
 
-					to_embed.push_back (*b);
-						
-					/* don't process this one again */
+	for (x = selection->tracks.begin(); nth > 0 && x != selection->tracks.end(); ++x) {
 
-					b = paths.erase (b);
-					break;
+		mtv = dynamic_cast<MidiTimeAxisView*>(*x);
 
-				} else {
-					++b;
-				}
+		if (!mtv) {
+			continue;
+		} else if (mtv->is_midi_track()) {
+			--nth;
+		}
+	}
+
+	if (x == selection->tracks.end()) {
+		mtv = dynamic_cast<MidiTimeAxisView*>(selection->tracks.back());
+	} else {
+		mtv = dynamic_cast<MidiTimeAxisView*>(*x);
+	}
+
+	if (!mtv || !mtv->is_midi_track()) {
+		return boost::shared_ptr<MidiTrack>();
+	}
+
+	return mtv->midi_track();
+}
+
+void
+Editor::do_import (vector<ustring> paths, ImportDisposition chns, ImportMode mode, SrcQuality quality, nframes64_t& pos)
+{
+	boost::shared_ptr<Track> track;
+	vector<ustring> to_import;
+	int nth = 0;
+
+	current_interthread_info = &import_status;
+	import_status.current = 1;
+	import_status.total = paths.size ();
+
+	ImportProgressWindow ipw (&import_status, _("Import"), _("Cancel Import"));
+
+	if (chns == Editing::ImportMergeFiles) {
+
+		/* create 1 region from all paths, add to 1 track,
+		   ignore "track"
+		*/
+
+		bool cancel = false;
+		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+			int check = check_whether_and_how_to_import(*a, false);
+			if (check == 2) {
+				cancel = true;
+				break;
 			}
 		}
 
-		if (to_embed.size() > 1) {
+		if (!cancel) {
+			import_sndfiles (paths, mode, quality, pos, 1, 1, track, false);
+		}
 
-			vector<string> choices;
+	} else {
 
-			choices.push_back (string_compose (_("Import as a %1 region"),
-							   to_embed.size() > 2 ? _("multichannel") : _("stereo")));
-			choices.push_back (_("Import as multiple regions"));
-			
-			Choice chooser (string_compose (_("Paired files detected (%1, %2 ...).\nDo you want to:"),
-								   to_embed[0],
-								   to_embed[1]),
-						   choices);
+                bool replace = false;
+		bool ok = true;
+
+		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+
+                        const int check = check_whether_and_how_to_import (*a, true);
+                        
+			switch (check) {
+			case 2:
+				// user said skip
+				continue;
+			case 0:
+				fatal << "Updating existing sources should be disabled!" << endmsg;
+				/* NOTREACHED*/
+				break;
+			case 1:
+				replace = false;
+				break;
+			default:
+				fatal << "Illegal return " << check <<  " from check_whether_and_how_to_import()!" << endmsg;
+				/* NOTREACHED*/
+			}
+
+                        switch (chns) {
+                        case Editing::ImportDistinctFiles:
+                                
+                                to_import.clear ();
+                                to_import.push_back (*a);
+                                
+                                if (mode == Editing::ImportToTrack) {
+                                        track = get_nth_selected_audio_track (nth++);
+                                }
 			
-			if (chooser.run () == 0) {
+                                ok = (import_sndfiles (to_import, mode, quality, pos, 1, -1, track, replace) == 0);
+                                break;
+				
+                        case Editing::ImportDistinctChannels:
+				
+                                to_import.clear ();
+                                to_import.push_back (*a);
 				
-				/* keep them paired */
+                                ok = (import_sndfiles (to_import, mode, quality, pos, -1, -1, track, replace) == 0);
+                                break;
+				
+                        case Editing::ImportSerializeFiles:
+				
+                                to_import.clear ();
+                                to_import.push_back (*a);
 
-				if (embed_sndfile (to_embed, split, multiple_files, check_sample_rate, mode, track, pos, prompt) < -1) {
-					break;
-				}
+                                ok = (import_sndfiles (to_import, mode, quality, pos, 1, 1, track, replace) == 0);
+                                break;
 
-			} else {
+                        case Editing::ImportMergeFiles:
+                                // Not entered, handled in earlier if() branch
+                                break;
+                        }
+                }
+	}
+}
 
-				/* one thing per file */
+void
+Editor::do_embed (vector<ustring> paths, ImportDisposition chns, ImportMode mode, nframes64_t& pos)
+{
+	boost::shared_ptr<Track> track;
+	bool check_sample_rate = true;
+	bool ok = false;
+	vector<ustring> to_embed;
+	bool multi = paths.size() > 1;
+	int nth = 0;
 
-				vector<ustring> foo;
+	switch (chns) {
+	case Editing::ImportDistinctFiles:
+		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
 
-				for (vector<ustring>::iterator x = to_embed.begin(); x != to_embed.end(); ++x) {
+			to_embed.clear ();
+			to_embed.push_back (*a);
 
-					foo.clear ();
-					foo.push_back (*x);
+			if (mode == Editing::ImportToTrack) {
+				track = get_nth_selected_audio_track (nth++);
+			}
 
-					if (embed_sndfile (foo, split, multiple_files, check_sample_rate, mode, track, pos, prompt) < -1) {
-						break;
-					}
-				}
+			if (embed_sndfiles (to_embed, multi, check_sample_rate, mode, pos, 1, -1, track) < -1) {
+				goto out;
 			}
+		}
+		break;
 
-		} else {
-			
-			if (embed_sndfile (to_embed, split, multiple_files, check_sample_rate, mode, track, pos, prompt) < -1) {
-				break;
+	case Editing::ImportDistinctChannels:
+		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+
+			to_embed.clear ();
+			to_embed.push_back (*a);
+
+			if (embed_sndfiles (to_embed, multi, check_sample_rate, mode, pos, -1, -1, track) < -1) {
+				goto out;
+			}
+		}
+		break;
+
+	case Editing::ImportMergeFiles:
+		if (embed_sndfiles (paths, multi, check_sample_rate, mode, pos, 1, 1, track) < -1) {
+			goto out;
+		}
+                break;
+
+	case Editing::ImportSerializeFiles:
+		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+
+			to_embed.clear ();
+			to_embed.push_back (*a);
+
+			if (embed_sndfiles (to_embed, multi, check_sample_rate, mode, pos, 1, 1, track) < -1) {
+				goto out;
 			}
 		}
+		break;
 	}
-	
-	if (a == paths.end()) {
-		session->save_state ("");
+
+	ok = true;
+
+  out:
+	if (ok) {
+		_session->save_state ("");
 	}
 }
 
 int
-Editor::import_sndfile (vector<ustring> paths, ImportMode mode, AudioTrack* track, nframes_t& pos)
+Editor::import_sndfiles (vector<ustring> paths, ImportMode mode, SrcQuality quality, nframes64_t& pos,
+			 int target_regions, int target_tracks, boost::shared_ptr<Track>& track, bool replace)
 {
-	WindowTitle title = string_compose (_("importing %1"), paths.front());
-
-	interthread_progress_window->set_title (title.get_string());
-	interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
-	interthread_progress_window->show_all ();
-	interthread_progress_bar.set_fraction (0.0f);
-	interthread_cancel_label.set_text (_("Cancel Import"));
-	current_interthread_info = &import_status;
-
 	import_status.paths = paths;
 	import_status.done = false;
 	import_status.cancel = false;
 	import_status.freeze = false;
 	import_status.done = 0.0;
-	
-	interthread_progress_connection = Glib::signal_timeout().connect 
-		(bind (mem_fun(*this, &Editor::import_progress_timeout), (gpointer) 0), 100);
-	
-	track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
-	ARDOUR_UI::instance()->flush_pending ();
-
-	/* start import thread for this spec. this will ultimately call Session::import_audiofile()
-	   and if successful will add the file(s) as a region to the session region list.
+	import_status.quality = quality;
+	import_status.replace_existing_source = replace;
+
+	import_status.mode = mode;
+	import_status.pos = pos;
+	import_status.target_tracks = target_tracks;
+	import_status.target_regions = target_regions;
+	import_status.track = track;
+	import_status.replace = replace;
+
+	track_canvas->get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
+	gdk_flush ();
+
+	/* start import thread for this spec. this will ultimately call Session::import_audiofiles()
+	   which, if successful, will add the files as regions to the region list. its up to us
+	   (the GUI) to direct additional steps after that.
 	*/
-	
-	pthread_create_and_store ("import", &import_status.thread, 0, _import_thread, this);
+
+	pthread_create_and_store ("import", &import_status.thread, _import_thread, this);
 	pthread_detach (import_status.thread);
-	
-	while (!(import_status.done || import_status.cancel)) {
+
+	while (!import_status.done && !import_status.cancel) {
 		gtk_main_iteration ();
 	}
 
-	interthread_progress_window->hide ();
-	
 	import_status.done = true;
-	interthread_progress_connection.disconnect ();
-	
-	/* import thread finished - see if we should build a new track */
-	
-	if (!import_status.new_regions.empty()) {
-		boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion>(import_status.new_regions.front());
-		finish_bringing_in_audio (region, region->n_channels(), region->n_channels(), track, pos, mode);
+
+	if (!import_status.cancel && !import_status.sources.empty()) {
+		if (add_sources (import_status.paths,
+				 import_status.sources,
+				 import_status.pos,
+				 import_status.mode,
+				 import_status.target_regions,
+				 import_status.target_tracks,
+				 track, false) == 0) {
+			_session->save_state ("");
+		}
+
+		/* update position from results */
+
+		pos = import_status.pos;
 	}
 
-	track_canvas.get_window()->set_cursor (*current_canvas_cursor);
+
+	track_canvas->get_window()->set_cursor (*current_canvas_cursor);
 	return 0;
 }
 
 int
-Editor::embed_sndfile (vector<Glib::ustring> paths, bool split, bool multiple_files, bool& check_sample_rate, ImportMode mode, 
-		       AudioTrack* track, nframes_t& pos, bool prompt)
+Editor::embed_sndfiles (vector<Glib::ustring> paths, bool multifile,
+			bool& check_sample_rate, ImportMode mode, nframes64_t& pos, int target_regions, int target_tracks,
+			boost::shared_ptr<Track>& track)
 {
 	boost::shared_ptr<AudioFileSource> source;
 	SourceList sources;
-	boost::shared_ptr<AudioRegion> region;
 	string linked_path;
 	SoundFileInfo finfo;
-	ustring region_name;
-	uint32_t input_chan = 0;
-	uint32_t output_chan = 0;
 	int ret = 0;
+	Glib::ustring path_to_use;
 
-	track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
-	ARDOUR_UI::instance()->flush_pending ();
+	track_canvas->get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
+	gdk_flush ();
 
 	for (vector<Glib::ustring>::iterator p = paths.begin(); p != paths.end(); ++p) {
 
 		ustring path = *p;
 
-		/* lets see if we can link it into the session */
-
-		sys::path tmp = session->session_directory().sound_path();
+		if (Config->get_try_link_for_embed()) {
 
-		tmp /= Glib::path_get_basename(path);
-		linked_path = tmp.to_string();
-		
-		if (link (path.c_str(), linked_path.c_str()) == 0) {
-
-			/* there are many reasons why link(2) might have failed.
-			   but if it succeeds, we now have a link in the
-			   session sound dir that will protect against
-			   unlinking of the original path. nice.
-			*/
+			/* lets see if we can link it into the session */
 			
-			path = linked_path;
-
-		} else {
-
-			/* one possible reason is that its already linked */
-
-			if (errno == EEXIST) {
-				struct stat sb;
+			sys::path tmp = _session->session_directory().sound_path() / Glib::path_get_basename(path);
+			linked_path = tmp.to_string();
+			
+			path_to_use = linked_path;
+			
+			if (link (path.c_str(), linked_path.c_str()) == 0) {
+				
+				/* there are many reasons why link(2) might have failed.
+				   but if it succeeds, we now have a link in the
+				   session sound dir that will protect against
+				   unlinking of the original path. nice.
+				*/
+				
+				path = linked_path;
+				path_to_use = Glib::path_get_basename (path);
+				
+			} else {
 
-				if (stat (linked_path.c_str(), &sb) == 0) {
-					if (sb.st_nlink > 1) { // its a hard link, assume its the one we want
-						path = linked_path;
+				/* one possible reason is that its already linked */
+				
+				if (errno == EEXIST) {
+					struct stat sb;
+					
+					if (stat (linked_path.c_str(), &sb) == 0) {
+						if (sb.st_nlink > 1) { // its a hard link, assume its the one we want
+							path = linked_path;
+							path_to_use = Glib::path_get_basename (path);
+						}
 					}
 				}
 			}
-
 		}
-		
+
 		/* note that we temporarily truncated _id at the colon */
-		
+
 		string error_msg;
-		
+
 		if (!AudioFileSource::get_soundfile_info (path, finfo, error_msg)) {
-			error << string_compose(_("Editor: cannot open file \"%1\", (%2)"), selection, error_msg ) << endmsg;
+			error << string_compose(_("Editor: cannot open file \"%1\", (%2)"), path, error_msg ) << endmsg;
 			goto out;
 		}
-		
-		if (check_sample_rate  && (finfo.samplerate != (int) session->frame_rate())) {
+
+		if (check_sample_rate  && (finfo.samplerate != (int) _session->frame_rate())) {
 			vector<string> choices;
-			
-			if (multiple_files) {
+
+			if (multifile) {
 				choices.push_back (_("Cancel entire import"));
 				choices.push_back (_("Don't embed it"));
 				choices.push_back (_("Embed all without questions"));
-			
+
 				Gtkmm2ext::Choice rate_choice (
-					string_compose (_("%1\nThis audiofile's sample rate doesn't match the session sample rate!"), 
+					_("Sample rate"),
+					string_compose (_("%1\nThis audiofile's sample rate doesn't match the session sample rate!"),
 							short_path (path, 40)),
-					choices, false);
-				
+					choices, false
+					);
+
 				int resx = rate_choice.run ();
-				
+
 				switch (resx) {
 				case 0: /* stop a multi-file import */
-				case 1: /* don't import this one */
+					ret = -2;
+					goto out;
+				case 1: /* don't embed this one */
 					ret = -1;
 					goto out;
 				case 2: /* do it, and the rest without asking */
@@ -367,13 +638,15 @@ Editor::embed_sndfile (vector<Glib::ustring> paths, bool split, bool multiple_fi
 			} else {
 				choices.push_back (_("Cancel"));
 				choices.push_back (_("Embed it anyway"));
-			
+
 				Gtkmm2ext::Choice rate_choice (
+					_("Sample rate"),
 					string_compose (_("%1\nThis audiofile's sample rate doesn't match the session sample rate!"), path),
-					choices, false);
-				
+					choices, false
+					);
+
 				int resx = rate_choice.run ();
-				
+
 				switch (resx) {
 				case 0: /* don't import */
 					ret = -1;
@@ -386,40 +659,37 @@ Editor::embed_sndfile (vector<Glib::ustring> paths, bool split, bool multiple_fi
 				}
 			}
 		}
-		
-		track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
-		ARDOUR_UI::instance()->flush_pending ();
-	
-		/* make the proper number of channels in the region */
-		
-		input_chan += finfo.channels;
 
-		for (int n = 0; n < finfo.channels; ++n)
-		{
+		track_canvas->get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
+
+		for (int n = 0; n < finfo.channels; ++n) {
 			try {
 
 				/* check if we have this thing embedded already */
 
 				boost::shared_ptr<Source> s;
 
-				if ((s = session->source_by_path_and_channel (path, n)) == 0) {
-					source = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createReadable 
-											       (DataType::AUDIO, *session, path,  n,
-												(mode == ImportAsTapeTrack ? 
-												 AudioFileSource::Destructive : 
-												 AudioFileSource::Flag (0))));
+				if ((s = _session->source_by_path_and_channel (path, n)) == 0) {
+
+					source = boost::dynamic_pointer_cast<AudioFileSource> (
+						SourceFactory::createReadable (DataType::AUDIO, *_session,
+									       path_to_use, n,
+									       (mode == ImportAsTapeTrack
+										? Source::Destructive
+										: Source::Flag (0)),
+									true, true));
 				} else {
 					source = boost::dynamic_pointer_cast<AudioFileSource> (s);
 				}
 
 				sources.push_back(source);
-			} 
-			
+			}
+
 			catch (failed_constructor& err) {
 				error << string_compose(_("could not open %1"), path) << endmsg;
 				goto out;
 			}
-			
+
 			ARDOUR_UI::instance()->flush_pending ();
 		}
 	}
@@ -428,67 +698,210 @@ Editor::embed_sndfile (vector<Glib::ustring> paths, bool split, bool multiple_fi
 		goto out;
 	}
 
-	if (sources[0]->natural_position() != 0) {
-		pos = sources[0]->natural_position();
-	} 
+	ret = add_sources (paths, sources, pos, mode, target_regions, target_tracks, track, true);
 
-	region_name = region_name_from_path (paths.front(), (sources.size() > 1));
-	
-	region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (sources, 0, sources[0]->length(), region_name, 0,
-										  Region::Flag (Region::DefaultFlags|Region::WholeFile|Region::External)));
+  out:
+	track_canvas->get_window()->set_cursor (*current_canvas_cursor);
+	return ret;
+}
+
+int
+Editor::add_sources (vector<Glib::ustring> paths, SourceList& sources, nframes64_t& pos, ImportMode mode,
+		     int target_regions, int target_tracks, boost::shared_ptr<Track>& track, bool /*add_channel_suffix*/)
+{
+	vector<boost::shared_ptr<Region> > regions;
+	ustring region_name;
+	uint32_t input_chan = 0;
+	uint32_t output_chan = 0;
+	bool use_timestamp;
+
+	use_timestamp = (pos == -1);
+
+	if (use_timestamp) {
+		if (sources[0]->natural_position() != 0) {
+			pos = sources[0]->natural_position();
+		} else {
+			pos = _session->current_start_frame();
+		}
+	}
+
+	// kludge (for MIDI we're abusing "channel" for "track" here)
+	if (paths.front().rfind(".mid") != Glib::ustring::npos)
+		target_regions = -1;
+
+	if (target_regions == 1) {
+
+		/* take all the sources we have and package them up as a region */
+
+		region_name = region_name_from_path (paths.front(), (sources.size() > 1), false);
+
+		PropertyList plist; 
+		
+		plist.add (ARDOUR::Properties::start, 0);
+		plist.add (ARDOUR::Properties::length, sources[0]->length (pos));
+		plist.add (ARDOUR::Properties::name, region_name);
+		plist.add (ARDOUR::Properties::layer, 0);
+		plist.add (ARDOUR::Properties::whole_file, true);
+		plist.add (ARDOUR::Properties::external, true);
+
+		boost::shared_ptr<Region> r = RegionFactory::create (sources, plist);
+
+		if (use_timestamp && boost::dynamic_pointer_cast<AudioRegion>(r)) {
+			boost::dynamic_pointer_cast<AudioRegion>(r)->special_set_position(sources[0]->natural_position());
+     		}
+
+		regions.push_back (r);
+
+
+	} else if (target_regions == -1 || target_regions > 1) {
+
+		/* take each source and create a region for each one */
+
+		SourceList just_one;
+		SourceList::iterator x;
+		uint32_t n;
+
+		for (n = 0, x = sources.begin(); x != sources.end(); ++x, ++n) {
+
+			just_one.clear ();
+			just_one.push_back (*x);
+
+			region_name = region_name_from_path ((*x)->path(), false, false, sources.size(), n);
+
+			PropertyList plist; 
+			
+			plist.add (ARDOUR::Properties::start, 0);
+			plist.add (ARDOUR::Properties::length, (*x)->length (pos));
+			plist.add (ARDOUR::Properties::name, region_name);
+			plist.add (ARDOUR::Properties::layer, 0);
+			plist.add (ARDOUR::Properties::whole_file, true);
+			plist.add (ARDOUR::Properties::external, true);
+
+			boost::shared_ptr<Region> r = RegionFactory::create (just_one, plist);
+
+			if (use_timestamp && boost::dynamic_pointer_cast<AudioRegion>(r)) {
+				boost::dynamic_pointer_cast<AudioRegion>(r)->special_set_position((*x)->natural_position());
+			}
+
+			regions.push_back (r);
+		}
+	}
+
+	if (target_regions == 1) {
+		input_chan = regions.front()->n_channels();
+	} else {
+		if (target_tracks == 1) {
+			input_chan = regions.size();
+		} else {
+			input_chan = 1;
+		}
+	}
 
 	if (Config->get_output_auto_connect() & AutoConnectMaster) {
-		output_chan = (session->master_out() ? session->master_out()->n_inputs().n_audio() : input_chan);
+		output_chan = (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan);
 	} else {
 		output_chan = input_chan;
 	}
 
-	finish_bringing_in_audio (region, input_chan, output_chan, track, pos, mode);
-	
-  out:
-	track_canvas.get_window()->set_cursor (*current_canvas_cursor);
-	return ret;
+	int n = 0;
+
+	for (vector<boost::shared_ptr<Region> >::iterator r = regions.begin(); r != regions.end(); ++r, ++n) {
+
+		finish_bringing_in_material (*r, input_chan, output_chan, pos, mode, track);
+
+		if (target_tracks != 1) {
+			track.reset ();
+		} else {
+			pos += (*r)->length();
+		}
+	}
+
+	/* setup peak file building in another thread */
+
+	for (SourceList::iterator x = sources.begin(); x != sources.end(); ++x) {
+		SourceFactory::setup_peakfile (*x, true);
+	}
+
+	return 0;
 }
 
 int
-Editor::finish_bringing_in_audio (boost::shared_ptr<AudioRegion> region, uint32_t in_chans, uint32_t out_chans, AudioTrack* track, nframes_t& pos, ImportMode mode)
+Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t in_chans, uint32_t out_chans, nframes64_t& pos,
+				  ImportMode mode, boost::shared_ptr<Track>& existing_track)
 {
+	boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
+	boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(region);
+
 	switch (mode) {
 	case ImportAsRegion:
 		/* relax, its been done */
 		break;
-		
+
 	case ImportToTrack:
-		if (track) {
-			boost::shared_ptr<Playlist> playlist = track->diskstream()->playlist();
-			
-			boost::shared_ptr<AudioRegion> copy (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (region)));
-			begin_reversible_command (_("insert sndfile"));
-                        XMLNode &before = playlist->get_state();
-			playlist->add_region (copy, pos);
-			session->add_command (new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
-			commit_reversible_command ();
-
-			pos += region->length();
+	{
+		if (!existing_track) {
+
+			if (ar) {
+				existing_track = get_nth_selected_audio_track (0);
+			} else if (mr) {
+				existing_track = get_nth_selected_midi_track (0);
+			}
+
+			if (!existing_track) {
+				return -1;
+			}
 		}
+
+		boost::shared_ptr<Playlist> playlist = existing_track->playlist();
+		boost::shared_ptr<Region> copy (RegionFactory::create (region, region->properties()));
+		begin_reversible_command (_("insert file"));
+                playlist->clear_history ();
+		playlist->add_region (copy, pos);
+		_session->add_command (new StatefulDiffCommand (playlist));
+		commit_reversible_command ();
 		break;
-		
+	}
+
 	case ImportAsTrack:
-	{ 
-		list<boost::shared_ptr<AudioTrack> > at (session->new_audio_track (in_chans, out_chans, Normal, 1));
-		if (!at.empty()) {
-			boost::shared_ptr<AudioRegion> copy (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (region)));
-			at.front()->diskstream()->playlist()->add_region (copy, pos);
+	{
+		if (!existing_track) {
+			if (ar) {
+				list<boost::shared_ptr<AudioTrack> > at (_session->new_audio_track (in_chans, out_chans, Normal, 0, 1));
+
+				if (at.empty()) {
+					return -1;
+				}
+
+				existing_track = at.front();
+			} else if (mr) {
+				list<boost::shared_ptr<MidiTrack> > mt (_session->new_midi_track (Normal, 0, 1));
+
+				if (mt.empty()) {
+					return -1;
+				}
+
+				existing_track = mt.front();
+			}
+
+			existing_track->set_name (region->name());
 		}
+
+		boost::shared_ptr<Region> copy (RegionFactory::create (region));
+		existing_track->playlist()->add_region (copy, pos);
 		break;
 	}
 
+
 	case ImportAsTapeTrack:
 	{
-		list<boost::shared_ptr<AudioTrack> > at (session->new_audio_track (in_chans, out_chans, Destructive));
+		if (!ar)
+			return -1;
+
+		list<boost::shared_ptr<AudioTrack> > at (_session->new_audio_track (in_chans, out_chans, Destructive));
 		if (!at.empty()) {
-			boost::shared_ptr<AudioRegion> copy (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (region)));
-			at.front()->diskstream()->playlist()->add_region (copy, pos);
+			boost::shared_ptr<Region> copy (RegionFactory::create (region));
+			at.front()->set_name (basename_nosuffix (copy->name()));
+			at.front()->playlist()->add_region (copy, pos);
 		}
 		break;
 	}
@@ -500,7 +913,7 @@ Editor::finish_bringing_in_audio (boost::shared_ptr<AudioRegion> region, uint32_
 void *
 Editor::_import_thread (void *arg)
 {
-	PBD::ThreadCreated (pthread_self(), X_("Import"));
+	SessionEvent::create_per_thread_pool ("import events", 64);
 
 	Editor *ed = (Editor *) arg;
 	return ed->import_thread ();
@@ -509,30 +922,8 @@ Editor::_import_thread (void *arg)
 void *
 Editor::import_thread ()
 {
-	session->import_audiofile (import_status);
+	_session->import_audiofiles (import_status);
 	pthread_exit_pbd (0);
 	/*NOTREACHED*/
 	return 0;
 }
-
-gint
-Editor::import_progress_timeout (void *arg)
-{
-	interthread_progress_label.set_text (import_status.doing_what);
-
-	if (import_status.freeze) {
-		interthread_cancel_button.set_sensitive(false);
-	} else {
-		interthread_cancel_button.set_sensitive(true);
-	}
-
-	if (import_status.doing_what == "building peak files") {
-		interthread_progress_bar.pulse ();
-		return FALSE;
-	} else {
-		interthread_progress_bar.set_fraction (import_status.progress);
-	}
-
-	return !(import_status.done || import_status.cancel);
-}
-