fix crash when copy'ing latent plugins

[ardour.git] / libs / ardour / source_factory.cc

diff --git a/libs/ardour/source_factory.cc b/libs/ardour/source_factory.cc
index 5e1a7d40d90507bf13cf57ffeaea36ea87412677..834014bd1f9874d712b3f57fa9a17d4072393d56 100644 (file)
--- a/libs/ardour/source_factory.cc
+++ b/libs/ardour/source_factory.cc
@@ -22,7 +22,6 @@
 #include "libardour-config.h"
 #endif
 
-#include "pbd/boost_debug.h"
 #include "pbd/error.h"
 #include "pbd/convert.h"
 #include "pbd/pthread_utils.h"
@@ -30,8 +29,10 @@
 
 #include "ardour/audioplaylist.h"
 #include "ardour/audio_playlist_source.h"
+#include "ardour/boost_debug.h"
 #include "ardour/midi_playlist.h"
 #include "ardour/midi_playlist_source.h"
+#include "ardour/source.h"
 #include "ardour/source_factory.h"
 #include "ardour/sndfilesource.h"
 #include "ardour/silentfilesource.h"
@@ -43,7 +44,7 @@
 #endif
 
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace ARDOUR;
 using namespace std;
@@ -54,6 +55,8 @@ Glib::Threads::Cond SourceFactory::PeaksToBuild;
 Glib::Threads::Mutex SourceFactory::peak_building_lock;
 std::list<boost::weak_ptr<AudioSource> > SourceFactory::files_with_peaks;
 
+static int active_threads = 0;
+
 static void
 peak_thread_work ()
 {
@@ -74,6 +77,7 @@ peak_thread_work ()
 
                boost::shared_ptr<AudioSource> as (SourceFactory::files_with_peaks.front().lock());
                SourceFactory::files_with_peaks.pop_front ();
+               ++active_threads;
                SourceFactory::peak_building_lock.unlock ();
 
                if (!as) {
@@ -81,9 +85,20 @@ peak_thread_work ()
                }
 
                as->setup_peakfile ();
+               SourceFactory::peak_building_lock.lock ();
+               --active_threads;
+               SourceFactory::peak_building_lock.unlock ();
        }
 }
 
+int
+SourceFactory::peak_work_queue_length ()
+{
+       // ideally we'd loop over the queue and check for duplicates
+       // and existing valid peak-files..
+       return SourceFactory::files_with_peaks.size () + active_threads;
+}
+
 void
 SourceFactory::init ()
 {
@@ -99,7 +114,8 @@ SourceFactory::setup_peakfile (boost::shared_ptr<Source> s, bool async)
 
        if (as) {
 
-               if (async) {
+               // immediately set 'peakfile-path' for empty and NoPeakFile sources
+               if (async && !as->empty() && !(as->flags() & Source::NoPeakFile)) {
 
                        Glib::Threads::Mutex::Lock lm (peak_building_lock);
                        files_with_peaks.push_back (boost::weak_ptr<AudioSource> (as));
@@ -134,7 +150,7 @@ boost::shared_ptr<Source>
 SourceFactory::create (Session& s, const XMLNode& node, bool defer_peaks)
 {
        DataType type = DataType::AUDIO;
-       const XMLProperty* prop = node.property("type");
+       XMLProperty const * prop = node.property("type");
 
        if (prop) {
                type = DataType (prop->value());
@@ -148,7 +164,7 @@ SourceFactory::create (Session& s, const XMLNode& node, bool defer_peaks)
 
                        try {
                                boost::shared_ptr<AudioPlaylistSource> ap (new AudioPlaylistSource (s, node));
-                               
+
                                if (setup_peakfile (ap, true)) {
                                        return boost::shared_ptr<Source>();
                                }
@@ -205,7 +221,8 @@ SourceFactory::create (Session& s, const XMLNode& node, bool defer_peaks)
                }
        } else if (type == DataType::MIDI) {
                boost::shared_ptr<SMFSource> src (new SMFSource (s, node));
-               src->load_model (true, true);
+               Source::Lock lock(src->mutex());
+               src->load_model (lock, true);
 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
                // boost_debug_shared_ptr_mark_interesting (src, "Source");
 #endif
@@ -222,7 +239,7 @@ SourceFactory::createExternal (DataType type, Session& s, const string& path,
                               int chn, Source::Flag flags, bool announce, bool defer_peaks)
 {
        if (type == DataType::AUDIO) {
-               
+
                if (!(flags & Destructive)) {
 
                        try {
@@ -272,18 +289,18 @@ SourceFactory::createExternal (DataType type, Session& s, const string& path,
 
        } else if (type == DataType::MIDI) {
 
-               SMFSource* src = new SMFSource (s, path, SMFSource::Flag(0));
-               src->load_model (true, true);
+               boost::shared_ptr<SMFSource> src (new SMFSource (s, path));
+               Source::Lock lock(src->mutex());
+               src->load_model (lock, 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);
+                       SourceCreated (src);
                }
 
-               return ret;
+               return src;
 
        }
 
@@ -291,7 +308,7 @@ SourceFactory::createExternal (DataType type, Session& s, const string& path,
 }
 
 boost::shared_ptr<Source>
-SourceFactory::createWritable (DataType type, Session& s, const std::string& path, 
+SourceFactory::createWritable (DataType type, Session& s, const std::string& path,
                               bool destructive, framecnt_t rate, bool announce, bool defer_peaks)
 {
        /* this might throw failed_constructor(), which is OK */
@@ -325,7 +342,8 @@ SourceFactory::createWritable (DataType type, Session& s, const std::string& pat
                boost::shared_ptr<SMFSource> src (new SMFSource (s, path, SndFileSource::default_writable_flags));
                assert (src->writable ());
 
-               src->load_model (true, true);
+               Source::Lock lock(src->mutex());
+               src->load_model (lock, true);
 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
                // boost_debug_shared_ptr_mark_interesting (src, "Source");
 #endif
@@ -342,6 +360,39 @@ SourceFactory::createWritable (DataType type, Session& s, const std::string& pat
        return boost::shared_ptr<Source> ();
 }
 
+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)