Bandlimited waveform generation

Question

I am writing a software synthesizer and need to generate bandlimited, alias free waveforms in real time at 44.1 kHz samplerate. Sawtooth waveform would do for now, since I can generate a pulse wave by mixing two sawtooths together, one inverted and phase shifted.

So far I've tried the following approaches:

1. Precomputing one-cycle perfectly bandlimited waveform samples at different bandlimit frequencies at startup, then playing back the two closest ones mixed together. Works okay I guess, but does not feel very elegant. A lot of samples are needed or the "gaps" between them will be heard. Interpolating and mixing is also quite CPU intensive.

2. Integrating a train of DC compensated sinc pulses to get a sawtooth wave. Sounds great except that the wave drifts away from zero if you don't get the DC compensation exactly right (which I found to be really tricky). The DC problem can be reduced by adding a bit of leakage to the integrator, but then you lose the low frequencies.

So, my question is: What is the usual way this is done? Any suggested solution must be efficient in terms of CPU, since it must be done in real time, for many voices at once.

Answer 1

There are a lot of ways to approach the bandlimited waveform generation. You will end up trading computational cost against quality as usual.

I suggest that you take a look at this site here:

http://www.musicdsp.org/

Check out the archive! It's full of good material. I just did a search on the keyword "bandlimited". The material that pops up should you keep busy for at least a week.

Btw - Don't know if that's what you looking for, but I did alias reduced (e.g. not really band limited) waveform generation a couple of years ago. I just calculated the integral between the last and current sample-position. For traditional synth-waveforms you can do that rather easy if you split your integration interval at the singularities (e.g. when the sawtooth get's his reset). The CPU load was low and the quality acceptable for my needs.

I had the same drift-problems, but applying a high-pass with a very low cutoff-frequency on the integral got rid of that effect. Real analog-synth don't go down into the subhertz region anyway, so you won't miss much.

Answer 2

@Nils:

I've been looking around at musicdsp.org a bit. In fact, the articles there inspired my first two implementations. Good stuff.

Your trick to generate alias reduced waveforms seems really nice, going to try it now to see how it sounds!

100% proper bandlimiting is not that important, I just want it to sound better than x-floor(x) :)

Answer 3

This is what I came up with, inspired by Nils' ideas. Pasting it here in case it is useful for someone else. I simply box filter a sawtooth wave analytically using the change in phase from the last sample as a kernel size (or cutoff). It works fairly well, there is some audible aliasing at the very highest notes, but for normal usage it sounds great.

To reduce aliasing even more the kernel size can be increased a bit, making it 2*phaseChange for example sounds good as well, though you lose a bit of the highest frequencies.

Also, here is another good DSP resource I found when browsing SP for similar topics: The Synthesis ToolKit in C++ (STK). It's a class library that has lot's of useful DSP tools. It even has ready to use bandlimited waveform generators. The method they use is to integrate sinc as I described in my first post (though I guess they do it better then me...).

float getSaw(float phaseChange)
{
 static float phase = 0.0f;
 phase = fmod(phase + phaseChange, 1.0f);
 return getBoxFilteredSaw(phase, phaseChange);
}

float getPulse(float phaseChange, float pulseWidth)
{
 static float phase = 0.0f;
 phase = fmod(phase + phaseChange, 1.0f);
 return getBoxFilteredSaw(phase, phaseChange) - getBoxFilteredSaw(fmod(phase + pulseWidth, 1.0f), phaseChange);
}

float getBoxFilteredSaw(float phase, float kernelSize)
{
 float a, b;

 // Check if kernel is longer that one cycle
 if (kernelSize >= 1.0f) {
  return 0.0f;
 }

 // Remap phase and kernelSize from [0.0, 1.0] to [-1.0, 1.0]
 kernelSize *= 2.0f;
 phase = phase * 2.0f - 1.0f;

 if (phase + kernelSize > 1.0f)
 {
  // Kernel wraps around edge of [-1.0, 1.0]
  a = phase;
  b = phase + kernelSize - 2.0f;
 }
 else
 {
  // Kernel fits nicely in [-1.0, 1.0]
  a = phase;
  b = phase + kernelSize;
 }

 // Integrate and divide with kernelSize
 return (b * b - a * a) / (2.0f * kernelSize);
}

Answer 4

I realize this was asked about a year ago, but for anyone else stumbling upon this, I'll recommend searching the friendly and highly competent DSP and Plug-in Development forum at KVR

Answer 5

This is weird, but supposedly good in both quality and computation time: MinBLEPs

MinBLEPs take the idea further and take a windowed sinc, perform a minimum phase reconstruction and then integrate the result and store it in a table. Now to make an oscillator you just insert a MinBLEP at each discontinuity in the waveform. So for a square wave you insert a MinBLEP where the waveform inverts, for saw wave you insert a MinBLEP where the value inverts, but you generate the ramp as normal.