#include <ctime>
#include <cmath>
#include <iomanip>
-#include <fstream>
#include <algorithm>
#include <vector>
#endif
#include <glib.h>
-#include <glib/gstdio.h>
+#include "pbd/gstdio_compat.h"
#include <boost/scoped_ptr.hpp>
#include <glibmm/fileutils.h>
#include <glibmm/miscutils.h>
+#include "pbd/file_utils.h"
#include "pbd/scoped_file_descriptor.h"
#include "pbd/xml++.h"
#include "ardour/audiosource.h"
#include "ardour/rc_configuration.h"
#include "ardour/runtime_functions.h"
+#include "ardour/session.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
#include "ardour/debug.h"
#define _FPP 256
-AudioSource::AudioSource (Session& s, string name)
+AudioSource::AudioSource (Session& s, const string& name)
: Source (s, DataType::AUDIO, name)
, _length (0)
, _peak_byte_max (0)
XMLNode& node (Source::get_state());
if (_captured_for.length()) {
- node.add_property ("captured-for", _captured_for);
+ node.set_property ("captured-for", _captured_for);
}
return node;
int
AudioSource::set_state (const XMLNode& node, int /*version*/)
{
- const XMLProperty* prop;
-
- if ((prop = node.property ("captured-for")) != 0) {
- _captured_for = prop->value();
- }
-
+ node.get_property ("captured-for", _captured_for);
return 0;
}
return _length == 0;
}
-framecnt_t
-AudioSource::length (framepos_t /*pos*/) const
+samplecnt_t
+AudioSource::length (samplepos_t /*pos*/) const
{
return _length;
}
void
-AudioSource::update_length (framecnt_t len)
+AudioSource::update_length (samplecnt_t len)
{
if (len > _length) {
_length = len;
{
GStatBuf statbuf;
- if (g_stat (peakpath.c_str(), &statbuf) != 0 || statbuf.st_size == 0) {
+ if (g_stat (_peakpath.c_str(), &statbuf) != 0 || statbuf.st_size == 0) {
return;
}
tbuf.actime = statbuf.st_atime;
tbuf.modtime = time ((time_t*) 0);
- g_utime (peakpath.c_str(), &tbuf);
+ g_utime (_peakpath.c_str(), &tbuf);
}
int
{
/* caller must hold _lock */
- string oldpath = peakpath;
+ string oldpath = _peakpath;
if (Glib::file_test (oldpath, Glib::FILE_TEST_EXISTS)) {
if (g_rename (oldpath.c_str(), newpath.c_str()) != 0) {
}
}
- peakpath = newpath;
+ _peakpath = newpath;
return 0;
}
int
-AudioSource::initialize_peakfile (string audio_path)
+AudioSource::initialize_peakfile (const string& audio_path, const bool in_session)
{
+ Glib::Threads::Mutex::Lock lm (_initialize_peaks_lock);
GStatBuf statbuf;
- peakpath = peak_path (audio_path);
-
- DEBUG_TRACE(DEBUG::Peaks, string_compose ("Initialize Peakfile %1 for Audio file %2\n", peakpath, audio_path));
-
- /* if the peak file should be there, but isn't .... */
+ _peakpath = construct_peak_filepath (audio_path, in_session);
- if (!empty() && !Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
- peakpath = find_broken_peakfile (peakpath, audio_path);
+ if (!empty() && !Glib::file_test (_peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
+ string oldpeak = construct_peak_filepath (audio_path, in_session, true);
+ DEBUG_TRACE(DEBUG::Peaks, string_compose ("Looking for old peak file %1 for Audio file %2\n", oldpeak, audio_path));
+ if (Glib::file_test (oldpeak.c_str(), Glib::FILE_TEST_EXISTS)) {
+ // TODO use hard-link if possible
+ DEBUG_TRACE(DEBUG::Peaks, string_compose ("Copy old peakfile %1 to %2\n", oldpeak, _peakpath));
+ PBD::copy_file (oldpeak, _peakpath);
+ }
}
- if (g_stat (peakpath.c_str(), &statbuf)) {
+ DEBUG_TRACE(DEBUG::Peaks, string_compose ("Initialize Peakfile %1 for Audio file %2\n", _peakpath, audio_path));
+
+ if (g_stat (_peakpath.c_str(), &statbuf)) {
if (errno != ENOENT) {
/* it exists in the peaks dir, but there is some kind of error */
- error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), peakpath) << endmsg;
+ error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), _peakpath) << endmsg;
return -1;
}
- DEBUG_TRACE(DEBUG::Peaks, string_compose("Peakfile %1 does not exist\n", peakpath));
+ DEBUG_TRACE(DEBUG::Peaks, string_compose("Peakfile %1 does not exist\n", _peakpath));
_peaks_built = false;
/* we found it in the peaks dir, so check it out */
if (statbuf.st_size == 0 || (statbuf.st_size < (off_t) ((length(_timeline_position) / _FPP) * sizeof (PeakData)))) {
- DEBUG_TRACE(DEBUG::Peaks, string_compose("Peakfile %1 is empty\n", peakpath));
+ DEBUG_TRACE(DEBUG::Peaks, string_compose("Peakfile %1 is empty\n", _peakpath));
_peaks_built = false;
} else {
// Check if the audio file has changed since the peakfile was built.
/* no audio path - nested source or we can't
read it or ... whatever, use the peakfile as-is.
*/
- DEBUG_TRACE(DEBUG::Peaks, string_compose("Error when calling stat on Peakfile %1\n", peakpath));
+ DEBUG_TRACE(DEBUG::Peaks, string_compose("Error when calling stat on Peakfile %1\n", _peakpath));
_peaks_built = true;
_peak_byte_max = statbuf.st_size;
return 0;
}
-framecnt_t
-AudioSource::read (Sample *dst, framepos_t start, framecnt_t cnt, int /*channel*/) const
+samplecnt_t
+AudioSource::read (Sample *dst, samplepos_t start, samplecnt_t cnt, int /*channel*/) const
{
assert (cnt >= 0);
-
+
Glib::Threads::Mutex::Lock lm (_lock);
return read_unlocked (dst, start, cnt);
}
-framecnt_t
-AudioSource::write (Sample *dst, framecnt_t cnt)
+samplecnt_t
+AudioSource::write (Sample *dst, samplecnt_t cnt)
{
Glib::Threads::Mutex::Lock lm (_lock);
/* any write makes the file not removable */
}
int
-AudioSource::read_peaks (PeakData *peaks, framecnt_t npeaks, framepos_t start, framecnt_t cnt, double samples_per_visual_peak) const
+AudioSource::read_peaks (PeakData *peaks, samplecnt_t npeaks, samplepos_t start, samplecnt_t cnt, double samples_per_visual_peak) const
{
return read_peaks_with_fpp (peaks, npeaks, start, cnt, samples_per_visual_peak, _FPP);
}
*/
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
+AudioSource::read_peaks_with_fpp (PeakData *peaks, samplecnt_t npeaks, samplepos_t start, samplecnt_t cnt,
+ double samples_per_visual_peak, samplecnt_t samples_per_file_peak) const
{
Glib::Threads::Mutex::Lock lm (_lock);
double scale;
#else
const int bufsize = sysconf(_SC_PAGESIZE);
#endif
- framecnt_t read_npeaks = npeaks;
- framecnt_t zero_fill = 0;
+ samplecnt_t read_npeaks = npeaks;
+ samplecnt_t zero_fill = 0;
GStatBuf statbuf;
expected_peaks = (cnt / (double) samples_per_file_peak);
- if (g_stat (peakpath.c_str(), &statbuf) != 0) {
- error << string_compose (_("Cannot open peakfile @ %1 for size check (%2)"), peakpath, strerror (errno)) << endmsg;
+ if (g_stat (_peakpath.c_str(), &statbuf) != 0) {
+ error << string_compose (_("Cannot open peakfile @ %1 for size check (%2)"), _peakpath, strerror (errno)) << endmsg;
return -1;
}
if (!_captured_for.empty()) {
-
+
/* _captured_for is only set after a capture pass is
* complete. so we know that capturing is finished for this
* file, and now we can check actual size of the peakfile is at
*
* XXX this may not work for destructive recording, but we
* might decided to get rid of that anyway.
- *
+ *
*/
-
+
const off_t expected_file_size = (_length / (double) samples_per_file_peak) * sizeof (PeakData);
-
+
if (statbuf.st_size < expected_file_size) {
- warning << string_compose (_("peak file %1 is truncated from %2 to %3"), peakpath, expected_file_size, statbuf.st_size) << endmsg;
+ warning << string_compose (_("peak file %1 is truncated from %2 to %3"), _peakpath, expected_file_size, statbuf.st_size) << endmsg;
+ lm.release(); // build_peaks_from_scratch() takes _lock
const_cast<AudioSource*>(this)->build_peaks_from_scratch ();
- if (g_stat (peakpath.c_str(), &statbuf) != 0) {
- error << string_compose (_("Cannot open peakfile @ %1 for size check (%2) after rebuild"), peakpath, strerror (errno)) << endmsg;
+ lm.acquire ();
+ if (g_stat (_peakpath.c_str(), &statbuf) != 0) {
+ error << string_compose (_("Cannot open peakfile @ %1 for size check (%2) after rebuild"), _peakpath, strerror (errno)) << endmsg;
}
if (statbuf.st_size < expected_file_size) {
fatal << "peak file is still truncated after rebuild" << endmsg;
}
}
- ScopedFileDescriptor sfd (g_open (peakpath.c_str(), O_RDONLY, 0444));
+ ScopedFileDescriptor sfd (g_open (_peakpath.c_str(), O_RDONLY, 0444));
if (sfd < 0) {
- error << string_compose (_("Cannot open peakfile @ %1 for reading (%2)"), peakpath, strerror (errno)) << endmsg;
+ error << string_compose (_("Cannot open peakfile @ %1 for reading (%2)"), _peakpath, strerror (errno)) << endmsg;
return -1;
}
-
+
scale = npeaks/expected_peaks;
/* fix for near-end-of-file conditions */
- if (cnt > _length - start) {
+ if (cnt + start > _length) {
// cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << " (" << _length - start << ")" << endl;
- cnt = _length - start;
- read_npeaks = min ((framecnt_t) floor (cnt / samples_per_visual_peak), npeaks);
+ cnt = std::max ((samplecnt_t)0, _length - start);
+ read_npeaks = min ((samplecnt_t) floor (cnt / samples_per_visual_peak), npeaks);
zero_fill = npeaks - read_npeaks;
expected_peaks = (cnt / (double) samples_per_file_peak);
scale = npeaks/expected_peaks;
}
+ assert (cnt >= 0);
+
// cerr << "actual npeaks = " << read_npeaks << " zf = " << zero_fill << endl;
if (npeaks == cnt) {
return -1;
}
- for (framecnt_t i = 0; i < npeaks; ++i) {
+ for (samplecnt_t i = 0; i < npeaks; ++i) {
peaks[i].max = raw_staging[i];
peaks[i].min = raw_staging[i];
}
map_handle = CreateFileMapping(file_handle, NULL, PAGE_READONLY, 0, 0, NULL);
if (map_handle == NULL) {
- error << string_compose (_("map failed - could not create file mapping for peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("map failed - could not create file mapping for peakfile %1."), _peakpath) << endmsg;
return -1;
}
view_handle = MapViewOfFile(map_handle, FILE_MAP_READ, 0, read_map_off, map_length);
if (view_handle == NULL) {
- error << string_compose (_("map failed - could not map peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("map failed - could not map peakfile %1."), _peakpath) << endmsg;
return -1;
}
err_flag = UnmapViewOfFile (view_handle);
err_flag = CloseHandle(map_handle);
if(!err_flag) {
- error << string_compose (_("unmap failed - could not unmap peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("unmap failed - could not unmap peakfile %1."), _peakpath) << endmsg;
return -1;
}
#else
addr = (char*) mmap (0, map_length, PROT_READ, MAP_PRIVATE, sfd, read_map_off);
if (addr == MAP_FAILED) {
- error << string_compose (_("map failed - could not mmap peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("map failed - could not mmap peakfile %1."), _peakpath) << endmsg;
return -1;
}
/* the caller wants:
- - more frames-per-peak (lower resolution) than the peakfile, or to put it another way,
+ - more samples-per-peak (lower resolution) than the peakfile, or to put it another way,
- less peaks than the peakfile holds for the same range
So, read a block into a staging area, and then downsample from there.
to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks
*/
- const framecnt_t chunksize = (framecnt_t) expected_peaks; // we read all the peaks we need in one hit.
+ const samplecnt_t chunksize = (samplecnt_t) expected_peaks; // we read all the peaks we need in one hit.
- /* compute the rounded up frame position */
+ /* compute the rounded up sample position */
- framepos_t current_stored_peak = (framepos_t) ceil (start / (double) samples_per_file_peak);
- framepos_t next_visual_peak = (framepos_t) ceil (start / samples_per_visual_peak);
- double next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
- framepos_t stored_peak_before_next_visual_peak = (framepos_t) next_visual_peak_frame / samples_per_file_peak;
- framecnt_t nvisual_peaks = 0;
+ samplepos_t current_stored_peak = (samplepos_t) ceil (start / (double) samples_per_file_peak);
+ samplepos_t next_visual_peak = (samplepos_t) ceil (start / samples_per_visual_peak);
+ double next_visual_peak_sample = next_visual_peak * samples_per_visual_peak;
+ samplepos_t stored_peak_before_next_visual_peak = (samplepos_t) next_visual_peak_sample / samples_per_file_peak;
+ samplecnt_t nvisual_peaks = 0;
uint32_t i = 0;
/* handle the case where the initial visual peak is on a pixel boundary */
map_handle = CreateFileMapping(file_handle, NULL, PAGE_READONLY, 0, 0, NULL);
if (map_handle == NULL) {
- error << string_compose (_("map failed - could not create file mapping for peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("map failed - could not create file mapping for peakfile %1."), _peakpath) << endmsg;
return -1;
}
view_handle = MapViewOfFile(map_handle, FILE_MAP_READ, 0, read_map_off, map_length);
if (view_handle == NULL) {
- error << string_compose (_("map failed - could not map peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("map failed - could not map peakfile %1."), _peakpath) << endmsg;
return -1;
}
err_flag = UnmapViewOfFile (view_handle);
err_flag = CloseHandle(map_handle);
if(!err_flag) {
- error << string_compose (_("unmap failed - could not unmap peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("unmap failed - could not unmap peakfile %1."), _peakpath) << endmsg;
return -1;
}
#else
addr = (char*) mmap (0, map_length, PROT_READ, MAP_PRIVATE, sfd, read_map_off);
if (addr == MAP_FAILED) {
- error << string_compose (_("map failed - could not mmap peakfile %1."), peakpath) << endmsg;
+ error << string_compose (_("map failed - could not mmap peakfile %1."), _peakpath) << endmsg;
return -1;
}
peak_cache[nvisual_peaks].max = xmax;
peak_cache[nvisual_peaks].min = xmin;
++nvisual_peaks;
- next_visual_peak_frame = min ((double) start + cnt, (next_visual_peak_frame + samples_per_visual_peak));
- stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / samples_per_file_peak;
+ next_visual_peak_sample = min ((double) start + cnt, (next_visual_peak_sample + samples_per_visual_peak));
+ stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_sample / samples_per_file_peak;
}
if (zero_fill) {
/* the caller wants
- - less frames-per-peak (more resolution)
+ - less samples-per-peak (more resolution)
- more peaks than stored in the Peakfile
So, fetch data from the raw source, and generate peak
data on the fly.
*/
- framecnt_t frames_read = 0;
- framepos_t current_frame = start;
- framecnt_t i = 0;
- framecnt_t nvisual_peaks = 0;
- framecnt_t chunksize = (framecnt_t) min (cnt, (framecnt_t) 4096);
+ samplecnt_t samples_read = 0;
+ samplepos_t current_sample = start;
+ samplecnt_t i = 0;
+ samplecnt_t nvisual_peaks = 0;
+ samplecnt_t chunksize = (samplecnt_t) min (cnt, (samplecnt_t) 4096);
boost::scoped_array<Sample> raw_staging(new Sample[chunksize]);
- framepos_t frame_pos = start;
- double pixel_pos = floor (frame_pos / samples_per_visual_peak);
- double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
- double pixels_per_frame = 1.0 / samples_per_visual_peak;
+ samplepos_t sample_pos = start;
+ double pixel_pos = floor (sample_pos / samples_per_visual_peak);
+ double next_pixel_pos = ceil (sample_pos / samples_per_visual_peak);
+ double pixels_per_sample = 1.0 / samples_per_visual_peak;
xmin = 1.0;
xmax = -1.0;
while (nvisual_peaks < read_npeaks) {
- if (i == frames_read) {
+ if (i == samples_read) {
- to_read = min (chunksize, (framecnt_t)(_length - current_frame));
+ to_read = min (chunksize, (samplecnt_t)(_length - current_sample));
- if (current_frame >= _length) {
+ if (current_sample >= _length) {
/* hmm, error condition - we've reached the end of the file
without generating all the peak data. cook up a zero-filled
} else {
- to_read = min (chunksize, (_length - current_frame));
+ to_read = min (chunksize, (_length - current_sample));
- if ((frames_read = read_unlocked (raw_staging.get(), current_frame, to_read)) == 0) {
+ if ((samples_read = read_unlocked (raw_staging.get(), current_sample, 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))
+ _name, to_read, current_sample, _length, strerror (errno))
<< endmsg;
return -1;
}
xmax = max (xmax, raw_staging[i]);
xmin = min (xmin, raw_staging[i]);
++i;
- ++current_frame;
- pixel_pos += pixels_per_frame;
+ ++current_sample;
+ pixel_pos += pixels_per_sample;
if (pixel_pos >= next_pixel_pos) {
int
AudioSource::build_peaks_from_scratch ()
{
- const framecnt_t bufsize = 65536; // 256kB per disk read for mono data is about ideal
+ const samplecnt_t bufsize = 65536; // 256kB per disk read for mono data is about ideal
DEBUG_TRACE (DEBUG::Peaks, "Building peaks from scratch\n");
/* hold lock while building peaks */
Glib::Threads::Mutex::Lock lp (_lock);
-
+
if (prepare_for_peakfile_writes ()) {
goto out;
}
- framecnt_t current_frame = 0;
- framecnt_t cnt = _length;
+ samplecnt_t current_sample = 0;
+ samplecnt_t cnt = _length;
_peaks_built = false;
boost::scoped_array<Sample> buf(new Sample[bufsize]);
while (cnt) {
- framecnt_t frames_to_read = min (bufsize, cnt);
- framecnt_t frames_read;
-
- if ((frames_read = read_unlocked (buf.get(), current_frame, frames_to_read)) != frames_to_read) {
+ samplecnt_t samples_to_read = min (bufsize, cnt);
+ samplecnt_t samples_read;
+
+ if ((samples_read = read_unlocked (buf.get(), current_sample, samples_to_read)) != samples_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);
goto out;
}
- if (compute_and_write_peaks (buf.get(), current_frame, frames_read, true, false, _FPP)) {
+ lp.release(); // allow butler to refill buffers
+
+ if (_session.deletion_in_progress() || _session.peaks_cleanup_in_progres()) {
+ cerr << "peak file creation interrupted: " << _name << endmsg;
+ lp.acquire();
+ done_with_peakfile_writes (false);
+ goto out;
+ }
+
+ if (compute_and_write_peaks (buf.get(), current_sample, samples_read, true, false, _FPP)) {
break;
}
- current_frame += frames_read;
- cnt -= frames_read;
+ current_sample += samples_read;
+ cnt -= samples_read;
+
+ lp.acquire();
}
if (cnt == 0) {
out:
if (ret) {
- DEBUG_TRACE (DEBUG::Peaks, string_compose("Could not write peak data, attempting to remove peakfile %1\n", peakpath));
- ::g_unlink (peakpath.c_str());
+ DEBUG_TRACE (DEBUG::Peaks, string_compose("Could not write peak data, attempting to remove peakfile %1\n", _peakpath));
+ ::g_unlink (_peakpath.c_str());
}
return ret;
}
+int
+AudioSource::close_peakfile ()
+{
+ Glib::Threads::Mutex::Lock lp (_lock);
+ if (_peakfile_fd >= 0) {
+ close (_peakfile_fd);
+ _peakfile_fd = -1;
+ }
+ if (!_peakpath.empty()) {
+ ::g_unlink (_peakpath.c_str());
+ }
+ _peaks_built = false;
+ return 0;
+}
+
int
AudioSource::prepare_for_peakfile_writes ()
{
- if ((_peakfile_fd = g_open (peakpath.c_str(), O_CREAT|O_RDWR, 0664)) < 0) {
- error << string_compose(_("AudioSource: cannot open peakpath (c) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
+ if (_session.deletion_in_progress() || _session.peaks_cleanup_in_progres()) {
+ return -1;
+ }
+
+ if ((_peakfile_fd = g_open (_peakpath.c_str(), O_CREAT|O_RDWR, 0664)) < 0) {
+ error << string_compose(_("AudioSource: cannot open _peakpath (c) \"%1\" (%2)"), _peakpath, strerror (errno)) << endmsg;
return -1;
}
return 0;
void
AudioSource::done_with_peakfile_writes (bool done)
{
+ if (_session.deletion_in_progress() || _session.peaks_cleanup_in_progres()) {
+ if (_peakfile_fd) {
+ close (_peakfile_fd);
+ _peakfile_fd = -1;
+ }
+ return;
+ }
+
if (peak_leftover_cnt) {
compute_and_write_peaks (0, 0, 0, true, false, _FPP);
}
_peakfile_fd = -1;
}
-/** @param first_frame Offset from the source start of the first frame to
+/** @param first_sample Offset from the source start of the first sample to
* process. _lock MUST be held by caller.
*/
int
-AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
+AudioSource::compute_and_write_peaks (Sample* buf, samplecnt_t first_sample, samplecnt_t cnt,
bool force, bool intermediate_peaks_ready)
{
- return compute_and_write_peaks (buf, first_frame, cnt, force, intermediate_peaks_ready, _FPP);
+ return compute_and_write_peaks (buf, first_sample, cnt, force, intermediate_peaks_ready, _FPP);
}
int
-AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
- bool force, bool intermediate_peaks_ready, framecnt_t fpp)
+AudioSource::compute_and_write_peaks (Sample* buf, samplecnt_t first_sample, samplecnt_t cnt,
+ bool force, bool intermediate_peaks_ready, samplecnt_t fpp)
{
- framecnt_t to_do;
+ samplecnt_t to_do;
uint32_t peaks_computed;
- framepos_t current_frame;
- framecnt_t frames_done;
+ samplepos_t current_sample;
+ samplecnt_t samples_done;
const size_t blocksize = (128 * 1024);
off_t first_peak_byte;
boost::scoped_array<Sample> buf2;
restart:
if (peak_leftover_cnt) {
- if (first_frame != peak_leftover_frame + peak_leftover_cnt) {
+ if (first_sample != peak_leftover_sample + peak_leftover_cnt) {
/* uh-oh, ::seek() since the last ::compute_and_write_peaks(),
and we have leftovers. flush a single peak (since the leftovers
x.min = peak_leftovers[0];
x.max = peak_leftovers[0];
- off_t byte = (peak_leftover_frame / fpp) * sizeof (PeakData);
+ off_t byte = (peak_leftover_sample / fpp) * sizeof (PeakData);
off_t offset = lseek (_peakfile_fd, byte, SEEK_SET);
{
Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
- PeakRangeReady (peak_leftover_frame, peak_leftover_cnt); /* EMIT SIGNAL */
+ PeakRangeReady (peak_leftover_sample, peak_leftover_cnt); /* EMIT SIGNAL */
if (intermediate_peaks_ready) {
PeaksReady (); /* EMIT SIGNAL */
}
memcpy (buf2.get(), peak_leftovers, peak_leftover_cnt * sizeof (Sample));
/* the new stuff */
- memcpy (buf2.get()+peak_leftover_cnt, buf, cnt * sizeof (Sample));
+ if (buf && cnt > 0) {
+ memcpy (buf2.get()+peak_leftover_cnt, buf, cnt * sizeof (Sample));
+ }
/* no more leftovers */
peak_leftover_cnt = 0;
/* make sure that when we write into the peakfile, we startup where we left off */
- first_frame = peak_leftover_frame;
+ first_sample = peak_leftover_sample;
} else {
to_do = cnt;
boost::scoped_array<PeakData> peakbuf(new PeakData[(to_do/fpp)+1]);
peaks_computed = 0;
- current_frame = first_frame;
- frames_done = 0;
+ current_sample = first_sample;
+ samples_done = 0;
while (to_do) {
- /* if some frames were passed in (i.e. we're not flushing leftovers)
+ /* if some samples were passed in (i.e. we're not flushing leftovers)
and there are less than fpp to do, save them till
next time
*/
}
memcpy (peak_leftovers, buf, to_do * sizeof (Sample));
peak_leftover_cnt = to_do;
- peak_leftover_frame = current_frame;
+ peak_leftover_sample = current_sample;
/* done for now */
break;
}
- framecnt_t this_time = min (fpp, to_do);
+ samplecnt_t this_time = min (fpp, to_do);
peakbuf[peaks_computed].max = buf[0];
peakbuf[peaks_computed].min = buf[0];
peaks_computed++;
buf += this_time;
to_do -= this_time;
- frames_done += this_time;
- current_frame += this_time;
+ samples_done += this_time;
+ current_sample += this_time;
}
- first_peak_byte = (first_frame / fpp) * sizeof (PeakData);
+ first_peak_byte = (first_sample / fpp) * sizeof (PeakData);
if (can_truncate_peaks()) {
off_t target_length = blocksize * ((first_peak_byte + blocksize + 1) / blocksize);
if (endpos < target_length) {
- DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile %1\n", peakpath));
+ DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile %1\n", _peakpath));
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 + bytes_to_write));
- if (frames_done) {
+ if (samples_done) {
Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
- PeakRangeReady (first_frame, frames_done); /* EMIT SIGNAL */
+ PeakRangeReady (first_sample, samples_done); /* EMIT SIGNAL */
if (intermediate_peaks_ready) {
PeaksReady (); /* EMIT SIGNAL */
}
off_t end = lseek (_peakfile_fd, 0, SEEK_END);
if (end > _peak_byte_max) {
- DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile %1\n", peakpath));
+ DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile %1\n", _peakpath));
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;
+ _peakpath, _peak_byte_max, errno) << endmsg;
}
}
}
-framecnt_t
+samplecnt_t
AudioSource::available_peaks (double zoom_factor) const
{
if (zoom_factor < _FPP) {
}
void
-AudioSource::allocate_working_buffers (framecnt_t framerate)
+AudioSource::allocate_working_buffers (samplecnt_t framerate)
{
Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
}
void
-AudioSource::ensure_buffers_for_level (uint32_t level, framecnt_t frame_rate)
+AudioSource::ensure_buffers_for_level (uint32_t level, samplecnt_t sample_rate)
{
Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
- ensure_buffers_for_level_locked (level, frame_rate);
+ ensure_buffers_for_level_locked (level, sample_rate);
}
void
-AudioSource::ensure_buffers_for_level_locked (uint32_t level, framecnt_t frame_rate)
+AudioSource::ensure_buffers_for_level_locked (uint32_t level, samplecnt_t sample_rate)
{
- framecnt_t nframes = (framecnt_t) floor (Config->get_audio_playback_buffer_seconds() * frame_rate);
+ samplecnt_t nframes = (samplecnt_t) floor (Config->get_audio_playback_buffer_seconds() * sample_rate);
- /* this may be called because either "level" or "frame_rate" have
+ /* this may be called because either "level" or "sample_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.
projects / ardour.git / blobdiff