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