libs/ardour/audio_diskstream.cc

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