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
1514                         _playlist->add_region (region, (*ci)->start, 1, non_layered());
1515                         _playlist->set_layer (region, DBL_MAX);
1516                         i_am_the_modifier--;
1517
1518                         buffer_position += (*ci)->frames;
1519                 }
1520
1521                 _playlist->thaw ();
1522                 _session.add_command (new StatefulDiffCommand (_playlist));
1523         }
1524
1525         mark_write_completed = true;
1526
1527   out:
1528         reset_write_sources (mark_write_completed);
1529
1530   outout:
1531
1532         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1533                 delete *ci;
1534         }
1535
1536         capture_info.clear ();
1537         capture_start_frame = 0;
1538 }
1539
1540 void
1541 AudioDiskstream::transport_looped (framepos_t transport_frame)
1542 {
1543         if (was_recording) {
1544                 // all we need to do is finish this capture, with modified capture length
1545                 boost::shared_ptr<ChannelList> c = channels.reader();
1546
1547                 // adjust the capture length knowing that the data will be recorded to disk
1548                 // only necessary after the first loop where we're recording
1549                 if (capture_info.size() == 0) {
1550                         capture_captured += _capture_offset;
1551
1552                         if (_alignment_style == ExistingMaterial) {
1553                                 capture_captured += _session.worst_output_latency();
1554                         } else {
1555                                 capture_captured += _roll_delay;
1556                         }
1557                 }
1558
1559                 finish_capture (c);
1560
1561                 // the next region will start recording via the normal mechanism
1562                 // we'll set the start position to the current transport pos
1563                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1564                 capture_start_frame = transport_frame;
1565                 first_recordable_frame = transport_frame; // mild lie
1566                 last_recordable_frame = max_framepos;
1567                 was_recording = true;
1568
1569                 if (recordable() && destructive()) {
1570                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1571
1572                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1573                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1574
1575                                 if (transvec.len[0] > 0) {
1576                                         transvec.buf[0]->type = CaptureStart;
1577                                         transvec.buf[0]->capture_val = capture_start_frame;
1578                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1579                                 }
1580                                 else {
1581                                         // bad!
1582                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1583                                               << endmsg;
1584                                 }
1585                         }
1586                 }
1587
1588         }
1589 }
1590
1591 void
1592 AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)
1593 {
1594         was_recording = false;
1595         first_recordable_frame = max_framepos;
1596         last_recordable_frame = max_framepos;
1597
1598         if (capture_captured == 0) {
1599                 return;
1600         }
1601
1602         if (recordable() && destructive()) {
1603                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1604
1605                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1606                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
1607
1608                         if (transvec.len[0] > 0) {
1609                                 transvec.buf[0]->type = CaptureEnd;
1610                                 transvec.buf[0]->capture_val = capture_captured;
1611                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
1612                         }
1613                         else {
1614                                 // bad!
1615                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
1616                         }
1617                 }
1618         }
1619
1620
1621         CaptureInfo* ci = new CaptureInfo;
1622
1623         ci->start =  capture_start_frame;
1624         ci->frames = capture_captured;
1625
1626         /* XXX theoretical race condition here. Need atomic exchange ?
1627            However, the circumstances when this is called right
1628            now (either on record-disable or transport_stopped)
1629            mean that no actual race exists. I think ...
1630            We now have a capture_info_lock, but it is only to be used
1631            to synchronize in the transport_stop and the capture info
1632            accessors, so that invalidation will not occur (both non-realtime).
1633         */
1634
1635         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1636
1637         capture_info.push_back (ci);
1638         capture_captured = 0;
1639
1640         /* now we've finished a capture, reset first_recordable_frame for next time */
1641         first_recordable_frame = max_framepos;
1642 }
1643
1644 void
1645 AudioDiskstream::set_record_enabled (bool yn)
1646 {
1647         if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1648                 return;
1649         }
1650
1651         /* can't rec-enable in destructive mode if transport is before start */
1652
1653         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1654                 return;
1655         }
1656
1657         /* yes, i know that this not proof against race conditions, but its
1658            good enough. i think.
1659         */
1660
1661         if (record_enabled() != yn) {
1662                 if (yn) {
1663                         engage_record_enable ();
1664                 } else {
1665                         disengage_record_enable ();
1666                 }
1667         }
1668 }
1669
1670 void
1671 AudioDiskstream::engage_record_enable ()
1672 {
1673         bool rolling = _session.transport_speed() != 0.0f;
1674         boost::shared_ptr<ChannelList> c = channels.reader();
1675
1676         g_atomic_int_set (&_record_enabled, 1);
1677         capturing_sources.clear ();
1678
1679         if (Config->get_monitoring_model() == HardwareMonitoring) {
1680
1681                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1682                         (*chan)->source.request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
1683                         capturing_sources.push_back ((*chan)->write_source);
1684                         (*chan)->write_source->mark_streaming_write_started ();
1685                 }
1686
1687         } else {
1688                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1689                         capturing_sources.push_back ((*chan)->write_source);
1690                         (*chan)->write_source->mark_streaming_write_started ();
1691                 }
1692         }
1693
1694         RecordEnableChanged (); /* EMIT SIGNAL */
1695 }
1696
1697 void
1698 AudioDiskstream::disengage_record_enable ()
1699 {
1700         g_atomic_int_set (&_record_enabled, 0);
1701         boost::shared_ptr<ChannelList> c = channels.reader();
1702         if (Config->get_monitoring_model() == HardwareMonitoring) {
1703                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1704                         (*chan)->source.request_jack_monitors_input (false);
1705                 }
1706         }
1707         capturing_sources.clear ();
1708         RecordEnableChanged (); /* EMIT SIGNAL */
1709 }
1710
1711 XMLNode&
1712 AudioDiskstream::get_state ()
1713 {
1714         XMLNode& node (Diskstream::get_state());
1715         char buf[64] = "";
1716         LocaleGuard lg (X_("POSIX"));
1717
1718         boost::shared_ptr<ChannelList> c = channels.reader();
1719         snprintf (buf, sizeof(buf), "%zd", c->size());
1720         node.add_property ("channels", buf);
1721
1722         if (!capturing_sources.empty() && _session.get_record_enabled()) {
1723
1724                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1725                 XMLNode* cs_grandchild;
1726
1727                 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1728                         cs_grandchild = new XMLNode (X_("file"));
1729                         cs_grandchild->add_property (X_("path"), (*i)->path());
1730                         cs_child->add_child_nocopy (*cs_grandchild);
1731                 }
1732
1733                 /* store the location where capture will start */
1734
1735                 Location* pi;
1736
1737                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1738                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1739                 } else {
1740                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1741                 }
1742
1743                 cs_child->add_property (X_("at"), buf);
1744                 node.add_child_nocopy (*cs_child);
1745         }
1746
1747         return node;
1748 }
1749
1750 int
1751 AudioDiskstream::set_state (const XMLNode& node, int version)
1752 {
1753         const XMLProperty* prop;
1754         XMLNodeList nlist = node.children();
1755         XMLNodeIterator niter;
1756         uint32_t nchans = 1;
1757         XMLNode* capture_pending_node = 0;
1758         LocaleGuard lg (X_("POSIX"));
1759
1760         /* prevent write sources from being created */
1761
1762         in_set_state = true;
1763
1764         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1765                 if ((*niter)->name() == IO::state_node_name) {
1766                         deprecated_io_node = new XMLNode (**niter);
1767                 }
1768
1769                 if ((*niter)->name() == X_("CapturingSources")) {
1770                         capture_pending_node = *niter;
1771                 }
1772         }
1773
1774         if (Diskstream::set_state (node, version)) {
1775                 return -1;
1776         }
1777
1778         if ((prop = node.property ("channels")) != 0) {
1779                 nchans = atoi (prop->value().c_str());
1780         }
1781
1782         // create necessary extra channels
1783         // we are always constructed with one and we always need one
1784
1785         _n_channels.set(DataType::AUDIO, channels.reader()->size());
1786
1787         if (nchans > _n_channels.n_audio()) {
1788
1789                 add_channel (nchans - _n_channels.n_audio());
1790                 IO::PortCountChanged(_n_channels);
1791
1792         } else if (nchans < _n_channels.n_audio()) {
1793
1794                 remove_channel (_n_channels.n_audio() - nchans);
1795         }
1796
1797
1798
1799         if (!destructive() && capture_pending_node) {
1800                 /* destructive streams have one and only one source per channel,
1801                    and so they never end up in pending capture in any useful
1802                    sense.
1803                 */
1804                 use_pending_capture_data (*capture_pending_node);
1805         }
1806
1807         in_set_state = false;
1808
1809         /* make sure this is clear before we do anything else */
1810
1811         capturing_sources.clear ();
1812
1813         /* write sources are handled when we handle the input set
1814            up of the IO that owns this DS (::non_realtime_input_change())
1815         */
1816
1817         return 0;
1818 }
1819
1820 int
1821 AudioDiskstream::use_new_write_source (uint32_t n)
1822 {
1823         boost::shared_ptr<ChannelList> c = channels.reader();
1824
1825         if (!recordable()) {
1826                 return 1;
1827         }
1828
1829         if (n >= c->size()) {
1830                 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1831                 return -1;
1832         }
1833
1834         ChannelInfo* chan = (*c)[n];
1835
1836         try {
1837                 if ((chan->write_source = _session.create_audio_source_for_session (
1838                              n_channels().n_audio(), name(), n, destructive())) == 0) {
1839                         throw failed_constructor();
1840                 }
1841         }
1842
1843         catch (failed_constructor &err) {
1844                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1845                 chan->write_source.reset ();
1846                 return -1;
1847         }
1848
1849         /* do not remove destructive files even if they are empty */
1850
1851         chan->write_source->set_allow_remove_if_empty (!destructive());
1852
1853         return 0;
1854 }
1855
1856 list<boost::shared_ptr<Source> >
1857 AudioDiskstream::steal_write_sources()
1858 {
1859         /* not possible to steal audio write sources */
1860         list<boost::shared_ptr<Source> > ret;
1861         return ret;
1862 }
1863
1864 void
1865 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1866 {
1867         ChannelList::iterator chan;
1868         boost::shared_ptr<ChannelList> c = channels.reader();
1869         uint32_t n;
1870
1871         if (!_session.writable() || !recordable()) {
1872                 return;
1873         }
1874
1875         capturing_sources.clear ();
1876
1877         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1878
1879                 if (!destructive()) {
1880
1881                         if ((*chan)->write_source) {
1882
1883                                 if (mark_write_complete) {
1884                                         (*chan)->write_source->mark_streaming_write_completed ();
1885                                         (*chan)->write_source->done_with_peakfile_writes ();
1886                                 }
1887
1888                                 if ((*chan)->write_source->removable()) {
1889                                         (*chan)->write_source->mark_for_remove ();
1890                                         (*chan)->write_source->drop_references ();
1891                                 }
1892
1893                                 (*chan)->write_source.reset ();
1894                         }
1895
1896                         use_new_write_source (n);
1897
1898                         if (record_enabled()) {
1899                                 capturing_sources.push_back ((*chan)->write_source);
1900                         }
1901
1902                 } else {
1903
1904                         if ((*chan)->write_source == 0) {
1905                                 use_new_write_source (n);
1906                         }
1907                 }
1908         }
1909
1910         if (destructive() && !c->empty ()) {
1911
1912                 /* we now have all our write sources set up, so create the
1913                    playlist's single region.
1914                 */
1915
1916                 if (_playlist->empty()) {
1917                         setup_destructive_playlist ();
1918                 }
1919         }
1920 }
1921
1922 void
1923 AudioDiskstream::set_block_size (pframes_t /*nframes*/)
1924 {
1925         if (_session.get_block_size() > speed_buffer_size) {
1926                 speed_buffer_size = _session.get_block_size();
1927                 boost::shared_ptr<ChannelList> c = channels.reader();
1928
1929                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1930                         if ((*chan)->speed_buffer)
1931                                 delete [] (*chan)->speed_buffer;
1932                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
1933                 }
1934         }
1935         allocate_temporary_buffers ();
1936 }
1937
1938 void
1939 AudioDiskstream::allocate_temporary_buffers ()
1940 {
1941         /* make sure the wrap buffer is at least large enough to deal
1942            with the speeds up to 1.2, to allow for micro-variation
1943            when slaving to MTC, Timecode etc.
1944         */
1945
1946         double const sp = max (fabsf (_actual_speed), 1.2f);
1947         framecnt_t required_wrap_size = (framecnt_t) floor (_session.get_block_size() * sp) + 1;
1948
1949         if (required_wrap_size > wrap_buffer_size) {
1950
1951                 boost::shared_ptr<ChannelList> c = channels.reader();
1952
1953                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1954                         if ((*chan)->playback_wrap_buffer) {
1955                                 delete [] (*chan)->playback_wrap_buffer;
1956                         }
1957                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
1958                         if ((*chan)->capture_wrap_buffer) {
1959                                 delete [] (*chan)->capture_wrap_buffer;
1960                         }
1961                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
1962                 }
1963
1964                 wrap_buffer_size = required_wrap_size;
1965         }
1966 }
1967
1968 void
1969 AudioDiskstream::request_jack_monitors_input (bool yn)
1970 {
1971         boost::shared_ptr<ChannelList> c = channels.reader();
1972
1973         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1974                 (*chan)->source.request_jack_monitors_input (yn);
1975         }
1976 }
1977
1978 void
1979 AudioDiskstream::set_align_style_from_io ()
1980 {
1981         bool have_physical = false;
1982
1983         if (_alignment_choice != Automatic) {
1984                 return;
1985         }
1986
1987         if (_io == 0) {
1988                 return;
1989         }
1990
1991         get_input_sources ();
1992
1993         boost::shared_ptr<ChannelList> c = channels.reader();
1994
1995         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1996                 if ((*chan)->source.is_physical ()) {
1997                         have_physical = true;
1998                         break;
1999                 }
2000         }
2001
2002         if (have_physical) {
2003                 set_align_style (ExistingMaterial);
2004         } else {
2005                 set_align_style (CaptureTime);
2006         }
2007 }
2008
2009 int
2010 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2011 {
2012         while (how_many--) {
2013                 c->push_back (new ChannelInfo(
2014                                       _session.butler()->audio_diskstream_playback_buffer_size(),
2015                                       _session.butler()->audio_diskstream_capture_buffer_size(),
2016                                       speed_buffer_size, wrap_buffer_size));
2017                 interpolation.add_channel_to (
2018                         _session.butler()->audio_diskstream_playback_buffer_size(),
2019                         speed_buffer_size);
2020         }
2021
2022         _n_channels.set(DataType::AUDIO, c->size());
2023
2024         return 0;
2025 }
2026
2027 int
2028 AudioDiskstream::add_channel (uint32_t how_many)
2029 {
2030         RCUWriter<ChannelList> writer (channels);
2031         boost::shared_ptr<ChannelList> c = writer.get_copy();
2032
2033         return add_channel_to (c, how_many);
2034 }
2035
2036 int
2037 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2038 {
2039         while (how_many-- && !c->empty()) {
2040                 delete c->back();
2041                 c->pop_back();
2042                 interpolation.remove_channel_from ();
2043         }
2044
2045         _n_channels.set(DataType::AUDIO, c->size());
2046
2047         return 0;
2048 }
2049
2050 int
2051 AudioDiskstream::remove_channel (uint32_t how_many)
2052 {
2053         RCUWriter<ChannelList> writer (channels);
2054         boost::shared_ptr<ChannelList> c = writer.get_copy();
2055
2056         return remove_channel_from (c, how_many);
2057 }
2058
2059 float
2060 AudioDiskstream::playback_buffer_load () const
2061 {
2062         boost::shared_ptr<ChannelList> c = channels.reader();
2063
2064         if (c->empty ()) {
2065                 return 0;
2066         }
2067
2068         return (float) ((double) c->front()->playback_buf->read_space()/
2069                         (double) c->front()->playback_buf->bufsize());
2070 }
2071
2072 float
2073 AudioDiskstream::capture_buffer_load () const
2074 {
2075         boost::shared_ptr<ChannelList> c = channels.reader();
2076
2077         if (c->empty ()) {
2078                 return 0;
2079         }
2080
2081         return (float) ((double) c->front()->capture_buf->write_space()/
2082                         (double) c->front()->capture_buf->bufsize());
2083 }
2084
2085 int
2086 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2087 {
2088         const XMLProperty* prop;
2089         XMLNodeList nlist = node.children();
2090         XMLNodeIterator niter;
2091         boost::shared_ptr<AudioFileSource> fs;
2092         boost::shared_ptr<AudioFileSource> first_fs;
2093         SourceList pending_sources;
2094         framepos_t position;
2095
2096         if ((prop = node.property (X_("at"))) == 0) {
2097                 return -1;
2098         }
2099
2100         if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
2101                 return -1;
2102         }
2103
2104         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2105                 if ((*niter)->name() == X_("file")) {
2106
2107                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2108                                 continue;
2109                         }
2110
2111                         // This protects sessions from errant CapturingSources in stored sessions
2112                         struct stat sbuf;
2113                         if (stat (prop->value().c_str(), &sbuf)) {
2114                                 continue;
2115                         }
2116
2117                         try {
2118                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2119                                         SourceFactory::createWritable (
2120                                                 DataType::AUDIO, _session,
2121                                                 prop->value(), string(), false, _session.frame_rate()));
2122                         }
2123
2124                         catch (failed_constructor& err) {
2125                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2126                                                   _name, prop->value())
2127                                       << endmsg;
2128                                 return -1;
2129                         }
2130
2131                         pending_sources.push_back (fs);
2132
2133                         if (first_fs == 0) {
2134                                 first_fs = fs;
2135                         }
2136
2137                         fs->set_captured_for (_name.val());
2138                 }
2139         }
2140
2141         if (pending_sources.size() == 0) {
2142                 /* nothing can be done */
2143                 return 1;
2144         }
2145
2146         if (pending_sources.size() != _n_channels.n_audio()) {
2147                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2148                       << endmsg;
2149                 return -1;
2150         }
2151
2152         boost::shared_ptr<AudioRegion> region;
2153
2154         try {
2155
2156                 PropertyList plist;
2157
2158                 plist.add (Properties::start, 0);
2159                 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2160                 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2161
2162                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2163
2164                 region->set_automatic (true);
2165                 region->set_whole_file (true);
2166                 region->special_set_position (0);
2167         }
2168
2169         catch (failed_constructor& err) {
2170                 error << string_compose (
2171                                 _("%1: cannot create whole-file region from pending capture sources"),
2172                                 _name) << endmsg;
2173
2174                 return -1;
2175         }
2176
2177         _playlist->add_region (region, position);
2178
2179         return 0;
2180 }
2181
2182 int
2183 AudioDiskstream::set_non_layered (bool yn)
2184 {
2185         if (yn != non_layered()) {
2186
2187                 if (yn) {
2188                         _flags = Flag (_flags | NonLayered);
2189                 } else {
2190                         _flags = Flag (_flags & ~NonLayered);
2191                 }
2192         }
2193
2194         return 0;
2195 }
2196
2197 int
2198 AudioDiskstream::set_destructive (bool yn)
2199 {
2200         if (yn != destructive()) {
2201
2202                 if (yn) {
2203                         bool bounce_ignored;
2204                         /* requestor should already have checked this and
2205                            bounced if necessary and desired
2206                         */
2207                         if (!can_become_destructive (bounce_ignored)) {
2208                                 return -1;
2209                         }
2210                         _flags = Flag (_flags | Destructive);
2211                         use_destructive_playlist ();
2212                 } else {
2213                         _flags = Flag (_flags & ~Destructive);
2214                         reset_write_sources (true, true);
2215                 }
2216         }
2217
2218         return 0;
2219 }
2220
2221 bool
2222 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2223 {
2224         if (!_playlist) {
2225                 requires_bounce = false;
2226                 return false;
2227         }
2228
2229         /* is there only one region ? */
2230
2231         if (_playlist->n_regions() != 1) {
2232                 requires_bounce = true;
2233                 return false;
2234         }
2235
2236         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2237         if (!first) {
2238                 requires_bounce = false;
2239                 return true;
2240         }
2241
2242         /* do the source(s) for the region cover the session start position ? */
2243
2244         if (first->position() != _session.current_start_frame()) {
2245                 if (first->start() > _session.current_start_frame()) {
2246                         requires_bounce = true;
2247                         return false;
2248                 }
2249         }
2250
2251         /* is the source used by only 1 playlist ? */
2252
2253         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2254
2255         assert (afirst);
2256
2257         if (_session.playlists->source_use_count (afirst->source()) > 1) {
2258                 requires_bounce = true;
2259                 return false;
2260         }
2261
2262         requires_bounce = false;
2263         return true;
2264 }
2265
2266 void
2267 AudioDiskstream::adjust_playback_buffering ()
2268 {
2269         boost::shared_ptr<ChannelList> c = channels.reader();
2270
2271         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2272                 (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
2273         }
2274 }
2275
2276 void
2277 AudioDiskstream::adjust_capture_buffering ()
2278 {
2279         boost::shared_ptr<ChannelList> c = channels.reader();
2280
2281         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2282                 (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
2283         }
2284 }
2285
2286 bool
2287 AudioDiskstream::ChannelSource::is_physical () const
2288 {
2289         if (name.empty()) {
2290                 return false;
2291         }
2292
2293         return AudioEngine::instance()->port_is_physical (name);
2294 }
2295
2296 void
2297 AudioDiskstream::ChannelSource::request_jack_monitors_input (bool yn) const
2298 {
2299         if (name.empty()) {
2300                 return;
2301         }
2302
2303         return AudioEngine::instance()->request_jack_monitors_input (name, yn);
2304 }
2305
2306 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
2307 {
2308         current_capture_buffer = 0;
2309         current_playback_buffer = 0;
2310         curr_capture_cnt = 0;
2311
2312         speed_buffer = new Sample[speed_size];
2313         playback_wrap_buffer = new Sample[wrap_size];
2314         capture_wrap_buffer = new Sample[wrap_size];
2315
2316         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2317         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2318         capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2319
2320         /* touch the ringbuffer buffers, which will cause
2321            them to be mapped into locked physical RAM if
2322            we're running with mlockall(). this doesn't do
2323            much if we're not.
2324         */
2325
2326         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2327         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2328         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2329 }
2330
2331 void
2332 AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
2333 {
2334         delete playback_buf;
2335         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2336         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2337 }
2338
2339 void
2340 AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
2341 {
2342         delete capture_buf;
2343
2344         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2345         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2346 }
2347
2348 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2349 {
2350         write_source.reset ();
2351
2352         delete [] speed_buffer;
2353         speed_buffer = 0;
2354
2355         delete [] playback_wrap_buffer;
2356         playback_wrap_buffer = 0;
2357
2358         delete [] capture_wrap_buffer;
2359         capture_wrap_buffer = 0;
2360
2361         delete playback_buf;
2362         playback_buf = 0;
2363
2364         delete capture_buf;
2365         capture_buf = 0;
2366
2367         delete capture_transition_buf;
2368         capture_transition_buf = 0;
2369 }
2370
2371
2372 bool
2373 AudioDiskstream::set_name (string const & name)
2374 {
2375         Diskstream::set_name (name);
2376
2377         /* get a new write source so that its name reflects the new diskstream name */
2378
2379         boost::shared_ptr<ChannelList> c = channels.reader();
2380         ChannelList::iterator i;
2381         int n = 0;
2382
2383         for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2384                 use_new_write_source (n);
2385         }
2386
2387         return true;
2388 }