libs/ardour/delivery.cc

   1 /*
   2     Copyright (C) 2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify it
   5     under the terms of the GNU General Public License as published by the Free
   6     Software Foundation; either version 2 of the License, or (at your option)
   7     any later version.
   8
   9     This program is distributed in the hope that it will be useful, but WITHOUT
  10     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12     for more details.
  13
  14     You should have received a copy of the GNU General Public License along
  15     with this program; if not, write to the Free Software Foundation, Inc.,
  16     675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include <cmath>
  20 #include <algorithm>
  21
  22 #include "pbd/enumwriter.h"
  23 #include "pbd/convert.h"
  24
  25 #include "ardour/midi_buffer.h"
  26
  27 #include "ardour/delivery.h"
  28 #include "ardour/audio_buffer.h"
  29 #include "ardour/amp.h"
  30 #include "ardour/buffer_set.h"
  31 #include "ardour/configuration.h"
  32 #include "ardour/io.h"
  33 #include "ardour/meter.h"
  34 #include "ardour/mute_master.h"
  35 #include "ardour/panner.h"
  36 #include "ardour/port.h"
  37 #include "ardour/session.h"
  38 #include "ardour/audioengine.h"
  39
  40 #include "i18n.h"
  41
  42 using namespace std;
  43 using namespace PBD;
  44 using namespace ARDOUR;
  45
  46 PBD::Signal1<void, pframes_t> Delivery::CycleStart;
  47 PBD::Signal0<int>             Delivery::PannersLegal;
  48 bool                          Delivery::panners_legal = false;
  49
  50 /* deliver to an existing IO object */
  51
  52 Delivery::Delivery (Session& s, boost::shared_ptr<IO> io, boost::shared_ptr<MuteMaster> mm, const string& name, Role r)
  53         : IOProcessor(s, boost::shared_ptr<IO>(), (role_requires_output_ports (r) ? io : boost::shared_ptr<IO>()), name)
  54         , _role (r)
  55         , _output_buffers (new BufferSet())
  56         , _current_gain (1.0)
  57         , _output_offset (0)
  58         , _no_outs_cuz_we_no_monitor (false)
  59         , _mute_master (mm)
  60         , no_panner_reset (false)
  61 {
  62         _panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
  63         _display_to_user = false;
  64
  65         if (_output) {
  66                 _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
  67         }
  68
  69         CycleStart.connect_same_thread (*this, boost::bind (&Delivery::cycle_start, this, _1));
  70 }
  71
  72 /* deliver to a new IO object */
  73
  74 Delivery::Delivery (Session& s, boost::shared_ptr<MuteMaster> mm, const string& name, Role r)
  75         : IOProcessor(s, false, (role_requires_output_ports (r) ? true : false), name)
  76         , _role (r)
  77         , _output_buffers (new BufferSet())
  78         , _current_gain (1.0)
  79         , _output_offset (0)
  80         , _no_outs_cuz_we_no_monitor (false)
  81         , _mute_master (mm)
  82         , no_panner_reset (false)
  83 {
  84         _panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
  85         _display_to_user = false;
  86
  87         if (_output) {
  88                 _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
  89         }
  90
  91         CycleStart.connect_same_thread (*this, boost::bind (&Delivery::cycle_start, this, _1));
  92 }
  93
  94
  95 Delivery::~Delivery()
  96 {
  97         delete _output_buffers;
  98 }
  99
 100 std::string
 101 Delivery::display_name () const
 102 {
 103         switch (_role) {
 104         case Main:
 105                 return _("main outs");
 106                 break;
 107         case Listen:
 108                 return _("listen");
 109                 break;
 110         case Send:
 111         case Insert:
 112         default:
 113                 return name();
 114         }
 115 }
 116
 117 void
 118 Delivery::cycle_start (pframes_t /*nframes*/)
 119 {
 120         _output_offset = 0;
 121         _no_outs_cuz_we_no_monitor = false;
 122 }
 123
 124 void
 125 Delivery::increment_output_offset (framecnt_t n)
 126 {
 127         _output_offset += n;
 128 }
 129
 130 bool
 131 Delivery::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
 132 {
 133         if (_role == Main) {
 134
 135                 /* the out buffers will be set to point to the port output buffers
 136                    of our output object.
 137                 */
 138
 139                 if (_output) {
 140                         if (_output->n_ports() != ChanCount::ZERO) {
 141                                 /* increase number of output ports if the processor chain requires it */
 142                                 out = ChanCount::max (_output->n_ports(), in);
 143                                 return true;
 144                         } else {
 145                                 /* not configured yet - we will passthru */
 146                                 out = in;
 147                                 return true;
 148                         }
 149                 } else {
 150                         fatal << "programming error: this should never be reached" << endmsg;
 151                         /*NOTREACHED*/
 152                 }
 153
 154
 155         } else if (_role == Insert) {
 156
 157                 /* the output buffers will be filled with data from the *input* ports
 158                    of this Insert.
 159                 */
 160
 161                 if (_input) {
 162                         if (_input->n_ports() != ChanCount::ZERO) {
 163                                 out = _input->n_ports();
 164                                 return true;
 165                         } else {
 166                                 /* not configured yet - we will passthru */
 167                                 out = in;
 168                                 return true;
 169                         }
 170                 } else {
 171                         fatal << "programming error: this should never be reached" << endmsg;
 172                         /*NOTREACHED*/
 173                 }
 174
 175         } else {
 176                 fatal << "programming error: this should never be reached" << endmsg;
 177         }
 178
 179         return false;
 180 }
 181
 182 /** Caller must hold process lock */
 183 bool
 184 Delivery::configure_io (ChanCount in, ChanCount out)
 185 {
 186         assert (!AudioEngine::instance()->process_lock().trylock());
 187
 188         /* check configuration by comparison with our I/O port configuration, if appropriate.
 189            see ::can_support_io_configuration() for comments
 190         */
 191
 192         if (_role == Main) {
 193
 194                 if (_output) {
 195                         if (_output->n_ports() != out) {
 196                                 if (_output->n_ports() != ChanCount::ZERO) {
 197                                         _output->ensure_io (out, false, this);
 198                                 } else {
 199                                         /* I/O not yet configured */
 200                                 }
 201                         }
 202                 }
 203
 204         } else if (_role == Insert) {
 205
 206                 if (_input) {
 207                         if (_input->n_ports() != in) {
 208                                 if (_input->n_ports() != ChanCount::ZERO) {
 209                                         fatal << _name << " programming error: configure_io called with " << in << " and " << out << " with " << _input->n_ports() << " input ports" << endmsg;
 210                                         /*NOTREACHED*/
 211                                 } else {
 212                                         /* I/O not yet configured */
 213                                 }
 214                         }
 215                 }
 216
 217         }
 218
 219         if (!Processor::configure_io (in, out)) {
 220                 return false;
 221         }
 222
 223         reset_panner ();
 224
 225         return true;
 226 }
 227
 228 void
 229 Delivery::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool result_required)
 230 {
 231         assert (_output);
 232
 233         PortSet& ports (_output->ports());
 234         gain_t tgain;
 235
 236         if (_output->n_ports ().get (_output->default_type()) == 0) {
 237                 goto out;
 238         }
 239
 240         if (!_active && !_pending_active) {
 241                 _output->silence (nframes);
 242                 goto out;
 243         }
 244
 245         /* this setup is not just for our purposes, but for anything that comes after us in the
 246            processing pathway that wants to use this->output_buffers() for some reason.
 247         */
 248
 249         output_buffers().attach_buffers (ports, nframes, _output_offset);
 250
 251         // this Delivery processor is not a derived type, and thus we assume
 252         // we really can modify the buffers passed in (it is almost certainly
 253         // the main output stage of a Route). Contrast with Send::run()
 254         // which cannot do this.
 255
 256         tgain = target_gain ();
 257
 258         if (tgain != _current_gain) {
 259                 /* target gain has changed */
 260
 261                 Amp::apply_gain (bufs, nframes, _current_gain, tgain);
 262                 _current_gain = tgain;
 263
 264         } else if (tgain == 0.0) {
 265
 266                 /* we were quiet last time, and we're still supposed to be quiet.
 267                    Silence the outputs, and make sure the buffers are quiet too,
 268                 */
 269
 270                 _output->silence (nframes);
 271                 if (result_required) {
 272                         Amp::apply_simple_gain (bufs, nframes, 0.0);
 273                 }
 274                 goto out;
 275
 276         } else if (tgain != 1.0) {
 277
 278                 /* target gain has not changed, but is not unity */
 279                 Amp::apply_simple_gain (bufs, nframes, tgain);
 280         }
 281
 282         if (_panner && _panner->npanners() && !_panner->bypassed()) {
 283
 284                 // Use the panner to distribute audio to output port buffers
 285
 286                 _panner->run (bufs, output_buffers(), start_frame, end_frame, nframes);
 287
 288                 if (result_required) {
 289                         bufs.read_from (output_buffers (), nframes);
 290                 }
 291
 292         } else {
 293
 294                 // Do a 1:1 copy of data to output ports
 295
 296                 if (bufs.count().n_audio() > 0 && ports.count().n_audio () > 0) {
 297                         _output->copy_to_outputs (bufs, DataType::AUDIO, nframes, _output_offset);
 298                 }
 299
 300                 if (bufs.count().n_midi() > 0 && ports.count().n_midi () > 0) {
 301                         _output->copy_to_outputs (bufs, DataType::MIDI, nframes, _output_offset);
 302                 }
 303
 304
 305         }
 306
 307   out:
 308         _active = _pending_active;
 309 }
 310
 311 XMLNode&
 312 Delivery::state (bool full_state)
 313 {
 314         XMLNode& node (IOProcessor::state (full_state));
 315
 316         if (_role & Main) {
 317                 node.add_property("type", "main-outs");
 318         } else if (_role & Listen) {
 319                 node.add_property("type", "listen");
 320         } else {
 321                 node.add_property("type", "delivery");
 322         }
 323
 324         node.add_property("role", enum_2_string(_role));
 325         node.add_child_nocopy (_panner->state (full_state));
 326
 327         return node;
 328 }
 329
 330 int
 331 Delivery::set_state (const XMLNode& node, int version)
 332 {
 333         const XMLProperty* prop;
 334
 335         if (IOProcessor::set_state (node, version)) {
 336                 return -1;
 337         }
 338
 339         if ((prop = node.property ("role")) != 0) {
 340                 _role = Role (string_2_enum (prop->value(), _role));
 341                 // std::cerr << this << ' ' << _name << " set role to " << enum_2_string (_role) << std::endl;
 342         } else {
 343                 // std::cerr << this << ' ' << _name << " NO ROLE INFO\n";
 344         }
 345
 346         XMLNode* pan_node = node.child (X_("Panner"));
 347
 348         if (pan_node) {
 349                 _panner->set_state (*pan_node, version);
 350         }
 351
 352         reset_panner ();
 353
 354         return 0;
 355 }
 356
 357 void
 358 Delivery::reset_panner ()
 359 {
 360         if (panners_legal) {
 361                 if (!no_panner_reset) {
 362
 363                         uint32_t ntargets;
 364
 365                         if (_output) {
 366                                 ntargets = _output->n_ports().n_audio();
 367                         } else {
 368                                 ntargets = _configured_output.n_audio();
 369                         }
 370
 371                         _panner->reset (ntargets, pans_required());
 372                 }
 373         } else {
 374                 panner_legal_c.disconnect ();
 375                 PannersLegal.connect_same_thread (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
 376         }
 377 }
 378
 379 int
 380 Delivery::panners_became_legal ()
 381 {
 382         uint32_t ntargets;
 383
 384         if (_output) {
 385                 ntargets = _output->n_ports().n_audio();
 386         } else {
 387                 ntargets = _configured_output.n_audio();
 388         }
 389
 390         _panner->reset (ntargets, pans_required());
 391         _panner->load (); // automation
 392         panner_legal_c.disconnect ();
 393         return 0;
 394 }
 395
 396 void
 397 Delivery::defer_pan_reset ()
 398 {
 399         no_panner_reset = true;
 400 }
 401
 402 void
 403 Delivery::allow_pan_reset ()
 404 {
 405         no_panner_reset = false;
 406         reset_panner ();
 407 }
 408
 409
 410 int
 411 Delivery::disable_panners (void)
 412 {
 413         panners_legal = false;
 414         return 0;
 415 }
 416
 417 int
 418 Delivery::reset_panners ()
 419 {
 420         panners_legal = true;
 421         return *PannersLegal ();
 422 }
 423
 424
 425 void
 426 Delivery::start_pan_touch (uint32_t which, double when)
 427 {
 428         if (which < _panner->npanners()) {
 429                 _panner->pan_control(which)->start_touch(when);
 430         }
 431 }
 432
 433 void
 434 Delivery::end_pan_touch (uint32_t which, bool mark, double when)
 435 {
 436         if (which < _panner->npanners()) {
 437                 _panner->pan_control(which)->stop_touch(mark, when);
 438         }
 439
 440 }
 441
 442
 443 void
 444 Delivery::flush_buffers (framecnt_t nframes, framepos_t time)
 445 {
 446         /* io_lock, not taken: function must be called from Session::process() calltree */
 447
 448         PortSet& ports (_output->ports());
 449
 450         for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 451                 (*i).flush_buffers (nframes, time, _output_offset);
 452         }
 453 }
 454
 455 void
 456 Delivery::transport_stopped (framepos_t now)
 457 {
 458         Processor::transport_stopped (now);
 459
 460         _panner->transport_stopped (now);
 461
 462         if (_output) {
 463                 PortSet& ports (_output->ports());
 464
 465                 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 466                         (*i).transport_stopped ();
 467                 }
 468         }
 469 }
 470
 471 gain_t
 472 Delivery::target_gain ()
 473 {
 474         /* if we've been requested to deactivate, our target gain is zero */
 475
 476         if (!_pending_active) {
 477                 return 0.0;
 478         }
 479
 480         /* if we've been told not to output because its a monitoring situation and
 481            we're not monitoring, then be quiet.
 482         */
 483
 484         if (_no_outs_cuz_we_no_monitor) {
 485                 return 0.0;
 486         }
 487
 488         MuteMaster::MutePoint mp = MuteMaster::Main; // stupid gcc uninit warning
 489
 490         switch (_role) {
 491         case Main:
 492                 mp = MuteMaster::Main;
 493                 break;
 494         case Listen:
 495                 mp = MuteMaster::Listen;
 496                 break;
 497         case Send:
 498         case Insert:
 499         case Aux:
 500                 if (_pre_fader) {
 501                         mp = MuteMaster::PreFader;
 502                 } else {
 503                         mp = MuteMaster::PostFader;
 504                 }
 505                 break;
 506         }
 507
 508         gain_t desired_gain = _mute_master->mute_gain_at (mp);
 509
 510         if (_role == Listen && _session.monitor_out() && !_session.listening()) {
 511
 512                 /* nobody is soloed, and this delivery is a listen-send to the
 513                    control/monitor/listen bus, we should be silent since
 514                    it gets its signal from the master out.
 515                 */
 516
 517                 desired_gain = 0.0;
 518
 519         }
 520
 521         return desired_gain;
 522 }
 523
 524 void
 525 Delivery::no_outs_cuz_we_no_monitor (bool yn)
 526 {
 527         _no_outs_cuz_we_no_monitor = yn;
 528 }
 529
 530 bool
 531 Delivery::set_name (const std::string& name)
 532 {
 533         bool ret = IOProcessor::set_name (name);
 534
 535         if (ret) {
 536                 ret = _panner->set_name (name);
 537         }
 538
 539         return ret;
 540 }
 541
 542 void
 543 Delivery::output_changed (IOChange change, void* /*src*/)
 544 {
 545         if (change.type & IOChange::ConfigurationChanged) {
 546                 reset_panner ();
 547         }
 548 }
 549