tracktion_VSTXML.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
class VSTXML
{
public:
    static VSTXML* createFor (const juce::XmlElement& xml)
    {
        if (xml.hasTagName ("VSTParametersStructure"))
            return new VSTXML (xml);
 
        if (const auto* x = xml.getChildByName ("VSTParametersStructure"))
            return new VSTXML (*x);
 
        return {};
    }
 
    //=============================================================================
    struct Group;
 
    struct Base
    {
        Base() noexcept {}
        virtual ~Base() {}
 
        Group* parent = nullptr;
    };
 
    struct Param  : public Base
    {
        int paramID = 0;
        juce::String expr, name, label;
        juce::StringArray shortNames;
        juce::String type;
        int numberOfStates = 0;
        float defaultValue = 0.0f;
    };
 
    struct Group  : public Base
    {
        juce::String name;
        juce::OwnedArray<Base> paramTree;
    };
 
    struct Range
    {
        Range() noexcept {}
        Range (const juce::String& s)       { set (s); }
 
        void set (const juce::String& s)
        {
            inclusiveLow  = s.startsWithChar ('[');
            inclusiveHigh = s.endsWithChar   (']');
 
            auto str = s.removeCharacters ("[]");
 
            low  = str.upToFirstOccurrenceOf (",", false, false).getFloatValue();
            high = str.fromLastOccurrenceOf  (",", false, false).getFloatValue();
        }
 
        bool contains (float f) const noexcept
        {
            return (inclusiveLow  ? (f >= low)  : (f > low))
                && (inclusiveHigh ? (f <= high) : (f < high));
        }
 
        float low = 0;
        float high = 0;
 
        bool inclusiveLow = false;
        bool inclusiveHigh = false;
    };
 
    struct Entry
    {
        juce::String name;
        Range range;
    };
 
    struct ValueType
    {
        juce::String name, label;
        juce::OwnedArray<Entry> entries;
    };
 
    struct Template
    {
        juce::String name;
        juce::OwnedArray<Param> params;
    };
 
    const Param* getParamForID (int paramID, const Group* grp) const
    {
        for (auto item : (grp != nullptr ? grp->paramTree : paramTree))
        {
            if (auto param = dynamic_cast<const Param*> (item))
                if (param->paramID == paramID)
                    return param;
 
            if (auto group = dynamic_cast<const Group*> (item))
                if (auto res = getParamForID (paramID, group))
                    return res;
        }
 
        return {};
    }
 
    const ValueType* getValueType (const juce::String& name) const
    {
        for (auto v : valueTypes)
            if (v->name == name)
                return v;
 
        return {};
    }
 
    juce::OwnedArray<Base> paramTree;
    juce::OwnedArray<ValueType> valueTypes;
    juce::OwnedArray<Template> templates;
 
private:
    VSTXML (const juce::XmlElement& xml)
    {
        for (auto item : xml.getChildIterator())
        {
            if (item->hasTagName ("Param"))           parseParam (*item, nullptr, nullptr);
            else if (item->hasTagName ("ValueType"))  parseValueType (*item);
            else if (item->hasTagName ("Template"))   parseTemplate (*item);
            else if (item->hasTagName ("Group"))      parseGroup (*item, nullptr);
        }
    }
 
    void parseParam (const juce::XmlElement& item, Group* group, Template* temp)
    {
        auto param = new Param();
 
        if (temp != nullptr)
            param->expr = item.getStringAttribute ("id");
        else
            param->paramID = item.getIntAttribute ("id");
 
        param->name             = item.getStringAttribute ("name");
        param->label            = item.getStringAttribute ("label");
        param->type             = item.getStringAttribute ("type");
        param->numberOfStates   = item.getIntAttribute ("numberOfStates");
        param->defaultValue     = (float) item.getDoubleAttribute ("defaultValue");
 
        param->shortNames.addTokens (item.getStringAttribute ("shortName"), ",", {});
        param->shortNames.trim();
        param->shortNames.removeEmptyStrings();
 
        if (group != nullptr)
        {
            group->paramTree.add (param);
            param->parent = group;
        }
        else if (temp != nullptr)
        {
            temp->params.add (param);
        }
        else
        {
            paramTree.add (param);
        }
    }
 
