DPF

CairoExamplePlugin.cpp (6228B)

---

 /*
  * DISTRHO Plugin Framework (DPF)
  * Copyright (C) 2019-2021 Jean Pierre Cimalando <jp-dev@inbox.ru>
  * Copyright (C) 2012-2024 Filipe Coelho <falktx@falktx.com>
  *
  * Permission to use, copy, modify, and/or distribute this software for any purpose with
  * or without fee is hereby granted, provided that the above copyright notice and this
  * permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 #include "DistrhoPlugin.hpp"
 
 #include <string.h>
 
 START_NAMESPACE_DISTRHO
 
 class CairoExamplePlugin : public Plugin
 {
     float fParameters[kParameterCount];
 
 public:
     CairoExamplePlugin()
         : Plugin(kParameterCount, 0, 0)
     {
         std::memset(fParameters, 0, sizeof(fParameters));
     }
 
    /**
       Get the plugin label.@n
       This label is a short restricted name consisting of only _, a-z, A-Z and 0-9 characters.
     */
     const char* getLabel() const override
     {
         return "cairo_ui";
     }
 
    /**
       Get an extensive comment/description about the plugin.
     */
     const char* getDescription() const override
     {
         return "Cairo DPF Example";
     }
 
    /**
       Get the plugin author/maker.
     */
     const char* getMaker() const override
     {
         return "DISTRHO";
     }
 
    /**
       Get the plugin license (a single line of text or a URL).@n
       For commercial plugins this should return some short copyright information.
     */
     const char* getLicense() const override
     {
         return "ISC";
     }
 
    /**
       Get the plugin version, in hexadecimal.
     */
     uint32_t getVersion() const override
     {
         return d_version(1, 0, 0);
     }
 
    /**
       Initialize the audio port @a index.@n
       This function will be called once, shortly after the plugin is created.
     */
     void initAudioPort(const bool input, const uint32_t index, AudioPort& port) override
     {
         // treat meter audio ports as stereo
         port.groupId = kPortGroupMono;
 
         // everything else is as default
         Plugin::initAudioPort(input, index, port);
     }
 
    /**
       Initialize the parameter @a index.@n
       This function will be called once, shortly after the plugin is created.
     */
     void initParameter(const uint32_t index, Parameter& parameter) override
     {
        /**
           All parameters in this plugin have the same ranges.
         */
         switch (index)
         {
         case kParameterKnob:
             parameter.hints  = kParameterIsAutomatable;
             parameter.name   = "Knob";
             parameter.symbol = "knob";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             parameter.ranges.def = 0.0f;
             break;
         case kParameterTriState:
             parameter.hints  = kParameterIsAutomatable|kParameterIsInteger;
             parameter.name   = "Color";
             parameter.symbol = "color";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 2.0f;
             parameter.ranges.def = 0.0f;
             parameter.enumValues.count = 3;
             parameter.enumValues.restrictedMode = true;
             {
                 ParameterEnumerationValue* const values = new ParameterEnumerationValue[3];
                 parameter.enumValues.values = values;
                 values[0].label = "Red";
                 values[0].value = 0;
                 values[1].label = "Green";
                 values[1].value = 1;
                 values[2].label = "Blue";
                 values[2].value = 2;
             }
             break;
         case kParameterButton:
             parameter.hints  = kParameterIsAutomatable|kParameterIsBoolean;
             parameter.name   = "Button";
             parameter.symbol = "button";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             parameter.ranges.def = 0.0f;
             parameter.enumValues.count = 2;
             parameter.enumValues.restrictedMode = true;
             {
                 ParameterEnumerationValue* const values = new ParameterEnumerationValue[2];
                 parameter.enumValues.values = values;
                 values[0].label = "Off";
                 values[0].value = 0;
                 values[1].label = "On";
                 values[1].value = 1;
             }
             break;
         }
     }
 
    /**
       Get the current value of a parameter.@n
       The host may call this function from any context, including realtime processing.
     */
     float getParameterValue(const uint32_t index) const override
     {
         return fParameters[index];
     }
 
    /**
       Change a parameter value.@n
       The host may call this function from any context, including realtime processing.@n
       When a parameter is marked as automatable, you must ensure no non-realtime operations are performed.
       @note This function will only be called for parameter inputs.
     */
     void setParameterValue(const uint32_t index, const float value) override
     {
         fParameters[index] = value;
     }
 
    /**
       Run/process function for plugins without MIDI input.
       @note Some parameters might be null if there are no audio inputs or outputs.
     */
     void run(const float** const inputs, float** const outputs, const uint32_t frames) override
     {
        /**
           This plugin does nothing, it just demonstrates cairo UI usage.
           So here we directly copy inputs over outputs, leaving the audio untouched.
           We need to be careful in case the host re-uses the same buffer for both inputs and outputs.
         */
         if (outputs[0] != inputs[0])
             std::memcpy(outputs[0], inputs[0], sizeof(float)*frames);
     }
 };
 
 Plugin* createPlugin()
 {
     return new CairoExamplePlugin;
 }
 
 END_NAMESPACE_DISTRHO