Merge branch 'master' into cairocanvas

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

diff --git a/libs/ardour/audiosource.cc b/libs/ardour/audiosource.cc
index e33a3d30dee670352ea62318b07d59c866c7a26d..3c6d4f81b869bd878ddf483f06b3d2b7175986c0 100644 (file)
--- a/libs/ardour/audiosource.cc
+++ b/libs/ardour/audiosource.cc
@@ -46,9 +46,9 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-Glib::StaticMutex AudioSource::_level_buffer_lock = GLIBMM_STATIC_MUTEX_INIT;
-vector<boost::shared_ptr<Sample> > AudioSource::_mixdown_buffers;
-vector<boost::shared_ptr<gain_t> > AudioSource::_gain_buffers;
+Glib::Threads::Mutex AudioSource::_level_buffer_lock;
+vector<boost::shared_array<Sample> > AudioSource::_mixdown_buffers;
+vector<boost::shared_array<gain_t> > AudioSource::_gain_buffers;
 size_t AudioSource::_working_buffers_size = 0;
 bool AudioSource::_build_missing_peakfiles = false;
 
@@ -160,7 +160,7 @@ bool
 AudioSource::peaks_ready (boost::function<void()> doThisWhenReady, ScopedConnection** connect_here_if_not, EventLoop* event_loop) const
 {
        bool ret;
-       Glib::Mutex::Lock lm (_peaks_ready_lock);
+       Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 
        if (!(ret = _peaks_built)) {
                *connect_here_if_not = new ScopedConnection;
@@ -182,7 +182,7 @@ AudioSource::touch_peakfile ()
        struct utimbuf tbuf;
 
        tbuf.actime = statbuf.st_atime;
-       tbuf.modtime = time ((time_t) 0);
+       tbuf.modtime = time ((time_t*) 0);
 
        utime (peakpath.c_str(), &tbuf);
 }
@@ -207,7 +207,7 @@ AudioSource::rename_peakfile (string newpath)
 }
 
 int
-AudioSource::initialize_peakfile (bool newfile, string audio_path)
+AudioSource::initialize_peakfile (string audio_path)
 {
        struct stat statbuf;
 
@@ -215,7 +215,7 @@ AudioSource::initialize_peakfile (bool newfile, string audio_path)
 
        /* if the peak file should be there, but isn't .... */
 
-       if (!newfile && !Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
+       if (!empty() && !Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
                peakpath = find_broken_peakfile (peakpath, audio_path);
        }
 
@@ -269,7 +269,7 @@ AudioSource::initialize_peakfile (bool newfile, string audio_path)
                }
        }
 
