The wavetable oscillator code follows the basic structure of most audio processing blocks, with three types of functions:<\/p>\n
Initialization<\/i>\u2014Most of our work for the oscillator is here. Fortunately, this is the part that’s not time-critical. We start by initializing the oscillator’s phase to zero, and creating all of the wavetables we need\u2014starting with the lowest frequency wavetable, followed by its progressively bandwidth-reduced copies for successively higher frequency ranges. In this implementation, each wavetable is accompanied by its table length, and the highest pitch that the table is built to handle without noticeable aliasing.<\/p>\nAs needed<\/h3>\n
Control<\/i>\u2014You may change the oscillator frequency only for new notes, or it might be as often as every sample if you want modulation with updates at the sample rate (also true of pulse-width if you want to pulse-width modulation). And fortunately this task is the simplest and fastest of all for the oscillator, so it’s no problem supporting it for every sample.<\/p>\nEvery sample<\/h3>\n
Processing<\/i>\u2014In general you need to update each oscillator’s phase for every sample, though you can choose to suspend updating of any oscillator that’s part of a voice that’s silent. And of course the oscillator won’t do you much good if you don’t get its output for every sample and use it.<\/p>\n
Updating the phase is trivial\u2014just add the phase increment, and wrap it back into the range of 0-1 if necessary.<\/p>\n
Retrieving the current output is a bit more work. First, we need to determine which table to use, by comparing the current frequency control (phase increment) with the highest-frequency table that can accommodate it. Then we use the current phase value, from the phase accumulator, to determine the wavetable positions and weighting for our linear interpolation to yield the oscillator output.<\/p>\n
For instance, if the phase accumulator is 0.51, and the length of the appropriate wavetable is 2048, then the offset into the table is 0.51 x 2048, or 1044.48. So, we use table samples at indices 1044 and 1045, and use the fractional part\u20140.48\u2014in the interpolation.<\/p>\n
The oscillator is implemented in C++. We’ll start with the oscillator’s private member variables, but keep in mind that you won’t access these directly\u2014you’ll interact with the oscillator through the member functions.<\/p>\n
First, each oscillator needs a phase accumulator and a phase increment (frequency control):<\/p>\n
double phasor; \/\/ phase accumulator\ndouble phaseInc; \/\/ phase increment\n<\/pre>\nAnd since we’re supporting variable pulse width via the difference between two saws, we need a phase offset control:<\/p>\n
double phaseOfs; \/\/ phase offset for PWM\n<\/pre>\nAnd each oscillator needs its list of wavetables and how many there are. We pick a maximum number of wavetables to support\u2014this information doesn’t take up much memory, and it’s more efficient than allocating the list dynamically; we can cover 20 Hz to 20 kHz with ten tables\u2014I picked 32 as the maximum in case you want to try half- or third-octave tables, but you can set numWaveTableSlots to whatever value you want:<\/p>\n
\/\/ list of wavetables\nint numWaveTables;\nwaveTable waveTables[numWaveTableSlots];\n<\/pre>\nHere’s the wavetable structure\u2014the length of the wavetable, the top frequency it’s designed for, and the wavetable itself (which is allocated dynamically):<\/p>\n
typedef struct {\n double topFreq;\n int waveTableLen;\n float *waveTable;\n} waveTable;\n<\/pre>\nWhy does each wavetable have its own length variable? Because this oscillator doesn’t require a constant size. For example, for a memory-sensitive environment, you could use longer tables for low frequencies in order to accommodate more harmonics, and shorter ones for higher frequency tables. For constant oversampling, you could cut the table size in half (along with the number of harmonics) for each higher octave.<\/p>\n
Functions<\/h4>\n
Now for the oscillator functions. Besides the constructor\u2014which simply initializes the phase accumulator, phase increment, phase offset, and the empty wavetable list\u2014and the destructor, we have this function to initialize the oscillator:<\/p>\n
void addWaveTable(int len, float *waveTableIn, double topFreq);\n<\/pre>\nThe addWaveTable function specifies the length of a wavetable to add to the oscillator, its contents, and the top frequency (phase increment) it’s designed for. Call it once for each wavetable you need to add\u2014from lowest frequency tables to highest.<\/p>\n
We have these functions for setting frequency (normalized to the sample rate\u2014it’s the phase increment) and the phase offset (for setting pulse width, and perhaps other uses in the future):<\/p>\n
void setFrequency(double inc);\nvoid setPhaseOffset(double offset);\n<\/pre>\nHere is the function to update the oscillator phase by adding adding the phase increment to the phase accumulator\u2014call this once per sample:<\/p>\n
void updatePhase(void);\n<\/pre>\nFinally, the routines that retrieve the current oscillator output. Use getOutput, normally. But for variable pulse width, initialize the oscillator for a sawtooth oscillator, and get the oscillator output via getOutputMinusOffset, where the pulse width is set with setPhaseOffset, with a value between 0.0 and 1.0 corresponding to the pulse width:<\/p>\n
float getOutput(void);\nfloat getOutputMinusOffset(void);\n<\/pre>\nThe code<\/h3>\n
Here’s the wavetable oscillator source code, in a .zip file\u2014WaveTableOsc.cpp and WaveTableOsc.h, along with a file, main.c, that gives a few oscillator examples and generates .wav file output:<\/p>\n
WaveTableOsc source code<\/a><\/p>\n
More comments and output examples coming soon.<\/i><\/p>\n\n\n
Update:<\/strong> Be sure to check out the updated WaveTableOsc, in WaveTableOsc optimized<\/a>.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
The wavetable oscillator code follows the basic structure of most audio processing blocks, with three types of functions: at the start: initialization\u2014create the oscillator and its wavetables as needed: control\u2014change the oscillator frequency, and pulse width for PWM every sample: … Continue reading