libs/ardour/audio_diskstream.cc

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