using namespace PBD;
using namespace ARDOUR;
-sigc::signal<void,nframes_t> Delivery::CycleStart;
-sigc::signal<int> Delivery::PannersLegal;
-bool Delivery::panners_legal = false;
+PBD::Signal1<void,nframes_t> Delivery::CycleStart;
+PBD::Signal0<int> Delivery::PannersLegal;
+bool Delivery::panners_legal = false;
/* deliver to an existing IO object */
, _solo_isolated (false)
, _mute_master (mm)
, no_panner_reset (false)
-
{
_panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
+ _display_to_user = false;
if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
+ _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
}
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
+ CycleStart.connect_same_thread (*this, boost::bind (&Delivery::cycle_start, this, _1));
}
/* deliver to a new IO object */
, no_panner_reset (false)
{
_panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
+ _display_to_user = false;
if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
+ _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
}
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
+ CycleStart.connect_same_thread (*this, boost::bind (&Delivery::cycle_start, this, _1));
}
-/* deliver to a new IO object, reconstruct from XML */
-Delivery::Delivery (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
- : IOProcessor (s, false, true, "reset")
- , _role (Role (0))
- , _output_buffers (new BufferSet())
- , _current_gain (1.0)
- , _output_offset (0)
- , _no_outs_cuz_we_no_monitor (false)
- , _solo_level (0)
- , _solo_isolated (false)
- , _mute_master (mm)
- , no_panner_reset (false)
+Delivery::~Delivery()
{
- _panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
-
- if (set_state (node)) {
- throw failed_constructor ();
- }
-
- if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
- }
-
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
-}
-
-/* deliver to an existing IO object, reconstruct from XML */
-
-Delivery::Delivery (Session& s, boost::shared_ptr<IO> out, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
- : IOProcessor (s, boost::shared_ptr<IO>(), out, "reset")
- , _role (Role (0))
- , _output_buffers (new BufferSet())
- , _current_gain (1.0)
- , _output_offset (0)
- , _no_outs_cuz_we_no_monitor (false)
- , _solo_level (0)
- , _solo_isolated (false)
- , _mute_master (mm)
- , no_panner_reset (false)
-{
- _panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
-
- if (set_state (node)) {
- throw failed_constructor ();
- }
-
- if (_output) {
- _output->changed.connect (mem_fun (*this, &Delivery::output_changed));
- }
-
- CycleStart.connect (mem_fun (*this, &Delivery::cycle_start));
+ delete _output_buffers;
}
std::string
_output_offset += n;
}
-bool
-Delivery::visible () const
-{
- return true;
-}
-
bool
Delivery::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
{
}
void
-Delivery::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes)
+Delivery::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes, bool result_required)
{
assert (_output);
*/
_output->silence (nframes);
- Amp::apply_simple_gain (bufs, nframes, 0.0);
+ if (result_required) {
+ Amp::apply_simple_gain (bufs, nframes, 0.0);
+ }
goto out;
} else if (tgain != 1.0) {
_panner->run (bufs, output_buffers(), start_frame, end_frame, nframes);
+ if (result_required) {
+ bufs.read_from (output_buffers (), nframes);
+ }
+
} else {
+
// Do a 1:1 copy of data to output ports
if (bufs.count().n_audio() > 0 && ports.count().n_audio () > 0) {
}
int
-Delivery::set_state (const XMLNode& node)
+Delivery::set_state (const XMLNode& node, int version)
{
const XMLProperty* prop;
- if (IOProcessor::set_state (node)) {
+ if (IOProcessor::set_state (node, version)) {
return -1;
}
XMLNode* pan_node = node.child (X_("Panner"));
if (pan_node) {
- _panner->set_state (*pan_node);
+ _panner->set_state (*pan_node, version);
}
reset_panner ();
}
} else {
panner_legal_c.disconnect ();
- panner_legal_c = PannersLegal.connect (mem_fun (*this, &Delivery::panners_became_legal));
+ PannersLegal.connect_same_thread (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
}
}
Delivery::reset_panners ()
{
panners_legal = true;
- return PannersLegal ();
+ return *PannersLegal ();
}
}
void
-Delivery::flush (nframes_t nframes)
+Delivery::flush (nframes_t nframes, nframes64_t time)
{
/* io_lock, not taken: function must be called from Session::process() calltree */
PortSet& ports (_output->ports());
for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
- (*i).flush_buffers (nframes, _output_offset);
+ (*i).flush_buffers (nframes, time, _output_offset);
+ }
+}
+
+void
+Delivery::transport_stopped ()
+{
+ /* turn off any notes that are on */
+
+ PortSet& ports (_output->ports());
+
+ for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
+ (*i).transport_stopped ();
}
}
return 0.0;
}
- gain_t desired_gain;
-
- if (_solo_level) {
- desired_gain = 1.0;
- } else {
-
- MuteMaster::MutePoint mp;
-
- switch (_role) {
- case Main:
- mp = MuteMaster::Main;
- break;
- case Listen:
- mp = MuteMaster::Listen;
- break;
- case Send:
- case Insert:
- case Aux:
- /* XXX FIX ME this is wrong, we need per-delivery muting */
- mp = MuteMaster::PreFader;
- break;
- }
-
- if (_solo_isolated) {
-
- /* ... but we are isolated from all that nonsense */
-
- desired_gain = _mute_master->mute_gain_at (mp);
+ gain_t desired_gain = -1.0f;
- } else if (_session.soloing()) {
+ if (_solo_level) {
- desired_gain = min (Config->get_solo_mute_gain(), _mute_master->mute_gain_at (mp));
+ desired_gain = 1.0;
- } else {
- desired_gain = _mute_master->mute_gain_at (mp);
- }
- }
+ } else {
+
+ if (_role == Listen && _session.monitor_out() && !_session.soloing()) {
+
+ /* nobody is soloed, so control/monitor/listen bus gets its
+ signal from master out, we should be silent
+ */
+ desired_gain = 0.0;
+
+ } else {
+
+ MuteMaster::MutePoint mp;
+
+ switch (_role) {
+ case Main:
+ mp = MuteMaster::Main;
+ break;
+ case Listen:
+ mp = MuteMaster::Listen;
+ break;
+ case Send:
+ case Insert:
+ case Aux:
+ /* XXX FIX ME this is wrong, we need per-delivery muting */
+ mp = MuteMaster::PreFader;
+ break;
+ }
+
+ if (!_solo_isolated && _session.soloing()) {
+ desired_gain = min (Config->get_solo_mute_gain(), _mute_master->mute_gain_at (mp));
+
+ } else {
+
+ desired_gain = _mute_master->mute_gain_at (mp);
+ }
+ }
+ }
return desired_gain;
}
projects / ardour.git / blobdiff