Sean Barrett
ago%!(EXTRA string=4 years)
parent
b42009b3b9
commit
559d759c2c
7 changed files with 659 additions and 39 deletions
@ -0,0 +1,634 @@ |
|||||||
|
// stb_hexwave - v0.5 - public domain, initial release 2021-04-01
|
||||||
|
//
|
||||||
|
// A flexible anti-aliased (bandlimited) digital audio oscillator.
|
||||||
|
//
|
||||||
|
// This library generates waveforms of a variety of shapes made of
|
||||||
|
// line segments. It does not do envelopes, LFO effects, etc.; it
|
||||||
|
// merely tries to solve the problem of generating an artifact-free
|
||||||
|
// morphable digital waveform with a variety of spectra, and leaves
|
||||||
|
// it to the user to rescale the waveform and mix multiple voices, etc.
|
||||||
|
//
|
||||||
|
// Compiling:
|
||||||
|
//
|
||||||
|
// In one C/CPP file that #includes this file, do
|
||||||
|
//
|
||||||
|
// #define STB_HEXWAVE_IMPLEMENTATION
|
||||||
|
// #include "stb_hexwave.h"
|
||||||
|
//
|
||||||
|
// Optionally, #define STB_HEXWAVE_STATIC before including
|
||||||
|
// the header to cause the definitions to be private to the
|
||||||
|
// implementation file (i.e. to be "static" instead of "extern").
|
||||||
|
//
|
||||||
|
// Notes:
|
||||||
|
//
|
||||||
|
// Optionally performs memory allocation during initialization,
|
||||||
|
// never allocates otherwise.
|
||||||
|
//
|
||||||
|
// Usage:
|
||||||
|
//
|
||||||
|
// Initialization:
|
||||||
|
//
|
||||||
|
// hexwave_init(32,16,NULL); // read "header section" for alternatives
|
||||||
|
//
|
||||||
|
// Create oscillator:
|
||||||
|
//
|
||||||
|
// HexWave *osc = malloc(sizeof(*osc)); // or "new HexWave", or declare globally or on stack
|
||||||
|
// hexwave_create(osc, reflect_flag, peak_time, half_height, zero_wait);
|
||||||
|
// see "Waveform shapes" below for the meaning of these parameters
|
||||||
|
//
|
||||||
|
// Generate audio:
|
||||||
|
//
|
||||||
|
// hexwave_generate_samples(output, number_of_samples, osc, oscillator_freq)
|
||||||
|
// where:
|
||||||
|
// output is a buffer where the library will store floating point audio samples
|
||||||
|
// number_of_samples is the number of audio samples to generate
|
||||||
|
// osc is a pointer to a Hexwave
|
||||||
|
// oscillator_freq is the frequency of the oscillator divided by the sample rate
|
||||||
|
//
|
||||||
|
// The output samples will continue from where the samples generated by the
|
||||||
|
// previous hexwave_generate_samples() on this oscillator ended.
|
||||||
|
//
|
||||||
|
// Change oscillator waveform:
|
||||||
|
//
|
||||||
|
// hexwave_change(osc, reflect_flag, peak_time, half_height, zero_wait);
|
||||||
|
// can call in between calls to hexwave_generate_samples
|
||||||
|
//
|
||||||
|
// Waveform shapes:
|
||||||
|
//
|
||||||
|
// All waveforms generated by hexwave are constructed from six line segments
|
||||||
|
// characterized by 3 parameters.
|
||||||
|
//
|
||||||
|
// See demonstration: https://www.youtube.com/watch?v=hsUCrAsDN-M
|
||||||
|
//
|
||||||
|
// reflect=0 reflect=1
|
||||||
|
//
|
||||||
|
// 0-----P---1 0-----P---1 peak_time = P
|
||||||
|
// . 1 . 1
|
||||||
|
// /\_ : /\_ :
|
||||||
|
// / \_ : / \_ :
|
||||||
|
// / \.H / \.H half_height = H
|
||||||
|
// / | : / | :
|
||||||
|
// _____/ |_:___ _____/ | : _____
|
||||||
|
// . : \ | . | : /
|
||||||
|
// . : \ | . | : /
|
||||||
|
// . : \ _/ . \_: /
|
||||||
|
// . : \ _/ . :_ /
|
||||||
|
// . -1 \/ . -1 \/
|
||||||
|
// 0 - Z - - - - 1 0 - Z - - - - 1 zero_wait = Z
|
||||||
|
//
|
||||||
|
// Classic waveforms:
|
||||||
|
// peak half zero
|
||||||
|
// reflect time height wait
|
||||||
|
// Sawtooth 1 0 0 0
|
||||||
|
// Square 1 0 1 0
|
||||||
|
// Triangle 1 0.5 0 0
|
||||||
|
//
|
||||||
|
// Some waveforms can be produced in multiple ways, which is useful when morphing
|
||||||
|
// into other waveforms, and there are a few more notable shapes:
|
||||||
|
//
|
||||||
|
// peak half zero
|
||||||
|
// reflect time height wait
|
||||||
|
// Sawtooth 1 1 any 0
|
||||||
|
// Sawtooth (8va) 1 0 -1 0
|
||||||
|
// Triangle 1 0.5 0 0
|
||||||
|
// Square 1 0 1 0
|
||||||
|
// Square 0 0 1 0
|
||||||
|
// Triangle 0 0.5 0 0
|
||||||
|
// Triangle 0 0 -1 0
|
||||||
|
// AlternatingSaw 0 0 0 0
|
||||||
|
// AlternatingSaw 0 1 any 0
|
||||||
|
// Stairs 0 0 1 0.5
|
||||||
|
//
|
||||||
|
// The "Sawtooth (8va)" waveform is identical to a sawtooth wave with 2x the
|
||||||
|
// frequency, but when morphed with other values, it becomes an overtone of
|
||||||
|
// the base frequency.
|
||||||
|
//
|
||||||
|
// Morphing waveforms:
|
||||||
|
//
|
||||||
|
// Sweeping peak_time morphs the waveform while producing various spectra.
|
||||||
|
// Sweeping half_height effectively crossfades between two waveforms; useful, but less exciting.
|
||||||
|
// Sweeping zero_wait produces a similar effect no matter the reset of the waveform,
|
||||||
|
// a sort of high-pass/PWM effect where the wave becomes silent at zero_wait=1.
|
||||||
|
//
|
||||||
|
// You can trivially morph between any two waveforms from the above table
|
||||||
|
// which only differ in one column.
|
||||||
|
//
|
||||||
|
// Crossfade between classic waveforms:
|
||||||
|
// peak half zero
|
||||||
|
// Start End reflect time height wait
|
||||||
|
// ----- --- ------- ---- ------ ----
|
||||||
|
// Triangle Square 0 0 -1..1 0
|
||||||
|
// Saw Square 1 0 0..1 0
|
||||||
|
// Triangle Saw 1 0.5 0..2 0
|
||||||
|
//
|
||||||
|
// The last morph uses uses half-height values larger than 1, which means it will
|
||||||
|
// be louder and the output should be scaled down by half to compensate, or better
|
||||||
|
// by dynamically tracking the morph: volume_scale = 1 - half_height/4
|
||||||
|
//
|
||||||
|
// Non-crossfade morph between classic waveforms, most require changing
|
||||||
|
// two parameters at the same time:
|
||||||
|
// peak half zero
|
||||||
|
// Start End reflect time height wait
|
||||||
|
// ----- --- ------- ---- ------ ----
|
||||||
|
// Square Triangle any 0..0.5 1..0 0
|
||||||
|
// Square Saw 1 0..1 1..any 0
|
||||||
|
// Triangle Saw 1 0.5..1 0..-1 0
|
||||||
|
//
|
||||||
|
// Other noteworthy morphs between simple shapes:
|
||||||
|
// peak half zero
|
||||||
|
// Start Halfway End reflect time height wait
|
||||||
|
// ----- --------- --- ------- ---- ------ ----
|
||||||
|
// Saw (8va,neg) Saw (pos) 1 0..1 -1 0
|
||||||
|
// Saw (neg) Saw (pos) 1 0..1 0 0
|
||||||
|
// Triangle AlternatingSaw 0 0..1 -1 0
|
||||||
|
// AlternatingSaw Triangle AlternatingSaw 0 0..1 0 0
|
||||||
|
// Square AlternatingSaw 0 0..1 1 0
|
||||||
|
// Triangle Triangle AlternatingSaw 0 0..1 -1..1 0
|
||||||
|
// Square AlternatingSaw 0 0..1 1..0 0
|
||||||
|
// Saw (8va) Triangle Saw 1 0..1 -1..1 0
|
||||||
|
// Saw (neg) Saw (pos) 1 0..1 0..1 0
|
||||||
|
// AlternatingSaw AlternatingSaw 0 0..1 0..any 0
|
||||||
|
//
|
||||||
|
// The last entry is noteworthy because the morph from the halfway point to either
|
||||||
|
// endpoint sounds very different. For example, an LFO sweeping back and forth over
|
||||||
|
// the whole range will morph between the middle timbre and the AlternatingSaw
|
||||||
|
// timbre in two different ways, alternating.
|
||||||
|
//
|
||||||
|
// Entries with "any" for half_height are whole families of morphs, as you can pick
|
||||||
|
// any value you want as the endpoint for half_height.
|
||||||
|
//
|
||||||
|
// You can always morph between any two waveforms with the same value of 'reflect'
|
||||||
|
// by just sweeping the parameters simultaneously. There will never be artifacts
|
||||||
|
// and the result will always be useful, if not necessarily what you want.
|
||||||
|
//
|
||||||
|
// You can vary the sound of two-parameter morphs by ramping them differently,
|
||||||
|
// e.g. if the morph goes from t=0..1, then square-to-triangle looks like:
|
||||||
|
// peak_time = lerp(t, 0, 0.5)
|
||||||
|
// half_height = lerp(t, 1, 0 )
|
||||||
|
// but you can also do things like:
|
||||||
|
// peak_time = lerp(smoothstep(t), 0, 0.5)
|
||||||
|
// half_height = cos(PI/2 * t)
|
||||||
|
//
|
||||||
|
// How it works:
|
||||||
|
//
|
||||||
|
// hexwave use BLEP to bandlimit discontinuities and BLAMP
|
||||||
|
// to bandlimit C1 discontinuities. This is not polyBLEP
|
||||||
|
// (polynomial BLEP), it is table-driven BLEP. It is
|
||||||
|
// also not minBLEP (minimum-phase BLEP), as that complicates
|
||||||
|
// things for little benefit once BLAMP is involved.
|
||||||
|
//
|
||||||
|
// The previous oscillator frequency is remembered, and when
|
||||||
|
// the frequency changes, a BLAMP is generated to remove the
|
||||||
|
// C1 discontinuity, which reduces artifacts for sweeps/LFO.
|
||||||
|
//
|
||||||
|
// Changes to an oscillator timbre using hexwave_change() actually
|
||||||
|
// wait until the oscillator finishes its current cycle. All
|
||||||
|
// waveforms with non-zero "zero_wait" settings pass through 0
|
||||||
|
// and have 0-slope at the start of a cycle, which means changing
|
||||||
|
// the settings is artifact free at that time. (If zero_wait is 0,
|
||||||
|
// the code still treats it as passing through 0 with 0-slope; it'll
|
||||||
|
// apply the necessary fixups to make it artifact free as if it does
|
||||||
|
// transition to 0 with 0-slope vs. the waveform at the end of
|
||||||
|
// the cycle, then adds the fixups for a non-0 and non-0 slope
|
||||||
|
// at the start of the cycle, which cancels out if zero_wait is 0,
|
||||||
|
// and still does the right thing if zero_wait is 0 when the
|
||||||
|
// settings are updated.)
|
||||||
|
//
|
||||||
|
// BLEP/BLAMP normally requires overlapping buffers, but this
|
||||||
|
// is hidden from the user by generating the waveform to a
|
||||||
|
// temporary buffer and saving the overlap regions internally
|
||||||
|
// between calls. (It is slightly more complicated; see code.)
|
||||||
|
//
|
||||||
|
// By design all shapes have 0 DC offset; this is one reason
|
||||||
|
// hexwave uses zero_wait instead of standard PWM.
|
||||||
|
//
|
||||||
|
// The internals of hexwave could support any arbitrary shape
|
||||||
|
// made of line segments, but I chose not to expose this
|
||||||
|
// generality in favor of a simple, easy-to-use API.
|
||||||
|
|
||||||
|
#ifndef STB_INCLUDE_STB_HEXWAVE_H |
||||||
|
#define STB_INCLUDE_STB_HEXWAVE_H |
||||||
|
|
||||||
|
#ifndef STB_HEXWAVE_MAX_BLEP_LENGTH |
||||||
|
#define STB_HEXWAVE_MAX_BLEP_LENGTH 64 // good enough for anybody
|
||||||
|
#endif |
||||||
|
|
||||||
|
#ifdef STB_HEXWAVE_STATIC |
||||||
|
#define STB_HEXWAVE_DEF static |
||||||
|
#else |
||||||
|
#define STB_HEXWAVE_DEF extern |
||||||
|
#endif |
||||||
|
|
||||||
|
typedef struct HexWave HexWave; |
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer); |
||||||
|
// width: size of BLEP, from 4..64, larger is slower & more memory but less aliasing
|
||||||
|
// oversample: 2+, number of subsample positions, larger uses more memory but less noise
|
||||||
|
// user_buffer: optional, if provided the library will perform no allocations.
|
||||||
|
// 16*width*(oversample+1) bytes, must stay allocated as long as library is used
|
||||||
|
// technically it only needs: 8*( width * (oversample + 1))
|
||||||
|
// + 8*((width * oversample) + 1) bytes
|
||||||
|
//
|
||||||
|
// width can be larger than 64 if you define STB_HEXWAVE_MAX_BLEP_LENGTH to a larger value
|
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer); |
||||||
|
// user_buffer: pass in same parameter as passed to hexwave_init
|
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait); |
||||||
|
// see docs above for description
|
||||||
|
//
|
||||||
|
// reflect is tested as 0 or non-zero
|
||||||
|
// peak_time is clamped to 0..1
|
||||||
|
// half_height is not clamped
|
||||||
|
// zero_wait is clamped to 0..1
|
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait); |
||||||
|
// see docs
|
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq); |
||||||
|
// output: buffer where the library will store generated floating point audio samples
|
||||||
|
// number_of_samples: the number of audio samples to generate
|
||||||
|
// osc: pointer to a Hexwave initialized with 'hexwave_create'
|
||||||
|
// oscillator_freq: frequency of the oscillator divided by the sample rate
|
||||||
|
|
||||||
|
// private:
|
||||||
|
typedef struct |
||||||
|
{ |
||||||
|
int reflect; |
||||||
|
float peak_time; |
||||||
|
float zero_wait; |
||||||
|
float half_height; |
||||||
|
} HexWaveParameters; |
||||||
|
|
||||||
|
struct HexWave |
||||||
|
{ |
||||||
|
float t, prev_dt; |
||||||
|
HexWaveParameters current, pending; |
||||||
|
int have_pending; |
||||||
|
float buffer[STB_HEXWAVE_MAX_BLEP_LENGTH]; |
||||||
|
};
|
||||||
|
#endif |
||||||
|
|
||||||
|
#ifdef STB_HEXWAVE_IMPLEMENTATION |
||||||
|
|
||||||
|
#ifndef STB_HEXWAVE_NO_ALLOCATION |
||||||
|
#include <stdlib.h> // malloc,free |
||||||
|
#endif |
||||||
|
|
||||||
|
#include <string.h> // memset,memcpy,memmove |
||||||
|
#include <math.h> // sin,cos,fabs |
||||||
|
|
||||||
|
#define hexwave_clamp(v,a,b) ((v) < (a) ? (a) : (v) > (b) ? (b) : (v)) |
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait) |
||||||
|
{ |
||||||
|
hex->pending.reflect = reflect; |
||||||
|
hex->pending.peak_time = hexwave_clamp(peak_time,0,1); |
||||||
|
hex->pending.half_height = half_height; |
||||||
|
hex->pending.zero_wait = hexwave_clamp(zero_wait,0,1); |
||||||
|
// put a barrier here to allow changing from a different thread than the generator
|
||||||
|
hex->have_pending = 1; |
||||||
|
} |
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait) |
||||||
|
{ |
||||||
|
memset(hex, 0, sizeof(*hex)); |
||||||
|
hexwave_change(hex, reflect, peak_time, half_height, zero_wait); |
||||||
|
hex->current = hex->pending; |
||||||
|
hex->have_pending = 0; |
||||||
|
hex->t = 0; |
||||||
|
hex->prev_dt = 0; |
||||||
|
} |
||||||
|
|
||||||
|
static struct |
||||||
|
{ |
||||||
|
int width; // width of fixup in samples
|
||||||
|
int oversample; // number of oversampled versions (there's actually one more to allow lerpign)
|
||||||
|
float *blep; |
||||||
|
float *blamp; |
||||||
|
} hexblep; |
||||||
|
|
||||||
|
static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data) |
||||||
|
{ |
||||||
|
float *d1,*d2; |
||||||
|
float lerpweight; |
||||||
|
int i, bw = hexblep.width; |
||||||
|
|
||||||
|
int slot = (int) (time_since_transition * hexblep.oversample); |
||||||
|
if (slot >= hexblep.oversample) |
||||||
|
slot = hexblep.oversample-1; // clamp in case the floats overshoot
|
||||||
|
|
||||||
|
d1 = &data[ slot *bw]; |
||||||
|
d2 = &data[(slot+1)*bw]; |
||||||
|
|
||||||
|
lerpweight = time_since_transition * hexblep.oversample - slot; |
||||||
|
for (i=0; i < bw; ++i) |
||||||
|
output[i] += scale * (d1[i] + (d2[i]-d1[i])*lerpweight); |
||||||
|
} |
||||||
|
|
||||||
|
static void hex_blep (float *output, float time_since_transition, float scale) |
||||||
|
{ |
||||||
|
hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blep); |
||||||
|
} |
||||||
|
|
||||||
|
static void hex_blamp(float *output, float time_since_transition, float scale) |
||||||
|
{ |
||||||
|
hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blamp); |
||||||
|
} |
||||||
|
|
||||||
|
typedef struct |
||||||
|
{ |
||||||
|
float t,v,s; // time, value, slope
|
||||||
|
} hexvert; |
||||||
|
|
||||||
|
// each half of the waveform needs 4 vertices to represent 3 line
|
||||||
|
// segments, plus 1 more for wraparound
|
||||||
|
static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt) |
||||||
|
{ |
||||||
|
int j; |
||||||
|
float min_len = dt / 256.0f; |
||||||
|
|
||||||
|
vert[0].t = 0; |
||||||
|
vert[0].v = 0; |
||||||
|
vert[1].t = hex->current.zero_wait*0.5f; |
||||||
|
vert[1].v = 0; |
||||||
|
vert[2].t = 0.5f*hex->current.peak_time + vert[1].t*(1-hex->current.peak_time); |
||||||
|
vert[2].v = 1; |
||||||
|
vert[3].t = 0.5f; |
||||||
|
vert[3].v = hex->current.half_height; |
||||||
|
|
||||||
|
if (hex->current.reflect) { |
||||||
|
for (j=4; j <= 7; ++j) { |
||||||
|
vert[j].t = 1 - vert[7-j].t; |
||||||
|
vert[j].v = - vert[7-j].v; |
||||||
|
} |
||||||
|
} else { |
||||||
|
for (j=4; j <= 7; ++j) { |
||||||
|
vert[j].t = 0.5f + vert[j-4].t; |
||||||
|
vert[j].v = - vert[j-4].v; |
||||||
|
} |
||||||
|
} |
||||||
|
vert[8].t = 1; |
||||||
|
vert[8].v = 0; |
||||||
|
|
||||||
|
for (j=0; j < 8; ++j) { |
||||||
|
if (vert[j+1].t <= vert[j].t + min_len) { |
||||||
|
// if change takes place over less than a fraction of a sample treat as discontinuity
|
||||||
|
//
|
||||||
|
// otherwise the slope computation can blow up to arbitrarily large and we
|
||||||
|
// try to generate a huge BLAMP and the result is wrong.
|
||||||
|
//
|
||||||
|
// why does this happen if the math is right? i believe if done perfectly,
|
||||||
|
// the two BLAMPs on either side of the slope would cancel out, but our
|
||||||
|
// BLAMPs have only limited sub-sample precision and limited integration
|
||||||
|
// accuracy. or maybe it's just the math blowing up w/ floating point precision
|
||||||
|
// limits as we try to make x * (1/x) cancel out
|
||||||
|
//
|
||||||
|
// min_len verified artifact-free even near nyquist with only oversample=4
|
||||||
|
vert[j+1].t = vert[j].t; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (vert[8].t != 1.0f) { |
||||||
|
// if the above fixup moved the endpoint away from 1.0, move it back,
|
||||||
|
// along with any other vertices that got moved to the same time
|
||||||
|
float t = vert[8].t; |
||||||
|
for (j=5; j <= 8; ++j) |
||||||
|
if (vert[j].t == t) |
||||||
|
vert[j].t = 1.0f; |
||||||
|
} |
||||||
|
|
||||||
|
// compute the exact slopes from the final fixed-up positions
|
||||||
|
for (j=0; j < 8; ++j) |
||||||
|
if (vert[j+1].t == vert[j].t) |
||||||
|
vert[j].s = 0; |
||||||
|
else |
||||||
|
vert[j].s = (vert[j+1].v - vert[j].v) / (vert[j+1].t - vert[j].t); |
||||||
|
|
||||||
|
// wraparound at end
|
||||||
|
vert[8].t = 1; |
||||||
|
vert[8].v = vert[0].v; |
||||||
|
vert[8].s = vert[0].s; |
||||||
|
} |
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq) |
||||||
|
{ |
||||||
|
hexvert vert[9]; |
||||||
|
int pass,i,j; |
||||||
|
float t = hex->t; |
||||||
|
float temp_output[2*STB_HEXWAVE_MAX_BLEP_LENGTH]; |
||||||
|
int buffered_length = sizeof(float)*hexblep.width; |
||||||
|
float dt = (float) fabs(freq); |
||||||
|
float recip_dt = (dt == 0.0f) ? 0.0f : 1.0f / dt; |
||||||
|
|
||||||
|
int halfw = hexblep.width/2; |
||||||
|
// all sample times are biased by halfw to leave room for BLEP/BLAMP to go back in time
|
||||||
|
|
||||||
|
if (num_samples <= 0) |
||||||
|
return; |
||||||
|
|
||||||
|
// convert parameters to times and slopes
|
||||||
|
hexwave_generate_linesegs(vert, hex, dt); |
||||||
|
|
||||||
|
if (hex->prev_dt != dt) { |
||||||
|
// if frequency changes, add a fixup at the derivative discontinuity starting at now
|
||||||
|
float slope; |
||||||
|
for (j=1; j < 6; ++j) |
||||||
|
if (t < vert[j].t) |
||||||
|
break; |
||||||
|
slope = vert[j].s; |
||||||
|
if (slope != 0) |
||||||
|
hex_blamp(output, 0, (dt - hex->prev_dt)*slope); |
||||||
|
hex->prev_dt = dt; |
||||||
|
} |
||||||
|
|
||||||
|
// copy the buffered data from last call and clear the rest of the output array
|
||||||
|
memset(output, 0, sizeof(float)*num_samples); |
||||||
|
memset(temp_output, 0, 2*hexblep.width*sizeof(float)); |
||||||
|
|
||||||
|
if (num_samples >= hexblep.width) { |
||||||
|
memcpy(output, hex->buffer, buffered_length); |
||||||
|
} else { |
||||||
|
// if the output is shorter than hexblep.width, we do all synthesis to temp_output
|
||||||
|
memcpy(temp_output, hex->buffer, buffered_length); |
||||||
|
} |
||||||
|
|
||||||
|
for (pass=0; pass < 2; ++pass) { |
||||||
|
int i0,i1; |
||||||
|
float *out; |
||||||
|
|
||||||
|
// we want to simulate having one buffer that is num_output + hexblep.width
|
||||||
|
// samples long, without putting that requirement on the user, and without
|
||||||
|
// allocating a temp buffer that's as long as the whole thing. so we use two
|
||||||
|
// overlapping buffers, one the user's buffer and one a fixed-length temp
|
||||||
|
// buffer.
|
||||||
|
|
||||||
|
if (pass == 0) { |
||||||
|
if (num_samples < hexblep.width) |
||||||
|
continue; |
||||||
|
// run as far as we can without overwriting the end of the user's buffer
|
||||||
|
out = output; |
||||||
|
i0 = 0; |
||||||
|
i1 = num_samples - hexblep.width; |
||||||
|
} else { |
||||||
|
// generate the rest into a temp buffer
|
||||||
|
out = temp_output; |
||||||
|
i0 = 0; |
||||||
|
if (num_samples >= hexblep.width) |
||||||
|
i1 = hexblep.width; |
||||||
|
else |
||||||
|
i1 = num_samples; |
||||||
|
} |
||||||
|
|
||||||
|
// determine current segment
|
||||||
|
for (j=0; j < 8; ++j) |
||||||
|
if (t < vert[j+1].t)
|
||||||
|
break; |
||||||
|
|
||||||
|
i = i0; |
||||||
|
for(;;) { |
||||||
|
while (t < vert[j+1].t) { |
||||||
|
if (i == i1) |
||||||
|
goto done; |
||||||
|
out[i+halfw] += vert[j].v + vert[j].s*(t - vert[j].t); |
||||||
|
t += dt; |
||||||
|
++i; |
||||||
|
} |
||||||
|
// transition from lineseg starting at j to lineseg starting at j+1
|
||||||
|
|
||||||
|
if (vert[j].t == vert[j+1].t) |
||||||
|
hex_blep(out+i, recip_dt*(t-vert[j+1].t), (vert[j+1].v - vert[j].v)); |
||||||
|
hex_blamp(out+i, recip_dt*(t-vert[j+1].t), dt*(vert[j+1].s - vert[j].s)); |
||||||
|
++j; |
||||||
|
|
||||||
|
if (j == 8) { |
||||||
|
// change to different waveform if there's a change pending
|
||||||
|
j = 0; |
||||||
|
t -= 1.0; // t was >= 1.f if j==8
|
||||||
|
if (hex->have_pending) { |
||||||
|
float prev_s0 = vert[j].s; |
||||||
|
float prev_v0 = vert[j].v; |
||||||
|
hex->current = hex->pending; |
||||||
|
hex->have_pending = 0; |
||||||
|
hexwave_generate_linesegs(vert, hex, dt); |
||||||
|
// the following never occurs with this oscillator, but it makes
|
||||||
|
// the code work in more general cases
|
||||||
|
if (vert[j].v != prev_v0) |
||||||
|
hex_blep (out+i, recip_dt*t, (vert[j].v - prev_v0)); |
||||||
|
if (vert[j].s != prev_s0) |
||||||
|
hex_blamp(out+i, recip_dt*t, dt*(vert[j].s - prev_s0)); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
done: |
||||||
|
; |
||||||
|
} |
||||||
|
|
||||||
|
// at this point, we've written output[] and temp_output[]
|
||||||
|
if (num_samples >= hexblep.width) { |
||||||
|
// the first half of temp[] overlaps the end of output, the second half will be the new start overlap
|
||||||
|
for (i=0; i < hexblep.width; ++i) |
||||||
|
output[num_samples-hexblep.width + i] += temp_output[i]; |
||||||
|
memcpy(hex->buffer, temp_output+hexblep.width, buffered_length); |
||||||
|
} else { |
||||||
|
for (i=0; i < num_samples; ++i) |
||||||
|
output[i] = temp_output[i]; |
||||||
|
memcpy(hex->buffer, temp_output+num_samples, buffered_length); |
||||||
|
} |
||||||
|
|
||||||
|
hex->t = t; |
||||||
|
} |
||||||
|
|
||||||
|
STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer) |
||||||
|
{ |
||||||
|
#ifndef STB_HEXWAVE_NO_ALLOCATION |
||||||
|
if (user_buffer != 0) { |
||||||
|
free(hexblep.blep); |
||||||
|
free(hexblep.blamp); |
||||||
|
} |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
// buffer should be NULL or must be 4*(width*(oversample+1)*2 +
|
||||||
|
STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer) |
||||||
|
{ |
||||||
|
int halfwidth = width/2; |
||||||
|
int half = halfwidth*oversample; |
||||||
|
int blep_buffer_count = width*(oversample+1); |
||||||
|
int n = 2*half+1; |
||||||
|
#ifdef STB_HEXWAVE_NO_ALLOCATION |
||||||
|
float *buffers = user_buffer; |
||||||
|
#else |
||||||
|
float *buffers = user_buffer ? user_buffer : (float *) malloc(sizeof(float) * n * 2); |
||||||
|
#endif |
||||||
|
float *step = buffers+0*n; |
||||||
|
float *ramp = buffers+1*n; |
||||||
|
float *blep_buffer, *blamp_buffer; |
||||||
|
double integrate_impulse=0, integrate_step=0; |
||||||
|
int i,j; |
||||||
|
|
||||||
|
if (width > STB_HEXWAVE_MAX_BLEP_LENGTH) |
||||||
|
width = STB_HEXWAVE_MAX_BLEP_LENGTH; |
||||||
|
|
||||||
|
if (user_buffer == 0) { |
||||||
|
#ifndef STB_HEXWAVE_NO_ALLOCATION |
||||||
|
blep_buffer = (float *) malloc(sizeof(float)*blep_buffer_count); |
||||||
|
blamp_buffer = (float *) malloc(sizeof(float)*blep_buffer_count); |
||||||
|
#endif |
||||||
|
} else { |
||||||
|
blep_buffer = ramp+n; |
||||||
|
blamp_buffer = blep_buffer + blep_buffer_count; |
||||||
|
} |
||||||
|
|
||||||
|
// compute BLEP and BLAMP by integerating windowed sinc
|
||||||
|
for (i=0; i < n; ++i) { |
||||||
|
for (j=0; j < 16; ++j) { |
||||||
|
float sinc_t = 3.141592f* (i-half) / oversample; |
||||||
|
float sinc = (i==half) ? 1.0f : (float) sin(sinc_t) / (sinc_t); |
||||||
|
float wt = 2.0f*3.1415926f * i / (n-1); |
||||||
|
float window = (float) (0.355768 - 0.487396*cos(wt) + 0.144232*cos(2*wt) - 0.012604*cos(3*wt)); // Nuttall
|
||||||
|
double value = window * sinc; |
||||||
|
integrate_impulse += value/16; |
||||||
|
integrate_step += integrate_impulse/16; |
||||||
|
} |
||||||
|
step[i] = (float) integrate_impulse; |
||||||
|
ramp[i] = (float) integrate_step; |
||||||
|
} |
||||||
|
|
||||||
|
// renormalize
|
||||||
|
for (i=0; i < n; ++i) { |
||||||
|
step[i] = step[i] * (float) (1.0 / step[n-1]); // step needs to reach to 1.0
|
||||||
|
ramp[i] = ramp[i] * (float) (halfwidth / ramp[n-1]); // ramp needs to become a slope of 1.0 after oversampling
|
||||||
|
} |
||||||
|
|
||||||
|
// deinterleave to allow efficient interpolation e.g. w/SIMD
|
||||||
|
for (j=0; j <= oversample; ++j) { |
||||||
|
for (i=0; i < width; ++i) { |
||||||
|
blep_buffer [j*width+i] = step[j+i*oversample]; |
||||||
|
blamp_buffer[j*width+i] = ramp[j+i*oversample]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// subtract out the naive waveform; note we can't do this to the raw data
|
||||||
|
// above, because we want the discontinuity to be in a different locations
|
||||||
|
// for j=0 and j=oversample (which exists to provide something to interpolate against)
|
||||||
|
for (j=0; j <= oversample; ++j) { |
||||||
|
// subtract step
|
||||||
|
for (i=halfwidth; i < width; ++i) |
||||||
|
blep_buffer [j*width+i] -= 1.0f; |
||||||
|
// subtract ramp
|
||||||
|
for (i=halfwidth; i < width; ++i) |
||||||
|
blamp_buffer[j*width+i] -= (j+i*oversample-half)*(1.0f/oversample); |
||||||
|
} |
||||||
|
|
||||||
|
hexblep.blep = blep_buffer; |
||||||
|
hexblep.blamp = blamp_buffer; |
||||||
|
hexblep.width = width; |
||||||
|
hexblep.oversample = oversample; |
||||||
|
|
||||||
|
#ifndef STB_HEXWAVE_NO_ALLOCATION |
||||||
|
if (user_buffer == 0) |
||||||
|
free(buffers); |
||||||
|
#endif |
||||||
|
} |
||||||
|
#endif // STB_HEXWAVE_IMPLEMENTATION
|
||||||
@ -1,7 +0,0 @@ |
|||||||
#include "stretchy_buffer.h" |
|
||||||
|
|
||||||
void test_sb(void) |
|
||||||
{ |
|
||||||
char *x = NULL; |
|
||||||
sb_push(x, 'x'); |
|
||||||
} |
|
||||||
Loading…
Reference in New Issue