lua_api.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016-2019 Robin Gareus <robin@gareus.org>
 * Copyright (C) 2017 Paul Davis <paul@linuxaudiosystems.com>
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#ifndef _ardour_lua_api_h_
#define _ardour_lua_api_h_
 
#include <memory>
#include <string>
 
#include <lo/lo.h>
#include <rubberband/RubberBandStretcher.h>
#include <vamp-hostsdk/Plugin.h>
 
#include "evoral/Note.h"
 
#include "ardour/libardour_visibility.h"
 
#include "ardour/audioregion.h"
#include "ardour/midi_model.h"
#include "ardour/processor.h"
#include "ardour/session.h"
 
namespace ARDOUR {
        class AudioReadable;
}
 
namespace ARDOUR { namespace LuaAPI {
 
        int datatype_ctor_null (lua_State *lua);
        int datatype_ctor_audio (lua_State *L);
        int datatype_ctor_midi (lua_State *L);
 
        std::shared_ptr<Processor> new_send (Session* s, std::shared_ptr<ARDOUR::Route> r, std::shared_ptr<ARDOUR::Processor> p);
 
        std::shared_ptr<ARDOUR::Processor> nil_processor ();
 
        std::shared_ptr<ARDOUR::Processor> new_luaproc_with_time_domain (ARDOUR::Session *s, const std::string& p, Temporal::TimeDomain td);
 
        /* As above but uses default time domain for the session/application */
        std::shared_ptr<ARDOUR::Processor> new_luaproc (ARDOUR::Session *s, const std::string& p);
 
        std::list<std::shared_ptr<ARDOUR::PluginInfo> > list_plugins ();
 
        std::string dump_untagged_plugins ();
 
        std::shared_ptr<ARDOUR::PluginInfo> new_plugin_info (const std::string& id, ARDOUR::PluginType type);
 
        std::shared_ptr<ARDOUR::Processor> new_plugin_with_time_domain (ARDOUR::Session *s, const std::string& id, ARDOUR::PluginType type, Temporal::TimeDomain td, const std::string& preset = "");
 
        /* As above but uses default time domain for the session/application */
        std::shared_ptr<ARDOUR::Processor> new_plugin (ARDOUR::Session *s, const std::string& id, ARDOUR::PluginType type, const std::string& preset = "");
 
        bool set_processor_param (std::shared_ptr<ARDOUR::Processor> proc, uint32_t which, float value);
 
        float get_processor_param (std::shared_ptr<Processor> proc, uint32_t which, bool &ok);
 
        bool reset_processor_to_default (std::shared_ptr<Processor> proc);
 
        bool set_plugin_insert_param (std::shared_ptr<ARDOUR::PluginInsert> pi, uint32_t which, float value);
 
        float get_plugin_insert_param (std::shared_ptr<ARDOUR::PluginInsert> pi, uint32_t which, bool &ok);
 
        bool set_plugin_insert_property (std::shared_ptr<ARDOUR::PluginInsert> pi, std::string const& uri, luabridge::LuaRef value);
 
        int get_plugin_insert_property (lua_State *p);
 
        int plugin_automation (lua_State *lua);
 
        /*
         * A convenience function to get a scale-points from a ParameterDescriptor
         * @param p a ParameterDescriptor
         * @returns Lua Table with "name" -> value pairs
         */
        int desc_scale_points (lua_State* p);
 
        /* Replace all automation data for an AutomationContol from a Lua table
         * @param ac an AutomationControl
         * @param tbl Lua Table {[sample-time] = value}
         * @param thin thinning factor (-1; use default, 0: no thinning)
         * @returns true on success
         */
        bool set_automation_data (std::shared_ptr<ARDOUR::AutomationControl> ac, luabridge::LuaRef tbl, double thin = -1);
 
        int hsla_to_rgba (lua_State *lua);
 
        int color_to_rgba (lua_State *lua);
 
        std::string ascii_dtostr (const double d);
 
        int build_filename (lua_State *lua);
 
        int sample_to_timecode (lua_State *L);
 
        int timecode_to_sample (lua_State *L);
 
        int sample_to_timecode_lua (lua_State *L);
 
        int timecode_to_sample_lua (lua_State *L);
 
        int simple_export (lua_State* L);
 
        bool wait_for_process_callback (size_t n_cycles, int64_t timeout_ms);
 
        void segfault ();
 
        std::vector<std::string> env ();
 
        class Vamp {
                public:
                        Vamp (const std::string&, float sample_rate);
                        ~Vamp ();
 
                        static std::vector<std::string> list_plugins ();
 
