brian/Cardinal
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Send audio input and time values to mini GUI

Browse source 
Signed-off-by: falkTX <falktx@falktx.com>
This commit is contained in:
falkTX 2022-12-31 11:57:39 +00:00
parent 73711f77a6
commit 919e21703b
No known key found for this signature in database
GPG key ID: CDBAA37ABC74FBA0
7 changed files with 587 additions and 287 deletions
Download patch file Download diff file Expand all files Collapse all files

16
plugins/Cardinal/src/HostParameters-Map.cpp
View file

@ -63,8 +63,8 @@ struct HostParametersMap : TerminalModule {
uint8_t learningId = UINT8_MAX; uint8_t learningId = UINT8_MAX;
CardinalPluginContext* const pcontext; CardinalPluginContext* const pcontext;
bool parametersChanged[kModuleParameters] = {}; bool parametersChanged[kModuleParameterCount] = {};
float parameterValues[kModuleParameters]; float parameterValues[kModuleParameterCount];
bool bypassed = false; bool bypassed = false;
bool firstRun = true; bool firstRun = true;
uint32_t lastProcessCounter = 0; uint32_t lastProcessCounter = 0;
@ -135,7 +135,7 @@ struct HostParametersMap : TerminalModule {
if (isBypassed()) if (isBypassed())
return; return;
for (uint32_t i = 0; i < kModuleParameters; ++i) for (uint32_t i = 0; i < kModuleParameterCount; ++i)
{ {
if (d_isEqual(pcontext->parameters[i], parameterValues[i])) if (d_isEqual(pcontext->parameters[i], parameterValues[i]))
continue; continue;
@ -161,7 +161,7 @@ struct HostParametersMap : TerminalModule {
// Validate hostParamId // Validate hostParamId
const uint8_t hostParamId = mappings[id].hostParamId; const uint8_t hostParamId = mappings[id].hostParamId;
if (hostParamId >= kModuleParameters) if (hostParamId >= kModuleParameterCount)
continue; continue;
// Set filter from param value if filter is uninitialized // Set filter from param value if filter is uninitialized
@ -350,7 +350,7 @@ struct ParameterIndexQuantity : Quantity {
return 0; return 0;
} }
float getMaxValue() override { float getMaxValue() override {
return kModuleParameters - 1; return kModuleParameterCount - 1;
} }
float getDefaultValue() override { float getDefaultValue() override {
return 0; return 0;
@ -360,7 +360,7 @@ struct ParameterIndexQuantity : Quantity {
} }
void setValue(float value) override { void setValue(float value) override {
v = math::clamp(value, getMinValue(), getMaxValue()); v = math::clamp(value, getMinValue(), getMaxValue());
mapping.hostParamId = math::clamp(static_cast<int>(v + 0.5f), 0, kModuleParameters - 1); mapping.hostParamId = math::clamp(static_cast<int>(v + 0.5f), 0, kModuleParameterCount - 1);
} }
float getDisplayValue() override { float getDisplayValue() override {
return mapping.hostParamId + 1; return mapping.hostParamId + 1;
@ -437,7 +437,7 @@ struct HostParametersMapChoice : CardinalLedDisplayChoice {
if (ParamWidget* const touchedParam = APP->scene->rack->touchedParam) if (ParamWidget* const touchedParam = APP->scene->rack->touchedParam)
{ {
APP->scene->rack->touchedParam = nullptr; APP->scene->rack->touchedParam = nullptr;
DISTRHO_SAFE_ASSERT_RETURN(mapping.hostParamId < kModuleParameters,); DISTRHO_SAFE_ASSERT_RETURN(mapping.hostParamId < kModuleParameterCount,);
const int64_t moduleId = touchedParam->module->id; const int64_t moduleId = touchedParam->module->id;
const int paramId = touchedParam->paramId; const int paramId = touchedParam->paramId;
@ -453,7 +453,7 @@ struct HostParametersMapChoice : CardinalLedDisplayChoice {
text.clear(); text.clear();
// mapped // mapped
if (module->mappings[id].hostParamId < kModuleParameters) if (module->mappings[id].hostParamId < kModuleParameterCount)
text += string::f("P%02d: ", module->mappings[id].hostParamId + 1); text += string::f("P%02d: ", module->mappings[id].hostParamId + 1);
if (module->mappings[id].paramHandle.moduleId >= 0) if (module->mappings[id].paramHandle.moduleId >= 0)
text += getParamName(); text += getParamName();

12
plugins/Cardinal/src/HostParameters.cpp
View file

@ -28,15 +28,15 @@ struct HostParameters : TerminalModule {
NUM_INPUTS NUM_INPUTS
}; };
enum OutputIds { enum OutputIds {
NUM_OUTPUTS = 24 NUM_OUTPUTS = kModuleParameterCount
}; };
enum LightIds { enum LightIds {
NUM_LIGHTS NUM_LIGHTS
}; };
CardinalPluginContext* const pcontext; CardinalPluginContext* const pcontext;
rack::dsp::SlewLimiter parameters[kModuleParameters]; rack::dsp::SlewLimiter parameters[kModuleParameterCount];
bool parametersConnected[kModuleParameters] = {}; bool parametersConnected[kModuleParameterCount] = {};
bool bypassed = false; bool bypassed = false;
bool smooth = true; bool smooth = true;
uint32_t lastProcessCounter = 0; uint32_t lastProcessCounter = 0;
@ -59,7 +59,7 @@ struct HostParameters : TerminalModule {
bypassed = isBypassed(); bypassed = isBypassed();
lastProcessCounter = processCounter; lastProcessCounter = processCounter;
for (uint32_t i=0; i<kModuleParameters; ++i) for (uint32_t i=0; i<kModuleParameterCount; ++i)
{ {
const bool connected = outputs[i].isConnected(); const bool connected = outputs[i].isConnected();
@ -74,7 +74,7 @@ struct HostParameters : TerminalModule {
if (bypassed) if (bypassed)
return; return;
for (uint32_t i=0; i<kModuleParameters; ++i) for (uint32_t i=0; i<kModuleParameterCount; ++i)
{ {
if (parametersConnected[i]) if (parametersConnected[i])
outputs[i].setVoltage(smooth ? parameters[i].process(args.sampleTime, pcontext->parameters[i]) outputs[i].setVoltage(smooth ? parameters[i].process(args.sampleTime, pcontext->parameters[i])
@ -89,7 +89,7 @@ struct HostParameters : TerminalModule {
{ {
const double fall = 1.0 / (double(pcontext->bufferSize) / e.sampleRate); const double fall = 1.0 / (double(pcontext->bufferSize) / e.sampleRate);
for (uint32_t i=0; i<kModuleParameters; ++i) for (uint32_t i=0; i<kModuleParameterCount; ++i)
{ {
parameters[i].reset(); parameters[i].reset();
parameters[i].setRiseFall(fall, fall); parameters[i].setRiseFall(fall, fall);

4
plugins/Cardinal/src/plugincontext.hpp
View file

@ -33,7 +33,7 @@ END_NAMESPACE_DGL
START_NAMESPACE_DISTRHO START_NAMESPACE_DISTRHO
static constexpr const uint32_t kModuleParameters = 24; static constexpr const uint32_t kModuleParameterCount = 24;
enum CardinalVariant { enum CardinalVariant {
kCardinalVariantMain, kCardinalVariantMain,
@ -57,7 +57,7 @@ struct MidiEvent {
struct CardinalPluginContext : rack::Context { struct CardinalPluginContext : rack::Context {
uint32_t bufferSize, processCounter; uint32_t bufferSize, processCounter;
double sampleRate; double sampleRate;
float parameters[kModuleParameters]; float parameters[kModuleParameterCount];
CardinalVariant variant; CardinalVariant variant;
bool bypassed, playing, reset, bbtValid; bool bypassed, playing, reset, bbtValid;
int32_t bar, beat, beatsPerBar, beatType; int32_t bar, beat, beatsPerBar, beatType;

4
src/CardinalMini/DistrhoPluginInfo.h
View file

@ -42,8 +42,8 @@
#define DISTRHO_UI_DEFAULT_WIDTH 1000 #define DISTRHO_UI_DEFAULT_WIDTH 1000
#define DISTRHO_UI_DEFAULT_HEIGHT 600 #define DISTRHO_UI_DEFAULT_HEIGHT 600
#define DISTRHO_PLUGIN_IS_SYNTH 0 #define DISTRHO_PLUGIN_IS_SYNTH 0
#define DISTRHO_PLUGIN_NUM_INPUTS CARDINAL_NUM_AUDIO_INPUTS #define DISTRHO_PLUGIN_NUM_INPUTS CARDINAL_NUM_AUDIO_INPUTS + 5
#define DISTRHO_PLUGIN_NUM_OUTPUTS CARDINAL_NUM_AUDIO_OUTPUTS #define DISTRHO_PLUGIN_NUM_OUTPUTS CARDINAL_NUM_AUDIO_OUTPUTS + 5
#define DISTRHO_PLUGIN_WANT_MIDI_INPUT 1 #define DISTRHO_PLUGIN_WANT_MIDI_INPUT 1
#define DISTRHO_PLUGIN_WANT_MIDI_OUTPUT 1 #define DISTRHO_PLUGIN_WANT_MIDI_OUTPUT 1
#define DISTRHO_PLUGIN_WANT_FULL_STATE 1 #define DISTRHO_PLUGIN_WANT_FULL_STATE 1

252
src/CardinalPlugin.cpp
View file

@ -38,6 +38,7 @@
# include "extra/Thread.hpp" # include "extra/Thread.hpp"
#endif #endif
#include <cfloat>
#include <list> #include <list>
#include "CardinalCommon.hpp" #include "CardinalCommon.hpp"
@ -54,25 +55,8 @@
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS) #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
# include "extra/ScopedValueSetter.hpp" # include "extra/ScopedValueSetter.hpp"
# include "WindowParameters.hpp"
#else
# define kWindowParameterCount 0
#endif #endif
enum CardinalStates {
kCardinalStatePatch,
kCardinalStateScreenshot,
kCardinalStateComment,
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
kCardinalStateModuleInfos,
kCardinalStateWindowSize,
#endif
#if CARDINAL_VARIANT_MINI
kCardinalStateParamChange,
#endif
kCardinalStateCount
};
extern const std::string CARDINAL_VERSION; extern const std::string CARDINAL_VERSION;
namespace rack { namespace rack {
@ -194,10 +178,13 @@ class CardinalPlugin : public CardinalBasePlugin
// real values, not VCV interpreted ones // real values, not VCV interpreted ones
float fWindowParameters[kWindowParameterCount]; float fWindowParameters[kWindowParameterCount];
#endif #endif
#if CARDINAL_VARIANT_MINI
float fMiniReportValues[kCardinalParameterCountAtMini - kCardinalParameterStartMini];
#endif
public: public:
CardinalPlugin() CardinalPlugin()
: CardinalBasePlugin(kModuleParameters + kWindowParameterCount + 1, 0, kCardinalStateCount), : CardinalBasePlugin(kCardinalParameterCount, 0, kCardinalStateCount),
#ifdef DISTRHO_OS_WASM #ifdef DISTRHO_OS_WASM
fInitializer(new Initializer(this, static_cast<const CardinalBaseUI*>(nullptr))), fInitializer(new Initializer(this, static_cast<const CardinalBaseUI*>(nullptr))),
#else #else
@ -225,6 +212,14 @@ public:
fWindowParameters[kWindowParameterInvertZoom] = 0.0f; fWindowParameters[kWindowParameterInvertZoom] = 0.0f;
fWindowParameters[kWindowParameterSqueezeModulePositions] = 1.0f; fWindowParameters[kWindowParameterSqueezeModulePositions] = 1.0f;
#endif #endif
#if CARDINAL_VARIANT_MINI
std::memset(fMiniReportValues, 0, sizeof(fMiniReportValues));
fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = 1;
fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = 1;
fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = 4;
fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = 4;
fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = 120;
#endif
// create unique temporary path for this instance // create unique temporary path for this instance
try { try {
@ -384,17 +379,23 @@ protected:
void initAudioPort(const bool input, uint32_t index, AudioPort& port) override void initAudioPort(const bool input, uint32_t index, AudioPort& port) override
{ {
#if CARDINAL_VARIANT_MAIN #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI
if (index < 8) static_assert(CARDINAL_NUM_AUDIO_INPUTS == CARDINAL_NUM_AUDIO_OUTPUTS, "inputs == outputs");
if (index < CARDINAL_NUM_AUDIO_INPUTS)
{ {
#if CARDINAL_VARIANT_MINI
port.groupId = kPortGroupStereo;
#else
port.groupId = index / 2; port.groupId = index / 2;
#endif
} }
else else
{ {
port.hints = kAudioPortIsCV | kCVPortHasPositiveUnipolarRange | kCVPortHasScaledRange | kCVPortIsOptional; port.hints = kAudioPortIsCV | kCVPortHasPositiveUnipolarRange | kCVPortHasScaledRange | kCVPortIsOptional;
index -= 8; index -= CARDINAL_NUM_AUDIO_INPUTS;
} }
#elif CARDINAL_VARIANT_MINI || CARDINAL_VARIANT_NATIVE || CARDINAL_VARIANT_FX || CARDINAL_VARIANT_SYNTH #elif CARDINAL_VARIANT_NATIVE || CARDINAL_VARIANT_FX || CARDINAL_VARIANT_SYNTH
if (index < 2) if (index < 2)
port.groupId = kPortGroupStereo; port.groupId = kPortGroupStereo;
#endif #endif
@ -429,7 +430,7 @@ protected:
void initParameter(const uint32_t index, Parameter& parameter) override void initParameter(const uint32_t index, Parameter& parameter) override
{ {
if (index < kModuleParameters) if (index < kCardinalParameterCountAtModules)
{ {
parameter.name = "Parameter "; parameter.name = "Parameter ";
parameter.name += String(index + 1); parameter.name += String(index + 1);
@ -447,14 +448,16 @@ protected:
return; return;
} }
if (index == kModuleParameters) if (index == kCardinalParameterBypass)
{ {
parameter.initDesignation(kParameterDesignationBypass); parameter.initDesignation(kParameterDesignationBypass);
return; return;
} }
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS) #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
switch (index - kModuleParameters - 1) if (index < kCardinalParameterCountAtWindow)
{
switch (index - kCardinalParameterStartWindow)
{ {
case kWindowParameterShowTooltips: case kWindowParameterShowTooltips:
parameter.name = "Show tooltips"; parameter.name = "Show tooltips";
@ -624,6 +627,149 @@ protected:
parameter.ranges.max = 1.0f; parameter.ranges.max = 1.0f;
break; break;
} }
}
#endif
#if CARDINAL_VARIANT_MINI
switch (index)
{
case kCardinalParameterMiniAudioIn1:
parameter.name = "Report Audio Input 1";
parameter.symbol = "r_audio_in_1";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 0.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 1.0f;
break;
case kCardinalParameterMiniAudioIn2:
parameter.name = "Report Audio Input 2";
parameter.symbol = "r_audio_in_2";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 0.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 1.0f;
break;
case kCardinalParameterMiniCVIn1:
parameter.name = "Report CV Input 1";
parameter.symbol = "r_cv_in_1";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = -10.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 10.0f;
break;
case kCardinalParameterMiniCVIn2:
parameter.name = "Report CV Input 2";
parameter.symbol = "r_cv_in_2";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = -10.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 10.0f;
break;
case kCardinalParameterMiniCVIn3:
parameter.name = "Report CV Input 3";
parameter.symbol = "r_cv_in_3";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = -10.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 10.0f;
break;
case kCardinalParameterMiniCVIn4:
parameter.name = "Report CV Input 4";
parameter.symbol = "r_cv_in_4";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = -10.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 10.0f;
break;
case kCardinalParameterMiniCVIn5:
parameter.name = "Report CV Input 5";
parameter.symbol = "r_cv_in_5";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = -10.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 10.0f;
break;
case kCardinalParameterMiniTimeFlags:
parameter.name = "Report Time Flags";
parameter.symbol = "r_time_flags";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 0x0;
parameter.ranges.min = 0x0;
parameter.ranges.max = 0x7;
break;
case kCardinalParameterMiniTimeBar:
parameter.name = "Report Time Bar";
parameter.symbol = "r_time_bar";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 1.0f;
parameter.ranges.min = 1.0f;
parameter.ranges.max = FLT_MAX;
break;
case kCardinalParameterMiniTimeBeat:
parameter.name = "Report Time Beat";
parameter.symbol = "r_time_beat";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 1.0f;
parameter.ranges.min = 1.0f;
parameter.ranges.max = 128.0f;
break;
case kCardinalParameterMiniTimeBeatsPerBar:
parameter.name = "Report Time Beats Per Bar";
parameter.symbol = "r_time_beatsPerBar";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 4.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 128.0f;
break;
case kCardinalParameterMiniTimeBeatType:
parameter.name = "Report Time Beat Type";
parameter.symbol = "r_time_beatType";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 4.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 128.0f;
break;
case kCardinalParameterMiniTimeFrame:
parameter.name = "Report Time Frame";
parameter.symbol = "r_time_frame";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 0.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = FLT_MAX;
break;
case kCardinalParameterMiniTimeBarStartTick:
parameter.name = "Report Time BarStartTick";
parameter.symbol = "r_time_barStartTick";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 0.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = FLT_MAX;
break;
case kCardinalParameterMiniTimeBeatsPerMinute:
parameter.name = "Report Time Beats Per Minute";
parameter.symbol = "r_time_bpm";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 20.0f;
parameter.ranges.min = 120.0f;
parameter.ranges.max = 999.0f;
break;
case kCardinalParameterMiniTimeTick:
parameter.name = "Report Time Tick";
parameter.symbol = "r_time_tick";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 0.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 8192.0f;
break;
case kCardinalParameterMiniTimeTicksPerBeat:
parameter.name = "Report Time Ticks Per Beat";
parameter.symbol = "r_time_ticksPerBeat";
parameter.hints = kParameterIsAutomatable|kParameterIsOutput;
parameter.ranges.def = 0.0f;
parameter.ranges.min = 0.0f;
parameter.ranges.max = 8192.0f;
break;
}
#endif #endif
} }
@ -708,19 +854,21 @@ protected:
float getParameterValue(uint32_t index) const override float getParameterValue(uint32_t index) const override
{ {
// host mapped parameters // host mapped parameters
if (index < kModuleParameters) if (index < kCardinalParameterCountAtModules)
return context->parameters[index]; return context->parameters[index];
// bypass // bypass
if (index == kModuleParameters) if (index == kCardinalParameterBypass)
return context->bypassed ? 1.0f : 0.0f; return context->bypassed ? 1.0f : 0.0f;
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS) #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
// window related parameters if (index < kCardinalParameterCountAtWindow)
index -= kModuleParameters + 1; return fWindowParameters[index - kCardinalParameterStartWindow];
#endif
if (index < kWindowParameterCount) #if CARDINAL_VARIANT_MINI
return fWindowParameters[index]; if (index < kCardinalParameterCountAtMini)
return fMiniReportValues[index - kCardinalParameterStartMini];
#endif #endif
return 0.0f; return 0.0f;
@ -729,26 +877,23 @@ protected:
void setParameterValue(uint32_t index, float value) override void setParameterValue(uint32_t index, float value) override
{ {
// host mapped parameters // host mapped parameters
if (index < kModuleParameters) if (index < kCardinalParameterCountAtModules)
{ {
context->parameters[index] = value; context->parameters[index] = value;
return; return;
} }
// bypass // bypass
if (index == kModuleParameters) if (index == kCardinalParameterBypass)
{ {
context->bypassed = value > 0.5f; context->bypassed = value > 0.5f;
return; return;
} }
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS) #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
// window related parameters if (index < kCardinalParameterCountAtWindow)
index -= kModuleParameters + 1;
if (index < kWindowParameterCount)
{ {
fWindowParameters[index] = value; fWindowParameters[index - kCardinalParameterStartWindow] = value;
return; return;
} }
#endif #endif
@ -1044,10 +1189,28 @@ protected:
context->ticksPerClock = timePos.bbt.ticksPerBeat / timePos.bbt.beatType; context->ticksPerClock = timePos.bbt.ticksPerBeat / timePos.bbt.beatType;
context->ticksPerFrame = 1.0 / samplesPerTick; context->ticksPerFrame = 1.0 / samplesPerTick;
context->tickClock = std::fmod(timePos.bbt.tick, context->ticksPerClock); context->tickClock = std::fmod(timePos.bbt.tick, context->ticksPerClock);
#if CARDINAL_VARIANT_MINI
fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = timePos.bbt.bar;
fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = timePos.bbt.beat;
fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = timePos.bbt.beatsPerBar;
fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = timePos.bbt.beatType;
fMiniReportValues[kCardinalParameterMiniTimeBarStartTick - kCardinalParameterStartMini] = timePos.bbt.barStartTick;
fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = timePos.bbt.beatsPerMinute;
fMiniReportValues[kCardinalParameterMiniTimeTick - kCardinalParameterStartMini] = timePos.bbt.tick;
fMiniReportValues[kCardinalParameterMiniTimeTicksPerBeat - kCardinalParameterStartMini] = timePos.bbt.ticksPerBeat;
#endif
} }
context->reset = reset; context->reset = reset;
fNextExpectedFrame = timePos.playing ? timePos.frame + frames : 0; fNextExpectedFrame = timePos.playing ? timePos.frame + frames : 0;
#if CARDINAL_VARIANT_MINI
const int flags = (timePos.playing ? 0x1 : 0x0)
| (timePos.bbt.valid ? 0x2 : 0x0)
| (reset ? 0x4 : 0x0);
fMiniReportValues[kCardinalParameterMiniTimeFlags - kCardinalParameterStartMini] = flags;
fMiniReportValues[kCardinalParameterMiniTimeFrame - kCardinalParameterStartMini] = timePos.frame / getSampleRate();
#endif
} }
// separate buffers, use them // separate buffers, use them
@ -1062,8 +1225,8 @@ protected:
#if DISTRHO_PLUGIN_NUM_INPUTS != 0 #if DISTRHO_PLUGIN_NUM_INPUTS != 0
for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i) for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)
{ {
#if CARDINAL_VARIANT_MAIN #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI
// can be null on main variant // can be null on main and mini variants
if (inputs[i] != nullptr) if (inputs[i] != nullptr)
#endif #endif
std::memcpy(fAudioBufferCopy[i], inputs[i], sizeof(float)*frames); std::memcpy(fAudioBufferCopy[i], inputs[i], sizeof(float)*frames);
@ -1077,13 +1240,18 @@ protected:
for (int i=0; i<DISTRHO_PLUGIN_NUM_OUTPUTS; ++i) for (int i=0; i<DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)
{ {
#if CARDINAL_VARIANT_MAIN #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI
// can be null on main variant // can be null on main and mini variants
if (outputs[i] != nullptr) if (outputs[i] != nullptr)
#endif #endif
std::memset(outputs[i], 0, sizeof(float)*frames); std::memset(outputs[i], 0, sizeof(float)*frames);
} }
#if CARDINAL_VARIANT_MINI
for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)
fMiniReportValues[i] = context->dataIns[i][0];
#endif
if (bypassed) if (bypassed)
{ {
if (fWasBypassed != bypassed) if (fWasBypassed != bypassed)

66
src/CardinalUI.cpp
View file

@ -704,7 +704,7 @@ public:
return; return;
} }
setParameterValue(kModuleParameters + param + 1, value * mult); setParameterValue(kCardinalParameterStartWindow + param, value * mult);
} }
protected: protected:
@ -718,7 +718,7 @@ protected:
void parameterChanged(const uint32_t index, const float value) override void parameterChanged(const uint32_t index, const float value) override
{ {
// host mapped parameters // host mapped parameters
if (index < kModuleParameters) if (index < kCardinalParameterCountAtModules)
{ {
#if CARDINAL_VARIANT_MINI #if CARDINAL_VARIANT_MINI
context->parameters[index] = value; context->parameters[index] = value;
@ -727,7 +727,7 @@ protected:
} }
// bypass // bypass
if (index == kModuleParameters) if (index == kCardinalParameterBypass)
{ {
#if CARDINAL_VARIANT_MINI #if CARDINAL_VARIANT_MINI
context->bypassed = value > 0.5f; context->bypassed = value > 0.5f;
@ -735,7 +735,9 @@ protected:
return; return;
} }
switch (index - kModuleParameters - 1) if (index < kCardinalParameterCountAtWindow)
{
switch (index - kCardinalParameterStartWindow)
{ {
case kWindowParameterShowTooltips: case kWindowParameterShowTooltips:
windowParameters.tooltips = value > 0.5f; windowParameters.tooltips = value > 0.5f;
@ -818,6 +820,62 @@ protected:
} }
WindowParametersSetValues(context->window, windowParameters); WindowParametersSetValues(context->window, windowParameters);
return;
}
#if CARDINAL_VARIANT_MINI
if (index < kCardinalParameterCountAtMiniBuffers)
{
float* const buffer = *const_cast<float**>(&context->dataIns[index - kCardinalParameterStartMiniBuffers]);
buffer[0] = value;
return;
}
switch (index)
{
case kCardinalParameterMiniTimeFlags: {
const int32_t flags = static_cast<int32_t>(value + 0.5f);
context->playing = flags & 0x1;
context->bbtValid = flags & 0x2;
context->reset = flags & 0x4;
return;
}
case kCardinalParameterMiniTimeBar:
context->bar = static_cast<int32_t>(value + 0.5f);
return;
case kCardinalParameterMiniTimeBeat:
context->beat = static_cast<int32_t>(value + 0.5f);
return;
case kCardinalParameterMiniTimeBeatsPerBar:
context->beatsPerBar = static_cast<int32_t>(value + 0.5f);
return;
case kCardinalParameterMiniTimeBeatType:
context->beatType = static_cast<int32_t>(value + 0.5f);
context->ticksPerClock = context->ticksPerBeat / context->beatType;
context->tickClock = std::fmod(context->tick, context->ticksPerClock);
return;
case kCardinalParameterMiniTimeFrame:
context->frame = static_cast<uint64_t>(value * context->sampleRate + 0.5f);
return;
case kCardinalParameterMiniTimeBarStartTick:
context->barStartTick = value;
return;
case kCardinalParameterMiniTimeBeatsPerMinute:
context->beatsPerMinute = value;
context->ticksPerFrame = 1.0 / (60.0 * context->sampleRate / context->beatsPerMinute / context->ticksPerBeat);
return;
case kCardinalParameterMiniTimeTick:
context->tick = value;
context->tickClock = std::fmod(context->tick, context->ticksPerClock);
return;
case kCardinalParameterMiniTimeTicksPerBeat:
context->ticksPerBeat = value;
context->ticksPerClock = context->ticksPerBeat / context->beatType;
context->ticksPerFrame = 1.0 / (60.0 * context->sampleRate / context->beatsPerMinute / context->ticksPerBeat);
context->tickClock = std::fmod(context->tick, context->ticksPerClock);
return;
}
#endif
} }
void stateChanged(const char* const key, const char* const value) override void stateChanged(const char* const key, const char* const value) override

78
src/PluginContext.hpp
View file

@ -28,6 +28,12 @@
#include "CardinalRemote.hpp" #include "CardinalRemote.hpp"
#include "DistrhoPlugin.hpp" #include "DistrhoPlugin.hpp"
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
# include "WindowParameters.hpp"
#else
# define kWindowParameterCount 0
#endif
#ifndef HEADLESS #ifndef HEADLESS
# include "DistrhoUI.hpp" # include "DistrhoUI.hpp"
#else #else
@ -43,7 +49,7 @@ START_NAMESPACE_DISTRHO
// ----------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------
static constexpr const uint kModuleParameters = 24; static constexpr const uint kModuleParameterCount = 24;
enum CardinalVariant { enum CardinalVariant {
kCardinalVariantMain, kCardinalVariantMain,
@ -53,6 +59,74 @@ enum CardinalVariant {
kCardinalVariantSynth, kCardinalVariantSynth,
}; };
enum CardinalParameters {
kCardinalParameterCountAtModules = kModuleParameterCount,
kCardinalParameterBypass = kCardinalParameterCountAtModules,
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
kCardinalParameterStartWindow,
kCardinalParameterCountAtWindow = kCardinalParameterStartWindow + kWindowParameterCount,
#if CARDINAL_VARIANT_MINI
kCardinalParameterStartMini = kCardinalParameterCountAtWindow,
kCardinalParameterStartMiniBuffers = kCardinalParameterStartMini,
kCardinalParameterMiniAudioIn1 = kCardinalParameterStartMiniBuffers,
kCardinalParameterMiniAudioIn2,
kCardinalParameterMiniCVIn1,
kCardinalParameterMiniCVIn2,
kCardinalParameterMiniCVIn3,
kCardinalParameterMiniCVIn4,
kCardinalParameterMiniCVIn5,
kCardinalParameterCountAtMiniBuffers,
kCardinalParameterStartMiniTime = kCardinalParameterCountAtMiniBuffers,
kCardinalParameterMiniTimeFlags = kCardinalParameterStartMiniTime,
kCardinalParameterMiniTimeBar,
kCardinalParameterMiniTimeBeat,
kCardinalParameterMiniTimeBeatsPerBar,
kCardinalParameterMiniTimeBeatType,
kCardinalParameterMiniTimeFrame,
kCardinalParameterMiniTimeBarStartTick,
kCardinalParameterMiniTimeBeatsPerMinute,
kCardinalParameterMiniTimeTick,
kCardinalParameterMiniTimeTicksPerBeat,
kCardinalParameterCountAtMiniTime,
kCardinalParameterCountAtMini = kCardinalParameterCountAtMiniTime,
kCardinalParameterCount = kCardinalParameterCountAtMini
#else
kCardinalParameterCount = kCardinalParameterCountAtWindow
#endif
#else
kCardinalParameterCount
#endif
};
enum CardinalStates {
kCardinalStatePatch,
kCardinalStateScreenshot,
kCardinalStateComment,
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
kCardinalStateModuleInfos,
kCardinalStateWindowSize,
#endif
#if CARDINAL_VARIANT_MINI
kCardinalStateParamChange,
#endif
kCardinalStateCount
};
static_assert(kCardinalParameterBypass == kModuleParameterCount, "valid parameter indexes");
#if CARDINAL_VARIANT_MINI || !defined(HEADLESS)
static_assert(kCardinalParameterStartWindow == kModuleParameterCount + 1, "valid parameter indexes");
static_assert(kCardinalParameterStartWindow == kCardinalParameterBypass + 1, "valid parameter indexes");
static_assert(kCardinalParameterCountAtWindow == kModuleParameterCount + kWindowParameterCount + 1, "valid parameter indexes");
#endif
#if CARDINAL_VARIANT_MINI
static_assert(0 == kCardinalParameterStartMini - kCardinalParameterMiniAudioIn1, "valid parameter indexes");
static_assert(kCardinalParameterStartMini == kCardinalParameterCountAtWindow, "valid parameter indexes");
static_assert(kCardinalParameterStartMini == kCardinalParameterBypass + kWindowParameterCount + 1, "valid parameter indexes");
static_assert(kCardinalParameterStartMini == kModuleParameterCount + kWindowParameterCount + 1, "valid parameter indexes");
static_assert(kCardinalParameterCountAtWindow == kModuleParameterCount + kWindowParameterCount + 1, "valid parameter indexes");
static_assert(DISTRHO_PLUGIN_NUM_INPUTS == kCardinalParameterCountAtMiniBuffers - kCardinalParameterStartMiniBuffers, "valid parameter indexes");
#endif
class UI; class UI;
// ----------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------
@ -60,7 +134,7 @@ class UI;
struct CardinalPluginContext : rack::Context { struct CardinalPluginContext : rack::Context {
uint32_t bufferSize, processCounter; uint32_t bufferSize, processCounter;
double sampleRate; double sampleRate;
float parameters[kModuleParameters]; float parameters[kModuleParameterCount];
CardinalVariant variant; CardinalVariant variant;
bool bypassed, playing, reset, bbtValid; bool bypassed, playing, reset, bbtValid;
int32_t bar, beat, beatsPerBar, beatType; int32_t bar, beat, beatsPerBar, beatType;