implement file-[un]archive progress report

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

diff --git a/libs/ardour/audioregion.cc b/libs/ardour/audioregion.cc
index dff261a9dfe2f87a405a65ebb01f8bb1031b5d92..873d4119d45e505c0dbb36ce1c4381e418ec20f5 100644 (file)
--- a/libs/ardour/audioregion.cc
+++ b/libs/ardour/audioregion.cc
@@ -55,7 +55,7 @@
 #include "ardour/coreaudiosource.h"
 #endif // HAVE_COREAUDIO
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 #include <locale.h>
 
 using namespace std;
@@ -279,7 +279,7 @@ AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other)
        assert (_sources.size() == _master_sources.size());
 }
 
-AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, framecnt_t offset, const int32_t& sub_num)
+AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, framecnt_t offset, const int32_t sub_num)
        : Region (other, offset, sub_num)
        , AUDIOREGION_COPY_STATE (other)
          /* As far as I can see, the _envelope's times are relative to region position, and have nothing
@@ -1402,9 +1402,6 @@ AudioRegion::set_scale_amplitude (gain_t g)
        send_change (PropertyChange (Properties::scale_amplitude));
 }
 
-/** @return the maximum (linear) amplitude of the region, or a -ve
- *  number if the Progress object reports that the process was cancelled.
- */
 double
 AudioRegion::maximum_amplitude (Progress* p) const
 {
@@ -1444,6 +1441,45 @@ AudioRegion::maximum_amplitude (Progress* p) const
        return maxamp;
 }
 
+double
+AudioRegion::rms (Progress* p) const
+{
+       framepos_t fpos = _start;
+       framepos_t const fend = _start + _length;
+       uint32_t const n_chan = n_channels ();
+       double rms = 0;
+
+       framecnt_t const blocksize = 64 * 1024;
+       Sample buf[blocksize];
+
+       framecnt_t total = 0;
+
+       if (n_chan == 0) {
+               return 0;
+       }
+
+       while (fpos < fend) {
+               framecnt_t const to_read = min (fend - fpos, blocksize);
+               total += to_read;
+               for (uint32_t c = 0; c < n_chan; ++c) {
+                       if (read_raw_internal (buf, fpos, to_read, c) != to_read) {
+                               return 0;
+                       }
+                       for (framepos_t i = 0; i < to_read; ++i) {
+                               rms += buf[i] * buf[i];
+                       }
+                       fpos += to_read;
+                       if (p) {
+                               p->set_progress (float (fpos - _start) / _length);
+                               if (p->cancelled ()) {
+                                       return -1;
+                               }
+                       }
+               }
+       }
+       return sqrt (rms / (double)(total * n_chan));
+}
+
 /** Normalize using a given maximum amplitude and target, so that region
  *  _scale_amplitude becomes target / max_amplitude.
  */