X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_audio_import.cc;h=7f56cd9121225db90714585d0ef34412ce77dcdc;hb=91e6c1b176d93f43bab6713574c590ea97801bdc;hp=48edb52756d8d8626a241bbf79c79b1221ae3c74;hpb=532f6aad4ac79ca15d69deccd18fca90e444c437;p=ardour.git

diff --git a/gtk2_ardour/editor_audio_import.cc b/gtk2_ardour/editor_audio_import.cc
index 48edb52756..7f56cd9121 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
@@ -15,352 +15,666 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
-#include <pbd/pthread_utils.h>
-#include <pbd/basename.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <unistd.h>
+#include <algorithm>
+
+#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 <ardour/session.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 "ardour/smf_source.h"
+#include "ardour/operations.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 "mouse_cursors.h"
+#include "editor_cursors.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;
-using Glib::ustring;
+using std::string;
 
 /* 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;
-	AudioTrack* track = 0;
-
-	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, 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<string> 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 */
+
+		vector<string> upaths = sfbrowser->get_paths ();
+                for (vector<string>::iterator x = upaths.begin(); x != upaths.end(); ++x) {
+                        paths.push_back (*x);
+                }
+                
+		ImportPosition pos = sfbrowser->get_position ();
+		ImportMode mode = sfbrowser->get_mode ();
+		ImportDisposition chns = sfbrowser->get_channel_disposition ();
+		framepos_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 ();
+}
+
+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 already_exists = false;
+	uint32_t existing;
 
-	if (interthread_progress_window == 0) {
-		build_interthread_progress_window ();
+	if ((existing = _session->count_sources_by_origin (path)) > 0) {
+		already_exists = true;
 	}
 
-	vector<ustring> to_import;
+	int function = 1;
 
-	for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+	if (already_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);
+
+		}
+		MessageDialog dialog(message, false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE, true);
+
+		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();
 
-		to_import.clear ();
-		to_import.push_back (*a);
+		function = dialog.run ();
 
