DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
Browse Source

Partially revert changes to ParameterEnumerationValues 

Signed-off-by: falkTX <falktx@falktx.com>
pull/421/head
falkTX 2 years ago
parent
354be5a665
commit
b0d860f5d6
Signed by: falkTX <falktx@falktx.com> GPG Key ID: CDBAA37ABC74FBA0
7 changed files with 49 additions and 129 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +19
    -90
      distrho/DistrhoDetails.hpp
  2. +5
    -6
      distrho/src/DistrhoPlugin.cpp
  3. +4
    -4
      distrho/src/DistrhoPluginCLAP.cpp
  4. +6
    -14
      distrho/src/DistrhoPluginInternal.hpp
  5. +6
    -6
      distrho/src/DistrhoPluginLV2export.cpp
  6. +2
    -2
      distrho/src/DistrhoPluginVST2.cpp
  7. +7
    -7
      distrho/src/DistrhoPluginVST3.cpp

+ 19
- 90
distrho/DistrhoDetails.hpp View File

@@ -506,93 +506,11 @@ struct ParameterEnumerationValue {
#endif
};

/**
Collection of parameter enumeration values.@n
Handy class to handle the lifetime and count of all enumeration values.
*/
struct ParameterEnumerationValues {
uint8_t count;
bool deleteLater;
const ParameterEnumerationValue* ptr;

constexpr ParameterEnumerationValues() noexcept
: count(0),
deleteLater(false),
ptr(nullptr) {}

constexpr ParameterEnumerationValues(uint32_t c, const ParameterEnumerationValue* v) noexcept
: count(c),
deleteLater(false),
ptr(v) {}

// constexpr
~ParameterEnumerationValues() noexcept
{
if (deleteLater)
delete[] ptr;
}

const ParameterEnumerationValue& operator[](const uint8_t index) const noexcept
{
return ptr[index];
}

template<uint8_t numValues>
ParameterEnumerationValues& operator=(const ParameterEnumerationValue values[numValues]) noexcept
{
if (deleteLater)
delete[] ptr;

count = numValues;
ptr = values;
deleteLater = true;
return *this;
}

ParameterEnumerationValues& operator=(const ParameterEnumerationValues& other) noexcept
{
if (deleteLater)
delete[] ptr;

count = 0;
ptr = nullptr;
deleteLater = false;

if (other.ptr != nullptr && other.count != 0)
{
ParameterEnumerationValue* ptr2;

try {
ptr2 = new ParameterEnumerationValue[other.count];
} DISTRHO_SAFE_EXCEPTION_RETURN("ParameterEnumerationValues::recreate", *this);

for (uint8_t i=0; i<other.count; ++i)
{
ptr2[i].value = other.ptr[i].value;
ptr2[i].label = other.ptr[i].label;
}

count = other.count;
ptr = ptr2;
deleteLater = true;
}

return *this;
}

private:
#ifdef DISTRHO_PROPER_CPP11_SUPPORT
ParameterEnumerationValues(const ParameterEnumerationValues&) = delete;
#else
ParameterEnumerationValues(const ParameterEnumerationValues&);
#endif
};

