Collect plugin runtime profile statistics.

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

diff --git a/libs/ardour/session_playlists.cc b/libs/ardour/session_playlists.cc
index b586ab196ebd318d65f09d9951fe86fa815664ac..50bc710347ab4935a7940437dd40455402f9e01c 100644 (file)
--- a/libs/ardour/session_playlists.cc
+++ b/libs/ardour/session_playlists.cc
@@ -23,7 +23,7 @@
 #include "ardour/playlist_factory.h"
 #include "ardour/session_playlists.h"
 #include "ardour/track.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
 #include "pbd/compose.h"
 #include "pbd/xml++.h"
 
@@ -244,7 +244,6 @@ SessionPlaylists::destroy_region (boost::shared_ptr<Region> r)
        }
 }
 
-
 void
 SessionPlaylists::find_equivalent_playlist_regions (boost::shared_ptr<Region> region, vector<boost::shared_ptr<Region> >& result)
 {
@@ -260,6 +259,10 @@ SessionPlaylists::source_use_count (boost::shared_ptr<const Source> src) const
 {
        uint32_t count = 0;
 
+       /* XXXX this can go wildly wrong in the presence of circular references
+        * between compound regions.
+        */
+
        for (List::const_iterator p = playlists.begin(); p != playlists.end(); ++p) {
                 if ((*p)->uses_source (src)) {
                         ++count;
@@ -299,28 +302,63 @@ SessionPlaylists::update_after_tempo_map_change ()
        }
 }
 
+namespace {
+struct id_compare
+{
+       bool operator()(const boost::shared_ptr<Playlist>& p1, const boost::shared_ptr<Playlist>& p2)
+       {
+               return p1->id () < p2->id ();
+       }
+};
+
+typedef std::set<boost::shared_ptr<Playlist> > List;
+typedef std::set<boost::shared_ptr<Playlist>, id_compare> IDSortedList;
+
+static void
+get_id_sorted_playlists (const List& playlists, IDSortedList& id_sorted_playlists)
+{
+       for (List::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
+               id_sorted_playlists.insert(*i);
+       }
+}
+
+} // anonymous namespace
+
 void
-SessionPlaylists::add_state (XMLNode* node, bool full_state)
+SessionPlaylists::add_state (XMLNode* node, bool save_template, bool include_unused)
 {
        XMLNode* child = node->add_child ("Playlists");
-       for (List::iterator i = playlists.begin(); i != playlists.end(); ++i) {
-               if (!(*i)->hidden()) {
-                        if (full_state) {
-                                child->add_child_nocopy ((*i)->get_state());
-                        } else {
-                                child->add_child_nocopy ((*i)->get_template());
-                        }
-                }
+
+       IDSortedList id_sorted_playlists;
+       get_id_sorted_playlists (playlists, id_sorted_playlists);
+
+       for (IDSortedList::iterator i = id_sorted_playlists.begin (); i != id_sorted_playlists.end (); ++i) {
+               if (!(*i)->hidden ()) {
+                       if (save_template) {
+                               child->add_child_nocopy ((*i)->get_template ());
+                       } else {
+                               child->add_child_nocopy ((*i)->get_state ());
+                       }
+               }
+       }
+
+       if (!include_unused) {
+               return;
        }
 
        child = node->add_child ("UnusedPlaylists");
-       for (List::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
+
+       IDSortedList id_sorted_unused_playlists;
+       get_id_sorted_playlists (unused_playlists, id_sorted_unused_playlists);
+
+       for (IDSortedList::iterator i = id_sorted_unused_playlists.begin ();
+            i != id_sorted_unused_playlists.end (); ++i) {
                if (!(*i)->hidden()) {
                        if (!(*i)->empty()) {
-                               if (full_state) {
-                                       child->add_child_nocopy ((*i)->get_state());
-                               } else {
+                               if (save_template) {
                                        child->add_child_nocopy ((*i)->get_template());
+                               } else {
+                                       child->add_child_nocopy ((*i)->get_state());
                                }
                        }
                }
@@ -333,15 +371,39 @@ SessionPlaylists::maybe_delete_unused (boost::function<int(boost::shared_ptr<Pla
 {
        vector<boost::shared_ptr<Playlist> > playlists_tbd;
 
+       bool delete_remaining = false;
+       bool keep_remaining = false;
+
        for (List::iterator x = unused_playlists.begin(); x != unused_playlists.end(); ++x) {
 
+               if (keep_remaining) {
+                       break;
+               }
+
+               if (delete_remaining) {
+                       playlists_tbd.push_back (*x);
+                       continue;
+               }
+
                int status = ask (*x);
 
                switch (status) {
                case -1:
+                       // abort
                        return true;
 
-               case 0:
+               case -2:
+                       // keep this and all later
+                       keep_remaining = true;
+                       break;
+
+               case 2:
+                       // delete this and all later
+                       delete_remaining = true;
+                       // no break;
+
+               case 1:
+                       // delete this
                        playlists_tbd.push_back (*x);
                        break;
 
@@ -465,14 +527,36 @@ SessionPlaylists::playlists_for_track (boost::shared_ptr<Track> tr) const
 {
        vector<boost::shared_ptr<Playlist> > pl;
        get (pl);
-       
+
        vector<boost::shared_ptr<Playlist> > pl_tr;
 
        for (vector<boost::shared_ptr<Playlist> >::iterator i = pl.begin(); i != pl.end(); ++i) {
-               if (((*i)->get_orig_track_id() == tr->id()) || (tr->playlist()->id() == (*i)->id())) {
+               if ( ((*i)->get_orig_track_id() == tr->id()) ||
+                       (tr->playlist()->id() == (*i)->id())    ||
+                       ((*i)->shared_with (tr->id())) )
+               {
                        pl_tr.push_back (*i);
                }
        }
 
        return pl_tr;
 }
+
+void
+SessionPlaylists::foreach (boost::function<void(boost::shared_ptr<const Playlist>)> functor, bool incl_unused)
+{
+       Glib::Threads::Mutex::Lock lm (lock);
+       for (List::iterator i = playlists.begin(); i != playlists.end(); i++) {
+               if (!(*i)->hidden()) {
+                       functor (*i);
+               }
+       }
+       if (!incl_unused) {
+               return;
+       }
+       for (List::iterator i = unused_playlists.begin(); i != unused_playlists.end(); i++) {
+               if (!(*i)->hidden()) {
+                       functor (*i);
+               }
+       }
+}