    void parseValueType (const juce::XmlElement& item)
    {
        auto vt = new ValueType();
        valueTypes.add (vt);
 
        vt->name  = item.getStringAttribute ("name");
        vt->label = item.getStringAttribute ("label");
 
        int curEntry = 0;
        const int numEntries = item.getNumChildElements();
 
        for (auto entryXml : item.getChildWithTagNameIterator ("Entry"))
        {
            auto entry = new Entry();
            entry->name = entryXml->getStringAttribute ("name");
 
            if (entryXml->hasAttribute ("value"))
            {
                entry->range.set (entryXml->getStringAttribute ("value"));
            }
            else
            {
                entry->range.low  = curEntry / (float) numEntries;
                entry->range.high = (curEntry + 1) / (float) numEntries;
 
                entry->range.inclusiveLow  = true;
                entry->range.inclusiveHigh = (curEntry == numEntries - 1);
            }
 
            vt->entries.add (entry);
            ++curEntry;
        }
    }
 
    void parseTemplate (const juce::XmlElement& item)
    {
        auto temp = new Template();
        templates.add (temp);
        temp->name = item.getStringAttribute ("name");
 
        for (auto param : item.getChildIterator())
            parseParam (*param, nullptr, temp);
    }
 
    void parseGroup (const juce::XmlElement& item, Group* parentGroup)
    {
        auto group = new Group();
 
        if (parentGroup)
        {
            parentGroup->paramTree.add (group);
            group->parent = parentGroup;
        }
        else
        {
            paramTree.add (group);
        }
 
        group->name = item.getStringAttribute ("name");
 
        if (item.hasAttribute ("template"))
        {
            juce::StringArray variables;
            variables.addTokens (item.getStringAttribute ("values"), ";", {});
            variables.trim();
 
            for (auto temp : templates)
            {
                if (temp->name == item.getStringAttribute ("template"))
                {
                    for (int i = 0; i < temp->params.size(); ++i)
                    {
                        auto param = new Param();
                        group->paramTree.add (param);
 
                        param->parent           = group;
                        param->paramID          = evaluate (temp->params[i]->expr, variables);
                        param->defaultValue     = temp->params[i]->defaultValue;
                        param->label            = temp->params[i]->label;
                        param->name             = temp->params[i]->name;
                        param->numberOfStates   = temp->params[i]->numberOfStates;
                        param->shortNames       = temp->params[i]->shortNames;
                        param->type             = temp->params[i]->type;
                    }
                }
            }
        }
        else
        {
            for (auto subItem : item.getChildIterator())
            {
                if (subItem->hasTagName ("Param"))       parseParam (*subItem, group, nullptr);
                else if (subItem->hasTagName ("Group"))  parseGroup (*subItem, group);
            }
        }
    }
 
    int evaluate (juce::String expr, const juce::StringArray& variables) const
    {
        juce::StringArray names;
        juce::Array<int> vals;
 
        for (auto& v : variables)
        {
            if (v.contains ("="))
            {
                names.add (v.upToFirstOccurrenceOf ("=", false, false));
                vals.add  (v.fromFirstOccurrenceOf ("=", false, false).getIntValue());
            }
        }
 
        for (int i = 0; i < names.size(); ++i)
        {
            for (;;)
            {
                const int idx = expr.indexOfWholeWord (names[i]);
                if (idx < 0)
                    break;
 
                expr = expr.replaceSection (idx, names[i].length(), juce::String (vals[i]));
            }
        }
 
        expr = expr.retainCharacters ("01234567890-+")
                   .replace ("+", " + ")
                   .replace ("-", " - ");
 
        juce::StringArray tokens;
        tokens.addTokens (expr, " ", {});
 
        bool add = true;
        int val = 0;
 
        for (const auto& s : tokens)
        {
            if (s == "+")
            {
                add = true;
            }
            else if (s == "-")
            {
                add = false;
            }
            else
            {
                if (add)
                    val += s.getIntValue();
                else
                    val -= s.getIntValue();
            }
        }
 
        return val;
    }
};
 
}} // namespace tracktion { inline namespace engine