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 "pbd/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, double /*speed*/, pframes_t nframes, bool result_required)
 233 {
 234         assert (_output);
 235
 236         PortSet& ports (_output->ports());
 237         gain_t tgain;
 238
 239         if (ports.num_ports () == 0) {
 240                 goto out;
 241         }
 242
 243         if (!_active && !_pending_active) {
 244                 _output->silence (nframes);
 245                 goto out;
 246         }
 247
 248         /* this setup is not just for our purposes, but for anything that comes after us in the
 249          * processing pathway that wants to use this->output_buffers() for some reason.
 250          */
 251
 252         // TODO delayline -- latency-compensation
 253         output_buffers().get_backend_port_addresses (ports, nframes);
 254
 255         // this Delivery processor is not a derived type, and thus we assume
 256         // we really can modify the buffers passed in (it is almost certainly
 257         // the main output stage of a Route). Contrast with Send::run()
 258         // which cannot do this.
 259
 260         tgain = target_gain ();
 261
 262         if (tgain != _current_gain) {
 263                 /* target gain has changed */
 264
 265                 _current_gain = Amp::apply_gain (bufs, _session.nominal_frame_rate(), nframes, _current_gain, tgain);
 266
 267         } else if (tgain < GAIN_COEFF_SMALL) {
 268
 269                 /* we were quiet last time, and we're still supposed to be quiet.
 270                          Silence the outputs, and make sure the buffers are quiet too,
 271                          */
 272
 273                 _output->silence (nframes);
 274                 if (result_required) {
 275                         bufs.set_count (output_buffers().count ());
 276                         Amp::apply_simple_gain (bufs, nframes, GAIN_COEFF_ZERO);
 277                 }
 278                 goto out;
 279
 280         } else if (tgain != GAIN_COEFF_UNITY) {
 281
 282                 /* target gain has not changed, but is not unity */
 283                 Amp::apply_simple_gain (bufs, nframes, tgain);
 284         }
 285
 286         // Speed quietning
 287
 288         if (fabs (_session.transport_speed()) > 1.5 && Config->get_quieten_at_speed ()) {
 289                 Amp::apply_simple_gain (bufs, nframes, speed_quietning, false);
 290         }
 291
 292         // Panning
 293
 294         if (_panshell && !_panshell->bypassed() && _panshell->panner()) {
 295
 296                 // Use the panner to distribute audio to output port buffers
 297
 298                 _panshell->run (bufs, output_buffers(), start_frame, end_frame, nframes);
 299
 300                 // non-audio data will not have been delivered by the panner
 301
 302                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 303                         if (*t != DataType::AUDIO && bufs.count().get(*t) > 0) {
 304                                 _output->copy_to_outputs (bufs, *t, nframes, Port::port_offset());
 305                         }
 306                 }
 307
 308         } else {
 309
 310                 /* Do a 1:1 copy of data to output ports
 311
 312                    Audio is handled separately because we use 0 for the offset,
 313                    since the port offset is only used for timestamped events
 314                    (i.e. MIDI).
 315                 */
 316
 317                 if (bufs.count().n_audio() > 0) {
 318                         _output->copy_to_outputs (bufs, DataType::AUDIO, nframes, 0);
 319                 }
 320
 321                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 322                         if (*t != DataType::AUDIO && bufs.count().get(*t) > 0) {
 323                                 _output->copy_to_outputs (bufs, *t, nframes, Port::port_offset());
 324                         }
 325                 }
 326         }
 327
 328         if (result_required) {
 329
 330                 /* "bufs" are internal, meaning they should never reflect
 331                    split-cycle offsets. So shift events back in time from where
 332                    they were for the external buffers associated with Ports.
 333                 */
 334
 335                 BufferSet& outs (output_buffers());
 336
 337                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 338
 339                         uint32_t n = 0;
 340                         for (BufferSet::iterator b = bufs.begin (*t); b != bufs.end (*t); ++b) {
 341                                 if (outs.count ().get (*t) <= n) {
 342                                         continue;
 343                                 }
 344                                 b->read_from (outs.get (*t, n++), nframes, (*t == DataType::AUDIO ? 0 : -Port::port_offset()));
 345                         }
 346                 }
 347         }
 348
 349 out:
 350         _active = _pending_active;
 351 }
 352
 353 XMLNode&
 354 Delivery::state (bool full_state)
 355 {
 356         XMLNode& node (IOProcessor::state (full_state));
 357
 358         if (_role & Main) {
 359                 node.add_property("type", "main-outs");
 360         } else if (_role & Listen) {
 361                 node.add_property("type", "listen");
 362         } else {
 363                 node.add_property("type", "delivery");
 364         }
 365
 366         node.add_property("role", enum_2_string(_role));
 367
 368         if (_panshell) {
 369                 node.add_child_nocopy (_panshell->get_state ());
 370                 if (_panshell->pannable()) {
 371                         node.add_child_nocopy (_panshell->pannable()->get_state ());
 372                 }
 373         }
 374
 375         return node;
 376 }
 377
 378 int
 379 Delivery::set_state (const XMLNode& node, int version)
 380 {
 381         XMLProperty const * prop;
 382
 383         if (IOProcessor::set_state (node, version)) {
 384                 return -1;
 385         }
 386
 387         if ((prop = node.property ("role")) != 0) {
 388                 _role = Role (string_2_enum (prop->value(), _role));
 389                 // std::cerr << this << ' ' << _name << " set role to " << enum_2_string (_role) << std::endl;
 390         } else {
 391                 // std::cerr << this << ' ' << _name << " NO ROLE INFO\n";
 392         }
 393
 394         XMLNode* pan_node = node.child (X_("PannerShell"));
 395
 396         if (pan_node && _panshell) {
 397                 _panshell->set_state (*pan_node, version);
 398         }
 399
 400         reset_panner ();
 401
 402         XMLNode* pannnode = node.child (X_("Pannable"));
 403         if (_panshell && _panshell->panner() && pannnode) {
 404                 _panshell->pannable()->set_state (*pannnode, version);
 405         }
 406
 407         return 0;
 408 }
 409
 410 void
 411 Delivery::unpan ()
 412 {
 413         /* caller must hold process lock */
 414
 415         _panshell.reset ();
 416 }
 417
 418 uint32_t
 419 Delivery::pan_outs () const
 420 {
 421         if (_output) {
 422                 return _output->n_ports().n_audio();
 423         }
 424
 425         return _configured_output.n_audio();
 426 }
 427
 428 void
 429 Delivery::reset_panner ()
 430 {
 431         if (panners_legal) {
 432                 if (!_no_panner_reset) {
 433
 434                         if (_panshell && _role != Insert && _role != Listen) {
 435                                 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
 436                         }
 437                 }
 438
 439         } else {
 440                 panner_legal_c.disconnect ();
 441                 PannersLegal.connect_same_thread (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
 442         }
 443 }
 444
 445 void
 446 Delivery::panners_became_legal ()
 447 {
 448         if (_panshell && _role != Insert) {
 449                 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
 450         }
 451
 452         panner_legal_c.disconnect ();
 453 }
 454
 455 void
 456 Delivery::defer_pan_reset ()
 457 {
 458         _no_panner_reset = true;
 459 }
 460
 461 void
 462 Delivery::allow_pan_reset ()
 463 {
 464         _no_panner_reset = false;
 465         reset_panner ();
 466 }
 467
 468
 469 int
 470 Delivery::disable_panners ()
 471 {
 472         panners_legal = false;
 473         return 0;
 474 }
 475
 476 void
 477 Delivery::reset_panners ()
 478 {
 479         panners_legal = true;
 480         PannersLegal ();
 481 }
 482
 483 void
 484 Delivery::flush_buffers (framecnt_t nframes)
 485 {
 486         /* io_lock, not taken: function must be called from Session::process() calltree */
 487
 488         if (!_output) {
 489                 return;
 490         }
 491
 492         PortSet& ports (_output->ports());
 493
 494         for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 495                 i->flush_buffers (nframes);
 496         }
 497 }
 498
 499 void
 500 Delivery::transport_stopped (framepos_t now)
 501 {
 502         Processor::transport_stopped (now);
 503
 504         if (_panshell) {
 505                 _panshell->pannable()->transport_stopped (now);
 506         }
 507
 508         if (_output) {
 509                 PortSet& ports (_output->ports());
 510
 511                 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 512                         i->transport_stopped ();
 513                 }
 514         }
 515 }
 516
 517 void
 518 Delivery::realtime_locate ()
 519 {
 520         if (_output) {
 521                 PortSet& ports (_output->ports());
 522
 523                 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 524                         i->realtime_locate ();
 525                 }
 526         }
 527 }
 528
 529 gain_t
 530 Delivery::target_gain ()
 531 {
 532         /* if we've been requested to deactivate, our target gain is zero */
 533
 534         if (!_pending_active) {
 535                 return GAIN_COEFF_ZERO;
 536         }
 537
 538         /* if we've been told not to output because its a monitoring situation and
 539            we're not monitoring, then be quiet.
 540         */
 541
 542         if (_no_outs_cuz_we_no_monitor) {
 543                 return GAIN_COEFF_ZERO;
 544         }
 545
 546         MuteMaster::MutePoint mp = MuteMaster::Main; // stupid gcc uninit warning
 547
 548         switch (_role) {
 549         case Main:
 550                 mp = MuteMaster::Main;
 551                 break;
 552         case Listen:
 553                 mp = MuteMaster::Listen;
 554                 break;
 555         case Send:
 556         case Insert:
 557         case Aux:
 558                 if (_pre_fader) {
 559                         mp = MuteMaster::PreFader;
 560                 } else {
 561                         mp = MuteMaster::PostFader;
 562                 }
 563                 break;
 564         }
 565
 566         gain_t desired_gain = _mute_master->mute_gain_at (mp);
 567
 568         if (_role == Listen && _session.monitor_out() && !_session.listening()) {
 569
 570                 /* nobody is soloed, and this delivery is a listen-send to the
 571                    control/monitor/listen bus, we should be silent since
 572                    it gets its signal from the master out.
 573                 */
 574
 575                 desired_gain = GAIN_COEFF_ZERO;
 576
 577         }
 578
 579         return desired_gain;
 580 }
 581
 582 void
 583 Delivery::no_outs_cuz_we_no_monitor (bool yn)
 584 {
 585         _no_outs_cuz_we_no_monitor = yn;
 586 }
 587
 588 bool
 589 Delivery::set_name (const std::string& name)
 590 {
 591         bool ret = IOProcessor::set_name (name);
 592
 593         if (ret && _panshell) {
 594                 ret = _panshell->set_name (name);
 595         }
 596
 597         return ret;
 598 }
 599
 600 bool ignore_output_change = false;
 601
 602 void
 603 Delivery::output_changed (IOChange change, void* /*src*/)
 604 {
 605         if (change.type & IOChange::ConfigurationChanged) {
 606                 reset_panner ();
 607                 _output_buffers->attach_buffers (_output->ports ());
 608         }
 609 }
 610
 611 boost::shared_ptr<Panner>
 612 Delivery::panner () const
 613 {
 614         if (_panshell) {
 615                 return _panshell->panner();
 616         } else {
 617                 return boost::shared_ptr<Panner>();
 618         }
 619 }
 620