plugin_descriptor.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2021 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __PLUGINS_PLUGIN_DESCRIPTOR_H__
#define __PLUGINS_PLUGIN_DESCRIPTOR_H__
 
#include "zrythm-config.h"
 
#include <stdbool.h>
 
#include "utils/yaml.h"
 
#include <glib/gi18n.h>
 
#include <CarlaBackend.h>
 
typedef struct _WrappedObjectWithChangeSignal WrappedObjectWithChangeSignal;
 
#define PLUGIN_DESCRIPTOR_SCHEMA_VERSION 1
 
typedef enum ZPluginCategory
{
  ZPLUGIN_CATEGORY_NONE,
  PC_DELAY,
  PC_REVERB,
  PC_DISTORTION,
  PC_WAVESHAPER,
  PC_DYNAMICS,
  PC_AMPLIFIER,
  PC_COMPRESSOR,
  PC_ENVELOPE,
  PC_EXPANDER,
  PC_GATE,
  PC_LIMITER,
  PC_FILTER,
  PC_ALLPASS_FILTER,
  PC_BANDPASS_FILTER,
  PC_COMB_FILTER,
  PC_EQ,
  PC_MULTI_EQ,
  PC_PARA_EQ,
  PC_HIGHPASS_FILTER,
  PC_LOWPASS_FILTER,
  PC_GENERATOR,
  PC_CONSTANT,
  PC_INSTRUMENT,
  PC_OSCILLATOR,
  PC_MIDI,
  PC_MODULATOR,
  PC_CHORUS,
  PC_FLANGER,
  PC_PHASER,
  PC_SIMULATOR,
  PC_SIMULATOR_REVERB,
  PC_SPATIAL,
  PC_SPECTRAL,
  PC_PITCH,
  PC_UTILITY,
  PC_ANALYZER,
  PC_CONVERTER,
  PC_FUNCTION,
  PC_MIXER,
} ZPluginCategory;
 
static const cyaml_strval_t plugin_descriptor_category_strings[] = {
  {"None",              ZPLUGIN_CATEGORY_NONE},
  { "Delay",            PC_DELAY             },
  { "Reverb",           PC_REVERB            },
  { "Distortion",       PC_DISTORTION        },
  { "Waveshaper",       PC_WAVESHAPER        },
  { "Dynamics",         PC_DYNAMICS          },
  { "Amplifier",        PC_AMPLIFIER         },
  { "Compressor",       PC_COMPRESSOR        },
  { "Envelope",         PC_ENVELOPE          },
  { "Expander",         PC_EXPANDER          },
  { "Gate",             PC_GATE              },
  { "Limiter",          PC_LIMITER           },
  { "Filter",           PC_FILTER            },
  { "Allpass Filter",   PC_ALLPASS_FILTER    },
  { "Bandpass Filter",  PC_BANDPASS_FILTER   },
  { "Comb Filter",      PC_COMB_FILTER       },
  { "EQ",               PC_EQ                },
  { "Multi-EQ",         PC_MULTI_EQ          },
  { "Parametric EQ",    PC_PARA_EQ           },
  { "Highpass Filter",  PC_HIGHPASS_FILTER   },
  { "Lowpass Filter",   PC_LOWPASS_FILTER    },
  { "Generator",        PC_GENERATOR         },
  { "Constant",         PC_CONSTANT          },
  { "Instrument",       PC_INSTRUMENT        },
  { "Oscillator",       PC_OSCILLATOR        },
  { "MIDI",             PC_MIDI              },
  { "Modulator",        PC_MODULATOR         },
  { "Chorus",           PC_CHORUS            },
  { "Flanger",          PC_FLANGER           },
  { "Phaser",           PC_PHASER            },
  { "Simulator",        PC_SIMULATOR         },
  { "Simulator Reverb", PC_SIMULATOR_REVERB  },
  { "Spatial",          PC_SPATIAL           },
  { "Spectral",         PC_SPECTRAL          },
  { "Pitch",            PC_PITCH             },
  { "Utility",          PC_UTILITY           },
  { "Analyzer",         PC_ANALYZER          },
  { "Converter",        PC_CONVERTER         },
  { "Function",         PC_FUNCTION          },
  { "Mixer",            PC_MIXER             },
};
 
