libs/ardour/ardour/insert.h

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_insert_h__
  21 #define __ardour_insert_h__
  22
  23 #include <vector>
  24 #include <string>
  25 #include <exception>
  26
  27 #include <sigc++/signal.h>
  28 #include <ardour/ardour.h>
  29 #include <ardour/redirect.h>
  30 #include <ardour/types.h>
  31
  32 class XMLNode;
  33
  34 namespace MIDI {
  35         class Port;
  36 }
  37
  38 namespace ARDOUR {
  39
  40 class Session;
  41 class Route;
  42 class Plugin;
  43
  44 class Insert : public Redirect
  45 {
  46   public:
  47         Insert(Session& s, std::string name, Placement p);
  48         Insert(Session& s, std::string name, Placement p, int imin, int imax, int omin, int omax);
  49
  50         virtual ~Insert() { }
  51
  52         virtual void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes) = 0;
  53         virtual void activate () {}
  54         virtual void deactivate () {}
  55
  56         virtual int32_t can_do (int32_t in, int32_t& out) = 0;
  57         virtual int32_t configure_io (int32_t magic, int32_t in, int32_t out) = 0;
  58 };
  59
  60 class PortInsert : public Insert
  61 {
  62   public:
  63         PortInsert (Session&, Placement);
  64         PortInsert (Session&, const XMLNode&);
  65         PortInsert (const PortInsert&);
  66         ~PortInsert ();
  67
  68         XMLNode& state(bool full);
  69         XMLNode& get_state(void);
  70         int set_state(const XMLNode&);
  71
  72         void init ();
  73         void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes);
  74
  75         nframes_t latency();
  76
  77         uint32_t output_streams() const;
  78         uint32_t input_streams() const;
  79
  80         int32_t can_do (int32_t, int32_t& out);
  81         int32_t configure_io (int32_t magic, int32_t in, int32_t out);
  82         uint32_t bit_slot() const { return bitslot; }
  83
  84   private:
  85         uint32_t bitslot;
  86 };
  87
  88 class PluginInsert : public Insert
  89 {
  90   public:
  91         PluginInsert (Session&, boost::shared_ptr<Plugin>, Placement);
  92         PluginInsert (Session&, const XMLNode&);
  93         PluginInsert (const PluginInsert&);
  94         ~PluginInsert ();
  95
  96         static const string port_automation_node_name;
  97
  98         XMLNode& state(bool);
  99         XMLNode& get_state(void);
 100         int set_state(const XMLNode&);
 101
 102         void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes);
 103         void silence (nframes_t nframes);
 104         void activate ();
 105         void deactivate ();
 106
 107         void set_block_size (nframes_t nframes);
 108
 109         uint32_t output_streams() const;
 110         uint32_t input_streams() const;
 111         uint32_t natural_output_streams() const;
 112         uint32_t natural_input_streams() const;
 113
 114         int      set_count (uint32_t num);
 115         uint32_t get_count () const { return _plugins.size(); }
 116
 117         int32_t can_do (int32_t, int32_t& out);
 118         int32_t configure_io (int32_t magic, int32_t in, int32_t out);
 119
 120         bool is_generator() const;
 121
 122         void set_parameter (uint32_t port, float val);
 123
 124         AutoState get_port_automation_state (uint32_t port);
 125         void set_port_automation_state (uint32_t port, AutoState);
 126         void protect_automation ();
 127
 128         float default_parameter_value (uint32_t which);
 129
 130         boost::shared_ptr<Plugin> plugin(uint32_t num=0) const {
 131                 if (num < _plugins.size()) {
 132                         return _plugins[num];
 133                 } else {
 134                         return _plugins[0]; // we always have one
 135                 }
 136         }
 137
 138         PluginType type ();
 139
 140         string describe_parameter (uint32_t);
 141
 142         nframes_t latency();
 143
 144         void transport_stopped (nframes_t now);
 145         void automation_snapshot (nframes_t now, bool force);
 146
 147   private:
 148
 149         void parameter_changed (uint32_t, float);
 150
 151         vector<boost::shared_ptr<Plugin> > _plugins;
 152         void automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes);
 153         void connect_and_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now = 0);
 154
 155         void init ();
 156         void set_automatable ();
 157         void auto_state_changed (uint32_t which);
 158         void automation_list_creation_callback (uint32_t, AutomationList&);
 159
 160         boost::shared_ptr<Plugin> plugin_factory (boost::shared_ptr<Plugin>);
 161 };
 162
 163 } // namespace ARDOUR
 164
 165 #endif /* __ardour_insert_h__ */