-		import_sndfile (to_import, mode, track, pos);
+		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(); ) {
-	
-		Glib::ustring path = *a;
-		Glib::ustring pair_base;
-		vector<ustring> to_embed;
+	for (x = selection->tracks.begin(); nth > 0 && x != selection->tracks.end(); ++x) {
 
-		to_embed.push_back (path);
-		a = paths.erase (a);
+		atv = dynamic_cast<AudioTimeAxisView*>(*x);
 
-		if (path_is_paired (path, pair_base)) {
+		if (!atv) {
+			continue;
+		} else if (atv->is_audio_track()) {
+			--nth;
+		}
+	}
 
-			ustring::size_type len = pair_base.length();
+	if (x == selection->tracks.end()) {
+		atv = dynamic_cast<AudioTimeAxisView*>(selection->tracks.back());
+	} else {
+		atv = dynamic_cast<AudioTimeAxisView*>(*x);
+	}
 
-			for (vector<Glib::ustring>::iterator b = paths.begin(); b != paths.end(); ) {
+	if (!atv || !atv->is_audio_track()) {
+		return boost::shared_ptr<AudioTrack>();
+	}
 
-				if (((*b).substr (0, len) == pair_base) && ((*b).length() == path.length())) {
+	return atv->audio_track();
+}
 
-					to_embed.push_back (*b);
-						
-					/* don't process this one again */
+boost::shared_ptr<MidiTrack>
+Editor::get_nth_selected_midi_track (int nth) const
+{
+	MidiTimeAxisView* mtv;
+	TrackSelection::iterator x;
 
-					b = paths.erase (b);
-					break;
+	for (x = selection->tracks.begin(); nth > 0 && x != selection->tracks.end(); ++x) {
 
-				} else {
-					++b;
-				}
-			}
+		mtv = dynamic_cast<MidiTimeAxisView*>(*x);
+
+		if (!mtv) {
+			continue;
+		} else if (mtv->is_midi_track()) {
+			--nth;
 		}
+	}
 
-		if (to_embed.size() > 1) {
+	if (x == selection->tracks.end()) {
+		mtv = dynamic_cast<MidiTimeAxisView*>(selection->tracks.back());
+	} else {
+		mtv = dynamic_cast<MidiTimeAxisView*>(*x);
+	}
 
-			vector<string> choices;
+	if (!mtv || !mtv->is_midi_track()) {
+		return boost::shared_ptr<MidiTrack>();
+	}
 
-			choices.push_back (string_compose (_("Import as a %1 region"),
-							   to_embed.size() > 2 ? _("multichannel") : _("stereo")));
-			choices.push_back (_("Import as multiple regions"));
-			
-			Gtkmm2ext::Choice chooser (string_compose (_("Paired files detected (%1, %2 ...).\nDo you want to:"),
-								   to_embed[0],
-								   to_embed[1]),
-						   choices);
-			
-			if (chooser.run () == 0) {
-				
-				/* keep them paired */
+	return mtv->midi_track();
+}
 
-				if (embed_sndfile (to_embed, split, multiple_files, check_sample_rate, mode, track, pos, prompt) < -1) {
-					break;
-				}
+void
+Editor::do_import (vector<string> paths, ImportDisposition chns, ImportMode mode, SrcQuality quality, framepos_t& pos)
+{
+	boost::shared_ptr<Track> track;
+	vector<string> to_import;
+	int nth = 0;
+	bool use_timestamp = (pos == -1);
 
-			} else {
+	current_interthread_info = &import_status;
+	import_status.current = 1;
+	import_status.total = paths.size ();
+	import_status.all_done = false;
 
-				/* one thing per file */
+	ImportProgressWindow ipw (&import_status, _("Import"), _("Cancel Import"));
 
-				vector<ustring> foo;
+	bool ok = true;
 
-				for (vector<ustring>::iterator x = to_embed.begin(); x != to_embed.end(); ++x) {
+	if (chns == Editing::ImportMergeFiles) {
 
-					foo.clear ();
-					foo.push_back (*x);
+		/* create 1 region from all paths, add to 1 track,
+		   ignore "track"
+		*/
 
-					if (embed_sndfile (foo, split, multiple_files, check_sample_rate, mode, track, pos, prompt) < -1) {
-						break;
-					}
-				}
+		bool cancel = false;
+		for (vector<string>::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 (cancel) {
+			ok = false;
 		} else {
+			ipw.show ();
+			ok = (import_sndfiles (paths, mode, quality, pos, 1, 1, track, false) == 0);
+		}
+
+	} else {
+
+		bool replace = false;
+
+		for (vector<string>::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*/
+			}
+
+			/* have to reset this for every file we handle */
+                        
+			if (use_timestamp) {
+				pos = -1;
+			}
+
+			ipw.show ();
+                                
+			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 (embed_sndfile (to_embed, split, multiple_files, check_sample_rate, mode, track, pos, prompt) < -1) {
+				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);
+				
+				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);
+
+				ok = (import_sndfiles (to_import, mode, quality, pos, 1, 1, track, replace) == 0);
+				break;
+
+			case Editing::ImportMergeFiles:
+				// Not entered, handled in earlier if() branch
 				break;
 			}
 		}
 	}
-	
-	if (a == paths.end()) {
-		session->save_state ("");
+
+	if (ok) {
+		_session->save_state ("");
 	}
+
+	import_status.all_done = true;
 }
 
-int
-Editor::import_sndfile (vector<ustring> paths, ImportMode mode, AudioTrack* track, nframes_t& pos)
+void
+Editor::do_embed (vector<string> paths, ImportDisposition chns, ImportMode mode, framepos_t& pos)
 {
-	interthread_progress_window->set_title (string_compose (_("ardour: importing %1"), paths.front()));
-	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;
+	boost::shared_ptr<Track> track;
+	bool check_sample_rate = true;
+	bool ok = false;
+	vector<string> to_embed;
+	bool multi = paths.size() > 1;
+	int nth = 0;
+
+	switch (chns) {
+	case Editing::ImportDistinctFiles:
+		for (vector<string>::iterator a = paths.begin(); a != paths.end(); ++a) {
+
+			to_embed.clear ();
+			to_embed.push_back (*a);
+
+			if (mode == Editing::ImportToTrack) {
+				track = get_nth_selected_audio_track (nth++);
+			}
+
+			if (embed_sndfiles (to_embed, multi, check_sample_rate, mode, pos, 1, -1, track) < -1) {
+				goto out;
+			}
+		}
+		break;
+
+	case Editing::ImportDistinctChannels:
+		for (vector<string>::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<string>::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;
+	}
+
+	ok = true;
 
+  out:
+	if (ok) {
+		_session->save_state ("");
+	}
+}
+
+int
+Editor::import_sndfiles (vector<string> paths, ImportMode mode, SrcQuality quality, framepos_t& pos,
+			 int target_regions, int target_tracks, boost::shared_ptr<Track>& track, bool replace)
+{
 	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;
+        
+	set_canvas_cursor (_cursors->wait);
+	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 ();
 	}
-	
+
 	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);
+
+	int result = -1;
+
+	if (!import_status.cancel && !import_status.sources.empty()) {
+		result = add_sources (
+			import_status.paths,
+			import_status.sources,
+			import_status.pos,
+			import_status.mode,
+			import_status.target_regions,
+			import_status.target_tracks,
+			track, false
+			);
+
+		/* update position from results */
+
+		pos = import_status.pos;
 	}
 
-	track_canvas.get_window()->set_cursor (*current_canvas_cursor);
-	return 0;
+	set_canvas_cursor (current_canvas_cursor);
+	return result;
 }
 
 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<string> paths, bool multifile,
+			bool& check_sample_rate, ImportMode mode, framepos_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 idspec;
 	string linked_path;
 	SoundFileInfo finfo;
-	ustring region_name;
-	uint32_t input_chan = 0;
-	uint32_t output_chan = 0;
+	int ret = 0;
 
-	track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
-	ARDOUR_UI::instance()->flush_pending ();
+	set_canvas_cursor (_cursors->wait);
+	gdk_flush ();
 
-	for (vector<Glib::ustring>::iterator p = paths.begin(); p != paths.end(); ++p) {
+	for (vector<string>::iterator p = paths.begin(); p != paths.end(); ++p) {
 
-		ustring path = *p;
+		string path = *p;
+		string error_msg;
 
-		/* lets see if we can link it into the session */
-		
-		linked_path = session->sound_dir();
-		linked_path += '/';
-		linked_path += Glib::path_get_basename (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;
-		}
-		
 		/* 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;
-			return 0;
+			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 (
+					_("Sample rate"),
+					string_compose (_("%1\nThis audiofile's sample rate doesn't match the session sample rate!"),
+							short_path (path, 40)),
+					choices, false
+					);
+
+				int resx = rate_choice.run ();
+
+				switch (resx) {
+				case 0: /* stop a multi-file import */
+					ret = -2;
+					goto out;
+				case 1: /* don't embed this one */
+					ret = -1;
+					goto out;
+				case 2: /* do it, and the rest without asking */
+					check_sample_rate = false;
+					break;
+				case 3: /* do it */
+					break;
+				default:
+					ret = -2;
+					goto out;
+				}
 			} else {
 				choices.push_back (_("Cancel"));
-			}
-			
-			choices.push_back (_("Embed it anyway"));
-			
-			Gtkmm2ext::Choice rate_choice (
-				string_compose (_("%1\nThis audiofile's sample rate doesn't match the session sample rate!"), path),
-				choices, false);
-			
-			switch (rate_choice.run()) {
-			case 0: /* stop a multi-file import */
-			case 1: /* don't import this one */
-				return -1;
-			case 2: /* do it, and the rest without asking */
-				check_sample_rate = false;
-				break;
-			case 3: /* do it */
-				break;
-			default:
-				return -2;
+				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
+					);
+
+				int resx = rate_choice.run ();
+
+				switch (resx) {
+				case 0: /* don't import */
+					ret = -1;
+					goto out;
+				case 1: /* do it */
+					break;
+				default:
+					ret = -2;
+					goto out;
+				}
 			}
 		}
