libs/ardour/audiosource.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   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.
   8
   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.
  13
  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.
  17
  18 */
  19
  20 #ifdef COMPILER_MSVC
  21 #include <sys/utime.h>
  22 #else
  23 #include <unistd.h>
  24 #include <utime.h>
  25 #endif
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #include <float.h>
  29 #include <cerrno>
  30 #include <ctime>
  31 #include <cmath>
  32 #include <iomanip>
  33 #include <fstream>
  34 #include <algorithm>
  35 #include <vector>
  36
  37 #include <glib.h>
  38 #include <glib/gstdio.h>
  39
  40 #include <boost/scoped_array.hpp>
  41 #include <boost/scoped_ptr.hpp>
  42
  43 #include <glibmm/fileutils.h>
  44 #include <glibmm/miscutils.h>
  45
  46 #include "pbd/xml++.h"
  47
  48 #include "ardour/audiosource.h"
  49 #include "ardour/rc_configuration.h"
  50 #include "ardour/runtime_functions.h"
  51
  52 #include "i18n.h"
  53
  54 #include "ardour/debug.h"
  55
  56 using namespace std;
  57 using namespace ARDOUR;
  58 using namespace PBD;
  59
  60 Glib::Threads::Mutex AudioSource::_level_buffer_lock;
  61 vector<boost::shared_array<Sample> > AudioSource::_mixdown_buffers;
  62 vector<boost::shared_array<gain_t> > AudioSource::_gain_buffers;
  63 size_t AudioSource::_working_buffers_size = 0;
  64 bool AudioSource::_build_missing_peakfiles = false;
  65
  66 /** true if we want peakfiles (e.g. if we are displaying a GUI) */
  67 bool AudioSource::_build_peakfiles = false;
  68
  69 #define _FPP 256
  70
  71 AudioSource::AudioSource (Session& s, string name)
  72         : Source (s, DataType::AUDIO, name)
  73         , _length (0)
  74         , _peak_byte_max (0)
  75         , _peaks_built (false)
  76         , _peakfile_fd (-1)
  77         , peak_leftover_cnt (0)
  78         , peak_leftover_size (0)
  79         , peak_leftovers (0)
  80 {
  81 }
  82
  83 AudioSource::AudioSource (Session& s, const XMLNode& node)
  84         : Source (s, node)
  85         , _length (0)
  86         , _peak_byte_max (0)
  87         , _peaks_built (false)
  88         , _peakfile_fd (-1)
  89         , peak_leftover_cnt (0)
  90         , peak_leftover_size (0)
  91         , peak_leftovers (0)
  92 {
  93         if (set_state (node, Stateful::loading_state_version)) {
  94                 throw failed_constructor();
  95         }
  96 }
  97
  98 AudioSource::~AudioSource ()
  99 {
 100         /* shouldn't happen but make sure we don't leak file descriptors anyway */
 101
 102         if (peak_leftover_cnt) {
 103                 cerr << "AudioSource destroyed with leftover peak data pending" << endl;
 104         }
 105
 106         close (_peakfile_fd);
 107         _peakfile_fd = -1;
 108
 109         delete [] peak_leftovers;
 110 }
 111
 112 XMLNode&
 113 AudioSource::get_state ()
 114 {
 115         XMLNode& node (Source::get_state());
 116
 117         if (_captured_for.length()) {
 118                 node.add_property ("captured-for", _captured_for);
 119         }
 120
 121         return node;
 122 }
 123
 124 int
 125 AudioSource::set_state (const XMLNode& node, int /*version*/)
 126 {
 127         const XMLProperty* prop;
 128
 129         if ((prop = node.property ("captured-for")) != 0) {
 130                 _captured_for = prop->value();
 131         }
 132
 133         return 0;
 134 }
 135
 136 bool
 137 AudioSource::empty () const
 138 {
 139         return _length == 0;
 140 }
 141
 142 framecnt_t
 143 AudioSource::length (framepos_t /*pos*/) const
 144 {
 145         return _length;
 146 }
 147
 148 void
 149 AudioSource::update_length (framecnt_t len)
 150 {
 151         if (len > _length) {
 152                 _length = len;
 153         }
 154 }
 155
 156
 157 /***********************************************************************
 158   PEAK FILE STUFF
 159  ***********************************************************************/
 160
 161 /** Checks to see if peaks are ready.  If so, we return true.  If not, we return false, and
 162  *  things are set up so that doThisWhenReady is called when the peaks are ready.
 163  *  A new PBD::ScopedConnection is created for the associated connection and written to
 164  *  *connect_here_if_not.
 165  *
 166  *  @param doThisWhenReady Function to call when peaks are ready (if they are not already).
 167  *  @param connect_here_if_not Address to write new ScopedConnection to.
 168  *  @param event_loop Event loop for doThisWhenReady to be called in.
 169  */
 170 bool
 171 AudioSource::peaks_ready (boost::function<void()> doThisWhenReady, ScopedConnection** connect_here_if_not, EventLoop* event_loop) const
 172 {
 173         bool ret;
 174         Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 175
 176         if (!(ret = _peaks_built)) {
 177                 *connect_here_if_not = new ScopedConnection;
 178                 PeaksReady.connect (**connect_here_if_not, MISSING_INVALIDATOR, doThisWhenReady, event_loop);
 179         }
 180
 181         return ret;
 182 }
 183
 184 void
 185 AudioSource::touch_peakfile ()
 186 {
 187         GStatBuf statbuf;
 188
 189         if (g_stat (peakpath.c_str(), &statbuf) != 0 || statbuf.st_size == 0) {
 190                 return;
 191         }
 192
 193         struct utimbuf tbuf;
 194
 195         tbuf.actime = statbuf.st_atime;
 196         tbuf.modtime = time ((time_t*) 0);
 197
 198         g_utime (peakpath.c_str(), &tbuf);
 199 }
 200
 201 int
 202 AudioSource::rename_peakfile (string newpath)
 203 {
 204         /* caller must hold _lock */
 205
 206         string oldpath = peakpath;
 207
 208         if (Glib::file_test (oldpath, Glib::FILE_TEST_EXISTS)) {
 209                 if (g_rename (oldpath.c_str(), newpath.c_str()) != 0) {
 210                         error << string_compose (_("cannot rename peakfile for %1 from %2 to %3 (%4)"), _name, oldpath, newpath, strerror (errno)) << endmsg;
 211                         return -1;
 212                 }
 213         }
 214
 215         peakpath = newpath;
 216
 217         return 0;
 218 }
 219
 220 int
 221 AudioSource::initialize_peakfile (string audio_path)
 222 {
 223         GStatBuf statbuf;
 224
 225         peakpath = peak_path (audio_path);
 226
 227         DEBUG_TRACE(DEBUG::Peaks, string_compose ("Initialize Peakfile %1 for Audio file %2\n", peakpath, audio_path));
 228
 229         /* if the peak file should be there, but isn't .... */
 230
 231         if (!empty() && !Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
 232                 peakpath = find_broken_peakfile (peakpath, audio_path);
 233         }
 234
 235         if (g_stat (peakpath.c_str(), &statbuf)) {
 236                 if (errno != ENOENT) {
 237                         /* it exists in the peaks dir, but there is some kind of error */
 238
 239                         error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), peakpath) << endmsg;
 240                         return -1;
 241                 }
 242
 243                 DEBUG_TRACE(DEBUG::Peaks, string_compose("Peakfile %1 does not exist\n", peakpath));
 244
 245                 _peaks_built = false;
 246
 247         } else {
 248
 249                 /* we found it in the peaks dir, so check it out */
 250
 251                 if (statbuf.st_size == 0 || (statbuf.st_size < (off_t) ((length(_timeline_position) / _FPP) * sizeof (PeakData)))) {
 252                         DEBUG_TRACE(DEBUG::Peaks, string_compose("Peakfile %1 is empty\n", peakpath));
 253                         _peaks_built = false;
 254                 } else {
 255                         // Check if the audio file has changed since the peakfile was built.
 256                         struct stat stat_file;
 257                         int err = stat (audio_path.c_str(), &stat_file);
 258
 259                         if (err) {
 260
 261                                 /* no audio path - nested source or we can't
 262                                    read it or ... whatever, use the peakfile as-is.
 263                                 */
 264                                 DEBUG_TRACE(DEBUG::Peaks, string_compose("Error when calling stat on Peakfile %1\n", peakpath));
 265
 266                                 _peaks_built = true;
 267                                 _peak_byte_max = statbuf.st_size;
 268
 269                         } else {
 270
 271                                 /* allow 6 seconds slop on checking peak vs. file times because of various
 272                                    disk action "races"
 273                                 */
 274
 275                                 if (stat_file.st_mtime > statbuf.st_mtime && (stat_file.st_mtime - statbuf.st_mtime > 6)) {
 276                                         _peaks_built = false;
 277                                         _peak_byte_max = 0;
 278                                 } else {
 279                                         _peaks_built = true;
 280                                         _peak_byte_max = statbuf.st_size;
 281                                 }
 282                         }
 283                 }
 284         }
 285
 286         if (!empty() && !_peaks_built && _build_missing_peakfiles && _build_peakfiles) {
 287                 build_peaks_from_scratch ();
 288         }
 289
 290         return 0;
 291 }
 292
 293 framecnt_t
 294 AudioSource::read (Sample *dst, framepos_t start, framecnt_t cnt, int /*channel*/) const
 295 {
 296         assert (cnt >= 0);
 297
 298         Glib::Threads::Mutex::Lock lm (_lock);
 299         return read_unlocked (dst, start, cnt);
 300 }
 301
 302 framecnt_t
 303 AudioSource::write (Sample *dst, framecnt_t cnt)
 304 {
 305         Glib::Threads::Mutex::Lock lm (_lock);
 306         /* any write makes the file not removable */
 307         _flags = Flag (_flags & ~Removable);
 308         return write_unlocked (dst, cnt);
 309 }
 310
 311 int
 312 AudioSource::read_peaks (PeakData *peaks, framecnt_t npeaks, framepos_t start, framecnt_t cnt, double samples_per_visual_peak) const
 313 {
 314         return read_peaks_with_fpp (peaks, npeaks, start, cnt, samples_per_visual_peak, _FPP);
 315 }
 316
 317 /** @param peaks Buffer to write peak data.
 318  *  @param npeaks Number of peaks to write.
 319  */
 320
 321 struct ScopedFileDescriptor {
 322         ScopedFileDescriptor (int fd) : _fd (fd) {}
 323         ~ScopedFileDescriptor() { close (_fd); }
 324         operator int() { return _fd; }
 325         int _fd;
 326 };
 327
 328 int
 329 AudioSource::read_peaks_with_fpp (PeakData *peaks, framecnt_t npeaks, framepos_t start, framecnt_t cnt,
 330                                   double samples_per_visual_peak, framecnt_t samples_per_file_peak) const
 331 {
 332         Glib::Threads::Mutex::Lock lm (_lock);
 333         double scale;
 334         double expected_peaks;
 335         PeakData::PeakDatum xmax;
 336         PeakData::PeakDatum xmin;
 337         int32_t to_read;
 338         ssize_t nread;
 339         framecnt_t zero_fill = 0;
 340
 341         ScopedFileDescriptor sfd (::open (peakpath.c_str(), O_RDONLY));
 342
 343         if (sfd < 0) {
 344                 error << string_compose (_("Cannot open peakfile @ %1 for reading (%2)"), peakpath, strerror (errno)) << endmsg;
 345                 return -1;
 346         }
 347
 348         expected_peaks = (cnt / (double) samples_per_file_peak);
 349         scale = npeaks/expected_peaks;
 350
 351         DEBUG_TRACE (DEBUG::Peaks, string_compose (" ======>RP: npeaks = %1 start = %2 cnt = %3 len = %4 samples_per_visual_peak = %5 expected was %6 ... scale =  %7 PD ptr = %8\n"
 352                         , npeaks, start, cnt, _length, samples_per_visual_peak, expected_peaks, scale, peaks));
 353
 354         /* fix for near-end-of-file conditions */
 355
 356         if (cnt > _length - start) {
 357                 // cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << " (" << _length - start << ")" << endl;
 358                 cnt = _length - start;
 359                 framecnt_t old = npeaks;
 360                 npeaks = min ((framecnt_t) floor (cnt / samples_per_visual_peak), npeaks);
 361                 zero_fill = old - npeaks;
 362         }
 363
 364         // cerr << "actual npeaks = " << npeaks << " zf = " << zero_fill << endl;
 365
 366         if (npeaks == cnt) {
 367
 368                 DEBUG_TRACE (DEBUG::Peaks, "RAW DATA\n");
 369
 370                 /* no scaling at all, just get the sample data and duplicate it for
 371                    both max and min peak values.
 372                 */
 373
 374                 boost::scoped_array<Sample> raw_staging(new Sample[cnt]);
 375
 376                 if (read_unlocked (raw_staging.get(), start, cnt) != cnt) {
 377                         error << _("cannot read sample data for unscaled peak computation") << endmsg;
 378                         return -1;
 379                 }
 380
 381                 for (framecnt_t i = 0; i < npeaks; ++i) {
 382                         peaks[i].max = raw_staging[i];
 383                         peaks[i].min = raw_staging[i];
 384                 }
 385
 386                 return 0;
 387         }
 388
 389         if (scale == 1.0) {
 390
 391                 off_t offset = 0;
 392                 off_t first_peak_byte = (start / samples_per_file_peak) * sizeof (PeakData);
 393                 ssize_t bytes_to_read = sizeof (PeakData)* npeaks;
 394                 /* open, read, close */
 395
 396                 DEBUG_TRACE (DEBUG::Peaks, "DIRECT PEAKS\n");
 397
 398                 offset = lseek (sfd, first_peak_byte, SEEK_SET);
 399
 400                 if (offset != first_peak_byte) {
 401                         error << string_compose(_("AudioSource: could not seek to correct location in peak file \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 402                         return -1;
 403                 }
 404
 405                 nread = ::read (sfd, peaks, bytes_to_read);
 406
 407                 if (nread != bytes_to_read) {
 408                         DEBUG_TRACE (DEBUG::Peaks,  string_compose ("[%1]: Cannot read peaks from peakfile! (read only %2 not %3 at sample %4 = byte %5 )\n"
 409                              , _name, nread, npeaks, start, first_peak_byte));
 410                         return -1;
 411                 }
 412
 413                 if (zero_fill) {
 414                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 415                 }
 416
 417                 return 0;
 418         }
 419
 420
 421         framecnt_t tnp;
 422
 423         if (scale < 1.0) {
 424
 425                 DEBUG_TRACE (DEBUG::Peaks, "DOWNSAMPLE\n");
 426
 427                 /* the caller wants:
 428
 429                     - more frames-per-peak (lower resolution) than the peakfile, or to put it another way,
 430                     - less peaks than the peakfile holds for the same range
 431
 432                     So, read a block into a staging area, and then downsample from there.
 433
 434                     to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks
 435                 */
 436
 437                 const framecnt_t chunksize = (framecnt_t) min (expected_peaks, 65536.0);
 438
 439                 boost::scoped_array<PeakData> staging(new PeakData[chunksize]);
 440
 441                 /* compute the rounded up frame position  */
 442
 443                 framepos_t current_frame = start;
 444                 framepos_t current_stored_peak = (framepos_t) ceil (current_frame / (double) samples_per_file_peak);
 445                 framepos_t next_visual_peak  = (framepos_t) ceil (current_frame / samples_per_visual_peak);
 446                 double     next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
 447                 framepos_t stored_peak_before_next_visual_peak = (framepos_t) next_visual_peak_frame / samples_per_file_peak;
 448                 framecnt_t nvisual_peaks = 0;
 449                 framecnt_t stored_peaks_read = 0;
 450                 framecnt_t i = 0;
 451
 452                 /* handle the case where the initial visual peak is on a pixel boundary */
 453
 454                 current_stored_peak = min (current_stored_peak, stored_peak_before_next_visual_peak);
 455
 456                 /* open ... close during out: handling */
 457
 458                 while (nvisual_peaks < npeaks) {
 459
 460                         if (i == stored_peaks_read) {
 461
 462                                 uint32_t       start_byte = current_stored_peak * sizeof(PeakData);
 463                                 tnp = min ((framecnt_t)(_length/samples_per_file_peak - current_stored_peak), (framecnt_t) expected_peaks);
 464                                 to_read = min (chunksize, tnp);
 465                                 ssize_t bytes_to_read = sizeof (PeakData) * to_read;
 466
 467                                 DEBUG_TRACE (DEBUG::Peaks, string_compose ("reading %1 bytes from peakfile @ %2\n"
 468                                                 , bytes_to_read, start_byte));
 469
 470
 471                                 off_t offset = lseek (sfd, start_byte, SEEK_SET);
 472
 473                                 if (offset != start_byte) {
 474                                         error << string_compose(_("AudioSource: could not seek to correct location in peak file \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 475                                         return -1;
 476                                 }
 477
 478                                 if ((nread = ::read (sfd, staging.get(), bytes_to_read)) != bytes_to_read) {
 479
 480                                         off_t fend = lseek (sfd, 0, SEEK_END);
 481
 482                                         DEBUG_TRACE (DEBUG::Peaks, string_compose ("[%1]: cannot read peak data from peakfile (%2 peaks instead of %3) (%4) at start_byte = %5 _length = %6 versus len = %7 expected maxpeaks = %8 npeaks was %9"
 483                                              , _name, (nread / sizeof(PeakData)), to_read, g_strerror (errno), start_byte, _length, fend, ((_length - current_frame)/samples_per_file_peak), npeaks));
 484                                         return -1;
 485                                 }
 486                                 i = 0;
 487                                 stored_peaks_read = nread / sizeof(PeakData);
 488                         }
 489
 490                         xmax = -1.0;
 491                         xmin = 1.0;
 492
 493                         while ((i < stored_peaks_read) && (current_stored_peak <= stored_peak_before_next_visual_peak)) {
 494
 495                                 xmax = max (xmax, staging[i].max);
 496                                 xmin = min (xmin, staging[i].min);
 497                                 ++i;
 498                                 ++current_stored_peak;
 499                                 --expected_peaks;
 500                         }
 501
 502                         peaks[nvisual_peaks].max = xmax;
 503                         peaks[nvisual_peaks].min = xmin;
 504                         ++nvisual_peaks;
 505                         ++next_visual_peak;
 506
 507                         //next_visual_peak_frame = min ((next_visual_peak * samples_per_visual_peak), (next_visual_peak_frame+samples_per_visual_peak) );
 508                         next_visual_peak_frame =  min ((double) start+cnt, (next_visual_peak_frame+samples_per_visual_peak) );
 509                         stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / samples_per_file_peak;
 510                 }
 511
 512                 if (zero_fill) {
 513                         cerr << "Zero fill end of peaks (@ " << npeaks << " with " << zero_fill << endl;
 514                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 515                 }
 516
 517         } else {
 518
 519                 DEBUG_TRACE (DEBUG::Peaks, "UPSAMPLE\n");
 520
 521                 /* the caller wants
 522
 523                      - less frames-per-peak (more resolution)
 524                      - more peaks than stored in the Peakfile
 525
 526                    So, fetch data from the raw source, and generate peak
 527                    data on the fly.
 528                 */
 529
 530                 framecnt_t frames_read = 0;
 531                 framepos_t current_frame = start;
 532                 framecnt_t i = 0;
 533                 framecnt_t nvisual_peaks = 0;
 534                 framecnt_t chunksize = (framecnt_t) min (cnt, (framecnt_t) 4096);
 535                 boost::scoped_array<Sample> raw_staging(new Sample[chunksize]);
 536
 537                 framepos_t frame_pos = start;
 538                 double pixel_pos = floor (frame_pos / samples_per_visual_peak);
 539                 double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
 540                 double pixels_per_frame = 1.0 / samples_per_visual_peak;
 541
 542                 xmin = 1.0;
 543                 xmax = -1.0;
 544
 545                 while (nvisual_peaks < npeaks) {
 546
 547                         if (i == frames_read) {
 548
 549                                 to_read = min (chunksize, (framecnt_t)(_length - current_frame));
 550
 551                                 if (current_frame >= _length) {
 552
 553                                         /* hmm, error condition - we've reached the end of the file
 554                                            without generating all the peak data. cook up a zero-filled
 555                                            data buffer and then use it. this is simpler than
 556                                            adjusting zero_fill and npeaks and then breaking out of
 557                                            this loop early
 558                                         */
 559
 560                                         memset (raw_staging.get(), 0, sizeof (Sample) * chunksize);
 561
 562                                 } else {
 563
 564                                         to_read = min (chunksize, (_length - current_frame));
 565
 566
 567                                         if ((frames_read = read_unlocked (raw_staging.get(), current_frame, to_read)) == 0) {
 568                                                 error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3 of %4 (%5)"),
 569                                                                         _name, to_read, current_frame, _length, strerror (errno))
 570                                                       << endmsg;
 571                                                 return -1;
 572                                         }
 573                                 }
 574
 575                                 i = 0;
 576                         }
 577
 578                         xmax = max (xmax, raw_staging[i]);
 579                         xmin = min (xmin, raw_staging[i]);
 580                         ++i;
 581                         ++current_frame;
 582                         pixel_pos += pixels_per_frame;
 583
 584                         if (pixel_pos >= next_pixel_pos) {
 585
 586                                 peaks[nvisual_peaks].max = xmax;
 587                                 peaks[nvisual_peaks].min = xmin;
 588                                 ++nvisual_peaks;
 589                                 xmin = 1.0;
 590                                 xmax = -1.0;
 591
 592                                 next_pixel_pos = ceil (pixel_pos + 0.5);
 593                         }
 594                 }
 595
 596                 if (zero_fill) {
 597                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 598                 }
 599         }
 600
 601         DEBUG_TRACE (DEBUG::Peaks, "READPEAKS DONE\n");
 602         return 0;
 603 }
 604
 605 int
 606 AudioSource::build_peaks_from_scratch ()
 607 {
 608         const framecnt_t bufsize = 65536; // 256kB per disk read for mono data is about ideal
 609
 610         DEBUG_TRACE (DEBUG::Peaks, "Building peaks from scratch\n");
 611
 612         int ret = -1;
 613
 614         {
 615                 /* hold lock while building peaks */
 616
 617                 Glib::Threads::Mutex::Lock lp (_lock);
 618
 619                 if (prepare_for_peakfile_writes ()) {
 620                         goto out;
 621                 }
 622
 623                 framecnt_t current_frame = 0;
 624                 framecnt_t cnt = _length;
 625
 626                 _peaks_built = false;
 627                 boost::scoped_array<Sample> buf(new Sample[bufsize]);
 628
 629                 while (cnt) {
 630
 631                         framecnt_t frames_to_read = min (bufsize, cnt);
 632                         framecnt_t frames_read;
 633
 634                         if ((frames_read = read_unlocked (buf.get(), current_frame, frames_to_read)) != frames_to_read) {
 635                                 error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
 636                                 done_with_peakfile_writes (false);
 637                                 goto out;
 638                         }
 639
 640                         if (compute_and_write_peaks (buf.get(), current_frame, frames_read, true, false, _FPP)) {
 641                                 break;
 642                         }
 643
 644                         current_frame += frames_read;
 645                         cnt -= frames_read;
 646                 }
 647
 648                 if (cnt == 0) {
 649                         /* success */
 650                         truncate_peakfile();
 651                 }
 652
 653                 done_with_peakfile_writes ((cnt == 0));
 654                 if (cnt == 0) {
 655                         ret = 0;
 656                 }
 657         }
 658
 659   out:
 660         if (ret) {
 661                 DEBUG_TRACE (DEBUG::Peaks, string_compose("Could not write peak data, attempting to remove peakfile %1\n", peakpath));
 662                 ::g_unlink (peakpath.c_str());
 663         }
 664
 665         return ret;
 666 }
 667
 668 int
 669 AudioSource::prepare_for_peakfile_writes ()
 670 {
 671         if ((_peakfile_fd = open (peakpath.c_str(), O_CREAT|O_RDWR, 0664)) < 0) {
 672                 error << string_compose(_("AudioSource: cannot open peakpath (c) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 673                 return -1;
 674         }
 675         return 0;
 676 }
 677
 678 void
 679 AudioSource::done_with_peakfile_writes (bool done)
 680 {
 681         if (peak_leftover_cnt) {
 682                 compute_and_write_peaks (0, 0, 0, true, false, _FPP);
 683         }
 684
 685         if (done) {
 686                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 687                 _peaks_built = true;
 688                 PeaksReady (); /* EMIT SIGNAL */
 689         }
 690
 691         close (_peakfile_fd);
 692         _peakfile_fd = -1;
 693 }
 694
 695 /** @param first_frame Offset from the source start of the first frame to process */
 696 int
 697 AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
 698                                       bool force, bool intermediate_peaks_ready)
 699 {
 700         return compute_and_write_peaks (buf, first_frame, cnt, force, intermediate_peaks_ready, _FPP);
 701 }
 702
 703 int
 704 AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
 705                                       bool force, bool intermediate_peaks_ready, framecnt_t fpp)
 706 {
 707         framecnt_t to_do;
 708         uint32_t  peaks_computed;
 709         framepos_t current_frame;
 710         framecnt_t frames_done;
 711         const size_t blocksize = (128 * 1024);
 712         off_t first_peak_byte;
 713         boost::scoped_array<Sample> buf2;
 714
 715         if (_peakfile_fd < 0) {
 716                 if (prepare_for_peakfile_writes ()) {
 717                         return -1;
 718                 }
 719         }
 720
 721   restart:
 722         if (peak_leftover_cnt) {
 723
 724                 if (first_frame != peak_leftover_frame + peak_leftover_cnt) {
 725
 726                         /* uh-oh, ::seek() since the last ::compute_and_write_peaks(),
 727                            and we have leftovers. flush a single peak (since the leftovers
 728                            never represent more than that, and restart.
 729                         */
 730
 731                         PeakData x;
 732
 733                         x.min = peak_leftovers[0];
 734                         x.max = peak_leftovers[0];
 735
 736                         off_t byte = (peak_leftover_frame / fpp) * sizeof (PeakData);
 737
 738                         off_t offset = lseek (_peakfile_fd, byte, SEEK_SET);
 739
 740                         if (offset != byte) {
 741                                 error << string_compose(_("%1: could not seek in peak file data (%2)"), _name, strerror (errno)) << endmsg;
 742                                 return -1;
 743                         }
 744
 745                         if (::write (_peakfile_fd, &x, sizeof (PeakData)) != sizeof (PeakData)) {
 746                                 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
 747                                 return -1;
 748                         }
 749
 750                         _peak_byte_max = max (_peak_byte_max, (off_t) (byte + sizeof(PeakData)));
 751
 752                         {
 753                                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 754                                 PeakRangeReady (peak_leftover_frame, peak_leftover_cnt); /* EMIT SIGNAL */
 755                                 if (intermediate_peaks_ready) {
 756                                         PeaksReady (); /* EMIT SIGNAL */
 757                                 }
 758                         }
 759
 760                         /* left overs are done */
 761
 762                         peak_leftover_cnt = 0;
 763                         goto restart;
 764                 }
 765
 766                 /* else ... had leftovers, but they immediately preceed the new data, so just
 767                    merge them and compute.
 768                 */
 769
 770                 /* make a new contiguous buffer containing leftovers and the new stuff */
 771
 772                 to_do = cnt + peak_leftover_cnt;
 773                 buf2.reset(new Sample[to_do]);
 774
 775                 /* the remnants */
 776                 memcpy (buf2.get(), peak_leftovers, peak_leftover_cnt * sizeof (Sample));
 777
 778                 /* the new stuff */
 779                 memcpy (buf2.get()+peak_leftover_cnt, buf, cnt * sizeof (Sample));
 780
 781                 /* no more leftovers */
 782                 peak_leftover_cnt = 0;
 783
 784                 /* use the temporary buffer */
 785                 buf = buf2.get();
 786
 787                 /* make sure that when we write into the peakfile, we startup where we left off */
 788
 789                 first_frame = peak_leftover_frame;
 790
 791         } else {
 792                 to_do = cnt;
 793         }
 794
 795         boost::scoped_array<PeakData> peakbuf(new PeakData[(to_do/fpp)+1]);
 796         peaks_computed = 0;
 797         current_frame = first_frame;
 798         frames_done = 0;
 799
 800         while (to_do) {
 801
 802                 /* if some frames were passed in (i.e. we're not flushing leftovers)
 803                    and there are less than fpp to do, save them till
 804                    next time
 805                 */
 806
 807                 if (force && (to_do < fpp)) {
 808                         /* keep the left overs around for next time */
 809
 810                         if (peak_leftover_size < to_do) {
 811                                 delete [] peak_leftovers;
 812                                 peak_leftovers = new Sample[to_do];
 813                                 peak_leftover_size = to_do;
 814                         }
 815                         memcpy (peak_leftovers, buf, to_do * sizeof (Sample));
 816                         peak_leftover_cnt = to_do;
 817                         peak_leftover_frame = current_frame;
 818
 819                         /* done for now */
 820
 821                         break;
 822                 }
 823
 824                 framecnt_t this_time = min (fpp, to_do);
 825
 826                 peakbuf[peaks_computed].max = buf[0];
 827                 peakbuf[peaks_computed].min = buf[0];
 828
 829                 ARDOUR::find_peaks (buf+1, this_time-1, &peakbuf[peaks_computed].min, &peakbuf[peaks_computed].max);
 830
 831                 peaks_computed++;
 832                 buf += this_time;
 833                 to_do -= this_time;
 834                 frames_done += this_time;
 835                 current_frame += this_time;
 836         }
 837
 838         first_peak_byte = (first_frame / fpp) * sizeof (PeakData);
 839
 840         if (can_truncate_peaks()) {
 841
 842                 /* on some filesystems (ext3, at least) this helps to reduce fragmentation of
 843                    the peakfiles. its not guaranteed to do so, and even on ext3 (as of december 2006)
 844                    it does not cause single-extent allocation even for peakfiles of
 845                    less than BLOCKSIZE bytes.  only call ftruncate if we'll make the file larger.
 846                 */
 847
 848                 off_t endpos = lseek (_peakfile_fd, 0, SEEK_END);
 849                 off_t target_length = blocksize * ((first_peak_byte + blocksize + 1) / blocksize);
 850
 851                 if (endpos < target_length) {
 852                         DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile %1\n", peakpath));
 853                         if (ftruncate (_peakfile_fd, target_length)) {
 854                                 /* error doesn't actually matter so continue on without testing */
 855                         }
 856                 }
 857         }
 858
 859
 860         off_t offset = lseek(_peakfile_fd, first_peak_byte, SEEK_SET);
 861
 862         if (offset != first_peak_byte) {
 863                 error << string_compose(_("%1: could not seek in peak file data (%2)"), _name, strerror (errno)) << endmsg;
 864                 return -1;
 865         }
 866
 867         ssize_t bytes_to_write = sizeof (PeakData) * peaks_computed;
 868
 869         ssize_t bytes_written = ::write (_peakfile_fd, peakbuf.get(), bytes_to_write);
 870
 871         if (bytes_written != bytes_to_write) {
 872                 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
 873                 return -1;
 874         }
 875
 876         _peak_byte_max = max (_peak_byte_max, (off_t) (first_peak_byte + bytes_to_write));
 877
 878         if (frames_done) {
 879                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 880                 PeakRangeReady (first_frame, frames_done); /* EMIT SIGNAL */
 881                 if (intermediate_peaks_ready) {
 882                         PeaksReady (); /* EMIT SIGNAL */
 883                 }
 884         }
 885
 886         return 0;
 887 }
 888
 889 void
 890 AudioSource::truncate_peakfile ()
 891 {
 892         if (_peakfile_fd < 0) {
 893                 error << string_compose (_("programming error: %1"), "AudioSource::truncate_peakfile() called without open peakfile descriptor")
 894                       << endmsg;
 895                 return;
 896         }
 897
 898         /* truncate the peakfile down to its natural length if necessary */
 899
 900         off_t end = lseek (_peakfile_fd, 0, SEEK_END);
 901
 902         if (end > _peak_byte_max) {
 903                 DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile  %1\n", peakpath));
 904                 if (ftruncate (_peakfile_fd, _peak_byte_max)) {
 905                         error << string_compose (_("could not truncate peakfile %1 to %2 (error: %3)"),
 906                                                  peakpath, _peak_byte_max, errno) << endmsg;
 907                 }
 908         }
 909 }
 910
 911 framecnt_t
 912 AudioSource::available_peaks (double zoom_factor) const
 913 {
 914         if (zoom_factor < _FPP) {
 915                 return length(_timeline_position); // peak data will come from the audio file
 916         }
 917
 918         /* peak data comes from peakfile, but the filesize might not represent
 919            the valid data due to ftruncate optimizations, so use _peak_byte_max state.
 920            XXX - there might be some atomicity issues here, we should probably add a lock,
 921            but _peak_byte_max only monotonically increases after initialization.
 922         */
 923
 924         off_t end = _peak_byte_max;
 925
 926         return (end/sizeof(PeakData)) * _FPP;
 927 }
 928
 929 void
 930 AudioSource::mark_streaming_write_completed ()
 931 {
 932         Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 933
 934         if (_peaks_built) {
 935                 PeaksReady (); /* EMIT SIGNAL */
 936         }
 937 }
 938
 939 void
 940 AudioSource::allocate_working_buffers (framecnt_t framerate)
 941 {
 942         Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
 943
 944
 945         /* Note: we don't need any buffers allocated until
 946            a level 1 audiosource is created, at which
 947            time we'll call ::ensure_buffers_for_level()
 948            with the right value and do the right thing.
 949         */
 950
 951         if (!_mixdown_buffers.empty()) {
 952                 ensure_buffers_for_level_locked ( _mixdown_buffers.size(), framerate);
 953         }
 954 }
 955
 956 void
 957 AudioSource::ensure_buffers_for_level (uint32_t level, framecnt_t frame_rate)
 958 {
 959         Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
 960         ensure_buffers_for_level_locked (level, frame_rate);
 961 }
 962
 963 void
 964 AudioSource::ensure_buffers_for_level_locked (uint32_t level, framecnt_t frame_rate)
 965 {
 966         framecnt_t nframes = (framecnt_t) floor (Config->get_audio_playback_buffer_seconds() * frame_rate);
 967
 968         /* this may be called because either "level" or "frame_rate" have
 969          * changed. and it may be called with "level" smaller than the current
 970          * number of buffers, because a new compound region has been created at
 971          * a more shallow level than the deepest one we currently have.
 972          */
 973
 974         uint32_t limit = max ((size_t) level, _mixdown_buffers.size());
 975
 976         _mixdown_buffers.clear ();
 977         _gain_buffers.clear ();
 978
 979         for (uint32_t n = 0; n < limit; ++n) {
 980                 _mixdown_buffers.push_back (boost::shared_array<Sample> (new Sample[nframes]));
 981                 _gain_buffers.push_back (boost::shared_array<gain_t> (new gain_t[nframes]));
 982         }
 983 }