X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsource_factory.cc;h=a2e93ee61b9711efb8bdedebdd63f212e7382136;hb=a473d630eb165272992e90f8d854b1d66ec0be63;hp=001af609dc1c20997fe1985de0c2ab7fa1cebbb5;hpb=ef6b25432d9c46d71b08c0f7d5f2686df428c4e8;p=ardour.git

diff --git a/libs/ardour/source_factory.cc b/libs/ardour/source_factory.cc
index 001af609dc..a2e93ee61b 100644
--- a/libs/ardour/source_factory.cc
+++ b/libs/ardour/source_factory.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
@@ -18,257 +18,396 @@
     $Id$
 */
 
-#include <pbd/error.h>
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
 
-#include <ardour/source_factory.h>
-#include <ardour/sndfilesource.h>
-#include <ardour/smf_source.h>
-#include <ardour/destructive_filesource.h>
-#include <ardour/configuration.h>
+#include "pbd/boost_debug.h"
+#include "pbd/error.h"
+#include "pbd/convert.h"
+#include "pbd/pthread_utils.h"
+#include "pbd/stacktrace.h"
+
+#include "ardour/audioplaylist.h"
+#include "ardour/audio_playlist_source.h"
+#include "ardour/midi_playlist.h"
+#include "ardour/midi_playlist_source.h"
+#include "ardour/source_factory.h"
+#include "ardour/sndfilesource.h"
+#include "ardour/silentfilesource.h"
+#include "ardour/rc_configuration.h"
+#include "ardour/smf_source.h"
+#include "ardour/session.h"
+
+#ifdef  HAVE_COREAUDIO
+#define USE_COREAUDIO_FOR_FILES
+#endif
 
-#ifdef HAVE_COREAUDIO
-#include <ardour/coreaudiosource.h>
+#ifdef USE_COREAUDIO_FOR_FILES
+#include "ardour/coreaudiosource.h"
 #endif
 
+
 #include "i18n.h"
 
 using namespace ARDOUR;
 using namespace std;
 using namespace PBD;
 
-sigc::signal<void,boost::shared_ptr<Source> > SourceFactory::SourceCreated;
+PBD::Signal1<void,boost::shared_ptr<Source> > SourceFactory::SourceCreated;
+Glib::Cond* SourceFactory::PeaksToBuild;
+Glib::StaticMutex SourceFactory::peak_building_lock = GLIBMM_STATIC_MUTEX_INIT;
+std::list<boost::weak_ptr<AudioSource> > SourceFactory::files_with_peaks;
+
+static void
+peak_thread_work ()
+{
+	SessionEvent::create_per_thread_pool (X_("PeakFile Builder "), 64);
+
+	while (true) {
+
+		SourceFactory::peak_building_lock.lock ();
+
+	  wait:
+		if (SourceFactory::files_with_peaks.empty()) {
+			SourceFactory::PeaksToBuild->wait (SourceFactory::peak_building_lock);
+		}
+
+		if (SourceFactory::files_with_peaks.empty()) {
+			goto wait;
+		}
+
+		boost::shared_ptr<AudioSource> as (SourceFactory::files_with_peaks.front().lock());
+		SourceFactory::files_with_peaks.pop_front ();
+		SourceFactory::peak_building_lock.unlock ();
+
+		if (!as) {
+			continue;
+		}
+
+		as->setup_peakfile ();
+	}
+}
+
+void
+SourceFactory::init ()
+{
+	PeaksToBuild = new Glib::Cond();
+
+	for (int n = 0; n < 2; ++n) {
+		Glib::Thread::create (sigc::ptr_fun (::peak_thread_work), false);
+	}
+}
 
 int
