stelpa6's Recent Posts
Hiya! Was wondering if there's plans to add additional resonators to Kaivo down the line? (also curious how involved the implementation of new resonators is!). I love the existing ones, but feel like there's tons of potential for new ones too - realized this when I was trying to make a convincing wind sound, because I haven't yet been very successful yet sadly with the existing resonators..
In particular, I think wind instruments (brass+woodwind tubes, pvc pipe even?), wooden bars, and various membrane/drumheads would be valuable additions to the resonator palette. Maybe even a vocal cord resonator (or a general purpose reed).
As for Bodies, it feels like the sky is the limit - it'd be pretty fun to have a formant option for vowel sounds, haha, would work great with the 2d modulation :D
Feel free to post if you have any more ideas, also!
Hey, just wanted to do a quick update since I used another plugin that I thought had a pretty clever implementation of mpe smoothing - in it, each mpe parameter had a separate "smoothing" slider, EXCEPT for pressure which had a separate smoothing/sleep slider for going up or down, so you can get fast attacks and then gradually releases or other sorts of responses, as jumpy as youd like. The plugin is called plasmonic if you wanna check it out - just thought I'd mention this :)
I understand - thanks for the response 
UPDATE: I dug around in the Surge source code and found the relevant bits here, I hope this helps (sorry for the lack of indents, the forum doesn't seem to be preserving them but here's a pastebin: https://pastebin.com/yiYaNK1X )
class ControllerModulationSource : public ModulationSource
{
public:
// Smoothing and Shaping Behaviors
enum SmoothingMode
{
LEGACY = -1, // This is (1) the exponential backoff and (2) not streamed.
SLOW_EXP, // Legacy with a sigma clamp
FAST_EXP, // Faster Legacy with a sigma clamp
FAST_LINE, // Linearly move
DIRECT // Apply the value directly
} smoothingMode = LEGACY;
ControllerModulationSource()
{
target = 0.f;
output = 0.f;
bipolar = false;
changed = true;
smoothingMode = LEGACY;
}
ControllerModulationSource(SmoothingMode mode) : ControllerModulationSource()
{
smoothingMode = mode;
}
virtual ~ControllerModulationSource() {}
void set_target(float f)
{
target = f;
startingpoint = output;
changed = true;
}
void init(float f)
{
target = f;
output = f;
startingpoint = f;
changed = true;
}
void set_target01(float f, bool updatechanged = true)
{
if (bipolar)
target = 2.f * f - 1.f;
else
target = f;
startingpoint = output;
if (updatechanged)
changed = true;
}
virtual float get_output01(int i) override
{
if (bipolar)
return 0.5f + 0.5f * output;
return output;
}
virtual float get_target01()
{
if (bipolar)
return 0.5f + 0.5f * target;
return target;
}
virtual bool has_changed(bool reset)
{
if (changed)
{
if (reset)
changed = false;
return true;
}
return false;
}
virtual void reset() override
{
target = 0.f;
output = 0.f;
bipolar = false;
}
inline void processSmoothing(SmoothingMode mode, float sigma)
{
if (mode == LEGACY || mode == SLOW_EXP || mode == FAST_EXP)
{
float b = fabs(target - output);
if (b < sigma && mode != LEGACY)
{
output = target;
}
else
{
float a = (mode == FAST_EXP ? 0.99f : 0.9f) * 44100 * samplerate_inv * b;
output = (1 - a) * output + a * target;
}
return;
};
if (mode == FAST_LINE)
{
/*
* Apply a constant change until we get there.
* Rate is set so we cover the entire range (0,1)
* in 50 blocks at 44k
*/
float sampf = samplerate / 44100;
float da = (target - startingpoint) / (50 * sampf);
float b = target - output;
if (fabs(b) < fabs(da))
{
output = target;
}
else
{
output += da;
}
}
if (mode == DIRECT)
{
output = target;
}
}
virtual void process_block() override
{
processSmoothing(smoothingMode, smoothingMode == FAST_EXP ? 0.005f : 0.0025f);
}
virtual bool process_block_until_close(float sigma)
{
if (smoothingMode == LEGACY)
processSmoothing(SLOW_EXP, sigma);
else
processSmoothing(smoothingMode, sigma);
return (output != target); // continue
}
virtual bool is_bipolar() override { return bipolar; }
virtual void set_bipolar(bool b) override { bipolar = b; }
float target, startingpoint;
int id; // can be used to assign the controller to a parameter id
bool bipolar;
bool changed;
};
And then, elsewhere in the code, the smoothing selected is applied to these midi signals:
scene.modsources[ms_modwheel] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_breath] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_expression] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_sustain] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_aftertouch] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_pitchbend] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_lowest_key] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_highest_key] = new ControllerModulationSource(storage.smoothingMode);
scene.modsources[ms_latest_key] = new ControllerModulationSource(storage.smoothingMode);
Hey Randy, thanks so much for the response!
I like your thought process on the adaptive smoothing, but think that really a simple toggle in the settings between having incoming aftertouch/cc interpolation on/off would satisfy most users. For different smoothing methods inspiration, the opensource Surge vst has a setting for this with a few different interpolation modes which you could potentially easily port - though really a toggle-able simple linear interpolation would make a huge difference!
Personally, I dont think I'd ever want unsmoothed ccs unless I was trying to get a glitchy/steppy sound for some reason, in which case I wouldnt want any smoothing at all. Occams razor seems to apply :)
Hope you're doing well!
Hey, bumping this thread since this issue is still pretty apparent in Aalto and Kaivo. I think the simple solution would be to apply some smoothing to incoming midi CC/aftertouch messages. Currently, Aalto and Kaivo are almost perfect with MPE, but the zippering noise can be pretty distracting with some parameters.
Hey, after a lot of troubleshooting with Randy (thanks again for your responsiveness!), I've found the source of all the confusion regarding how Aalto/Kaivo microtune.
I'll spare the details and jump to the conclusion - as it currently is, Aalto/Kaivo aren't following the "official" standard of how to tune a .scl file in absence of a matching .kbm file. Essentially, the main "issue" is that Aalto/Kaivo are starting with "A4" as the "root note" of the scale, whereas the official standard is to start from "C4". They are also basing the tuning of the scale on making A4=440, when the "official default" method is to tune C4=261.625565 instead.
I've let Randy know about this, but in the meantime, you can easily adjust the behavior to match your other plugins by using a .kbm file with the same name as your .scl file - the important part of the .kbm file is here:
! Middle note where the first entry of the mapping is mapped to:
60
! Reference note for which frequency is given:
60
! Frequency to tune the above note to
261.625565
If you use the above in your matching .kbm file, these plugins should be "in tune".
I hope this helps anyone in the same boat I was :)
Hey, after a lot of troubleshooting with Randy (thanks again for your responsiveness!), I've found the source of all the confusion regarding how Aalto/Kaivo microtune.
I'll spare the details and jump to the conclusion - as it currently is, Aalto/Kaivo aren't following the "official" standard of how to tune a .scl file in absence of a matching .kbm file. Essentially, the main "issue" is that Aalto/Kaivo are starting with "A4" as the "root note" of the scale, whereas the official standard is to start from "C4". They are also basing the tuning of the scale on making A4=440, when the "official default" method is to tune C4=261.625565 instead.
I've let Randy know about this, but in the meantime, you can easily adjust the behavior to match your other plugins by using a .kbm file with the same name as your .scl file - the important part of the .kbm file is here:
! Middle note where the first entry of the mapping is mapped to:
60
! Reference note for which frequency is given:
60
! Frequency to tune the above note to
261.625565
If you use the above in your matching .kbm file, these plugins should be "in tune".
I hope this helps anyone in the same boat I was :)
Hey, new user of Aalto and Kaivo, and it doesn't seem like the issues were ever fixed - I have found blatant examples of Aalto and Kaivo not interpreting scala files correctly, especially when it comes to Just Intonation.
As an example, try the scala files found here https://sevish.com/music-resources/#tuning-files in the Eikosany folder - compare the results you get from loading, for example, the scale called "Dekany 3 5 7 9 11" to results from another microtonal VST (for example, Vital), and you'll find the results are completely different, and actually out of tune.
Considering I bought Aalto and Kaivo specifically for making microtonal music, this is a major disappointment, as it means I not only cannot trust them when used together with other microtonal VSTs, but I also cannot trust them to even interpret the tuning files correctly.
Really hoping this gets addressed :(
Bumping this thread to show that, in 2021, I'm still having the same issue, with loading Eikosany tunings from Sevish (compared to any other microtonal vst I have). Not only are they not keymapped correctly, but they don't actually seem to be in tune at all. Hoping this gets addressed :(