Remove aliasing caused by scanning a wave file at arbitrary playback rates

Question

I am writing a sound generator that needs to scan through audio samples at an arbitrary rate. When the sample is played at it's original rate, it sounds fine. But when I change the playback speed, it produces aliasing noise.

I read this answer and it seems that I need to use Lanczos resampling to get a better outcome (I have tried the linear interpolation suggested in the answer. It improved the issue but still not optimal).

Based on Wikipedia's info about Lanczos, to calculate the value for sample at position x, I'll need the samples between x - a and x + a:

In the following example, the system periodically calls the function processAudio to get the next chunk of audio to playback. I applied the Lanczos function to the sample calculation, but the aliasing isn't improved at all, and it sounds worse than linear interpolation. Is there something wrong with my approach?

float samplePlaybackSpeed = 1.25f;
float currentPlayHead = 0.0f;
int filterFactor = 2;
// system callback function to fetch the next chunk of audio
void processAudio(float[] data)
{
    // output data is stereo
    for (int i = 0; i < data.Length; i += 2)
    {
        int flooredIndex = (int)Mathf.Floor(currentPlayHead);
        for (int j = flooredIndex - filterFactor + 1; j < flooredIndex + filterFactor; ++j)
        {
            if (j >= 0 && j < sampleLength)
            {
                float value = lanczos(currentPlayHead - j);
                // left channel
                data[i] += samples[j * 2] * value;
                // right channel
                data[i + 1] += samples[j * 2 + 1] * value;
            }
        }

        // round the playhead to the beginning when exceeding the sample length
        currentPlayHead = (currentPlayHead + samplePlaybackSpeed) % sampleLength;
    }
}

float lanczos(float pos)
{
    if (pos == 0)
        return 1;

    return filterFactor * Mathf.Sin(Mathf.PI * pos) * Mathf.Sin(Mathf.PI * pos / filterFactor) 
            / (Mathf.PI * Mathf.PI * pos * pos);   
}