libs/ardour/diskstream.cc

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