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/amp.h"
  26 #include "ardour/audioengine.h"
  27 #include "ardour/buffer_set.h"
  28 #include "ardour/debug.h"
  29 #include "ardour/delivery.h"
  30 #include "ardour/io.h"
  31 #include "ardour/mute_master.h"
  32 #include "ardour/pannable.h"
  33 #include "ardour/panner_shell.h"
  34 #include "ardour/port.h"
  35 #include "ardour/session.h"
  36
  37 #include "i18n.h"
  38
  39 namespace ARDOUR { class Panner; }
  40
  41 using namespace std;
  42 using namespace PBD;
  43 using namespace ARDOUR;
  44
  45 PBD::Signal0<void>            Delivery::PannersLegal;
  46 bool                          Delivery::panners_legal = false;
  47
  48 /* deliver to an existing IO object */
  49
  50 Delivery::Delivery (Session& s, boost::shared_ptr<IO> io, boost::shared_ptr<Pannable> pannable,
  51                     boost::shared_ptr<MuteMaster> mm, const string& name, Role r)
  52         : IOProcessor(s, boost::shared_ptr<IO>(), (role_requires_output_ports (r) ? io : boost::shared_ptr<IO>()), name)
  53         , _role (r)
  54         , _output_buffers (new BufferSet())
  55         , _amp (new Amp (s))
  56         , _no_outs_cuz_we_no_monitor (false)
  57         , _mute_master (mm)
  58         , _no_panner_reset (false)
  59 {
  60         if (pannable) {
  61                 bool is_send = false;
  62                 if (r & (Delivery::Send|Delivery::Aux)) is_send = true;
  63                 _panshell = boost::shared_ptr<PannerShell>(new PannerShell (_name, _session, pannable, is_send));
  64         }
  65
  66         _display_to_user = false;
  67
  68         if (_output) {
  69                 _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
  70         }
  71
  72         _amp->activate ();
  73 }
  74
  75 /* deliver to a new IO object */
  76
  77 Delivery::Delivery (Session& s, boost::shared_ptr<Pannable> pannable, boost::shared_ptr<MuteMaster> mm, const string& name, Role r)
  78         : IOProcessor(s, false, (role_requires_output_ports (r) ? true : false), name, "", DataType::AUDIO, (r == Send))
  79         , _role (r)
  80         , _output_buffers (new BufferSet())
  81         , _amp (new Amp (s))
  82         , _no_outs_cuz_we_no_monitor (false)
  83         , _mute_master (mm)
  84         , _no_panner_reset (false)
  85 {
  86         if (pannable) {
  87                 bool is_send = false;
  88                 if (r & (Delivery::Send|Delivery::Aux)) is_send = true;
  89                 _panshell = boost::shared_ptr<PannerShell>(new PannerShell (_name, _session, pannable, is_send));
  90         }
  91
  92         _display_to_user = false;
  93
  94         if (_output) {
  95                 _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
  96         }
  97
  98         _amp->activate ();
  99 }
 100
 101 Delivery::~Delivery()
 102 {
 103         DEBUG_TRACE (DEBUG::Destruction, string_compose ("delivery %1 destructor\n", _name));
 104
 105         /* this object should vanish from any signal callback lists
 106            that it is on before we get any further. The full qualification
 107            of the method name is not necessary, but is here to make it
 108            clear that this call is about signals, not data flow connections.
 109         */
 110
 111         ScopedConnectionList::drop_connections ();
 112
 113         delete _output_buffers;
 114 }
 115
 116 std::string
 117 Delivery::display_name () const
 118 {
 119         switch (_role) {
 120         case Main:
 121                 return _("main outs");
 122                 break;
 123         case Listen:
 124                 return _("listen");
 125                 break;
 126         case Send:
 127         case Insert:
 128         default:
 129                 return name();
 130         }
 131 }
 132
 133 bool
 134 Delivery::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 135 {
 136         if (_role == Main) {
 137
 138                 /* the out buffers will be set to point to the port output buffers
 139                    of our output object.
 140                 */
 141
 142                 if (_output) {
 143                         if (_output->n_ports() != ChanCount::ZERO) {
 144                                 /* increase number of output ports if the processor chain requires it */
 145                                 out = ChanCount::max (_output->n_ports(), in);
 146                                 return true;
 147                         } else {
 148                                 /* not configured yet - we will passthru */
 149                                 out = in;
 150                                 return true;
 151                         }
 152                 } else {
 153                         fatal << "programming error: this should never be reached" << endmsg;
 154                         abort(); /*NOTREACHED*/
 155                 }
 156
 157
 158         } else if (_role == Insert) {
 159
 160                 /* the output buffers will be filled with data from the *input* ports
 161                    of this Insert.
 162                 */
 163
 164                 if (_input) {
 165                         if (_input->n_ports() != ChanCount::ZERO) {
 166                                 out = _input->n_ports();
 167                                 return true;
 168                         } else {
 169                                 /* not configured yet - we will passthru */
 170                                 out = in;
 171                                 return true;
 172                         }
 173                 } else {
 174                         fatal << "programming error: this should never be reached" << endmsg;
 175                         abort(); /*NOTREACHED*/
 176                 }
 177
 178         } else {
 179                 fatal << "programming error: this should never be reached" << endmsg;
 180         }
 181
 182         return false;
 183 }
 184
 185 /** Caller must hold process lock */
 186 bool
 187 Delivery::configure_io (ChanCount in, ChanCount out)
 188 {
 189 #ifndef NDEBUG
 190         bool r = AudioEngine::instance()->process_lock().trylock();
 191         assert (!r && "trylock inside Delivery::configure_io");
 192 #endif
 193
 194         /* check configuration by comparison with our I/O port configuration, if appropriate.
 195            see ::can_support_io_configuration() for comments
 196         */
 197
 198         if (_role == Main) {
 199
 200                 if (_output) {
 201                         if (_output->n_ports() != out) {
 202                                 if (_output->n_ports() != ChanCount::ZERO) {
 203                                         _output->ensure_io (out, false, this);
 204                                 } else {
 205                                         /* I/O not yet configured */
 206                                 }
 207                         }
 208                 }
 209
 210         } else if (_role == Insert) {
 211
 212                 if (_input) {
 213                         if (_input->n_ports() != in) {
 214                                 if (_input->n_ports() != ChanCount::ZERO) {
 215                                         fatal << _name << " programming error: configure_io called with " << in << " and " << out << " with " << _input->n_ports() << " input ports" << endmsg;
 216                                         abort(); /*NOTREACHED*/
 217                                 } else {
 218                                         /* I/O not yet configured */
 219                                 }
 220                         }
 221                 }
 222
 223         }
 224
 225         if (!Processor::configure_io (in, out)) {
 226                 return false;
 227         }
 228
 229         reset_panner ();
 230
 231         return true;
 232 }
 233
 234 void
 235 Delivery::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool result_required)
 236 {
 237         assert (_output);
 238
 239         PortSet& ports (_output->ports());
 240         gain_t tgain;
 241         bool need_amp = true;
 242
 243         if (_output->n_ports ().get (_output->default_type()) == 0) {
 244                 goto out;
 245         }
 246
 247         if (!_active && !_pending_active) {
 248                 _output->silence (nframes);
 249                 goto out;
 250         }
 251
 252         /* this setup is not just for our purposes, but for anything that comes after us in the
 253            processing pathway that wants to use this->output_buffers() for some reason.
 254         */
 255
 256         // TODO delayline -- latency-compensation
 257         output_buffers().get_backend_port_addresses (ports, nframes);
 258
 259         // this Delivery processor is not a derived type, and thus we assume
 260         // we really can modify the buffers passed in (it is almost certainly
 261         // the main output stage of a Route). Contrast with Send::run()
 262         // which cannot do this.
 263
 264         tgain = target_gain ();
 265
 266         if (tgain < GAIN_COEFF_SMALL && _amp->gain() < GAIN_COEFF_SMALL) {
 267
 268                 /* special case (but very common) fast path:
 269                  *
 270                  * if we are supposed to be silent, and we were already silent,
 271                  * then short-circuit the computation in Amp and just put silence into
 272                  * our output(s)
 273                  */
 274
 275                 _output->silence (nframes);
 276
 277                 if (!result_required) {
 278                         /* if !result_required, then the buffers won't actually
 279                          * be used. This means we don't actually need to silence
 280                          * them, because we've already filled the output ports
 281                          * with silence.
 282                          *
 283                          * but we just noted that result_required is true,
 284                          * and so we do need to run the amp to ensure
 285                          * that the buffers are silenced.
 286                          */
 287                         need_amp = false;
 288                 }
 289         }
 290
 291         if (need_amp) {
 292
 293                 bufs.set_count (output_buffers().count ());
 294
 295                 if (_role != Main) {
 296
 297                         /* inserts, external and internal sends have
 298                          * automatable gain and the Amp::run() method has
 299                          * already been executed by the time we get here.
 300                          *
 301                          * XXX we do not expose the automatable gain for
 302                          * Inserts as of September 2015.
 303                          */
 304
 305                 } else {
 306
 307                         /* main outs have no automatable gain, the amp is just
 308                          * used for ramping gain changes caused by monitoring
 309                          * state changes.
 310                          */
 311
 312                         _amp->set_gain (tgain, this);
 313                         _amp->run (bufs, 0, 0, nframes, false);
 314
 315                 }
 316
 317         } else {
 318                 goto out;
 319         }
 320
 321         if (_panshell && !_panshell->bypassed() && _panshell->panner()) {
 322
 323                 // Use the panner to distribute audio to output port buffers
 324
 325                 _panshell->run (bufs, output_buffers(), start_frame, end_frame, nframes);
 326
 327                 // MIDI data will not have been delivered by the panner
 328
 329                 if (bufs.count().n_midi() > 0 && ports.count().n_midi () > 0) {
 330                         _output->copy_to_outputs (bufs, DataType::MIDI, nframes, 0);
 331                 }
 332
 333         } else {
 334
 335                 // Do a 1:1 copy of data to output ports
 336
 337                 if (bufs.count().n_audio() > 0 && ports.count().n_audio () > 0) {
 338                         _output->copy_to_outputs (bufs, DataType::AUDIO, nframes, 0);
 339                 }
 340
 341                 if (bufs.count().n_midi() > 0 && ports.count().n_midi () > 0) {
 342                         _output->copy_to_outputs (bufs, DataType::MIDI, nframes, 0);
 343                 }
 344         }
 345
 346         if (result_required) {
 347                 bufs.read_from (output_buffers (), nframes);
 348         }
 349
 350   out:
 351         _active = _pending_active;
 352 }
 353
 354 XMLNode&
 355 Delivery::state (bool full_state)
 356 {
 357         XMLNode& node (IOProcessor::state (full_state));
 358
 359         if (_role & Main) {
 360                 node.add_property("type", "main-outs");
 361         } else if (_role & Listen) {
 362                 node.add_property("type", "listen");
 363         } else {
 364                 node.add_property("type", "delivery");
 365         }
 366
 367         node.add_property("role", enum_2_string(_role));
 368
 369         if (_panshell) {
 370                 node.add_child_nocopy (_panshell->get_state ());
 371                 if (_panshell->pannable()) {
 372                         node.add_child_nocopy (_panshell->pannable()->get_state ());
 373                 }
 374         }
 375
 376         return node;
 377 }
 378
 379 int
 380 Delivery::set_state (const XMLNode& node, int version)
 381 {
 382         const XMLProperty* prop;
 383
 384         if (IOProcessor::set_state (node, version)) {
 385                 return -1;
 386         }
 387
 388         if ((prop = node.property ("role")) != 0) {
 389                 _role = Role (string_2_enum (prop->value(), _role));
 390                 // std::cerr << this << ' ' << _name << " set role to " << enum_2_string (_role) << std::endl;
 391         } else {
 392                 // std::cerr << this << ' ' << _name << " NO ROLE INFO\n";
 393         }
 394
 395         XMLNode* pan_node = node.child (X_("PannerShell"));
 396
 397         if (pan_node && _panshell) {
 398                 _panshell->set_state (*pan_node, version);
 399         }
 400
 401         reset_panner ();
 402
 403         XMLNode* pannnode = node.child (X_("Pannable"));
 404         if (_panshell && _panshell->panner() && pannnode) {
 405                 _panshell->pannable()->set_state (*pannnode, version);
 406         }
 407
 408         return 0;
 409 }
 410
 411 void
 412 Delivery::unpan ()
 413 {
 414         /* caller must hold process lock */
 415
 416         _panshell.reset ();
 417 }
 418
 419 uint32_t
 420 Delivery::pan_outs () const
 421 {
 422         if (_output) {
 423                 return _output->n_ports().n_audio();
 424         }
 425
 426         return _configured_output.n_audio();
 427 }
 428
 429 void
 430 Delivery::reset_panner ()
 431 {
 432         if (panners_legal) {
 433                 if (!_no_panner_reset) {
 434
 435                         if (_panshell && _role != Insert && _role != Listen) {
 436                                 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
 437                         }
 438                 }
 439
 440         } else {
 441                 panner_legal_c.disconnect ();
 442                 PannersLegal.connect_same_thread (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
 443         }
 444 }
 445
 446 void
 447 Delivery::panners_became_legal ()
 448 {
 449         if (_panshell && _role != Insert) {
 450                 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
 451         }
 452
 453         panner_legal_c.disconnect ();
 454 }
 455
 456 void
 457 Delivery::defer_pan_reset ()
 458 {
 459         _no_panner_reset = true;
 460 }
 461
 462 void
 463 Delivery::allow_pan_reset ()
 464 {
 465         _no_panner_reset = false;
 466         reset_panner ();
 467 }
 468
 469
 470 int
 471 Delivery::disable_panners ()
 472 {
 473         panners_legal = false;
 474         return 0;
 475 }
 476
 477 void
 478 Delivery::reset_panners ()
 479 {
 480         panners_legal = true;
 481         PannersLegal ();
 482 }
 483
 484 void
 485 Delivery::flush_buffers (framecnt_t nframes)
 486 {
 487         /* io_lock, not taken: function must be called from Session::process() calltree */
 488
 489         if (!_output) {
 490                 return;
 491         }
 492
 493         PortSet& ports (_output->ports());
 494
 495         for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 496                 i->flush_buffers (nframes);
 497         }
 498 }
 499
 500 void
 501 Delivery::transport_stopped (framepos_t now)
 502 {
 503         Processor::transport_stopped (now);
 504
 505         if (_panshell) {
 506                 _panshell->pannable()->transport_stopped (now);
 507         }
 508
 509         if (_output) {
 510                 PortSet& ports (_output->ports());
 511
 512                 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 513                         i->transport_stopped ();
 514                 }
 515         }
 516 }
 517
 518 void
 519 Delivery::realtime_locate ()
 520 {
 521         if (_output) {
 522                 PortSet& ports (_output->ports());
 523
 524                 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 525                         i->realtime_locate ();
 526                 }
 527         }
 528 }
 529
 530 gain_t
 531 Delivery::target_gain ()
 532 {
 533         /* if we've been requested to deactivate, our target gain is zero */
 534
 535         if (!_pending_active) {
 536                 return GAIN_COEFF_ZERO;
 537         }
 538
 539         /* if we've been told not to output because its a monitoring situation and
 540            we're not monitoring, then be quiet.
 541         */
 542
 543         if (_role == Main && _session.config.get_use_monitor_fades() && _no_outs_cuz_we_no_monitor) {
 544                 return GAIN_COEFF_ZERO;
 545         }
 546
 547         MuteMaster::MutePoint mp = MuteMaster::Main; // stupid gcc uninit warning
 548
 549         switch (_role) {
 550         case Main:
 551                 mp = MuteMaster::Main;
 552                 break;
 553         case Listen:
 554                 mp = MuteMaster::Listen;
 555                 break;
 556         case Send:
 557         case Insert:
 558         case Aux:
 559                 if (_pre_fader) {
 560                         mp = MuteMaster::PreFader;
 561                 } else {
 562                         mp = MuteMaster::PostFader;
 563                 }
 564                 break;
 565         }
 566
 567         gain_t desired_gain = _mute_master->mute_gain_at (mp);
 568
 569         if (_role == Listen && _session.monitor_out() && !_session.listening()) {
 570
 571                 /* nobody is soloed, and this delivery is a listen-send to the
 572                    control/monitor/listen bus, we should be silent since
 573                    it gets its signal from the master out.
 574                 */
 575
 576                 desired_gain = GAIN_COEFF_ZERO;
 577
 578         }
 579
 580         return desired_gain;
 581 }
 582
 583 void
 584 Delivery::no_outs_cuz_we_no_monitor (bool yn)
 585 {
 586         _no_outs_cuz_we_no_monitor = yn;
 587 }
 588
 589 bool
 590 Delivery::set_name (const std::string& name)
 591 {
 592         bool ret = IOProcessor::set_name (name);
 593
 594         if (ret && _panshell) {
 595                 ret = _panshell->set_name (name);
 596         }
 597
 598         return ret;
 599 }
 600
 601 bool ignore_output_change = false;
 602
 603 void
 604 Delivery::output_changed (IOChange change, void* /*src*/)
 605 {
 606         if (change.type & IOChange::ConfigurationChanged) {
 607                 reset_panner ();
 608                 _output_buffers->attach_buffers (_output->ports ());
 609         }
 610 }
 611
 612 boost::shared_ptr<Panner>
 613 Delivery::panner () const
 614 {
 615         if (_panshell) {
 616                 return _panshell->panner();
 617         } else {
 618                 return boost::shared_ptr<Panner>();
 619         }
 620 }
 621