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