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 #include "ardour/session.h"
  60
  61 #include "i18n.h"
  62
  63 #include "ardour/debug.h"
  64
  65 using namespace std;
  66 using namespace ARDOUR;
  67 using namespace PBD;
  68
  69 Glib::Threads::Mutex AudioSource::_level_buffer_lock;
  70 vector<boost::shared_array<Sample> > AudioSource::_mixdown_buffers;
  71 vector<boost::shared_array<gain_t> > AudioSource::_gain_buffers;
  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, const 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 (const string& audio_path)
 240 {
 241         GStatBuf statbuf;
 242
 243         _peakpath = construct_peak_filepath (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                         GStatBuf stat_file;
 275                         int err = g_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         if (!_captured_for.empty()) {
 368
 369                 /* _captured_for is only set after a capture pass is
 370                  * complete. so we know that capturing is finished for this
 371                  * file, and now we can check actual size of the peakfile is at
 372                  * least large enough for all the data in the audio file. if it
 373                  * is too short, assume that a crash or other error truncated
 374                  * it, and rebuild it from scratch.
 375                  *
 376                  * XXX this may not work for destructive recording, but we
 377                  * might decided to get rid of that anyway.
 378                  *
 379                  */
 380
 381                 const off_t expected_file_size = (_length / (double) samples_per_file_peak) * sizeof (PeakData);
 382
 383                 if (statbuf.st_size < expected_file_size) {
 384                         warning << string_compose (_("peak file %1 is truncated from %2 to %3"), _peakpath, expected_file_size, statbuf.st_size) << endmsg;
 385                         const_cast<AudioSource*>(this)->build_peaks_from_scratch ();
 386                         if (g_stat (_peakpath.c_str(), &statbuf) != 0) {
 387                                 error << string_compose (_("Cannot open peakfile @ %1 for size check (%2) after rebuild"), _peakpath, strerror (errno)) << endmsg;
 388                         }
 389                         if (statbuf.st_size < expected_file_size) {
 390                                 fatal << "peak file is still truncated after rebuild" << endmsg;
 391                                 /*NOTREACHED*/
 392                         }
 393                 }
 394         }
 395
 396         ScopedFileDescriptor sfd (g_open (_peakpath.c_str(), O_RDONLY, 0444));
 397
 398         if (sfd < 0) {
 399                 error << string_compose (_("Cannot open peakfile @ %1 for reading (%2)"), _peakpath, strerror (errno)) << endmsg;
 400                 return -1;
 401         }
 402
 403         scale = npeaks/expected_peaks;
 404
 405
 406         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"
 407                         , npeaks, start, cnt, _length, samples_per_visual_peak, expected_peaks, scale, peaks));
 408
 409         /* fix for near-end-of-file conditions */
 410
 411         if (cnt > _length - start) {
 412                 // cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << " (" << _length - start << ")" << endl;
 413                 cnt = _length - start;
 414                 read_npeaks = min ((framecnt_t) floor (cnt / samples_per_visual_peak), npeaks);
 415                 zero_fill = npeaks - read_npeaks;
 416                 expected_peaks = (cnt / (double) samples_per_file_peak);
 417                 scale = npeaks/expected_peaks;
 418         }
 419
 420         // cerr << "actual npeaks = " << read_npeaks << " zf = " << zero_fill << endl;
 421
 422         if (npeaks == cnt) {
 423
 424                 DEBUG_TRACE (DEBUG::Peaks, "RAW DATA\n");
 425
 426                 /* no scaling at all, just get the sample data and duplicate it for
 427                    both max and min peak values.
 428                 */
 429
 430                 boost::scoped_array<Sample> raw_staging(new Sample[cnt]);
 431
 432                 if (read_unlocked (raw_staging.get(), start, cnt) != cnt) {
 433                         error << _("cannot read sample data for unscaled peak computation") << endmsg;
 434                         return -1;
 435                 }
 436
 437                 for (framecnt_t i = 0; i < npeaks; ++i) {
 438                         peaks[i].max = raw_staging[i];
 439                         peaks[i].min = raw_staging[i];
 440                 }
 441
 442                 return 0;
 443         }
 444
 445         if (scale == 1.0) {
 446                 off_t first_peak_byte = (start / samples_per_file_peak) * sizeof (PeakData);
 447                 size_t bytes_to_read = sizeof (PeakData) * read_npeaks;
 448                 /* open, read, close */
 449
 450                 DEBUG_TRACE (DEBUG::Peaks, "DIRECT PEAKS\n");
 451
 452                 off_t  map_off =  first_peak_byte;
 453                 off_t  read_map_off = map_off & ~(bufsize - 1);
 454                 off_t  map_delta = map_off - read_map_off;
 455                 size_t map_length = bytes_to_read + map_delta;
 456
 457                 if (_first_run  || (_last_scale != samples_per_visual_peak) || (_last_map_off != map_off) || (_last_raw_map_length  < bytes_to_read)) {
 458                         peak_cache.reset (new PeakData[npeaks]);
 459                         char* addr;
 460 #ifdef PLATFORM_WINDOWS
 461                         HANDLE file_handle = (HANDLE) _get_osfhandle(int(sfd));
 462                         HANDLE map_handle;
 463                         LPVOID view_handle;
 464                         bool err_flag;
 465
 466                         map_handle = CreateFileMapping(file_handle, NULL, PAGE_READONLY, 0, 0, NULL);
 467                         if (map_handle == NULL) {
 468                                 error << string_compose (_("map failed - could not create file mapping for peakfile %1."), _peakpath) << endmsg;
 469                                 return -1;
 470                         }
 471
 472                         view_handle = MapViewOfFile(map_handle, FILE_MAP_READ, 0, read_map_off, map_length);
 473                         if (view_handle == NULL) {
 474                                 error << string_compose (_("map failed - could not map peakfile %1."), _peakpath) << endmsg;
 475                                 return -1;
 476                         }
 477
 478                         addr = (char*) view_handle;
 479
 480                         memcpy ((void*)peak_cache.get(), (void*)(addr + map_delta), bytes_to_read);
 481
 482                         err_flag = UnmapViewOfFile (view_handle);
 483                         err_flag = CloseHandle(map_handle);
 484                         if(!err_flag) {
 485                                 error << string_compose (_("unmap failed - could not unmap peakfile %1."), _peakpath) << endmsg;
 486                                 return -1;
 487                         }
 488 #else
 489                         addr = (char*) mmap (0, map_length, PROT_READ, MAP_PRIVATE, sfd, read_map_off);
 490                         if (addr ==  MAP_FAILED) {
 491                                 error << string_compose (_("map failed - could not mmap peakfile %1."), _peakpath) << endmsg;
 492                                 return -1;
 493                         }
 494
 495                         memcpy ((void*)peak_cache.get(), (void*)(addr + map_delta), bytes_to_read);
 496                         munmap (addr, map_length);
 497 #endif
 498                         if (zero_fill) {
 499                                 memset (&peak_cache[read_npeaks], 0, sizeof (PeakData) * zero_fill);
 500                         }
 501
 502                         _first_run = false;
 503                         _last_scale = samples_per_visual_peak;
 504                         _last_map_off = map_off;
 505                         _last_raw_map_length = bytes_to_read;
 506                 }
 507
 508                 memcpy ((void*)peaks, (void*)peak_cache.get(), npeaks * sizeof(PeakData));
 509
 510                 return 0;
 511         }
 512
 513         if (scale < 1.0) {
 514
 515                 DEBUG_TRACE (DEBUG::Peaks, "DOWNSAMPLE\n");
 516
 517                 /* the caller wants:
 518
 519                     - more frames-per-peak (lower resolution) than the peakfile, or to put it another way,
 520                     - less peaks than the peakfile holds for the same range
 521
 522                     So, read a block into a staging area, and then downsample from there.
 523
 524                     to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks
 525                 */
 526
 527                 const framecnt_t chunksize = (framecnt_t) expected_peaks; // we read all the peaks we need in one hit.
 528
 529                 /* compute the rounded up frame position  */
 530
 531                 framepos_t current_stored_peak = (framepos_t) ceil (start / (double) samples_per_file_peak);
 532                 framepos_t next_visual_peak  = (framepos_t) ceil (start / samples_per_visual_peak);
 533                 double     next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
 534                 framepos_t stored_peak_before_next_visual_peak = (framepos_t) next_visual_peak_frame / samples_per_file_peak;
 535                 framecnt_t nvisual_peaks = 0;
 536                 uint32_t i = 0;
 537
 538                 /* handle the case where the initial visual peak is on a pixel boundary */
 539
 540                 current_stored_peak = min (current_stored_peak, stored_peak_before_next_visual_peak);
 541
 542                 /* open ... close during out: handling */
 543
 544                 off_t  map_off =  (uint32_t) (ceil (start / (double) samples_per_file_peak)) * sizeof(PeakData);
 545                 off_t  read_map_off = map_off & ~(bufsize - 1);
 546                 off_t  map_delta = map_off - read_map_off;
 547                 size_t raw_map_length = chunksize * sizeof(PeakData);
 548                 size_t map_length = (chunksize * sizeof(PeakData)) + map_delta;
 549
 550                 if (_first_run || (_last_scale != samples_per_visual_peak) || (_last_map_off != map_off) || (_last_raw_map_length < raw_map_length)) {
 551                         peak_cache.reset (new PeakData[npeaks]);
 552                         boost::scoped_array<PeakData> staging (new PeakData[chunksize]);
 553
 554                         char* addr;
 555 #ifdef PLATFORM_WINDOWS
 556                         HANDLE file_handle =  (HANDLE) _get_osfhandle(int(sfd));
 557                         HANDLE map_handle;
 558                         LPVOID view_handle;
 559                         bool err_flag;
 560
 561                         map_handle = CreateFileMapping(file_handle, NULL, PAGE_READONLY, 0, 0, NULL);
 562                         if (map_handle == NULL) {
 563                                 error << string_compose (_("map failed - could not create file mapping for peakfile %1."), _peakpath) << endmsg;
 564                                 return -1;
 565                         }
 566
 567                         view_handle = MapViewOfFile(map_handle, FILE_MAP_READ, 0, read_map_off, map_length);
 568                         if (view_handle == NULL) {
 569                                 error << string_compose (_("map failed - could not map peakfile %1."), _peakpath) << endmsg;
 570                                 return -1;
 571                         }
 572
 573                         addr = (char *) view_handle;
 574
 575                         memcpy ((void*)staging.get(), (void*)(addr + map_delta), raw_map_length);
 576
 577                         err_flag = UnmapViewOfFile (view_handle);
 578                         err_flag = CloseHandle(map_handle);
 579                         if(!err_flag) {
 580                                 error << string_compose (_("unmap failed - could not unmap peakfile %1."), _peakpath) << endmsg;
 581                                 return -1;
 582                         }
 583 #else
 584                         addr = (char*) mmap (0, map_length, PROT_READ, MAP_PRIVATE, sfd, read_map_off);
 585                         if (addr ==  MAP_FAILED) {
 586                                 error << string_compose (_("map failed - could not mmap peakfile %1."), _peakpath) << endmsg;
 587                                 return -1;
 588                         }
 589
 590                         memcpy ((void*)staging.get(), (void*)(addr + map_delta), raw_map_length);
 591                         munmap (addr, map_length);
 592 #endif
 593                         while (nvisual_peaks < read_npeaks) {
 594
 595                                 xmax = -1.0;
 596                                 xmin = 1.0;
 597
 598                                 while ((current_stored_peak <= stored_peak_before_next_visual_peak) && (i < chunksize)) {
 599
 600                                         xmax = max (xmax, staging[i].max);
 601                                         xmin = min (xmin, staging[i].min);
 602                                         ++i;
 603                                         ++current_stored_peak;
 604                                 }
 605
 606                                 peak_cache[nvisual_peaks].max = xmax;
 607                                 peak_cache[nvisual_peaks].min = xmin;
 608                                 ++nvisual_peaks;
 609                                 next_visual_peak_frame =  min ((double) start + cnt, (next_visual_peak_frame + samples_per_visual_peak));
 610                                 stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / samples_per_file_peak;
 611                         }
 612
 613                         if (zero_fill) {
 614                                 cerr << "Zero fill end of peaks (@ " << read_npeaks << " with " << zero_fill << ")" << endl;
 615                                 memset (&peak_cache[read_npeaks], 0, sizeof (PeakData) * zero_fill);
 616                         }
 617
 618                         _first_run = false;
 619                         _last_scale = samples_per_visual_peak;
 620                         _last_map_off = map_off;
 621                         _last_raw_map_length = raw_map_length;
 622                 }
 623
 624                 memcpy ((void*)peaks, (void*)peak_cache.get(), npeaks * sizeof(PeakData));
 625
 626         } else {
 627                 DEBUG_TRACE (DEBUG::Peaks, "UPSAMPLE\n");
 628
 629                 /* the caller wants
 630
 631                      - less frames-per-peak (more resolution)
 632                      - more peaks than stored in the Peakfile
 633
 634                    So, fetch data from the raw source, and generate peak
 635                    data on the fly.
 636                 */
 637
 638                 framecnt_t frames_read = 0;
 639                 framepos_t current_frame = start;
 640                 framecnt_t i = 0;
 641                 framecnt_t nvisual_peaks = 0;
 642                 framecnt_t chunksize = (framecnt_t) min (cnt, (framecnt_t) 4096);
 643                 boost::scoped_array<Sample> raw_staging(new Sample[chunksize]);
 644
 645                 framepos_t frame_pos = start;
 646                 double pixel_pos = floor (frame_pos / samples_per_visual_peak);
 647                 double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
 648                 double pixels_per_frame = 1.0 / samples_per_visual_peak;
 649
 650                 xmin = 1.0;
 651                 xmax = -1.0;
 652
 653                 while (nvisual_peaks < read_npeaks) {
 654
 655                         if (i == frames_read) {
 656
 657                                 to_read = min (chunksize, (framecnt_t)(_length - current_frame));
 658
 659                                 if (current_frame >= _length) {
 660
 661                                         /* hmm, error condition - we've reached the end of the file
 662                                            without generating all the peak data. cook up a zero-filled
 663                                            data buffer and then use it. this is simpler than
 664                                            adjusting zero_fill and read_npeaks and then breaking out of
 665                                            this loop early
 666                                         */
 667
 668                                         memset (raw_staging.get(), 0, sizeof (Sample) * chunksize);
 669
 670                                 } else {
 671
 672                                         to_read = min (chunksize, (_length - current_frame));
 673
 674
 675                                         if ((frames_read = read_unlocked (raw_staging.get(), current_frame, to_read)) == 0) {
 676                                                 error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3 of %4 (%5)"),
 677                                                                         _name, to_read, current_frame, _length, strerror (errno))
 678                                                       << endmsg;
 679                                                 return -1;
 680                                         }
 681                                 }
 682
 683                                 i = 0;
 684                         }
 685
 686                         xmax = max (xmax, raw_staging[i]);
 687                         xmin = min (xmin, raw_staging[i]);
 688                         ++i;
 689                         ++current_frame;
 690                         pixel_pos += pixels_per_frame;
 691
 692                         if (pixel_pos >= next_pixel_pos) {
 693
 694                                 peaks[nvisual_peaks].max = xmax;
 695                                 peaks[nvisual_peaks].min = xmin;
 696                                 ++nvisual_peaks;
 697                                 xmin = 1.0;
 698                                 xmax = -1.0;
 699
 700                                 next_pixel_pos = ceil (pixel_pos + 0.5);
 701                         }
 702                 }
 703
 704                 if (zero_fill) {
 705                         memset (&peaks[read_npeaks], 0, sizeof (PeakData) * zero_fill);
 706                 }
 707         }
 708
 709         DEBUG_TRACE (DEBUG::Peaks, "READPEAKS DONE\n");
 710         return 0;
 711 }
 712
 713 int
 714 AudioSource::build_peaks_from_scratch ()
 715 {
 716         const framecnt_t bufsize = 65536; // 256kB per disk read for mono data is about ideal
 717
 718         DEBUG_TRACE (DEBUG::Peaks, "Building peaks from scratch\n");
 719
 720         int ret = -1;
 721
 722         {
 723                 /* hold lock while building peaks */
 724
 725                 Glib::Threads::Mutex::Lock lp (_lock);
 726
 727                 if (prepare_for_peakfile_writes ()) {
 728                         goto out;
 729                 }
 730
 731                 framecnt_t current_frame = 0;
 732                 framecnt_t cnt = _length;
 733
 734                 _peaks_built = false;
 735                 boost::scoped_array<Sample> buf(new Sample[bufsize]);
 736
 737                 while (cnt) {
 738
 739                         framecnt_t frames_to_read = min (bufsize, cnt);
 740                         framecnt_t frames_read;
 741
 742                         if ((frames_read = read_unlocked (buf.get(), current_frame, frames_to_read)) != frames_to_read) {
 743                                 error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
 744                                 done_with_peakfile_writes (false);
 745                                 goto out;
 746                         }
 747
 748                         lp.release(); // allow butler to refill buffers
 749
 750                         if (_session.deletion_in_progress()) {
 751                                 cerr << "peak file creation interrupted: " << _name << endmsg;
 752                                 done_with_peakfile_writes (false);
 753                                 goto out;
 754                         }
 755
 756                         if (compute_and_write_peaks (buf.get(), current_frame, frames_read, true, false, _FPP)) {
 757                                 break;
 758                         }
 759
 760                         current_frame += frames_read;
 761                         cnt -= frames_read;
 762
 763                         lp.acquire();
 764                 }
 765
 766                 if (cnt == 0) {
 767                         /* success */
 768                         truncate_peakfile();
 769                 }
 770
 771                 done_with_peakfile_writes ((cnt == 0));
 772                 if (cnt == 0) {
 773                         ret = 0;
 774                 }
 775         }
 776
 777   out:
 778         if (ret) {
 779                 DEBUG_TRACE (DEBUG::Peaks, string_compose("Could not write peak data, attempting to remove peakfile %1\n", _peakpath));
 780                 ::g_unlink (_peakpath.c_str());
 781         }
 782
 783         return ret;
 784 }
 785
 786 int
 787 AudioSource::prepare_for_peakfile_writes ()
 788 {
 789         if ((_peakfile_fd = g_open (_peakpath.c_str(), O_CREAT|O_RDWR, 0664)) < 0) {
 790                 error << string_compose(_("AudioSource: cannot open _peakpath (c) \"%1\" (%2)"), _peakpath, strerror (errno)) << endmsg;
 791                 return -1;
 792         }
 793         return 0;
 794 }
 795
 796 void
 797 AudioSource::done_with_peakfile_writes (bool done)
 798 {
 799         if (peak_leftover_cnt) {
 800                 compute_and_write_peaks (0, 0, 0, true, false, _FPP);
 801         }
 802
 803         if (done) {
 804                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 805                 _peaks_built = true;
 806                 PeaksReady (); /* EMIT SIGNAL */
 807         }
 808
 809         close (_peakfile_fd);
 810         _peakfile_fd = -1;
 811 }
 812
 813 /** @param first_frame Offset from the source start of the first frame to
 814  * process. _lock MUST be held by caller.
 815 */
 816 int
 817 AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
 818                                       bool force, bool intermediate_peaks_ready)
 819 {
 820         return compute_and_write_peaks (buf, first_frame, cnt, force, intermediate_peaks_ready, _FPP);
 821 }
 822
 823 int
 824 AudioSource::compute_and_write_peaks (Sample* buf, framecnt_t first_frame, framecnt_t cnt,
 825                                       bool force, bool intermediate_peaks_ready, framecnt_t fpp)
 826 {
 827         framecnt_t to_do;
 828         uint32_t  peaks_computed;
 829         framepos_t current_frame;
 830         framecnt_t frames_done;
 831         const size_t blocksize = (128 * 1024);
 832         off_t first_peak_byte;
 833         boost::scoped_array<Sample> buf2;
 834
 835         if (_peakfile_fd < 0) {
 836                 if (prepare_for_peakfile_writes ()) {
 837                         return -1;
 838                 }
 839         }
 840
 841   restart:
 842         if (peak_leftover_cnt) {
 843
 844                 if (first_frame != peak_leftover_frame + peak_leftover_cnt) {
 845
 846                         /* uh-oh, ::seek() since the last ::compute_and_write_peaks(),
 847                            and we have leftovers. flush a single peak (since the leftovers
 848                            never represent more than that, and restart.
 849                         */
 850
 851                         PeakData x;
 852
 853                         x.min = peak_leftovers[0];
 854                         x.max = peak_leftovers[0];
 855
 856                         off_t byte = (peak_leftover_frame / fpp) * sizeof (PeakData);
 857
 858                         off_t offset = lseek (_peakfile_fd, byte, SEEK_SET);
 859
 860                         if (offset != byte) {
 861                                 error << string_compose(_("%1: could not seek in peak file data (%2)"), _name, strerror (errno)) << endmsg;
 862                                 return -1;
 863                         }
 864
 865                         if (::write (_peakfile_fd, &x, sizeof (PeakData)) != sizeof (PeakData)) {
 866                                 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
 867                                 return -1;
 868                         }
 869
 870                         _peak_byte_max = max (_peak_byte_max, (off_t) (byte + sizeof(PeakData)));
 871
 872                         {
 873                                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
 874                                 PeakRangeReady (peak_leftover_frame, peak_leftover_cnt); /* EMIT SIGNAL */
 875                                 if (intermediate_peaks_ready) {
 876                                         PeaksReady (); /* EMIT SIGNAL */
 877                                 }
 878                         }
 879
 880                         /* left overs are done */
 881
 882                         peak_leftover_cnt = 0;
 883                         goto restart;
 884                 }
 885
 886                 /* else ... had leftovers, but they immediately preceed the new data, so just
 887                    merge them and compute.
 888                 */
 889
 890                 /* make a new contiguous buffer containing leftovers and the new stuff */
 891
 892                 to_do = cnt + peak_leftover_cnt;
 893                 buf2.reset(new Sample[to_do]);
 894
 895                 /* the remnants */
 896                 memcpy (buf2.get(), peak_leftovers, peak_leftover_cnt * sizeof (Sample));
 897
 898                 /* the new stuff */
 899                 memcpy (buf2.get()+peak_leftover_cnt, buf, cnt * sizeof (Sample));
 900
 901                 /* no more leftovers */
 902                 peak_leftover_cnt = 0;
 903
 904                 /* use the temporary buffer */
 905                 buf = buf2.get();
 906
 907                 /* make sure that when we write into the peakfile, we startup where we left off */
 908
 909                 first_frame = peak_leftover_frame;
 910
 911         } else {
 912                 to_do = cnt;
 913         }
 914
 915         boost::scoped_array<PeakData> peakbuf(new PeakData[(to_do/fpp)+1]);
 916         peaks_computed = 0;
 917         current_frame = first_frame;
 918         frames_done = 0;
 919
 920         while (to_do) {
 921
 922                 /* if some frames were passed in (i.e. we're not flushing leftovers)
 923                    and there are less than fpp to do, save them till
 924                    next time
 925                 */
 926
 927                 if (force && (to_do < fpp)) {
 928                         /* keep the left overs around for next time */
 929
 930                         if (peak_leftover_size < to_do) {
 931                                 delete [] peak_leftovers;
 932                                 peak_leftovers = new Sample[to_do];
 933                                 peak_leftover_size = to_do;
 934                         }
 935                         memcpy (peak_leftovers, buf, to_do * sizeof (Sample));
 936                         peak_leftover_cnt = to_do;
 937                         peak_leftover_frame = current_frame;
 938
 939                         /* done for now */
 940
 941                         break;
 942                 }
 943
 944                 framecnt_t this_time = min (fpp, to_do);
 945
 946                 peakbuf[peaks_computed].max = buf[0];
 947                 peakbuf[peaks_computed].min = buf[0];
 948
 949                 ARDOUR::find_peaks (buf+1, this_time-1, &peakbuf[peaks_computed].min, &peakbuf[peaks_computed].max);
 950
 951                 peaks_computed++;
 952                 buf += this_time;
 953                 to_do -= this_time;
 954                 frames_done += this_time;
 955                 current_frame += this_time;
 956         }
 957
 958         first_peak_byte = (first_frame / fpp) * sizeof (PeakData);
 959
 960         if (can_truncate_peaks()) {
 961
 962                 /* on some filesystems (ext3, at least) this helps to reduce fragmentation of
 963                    the peakfiles. its not guaranteed to do so, and even on ext3 (as of december 2006)
 964                    it does not cause single-extent allocation even for peakfiles of
 965                    less than BLOCKSIZE bytes.  only call ftruncate if we'll make the file larger.
 966                 */
 967
 968                 off_t endpos = lseek (_peakfile_fd, 0, SEEK_END);
 969                 off_t target_length = blocksize * ((first_peak_byte + blocksize + 1) / blocksize);
 970
 971                 if (endpos < target_length) {
 972                         DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile %1\n", _peakpath));
 973                         if (ftruncate (_peakfile_fd, target_length)) {
 974                                 /* error doesn't actually matter so continue on without testing */
 975                         }
 976                 }
 977         }
 978
 979
 980         off_t offset = lseek(_peakfile_fd, first_peak_byte, SEEK_SET);
 981
 982         if (offset != first_peak_byte) {
 983                 error << string_compose(_("%1: could not seek in peak file data (%2)"), _name, strerror (errno)) << endmsg;
 984                 return -1;
 985         }
 986
 987         ssize_t bytes_to_write = sizeof (PeakData) * peaks_computed;
 988
 989         ssize_t bytes_written = ::write (_peakfile_fd, peakbuf.get(), bytes_to_write);
 990
 991         if (bytes_written != bytes_to_write) {
 992                 error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
 993                 return -1;
 994         }
 995
 996         _peak_byte_max = max (_peak_byte_max, (off_t) (first_peak_byte + bytes_to_write));
 997
 998         if (frames_done) {
 999                 Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
1000                 PeakRangeReady (first_frame, frames_done); /* EMIT SIGNAL */
1001                 if (intermediate_peaks_ready) {
1002                         PeaksReady (); /* EMIT SIGNAL */
1003                 }
1004         }
1005
1006         return 0;
1007 }
1008
1009 void
1010 AudioSource::truncate_peakfile ()
1011 {
1012         if (_peakfile_fd < 0) {
1013                 error << string_compose (_("programming error: %1"), "AudioSource::truncate_peakfile() called without open peakfile descriptor")
1014                       << endmsg;
1015                 return;
1016         }
1017
1018         /* truncate the peakfile down to its natural length if necessary */
1019
1020         off_t end = lseek (_peakfile_fd, 0, SEEK_END);
1021
1022         if (end > _peak_byte_max) {
1023                 DEBUG_TRACE(DEBUG::Peaks, string_compose ("Truncating Peakfile  %1\n", _peakpath));
1024                 if (ftruncate (_peakfile_fd, _peak_byte_max)) {
1025                         error << string_compose (_("could not truncate peakfile %1 to %2 (error: %3)"),
1026                                                  _peakpath, _peak_byte_max, errno) << endmsg;
1027                 }
1028         }
1029 }
1030
1031 framecnt_t
1032 AudioSource::available_peaks (double zoom_factor) const
1033 {
1034         if (zoom_factor < _FPP) {
1035                 return length(_timeline_position); // peak data will come from the audio file
1036         }
1037
1038         /* peak data comes from peakfile, but the filesize might not represent
1039            the valid data due to ftruncate optimizations, so use _peak_byte_max state.
1040            XXX - there might be some atomicity issues here, we should probably add a lock,
1041            but _peak_byte_max only monotonically increases after initialization.
1042         */
1043
1044         off_t end = _peak_byte_max;
1045
1046         return (end/sizeof(PeakData)) * _FPP;
1047 }
1048
1049 void
1050 AudioSource::mark_streaming_write_completed (const Lock& lock)
1051 {
1052         Glib::Threads::Mutex::Lock lm (_peaks_ready_lock);
1053
1054         if (_peaks_built) {
1055                 PeaksReady (); /* EMIT SIGNAL */
1056         }
1057 }
1058
1059 void
1060 AudioSource::allocate_working_buffers (framecnt_t framerate)
1061 {
1062         Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
1063
1064
1065         /* Note: we don't need any buffers allocated until
1066            a level 1 audiosource is created, at which
1067            time we'll call ::ensure_buffers_for_level()
1068            with the right value and do the right thing.
1069         */
1070
1071         if (!_mixdown_buffers.empty()) {
1072                 ensure_buffers_for_level_locked ( _mixdown_buffers.size(), framerate);
1073         }
1074 }
1075
1076 void
1077 AudioSource::ensure_buffers_for_level (uint32_t level, framecnt_t frame_rate)
1078 {
1079         Glib::Threads::Mutex::Lock lm (_level_buffer_lock);
1080         ensure_buffers_for_level_locked (level, frame_rate);
1081 }
1082
1083 void
1084 AudioSource::ensure_buffers_for_level_locked (uint32_t level, framecnt_t frame_rate)
1085 {
1086         framecnt_t nframes = (framecnt_t) floor (Config->get_audio_playback_buffer_seconds() * frame_rate);
1087
1088         /* this may be called because either "level" or "frame_rate" have
1089          * changed. and it may be called with "level" smaller than the current
1090          * number of buffers, because a new compound region has been created at
1091          * a more shallow level than the deepest one we currently have.
1092          */
1093
1094         uint32_t limit = max ((size_t) level, _mixdown_buffers.size());
1095
1096         _mixdown_buffers.clear ();
1097         _gain_buffers.clear ();
1098
1099         for (uint32_t n = 0; n < limit; ++n) {
1100                 _mixdown_buffers.push_back (boost::shared_array<Sample> (new Sample[nframes]));
1101                 _gain_buffers.push_back (boost::shared_array<gain_t> (new gain_t[nframes]));
1102         }
1103 }