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         , _current_gain (GAIN_COEFF_UNITY)
  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
  73 /* deliver to a new IO object */
  74
  75 Delivery::Delivery (Session& s, boost::shared_ptr<Pannable> pannable, boost::shared_ptr<MuteMaster> mm, const string& name, Role r)
  76         : IOProcessor(s, false, (role_requires_output_ports (r) ? true : false), name, "", DataType::AUDIO, (r == Send))
  77         , _role (r)
  78         , _output_buffers (new BufferSet())
  79         , _current_gain (GAIN_COEFF_UNITY)
  80         , _no_outs_cuz_we_no_monitor (false)
  81         , _mute_master (mm)
  82         , _no_panner_reset (false)
  83 {
  84         if (pannable) {
  85                 bool is_send = false;
  86                 if (r & (Delivery::Send|Delivery::Aux)) is_send = true;
  87                 _panshell = boost::shared_ptr<PannerShell>(new PannerShell (_name, _session, pannable, is_send));
  88         }
  89
  90         _display_to_user = false;
  91
  92         if (_output) {
  93                 _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
  94         }
  95 }
  96
  97
  98 Delivery::~Delivery()
  99 {
 100         DEBUG_TRACE (DEBUG::Destruction, string_compose ("delivery %1 destructor\n", _name));
 101
 102         /* this object should vanish from any signal callback lists
 103            that it is on before we get any further. The full qualification
 104            of the method name is not necessary, but is here to make it
 105            clear that this call is about signals, not data flow connections.
 106         */
 107
 108         ScopedConnectionList::drop_connections ();
 109
 110         delete _output_buffers;
 111 }
 112
 113 std::string
 114 Delivery::display_name () const
 115 {
 116         switch (_role) {
 117         case Main:
 118                 return _("main outs");
 119                 break;
 120         case Listen:
 121                 return _("listen");
 122                 break;
 123         case Send:
 124         case Insert:
 125         default:
 126                 return name();
 127         }
 128 }
 129
 130 bool
 131 Delivery::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 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                         abort(); /*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                         abort(); /*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 #ifndef NDEBUG
 187         bool r = AudioEngine::instance()->process_lock().trylock();
 188         assert (!r && "trylock inside Delivery::configure_io");
 189 #endif
 190
 191         /* check configuration by comparison with our I/O port configuration, if appropriate.
 192            see ::can_support_io_configuration() for comments
 193         */
 194
 195         if (_role == Main) {
 196
 197                 if (_output) {
 198                         if (_output->n_ports() != out) {
 199                                 if (_output->n_ports() != ChanCount::ZERO) {
 200                                         _output->ensure_io (out, false, this);
 201                                 } else {
 202                                         /* I/O not yet configured */
 203                                 }
 204                         }
 205                 }
 206
 207         } else if (_role == Insert) {
 208
 209                 if (_input) {
 210                         if (_input->n_ports() != in) {
 211                                 if (_input->n_ports() != ChanCount::ZERO) {
 212                                         fatal << _name << " programming error: configure_io called with " << in << " and " << out << " with " << _input->n_ports() << " input ports" << endmsg;
 213                                         abort(); /*NOTREACHED*/
 214                                 } else {
 215                                         /* I/O not yet configured */
 216                                 }
 217                         }
 218                 }
 219
 220         }
 221
 222         if (!Processor::configure_io (in, out)) {
 223                 return false;
 224         }
 225
 226         reset_panner ();
 227
 228         return true;
 229 }
 230
 231 void
 232 Delivery::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool result_required)
 233 {
 234         assert (_output);
 235
 236         PortSet& ports (_output->ports());
 237         gain_t tgain;
 238
 239         if (!_active && !_pending_active) {
 240                 _output->silence (nframes);
 241                 goto out;
 242         }
 243
 244         /* this setup is not just for our purposes, but for anything that comes after us in the
 245            processing pathway that wants to use this->output_buffers() for some reason.
 246         */
 247
 248         // TODO delayline -- latency-compensation
 249         output_buffers().get_backend_port_addresses (ports, nframes);
 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                 _current_gain = Amp::apply_gain (bufs, _session.nominal_frame_rate(), nframes, _current_gain, tgain);
 262
 263         } else if (tgain < GAIN_COEFF_SMALL) {
 264
 265                 /* we were quiet last time, and we're still supposed to be quiet.
 266                    Silence the outputs, and make sure the buffers are quiet too,
 267                 */
 268
 269                 _output->silence (nframes);
 270                 if (result_required) {
 271                         bufs.set_count (output_buffers().count ());
 272                         Amp::apply_simple_gain (bufs, nframes, GAIN_COEFF_ZERO);
 273                 }
 274                 goto out;
 275
 276         } else if (tgain != GAIN_COEFF_UNITY) {
 277
 278                 /* target gain has not changed, but is not unity */
 279                 Amp::apply_simple_gain (bufs, nframes, tgain);
 280         }
 281
 282         // Speed quietning
 283
 284         if (fabs (_session.transport_speed()) > 1.5 && Config->get_quieten_at_speed ()) {
 285                 Amp::apply_simple_gain (bufs, nframes, speed_quietning, false);
 286         }
 287
 288         // Panning
 289
 290         if (_panshell && !_panshell->bypassed() && _panshell->panner()) {
 291
 292                 // Use the panner to distribute audio to output port buffers
 293
 294                 _panshell->run (bufs, output_buffers(), start_frame, end_frame, nframes);
 295
 296                 // MIDI data will not have been delivered by the panner
 297
 298                 if (bufs.count().n_midi() > 0 && ports.count().n_midi () > 0) {
 299                         _output->copy_to_outputs (bufs, DataType::MIDI, nframes, ports.port(0)->port_offset());
 300                 }
 301
 302         } else {
 303
 304                 // Do a 1:1 copy of data to output ports
 305
 306                 if (bufs.count().n_audio() > 0 && ports.count().n_audio () > 0) {
 307                         _output->copy_to_outputs (bufs, DataType::AUDIO, nframes, 0);
 308                 }
 309
 310                 if (bufs.count().n_midi() > 0 && ports.count().n_midi () > 0) {
 311                         _output->copy_to_outputs (bufs, DataType::MIDI, nframes, ports.port(0)->port_offset());
 312                 }
 313         }
 314
 315         if (result_required) {
 316                 bufs.read_from (output_buffers (), nframes);
 317         }
 318
 319   out:
 320         _active = _pending_active;
 321 }
 322
 323 XMLNode&
 324 Delivery::state (bool full_state)
 325 {
 326         XMLNode& node (IOProcessor::state (full_state));
 327
 328         if (_role & Main) {
 329                 node.add_property("type", "main-outs");
 330         } else if (_role & Listen) {
 331                 node.add_property("type", "listen");
 332         } else {
 333                 node.add_property("type", "delivery");
 334         }
 335
 336         node.add_property("role", enum_2_string(_role));
 337
 338         if (_panshell) {
 339                 node.add_child_nocopy (_panshell->get_state ());
 340                 if (_panshell->pannable()) {
 341                         node.add_child_nocopy (_panshell->pannable()->get_state ());
 342                 }
 343         }
 344
 345         return node;
 346 }
 347
 348 int
 349 Delivery::set_state (const XMLNode& node, int version)
 350 {
 351         const XMLProperty* prop;
 352
 353         if (IOProcessor::set_state (node, version)) {
 354                 return -1;
 355         }
 356
 357         if ((prop = node.property ("role")) != 0) {
 358                 _role = Role (string_2_enum (prop->value(), _role));
 359                 // std::cerr << this << ' ' << _name << " set role to " << enum_2_string (_role) << std::endl;
 360         } else {
 361                 // std::cerr << this << ' ' << _name << " NO ROLE INFO\n";
 362         }
 363
 364         XMLNode* pan_node = node.child (X_("PannerShell"));
 365
 366         if (pan_node && _panshell) {
 367                 _panshell->set_state (*pan_node, version);
 368         }
 369
 370         reset_panner ();
 371
 372         XMLNode* pannnode = node.child (X_("Pannable"));
 373         if (_panshell && _panshell->panner() && pannnode) {
 374                 _panshell->pannable()->set_state (*pannnode, version);
 375         }
 376
 377         return 0;
 378 }
 379
 380 void
 381 Delivery::unpan ()
 382 {
 383         /* caller must hold process lock */
 384
 385         _panshell.reset ();
 386 }
 387
 388 uint32_t
 389 Delivery::pan_outs () const
 390 {
 391         if (_output) {
 392                 return _output->n_ports().n_audio();
 393         }
 394
 395         return _configured_output.n_audio();
 396 }
 397
 398 void
 399 Delivery::reset_panner ()
 400 {
 401         if (panners_legal) {
 402                 if (!_no_panner_reset) {
 403
 404                         if (_panshell && _role != Insert && _role != Listen) {
 405                                 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
 406                         }
 407                 }
 408
 409         } else {
 410                 panner_legal_c.disconnect ();
 411                 PannersLegal.connect_same_thread (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
 412         }
 413 }
 414
 415 void
 416 Delivery::panners_became_legal ()
 417 {
 418         if (_panshell && _role != Insert) {
 419                 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
 420         }
 421
 422         panner_legal_c.disconnect ();
 423 }
 424
 425 void
 426 Delivery::defer_pan_reset ()
 427 {
 428         _no_panner_reset = true;
 429 }
 430
 431 void
 432 Delivery::allow_pan_reset ()
 433 {
 434         _no_panner_reset = false;
 435         reset_panner ();
 436 }
 437
 438
 439 int
 440 Delivery::disable_panners ()
 441 {
 442         panners_legal = false;
 443         return 0;
 444 }
 445
 446 void
 447 Delivery::reset_panners ()
 448 {
 449         panners_legal = true;
 450         PannersLegal ();
 451 }
 452
 453 void
 454 Delivery::flush_buffers (framecnt_t nframes)
 455 {
 456         /* io_lock, not taken: function must be called from Session::process() calltree */
 457
 458         if (!_output) {
 459                 return;
 460         }
 461
 462         PortSet& ports (_output->ports());
 463
 464         for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 465                 i->flush_buffers (nframes);
 466         }
 467 }
 468
 469 void
 470 Delivery::transport_stopped (framepos_t now)
 471 {
 472         Processor::transport_stopped (now);
 473
 474         if (_panshell) {
 475                 _panshell->pannable()->transport_stopped (now);
 476         }
 477
 478         if (_output) {
 479                 PortSet& ports (_output->ports());
 480
 481                 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 482                         i->transport_stopped ();
 483                 }
 484         }
 485 }
 486
 487 void
 488 Delivery::realtime_locate ()
 489 {
 490         if (_output) {
 491                 PortSet& ports (_output->ports());
 492
 493                 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 494                         i->realtime_locate ();
 495                 }
 496         }
 497 }
 498
 499 gain_t
 500 Delivery::target_gain ()
 501 {
 502         /* if we've been requested to deactivate, our target gain is zero */
 503
 504         if (!_pending_active) {
 505                 return GAIN_COEFF_ZERO;
 506         }
 507
 508         /* if we've been told not to output because its a monitoring situation and
 509            we're not monitoring, then be quiet.
 510         */
 511
 512         if (_no_outs_cuz_we_no_monitor) {
 513                 return GAIN_COEFF_ZERO;
 514         }
 515
 516         MuteMaster::MutePoint mp = MuteMaster::Main; // stupid gcc uninit warning
 517
 518         switch (_role) {
 519         case Main:
 520                 mp = MuteMaster::Main;
 521                 break;
 522         case Listen:
 523                 mp = MuteMaster::Listen;
 524                 break;
 525         case Send:
 526         case Insert:
 527         case Aux:
 528                 if (_pre_fader) {
 529                         mp = MuteMaster::PreFader;
 530                 } else {
 531                         mp = MuteMaster::PostFader;
 532                 }
 533                 break;
 534         }
 535
 536         gain_t desired_gain = _mute_master->mute_gain_at (mp);
 537
 538         if (_role == Listen && _session.monitor_out() && !_session.listening()) {
 539
 540                 /* nobody is soloed, and this delivery is a listen-send to the
 541                    control/monitor/listen bus, we should be silent since
 542                    it gets its signal from the master out.
 543                 */
 544
 545                 desired_gain = GAIN_COEFF_ZERO;
 546
 547         }
 548
 549         return desired_gain;
 550 }
 551
 552 void
 553 Delivery::no_outs_cuz_we_no_monitor (bool yn)
 554 {
 555         _no_outs_cuz_we_no_monitor = yn;
 556 }
 557
 558 bool
 559 Delivery::set_name (const std::string& name)
 560 {
 561         bool ret = IOProcessor::set_name (name);
 562
 563         if (ret && _panshell) {
 564                 ret = _panshell->set_name (name);
 565         }
 566
 567         return ret;
 568 }
 569
 570 bool ignore_output_change = false;
 571
 572 void
 573 Delivery::output_changed (IOChange change, void* /*src*/)
 574 {
 575         if (change.type & IOChange::ConfigurationChanged) {
 576                 reset_panner ();
 577                 _output_buffers->attach_buffers (_output->ports ());
 578         }
 579 }
 580
 581 boost::shared_ptr<Panner>
 582 Delivery::panner () const
 583 {
 584         if (_panshell) {
 585                 return _panshell->panner();
 586         } else {
 587                 return boost::shared_ptr<Panner>();
 588         }
 589 }
 590