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