-SourceFactory::setup_peakfile (boost::shared_ptr<Source> s)
+SourceFactory::setup_peakfile (boost::shared_ptr<Source> s, bool async)
 {
 	boost::shared_ptr<AudioSource> as (boost::dynamic_pointer_cast<AudioSource> (s));
+
 	if (as) {
-		if (as->setup_peakfile ()) {
-			error << string_compose("SourceFactory: could not set up peakfile for %1", as->name()) << endmsg;
-			return -1;
+
+		if (async) {
+
+			Glib::Mutex::Lock lm (peak_building_lock);
+			files_with_peaks.push_back (boost::weak_ptr<AudioSource> (as));
+			PeaksToBuild->broadcast ();
+
+		} else {
+
+			if (as->setup_peakfile ()) {
+				error << string_compose("SourceFactory: could not set up peakfile for %1", as->name()) << endmsg;
+				return -1;
+			}
 		}
 	}
 
 	return 0;
 }
 
-#ifdef HAVE_COREAUDIO
 boost::shared_ptr<Source>
-SourceFactory::create (Session& s, const XMLNode& node)
+SourceFactory::createSilent (Session& s, const XMLNode& node, framecnt_t nframes, float sr)
+{
+	Source* src = new SilentFileSource (s, node, nframes, sr);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+	// boost_debug_shared_ptr_mark_interesting (src, "Source");
+#endif
+	boost::shared_ptr<Source> ret (src);
+	// no analysis data - the file is non-existent
+	SourceCreated (ret);
+	return ret;
+}
+
+boost::shared_ptr<Source>
+SourceFactory::create (Session& s, const XMLNode& node, bool defer_peaks)
 {
 	DataType type = DataType::AUDIO;
 	const XMLProperty* prop = node.property("type");
+
 	if (prop) {
-		type = DataType(prop->value());
+		type = DataType (prop->value());
 	}
 
 	if (type == DataType::AUDIO) {
 
-		if (node.property (X_("destructive")) != 0) {
+		/* it could be nested */
+
+		if (node.property ("playlist") != 0) {
+
+			try {
+				boost::shared_ptr<AudioPlaylistSource> ap (new AudioPlaylistSource (s, node));
+
+				if (setup_peakfile (ap, true)) {
+					return boost::shared_ptr<Source>();
+				}
+
+				ap->check_for_analysis_data_on_disk ();
+				SourceCreated (ap);
+				return ap;
 
-			boost::shared_ptr<Source> ret (new DestructiveFileSource (s, node));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
+			} catch (failed_constructor&) {
+				/* oh well, so much for that then ... */
 			}
-			SourceCreated (ret);
-			return ret;
 
 		} else {
-		
-		try {
-			boost::shared_ptr<Source> ret (new CoreAudioSource (s, node));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
-			}
-			SourceCreated (ret);
-			return ret;
-		
-		} catch (failed_constructor& err) {
+
 
 			try {
-				boost::shared_ptr<Source> ret (new CoreAudioSource (node));
+				Source* src = new SndFileSource (s, node);
+#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, defer_peaks)) {
+					return boost::shared_ptr<Source>();
+				}
+				ret->check_for_analysis_data_on_disk ();
 				SourceCreated (ret);
 				return ret;
-			} 
-
+			}
 
 			catch (failed_constructor& err) {
 
-				boost::shared_ptr<Source> ret (new SndFileSource (s, node));
-				if (setup_peakfile (ret)) {
+#ifdef USE_COREAUDIO_FOR_FILES
+
+				/* this is allowed to throw */
+
+				Source *src = new CoreAudioSource (s, node);
+#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, defer_peaks)) {
 					return boost::shared_ptr<Source>();
 				}
+
+				ret->check_for_analysis_data_on_disk ();
 				SourceCreated (ret);
 				return ret;
+#else
+				throw; // rethrow
+#endif
 			}
 		}
-
 	} else if (type == DataType::MIDI) {
-		
-		boost::shared_ptr<Source> ret (new SMFSource (node));
-		SourceCreated (ret);
-		return ret;
-
+		boost::shared_ptr<SMFSource> src (new SMFSource (s, node));
+		src->load_model (true, true);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+		// boost_debug_shared_ptr_mark_interesting (src, "Source");
+#endif
+		src->check_for_analysis_data_on_disk ();
+		SourceCreated (src);
+		return src;
 	}
 
 	return boost::shared_ptr<Source>();
 }
 
-#else
-
 boost::shared_ptr<Source>