/**
Details around parameter enumeration values.@n
Wraps ParameterEnumerationValues and provides a few extra details to the host about these values.
*/
struct ParameterEnumerationDetails {
struct ParameterEnumerationValues {
/**
Number of elements allocated in @values.
*/
@@ -609,24 +527,36 @@ struct ParameterEnumerationDetails {
Array of @ParameterEnumerationValue items.@n
This pointer must be null or have been allocated on the heap with `new ParameterEnumerationValue[count]`.
*/
ParameterEnumerationValues values;
const ParameterEnumerationValue* values;

/**
Default constructor, for zero enumeration values.
*/
constexpr ParameterEnumerationDetails() noexcept
constexpr ParameterEnumerationValues() noexcept
: count(0),
restrictedMode(false),
values() {}
values(nullptr),
deleteLater(true) {}

/**
Constructor using custom values.@n
The pointer to @values must have been allocated on the heap with `new`.
*/
constexpr ParameterEnumerationDetails(uint32_t c, bool r, const ParameterEnumerationValue* v) noexcept
constexpr ParameterEnumerationValues(uint32_t c, bool r, const ParameterEnumerationValue* v) noexcept
: count(c),
restrictedMode(r),
values(c, v) {}
values(v),
deleteLater(false) {}

// constexpr
~ParameterEnumerationValues() noexcept
{
if (deleteLater)
delete[] values;
}

private:
bool deleteLater;
};

/**
@@ -683,9 +613,8 @@ struct Parameter {
/**
Enumeration details.@n
Can be used to give meaning to parameter values, working as an enumeration.
@todo rename to enumDetails
*/
ParameterEnumerationDetails enumValues;
ParameterEnumerationValues enumValues;

/**
Designation for this parameter.


+ 5
- 6
distrho/src/DistrhoPlugin.cpp View File

@@ -31,12 +31,11 @@ bool d_nextCanRequestParameterValueChanges = false;
/* ------------------------------------------------------------------------------------------------------------
* Static fallback data, see DistrhoPluginInternal.hpp */

const String PluginExporter::sFallbackString;
/* */ AudioPortWithBusId PluginExporter::sFallbackAudioPort;
const ParameterRanges PluginExporter::sFallbackRanges;
const ParameterEnumerationDetails PluginExporter::sFallbackEnumDetails;
const ParameterEnumerationValues PluginExporter::sFallbackEnumValues;
const PortGroupWithId PluginExporter::sFallbackPortGroup;
const String PluginExporter::sFallbackString;
/* */ AudioPortWithBusId PluginExporter::sFallbackAudioPort;
const ParameterRanges PluginExporter::sFallbackRanges;
const ParameterEnumerationValues PluginExporter::sFallbackEnumValues;
const PortGroupWithId PluginExporter::sFallbackPortGroup;

/* ------------------------------------------------------------------------------------------------------------
* Plugin */


+ 4
- 4
distrho/src/DistrhoPluginCLAP.cpp View File

@@ -1181,9 +1181,9 @@ public:

for (uint32_t i=0; i < enumValues.count; ++i)
{
if (d_isEqual(static_cast<double>(enumValues.ptr[i].value), value))
if (d_isEqual(static_cast<double>(enumValues.values[i].value), value))
{
d_strncpy(display, enumValues.ptr[i].label, size);
d_strncpy(display, enumValues.values[i].label, size);
return true;
}
}
@@ -1203,9 +1203,9 @@ public:

for (uint32_t i=0; i < enumValues.count; ++i)
{
if (std::strcmp(display, enumValues.ptr[i].label) == 0)
if (std::strcmp(display, enumValues.values[i].label) == 0)
{
*value = enumValues.ptr[i].value;
*value = enumValues.values[i].value;
return true;
}
}


+ 6
- 14
distrho/src/DistrhoPluginInternal.hpp View File

@@ -704,18 +704,11 @@ public:
return fData->parameters[index].description;
}

const ParameterEnumerationDetails& getParameterEnumDetails(const uint32_t index) const noexcept
{
DISTRHO_SAFE_ASSERT_RETURN(fData != nullptr && index < fData->parameterCount, sFallbackEnumDetails);

return fData->parameters[index].enumValues;
}

const ParameterEnumerationValues& getParameterEnumValues(const uint32_t index) const noexcept
{
DISTRHO_SAFE_ASSERT_RETURN(fData != nullptr && index < fData->parameterCount, sFallbackEnumValues);

return fData->parameters[index].enumValues.values;
return fData->parameters[index].enumValues;
}

const ParameterRanges& getParameterRanges(const uint32_t index) const noexcept
@@ -1052,12 +1045,11 @@ private:
// -------------------------------------------------------------------
// Static fallback data, see DistrhoPlugin.cpp

static const String sFallbackString;
static /* */ AudioPortWithBusId sFallbackAudioPort;
static const ParameterRanges sFallbackRanges;
static const ParameterEnumerationDetails sFallbackEnumDetails;
static const ParameterEnumerationValues sFallbackEnumValues;
static const PortGroupWithId sFallbackPortGroup;
static const String sFallbackString;
static /* */ AudioPortWithBusId sFallbackAudioPort;
static const ParameterRanges sFallbackRanges;
static const ParameterEnumerationValues sFallbackEnumValues;
static const PortGroupWithId sFallbackPortGroup;

DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginExporter)
};


