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     $Id: source.cc 404 2006-03-17 17:39:21Z pauld $
  19 */
  20
  21 #include <sys/stat.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <poll.h>
  25 #include <float.h>
  26 #include <utime.h>
  27 #include <cerrno>
  28 #include <ctime>
  29 #include <cmath>
  30 #include <iomanip>
  31 #include <algorithm>
  32 #include <vector>
  33
  34 #include <pbd/xml++.h>
  35 #include <pbd/pthread_utils.h>
  36
  37 #include <ardour/audiosource.h>
  38
  39 #include "i18n.h"
  40
  41 using namespace std;
  42 using namespace ARDOUR;
  43 using namespace PBD;
  44
  45 pthread_t                    AudioSource::peak_thread;
  46 bool                         AudioSource::have_peak_thread = false;
  47 vector<boost::shared_ptr<AudioSource> > AudioSource::pending_peak_sources;
  48 Glib::Mutex*                 AudioSource::pending_peak_sources_lock = 0;
  49 int                          AudioSource::peak_request_pipe[2];
  50
  51 bool AudioSource::_build_missing_peakfiles = false;
  52 bool AudioSource::_build_peakfiles = false;
  53
  54 AudioSource::AudioSource (Session& s, string name)
  55         : Source (s, name, DataType::AUDIO)
  56 {
  57         if (pending_peak_sources_lock == 0) {
  58                 pending_peak_sources_lock = new Glib::Mutex;
  59         }
  60
  61         _peaks_built = false;
  62         next_peak_clear_should_notify = true;
  63         _read_data_count = 0;
  64         _write_data_count = 0;
  65 }
  66
  67 AudioSource::AudioSource (Session& s, const XMLNode& node)
  68         : Source (s, node)
  69 {
  70         if (pending_peak_sources_lock == 0) {
  71                 pending_peak_sources_lock = new Glib::Mutex;
  72         }
  73
  74         _peaks_built = false;
  75         next_peak_clear_should_notify = true;
  76         _read_data_count = 0;
  77         _write_data_count = 0;
  78
  79         if (set_state (node)) {
  80                 throw failed_constructor();
  81         }
  82 }
  83
  84 AudioSource::~AudioSource ()
  85 {
  86 }
  87
  88 XMLNode&
  89 AudioSource::get_state ()
  90 {
  91         XMLNode& node (Source::get_state());
  92
  93         if (_captured_for.length()) {
  94                 node.add_property ("captured-for", _captured_for);
  95         }
  96
  97         return node;
  98 }
  99
 100 int
 101 AudioSource::set_state (const XMLNode& node)
 102 {
 103         const XMLProperty* prop;
 104
 105         Source::set_state (node);
 106
 107         if ((prop = node.property ("captured-for")) != 0) {
 108                 _captured_for = prop->value();
 109         }
 110
 111         return 0;
 112 }
 113
 114 /***********************************************************************
 115   PEAK FILE STUFF
 116  ***********************************************************************/
 117
 118 void*
 119 AudioSource::peak_thread_work (void* arg)
 120 {
 121         PBD::ThreadCreated (pthread_self(), X_("Peak"));
 122         struct pollfd pfd[1];
 123
 124         if (pending_peak_sources_lock == 0) {
 125                 pending_peak_sources_lock = new Glib::Mutex;
 126         }
 127
 128         Glib::Mutex::Lock lm (*pending_peak_sources_lock);
 129
 130         while (true) {
 131
 132                 pfd[0].fd = peak_request_pipe[0];
 133                 pfd[0].events = POLLIN|POLLERR|POLLHUP;
 134
 135                 pending_peak_sources_lock->unlock ();
 136
 137                 if (poll (pfd, 1, -1) < 0) {
 138
 139                         if (errno == EINTR) {
 140                                 pending_peak_sources_lock->lock ();
 141                                 continue;
 142                         }
 143
 144                         error << string_compose (_("poll on peak request pipe failed (%1)"),
 145                                           strerror (errno))
 146                               << endmsg;
 147                         break;
 148                 }
 149
 150                 if (pfd[0].revents & ~POLLIN) {
 151                         error << _("Error on peak thread request pipe") << endmsg;
 152                         break;
 153                 }
 154
 155                 if (pfd[0].revents & POLLIN) {
 156
 157                         char req;
 158
 159                         /* empty the pipe of all current requests */
 160
 161                         while (1) {
 162                                 size_t nread = ::read (peak_request_pipe[0], &req, sizeof (req));
 163
 164                                 if (nread == 1) {
 165                                         switch ((PeakRequest::Type) req) {
 166
 167                                         case PeakRequest::Build:
 168                                                 break;
 169
 170                                         case PeakRequest::Quit:
 171                                                 pthread_exit_pbd (0);
 172                                                 /*NOTREACHED*/
 173                                                 break;
 174
 175                                         default:
 176                                                 break;
 177                                         }
 178
 179                                 } else if (nread == 0) {
 180                                         break;
 181                                 } else if (errno == EAGAIN) {
 182                                         break;
 183                                 } else {
 184                                         fatal << _("Error reading from peak request pipe") << endmsg;
 185                                         /*NOTREACHED*/
 186                                 }
 187                         }
 188                 }
 189
 190                 pending_peak_sources_lock->lock ();
 191
 192                 while (!pending_peak_sources.empty()) {
 193
 194                         boost::shared_ptr<AudioSource> s = pending_peak_sources.front();
 195                         pending_peak_sources.erase (pending_peak_sources.begin());
 196
 197                         pending_peak_sources_lock->unlock ();
 198                         s->build_peaks();
 199                         pending_peak_sources_lock->lock ();
 200                 }
 201         }
 202
 203         pthread_exit_pbd (0);
 204         /*NOTREACHED*/
 205         return 0;
 206 }
 207
 208 int
 209 AudioSource::start_peak_thread ()
 210 {
 211         if (!_build_peakfiles) {
 212                 return 0;
 213         }
 214
 215         if (pipe (peak_request_pipe)) {
 216                 error << string_compose(_("Cannot create transport request signal pipe (%1)"), strerror (errno)) << endmsg;
 217                 return -1;
 218         }
 219
 220         if (fcntl (peak_request_pipe[0], F_SETFL, O_NONBLOCK)) {
 221                 error << string_compose(_("UI: cannot set O_NONBLOCK on peak request pipe (%1)"), strerror (errno)) << endmsg;
 222                 return -1;
 223         }
 224
 225         if (fcntl (peak_request_pipe[1], F_SETFL, O_NONBLOCK)) {
 226                 error << string_compose(_("UI: cannot set O_NONBLOCK on peak request pipe (%1)"), strerror (errno)) << endmsg;
 227                 return -1;
 228         }
 229
 230         if (pthread_create_and_store ("peak file builder", &peak_thread, 0, peak_thread_work, 0)) {
 231                 error << _("AudioSource: could not create peak thread") << endmsg;
 232                 return -1;
 233         }
 234
 235         have_peak_thread = true;
 236         return 0;
 237 }
 238
 239 void
 240 AudioSource::stop_peak_thread ()
 241 {
 242         if (!have_peak_thread) {
 243                 return;
 244         }
 245
 246         void* status;
 247
 248         char c = (char) PeakRequest::Quit;
 249         ::write (peak_request_pipe[1], &c, 1);
 250         pthread_join (peak_thread, &status);
 251 }
 252
 253 void
 254 AudioSource::queue_for_peaks (boost::shared_ptr<AudioSource> source)
 255 {
 256         if (have_peak_thread) {
 257
 258                 Glib::Mutex::Lock lm (*pending_peak_sources_lock);
 259
 260                 source->next_peak_clear_should_notify = true;
 261
 262                 if (find (pending_peak_sources.begin(),
 263                           pending_peak_sources.end(),
 264                           source) == pending_peak_sources.end()) {
 265                         pending_peak_sources.push_back (source);
 266                 }
 267
 268                 char c = (char) PeakRequest::Build;
 269                 ::write (peak_request_pipe[1], &c, 1);
 270         }
 271 }
 272
 273 void AudioSource::clear_queue_for_peaks ()
 274 {
 275         /* this is done to cancel a group of running peak builds */
 276         if (have_peak_thread) {
 277                 Glib::Mutex::Lock lm (*pending_peak_sources_lock);
 278                 pending_peak_sources.clear ();
 279         }
 280 }
 281
 282
 283 bool
 284 AudioSource::peaks_ready (sigc::slot<void> the_slot, sigc::connection& conn) const
 285 {
 286         bool ret;
 287         Glib::Mutex::Lock lm (_lock);
 288
 289         /* check to see if the peak data is ready. if not
 290            connect the slot while still holding the lock.
 291         */
 292
 293         if (!(ret = _peaks_built)) {
 294                 conn = PeaksReady.connect (the_slot);
 295         }
 296
 297         return ret;
 298 }
 299
 300 void
 301 AudioSource::touch_peakfile ()
 302 {
 303         struct stat statbuf;
 304
 305         if (stat (peakpath.c_str(), &statbuf) != 0 || statbuf.st_size == 0) {
 306                 return;
 307         }
 308
 309         struct utimbuf tbuf;
 310
 311         tbuf.actime = statbuf.st_atime;
 312         tbuf.modtime = time ((time_t) 0);
 313
 314         utime (peakpath.c_str(), &tbuf);
 315 }
 316
 317 int
 318 AudioSource::rename_peakfile (string newpath)
 319 {
 320         /* caller must hold _lock */
 321
 322         string oldpath = peakpath;
 323
 324         if (access (oldpath.c_str(), F_OK) == 0) {
 325                 if (rename (oldpath.c_str(), newpath.c_str()) != 0) {
 326                         error << string_compose (_("cannot rename peakfile for %1 from %2 to %3 (%4)"), _name, oldpath, newpath, strerror (errno)) << endmsg;
 327                         return -1;
 328                 }
 329         }
 330
 331         peakpath = newpath;
 332
 333         return 0;
 334 }
 335
 336 int
 337 AudioSource::initialize_peakfile (bool newfile, string audio_path)
 338 {
 339         struct stat statbuf;
 340
 341         peakpath = peak_path (audio_path);
 342
 343         /* Nasty band-aid for older sessions that were created before we
 344            used libsndfile for all audio files.
 345         */
 346
 347         if (!newfile && access (peakpath.c_str(), R_OK) != 0) {
 348                 string str = old_peak_path (audio_path);
 349                 if (access (str.c_str(), R_OK) == 0) {
 350                         peakpath = str;
 351                 }
 352         }
 353
 354         if (newfile) {
 355
 356                 if (!_build_peakfiles) {
 357                         return 0;
 358                 }
 359
 360                 _peaks_built = false;
 361
 362         } else {
 363
 364                 if (stat (peakpath.c_str(), &statbuf)) {
 365                         if (errno != ENOENT) {
 366                                 /* it exists in the peaks dir, but there is some kind of error */
 367
 368                                 error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), peakpath) << endmsg;
 369                                 return -1;
 370                         }
 371                 } else {
 372
 373                         /* we found it in the peaks dir */
 374                 }
 375
 376                 if (statbuf.st_size == 0) {
 377                         _peaks_built = false;
 378                 } else {
 379                         // Check if the audio file has changed since the peakfile was built.
 380                         struct stat stat_file;
 381                         int err = stat (audio_path.c_str(), &stat_file);
 382
 383                         if (!err && stat_file.st_mtime > statbuf.st_mtime){
 384                                 _peaks_built = false;
 385                         } else {
 386                                 _peaks_built = true;
 387                         }
 388                 }
 389         }
 390
 391         if (!newfile && !_peaks_built && _build_missing_peakfiles && _build_peakfiles) {
 392                 build_peaks_from_scratch ();
 393         }
 394
 395         return 0;
 396 }
 397
 398 nframes_t
 399 AudioSource::read (Sample *dst, nframes_t start, nframes_t cnt) const
 400 {
 401         Glib::Mutex::Lock lm (_lock);
 402         return read_unlocked (dst, start, cnt);
 403 }
 404
 405 nframes_t
 406 AudioSource::write (Sample *dst, nframes_t cnt)
 407 {
 408         Glib::Mutex::Lock lm (_lock);
 409         return write_unlocked (dst, cnt);
 410 }
 411
 412 int
 413 AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nframes_t cnt, double samples_per_visual_peak) const
 414 {
 415         Glib::Mutex::Lock lm (_lock);
 416         double scale;
 417         double expected_peaks;
 418         PeakData::PeakDatum xmax;
 419         PeakData::PeakDatum xmin;
 420         int32_t to_read;
 421         uint32_t nread;
 422         nframes_t zero_fill = 0;
 423         int ret = -1;
 424         PeakData* staging = 0;
 425         Sample* raw_staging = 0;
 426         int peakfile = -1;
 427
 428         expected_peaks = (cnt / (double) frames_per_peak);
 429         scale = npeaks/expected_peaks;
 430
 431 #if 0
 432         cerr << "======>RP: npeaks = " << npeaks
 433              << " start = " << start
 434              << " cnt = " << cnt
 435              << " len = " << _length
 436              << "   samples_per_visual_peak =" << samples_per_visual_peak
 437              << " expected was " << expected_peaks << " ... scale = " << scale
 438              << " PD ptr = " << peaks
 439              <<endl;
 440
 441 #endif
 442
 443         /* fix for near-end-of-file conditions */
 444
 445         if (cnt > _length - start) {
 446                 // cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << endl;
 447                 cnt = _length - start;
 448                 nframes_t old = npeaks;
 449                 npeaks = min ((nframes_t) floor (cnt / samples_per_visual_peak), npeaks);
 450                 zero_fill = old - npeaks;
 451         }
 452
 453         // cerr << "actual npeaks = " << npeaks << " zf = " << zero_fill << endl;
 454
 455         if (npeaks == cnt) {
 456
 457                 cerr << "RAW DATA\n";
 458
 459                 /* no scaling at all, just get the sample data and duplicate it for
 460                    both max and min peak values.
 461                 */
 462
 463                 Sample* raw_staging = new Sample[cnt];
 464
 465                 if (read_unlocked (raw_staging, start, cnt) != cnt) {
 466                         error << _("cannot read sample data for unscaled peak computation") << endmsg;
 467                         return -1;
 468                 }
 469
 470                 for (nframes_t i = 0; i < npeaks; ++i) {
 471                         peaks[i].max = raw_staging[i];
 472                         peaks[i].min = raw_staging[i];
 473                 }
 474
 475                 delete [] raw_staging;
 476                 return 0;
 477         }
 478
 479         if (scale == 1.0) {
 480
 481                 off_t first_peak_byte = (start / frames_per_peak) * sizeof (PeakData);
 482
 483                 /* open, read, close */
 484
 485                 if ((peakfile = ::open (peakpath.c_str(), O_RDWR|O_CREAT, 0664)) < 0) {
 486                         error << string_compose(_("AudioSource: cannot open peakpath \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 487                         return -1;
 488                 }
 489
 490                 // cerr << "DIRECT PEAKS\n";
 491
 492                 nread = ::pread (peakfile, peaks, sizeof (PeakData)* npeaks, first_peak_byte);
 493                 close (peakfile);
 494
 495                 if (nread != sizeof (PeakData) * npeaks) {
 496                         cerr << "AudioSource["
 497                              << _name
 498                              << "]: cannot read peaks from peakfile! (read only "
 499                              << nread
 500                              << " not "
 501                              << npeaks
 502                               << "at sample "
 503                              << start
 504                              << " = byte "
 505                              << first_peak_byte
 506                              << ')'
 507                              << endl;
 508                         return -1;
 509                 }
 510
 511                 if (zero_fill) {
 512                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 513                 }
 514
 515                 return 0;
 516         }
 517
 518
 519         nframes_t tnp;
 520
 521         if (scale < 1.0) {
 522
 523                 // cerr << "DOWNSAMPLE\n";
 524
 525                 /* the caller wants:
 526
 527                     - more frames-per-peak (lower resolution) than the peakfile, or to put it another way,
 528                     - less peaks than the peakfile holds for the same range
 529
 530                     So, read a block into a staging area, and then downsample from there.
 531
 532                     to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks
 533                 */
 534
 535                 const uint32_t chunksize = (uint32_t) min (expected_peaks, 4096.0);
 536
 537                 staging = new PeakData[chunksize];
 538
 539                 /* compute the rounded up frame position  */
 540
 541                 nframes_t current_frame = start;
 542                 nframes_t current_stored_peak = (nframes_t) ceil (current_frame / (double) frames_per_peak);
 543                 uint32_t       next_visual_peak  = (uint32_t) ceil (current_frame / samples_per_visual_peak);
 544                 double         next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
 545                 uint32_t       stored_peak_before_next_visual_peak = (nframes_t) next_visual_peak_frame / frames_per_peak;
 546                 uint32_t       nvisual_peaks = 0;
 547                 uint32_t       stored_peaks_read = 0;
 548                 uint32_t       i = 0;
 549
 550                 /* handle the case where the initial visual peak is on a pixel boundary */
 551
 552                 current_stored_peak = min (current_stored_peak, stored_peak_before_next_visual_peak);
 553
 554                 /* open ... close during out: handling */
 555
 556                 if ((peakfile = ::open (peakpath.c_str(), O_RDWR|O_CREAT, 0664)) < 0) {
 557                         error << string_compose(_("AudioSource: cannot open peakpath \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 558                         return 0;
 559                 }
 560
 561                 while (nvisual_peaks < npeaks) {
 562
 563                         if (i == stored_peaks_read) {
 564
 565                                 uint32_t       start_byte = current_stored_peak * sizeof(PeakData);
 566                                 tnp = min ((_length/frames_per_peak - current_stored_peak), (nframes_t) expected_peaks);
 567                                 to_read = min (chunksize, tnp);
 568
 569                                 off_t fend = lseek (peakfile, 0, SEEK_END);
 570
 571                                 if ((nread = ::pread (peakfile, staging, sizeof (PeakData) * to_read, start_byte))
 572                                     != sizeof (PeakData) * to_read) {
 573                                         cerr << "AudioSource["
 574                                              << _name
 575                                              << "]: cannot read peak data from peakfile ("
 576                                              << (nread / sizeof(PeakData))
 577                                              << " peaks instead of "
 578                                              << to_read
 579                                              << ") ("
 580                                              << strerror (errno)
 581                                              << ')'
 582                                              << " at start_byte = " << start_byte
 583                                              << " _length = " << _length << " versus len = " << fend
 584                                              << " expected maxpeaks = " << (_length - current_frame)/frames_per_peak
 585                                              << " npeaks was " << npeaks
 586                                              << endl;
 587                                         goto out;
 588                                 }
 589
 590                                 i = 0;
 591                                 stored_peaks_read = nread / sizeof(PeakData);
 592                         }
 593
 594                         xmax = -1.0;
 595                         xmin = 1.0;
 596
 597                         while ((i < stored_peaks_read) && (current_stored_peak <= stored_peak_before_next_visual_peak)) {
 598
 599                                 xmax = max (xmax, staging[i].max);
 600                                 xmin = min (xmin, staging[i].min);
 601                                 ++i;
 602                                 ++current_stored_peak;
 603                                 --expected_peaks;
 604                         }
 605
 606                         peaks[nvisual_peaks].max = xmax;
 607                         peaks[nvisual_peaks].min = xmin;
 608                         ++nvisual_peaks;
 609                         ++next_visual_peak;
 610
 611                         //next_visual_peak_frame = min ((next_visual_peak * samples_per_visual_peak), (next_visual_peak_frame+samples_per_visual_peak) );
 612                         next_visual_peak_frame =  min ((double) start+cnt, (next_visual_peak_frame+samples_per_visual_peak) );
 613                         stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / frames_per_peak;
 614                 }
 615
 616                 if (zero_fill) {
 617                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 618                 }
 619
 620                 ret = 0;
 621
 622         } else {
 623
 624                 // cerr << "UPSAMPLE\n";
 625
 626                 /* the caller wants
 627
 628                      - less frames-per-peak (more resolution)
 629                      - more peaks than stored in the Peakfile
 630
 631                    So, fetch data from the raw source, and generate peak
 632                    data on the fly.
 633                 */
 634
 635                 nframes_t frames_read = 0;
 636                 nframes_t current_frame = start;
 637                 nframes_t i = 0;
 638                 nframes_t nvisual_peaks = 0;
 639                 nframes_t chunksize = (nframes_t) min (cnt, (nframes_t) 4096);
 640                 raw_staging = new Sample[chunksize];
 641
 642                 nframes_t frame_pos = start;
 643                 double pixel_pos = floor (frame_pos / samples_per_visual_peak);
 644                 double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
 645                 double pixels_per_frame = 1.0 / samples_per_visual_peak;
 646
 647                 xmin = 1.0;
 648                 xmax = -1.0;
 649
 650                 while (nvisual_peaks < npeaks) {
 651
 652                         if (i == frames_read) {
 653
 654                                 to_read = min (chunksize, (_length - current_frame));
 655
 656                                 if ((frames_read = read_unlocked (raw_staging, current_frame, to_read)) == 0) {
 657                                         error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3")
 658                                                          , _name, to_read, current_frame)
 659                                               << endmsg;
 660                                         goto out;
 661                                 }
 662
 663                                 i = 0;
 664                         }
 665
 666                         xmax = max (xmax, raw_staging[i]);
 667                         xmin = min (xmin, raw_staging[i]);
 668                         ++i;
 669                         ++current_frame;
 670                         pixel_pos += pixels_per_frame;
 671
 672                         if (pixel_pos >= next_pixel_pos) {
 673
 674                                 peaks[nvisual_peaks].max = xmax;
 675                                 peaks[nvisual_peaks].min = xmin;
 676                                 ++nvisual_peaks;
 677                                 xmin = 1.0;
 678                                 xmax = -1.0;
 679
 680                                 next_pixel_pos = ceil (pixel_pos + 0.5);
 681                         }
 682                 }
 683
 684                 if (zero_fill) {
 685                         memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 686                 }
 687
 688                 ret = 0;
 689         }
 690
 691   out:
 692         if (peakfile >= 0) {
 693                 close (peakfile);
 694         }
 695
 696         if (staging) {
 697                 delete [] staging;
 698         }
 699
 700         if (raw_staging) {
 701                 delete [] raw_staging;
 702         }
 703
 704         return ret;
 705 }
 706
 707 #undef DEBUG_PEAK_BUILD
 708
 709 int
 710 AudioSource::build_peaks ()
 711 {
 712         vector<PeakBuildRecord*> built;
 713         int status = -1;
 714         bool pr_signal = false;
 715         list<PeakBuildRecord*> copy;
 716
 717         {
 718                 Glib::Mutex::Lock lm (_lock);
 719                 copy = pending_peak_builds;
 720                 pending_peak_builds.clear ();
 721         }
 722
 723 #ifdef DEBUG_PEAK_BUILD
 724         cerr << "build peaks with " << copy.size() << " requests pending\n";
 725 #endif
 726
 727         for (list<PeakBuildRecord *>::iterator i = copy.begin(); i != copy.end(); ++i) {
 728
 729                 if ((status = do_build_peak ((*i)->frame, (*i)->cnt)) != 0) {
 730                         unlink (peakpath.c_str());
 731                         break;
 732                 }
 733                 built.push_back (new PeakBuildRecord (*(*i)));
 734                 delete *i;
 735         }
 736
 737         {
 738                 Glib::Mutex::Lock lm (_lock);
 739
 740                 if (status == 0) {
 741                         _peaks_built = true;
 742
 743                         if (next_peak_clear_should_notify) {
 744                                 next_peak_clear_should_notify = false;
 745                                 pr_signal = true;
 746                         }
 747                 }
 748         }
 749
 750         if (status == 0) {
 751                 for (vector<PeakBuildRecord *>::iterator i = built.begin(); i != built.end(); ++i) {
 752                         PeakRangeReady ((*i)->frame, (*i)->cnt); /* EMIT SIGNAL */
 753                         delete *i;
 754                 }
 755
 756                 if (pr_signal) {
 757                         PeaksReady (); /* EMIT SIGNAL */
 758                 }
 759         }
 760
 761         return status;
 762 }
 763
 764 int
 765 AudioSource::do_build_peak (nframes_t first_frame, nframes_t cnt)
 766 {
 767         nframes_t current_frame;
 768         Sample buf[frames_per_peak];
 769         Sample xmin, xmax;
 770         uint32_t  peaki;
 771         PeakData* peakbuf;
 772         nframes_t frames_read;
 773         nframes_t frames_to_read;
 774         off_t first_peak_byte;
 775         int peakfile = -1;
 776         int ret = -1;
 777
 778 #ifdef DEBUG_PEAK_BUILD
 779         cerr << pthread_self() << ": " << _name << ": building peaks for " << first_frame << " to " << first_frame + cnt - 1 << endl;
 780 #endif
 781
 782         first_peak_byte = (first_frame / frames_per_peak) * sizeof (PeakData);
 783
 784 #ifdef DEBUG_PEAK_BUILD
 785         cerr << "seeking to " << first_peak_byte << " before writing new peak data\n";
 786 #endif
 787
 788         current_frame = first_frame;
 789         peakbuf = new PeakData[(cnt/frames_per_peak)+1];
 790         peaki = 0;
 791
 792         if ((peakfile = ::open (peakpath.c_str(), O_RDWR|O_CREAT, 0664)) < 0) {
 793                 error << string_compose(_("AudioSource: cannot open peakpath \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 794                 return -1;
 795         }
 796
 797         while (cnt) {
 798
 799                 frames_to_read = min (frames_per_peak, cnt);
 800
 801                 /* lock for every read */
 802
 803                 if ((frames_read = read (buf, current_frame, frames_to_read)) != frames_to_read) {
 804                         error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
 805                         goto out;
 806                 }
 807
 808                 xmin = buf[0];
 809                 xmax = buf[0];
 810
 811                 for (nframes_t n = 1; n < frames_read; ++n) {
 812                         xmax = max (xmax, buf[n]);
 813                         xmin = min (xmin, buf[n]);
 814
 815 //                      if (current_frame < frames_read) {
 816 //                              cerr << "sample = " << buf[n] << " max = " << xmax << " min = " << xmin << " max of 2 = " << max (xmax, buf[n]) << endl;
 817 //                      }
 818                 }
 819
 820                 peakbuf[peaki].max = xmax;
 821                 peakbuf[peaki].min = xmin;
 822                 peaki++;
 823
 824                 current_frame += frames_read;
 825                 cnt -= frames_read;
 826         }
 827
 828         if (::pwrite (peakfile, peakbuf, sizeof (PeakData) * peaki, first_peak_byte) != (ssize_t) (sizeof (PeakData) * peaki)) {
 829                 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
 830                 goto out;
 831         }
 832
 833         ret = 0;
 834
 835   out:
 836         delete [] peakbuf;
 837         if (peakfile >= 0) {
 838                 close (peakfile);
 839         }
 840         return ret;
 841 }
 842
 843 void
 844 AudioSource::build_peaks_from_scratch ()
 845 {
 846         Glib::Mutex::Lock lp (_lock);
 847
 848         next_peak_clear_should_notify = true;
 849         pending_peak_builds.push_back (new PeakBuildRecord (0, _length));
 850         queue_for_peaks (shared_from_this());
 851 }
 852
 853 bool
 854 AudioSource::file_changed (string path)
 855 {
 856         struct stat stat_file;
 857         struct stat stat_peak;
 858
 859         int e1 = stat (path.c_str(), &stat_file);
 860         int e2 = stat (peak_path(path).c_str(), &stat_peak);
 861
 862         if (!e1 && !e2 && stat_file.st_mtime > stat_peak.st_mtime){
 863                 return true;
 864         } else {
 865                 return false;
 866         }
 867 }
 868
 869 nframes_t
 870 AudioSource::available_peaks (double zoom_factor) const
 871 {
 872         int peakfile;
 873         off_t end;
 874
 875         if (zoom_factor < frames_per_peak) {
 876                 return length(); // peak data will come from the audio file
 877         }
 878
 879         /* peak data comes from peakfile */
 880
 881         if ((peakfile = ::open (peakpath.c_str(), O_RDONLY)) < 0) {
 882                 error << string_compose(_("AudioSource: cannot open peakpath \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
 883                 return 0;
 884         }
 885
 886         {
 887                 Glib::Mutex::Lock lm (_lock);
 888                 end = lseek (peakfile, 0, SEEK_END);
 889         }
 890
 891         close (peakfile);
 892
 893         return (end/sizeof(PeakData)) * frames_per_peak;
 894 }
 895