libs/ardour/audio_diskstream.cc

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