match *.[mM][iI][dD][iI]$ as well as *.[mM][iI][dD] files when looking for MIDI files

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

diff --git a/libs/ardour/audiosource.cc b/libs/ardour/audiosource.cc
index aeb5f12baecd5d2412d5ddc099054aa673af9552..4deb053cd8f0bf3a2b4a06d6db878447b0d2eac9 100644 (file)
--- a/libs/ardour/audiosource.cc
+++ b/libs/ardour/audiosource.cc
@@ -35,13 +35,9 @@
 #include <glibmm/miscutils.h>
 
 #include "pbd/xml++.h"
-#include "pbd/pthread_utils.h"
 
 #include "ardour/audiosource.h"
-#include "ardour/audio_diskstream.h"
-#include "ardour/cycle_timer.h"
-#include "ardour/session.h"
-#include "ardour/transient_detector.h"
+#include "ardour/rc_configuration.h"
 #include "ardour/runtime_functions.h"
 
 #include "i18n.h"
@@ -50,7 +46,7 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-Glib::StaticMutex AudioSource::_level_buffer_lock = GLIBMM_STATIC_MUTEX_INIT;
+Glib::Threads::Mutex AudioSource::_level_buffer_lock;
 vector<boost::shared_ptr<Sample> > AudioSource::_mixdown_buffers;
 vector<boost::shared_ptr<gain_t> > AudioSource::_gain_buffers;
 size_t AudioSource::_working_buffers_size = 0;
@@ -68,8 +64,6 @@ AudioSource::AudioSource (Session& s, string name)
        _peaks_built = false;
        _peak_byte_max = 0;
        _peakfile_descriptor = 0;
-       _read_data_count = 0;
-       _write_data_count = 0;
        peak_leftover_cnt = 0;
        peak_leftover_size = 0;
        peak_leftovers = 0;
@@ -83,8 +77,6 @@ AudioSource::AudioSource (Session& s, const XMLNode& node)
        _peaks_built = false;
        _peak_byte_max = 0;
        _peakfile_descriptor = 0;
-       _read_data_count = 0;
-       _write_data_count = 0;
        peak_leftover_cnt = 0;
        peak_leftover_size = 0;
        peak_leftovers = 0;
@@ -143,10 +135,10 @@ AudioSource::length (framepos_t /*pos*/) const
 }
 
 void
-AudioSource::update_length (framepos_t pos, framecnt_t cnt)
+AudioSource::update_length (framecnt_t len)
 {
-       if (pos + cnt > _length) {
-               _length = pos + cnt;
+       if (len > _length) {
+               _length = len;
        }
 }
 
@@ -168,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;
@@ -287,14 +279,16 @@ AudioSource::initialize_peakfile (bool newfile, string audio_path)
 framecnt_t
 AudioSource::read (Sample *dst, framepos_t start, framecnt_t cnt, int /*channel*/) const
 {
-       Glib::Mutex::Lock lm (_lock);
+       assert (cnt >= 0);
+       
+       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);
@@ -314,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;
@@ -400,7 +394,6 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, framecnt_t npeaks, framepos_t
 #endif
 
                nread = ::pread (peakfile_fd, peaks, sizeof (PeakData)* npeaks, first_peak_byte);
-               delete peakfile_descriptor;
 
                if (nread != sizeof (PeakData) * npeaks) {
                        cerr << "AudioSource["
@@ -653,7 +646,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;
@@ -669,8 +662,7 @@ AudioSource::build_peaks_from_scratch ()
 
                        framecnt_t frames_to_read = min (bufsize, cnt);
                        framecnt_t frames_read;
-
-
+                       
                        if ((frames_read = read_unlocked (buf, current_frame, frames_to_read)) != frames_to_read) {
                                error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
                                done_with_peakfile_writes (false);
@@ -725,7 +717,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 */
        }
@@ -785,7 +777,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 */
@@ -884,8 +876,9 @@ AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, frame
                off_t target_length = blocksize * ((first_peak_byte + blocksize + 1) / blocksize);
 
                if (endpos < target_length) {
-                       (void) ftruncate (_peakfile_fd, target_length);
-                       /* error doesn't actually matter though, so continue on without testing */
+                       if (ftruncate (_peakfile_fd, target_length)) {
+                               /* error doesn't actually matter so continue on without testing */
+                       }
                }
        }
 
@@ -897,7 +890,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 */
@@ -927,7 +920,10 @@ AudioSource::truncate_peakfile ()
        off_t end = lseek (_peakfile_fd, 0, SEEK_END);
 
        if (end > _peak_byte_max) {
-               (void) ftruncate (_peakfile_fd, _peak_byte_max);
+               if (ftruncate (_peakfile_fd, _peak_byte_max)) {
+                       error << string_compose (_("could not truncate peakfile %1 to %2 (error: %3)"),
+                                                peakpath, _peak_byte_max, errno) << endmsg;
+               }
        }
 }
 
@@ -949,22 +945,10 @@ AudioSource::available_peaks (double zoom_factor) const
        return (end/sizeof(PeakData)) * _FPP;
 }
 
-void
-AudioSource::dec_read_data_count (framecnt_t cnt)
-{
-        uint32_t val = cnt * sizeof (Sample);
-
-        if (val < _read_data_count) {
-                _read_data_count -= val;
-        } else {
-                _read_data_count = 0;
-        }
-}
-
 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 */
@@ -974,7 +958,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
@@ -991,7 +975,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);
 }