#include <ardour/ardour.h>
#include <ardour/io.h>
#include <ardour/session.h>
-#include <ardour/redirect.h>
+#include <ardour/io_processor.h>
#include <ardour/types.h>
namespace ARDOUR {
-class Insert;
+class Processor;
class Send;
class RouteGroup;
{
protected:
- typedef list<boost::shared_ptr<Insert> > InsertList;
+ typedef list<boost::shared_ptr<Processor> > ProcessorList;
public:
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_inserts);
+ virtual void handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
virtual void set_pending_declick (int);
/* end of vfunc-based API */
virtual void set_meter_point (MeterPoint, void *src);
MeterPoint meter_point() const { return _meter_point; }
- /* Inserts */
+ /* Processors */
- void flush_inserts ();
+ void flush_processors ();
- template<class T> void foreach_insert (T *obj, void (T::*func)(boost::shared_ptr<Insert>)) {
- Glib::RWLock::ReaderLock lm (insert_lock);
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ template<class T> void foreach_processor (T *obj, void (T::*func)(boost::shared_ptr<Processor>)) {
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(obj->*func) (*i);
}
}
- boost::shared_ptr<Insert> nth_insert (uint32_t n) {
- Glib::RWLock::ReaderLock lm (insert_lock);
- InsertList::iterator i;
- for (i = _inserts.begin(); i != _inserts.end() && n; ++i, --n);
- if (i == _inserts.end()) {
- return boost::shared_ptr<Redirect> ();
+ boost::shared_ptr<Processor> nth_processor (uint32_t n) {
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
+ for (i = _processors.begin(); i != _processors.end() && n; ++i, --n);
+ if (i == _processors.end()) {
+ return boost::shared_ptr<IOProcessor> ();
} else {
return *i;
}
}
- ChanCount max_insert_outs () const { return insert_max_outs; }
+ ChanCount max_processor_outs () const { return processor_max_outs; }
ChanCount pre_fader_streams() const;
- /** A record of the stream configuration at some point in the insert list.
- * Used to return where and why an insert list configuration request failed.
+ /** 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 InsertStreams {
- InsertStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
+ struct ProcessorStreams {
+ ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
- size_t index; ///< Index of insert where configuration failed
- ChanCount count; ///< Input requested of insert
+ size_t index; ///< Index of processor where configuration failed
+ ChanCount count; ///< Input requested of processor
};
- int add_insert (boost::shared_ptr<Insert>, InsertStreams* err = 0);
- int add_inserts (const InsertList&, InsertStreams* err = 0);
- int remove_insert (boost::shared_ptr<Insert>, InsertStreams* err = 0);
- int copy_inserts (const Route&, Placement, InsertStreams* err = 0);
- int sort_inserts (InsertStreams* err = 0);
- void disable_inserts (Placement);
- void disable_inserts ();
+ int add_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
+ int add_processors (const ProcessorList&, ProcessorStreams* err = 0);
+ int remove_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
+ int copy_processors (const Route&, Placement, ProcessorStreams* err = 0);
+ int sort_processors (ProcessorStreams* err = 0);
+ void disable_processors (Placement);
+ void disable_processors ();
void disable_plugins (Placement);
void disable_plugins ();
void ab_plugins (bool forward);
- void clear_inserts (Placement);
- void all_inserts_flip();
- void all_inserts_active (Placement, bool state);
+ void clear_processors (Placement);
+ void all_processors_flip();
+ void all_processors_active (Placement, bool state);
virtual nframes_t update_total_latency();
nframes_t signal_latency() const { return _own_latency; }
sigc::signal<void,void*> post_fader_changed;
sigc::signal<void,void*> control_outs_changed;
sigc::signal<void,void*> main_outs_changed;
- sigc::signal<void> inserts_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;
int set_state(const XMLNode& node);
virtual XMLNode& get_template();
- XMLNode& get_insert_state ();
- int set_insert_state (const XMLNode&);
+ XMLNode& get_processor_state ();
+ int set_processor_state (const XMLNode&);
sigc::signal<void,void*> SelectedChanged;
gain_t desired_solo_gain;
gain_t desired_mute_gain;
- nframes_t check_initial_delay (nframes_t, nframes_t&, nframes_t&);
+
nframes_t _initial_delay;
nframes_t _roll_delay;
nframes_t _own_latency;
- InsertList _inserts;
- Glib::RWLock insert_lock;
- IO *_control_outs;
- Glib::Mutex control_outs_lock;
- RouteGroup *_edit_group;
- RouteGroup *_mix_group;
- std::string _comment;
- bool _have_internal_generator;
+ ProcessorList _processors;
+ Glib::RWLock _processor_lock;
+ IO *_control_outs;
+ Glib::Mutex _control_outs_lock;
+ RouteGroup *_edit_group;
+ RouteGroup *_mix_group;
+ std::string _comment;
+ bool _have_internal_generator;
ToggleControllable _solo_control;
ToggleControllable _mute_control;
+ nframes_t check_initial_delay (nframes_t, nframes_t&, nframes_t&);
+
void passthru (nframes_t start_frame, nframes_t end_frame,
nframes_t nframes, nframes_t offset, int declick, bool meter_inputs);
virtual void process_output_buffers (BufferSet& bufs,
nframes_t start_frame, nframes_t end_frame,
- nframes_t nframes, nframes_t offset, bool with_inserts, int declick,
+ nframes_t nframes, nframes_t offset, bool with_processors, int declick,
bool meter);
protected:
sigc::connection input_signal_connection;
- ChanCount insert_max_outs;
+ ChanCount processor_max_outs;
uint32_t _remote_control_id;
uint32_t pans_required() const;
ChanCount n_process_buffers ();
virtual int _set_state (const XMLNode&, bool call_base);
- virtual void _set_insert_states (const XMLNodeList&);
+ virtual void _set_processor_states (const XMLNodeList&);
private:
void init ();
void input_change_handler (IOChange, void *src);
void output_change_handler (IOChange, void *src);
- int reset_plugin_counts (InsertStreams*); /* locked */
- int _reset_plugin_counts (InsertStreams*); /* unlocked */
+ int reset_plugin_counts (ProcessorStreams*); /* locked */
+ int _reset_plugin_counts (ProcessorStreams*); /* unlocked */
- /* insert I/O channels and plugin count handling */
+ /* processor I/O channels and plugin count handling */
- struct InsertCount {
- boost::shared_ptr<ARDOUR::Insert> insert;
+ struct ProcessorCount {
+ boost::shared_ptr<ARDOUR::Processor> processor;
ChanCount in;
ChanCount out;
- InsertCount (boost::shared_ptr<ARDOUR::Insert> ins) : insert(ins) {}
+ ProcessorCount (boost::shared_ptr<ARDOUR::Processor> ins) : processor(ins) {}
};
- int32_t apply_some_plugin_counts (std::list<InsertCount>& iclist);
- bool check_some_plugin_counts (std::list<InsertCount>& iclist, ChanCount required_inputs, InsertStreams* err_streams);
+ int32_t apply_some_plugin_counts (std::list<ProcessorCount>& iclist);
+ bool check_some_plugin_counts (std::list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err_streams);
void set_deferred_state ();
- void add_insert_from_xml (const XMLNode&);
+ void add_processor_from_xml (const XMLNode&);
};
} // namespace ARDOUR
projects / ardour.git / blobdiff