GFFrequencyAnalyzer/GFFADLL/GFFADLL.cpp

// (c)2003 by Louis. See GFFrequencyAnalyzer for more information.
//
#include "math.h" // sin
#include "stdlib.h" // malloc
#include "malloc.h" // malloc
// #include "memory.h" // memcpy
//
void _stdcall GFFADLL_Test(double *SinArray);
void _stdcall GFFADLL_GetSpectrumArray(short *InputArray, double *SpectrumArray, long SpectrumArraySize, long *ReversedBitArray, long FilterBits);
//
#define TWO_PI (double) 6.28318530717959 // 2 * Pi = 2 * 3.14159265358979
//
#define GFFA_FILTERBIT_NOFILTER         0L
#define GFFA_FILTERBIT_HANNINGFILTER    1L

void _stdcall GFFADLL_Test(double *SinArray)
{
    double a = 0;
    long l = 0;
    // begin
    for (l; l < 100000000L; l++)
    {
        // a = SinArray[(long)((double)6.2831 * (double)10000)];
        a = sin ((double)6.2831 * (double)10000); // faster than stuff above :‑| ?!?
    }
}

void _stdcall GFFADLL_GetSpectrumArray(short *InputArray, double *SpectrumArray, long SpectrumArraySize, long *ReversedBitArray, long FilterBits)
{
    long BlockSize = 0;
    long BlockEndPos = 0;
    double DeltaAngle = 0;
    double DeltaAR = 0;
    double Alpha = 0;
    double Beta = 0;
    double TR = 0;
    double TI = 0;
    double AR = 0;
    double AI = 0;
    double TempSpectrumArray[65536]; // using a pointer and malloc failed, periodical, false signals where in the output (also if declared locally within procedure) (?!?)
    long Temp1 = 0;
    long Temp2 = 0;
    long Temp4 = 0;
    long Temp3 = 0;
    double TempDbl = 0;

    // preset
    // TempSpectrumArray = (double*)malloc (SpectrumArraySize * 8L);

    // short InputArrayFast[131072]; // not faster
    // memcpy (InputArrayFast, InputArray, 131072 * 2); // not faster

    // double SpectrumArrayFast[131072]; // even slower (although VC instead of VB array)

    // ZeroMemory (TempSpectrumArray, 131072); // does not work as 'DWORD' not defined (although winbase.h included (?!?))

    // begin
    for (Temp1 = 0L; Temp1 < SpectrumArraySize; Temp1 ++)
    {
        SpectrumArray[ReversedBitArray[Temp1]] = (double)InputArray[Temp1];
        TempSpectrumArray[Temp1] = (double)0; // since this array is static, gotta make sure it's clear
        // ReversedBitArray[Temp1] // note that using Temp1 instead of ReversedBitArray[Temp1] as array index above is faster and has the same function (differs from original code)
    }
    // begin

    BlockEndPos = 1L;
    BlockSize = 2L;

    while (BlockSize <= SpectrumArraySize)
    {
        DeltaAngle = TWO_PI / BlockSize;
        Alpha = sin ((double)0.5 * DeltaAngle);
        Alpha = (double)2 * Alpha * Alpha;
        Beta = sin (DeltaAngle);
        Temp1 = 0L; // reset

        while (Temp1 < SpectrumArraySize)
        {
            AR = (double)1;
            AI = (double)0;

            Temp2 = Temp1; // preset
            for (Temp3 = 0L; Temp3 < BlockEndPos; Temp3 ++)
            {
                Temp4 = Temp2 + BlockEndPos;
                TR = AR * SpectrumArray[Temp4] ‑ AI * TempSpectrumArray[Temp4];
                TI = AI * SpectrumArray[Temp4] + AR * TempSpectrumArray[Temp4];
                SpectrumArray[Temp4] = SpectrumArray[Temp2] ‑ TR;
                TempSpectrumArray[Temp4] = TempSpectrumArray[Temp2] ‑ TI;
                SpectrumArray[Temp2] = SpectrumArray[Temp2] + TR;
                TempSpectrumArray[Temp2] = TempSpectrumArray[Temp2] + TI;
                DeltaAR = Alpha * AR + Beta * AI;
                AI = AI ‑ (Alpha * AI ‑ Beta * AR);
                AR = AR ‑ DeltaAR;
                Temp2 = Temp2 + 1L;
            }
            Temp1 = Temp1 + BlockSize;
        }

        BlockEndPos = BlockSize;
        BlockSize = BlockSize * 2L;
    }
    /* unusable
    if (FilterBits && GFFA_FILTERBIT_HANNINGFILTER)
    {
        double InputArraySizeHalf = (SpectrumArraySize / 2L);

        for (TempDbl = (double)0; TempDbl < InputArraySizeHalf; TempDbl ++)
        {
            SpectrumArray[(long)TempDbl] *= (double)0.5 * ((double)1 ‑ cos (TempDbl * TWO_PI / InputArraySizeHalf));
        }
    }
    */
}


[END OF FILE]