| // 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/C++ 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. |
| // |
| // License: |
| // |
| // See end of file for license information. |
| // |
| // 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 |
| |
| /* |
| ------------------------------------------------------------------------------ |
| This software is available under 2 licenses -- choose whichever you prefer. |
| ------------------------------------------------------------------------------ |
| ALTERNATIVE A - MIT License |
| Copyright (c) 2017 Sean Barrett |
| Permission is hereby granted, free of charge, to any person obtaining a copy of |
| this software and associated documentation files (the "Software"), to deal in |
| the Software without restriction, including without limitation the rights to |
| use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies |
| of the Software, and to permit persons to whom the Software is furnished to do |
| so, subject to the following conditions: |
| The above copyright notice and this permission notice shall be included in all |
| copies or substantial portions of the Software. |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| SOFTWARE. |
| ------------------------------------------------------------------------------ |
| ALTERNATIVE B - Public Domain (www.unlicense.org) |
| This is free and unencumbered software released into the public domain. |
| Anyone is free to copy, modify, publish, use, compile, sell, or distribute this |
| software, either in source code form or as a compiled binary, for any purpose, |
| commercial or non-commercial, and by any means. |
| In jurisdictions that recognize copyright laws, the author or authors of this |
| software dedicate any and all copyright interest in the software to the public |
| domain. We make this dedication for the benefit of the public at large and to |
| the detriment of our heirs and successors. We intend this dedication to be an |
| overt act of relinquishment in perpetuity of all present and future rights to |
| this software under copyright law. |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| ------------------------------------------------------------------------------ |
| */ |