typedef enum ZPluginProtocol
{
  Z_PLUGIN_PROTOCOL_DUMMY,
  Z_PLUGIN_PROTOCOL_LV2,
  Z_PLUGIN_PROTOCOL_DSSI,
  Z_PLUGIN_PROTOCOL_LADSPA,
  Z_PLUGIN_PROTOCOL_VST,
  Z_PLUGIN_PROTOCOL_VST3,
  Z_PLUGIN_PROTOCOL_AU,
  Z_PLUGIN_PROTOCOL_SFZ,
  Z_PLUGIN_PROTOCOL_SF2,
  Z_PLUGIN_PROTOCOL_CLAP,
  Z_PLUGIN_PROTOCOL_JSFX,
} ZPluginProtocol;
 
static const cyaml_strval_t plugin_protocol_strings[] = {
  {N_ ("Dummy"), Z_PLUGIN_PROTOCOL_DUMMY },
  { "LV2",       Z_PLUGIN_PROTOCOL_LV2   },
  { "DSSI",      Z_PLUGIN_PROTOCOL_DSSI  },
  { "LADSPA",    Z_PLUGIN_PROTOCOL_LADSPA},
  { "VST",       Z_PLUGIN_PROTOCOL_VST   },
  { "VST3",      Z_PLUGIN_PROTOCOL_VST3  },
  { "AU",        Z_PLUGIN_PROTOCOL_AU    },
  { "SFZ",       Z_PLUGIN_PROTOCOL_SFZ   },
  { "SF2",       Z_PLUGIN_PROTOCOL_SF2   },
  { "CLAP",      Z_PLUGIN_PROTOCOL_CLAP  },
  { "JSFX",      Z_PLUGIN_PROTOCOL_JSFX  },
};
 
typedef enum PluginArchitecture
{
  ARCH_32,
  ARCH_64
} PluginArchitecture;
 
static const cyaml_strval_t plugin_architecture_strings[] = {
  {"32-bit",  ARCH_32},
  { "64-bit", ARCH_64},
};
 
typedef enum CarlaBridgeMode
{
  CARLA_BRIDGE_NONE,
  CARLA_BRIDGE_UI,
  CARLA_BRIDGE_FULL,
} CarlaBridgeMode;
 
static const cyaml_strval_t carla_bridge_mode_strings[] = {
  {"None",  CARLA_BRIDGE_NONE},
  { "UI",   CARLA_BRIDGE_UI  },
  { "Full", CARLA_BRIDGE_FULL},
};
 
/***
 * A descriptor to be implemented by all plugins
 * This will be used throughout the UI
 */
typedef struct PluginDescriptor
{
  int             schema_version;
  char *          author;
  char *          name;
  char *          website;
  ZPluginCategory category;
  char * category_str;
  int num_audio_ins;
  int num_midi_ins;
  int num_audio_outs;
  int num_midi_outs;
  int num_ctrl_ins;
  int num_ctrl_outs;
  int num_cv_ins;
  int num_cv_outs;
  PluginArchitecture arch;
  ZPluginProtocol protocol;
  char * path;
  char * uri;
 
  int64_t unique_id;
 
  CarlaBridgeMode min_bridge_mode;
 
  bool has_custom_ui;
 
  unsigned int ghash;
 
  char * sha1;
 
  WrappedObjectWithChangeSignal * gobj;
} PluginDescriptor;
 
static const cyaml_schema_field_t plugin_descriptor_fields_schema[] = {
  YAML_FIELD_INT (PluginDescriptor, schema_version),
  YAML_FIELD_STRING_PTR_OPTIONAL (PluginDescriptor, author),
  YAML_FIELD_STRING_PTR_OPTIONAL (PluginDescriptor, name),
  YAML_FIELD_STRING_PTR_OPTIONAL (PluginDescriptor, website),
  YAML_FIELD_ENUM (PluginDescriptor, category, plugin_descriptor_category_strings),
  YAML_FIELD_STRING_PTR_OPTIONAL (PluginDescriptor, category_str),
  YAML_FIELD_INT (PluginDescriptor, num_audio_ins),
  YAML_FIELD_INT (PluginDescriptor, num_audio_outs),
  YAML_FIELD_INT (PluginDescriptor, num_midi_ins),
  YAML_FIELD_INT (PluginDescriptor, num_midi_outs),
  YAML_FIELD_INT (PluginDescriptor, num_ctrl_ins),
  YAML_FIELD_INT (PluginDescriptor, num_ctrl_outs),
  YAML_FIELD_INT (PluginDescriptor, num_cv_ins),
  YAML_FIELD_UINT (PluginDescriptor, unique_id),
  YAML_FIELD_INT (PluginDescriptor, num_cv_outs),
  YAML_FIELD_ENUM (PluginDescriptor, arch, plugin_architecture_strings),
  YAML_FIELD_ENUM (PluginDescriptor, protocol, plugin_protocol_strings),
  YAML_FIELD_STRING_PTR_OPTIONAL (PluginDescriptor, path),
  YAML_FIELD_STRING_PTR_OPTIONAL (PluginDescriptor, uri),
  YAML_FIELD_ENUM (PluginDescriptor, min_bridge_mode, carla_bridge_mode_strings),
  YAML_FIELD_INT (PluginDescriptor, has_custom_ui),
  YAML_FIELD_UINT (PluginDescriptor, ghash),
  YAML_FIELD_STRING_PTR_OPTIONAL (PluginDescriptor, sha1),
 
  CYAML_FIELD_END
};
 
