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