Granular pitch shifter

[jpcima]

A granular pitch shifter can give a subtantial improvement to ef.transpose.
This operates in the time-domain, surely one could be implemented with Faust.

The principle is to replay delayed versions (grains) of the signal with an AR envelope (window) applied.
It's not that different of what ef.transpose already does, but it can involve more delay lines.

The best resource which I know is the SuperCollider PitchShift ugen.
https://doc.sccode.org/Classes/PitchShift.html

A time domain granular pitch shifter. Grains have a triangular amplitude envelope and an overlap of 4:1, and use linear interpolation of the buffer.

There is also random deviation of time and frequency, which seems important to improving the sound quality.

[dariosanfilippo]

Hi, @jpcima.

I remember us talking about this and I still had the code that we tried, to which I made a few changes.

This is just the classic pitch shifter similar to ef.transpose, except using a Hann window, which appears to make things cleaner. The other difference in what I wrote is that the window length is constant regardless of the transposition, which means that the fundamental frequency of the comb effect is also constant instead of gliding as we change transpositions. Whether this is a good thing or not is perhaps a matter of taste.

I'm not sure what the advantage of using more delay lines could be, since it means that there will be more signals overlapping and, consequently, more undesired comb effect, potentially.

I have also implemented the random delay offset described on the SC page: it works to some extent but it makes the overall output rather noisy for me.

I tried cascading 4 first-order allpass filters with random cut-off frequencies but that, too, resulted in too much noise.

Especially for noisy inputs, there can be a little bit of improvement for the comb effect by filtering the output of the two reading heads with an analytic filter: I take the real part of one, the imaginary part of the other. Although there's undesirable modulation for sinusoidal signals and it's generally not consistent.

I'm attaching the code below for testing.

Ciao,
Dario

import("stdfaust.lib");

analytic(x) =  real ,
               imaginary
      with {
           im_c = (    0.47944111608296202665 ,
                       0.87624358989504858020 ,
                       0.97660296916871658368 ,
                       0.99749940412203375040);
           re_c = (    0.16177741706363166219 ,
                       0.73306690130335572242 ,
                       0.94536301966806279840 ,
                       0.99060051416704042460);
           tf(c, y, x) = c * (x + y') - x'';
           imaginary = x' : seq(i, 4,  tf(ba.take(i + 1, im_c))
                                       ~ _);
           real = x : seq(i, 4,    tf(ba.take(i + 1, re_c))
                                   ~ _);
      };

pitchShift(winLen, factor, x) = head1 + head2 
    with {
        win(ph) = sin(ma.PI * ph) ^ 2.0; // Hann
        phase1 = os.phasor(1.0, 1.0 / winLen * ma.signum(-factor));
        phase2 = ma.frac(phase1 + .5);
        clock1 = phase1 - phase1' < 0;
        clock2 = phase2 - phase2' < 0;
        shift1 = (phase1 * winLen * abs((1 - factor)) + rand1) * ma.SR;
        shift2 = (phase2 * winLen * abs((1 - factor)) + rand2) * ma.SR;
        rand1 = hslider("rand depth", 0, 0, .1, .000001) ^ 2.0 * ba.sAndH(clock1, abs(no.noise));
        rand2 = hslider("rand depth", 0, 0, .1, .000001) ^ 2.0 * ba.sAndH(clock2, abs(no.noise));
        head1 = de.fdelay(2 ^ 19, shift1, x) * win(phase1) <: *(1 - checkbox("Hilbert")) + (analytic : _ , !) * checkbox("Hilbert");
        head2 = de.fdelay(2 ^ 19, shift2, x) * win(phase2) <: *(1 - checkbox("Hilbert")) + (analytic : ! , _) * checkbox("Hilbert");
    };

window = hslider("win len (s)", .01, .001, 1, .001);
factor = hslider("factor", 4, 1, 8, .001);
semitones = ma.log2(factor) * 12;

//input = os.osc(hslider("f[scale: log]", 1536, 20, 20000, .001));
input = no.noise;
//input = _; // to test it with the sample from the IDE

switch = checkbox("This 0/Faust 1");
process = (input : pitchShift(window, factor) * (1 - switch) * .5) , (input : ef.transpose(window*ma.SR, window*ma.SR, semitones) * (0-switch) * .5) :> _ <: _ , _;

[jpcima]

I know not much on granular PS at the moment, except some claims of success based on a project that @alcomposer is working on. The information available in public research on this topic is surprisingly little.

I can elaborate though, regarding the random deviation:
Consider a sequence of snare hits playing at quick regular interval; the transposer based on 2 delay lines and opposite modulation is able to create cancellations which remove the track entirely.
The ef.transpose function suffers from this, where you are at the mercy of the phase of the modulation: have Faustlive reload the source without changes, at one you hear the sound doubled and another time cancelled, or any nuances in between.