static const cyaml_schema_value_t plugin_descriptor_schema = {
  YAML_VALUE_PTR (PluginDescriptor, plugin_descriptor_fields_schema),
};
 
PluginDescriptor *
plugin_descriptor_new (void);
 
const char *
plugin_protocol_to_str (ZPluginProtocol prot);
 
ZPluginProtocol
plugin_protocol_from_str (const char * str);
 
static inline const char *
plugin_protocol_get_icon_name (ZPluginProtocol prot)
{
  const char * icon = NULL;
  switch (prot)
    {
    case Z_PLUGIN_PROTOCOL_LV2:
      icon = "logo-lv2";
      break;
    case Z_PLUGIN_PROTOCOL_LADSPA:
      icon = "logo-ladspa";
      break;
    case Z_PLUGIN_PROTOCOL_AU:
      icon = "logo-au";
      break;
    case Z_PLUGIN_PROTOCOL_VST:
    case Z_PLUGIN_PROTOCOL_VST3:
      icon = "logo-vst";
      break;
    case Z_PLUGIN_PROTOCOL_SFZ:
    case Z_PLUGIN_PROTOCOL_SF2:
      icon = "file-music-line";
      break;
    default:
      icon = "plug";
      break;
    }
  return icon;
}
 
bool
plugin_protocol_is_supported (ZPluginProtocol protocol);
 
const char *
plugin_category_to_string (ZPluginCategory category);
 
PluginType
plugin_descriptor_get_carla_plugin_type_from_protocol (ZPluginProtocol protocol);
 
ZPluginProtocol
plugin_descriptor_get_protocol_from_carla_plugin_type (PluginType ptype);
 
ZPluginCategory
plugin_descriptor_get_category_from_carla_category_str (const char * category);
 
ZPluginCategory
plugin_descriptor_get_category_from_carla_category (PluginCategory carla_cat);
 
NONNULL void
plugin_descriptor_copy (PluginDescriptor * dest, const PluginDescriptor * src);
 
NONNULL PluginDescriptor *
plugin_descriptor_clone (const PluginDescriptor * src);
 
NONNULL bool
plugin_descriptor_is_instrument (const PluginDescriptor * const descr);
 
NONNULL bool
plugin_descriptor_is_effect (const PluginDescriptor * const descr);
 
NONNULL int
plugin_descriptor_is_modulator (const PluginDescriptor * const descr);
 
NONNULL int
plugin_descriptor_is_midi_modifier (const PluginDescriptor * const descr);
 
NONNULL ZPluginCategory
plugin_descriptor_string_to_category (const char * str);
 
char *
plugin_descriptor_category_to_string (ZPluginCategory category);
 
const char *
plugin_descriptor_get_icon_name (const PluginDescriptor * const self);
 
bool
plugin_descriptor_is_valid_for_slot_type (
  const PluginDescriptor * self,
  int                      slot_type,
  int                      track_type);
 
NONNULL bool
plugin_descriptor_is_same_plugin (
  const PluginDescriptor * a,
  const PluginDescriptor * b);
 
NONNULL bool
plugin_descriptor_has_custom_ui (const PluginDescriptor * self);
 
NONNULL CarlaBridgeMode
plugin_descriptor_get_min_bridge_mode (const PluginDescriptor * self);
 
NONNULL bool
plugin_descriptor_is_whitelisted (const PluginDescriptor * self);
 
NONNULL GMenuModel *
plugin_descriptor_generate_context_menu (const PluginDescriptor * self);
 
NONNULL void
plugin_descriptor_free (PluginDescriptor * self);
 
NONNULL void
plugin_descriptor_free_closure (void * data, GClosure * closure);
 
#endif