                        ::Vamp::Plugin* plugin () { return _plugin; }
 
                        int analyze (std::shared_ptr<ARDOUR::AudioReadable> r, uint32_t channel, luabridge::LuaRef fn);
 
                        void reset ();
 
                        bool initialize ();
 
                        bool initialized () const { return _initialized; }
 
                        ::Vamp::Plugin::FeatureSet process (const std::vector<float*>& d, ::Vamp::RealTime rt);
 
                private:
                        ::Vamp::Plugin* _plugin;
                        float           _sample_rate;
                        samplecnt_t     _bufsize;
                        samplecnt_t     _stepsize;
                        bool            _initialized;
 
        };
 
        class Rubberband : public AudioReadable , public std::enable_shared_from_this<Rubberband>
        {
                public:
                        Rubberband (std::shared_ptr<AudioRegion>, bool percussive);
                        ~Rubberband ();
                        bool set_strech_and_pitch (double stretch_ratio, double pitch_ratio);
                        bool set_mapping (luabridge::LuaRef tbl);
                        std::shared_ptr<AudioRegion> process (luabridge::LuaRef cb);
                        std::shared_ptr<AudioReadable> readable ();
 
                        /* audioreadable API */
                        samplecnt_t readable_length_samples () const { return _read_len; }
                        uint32_t n_channels () const { return _n_channels; }
                        samplecnt_t read (Sample*, samplepos_t pos, samplecnt_t cnt, int channel) const;
 
                private:
                        Rubberband (Rubberband const&); // no copy construction
                        bool read_region (bool study);
                        bool retrieve (float**);
                        void cleanup (bool abort);
                        std::shared_ptr<AudioRegion> finalize ();
 
                        std::shared_ptr<AudioRegion> _region;
 
                        uint32_t    _n_channels;
                        samplecnt_t _read_len;
                        samplecnt_t _read_start;
                        samplecnt_t _read_offset;
 
                        std::vector<std::shared_ptr<AudioSource> > _asrc;
 
                        RubberBand::RubberBandStretcher _rbs;
                        std::map<size_t, size_t>        _mapping;
 
                        double _stretch_ratio;
                        double _pitch_ratio;
 
                        luabridge::LuaRef*            _cb;
                        std::shared_ptr<Rubberband> _self;
                        static const samplecnt_t      _bufsize;
        };
 
        std::shared_ptr<Evoral::Note<Temporal::Beats> >
                new_noteptr (uint8_t, Temporal::Beats, Temporal::Beats, uint8_t, uint8_t);
 
        std::list<std::shared_ptr< Evoral::Note<Temporal::Beats> > >
                note_list (std::shared_ptr<ARDOUR::MidiModel>);
 
        std::list<std::shared_ptr< Evoral::Event<Temporal::Beats> > >
                sysex_list (std::shared_ptr<ARDOUR::MidiModel>);
 
        std::list<std::shared_ptr< Evoral::PatchChange<Temporal::Beats> > >
                patch_change_list (std::shared_ptr<ARDOUR::MidiModel>);
 
 
} } /* namespace */
 
namespace ARDOUR { namespace LuaOSC {
        class Address {
                /*
                 * OSC is kinda special, lo_address is a void* and lo_send() has varags
                 * and typed arguments which makes it hard to bind, even lo_cpp.
                 */
                public:
                        Address (std::string uri) {
                                _addr = lo_address_new_from_url (uri.c_str());
                        }
 
                        ~Address () { if (_addr) { lo_address_free (_addr); } }
                        int send (lua_State *lua);
                private:
                        lo_address _addr;
        };
 
}
 
class LuaTableRef {
public:
        LuaTableRef ();
        ~LuaTableRef ();
 
        int get (lua_State* L);
        int set (lua_State* L);
 
private:
        struct LuaTableEntry {
                LuaTableEntry (int kt, int vt)
                        : keytype (kt)
                        , valuetype (vt)
                { }
 
                int keytype;
                std::string k_s;
                unsigned int k_n;
 
                int valuetype;
                // LUA_TUSERDATA
                const void* c;
                void* p;
                // LUA_TBOOLEAN
                bool b;
                // LUA_TSTRING:
                std::string s;
                // LUA_TNUMBER:
                double n;
        };
 
        std::vector<LuaTableEntry> _data;
 
        static void* findclasskey (lua_State *L, const void* key);
        template<typename T>
        static void assign (luabridge::LuaRef* rv, T key, const LuaTableEntry& s);
};
 
} /* namespace */
 
#endif // _ardour_lua_api_h_