#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"
int
AudioSource::set_state (const XMLNode& node, int /*version*/)
{
- const XMLProperty* prop;
+ XMLProperty const * prop;
if ((prop = node.property ("captured-for")) != 0) {
_captured_for = prop->value();
}
int
-AudioSource::initialize_peakfile (const 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 = generate_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);
+ 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);
+ }
}
+ 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 */
AudioSource::read (Sample *dst, framepos_t start, framecnt_t cnt, int /*channel*/) const
{
assert (cnt >= 0);
-
+
Glib::Threads::Mutex::Lock lm (_lock);
return read_unlocked (dst, start, cnt);
}
}
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;
const_cast<AudioSource*>(this)->build_peaks_from_scratch ();
error << string_compose (_("Cannot open peakfile @ %1 for reading (%2)"), _peakpath, strerror (errno)) << endmsg;
return -1;
}
-
+
scale = npeaks/expected_peaks;
/* hold lock while building peaks */
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.get(), 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);
goto out;
}
+ 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_frame, frames_read, true, false, _FPP)) {
break;
}
current_frame += frames_read;
cnt -= frames_read;
+
+ lp.acquire();
}
if (cnt == 0) {
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 (_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;
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);
}
projects / ardour.git / blobdiff