plugin.hpp

/*
    plugin.hpp - Support file for writing LV2 plugins in C++
    Copyright (C) 2006-2007 Lars Luthman <lars.luthman@gmail.com>
    Modified by Dave Robillard, 2008
    Modified by Michael Fisher, 2012

    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 3 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., 59 Temple Place, Suite 330, Boston, MA 01222-1307  USA
*/

#ifndef LVTK_PLUGIN_HPP
#define LVTK_PLUGIN_HPP

#include <iostream>
#include <cstdarg>
#include <cstring>
#include <string>
#include <vector>

#include <lv2/lv2plug.in/ns/lv2core/lv2.h>

#include <lvtk/feature.hpp>
#include <lvtk/ext/common.h>
#include <lvtk/ext/bufsize.hpp>
#include <lvtk/ext/resize_port.hpp>
#include <lvtk/ext/state.hpp>
#include <lvtk/ext/worker.hpp>

#include "private/debug.hpp"

namespace lvtk {

    using std::vector;

    class DescList : public vector<LV2_Descriptor> {
    public:
        ~DescList();
    };


    DescList& get_lv2_descriptors();


    template <class Derived,
              class Ext1 = end, class Ext2 = end, class Ext3 = end,
              class Ext4 = end, class Ext5 = end, class Ext6 = end,
              class Ext7 = end, class Ext8 = end, class Ext9 = end>
    class Plugin : public MixinTree<Derived, Ext1, Ext2, Ext3,
                                             Ext4, Ext5, Ext6,
                                             Ext7, Ext8, Ext9>
    {
    public:

        Plugin(uint32_t ports)
            : m_ports(ports, 0), m_ok(true)
        {
            m_features = s_features;
            m_bundle_path = s_bundle_path;
            s_features = 0;
            s_bundle_path = 0;

            if (m_features)
            {
                FeatureHandlerMap hmap;
                Derived::map_feature_handlers (hmap);

                for (const Feature* const* iter = m_features; *iter != 0; ++iter)
                {
                    FeatureHandlerMap::iterator miter;
                    miter = hmap.find((*iter)->URI);

                    if (miter != hmap.end())
                    {
                        miter->second (static_cast<Derived*>(this), (*iter)->data);
                    }
                }
            }
        }


        void connect_port(uint32_t port, void* data_location) {
            m_ports[port] = data_location;
        }

        void activate() { }

        void run(uint32_t sample_count) { }

        void deactivate() { }

        static unsigned
        register_class(const char* uri)
        {
            LV2_Descriptor desc;
            std::memset(&desc, 0, sizeof(LV2_Descriptor));
            desc.URI = strdup (uri);
            desc.instantiate = &Derived::_create_plugin_instance;
            desc.connect_port = &Derived::_connect_port;
            desc.activate = &Derived::_activate;
            desc.run = &Derived::_run;
            desc.deactivate = &Derived::_deactivate;
            desc.cleanup = &Derived::_delete_plugin_instance;
            desc.extension_data = &Derived::extension_data;
            get_lv2_descriptors().push_back (desc);

            return get_lv2_descriptors().size() - 1;
        }

        bool check_ok() {
            return m_ok && MixinTree<Derived,
                    Ext1, Ext2, Ext3, Ext4, Ext5,
                    Ext6, Ext7, Ext8, Ext9>::check_ok();
        }

    protected:

        template <typename T> T*&
        p(uint32_t port)
        {
            return reinterpret_cast<T*&>(m_ports[port]);
        }

        float*&
        p(uint32_t port) {
            return reinterpret_cast<float*&>(m_ports[port]);
        }

        const char*
        bundle_path() const
        {
            return m_bundle_path;
        }

        void
        set_ok(bool ok)
        {
            m_ok = ok;
        }

        std::vector<void*> m_ports;

    private:

        static void _connect_port(LV2_Handle instance, uint32_t port,
                void* data_location) {
            reinterpret_cast<Derived*>(instance)->connect_port(port, data_location);
        }

        static void _activate(LV2_Handle instance) {
            reinterpret_cast<Derived*>(instance)->activate();
        }

        static void _run(LV2_Handle instance, uint32_t sample_count) {
            reinterpret_cast<Derived*>(instance)->run(sample_count);
        }

        static void _deactivate(LV2_Handle instance) {
            reinterpret_cast<Derived*>(instance)->deactivate();
        }

        static LV2_Handle _create_plugin_instance(const LV2_Descriptor* descriptor,
                                                  double sample_rate,
                                                  const char* bundle_path,
                                                  const LV2_Feature* const*
                                                  features)
        {
            // copy some data to static variables so the subclasses don't have to
            // bother with it
            s_features = features;
            s_bundle_path = bundle_path;

            if (LVTK_DEBUG)
            {
                std::clog<<"[plugin] Instantiating plugin...\n"
                        <<"  Bundle path: "<<bundle_path<<"\n"
                        <<"  features: \n";

                FeatureIter feats (features);
                while (const Feature* feature = feats.next())
                    std::clog <<"    "<< feature->URI << "\n";

                std::clog<<"  Creating plugin object...\n";
            }

            Derived* t = new Derived (sample_rate);

            if (LVTK_DEBUG) { std::clog<<"  Validating...\n"; }

            if (t->check_ok()) {
                if (LVTK_DEBUG)
                    std::clog<<"  Done!"<<std::endl;
                return reinterpret_cast<LV2_Handle>(t);
            }

            if (LVTK_DEBUG) {
                std::clog<<"  Failed!\n"
                        <<"  Deleting object."<<std::endl;
            }

            delete t;
            return 0;
        }

        static void _delete_plugin_instance(LV2_Handle instance) {
            delete reinterpret_cast<Derived*> (instance);
        }


    private:

        Feature const* const* m_features;

        char const* m_bundle_path;

        static Feature const* const* s_features;

        static char const* s_bundle_path;

        bool m_ok;

    };


    // The static variables need to be initialised.
    template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
    class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
    Feature const* const*
    Plugin<Derived, Ext1, Ext2, Ext3, Ext4,
    Ext5, Ext6, Ext7, Ext8, Ext9>::s_features = 0;

    template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
    class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
    char const*
    Plugin<Derived, Ext1, Ext2, Ext3, Ext4,
    Ext5, Ext6, Ext7, Ext8, Ext9>::s_bundle_path = 0;


} /* namespace lvtk */


#endif /* LVTK_PLUGIN_HPP */