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
  98 Delivery::~Delivery()
  99 {
 100         delete _output_buffers;
 101 }
 102
 103 std::string
 104 Delivery::display_name () const
 105 {
 106         switch (_role) {
 107         case Main:
 108                 return _("main outs");
 109                 break;
 110         case Listen:
 111                 return _("listen");
 112                 break;
 113         case Send:
 114         case Insert:
 115         default:
 116                 return name();
 117         }
 118 }
 119
 120 void
 121 Delivery::cycle_start (nframes_t /*nframes*/)
 122 {
 123         _output_offset = 0;
 124         _no_outs_cuz_we_no_monitor = false;
 125 }
 126
 127 void
 128 Delivery::increment_output_offset (nframes_t n)
 129 {
 130         _output_offset += n;
 131 }
 132
 133 bool
 134 Delivery::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
 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                                 out = _output->n_ports();
 145                                 return true;
 146                         } else {
 147                                 /* not configured yet - we will passthru */
 148                                 out = in;
 149                                 return true;
 150                         }
 151                 } else {
 152                         fatal << "programming error: this should never be reached" << endmsg;
 153                         /*NOTREACHED*/
 154                 }
 155
 156
 157         } else if (_role == Insert) {
 158
 159                 /* the output buffers will be filled with data from the *input* ports
 160                    of this Insert.
 161                 */
 162
 163                 if (_input) {
 164                         if (_input->n_ports() != ChanCount::ZERO) {
 165                                 out = _input->n_ports();
 166                                 return true;
 167                         } else {
 168                                 /* not configured yet - we will passthru */
 169                                 out = in;
 170                                 return true;
 171                         }
 172                 } else {
 173                         fatal << "programming error: this should never be reached" << endmsg;
 174                         /*NOTREACHED*/
 175                 }
 176
 177         } else {
 178                 fatal << "programming error: this should never be reached" << endmsg;
 179         }
 180
 181         return false;
 182 }
 183
 184 bool
 185 Delivery::configure_io (ChanCount in, ChanCount out)
 186 {
 187         /* check configuration by comparison with our I/O port configuration, if appropriate.
 188            see ::can_support_io_configuration() for comments
 189         */
 190
 191         if (_role == Main) {
 192
 193                 if (_output) {
 194                         if (_output->n_ports() != out) {
 195                                 if (_output->n_ports() != ChanCount::ZERO) {
 196                                         fatal << _name << " programming error: configure_io with nports = " << _output->n_ports() << " called with " << in << " and " << out << " with " << _output->n_ports() << " output ports" << endmsg;
 197                                         /*NOTREACHED*/
 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         if (!Processor::configure_io (in, out)) {
 219                 return false;
 220         }
 221
 222         reset_panner ();
 223
 224         return true;
 225 }
 226
 227 void
 228 Delivery::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes, bool result_required)
 229 {
 230         assert (_output);
 231
 232         PortSet& ports (_output->ports());
 233         gain_t tgain;
 234
 235         if (_output->n_ports ().get (_output->default_type()) == 0) {
 236                 goto out;
 237         }
 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         output_buffers().attach_buffers (ports, nframes, _output_offset);
 249
 250         // this Delivery processor is not a derived type, and thus we assume
 251         // we really can modify the buffers passed in (it is almost certainly
 252         // the main output stage of a Route). Contrast with Send::run()
 253         // which cannot do this.
 254
 255         tgain = target_gain ();
 256
 257         if (tgain != _current_gain) {
 258
 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   out:
 306         _active = _pending_active;
 307 }
 308
 309 XMLNode&
 310 Delivery::state (bool full_state)
 311 {
 312         XMLNode& node (IOProcessor::state (full_state));
 313
 314         if (_role & Main) {
 315                 node.add_property("type", "main-outs");
 316         } else if (_role & Listen) {
 317                 node.add_property("type", "listen");
 318         } else {
 319                 node.add_property("type", "delivery");
 320         }
 321
 322         node.add_property("role", enum_2_string(_role));
 323         node.add_child_nocopy (_panner->state (full_state));
 324
 325         return node;
 326 }
 327
 328 int
 329 Delivery::set_state (const XMLNode& node, int version)
 330 {
 331         const XMLProperty* prop;
 332
 333         if (IOProcessor::set_state (node, version)) {
 334                 return -1;
 335         }
 336
 337         if ((prop = node.property ("role")) != 0) {
 338                 _role = Role (string_2_enum (prop->value(), _role));
 339                 // std::cerr << this << ' ' << _name << " set role to " << enum_2_string (_role) << std::endl;
 340         } else {
 341                 // std::cerr << this << ' ' << _name << " NO ROLE INFO\n";
 342         }
 343
 344         XMLNode* pan_node = node.child (X_("Panner"));
 345
 346         if (pan_node) {
 347                 _panner->set_state (*pan_node, version);
 348         }
 349
 350         reset_panner ();
 351
 352         return 0;
 353 }
 354
 355 void
 356 Delivery::reset_panner ()
 357 {
 358         if (panners_legal) {
 359                 if (!no_panner_reset) {
 360
 361                         uint32_t ntargets;
 362
 363                         if (_output) {
 364                                 ntargets = _output->n_ports().n_audio();
 365                         } else {
 366                                 ntargets = _configured_output.n_audio();
 367                         }
 368
 369                         _panner->reset (ntargets, pans_required());
 370                 }
 371         } else {
 372                 panner_legal_c.disconnect ();
 373                 PannersLegal.connect_same_thread (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
 374         }
 375 }
 376
 377 int
 378 Delivery::panners_became_legal ()
 379 {
 380         uint32_t ntargets;
 381
 382         if (_output) {
 383                 ntargets = _output->n_ports().n_audio();
 384         } else {
 385                 ntargets = _configured_output.n_audio();
 386         }
 387
 388         _panner->reset (ntargets, pans_required());
 389         _panner->load (); // automation
 390         panner_legal_c.disconnect ();
 391         return 0;
 392 }
 393
 394 void
 395 Delivery::defer_pan_reset ()
 396 {
 397         no_panner_reset = true;
 398 }
 399
 400 void
 401 Delivery::allow_pan_reset ()
 402 {
 403         no_panner_reset = false;
 404         reset_panner ();
 405 }
 406
 407
 408 int
 409 Delivery::disable_panners (void)
 410 {
 411         panners_legal = false;
 412         return 0;
 413 }
 414
 415 int
 416 Delivery::reset_panners ()
 417 {
 418         panners_legal = true;
 419         return *PannersLegal ();
 420 }
 421
 422
 423 void
 424 Delivery::start_pan_touch (uint32_t which)
 425 {
 426         if (which < _panner->npanners()) {
 427                 _panner->pan_control(which)->start_touch();
 428         }
 429 }
 430
 431 void
 432 Delivery::end_pan_touch (uint32_t which)
 433 {
 434         if (which < _panner->npanners()) {
 435                 _panner->pan_control(which)->stop_touch();
 436         }
 437
 438 }
 439
 440 void
 441 Delivery::transport_stopped (sframes_t frame)
 442 {
 443         _panner->transport_stopped (frame);
 444 }
 445
 446 void
 447 Delivery::flush (nframes_t nframes, nframes64_t time)
 448 {
 449         /* io_lock, not taken: function must be called from Session::process() calltree */
 450
 451         PortSet& ports (_output->ports());
 452
 453         for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
 454                 (*i).flush_buffers (nframes, time, _output_offset);
 455         }
 456 }
 457
 458 void
 459 Delivery::transport_stopped ()
 460 {
 461         /* turn off any notes that are on */
 462
 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 gain_t
 471 Delivery::target_gain ()
 472 {
 473         /* if we've been requested to deactivate, our target gain is zero */
 474
 475         if (!_pending_active) {
 476                 return 0.0;
 477         }
 478
 479         /* if we've been told not to output because its a monitoring situation and
 480            we're not monitoring, then be quiet.
 481         */
 482
 483         if (_no_outs_cuz_we_no_monitor) {
 484                 return 0.0;
 485         }
 486
 487         gain_t desired_gain = -1.0f;
 488
 489         if (_solo_level) {
 490
 491                 desired_gain = 1.0;
 492
 493         } else {
 494
 495                 if (_role == Listen && _session.monitor_out() && !_session.soloing()) {
 496
 497                         /* nobody is soloed, so control/monitor/listen bus gets its
 498                            signal from master out, we should be silent
 499                         */
 500                         desired_gain = 0.0;
 501
 502                 } else {
 503
 504                         MuteMaster::MutePoint mp;
 505
 506                         switch (_role) {
 507                         case Main:
 508                                 mp = MuteMaster::Main;
 509                                 break;
 510                         case Listen:
 511                                 mp = MuteMaster::Listen;
 512                                 break;
 513                         case Send:
 514                         case Insert:
 515                         case Aux:
 516                                 /* XXX FIX ME this is wrong, we need per-delivery muting */
 517                                 mp = MuteMaster::PreFader;
 518                                 break;
 519                         }
 520
 521                         if (!_solo_isolated && _session.soloing()) {
 522                                 desired_gain = min (Config->get_solo_mute_gain(), _mute_master->mute_gain_at (mp));
 523
 524                         } else {
 525
 526                                 desired_gain = _mute_master->mute_gain_at (mp);
 527                         }
 528                 }
 529         }
 530
 531         return desired_gain;
 532 }
 533
 534 void
 535 Delivery::no_outs_cuz_we_no_monitor (bool yn)
 536 {
 537         _no_outs_cuz_we_no_monitor = yn;
 538 }
 539
 540 bool
 541 Delivery::set_name (const std::string& name)
 542 {
 543         bool ret = IOProcessor::set_name (name);
 544
 545         if (ret) {
 546                 ret = _panner->set_name (name);
 547         }
 548
 549         return ret;
 550 }
 551
 552 void
 553 Delivery::output_changed (IOChange change, void* /*src*/)
 554 {
 555         if (change & ARDOUR::ConfigurationChanged) {
 556                 reset_panner ();
 557         }
 558 }
 559