-SourceFactory::create (Session& s, const XMLNode& node)
+SourceFactory::createReadable (DataType type, Session& s, const string& path,
+			       int chn, Source::Flag flags, bool announce, bool defer_peaks)
 {
-	DataType type = DataType::AUDIO;
-	const XMLProperty* prop = node.property("type");
-	if (prop) {
-		type = DataType(prop->value());
-	}
-
 	if (type == DataType::AUDIO) {
-		
-		if (node.property (X_("destructive")) != 0) {
-			
-			boost::shared_ptr<Source> ret (new DestructiveFileSource (s, node));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
-			}
-			SourceCreated (ret);
-			return ret;
 
-		} else {
-			
-			boost::shared_ptr<Source> ret (new SndFileSource (s, node));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
-			}
-			SourceCreated (ret);
-			return ret;
-		}
-
-	} else if (type == DataType::MIDI) {
+		if (!(flags & Destructive)) {
 
-		boost::shared_ptr<Source> ret (new SMFSource (s, node));
-		SourceCreated (ret);
-		return ret;
+			try {
 
-	}
-	
-	return boost::shared_ptr<Source> ();
-}
+				Source* src = new SndFileSource (s, path, chn, flags);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+				// boost_debug_shared_ptr_mark_interesting (src, "Source");
+#endif
+				boost::shared_ptr<Source> ret (src);
 
-#endif // HAVE_COREAUDIO
+				if (setup_peakfile (ret, defer_peaks)) {
+					return boost::shared_ptr<Source>();
+				}
 
-#ifdef HAVE_COREAUDIO
-boost::shared_ptr<Source>
-SourceFactory::createReadable (DataType type, Session& s, string idstr, AudioFileSource::Flag flags, bool announce)
-{
-	if (type == DataType::AUDIO) {
-		if (flags & Destructive) {
-			boost::shared_ptr<Source> ret (new DestructiveFileSource (s, idstr, flags));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
-			}
-			if (announce) {
-				SourceCreated (ret);
-			}
-			return ret;
-	
-			try {
-				boost::shared_ptr<Source> ret (new CoreAudioSource (s, idstr, flags));
+				ret->check_for_analysis_data_on_disk ();
 				if (announce) {
 					SourceCreated (ret);
 				}
 				return ret;
-		
-			} catch (failed_constructor& err) {
-				boost::shared_ptr<Source> ret (new SndFileSource (s, idstr, flags));
+			}
+
+			catch (failed_constructor& err) {
+#ifdef USE_COREAUDIO_FOR_FILES
+
+				Source* src = new CoreAudioSource (s, path, chn, flags);
+#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, defer_peaks)) {
+					return boost::shared_ptr<Source>();
+				}
+				ret->check_for_analysis_data_on_disk ();
 				if (announce) {
 					SourceCreated (ret);
 				}
 				return ret;
+
+#else
+				throw; // rethrow
+#endif
 			}
 
+		} else {
+			// eh?
+		}
+
 	} else if (type == DataType::MIDI) {
 
-		boost::shared_ptr<Source> ret (new SMFSource (s, node));
-		SourceCreated (ret);
+		SMFSource* src = new SMFSource (s, path, SMFSource::Flag(0));
+		src->load_model (true, true);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+		// boost_debug_shared_ptr_mark_interesting (src, "Source");
+#endif
+		boost::shared_ptr<Source> ret (src);
+
+		if (announce) {
+			SourceCreated (ret);
+		}
+
 		return ret;
 
 	}
-	
+
 	return boost::shared_ptr<Source>();
 }
 
-#else
-
 boost::shared_ptr<Source>
