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         pending_state = const_cast<XMLNode*> (&node);
 253
 254         if (_session.state_of_the_state() & Session::Loading) {
 255                 _session.StateReady.connect_same_thread (*this, boost::bind (&AudioTrack::set_state_part_two, this));
 256         } else {
 257                 set_state_part_two ();
 258         }
 259
 260         return 0;
 261 }
 262
 263 XMLNode&
 264 AudioTrack::state (bool full_state)
 265 {
 266         XMLNode& root (Route::state(full_state));
 267         XMLNode* freeze_node;
 268         char buf[64];
 269
 270         if (_freeze_record.playlist) {
 271                 XMLNode* inode;
 272
 273                 freeze_node = new XMLNode (X_("freeze-info"));
 274                 freeze_node->add_property ("playlist", _freeze_record.playlist->name());
 275                 freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
 276
 277                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 278                         inode = new XMLNode (X_("processor"));
 279                         (*i)->id.print (buf, sizeof (buf));
 280                         inode->add_property (X_("id"), buf);
 281                         inode->add_child_copy ((*i)->state);
 282
 283                         freeze_node->add_child_nocopy (*inode);
 284                 }
 285
 286                 root.add_child_nocopy (*freeze_node);
 287         }
 288
 289         root.add_property (X_("mode"), enum_2_string (_mode));
 290         root.add_child_nocopy (_rec_enable_control->get_state());
 291         root.add_child_nocopy (_diskstream->get_state ());
 292
 293         return root;
 294 }
 295
 296 void
 297 AudioTrack::set_state_part_two ()
 298 {
 299         XMLNode* fnode;
 300         XMLProperty* prop;
 301         LocaleGuard lg (X_("POSIX"));
 302
 303         /* This is called after all session state has been restored but before
 304            have been made ports and connections are established.
 305         */
 306
 307         if (pending_state == 0) {
 308                 return;
 309         }
 310
 311         if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
 312
 313                 _freeze_record.state = Frozen;
 314
 315                 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
 316                         delete *i;
 317                 }
 318                 _freeze_record.processor_info.clear ();
 319
 320                 if ((prop = fnode->property (X_("playlist"))) != 0) {
 321                         boost::shared_ptr<Playlist> pl = _session.playlists->by_name (prop->value());
 322                         if (pl) {
 323                                 _freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist> (pl);
 324                         } else {
 325                                 _freeze_record.playlist.reset ();
 326                                 _freeze_record.state = NoFreeze;
 327                         return;
 328                         }
 329                 }
 330
 331                 if ((prop = fnode->property (X_("state"))) != 0) {
 332                         _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
 333                 }
 334
 335                 XMLNodeConstIterator citer;
 336                 XMLNodeList clist = fnode->children();
 337
 338                 for (citer = clist.begin(); citer != clist.end(); ++citer) {
 339                         if ((*citer)->name() != X_("processor")) {
 340                                 continue;
 341                         }
 342
 343                         if ((prop = (*citer)->property (X_("id"))) == 0) {
 344                                 continue;
 345                         }
 346
 347                         FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
 348                                                                                    boost::shared_ptr<Processor>());
 349                         frii->id = prop->value ();
 350                         _freeze_record.processor_info.push_back (frii);
 351                 }
 352         }
 353 }
 354
 355 int
 356 AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
 357                   bool can_record, bool rec_monitors_input, bool& need_butler)
 358 {
 359         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 360         if (!lm.locked()) {
 361                 return 0;
 362         }
 363
 364         int dret;
 365         Sample* b;
 366         Sample* tmpb;
 367         framepos_t transport_frame;
 368         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 369
 370         automation_snapshot (start_frame, false);
 371
 372         if (n_outputs().n_total() == 0 && _processors.empty()) {
 373                 return 0;
 374         }
 375
 376         if (!_active) {
 377                 silence (nframes);
 378                 return 0;
 379         }
 380
 381         transport_frame = _session.transport_frame();
 382
 383         if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
 384
 385                 /* need to do this so that the diskstream sets its
 386                    playback distance to zero, thus causing diskstream::commit
 387                    to do nothing.
 388                 */
 389                 cerr << name() << " Can't operate at " << transport_frame << " since roll delay is only " << _roll_delay << endl;
 390                 return diskstream->process (transport_frame, 0, can_record, rec_monitors_input, need_butler);
 391         }
 392
 393         _silent = false;
 394         _amp->apply_gain_automation(false);
 395
 396         if ((dret = diskstream->process (transport_frame, nframes, can_record, rec_monitors_input, need_butler)) != 0) {
 397                 silence (nframes);
 398                 return dret;
 399         }
 400
 401         /* special condition applies */
 402
 403         if (_meter_point == MeterInput) {
 404                 _input->process_input (_meter, start_frame, end_frame, nframes);
 405         }
 406
 407         if (diskstream->record_enabled() && !can_record && !_session.config.get_auto_input()) {
 408
 409                 /* not actually recording, but we want to hear the input material anyway,
 410                    at least potentially (depending on monitoring options)
 411                  */
 412
 413                 passthru (start_frame, end_frame, nframes, false);
 414
 415         } else if ((b = diskstream->playback_buffer(0)) != 0) {
 416
 417                 /*
 418                   XXX is it true that the earlier test on n_outputs()
 419                   means that we can avoid checking it again here? i think
 420                   so, because changing the i/o configuration of an IO
 421                   requires holding the AudioEngine lock, which we hold
 422                   while in the process() tree.
 423                 */
 424
 425
 426                 /* copy the diskstream data to all output buffers */
 427
 428                 size_t limit = input_streams ().n_audio();
 429                 BufferSet& bufs = _session.get_scratch_buffers ();
 430                 const size_t blimit = bufs.count().n_audio();
 431
 432                 uint32_t n;
 433                 uint32_t i;
 434
 435                 if (limit > blimit) {
 436
 437                         /* example case: auditioner configured for stereo output,
 438                            but loaded with an 8 channel file. there are only
 439                            2 passthrough buffers, but n_process_buffers() will
 440                            return 8.
 441
 442                            arbitrary decision: map all channels in the diskstream
 443                            to the outputs available.
 444                         */
 445
 446                         float scaling = limit/blimit;
 447
 448                         for (i = 0, n = 1; i < blimit; ++i, ++n) {
 449
 450                                 /* first time through just copy a channel into
 451                                    the output buffer.
 452                                 */
 453
 454                                 Sample* bb = bufs.get_audio (i).data();
 455
 456                                 for (pframes_t xx = 0; xx < nframes; ++xx) {
 457                                         bb[xx] = b[xx] * scaling;
 458                                 }
 459
 460                                 if (n < diskstream->n_channels().n_audio()) {
 461                                         tmpb = diskstream->playback_buffer(n);
 462                                         if (tmpb!=0) {
 463                                                 b = tmpb;
 464                                         }
 465                                 }
 466                         }
 467
 468                         for (;i < limit; ++i, ++n) {
 469
 470                                 /* for all remaining channels, sum with existing
 471                                    data in the output buffers
 472                                 */
 473
 474                                 bufs.get_audio (i%blimit).accumulate_with_gain_from (b, nframes, 0, scaling);
 475
 476                                 if (n < diskstream->n_channels().n_audio()) {
 477                                         tmpb = diskstream->playback_buffer(n);
 478                                         if (tmpb!=0) {
 479                                                 b = tmpb;
 480                                         }
 481                                 }
 482
 483                         }
 484
 485                         limit = blimit;
 486
 487                 } else {
 488                         for (i = 0, n = 1; i < limit; ++i, ++n) {
 489                                 memcpy (bufs.get_audio (i).data(), b, sizeof (Sample) * nframes);
 490                                 if (n < diskstream->n_channels().n_audio()) {
 491                                         tmpb = diskstream->playback_buffer(n);
 492                                         if (tmpb!=0) {
 493                                                 b = tmpb;
 494                                         }
 495                                 }
 496                         }
 497
 498                         /* try to leave any MIDI buffers alone */
 499
 500                         ChanCount chn;
 501                         chn.set_audio (limit);
 502                         chn.set_midi (_input->n_ports().n_midi());
 503                         bufs.set_count (chn);
 504                 }
 505
 506                 /* final argument: don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
 507
 508                 process_output_buffers (
 509                         bufs, start_frame, end_frame, nframes,
 510                         (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()),
 511                         declick,
 512                         (!diskstream->record_enabled() && _session.transport_rolling()));
 513
 514         } else {
 515                 /* problem with the diskstream; just be quiet for a bit */
 516                 silence (nframes);
 517         }
 518
 519         return 0;
 520 }
 521
 522 int
 523 AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes, bool enable_processing)
 524 {
 525         boost::scoped_array<gain_t> gain_buffer (new gain_t[nframes]);
 526         boost::scoped_array<Sample> mix_buffer (new Sample[nframes]);
 527         boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 528
 529         Glib::RWLock::ReaderLock rlock (_processor_lock);
 530
 531         boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist());
 532
 533         assert(apl);
 534         assert(buffers.count().n_audio() >= 1);
 535         assert ((framecnt_t) buffers.get_audio(0).capacity() >= nframes);
 536
 537         if (apl->read (buffers.get_audio(0).data(), mix_buffer.get(), gain_buffer.get(), start, nframes) != nframes) {
 538                 return -1;
 539         }
 540
 541         uint32_t n=1;
 542         Sample* b = buffers.get_audio(0).data();
 543         BufferSet::audio_iterator bi = buffers.audio_begin();
 544         ++bi;
 545         for ( ; bi != buffers.audio_end(); ++bi, ++n) {
 546                 if (n < diskstream->n_channels().n_audio()) {
 547                         if (apl->read (bi->data(), mix_buffer.get(), gain_buffer.get(), start, nframes, n) != nframes) {
 548                                 return -1;
 549                         }
 550                         b = bi->data();
 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 }