-       if (!newfile && !_peaks_built && _build_missing_peakfiles && _build_peakfiles) {
+       if (!empty() && !_peaks_built && _build_missing_peakfiles && _build_peakfiles) {
                build_peaks_from_scratch ();
        }
 
@@ -281,14 +281,14 @@ AudioSource::read (Sample *dst, framepos_t start, framecnt_t cnt, int /*channel*
 {
        assert (cnt >= 0);
        
-       Glib::Mutex::Lock lm (_lock);
+       Glib::Threads::Mutex::Lock lm (_lock);
        return read_unlocked (dst, start, cnt);
 }
 
 framecnt_t
 AudioSource::write (Sample *dst, framecnt_t cnt)
 {
-       Glib::Mutex::Lock lm (_lock);
+       Glib::Threads::Mutex::Lock lm (_lock);
        /* any write makes the fill not removable */
        _flags = Flag (_flags & ~Removable);
        return write_unlocked (dst, cnt);
@@ -308,7 +308,7 @@ int
 AudioSource::read_peaks_with_fpp (PeakData *peaks, framecnt_t npeaks, framepos_t start, framecnt_t cnt,
                                  double samples_per_visual_peak, framecnt_t samples_per_file_peak) const
 {
-       Glib::Mutex::Lock lm (_lock);
+       Glib::Threads::Mutex::Lock lm (_lock);
        double scale;
        double expected_peaks;
        PeakData::PeakDatum xmax;
@@ -342,7 +342,7 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, framecnt_t npeaks, framepos_t
        /* fix for near-end-of-file conditions */
 
        if (cnt > _length - start) {
-               // cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << endl;
+               // cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << " (" << _length - start << ")" << endl;
                cnt = _length - start;
                framecnt_t old = npeaks;
                npeaks = min ((framecnt_t) floor (cnt / samples_per_visual_peak), npeaks);
@@ -527,6 +527,7 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, framecnt_t npeaks, framepos_t
                }
 
                if (zero_fill) {
+                       cerr << "Zero fill end of peaks (@ " << npeaks << " with " << zero_fill << endl;
                        memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
                }
 
@@ -646,7 +647,7 @@ AudioSource::build_peaks_from_scratch ()
        {
                /* hold lock while building peaks */
 
-               Glib::Mutex::Lock lp (_lock);
+               Glib::Threads::Mutex::Lock lp (_lock);
 
                if (prepare_for_peakfile_writes ()) {
                        goto out;
@@ -717,7 +718,7 @@ AudioSource::done_with_peakfile_writes (bool done)
        }
 
        if (done) {
-               Glib::Mutex::Lock lm (_peaks_ready_lock);
+               Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
                _peaks_built = true;
                PeaksReady (); /* EMIT SIGNAL */
        }
@@ -777,7 +778,7 @@ AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, frame
                        _peak_byte_max = max (_peak_byte_max, (off_t) (byte + sizeof(PeakData)));
 
                        {
-                               Glib::Mutex::Lock lm (_peaks_ready_lock);
+                               Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
                                PeakRangeReady (peak_leftover_frame, peak_leftover_cnt); /* EMIT SIGNAL */
                                if (intermediate_peaks_ready) {
                                        PeaksReady (); /* EMIT SIGNAL */
@@ -890,7 +891,7 @@ AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, frame
        _peak_byte_max = max (_peak_byte_max, (off_t) (first_peak_byte + sizeof(PeakData)*peaks_computed));
 
        if (frames_done) {
-               Glib::Mutex::Lock lm (_peaks_ready_lock);
+               Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
                PeakRangeReady (first_frame, frames_done); /* EMIT SIGNAL */
                if (intermediate_peaks_ready) {
                        PeaksReady (); /* EMIT SIGNAL */
@@ -948,7 +949,7 @@ AudioSource::available_peaks (double zoom_factor) const
 void
 AudioSource::mark_streaming_write_completed ()
 {
-       Glib::Mutex::Lock lm (_peaks_ready_lock);
+       Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 
        if (_peaks_built) {
                PeaksReady (); /* EMIT SIGNAL */
@@ -958,7 +959,7 @@ AudioSource::mark_streaming_write_completed ()
 void
 AudioSource::allocate_working_buffers (framecnt_t framerate)
 {
-       Glib::Mutex::Lock lm (_level_buffer_lock);
+       Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
 
 
        /* Note: we don't need any buffers allocated until
@@ -975,7 +976,7 @@ AudioSource::allocate_working_buffers (framecnt_t framerate)
 void
 AudioSource::ensure_buffers_for_level (uint32_t level, framecnt_t frame_rate)
 {
-       Glib::Mutex::Lock lm (_level_buffer_lock);
+       Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
        ensure_buffers_for_level_locked (level, frame_rate);
 }
 
@@ -984,11 +985,19 @@ AudioSource::ensure_buffers_for_level_locked (uint32_t level, framecnt_t frame_r
 {
        framecnt_t nframes = (framecnt_t) floor (Config->get_audio_playback_buffer_seconds() * frame_rate);
 
+       /* this may be called because either "level" or "frame_rate" have
+        * changed. and it may be called with "level" smaller than the current
+        * number of buffers, because a new compound region has been created at
+        * a more shallow level than the deepest one we currently have.
+        */
+
+       uint32_t limit = max ((size_t) level, _mixdown_buffers.size());
+
        _mixdown_buffers.clear ();
        _gain_buffers.clear ();
 
-       while (_mixdown_buffers.size() < level) {
-               _mixdown_buffers.push_back (boost::shared_ptr<Sample> (new Sample[nframes]));
-               _gain_buffers.push_back (boost::shared_ptr<gain_t> (new gain_t[nframes]));
+       for (uint32_t n = 0; n < limit; ++n) {
+               _mixdown_buffers.push_back (boost::shared_array<Sample> (new Sample[nframes]));
+               _gain_buffers.push_back (boost::shared_array<gain_t> (new gain_t[nframes]));
        }
 }