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