libs/ardour/ardour/luaproc.h

   1 /*
   2     Copyright (C) 2016 Robin Gareus <robin@gareus.org>
   3     Copyright (C) 2006 Paul Davis
   4
   5     This program is free software; you can redistribute it and/or modify it
   6     under the terms of the GNU General Public License as published by the Free
   7     Software Foundation; either version 2 of the License, or (at your option)
   8     any later version.
   9
  10     This program is distributed in the hope that it will be useful, but WITHOUT
  11     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13     for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 /* print runtime and garbage-collection timing statistics */
  21 //#define WITH_LUAPROC_STATS
  22
  23 /* memory allocation system, default: ReallocPool */
  24 //#define USE_TLSF // use TLSF instead of ReallocPool
  25 //#define USE_MALLOC // or plain OS provided realloc (no mlock) -- if USE_TLSF isn't defined
  26
  27 #ifndef __ardour_luaproc_h__
  28 #define __ardour_luaproc_h__
  29
  30 #include <set>
  31 #include <vector>
  32 #include <string>
  33
  34 #ifdef USE_TLSF
  35 #  include "pbd/tlsf.h"
  36 #else
  37 #  include "pbd/reallocpool.h"
  38 #endif
  39
  40 #include "pbd/stateful.h"
  41
  42 #include "ardour/types.h"
  43 #include "ardour/plugin.h"
  44 #include "ardour/luascripting.h"
  45 #include "ardour/dsp_filter.h"
  46 #include "ardour/lua_api.h"
  47
  48 #include "lua/luastate.h"
  49
  50 namespace luabridge {
  51         class LuaRef;
  52 }
  53
  54 namespace ARDOUR {
  55
  56 class LIBARDOUR_API LuaProc : public ARDOUR::Plugin {
  57 public:
  58         LuaProc (AudioEngine&, Session&, const std::string&);
  59         LuaProc (const LuaProc &);
  60         ~LuaProc ();
  61
  62         /* Plugin interface */
  63
  64         std::string unique_id() const { return get_info()->unique_id; }
  65         const char* name()  const { return get_info()->name.c_str(); }
  66         const char* label() const { return get_info()->name.c_str(); }
  67         const char* maker() const { return get_info()->creator.c_str(); }
  68
  69         uint32_t    parameter_count() const;
  70         float       default_value (uint32_t port);
  71         void        set_parameter (uint32_t port, float val);
  72         float       get_parameter (uint32_t port) const;
  73         int         get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const;
  74         uint32_t    nth_parameter (uint32_t port, bool& ok) const;
  75
  76         std::string get_docs () const { return _docs; }
  77         std::string get_parameter_docs (uint32_t) const;
  78
  79         PluginOutputConfiguration possible_output () const { return _output_configs; }
  80
  81         std::set<Evoral::Parameter> automatable() const;
  82
  83         void activate () { }
  84         void deactivate () { }
  85         void cleanup () { }
  86
  87         int set_block_size (pframes_t /*nframes*/) { return 0; }
  88         samplecnt_t signal_latency() const { return _signal_latency; }
  89
  90         int connect_and_run (BufferSet& bufs,
  91                         samplepos_t start, samplepos_t end, double speed,
  92                         ChanMapping const& in, ChanMapping const& out,
  93                         pframes_t nframes, samplecnt_t offset);
  94
  95         std::string describe_parameter (Evoral::Parameter);
  96         void        print_parameter (uint32_t, char*, uint32_t len) const;
  97         boost::shared_ptr<ScalePoints> get_scale_points(uint32_t port_index) const;
  98
  99         bool parameter_is_audio (uint32_t) const { return false; }
 100         bool parameter_is_control (uint32_t) const { return true; }
 101         bool parameter_is_input (uint32_t) const;
 102         bool parameter_is_output (uint32_t) const;
 103
 104         uint32_t designated_bypass_port () {
 105                 return _designated_bypass_port;
 106         }
 107
 108         std::string state_node_name() const { return "luaproc"; }
 109         void add_state (XMLNode *) const;
 110         int set_state (const XMLNode&, int version);
 111         int set_script_from_state (const XMLNode&);
 112
 113         bool load_preset (PresetRecord);
 114         std::string do_save_preset (std::string);
 115         void do_remove_preset (std::string);
 116
 117         bool has_editor() const { return false; }
 118
 119         bool can_support_io_configuration (const ChanCount& in, ChanCount& out, ChanCount* imprecise);
 120         bool configure_io (ChanCount in, ChanCount out);
 121
 122         ChanCount output_streams() const { return _configured_out; }
 123         ChanCount input_streams() const { return _configured_in; }
 124
 125         bool has_inline_display () { return _lua_has_inline_display; }
 126         void setup_lua_inline_gui (LuaState *lua_gui);
 127
 128         DSP::DspShm* instance_shm () { return &lshm; }
 129         LuaTableRef* instance_ref () { return &lref; }
 130
 131 private:
 132         void find_presets ();
 133
 134         /* END Plugin interface */
 135
 136 public:
 137         void set_origin (std::string& path) { _origin = path; }
 138
 139 protected:
 140         const std::string& script() const { return _script; }
 141         const std::string& origin() const { return _origin; }
 142
 143 private:
 144 #ifdef USE_TLSF
 145         PBD::TLSF _mempool;
 146 #else
 147         PBD::ReallocPool _mempool;
 148 #endif
 149         LuaState lua;
 150         luabridge::LuaRef * _lua_dsp;
 151         luabridge::LuaRef * _lua_latency;
 152         std::string _script;
 153         std::string _origin;
 154         std::string _docs;
 155         bool _lua_does_channelmapping;
 156         bool _lua_has_inline_display;
 157
 158         void queue_draw () { QueueDraw(); /* EMIT SIGNAL */ }
 159         DSP::DspShm lshm;
 160
 161         LuaTableRef lref;
 162
 163         boost::weak_ptr<Route> route () const;
 164
 165         void init ();
 166         bool load_script ();
 167         void lua_print (std::string s);
 168
 169         std::string preset_name_to_uri (const std::string&) const;
 170         std::string presets_file () const;
 171         XMLTree* presets_tree () const;
 172
 173         boost::shared_ptr<ScalePoints> parse_scale_points (luabridge::LuaRef*);
 174
 175         std::vector<std::pair<bool, int> > _ctrl_params;
 176         std::map<int, ARDOUR::ParameterDescriptor> _param_desc;
 177         std::map<int, std::string> _param_doc;
 178         uint32_t _designated_bypass_port;
 179
 180         samplecnt_t _signal_latency;
 181
 182         float* _control_data;
 183         float* _shadow_data;
 184
 185         ChanCount _configured_in;
 186         ChanCount _configured_out;
 187
 188         bool      _configured;
 189
 190         ChanCount _selected_in;
 191         ChanCount _selected_out;
 192
 193         PluginOutputConfiguration _output_configs;
 194
 195         bool _has_midi_input;
 196         bool _has_midi_output;
 197
 198
 199 #ifdef WITH_LUAPROC_STATS
 200         int64_t _stats_avg[2];
 201         int64_t _stats_max[2];
 202         int64_t _stats_cnt;
 203 #endif
 204 };
 205
 206 class LIBARDOUR_API LuaPluginInfo : public PluginInfo
 207 {
 208   public:
 209         LuaPluginInfo (LuaScriptInfoPtr lsi);
 210         ~LuaPluginInfo () { };
 211
 212         PluginPtr load (Session& session);
 213         std::vector<Plugin::PresetRecord> get_presets (bool user_only) const;
 214
 215         bool reconfigurable_io() const { return true; }
 216 };
 217
 218 typedef boost::shared_ptr<LuaPluginInfo> LuaPluginInfoPtr;
 219
 220 } // namespace ARDOUR
 221
 222 #endif // __ardour_luaproc_h__