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