-		
-		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)
-		{
-			idspec = path;
-			idspec += string_compose(":%1", n);
-			
+
+		set_canvas_cursor (_cursors->wait);
+
+		for (int n = 0; n < finfo.channels; ++n) {
 			try {
-				source = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createReadable 
-										       (DataType::AUDIO, *session, idspec, 
-											(mode == ImportAsTapeTrack ? 
-											 AudioFileSource::Destructive : 
-											 AudioFileSource::Flag (0))));
+
+				/* 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
+										? 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 ();
 		}
 	}
@@ -369,67 +683,257 @@ 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);
+
+  out:
+	set_canvas_cursor (current_canvas_cursor);
+	return ret;
+}
+
+int
+Editor::add_sources (vector<string> paths, SourceList& sources, framepos_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;
+	string region_name;
+	uint32_t input_chan = 0;
+	uint32_t output_chan = 0;
+	bool use_timestamp;
+
+	use_timestamp = (pos == -1);
+
+	// kludge (for MIDI we're abusing "channel" for "track" here)
+	if (SMFSource::safe_midi_file_extension (paths.front())) {
+		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);
+
+		/* we checked in import_sndfiles() that there were not too many */
+
+		while (RegionFactory::region_by_name (region_name)) {
+			region_name = bump_name_once (region_name, '.');
+		}
+
+		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;
+		}
+	}
 