+ 6
- 6
distrho/src/DistrhoPluginLV2export.cpp View File

@@ -820,16 +820,16 @@ void lv2_generate_ttl(const char* const basename)
}

// enumeration
const ParameterEnumerationDetails& enumDetails(plugin.getParameterEnumDetails(i));
const ParameterEnumerationValues& enumValues(plugin.getParameterEnumValues(i));

if (enumDetails.count > 0)
if (enumValues.count > 0)
{
if (enumDetails.count >= 2 && enumDetails.restrictedMode)
if (enumValues.count >= 2 && enumValues.restrictedMode)
pluginString += " lv2:portProperty lv2:enumeration ;\n";

for (uint8_t j=0; j < enumDetails.count; ++j)
for (uint8_t j=0; j < enumValues.count; ++j)
{
const ParameterEnumerationValue& enumValue(enumDetails.values[j]);
const ParameterEnumerationValue& enumValue(enumValues.values[j]);

if (j == 0)
pluginString += " lv2:scalePoint [\n";
@@ -851,7 +851,7 @@ void lv2_generate_ttl(const char* const basename)
pluginString += " rdf:value " + String(enumValue.value) + " ;\n";
}

if (j+1 == enumDetails.count)
if (j+1 == enumValues.count)
pluginString += " ] ;\n";
else
pluginString += " ] ,\n";


+ 2
- 2
distrho/src/DistrhoPluginVST2.cpp View File

@@ -527,10 +527,10 @@ public:

for (uint8_t i = 0; i < enumValues.count; ++i)
{
if (d_isNotEqual(value, enumValues.ptr[i].value))
if (d_isNotEqual(value, enumValues.values[i].value))
continue;

strncpy((char*)ptr, enumValues.ptr[i].label.buffer(), 24);
strncpy((char*)ptr, enumValues.values[i].label.buffer(), 24);
return 1;
}



+ 7
- 7
distrho/src/DistrhoPluginVST3.cpp View File

@@ -1711,7 +1711,7 @@ public:
// set up flags
int32_t flags = 0;

const ParameterEnumerationDetails& enumDetails(fPlugin.getParameterEnumDetails(index));
const ParameterEnumerationValues& enumValues(fPlugin.getParameterEnumValues(index));
const ParameterRanges& ranges(fPlugin.getParameterRanges(index));
const uint32_t hints = fPlugin.getParameterHints(index);

@@ -1737,10 +1737,10 @@ public:
else if (hints & kParameterIsInteger)
step_count = ranges.max - ranges.min;

if (enumDetails.count >= 2 && enumDetails.restrictedMode)
if (enumValues.count >= 2 && enumValues.restrictedMode)
{
flags |= V3_PARAM_IS_LIST;
step_count = enumDetails.count - 1;
step_count = enumValues.count - 1;
}

info->flags = flags;
@@ -1810,9 +1810,9 @@ public:

for (uint32_t i=0; i < enumValues.count; ++i)
{
if (d_isEqual(enumValues.ptr[i].value, value))
if (d_isEqual(enumValues.values[i].value, value))
{
strncpy_utf16(output, enumValues.ptr[i].label, 128);
strncpy_utf16(output, enumValues.values[i].label, 128);
return V3_OK;
}
}
@@ -1874,9 +1874,9 @@ public:

for (uint32_t i=0; i < enumValues.count; ++i)
{
if (strcmp_utf16(input, enumValues.ptr[i].label))
if (strcmp_utf16(input, enumValues.values[i].label))
{
*output = ranges.getNormalizedValue(enumValues.ptr[i].value);
*output = ranges.getNormalizedValue(enumValues.values[i].value);
return V3_OK;
}
}


Write Preview
Loading…
Cancel
Save