/*
An LV2 plugin to generate a random wave of varying frequency and smoothness.
Copyright 2011 David Robillard
Copyright 2002 Mike Rawes
This is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This software is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this software. If not, see .
*/
#include
#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
#include
#include "math_func.h"
#include "common.h"
#define RANDOM_FREQUENCY 0
#define RANDOM_SMOOTH 1
#define RANDOM_OUTPUT 2
typedef struct {
float* frequency;
float* smooth;
float* output;
float nyquist;
float inv_nyquist;
float phase;
float value1;
float value2;
} Random;
float inv_rand_max;
static void
cleanup(LV2_Handle instance)
{
free(instance);
}
static void
connect_port(LV2_Handle instance,
uint32_t port,
void* data)
{
Random* plugin = (Random*)instance;
switch (port) {
case RANDOM_FREQUENCY:
plugin->frequency = data;
break;
case RANDOM_SMOOTH:
plugin->smooth = data;
break;
case RANDOM_OUTPUT:
plugin->output = data;
break;
}
}
static LV2_Handle
instantiate(const LV2_Descriptor* descriptor,
double sample_rate,
const char* bundle_path,
const LV2_Feature* const* features)
{
Random* plugin = (Random*)malloc(sizeof(Random));
srand((int)time((time_t*)0));
inv_rand_max = 2.0f / (float)RAND_MAX;
plugin->nyquist = (float)sample_rate / 2.0f;
plugin->inv_nyquist = 1.0f / plugin->nyquist;
plugin->value1 = rand() * inv_rand_max - 1.0f;
plugin->value2 = rand() * inv_rand_max - 1.0f;
return (LV2_Handle)plugin;
}
static void
activate(LV2_Handle instance)
{
Random* plugin = (Random*)instance;
plugin->phase = 0.0f;
}
static void
runRandom_fasa_oa(LV2_Handle instance,
uint32_t sample_count)
{
Random* plugin = (Random*)instance;
/* Frequency (Hz) (array of floats of length sample_count) */
float* frequency = plugin->frequency;
/* Wave smoothness (array of floats of length sample_count) */
float* smooth = plugin->smooth;
/* Output (array of floats of length sample_count) */
float* output = plugin->output;
/* Instance data */
float nyquist = plugin->nyquist;
float inv_nyquist = plugin->inv_nyquist;
float phase = plugin->phase;
float value1 = plugin->value1;
float value2 = plugin->value2;
float freq;
float smth;
float interval;
float result;
for (uint32_t s = 0; s < sample_count; ++s) {
freq = f_clip(frequency[s], 0.0f, nyquist);
smth = f_clip(smooth[s], 0.0f, 1.0f);
interval = (1.0f - smth) * 0.5f;
if (phase < interval) {
result = 1.0f;
} else if (phase > (1.0f - interval)) {
result = -1.0f;
} else if (interval > 0.0f) {
result = COSF((phase - interval) / smth * M_PI);
} else {
result = COSF(phase * M_PI);
}
result *= (value2 - value1) * 0.5f;
result -= (value2 + value1) * 0.5f;
output[s] = result;
phase += freq * inv_nyquist;
if (phase > 1.0f) {
phase -= 1.0f;
value1 = value2;
value2 = (float)rand() * inv_rand_max - 1.0f;
}
}
plugin->phase = phase;
plugin->value1 = value1;
plugin->value2 = value2;
}
static void
runRandom_fasc_oa(LV2_Handle instance,
uint32_t sample_count)
{
Random* plugin = (Random*)instance;
/* Frequency (Hz) (array of floats of length sample_count) */
float* frequency = plugin->frequency;
/* Wave smoothness (float value) */
float smooth = f_clip(*(plugin->smooth), 0.0f, 1.0f);
/* Output (array of floats of length sample_count) */
float* output = plugin->output;
/* Instance data */
float nyquist = plugin->nyquist;
float inv_nyquist = plugin->inv_nyquist;
float phase = plugin->phase;
float value1 = plugin->value1;
float value2 = plugin->value2;
float freq;
float interval = (1.0f - smooth) * 0.5f;
float result;
for (uint32_t s = 0; s < sample_count; ++s) {
freq = f_clip(frequency[s], 0.0f, nyquist);
if (phase < interval) {
result = 1.0f;
} else if (phase > (1.0f - interval)) {
result = -1.0f;
} else if (interval > 0.0f) {
result = COSF((phase - interval) / smooth * M_PI);
} else {
result = COSF(phase * M_PI);
}
result *= (value2 - value1) * 0.5f;
result -= (value2 + value1) * 0.5f;
output[s] = result;
phase += freq * inv_nyquist;
if (phase > 1.0f) {
phase -= 1.0f;
value1 = value2;
value2 = (float)rand() * inv_rand_max - 1.0f;
}
}
plugin->phase = phase;
plugin->value1 = value1;
plugin->value2 = value2;
}
static void
runRandom_fcsa_oa(LV2_Handle instance,
uint32_t sample_count)
{
Random* plugin = (Random*)instance;
/* Frequency (Hz) (float value) */
float frequency = *(plugin->frequency);
/* Wave smoothness (array of floats of length sample_count) */
float* smooth = plugin->smooth;
/* Output (pointer to float value) */
float* output = plugin->output;
/* Instance data */
float nyquist = plugin->nyquist;
float inv_nyquist = plugin->inv_nyquist;
float phase = plugin->phase;
float value1 = plugin->value1;
float value2 = plugin->value2;
float phase_scale = f_clip(frequency, 0.0f, nyquist) * inv_nyquist;
float smth;
float interval;
float result;
for (uint32_t s = 0; s < sample_count; ++s) {
smth = f_clip(smooth[s], 0.0f, 1.0f);
interval = (1.0f - smth) * 0.5f;
if (phase < interval) {
result = 1.0f;
} else if (phase > (1.0f - interval)) {
result = -1.0f;
} else if (interval > 0.0f) {
result = COSF((phase - interval) / smth * M_PI);
} else {
result = COSF(phase * M_PI);
}
result *= (value2 - value1) * 0.5f;
result -= (value2 + value1) * 0.5f;
output[s] = result;
phase += phase_scale;
if (phase > 1.0f) {
phase -= 1.0f;
value1 = value2;
value2 = (float)rand() * inv_rand_max - 1.0f;
}
}
plugin->phase = phase;
plugin->value1 = value1;
plugin->value2 = value2;
}
static void
runRandom_fcsc_oa(LV2_Handle instance,
uint32_t sample_count)
{
Random* plugin = (Random*)instance;
/* Frequency (Hz) (float value) */
float frequency = *(plugin->frequency);
/* Wave smoothness (float value) */
float smooth = f_clip(*(plugin->smooth), 0.0f, 1.0f);
/* Output (array of floats of length sample_count) */
float* output = plugin->output;
/* Instance data */
float nyquist = plugin->nyquist;
float inv_nyquist = plugin->inv_nyquist;
float phase = plugin->phase;
float value1 = plugin->value1;
float value2 = plugin->value2;
float phase_scale = f_clip(frequency, 0.0f, nyquist) * inv_nyquist;
float interval = (1.0f - smooth) * 0.5f;
float result;
for (uint32_t s = 0; s < sample_count; ++s) {
if (phase < interval) {
result = 1.0f;
} else if (phase > (1.0f - interval)) {
result = -1.0f;
} else if (interval > 0.0f) {
result = COSF((phase - interval) / smooth * M_PI);
} else {
result = COSF(phase * M_PI);
}
result *= (value2 - value1) * 0.5f;
result -= (value2 + value1) * 0.5f;
output[s] = result;
phase += phase_scale;
if (phase > 1.0f) {
phase -= 1.0f;
value1 = value2;
value2 = (float)rand() * inv_rand_max - 1.0f;
}
}
plugin->phase = phase;
plugin->value1 = value1;
plugin->value2 = value2;
}
static const LV2_Descriptor descriptor = {
"http://drobilla.net/plugins/blip/random",
instantiate,
connect_port,
activate,
runRandom_fcsc_oa,
NULL,
cleanup,
NULL,
};
LV2_SYMBOL_EXPORT const LV2_Descriptor*
lv2_descriptor(uint32_t index)
{
switch (index) {
case 0: return &descriptor;
default: return NULL;
}
}