#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;
+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;
_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;
{
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);
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["
{
/* hold lock while building peaks */
- Glib::Mutex::Lock lp (_lock);
+ Glib::Threads::Mutex::Lock lp (_lock);
if (prepare_for_peakfile_writes ()) {
goto out;
}
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 (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
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);
}