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 <boost/scoped_array.hpp>
  21
  22 #include "pbd/error.h"
  23 #include "pbd/enumwriter.h"
  24 #include "pbd/boost_debug.h"
  25
  26 #include "evoral/Curve.hpp"
  27
  28 #include "ardour/amp.h"
  29 #include "ardour/audio_buffer.h"
  30 #include "ardour/audio_diskstream.h"
  31 #include "ardour/audio_track.h"
  32 #include "ardour/audioplaylist.h"
  33 #include "ardour/audioregion.h"
  34 #include "ardour/audiosource.h"
  35 #include "ardour/buffer_set.h"
  36 #include "ardour/io_processor.h"
  37 #include "ardour/panner.h"
  38 #include "ardour/meter.h"
  39 #include "ardour/playlist_factory.h"
  40 #include "ardour/plugin_insert.h"
  41 #include "ardour/processor.h"
  42 #include "ardour/region_factory.h"
  43 #include "ardour/route_group_specialized.h"
  44 #include "ardour/session.h"
  45 #include "ardour/utils.h"
  46 #include "ardour/session_playlists.h"
  47 #include "ardour/delivery.h"
  48 #include "ardour/meter.h"
  49 #include "i18n.h"
  50
  51 using namespace std;
  52 using namespace ARDOUR;
  53 using namespace PBD;
  54
  55 AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
  56         : Track (sess, name, flag, mode)
  57 {
  58 }
  59
  60 AudioTrack::~AudioTrack ()
  61 {
  62 }
  63
  64 void
  65 AudioTrack::use_new_diskstream ()
  66 {
  67         AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0);
  68
  69         if (_flags & Hidden) {
  70                 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden);
  71         } else {
  72                 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Recordable);
  73         }
  74
  75         if (_mode == Destructive) {
  76                 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive);
  77         } else if (_mode == NonLayered){
  78                 dflags = AudioDiskstream::Flag(dflags | AudioDiskstream::NonLayered);
  79         }
  80
  81         AudioDiskstream* dsp (new AudioDiskstream (_session, name(), dflags));
  82         boost::shared_ptr<AudioDiskstream> ds (dsp);
  83
  84         ds->do_refill_with_alloc ();
  85         ds->set_block_size (_session.get_block_size ());
  86
  87         set_diskstream (ds);
  88 }
  89
  90 void
  91 AudioTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
  92 {
  93         Track::set_diskstream (ds);
  94
  95         _diskstream->set_track (this);
  96         _diskstream->set_destructive (_mode == Destructive);
  97         _diskstream->set_non_layered (_mode == NonLayered);
  98
  99         if (audio_diskstream()->deprecated_io_node) {
 100
 101                 if (!IO::connecting_legal) {
 102                         IO::ConnectingLegal.connect_same_thread (*this, boost::bind (&AudioTrack::deprecated_use_diskstream_connections, this));
 103                 } else {
 104                         deprecated_use_diskstream_connections ();
 105                 }
 106         }
 107
 108         _diskstream->set_record_enabled (false);
 109         _diskstream->monitor_input (false);
 110
 111         DiskstreamChanged (); /* EMIT SIGNAL */
 112 }
 113
 114 boost::shared_ptr<AudioDiskstream>
 115 AudioTrack::audio_diskstream() const
 116 {
 117         return boost::dynamic_pointer_cast<AudioDiskstream>(_diskstream);
 118 }
 119
 120 int
 121 AudioTrack::set_mode (TrackMode m)
 122 {
 123         if (m != _mode) {
 124
 125                 if (_diskstream->set_destructive (m == Destructive)) {
 126                         return -1;
 127                 }
 128
 129                 _diskstream->set_non_layered (m == NonLayered);
 130                 _mode = m;
 131
 132                 TrackModeChanged (); /* EMIT SIGNAL */
 133         }
 134
 135         return 0;
 136 }
 137
 138 bool
 139 AudioTrack::can_use_mode (TrackMode m, bool& bounce_required)
 140 {
 141         switch (m) {
 142         case NonLayered:
 143         case Normal:
 144                 bounce_required = false;
 145                 return true;
 146
 147         case Destructive:
 148         default:
 149                 return _diskstream->can_become_destructive (bounce_required);
 150         }
 151 }
 152
 153 int
 154 AudioTrack::deprecated_use_diskstream_connections ()
 155 {
 156         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 157
 158         if (diskstream->deprecated_io_node == 0) {
 159                 return 0;
 160         }
 161
 162         const XMLProperty* prop;
 163         XMLNode& node (*diskstream->deprecated_io_node);
 164
 165         /* don't do this more than once. */
 166
 167         diskstream->deprecated_io_node = 0;
 168
 169         if ((prop = node.property ("gain")) != 0) {
 170                 _amp->set_gain (atof (prop->value().c_str()), this);
 171         }
 172
 173         if ((prop = node.property ("input-connection")) != 0) {
 174                 boost::shared_ptr<Bundle> c = _session.bundle_by_name (prop->value());
 175
 176                 if (c == 0) {
 177                         error << string_compose(_("Unknown bundle \"%1\" listed for input of %2"), prop->value(), _name) << endmsg;
 178
 179                         if ((c = _session.bundle_by_name (_("in 1"))) == 0) {
 180                                 error << _("No input bundles available as a replacement")
 181                                 << endmsg;
 182                                 return -1;
 183                         } else {
 184                                 info << string_compose (_("Bundle %1 was not available - \"in 1\" used instead"), prop->value())
 185                                << endmsg;
 186                         }
 187                 }
 188
 189                 _input->connect_ports_to_bundle (c, this);
 190
 191         } else if ((prop = node.property ("inputs")) != 0) {
 192                 if (_input->set_ports (prop->value())) {
 193                         error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg;
 194                         return -1;
 195                 }
 196         }
 197
 198         return 0;
 199 }
 200
 201 int
 202 AudioTrack::set_state (const XMLNode& node, int version)
 203 {
 204         return _set_state (node, version, true);
 205 }
 206
 207 int
 208 AudioTrack::_set_state (const XMLNode& node, int version, bool call_base)
 209 {
 210         const XMLProperty *prop;
 211         XMLNodeConstIterator iter;
 212         XMLNode *child;
 213
 214         if (call_base) {
 215                 if (Route::_set_state (node, version, call_base)) {
 216                         return -1;
 217                 }
 218         }
 219
 220         if ((prop = node.property (X_("mode"))) != 0) {
 221                 _mode = TrackMode (string_2_enum (prop->value(), _mode));
 222         } else {
 223                 _mode = Normal;
 224         }
 225
 226         if (version >= 3000) {
 227                 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
 228                         boost::shared_ptr<AudioDiskstream> ds (new AudioDiskstream (_session, *child));
 229                         ds->do_refill_with_alloc ();
 230                         set_diskstream (ds);
 231                 }
 232         }
 233
 234         /* set rec-enable control *AFTER* setting up diskstream, because it may want to operate
 235            on the diskstream as it sets its own state
 236         */
 237
 238         XMLNodeList nlist;
 239         XMLNodeConstIterator niter;
 240
 241         nlist = node.children();
 242         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
 243                 child = *niter;
 244
 245                 if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
 246                         if (prop->value() == X_("recenable")) {
 247                                 _rec_enable_control->set_state (*child, version);
 248                         }
 249                 }
 250         }
 251
 252
 253         pending_state = const_cast<XMLNode*> (&node);
 254
 255         if (_session.state_of_the_state() & Session::Loading) {
 256                 _session.StateReady.connect_same_thread (*this, boost::bind (&AudioTrack::set_state_part_two, this));
 257         } else {
 258                 set_state_part_two ();
 259         }
 260
 261         return 0;
 262 }
 263
 264 XMLNode&
 265 AudioTrack::state (bool full_state)
 266 {
 267         XMLNode& root (Route::state(full_state));
 268         XMLNode* freeze_node;
 269         char buf[64];
 270
 271         if (_freeze_record.playlist) {
 272                 XMLNode* inode;
 273
 274                 freeze_node = new XMLNode (X_("freeze-info"));
 275                 freeze_node->add_property ("playlist", _freeze_record.playlist->name());
 276                 freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
 277
 278                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 279                         inode = new XMLNode (X_("processor"));
 280                         (*i)->id.print (buf, sizeof (buf));
 281                         inode->add_property (X_("id"), buf);
 282                         inode->add_child_copy ((*i)->state);
 283
 284                         freeze_node->add_child_nocopy (*inode);
 285                 }
 286
 287                 root.add_child_nocopy (*freeze_node);
 288         }
 289
 290         root.add_property (X_("mode"), enum_2_string (_mode));
 291         root.add_child_nocopy (_rec_enable_control->get_state());
 292         root.add_child_nocopy (_diskstream->get_state ());
 293
 294         return root;
 295 }
 296
 297 void
 298 AudioTrack::set_state_part_two ()
 299 {
 300         XMLNode* fnode;
 301         XMLProperty* prop;
 302         LocaleGuard lg (X_("POSIX"));
 303
 304         /* This is called after all session state has been restored but before
 305            have been made ports and connections are established.
 306         */
 307
 308         if (pending_state == 0) {
 309                 return;
 310         }
 311
 312         if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
 313
 314                 _freeze_record.state = Frozen;
 315
 316                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 317                         delete *i;
 318                 }
 319                 _freeze_record.processor_info.clear ();
 320
 321                 if ((prop = fnode->property (X_("playlist"))) != 0) {
 322                         boost::shared_ptr<Playlist> pl = _session.playlists->by_name (prop->value());
 323                         if (pl) {
 324                                 _freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist> (pl);
 325                         } else {
 326                                 _freeze_record.playlist.reset ();
 327                                 _freeze_record.state = NoFreeze;
 328                         return;
 329                         }
 330                 }
 331
 332                 if ((prop = fnode->property (X_("state"))) != 0) {
 333                         _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
 334                 }
 335
 336                 XMLNodeConstIterator citer;
 337                 XMLNodeList clist = fnode->children();
 338
 339                 for (citer = clist.begin(); citer != clist.end(); ++citer) {
 340                         if ((*citer)->name() != X_("processor")) {
 341                                 continue;
 342                         }
 343
 344                         if ((prop = (*citer)->property (X_("id"))) == 0) {
 345                                 continue;
 346                         }
 347
 348                         FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
 349                                                                                    boost::shared_ptr<Processor>());
 350                         frii->id = prop->value ();
 351                         _freeze_record.processor_info.push_back (frii);
 352                 }
 353         }
 354 }
 355
 356 int
 357 AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
 358                   bool can_record, bool rec_monitors_input, bool& need_butler)
 359 {
 360         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 361         if (!lm.locked()) {
 362                 return 0;
 363         }
 364
 365         int dret;
 366         Sample* b;
 367         Sample* tmpb;
 368         framepos_t transport_frame;
 369         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 370
 371         automation_snapshot (start_frame, false);
 372
 373         if (n_outputs().n_total() == 0 && _processors.empty()) {
 374                 return 0;
 375         }
 376
 377         if (!_active) {
 378                 silence (nframes);
 379                 return 0;
 380         }
 381
 382         transport_frame = _session.transport_frame();
 383
 384         if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
 385
 386                 /* need to do this so that the diskstream sets its
 387                    playback distance to zero, thus causing diskstream::commit
 388                    to do nothing.
 389                 */
 390                 cerr << name() << " Can't operate at " << transport_frame << " since roll delay is only " << _roll_delay << endl;
 391                 return diskstream->process (transport_frame, 0, can_record, rec_monitors_input, need_butler);
 392         }
 393
 394         _silent = false;
 395         _amp->apply_gain_automation(false);
 396
 397         if ((dret = diskstream->process (transport_frame, nframes, can_record, rec_monitors_input, need_butler)) != 0) {
 398                 silence (nframes);
 399                 return dret;
 400         }
 401
 402         /* special condition applies */
 403
 404         if (_meter_point == MeterInput) {
 405                 _input->process_input (_meter, start_frame, end_frame, nframes);
 406         }
 407
 408         if (diskstream->record_enabled() && !can_record && !_session.config.get_auto_input()) {
 409
 410                 /* not actually recording, but we want to hear the input material anyway,
 411                    at least potentially (depending on monitoring options)
 412                  */
 413
 414                 passthru (start_frame, end_frame, nframes, false);
 415
 416         } else if ((b = diskstream->playback_buffer(0)) != 0) {
 417
 418                 /*
 419                   XXX is it true that the earlier test on n_outputs()
 420                   means that we can avoid checking it again here? i think
 421                   so, because changing the i/o configuration of an IO
 422                   requires holding the AudioEngine lock, which we hold
 423                   while in the process() tree.
 424                 */
 425
 426
 427                 /* copy the diskstream data to all output buffers */
 428
 429                 size_t limit = input_streams ().n_audio();
 430                 BufferSet& bufs = _session.get_scratch_buffers ();
 431                 const size_t blimit = bufs.count().n_audio();
 432
 433                 uint32_t n;
 434                 uint32_t i;
 435
 436                 if (limit > blimit) {
 437
 438                         /* example case: auditioner configured for stereo output,
 439                            but loaded with an 8 channel file. there are only
 440                            2 passthrough buffers, but n_process_buffers() will
 441                            return 8.
 442
 443                            arbitrary decision: map all channels in the diskstream
 444                            to the outputs available.
 445                         */
 446
 447                         float scaling = limit/blimit;
 448
 449                         for (i = 0, n = 1; i < blimit; ++i, ++n) {
 450
 451                                 /* first time through just copy a channel into
 452                                    the output buffer.
 453                                 */
 454
 455                                 Sample* bb = bufs.get_audio (i).data();
 456
 457                                 for (pframes_t xx = 0; xx < nframes; ++xx) {
 458                                         bb[xx] = b[xx] * scaling;
 459                                 }
 460
 461                                 if (n < diskstream->n_channels().n_audio()) {
 462                                         tmpb = diskstream->playback_buffer(n);
 463                                         if (tmpb!=0) {
 464                                                 b = tmpb;
 465                                         }
 466                                 }
 467                         }
 468
 469                         for (;i < limit; ++i, ++n) {
 470
 471                                 /* for all remaining channels, sum with existing
 472                                    data in the output buffers
 473                                 */
 474
 475                                 bufs.get_audio (i%blimit).accumulate_with_gain_from (b, nframes, 0, scaling);
 476
 477                                 if (n < diskstream->n_channels().n_audio()) {
 478                                         tmpb = diskstream->playback_buffer(n);
 479                                         if (tmpb!=0) {
 480                                                 b = tmpb;
 481                                         }
 482                                 }
 483
 484                         }
 485
 486                         limit = blimit;
 487
 488                 } else {
 489                         for (i = 0, n = 1; i < limit; ++i, ++n) {
 490                                 memcpy (bufs.get_audio (i).data(), b, sizeof (Sample) * nframes);
 491                                 if (n < diskstream->n_channels().n_audio()) {
 492                                         tmpb = diskstream->playback_buffer(n);
 493                                         if (tmpb!=0) {
 494                                                 b = tmpb;
 495                                         }
 496                                 }
 497                         }
 498
 499                         /* try to leave any MIDI buffers alone */
 500
 501                         ChanCount chn;
 502                         chn.set_audio (limit);
 503                         chn.set_midi (_input->n_ports().n_midi());
 504                         bufs.set_count (chn);
 505                 }
 506
 507                 /* final argument: don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
 508
 509                 process_output_buffers (bufs, start_frame, end_frame, nframes, (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick,
 510                                         (!diskstream->record_enabled() && _session.transport_rolling()));
 511
 512
 513         } else {
 514                 /* problem with the diskstream; just be quiet for a bit */
 515                 silence (nframes);
 516         }
 517
 518         return 0;
 519 }
 520
 521 int
 522 AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes, bool enable_processing)
 523 {
 524         boost::scoped_array<gain_t> gain_buffer (new gain_t[nframes]);
 525         boost::scoped_array<Sample> mix_buffer (new Sample[nframes]);
 526         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 527
 528         Glib::RWLock::ReaderLock rlock (_processor_lock);
 529
 530         boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist());
 531         assert(apl);
 532
 533         assert ((framecnt_t) buffers.get_audio(0).capacity() >= nframes);
 534
 535         if (apl->read (buffers.get_audio(0).data(), mix_buffer.get(), gain_buffer.get(), start, nframes) != nframes) {
 536                 return -1;
 537         }
 538
 539         assert(buffers.count().n_audio() >= 1);
 540         uint32_t n=1;
 541         Sample* b = buffers.get_audio(0).data();
 542         BufferSet::audio_iterator bi = buffers.audio_begin();
 543         ++bi;
 544         for ( ; bi != buffers.audio_end(); ++bi, ++n) {
 545                 if (n < diskstream->n_channels().n_audio()) {
 546                         if (apl->read (bi->data(), mix_buffer.get(), gain_buffer.get(), start, nframes, n) != nframes) {
 547                                 return -1;
 548                         }
 549                         b = bi->data();
 550                 }
 551                 else {
 552                         /* duplicate last across remaining buffers */
 553                         memcpy (bi->data(), b, sizeof (Sample) * nframes);
 554                 }
 555         }
 556
 557         // If no processing is required, there's no need to go any further.
 558         if (!enable_processing) {
 559                 return 0;
 560         }
 561
 562         /* note: only run processors during export. other layers in the machinery
 563            will already have checked that there are no external port processors.
 564            Also, don't run deliveries that write to real output ports, and don't
 565            run meters.
 566         */
 567
 568         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 569                 boost::shared_ptr<Processor> processor = boost::dynamic_pointer_cast<Processor> (*i);
 570                 boost::shared_ptr<Delivery> delivery = boost::dynamic_pointer_cast<Delivery> (*i);
 571                 boost::shared_ptr<PeakMeter> meter = boost::dynamic_pointer_cast<PeakMeter> (*i);
 572
 573                 if (processor && (!delivery || !Delivery::role_requires_output_ports (delivery->role())) && !meter) {
 574                         processor->run (buffers, start, start+nframes, nframes, true);
 575                 }
 576         }
 577
 578         return 0;
 579 }
 580
 581 boost::shared_ptr<Region>
 582 AudioTrack::bounce (InterThreadInfo& itt)
 583 {
 584         vector<boost::shared_ptr<Source> > srcs;
 585         return _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), false, srcs, itt);
 586 }
 587
 588 boost::shared_ptr<Region>
 589 AudioTrack::bounce_range (framepos_t start, framepos_t end, InterThreadInfo& itt, bool enable_processing)
 590 {
 591         vector<boost::shared_ptr<Source> > srcs;
 592         return _session.write_one_track (*this, start, end, false, srcs, itt, enable_processing);
 593 }
 594
 595 void
 596 AudioTrack::freeze_me (InterThreadInfo& itt)
 597 {
 598         vector<boost::shared_ptr<Source> > srcs;
 599         string new_playlist_name;
 600         boost::shared_ptr<Playlist> new_playlist;
 601         string dir;
 602         string region_name;
 603         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 604
 605         if ((_freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist())) == 0) {
 606                 return;
 607         }
 608
 609         uint32_t n = 1;
 610
 611         while (n < (UINT_MAX-1)) {
 612
 613                 string candidate;
 614
 615                 candidate = string_compose ("<F%2>%1", _freeze_record.playlist->name(), n);
 616
 617                 if (_session.playlists->by_name (candidate) == 0) {
 618                         new_playlist_name = candidate;
 619                         break;
 620                 }
 621
 622                 ++n;
 623
 624         }
 625
 626         if (n == (UINT_MAX-1)) {
 627           error << string_compose (X_("There are too many frozen versions of playlist \"%1\""
 628                             " to create another one"), _freeze_record.playlist->name())
 629                << endmsg;
 630                 return;
 631         }
 632
 633         boost::shared_ptr<Region> res;
 634
 635         if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt)) == 0) {
 636                 return;
 637         }
 638
 639         _freeze_record.processor_info.clear ();
 640
 641         {
 642                 Glib::RWLock::ReaderLock lm (_processor_lock);
 643
 644                 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
 645
 646                         boost::shared_ptr<Processor> processor;
 647
 648                         if ((processor = boost::dynamic_pointer_cast<Processor>(*r)) != 0) {
 649
 650                                 FreezeRecordProcessorInfo* frii  = new FreezeRecordProcessorInfo ((*r)->get_state(), processor);
 651
 652                                 frii->id = processor->id();
 653
 654                                 _freeze_record.processor_info.push_back (frii);
 655
 656                                 /* now deactivate the processor */
 657
 658                                 processor->deactivate ();
 659                                 _session.set_dirty ();
 660                         }
 661                 }
 662         }
 663
 664         new_playlist = PlaylistFactory::create (DataType::AUDIO, _session, new_playlist_name, false);
 665
 666         /* XXX need main outs automation state _freeze_record.pan_automation_state = _mainpanner->automation_state(); */
 667
 668         region_name = new_playlist_name;
 669
 670         /* create a new region from all filesources, keep it private */
 671
 672         PropertyList plist;
 673
 674         plist.add (Properties::start, 0);
 675         plist.add (Properties::length, srcs[0]->length(srcs[0]->timeline_position()));
 676         plist.add (Properties::name, region_name);
 677         plist.add (Properties::whole_file, true);
 678
 679         boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist, false));
 680
 681         new_playlist->set_orig_diskstream_id (_diskstream->id());
 682         new_playlist->add_region (region, _session.current_start_frame());
 683         new_playlist->set_frozen (true);
 684         region->set_locked (true);
 685
 686         diskstream->use_playlist (boost::dynamic_pointer_cast<AudioPlaylist>(new_playlist));
 687         diskstream->set_record_enabled (false);
 688
 689         /* reset stuff that has already been accounted for in the freeze process */
 690
 691         set_gain (1.0, this);
 692         _amp->gain_control()->set_automation_state (Off);
 693         /* XXX need to use _main_outs _panner->set_automation_state (Off); */
 694
 695         _freeze_record.state = Frozen;
 696         FreezeChange(); /* EMIT SIGNAL */
 697 }
 698
 699 void
 700 AudioTrack::unfreeze ()
 701 {
 702         if (_freeze_record.playlist) {
 703                 audio_diskstream()->use_playlist (_freeze_record.playlist);
 704
 705                 {
 706                         Glib::RWLock::ReaderLock lm (_processor_lock); // should this be a write lock? jlc
 707                         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 708                                 for (vector<FreezeRecordProcessorInfo*>::iterator ii = _freeze_record.processor_info.begin(); ii != _freeze_record.processor_info.end(); ++ii) {
 709                                         if ((*ii)->id == (*i)->id()) {
 710                                                 (*i)->set_state (((*ii)->state), Stateful::current_state_version);
 711                                                 break;
 712                                         }
 713                                 }
 714                         }
 715                 }
 716
 717                 _freeze_record.playlist.reset ();
 718                 /* XXX need to use _main_outs _panner->set_automation_state (_freeze_record.pan_automation_state); */
 719         }
 720
 721         _freeze_record.state = UnFrozen;
 722         FreezeChange (); /* EMIT SIGNAL */
 723 }
 724
 725 boost::shared_ptr<AudioFileSource>
 726 AudioTrack::write_source (uint32_t n)
 727 {
 728         boost::shared_ptr<AudioDiskstream> ds = boost::dynamic_pointer_cast<AudioDiskstream> (_diskstream);
 729         assert (ds);
 730         return ds->write_source (n);
 731 }
 732
 733 bool
 734 AudioTrack::bounceable () const
 735 {
 736         return n_inputs().n_audio() >= n_outputs().n_audio();
 737 }