-SourceFactory::createReadable (DataType type, Session& s, string idstr, AudioFileSource::Flag flags, bool announce)
+SourceFactory::createWritable (DataType type, Session& s, const std::string& path, const std::string& origin,
+			       bool destructive, framecnt_t rate, bool announce, bool defer_peaks)
 {
+	/* this might throw failed_constructor(), which is OK */
+
 	if (type == DataType::AUDIO) {
-	
-		boost::shared_ptr<Source> ret (new SndFileSource (s, idstr, flags));
-		if (setup_peakfile (ret)) {
+		Source* src = new SndFileSource (s, path, origin,
+				s.config.get_native_file_data_format(),
+				s.config.get_native_file_header_format(),
+				rate,
+				(destructive
+					? Source::Flag (SndFileSource::default_writable_flags | Source::Destructive)
+				 : SndFileSource::default_writable_flags));
+#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, defer_peaks)) {
 			return boost::shared_ptr<Source>();
 		}
+
+		// no analysis data - this is a new file
+
 		if (announce) {
 			SourceCreated (ret);
 		}
 		return ret;
 
 	} else if (type == DataType::MIDI) {
+                // XXX writable flags should belong to MidiSource too
+		boost::shared_ptr<SMFSource> src (new SMFSource (s, path, SndFileSource::default_writable_flags));
+		assert (src->writable ());
+
+		src->load_model (true, true);
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+		// boost_debug_shared_ptr_mark_interesting (src, "Source");
+#endif
+
+		// no analysis data - this is a new file
 
-		boost::shared_ptr<Source> ret (new SMFSource (s, idstr, SMFSource::Flag(0))); // FIXME: flags?
 		if (announce) {
-			SourceCreated (ret);
+			SourceCreated (src);
 		}
-		return ret;
+		return src;
 
 	}
-	
+
 	return boost::shared_ptr<Source> ();
 }
 
-#endif // HAVE_COREAUDIO
-
 boost::shared_ptr<Source>
-SourceFactory::createWritable (DataType type, Session& s, std::string path, bool destructive, nframes_t rate, bool announce)
+SourceFactory::createFromPlaylist (DataType type, Session& s, boost::shared_ptr<Playlist> p, const ID& orig, const std::string& name,
+				   uint32_t chn, frameoffset_t start, framecnt_t len, bool copy, bool defer_peaks)
 {
-	/* this might throw failed_constructor(), which is OK */
 	if (type == DataType::AUDIO) {
-	
-		if (destructive) {
-			boost::shared_ptr<Source> ret (new DestructiveFileSource (s, path,
-						Config->get_native_file_data_format(),
-						Config->get_native_file_header_format(),
-						rate));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
-			}
-			if (announce) {
+		try {
+
+			boost::shared_ptr<AudioPlaylist> ap = boost::dynamic_pointer_cast<AudioPlaylist>(p);
+
+			if (ap) {
+
+				if (copy) {
+					ap.reset (new AudioPlaylist (ap, start, len, name, true));
+					start = 0;
+				}
+
+				Source* src = new AudioPlaylistSource (s, orig, name, ap, chn, start, len, Source::Flag (0));
+				boost::shared_ptr<Source> ret (src);
+
+				if (setup_peakfile (ret, defer_peaks)) {
+					return boost::shared_ptr<Source>();
+				}
+
+				ret->check_for_analysis_data_on_disk ();
 				SourceCreated (ret);
+				return ret;
 			}
-		} else {
-			boost::shared_ptr<Source> ret (new SndFileSource (s, path, 
-						Config->get_native_file_data_format(),
-						Config->get_native_file_header_format(),
-						rate));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
-			}
-			if (announce) {
+		}
+
+		catch (failed_constructor& err) {
+			/* relax - return at function scope */
+		}
+
+	} else if (type == DataType::MIDI) {
+
+		try {
+
+			boost::shared_ptr<MidiPlaylist> ap = boost::dynamic_pointer_cast<MidiPlaylist>(p);
+
+			if (ap) {
+
+				if (copy) {
+					ap.reset (new MidiPlaylist (ap, start, len, name, true));
+					start = 0;
+				}
+
+				Source* src = new MidiPlaylistSource (s, orig, name, ap, chn, start, len, Source::Flag (0));
+				boost::shared_ptr<Source> ret (src);
+
 				SourceCreated (ret);
+				return ret;
 			}
-			return ret;
 		}
 
-	} else if (type == DataType::MIDI) {
+		catch (failed_constructor& err) {
+			/* relax - return at function scope */
+		}
 
-		boost::shared_ptr<Source> ret (new SMFSource (s, path));
-		SourceCreated (ret);
-		return ret;
-	
 	}
 
-	return boost::shared_ptr<Source> ();
+	return boost::shared_ptr<Source>();
 }
+