2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
34 #include <glibmm/fileutils.h>
35 #include <glibmm/miscutils.h>
37 #include "pbd/xml++.h"
38 #include "pbd/pthread_utils.h"
40 #include "ardour/audiosource.h"
41 #include "ardour/cycle_timer.h"
42 #include "ardour/session.h"
43 #include "ardour/transient_detector.h"
44 #include "ardour/runtime_functions.h"
49 using namespace ARDOUR;
53 bool AudioSource::_build_missing_peakfiles = false;
55 /** true if we want peakfiles (e.g. if we are displaying a GUI) */
56 bool AudioSource::_build_peakfiles = false;
60 AudioSource::AudioSource (Session& s, ustring name)
61 : Source (s, DataType::AUDIO, name)
68 _write_data_count = 0;
69 peak_leftover_cnt = 0;
70 peak_leftover_size = 0;
74 AudioSource::AudioSource (Session& s, const XMLNode& node)
83 _write_data_count = 0;
84 peak_leftover_cnt = 0;
85 peak_leftover_size = 0;
88 if (set_state (node, Stateful::loading_state_version)) {
89 throw failed_constructor();
93 AudioSource::~AudioSource ()
95 /* shouldn't happen but make sure we don't leak file descriptors anyway */
97 if (peak_leftover_cnt) {
98 cerr << "AudioSource destroyed with leftover peak data pending" << endl;
105 delete [] peak_leftovers;
109 AudioSource::get_state ()
111 XMLNode& node (Source::get_state());
113 if (_captured_for.length()) {
114 node.add_property ("captured-for", _captured_for);
121 AudioSource::set_state (const XMLNode& node, int /*version*/)
123 const XMLProperty* prop;
125 if ((prop = node.property ("captured-for")) != 0) {
126 _captured_for = prop->value();
133 AudioSource::length (sframes_t /*pos*/) const
139 AudioSource::update_length (sframes_t pos, sframes_t cnt)
141 if (pos + cnt > _length) {
147 /***********************************************************************
149 ***********************************************************************/
152 AudioSource::peaks_ready (sigc::slot<void> the_slot, sigc::connection& conn) const
155 Glib::Mutex::Lock lm (_peaks_ready_lock);
157 /* check to see if the peak data is ready. if not
158 connect the slot while still holding the lock.
161 if (!(ret = _peaks_built)) {
162 conn = PeaksReady.connect (the_slot);
169 AudioSource::touch_peakfile ()
173 if (stat (peakpath.c_str(), &statbuf) != 0 || statbuf.st_size == 0) {
179 tbuf.actime = statbuf.st_atime;
180 tbuf.modtime = time ((time_t) 0);
182 utime (peakpath.c_str(), &tbuf);
186 AudioSource::rename_peakfile (ustring newpath)
188 /* caller must hold _lock */
190 ustring oldpath = peakpath;
192 if (access (oldpath.c_str(), F_OK) == 0) {
193 if (rename (oldpath.c_str(), newpath.c_str()) != 0) {
194 error << string_compose (_("cannot rename peakfile for %1 from %2 to %3 (%4)"), _name, oldpath, newpath, strerror (errno)) << endmsg;
205 AudioSource::initialize_peakfile (bool newfile, ustring audio_path)
209 peakpath = peak_path (audio_path);
211 /* if the peak file should be there, but isn't .... */
213 if (!newfile && !Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
214 peakpath = find_broken_peakfile (peakpath, audio_path);
217 if (stat (peakpath.c_str(), &statbuf)) {
218 if (errno != ENOENT) {
219 /* it exists in the peaks dir, but there is some kind of error */
221 error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), peakpath) << endmsg;
225 /* peakfile does not exist */
227 _peaks_built = false;
231 /* we found it in the peaks dir, so check it out */
233 if (statbuf.st_size == 0 || ((nframes_t) statbuf.st_size < ((length(_timeline_position) / _FPP) * sizeof (PeakData)))) {
235 _peaks_built = false;
237 // Check if the audio file has changed since the peakfile was built.
238 struct stat stat_file;
239 int err = stat (audio_path.c_str(), &stat_file);
242 _peaks_built = false;
246 /* allow 6 seconds slop on checking peak vs. file times because of various
250 if (stat_file.st_mtime > statbuf.st_mtime && (stat_file.st_mtime - statbuf.st_mtime > 6)) {
251 _peaks_built = false;
255 _peak_byte_max = statbuf.st_size;
261 if (!newfile && !_peaks_built && _build_missing_peakfiles && _build_peakfiles) {
262 build_peaks_from_scratch ();
269 AudioSource::read (Sample *dst, sframes_t start, nframes_t cnt, int /*channel*/) const
271 Glib::Mutex::Lock lm (_lock);
272 return read_unlocked (dst, start, cnt);
276 AudioSource::write (Sample *dst, nframes_t cnt)
278 Glib::Mutex::Lock lm (_lock);
279 return write_unlocked (dst, cnt);
283 AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, sframes_t start, nframes_t cnt, double samples_per_visual_peak) const
285 return read_peaks_with_fpp (peaks, npeaks, start, cnt, samples_per_visual_peak, _FPP);
288 /** @param peaks Buffer to write peak data.
289 * @param npeaks Number of peaks to write.
293 AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, sframes_t start, nframes_t cnt,
294 double samples_per_visual_peak, nframes_t samples_per_file_peak) const
296 Glib::Mutex::Lock lm (_lock);
298 double expected_peaks;
299 PeakData::PeakDatum xmax;
300 PeakData::PeakDatum xmin;
303 nframes_t zero_fill = 0;
305 PeakData* staging = 0;
306 Sample* raw_staging = 0;
309 expected_peaks = (cnt / (double) samples_per_file_peak);
310 scale = npeaks/expected_peaks;
312 #undef DEBUG_READ_PEAKS
313 #ifdef DEBUG_READ_PEAKS
314 cerr << "======>RP: npeaks = " << npeaks
315 << " start = " << start
317 << " len = " << _length
318 << " samples_per_visual_peak =" << samples_per_visual_peak
319 << " expected was " << expected_peaks << " ... scale = " << scale
320 << " PD ptr = " << peaks
325 /* fix for near-end-of-file conditions */
327 if (cnt > _length - start) {
328 // cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << endl;
329 cnt = _length - start;
330 nframes_t old = npeaks;
331 npeaks = min ((nframes_t) floor (cnt / samples_per_visual_peak), npeaks);
332 zero_fill = old - npeaks;
335 // cerr << "actual npeaks = " << npeaks << " zf = " << zero_fill << endl;
339 #ifdef DEBUG_READ_PEAKS
340 cerr << "RAW DATA\n";
342 /* no scaling at all, just get the sample data and duplicate it for
343 both max and min peak values.
346 Sample* raw_staging = new Sample[cnt];
348 if (read_unlocked (raw_staging, start, cnt) != cnt) {
349 error << _("cannot read sample data for unscaled peak computation") << endmsg;
353 for (nframes_t i = 0; i < npeaks; ++i) {
354 peaks[i].max = raw_staging[i];
355 peaks[i].min = raw_staging[i];
358 delete [] raw_staging;
364 off_t first_peak_byte = (start / samples_per_file_peak) * sizeof (PeakData);
366 /* open, read, close */
368 if ((_peakfile = ::open (peakpath.c_str(), O_RDONLY, 0664)) < 0) {
369 error << string_compose(_("AudioSource: cannot open peakpath (a) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
373 #ifdef DEBUG_READ_PEAKS
374 cerr << "DIRECT PEAKS\n";
377 nread = ::pread (_peakfile, peaks, sizeof (PeakData)* npeaks, first_peak_byte);
380 if (nread != sizeof (PeakData) * npeaks) {
381 cerr << "AudioSource["
383 << "]: cannot read peaks from peakfile! (read only "
397 memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
408 #ifdef DEBUG_READ_PEAKS
409 cerr << "DOWNSAMPLE\n";
413 - more frames-per-peak (lower resolution) than the peakfile, or to put it another way,
414 - less peaks than the peakfile holds for the same range
416 So, read a block into a staging area, and then downsample from there.
418 to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks
421 const uint32_t chunksize = (uint32_t) min (expected_peaks, 65536.0);
423 staging = new PeakData[chunksize];
425 /* compute the rounded up frame position */
427 nframes_t current_frame = start;
428 nframes_t current_stored_peak = (nframes_t) ceil (current_frame / (double) samples_per_file_peak);
429 uint32_t next_visual_peak = (uint32_t) ceil (current_frame / samples_per_visual_peak);
430 double next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
431 uint32_t stored_peak_before_next_visual_peak = (nframes_t) next_visual_peak_frame / samples_per_file_peak;
432 uint32_t nvisual_peaks = 0;
433 uint32_t stored_peaks_read = 0;
436 /* handle the case where the initial visual peak is on a pixel boundary */
438 current_stored_peak = min (current_stored_peak, stored_peak_before_next_visual_peak);
440 /* open ... close during out: handling */
442 if ((_peakfile = ::open (peakpath.c_str(), O_RDONLY, 0664)) < 0) {
443 error << string_compose(_("AudioSource: cannot open peakpath (b) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
447 while (nvisual_peaks < npeaks) {
449 if (i == stored_peaks_read) {
451 uint32_t start_byte = current_stored_peak * sizeof(PeakData);
452 tnp = min ((nframes_t)(_length/samples_per_file_peak - current_stored_peak), (nframes_t) expected_peaks);
453 to_read = min (chunksize, tnp);
455 #ifdef DEBUG_READ_PEAKS
456 cerr << "read " << sizeof (PeakData) * to_read << " from peakfile @ " << start_byte << endl;
459 if ((nread = ::pread (_peakfile, staging, sizeof (PeakData) * to_read, start_byte))
460 != sizeof (PeakData) * to_read) {
462 off_t fend = lseek (_peakfile, 0, SEEK_END);
464 cerr << "AudioSource["
466 << "]: cannot read peak data from peakfile ("
467 << (nread / sizeof(PeakData))
468 << " peaks instead of "
473 << " at start_byte = " << start_byte
474 << " _length = " << _length << " versus len = " << fend
475 << " expected maxpeaks = " << (_length - current_frame)/samples_per_file_peak
476 << " npeaks was " << npeaks
482 stored_peaks_read = nread / sizeof(PeakData);
488 while ((i < stored_peaks_read) && (current_stored_peak <= stored_peak_before_next_visual_peak)) {
490 xmax = max (xmax, staging[i].max);
491 xmin = min (xmin, staging[i].min);
493 ++current_stored_peak;
497 peaks[nvisual_peaks].max = xmax;
498 peaks[nvisual_peaks].min = xmin;
502 //next_visual_peak_frame = min ((next_visual_peak * samples_per_visual_peak), (next_visual_peak_frame+samples_per_visual_peak) );
503 next_visual_peak_frame = min ((double) start+cnt, (next_visual_peak_frame+samples_per_visual_peak) );
504 stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / samples_per_file_peak;
508 memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
515 #ifdef DEBUG_READ_PEAKS
516 cerr << "UPSAMPLE\n";
520 - less frames-per-peak (more resolution)
521 - more peaks than stored in the Peakfile
523 So, fetch data from the raw source, and generate peak
527 nframes_t frames_read = 0;
528 nframes_t current_frame = start;
530 nframes_t nvisual_peaks = 0;
531 nframes_t chunksize = (nframes_t) min (cnt, (nframes_t) 4096);
532 raw_staging = new Sample[chunksize];
534 nframes_t frame_pos = start;
535 double pixel_pos = floor (frame_pos / samples_per_visual_peak);
536 double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
537 double pixels_per_frame = 1.0 / samples_per_visual_peak;
542 while (nvisual_peaks < npeaks) {
544 if (i == frames_read) {
546 to_read = min (chunksize, nframes_t(_length - current_frame));
549 /* XXX ARGH .. out by one error ... need to figure out why this happens
550 and fix it rather than do this band-aid move.
552 zero_fill = npeaks - nvisual_peaks;
557 if ((frames_read = read_unlocked (raw_staging, current_frame, to_read)) == 0) {
558 error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3 of %4 (%5)"),
559 _name, to_read, current_frame, _length, strerror (errno))
567 xmax = max (xmax, raw_staging[i]);
568 xmin = min (xmin, raw_staging[i]);
571 pixel_pos += pixels_per_frame;
573 if (pixel_pos >= next_pixel_pos) {
575 peaks[nvisual_peaks].max = xmax;
576 peaks[nvisual_peaks].min = xmin;
581 next_pixel_pos = ceil (pixel_pos + 0.5);
586 memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
593 if (_peakfile >= 0) {
598 delete [] raw_staging;
600 #ifdef DEBUG_READ_PEAKS
607 #undef DEBUG_PEAK_BUILD
610 AudioSource::build_peaks_from_scratch ()
612 nframes_t current_frame;
615 nframes_t frames_read;
616 nframes_t frames_to_read;
617 const nframes_t bufsize = 65536; // 256kB per disk read for mono data is about ideal
622 /* hold lock while building peaks */
624 Glib::Mutex::Lock lp (_lock);
626 if (prepare_for_peakfile_writes ()) {
632 _peaks_built = false;
633 buf = new Sample[bufsize];
637 frames_to_read = min (bufsize, cnt);
639 if ((frames_read = read_unlocked (buf, current_frame, frames_to_read)) != frames_to_read) {
640 error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
641 done_with_peakfile_writes (false);
645 if (compute_and_write_peaks (buf, current_frame, frames_read, true, false, _FPP)) {
649 current_frame += frames_read;
658 done_with_peakfile_writes ((cnt == 0));
662 Glib::Mutex::Lock lm (_peaks_ready_lock);
665 PeaksReady (); /* EMIT SIGNAL */
672 unlink (peakpath.c_str());
681 AudioSource::prepare_for_peakfile_writes ()
683 if ((peakfile = ::open (peakpath.c_str(), O_RDWR|O_CREAT, 0664)) < 0) {
684 error << string_compose(_("AudioSource: cannot open peakpath (c) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
691 AudioSource::done_with_peakfile_writes (bool done)
693 if (peak_leftover_cnt) {
694 compute_and_write_peaks (0, 0, 0, true, false, _FPP);
708 AudioSource::compute_and_write_peaks (Sample* buf, sframes_t first_frame, nframes_t cnt,
709 bool force, bool intermediate_peaks_ready)
711 return compute_and_write_peaks (buf, first_frame, cnt, force, intermediate_peaks_ready, _FPP);
715 AudioSource::compute_and_write_peaks (Sample* buf, sframes_t first_frame, nframes_t cnt,
716 bool force, bool intermediate_peaks_ready, nframes_t fpp)
720 uint32_t peaks_computed;
721 PeakData* peakbuf = 0;
723 nframes_t current_frame;
724 nframes_t frames_done;
725 const size_t blocksize = (128 * 1024);
726 off_t first_peak_byte;
729 prepare_for_peakfile_writes ();
733 if (peak_leftover_cnt) {
735 if (first_frame != peak_leftover_frame + peak_leftover_cnt) {
737 /* uh-oh, ::seek() since the last ::compute_and_write_peaks(),
738 and we have leftovers. flush a single peak (since the leftovers
739 never represent more than that, and restart.
744 x.min = peak_leftovers[0];
745 x.max = peak_leftovers[0];
747 off_t byte = (peak_leftover_frame / fpp) * sizeof (PeakData);
749 if (::pwrite (peakfile, &x, sizeof (PeakData), byte) != sizeof (PeakData)) {
750 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
754 _peak_byte_max = max (_peak_byte_max, (off_t) (byte + sizeof(PeakData)));
757 Glib::Mutex::Lock lm (_peaks_ready_lock);
758 PeakRangeReady (peak_leftover_frame, peak_leftover_cnt); /* EMIT SIGNAL */
759 if (intermediate_peaks_ready) {
760 PeaksReady (); /* EMIT SIGNAL */
764 /* left overs are done */
766 peak_leftover_cnt = 0;
770 /* else ... had leftovers, but they immediately preceed the new data, so just
771 merge them and compute.
774 /* make a new contiguous buffer containing leftovers and the new stuff */
776 to_do = cnt + peak_leftover_cnt;
777 buf2 = new Sample[to_do];
780 memcpy (buf2, peak_leftovers, peak_leftover_cnt * sizeof (Sample));
783 memcpy (buf2+peak_leftover_cnt, buf, cnt * sizeof (Sample));
785 /* no more leftovers */
786 peak_leftover_cnt = 0;
788 /* use the temporary buffer */
791 /* make sure that when we write into the peakfile, we startup where we left off */
793 first_frame = peak_leftover_frame;
799 peakbuf = new PeakData[(to_do/fpp)+1];
801 current_frame = first_frame;
806 /* if some frames were passed in (i.e. we're not flushing leftovers)
807 and there are less than fpp to do, save them till
811 if (force && (to_do < fpp)) {
812 /* keep the left overs around for next time */
814 if (peak_leftover_size < to_do) {
815 delete [] peak_leftovers;
816 peak_leftovers = new Sample[to_do];
817 peak_leftover_size = to_do;
819 memcpy (peak_leftovers, buf, to_do * sizeof (Sample));
820 peak_leftover_cnt = to_do;
821 peak_leftover_frame = current_frame;
828 nframes_t this_time = min (fpp, to_do);
830 peakbuf[peaks_computed].max = buf[0];
831 peakbuf[peaks_computed].min = buf[0];
833 ARDOUR::find_peaks (buf+1, this_time-1, &peakbuf[peaks_computed].min, &peakbuf[peaks_computed].max);
838 frames_done += this_time;
839 current_frame += this_time;
842 first_peak_byte = (first_frame / fpp) * sizeof (PeakData);
844 if (can_truncate_peaks()) {
846 /* on some filesystems (ext3, at least) this helps to reduce fragmentation of
847 the peakfiles. its not guaranteed to do so, and even on ext3 (as of december 2006)
848 it does not cause single-extent allocation even for peakfiles of
849 less than BLOCKSIZE bytes. only call ftruncate if we'll make the file larger.
852 off_t endpos = lseek (peakfile, 0, SEEK_END);
853 off_t target_length = blocksize * ((first_peak_byte + blocksize + 1) / blocksize);
855 if (endpos < target_length) {
856 ftruncate (peakfile, target_length);
857 /* error doesn't actually matter though, so continue on without testing */
861 if (::pwrite (peakfile, peakbuf, sizeof (PeakData) * peaks_computed, first_peak_byte) != (ssize_t) (sizeof (PeakData) * peaks_computed)) {
862 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
866 _peak_byte_max = max (_peak_byte_max, (off_t) (first_peak_byte + sizeof(PeakData)*peaks_computed));
869 Glib::Mutex::Lock lm (_peaks_ready_lock);
870 PeakRangeReady (first_frame, frames_done); /* EMIT SIGNAL */
871 if (intermediate_peaks_ready) {
872 PeaksReady (); /* EMIT SIGNAL */
886 AudioSource::truncate_peakfile ()
889 error << string_compose (_("programming error: %1"), "AudioSource::truncate_peakfile() called without open peakfile descriptor")
894 /* truncate the peakfile down to its natural length if necessary */
896 off_t end = lseek (peakfile, 0, SEEK_END);
898 if (end > _peak_byte_max) {
899 ftruncate (peakfile, _peak_byte_max);
904 AudioSource::available_peaks (double zoom_factor) const
906 if (zoom_factor < _FPP) {
907 return length(_timeline_position); // peak data will come from the audio file
910 /* peak data comes from peakfile, but the filesize might not represent
911 the valid data due to ftruncate optimizations, so use _peak_byte_max state.
912 XXX - there might be some atomicity issues here, we should probably add a lock,
913 but _peak_byte_max only monotonically increases after initialization.
916 off_t end = _peak_byte_max;
918 return (end/sizeof(PeakData)) * _FPP;