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& 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 (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            Note: it is a design assumption that disk_io_chunk_frames is smaller
1026            than the playback buffer size, so this check should never trip when
1027            the playback buffer is empty.
1028         */
1029
1030         if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1031                 return 0;
1032         }
1033
1034         /* when slaved, don't try to get too close to the read pointer. this
1035            leaves space for the buffer reversal to have something useful to
1036            work with.
1037         */
1038
1039         if (_slaved && total_space < (framecnt_t) (c->front()->playback_buf->bufsize() / 2)) {
1040                 return 0;
1041         }
1042
1043         /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1044
1045         total_space = min (disk_io_chunk_frames, total_space);
1046
1047         if (reversed) {
1048
1049                 if (file_frame == 0) {
1050
1051                         /* at start: nothing to do but fill with silence */
1052
1053                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1054
1055                                 ChannelInfo* chan (*i);
1056                                 chan->playback_buf->get_write_vector (&vector);
1057                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1058                                 if (vector.len[1]) {
1059                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1060                                 }
1061                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1062                         }
1063                         return 0;
1064                 }
1065
1066                 if (file_frame < total_space) {
1067
1068                         /* too close to the start: read what we can,
1069                            and then zero fill the rest
1070                         */
1071
1072                         zero_fill = total_space - file_frame;
1073                         total_space = file_frame;
1074
1075                 } else {
1076
1077                         zero_fill = 0;
1078                 }
1079
1080         } else {
1081
1082                 if (file_frame == max_framepos) {
1083
1084                         /* at end: nothing to do but fill with silence */
1085
1086                         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1087
1088                                 ChannelInfo* chan (*i);
1089                                 chan->playback_buf->get_write_vector (&vector);
1090                                 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1091                                 if (vector.len[1]) {
1092                                         memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1093                                 }
1094                                 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1095                         }
1096                         return 0;
1097                 }
1098
1099                 if (file_frame > max_framepos - total_space) {
1100
1101                         /* to close to the end: read what we can, and zero fill the rest */
1102
1103                         zero_fill = total_space - (max_framepos - file_frame);
1104                         total_space = max_framepos - file_frame;
1105
1106                 } else {
1107                         zero_fill = 0;
1108                 }
1109         }
1110
1111         framepos_t file_frame_tmp = 0;
1112
1113         for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1114
1115                 ChannelInfo* chan (*i);
1116                 Sample* buf1;
1117                 Sample* buf2;
1118                 framecnt_t len1, len2;
1119
1120                 chan->playback_buf->get_write_vector (&vector);
1121
1122                 if ((framecnt_t) vector.len[0] > disk_io_chunk_frames) {
1123
1124                         /* we're not going to fill the first chunk, so certainly do not bother with the
1125                            other part. it won't be connected with the part we do fill, as in:
1126
1127                            .... => writable space
1128                            ++++ => readable space
1129                            ^^^^ => 1 x disk_io_chunk_frames that would be filled
1130
1131                            |......|+++++++++++++|...............................|
1132                            buf1                buf0
1133                                                 ^^^^^^^^^^^^^^^
1134
1135
1136                            So, just pretend that the buf1 part isn't there.
1137
1138                         */
1139
1140                         vector.buf[1] = 0;
1141                         vector.len[1] = 0;
1142
1143                 }
1144
1145                 ts = total_space;
1146                 file_frame_tmp = file_frame;
1147
1148                 buf1 = vector.buf[0];
1149                 len1 = vector.len[0];
1150                 buf2 = vector.buf[1];
1151                 len2 = vector.len[1];
1152
1153                 to_read = min (ts, len1);
1154                 to_read = min (to_read, disk_io_chunk_frames);
1155
1156                 assert (to_read >= 0);
1157
1158                 if (to_read) {
1159
1160                         if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1161                                 ret = -1;
1162                                 goto out;
1163                         }
1164
1165                         chan->playback_buf->increment_write_ptr (to_read);
1166                         ts -= to_read;
1167                 }
1168
1169                 to_read = min (ts, len2);
1170
1171                 if (to_read) {
1172
1173                         /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1174                            so read some or all of vector.len[1] as well.
1175                         */
1176
1177                         if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1178                                 ret = -1;
1179                                 goto out;
1180                         }
1181
1182                         chan->playback_buf->increment_write_ptr (to_read);
1183                 }
1184
1185                 if (zero_fill) {
1186                         /* do something */
1187                 }
1188
1189         }
1190
1191         file_frame = file_frame_tmp;
1192         assert (file_frame >= 0);
1193
1194   out:
1195
1196         return ret;
1197 }
1198
1199 /** Flush pending data to disk.
1200  *
1201  * Important note: this function will write *AT MOST* disk_io_chunk_frames
1202  * of data to disk. it will never write more than that.  If it writes that
1203  * much and there is more than that waiting to be written, it will return 1,
1204  * otherwise 0 on success or -1 on failure.
1205  *
1206  * If there is less than disk_io_chunk_frames to be written, no data will be
1207  * written at all unless @a force_flush is true.
1208  */
1209 int
1210 AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
1211 {
1212         uint32_t to_write;
1213         int32_t ret = 0;
1214         RingBufferNPT<Sample>::rw_vector vector;
1215         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1216         framecnt_t total;
1217
1218         _write_data_count = 0;
1219
1220         transvec.buf[0] = 0;
1221         transvec.buf[1] = 0;
1222         vector.buf[0] = 0;
1223         vector.buf[1] = 0;
1224
1225         boost::shared_ptr<ChannelList> c = channels.reader();
1226         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1227
1228                 (*chan)->capture_buf->get_read_vector (&vector);
1229
1230                 total = vector.len[0] + vector.len[1];
1231
1232                 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1233                         goto out;
1234                 }
1235
1236                 /* if there are 2+ chunks of disk i/o possible for
1237                    this track, let the caller know so that it can arrange
1238                    for us to be called again, ASAP.
1239
1240                    if we are forcing a flush, then if there is* any* extra
1241                    work, let the caller know.
1242
1243                    if we are no longer recording and there is any extra work,
1244                    let the caller know too.
1245                 */
1246
1247                 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1248                         ret = 1;
1249                 }
1250
1251                 to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]);
1252
1253                 // check the transition buffer when recording destructive
1254                 // important that we get this after the capture buf
1255
1256                 if (destructive()) {
1257                         (*chan)->capture_transition_buf->get_read_vector(&transvec);
1258                         size_t transcount = transvec.len[0] + transvec.len[1];
1259                         size_t ti;
1260
1261                         for (ti=0; ti < transcount; ++ti) {
1262                                 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1263
1264                                 if (captrans.type == CaptureStart) {
1265                                         // by definition, the first data we got above represents the given capture pos
1266
1267                                         (*chan)->write_source->mark_capture_start (captrans.capture_val);
1268                                         (*chan)->curr_capture_cnt = 0;
1269
1270                                 } else if (captrans.type == CaptureEnd) {
1271
1272                                         // capture end, the capture_val represents total frames in capture
1273
1274                                         if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1275
1276                                                 // shorten to make the write a perfect fit
1277                                                 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1278
1279                                                 if (nto_write < to_write) {
1280                                                         ret = 1; // should we?
1281                                                 }
1282                                                 to_write = nto_write;
1283
1284                                                 (*chan)->write_source->mark_capture_end ();
1285
1286                                                 // increment past this transition, but go no further
1287                                                 ++ti;
1288                                                 break;
1289                                         }
1290                                         else {
1291                                                 // actually ends just beyond this chunk, so force more work
1292                                                 ret = 1;
1293                                                 break;
1294                                         }
1295                                 }
1296                         }
1297
1298                         if (ti > 0) {
1299                                 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1300                         }
1301                 }
1302
1303                 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1304                         error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1305                         return -1;
1306                 }
1307
1308                 (*chan)->capture_buf->increment_read_ptr (to_write);
1309                 (*chan)->curr_capture_cnt += to_write;
1310
1311                 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1312
1313                         /* we wrote all of vector.len[0] but it wasn't an entire
1314                            disk_io_chunk_frames of data, so arrange for some part
1315                            of vector.len[1] to be flushed to disk as well.
1316                         */
1317
1318                         to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1319
1320                         if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1321                                 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1322                                 return -1;
1323                         }
1324
1325                         _write_data_count += (*chan)->write_source->write_data_count();
1326
1327                         (*chan)->capture_buf->increment_read_ptr (to_write);
1328                         (*chan)->curr_capture_cnt += to_write;
1329                 }
1330         }
1331
1332   out:
1333         return ret;
1334 }
1335
1336 void
1337 AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1338 {
1339         uint32_t buffer_position;
1340         bool more_work = true;
1341         int err = 0;
1342         boost::shared_ptr<AudioRegion> region;
1343         framecnt_t total_capture;
1344         SourceList srcs;
1345         SourceList::iterator src;
1346         ChannelList::iterator chan;
1347         vector<CaptureInfo*>::iterator ci;
1348         boost::shared_ptr<ChannelList> c = channels.reader();
1349         uint32_t n = 0;
1350         bool mark_write_completed = false;
1351
1352         finish_capture (c);
1353
1354         /* butler is already stopped, but there may be work to do
1355            to flush remaining data to disk.
1356         */
1357
1358         while (more_work && !err) {
1359                 switch (do_flush (TransportContext, true)) {
1360                 case 0:
1361                         more_work = false;
1362                         break;
1363                 case 1:
1364                         break;
1365                 case -1:
1366                         error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1367                         err++;
1368                 }
1369         }
1370
1371         /* XXX is there anything we can do if err != 0 ? */
1372         Glib::Mutex::Lock lm (capture_info_lock);
1373
1374         if (capture_info.empty()) {
1375                 return;
1376         }
1377
1378         if (abort_capture) {
1379
1380                 if (destructive()) {
1381                         goto outout;
1382                 }
1383
1384                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1385
1386                         if ((*chan)->write_source) {
1387
1388                                 (*chan)->write_source->mark_for_remove ();
1389                                 (*chan)->write_source->drop_references ();
1390                                 (*chan)->write_source.reset ();
1391                         }
1392
1393                         /* new source set up in "out" below */
1394                 }
1395
1396                 goto out;
1397         }
1398
1399         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1400                 total_capture += (*ci)->frames;
1401         }
1402
1403         /* figure out the name for this take */
1404
1405         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1406
1407                 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1408
1409                 if (s) {
1410                         srcs.push_back (s);
1411                         s->update_header (capture_info.front()->start, when, twhen);
1412                         s->set_captured_for (_name.val());
1413                         s->mark_immutable ();
1414
1415                         if (Config->get_auto_analyse_audio()) {
1416                                 Analyser::queue_source_for_analysis (s, true);
1417                         }
1418                 }
1419         }
1420
1421         /* destructive tracks have a single, never changing region */
1422
1423         if (destructive()) {
1424
1425                 /* send a signal that any UI can pick up to do the right thing. there is
1426                    a small problem here in that a UI may need the peak data to be ready
1427                    for the data that was recorded and this isn't interlocked with that
1428                    process. this problem is deferred to the UI.
1429                  */
1430
1431                 _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
1432
1433         } else {
1434
1435                 string whole_file_region_name;
1436                 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1437
1438                 /* Register a new region with the Session that
1439                    describes the entire source. Do this first
1440                    so that any sub-regions will obviously be
1441                    children of this one (later!)
1442                 */
1443
1444                 try {
1445                         PropertyList plist;
1446
1447                         plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1448                         plist.add (Properties::length, total_capture);
1449                         plist.add (Properties::name, whole_file_region_name);
1450                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1451                         rx->set_automatic (true);
1452                         rx->set_whole_file (true);
1453
1454                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1455                         region->special_set_position (capture_info.front()->start);
1456                 }
1457
1458
1459                 catch (failed_constructor& err) {
1460                         error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1461                         /* XXX what now? */
1462                 }
1463
1464                 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1465
1466                 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1467
1468                 _playlist->clear_changes ();
1469                 _playlist->freeze ();
1470
1471                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1472
1473                         string region_name;
1474
1475                         RegionFactory::region_name (region_name, whole_file_region_name, false);
1476
1477                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1478                                                                               _name, (*ci)->start, (*ci)->frames, region_name));
1479
1480                         try {
1481
1482                                 PropertyList plist;
1483
1484                                 plist.add (Properties::start, buffer_position);
1485                                 plist.add (Properties::length, (*ci)->frames);
1486                                 plist.add (Properties::name, region_name);
1487
1488                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1489                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1490                         }
1491
1492                         catch (failed_constructor& err) {
1493                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1494                                 continue; /* XXX is this OK? */
1495                         }
1496
1497                         i_am_the_modifier++;
1498
1499                         if (_playlist->explicit_relayering()) {
1500                                 /* We are in `explicit relayering' mode, so we must specify which layer this new region
1501                                    should end up on.  Put it at the top.
1502                                 */
1503                                 region->set_layer (_playlist->top_layer() + 1);
1504                                 region->set_pending_explicit_relayer (true);
1505                         }
1506
1507                         _playlist->add_region (region, (*ci)->start, 1, non_layered());
1508                         i_am_the_modifier--;
1509
1510                         buffer_position += (*ci)->frames;
1511                 }
1512
1513                 _playlist->thaw ();
1514                 _session.add_command (new StatefulDiffCommand (_playlist));
1515         }
1516
1517         mark_write_completed = true;
1518
1519   out:
1520         reset_write_sources (mark_write_completed);
1521
1522   outout:
1523
1524         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1525                 delete *ci;
1526         }
1527
1528         capture_info.clear ();
1529         capture_start_frame = 0;
1530 }
1531
1532 void
1533 AudioDiskstream::transport_looped (framepos_t transport_frame)
1534 {
1535         if (was_recording) {
1536                 // all we need to do is finish this capture, with modified capture length
1537                 boost::shared_ptr<ChannelList> c = channels.reader();
1538
1539                 // adjust the capture length knowing that the data will be recorded to disk
1540                 // only necessary after the first loop where we're recording
1541                 if (capture_info.size() == 0) {
1542                         capture_captured += _capture_offset;
1543
1544                         if (_alignment_style == ExistingMaterial) {
1545                                 capture_captured += _session.worst_output_latency();
1546                         } else {
1547                                 capture_captured += _roll_delay;
1548                         }
1549                 }
1550
1551                 finish_capture (c);
1552
1553                 // the next region will start recording via the normal mechanism
1554                 // we'll set the start position to the current transport pos
1555                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1556                 capture_start_frame = transport_frame;
1557                 first_recordable_frame = transport_frame; // mild lie
1558                 last_recordable_frame = max_framepos;
1559                 was_recording = true;
1560
1561                 if (recordable() && destructive()) {
1562                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1563
1564                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1565                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1566
1567                                 if (transvec.len[0] > 0) {
1568                                         transvec.buf[0]->type = CaptureStart;
1569                                         transvec.buf[0]->capture_val = capture_start_frame;
1570                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1571                                 }
1572                                 else {
1573                                         // bad!
1574                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1575                                               << endmsg;
1576                                 }
1577                         }
1578                 }
1579
1580         }
1581 }
1582
1583 void
1584 AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)
1585 {
1586         was_recording = false;
1587         first_recordable_frame = max_framepos;
1588         last_recordable_frame = max_framepos;
1589
1590         if (capture_captured == 0) {
1591                 return;
1592         }
1593
1594         if (recordable() && destructive()) {
1595                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1596
1597                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
1598                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
1599
1600                         if (transvec.len[0] > 0) {
1601                                 transvec.buf[0]->type = CaptureEnd;
1602                                 transvec.buf[0]->capture_val = capture_captured;
1603                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
1604                         }
1605                         else {
1606                                 // bad!
1607                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
1608                         }
1609                 }
1610         }
1611
1612
1613         CaptureInfo* ci = new CaptureInfo;
1614
1615         ci->start =  capture_start_frame;
1616         ci->frames = capture_captured;
1617
1618         /* XXX theoretical race condition here. Need atomic exchange ?
1619            However, the circumstances when this is called right
1620            now (either on record-disable or transport_stopped)
1621            mean that no actual race exists. I think ...
1622            We now have a capture_info_lock, but it is only to be used
1623            to synchronize in the transport_stop and the capture info
1624            accessors, so that invalidation will not occur (both non-realtime).
1625         */
1626
1627         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1628
1629         capture_info.push_back (ci);
1630         capture_captured = 0;
1631
1632         /* now we've finished a capture, reset first_recordable_frame for next time */
1633         first_recordable_frame = max_framepos;
1634 }
1635
1636 void
1637 AudioDiskstream::set_record_enabled (bool yn)
1638 {
1639         if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1640                 return;
1641         }
1642
1643         /* can't rec-enable in destructive mode if transport is before start */
1644
1645         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1646                 return;
1647         }
1648
1649         /* yes, i know that this not proof against race conditions, but its
1650            good enough. i think.
1651         */
1652
1653         if (record_enabled() != yn) {
1654                 if (yn) {
1655                         engage_record_enable ();
1656                 } else {
1657                         disengage_record_enable ();
1658                 }
1659         }
1660 }
1661
1662 void
1663 AudioDiskstream::engage_record_enable ()
1664 {
1665         bool rolling = _session.transport_speed() != 0.0f;
1666         boost::shared_ptr<ChannelList> c = channels.reader();
1667
1668         g_atomic_int_set (&_record_enabled, 1);
1669         capturing_sources.clear ();
1670
1671         if (Config->get_monitoring_model() == HardwareMonitoring) {
1672
1673                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1674                         (*chan)->source.ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
1675                         capturing_sources.push_back ((*chan)->write_source);
1676                         (*chan)->write_source->mark_streaming_write_started ();
1677                 }
1678
1679         } else {
1680                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1681                         capturing_sources.push_back ((*chan)->write_source);
1682                         (*chan)->write_source->mark_streaming_write_started ();
1683                 }
1684         }
1685
1686         RecordEnableChanged (); /* EMIT SIGNAL */
1687 }
1688
1689 void
1690 AudioDiskstream::disengage_record_enable ()
1691 {
1692         g_atomic_int_set (&_record_enabled, 0);
1693         boost::shared_ptr<ChannelList> c = channels.reader();
1694         if (Config->get_monitoring_model() == HardwareMonitoring) {
1695                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1696                         (*chan)->source.ensure_monitor_input (false);
1697                 }
1698         }
1699         capturing_sources.clear ();
1700         RecordEnableChanged (); /* EMIT SIGNAL */
1701 }
1702
1703 XMLNode&
1704 AudioDiskstream::get_state ()
1705 {
1706         XMLNode& node (Diskstream::get_state());
1707         char buf[64] = "";
1708         LocaleGuard lg (X_("POSIX"));
1709
1710         boost::shared_ptr<ChannelList> c = channels.reader();
1711         snprintf (buf, sizeof(buf), "%zd", c->size());
1712         node.add_property ("channels", buf);
1713
1714         if (!capturing_sources.empty() && _session.get_record_enabled()) {
1715
1716                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1717                 XMLNode* cs_grandchild;
1718
1719                 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1720                         cs_grandchild = new XMLNode (X_("file"));
1721                         cs_grandchild->add_property (X_("path"), (*i)->path());
1722                         cs_child->add_child_nocopy (*cs_grandchild);
1723                 }
1724
1725                 /* store the location where capture will start */
1726
1727                 Location* pi;
1728
1729                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1730                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1731                 } else {
1732                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1733                 }
1734
1735                 cs_child->add_property (X_("at"), buf);
1736                 node.add_child_nocopy (*cs_child);
1737         }
1738
1739         return node;
1740 }
1741
1742 int
1743 AudioDiskstream::set_state (const XMLNode& node, int version)
1744 {
1745         const XMLProperty* prop;
1746         XMLNodeList nlist = node.children();
1747         XMLNodeIterator niter;
1748         uint32_t nchans = 1;
1749         XMLNode* capture_pending_node = 0;
1750         LocaleGuard lg (X_("POSIX"));
1751
1752         /* prevent write sources from being created */
1753
1754         in_set_state = true;
1755
1756         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1757                 if ((*niter)->name() == IO::state_node_name) {
1758                         deprecated_io_node = new XMLNode (**niter);
1759                 }
1760
1761                 if ((*niter)->name() == X_("CapturingSources")) {
1762                         capture_pending_node = *niter;
1763                 }
1764         }
1765
1766         if (Diskstream::set_state (node, version)) {
1767                 return -1;
1768         }
1769
1770         if ((prop = node.property ("channels")) != 0) {
1771                 nchans = atoi (prop->value().c_str());
1772         }
1773
1774         // create necessary extra channels
1775         // we are always constructed with one and we always need one
1776
1777         _n_channels.set(DataType::AUDIO, channels.reader()->size());
1778
1779         if (nchans > _n_channels.n_audio()) {
1780
1781                 add_channel (nchans - _n_channels.n_audio());
1782                 IO::PortCountChanged(_n_channels);
1783
1784         } else if (nchans < _n_channels.n_audio()) {
1785
1786                 remove_channel (_n_channels.n_audio() - nchans);
1787         }
1788
1789
1790
1791         if (!destructive() && capture_pending_node) {
1792                 /* destructive streams have one and only one source per channel,
1793                    and so they never end up in pending capture in any useful
1794                    sense.
1795                 */
1796                 use_pending_capture_data (*capture_pending_node);
1797         }
1798
1799         in_set_state = false;
1800
1801         /* make sure this is clear before we do anything else */
1802
1803         capturing_sources.clear ();
1804
1805         /* write sources are handled when we handle the input set
1806            up of the IO that owns this DS (::non_realtime_input_change())
1807         */
1808
1809         return 0;
1810 }
1811
1812 int
1813 AudioDiskstream::use_new_write_source (uint32_t n)
1814 {
1815         boost::shared_ptr<ChannelList> c = channels.reader();
1816
1817         if (!recordable()) {
1818                 return 1;
1819         }
1820
1821         if (n >= c->size()) {
1822                 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1823                 return -1;
1824         }
1825
1826         ChannelInfo* chan = (*c)[n];
1827
1828         try {
1829                 if ((chan->write_source = _session.create_audio_source_for_session (
1830                              n_channels().n_audio(), name(), n, destructive())) == 0) {
1831                         throw failed_constructor();
1832                 }
1833         }
1834
1835         catch (failed_constructor &err) {
1836                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1837                 chan->write_source.reset ();
1838                 return -1;
1839         }
1840
1841         /* do not remove destructive files even if they are empty */
1842
1843         chan->write_source->set_allow_remove_if_empty (!destructive());
1844
1845         return 0;
1846 }
1847
1848 list<boost::shared_ptr<Source> >
1849 AudioDiskstream::steal_write_sources()
1850 {
1851         /* not possible to steal audio write sources */
1852         list<boost::shared_ptr<Source> > ret;
1853         return ret;
1854 }
1855
1856 void
1857 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1858 {
1859         ChannelList::iterator chan;
1860         boost::shared_ptr<ChannelList> c = channels.reader();
1861         uint32_t n;
1862
1863         if (!_session.writable() || !recordable()) {
1864                 return;
1865         }
1866
1867         capturing_sources.clear ();
1868
1869         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1870
1871                 if (!destructive()) {
1872
1873                         if ((*chan)->write_source) {
1874
1875                                 if (mark_write_complete) {
1876                                         (*chan)->write_source->mark_streaming_write_completed ();
1877                                         (*chan)->write_source->done_with_peakfile_writes ();
1878                                 }
1879
1880                                 if ((*chan)->write_source->removable()) {
1881                                         (*chan)->write_source->mark_for_remove ();
1882                                         (*chan)->write_source->drop_references ();
1883                                 }
1884
1885                                 (*chan)->write_source.reset ();
1886                         }
1887
1888                         use_new_write_source (n);
1889
1890                         if (record_enabled()) {
1891                                 capturing_sources.push_back ((*chan)->write_source);
1892                         }
1893
1894                 } else {
1895
1896                         if ((*chan)->write_source == 0) {
1897                                 use_new_write_source (n);
1898                         }
1899                 }
1900         }
1901
1902         if (destructive() && !c->empty ()) {
1903
1904                 /* we now have all our write sources set up, so create the
1905                    playlist's single region.
1906                 */
1907
1908                 if (_playlist->empty()) {
1909                         setup_destructive_playlist ();
1910                 }
1911         }
1912 }
1913
1914 void
1915 AudioDiskstream::set_block_size (pframes_t /*nframes*/)
1916 {
1917         if (_session.get_block_size() > speed_buffer_size) {
1918                 speed_buffer_size = _session.get_block_size();
1919                 boost::shared_ptr<ChannelList> c = channels.reader();
1920
1921                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1922                         if ((*chan)->speed_buffer)
1923                                 delete [] (*chan)->speed_buffer;
1924                         (*chan)->speed_buffer = new Sample[speed_buffer_size];
1925                 }
1926         }
1927         allocate_temporary_buffers ();
1928 }
1929
1930 void
1931 AudioDiskstream::allocate_temporary_buffers ()
1932 {
1933         /* make sure the wrap buffer is at least large enough to deal
1934            with the speeds up to 1.2, to allow for micro-variation
1935            when slaving to MTC, Timecode etc.
1936         */
1937
1938         double const sp = max (fabsf (_actual_speed), 1.2f);
1939         framecnt_t required_wrap_size = (framecnt_t) floor (_session.get_block_size() * sp) + 1;
1940
1941         if (required_wrap_size > wrap_buffer_size) {
1942
1943                 boost::shared_ptr<ChannelList> c = channels.reader();
1944
1945                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1946                         if ((*chan)->playback_wrap_buffer)
1947                                 delete [] (*chan)->playback_wrap_buffer;
1948                         (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
1949                         if ((*chan)->capture_wrap_buffer)
1950                                 delete [] (*chan)->capture_wrap_buffer;
1951                         (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
1952                 }
1953
1954                 wrap_buffer_size = required_wrap_size;
1955         }
1956 }
1957
1958 void
1959 AudioDiskstream::monitor_input (bool yn)
1960 {
1961         boost::shared_ptr<ChannelList> c = channels.reader();
1962
1963         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1964                 (*chan)->source.ensure_monitor_input (yn);
1965         }
1966 }
1967
1968 void
1969 AudioDiskstream::set_align_style_from_io ()
1970 {
1971         bool have_physical = false;
1972
1973         if (_alignment_choice != Automatic) {
1974                 return;
1975         }
1976
1977         if (_io == 0) {
1978                 return;
1979         }
1980
1981         get_input_sources ();
1982
1983         boost::shared_ptr<ChannelList> c = channels.reader();
1984
1985         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1986                 if ((*chan)->source.is_physical ()) {
1987                         have_physical = true;
1988                         break;
1989                 }
1990         }
1991
1992         if (have_physical) {
1993                 set_align_style (ExistingMaterial);
1994         } else {
1995                 set_align_style (CaptureTime);
1996         }
1997 }
1998
1999 int
2000 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2001 {
2002         while (how_many--) {
2003                 c->push_back (new ChannelInfo(
2004                                       _session.butler()->audio_diskstream_playback_buffer_size(),
2005                                       _session.butler()->audio_diskstream_capture_buffer_size(),
2006                                       speed_buffer_size, wrap_buffer_size));
2007                 interpolation.add_channel_to (
2008                         _session.butler()->audio_diskstream_playback_buffer_size(),
2009                         speed_buffer_size);
2010         }
2011
2012         _n_channels.set(DataType::AUDIO, c->size());
2013
2014         return 0;
2015 }
2016
2017 int
2018 AudioDiskstream::add_channel (uint32_t how_many)
2019 {
2020         RCUWriter<ChannelList> writer (channels);
2021         boost::shared_ptr<ChannelList> c = writer.get_copy();
2022
2023         return add_channel_to (c, how_many);
2024 }
2025
2026 int
2027 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2028 {
2029         while (how_many-- && !c->empty()) {
2030                 delete c->back();
2031                 c->pop_back();
2032                 interpolation.remove_channel_from ();
2033         }
2034
2035         _n_channels.set(DataType::AUDIO, c->size());
2036
2037         return 0;
2038 }
2039
2040 int
2041 AudioDiskstream::remove_channel (uint32_t how_many)
2042 {
2043         RCUWriter<ChannelList> writer (channels);
2044         boost::shared_ptr<ChannelList> c = writer.get_copy();
2045
2046         return remove_channel_from (c, how_many);
2047 }
2048
2049 float
2050 AudioDiskstream::playback_buffer_load () const
2051 {
2052         boost::shared_ptr<ChannelList> c = channels.reader();
2053
2054         if (c->empty ()) {
2055                 return 0;
2056         }
2057
2058         return (float) ((double) c->front()->playback_buf->read_space()/
2059                         (double) c->front()->playback_buf->bufsize());
2060 }
2061
2062 float
2063 AudioDiskstream::capture_buffer_load () const
2064 {
2065         boost::shared_ptr<ChannelList> c = channels.reader();
2066
2067         if (c->empty ()) {
2068                 return 0;
2069         }
2070
2071         return (float) ((double) c->front()->capture_buf->write_space()/
2072                         (double) c->front()->capture_buf->bufsize());
2073 }
2074
2075 int
2076 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2077 {
2078         const XMLProperty* prop;
2079         XMLNodeList nlist = node.children();
2080         XMLNodeIterator niter;
2081         boost::shared_ptr<AudioFileSource> fs;
2082         boost::shared_ptr<AudioFileSource> first_fs;
2083         SourceList pending_sources;
2084         framepos_t position;
2085
2086         if ((prop = node.property (X_("at"))) == 0) {
2087                 return -1;
2088         }
2089
2090         if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
2091                 return -1;
2092         }
2093
2094         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2095                 if ((*niter)->name() == X_("file")) {
2096
2097                         if ((prop = (*niter)->property (X_("path"))) == 0) {
2098                                 continue;
2099                         }
2100
2101                         // This protects sessions from errant CapturingSources in stored sessions
2102                         struct stat sbuf;
2103                         if (stat (prop->value().c_str(), &sbuf)) {
2104                                 continue;
2105                         }
2106
2107                         try {
2108                                 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2109                                         SourceFactory::createWritable (
2110                                                 DataType::AUDIO, _session,
2111                                                 prop->value(), string(), false, _session.frame_rate()));
2112                         }
2113
2114                         catch (failed_constructor& err) {
2115                                 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2116                                                   _name, prop->value())
2117                                       << endmsg;
2118                                 return -1;
2119                         }
2120
2121                         pending_sources.push_back (fs);
2122
2123                         if (first_fs == 0) {
2124                                 first_fs = fs;
2125                         }
2126
2127                         fs->set_captured_for (_name.val());
2128                 }
2129         }
2130
2131         if (pending_sources.size() == 0) {
2132                 /* nothing can be done */
2133                 return 1;
2134         }
2135
2136         if (pending_sources.size() != _n_channels.n_audio()) {
2137                 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2138                       << endmsg;
2139                 return -1;
2140         }
2141
2142         boost::shared_ptr<AudioRegion> region;
2143
2144         try {
2145
2146                 PropertyList plist;
2147
2148                 plist.add (Properties::start, 0);
2149                 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2150                 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2151
2152                 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2153
2154                 region->set_automatic (true);
2155                 region->set_whole_file (true);
2156                 region->special_set_position (0);
2157         }
2158
2159         catch (failed_constructor& err) {
2160                 error << string_compose (
2161                                 _("%1: cannot create whole-file region from pending capture sources"),
2162                                 _name) << endmsg;
2163
2164                 return -1;
2165         }
2166
2167         _playlist->add_region (region, position);
2168
2169         return 0;
2170 }
2171
2172 int
2173 AudioDiskstream::set_non_layered (bool yn)
2174 {
2175         if (yn != non_layered()) {
2176
2177                 if (yn) {
2178                         _flags = Flag (_flags | NonLayered);
2179                 } else {
2180                         _flags = Flag (_flags & ~NonLayered);
2181                 }
2182         }
2183
2184         return 0;
2185 }
2186
2187 int
2188 AudioDiskstream::set_destructive (bool yn)
2189 {
2190         if (yn != destructive()) {
2191
2192                 if (yn) {
2193                         bool bounce_ignored;
2194                         /* requestor should already have checked this and
2195                            bounced if necessary and desired
2196                         */
2197                         if (!can_become_destructive (bounce_ignored)) {
2198                                 return -1;
2199                         }
2200                         _flags = Flag (_flags | Destructive);
2201                         use_destructive_playlist ();
2202                 } else {
2203                         _flags = Flag (_flags & ~Destructive);
2204                         reset_write_sources (true, true);
2205                 }
2206         }
2207
2208         return 0;
2209 }
2210
2211 bool
2212 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2213 {
2214         if (!_playlist) {
2215                 requires_bounce = false;
2216                 return false;
2217         }
2218
2219         /* is there only one region ? */
2220
2221         if (_playlist->n_regions() != 1) {
2222                 requires_bounce = true;
2223                 return false;
2224         }
2225
2226         boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2227         if (!first) {
2228                 requires_bounce = false;
2229                 return true;
2230         }
2231
2232         /* do the source(s) for the region cover the session start position ? */
2233
2234         if (first->position() != _session.current_start_frame()) {
2235                 if (first->start() > _session.current_start_frame()) {
2236                         requires_bounce = true;
2237                         return false;
2238                 }
2239         }
2240
2241         /* is the source used by only 1 playlist ? */
2242
2243         boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2244
2245         assert (afirst);
2246
2247         if (_session.playlists->source_use_count (afirst->source()) > 1) {
2248                 requires_bounce = true;
2249                 return false;
2250         }
2251
2252         requires_bounce = false;
2253         return true;
2254 }
2255
2256 void
2257 AudioDiskstream::adjust_playback_buffering ()
2258 {
2259         boost::shared_ptr<ChannelList> c = channels.reader();
2260
2261         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2262                 (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
2263         }
2264 }
2265
2266 void
2267 AudioDiskstream::adjust_capture_buffering ()
2268 {
2269         boost::shared_ptr<ChannelList> c = channels.reader();
2270
2271         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2272                 (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
2273         }
2274 }
2275
2276 bool
2277 AudioDiskstream::ChannelSource::is_physical () const
2278 {
2279         if (name.empty()) {
2280                 return false;
2281         }
2282
2283         return AudioEngine::instance()->port_is_physical (name);
2284 }
2285
2286 void
2287 AudioDiskstream::ChannelSource::ensure_monitor_input (bool yn) const
2288 {
2289         if (name.empty()) {
2290                 return;
2291         }
2292
2293         return AudioEngine::instance()->ensure_monitor_input (name, yn);
2294 }
2295
2296 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
2297 {
2298         peak_power = 0.0f;
2299         current_capture_buffer = 0;
2300         current_playback_buffer = 0;
2301         curr_capture_cnt = 0;
2302
2303         speed_buffer = new Sample[speed_size];
2304         playback_wrap_buffer = new Sample[wrap_size];
2305         capture_wrap_buffer = new Sample[wrap_size];
2306
2307         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2308         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2309         capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2310
2311         /* touch the ringbuffer buffers, which will cause
2312            them to be mapped into locked physical RAM if
2313            we're running with mlockall(). this doesn't do
2314            much if we're not.
2315         */
2316
2317         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2318         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2319         memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2320 }
2321
2322 void
2323 AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
2324 {
2325         delete playback_buf;
2326         playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2327         memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2328 }
2329
2330 void
2331 AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
2332 {
2333         delete capture_buf;
2334
2335         capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2336         memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2337 }
2338
2339 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2340 {
2341         write_source.reset ();
2342
2343         delete [] speed_buffer;
2344         speed_buffer = 0;
2345
2346         delete [] playback_wrap_buffer;
2347         playback_wrap_buffer = 0;
2348
2349         delete [] capture_wrap_buffer;
2350         capture_wrap_buffer = 0;
2351
2352         delete playback_buf;
2353         playback_buf = 0;
2354
2355         delete capture_buf;
2356         capture_buf = 0;
2357
2358         delete capture_transition_buf;
2359         capture_transition_buf = 0;
2360 }
2361
2362
2363 bool
2364 AudioDiskstream::set_name (string const & name)
2365 {
2366         Diskstream::set_name (name);
2367
2368         /* get a new write source so that its name reflects the new diskstream name */
2369
2370         boost::shared_ptr<ChannelList> c = channels.reader();
2371         ChannelList::iterator i;
2372         int n = 0;
2373
2374         for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2375                 use_new_write_source (n);
2376         }
2377
2378         return true;
2379 }