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"
|
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;
|
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;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
enum mute_type {
|
|
|
|
PRE_FADER = 0x1,
|
|
|
|
POST_FADER = 0x2,
|
|
|
|
CONTROL_OUTS = 0x4,
|
|
|
|
MAIN_OUTS = 0x8
|
|
|
|
};
|
|
|
|
|
|
|
|
class Route : public IO
|
|
|
|
{
|
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();
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
long order_key (const char* name) const;
|
|
|
|
void set_order_key (const char* name, long n);
|
|
|
|
|
|
|
|
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; }
|
|
|
|
virtual void set_record_enable (bool yn, void *src) {}
|
|
|
|
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);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* override IO::set_gain() to provide group control */
|
|
|
|
|
|
|
|
void set_gain (gain_t val, void *src);
|
|
|
|
void inc_gain (gain_t delta, void *src);
|
|
|
|
|
|
|
|
void set_solo (bool yn, void *src);
|
|
|
|
bool soloed() const { return _soloed; }
|
|
|
|
|
|
|
|
void set_solo_safe (bool yn, void *src);
|
|
|
|
bool solo_safe() const { return _solo_safe; }
|
2008-12-12 09:43:24 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_mute (bool yn, void *src);
|
|
|
|
bool muted() const { return _muted; }
|
|
|
|
bool solo_muted() const { return desired_solo_gain == 0.0; }
|
|
|
|
|
|
|
|
void set_mute_config (mute_type, bool, void *src);
|
|
|
|
bool get_mute_config (mute_type);
|
|
|
|
|
|
|
|
void set_edit_group (RouteGroup *, void *);
|
|
|
|
void drop_edit_group (void *);
|
|
|
|
RouteGroup *edit_group () { return _edit_group; }
|
|
|
|
|
|
|
|
void set_mix_group (RouteGroup *, void *);
|
|
|
|
void drop_mix_group (void *);
|
|
|
|
RouteGroup *mix_group () { return _mix_group; }
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
virtual void set_meter_point (MeterPoint, void *src);
|
|
|
|
MeterPoint meter_point() const { return _meter_point; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Processors */
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
void foreach_processor (Placement p, sigc::slot<void, boost::weak_ptr<Processor> > method) {
|
|
|
|
Glib::RWLock::ReaderLock lm (_processor_lock);
|
|
|
|
ProcessorList::iterator start, end;
|
|
|
|
placement_range(p, start, end);
|
|
|
|
for (ProcessorList::iterator i = start; i != end; ++i) {
|
|
|
|
method (boost::weak_ptr<Processor> (*i));
|
|
|
|
}
|
|
|
|
}
|
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-05-15 22:51:17 -04:00
|
|
|
ProcessorList::iterator prefader_iterator();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-04 11:50:51 -04:00
|
|
|
ChanCount max_processor_streams () const { return processor_max_streams; }
|
2008-06-02 17:41:35 -04:00
|
|
|
ChanCount pre_fader_streams() const;
|
2009-05-13 17:34:09 -04:00
|
|
|
|
|
|
|
/* special processors */
|
|
|
|
|
|
|
|
boost::shared_ptr<Delivery> control_outs() const { return _control_outs; }
|
|
|
|
boost::shared_ptr<Delivery> main_outs() const { return _main_outs; }
|
2009-05-16 22:08:13 -04:00
|
|
|
|
2009-05-17 10:11:16 -04:00
|
|
|
boost::shared_ptr<Send> send_for (boost::shared_ptr<const IO> target) const;
|
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);
|
|
|
|
int add_processors (const ProcessorList&, Placement placement, ProcessorStreams* err = 0);
|
|
|
|
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-05-15 22:51:17 -04:00
|
|
|
int reorder_processors (const ProcessorList& new_order, Placement placement, 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; }
|
|
|
|
|
|
|
|
sigc::signal<void,void*> solo_changed;
|
|
|
|
sigc::signal<void,void*> solo_safe_changed;
|
|
|
|
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;
|
|
|
|
sigc::signal<void,void*> edit_group_changed;
|
|
|
|
sigc::signal<void,void*> mix_group_changed;
|
|
|
|
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 ();
|
|
|
|
int 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
|
|
|
|
|
|
|
int listen_via (boost::shared_ptr<IO>, const std::string& name);
|
|
|
|
void drop_listen (boost::shared_ptr<IO>);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-16 22:08:13 -04:00
|
|
|
bool feeds (boost::shared_ptr<IO>);
|
2009-01-30 15:18:31 -05:00
|
|
|
std::set<boost::shared_ptr<Route> > fed_by;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
struct ToggleControllable : public PBD::Controllable {
|
|
|
|
enum ToggleType {
|
|
|
|
MuteControl = 0,
|
|
|
|
SoloControl
|
|
|
|
};
|
|
|
|
|
|
|
|
ToggleControllable (std::string name, Route&, ToggleType);
|
|
|
|
void set_value (float);
|
|
|
|
float get_value (void) const;
|
|
|
|
|
|
|
|
Route& route;
|
|
|
|
ToggleType type;
|
|
|
|
};
|
|
|
|
|
|
|
|
boost::shared_ptr<PBD::Controllable> solo_control() {
|
|
|
|
return _solo_control;
|
|
|
|
}
|
|
|
|
|
|
|
|
boost::shared_ptr<PBD::Controllable> mute_control() {
|
|
|
|
return _mute_control;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2008-12-08 13:16:12 -05:00
|
|
|
void sync_order_keys (const char* base);
|
|
|
|
static sigc::signal<void,const char*> 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 ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_solo_mute (bool yn);
|
|
|
|
void set_block_size (nframes_t nframes);
|
|
|
|
bool has_external_redirects() const;
|
|
|
|
void curve_reallocate ();
|
|
|
|
|
|
|
|
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-02-16 21:11:49 -05:00
|
|
|
Flag _flags;
|
|
|
|
int _pending_declick;
|
|
|
|
MeterPoint _meter_point;
|
|
|
|
|
|
|
|
gain_t solo_gain;
|
|
|
|
gain_t mute_gain;
|
|
|
|
gain_t desired_solo_gain;
|
|
|
|
gain_t desired_mute_gain;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
nframes_t _initial_delay;
|
|
|
|
nframes_t _roll_delay;
|
|
|
|
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;
|
|
|
|
boost::shared_ptr<Delivery> _control_outs; // XXX to be removed/generalized by listen points
|
2009-02-16 21:11:49 -05:00
|
|
|
RouteGroup *_edit_group;
|
|
|
|
RouteGroup *_mix_group;
|
|
|
|
std::string _comment;
|
|
|
|
bool _have_internal_generator;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
boost::shared_ptr<ToggleControllable> _solo_control;
|
|
|
|
boost::shared_ptr<ToggleControllable> _mute_control;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/* tight cache-line access here is more important than sheer speed of access.
|
|
|
|
keep these after things that should be aligned
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool _muted : 1;
|
|
|
|
bool _soloed : 1;
|
|
|
|
bool _solo_safe : 1;
|
|
|
|
bool _recordable : 1;
|
|
|
|
bool _mute_affects_pre_fader : 1;
|
|
|
|
bool _mute_affects_post_fader : 1;
|
|
|
|
bool _mute_affects_control_outs : 1;
|
|
|
|
bool _mute_affects_main_outs : 1;
|
|
|
|
bool _silent : 1;
|
|
|
|
bool _declickable : 1;
|
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
|
|
|
|
|
|
|
void setup_peak_meters ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
virtual int _set_state (const XMLNode&, bool call_base);
|
|
|
|
virtual void _set_processor_states (const XMLNodeList&);
|
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
boost::shared_ptr<Delivery> add_listener (boost::shared_ptr<IO>, const std::string&);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
|
|
|
void init ();
|
|
|
|
|
|
|
|
static uint32_t order_key_cnt;
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
struct ltstr {
|
|
|
|
bool operator()(const char* s1, const char* s2) const {
|
2008-06-02 17:41:35 -04:00
|
|
|
return strcmp(s1, s2) < 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef std::map<const char*,long,ltstr> OrderKeys;
|
|
|
|
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*);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_deferred_state ();
|
2009-05-15 22:51:17 -04:00
|
|
|
bool add_processor_from_xml (const XMLNode&, Placement);
|
|
|
|
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__ */
|