libs/ardour/audio_track.cc

   1 /*
   2     Copyright (C) 2002 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
  20 #include <sigc++/retype.h>
  21 #include <sigc++/retype_return.h>
  22 #include <sigc++/bind.h>
  23
  24 #include "pbd/error.h"
  25 #include "pbd/enumwriter.h"
  26
  27 #include "evoral/Curve.hpp"
  28
  29 #include "ardour/audio_track.h"
  30 #include "ardour/audio_diskstream.h"
  31 #include "ardour/session.h"
  32 #include "ardour/io_processor.h"
  33 #include "ardour/audioregion.h"
  34 #include "ardour/audiosource.h"
  35 #include "ardour/region_factory.h"
  36 #include "ardour/route_group_specialized.h"
  37 #include "ardour/processor.h"
  38 #include "ardour/plugin_insert.h"
  39 #include "ardour/audioplaylist.h"
  40 #include "ardour/playlist_factory.h"
  41 #include "ardour/panner.h"
  42 #include "ardour/utils.h"
  43 #include "ardour/buffer_set.h"
  44 #include "ardour/audio_buffer.h"
  45 #include "i18n.h"
  46
  47 using namespace std;
  48 using namespace ARDOUR;
  49 using namespace PBD;
  50
  51 AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
  52         : Track (sess, name, flag, mode)
  53 {
  54         use_new_diskstream ();
  55 }
  56
  57 AudioTrack::AudioTrack (Session& sess, const XMLNode& node)
  58         : Track (sess, node)
  59 {
  60         _set_state (node, false);
  61 }
  62
  63 AudioTrack::~AudioTrack ()
  64 {
  65 }
  66
  67 void
  68 AudioTrack::use_new_diskstream ()
  69 {
  70         AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0);
  71
  72         if (_flags & Hidden) {
  73                 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden);
  74         } else {
  75                 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Recordable);
  76         }
  77
  78         if (_mode == Destructive) {
  79                 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive);
  80         }
  81
  82         boost::shared_ptr<AudioDiskstream> ds (new AudioDiskstream (_session, name(), dflags));
  83
  84         _session.add_diskstream (ds);
  85
  86         set_diskstream (boost::dynamic_pointer_cast<AudioDiskstream> (ds), this);
  87 }
  88
  89 int
  90 AudioTrack::set_mode (TrackMode m)
  91 {
  92         if (m != _mode) {
  93
  94                 if (_diskstream->set_destructive (m == Destructive)) {
  95                         return -1;
  96                 }
  97
  98                 _mode = m;
  99
 100                 TrackModeChanged (); /* EMIT SIGNAL */
 101         }
 102
 103         return 0;
 104 }
 105
 106 bool
 107 AudioTrack::can_use_mode (TrackMode m, bool& bounce_required)
 108 {
 109         switch (m) {
 110         case Normal:
 111                 bounce_required = false;
 112                 return true;
 113
 114         case Destructive:
 115         default:
 116                 return _diskstream->can_become_destructive (bounce_required);
 117         }
 118 }
 119
 120 int
 121 AudioTrack::deprecated_use_diskstream_connections ()
 122 {
 123         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 124
 125         if (diskstream->deprecated_io_node == 0) {
 126                 return 0;
 127         }
 128
 129         const XMLProperty* prop;
 130         XMLNode& node (*diskstream->deprecated_io_node);
 131
 132         /* don't do this more than once. */
 133
 134         diskstream->deprecated_io_node = 0;
 135
 136         set_input_minimum (ChanCount::ZERO);
 137         set_input_maximum (ChanCount::INFINITE);
 138         set_output_minimum (ChanCount::ZERO);
 139         set_output_maximum (ChanCount::INFINITE);
 140
 141         if ((prop = node.property ("gain")) != 0) {
 142                 set_gain (atof (prop->value().c_str()), this);
 143                 _gain = _desired_gain;
 144         }
 145
 146         if ((prop = node.property ("input-connection")) != 0) {
 147                 boost::shared_ptr<Bundle> c = _session.bundle_by_name (prop->value());
 148
 149                 if (c == 0) {
 150                         error << string_compose(_("Unknown bundle \"%1\" listed for input of %2"), prop->value(), _name) << endmsg;
 151
 152                         if ((c = _session.bundle_by_name (_("in 1"))) == 0) {
 153                                 error << _("No input bundles available as a replacement")
 154                                 << endmsg;
 155                                 return -1;
 156                         } else {
 157                                 info << string_compose (_("Bundle %1 was not available - \"in 1\" used instead"), prop->value())
 158                                << endmsg;
 159                         }
 160                 }
 161
 162                 connect_input_ports_to_bundle (c, this);
 163
 164         } else if ((prop = node.property ("inputs")) != 0) {
 165                 if (set_inputs (prop->value())) {
 166                         error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg;
 167                         return -1;
 168                 }
 169         }
 170
 171         return 0;
 172 }
 173
 174 int
 175 AudioTrack::set_diskstream (boost::shared_ptr<AudioDiskstream> ds, void *src)
 176 {
 177         _diskstream = ds;
 178         _diskstream->set_io (*this);
 179         _diskstream->set_destructive (_mode == Destructive);
 180
 181         if (audio_diskstream()->deprecated_io_node) {
 182
 183                 if (!connecting_legal) {
 184                         ConnectingLegal.connect (mem_fun (*this, &AudioTrack::deprecated_use_diskstream_connections));
 185                 } else {
 186                         deprecated_use_diskstream_connections ();
 187                 }
 188         }
 189
 190         _diskstream->set_record_enabled (false);
 191         _diskstream->monitor_input (false);
 192
 193         ic_connection.disconnect();
 194         ic_connection = input_changed.connect (mem_fun (*_diskstream, &Diskstream::handle_input_change));
 195
 196         DiskstreamChanged (); /* EMIT SIGNAL */
 197
 198         return 0;
 199 }
 200
 201 int
 202 AudioTrack::use_diskstream (string name)
 203 {
 204         boost::shared_ptr<AudioDiskstream> dstream;
 205
 206         if ((dstream = boost::dynamic_pointer_cast<AudioDiskstream>(_session.diskstream_by_name (name))) == 0) {
 207                 error << string_compose(_("AudioTrack: audio diskstream \"%1\" not known by session"), name) << endmsg;
 208                 return -1;
 209         }
 210
 211         return set_diskstream (dstream, this);
 212 }
 213
 214 int
 215 AudioTrack::use_diskstream (const PBD::ID& id)
 216 {
 217         boost::shared_ptr<AudioDiskstream> dstream;
 218
 219         if ((dstream = boost::dynamic_pointer_cast<AudioDiskstream> (_session.diskstream_by_id (id))) == 0) {
 220                 error << string_compose(_("AudioTrack: audio diskstream \"%1\" not known by session"), id) << endmsg;
 221                 return -1;
 222         }
 223
 224         return set_diskstream (dstream, this);
 225 }
 226
 227 boost::shared_ptr<AudioDiskstream>
 228 AudioTrack::audio_diskstream() const
 229 {
 230         return boost::dynamic_pointer_cast<AudioDiskstream>(_diskstream);
 231 }
 232
 233 int
 234 AudioTrack::set_state (const XMLNode& node)
 235 {
 236         return _set_state (node, true);
 237 }
 238
 239 int
 240 AudioTrack::_set_state (const XMLNode& node, bool call_base)
 241 {
 242         const XMLProperty *prop;
 243         XMLNodeConstIterator iter;
 244
 245         if (call_base) {
 246                 if (Route::_set_state (node, call_base)) {
 247                         return -1;
 248                 }
 249         }
 250
 251         if ((prop = node.property (X_("mode"))) != 0) {
 252                 _mode = TrackMode (string_2_enum (prop->value(), _mode));
 253         } else {
 254                 _mode = Normal;
 255         }
 256
 257         if ((prop = node.property ("diskstream-id")) == 0) {
 258
 259                 /* some old sessions use the diskstream name rather than the ID */
 260
 261                 if ((prop = node.property ("diskstream")) == 0) {
 262                         fatal << _("programming error: AudioTrack given state without diskstream!") << endmsg;
 263                         /*NOTREACHED*/
 264                         return -1;
 265                 }
 266
 267                 if (use_diskstream (prop->value())) {
 268                         return -1;
 269                 }
 270
 271         } else {
 272
 273                 PBD::ID id (prop->value());
 274                 PBD::ID zero ("0");
 275
 276                 /* this wierd hack is used when creating tracks from a template. there isn't
 277                    a particularly good time to interpose between setting the first part of
 278                    the track state (notably Route::set_state() and the track mode), and the
 279                    second part (diskstream stuff). So, we have a special ID for the diskstream
 280                    that means "you should create a new diskstream here, not look for
 281                    an old one.
 282                 */
 283
 284                 if (id == zero) {
 285                         use_new_diskstream ();
 286                 } else if (use_diskstream (id)) {
 287                         return -1;
 288                 }
 289         }
 290
 291
 292         XMLNodeList nlist;
 293         XMLNodeConstIterator niter;
 294         XMLNode *child;
 295
 296         nlist = node.children();
 297         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
 298                 child = *niter;
 299
 300                 if (child->name() == X_("recenable")) {
 301                         _rec_enable_control->set_state (*child);
 302                         _session.add_controllable (_rec_enable_control);
 303                 }
 304         }
 305
 306         pending_state = const_cast<XMLNode*> (&node);
 307
 308         if (_session.state_of_the_state() & Session::Loading) {
 309                 _session.StateReady.connect (mem_fun (*this, &AudioTrack::set_state_part_two));
 310         } else {
 311                 set_state_part_two ();
 312         }
 313
 314         return 0;
 315 }
 316
 317 XMLNode&
 318 AudioTrack::state(bool full_state)
 319 {
 320         XMLNode& root (Route::state(full_state));
 321         XMLNode* freeze_node;
 322         char buf[64];
 323
 324         if (_freeze_record.playlist) {
 325                 XMLNode* inode;
 326
 327                 freeze_node = new XMLNode (X_("freeze-info"));
 328                 freeze_node->add_property ("playlist", _freeze_record.playlist->name());
 329                 freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
 330
 331                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 332                         inode = new XMLNode (X_("processor"));
 333                         (*i)->id.print (buf, sizeof (buf));
 334                         inode->add_property (X_("id"), buf);
 335                         inode->add_child_copy ((*i)->state);
 336
 337                         freeze_node->add_child_nocopy (*inode);
 338                 }
 339
 340                 root.add_child_nocopy (*freeze_node);
 341         }
 342
 343         /* Alignment: act as a proxy for the diskstream */
 344
 345         XMLNode* align_node = new XMLNode (X_("Alignment"));
 346         AlignStyle as = _diskstream->alignment_style ();
 347         align_node->add_property (X_("style"), enum_2_string (as));
 348         root.add_child_nocopy (*align_node);
 349
 350         root.add_property (X_("mode"), enum_2_string (_mode));
 351
 352         /* we don't return diskstream state because we don't
 353            own the diskstream exclusively. control of the diskstream
 354            state is ceded to the Session, even if we create the
 355            diskstream.
 356         */
 357
 358         _diskstream->id().print (buf, sizeof (buf));
 359         root.add_property ("diskstream-id", buf);
 360
 361         root.add_child_nocopy (_rec_enable_control->get_state());
 362
 363         return root;
 364 }
 365
 366 void
 367 AudioTrack::set_state_part_two ()
 368 {
 369         XMLNode* fnode;
 370         XMLProperty* prop;
 371         LocaleGuard lg (X_("POSIX"));
 372
 373         /* This is called after all session state has been restored but before
 374            have been made ports and connections are established.
 375         */
 376
 377         if (pending_state == 0) {
 378                 return;
 379         }
 380
 381         if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
 382
 383                 _freeze_record.state = Frozen;
 384
 385                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 386                         delete *i;
 387                 }
 388                 _freeze_record.processor_info.clear ();
 389
 390                 if ((prop = fnode->property (X_("playlist"))) != 0) {
 391                         boost::shared_ptr<Playlist> pl = _session.playlist_by_name (prop->value());
 392                         if (pl) {
 393                                 _freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist> (pl);
 394                         } else {
 395                                 _freeze_record.playlist.reset ();
 396                                 _freeze_record.state = NoFreeze;
 397                         return;
 398                         }
 399                 }
 400
 401                 if ((prop = fnode->property (X_("state"))) != 0) {
 402                         _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
 403                 }
 404
 405                 XMLNodeConstIterator citer;
 406                 XMLNodeList clist = fnode->children();
 407
 408                 for (citer = clist.begin(); citer != clist.end(); ++citer) {
 409                         if ((*citer)->name() != X_("processor")) {
 410                                 continue;
 411                         }
 412
 413                         if ((prop = (*citer)->property (X_("id"))) == 0) {
 414                                 continue;
 415                         }
 416
 417                         FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
 418                                                                                    boost::shared_ptr<Processor>());
 419                         frii->id = prop->value ();
 420                         _freeze_record.processor_info.push_back (frii);
 421                 }
 422         }
 423
 424         /* Alignment: act as a proxy for the diskstream */
 425
 426         if ((fnode = find_named_node (*pending_state, X_("Alignment"))) != 0) {
 427
 428                 if ((prop = fnode->property (X_("style"))) != 0) {
 429
 430                         /* fix for older sessions from before EnumWriter */
 431
 432                         string pstr;
 433
 434                         if (prop->value() == "capture") {
 435                                 pstr = "CaptureTime";
 436                         } else if (prop->value() == "existing") {
 437                                 pstr = "ExistingMaterial";
 438                         } else {
 439                                 pstr = prop->value();
 440                         }
 441
 442                         AlignStyle as = AlignStyle (string_2_enum (pstr, as));
 443                         _diskstream->set_persistent_align_style (as);
 444                 }
 445         }
 446         return;
 447 }
 448
 449 int
 450 AudioTrack::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
 451                      bool session_state_changing, bool can_record, bool rec_monitors_input)
 452 {
 453         if (n_outputs().n_total() == 0) {
 454                 return 0;
 455         }
 456
 457         if (!_active) {
 458                 silence (nframes, offset);
 459                 return 0;
 460         }
 461
 462         if (session_state_changing) {
 463
 464                 /* XXX is this safe to do against transport state changes? */
 465
 466                 passthru_silence (start_frame, end_frame, nframes, offset, 0, false);
 467                 return 0;
 468         }
 469
 470         audio_diskstream()->check_record_status (start_frame, nframes, can_record);
 471
 472         bool send_silence;
 473
 474         if (_have_internal_generator) {
 475                 /* since the instrument has no input streams,
 476                    there is no reason to send any signal
 477                    into the route.
 478                 */
 479                 send_silence = true;
 480         } else {
 481
 482                 if (!Config->get_tape_machine_mode()) {
 483                         /*
 484                            ADATs work in a strange way..
 485                            they monitor input always when stopped.and auto-input is engaged.
 486                         */
 487                         if ((Config->get_monitoring_model() == SoftwareMonitoring) && (Config->get_auto_input () || _diskstream->record_enabled())) {
 488                                 send_silence = false;
 489                         } else {
 490                                 send_silence = true;
 491                         }
 492                 } else {
 493                         /*
 494                            Other machines switch to input on stop if the track is record enabled,
 495                            regardless of the auto input setting (auto input only changes the
 496                            monitoring state when the transport is rolling)
 497                         */
 498                         if ((Config->get_monitoring_model() == SoftwareMonitoring) && _diskstream->record_enabled()) {
 499                                 send_silence = false;
 500                         } else {
 501                                 send_silence = true;
 502                         }
 503                 }
 504         }
 505
 506         apply_gain_automation = false;
 507
 508         if (send_silence) {
 509
 510                 /* if we're sending silence, but we want the meters to show levels for the signal,
 511                    meter right here.
 512                 */
 513
 514                 if (_have_internal_generator) {
 515                         passthru_silence (start_frame, end_frame, nframes, offset, 0, true);
 516                 } else {
 517                         if (_meter_point == MeterInput) {
 518                                 just_meter_input (start_frame, end_frame, nframes, offset);
 519                         }
 520                         passthru_silence (start_frame, end_frame, nframes, offset, 0, false);
 521                 }
 522
 523         } else {
 524
 525                 /* we're sending signal, but we may still want to meter the input.
 526                  */
 527
 528                 passthru (start_frame, end_frame, nframes, offset, 0, (_meter_point == MeterInput));
 529         }
 530
 531         return 0;
 532 }
 533
 534 int
 535 AudioTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
 536                   bool can_record, bool rec_monitors_input)
 537 {
 538         int dret;
 539         Sample* b;
 540         Sample* tmpb;
 541         nframes_t transport_frame;
 542         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 543
 544         {
 545                 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 546                 if (lm.locked()) {
 547                         // automation snapshot can also be called from the non-rt context
 548                         // and it uses the redirect list, so we take the lock out here
 549                         automation_snapshot (start_frame, false);
 550                 }
 551         }
 552
 553
 554         if (n_outputs().n_total() == 0 && _processors.empty()) {
 555                 return 0;
 556         }
 557
 558         if (!_active) {
 559                 silence (nframes, offset);
 560                 return 0;
 561         }
 562
 563         transport_frame = _session.transport_frame();
 564
 565         prepare_inputs( nframes, offset );
 566
 567         if ((nframes = check_initial_delay (nframes, offset, transport_frame)) == 0) {
 568                 /* need to do this so that the diskstream sets its
 569                    playback distance to zero, thus causing diskstream::commit
 570                    to do nothing.
 571                 */
 572                 return diskstream->process (transport_frame, 0, 0, can_record, rec_monitors_input);
 573         }
 574
 575         _silent = false;
 576         apply_gain_automation = false;
 577
 578         if ((dret = diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) {
 579
 580                 silence (nframes, offset);
 581
 582                 return dret;
 583         }
 584
 585         /* special condition applies */
 586
 587         if (_meter_point == MeterInput) {
 588                 just_meter_input (start_frame, end_frame, nframes, offset);
 589         }
 590
 591         if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) {
 592
 593                 /* not actually recording, but we want to hear the input material anyway,
 594                    at least potentially (depending on monitoring options)
 595                  */
 596
 597                 passthru (start_frame, end_frame, nframes, offset, 0, true);
 598
 599         } else if ((b = diskstream->playback_buffer(0)) != 0) {
 600
 601                 /*
 602                   XXX is it true that the earlier test on n_outputs()
 603                   means that we can avoid checking it again here? i think
 604                   so, because changing the i/o configuration of an IO
 605                   requires holding the AudioEngine lock, which we hold
 606                   while in the process() tree.
 607                 */
 608
 609
 610                 /* copy the diskstream data to all output buffers */
 611
 612                 size_t limit = n_process_buffers().n_audio();
 613                 BufferSet& bufs = _session.get_scratch_buffers ();
 614                 const size_t blimit = bufs.count().n_audio();
 615
 616                 uint32_t n;
 617                 uint32_t i;
 618
 619                 if (limit > blimit) {
 620
 621                         /* example case: auditioner configured for stereo output,
 622                            but loaded with an 8 channel file. there are only
 623                            2 passthrough buffers, but n_process_buffers() will
 624                            return 8.
 625
 626                            arbitrary decision: map all channels in the diskstream
 627                            to the outputs available.
 628                         */
 629
 630                         float scaling = limit/blimit;
 631
 632                         for (i = 0, n = 1; i < blimit; ++i, ++n) {
 633
 634                                 /* first time through just copy a channel into
 635                                    the output buffer.
 636                                 */
 637
 638                                 Sample* bb = bufs.get_audio (i).data();
 639
 640                                 for (nframes_t xx = 0; xx < nframes; ++xx) {
 641                                         bb[xx] = b[xx] * scaling;
 642                                 }
 643
 644                                 if (n < diskstream->n_channels().n_audio()) {
 645                                         tmpb = diskstream->playback_buffer(n);
 646                                         if (tmpb!=0) {
 647                                                 b = tmpb;
 648                                         }
 649                                 }
 650                         }
 651
 652                         for (;i < limit; ++i, ++n) {
 653
 654                                 /* for all remaining channels, sum with existing
 655                                    data in the output buffers
 656                                 */
 657
 658                                 bufs.get_audio (i%blimit).accumulate_with_gain_from (b, nframes, 0, scaling);
 659
 660                                 if (n < diskstream->n_channels().n_audio()) {
 661                                         tmpb = diskstream->playback_buffer(n);
 662                                         if (tmpb!=0) {
 663                                                 b = tmpb;
 664                                         }
 665                                 }
 666
 667                         }
 668
 669                         limit = blimit;
 670
 671                 } else {
 672                         for (i = 0, n = 1; i < blimit; ++i, ++n) {
 673                                 memcpy (bufs.get_audio (i).data(), b, sizeof (Sample) * nframes);
 674                                 if (n < diskstream->n_channels().n_audio()) {
 675                                         tmpb = diskstream->playback_buffer(n);
 676                                         if (tmpb!=0) {
 677                                                 b = tmpb;
 678                                         }
 679                                 }
 680                         }
 681                 }
 682
 683                 /* don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
 684
 685                 if (!diskstream->record_enabled() && _session.transport_rolling()) {
 686                         Glib::Mutex::Lock am (data().control_lock(), Glib::TRY_LOCK);
 687
 688                         if (am.locked() && gain_control()->automation_playback()) {
 689                                 apply_gain_automation = gain_control()->list()->curve().rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
 690                         }
 691                 }
 692
 693                 process_output_buffers (bufs, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput));
 694
 695         } else {
 696                 /* problem with the diskstream; just be quiet for a bit */
 697                 silence (nframes, offset);
 698         }
 699
 700         return 0;
 701 }
 702
 703 int
 704 AudioTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
 705                          bool can_record, bool rec_monitors_input)
 706 {
 707         if (n_outputs().n_total() == 0 && _processors.empty()) {
 708                 return 0;
 709         }
 710
 711         if (!_active) {
 712                 silence (nframes, offset);
 713                 return 0;
 714         }
 715
 716         _silent = true;
 717         apply_gain_automation = false;
 718
 719         silence (nframes, offset);
 720
 721         return audio_diskstream()->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input);
 722 }
 723
 724 int
 725 AudioTrack::export_stuff (BufferSet& buffers, nframes_t start, nframes_t nframes)
 726 {
 727         gain_t  gain_automation[nframes];
 728         gain_t  gain_buffer[nframes];
 729         float   mix_buffer[nframes];
 730         ProcessorList::iterator i;
 731         bool post_fader_work = false;
 732         gain_t this_gain = _gain;
 733         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 734
 735         Glib::RWLock::ReaderLock rlock (_processor_lock);
 736
 737         boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist());
 738         assert(apl);
 739
 740         assert(buffers.get_audio(0).capacity() >= nframes);
 741
 742         if (apl->read (buffers.get_audio(0).data(), mix_buffer, gain_buffer, start, nframes) != nframes) {
 743                 return -1;
 744         }
 745
 746         assert(buffers.count().n_audio() >= 1);
 747         uint32_t n=1;
 748         Sample* b = buffers.get_audio(0).data();
 749         BufferSet::audio_iterator bi = buffers.audio_begin();
 750         ++bi;
 751         for ( ; bi != buffers.audio_end(); ++bi, ++n) {
 752                 if (n < diskstream->n_channels().n_audio()) {
 753                         if (apl->read (bi->data(), mix_buffer, gain_buffer, start, nframes, n) != nframes) {
 754                                 return -1;
 755                         }
 756                         b = bi->data();
 757                 }
 758                 else {
 759                         /* duplicate last across remaining buffers */
 760                         memcpy (bi->data(), b, sizeof (Sample) * nframes);
 761                 }
 762         }
 763
 764
 765         /* note: only run processors during export. other layers in the machinery
 766            will already have checked that there are no external port processors.
 767         */
 768
 769         for (i = _processors.begin(); i != _processors.end(); ++i) {
 770                 boost::shared_ptr<Processor> processor;
 771
 772                 if ((processor = boost::dynamic_pointer_cast<Processor>(*i)) != 0) {
 773                         switch (processor->placement()) {
 774                         case PreFader:
 775                                 processor->run_in_place (buffers, start, start+nframes, nframes, 0);
 776                                 break;
 777                         case PostFader:
 778                                 post_fader_work = true;
 779                                 break;
 780                         }
 781                 }
 782         }
 783
 784         if (gain_control()->automation_state() == Play) {
 785
 786                 gain_control()->list()->curve().get_vector (start, start + nframes, gain_automation, nframes);
 787
 788                 for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) {
 789                         Sample *b = bi->data();
 790                         for (nframes_t n = 0; n < nframes; ++n) {
 791                                 b[n] *= gain_automation[n];
 792                         }
 793                 }
 794
 795         } else {
 796
 797                 for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) {
 798                         Sample *b = bi->data();
 799                         for (nframes_t n = 0; n < nframes; ++n) {
 800                                 b[n] *= this_gain;
 801                         }
 802                 }
 803         }
 804
 805         if (post_fader_work) {
 806
 807                 for (i = _processors.begin(); i != _processors.end(); ++i) {
 808                         boost::shared_ptr<PluginInsert> processor;
 809
 810                         if ((processor = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 811                                 switch ((*i)->placement()) {
 812                                 case PreFader:
 813                                         break;
 814                                 case PostFader:
 815                                         processor->run_in_place (buffers, start, start+nframes, nframes, 0);
 816                                         break;
 817                                 }
 818                         }
 819                 }
 820         }
 821
 822         return 0;
 823 }
 824
 825 boost::shared_ptr<Region>
 826 AudioTrack::bounce (InterThreadInfo& itt)
 827 {
 828         vector<boost::shared_ptr<Source> > srcs;
 829         return _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), false, srcs, itt);
 830 }
 831
 832 boost::shared_ptr<Region>
 833 AudioTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt)
 834 {
 835         vector<boost::shared_ptr<Source> > srcs;
 836         return _session.write_one_track (*this, start, end, false, srcs, itt);
 837 }
 838
 839 void
 840 AudioTrack::freeze (InterThreadInfo& itt)
 841 {
 842         vector<boost::shared_ptr<Source> > srcs;
 843         string new_playlist_name;
 844         boost::shared_ptr<Playlist> new_playlist;
 845         string dir;
 846         string region_name;
 847         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 848
 849         if ((_freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist())) == 0) {
 850                 return;
 851         }
 852
 853         uint32_t n = 1;
 854
 855         while (n < (UINT_MAX-1)) {
 856
 857                 string candidate;
 858
 859                 candidate = string_compose ("<F%2>%1", _freeze_record.playlist->name(), n);
 860
 861                 if (_session.playlist_by_name (candidate) == 0) {
 862                         new_playlist_name = candidate;
 863                         break;
 864                 }
 865
 866                 ++n;
 867
 868         }
 869
 870         if (n == (UINT_MAX-1)) {
 871           error << string_compose (X_("There are too many frozen versions of playlist \"%1\""
 872                             " to create another one"), _freeze_record.playlist->name())
 873                << endmsg;
 874                 return;
 875         }
 876
 877         boost::shared_ptr<Region> res;
 878
 879         if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt)) == 0) {
 880                 return;
 881         }
 882
 883         _freeze_record.processor_info.clear ();
 884
 885         {
 886                 Glib::RWLock::ReaderLock lm (_processor_lock);
 887
 888                 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
 889
 890                         boost::shared_ptr<Processor> processor;
 891
 892                         if ((processor = boost::dynamic_pointer_cast<Processor>(*r)) != 0) {
 893
 894                                 FreezeRecordProcessorInfo* frii  = new FreezeRecordProcessorInfo ((*r)->get_state(), processor);
 895
 896                                 frii->id = processor->id();
 897
 898                                 _freeze_record.processor_info.push_back (frii);
 899
 900                                 /* now deactivate the processor */
 901
 902                                 processor->deactivate ();
 903                                 _session.set_dirty ();
 904                         }
 905                 }
 906         }
 907
 908         new_playlist = PlaylistFactory::create (DataType::AUDIO, _session, new_playlist_name, false);
 909
 910         _freeze_record.gain = _gain;
 911         _freeze_record.gain_automation_state = _gain_control->automation_state();
 912         _freeze_record.pan_automation_state = _panner->automation_state();
 913
 914         region_name = new_playlist_name;
 915
 916         /* create a new region from all filesources, keep it private */
 917
 918         boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0,
 919                         srcs[0]->length(srcs[0]->timeline_position()),
 920                         region_name, 0,
 921                         (Region::Flag) (Region::WholeFile|Region::DefaultFlags),
 922                         false));
 923
 924         new_playlist->set_orig_diskstream_id (diskstream->id());
 925         new_playlist->add_region (region, _session.current_start_frame());
 926         new_playlist->set_frozen (true);
 927         region->set_locked (true);
 928
 929         diskstream->use_playlist (boost::dynamic_pointer_cast<AudioPlaylist>(new_playlist));
 930         diskstream->set_record_enabled (false);
 931
 932         /* reset stuff that has already been accounted for in the freeze process */
 933
 934         set_gain (1.0, this);
 935         _gain_control->set_automation_state (Off);
 936         _panner->set_automation_state (Off);
 937
 938         _freeze_record.state = Frozen;
 939         FreezeChange(); /* EMIT SIGNAL */
 940 }
 941
 942 void
 943 AudioTrack::unfreeze ()
 944 {
 945         if (_freeze_record.playlist) {
 946                 audio_diskstream()->use_playlist (_freeze_record.playlist);
 947
 948                 {
 949                         Glib::RWLock::ReaderLock lm (_processor_lock); // should this be a write lock? jlc
 950                         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 951                                 for (vector<FreezeRecordProcessorInfo*>::iterator ii = _freeze_record.processor_info.begin(); ii != _freeze_record.processor_info.end(); ++ii) {
 952                                         if ((*ii)->id == (*i)->id()) {
 953                                                 (*i)->set_state (((*ii)->state));
 954                                                 break;
 955                                         }
 956                                 }
 957                         }
 958                 }
 959
 960                 _freeze_record.playlist.reset ();
 961                 set_gain (_freeze_record.gain, this);
 962                 _gain_control->set_automation_state (_freeze_record.gain_automation_state);
 963                 _panner->set_automation_state (_freeze_record.pan_automation_state);
 964         }
 965
 966         _freeze_record.state = UnFrozen;
 967         FreezeChange (); /* EMIT SIGNAL */
 968 }
 969