-	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)));
-	
 	if (Config->get_output_auto_connect() & AutoConnectMaster) {
-		output_chan = (session->master_out() ? session->master_out()->n_inputs().get(DataType::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);
+	int n = 0;
+	framepos_t rlen = 0;
+
+	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);
+                
+		if (use_timestamp) {
+                        if (ar) {
+                        
+                                /* get timestamp for this region */
+                                
+                                const boost::shared_ptr<Source> s (ar->sources().front());
+                                const boost::shared_ptr<AudioSource> as = boost::dynamic_pointer_cast<AudioSource> (s);
+                                
+                                assert (as);
+                                
+                                if (as->natural_position() != 0) {
+                                        pos = as->natural_position();
+                                } else if (target_tracks == 1) {
+                                        /* hmm, no timestamp available, put it after the previous region
+                                         */
+                                        if (n == 0) {
+                                                pos = get_preferred_edit_position ();
+                                        } else {
+                                                pos += rlen;
+                                        }
+                                } else {
+                                        pos = get_preferred_edit_position ();
+                                }
+                        } else {
+                                /* should really get first position in MIDI file, but for now, use edit position*/
+                                pos = get_preferred_edit_position ();
+                        }
+                }
+                        
+
+		finish_bringing_in_material (*r, input_chan, output_chan, pos, mode, track);
+
+		rlen = (*r)->length();
+                
+		if (target_tracks != 1) {
+			track.reset ();
+		} else { 
+			if (!use_timestamp || !ar) {
+				/* line each one up right after the other */
+				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, framepos_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 ();
+	{
+		if (!existing_track) {
 
-			pos += region->length();
+			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 (Operations::insert_file);
+		playlist->clear_changes ();
+		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<Playlist> playlist = existing_track->playlist();
+		boost::shared_ptr<Region> copy (RegionFactory::create (region));
+		begin_reversible_command (Operations::insert_file);
+		playlist->clear_changes ();
+		playlist->add_region (copy, pos);
+		_session->add_command (new StatefulDiffCommand (playlist));
+		commit_reversible_command ();
 		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<Playlist> playlist = at.front()->playlist();
+			boost::shared_ptr<Region> copy (RegionFactory::create (region));
+			begin_reversible_command (Operations::insert_file);
+			playlist->clear_changes ();
+			playlist->add_region (copy, pos);
+			_session->add_command (new StatefulDiffCommand (playlist));
+			commit_reversible_command ();
 		}
 		break;
 	}
@@ -441,7 +945,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 ();
@@ -450,30 +954,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);
-}
-