#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"
using namespace ARDOUR;
using namespace PBD;
-Glib::StaticMutex AudioSource::_level_buffer_lock = GLIBMM_STATIC_MUTEX_INIT;
-vector<Sample*> AudioSource::_mixdown_buffers;
-vector<gain_t*> AudioSource::_gain_buffers;
+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;
bool AudioSource::_build_missing_peakfiles = false;
_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;
_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;
}
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;
}
}
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;
int err = stat (audio_path.c_str(), &stat_file);
if (err) {
- _peaks_built = false;
- _peak_byte_max = 0;
+
+ /* no audio path - nested source or we can't
+ read it or ... whatever, use the peakfile as-is.
+ */
+
+ _peaks_built = true;
+ _peak_byte_max = statbuf.st_size;
+
} else {
/* allow 6 seconds slop on checking peak vs. file times because of various
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);
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;
#endif
nread = ::pread (peakfile_fd, peaks, sizeof (PeakData)* npeaks, first_peak_byte);
- delete peakfile_descriptor;
if (nread != sizeof (PeakData) * npeaks) {
cerr << "AudioSource["
*/
const framecnt_t chunksize = (framecnt_t) min (expected_peaks, 65536.0);
-
+
staging = new PeakData[chunksize];
/* compute the rounded up frame position */
adjusting zero_fill and npeaks and then breaking out of
this loop early
*/
-
+
memset (raw_staging, 0, sizeof (Sample) * chunksize);
-
+
} else {
-
+
to_read = min (chunksize, (_length - current_frame));
-
-
+
+
if ((frames_read = read_unlocked (raw_staging, current_frame, to_read)) == 0) {
error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3 of %4 (%5)"),
_name, to_read, current_frame, _length, strerror (errno))
goto out;
}
}
-
+
i = 0;
}
{
/* hold lock while building peaks */
- Glib::Mutex::Lock lp (_lock);
+ Glib::Threads::Mutex::Lock lp (_lock);
if (prepare_for_peakfile_writes ()) {
goto out;
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);
}
if (done) {
- Glib::Mutex::Lock lm (_peaks_ready_lock);
+ Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
_peaks_built = true;
PeaksReady (); /* EMIT SIGNAL */
}
_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 */
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 */
+ }
}
}
_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 */
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;
+ }
}
}
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 */
}
void
-AudioSource::allocate_working_buffers()
+AudioSource::allocate_working_buffers (framecnt_t framerate)
{
- assert(AudioDiskstream::disk_io_frames() > 0);
- _working_buffers_size = AudioDiskstream::disk_io_frames();
- /* we don't need any buffers allocated until
+ Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
+
+
+ /* Note: we don't need any buffers allocated until
a level 1 audiosource is created, at which
time we'll call ::ensure_buffers_for_level()
with the right value and do the right thing.
*/
+
+ if (!_mixdown_buffers.empty()) {
+ ensure_buffers_for_level_locked ( _mixdown_buffers.size(), framerate);
+ }
}
void
-AudioSource::ensure_buffers_for_level (uint32_t level)
+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);
+}
+
+void
+AudioSource::ensure_buffers_for_level_locked (uint32_t level, framecnt_t frame_rate)
+{
+ framecnt_t nframes = (framecnt_t) floor (Config->get_audio_playback_buffer_seconds() * frame_rate);
+
+ _mixdown_buffers.clear ();
+ _gain_buffers.clear ();
while (_mixdown_buffers.size() < level) {
- _mixdown_buffers.push_back (new Sample[_working_buffers_size]);
- _gain_buffers.push_back (new gain_t[_working_buffers_size]);
+ _mixdown_buffers.push_back (boost::shared_ptr<Sample> (new Sample[nframes]));
+ _gain_buffers.push_back (boost::shared_ptr<gain_t> (new gain_t[nframes]));
}
}