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 #include <sigc++/retype.h>
  20 #include <sigc++/retype_return.h>
  21 #include <sigc++/bind.h>
  22
  23 #include "ardour/amp.h"
  24 #include "ardour/audioplaylist.h"
  25 #include "ardour/audioregion.h"
  26 #include "ardour/audiosource.h"
  27 #include "ardour/delivery.h"
  28 #include "ardour/diskstream.h"
  29 #include "ardour/io_processor.h"
  30 #include "ardour/meter.h"
  31 #include "ardour/port.h"
  32 #include "ardour/processor.h"
  33 #include "ardour/route_group_specialized.h"
  34 #include "ardour/session.h"
  35 #include "ardour/track.h"
  36 #include "ardour/utils.h"
  37
  38 #include "i18n.h"
  39
  40 using namespace std;
  41 using namespace ARDOUR;
  42 using namespace PBD;
  43
  44 Track::Track (Session& sess, string name, Route::Flag flag, TrackMode mode, DataType default_type)
  45         : Route (sess, name, flag, default_type)
  46         , _rec_enable_control (new RecEnableControllable(*this))
  47 {
  48         _declickable = true;
  49         _freeze_record.state = NoFreeze;
  50         _saved_meter_point = _meter_point;
  51         _mode = mode;
  52 }
  53
  54 Track::Track (Session& sess, const XMLNode& node, DataType default_type)
  55         : Route (sess, node, default_type)
  56         , _rec_enable_control (new RecEnableControllable(*this))
  57 {
  58         _freeze_record.state = NoFreeze;
  59         _declickable = true;
  60         _saved_meter_point = _meter_point;
  61 }
  62
  63 Track::~Track ()
  64 {
  65 }
  66
  67 void
  68 Track::set_meter_point (MeterPoint p, void *src)
  69 {
  70         Route::set_meter_point (p, src);
  71 }
  72
  73 XMLNode&
  74 Track::get_state ()
  75 {
  76         return state (true);
  77 }
  78
  79 XMLNode&
  80 Track::get_template ()
  81 {
  82         return state (false);
  83 }
  84
  85 void
  86 Track::toggle_monitor_input ()
  87 {
  88         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
  89                 i->ensure_monitor_input(!i->monitoring_input());
  90         }
  91 }
  92
  93 ARDOUR::nframes_t
  94 Track::update_total_latency ()
  95 {
  96         nframes_t old = _output->effective_latency();
  97         nframes_t own_latency = _output->user_latency();
  98
  99         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 100                 if ((*i)->active ()) {
 101                         own_latency += (*i)->signal_latency ();
 102                 }
 103         }
 104
 105 #undef DEBUG_LATENCY
 106 #ifdef DEBUG_LATENCY
 107         cerr << _name << ": internal redirect (final) latency = " << own_latency << endl;
 108 #endif
 109
 110         _output->set_port_latency (own_latency);
 111
 112         if (old != own_latency) {
 113                 _output->set_latency_delay (own_latency);
 114                 signal_latency_changed (); /* EMIT SIGNAL */
 115         }
 116
 117         return _output->effective_latency();
 118 }
 119
 120 Track::FreezeRecord::~FreezeRecord ()
 121 {
 122         for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
 123                 delete *i;
 124         }
 125 }
 126
 127 Track::FreezeState
 128 Track::freeze_state() const
 129 {
 130         return _freeze_record.state;
 131 }
 132
 133 Track::RecEnableControllable::RecEnableControllable (Track& s)
 134         : Controllable (X_("recenable")), track (s)
 135 {
 136 }
 137
 138 void
 139 Track::RecEnableControllable::set_value (float val)
 140 {
 141         bool bval = ((val >= 0.5f) ? true: false);
 142         track.set_record_enable (bval, this);
 143 }
 144
 145 float
 146 Track::RecEnableControllable::get_value (void) const
 147 {
 148         if (track.record_enabled()) { return 1.0f; }
 149         return 0.0f;
 150 }
 151
 152 bool
 153 Track::record_enabled () const
 154 {
 155         return _diskstream && _diskstream->record_enabled ();
 156 }
 157
 158 bool
 159 Track::can_record()
 160 {
 161         bool will_record = true;
 162         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
 163                 if (!i->connected())
 164                         will_record = false;
 165         }
 166
 167         return will_record;
 168 }
 169
 170 void
 171 Track::set_record_enable (bool yn, void *src)
 172 {
 173         if (!_session.writable()) {
 174                 return;
 175         }
 176
 177         if (_freeze_record.state == Frozen) {
 178                 return;
 179         }
 180
 181         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::RecEnable)) {
 182                 _route_group->apply (&Track::set_record_enable, yn, _route_group);
 183                 return;
 184         }
 185
 186         /* keep track of the meter point as it was before we rec-enabled */
 187         if (!_diskstream->record_enabled()) {
 188                 _saved_meter_point = _meter_point;
 189         }
 190
 191         _diskstream->set_record_enabled (yn);
 192
 193         if (_diskstream->record_enabled()) {
 194                 set_meter_point (MeterInput, this);
 195         } else {
 196                 set_meter_point (_saved_meter_point, this);
 197         }
 198
 199         _rec_enable_control->Changed ();
 200 }
 201
 202
 203 bool
 204 Track::set_name (const string& str)
 205 {
 206         bool ret;
 207
 208         if (record_enabled() && _session.actively_recording()) {
 209                 /* this messes things up if done while recording */
 210                 return false;
 211         }
 212
 213         if (_diskstream->set_name (str)) {
 214                 return false;
 215         }
 216
 217         /* save state so that the statefile fully reflects any filename changes */
 218
 219         if ((ret = Route::set_name (str)) == 0) {
 220                 _session.save_state ("");
 221         }
 222
 223         return ret;
 224 }
 225
 226 void
 227 Track::set_latency_delay (nframes_t longest_session_latency)
 228 {
 229         Route::set_latency_delay (longest_session_latency);
 230         _diskstream->set_roll_delay (_roll_delay);
 231 }
 232
 233 void
 234 Track::zero_diskstream_id_in_xml (XMLNode& node)
 235 {
 236         if (node.property ("diskstream-id")) {
 237                 node.add_property ("diskstream-id", "0");
 238         }
 239 }
 240
 241 int
 242 Track::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
 243                 bool session_state_changing, bool can_record, bool /*rec_monitors_input*/)
 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
 256                 /* XXX is this safe to do against transport state changes? */
 257
 258                 passthru_silence (start_frame, end_frame, nframes, 0);
 259                 return 0;
 260         }
 261
 262         diskstream()->check_record_status (start_frame, nframes, can_record);
 263
 264         bool send_silence;
 265
 266         if (_have_internal_generator) {
 267                 /* since the instrument has no input streams,
 268                    there is no reason to send any signal
 269                    into the route.
 270                 */
 271                 send_silence = true;
 272         } else {
 273                 if (!Config->get_tape_machine_mode()) {
 274                         /*
 275                            ADATs work in a strange way..
 276                            they monitor input always when stopped.and auto-input is engaged.
 277                         */
 278                         if ((Config->get_monitoring_model() == SoftwareMonitoring)
 279                                         && (_session.config.get_auto_input () || _diskstream->record_enabled())) {
 280                                 send_silence = false;
 281                         } else {
 282                                 send_silence = true;
 283                         }
 284                 } else {
 285                         /*
 286                            Other machines switch to input on stop if the track is record enabled,
 287                            regardless of the auto input setting (auto input only changes the
 288                            monitoring state when the transport is rolling)
 289                         */
 290                         if ((Config->get_monitoring_model() == SoftwareMonitoring)
 291                                         && _diskstream->record_enabled()) {
 292                                 send_silence = false;
 293                         } else {
 294                                 send_silence = true;
 295                         }
 296                 }
 297         }
 298
 299         _amp->apply_gain_automation(false);
 300
 301         if (send_silence) {
 302
 303                 /* if we're sending silence, but we want the meters to show levels for the signal,
 304                    meter right here.
 305                 */
 306
 307                 if (_have_internal_generator) {
 308                         passthru_silence (start_frame, end_frame, nframes, 0);
 309                 } else {
 310                         if (_meter_point == MeterInput) {
 311                                 _input->process_input (_meter, start_frame, end_frame, nframes);
 312                         }
 313                         passthru_silence (start_frame, end_frame, nframes, 0);
 314                 }
 315
 316         } else {
 317
 318                 /* we're sending signal, but we may still want to meter the input.
 319                  */
 320
 321                 passthru (start_frame, end_frame, nframes, false);
 322         }
 323
 324         _main_outs->flush (nframes, end_frame - start_frame - 1);
 325
 326         return 0;
 327 }
 328
 329 int
 330 Track::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
 331                     bool can_record, bool rec_monitors_input)
 332 {
 333         if (n_outputs().n_total() == 0 && _processors.empty()) {
 334                 return 0;
 335         }
 336
 337         if (!_active) {
 338                 silence (nframes);
 339                 return 0;
 340         }
 341
 342         _silent = true;
 343         _amp->apply_gain_automation(false);
 344
 345         silence (nframes);
 346
 347         return diskstream()->process (_session.transport_frame(), nframes, can_record, rec_monitors_input);
 348 }