Zero Stuffing in gen~ (upsampling)

I have done a 2x up and down sampling patch. It's partially working but not really in a shape to share currently, but I can maybe talk through it a bit.

The upsampling case has a signal input and two signal outputs for the odd & even signals. The input is written into a delay line. The outputs are the same delay line convolved with a sinc waveform (for the lowpass filtering), but moving through it in steps of 2. The first output is convolved with indices 0, 2, 4, .. etc, and the second output is convolved with indices 1, 3, 5, etc., which is the zero stuffing part of it.

The downsampling case is near identical, but using two inputs (both writing into a delay line each), and summing the two convolutions back to a single output.

// ASCII diagrams of upsampling:
// input signal as x[n], x[n-1], ... i.e. n[t] where t is delay index
// zero stuffed for 2x upsampling:
// n9 _  n8 _  n7 _  n6 _  n5 _  n4 _  n3 _  n2 _  n1 _  n0 _
// convolve with ideal IR kernels
// ir len == 9, buflen = 3
// out0                             _  b0 b1 b2 (1)b2 b1 b0 _
// out1                          _  b0 b1 b2 (1)b2 b1 b0 _
// IR len == 11, buflen = 4
// out0                       _  b0 b1 b2 b3  (1)b3 b2 b1 b0  _
// out1                    _  b0 b1 b2 b3  (1)b3 b2 b1 b0  _
// where b[t] indices the index into the IR buffer

// ASCII diagrams of downsampling
// in2 in1 in2 in1 in2 in1 in2 in1 in2 in1 in2 in1 in2 in1
// n6  n6  n5  n5  n4  n4  n3  n3  n2  n2  n1  n1  n0  n0
//                         _   b0  b1  b2  b3* b2  b1  b0  _
//                     _   b0  b1  b2  b3* b2  b1  b0  _
//                 _   b0  b1  b2  b3  b4* b3  b2  b1  b0  _
//             _   b0  b1  b2  b3  b4* b3  b2  b1  b0  _

The actual IR I was using was 21 samples long, computed as a sinc function under a Blackman window. Here's the genexpr for that part (assuming a [buffer~ ir_buf @samps 21]):

blackman(x) {
    return 0.42 - 0.5*cos(2*pi*x) + 0.08*cos(4*pi*x);
}

Buffer ir_buf;
// cutoff frequency in Hz
hz = in1;
// gain factor applied to all kernel to preserve throughput
gain = 2*hz/samplerate;
// if they change, recompute the IRs:
if (once || change(hz)) {
    once = 0;
    // length of the IR
    buflen = dim(ir_buf);
    sinc_midpoint = buflen-1;
    // the *conceptual* length of the IR
    // +3 because we trimmed the first & last (0), 
    // and middle occurs once
    len = buflen*2 + 1;
    // convert Hz to radians per sample
    w = hz * twopi/samplerate;
    // for each frame of the buffer:
    for (i=0; i<sinc_midpoint; i+=1) {
        // conceptual phase of the IR:
        // (i+1 because we trimmed the first 0-valued sample)
        p = (i+1)/(len-1);
        // k==0 at the dirac pulse in the centre of the sinc
        // (this is 1 sample after the buffer ends)
        // k==1 at the sample just before it, etc. etc.
        k = sinc_midpoint-i;
        // per-sample multiple/divisor for sinc:
        kw = k * w;
        // compute sinc kernel for lowpass
        lp = sin(kw)/kw;
        // sinc function is infinite, 
        // window it here to force sinc to zero at IR ends
        lp *= blackman(p);
        // write to the buffer:
        poke(ir_buf, lp * gain, i);
    }
     // lastvalue:
    poke(ir_buf, gain, sinc_midpoint);
}

How are you going with this Graham? Have you made much progress?

Interested too!

:O You can do it Graham! Oversampling would be a great addition to Oopsy Daisy.

I've been playing around with for loops and convolution trying to get something going myself but I keep going around in circles at this point :(
I've tried a few different things and I think the issue is the iteration & index of buffers not lining up all the time and perhaps that the second filter should be processing the zeros? in any case, heres an example;

// declare buffers:
Data input(64);
Data effect(64);
Data output(64);
// the impulse response: (14 zero crossings, kaiser window)
Buffer IR("sinc");
// the length of the IR:
len = dim(IR);
// declare variables for sums and output:
filter = 0;
FX_init = 0;
FX_filter = 0;
Out = 0;
// for loop
for (i=1; i<len; i+=2) {

    //store input samples
    poke(input,in1,i,0,0);

    // Read IR:
    // (by default peek will ignore out-of-bound indices)
    FIR = peek(IR, i, 0);        

    // len-i is to reverse buffer for convolution of input
    In = peek(input, (len-i), 0);

    // accumulate their product:
    filter += FIR * In;

    //inserts zeros by only placing samples at iteration points
    poke(effect,filter,i,0,0);

    //read (&scale from 1st sinc filter)
    FX_init = peek(effect, len-i, 0)*0.812;

    //read IR again
    FIR2 = peek(IR, i, 0);

    //apply effect and filter (skipping zeros coz we can?)
    FX_apply = tanh(FX_init);
    FX_filter += FIR2 * FX_apply;

    //store & read to decimate
    poke(output,FX_filter,i,0,0);
    Out = peek(output, i, 0);

}

Out1 = Out;

FYI - Ive kind of been using this as some sort of guide; https://www.willpirkle.com/app-notes/multiratepolyphase/

I'm also really interested in this. Robert, did you get any further?

Not really @DAMU but perhaps @Graham Wakefield can tease us with his updated Oversampling example which is coming in the next gen~ book :P ???

There's a new book coming? That's exciting. Do you know when that is due? I've still been working on this as much as possible but my DSP knowledge isn't enough to do anything better than rudimentary upsampling.

Hi folks

There is a 2x spline upsampler and downsampler in the 5D filter. I optimized the coefficients so it doesnt use much CPU.

https://yofiel.com/audio/synthcore.php