libs/ardour/audiofilesource.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <vector>
  21
  22 #include <sys/time.h>
  23 #include <sys/stat.h>
  24 #include <stdio.h> // for rename(), sigh
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <errno.h>
  28
  29 #include <pbd/convert.h>
  30 #include <pbd/basename.h>
  31 #include <pbd/mountpoint.h>
  32 #include <pbd/pathscanner.h>
  33 #include <pbd/stl_delete.h>
  34 #include <pbd/strsplit.h>
  35 #include <pbd/shortpath.h>
  36 #include <pbd/enumwriter.h>
  37
  38 #include <sndfile.h>
  39
  40 #include <glibmm/miscutils.h>
  41 #include <glibmm/fileutils.h>
  42 #include <glibmm/thread.h>
  43
  44 #include <ardour/audiofilesource.h>
  45 #include <ardour/sndfile_helpers.h>
  46 #include <ardour/sndfilesource.h>
  47 #include <ardour/session.h>
  48 #include <ardour/source_factory.h>
  49
  50 // if these headers come before sigc++ is included
  51 // the parser throws ObjC++ errors. (nil is a keyword)
  52 #ifdef HAVE_COREAUDIO
  53 #include <ardour/coreaudiosource.h>
  54 #include <AudioToolbox/ExtendedAudioFile.h>
  55 #include <AudioToolbox/AudioFormat.h>
  56 #endif // HAVE_COREAUDIO
  57
  58 #include "i18n.h"
  59
  60 using namespace ARDOUR;
  61 using namespace PBD;
  62 using namespace Glib;
  63
  64 ustring AudioFileSource::peak_dir = "";
  65 ustring AudioFileSource::search_path;
  66
  67 sigc::signal<void> AudioFileSource::HeaderPositionOffsetChanged;
  68 uint64_t           AudioFileSource::header_position_offset = 0;
  69
  70 /* XXX maybe this too */
  71 char   AudioFileSource::bwf_serial_number[13] = "000000000000";
  72
  73 struct SizedSampleBuffer {
  74     nframes_t size;
  75     Sample* buf;
  76
  77     SizedSampleBuffer (nframes_t sz) : size (sz) {
  78             buf = new Sample[size];
  79     }
  80
  81     ~SizedSampleBuffer() {
  82             delete [] buf;
  83     }
  84 };
  85
  86 Glib::StaticPrivate<SizedSampleBuffer> thread_interleave_buffer = GLIBMM_STATIC_PRIVATE_INIT;
  87
  88 AudioFileSource::AudioFileSource (Session& s, ustring path, Flag flags)
  89         : AudioSource (s, path), _flags (flags),
  90           _channel (0)
  91 {
  92         /* constructor used for existing external to session files. file must exist already */
  93         _is_embedded = AudioFileSource::determine_embeddedness (path);
  94
  95         if (init (path, true)) {
  96                 throw failed_constructor ();
  97         }
  98
  99         fix_writable_flags ();
 100 }
 101
 102 AudioFileSource::AudioFileSource (Session& s, ustring path, Flag flags, SampleFormat samp_format, HeaderFormat hdr_format)
 103         : AudioSource (s, path), _flags (flags),
 104           _channel (0)
 105 {
 106         /* constructor used for new internal-to-session files. file cannot exist */
 107         _is_embedded = false;
 108
 109         if (init (path, false)) {
 110                 throw failed_constructor ();
 111         }
 112
 113         fix_writable_flags ();
 114 }
 115
 116 AudioFileSource::AudioFileSource (Session& s, const XMLNode& node, bool must_exist)
 117         : AudioSource (s, node), _flags (Flag (Writable|CanRename))
 118           /* _channel is set in set_state() or init() */
 119 {
 120         /* constructor used for existing internal-to-session files. file must exist */
 121
 122         if (set_state (node)) {
 123                 throw failed_constructor ();
 124         }
 125
 126         string foo = _name;
 127
 128         if (init (foo, must_exist)) {
 129                 throw failed_constructor ();
 130         }
 131
 132         fix_writable_flags ();
 133 }
 134
 135 AudioFileSource::~AudioFileSource ()
 136 {
 137         if (removable()) {
 138                 unlink (_path.c_str());
 139                 unlink (peakpath.c_str());
 140         }
 141 }
 142
 143 void
 144 AudioFileSource::fix_writable_flags ()
 145 {
 146         if (!_session.writable()) {
 147                 _flags = Flag (_flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy|CanRename));
 148         }
 149 }
 150
 151 bool
 152 AudioFileSource::determine_embeddedness (ustring path)
 153 {
 154         return (path.find("/") == 0);
 155 }
 156
 157 bool
 158 AudioFileSource::removable () const
 159 {
 160         return (_flags & Removable) && ((_flags & RemoveAtDestroy) || ((_flags & RemovableIfEmpty) && length() == 0));
 161 }
 162
 163 bool
 164 AudioFileSource::writable() const
 165 {
 166         return (_flags & Writable);
 167 }
 168
 169 int
 170 AudioFileSource::init (ustring pathstr, bool must_exist)
 171 {
 172         _length = 0;
 173         timeline_position = 0;
 174         _peaks_built = false;
 175
 176         /* is_embedded() can't work yet, because our _path is not set */
 177
 178         bool embedded = determine_embeddedness (pathstr);
 179
 180         if (!find (pathstr, must_exist, embedded, file_is_new, _channel, _path, _name)) {
 181                 throw non_existent_source ();
 182         }
 183
 184         if (file_is_new && must_exist) {
 185                 return -1;
 186         }
 187
 188         return 0;
 189 }
 190
 191
 192 ustring
 193 AudioFileSource::peak_path (ustring audio_path)
 194 {
 195         ustring base;
 196
 197         base = PBD::basename_nosuffix (audio_path);
 198         base += '%';
 199         base += (char) ('A' + _channel);
 200
 201         return _session.peak_path (base);
 202 }
 203
 204 ustring
 205 AudioFileSource::find_broken_peakfile (ustring peak_path, ustring audio_path)
 206 {
 207         ustring str;
 208
 209         /* check for the broken location in use by 2.0 for several months */
 210
 211         str = broken_peak_path (audio_path);
 212
 213         if (Glib::file_test (str, Glib::FILE_TEST_EXISTS)) {
 214
 215                 if (is_embedded()) {
 216
 217                         /* it would be nice to rename it but the nature of
 218                            the bug means that we can't reliably use it.
 219                         */
 220
 221                         peak_path = str;
 222
 223                 } else {
 224                         /* all native files are mono, so we can just rename
 225                            it.
 226                         */
 227                         ::rename (str.c_str(), peak_path.c_str());
 228                 }
 229
 230         } else {
 231                 /* Nasty band-aid for older sessions that were created before we
 232                    used libsndfile for all audio files.
 233                 */
 234
 235
 236                 str = old_peak_path (audio_path);
 237                 if (Glib::file_test (str, Glib::FILE_TEST_EXISTS)) {
 238                         peak_path = str;
 239                 }
 240         }
 241
 242         return peak_path;
 243 }
 244
 245 ustring
 246 AudioFileSource::broken_peak_path (ustring audio_path)
 247 {
 248         return Glib::build_filename(_session.peak_dir (), PBD::basename_nosuffix (audio_path) + ".peak");
 249 }
 250
 251 ustring
 252 AudioFileSource::old_peak_path (ustring audio_path)
 253 {
 254         /* XXX hardly bombproof! fix me */
 255
 256         struct stat stat_file;
 257         struct stat stat_mount;
 258
 259         ustring mp = mountpoint (audio_path);
 260
 261         stat (audio_path.c_str(), &stat_file);
 262         stat (mp.c_str(), &stat_mount);
 263
 264         char buf[32];
 265 #ifdef __APPLE__
 266         snprintf (buf, sizeof (buf), "%u-%u-%d.peak", stat_mount.st_ino, stat_file.st_ino, _channel);
 267 #else
 268         snprintf (buf, sizeof (buf), "%ld-%ld-%d.peak", stat_mount.st_ino, stat_file.st_ino, _channel);
 269 #endif
 270
 271         ustring res = peak_dir;
 272         res += buf;
 273
 274         return res;
 275 }
 276
 277 bool
 278 AudioFileSource::get_soundfile_info (ustring path, SoundFileInfo& _info, string& error_msg)
 279 {
 280         /* try sndfile first because it gets timecode info from .wav (BWF) if it exists,
 281            which at present, ExtAudioFile from Apple seems unable to do.
 282         */
 283
 284         if (SndFileSource::get_soundfile_info (path, _info, error_msg) != 0) {
 285                 return true;
 286         }
 287
 288 #ifdef HAVE_COREAUDIO
 289         if (CoreAudioSource::get_soundfile_info (path, _info, error_msg) == 0) {
 290                 return true;
 291         }
 292 #endif // HAVE_COREAUDIO
 293
 294         return false;
 295 }
 296
 297 XMLNode&
 298 AudioFileSource::get_state ()
 299 {
 300         XMLNode& root (AudioSource::get_state());
 301         char buf[32];
 302         root.add_property (X_("flags"), enum_2_string (_flags));
 303         snprintf (buf, sizeof (buf), "%u", _channel);
 304         root.add_property (X_("channel"), buf);
 305         return root;
 306 }
 307
 308 int
 309 AudioFileSource::set_state (const XMLNode& node)
 310 {
 311         const XMLProperty* prop;
 312
 313         if (AudioSource::set_state (node)) {
 314                 return -1;
 315         }
 316
 317         if ((prop = node.property (X_("flags"))) != 0) {
 318                 _flags = Flag (string_2_enum (prop->value(), _flags));
 319         } else {
 320                 _flags = Flag (0);
 321
 322         }
 323
 324         fix_writable_flags ();
 325
 326         if ((prop = node.property (X_("channel"))) != 0) {
 327                 _channel = atoi (prop->value());
 328         } else {
 329                 _channel = 0;
 330         }
 331
 332         if ((prop = node.property (X_("name"))) != 0) {
 333                 _is_embedded = AudioFileSource::determine_embeddedness (prop->value());
 334         } else {
 335                 _is_embedded = false;
 336         }
 337
 338         if ((prop = node.property (X_("destructive"))) != 0) {
 339                 /* old style, from the period when we had DestructiveFileSource */
 340                 _flags = Flag (_flags | Destructive);
 341         }
 342
 343         return 0;
 344 }
 345
 346 void
 347 AudioFileSource::mark_for_remove ()
 348 {
 349         // This operation is not allowed for sources for destructive tracks or embedded files.
 350         // Fortunately mark_for_remove() is never called for embedded files. This function
 351         // must be fixed if that ever happens.
 352         if (!_session.writable() || (_flags & Destructive)) {
 353                 return;
 354         }
 355
 356         _flags = Flag (_flags | Removable | RemoveAtDestroy);
 357 }
 358
 359 void
 360 AudioFileSource::mark_streaming_write_completed ()
 361 {
 362         if (!writable()) {
 363                 return;
 364         }
 365
 366         /* XXX notice that we're readers of _peaks_built
 367            but we must hold a solid lock on PeaksReady.
 368         */
 369
 370         Glib::Mutex::Lock lm (_lock);
 371
 372         if (_peaks_built) {
 373                 PeaksReady (); /* EMIT SIGNAL */
 374         }
 375 }
 376
 377 void
 378 AudioFileSource::mark_take (ustring id)
 379 {
 380         if (writable()) {
 381                 _take_id = id;
 382         }
 383 }
 384
 385 int
 386 AudioFileSource::move_to_trash (const ustring& trash_dir_name)
 387 {
 388         if (is_embedded()) {
 389                 cerr << "tried to move an embedded region to trash" << endl;
 390                 return -1;
 391         }
 392
 393         ustring newpath;
 394
 395         if (!writable()) {
 396                 return -1;
 397         }
 398
 399         /* don't move the file across filesystems, just
 400            stick it in the `trash_dir_name' directory
 401            on whichever filesystem it was already on.
 402         */
 403
 404         newpath = Glib::path_get_dirname (_path);
 405         newpath = Glib::path_get_dirname (newpath);
 406
 407         cerr << "from " << _path << " dead dir looks like " << newpath << endl;
 408
 409         vector<string> p;
 410         p.push_back (newpath);
 411         p.push_back (trash_dir_name);
 412         p.push_back (Glib::path_get_basename (_path));
 413
 414         newpath = Glib::build_filename (p);
 415
 416         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
 417
 418                 /* the new path already exists, try versioning */
 419
 420                 char buf[PATH_MAX+1];
 421                 int version = 1;
 422                 ustring newpath_v;
 423
 424                 snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
 425                 newpath_v = buf;
 426
 427                 while (Glib::file_test (newpath_v, Glib::FILE_TEST_EXISTS) && version < 999) {
 428                         snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
 429                         newpath_v = buf;
 430                 }
 431
 432                 if (version == 999) {
 433                         error << string_compose (_("there are already 1000 files with names like %1; versioning discontinued"),
 434                                           newpath)
 435                               << endmsg;
 436                 } else {
 437                         newpath = newpath_v;
 438                 }
 439
 440         } else {
 441
 442                 /* it doesn't exist, or we can't read it or something */
 443
 444         }
 445
 446         if (::rename (_path.c_str(), newpath.c_str()) != 0) {
 447                 error << string_compose (_("cannot 1 rename audio file source from %1 to %2 (%3)"),
 448                                   _path, newpath, strerror (errno))
 449                       << endmsg;
 450                 return -1;
 451         }
 452
 453         if (::unlink (peakpath.c_str()) != 0) {
 454                 error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
 455                                   peakpath, _path, strerror (errno))
 456                       << endmsg;
 457                 /* try to back out */
 458                 rename (newpath.c_str(), _path.c_str());
 459                 return -1;
 460         }
 461
 462         _path = newpath;
 463         peakpath = "";
 464
 465         /* file can not be removed twice, since the operation is not idempotent */
 466
 467         _flags = Flag (_flags & ~(RemoveAtDestroy|Removable|RemovableIfEmpty));
 468
 469         return 0;
 470 }
 471
 472 bool
 473 AudioFileSource::find (ustring pathstr, bool must_exist, bool embedded,
 474                        bool& isnew, uint16_t& chan,
 475                        ustring& path, std::string& name)
 476 {
 477         ustring::size_type pos;
 478         bool ret = false;
 479
 480         isnew = false;
 481
 482         if (!Glib::path_is_absolute (pathstr)) {
 483
 484                 /* non-absolute pathname: find pathstr in search path */
 485
 486                 vector<ustring> dirs;
 487                 int cnt;
 488                 ustring fullpath;
 489                 ustring keeppath;
 490
 491                 if (search_path.length() == 0) {
 492                         error << _("FileSource: search path not set") << endmsg;
 493                         goto out;
 494                 }
 495
 496                 split (search_path, dirs, ':');
 497
 498                 cnt = 0;
 499
 500                 for (vector<ustring>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
 501
 502                         fullpath = Glib::build_filename (*i, pathstr);
 503
 504                         /* i (paul) made a nasty design error by using ':' as a special character in
 505                            Ardour 0.99 .. this hack tries to make things sort of work.
 506                         */
 507
 508                         if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
 509
 510                                 if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 511
 512                                         /* its a real file, no problem */
 513
 514                                         keeppath = fullpath;
 515                                         ++cnt;
 516
 517                                 } else {
 518
 519                                         if (must_exist) {
 520
 521                                                 /* might be an older session using file:channel syntax. see if the version
 522                                                    without the :suffix exists
 523                                                  */
 524
 525                                                 ustring shorter = pathstr.substr (0, pos);
 526                                                 fullpath = Glib::build_filename (*i, shorter);
 527
 528                                                 if (Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 529                                                         chan = atoi (pathstr.substr (pos+1));
 530                                                         pathstr = shorter;
 531                                                         keeppath = fullpath;
 532                                                         ++cnt;
 533                                                 }
 534
 535                                         } else {
 536
 537                                                 /* new derived file (e.g. for timefx) being created in a newer session */
 538
 539                                         }
 540                                 }
 541
 542                         } else {
 543
 544                                 if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 545                                         keeppath = fullpath;
 546                                         ++cnt;
 547                                 }
 548                         }
 549                 }
 550
 551                 if (cnt > 1) {
 552
 553                         error << string_compose (_("FileSource: \"%1\" is ambigous when searching %2\n\t"), pathstr, search_path) << endmsg;
 554                         goto out;
 555
 556                 } else if (cnt == 0) {
 557
 558                         if (must_exist) {
 559                                 error << string_compose(_("Filesource: cannot find required file (%1): while searching %2"), pathstr, search_path) << endmsg;
 560                                 goto out;
 561                         } else {
 562                                 isnew = true;
 563                         }
 564                 }
 565
 566                 name = pathstr;
 567                 path = keeppath;
 568                 ret = true;
 569
 570         } else {
 571
 572                 /* external files and/or very very old style sessions include full paths */
 573
 574                 /* ugh, handle ':' situation */
 575
 576                 if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
 577
 578                         ustring shorter = pathstr.substr (0, pos);
 579
 580                         if (Glib::file_test (shorter, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 581                                 chan = atoi (pathstr.substr (pos+1));
 582                                 pathstr = shorter;
 583                         }
 584                 }
 585
 586                 path = pathstr;
 587
 588                 if (embedded) {
 589                         name = pathstr;
 590                 } else {
 591                         name = Glib::path_get_basename (pathstr);
 592                 }
 593
 594                 if (!Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 595
 596                         /* file does not exist or we cannot read it */
 597
 598                         if (must_exist) {
 599                                 error << string_compose(_("Filesource: cannot find required file (%1): %2"), pathstr, strerror (errno)) << endmsg;
 600                                 goto out;
 601                         }
 602
 603                         if (errno != ENOENT) {
 604                                 error << string_compose(_("Filesource: cannot check for existing file (%1): %2"), pathstr, strerror (errno)) << endmsg;
 605                                 goto out;
 606                         }
 607
 608                         /* a new file */
 609
 610                         isnew = true;
 611                         ret = true;
 612
 613                 } else {
 614
 615                         /* already exists */
 616
 617                         ret = true;
 618
 619                 }
 620         }
 621
 622   out:
 623         return ret;
 624 }
 625
 626 void
 627 AudioFileSource::set_search_path (ustring p)
 628 {
 629         search_path = p;
 630 }
 631
 632 void
 633 AudioFileSource::set_header_position_offset (nframes_t offset)
 634 {
 635         header_position_offset = offset;
 636         HeaderPositionOffsetChanged ();
 637 }
 638
 639 void
 640 AudioFileSource::set_timeline_position (int64_t pos)
 641 {
 642         timeline_position = pos;
 643 }
 644
 645 void
 646 AudioFileSource::set_allow_remove_if_empty (bool yn)
 647 {
 648         if (!writable()) {
 649                 return;
 650         }
 651
 652         if (yn) {
 653                 _flags = Flag (_flags | RemovableIfEmpty);
 654         } else {
 655                 _flags = Flag (_flags & ~RemovableIfEmpty);
 656         }
 657
 658         fix_writable_flags ();
 659 }
 660
 661 int
 662 AudioFileSource::set_name (ustring newname, bool destructive)
 663 {
 664         Glib::Mutex::Lock lm (_lock);
 665         ustring oldpath = _path;
 666         ustring newpath = Session::change_audio_path_by_name (oldpath, _name, newname, destructive);
 667
 668         if (newpath.empty()) {
 669                 error << string_compose (_("programming error: %1"), "cannot generate a changed audio path") << endmsg;
 670                 return -1;
 671         }
 672
 673         // Test whether newpath exists, if yes notify the user but continue.
 674         if (access(newpath.c_str(),F_OK) == 0) {
 675                 error << _("Programming error! Tried to rename a file over another file! It's safe to continue working, but please report this to the developers.") << endmsg;
 676                 return -1;
 677         }
 678
 679         if (rename (oldpath.c_str(), newpath.c_str()) != 0) {
 680                 error << string_compose (_("cannot 2 rename audio file %1 to %2"), _name, newpath) << endmsg;
 681                 return -1;
 682         }
 683
 684         _name = Glib::path_get_basename (newpath);
 685         _path = newpath;
 686
 687         return rename_peakfile (peak_path (_path));
 688 }
 689
 690 bool
 691 AudioFileSource::is_empty (Session& s, ustring path)
 692 {
 693         SoundFileInfo info;
 694         string err;
 695
 696         if (!get_soundfile_info (path, info, err)) {
 697                 /* dangerous: we can't get info, so assume that its not empty */
 698                 return false;
 699         }
 700
 701         return info.length == 0;
 702 }
 703
 704 int
 705 AudioFileSource::setup_peakfile ()
 706 {
 707         if (!(_flags & NoPeakFile)) {
 708                 return initialize_peakfile (file_is_new, _path);
 709         } else {
 710                 return 0;
 711         }
 712 }
 713
 714 bool
 715 AudioFileSource::safe_file_extension(ustring file)
 716 {
 717         const char* suffixes[] = {
 718                 ".aif", ".AIF",
 719                 ".aifc", ".AIFC",
 720                 ".aiff", ".AIFF",
 721                 ".amb", ".AMB",
 722                 ".au", ".AU",
 723                 ".caf", ".CAF",
 724                 ".cdr", ".CDR",
 725                 ".flac", ".FLAC",
 726                 ".htk", ".HTK",
 727                 ".iff", ".IFF",
 728                 ".mat", ".MAT",
 729                 ".oga", ".OGA",
 730                 ".ogg", ".OGG",
 731                 ".paf", ".PAF",
 732                 ".pvf", ".PVF",
 733                 ".sf", ".SF",
 734                 ".smp", ".SMP",
 735                 ".snd", ".SND",
 736                 ".maud", ".MAUD",
 737                 ".voc", ".VOC"
 738                 ".vwe", ".VWE",
 739                 ".w64", ".W64",
 740                 ".wav", ".WAV",
 741 #ifdef HAVE_COREAUDIO
 742                 ".aac", ".AAC",
 743                 ".adts", ".ADTS",
 744                 ".ac3", ".AC3",
 745                 ".amr", ".AMR",
 746                 ".mpa", ".MPA",
 747                 ".mpeg", ".MPEG",
 748                 ".mp1", ".MP1",
 749                 ".mp2", ".MP2",
 750                 ".mp3", ".MP3",
 751                 ".mp4", ".MP4",
 752                 ".m4a", ".M4A",
 753                 ".sd2", ".SD2",         // libsndfile supports sd2 also, but the resource fork is required to open.
 754 #endif // HAVE_COREAUDIO
 755         };
 756
 757         for (size_t n = 0; n < sizeof(suffixes)/sizeof(suffixes[0]); ++n) {
 758                 if (file.rfind (suffixes[n]) == file.length() - strlen (suffixes[n])) {
 759                         return true;
 760                 }
 761         }
 762
 763         return false;
 764 }
 765
 766 void
 767 AudioFileSource::mark_immutable ()
 768 {
 769         /* destructive sources stay writable, and their other flags don't
 770            change.
 771         */
 772
 773         if (!(_flags & Destructive)) {
 774                 _flags = Flag (_flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy|CanRename));
 775         }
 776 }
 777
 778
 779 Sample*
 780 AudioFileSource::get_interleave_buffer (nframes_t size)
 781 {
 782         SizedSampleBuffer* ssb;
 783
 784         if ((ssb = thread_interleave_buffer.get()) == 0) {
 785                 ssb = new SizedSampleBuffer (size);
 786                 thread_interleave_buffer.set (ssb);
 787         }
 788
 789         if (ssb->size < size) {
 790                 ssb = new SizedSampleBuffer (size);
 791                 thread_interleave_buffer.set (ssb);
 792         }
 793
 794         return ssb->buf;
 795 }