Lv2Ports.h

Go to the documentation of this file.

/*
 * Lv2Ports.h - Lv2 port classes definitions
 *
 * Copyright (c) 2019-2020 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * 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 (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_LV2PORTS_H
#define LMMS_LV2PORTS_H
 
#include "lmmsconfig.h"
 
#ifdef LMMS_HAVE_LV2
 
#include <lilv/lilv.h>
#include <memory>
#include <vector>
 
#include "Flags.h"
#include "LmmsTypes.h"
#include "PluginIssue.h"
 
 
namespace lmms
{
 
class SampleFrame;
 
struct ConnectPortVisitor;
using LV2_Evbuf = struct LV2_Evbuf_Impl;
 
namespace Lv2Ports {
 
/*
    port structs
*/
enum class Flow {
    Unknown,
    Input,
    Output
};
 
enum class Type {
    Unknown,
    Control,
    Audio,
    AtomSeq,
    Cv 
};

enum class Vis {
    Generic, 
    Integer, 
    Enumeration, 
    Toggled 
};
 
const char* toStr(Lv2Ports::Flow pf);
const char* toStr(Lv2Ports::Type pt);
const char* toStr(Lv2Ports::Vis pv);
 
struct ControlPortBase;
struct Control;
struct Audio;
struct Cv;
struct AtomSeq;
struct Unknown;
 
struct ConstVisitor
{
    virtual void visit(const Lv2Ports::ControlPortBase& ) {}
    virtual void visit(const Lv2Ports::Control& ) {}
    virtual void visit(const Lv2Ports::Audio& ) {}
    virtual void visit(const Lv2Ports::Cv& ) {}
    virtual void visit(const Lv2Ports::AtomSeq& ) {}
    virtual void visit(const Lv2Ports::Unknown& ) {}
 
    virtual ~ConstVisitor() = default;
};
 
struct Visitor
{
    virtual void visit(Lv2Ports::ControlPortBase& ) {}
    virtual void visit(Lv2Ports::Control& ) {}
    virtual void visit(Lv2Ports::Audio& ) {}
    virtual void visit(Lv2Ports::Cv& ) {}
    virtual void visit(Lv2Ports::AtomSeq& ) {}
    virtual void visit(Lv2Ports::Unknown& ) {}
 
    virtual ~Visitor() = default;
};
 
struct Meta
{
    Type m_type = Type::Unknown;
    Flow m_flow = Flow::Unknown;
    Vis m_vis = Vis::Generic;
 
    bool m_logarithmic = false;
 
    bool m_optional = false;
    bool m_used = true;
 
    std::vector<PluginIssue> get(const LilvPlugin* plugin, std::size_t portNum);
 
    float def() const { return m_def; }
    float min(sample_rate_t sr) const { return m_sampleRate ? sr * m_min : m_min; }
    float max(sample_rate_t sr) const { return m_sampleRate ? sr * m_max : m_max; }
private:
    float m_def = .0f, m_min = .0f, m_max = .0f;
    bool m_sampleRate = false;
};
 
struct PortBase : public Meta
{
    const LilvPort* m_port = nullptr;
    const LilvPlugin* m_plugin = nullptr;
 
    virtual void accept(Visitor& v) = 0;
    virtual void accept(ConstVisitor& v) const = 0;
 
    QString name() const;
    QString uri() const;
 
    virtual ~PortBase() = default;
};
 
template<typename Derived, typename Base>
struct VisitablePort : public Base
{
    void accept(Visitor& v) override { v.visit(static_cast<Derived&>(*this)); }
    void accept(ConstVisitor& v) const override { v.visit(static_cast<const Derived&>(*this)); }
};
 
struct ControlPortBase : public VisitablePort<ControlPortBase, PortBase>
{
    std::unique_ptr<class AutomatableModel> m_connectedModel;

    std::vector<float> m_scalePointMap;
};
 
struct Control : public VisitablePort<Control, ControlPortBase>
{
    float m_val;
};
 
struct Cv : public VisitablePort<Cv, ControlPortBase>
{
    std::vector<float> m_buffer;
};
 
struct Audio : public VisitablePort<Audio, PortBase>
{
    Audio(std::size_t bufferSize, bool isSidechain);

    void copyBuffersFromCore(const SampleFrame* lmmsBuf, unsigned channel, f_cnt_t frames);

    void averageWithBuffersFromCore(const SampleFrame* lmmsBuf, unsigned channel, f_cnt_t frames);

    void copyBuffersToCore(SampleFrame* lmmsBuf, unsigned channel, f_cnt_t frames) const;
 
    bool isSideChain() const { return m_sidechain; }
    bool isOptional() const { return m_optional; }
    bool mustBeUsed() const { return !isSideChain() && !isOptional(); }
    std::size_t bufferSize() const { return m_buffer.size(); }
 
private:
    std::vector<float> m_buffer; 
    bool m_sidechain;
 
    // the only case when data of m_buffer may be referenced:
    friend struct lmms::ConnectPortVisitor;
};
 
struct AtomSeq : public VisitablePort<AtomSeq, PortBase>
{
    enum class FlagType
    {
        None = 0,
        Midi = 1
    };
    Flags<FlagType> flags = FlagType::None;
 
    struct Lv2EvbufDeleter
    {
        void operator()(LV2_Evbuf* n);
    };
    using AutoLv2Evbuf = std::unique_ptr<LV2_Evbuf, Lv2EvbufDeleter>;
    AutoLv2Evbuf m_buf;
};
 
struct Unknown : public VisitablePort<Unknown, PortBase>
{
};
 
/*
    port casts
*/
template<class Target>
struct DCastVisitor : public Visitor
{
    Target* m_result = nullptr;
    void visit(Target& tar) { m_result = &tar; }
};
 
template<class Target>
struct ConstDCastVisitor : public ConstVisitor
{
    const Target* m_result = nullptr;
    void visit(const Target& tar) { m_result = &tar; }
};

template<class Target>
Target* dcast(PortBase* base)
{
    DCastVisitor<Target> vis;
    base->accept(vis);
    return vis.m_result;
}

template<class Target>
const Target* dcast(const PortBase* base)
{
    ConstDCastVisitor<Target> vis;
    base->accept(vis);
    return vis.m_result;
}
 
} // namespace Lv2Ports
 
 
} // namespace lmms
 
#endif // LMMS_HAVE_LV2
 
#endif // LMMS_LV2PORTS_H