2008-06-02 17:41:35 -04:00
|
|
|
/*
|
|
|
|
Copyright (C) 2000-2002 Paul Davis
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __ardour_route_h__
|
|
|
|
#define __ardour_route_h__
|
|
|
|
|
|
|
|
#include <cmath>
|
2009-02-15 18:47:09 -05:00
|
|
|
#include <cstring>
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <list>
|
|
|
|
#include <map>
|
2009-02-15 18:47:09 -05:00
|
|
|
#include <set>
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#include <boost/shared_ptr.hpp>
|
2009-01-30 15:18:31 -05:00
|
|
|
#include <boost/weak_ptr.hpp>
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
#include <glibmm/thread.h>
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/fastlog.h"
|
|
|
|
#include "pbd/xml++.h"
|
|
|
|
#include "pbd/undo.h"
|
|
|
|
#include "pbd/stateful.h"
|
|
|
|
#include "pbd/controllable.h"
|
|
|
|
#include "pbd/destructible.h"
|
|
|
|
|
|
|
|
#include "ardour/ardour.h"
|
|
|
|
#include "ardour/io.h"
|
|
|
|
#include "ardour/types.h"
|
2009-06-09 16:21:19 -04:00
|
|
|
#include "ardour/mute_master.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
namespace ARDOUR {
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
class Amp;
|
2009-05-13 17:34:09 -04:00
|
|
|
class Delivery;
|
2009-01-30 15:18:31 -05:00
|
|
|
class IOProcessor;
|
2009-06-09 16:21:19 -04:00
|
|
|
class Panner;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
class Processor;
|
2008-06-02 17:41:35 -04:00
|
|
|
class RouteGroup;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
class Send;
|
2009-06-16 10:58:33 -04:00
|
|
|
class InternalReturn;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
class Route : public SessionObject, public AutomatableControls
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2009-05-15 22:51:17 -04:00
|
|
|
public:
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
enum Flag {
|
|
|
|
Hidden = 0x1,
|
|
|
|
MasterOut = 0x2,
|
|
|
|
ControlOut = 0x4
|
|
|
|
};
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
Route (Session&, std::string name, Flag flags = Flag(0),
|
2009-05-15 22:51:17 -04:00
|
|
|
DataType default_type = DataType::AUDIO);
|
2008-06-02 17:41:35 -04:00
|
|
|
Route (Session&, const XMLNode&, DataType default_type = DataType::AUDIO);
|
|
|
|
virtual ~Route();
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<IO> input() const { return _input; }
|
|
|
|
boost::shared_ptr<IO> output() const { return _output; }
|
|
|
|
|
|
|
|
ChanCount n_inputs() const { return _input->n_ports(); }
|
|
|
|
ChanCount n_outputs() const { return _output->n_ports(); }
|
|
|
|
|
|
|
|
bool active() const { return _active; }
|
|
|
|
void set_active (bool yn);
|
|
|
|
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
static std::string ensure_track_or_route_name(std::string, Session &);
|
|
|
|
|
|
|
|
std::string comment() { return _comment; }
|
|
|
|
void set_comment (std::string str, void *src);
|
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
bool set_name (const std::string& str);
|
|
|
|
|
2009-07-04 08:40:26 -04:00
|
|
|
long order_key (std::string const &) const;
|
|
|
|
void set_order_key (std::string const &, long);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
bool is_hidden() const { return _flags & Hidden; }
|
|
|
|
bool is_master() const { return _flags & MasterOut; }
|
|
|
|
bool is_control() const { return _flags & ControlOut; }
|
|
|
|
|
|
|
|
/* these are the core of the API of a Route. see the protected sections as well */
|
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
virtual int roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
|
2009-04-23 13:48:37 -04:00
|
|
|
int declick, bool can_record, bool rec_monitors_input);
|
2009-02-16 21:11:49 -05:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
virtual int no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
|
2009-04-23 13:48:37 -04:00
|
|
|
bool state_changing, bool can_record, bool rec_monitors_input);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
virtual int silent_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
|
2009-04-23 13:48:37 -04:00
|
|
|
bool can_record, bool rec_monitors_input);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
virtual void toggle_monitor_input ();
|
|
|
|
virtual bool can_record() { return false; }
|
2009-06-09 16:21:19 -04:00
|
|
|
|
2009-07-21 11:55:17 -04:00
|
|
|
virtual void set_record_enable (bool /*yn*/, void * /*src*/) {}
|
2008-06-02 17:41:35 -04:00
|
|
|
virtual bool record_enabled() const { return false; }
|
|
|
|
virtual void handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
|
|
|
|
virtual void set_pending_declick (int);
|
|
|
|
|
|
|
|
/* end of vfunc-based API */
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
void shift (nframes64_t, nframes64_t);
|
2009-06-09 16:21:19 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_gain (gain_t val, void *src);
|
|
|
|
void inc_gain (gain_t delta, void *src);
|
2009-06-09 16:21:19 -04:00
|
|
|
|
|
|
|
void set_mute (bool yn, void* src);
|
|
|
|
bool muted () const;
|
|
|
|
|
2009-07-01 09:36:50 -04:00
|
|
|
|
2009-06-17 11:50:29 -04:00
|
|
|
/* controls use set_solo() to modify this route's solo state
|
|
|
|
*/
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_solo (bool yn, void *src);
|
2009-06-17 11:50:29 -04:00
|
|
|
bool soloed () const { return (bool) _solo_level; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
void set_solo_isolated (bool yn, void *src);
|
|
|
|
bool solo_isolated() const;
|
2009-07-01 09:36:50 -04:00
|
|
|
|
|
|
|
void set_listen (bool yn, void* src);
|
|
|
|
bool listening () const;
|
2008-12-12 09:43:24 -05:00
|
|
|
|
2009-06-10 14:10:07 -04:00
|
|
|
void set_phase_invert (bool yn);
|
2009-06-09 16:21:19 -04:00
|
|
|
bool phase_invert() const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-10 14:10:07 -04:00
|
|
|
void set_denormal_protection (bool yn);
|
2009-06-09 16:21:19 -04:00
|
|
|
bool denormal_protection() const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
void set_route_group (RouteGroup *, void *);
|
|
|
|
void drop_route_group (void *);
|
|
|
|
RouteGroup *route_group () const { return _route_group; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
virtual void set_meter_point (MeterPoint, void *src);
|
|
|
|
MeterPoint meter_point() const { return _meter_point; }
|
2009-06-09 16:21:19 -04:00
|
|
|
void meter ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Processors */
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Amp> amp() const { return _amp; }
|
|
|
|
PeakMeter& peak_meter() { return *_meter.get(); }
|
|
|
|
const PeakMeter& peak_meter() const { return *_meter.get(); }
|
|
|
|
boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void flush_processors ();
|
|
|
|
|
2008-12-16 18:21:01 -05:00
|
|
|
void foreach_processor (sigc::slot<void, boost::weak_ptr<Processor> > method) {
|
2008-06-02 17:41:35 -04:00
|
|
|
Glib::RWLock::ReaderLock lm (_processor_lock);
|
|
|
|
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
|
2008-12-16 18:21:01 -05:00
|
|
|
method (boost::weak_ptr<Processor> (*i));
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
}
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<Processor> nth_processor (uint32_t n) {
|
|
|
|
Glib::RWLock::ReaderLock lm (_processor_lock);
|
|
|
|
ProcessorList::iterator i;
|
2009-02-25 16:48:32 -05:00
|
|
|
for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
|
2008-06-02 17:41:35 -04:00
|
|
|
if (i == _processors.end()) {
|
2009-01-30 15:18:31 -05:00
|
|
|
return boost::shared_ptr<Processor> ();
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
|
|
|
return *i;
|
|
|
|
}
|
|
|
|
}
|
2009-05-13 17:34:09 -04:00
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
bool processor_is_prefader (boost::shared_ptr<Processor> p);
|
|
|
|
|
2009-05-04 11:50:51 -04:00
|
|
|
ChanCount max_processor_streams () const { return processor_max_streams; }
|
2009-05-13 17:34:09 -04:00
|
|
|
|
|
|
|
/* special processors */
|
|
|
|
|
2009-06-16 10:58:33 -04:00
|
|
|
boost::shared_ptr<Delivery> control_outs() const { return _control_outs; }
|
|
|
|
boost::shared_ptr<Delivery> main_outs() const { return _main_outs; }
|
|
|
|
boost::shared_ptr<InternalReturn> internal_return() const { return _intreturn; }
|
|
|
|
boost::shared_ptr<Send> internal_send_for (boost::shared_ptr<const Route> target) const;
|
2009-06-25 16:46:39 -04:00
|
|
|
void add_internal_return ();
|
2009-06-16 10:58:33 -04:00
|
|
|
BufferSet* get_return_buffer () const;
|
|
|
|
void release_return_buffer () const;
|
2009-06-17 15:30:54 -04:00
|
|
|
void put_control_outs_at (Placement);
|
2009-06-16 10:58:33 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/** A record of the stream configuration at some point in the processor list.
|
|
|
|
* Used to return where and why an processor list configuration request failed.
|
|
|
|
*/
|
|
|
|
struct ProcessorStreams {
|
|
|
|
ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
uint32_t index; ///< Index of processor where configuration failed
|
2008-06-02 17:41:35 -04:00
|
|
|
ChanCount count; ///< Input requested of processor
|
|
|
|
};
|
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0);
|
|
|
|
int add_processor (boost::shared_ptr<Processor>, ProcessorList::iterator iter, ProcessorStreams* err = 0);
|
2009-07-15 16:29:02 -04:00
|
|
|
int add_processors (const ProcessorList&, boost::shared_ptr<Processor> before, ProcessorStreams* err = 0);
|
2009-05-15 22:51:17 -04:00
|
|
|
int add_processors (const ProcessorList&, ProcessorList::iterator iter, ProcessorStreams* err = 0);
|
2008-06-02 17:41:35 -04:00
|
|
|
int remove_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
|
2009-07-15 16:29:02 -04:00
|
|
|
int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
|
2009-07-12 20:26:28 -04:00
|
|
|
int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
|
2008-06-02 17:41:35 -04:00
|
|
|
void disable_processors (Placement);
|
|
|
|
void disable_processors ();
|
|
|
|
void disable_plugins (Placement);
|
|
|
|
void disable_plugins ();
|
|
|
|
void ab_plugins (bool forward);
|
|
|
|
void clear_processors (Placement);
|
|
|
|
void all_processors_flip();
|
|
|
|
void all_processors_active (Placement, bool state);
|
|
|
|
|
|
|
|
virtual nframes_t update_total_latency();
|
|
|
|
void set_latency_delay (nframes_t);
|
|
|
|
void set_user_latency (nframes_t);
|
|
|
|
nframes_t initial_delay() const { return _initial_delay; }
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
sigc::signal<void> active_changed;
|
2009-06-10 14:10:07 -04:00
|
|
|
sigc::signal<void> phase_invert_changed;
|
|
|
|
sigc::signal<void> denormal_protection_changed;
|
2009-07-01 09:36:50 -04:00
|
|
|
sigc::signal<void,void*> listen_changed;
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,void*> solo_changed;
|
|
|
|
sigc::signal<void,void*> solo_safe_changed;
|
2009-06-09 16:21:19 -04:00
|
|
|
sigc::signal<void,void*> solo_isolated_changed;
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,void*> comment_changed;
|
|
|
|
sigc::signal<void,void*> mute_changed;
|
|
|
|
sigc::signal<void,void*> pre_fader_changed;
|
|
|
|
sigc::signal<void,void*> post_fader_changed;
|
|
|
|
sigc::signal<void,void*> control_outs_changed;
|
|
|
|
sigc::signal<void,void*> main_outs_changed;
|
|
|
|
sigc::signal<void> processors_changed;
|
|
|
|
sigc::signal<void,void*> record_enable_changed;
|
2009-06-21 15:59:56 -04:00
|
|
|
sigc::signal<void,void*> route_group_changed;
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,void*> meter_change;
|
|
|
|
sigc::signal<void> signal_latency_changed;
|
|
|
|
sigc::signal<void> initial_delay_changed;
|
|
|
|
|
|
|
|
/* gui's call this for their own purposes. */
|
|
|
|
|
|
|
|
sigc::signal<void,std::string,void*> gui_changed;
|
|
|
|
|
|
|
|
/* stateful */
|
|
|
|
|
|
|
|
XMLNode& get_state();
|
|
|
|
int set_state(const XMLNode& node);
|
|
|
|
virtual XMLNode& get_template();
|
|
|
|
|
|
|
|
XMLNode& get_processor_state ();
|
2009-06-09 16:21:19 -04:00
|
|
|
virtual void set_processor_state (const XMLNode&);
|
|
|
|
|
2009-03-02 11:52:40 -05:00
|
|
|
int save_as_template (const std::string& path, const std::string& name);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,void*> SelectedChanged;
|
2009-05-13 17:34:09 -04:00
|
|
|
|
2009-07-14 20:47:34 -04:00
|
|
|
int listen_via (boost::shared_ptr<Route>, Placement p, bool active, bool aux);
|
2009-06-16 10:58:33 -04:00
|
|
|
void drop_listen (boost::shared_ptr<Route>);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-16 10:58:33 -04:00
|
|
|
bool feeds (boost::shared_ptr<Route>);
|
2009-01-30 15:18:31 -05:00
|
|
|
std::set<boost::shared_ptr<Route> > fed_by;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
/* Controls (not all directly owned by the Route */
|
|
|
|
|
|
|
|
boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
|
|
|
|
|
|
|
|
struct SoloControllable : public AutomationControl {
|
|
|
|
SoloControllable (std::string name, Route&);
|
|
|
|
void set_value (float);
|
|
|
|
float get_value (void) const;
|
|
|
|
|
|
|
|
Route& route;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<AutomationControl> solo_control() const {
|
2008-06-02 17:41:35 -04:00
|
|
|
return _solo_control;
|
|
|
|
}
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<AutomationControl> mute_control() const {
|
|
|
|
return _mute_master;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2009-06-09 16:21:19 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<MuteMaster> mute_master() const {
|
|
|
|
return _mute_master;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Route doesn't own these items, but sub-objects that it does own have them
|
|
|
|
and to make UI code a bit simpler, we provide direct access to them
|
|
|
|
here.
|
|
|
|
*/
|
|
|
|
|
|
|
|
boost::shared_ptr<Panner> panner() const;
|
|
|
|
boost::shared_ptr<AutomationControl> gain_control() const;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void automation_snapshot (nframes_t now, bool force=false);
|
|
|
|
void protect_automation ();
|
|
|
|
|
|
|
|
void set_remote_control_id (uint32_t id);
|
|
|
|
uint32_t remote_control_id () const;
|
|
|
|
sigc::signal<void> RemoteControlIDChanged;
|
|
|
|
|
2009-07-04 08:40:26 -04:00
|
|
|
void sync_order_keys (std::string const &);
|
|
|
|
static sigc::signal<void, std::string const &> SyncOrderKeys;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
protected:
|
|
|
|
friend class Session;
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
void catch_up_on_solo_mute_override ();
|
2009-06-09 16:21:19 -04:00
|
|
|
void mod_solo_level (int32_t);
|
2009-06-17 11:50:29 -04:00
|
|
|
uint32_t solo_level () const { return _solo_level; }
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_block_size (nframes_t nframes);
|
|
|
|
bool has_external_redirects() const;
|
|
|
|
void curve_reallocate ();
|
2009-06-09 16:21:19 -04:00
|
|
|
void just_meter_input (sframes_t start_frame, sframes_t end_frame, nframes_t nframes);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
protected:
|
2009-04-23 13:48:37 -04:00
|
|
|
nframes_t check_initial_delay (nframes_t, nframes_t&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
void passthru (sframes_t start_frame, sframes_t end_frame,
|
|
|
|
nframes_t nframes, int declick);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
virtual void process_output_buffers (BufferSet& bufs,
|
2009-05-13 17:34:09 -04:00
|
|
|
sframes_t start_frame, sframes_t end_frame,
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
nframes_t nframes, bool with_processors, int declick);
|
2009-04-23 13:48:37 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<IO> _input;
|
|
|
|
boost::shared_ptr<IO> _output;
|
2009-02-16 21:11:49 -05:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
bool _active;
|
2009-02-16 21:11:49 -05:00
|
|
|
nframes_t _initial_delay;
|
|
|
|
nframes_t _roll_delay;
|
2009-06-09 16:21:19 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
ProcessorList _processors;
|
2009-05-16 22:08:13 -04:00
|
|
|
mutable Glib::RWLock _processor_lock;
|
2009-05-13 17:34:09 -04:00
|
|
|
boost::shared_ptr<Delivery> _main_outs;
|
2009-06-17 11:50:29 -04:00
|
|
|
boost::shared_ptr<Delivery> _control_outs;
|
2009-06-16 10:58:33 -04:00
|
|
|
boost::shared_ptr<InternalReturn> _intreturn;
|
2009-02-16 21:11:49 -05:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
Flag _flags;
|
|
|
|
int _pending_declick;
|
|
|
|
MeterPoint _meter_point;
|
|
|
|
uint32_t _phase_invert;
|
2009-06-17 11:50:29 -04:00
|
|
|
uint32_t _solo_level;
|
|
|
|
bool _solo_isolated;
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
bool _denormal_protection;
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
bool _recordable : 1;
|
|
|
|
bool _silent : 1;
|
|
|
|
bool _declickable : 1;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<SoloControllable> _solo_control;
|
|
|
|
boost::shared_ptr<MuteMaster> _mute_master;
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
RouteGroup* _route_group;
|
2009-06-09 16:21:19 -04:00
|
|
|
std::string _comment;
|
|
|
|
bool _have_internal_generator;
|
|
|
|
bool _solo_safe;
|
|
|
|
DataType _default_type;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
protected:
|
|
|
|
|
|
|
|
virtual XMLNode& state(bool);
|
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
void passthru_silence (sframes_t start_frame, sframes_t end_frame,
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
nframes_t nframes, int declick);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-04-23 13:48:37 -04:00
|
|
|
void silence (nframes_t nframes);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
sigc::connection input_signal_connection;
|
|
|
|
|
2009-05-04 11:50:51 -04:00
|
|
|
ChanCount processor_max_streams;
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t _remote_control_id;
|
|
|
|
|
|
|
|
uint32_t pans_required() const;
|
|
|
|
ChanCount n_process_buffers ();
|
2009-05-04 11:50:51 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
virtual int _set_state (const XMLNode&, bool call_base);
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Amp> _amp;
|
|
|
|
boost::shared_ptr<PeakMeter> _meter;
|
|
|
|
sigc::connection _meter_connection;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
|
|
|
void init ();
|
|
|
|
|
|
|
|
static uint32_t order_key_cnt;
|
|
|
|
|
2009-07-04 08:40:26 -04:00
|
|
|
typedef std::map<std::string, long> OrderKeys;
|
2008-06-02 17:41:35 -04:00
|
|
|
OrderKeys order_keys;
|
|
|
|
|
|
|
|
void input_change_handler (IOChange, void *src);
|
|
|
|
void output_change_handler (IOChange, void *src);
|
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
bool _in_configure_processors;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
int configure_processors (ProcessorStreams*);
|
|
|
|
int configure_processors_unlocked (ProcessorStreams*);
|
2009-06-09 16:21:19 -04:00
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
bool add_processor_from_xml (const XMLNode&, ProcessorList::iterator iter);
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
|
2009-05-15 22:51:17 -04:00
|
|
|
void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ARDOUR
|
|
|
|
|
|
|
|
#endif /* __ardour_route_h__ */
|