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         cerr << "AD::NRIC ... " << name() << endl;
 164
 165         {
 166                 Glib::Mutex::Lock lm (state_lock);
 167
 168                 if (input_change_pending == NoChange) {
 169                         return;
 170                 }
 171
 172                 {
 173                         RCUWriter<ChannelList> writer (channels);
 174                         boost::shared_ptr<ChannelList> c = writer.get_copy();
 175
 176                         _n_channels.set(DataType::AUDIO, c->size());
 177
 178                         if (_io->n_ports().n_audio() > _n_channels.n_audio()) {
 179                                 add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio());
 180                         } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) {
 181                                 remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
 182                         }
 183                 }
 184
 185                 get_input_sources ();
 186                 set_capture_offset ();
 187
 188                 if (first_input_change) {
 189                         set_align_style (_persistent_alignment_style);
 190                         first_input_change = false;
 191                 } else {
 192                         set_align_style_from_io ();
 193                 }
 194
 195                 input_change_pending = NoChange;
 196
 197                 /* implicit unlock */
 198         }
 199
 200         /* reset capture files */
 201
 202         reset_write_sources (false);
 203
 204         /* now refill channel buffers */
 205
 206         if (speed() != 1.0f || speed() != -1.0f) {
 207                 seek ((nframes_t) (_session.transport_frame() * (double) speed()));
 208         } else {
 209                 seek (_session.transport_frame());
 210         }
 211 }
 212
 213 void
 214 AudioDiskstream::non_realtime_locate (nframes_t location)
 215 {
 216         /* now refill channel buffers */
 217
 218         if (speed() != 1.0f || speed() != -1.0f) {
 219                 seek ((nframes_t) (location * (double) speed()));
 220         } else {
 221                 seek (location);
 222         }
 223 }
 224
 225 void
 226 AudioDiskstream::get_input_sources ()
 227 {
 228         boost::shared_ptr<ChannelList> c = channels.reader();
 229
 230         uint32_t n;
 231         ChannelList::iterator chan;
 232         uint32_t ni = _io->n_ports().n_audio();
 233         vector<string> connections;
 234
 235         for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
 236
 237                 connections.clear ();
 238
 239                 if (_io->nth (n)->get_connections (connections) == 0) {
 240
 241                         if ((*chan)->source) {
 242                                 // _source->disable_metering ();
 243                         }
 244
 245                         (*chan)->source = 0;
 246
 247                 } else {
 248                         (*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
 249                 }
 250         }
 251 }
 252
 253 int
 254 AudioDiskstream::find_and_use_playlist (const string& name)
 255 {
 256         boost::shared_ptr<AudioPlaylist> playlist;
 257
 258         if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
 259                 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
 260         }
 261
 262         if (!playlist) {
 263                 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
 264                 return -1;
 265         }
 266
 267         return use_playlist (playlist);
 268 }
 269
 270 int
 271 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 272 {
 273         assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
 274
 275         Diskstream::use_playlist(playlist);
 276
 277         return 0;
 278 }
 279
 280 int
 281 AudioDiskstream::use_new_playlist ()
 282 {
 283         string newname;
 284         boost::shared_ptr<AudioPlaylist> playlist;
 285
 286         if (!in_set_state && destructive()) {
 287                 return 0;
 288         }
 289
 290         if (_playlist) {
 291                 newname = Playlist::bump_name (_playlist->name(), _session);
 292         } else {
 293                 newname = Playlist::bump_name (_name, _session);
 294         }
 295
 296         if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
 297
 298                 playlist->set_orig_diskstream_id (id());
 299                 return use_playlist (playlist);
 300
 301         } else {
 302                 return -1;
 303         }
 304 }
 305
 306 int
 307 AudioDiskstream::use_copy_playlist ()
 308 {
 309         assert(audio_playlist());
 310
 311         if (destructive()) {
 312                 return 0;
 313         }
 314
 315         if (_playlist == 0) {
 316                 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 317                 return -1;
 318         }
 319
 320         string newname;
 321         boost::shared_ptr<AudioPlaylist> playlist;
 322
 323         newname = Playlist::bump_name (_playlist->name(), _session);
 324
 325         if ((playlist  = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
 326                 playlist->set_orig_diskstream_id (id());
 327                 return use_playlist (playlist);
 328         } else {
 329                 return -1;
 330         }
 331 }
 332
 333 void
 334 AudioDiskstream::setup_destructive_playlist ()
 335 {
 336         SourceList srcs;
 337         boost::shared_ptr<ChannelList> c = channels.reader();
 338
 339         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 340                 srcs.push_back ((*chan)->write_source);
 341         }
 342
 343         /* a single full-sized region */
 344
 345         boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
 346         _playlist->add_region (region, srcs.front()->natural_position());
 347 }
 348
 349 void
 350 AudioDiskstream::use_destructive_playlist ()
 351 {
 352         /* this is called from the XML-based constructor or ::set_destructive. when called,
 353            we already have a playlist and a region, but we need to
 354            set up our sources for write. we use the sources associated
 355            with the (presumed single, full-extent) region.
 356         */
 357
 358         boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
 359
 360         if (!rp) {
 361                 reset_write_sources (false, true);
 362                 return;
 363         }
 364
 365         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
 366
 367         if (region == 0) {
 368                 throw failed_constructor();
 369         }
 370
 371         /* be sure to stretch the region out to the maximum length */
 372
 373         region->set_length (max_frames - region->position(), this);
 374
 375         uint32_t n;
 376         ChannelList::iterator chan;
 377         boost::shared_ptr<ChannelList> c = channels.reader();
 378
 379         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 380                 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
 381                 assert((*chan)->write_source);
 382                 (*chan)->write_source->set_allow_remove_if_empty (false);
 383
 384                 /* this might be false if we switched modes, so force it */
 385
 386                 (*chan)->write_source->set_destructive (true);
 387         }
 388
 389         /* the source list will never be reset for a destructive track */
 390 }
 391
 392 void
 393 AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
 394 {
 395         int possibly_recording;
 396         int rolling;
 397         int change;
 398         const int transport_rolling = 0x4;
 399         const int track_rec_enabled = 0x2;
 400         const int global_rec_enabled = 0x1;
 401
 402         /* merge together the 3 factors that affect record status, and compute
 403            what has changed.
 404         */
 405
 406         rolling = _session.transport_speed() != 0.0f;
 407         possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
 408         change = possibly_recording ^ last_possibly_recording;
 409
 410         if (possibly_recording == last_possibly_recording) {
 411                 return;
 412         }
 413
 414         /* change state */
 415
 416         /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
 417
 418         if (((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record)) ||
 419             ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
 420
 421                 /* starting to record: compute first+last frames */
 422
 423                 first_recordable_frame = transport_frame + _capture_offset;
 424                 last_recordable_frame = max_frames;
 425                 capture_start_frame = transport_frame;
 426
 427                 if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
 428
 429                         /* was stopped, now rolling (and recording) */
 430
 431                         if (_alignment_style == ExistingMaterial) {
 432                                 first_recordable_frame += _session.worst_output_latency();
 433                         } else {
 434                                 first_recordable_frame += _roll_delay;
 435                         }
 436
 437                 } else {
 438
 439                         /* was rolling, but record state changed */
 440
 441                         if (_alignment_style == ExistingMaterial) {
 442
 443                                 if (!_session.config.get_punch_in()) {
 444
 445                                         /* manual punch in happens at the correct transport frame
 446                                            because the user hit a button. but to get alignment correct
 447                                            we have to back up the position of the new region to the
 448                                            appropriate spot given the roll delay.
 449                                         */
 450
 451                                         capture_start_frame -= _roll_delay;
 452
 453                                         /* XXX paul notes (august 2005): i don't know why
 454                                            this is needed.
 455                                         */
 456
 457                                         first_recordable_frame += _capture_offset;
 458
 459                                 } else {
 460
 461                                         /* autopunch toggles recording at the precise
 462                                            transport frame, and then the DS waits
 463                                            to start recording for a time that depends
 464                                            on the output latency.
 465                                         */
 466
 467                                         first_recordable_frame += _session.worst_output_latency();
 468                                 }
 469
 470                         } else {
 471
 472                                 if (_session.config.get_punch_in()) {
 473                                         first_recordable_frame += _roll_delay;
 474                                 } else {
 475                                         capture_start_frame -= _roll_delay;
 476                                 }
 477                         }
 478
 479                 }
 480
 481                 if (recordable() && destructive()) {
 482                         boost::shared_ptr<ChannelList> c = channels.reader();
 483                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 484
 485                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
 486                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
 487
 488                                 if (transvec.len[0] > 0) {
 489                                         transvec.buf[0]->type = CaptureStart;
 490                                         transvec.buf[0]->capture_val = capture_start_frame;
 491                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
 492                                 }
 493                                 else {
 494                                         // bad!
 495                                         fatal << X_("programming error: capture_transition_buf is full on rec start!  inconceivable!")
 496                                               << endmsg;
 497                                 }
 498                         }
 499                 }
 500
 501         } else if (!record_enabled() || !can_record) {
 502
 503                 /* stop recording */
 504
 505                 last_recordable_frame = transport_frame + _capture_offset;
 506
 507                 if (_alignment_style == ExistingMaterial) {
 508                         last_recordable_frame += _session.worst_output_latency();
 509                 } else {
 510                         last_recordable_frame += _roll_delay;
 511                 }
 512         }
 513
 514         last_possibly_recording = possibly_recording;
 515 }
 516
 517 int
 518 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
 519 {
 520         uint32_t n;
 521         boost::shared_ptr<ChannelList> c = channels.reader();
 522         ChannelList::iterator chan;
 523         int ret = -1;
 524         nframes_t rec_offset = 0;
 525         nframes_t rec_nframes = 0;
 526         bool nominally_recording;
 527         bool re = record_enabled ();
 528         bool collect_playback = false;
 529
 530         /* if we've already processed the frames corresponding to this call,
 531            just return. this allows multiple routes that are taking input
 532            from this diskstream to call our ::process() method, but have
 533            this stuff only happen once. more commonly, it allows both
 534            the AudioTrack that is using this AudioDiskstream *and* the Session
 535            to call process() without problems.
 536         */
 537
 538         if (_processed) {
 539                 return 0;
 540         }
 541
 542         commit_should_unlock = false;
 543
 544         if (!_io || !_io->active()) {
 545                 _processed = true;
 546                 return 0;
 547         }
 548
 549         check_record_status (transport_frame, nframes, can_record);
 550
 551         nominally_recording = (can_record && re);
 552
 553         if (nframes == 0) {
 554                 _processed = true;
 555                 return 0;
 556         }
 557
 558         /* This lock is held until the end of AudioDiskstream::commit, so these two functions
 559            must always be called as a pair. The only exception is if this function
 560            returns a non-zero value, in which case, ::commit should not be called.
 561         */
 562
 563         // If we can't take the state lock return.
 564         if (!state_lock.trylock()) {
 565                 return 1;
 566         }
 567         commit_should_unlock = true;
 568         adjust_capture_position = 0;
 569
 570         for (chan = c->begin(); chan != c->end(); ++chan) {
 571                 (*chan)->current_capture_buffer = 0;
 572                 (*chan)->current_playback_buffer = 0;
 573         }
 574
 575         if (nominally_recording || (_session.get_record_enabled() && _session.config.get_punch_in())) {
 576                 OverlapType ot;
 577
 578                 // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
 579                 if (last_recordable_frame < first_recordable_frame) {
 580                         last_recordable_frame = max_frames;
 581                 }
 582
 583                 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 584
 585                 switch (ot) {
 586                 case OverlapNone:
 587                         rec_nframes = 0;
 588                         break;
 589
 590                 case OverlapInternal:
 591                 /*     ----------    recrange
 592                          |---|       transrange
 593                 */
 594                         rec_nframes = nframes;
 595                         rec_offset = 0;
 596                         break;
 597
 598                 case OverlapStart:
 599                         /*    |--------|    recrange
 600                             -----|          transrange
 601                         */
 602                         rec_nframes = transport_frame + nframes - first_recordable_frame;
 603                         if (rec_nframes) {
 604                                 rec_offset = first_recordable_frame - transport_frame;
 605                         }
 606                         break;
 607
 608                 case OverlapEnd:
 609                         /*    |--------|    recrange
 610                                  |--------  transrange
 611                         */
 612                         rec_nframes = last_recordable_frame - transport_frame;
 613                         rec_offset = 0;
 614                         break;
 615
 616                 case OverlapExternal:
 617                         /*    |--------|    recrange
 618                             --------------  transrange
 619                         */
 620                         rec_nframes = last_recordable_frame - first_recordable_frame;
 621                         rec_offset = first_recordable_frame - transport_frame;
 622                         break;
 623                 }
 624
 625                 if (rec_nframes && !was_recording) {
 626                         capture_captured = 0;
 627                         was_recording = true;
 628                 }
 629         }
 630
 631
 632         if (can_record && !_last_capture_regions.empty()) {
 633                 _last_capture_regions.clear ();
 634         }
 635
 636         if (nominally_recording || rec_nframes) {
 637
 638                 uint32_t limit = _io->n_ports ().n_audio();
 639
 640                 /* one or more ports could already have been removed from _io, but our
 641                    channel setup hasn't yet been updated. prevent us from trying to
 642                    use channels that correspond to missing ports. note that the
 643                    process callback (from which this is called) is always atomic
 644                    with respect to port removal/addition.
 645                 */
 646
 647                 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
 648
 649                         ChannelInfo* chaninfo (*chan);
 650
 651                         chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
 652
 653                         if (rec_nframes <= chaninfo->capture_vector.len[0]) {
 654
 655                                 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
 656
 657                                 /* note: grab the entire port buffer, but only copy what we were supposed to
 658                                    for recording, and use rec_offset
 659                                 */
 660
 661                                 AudioPort* const ap = _io->audio (n);
 662                                 assert(ap);
 663                                 assert(rec_nframes <= ap->get_audio_buffer(nframes).capacity());
 664                                 memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (rec_nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
 665
 666
 667                         } else {
 668
 669                                 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
 670
 671                                 if (rec_nframes > total) {
 672                                         DiskOverrun ();
 673                                         goto out;
 674                                 }
 675
 676                                 AudioPort* const ap = _io->audio (n);
 677                                 assert(ap);
 678
 679                                 Sample* buf = ap->get_audio_buffer(nframes).data();
 680                                 nframes_t first = chaninfo->capture_vector.len[0];
 681
 682                                 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
 683                                 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
 684                                 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
 685                                 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
 686
 687                                 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
 688                         }
 689                 }
 690
 691         } else {
 692
 693                 if (was_recording) {
 694                         finish_capture (rec_monitors_input, c);
 695                 }
 696
 697         }
 698
 699         if (rec_nframes) {
 700
 701                 /* data will be written to disk */
 702
 703                 if (rec_nframes == nframes && rec_offset == 0) {
 704
 705                         for (chan = c->begin(); chan != c->end(); ++chan) {
 706                                 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 707                         }
 708
 709                         playback_distance = nframes;
 710
 711                 } else {
 712
 713
 714                         /* we can't use the capture buffer as the playback buffer, because
 715                            we recorded only a part of the current process' cycle data
 716                            for capture.
 717                         */
 718
 719                         collect_playback = true;
 720                 }
 721
 722                 adjust_capture_position = rec_nframes;
 723
 724         } else if (nominally_recording) {
 725
 726                 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
 727
 728                 for (chan = c->begin(); chan != c->end(); ++chan) {
 729                         (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
 730                 }
 731
 732                 playback_distance = nframes;
 733
 734         } else {
 735
 736                 collect_playback = true;
 737         }
 738
 739         if (collect_playback) {
 740
 741                 /* we're doing playback */
 742
 743                 nframes_t necessary_samples;
 744
 745                 /* no varispeed playback if we're recording, because the output .... TBD */
 746
 747                 if (rec_nframes == 0 && _actual_speed != 1.0f) {
 748                         necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
 749                 } else {
 750                         necessary_samples = nframes;
 751                 }
 752
 753                 for (chan = c->begin(); chan != c->end(); ++chan) {
 754                         (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
 755                 }
 756
 757                 n = 0;
 758
 759                 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
 760
 761                         ChannelInfo* chaninfo (*chan);
 762
 763                         if (necessary_samples <= chaninfo->playback_vector.len[0]) {
 764
 765                                 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
 766
 767                         } else {
 768                                 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
 769
 770                                 if (necessary_samples > total) {
 771                                         cerr << "underrun for " << _name << endl;
 772                                         DiskUnderrun ();
 773                                         goto out;
 774
 775                                 } else {
 776
 777                                         memcpy ((char *) chaninfo->playback_wrap_buffer,
 778                                                         chaninfo->playback_vector.buf[0],
 779                                                         chaninfo->playback_vector.len[0] * sizeof (Sample));
 780                                         memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
 781                                                         chaninfo->playback_vector.buf[1],
 782                                                         (necessary_samples - chaninfo->playback_vector.len[0])
 783                                                                         * sizeof (Sample));
 784
 785                                         chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
 786                                 }
 787                         }
 788                 }
 789
 790                 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
 791                         process_varispeed_playback(nframes, c);
 792                 } else {
 793                         playback_distance = nframes;
 794                 }
 795
 796                 _speed = _target_speed;
 797
 798         }
 799
 800         ret = 0;
 801
 802   out:
 803         _processed = true;
 804
 805         if (ret) {
 806
 807                 /* we're exiting with failure, so ::commit will not
 808                    be called. unlock the state lock.
 809                 */
 810
 811                 commit_should_unlock = false;
 812                 state_lock.unlock();
 813         }
 814
 815         return ret;
 816 }
 817
 818 void
 819 AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c)
 820 {
 821         ChannelList::iterator chan;
 822
 823         interpolation.set_target_speed (_target_speed);
 824         interpolation.set_speed (_speed);
 825
 826         for (chan = c->begin(); chan != c->end(); ++chan) {
 827                 ChannelInfo* chaninfo (*chan);
 828
 829                 playback_distance = interpolation.interpolate (
 830                                 nframes, 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), "%" PRIu32, 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         cerr << _name << " RWS!!!\n";
2069
2070         if (!recordable()) {
2071                 return;
2072         }
2073
2074         capturing_sources.clear ();
2075
2076         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2077                 if (!destructive()) {
2078
2079                         if ((*chan)->write_source && mark_write_complete) {
2080                                 (*chan)->write_source->mark_streaming_write_completed ();
2081                         }
2082                         use_new_write_source (n);
2083
2084                         if (record_enabled()) {
2085                                 capturing_sources.push_back ((*chan)->write_source);
2086                         }
2087
2088                 } else {
2089                         if ((*chan)->write_source == 0) {
2090                                 use_new_write_source (n);
2091                         }
2092                 }
2093         }
2094
2095         if (destructive()) {
2096
2097                 /* we now have all our write sources set up, so create the
2098                    playlist's single region.
2099                 */
2100
2101                 if (_playlist->empty()) {
2102                         setup_destructive_playlist ();
2103                 }
2104         }
2105 }
2106
2107 int
2108 AudioDiskstream::rename_write_sources ()
2109 {
2110         ChannelList::iterator chan;
2111         boost::shared_ptr<ChannelList> c = channels.reader();
2112         uint32_t n;
2113
2114         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2115                 if ((*chan)->write_source != 0) {
2116                         (*chan)->write_source->set_source_name (_name, destructive());
2117                         /* XXX what to do if one of them fails ? */
2118                 }
2119         }
2120
2121         return 0;
2122 }
2123
2124 void
2125 AudioDiskstream::set_block_size (nframes_t nframes)
2126 {
2127         if (_session.get_block_size() > speed_buffer_size) {
2128                 speed_buffer_size = _session.get_block_size();
2129                 boost::shared_ptr<ChannelList> c = channels.reader();
2130
2131                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2132                         if ((*chan)->speed_buffer)
2133                                 delete [] (*chan)->speed_buffer;
2134                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
2135                 }
2136         }
2137         allocate_temporary_buffers ();
2138 }
2139
2140 void
2141 AudioDiskstream::allocate_temporary_buffers ()
2142 {
2143         /* make sure the wrap buffer is at least large enough to deal
2144            with the speeds up to 1.2, to allow for micro-variation
2145            when slaving to MTC, SMPTE etc.
2146         */
2147
2148         double sp = max (fabsf (_actual_speed), 1.2f);
2149         nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2150
2151         if (required_wrap_size > wrap_buffer_size) {
2152
2153                 boost::shared_ptr<ChannelList> c = channels.reader();
2154
2155                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2156                         if ((*chan)->playback_wrap_buffer)
2157                                 delete [] (*chan)->playback_wrap_buffer;
2158                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2159                         if ((*chan)->capture_wrap_buffer)
2160                                 delete [] (*chan)->capture_wrap_buffer;
2161                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2162                 }
2163
2164                 wrap_buffer_size = required_wrap_size;
2165         }
2166 }
2167
2168 void
2169 AudioDiskstream::monitor_input (bool yn)
2170 {
2171         boost::shared_ptr<ChannelList> c = channels.reader();
2172
2173         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2174
2175                 if ((*chan)->source) {
2176                         (*chan)->source->ensure_monitor_input (yn);
2177                 }
2178         }
2179 }
2180
2181 void
2182 AudioDiskstream::set_align_style_from_io ()
2183 {
2184         bool have_physical = false;
2185
2186         if (_io == 0) {
2187                 return;
2188         }
2189
2190         get_input_sources ();
2191
2192         boost::shared_ptr<ChannelList> c = channels.reader();
2193
2194         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2195                 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2196                         have_physical = true;
2197                         break;
2198                 }
2199         }
2200
2201         if (have_physical) {
2202                 set_align_style (ExistingMaterial);
2203         } else {
2204                 set_align_style (CaptureTime);
2205         }
2206 }
2207
2208 int
2209 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2210 {
2211         while (how_many--) {
2212                 c->push_back (new ChannelInfo(_session.audio_diskstream_buffer_size(), speed_buffer_size, wrap_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                 //delete c->back(); // FIXME: crash (thread safe with RCU?)
2234                 c->pop_back();
2235         }
2236
2237         _n_channels.set(DataType::AUDIO, c->size());
2238
2239         return 0;
2240 }
2241
2242 int
2243 AudioDiskstream::remove_channel (uint32_t how_many)
2244 {
2245         RCUWriter<ChannelList> writer (channels);
2246         boost::shared_ptr<ChannelList> c = writer.get_copy();
2247
2248         return remove_channel_from (c, how_many);
2249 }
2250
2251 float
2252 AudioDiskstream::playback_buffer_load () const
2253 {
2254         boost::shared_ptr<ChannelList> c = channels.reader();
2255
2256         return (float) ((double) c->front()->playback_buf->read_space()/
2257                         (double) c->front()->playback_buf->bufsize());
2258 }
2259
2260 float
2261 AudioDiskstream::capture_buffer_load () const
2262 {
2263         boost::shared_ptr<ChannelList> c = channels.reader();
2264
2265         return (float) ((double) c->front()->capture_buf->write_space()/
2266                         (double) c->front()->capture_buf->bufsize());
2267 }
2268
2269 int
2270 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2271 {
2272         const XMLProperty* prop;
2273         XMLNodeList nlist = node.children();
2274         XMLNodeIterator niter;
2275         boost::shared_ptr<AudioFileSource> fs;
2276         boost::shared_ptr<AudioFileSource> first_fs;
2277         SourceList pending_sources;
2278         nframes_t position;
2279
2280         if ((prop = node.property (X_("at"))) == 0) {
2281                 return -1;
2282         }
2283
2284         if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2285                 return -1;
2286         }
2287
2288         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2289                 if ((*niter)->name() == X_("file")) {
2290
2291                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2292                                 continue;
2293                         }
2294
2295                         // This protects sessions from errant CapturingSources in stored sessions
2296                         struct stat sbuf;
2297                         if (stat (prop->value().c_str(), &sbuf)) {
2298                                 continue;
2299                         }
2300
2301                         try {
2302                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2303                                                 SourceFactory::createWritable (DataType::AUDIO, _session,
2304                                                                 prop->value(), true,
2305                                                                 false, _session.frame_rate()));
2306                         }
2307
2308                         catch (failed_constructor& err) {
2309                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2310                                                   _name, prop->value())
2311                                       << endmsg;
2312                                 return -1;
2313                         }
2314
2315                         pending_sources.push_back (fs);
2316
2317                         if (first_fs == 0) {
2318                                 first_fs = fs;
2319                         }
2320
2321                         fs->set_captured_for (_name);
2322                 }
2323         }
2324
2325         if (pending_sources.size() == 0) {
2326                 /* nothing can be done */
2327                 return 1;
2328         }
2329
2330         if (pending_sources.size() != _n_channels.n_audio()) {
2331                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2332                       << endmsg;
2333                 return -1;
2334         }
2335
2336         boost::shared_ptr<AudioRegion> region;
2337
2338         try {
2339                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
2340                                 pending_sources, 0, first_fs->length(first_fs->timeline_position()),
2341                                 region_name_from_path (first_fs->name(), true), 0,
2342                                 Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
2343                 region->special_set_position (0);
2344         }
2345
2346         catch (failed_constructor& err) {
2347                 error << string_compose (
2348                                 _("%1: cannot create whole-file region from pending capture sources"),
2349                                 _name) << endmsg;
2350
2351                 return -1;
2352         }
2353
2354         try {
2355                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
2356                                 pending_sources, 0, first_fs->length(first_fs->timeline_position()),
2357                                 region_name_from_path (first_fs->name(), true)));
2358         }
2359
2360         catch (failed_constructor& err) {
2361                 error << string_compose (_("%1: cannot create region from pending capture sources"),
2362                                   _name)
2363                       << endmsg;
2364
2365                 return -1;
2366         }
2367
2368         _playlist->add_region (region, position);
2369
2370         return 0;
2371 }
2372
2373 int
2374 AudioDiskstream::set_non_layered (bool yn)
2375 {
2376         if (yn != non_layered()) {
2377
2378                 if (yn) {
2379                         _flags = Flag (_flags | NonLayered);
2380                 } else {
2381                         _flags = Flag (_flags & ~NonLayered);
2382                 }
2383         }
2384
2385         return 0;
2386 }
2387
2388 int
2389 AudioDiskstream::set_destructive (bool yn)
2390 {
2391         bool bounce_ignored;
2392
2393         if (yn != destructive()) {
2394
2395                 if (yn) {
2396                         /* requestor should already have checked this and
2397                            bounced if necessary and desired
2398                         */
2399                         if (!can_become_destructive (bounce_ignored)) {
2400                                 return -1;
2401                         }
2402                         _flags = Flag (_flags | Destructive);
2403                         use_destructive_playlist ();
2404                 } else {
2405                         _flags = Flag (_flags & ~Destructive);
2406                         reset_write_sources (true, true);
2407                 }
2408         }
2409
2410         return 0;
2411 }
2412
2413 bool
2414 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2415 {
2416         if (!_playlist) {
2417                 requires_bounce = false;
2418                 return false;
2419         }
2420
2421         /* is there only one region ? */
2422
2423         if (_playlist->n_regions() != 1) {
2424                 requires_bounce = true;
2425                 return false;
2426         }
2427
2428         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2429         assert (first);
2430
2431         /* do the source(s) for the region cover the session start position ? */
2432
2433         if (first->position() != _session.current_start_frame()) {
2434                 if (first->start() > _session.current_start_frame()) {
2435                         requires_bounce = true;
2436                         return false;
2437                 }
2438         }
2439
2440         /* is the source used by only 1 playlist ? */
2441
2442         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2443
2444         assert (afirst);
2445
2446         if (afirst->source()->used() > 1) {
2447                 requires_bounce = true;
2448                 return false;
2449         }
2450
2451         requires_bounce = false;
2452         return true;
2453 }
2454
2455 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2456 {
2457         peak_power = 0.0f;
2458         source = 0;
2459         current_capture_buffer = 0;
2460         current_playback_buffer = 0;
2461         curr_capture_cnt = 0;
2462
2463         speed_buffer = new Sample[speed_size];
2464         playback_wrap_buffer = new Sample[wrap_size];
2465         capture_wrap_buffer = new Sample[wrap_size];
2466
2467         playback_buf = new RingBufferNPT<Sample> (bufsize);
2468         capture_buf = new RingBufferNPT<Sample> (bufsize);
2469         capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2470
2471         /* touch the ringbuffer buffers, which will cause
2472            them to be mapped into locked physical RAM if
2473            we're running with mlockall(). this doesn't do
2474            much if we're not.
2475         */
2476
2477         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2478         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2479         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2480 }
2481
2482 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2483 {
2484         if (write_source) {
2485                 write_source.reset ();
2486         }
2487
2488         delete [] speed_buffer;
2489         speed_buffer = 0;
2490
2491         delete [] playback_wrap_buffer;
2492         playback_wrap_buffer = 0;
2493
2494         delete [] capture_wrap_buffer;
2495         capture_wrap_buffer = 0;
2496
2497         delete playback_buf;
2498         playback_buf = 0;
2499
2500         delete capture_buf;
2501         capture_buf = 0;
2502
2503         delete capture_transition_buf;
2504         capture_transition_buf = 0;
2505 }