Wavetable package

Thanks! *hides head in the sand*

It's like, ILO does something oversampling just can't, which is cleaning all the foldovers up to infinity, but the reduction of the first foldover is quite mild, so the combination is not redundant.

I would say it's the same thing, with ILO being the general case. Vadim does mention it in the ILO paper. Thing is, the generalization to an arbitrary input makes the math quite more complicated 😁

Rectangular ILO takes a plain average of the values from the previous to the current x, triangular (or linear) ILO takes a weighted average around the current x. Rectangular and triangular refers to the shape of the weighting function, aka lowpass kernel.

I spent like 90% of the effort solving this 😅 The main thing is that you can't extend differentiation to arbitrarily low frequencies, and phase/frequency modulation can make the instantaneous frequency reach or even cross zero very fast, so if you don't switch to plain interpolation below SR / table size you get a division by zero. There are a couple more problems though. Each differentiation has a delay of 1/2 sample, and at negative frequencies the delay goes in the opposite direction with respect to the table, so there's a 1 sample difference per order between positive and negative frequencies which you have to deal with. Any messing with the read position for the differentiated branch risks breaking the differentiators' states, so I fixed it "bridging" the negative and positive sides with a 1/2/3-sample phase shift across the plain interpolation branch (that is, for low frequencies around 0 Hz):

Say you have a 1024-sample frame and order 3. There's a 3 sample phase difference between positive and negative frequencies, so I apply a linear phase shift to the non-differentiated branch, from 3 samples at -SR/1024 Hz to zero at SR/1024 Hz.

The last thing concerns the part I marked in red. You can't use the same phase difference for all differentiators, like, for 3rd order with y = table value and x = phase/position:

Each phase difference needs to span the samples involved in the numerator. I haven't really proved this, I just spent a stupid amount of time trying to fix it in other ways, until I wrote it like this and it looked suspicious 🤗

They do. Like ILO, they bandlimit a continuous-time function before sampling it, they just focus specifically on discontinuities (jumps and corners). You can use them for functions whose discontinuities you know beforehand, and you'll have to keep track of their position. It's much more complicated to apply them to an arbitrary function, and pretty impossible to a wavetable: how do you know what's a jump and what's not?

They're not, and actually the tables I loaded are already aliased, they're naive, non-bandlimited triangle/saw/square. They only need to be centered, aka DC filtered, so the average of all values is subtracted from all values:

This is necessary to get a periodic integral: the integral of a non-centered signal grows indefinitely.

Well, a wavetable is a (usually short) sample in a (usually fast) loop, so yeah. I mean, it could be used generally as a form of bandlimited downsampling, for transposing a sample upwards.

I think you mean there's some aliasing 😁 Like, there could be actual noise too. For example in the current implementation, if 3rd order is used in 32 bit, or 2nd order is used in 32 bit with wide phase modulation. You'd also get noise if the low frequency gap was unsolved or wrongly solved, or the differentiators' gains were applied all together after taking all differences, etc. -these were the things I had to solve. I think you shouldn't get noise now, but you still get some aliasing, which is seen in the pictures. You don't hear aliasing at high frequencies using mipmaps because the table has been transposed and (heavily) filtered before resampling. The practicality of preintegration is that you don't need to have multiple copies of the table: using a single copy for the whole range, you get quite good antialiasing. Now, you could actually do both things: have, say, two copies, one for the upper half of the range which has been heavily filtered, and preintegrate both. You could call that preintegrated mipmaps. I'd consider it a bit overkill 😂

Most of it is still the actual saw, but the "noisy" part is indeed aliasing. You can see it here in a zoom around 16k, for order 1/2/3:

Nope, the builder module takes care of it. The sum is run twice, the first time to get the average (= DC), then with the average subtracted:

3rd order and the factory polyblep are indeed quite similar.

The passband and first foldover are almost the same. The next foldovers are lower in the polyblep, but 3rd order has wider holes at multiples of 2pi so it's cleaner below ~4k @44.1. The core polyblep uses a 7th order poly, quite longer than the quadratic in the Välimäki paper. All these methods do essentially the same, they lowpass a continuous-time reconstruction of a signal. Integration is a very rough lowpass (a moving average), so it takes three passes to get something comparable with a 7th order bandlimited step. Generalizing such a lowpass to an arbitrary waveform takes much more complexity (and processing power).

That's because it's not noise, it's the rest of the harmonic spectrum successively folded at sr/2 and 0. It's inharmonic with respect to the signal when the fundamental is not a submultiple of sr, but it's still periodic.

Yep, that's the place 😁 Summation is discrete integration. DC is the constant offset of a signal, hence its average, sum / length. If you subtract the average of a signal from it, you're removing DC.

No I'm not -I considered it, but it wouldn't make a... difference (cuack). This will be more clear with an example. Say you have a 5-sample saw:

1 2 3 4 5 😁

The sum gives 15, and 15/5 = 3, so you subtract it from all values to remove DC:

-2 -1 0 1 2

Now you take the partial sums: 1st, 1st+2nd, etc:

-2 -3 -3 -2 0

Now you take differences: 1st-last, 2nd-1st etc:

-2-0, -3-(-2), -3-(-3), -2-(-3), 0-(-2) = -2 -1 0 1 2

You've integrated and differentiated, congratulations. Now suppose for some reason you need to read the sums backwards:

0 -2 -3 -3 -2

Taking differences:

0-(-2), -2-0, -3-(-2), -3-(-3), -2-(-3) = 2 -2 -1 0 1

See? You've shifted by 1 sample. If you had taken 3 sums, you'd have shifted by 3 samples. Ok so, no problem: if for some reason you need to read backwards, just start reading with a 1 sample offset.

😅

It happens that in our case, the table is read backwards when the frequency is negative, and you go into negative frequency all the time when modulating phase. If you start reading with a 1 sample offset each time the frequency goes negative, you get a discontinuity at those points. I couldn't find a way to make that shift without breaking the differentiators' states (the memories of their previous sample), which causes clicks, and very big ones, because they happen around low frequencies, when the table is read slowly, and we take (table value diff) / (read position diff). Because at frequencies around 0 Hz I switch to plain interpolation, I can offset this read instead, which is stateless, so there's no risk of big clicks. Instead of just jumping at negative frequencies, which still causes a small discontinuity, I apply the offset progressively, from -sr/size to +sr/size. It's a hack but it works 🤗