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