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 {
  75         _peaks_built = false;
  76         _peak_byte_max = 0;
  77         _peakfile_descriptor = 0;
  78         peak_leftover_cnt = 0;
  79         peak_leftover_size = 0;
  80         peak_leftovers = 0;
  81 }
  82
  83 AudioSource::AudioSource (Session& s, const XMLNode& node)
  84         : Source (s, node)
  85         , _length (0)
  86 {
  87
  88         _peaks_built = false;
  89         _peak_byte_max = 0;
  90         _peakfile_descriptor = 0;
  91         peak_leftover_cnt = 0;
  92         peak_leftover_size = 0;
  93         peak_leftovers = 0;
  94
  95         if (set_state (node, Stateful::loading_state_version)) {
  96                 throw failed_constructor();
  97         }
  98 }
  99
 100 AudioSource::~AudioSource ()
 101 {
 102         /* shouldn't happen but make sure we don't leak file descriptors anyway */
 103
 104         if (peak_leftover_cnt) {
 105                 cerr << "AudioSource destroyed with leftover peak data pending" << endl;
 106         }
 107
 108         delete _peakfile_descriptor;
 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 fill 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 int
 322 AudioSource::read_peaks_with_fpp (PeakData *peaks, framecnt_t npeaks, framepos_t start, framecnt_t cnt,
 323                                   double samples_per_visual_peak, framecnt_t samples_per_file_peak) const
 324 {
 325         Glib::Threads::Mutex::Lock lm (_lock);
 326         double scale;
 327         double expected_peaks;
 328         PeakData::PeakDatum xmax;
 329         PeakData::PeakDatum xmin;
 330         int32_t to_read;
 331         uint32_t nread;
 332         framecnt_t zero_fill = 0;
 333
 334         boost::scoped_ptr<FdFileDescriptor> peakfile_descriptor(new FdFileDescriptor (peakpath, false, 0664));
 335         int peakfile_fd = -1;
 336
 337         expected_peaks = (cnt / (double) samples_per_file_peak);
 338         scale = npeaks/expected_peaks;
 339
 340         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"
 341                         , npeaks, start, cnt, _length, samples_per_visual_peak, expected_peaks, scale, peaks));
 342
 343         /* fix for near-end-of-file conditions */
 344
 345         if (cnt > _length - start) {
 346                 // cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << endl;
 347                 cnt = _length - start;
 348                 framecnt_t old = npeaks;
 349                 npeaks = min ((framecnt_t) floor (cnt / samples_per_visual_peak), npeaks);
 350                 zero_fill = old - npeaks;
 351         }
 352
 353         // cerr << "actual npeaks = " << npeaks << " zf = " << zero_fill << endl;
 354
 355         if (npeaks == cnt) {
 356
 357                 DEBUG_TRACE (DEBUG::Peaks, "RAW DATA\n");
 358
 359                 /* no scaling at all, just get the sample data and duplicate it for
 360                    both max and min peak values.
 361                 */
 362
 363                 boost::scoped_array<Sample> raw_staging(new Sample[cnt]);
 364
 365                 if (read_unlocked (raw_staging.get(), start, cnt) != cnt) {
 366                         error << _("cannot read sample data for unscaled peak computation") << endmsg;
 367                         return -1;
 368                 }
 369
 370                 for (framecnt_t i = 0; i < npeaks; ++i) {
 371                         peaks[i].max = raw_staging[i];
 372                         peaks[i].min = raw_staging[i];
 373                 }
 374
 375                 return 0;
 376         }
 377
 378         if (scale == 1.0) {
 379
 380                 off_t offset = 0;
 381                 off_t first_peak_byte = (start / samples_per_file_peak) * sizeof (PeakData);
 382                 ssize_t bytes_to_read = sizeof (PeakData)* npeaks;
 383                 /* open, read, close */
 384
 385                 if ((peakfile_fd = peakfile_descriptor->allocate ()) < 0) {
 386                         error << string_compose(_("AudioSource: cannot open peakpath (a) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 387                         return -1;
 388                 }
 389
 390                 DEBUG_TRACE (DEBUG::Peaks, "DIRECT PEAKS\n");
 391
 392                 offset = lseek (peakfile_fd, first_peak_byte, SEEK_SET);
 393
 394                 if (offset != first_peak_byte) {
 395                         error << string_compose(_("AudioSource: could not seek to correct location in peak file \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 396                         return -1;
 397                 }
 398
 399                 nread = ::read (peakfile_fd, peaks, bytes_to_read);
 400
 401                 if (nread != bytes_to_read) {
 402                         DEBUG_TRACE (DEBUG::Peaks,  string_compose ("[%1]: Cannot read peaks from peakfile! (read only %2 not %3 at sample %4 = byte %5 )\n"
 403                              , _name, nread, npeaks, start, first_peak_byte));
 404                         return -1;
 405                 }
 406
 407                 if (zero_fill) {
 408                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 409                 }
 410
 411                 return 0;
 412         }
 413
 414
 415         framecnt_t tnp;
 416
 417         if (scale < 1.0) {
 418
 419                 DEBUG_TRACE (DEBUG::Peaks, "DOWNSAMPLE\n");
 420
 421                 /* the caller wants:
 422
 423                     - more frames-per-peak (lower resolution) than the peakfile, or to put it another way,
 424                     - less peaks than the peakfile holds for the same range
 425
 426                     So, read a block into a staging area, and then downsample from there.
 427
 428                     to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks
 429                 */
 430
 431                 const framecnt_t chunksize = (framecnt_t) min (expected_peaks, 65536.0);
 432
 433                 boost::scoped_array<PeakData> staging(new PeakData[chunksize]);
 434
 435                 /* compute the rounded up frame position  */
 436
 437                 framepos_t current_frame = start;
 438                 framepos_t current_stored_peak = (framepos_t) ceil (current_frame / (double) samples_per_file_peak);
 439                 framepos_t next_visual_peak  = (framepos_t) ceil (current_frame / samples_per_visual_peak);
 440                 double     next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
 441                 framepos_t stored_peak_before_next_visual_peak = (framepos_t) next_visual_peak_frame / samples_per_file_peak;
 442                 framecnt_t nvisual_peaks = 0;
 443                 framecnt_t stored_peaks_read = 0;
 444                 framecnt_t i = 0;
 445
 446                 /* handle the case where the initial visual peak is on a pixel boundary */
 447
 448                 current_stored_peak = min (current_stored_peak, stored_peak_before_next_visual_peak);
 449
 450                 /* open ... close during out: handling */
 451
 452                 if ((peakfile_fd = peakfile_descriptor->allocate ()) < 0) {
 453                         error << string_compose(_("AudioSource: cannot open peakpath (b) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 454                         return 0;
 455                 }
 456
 457                 while (nvisual_peaks < npeaks) {
 458
 459                         if (i == stored_peaks_read) {
 460
 461                                 uint32_t       start_byte = current_stored_peak * sizeof(PeakData);
 462                                 tnp = min ((framecnt_t)(_length/samples_per_file_peak - current_stored_peak), (framecnt_t) expected_peaks);
 463                                 to_read = min (chunksize, tnp);
 464                                 ssize_t bytes_to_read = sizeof (PeakData) * to_read;
 465
 466                                 DEBUG_TRACE (DEBUG::Peaks, string_compose ("reading %1 bytes from peakfile @ %2\n"
 467                                                 , bytes_to_read, start_byte));
 468
 469
 470                                 off_t offset = lseek (peakfile_fd, start_byte, SEEK_SET);
 471
 472                                 if (offset != start_byte) {
 473                                         error << string_compose(_("AudioSource: could not seek to correct location in peak file \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 474                                         return -1;
 475                                 }
 476
 477                                 if ((nread = ::read (peakfile_fd, staging.get(), bytes_to_read)) != bytes_to_read) {
 478
 479                                         off_t fend = lseek (peakfile_fd, 0, SEEK_END);
 480
 481                                         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"
 482                                              , _name, (nread / sizeof(PeakData)), to_read, g_strerror (errno), start_byte, _length, fend, ((_length - current_frame)/samples_per_file_peak), npeaks));
 483                                         return -1;
 484                                 }
 485                                 i = 0;
 486                                 stored_peaks_read = nread / sizeof(PeakData);
 487                         }
 488
 489                         xmax = -1.0;
 490                         xmin = 1.0;
 491
 492                         while ((i < stored_peaks_read) && (current_stored_peak <= stored_peak_before_next_visual_peak)) {
 493
 494                                 xmax = max (xmax, staging[i].max);
 495                                 xmin = min (xmin, staging[i].min);
 496                                 ++i;
 497                                 ++current_stored_peak;
 498                                 --expected_peaks;
 499                         }
 500
 501                         peaks[nvisual_peaks].max = xmax;
 502                         peaks[nvisual_peaks].min = xmin;
 503                         ++nvisual_peaks;
 504                         ++next_visual_peak;
 505
 506                         //next_visual_peak_frame = min ((next_visual_peak * samples_per_visual_peak), (next_visual_peak_frame+samples_per_visual_peak) );
 507                         next_visual_peak_frame =  min ((double) start+cnt, (next_visual_peak_frame+samples_per_visual_peak) );
 508                         stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / samples_per_file_peak;
 509                 }
 510
 511                 if (zero_fill) {
 512                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 513                 }
 514
 515         } else {
 516
 517                 DEBUG_TRACE (DEBUG::Peaks, "UPSAMPLE\n");
 518
 519                 /* the caller wants
 520
 521                      - less frames-per-peak (more resolution)
 522                      - more peaks than stored in the Peakfile
 523
 524                    So, fetch data from the raw source, and generate peak
 525                    data on the fly.
 526                 */
 527
 528                 framecnt_t frames_read = 0;
 529                 framepos_t current_frame = start;
 530                 framecnt_t i = 0;
 531                 framecnt_t nvisual_peaks = 0;
 532                 framecnt_t chunksize = (framecnt_t) min (cnt, (framecnt_t) 4096);
 533                 boost::scoped_array<Sample> raw_staging(new Sample[chunksize]);
 534
 535                 framepos_t frame_pos = start;
 536                 double pixel_pos = floor (frame_pos / samples_per_visual_peak);
 537                 double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
 538                 double pixels_per_frame = 1.0 / samples_per_visual_peak;
 539
 540                 xmin = 1.0;
 541                 xmax = -1.0;
 542
 543                 while (nvisual_peaks < npeaks) {
 544
 545                         if (i == frames_read) {
 546
 547                                 to_read = min (chunksize, (framecnt_t)(_length - current_frame));
 548
 549                                 if (current_frame >= _length) {
 550
 551                                         /* hmm, error condition - we've reached the end of the file
 552                                            without generating all the peak data. cook up a zero-filled
 553                                            data buffer and then use it. this is simpler than
 554                                            adjusting zero_fill and npeaks and then breaking out of
 555                                            this loop early
 556                                         */
 557
 558                                         memset (raw_staging.get(), 0, sizeof (Sample) * chunksize);
 559
 560                                 } else {
 561
 562                                         to_read = min (chunksize, (_length - current_frame));
 563
 564
 565                                         if ((frames_read = read_unlocked (raw_staging.get(), current_frame, to_read)) == 0) {
 566                                                 error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3 of %4 (%5)"),
 567                                                                         _name, to_read, current_frame, _length, strerror (errno))
 568                                                       << endmsg;
 569                                                 return -1;
 570                                         }
 571                                 }
 572
 573                                 i = 0;
 574                         }
 575
 576                         xmax = max (xmax, raw_staging[i]);
 577                         xmin = min (xmin, raw_staging[i]);
 578                         ++i;
 579                         ++current_frame;
 580                         pixel_pos += pixels_per_frame;
 581
 582                         if (pixel_pos >= next_pixel_pos) {
 583
 584                                 peaks[nvisual_peaks].max = xmax;
 585                                 peaks[nvisual_peaks].min = xmin;
 586                                 ++nvisual_peaks;
 587                                 xmin = 1.0;
 588                                 xmax = -1.0;
 589
 590                                 next_pixel_pos = ceil (pixel_pos + 0.5);
 591                         }
 592                 }
 593
 594                 if (zero_fill) {
 595                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 596                 }
 597         }
 598
 599         DEBUG_TRACE (DEBUG::Peaks, "READPEAKS DONE\n");
 600         return 0;
 601 }
 602
 603 int
 604 AudioSource::build_peaks_from_scratch ()
 605 {
 606         const framecnt_t bufsize = 65536; // 256kB per disk read for mono data is about ideal
 607
 608         DEBUG_TRACE (DEBUG::Peaks, "Building peaks from scratch\n");
 609
 610         int ret = -1;
 611
 612         {
 613                 /* hold lock while building peaks */
 614
 615                 Glib::Threads::Mutex::Lock lp (_lock);
 616
 617                 if (prepare_for_peakfile_writes ()) {
 618                         goto out;
 619                 }
 620
 621                 framecnt_t current_frame = 0;
 622                 framecnt_t cnt = _length;
 623
 624                 _peaks_built = false;
 625                 boost::scoped_array<Sample> buf(new Sample[bufsize]);
 626
 627                 while (cnt) {
 628
 629                         framecnt_t frames_to_read = min (bufsize, cnt);
 630                         framecnt_t frames_read;
 631
 632                         if ((frames_read = read_unlocked (buf.get(), current_frame, frames_to_read)) != frames_to_read) {
 633                                 error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
 634                                 done_with_peakfile_writes (false);
 635                                 goto out;
 636                         }
 637
 638                         if (compute_and_write_peaks (buf.get(), current_frame, frames_read, true, false, _FPP)) {
 639                                 break;
 640                         }
 641
 642                         current_frame += frames_read;
 643                         cnt -= frames_read;
 644                 }
 645
 646                 if (cnt == 0) {
 647                         /* success */
 648                         truncate_peakfile();
 649                 }
 650
 651                 done_with_peakfile_writes ((cnt == 0));
 652                 if (cnt == 0) {
 653                         ret = 0;
 654                 }
 655         }
 656
 657   out:
 658         if (ret) {
 659                 DEBUG_TRACE (DEBUG::Peaks, string_compose("Could not write peak data, attempting to remove peakfile %1\n", peakpath));
 660                 ::g_unlink (peakpath.c_str());
 661         }
 662
 663         return ret;
 664 }
 665
 666 int
 667 AudioSource::prepare_for_peakfile_writes ()
 668 {
 669         _peakfile_descriptor = new FdFileDescriptor (peakpath, true, 0664);
 670         if ((_peakfile_fd = _peakfile_descriptor->allocate()) < 0) {
 671                 error << string_compose(_("AudioSource: cannot open peakpath (c) \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 672                 return -1;
 673         }
 674         return 0;
 675 }
 676
 677 void
 678 AudioSource::done_with_peakfile_writes (bool done)
 679 {
 680         if (peak_leftover_cnt) {
 681                 compute_and_write_peaks (0, 0, 0, true, false, _FPP);
 682         }
 683
 684         if (done) {
 685                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 686                 _peaks_built = true;
 687                 PeaksReady (); /* EMIT SIGNAL */
 688         }
 689
 690         delete _peakfile_descriptor;
 691         _peakfile_descriptor = 0;
 692 }
 693
 694 /** @param first_frame Offset from the source start of the first frame to process */
 695 int
 696 AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
 697                                       bool force, bool intermediate_peaks_ready)
 698 {
 699         return compute_and_write_peaks (buf, first_frame, cnt, force, intermediate_peaks_ready, _FPP);
 700 }
 701
 702 int
 703 AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
 704                                       bool force, bool intermediate_peaks_ready, framecnt_t fpp)
 705 {
 706         framecnt_t to_do;
 707         uint32_t  peaks_computed;
 708         framepos_t current_frame;
 709         framecnt_t frames_done;
 710         const size_t blocksize = (128 * 1024);
 711         off_t first_peak_byte;
 712         boost::scoped_array<Sample> buf2;
 713
 714         if (_peakfile_descriptor == 0) {
 715                 prepare_for_peakfile_writes ();
 716         }
 717
 718   restart:
 719         if (peak_leftover_cnt) {
 720
 721                 if (first_frame != peak_leftover_frame + peak_leftover_cnt) {
 722
 723                         /* uh-oh, ::seek() since the last ::compute_and_write_peaks(),
 724                            and we have leftovers. flush a single peak (since the leftovers
 725                            never represent more than that, and restart.
 726                         */
 727
 728                         PeakData x;
 729
 730                         x.min = peak_leftovers[0];
 731                         x.max = peak_leftovers[0];
 732
 733                         off_t byte = (peak_leftover_frame / fpp) * sizeof (PeakData);
 734
 735                         off_t offset = lseek (_peakfile_fd, byte, SEEK_SET);
 736
 737                         if (offset != byte) {
 738                                 error << string_compose(_("%1: could not seek in peak file data (%2)"), _name, strerror (errno)) << endmsg;
 739                                 return -1;
 740                         }
 741
 742                         if (::write (_peakfile_fd, &x, sizeof (PeakData)) != sizeof (PeakData)) {
 743                                 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
 744                                 return -1;
 745                         }
 746
 747                         _peak_byte_max = max (_peak_byte_max, (off_t) (byte + sizeof(PeakData)));
 748
 749                         {
 750                                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 751                                 PeakRangeReady (peak_leftover_frame, peak_leftover_cnt); /* EMIT SIGNAL */
 752                                 if (intermediate_peaks_ready) {
 753                                         PeaksReady (); /* EMIT SIGNAL */
 754                                 }
 755                         }
 756
 757                         /* left overs are done */
 758
 759                         peak_leftover_cnt = 0;
 760                         goto restart;
 761                 }
 762
 763                 /* else ... had leftovers, but they immediately preceed the new data, so just
 764                    merge them and compute.
 765                 */
 766
 767                 /* make a new contiguous buffer containing leftovers and the new stuff */
 768
 769                 to_do = cnt + peak_leftover_cnt;
 770                 buf2.reset(new Sample[to_do]);
 771
 772                 /* the remnants */
 773                 memcpy (buf2.get(), peak_leftovers, peak_leftover_cnt * sizeof (Sample));
 774
 775                 /* the new stuff */
 776                 memcpy (buf2.get()+peak_leftover_cnt, buf, cnt * sizeof (Sample));
 777
 778                 /* no more leftovers */
 779                 peak_leftover_cnt = 0;
 780
 781                 /* use the temporary buffer */
 782                 buf = buf2.get();
 783
 784                 /* make sure that when we write into the peakfile, we startup where we left off */
 785
 786                 first_frame = peak_leftover_frame;
 787
 788         } else {
 789                 to_do = cnt;
 790         }
 791
 792         boost::scoped_array<PeakData> peakbuf(new PeakData[(to_do/fpp)+1]);
 793         peaks_computed = 0;
 794         current_frame = first_frame;
 795         frames_done = 0;
 796
 797         while (to_do) {
 798
 799                 /* if some frames were passed in (i.e. we're not flushing leftovers)
 800                    and there are less than fpp to do, save them till
 801                    next time
 802                 */
 803
 804                 if (force && (to_do < fpp)) {
 805                         /* keep the left overs around for next time */
 806
 807                         if (peak_leftover_size < to_do) {
 808                                 delete [] peak_leftovers;
 809                                 peak_leftovers = new Sample[to_do];
 810                                 peak_leftover_size = to_do;
 811                         }
 812                         memcpy (peak_leftovers, buf, to_do * sizeof (Sample));
 813                         peak_leftover_cnt = to_do;
 814                         peak_leftover_frame = current_frame;
 815
 816                         /* done for now */
 817
 818                         break;
 819                 }
 820
 821                 framecnt_t this_time = min (fpp, to_do);
 822
 823                 peakbuf[peaks_computed].max = buf[0];
 824                 peakbuf[peaks_computed].min = buf[0];
 825
 826                 ARDOUR::find_peaks (buf+1, this_time-1, &peakbuf[peaks_computed].min, &peakbuf[peaks_computed].max);
 827
 828                 peaks_computed++;
 829                 buf += this_time;
 830                 to_do -= this_time;
 831                 frames_done += this_time;
 832                 current_frame += this_time;
 833         }
 834
 835         first_peak_byte = (first_frame / fpp) * sizeof (PeakData);
 836
 837         if (can_truncate_peaks()) {
 838
 839                 /* on some filesystems (ext3, at least) this helps to reduce fragmentation of
 840                    the peakfiles. its not guaranteed to do so, and even on ext3 (as of december 2006)
 841                    it does not cause single-extent allocation even for peakfiles of
 842                    less than BLOCKSIZE bytes.  only call ftruncate if we'll make the file larger.
 843                 */
 844
 845                 off_t endpos = lseek (_peakfile_fd, 0, SEEK_END);
 846                 off_t target_length = blocksize * ((first_peak_byte + blocksize + 1) / blocksize);
 847
 848                 if (endpos < target_length) {
 849                         DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile %1\n", peakpath));
 850                         if (ftruncate (_peakfile_fd, target_length)) {
 851                                 /* error doesn't actually matter so continue on without testing */
 852                         }
 853                 }
 854         }
 855
 856
 857         off_t offset = lseek(_peakfile_fd, first_peak_byte, SEEK_SET);
 858
 859         if (offset != first_peak_byte) {
 860                 error << string_compose(_("%1: could not seek in peak file data (%2)"), _name, strerror (errno)) << endmsg;
 861                 return -1;
 862         }
 863
 864         ssize_t bytes_to_write = sizeof (PeakData) * peaks_computed;
 865
 866         ssize_t bytes_written = ::write (_peakfile_fd, peakbuf.get(), bytes_to_write);
 867
 868         if (bytes_written != bytes_to_write) {
 869                 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
 870                 return -1;
 871         }
 872
 873         _peak_byte_max = max (_peak_byte_max, (off_t) (first_peak_byte + bytes_to_write));
 874
 875         if (frames_done) {
 876                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 877                 PeakRangeReady (first_frame, frames_done); /* EMIT SIGNAL */
 878                 if (intermediate_peaks_ready) {
 879                         PeaksReady (); /* EMIT SIGNAL */
 880                 }
 881         }
 882
 883         return 0;
 884 }
 885
 886 void
 887 AudioSource::truncate_peakfile ()
 888 {
 889         if (_peakfile_descriptor == 0) {
 890                 error << string_compose (_("programming error: %1"), "AudioSource::truncate_peakfile() called without open peakfile descriptor")
 891                       << endmsg;
 892                 return;
 893         }
 894
 895         /* truncate the peakfile down to its natural length if necessary */
 896
 897         off_t end = lseek (_peakfile_fd, 0, SEEK_END);
 898
 899         if (end > _peak_byte_max) {
 900                 DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile  %1\n", peakpath));
 901                 if (ftruncate (_peakfile_fd, _peak_byte_max)) {
 902                         error << string_compose (_("could not truncate peakfile %1 to %2 (error: %3)"),
 903                                                  peakpath, _peak_byte_max, errno) << endmsg;
 904                 }
 905         }
 906 }
 907
 908 framecnt_t
 909 AudioSource::available_peaks (double zoom_factor) const
 910 {
 911         if (zoom_factor < _FPP) {
 912                 return length(_timeline_position); // peak data will come from the audio file
 913         }
 914
 915         /* peak data comes from peakfile, but the filesize might not represent
 916            the valid data due to ftruncate optimizations, so use _peak_byte_max state.
 917            XXX - there might be some atomicity issues here, we should probably add a lock,
 918            but _peak_byte_max only monotonically increases after initialization.
 919         */
 920
 921         off_t end = _peak_byte_max;
 922
 923         return (end/sizeof(PeakData)) * _FPP;
 924 }
 925
 926 void
 927 AudioSource::mark_streaming_write_completed ()
 928 {
 929         Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 930
 931         if (_peaks_built) {
 932                 PeaksReady (); /* EMIT SIGNAL */
 933         }
 934 }
 935
 936 void
 937 AudioSource::allocate_working_buffers (framecnt_t framerate)
 938 {
 939         Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
 940
 941
 942         /* Note: we don't need any buffers allocated until
 943            a level 1 audiosource is created, at which
 944            time we'll call ::ensure_buffers_for_level()
 945            with the right value and do the right thing.
 946         */
 947
 948         if (!_mixdown_buffers.empty()) {
 949                 ensure_buffers_for_level_locked ( _mixdown_buffers.size(), framerate);
 950         }
 951 }
 952
 953 void
 954 AudioSource::ensure_buffers_for_level (uint32_t level, framecnt_t frame_rate)
 955 {
 956         Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
 957         ensure_buffers_for_level_locked (level, frame_rate);
 958 }
 959
 960 void
 961 AudioSource::ensure_buffers_for_level_locked (uint32_t level, framecnt_t frame_rate)
 962 {
 963         framecnt_t nframes = (framecnt_t) floor (Config->get_audio_playback_buffer_seconds() * frame_rate);
 964
 965         /* this may be called because either "level" or "frame_rate" have
 966          * changed. and it may be called with "level" smaller than the current
 967          * number of buffers, because a new compound region has been created at
 968          * a more shallow level than the deepest one we currently have.
 969          */
 970
 971         uint32_t limit = max ((size_t) level, _mixdown_buffers.size());
 972
 973         _mixdown_buffers.clear ();
 974         _gain_buffers.clear ();
 975
 976         for (uint32_t n = 0; n < limit; ++n) {
 977                 _mixdown_buffers.push_back (boost::shared_array<Sample> (new Sample[nframes]));
 978                 _gain_buffers.push_back (boost::shared_array<gain_t> (new gain_t[nframes]));
 979         }
 980 }