libs/ardour/audio_diskstream.cc

   1 /*
   2     Copyright (C) 2000-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 #include <fstream>
  20 #include <cstdio>
  21 #include <unistd.h>
  22 #include <cmath>
  23 #include <cerrno>
  24 #include <cassert>
  25 #include <string>
  26 #include <climits>
  27 #include <fcntl.h>
  28 #include <cstdlib>
  29 #include <ctime>
  30 #include <sys/stat.h>
  31 #include <sys/mman.h>
  32
  33 #include <pbd/error.h>
  34 #include <pbd/basename.h>
  35 #include <glibmm/thread.h>
  36 #include <pbd/xml++.h>
  37 #include <pbd/memento_command.h>
  38 #include <pbd/enumwriter.h>
  39 #include <pbd/stacktrace.h>
  40
  41 #include <ardour/ardour.h>
  42 #include <ardour/audioengine.h>
  43 #include <ardour/analyser.h>
  44 #include <ardour/audio_diskstream.h>
  45 #include <ardour/utils.h>
  46 #include <ardour/configuration.h>
  47 #include <ardour/audiofilesource.h>
  48 #include <ardour/send.h>
  49 #include <ardour/region_factory.h>
  50 #include <ardour/audioplaylist.h>
  51 #include <ardour/playlist_factory.h>
  52 #include <ardour/cycle_timer.h>
  53 #include <ardour/audioregion.h>
  54 #include <ardour/source_factory.h>
  55
  56 #include "i18n.h"
  57 #include <locale.h>
  58
  59 using namespace std;
  60 using namespace ARDOUR;
  61 using namespace PBD;
  62
  63 size_t  AudioDiskstream::_working_buffers_size = 0;
  64 Sample* AudioDiskstream::_mixdown_buffer       = 0;
  65 gain_t* AudioDiskstream::_gain_buffer          = 0;
  66
  67 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
  68         : Diskstream(sess, name, flag)
  69         , deprecated_io_node(NULL)
  70         , channels (new ChannelList)
  71 {
  72         /* prevent any write sources from being created */
  73
  74         in_set_state = true;
  75
  76         init(flag);
  77         use_new_playlist ();
  78
  79         in_set_state = false;
  80 }
  81
  82 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
  83         : Diskstream(sess, node)
  84         , deprecated_io_node(NULL)
  85         , channels (new ChannelList)
  86 {
  87         in_set_state = true;
  88         init (Recordable);
  89
  90         if (set_state (node)) {
  91                 in_set_state = false;
  92                 throw failed_constructor();
  93         }
  94
  95         in_set_state = false;
  96
  97         if (destructive()) {
  98                 use_destructive_playlist ();
  99         }
 100 }
 101
 102 void
 103 AudioDiskstream::init (Diskstream::Flag f)
 104 {
 105         Diskstream::init(f);
 106
 107         /* there are no channels at this point, so these
 108            two calls just get speed_buffer_size and wrap_buffer
 109            size setup without duplicating their code.
 110         */
 111
 112         set_block_size (_session.get_block_size());
 113         allocate_temporary_buffers ();
 114
 115         add_channel (1);
 116         assert(_n_channels == 1);
 117 }
 118
 119 AudioDiskstream::~AudioDiskstream ()
 120 {
 121         notify_callbacks ();
 122
 123         {
 124                 RCUWriter<ChannelList> writer (channels);
 125                 boost::shared_ptr<ChannelList> c = writer.get_copy();
 126
 127                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 128                         delete *chan;
 129                 }
 130
 131                 c->clear();
 132         }
 133
 134         channels.flush ();
 135 }
 136
 137 void
 138 AudioDiskstream::allocate_working_buffers()
 139 {
 140         assert(disk_io_frames() > 0);
 141
 142         _working_buffers_size = disk_io_frames();
 143         _mixdown_buffer       = new Sample[_working_buffers_size];
 144         _gain_buffer          = new gain_t[_working_buffers_size];
 145 }
 146
 147 void
 148 AudioDiskstream::free_working_buffers()
 149 {
 150         delete [] _mixdown_buffer;
 151         delete [] _gain_buffer;
 152         _working_buffers_size = 0;
 153         _mixdown_buffer       = 0;
 154         _gain_buffer          = 0;
 155 }
 156
 157 void
 158 AudioDiskstream::non_realtime_input_change ()
 159 {
 160         {
 161                 Glib::Mutex::Lock lm (state_lock);
 162
 163                 if (input_change_pending == NoChange) {
 164                         return;
 165                 }
 166
 167                 {
 168                         RCUWriter<ChannelList> writer (channels);
 169                         boost::shared_ptr<ChannelList> c = writer.get_copy();
 170
 171                         _n_channels = c->size();
 172
 173                         if (_io->n_inputs() > _n_channels) {
 174                                 add_channel_to (c, _io->n_inputs() - _n_channels);
 175                         } else if (_io->n_inputs() < _n_channels) {
 176                                 remove_channel_from (c, _n_channels - _io->n_inputs());
 177                         }
 178                 }
 179
 180                 get_input_sources ();
 181                 set_capture_offset ();
 182
 183                 if (first_input_change) {
 184                         set_align_style (_persistent_alignment_style);
 185                         first_input_change = false;
 186                 } else {
 187                         set_align_style_from_io ();
 188                 }
 189
 190                 input_change_pending = NoChange;
 191
 192                 /* implicit unlock */
 193         }
 194
 195         /* reset capture files */
 196
 197         reset_write_sources (false);
 198
 199         /* now refill channel buffers */
 200
 201         if (speed() != 1.0f || speed() != -1.0f) {
 202                 seek ((nframes_t) (_session.transport_frame() * (double) speed()));
 203         } else {
 204                 seek (_session.transport_frame());
 205         }
 206 }
 207
 208 void
 209 AudioDiskstream::get_input_sources ()
 210 {
 211         boost::shared_ptr<ChannelList> c = channels.reader();
 212
 213         uint32_t n;
 214         ChannelList::iterator chan;
 215         uint32_t ni = _io->n_inputs();
 216
 217         for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
 218
 219                 const char **connections = _io->input(n)->get_connections ();
 220
 221                 if (connections == 0 || connections[0] == 0) {
 222
 223                         if ((*chan)->source) {
 224                                 // _source->disable_metering ();
 225                         }
 226
 227                         (*chan)->source = 0;
 228
 229                 } else {
 230                         (*chan)->source = _session.engine().get_port_by_name (connections[0]);
 231                 }
 232
 233                 if (connections) {
 234                         free (connections);
 235                 }
 236         }
 237 }
 238
 239 int
 240 AudioDiskstream::find_and_use_playlist (const string& name)
 241 {
 242         boost::shared_ptr<AudioPlaylist> playlist;
 243
 244         if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
 245                 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (_session, name));
 246         }
 247
 248         if (!playlist) {
 249                 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
 250                 return -1;
 251         }
 252
 253         return use_playlist (playlist);
 254 }
 255
 256 int
 257 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 258 {
 259         assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
 260
 261         Diskstream::use_playlist(playlist);
 262
 263         return 0;
 264 }
 265
 266 int
 267 AudioDiskstream::use_new_playlist ()
 268 {
 269         string newname;
 270         boost::shared_ptr<AudioPlaylist> playlist;
 271
 272         if (!in_set_state && destructive()) {
 273                 return 0;
 274         }
 275
 276         if (_playlist) {
 277                 newname = Playlist::bump_name (_playlist->name(), _session);
 278         } else {
 279                 newname = Playlist::bump_name (_name, _session);
 280         }
 281
 282         if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (_session, newname, hidden()))) != 0) {
 283
 284                 playlist->set_orig_diskstream_id (id());
 285                 return use_playlist (playlist);
 286
 287         } else {
 288                 return -1;
 289         }
 290 }
 291
 292 int
 293 AudioDiskstream::use_copy_playlist ()
 294 {
 295         assert(audio_playlist());
 296
 297         if (destructive()) {
 298                 return 0;
 299         }
 300
 301         if (_playlist == 0) {
 302                 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 303                 return -1;
 304         }
 305
 306         string newname;
 307         boost::shared_ptr<AudioPlaylist> playlist;
 308
 309         newname = Playlist::bump_name (_playlist->name(), _session);
 310
 311         if ((playlist  = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
 312                 playlist->set_orig_diskstream_id (id());
 313                 return use_playlist (playlist);
 314         } else {
 315                 return -1;
 316         }
 317 }
 318
 319 void
 320 AudioDiskstream::setup_destructive_playlist ()
 321 {
 322         SourceList srcs;
 323         boost::shared_ptr<ChannelList> c = channels.reader();
 324
 325         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 326                 srcs.push_back ((*chan)->write_source);
 327         }
 328
 329         /* a single full-sized region */
 330
 331         boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
 332         _playlist->add_region (region, srcs.front()->natural_position());
 333 }
 334
 335 void
 336 AudioDiskstream::use_destructive_playlist ()
 337 {
 338         /* this is called from the XML-based constructor or ::set_destructive. when called,
 339            we already have a playlist and a region, but we need to
 340            set up our sources for write. we use the sources associated
 341            with the (presumed single, full-extent) region.
 342         */
 343
 344         boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
 345
 346         if (!rp) {
 347                 reset_write_sources (false, true);
 348                 return;
 349         }
 350
 351         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
 352
 353         if (region == 0) {
 354                 throw failed_constructor();
 355         }
 356
 357         /* be sure to stretch the region out to the maximum length */
 358
 359         region->set_length (max_frames - region->position(), this);
 360
 361         uint32_t n;
 362         ChannelList::iterator chan;
 363         boost::shared_ptr<ChannelList> c = channels.reader();
 364
 365         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 366                 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
 367                 assert((*chan)->write_source);
 368                 (*chan)->write_source->set_allow_remove_if_empty (false);
 369
 370                 /* this might be false if we switched modes, so force it */
 371
 372                 (*chan)->write_source->set_destructive (true);
 373         }
 374
 375         /* the source list will never be reset for a destructive track */
 376 }
 377
 378 void
 379 AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
 380 {
 381         int possibly_recording;
 382         int rolling;
 383         int change;
 384         const int transport_rolling = 0x4;
 385         const int track_rec_enabled = 0x2;
 386         const int global_rec_enabled = 0x1;
 387
 388         /* merge together the 3 factors that affect record status, and compute
 389            what has changed.
 390         */
 391
 392         rolling = _session.transport_speed() != 0.0f;
 393         possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
 394         change = possibly_recording ^ last_possibly_recording;
 395
 396         if (possibly_recording == last_possibly_recording) {
 397                 return;
 398         }
 399
 400         /* change state */
 401
 402         /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
 403
 404         if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) ||
 405             ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
 406
 407                 /* starting to record: compute first+last frames */
 408
 409                 first_recordable_frame = transport_frame + _capture_offset;
 410                 last_recordable_frame = max_frames;
 411                 capture_start_frame = transport_frame;
 412
 413                 if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
 414
 415                         /* was stopped, now rolling (and recording) */
 416
 417                         if (_alignment_style == ExistingMaterial) {
 418                                 first_recordable_frame += _session.worst_output_latency();
 419                         } else {
 420                                 first_recordable_frame += _roll_delay;
 421                         }
 422
 423                 } else {
 424
 425                         /* was rolling, but record state changed */
 426
 427                         if (_alignment_style == ExistingMaterial) {
 428
 429                                 if (!Config->get_punch_in()) {
 430
 431                                         /* manual punch in happens at the correct transport frame
 432                                            because the user hit a button. but to get alignment correct
 433                                            we have to back up the position of the new region to the
 434                                            appropriate spot given the roll delay.
 435                                         */
 436
 437                                         capture_start_frame -= _roll_delay;
 438
 439                                         /* XXX paul notes (august 2005): i don't know why
 440                                            this is needed.
 441                                         */
 442
 443                                         first_recordable_frame += _capture_offset;
 444
 445                                 } else {
 446
 447                                         /* autopunch toggles recording at the precise
 448                                            transport frame, and then the DS waits
 449                                            to start recording for a time that depends
 450                                            on the output latency.
 451                                         */
 452
 453                                         first_recordable_frame += _session.worst_output_latency();
 454                                 }
 455
 456                         } else {
 457
 458                                 if (Config->get_punch_in()) {
 459                                         first_recordable_frame += _roll_delay;
 460                                 } else {
 461                                         capture_start_frame -= _roll_delay;
 462                                 }
 463                         }
 464
 465                 }
 466
 467                 if (recordable() && destructive()) {
 468                         boost::shared_ptr<ChannelList> c = channels.reader();
 469                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 470
 471                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
 472                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
 473
 474                                 if (transvec.len[0] > 0) {
 475                                         transvec.buf[0]->type = CaptureStart;
 476                                         transvec.buf[0]->capture_val = capture_start_frame;
 477                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
 478                                 }
 479                                 else {
 480                                         // bad!
 481                                         fatal << X_("programming error: capture_transition_buf is full on rec start!  inconceivable!")
 482                                               << endmsg;
 483                                 }
 484                         }
 485                 }
 486
 487         } else if (!record_enabled() || !can_record) {
 488
 489                 /* stop recording */
 490
 491                 last_recordable_frame = transport_frame + _capture_offset;
 492
 493                 if (_alignment_style == ExistingMaterial) {
 494                         last_recordable_frame += _session.worst_output_latency();
 495                 } else {
 496                         last_recordable_frame += _roll_delay;
 497                 }
 498         }
 499
 500         last_possibly_recording = possibly_recording;
 501 }
 502
 503 int
 504 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
 505 {
 506         uint32_t n;
 507         boost::shared_ptr<ChannelList> c = channels.reader();
 508         ChannelList::iterator chan;
 509         int ret = -1;
 510         nframes_t rec_offset = 0;
 511         nframes_t rec_nframes = 0;
 512         bool nominally_recording;
 513         bool re = record_enabled ();
 514         bool collect_playback = false;
 515
 516         /* if we've already processed the frames corresponding to this call,
 517            just return. this allows multiple routes that are taking input
 518            from this diskstream to call our ::process() method, but have
 519            this stuff only happen once. more commonly, it allows both
 520            the AudioTrack that is using this AudioDiskstream *and* the Session
 521            to call process() without problems.
 522         */
 523
 524         if (_processed) {
 525                 return 0;
 526         }
 527
 528         commit_should_unlock = false;
 529
 530         if (!_io->active()) {
 531                 _processed = true;
 532                 return 0;
 533         }
 534
 535         check_record_status (transport_frame, nframes, can_record);
 536
 537         nominally_recording = (can_record && re);
 538
 539         if (nframes == 0) {
 540                 _processed = true;
 541                 return 0;
 542         }
 543
 544         /* This lock is held until the end of AudioDiskstream::commit, so these two functions
 545            must always be called as a pair. The only exception is if this function
 546            returns a non-zero value, in which case, ::commit should not be called.
 547         */
 548
 549         // If we can't take the state lock return.
 550         if (!state_lock.trylock()) {
 551                 return 1;
 552         }
 553         commit_should_unlock = true;
 554         adjust_capture_position = 0;
 555
 556         for (chan = c->begin(); chan != c->end(); ++chan) {
 557                 (*chan)->current_capture_buffer = 0;
 558                 (*chan)->current_playback_buffer  = 0;
 559         }
 560
 561         if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
 562                 OverlapType ot;
 563
 564                 // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
 565                 if (last_recordable_frame < first_recordable_frame) {
 566                         last_recordable_frame = max_frames;
 567
 568                 }
 569
 570                 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 571
 572                 switch (ot) {
 573                 case OverlapNone:
 574                         rec_nframes = 0;
 575                         break;
 576
 577                 case OverlapInternal:
 578                 /*     ----------    recrange
 579                          |---|       transrange
 580                 */
 581                         rec_nframes = nframes;
 582                         rec_offset = 0;
 583                         break;
 584
 585                 case OverlapStart:
 586                         /*    |--------|    recrange
 587                             -----|          transrange
 588                         */
 589                         rec_nframes = transport_frame + nframes - first_recordable_frame;
 590                         if (rec_nframes) {
 591                                 rec_offset = first_recordable_frame - transport_frame;
 592                         }
 593                         break;
 594
 595                 case OverlapEnd:
 596                         /*    |--------|    recrange
 597                                  |--------  transrange
 598                         */
 599                         rec_nframes = last_recordable_frame - transport_frame;
 600                         rec_offset = 0;
 601                         break;
 602
 603                 case OverlapExternal:
 604                         /*    |--------|    recrange
 605                             --------------  transrange
 606                         */
 607                         rec_nframes = last_recordable_frame - first_recordable_frame;
 608                         rec_offset = first_recordable_frame - transport_frame;
 609                         break;
 610                 }
 611
 612                 if (rec_nframes && !was_recording) {
 613                         capture_captured = 0;
 614                         was_recording = true;
 615                 }
 616         }
 617
 618
 619         if (can_record && !_last_capture_regions.empty()) {
 620                 _last_capture_regions.clear ();
 621         }
 622
 623         if (nominally_recording || rec_nframes) {
 624
 625                 uint32_t limit = _io->n_inputs ();
 626
 627                 /* one or more ports could already have been removed from _io, but our
 628                    channel setup hasn't yet been updated. prevent us from trying to
 629                    use channels that correspond to missing ports. note that the
 630                    process callback (from which this is called) is always atomic
 631                    with respect to port removal/addition.
 632                 */
 633
 634                 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
 635
 636                         ChannelInfo* chaninfo (*chan);
 637
 638                         chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
 639
 640                         if (rec_nframes <= chaninfo->capture_vector.len[0]) {
 641
 642                                 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
 643
 644                                 /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
 645                                    rec_offset
 646                                 */
 647
 648                                 memcpy (chaninfo->current_capture_buffer, _io->input(n)->get_buffer (rec_nframes) + offset + rec_offset, sizeof (Sample) * rec_nframes);
 649
 650                         } else {
 651
 652                                 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
 653
 654                                 if (rec_nframes > total) {
 655                                         DiskOverrun ();
 656                                         goto out;
 657                                 }
 658
 659                                 Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
 660                                 nframes_t first = chaninfo->capture_vector.len[0];
 661
 662                                 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
 663                                 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
 664                                 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
 665                                 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
 666
 667                                 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
 668                         }
 669                 }
 670
 671         } else {
 672
 673                 if (was_recording) {
 674                         finish_capture (rec_monitors_input, c);
 675                 }
 676
 677         }
 678
 679         if (rec_nframes) {
 680
 681                 /* data will be written to disk */
 682
 683                 if (rec_nframes == nframes && rec_offset == 0) {
 684
 685                         for (chan = c->begin(); chan != c->end(); ++chan) {
 686                                 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 687                         }
 688
 689                         playback_distance = nframes;
 690
 691                 } else {
 692
 693
 694                         /* we can't use the capture buffer as the playback buffer, because
 695                            we recorded only a part of the current process' cycle data
 696                            for capture.
 697                         */
 698
 699                         collect_playback = true;
 700                 }
 701
 702                 adjust_capture_position = rec_nframes;
 703
 704         } else if (nominally_recording) {
 705
 706                 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
 707
 708                 for (chan = c->begin(); chan != c->end(); ++chan) {
 709                         (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 710                 }
 711
 712                 playback_distance = nframes;
 713
 714         } else {
 715
 716                 collect_playback = true;
 717         }
 718
 719         if (collect_playback) {
 720
 721                 /* we're doing playback */
 722
 723                 nframes_t necessary_samples;
 724
 725                 /* no varispeed playback if we're recording, because the output .... TBD */
 726
 727                 if (rec_nframes == 0 && _actual_speed != 1.0f) {
 728                         necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
 729                 } else {
 730                         necessary_samples = nframes;
 731                 }
 732
 733                 for (chan = c->begin(); chan != c->end(); ++chan) {
 734                         (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
 735                 }
 736
 737                 n = 0;
 738
 739                 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
 740
 741                         ChannelInfo* chaninfo (*chan);
 742
 743                         if (necessary_samples <= chaninfo->playback_vector.len[0]) {
 744
 745                                 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
 746
 747                         } else {
 748                                 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
 749
 750                                 if (necessary_samples > total) {
 751                                         cerr << "underrun for " << _name << endl;
 752                                         DiskUnderrun ();
 753                                         goto out;
 754
 755                                 } else {
 756
 757                                         memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
 758                                                 chaninfo->playback_vector.len[0] * sizeof (Sample));
 759                                         memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
 760                                                 (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
 761
 762                                         chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
 763                                 }
 764                         }
 765                 }
 766
 767                 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
 768
 769                         uint64_t phase = last_phase;
 770                         int64_t phi_delta;
 771                         nframes_t i = 0;
 772
 773                         // Linearly interpolate into the alt buffer
 774                         // using 40.24 fixp maths (swh)
 775
 776                         if (phi != target_phi) {
 777                                 phi_delta = ((int64_t)(target_phi - phi)) / nframes;
 778                         } else {
 779                                 phi_delta = 0;
 780                         }
 781
 782                         for (chan = c->begin(); chan != c->end(); ++chan) {
 783
 784                                 float fr;
 785                                 ChannelInfo* chaninfo (*chan);
 786
 787                                 i = 0;
 788                                 phase = last_phase;
 789
 790                                 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
 791                                         i = phase >> 24;
 792                                         fr = (phase & 0xFFFFFF) / 16777216.0f;
 793                                         chaninfo->speed_buffer[outsample] =
 794                                                 chaninfo->current_playback_buffer[i] * (1.0f - fr) +
 795                                                 chaninfo->current_playback_buffer[i+1] * fr;
 796                                         phase += phi + phi_delta;
 797                                 }
 798
 799                                 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
 800                         }
 801
 802                         playback_distance = i; // + 1;
 803                         last_phase = (phase & 0xFFFFFF);
 804
 805                 } else {
 806                         playback_distance = nframes;
 807                 }
 808
 809                 phi = target_phi;
 810         }
 811
 812         ret = 0;
 813
 814   out:
 815         _processed = true;
 816
 817         if (ret) {
 818
 819                 /* we're exiting with failure, so ::commit will not
 820                    be called. unlock the state lock.
 821                 */
 822
 823                 commit_should_unlock = false;
 824                 state_lock.unlock();
 825         }
 826
 827         return ret;
 828 }
 829
 830 bool
 831 AudioDiskstream::commit (nframes_t nframes)
 832 {
 833         bool need_butler = false;
 834
 835         if (!_io->active()) {
 836                 return false;
 837         }
 838
 839         if (_actual_speed < 0.0) {
 840                 playback_sample -= playback_distance;
 841         } else {
 842                 playback_sample += playback_distance;
 843         }
 844
 845         boost::shared_ptr<ChannelList> c = channels.reader();
 846         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 847
 848                 (*chan)->playback_buf->increment_read_ptr (playback_distance);
 849
 850                 if (adjust_capture_position) {
 851                         (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
 852                 }
 853         }
 854
 855         if (adjust_capture_position != 0) {
 856                 capture_captured += adjust_capture_position;
 857                 adjust_capture_position = 0;
 858         }
 859
 860         if (_slaved) {
 861                 if (_io && _io->active()) {
 862                         need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
 863                 } else {
 864                         need_butler = false;
 865                 }
 866         } else {
 867                 if (_io && _io->active()) {
 868                         need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
 869                                 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
 870                 } else {
 871                         need_butler = c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
 872                 }
 873         }
 874
 875         if (commit_should_unlock) {
 876                 state_lock.unlock();
 877         }
 878
 879         _processed = false;
 880
 881         return need_butler;
 882 }
 883
 884 void
 885 AudioDiskstream::set_pending_overwrite (bool yn)
 886 {
 887         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 888
 889         pending_overwrite = yn;
 890
 891         overwrite_frame = playback_sample;
 892         overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
 893 }
 894
 895 int
 896 AudioDiskstream::overwrite_existing_buffers ()
 897 {
 898         boost::shared_ptr<ChannelList> c = channels.reader();
 899         Sample* mixdown_buffer;
 900         float* gain_buffer;
 901         int ret = -1;
 902         bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
 903
 904         overwrite_queued = false;
 905
 906         /* assume all are the same size */
 907         nframes_t size = c->front()->playback_buf->bufsize();
 908
 909         mixdown_buffer = new Sample[size];
 910         gain_buffer = new float[size];
 911
 912         /* reduce size so that we can fill the buffer correctly. */
 913         size--;
 914
 915         uint32_t n=0;
 916         nframes_t start;
 917
 918         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 919
 920                 start = overwrite_frame;
 921                 nframes_t cnt = size;
 922
 923                 /* to fill the buffer without resetting the playback sample, we need to
 924                    do it one or two chunks (normally two).
 925
 926                    |----------------------------------------------------------------------|
 927
 928                                        ^
 929                                        overwrite_offset
 930                     |<- second chunk->||<----------------- first chunk ------------------>|
 931
 932                 */
 933
 934                 nframes_t to_read = size - overwrite_offset;
 935
 936                 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
 937                         error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 938                                          _id, size, playback_sample) << endmsg;
 939                         goto out;
 940                 }
 941
 942                 if (cnt > to_read) {
 943
 944                         cnt -= to_read;
 945
 946                         if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
 947                                   start, cnt, *chan, n, reversed)) {
 948                                 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
 949                                                  _id, size, playback_sample) << endmsg;
 950                                 goto out;
 951                         }
 952                 }
 953         }
 954
 955         ret = 0;
 956
 957   out:
 958         pending_overwrite = false;
 959         delete [] gain_buffer;
 960         delete [] mixdown_buffer;
 961         return ret;
 962 }
 963
 964 int
 965 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
 966 {
 967         uint32_t n;
 968         int ret;
 969         ChannelList::iterator chan;
 970         boost::shared_ptr<ChannelList> c = channels.reader();
 971
 972         Glib::Mutex::Lock lm (state_lock);
 973
 974         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 975                 (*chan)->playback_buf->reset ();
 976                 (*chan)->capture_buf->reset ();
 977         }
 978
 979         /* can't rec-enable in destructive mode if transport is before start */
 980
 981         if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
 982                 disengage_record_enable ();
 983         }
 984
 985         playback_sample = frame;
 986         file_frame = frame;
 987
 988         if (complete_refill) {
 989                 while ((ret = do_refill_with_alloc ()) > 0) ;
 990         } else {
 991                 ret = do_refill_with_alloc ();
 992         }
 993
 994         return ret;
 995 }
 996
 997 int
 998 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
 999 {
1000         ChannelList::iterator chan;
1001         boost::shared_ptr<ChannelList> c = channels.reader();
1002
1003         for (chan = c->begin(); chan != c->end(); ++chan) {
1004                 if ((*chan)->playback_buf->read_space() < distance) {
1005                         return false;
1006                 }
1007         }
1008         return true;
1009 }
1010
1011 int
1012 AudioDiskstream::internal_playback_seek (nframes_t distance)
1013 {
1014         ChannelList::iterator chan;
1015         boost::shared_ptr<ChannelList> c = channels.reader();
1016
1017         for (chan = c->begin(); chan != c->end(); ++chan) {
1018                 (*chan)->playback_buf->increment_read_ptr (distance);
1019         }
1020
1021         first_recordable_frame += distance;
1022         playback_sample += distance;
1023
1024         return 0;
1025 }
1026
1027 int
1028 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
1029                        ChannelInfo* channel_info, int channel, bool reversed)
1030 {
1031         nframes_t this_read = 0;
1032         bool reloop = false;
1033         nframes_t loop_end = 0;
1034         nframes_t loop_start = 0;
1035         nframes_t loop_length = 0;
1036         nframes_t offset = 0;
1037         nframes_t xfade_samples = 0;
1038         Sample    xfade_buf[128];
1039         Location *loc = 0;
1040
1041         /* XXX we don't currently play loops in reverse. not sure why */
1042
1043         if (!reversed) {
1044
1045                 /* Make the use of a Location atomic for this read operation.
1046
1047                    Note: Locations don't get deleted, so all we care about
1048                    when I say "atomic" is that we are always pointing to
1049                    the same one and using a start/length values obtained
1050                    just once.
1051                 */
1052
1053                 if ((loc = loop_location) != 0) {
1054                         loop_start = loc->start();
1055                         loop_end = loc->end();
1056                         loop_length = loop_end - loop_start;
1057                 }
1058
1059                 /* if we are looping, ensure that the first frame we read is at the correct
1060                    position within the loop.
1061                 */
1062
1063                 if (loc && start >= loop_end) {
1064                         //cerr << "start adjusted from " << start;
1065                         start = loop_start + ((start - loop_start) % loop_length);
1066                         //cerr << "to " << start << endl;
1067                 }
1068
1069                 //cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
1070         }
1071
1072         while (cnt) {
1073
1074                 if (reversed) {
1075                         start -= cnt;
1076                 }
1077
1078                 /* take any loop into account. we can't read past the end of the loop. */
1079
1080                 if (loc && (loop_end - start < cnt)) {
1081                         this_read = loop_end - start;
1082                         //cerr << "reloop true: thisread: " << this_read << "  cnt: " << cnt << endl;
1083                         reloop = true;
1084                 } else {
1085                         reloop = false;
1086                         this_read = cnt;
1087                 }
1088
1089                 if (this_read == 0) {
1090                         break;
1091                 }
1092
1093                 this_read = min(cnt,this_read);
1094
1095                 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1096                         error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1097                                          start) << endmsg;
1098                         return -1;
1099                 }
1100
1101                 // xfade loop boundary if appropriate
1102
1103                 if (xfade_samples > 0) {
1104                         // just do a linear xfade for this short bit
1105
1106                         xfade_samples = min(xfade_samples, this_read);
1107
1108                         float delta = 1.0f / xfade_samples;
1109                         float scale = 0.0f;
1110                         Sample * tmpbuf = buf+offset;
1111
1112                         for (size_t i=0; i < xfade_samples; ++i) {
1113                                 *tmpbuf = (*tmpbuf * scale) + xfade_buf[i]*(1.0f - scale);
1114                                 ++tmpbuf;
1115                                 scale += delta;
1116                         }
1117
1118                         xfade_samples = 0;
1119                 }
1120
1121                 _read_data_count = _playlist->read_data_count();
1122
1123                 if (reversed) {
1124
1125                         swap_by_ptr (buf, buf + this_read - 1);
1126
1127                 } else {
1128                         start += this_read;
1129
1130                         /* if we read to the end of the loop, go back to the beginning */
1131
1132                         if (reloop) {
1133                                 // read crossfade samples to apply to the next read
1134
1135                                 xfade_samples = min((nframes_t) 128, cnt-this_read);
1136
1137                                 if (audio_playlist()->read (xfade_buf, mixdown_buffer, gain_buffer, start, xfade_samples, channel) != xfade_samples) {
1138                                         error << string_compose(_("AudioDiskstream %1: cannot read xfade samples %2 from playlist at frame %3"),
1139                                                                 _id, xfade_samples,start) << endmsg;
1140                                         memset(xfade_buf, 0, xfade_samples * sizeof(Sample)); // just in case
1141                                 }
1142
1143                                 start = loop_start;
1144                         }
1145                 }
1146
1147                 cnt -= this_read;
1148                 offset += this_read;
1149         }
1150
1151         return 0;
1152 }
1153
1154 int
1155 AudioDiskstream::do_refill_with_alloc ()
1156 {
1157         Sample* mix_buf  = new Sample[disk_io_chunk_frames];
1158         float*  gain_buf = new float[disk_io_chunk_frames];
1159
1160         int ret = _do_refill(mix_buf, gain_buf);
1161
1162         delete [] mix_buf;
1163         delete [] gain_buf;
1164
1165         return ret;
1166 }
1167
1168 int
1169 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1170 {
1171         int32_t ret = 0;
1172         nframes_t to_read;
1173         RingBufferNPT<Sample>::rw_vector vector;
1174         bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1175         nframes_t total_space;
1176         nframes_t zero_fill;
1177         uint32_t chan_n;
1178         ChannelList::iterator i;
1179         boost::shared_ptr<ChannelList> c = channels.reader();
1180         nframes_t ts;
1181
1182         if (c->empty()) {
1183                 return 0;
1184         }
1185
1186         assert(mixdown_buffer);
1187         assert(gain_buffer);
1188
1189         vector.buf[0] = 0;
1190         vector.len[0] = 0;
1191         vector.buf[1] = 0;
1192         vector.len[1] = 0;
1193
1194         c->front()->playback_buf->get_write_vector (&vector);
1195
1196         if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1197                 return 0;
1198         }
1199
1200         /* if there are 2+ chunks of disk i/o possible for
1201            this track, let the caller know so that it can arrange
1202            for us to be called again, ASAP.
1203         */
1204
1205         if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1206                 ret = 1;
1207         }
1208
1209         /* if we're running close to normal speed and there isn't enough
1210            space to do disk_io_chunk_frames of I/O, then don't bother.
1211
1212            at higher speeds, just do it because the sync between butler
1213            and audio thread may not be good enough.
1214         */
1215
1216         if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1217                 return 0;
1218         }
1219
1220         /* when slaved, don't try to get too close to the read pointer. this
1221            leaves space for the buffer reversal to have something useful to
1222            work with.
1223         */
1224
1225         if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1226                 return 0;
1227         }
1228
1229         /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1230
1231         total_space = min (disk_io_chunk_frames, total_space);
1232
1233         if (reversed) {
1234
1235                 if (file_frame == 0) {
1236
1237                         /* at start: nothing to do but fill with silence */
1238
1239                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1240
1241                                 ChannelInfo* chan (*i);
1242                                 chan->playback_buf->get_write_vector (&vector);
1243                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1244                                 if (vector.len[1]) {
1245                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1246                                 }
1247                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1248                         }
1249                         return 0;
1250                 }
1251
1252                 if (file_frame < total_space) {
1253
1254                         /* too close to the start: read what we can,
1255                            and then zero fill the rest
1256                         */
1257
1258                         zero_fill = total_space - file_frame;
1259                         total_space = file_frame;
1260                         file_frame = 0;
1261
1262                 } else {
1263
1264                         zero_fill = 0;
1265                 }
1266
1267         } else {
1268
1269                 if (file_frame == max_frames) {
1270
1271                         /* at end: nothing to do but fill with silence */
1272
1273                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1274
1275                                 ChannelInfo* chan (*i);
1276                                 chan->playback_buf->get_write_vector (&vector);
1277                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1278                                 if (vector.len[1]) {
1279                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1280                                 }
1281                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1282                         }
1283                         return 0;
1284                 }
1285
1286                 if (file_frame > max_frames - total_space) {
1287
1288                         /* to close to the end: read what we can, and zero fill the rest */
1289
1290                         zero_fill = total_space - (max_frames - file_frame);
1291                         total_space = max_frames - file_frame;
1292
1293                 } else {
1294                         zero_fill = 0;
1295                 }
1296         }
1297
1298         nframes_t file_frame_tmp = 0;
1299
1300         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1301
1302                 ChannelInfo* chan (*i);
1303                 Sample* buf1;
1304                 Sample* buf2;
1305                 nframes_t len1, len2;
1306
1307                 chan->playback_buf->get_write_vector (&vector);
1308
1309                 if (vector.len[0] > disk_io_chunk_frames) {
1310
1311                         /* we're not going to fill the first chunk, so certainly do not bother with the
1312                            other part. it won't be connected with the part we do fill, as in:
1313
1314                            .... => writable space
1315                            ++++ => readable space
1316                            ^^^^ => 1 x disk_io_chunk_frames that would be filled
1317
1318                            |......|+++++++++++++|...............................|
1319                            buf1                buf0
1320                                                 ^^^^^^^^^^^^^^^
1321
1322
1323                            So, just pretend that the buf1 part isn't there.
1324
1325                         */
1326
1327                         vector.buf[1] = 0;
1328                         vector.len[1] = 0;
1329
1330                 }
1331
1332                 ts = total_space;
1333                 file_frame_tmp = file_frame;
1334
1335                 buf1 = vector.buf[0];
1336                 len1 = vector.len[0];
1337                 buf2 = vector.buf[1];
1338                 len2 = vector.len[1];
1339
1340                 to_read = min (ts, len1);
1341                 to_read = min (to_read, disk_io_chunk_frames);
1342
1343                 if (to_read) {
1344
1345                         if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1346                                 ret = -1;
1347                                 goto out;
1348                         }
1349
1350                         chan->playback_buf->increment_write_ptr (to_read);
1351                         ts -= to_read;
1352                 }
1353
1354                 to_read = min (ts, len2);
1355
1356                 if (to_read) {
1357
1358                         /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1359                            so read some or all of vector.len[1] as well.
1360                         */
1361
1362                         if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1363                                 ret = -1;
1364                                 goto out;
1365                         }
1366
1367                         chan->playback_buf->increment_write_ptr (to_read);
1368                 }
1369
1370                 if (zero_fill) {
1371                         /* do something */
1372                 }
1373
1374         }
1375
1376         file_frame = file_frame_tmp;
1377
1378   out:
1379
1380         return ret;
1381 }
1382
1383 /** Flush pending data to disk.
1384  *
1385  * Important note: this function will write *AT MOST* disk_io_chunk_frames
1386  * of data to disk. it will never write more than that.  If it writes that
1387  * much and there is more than that waiting to be written, it will return 1,
1388  * otherwise 0 on success or -1 on failure.
1389  *
1390  * If there is less than disk_io_chunk_frames to be written, no data will be
1391  * written at all unless @a force_flush is true.
1392  */
1393 int
1394 AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
1395 {
1396         uint32_t to_write;
1397         int32_t ret = 0;
1398         RingBufferNPT<Sample>::rw_vector vector;
1399         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1400         nframes_t total;
1401
1402         _write_data_count = 0;
1403
1404         transvec.buf[0] = 0;
1405         transvec.buf[1] = 0;
1406         vector.buf[0] = 0;
1407         vector.buf[1] = 0;
1408
1409         boost::shared_ptr<ChannelList> c = channels.reader();
1410         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1411
1412                 (*chan)->capture_buf->get_read_vector (&vector);
1413
1414                 total = vector.len[0] + vector.len[1];
1415
1416                 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1417                         goto out;
1418                 }
1419
1420                 /* if there are 2+ chunks of disk i/o possible for
1421                    this track, let the caller know so that it can arrange
1422                    for us to be called again, ASAP.
1423
1424                    if we are forcing a flush, then if there is* any* extra
1425                    work, let the caller know.
1426
1427                    if we are no longer recording and there is any extra work,
1428                    let the caller know too.
1429                 */
1430
1431                 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1432                         ret = 1;
1433                 }
1434
1435                 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1436
1437                 // check the transition buffer when recording destructive
1438                 // important that we get this after the capture buf
1439
1440                 if (destructive()) {
1441                         (*chan)->capture_transition_buf->get_read_vector(&transvec);
1442                         size_t transcount = transvec.len[0] + transvec.len[1];
1443                         bool have_start = false;
1444                         size_t ti;
1445
1446                         for (ti=0; ti < transcount; ++ti) {
1447                                 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1448
1449                                 if (captrans.type == CaptureStart) {
1450                                         // by definition, the first data we got above represents the given capture pos
1451
1452                                         (*chan)->write_source->mark_capture_start (captrans.capture_val);
1453                                         (*chan)->curr_capture_cnt = 0;
1454
1455                                         have_start = true;
1456                                 }
1457                                 else if (captrans.type == CaptureEnd) {
1458
1459                                         // capture end, the capture_val represents total frames in capture
1460
1461                                         if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1462
1463                                                 // shorten to make the write a perfect fit
1464                                                 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1465
1466                                                 if (nto_write < to_write) {
1467                                                         ret = 1; // should we?
1468                                                 }
1469                                                 to_write = nto_write;
1470
1471                                                 (*chan)->write_source->mark_capture_end ();
1472
1473                                                 // increment past this transition, but go no further
1474                                                 ++ti;
1475                                                 break;
1476                                         }
1477                                         else {
1478                                                 // actually ends just beyond this chunk, so force more work
1479                                                 ret = 1;
1480                                                 break;
1481                                         }
1482                                 }
1483                         }
1484
1485                         if (ti > 0) {
1486                                 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1487                         }
1488                 }
1489
1490                 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1491                         error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1492                         return -1;
1493                 }
1494
1495                 (*chan)->capture_buf->increment_read_ptr (to_write);
1496                 (*chan)->curr_capture_cnt += to_write;
1497
1498                 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1499
1500                         /* we wrote all of vector.len[0] but it wasn't an entire
1501                            disk_io_chunk_frames of data, so arrange for some part
1502                            of vector.len[1] to be flushed to disk as well.
1503                         */
1504
1505                         to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1506
1507                         if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1508                                 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1509                                 return -1;
1510                         }
1511
1512                         _write_data_count += (*chan)->write_source->write_data_count();
1513
1514                         (*chan)->capture_buf->increment_read_ptr (to_write);
1515                         (*chan)->curr_capture_cnt += to_write;
1516                 }
1517         }
1518
1519   out:
1520         return ret;
1521 }
1522
1523 void
1524 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1525 {
1526         uint32_t buffer_position;
1527         bool more_work = true;
1528         int err = 0;
1529         boost::shared_ptr<AudioRegion> region;
1530         nframes_t total_capture;
1531         SourceList srcs;
1532         SourceList::iterator src;
1533         ChannelList::iterator chan;
1534         vector<CaptureInfo*>::iterator ci;
1535         boost::shared_ptr<ChannelList> c = channels.reader();
1536         uint32_t n = 0;
1537         bool mark_write_completed = false;
1538
1539         finish_capture (true, c);
1540
1541         /* butler is already stopped, but there may be work to do
1542            to flush remaining data to disk.
1543         */
1544
1545         while (more_work && !err) {
1546                 switch (do_flush (Session::TransportContext, true)) {
1547                 case 0:
1548                         more_work = false;
1549                         break;
1550                 case 1:
1551                         break;
1552                 case -1:
1553                         error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1554                         err++;
1555                 }
1556         }
1557
1558         /* XXX is there anything we can do if err != 0 ? */
1559         Glib::Mutex::Lock lm (capture_info_lock);
1560
1561         if (capture_info.empty()) {
1562                 return;
1563         }
1564
1565         if (abort_capture) {
1566
1567                 if (destructive()) {
1568                         goto outout;
1569                 }
1570
1571                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1572
1573                         if ((*chan)->write_source) {
1574
1575                                 (*chan)->write_source->mark_for_remove ();
1576                                 (*chan)->write_source->drop_references ();
1577                                 (*chan)->write_source.reset ();
1578                         }
1579
1580                         /* new source set up in "out" below */
1581                 }
1582
1583                 goto out;
1584         }
1585
1586         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1587                 total_capture += (*ci)->frames;
1588         }
1589
1590         /* figure out the name for this take */
1591
1592         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1593
1594                 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1595
1596                 if (s) {
1597                         srcs.push_back (s);
1598                         s->update_header (capture_info.front()->start, when, twhen);
1599                         s->set_captured_for (_name);
1600                         s->mark_immutable ();
1601                         Analyser::queue_source_for_analysis (s, true);
1602                 }
1603         }
1604
1605         /* destructive tracks have a single, never changing region */
1606
1607         if (destructive()) {
1608
1609                 /* send a signal that any UI can pick up to do the right thing. there is
1610                    a small problem here in that a UI may need the peak data to be ready
1611                    for the data that was recorded and this isn't interlocked with that
1612                    process. this problem is deferred to the UI.
1613                  */
1614
1615                 _playlist->Modified();
1616
1617         } else {
1618
1619                 string whole_file_region_name;
1620                 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1621
1622                 /* Register a new region with the Session that
1623                    describes the entire source. Do this first
1624                    so that any sub-regions will obviously be
1625                    children of this one (later!)
1626                 */
1627
1628                 try {
1629                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
1630                                                                              whole_file_region_name,
1631                                                                              0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
1632
1633                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1634                         region->special_set_position (capture_info.front()->start);
1635                 }
1636
1637
1638                 catch (failed_constructor& err) {
1639                         error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1640                         /* XXX what now? */
1641                 }
1642
1643                 _last_capture_regions.push_back (region);
1644
1645                 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1646
1647                 XMLNode &before = _playlist->get_state();
1648                 _playlist->freeze ();
1649
1650                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1651
1652                         string region_name;
1653
1654                         _session.region_name (region_name, whole_file_region_name, false);
1655
1656                         // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1657
1658                         try {
1659                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1660                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1661                         }
1662
1663                         catch (failed_constructor& err) {
1664                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1665                                 continue; /* XXX is this OK? */
1666                         }
1667
1668                         region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1669
1670                         _last_capture_regions.push_back (region);
1671
1672                         i_am_the_modifier++;
1673                         _playlist->add_region (region, (*ci)->start);
1674                         i_am_the_modifier--;
1675
1676                         buffer_position += (*ci)->frames;
1677                 }
1678
1679                 _playlist->thaw ();
1680                 XMLNode &after = _playlist->get_state();
1681                 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1682         }
1683
1684         mark_write_completed = true;
1685
1686   out:
1687         reset_write_sources (mark_write_completed);
1688
1689   outout:
1690
1691         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1692                 delete *ci;
1693         }
1694
1695         capture_info.clear ();
1696         capture_start_frame = 0;
1697 }
1698
1699 void
1700 AudioDiskstream::transport_looped (nframes_t transport_frame)
1701 {
1702         if (was_recording) {
1703                 // all we need to do is finish this capture, with modified capture length
1704                 boost::shared_ptr<ChannelList> c = channels.reader();
1705
1706                 // adjust the capture length knowing that the data will be recorded to disk
1707                 // only necessary after the first loop where we're recording
1708                 if (capture_info.size() == 0) {
1709                         capture_captured += _capture_offset;
1710
1711                         if (_alignment_style == ExistingMaterial) {
1712                                 capture_captured += _session.worst_output_latency();
1713                         } else {
1714                                 capture_captured += _roll_delay;
1715                         }
1716                 }
1717
1718                 finish_capture (true, c);
1719
1720                 // the next region will start recording via the normal mechanism
1721                 // we'll set the start position to the current transport pos
1722                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1723                 capture_start_frame = transport_frame;
1724                 first_recordable_frame = transport_frame; // mild lie
1725                 last_recordable_frame = max_frames;
1726                 was_recording = true;
1727
1728                 if (recordable() && destructive()) {
1729                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1730
1731                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1732                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1733
1734                                 if (transvec.len[0] > 0) {
1735                                         transvec.buf[0]->type = CaptureStart;
1736                                         transvec.buf[0]->capture_val = capture_start_frame;
1737                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1738                                 }
1739                                 else {
1740                                         // bad!
1741                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1742                                               << endmsg;
1743                                 }
1744                         }
1745                 }
1746
1747         }
1748 }
1749
1750 void
1751 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1752 {
1753         was_recording = false;
1754
1755         if (capture_captured == 0) {
1756                 return;
1757         }
1758
1759         if (recordable() && destructive()) {
1760                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1761
1762                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1763                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
1764
1765                         if (transvec.len[0] > 0) {
1766                                 transvec.buf[0]->type = CaptureEnd;
1767                                 transvec.buf[0]->capture_val = capture_captured;
1768                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
1769                         }
1770                         else {
1771                                 // bad!
1772                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
1773                         }
1774                 }
1775         }
1776
1777
1778         CaptureInfo* ci = new CaptureInfo;
1779
1780         ci->start =  capture_start_frame;
1781         ci->frames = capture_captured;
1782
1783         /* XXX theoretical race condition here. Need atomic exchange ?
1784            However, the circumstances when this is called right
1785            now (either on record-disable or transport_stopped)
1786            mean that no actual race exists. I think ...
1787            We now have a capture_info_lock, but it is only to be used
1788            to synchronize in the transport_stop and the capture info
1789            accessors, so that invalidation will not occur (both non-realtime).
1790         */
1791
1792         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1793
1794         capture_info.push_back (ci);
1795         capture_captured = 0;
1796 }
1797
1798 void
1799 AudioDiskstream::set_record_enabled (bool yn)
1800 {
1801         if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs() == 0) {
1802                 return;
1803         }
1804
1805         /* can't rec-enable in destructive mode if transport is before start */
1806
1807         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1808                 return;
1809         }
1810
1811         if (yn && channels.reader()->front()->source == 0) {
1812
1813                 /* pick up connections not initiated *from* the IO object
1814                    we're associated with.
1815                 */
1816
1817                 get_input_sources ();
1818         }
1819
1820         /* yes, i know that this not proof against race conditions, but its
1821            good enough. i think.
1822         */
1823
1824         if (record_enabled() != yn) {
1825                 if (yn) {
1826                         engage_record_enable ();
1827                 } else {
1828                         disengage_record_enable ();
1829                 }
1830         }
1831 }
1832
1833 void
1834 AudioDiskstream::engage_record_enable ()
1835 {
1836         bool rolling = _session.transport_speed() != 0.0f;
1837         boost::shared_ptr<ChannelList> c = channels.reader();
1838
1839         g_atomic_int_set (&_record_enabled, 1);
1840         capturing_sources.clear ();
1841
1842         if (Config->get_monitoring_model() == HardwareMonitoring) {
1843
1844                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1845                         if ((*chan)->source) {
1846                                 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1847                         }
1848                         capturing_sources.push_back ((*chan)->write_source);
1849                 }
1850
1851         } else {
1852                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1853                         capturing_sources.push_back ((*chan)->write_source);
1854                 }
1855         }
1856
1857         RecordEnableChanged (); /* EMIT SIGNAL */
1858 }
1859
1860 void
1861 AudioDiskstream::disengage_record_enable ()
1862 {
1863         g_atomic_int_set (&_record_enabled, 0);
1864         boost::shared_ptr<ChannelList> c = channels.reader();
1865         if (Config->get_monitoring_model() == HardwareMonitoring) {
1866                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1867                         if ((*chan)->source) {
1868                                 (*chan)->source->ensure_monitor_input (false);
1869                         }
1870                 }
1871         }
1872         capturing_sources.clear ();
1873         RecordEnableChanged (); /* EMIT SIGNAL */
1874 }
1875
1876 XMLNode&
1877 AudioDiskstream::get_state ()
1878 {
1879         XMLNode* node = new XMLNode ("AudioDiskstream");
1880         char buf[64] = "";
1881         LocaleGuard lg (X_("POSIX"));
1882         boost::shared_ptr<ChannelList> c = channels.reader();
1883
1884         node->add_property ("flags", enum_2_string (_flags));
1885
1886         snprintf (buf, sizeof(buf), "%zd", c->size());
1887         node->add_property ("channels", buf);
1888
1889         node->add_property ("playlist", _playlist->name());
1890
1891         snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1892         node->add_property ("speed", buf);
1893
1894         node->add_property("name", _name);
1895         id().print (buf, sizeof (buf));
1896         node->add_property("id", buf);
1897
1898         if (!capturing_sources.empty() && _session.get_record_enabled()) {
1899
1900                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1901                 XMLNode* cs_grandchild;
1902
1903                 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1904                         cs_grandchild = new XMLNode (X_("file"));
1905                         cs_grandchild->add_property (X_("path"), (*i)->path());
1906                         cs_child->add_child_nocopy (*cs_grandchild);
1907                 }
1908
1909                 /* store the location where capture will start */
1910
1911                 Location* pi;
1912
1913                 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1914                         snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1915                 } else {
1916                         snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1917                 }
1918
1919                 cs_child->add_property (X_("at"), buf);
1920                 node->add_child_nocopy (*cs_child);
1921         }
1922
1923         if (_extra_xml) {
1924                 node->add_child_copy (*_extra_xml);
1925         }
1926
1927         return* node;
1928 }
1929
1930 int
1931 AudioDiskstream::set_state (const XMLNode& node)
1932 {
1933         const XMLProperty* prop;
1934         XMLNodeList nlist = node.children();
1935         XMLNodeIterator niter;
1936         uint32_t nchans = 1;
1937         XMLNode* capture_pending_node = 0;
1938         LocaleGuard lg (X_("POSIX"));
1939
1940         in_set_state = true;
1941
1942         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1943                 if ((*niter)->name() == IO::state_node_name) {
1944                         deprecated_io_node = new XMLNode (**niter);
1945                 }
1946
1947                 if ((*niter)->name() == X_("CapturingSources")) {
1948                         capture_pending_node = *niter;
1949                 }
1950         }
1951
1952         /* prevent write sources from being created */
1953
1954         in_set_state = true;
1955
1956         if ((prop = node.property ("name")) != 0) {
1957                 _name = prop->value();
1958         }
1959
1960         if (deprecated_io_node) {
1961                 if ((prop = deprecated_io_node->property ("id")) != 0) {
1962                         _id = prop->value ();
1963                 }
1964         } else {
1965                 if ((prop = node.property ("id")) != 0) {
1966                         _id = prop->value ();
1967                 }
1968         }
1969
1970         if ((prop = node.property ("flags")) != 0) {
1971                 _flags = Flag (string_2_enum (prop->value(), _flags));
1972         }
1973
1974         if ((prop = node.property ("channels")) != 0) {
1975                 nchans = atoi (prop->value().c_str());
1976         }
1977
1978         // create necessary extra channels
1979         // we are always constructed with one and we always need one
1980
1981         _n_channels = channels.reader()->size();
1982
1983         if (nchans > _n_channels) {
1984
1985                 add_channel (nchans - _n_channels);
1986                 IO::MoreOutputs(_n_channels);
1987
1988         } else if (nchans < _n_channels) {
1989
1990                 remove_channel (_n_channels - nchans);
1991         }
1992
1993         if ((prop = node.property ("playlist")) == 0) {
1994                 return -1;
1995         }
1996
1997         {
1998                 bool had_playlist = (_playlist != 0);
1999
2000                 if (find_and_use_playlist (prop->value())) {
2001                         return -1;
2002                 }
2003
2004                 if (!had_playlist) {
2005                         _playlist->set_orig_diskstream_id (_id);
2006                 }
2007
2008                 if (!destructive() && capture_pending_node) {
2009                         /* destructive streams have one and only one source per channel,
2010                            and so they never end up in pending capture in any useful
2011                            sense.
2012                         */
2013                         use_pending_capture_data (*capture_pending_node);
2014                 }
2015
2016         }
2017
2018         if ((prop = node.property ("speed")) != 0) {
2019                 double sp = atof (prop->value().c_str());
2020
2021                 if (realtime_set_speed (sp, false)) {
2022                         non_realtime_set_speed ();
2023                 }
2024         }
2025
2026         in_set_state = false;
2027
2028         /* make sure this is clear before we do anything else */
2029
2030         capturing_sources.clear ();
2031
2032         /* write sources are handled when we handle the input set
2033            up of the IO that owns this DS (::non_realtime_input_change())
2034         */
2035
2036         return 0;
2037 }
2038
2039 int
2040 AudioDiskstream::use_new_write_source (uint32_t n)
2041 {
2042         boost::shared_ptr<ChannelList> c = channels.reader();
2043
2044         if (!recordable()) {
2045                 return 1;
2046         }
2047
2048         if (n >= c->size()) {
2049                 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2050                 return -1;
2051         }
2052
2053         ChannelInfo* chan = (*c)[n];
2054
2055         if (chan->write_source) {
2056                 chan->write_source->done_with_peakfile_writes ();
2057                 chan->write_source->set_allow_remove_if_empty (true);
2058                 chan->write_source.reset ();
2059         }
2060
2061         try {
2062                 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2063                         throw failed_constructor();
2064                 }
2065         }
2066
2067         catch (failed_constructor &err) {
2068                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2069                 chan->write_source.reset ();
2070                 return -1;
2071         }
2072
2073         /* do not remove destructive files even if they are empty */
2074
2075         chan->write_source->set_allow_remove_if_empty (!destructive());
2076
2077         return 0;
2078 }
2079
2080 void
2081 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2082 {
2083         ChannelList::iterator chan;
2084         boost::shared_ptr<ChannelList> c = channels.reader();
2085         uint32_t n;
2086
2087         if (!recordable()) {
2088                 return;
2089         }
2090
2091         capturing_sources.clear ();
2092
2093         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2094                 if (!destructive()) {
2095
2096                         if ((*chan)->write_source && mark_write_complete) {
2097                                 (*chan)->write_source->mark_streaming_write_completed ();
2098                         }
2099                         use_new_write_source (n);
2100
2101                         if (record_enabled()) {
2102                                 capturing_sources.push_back ((*chan)->write_source);
2103                         }
2104
2105                 } else {
2106                         if ((*chan)->write_source == 0) {
2107                                 use_new_write_source (n);
2108                         }
2109                 }
2110         }
2111
2112         if (destructive()) {
2113
2114                 /* we now have all our write sources set up, so create the
2115                    playlist's single region.
2116                 */
2117
2118                 if (_playlist->empty()) {
2119                         setup_destructive_playlist ();
2120                 }
2121         }
2122 }
2123
2124 int
2125 AudioDiskstream::rename_write_sources ()
2126 {
2127         ChannelList::iterator chan;
2128         boost::shared_ptr<ChannelList> c = channels.reader();
2129         uint32_t n;
2130
2131         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2132                 if ((*chan)->write_source != 0) {
2133                         (*chan)->write_source->set_name (_name, destructive());
2134                         /* XXX what to do if one of them fails ? */
2135                 }
2136         }
2137
2138         return 0;
2139 }
2140
2141 void
2142 AudioDiskstream::set_block_size (nframes_t nframes)
2143 {
2144         if (_session.get_block_size() > speed_buffer_size) {
2145                 speed_buffer_size = _session.get_block_size();
2146                 boost::shared_ptr<ChannelList> c = channels.reader();
2147
2148                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2149                         if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
2150                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
2151                 }
2152         }
2153         allocate_temporary_buffers ();
2154 }
2155
2156 void
2157 AudioDiskstream::allocate_temporary_buffers ()
2158 {
2159         /* make sure the wrap buffer is at least large enough to deal
2160            with the speeds up to 1.2, to allow for micro-variation
2161            when slaving to MTC, SMPTE etc.
2162         */
2163
2164         double sp = max (fabsf (_actual_speed), 1.2f);
2165         nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2166
2167         if (required_wrap_size > wrap_buffer_size) {
2168
2169                 boost::shared_ptr<ChannelList> c = channels.reader();
2170
2171                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2172                         if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
2173                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2174                         if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
2175                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2176                 }
2177
2178                 wrap_buffer_size = required_wrap_size;
2179         }
2180 }
2181
2182 void
2183 AudioDiskstream::monitor_input (bool yn)
2184 {
2185         boost::shared_ptr<ChannelList> c = channels.reader();
2186
2187         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2188
2189                 if ((*chan)->source) {
2190                         (*chan)->source->ensure_monitor_input (yn);
2191                 }
2192         }
2193 }
2194
2195 void
2196 AudioDiskstream::set_align_style_from_io ()
2197 {
2198         bool have_physical = false;
2199
2200         if (_io == 0) {
2201                 return;
2202         }
2203
2204         get_input_sources ();
2205
2206         boost::shared_ptr<ChannelList> c = channels.reader();
2207
2208         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2209                 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2210                         have_physical = true;
2211                         break;
2212                 }
2213         }
2214
2215         if (have_physical) {
2216                 set_align_style (ExistingMaterial);
2217         } else {
2218                 set_align_style (CaptureTime);
2219         }
2220 }
2221
2222 int
2223 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2224 {
2225         while (how_many--) {
2226                 c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2227         }
2228
2229         _n_channels = c->size();
2230
2231         return 0;
2232 }
2233
2234 int
2235 AudioDiskstream::add_channel (uint32_t how_many)
2236 {
2237         RCUWriter<ChannelList> writer (channels);
2238         boost::shared_ptr<ChannelList> c = writer.get_copy();
2239
2240         return add_channel_to (c, how_many);
2241 }
2242
2243 int
2244 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2245 {
2246         while (--how_many && !c->empty()) {
2247                 delete c->back();
2248                 c->pop_back();
2249         }
2250
2251         _n_channels = c->size();
2252
2253         return 0;
2254 }
2255
2256 int
2257 AudioDiskstream::remove_channel (uint32_t how_many)
2258 {
2259         RCUWriter<ChannelList> writer (channels);
2260         boost::shared_ptr<ChannelList> c = writer.get_copy();
2261
2262         return remove_channel_from (c, how_many);
2263 }
2264
2265 float
2266 AudioDiskstream::playback_buffer_load () const
2267 {
2268         boost::shared_ptr<ChannelList> c = channels.reader();
2269
2270         return (float) ((double) c->front()->playback_buf->read_space()/
2271                         (double) c->front()->playback_buf->bufsize());
2272 }
2273
2274 float
2275 AudioDiskstream::capture_buffer_load () const
2276 {
2277         boost::shared_ptr<ChannelList> c = channels.reader();
2278
2279         return (float) ((double) c->front()->capture_buf->write_space()/
2280                         (double) c->front()->capture_buf->bufsize());
2281 }
2282
2283 int
2284 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2285 {
2286         const XMLProperty* prop;
2287         XMLNodeList nlist = node.children();
2288         XMLNodeIterator niter;
2289         boost::shared_ptr<AudioFileSource> fs;
2290         boost::shared_ptr<AudioFileSource> first_fs;
2291         SourceList pending_sources;
2292         nframes_t position;
2293
2294         if ((prop = node.property (X_("at"))) == 0) {
2295                 return -1;
2296         }
2297
2298         if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2299                 return -1;
2300         }
2301
2302         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2303                 if ((*niter)->name() == X_("file")) {
2304
2305                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2306                                 continue;
2307                         }
2308
2309                         // This protects sessions from errant CapturingSources in stored sessions
2310                         struct stat sbuf;
2311                         if (stat (prop->value().c_str(), &sbuf)) {
2312                                 continue;
2313                         }
2314
2315                         try {
2316                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (_session, prop->value(), false, _session.frame_rate()));
2317                         }
2318
2319                         catch (failed_constructor& err) {
2320                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2321                                                   _name, prop->value())
2322                                       << endmsg;
2323                                 return -1;
2324                         }
2325
2326                         pending_sources.push_back (fs);
2327
2328                         if (first_fs == 0) {
2329                                 first_fs = fs;
2330                         }
2331
2332                         fs->set_captured_for (_name);
2333                 }
2334         }
2335
2336         if (pending_sources.size() == 0) {
2337                 /* nothing can be done */
2338                 return 1;
2339         }
2340
2341         if (pending_sources.size() != _n_channels) {
2342                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2343                       << endmsg;
2344                 return -1;
2345         }
2346
2347         boost::shared_ptr<AudioRegion> region;
2348
2349         try {
2350                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
2351                                                                                           region_name_from_path (first_fs->name(), true),
2352                                                                                           0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
2353                 region->special_set_position (0);
2354         }
2355
2356         catch (failed_constructor& err) {
2357                 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2358                                   _name)
2359                       << endmsg;
2360
2361                 return -1;
2362         }
2363
2364         try {
2365                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
2366         }
2367
2368         catch (failed_constructor& err) {
2369                 error << string_compose (_("%1: cannot create region from pending capture sources"),
2370                                   _name)
2371                       << endmsg;
2372
2373                 return -1;
2374         }
2375
2376         _playlist->add_region (region, position);
2377
2378         return 0;
2379 }
2380
2381 int
2382 AudioDiskstream::set_destructive (bool yn)
2383 {
2384         bool bounce_ignored;
2385
2386         if (yn != destructive()) {
2387
2388                 if (yn) {
2389                         /* requestor should already have checked this and
2390                            bounced if necessary and desired
2391                         */
2392                         if (!can_become_destructive (bounce_ignored)) {
2393                                 return -1;
2394                         }
2395                         _flags = Flag (_flags | Destructive);
2396                         use_destructive_playlist ();
2397                 } else {
2398                         _flags = Flag (_flags & ~Destructive);
2399                         reset_write_sources (true, true);
2400                 }
2401         }
2402
2403         return 0;
2404 }
2405
2406 bool
2407 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2408 {
2409         if (!_playlist) {
2410                 requires_bounce = false;
2411                 return false;
2412         }
2413
2414         /* is there only one region ? */
2415
2416         if (_playlist->n_regions() != 1) {
2417                 requires_bounce = true;
2418                 return false;
2419         }
2420
2421         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2422         assert (first);
2423
2424         /* do the source(s) for the region cover the session start position ? */
2425
2426         if (first->position() != _session.current_start_frame()) {
2427                 if (first->start() > _session.current_start_frame()) {
2428                         requires_bounce = true;
2429                         return false;
2430                 }
2431         }
2432
2433         /* is the source used by only 1 playlist ? */
2434
2435         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2436
2437         assert (afirst);
2438
2439         if (afirst->source()->used() > 1) {
2440                 requires_bounce = true;
2441                 return false;
2442         }
2443
2444         requires_bounce = false;
2445         return true;
2446 }
2447
2448 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2449 {
2450         peak_power = 0.0f;
2451         source = 0;
2452         current_capture_buffer = 0;
2453         current_playback_buffer = 0;
2454         curr_capture_cnt = 0;
2455
2456         speed_buffer = new Sample[speed_size];
2457         playback_wrap_buffer = new Sample[wrap_size];
2458         capture_wrap_buffer = new Sample[wrap_size];
2459
2460         playback_buf = new RingBufferNPT<Sample> (bufsize);
2461         capture_buf = new RingBufferNPT<Sample> (bufsize);
2462         capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2463
2464         /* touch the ringbuffer buffers, which will cause
2465            them to be mapped into locked physical RAM if
2466            we're running with mlockall(). this doesn't do
2467            much if we're not.
2468         */
2469
2470         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2471         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2472         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2473 }
2474
2475 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2476 {
2477         if (write_source) {
2478                 write_source.reset ();
2479         }
2480
2481         if (speed_buffer) {
2482                 delete [] speed_buffer;
2483                 speed_buffer = 0;
2484         }
2485
2486         if (playback_wrap_buffer) {
2487                 delete [] playback_wrap_buffer;
2488                 playback_wrap_buffer = 0;
2489         }
2490
2491         if (capture_wrap_buffer) {
2492                 delete [] capture_wrap_buffer;
2493                 capture_wrap_buffer = 0;
2494         }
2495
2496         if (playback_buf) {
2497                 delete playback_buf;
2498                 playback_buf = 0;
2499         }
2500
2501         if (capture_buf) {
2502                 delete capture_buf;
2503                 capture_buf = 0;
2504         }
2505
2506         if (capture_transition_buf) {
2507                 delete capture_transition_buf;
2508                 capture_transition_buf = 0;
2509         }
2510 }