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         , _rec_enable_control (new RecEnableControllable(*this))
  47 {
  48         _freeze_record.state = NoFreeze;
  49         _declickable = true;
  50 }
  51
  52 Track::~Track ()
  53 {
  54         DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
  55 }
  56
  57 int
  58 Track::init ()
  59 {
  60         if (Route::init ()) {
  61                 return -1;
  62         }
  63
  64         return 0;
  65 }
  66 XMLNode&
  67 Track::get_state ()
  68 {
  69         return state (true);
  70 }
  71
  72
  73
  74 XMLNode&
  75 Track::get_template ()
  76 {
  77         return state (false);
  78 }
  79
  80 void
  81 Track::toggle_monitor_input ()
  82 {
  83         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
  84                 i->ensure_monitor_input(!i->monitoring_input());
  85         }
  86 }
  87
  88 ARDOUR::framecnt_t
  89 Track::update_total_latency ()
  90 {
  91         framecnt_t old = _output->effective_latency();
  92         framecnt_t own_latency = _output->user_latency();
  93
  94         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
  95                 if ((*i)->active ()) {
  96                         own_latency += (*i)->signal_latency ();
  97                 }
  98         }
  99
 100 #undef DEBUG_LATENCY
 101 #ifdef DEBUG_LATENCY
 102         cerr << _name << ": internal redirect (final) latency = " << own_latency << endl;
 103 #endif
 104
 105         _output->set_port_latency (own_latency);
 106
 107         if (old != own_latency) {
 108                 _output->set_latency_delay (own_latency);
 109                 signal_latency_changed (); /* EMIT SIGNAL */
 110         }
 111
 112         return _output->effective_latency();
 113 }
 114
 115 Track::FreezeRecord::~FreezeRecord ()
 116 {
 117         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
 118                 delete *i;
 119         }
 120 }
 121
 122 Track::FreezeState
 123 Track::freeze_state() const
 124 {
 125         return _freeze_record.state;
 126 }
 127
 128 Track::RecEnableControllable::RecEnableControllable (Track& s)
 129         : Controllable (X_("recenable")), track (s)
 130 {
 131 }
 132
 133 void
 134 Track::RecEnableControllable::set_value (double val)
 135 {
 136         bool bval = ((val >= 0.5) ? true: false);
 137         track.set_record_enabled (bval, this);
 138 }
 139
 140 double
 141 Track::RecEnableControllable::get_value (void) const
 142 {
 143         if (track.record_enabled()) { return 1.0; }
 144         return 0.0;
 145 }
 146
 147 bool
 148 Track::record_enabled () const
 149 {
 150         return _diskstream && _diskstream->record_enabled ();
 151 }
 152
 153 bool
 154 Track::can_record()
 155 {
 156         bool will_record = true;
 157         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
 158                 if (!i->connected())
 159                         will_record = false;
 160         }
 161
 162         return will_record;
 163 }
 164
 165 void
 166 Track::set_record_enabled (bool yn, void *src)
 167 {
 168         if (!_session.writable()) {
 169                 return;
 170         }
 171
 172         if (_freeze_record.state == Frozen) {
 173                 return;
 174         }
 175
 176         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
 177                 _route_group->apply (&Track::set_record_enabled, yn, _route_group);
 178                 return;
 179         }
 180
 181         /* keep track of the meter point as it was before we rec-enabled */
 182         if (!_diskstream->record_enabled()) {
 183                 _saved_meter_point = _meter_point;
 184         }
 185
 186         _diskstream->set_record_enabled (yn);
 187
 188         if (_diskstream->record_enabled()) {
 189                 if (_meter_point != MeterCustom) {
 190                         set_meter_point (MeterInput);
 191                 }
 192         } else {
 193                 set_meter_point (_saved_meter_point);
 194         }
 195
 196         _rec_enable_control->Changed ();
 197 }
 198
 199
 200 bool
 201 Track::set_name (const string& str)
 202 {
 203         bool ret;
 204
 205         if (record_enabled() && _session.actively_recording()) {
 206                 /* this messes things up if done while recording */
 207                 return false;
 208         }
 209
 210         if (_diskstream->set_name (str)) {
 211                 return false;
 212         }
 213
 214         /* save state so that the statefile fully reflects any filename changes */
 215
 216         if ((ret = Route::set_name (str)) == 0) {
 217                 _session.save_state ("");
 218         }
 219
 220         return ret;
 221 }
 222
 223 void
 224 Track::set_latency_delay (framecnt_t longest_session_latency)
 225 {
 226         Route::set_latency_delay (longest_session_latency);
 227         _diskstream->set_roll_delay (_roll_delay);
 228 }
 229
 230 void
 231 Track::zero_diskstream_id_in_xml (XMLNode& node)
 232 {
 233         if (node.property ("diskstream-id")) {
 234                 node.add_property ("diskstream-id", "0");
 235         }
 236 }
 237
 238 int
 239 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 240                 bool session_state_changing, bool can_record, bool /*rec_monitors_input*/)
 241 {
 242         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 243         if (!lm.locked()) {
 244                 return 0;
 245         }
 246
 247         if (n_outputs().n_total() == 0) {
 248                 return 0;
 249         }
 250
 251         if (!_active) {
 252                 silence (nframes);
 253                 return 0;
 254         }
 255
 256         if (session_state_changing) {
 257                 if (_session.transport_speed() != 0.0f) {
 258                         /* we're rolling but some state is changing (e.g. our diskstream contents)
 259                            so we cannot use them. Be silent till this is over. Don't declick.
 260
 261                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
 262                         */
 263                         passthru_silence (start_frame, end_frame, nframes, 0);
 264                         return 0;
 265                 }
 266                 /* we're really not rolling, so we're either delivery silence or actually
 267                    monitoring, both of which are safe to do while session_state_changing is true.
 268                 */
 269         }
 270
 271         _diskstream->check_record_status (start_frame, can_record);
 272
 273         bool send_silence;
 274
 275         if (_have_internal_generator) {
 276                 /* since the instrument has no input streams,
 277                    there is no reason to send any signal
 278                    into the route.
 279                 */
 280                 send_silence = true;
 281         } else {
 282                 if (!Config->get_tape_machine_mode()) {
 283                         /*
 284                            ADATs work in a strange way..
 285                            they monitor input always when stopped.and auto-input is engaged.
 286                         */
 287                         if ((Config->get_monitoring_model() == SoftwareMonitoring)
 288                                         && (_session.config.get_auto_input () || _diskstream->record_enabled())) {
 289                                 send_silence = false;
 290                         } else {
 291                                 send_silence = true;
 292                         }
 293                 } else {
 294                         /*
 295                            Other machines switch to input on stop if the track is record enabled,
 296                            regardless of the auto input setting (auto input only changes the
 297                            monitoring state when the transport is rolling)
 298                         */
 299                         if ((Config->get_monitoring_model() == SoftwareMonitoring)
 300                                         && _diskstream->record_enabled()) {
 301                                 send_silence = false;
 302                         } else {
 303                                 send_silence = true;
 304                         }
 305                 }
 306         }
 307
 308         _amp->apply_gain_automation(false);
 309
 310         if (send_silence) {
 311
 312                 /* if we're sending silence, but we want the meters to show levels for the signal,
 313                    meter right here.
 314                 */
 315
 316                 if (_have_internal_generator) {
 317                         passthru_silence (start_frame, end_frame, nframes, 0);
 318                 } else {
 319                         if (_meter_point == MeterInput) {
 320                                 _input->process_input (_meter, start_frame, end_frame, nframes);
 321                         }
 322                         passthru_silence (start_frame, end_frame, nframes, 0);
 323                 }
 324
 325         } else {
 326
 327                 /* we're sending signal, but we may still want to meter the input.
 328                  */
 329
 330                 passthru (start_frame, end_frame, nframes, false);
 331         }
 332
 333         _main_outs->flush_buffers (nframes, end_frame - start_frame - 1);
 334
 335         return 0;
 336 }
 337
 338 int
 339 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
 340                     bool can_record, bool rec_monitors_input, bool& need_butler)
 341 {
 342         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
 343         if (!lm.locked()) {
 344                 return 0;
 345         }
 346
 347         if (n_outputs().n_total() == 0 && _processors.empty()) {
 348                 return 0;
 349         }
 350
 351         if (!_active) {
 352                 silence (nframes);
 353                 return 0;
 354         }
 355
 356         _silent = true;
 357         _amp->apply_gain_automation(false);
 358
 359         silence (nframes);
 360
 361         return _diskstream->process (_session.transport_frame(), nframes, can_record, rec_monitors_input, need_butler);
 362 }
 363
 364 ChanCount
 365 Track::input_streams () const
 366 {
 367         ChanCount cc = _input->n_ports ();
 368
 369         if (cc.n_total() == 0 && _diskstream) {
 370                 return cc = _diskstream->n_channels();
 371         }
 372
 373         return cc;
 374 }
 375
 376 void
 377 Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
 378 {
 379         _diskstream = ds;
 380
 381         ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
 382         diskstream_playlist_changed ();
 383         ds->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_record_enable_changed, this));
 384         ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
 385         ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
 386 }
 387
 388 void
 389 Track::diskstream_playlist_changed ()
 390 {
 391         PlaylistChanged (); /* EMIT SIGNAL */
 392 }
 393
 394 void
 395 Track::diskstream_record_enable_changed ()
 396 {
 397         RecordEnableChanged (); /* EMIT SIGNAL */
 398 }
 399
 400 void
 401 Track::diskstream_speed_changed ()
 402 {
 403         SpeedChanged (); /* EMIT SIGNAL */
 404 }
 405
 406 void
 407 Track::diskstream_alignment_style_changed ()
 408 {
 409         AlignmentStyleChanged (); /* EMIT SIGNAL */
 410 }
 411
 412 boost::shared_ptr<Playlist>
 413 Track::playlist ()
 414 {
 415         return _diskstream->playlist ();
 416 }
 417
 418 void
 419 Track::monitor_input (bool m)
 420 {
 421         _diskstream->monitor_input (m);
 422 }
 423
 424 bool
 425 Track::destructive () const
 426 {
 427         return _diskstream->destructive ();
 428 }
 429
 430 list<boost::shared_ptr<Source> > &
 431 Track::last_capture_sources ()
 432 {
 433         return _diskstream->last_capture_sources ();
 434 }
 435
 436 void
 437 Track::set_capture_offset ()
 438 {
 439         _diskstream->set_capture_offset ();
 440 }
 441
 442 list<boost::shared_ptr<Source> >
 443 Track::steal_write_sources()
 444 {
 445         return _diskstream->steal_write_sources ();
 446 }
 447
 448 void
 449 Track::reset_write_sources (bool r, bool force)
 450 {
 451         _diskstream->reset_write_sources (r, force);
 452 }
 453
 454 float
 455 Track::playback_buffer_load () const
 456 {
 457         return _diskstream->playback_buffer_load ();
 458 }
 459
 460 float
 461 Track::capture_buffer_load () const
 462 {
 463         return _diskstream->capture_buffer_load ();
 464 }
 465
 466 int
 467 Track::do_refill ()
 468 {
 469         return _diskstream->do_refill ();
 470 }
 471
 472 int
 473 Track::do_flush (RunContext c, bool force)
 474 {
 475         return _diskstream->do_flush (c, force);
 476 }
 477
 478 void
 479 Track::set_pending_overwrite (bool o)
 480 {
 481         _diskstream->set_pending_overwrite (o);
 482 }
 483
 484 int
 485 Track::seek (framepos_t p, bool complete_refill)
 486 {
 487         return _diskstream->seek (p, complete_refill);
 488 }
 489
 490 bool
 491 Track::hidden () const
 492 {
 493         return _diskstream->hidden ();
 494 }
 495
 496 int
 497 Track::can_internal_playback_seek (framepos_t p)
 498 {
 499         return _diskstream->can_internal_playback_seek (p);
 500 }
 501
 502 int
 503 Track::internal_playback_seek (framepos_t p)
 504 {
 505         return _diskstream->internal_playback_seek (p);
 506 }
 507
 508 void
 509 Track::non_realtime_input_change ()
 510 {
 511         _diskstream->non_realtime_input_change ();
 512 }
 513
 514 void
 515 Track::non_realtime_locate (framepos_t p)
 516 {
 517         _diskstream->non_realtime_locate (p);
 518 }
 519
 520 void
 521 Track::non_realtime_set_speed ()
 522 {
 523         _diskstream->non_realtime_set_speed ();
 524 }
 525
 526 int
 527 Track::overwrite_existing_buffers ()
 528 {
 529         return _diskstream->overwrite_existing_buffers ();
 530 }
 531
 532 framecnt_t
 533 Track::get_captured_frames (uint32_t n) const
 534 {
 535         return _diskstream->get_captured_frames (n);
 536 }
 537
 538 int
 539 Track::set_loop (Location* l)
 540 {
 541         return _diskstream->set_loop (l);
 542 }
 543
 544 void
 545 Track::transport_looped (framepos_t p)
 546 {
 547         _diskstream->transport_looped (p);
 548 }
 549
 550 bool
 551 Track::realtime_set_speed (double s, bool g)
 552 {
 553         return _diskstream->realtime_set_speed (s, g);
 554 }
 555
 556 void
 557 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 558 {
 559         _diskstream->transport_stopped_wallclock (n, t, g);
 560 }
 561
 562 bool
 563 Track::pending_overwrite () const
 564 {
 565         return _diskstream->pending_overwrite ();
 566 }
 567
 568 double
 569 Track::speed () const
 570 {
 571         return _diskstream->speed ();
 572 }
 573
 574 void
 575 Track::prepare_to_stop (framepos_t p)
 576 {
 577         _diskstream->prepare_to_stop (p);
 578 }
 579
 580 void
 581 Track::set_slaved (bool s)
 582 {
 583         _diskstream->set_slaved (s);
 584 }
 585
 586 ChanCount
 587 Track::n_channels ()
 588 {
 589         return _diskstream->n_channels ();
 590 }
 591
 592 framepos_t
 593 Track::get_capture_start_frame (uint32_t n) const
 594 {
 595         return _diskstream->get_capture_start_frame (n);
 596 }
 597
 598 AlignStyle
 599 Track::alignment_style () const
 600 {
 601         return _diskstream->alignment_style ();
 602 }
 603
 604 framepos_t
 605 Track::current_capture_start () const
 606 {
 607         return _diskstream->current_capture_start ();
 608 }
 609
 610 framepos_t
 611 Track::current_capture_end () const
 612 {
 613         return _diskstream->current_capture_end ();
 614 }
 615
 616 void
 617 Track::playlist_modified ()
 618 {
 619         _diskstream->playlist_modified ();
 620 }
 621
 622 int
 623 Track::use_playlist (boost::shared_ptr<Playlist> p)
 624 {
 625         return _diskstream->use_playlist (p);
 626 }
 627
 628 int
 629 Track::use_copy_playlist ()
 630 {
 631         return _diskstream->use_copy_playlist ();
 632 }
 633
 634 int
 635 Track::use_new_playlist ()
 636 {
 637         return _diskstream->use_new_playlist ();
 638 }
 639
 640 uint32_t
 641 Track::read_data_count () const
 642 {
 643         return _diskstream->read_data_count ();
 644 }
 645
 646 void
 647 Track::set_align_style (AlignStyle s)
 648 {
 649         _diskstream->set_align_style (s);
 650 }
 651
 652 uint32_t
 653 Track::write_data_count () const
 654 {
 655         return _diskstream->write_data_count ();
 656 }
 657
 658 PBD::ID const &
 659 Track::diskstream_id () const
 660 {
 661         return _diskstream->id ();
 662 }
 663
 664 void
 665 Track::set_block_size (pframes_t n)
 666 {
 667         Route::set_block_size (n);
 668         _diskstream->set_block_size (n);
 669 }
 670
 671 void
 672 Track::adjust_playback_buffering ()
 673 {
 674         if (_diskstream) {
 675                 _diskstream->adjust_playback_buffering ();
 676         }
 677 }
 678
 679 void
 680 Track::adjust_capture_buffering ()
 681 {
 682         if (_diskstream) {
 683                 _diskstream->adjust_capture_buffering ();
 684         }
 685 }