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