X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fstrip_silence.cc;h=62b08cbb0a3114b1b4997e5d344e07cf3bf950f3;hb=f66b919e298c1c4e5f780942a1ed75e262a6ee96;hp=a7308b06abf3f3d09e7de8d3f8b8b16a6fd03b9a;hpb=a2885a430bbb69a72f901d227cacce979f121020;p=ardour.git

diff --git a/libs/ardour/strip_silence.cc b/libs/ardour/strip_silence.cc
index a7308b06ab..62b08cbb0a 100644
--- a/libs/ardour/strip_silence.cc
+++ b/libs/ardour/strip_silence.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2009 Paul Davis
+    Copyright (C) 2009-2010 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
@@ -35,8 +35,10 @@ using namespace ARDOUR;
  *  @param fade_length Length of fade in/out to apply to trimmed regions, in samples.
  */
 
-StripSilence::StripSilence (Session & s, double threshold, nframes_t minimum_length, nframes_t fade_length)
-	: Filter (s), _threshold (threshold), _minimum_length (minimum_length), _fade_length (fade_length)
+StripSilence::StripSilence (Session & s, const AudioIntervalMap& sm, framecnt_t fade_length)
+	: Filter (s)
+        , _smap (sm)
+        , _fade_length (fade_length)
 {
 
 }
@@ -47,19 +49,23 @@ StripSilence::run (boost::shared_ptr<Region> r, Progress* progress)
 	results.clear ();
 
 	/* we only operate on AudioRegions, for now, though this could be adapted to MIDI
-	   as well I guess 
+	   as well I guess
         */
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (r);
         InterThreadInfo itt;
-        
+        AudioIntervalMap::const_iterator sm;
+
 	if (!region) {
 		results.push_back (r);
 		return -1;
 	}
 
-	/* find periods of silence in the region */
-	std::list<std::pair<frameoffset_t, framecnt_t> > const silence =
-		region->find_silence (dB_to_coefficient (_threshold), _minimum_length, itt);
+        if ((sm = _smap.find (r)) == _smap.end()) {
+		results.push_back (r);
+		return -1;
+        }
+
+        const AudioIntervalResult& silence = sm->second;
 
 	if (silence.size () == 1 && silence.front().first == 0 && silence.front().second == region->length() - 1) {
 		/* the region is all silence, so just return with nothing */
@@ -72,62 +78,62 @@ StripSilence::run (boost::shared_ptr<Region> r, Progress* progress)
 		return 0;
 	}
 
-	std::list<std::pair<framepos_t, framecnt_t > >::const_iterator s = silence.begin ();
-        PBD::PropertyList plist;
-        framepos_t start = 0;
-        framepos_t end;
-        bool in_silence;
-        boost::shared_ptr<AudioRegion> copy;
-
-        if (s->first == 0) {
-                /* initial segment, starting at zero, is silent */
-                end = s->second;
-                in_silence = true;
-        } else {
-                /* initial segment, starting at zero, is audible */
-                end = s->first;
-                in_silence = false;
-        }
+	/* Turn the silence list into an `audible' list */
+	AudioIntervalResult audible;
 
-	int n = 0;
-	int const N = silence.size ();
+	/* Add the possible audible section at the start of the region */
+	AudioIntervalResult::const_iterator first_silence = silence.begin ();
+	if (first_silence->first != region->start()) {
+		audible.push_back (std::make_pair (r->start(), first_silence->first));
+	}
+
+	/* Add audible sections in the middle of the region */
+	for (AudioIntervalResult::const_iterator i = silence.begin (); i != silence.end(); ++i) {
+		AudioIntervalResult::const_iterator j = i;
+		++j;
 
-        while (s != silence.end()) {
+		if (j != silence.end ()) {
+			audible.push_back (std::make_pair (i->second, j->first));
+		}
+	}
 
-                framecnt_t interval_duration;
+	/* Add the possible audible section at the end of the region */
+	AudioIntervalResult::const_iterator last_silence = silence.end ();
+	--last_silence;
 
-                interval_duration = end - start;
+	frameoffset_t const end_of_region = r->start() + r->length();
 
+	if (last_silence->second != end_of_region - 1) {
+		audible.push_back (std::make_pair (last_silence->second, end_of_region - 1));
+	}
+
+	int n = 0;
+	int const N = audible.size ();
 
-                if (!in_silence && interval_duration > 0) {
+	for (AudioIntervalResult::const_iterator i = audible.begin(); i != audible.end(); ++i) {
 
-                        plist.clear ();
-                        plist.add (Properties::length, interval_duration);
-                        plist.add (Properties::position, region->position() + start);
+		PBD::PropertyList plist;
+		boost::shared_ptr<AudioRegion> copy;
 
-                        copy = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create 
-                                                                         (region, start, plist));
+		plist.add (Properties::length, i->second - i->first);
+		plist.add (Properties::position, r->position() + (i->first - r->start()));
 
-                        copy->set_name (RegionFactory::new_region_name (region->name ()));
+		copy = boost::dynamic_pointer_cast<AudioRegion> (
+			RegionFactory::create (region, (i->first - r->start()), plist)
+			);
 
-                        std::cerr << "New silent delineated region called " << copy->name()
-                                  << " @ " << copy->start() << " length = " << copy->length() << " pos = " << 
-                                copy->position() << std::endl;
+		copy->set_name (RegionFactory::new_region_name (region->name ()));
 
-                        copy->set_fade_in_active (true);
-                        copy->set_fade_in (FadeLinear, _fade_length);
-                        results.push_back (copy);
-                }
+		framecnt_t const f = std::min (_fade_length, (i->second - i->first));
 
-                start = end;
-                ++s;
-                end = s->first;
-                in_silence = !in_silence;
+		copy->set_fade_in_active (true);
+		copy->set_fade_in (FadeLinear, f);
+		copy->set_fade_out (FadeLinear, f);
+		results.push_back (copy);
 
-		if (progress) {
+		if (progress && (n <= N)) {
 			progress->set_progress (float (n) / N);
 		}
-		++n;
         }
 
 	return 0;