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