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