libs/ardour/track.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18 #include "pbd/error.h"
  19
  20 #include "ardour/amp.h"
  21 #include "ardour/audioplaylist.h"
  22 #include "ardour/audioregion.h"
  23 #include "ardour/audiosource.h"
  24 #include "ardour/debug.h"
  25 #include "ardour/delivery.h"
  26 #include "ardour/diskstream.h"
  27 #include "ardour/io_processor.h"
  28 #include "ardour/meter.h"
  29 #include "ardour/port.h"
  30 #include "ardour/processor.h"
  31 #include "ardour/route_group_specialized.h"
  32 #include "ardour/session.h"
  33 #include "ardour/track.h"
  34 #include "ardour/utils.h"
  35
  36 #include "i18n.h"
  37
  38 using namespace std;
  39 using namespace ARDOUR;
  40 using namespace PBD;
  41
  42 Track::Track (Session& sess, string name, Route::Flag flag, TrackMode mode, DataType default_type)
  43         : Route (sess, name, flag, default_type)
  44         , _saved_meter_point (_meter_point)
  45         , _mode (mode)
  46         , _monitoring (MonitorAuto)
  47         , _rec_enable_control (new RecEnableControllable(*this))
  48 {
  49         _freeze_record.state = NoFreeze;
  50         _declickable = true;
  51 }
  52
  53 Track::~Track ()
  54 {
  55         DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
  56 }
  57
  58 int
  59 Track::init ()
  60 {
  61         if (Route::init ()) {
  62                 return -1;
  63         }
  64
  65         return 0;
  66 }
  67
  68 XMLNode&
  69 Track::get_state ()
  70 {
  71         return state (true);
  72 }
  73
  74 XMLNode&
  75 Track::state (bool full)
  76 {
  77         XMLNode& root (Route::state (full));
  78         root.add_property (X_("monitoring"), enum_2_string (_monitoring));
  79         root.add_property (X_("saved-meter-point"), enum_2_string (_saved_meter_point));
  80         root.add_child_nocopy (_rec_enable_control->get_state());
  81         root.add_child_nocopy (_diskstream->get_state ());
  82         return root;
  83 }
  84
  85 int
  86 Track::set_state (const XMLNode& node, int version)
  87 {
  88         if (Route::set_state (node, version)) {
  89                 return -1;
  90         }
  91
  92         XMLNode* child;
  93
  94         if (version >= 3000) {
  95                 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
  96                         boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
  97                         ds->do_refill_with_alloc ();
  98                         set_diskstream (ds);
  99                 }
 100         }
 101
 102         /* set rec-enable control *AFTER* setting up diskstream, because it may
 103            want to operate on the diskstream as it sets its own state
 104         */
 105
 106         XMLNodeList nlist = node.children();
 107         for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
 108                 child = *niter;
 109
 110                 XMLProperty* prop;
 111                 if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) {
 112                         if (prop->value() == X_("recenable")) {
 113                                 _rec_enable_control->set_state (*child, version);
 114                         }
 115                 }
 116         }
 117
 118         const XMLProperty* prop;
 119
 120         if ((prop = node.property (X_("monitoring"))) != 0) {
 121                 _monitoring = MonitorChoice (string_2_enum (prop->value(), _monitoring));
 122         } else {
 123                 _monitoring = MonitorAuto;
 124         }
 125
 126         if ((prop = node.property (X_("saved-meter-point"))) != 0) {
 127                 _saved_meter_point = MeterPoint (string_2_enum (prop->value(), _saved_meter_point));
 128         } else {
 129                 _saved_meter_point = _meter_point;
 130         }
 131
 132         return 0;
 133 }
 134
 135 XMLNode&
 136 Track::get_template ()
 137 {
 138         return state (false);
 139 }
 140
 141 void
 142 Track::toggle_monitor_input ()
 143 {
 144         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
 145                 i->ensure_monitor_input(!i->monitoring_input());
 146         }
 147 }
 148
 149 Track::FreezeRecord::~FreezeRecord ()
 150 {
 151         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
 152                 delete *i;
 153         }
 154 }
 155
 156 Track::FreezeState
 157 Track::freeze_state() const
 158 {
 159         return _freeze_record.state;
 160 }
 161
 162 Track::RecEnableControllable::RecEnableControllable (Track& s)
 163         : Controllable (X_("recenable")), track (s)
 164 {
 165 }
 166
 167 void
 168 Track::RecEnableControllable::set_value (double val)
 169 {
 170         bool bval = ((val >= 0.5) ? true: false);
 171         track.set_record_enabled (bval, this);
 172 }
 173
 174 double
 175 Track::RecEnableControllable::get_value (void) const
 176 {
 177         if (track.record_enabled()) { return 1.0; }
 178         return 0.0;
 179 }
 180
 181 bool
 182 Track::record_enabled () const
 183 {
 184         return _diskstream && _diskstream->record_enabled ();
 185 }
 186
 187 bool
 188 Track::can_record()
 189 {
 190         bool will_record = true;
 191         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
 192                 if (!i->connected())
 193                         will_record = false;
 194         }
 195
 196         return will_record;
 197 }
 198
 199 void
 200 Track::set_record_enabled (bool yn, void *src)
 201 {
 202         if (!_session.writable()) {
 203                 return;
 204         }
 205
 206         if (_freeze_record.state == Frozen) {
 207                 return;
 208         }
 209
 210         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
 211                 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
 212                 return;
 213         }
 214
 215         /* keep track of the meter point as it was before we rec-enabled */
 216         if (!_diskstream->record_enabled()) {
 217                 _saved_meter_point = _meter_point;
 218         }
 219
 220         _diskstream->set_record_enabled (yn);
 221
 222         if (_diskstream->record_enabled()) {
 223                 if (_meter_point != MeterCustom) {
 224                         set_meter_point (MeterInput);
 225                 }
 226         } else {
 227                 set_meter_point (_saved_meter_point);
 228         }
 229
 230         _rec_enable_control->Changed ();
 231 }
 232
 233
 234 bool
 235 Track::set_name (const string& str)
 236 {
 237         bool ret;
 238
 239         if (record_enabled() && _session.actively_recording()) {
 240                 /* this messes things up if done while recording */
 241                 return false;
 242         }
 243
 244         _diskstream->set_name (str);
 245
 246         /* save state so that the statefile fully reflects any filename changes */
 247
 248         if ((ret = Route::set_name (str)) == 0) {
 249                 _session.save_state ("");
 250         }
 251
 252         return ret;
 253 }
 254
 255 void
 256 Track::set_latency_compensation (framecnt_t longest_session_latency)
 257 {
 258         Route::set_latency_compensation (longest_session_latency);
 259         _diskstream->set_roll_delay (_roll_delay);
 260 }
 261
 262 void
 263 Track::zero_diskstream_id_in_xml (XMLNode& node)
 264 {
 265         if (node.property ("diskstream-id")) {
 266                 node.add_property ("diskstream-id", "0");
 267         }
 268 }
 269
 270 int
 271 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
 272 {
 273         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 274         if (!lm.locked()) {
 275                 return 0;
 276         }
 277
 278         bool can_record = _session.actively_recording ();
 279
 280         if (n_outputs().n_total() == 0) {
 281                 return 0;
 282         }
 283
 284         if (!_active) {
 285                 silence (nframes);
 286                 return 0;
 287         }
 288
 289         if (session_state_changing) {
 290                 if (_session.transport_speed() != 0.0f) {
 291                         /* we're rolling but some state is changing (e.g. our diskstream contents)
 292                            so we cannot use them. Be silent till this is over. Don't declick.
 293
 294                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
 295                         */
 296                         passthru_silence (start_frame, end_frame, nframes, 0);
 297                         return 0;
 298                 }
 299                 /* we're really not rolling, so we're either delivery silence or actually
 300                    monitoring, both of which are safe to do while session_state_changing is true.
 301                 */
 302         }
 303
 304         _diskstream->check_record_status (start_frame, can_record);
 305
 306         bool be_silent;
 307
 308         if (_have_internal_generator) {
 309                 /* since the instrument has no input streams,
 310                    there is no reason to send any signal
 311                    into the route.
 312                 */
 313                 be_silent = true;
 314         } else {
 315                 be_silent = send_silence ();
 316         }
 317
 318         _amp->apply_gain_automation(false);
 319
 320         if (be_silent) {
 321
 322                 /* if we're sending silence, but we want the meters to show levels for the signal,
 323                    meter right here.
 324                 */
 325
 326                 if (_have_internal_generator) {
 327                         passthru_silence (start_frame, end_frame, nframes, 0);
 328                 } else {
 329                         if (_meter_point == MeterInput) {
 330                                 _input->process_input (_meter, start_frame, end_frame, nframes);
 331                         }
 332                         passthru_silence (start_frame, end_frame, nframes, 0);
 333                 }
 334
 335         } else {
 336
 337                 /* we're sending signal, but we may still want to meter the input.
 338                  */
 339
 340                 passthru (start_frame, end_frame, nframes, false);
 341         }
 342
 343         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 344                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
 345                 if (d) {
 346                         d->flush_buffers (nframes, end_frame - start_frame - 1);
 347                 }
 348         }
 349
 350         return 0;
 351 }
 352
 353 int
 354 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
 355 {
 356         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 357         if (!lm.locked()) {
 358                 return 0;
 359         }
 360
 361         if (n_outputs().n_total() == 0 && _processors.empty()) {
 362                 return 0;
 363         }
 364
 365         if (!_active) {
 366                 silence (nframes);
 367                 return 0;
 368         }
 369
 370         _silent = true;
 371         _amp->apply_gain_automation(false);
 372
 373         silence (nframes);
 374
 375         framecnt_t playback_distance;
 376         int const dret = _diskstream->process (_session.transport_frame(), nframes, playback_distance);
 377         need_butler = _diskstream->commit (playback_distance);
 378         return dret;
 379 }
 380
 381 void
 382 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
 383 {
 384         _diskstream = ds;
 385
 386         ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
 387         diskstream_playlist_changed ();
 388         ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
 389         ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
 390         ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
 391 }
 392
 393 void
 394 Track::diskstream_playlist_changed ()
 395 {
 396         PlaylistChanged (); /* EMIT SIGNAL */
 397 }
 398
 399 void
 400 Track::diskstream_record_enable_changed ()
 401 {
 402         RecordEnableChanged (); /* EMIT SIGNAL */
 403 }
 404
 405 void
 406 Track::diskstream_speed_changed ()
 407 {
 408         SpeedChanged (); /* EMIT SIGNAL */
 409 }
 410
 411 void
 412 Track::diskstream_alignment_style_changed ()
 413 {
 414         AlignmentStyleChanged (); /* EMIT SIGNAL */
 415 }
 416
 417 boost::shared_ptr<Playlist>
 418 Track::playlist ()
 419 {
 420         return _diskstream->playlist ();
 421 }
 422
 423 void
 424 Track::monitor_input (bool m)
 425 {
 426         _diskstream->monitor_input (m);
 427 }
 428
 429 bool
 430 Track::destructive () const
 431 {
 432         return _diskstream->destructive ();
 433 }
 434
 435 list<boost::shared_ptr<Source> > &
 436 Track::last_capture_sources ()
 437 {
 438         return _diskstream->last_capture_sources ();
 439 }
 440
 441 void
 442 Track::set_capture_offset ()
 443 {
 444         _diskstream->set_capture_offset ();
 445 }
 446
 447 list<boost::shared_ptr<Source> >
 448 Track::steal_write_sources()
 449 {
 450         return _diskstream->steal_write_sources ();
 451 }
 452
 453 void
 454 Track::reset_write_sources (bool r, bool force)
 455 {
 456         _diskstream->reset_write_sources (r, force);
 457 }
 458
 459 float
 460 Track::playback_buffer_load () const
 461 {
 462         return _diskstream->playback_buffer_load ();
 463 }
 464
 465 float
 466 Track::capture_buffer_load () const
 467 {
 468         return _diskstream->capture_buffer_load ();
 469 }
 470
 471 int
 472 Track::do_refill ()
 473 {
 474         return _diskstream->do_refill ();
 475 }
 476
 477 int
 478 Track::do_flush (RunContext c, bool force)
 479 {
 480         return _diskstream->do_flush (c, force);
 481 }
 482
 483 void
 484 Track::set_pending_overwrite (bool o)
 485 {
 486         _diskstream->set_pending_overwrite (o);
 487 }
 488
 489 int
 490 Track::seek (framepos_t p, bool complete_refill)
 491 {
 492         return _diskstream->seek (p, complete_refill);
 493 }
 494
 495 bool
 496 Track::hidden () const
 497 {
 498         return _diskstream->hidden ();
 499 }
 500
 501 int
 502 Track::can_internal_playback_seek (framepos_t p)
 503 {
 504         return _diskstream->can_internal_playback_seek (p);
 505 }
 506
 507 int
 508 Track::internal_playback_seek (framepos_t p)
 509 {
 510         return _diskstream->internal_playback_seek (p);
 511 }
 512
 513 void
 514 Track::non_realtime_input_change ()
 515 {
 516         _diskstream->non_realtime_input_change ();
 517 }
 518
 519 void
 520 Track::non_realtime_locate (framepos_t p)
 521 {
 522         _diskstream->non_realtime_locate (p);
 523 }
 524
 525 void
 526 Track::non_realtime_set_speed ()
 527 {
 528         _diskstream->non_realtime_set_speed ();
 529 }
 530
 531 int
 532 Track::overwrite_existing_buffers ()
 533 {
 534         return _diskstream->overwrite_existing_buffers ();
 535 }
 536
 537 framecnt_t
 538 Track::get_captured_frames (uint32_t n) const
 539 {
 540         return _diskstream->get_captured_frames (n);
 541 }
 542
 543 int
 544 Track::set_loop (Location* l)
 545 {
 546         return _diskstream->set_loop (l);
 547 }
 548
 549 void
 550 Track::transport_looped (framepos_t p)
 551 {
 552         _diskstream->transport_looped (p);
 553 }
 554
 555 bool
 556 Track::realtime_set_speed (double s, bool g)
 557 {
 558         return _diskstream->realtime_set_speed (s, g);
 559 }
 560
 561 void
 562 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 563 {
 564         _diskstream->transport_stopped_wallclock (n, t, g);
 565 }
 566
 567 bool
 568 Track::pending_overwrite () const
 569 {
 570         return _diskstream->pending_overwrite ();
 571 }
 572
 573 double
 574 Track::speed () const
 575 {
 576         return _diskstream->speed ();
 577 }
 578
 579 void
 580 Track::prepare_to_stop (framepos_t p)
 581 {
 582         _diskstream->prepare_to_stop (p);
 583 }
 584
 585 void
 586 Track::set_slaved (bool s)
 587 {
 588         _diskstream->set_slaved (s);
 589 }
 590
 591 ChanCount
 592 Track::n_channels ()
 593 {
 594         return _diskstream->n_channels ();
 595 }
 596
 597 framepos_t
 598 Track::get_capture_start_frame (uint32_t n) const
 599 {
 600         return _diskstream->get_capture_start_frame (n);
 601 }
 602
 603 AlignStyle
 604 Track::alignment_style () const
 605 {
 606         return _diskstream->alignment_style ();
 607 }
 608
 609 AlignChoice
 610 Track::alignment_choice () const
 611 {
 612         return _diskstream->alignment_choice ();
 613 }
 614
 615 framepos_t
 616 Track::current_capture_start () const
 617 {
 618         return _diskstream->current_capture_start ();
 619 }
 620
 621 framepos_t
 622 Track::current_capture_end () const
 623 {
 624         return _diskstream->current_capture_end ();
 625 }
 626
 627 void
 628 Track::playlist_modified ()
 629 {
 630         _diskstream->playlist_modified ();
 631 }
 632
 633 int
 634 Track::use_playlist (boost::shared_ptr<Playlist> p)
 635 {
 636         return _diskstream->use_playlist (p);
 637 }
 638
 639 int
 640 Track::use_copy_playlist ()
 641 {
 642         return _diskstream->use_copy_playlist ();
 643 }
 644
 645 int
 646 Track::use_new_playlist ()
 647 {
 648         return _diskstream->use_new_playlist ();
 649 }
 650
 651 void
 652 Track::set_align_style (AlignStyle s, bool force)
 653 {
 654         _diskstream->set_align_style (s, force);
 655 }
 656
 657 void
 658 Track::set_align_choice (AlignChoice s, bool force)
 659 {
 660         _diskstream->set_align_choice (s, force);
 661 }
 662
 663 PBD::ID const &
 664 Track::diskstream_id () const
 665 {
 666         return _diskstream->id ();
 667 }
 668
 669 void
 670 Track::set_block_size (pframes_t n)
 671 {
 672         Route::set_block_size (n);
 673         _diskstream->set_block_size (n);
 674 }
 675
 676 void
 677 Track::adjust_playback_buffering ()
 678 {
 679         if (_diskstream) {
 680                 _diskstream->adjust_playback_buffering ();
 681         }
 682 }
 683
 684 void
 685 Track::adjust_capture_buffering ()
 686 {
 687         if (_diskstream) {
 688                 _diskstream->adjust_capture_buffering ();
 689         }
 690 }
 691
 692 bool
 693 Track::send_silence () const
 694 {
 695         bool send_silence;
 696
 697         if (Config->get_tape_machine_mode()) {
 698
 699                 /* ADATs work in a strange way..
 700                    they monitor input always when stopped.and auto-input is engaged.
 701                 */
 702
 703                 if ((Config->get_monitoring_model() == SoftwareMonitoring)
 704                     && ((_monitoring & MonitorInput) || (_diskstream->record_enabled()))) {
 705                         send_silence = false;
 706                 } else {
 707                         send_silence = true;
 708                 }
 709
 710
 711         } else {
 712
 713                 /* Other machines switch to input on stop if the track is record enabled,
 714                    regardless of the auto input setting (auto input only changes the
 715                    monitoring state when the transport is rolling)
 716                 */
 717
 718                 if ((Config->get_monitoring_model() == SoftwareMonitoring)
 719                     && ((_monitoring & MonitorInput) ||
 720                         (!(_monitoring & MonitorDisk) && (_session.config.get_auto_input () || _diskstream->record_enabled())))){
 721
 722                         DEBUG_TRACE (DEBUG::Monitor,
 723                                      string_compose ("%1: no roll, use silence = FALSE,  monitoring choice %2 recenable %3 sRA %4 autoinput %5\n",
 724                                                      name(), enum_2_string (_monitoring),
 725                                                      _diskstream->record_enabled(), _session.actively_recording(),
 726                                                      _session.config.get_auto_input()));
 727
 728                         send_silence = false;
 729                 } else {
 730                         DEBUG_TRACE (DEBUG::Monitor,
 731                                      string_compose ("%1: no roll, use silence = TRUE,  monitoring choice %2 recenable %3 sRA %4 autoinput %5\n",
 732                                                      name(), enum_2_string (_monitoring),
 733                                                      _diskstream->record_enabled(), _session.actively_recording(),
 734                                                      _session.config.get_auto_input()));
 735                         send_silence = true;
 736                 }
 737         }
 738
 739         return send_silence;
 740 }
 741
 742 MonitorState
 743 Track::monitoring_state ()
 744 {
 745         MonitorState ms = MonitoringSilence;
 746
 747         if (_session.transport_rolling()) {
 748
 749                 /* roll case */
 750
 751                 if (_monitoring & MonitorInput) { // explicitly requested input monitoring
 752
 753                         ms = MonitoringInput;
 754
 755                 } else if (_monitoring & MonitorDisk) { // explicitly requested disk monitoring
 756
 757                         ms = MonitoringDisk;
 758
 759                 } else if (_diskstream->record_enabled() && _session.actively_recording()) { // Track actually recording
 760
 761                         ms = MonitoringInput;
 762
 763                 } else if (_diskstream->record_enabled() && !_session.actively_recording() && _session.config.get_auto_input()) { // Track armed but not recording, with auto input enabled
 764
 765                         ms = MonitoringInput;
 766
 767                 } else { // Every other state
 768
 769                         ms = MonitoringDisk;
 770
 771                 }
 772
 773         } else {
 774
 775                 /* no-roll case */
 776
 777                 if (send_silence()) {
 778
 779                         ms = MonitoringSilence;
 780                 } else {
 781
 782                         ms = MonitoringInput;
 783                 }
 784         }
 785
 786         return ms;
 787 }
 788
 789 void
 790 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
 791 {
 792         /* never declick if there is an internal generator - we just want it to
 793            keep generating sound without interruption.
 794
 795            ditto if we are monitoring inputs.
 796         */
 797
 798         if (_have_internal_generator || monitoring_choice() == MonitorInput) {
 799                 return;
 800         }
 801
 802         if (!declick) {
 803                 declick = _pending_declick;
 804         }
 805
 806         if (declick != 0) {
 807                 Amp::declick (bufs, nframes, declick);
 808         }
 809 }
 810
 811 framecnt_t
 812 Track::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
 813 {
 814         if (_roll_delay > nframes) {
 815
 816                 _roll_delay -= nframes;
 817                 silence_unlocked (nframes);
 818                 /* transport frame is not legal for caller to use */
 819                 return 0;
 820
 821         } else if (_roll_delay > 0) {
 822
 823                 nframes -= _roll_delay;
 824                 silence_unlocked (_roll_delay);
 825                 transport_frame += _roll_delay;
 826
 827                 /* shuffle all the port buffers for things that lead "out" of this Route
 828                    to reflect that we just wrote _roll_delay frames of silence.
 829                 */
 830
 831                 Glib::RWLock::ReaderLock lm (_processor_lock);
 832                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 833                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
 834                         if (iop) {
 835                                 iop->increment_port_buffer_offset (_roll_delay);
 836                         }
 837                 }
 838                 _output->increment_port_buffer_offset (_roll_delay);
 839
 840                 _roll_delay = 0;
 841
 842         }
 843
 844         return nframes;
 845 }
 846
 847 void
 848 Track::set_monitoring (MonitorChoice mc)
 849 {
 850         if (mc !=  _monitoring) {
 851                 _monitoring = mc;
 852                 MonitoringChanged (); /* EMIT SIGNAL */
 853         }
 854 }
 855