Question

I know it was asked a thousand times before, but I still can’t find a solution.
Searching SO, I indeed found the algorithm for it, but lacking the mathematical knowledge required to truly understand it, I am helplessly lost!

To start with the beginning, my goal is to compute an entire spectrogram and save it to an image in order to use it for a visualizer.

I tried using Sound.computeSpectrum, but this requires to play the sound and wait for it to end, I want to compute the spectrogram in a way shorter time than that will require to listen all the song. And I have 2 hours long mp3s.

What I am doing now is to read the bytes from a Sound object, the separate into two Vectors(.); Then using a timer, at each 100 ms I call a function (step1) where I have the implementation of the algorithm, as follows:

1. for each vector (each for a channel) I apply the hann function to the elements;
2. for each vector I nullify the imaginary part (I have a secondary vector for that)
3. for each vector I apply FFT
4. for each vector I find the magnitude for the first N / 2 elements
5. for each vector I convert squared magnitude to dB scale
6. end.

But I get only negative values, and only 30 percent of the results might be useful (in the way that the rest are identical)

I will post the code for only one channel to get rid off the “for each vector” part.

private var N:Number = 512;
private function step1() : void
{
    var xReLeft:Vector.<Number> = new Vector.<Number>(N);
    var xImLeft:Vector.<Number> = new Vector.<Number>(N);

    var leftA:Vector.<Number> = new Vector.<Number>(N);

    // getting sample range
    leftA = this.channels.left.slice(step * N, step * (N) + (N));

    if (leftA.length < N)
    {
        stepper.removeEventListener(TimerEvent.TIMER, getFreq100ms);
        return;
    }
    else if (leftA.length == 0)
    {
        stepper.removeEventListener(TimerEvent.TIMER, getFreq100ms);
        return;
    }

    var i:int;

    // hann window function init
        m_win = new Vector.<Number>(N);
        for ( var i:int = 0; i < N; i++ )
            m_win[i] = (4.0 / N) * 0.5 * (1 - Math.cos(2 * Math.PI * i / N));

    // applying hann window function
    for ( i = 0; i < N; i++ )
    {
        xReLeft[i] = m_win[i]*leftA[i];
        //xReRight[i] = m_win[i]*rightA[i];
    }

    // nullify the imaginary part
    for ( i = 0; i < N; i++ )
    {
        xImLeft[i] = 0.0;
        //xImRight[i] = 0.0;
    }

    var magnitutel:Vector.<Number> = new Vector.<Number>(N);

    fftl.run( xReLeft, xImLeft );

    current = xReLeft;
    currf = xImLeft;

    for ( i = 0; i < N / 2; i++ )
    {
        var re:Number = xReLeft[i];
        var im:Number = xImLeft[i];
        magnitutel[i] = Math.sqrt(re * re + im * im);
    }

    const SCALE:Number = 20 / Math.LN10;
    var l:uint = this.total.length;
    for ( i = 0; i < N / 2; i++ )
    {
        magnitutel[i] = SCALE * Math.log( magnitutel[i] + Number.MIN_VALUE );
    }

    var bufferl:Vector.<Number> = new Vector.<Number>();

    for (i = 0; i < N / 2 ; i++)
    {
        bufferl[i] =  magnitutel[i];
    }

    var complete:Vector.<Vector.<Number>> = new Vector.<Vector.<Number>>();
    complete[0] = bufferl;
    this.total[step] = complete;

    this.step++;
}

This function is executed in the event dispatched by the timer (stepper).
Obviously I do something wrong, as I said I have only negative values and further more values range between 1 and 7000 (at least).

I want to thank you in advance for any help.

With respect,
Paul

Answer 1

Negative dB values are OK. Just add a constant (representing your volume control) until the number of points you want to color become positive. The remaining values that stay negative are usually just displayed or colored as black in a spectrogram. No matter how negative (as they might just be the FFT’s numerical noise, which can be a huge negative dB number or even NaN or -Inf for log(0)).