omxsp_fftinv_ctoc_sc32_sfs.c

The OpenMAX DL (Development Layer) APIs contain a comprehensive set of audio, video, signal processi

/**
 * 
 * File Name:  omxSP_FFTInv_CToC_SC32_Sfs.c
 * OpenMAX DL: v1.0.2
 * Revision:   10586
 * Date:       Wednesday, March 5, 2008
 * 
 * (c) Copyright 2007-2008 ARM Limited. All Rights Reserved.
 * 
 * 
 * Description:
 * Compute an inverse FFT for a complex signal
 */

#include "omxtypes.h"
#include "armOMX.h"
#include "omxSP.h"
#include "armCOMM.h"
#include "armSP.h"

/**
 * Function:  omxSP_FFTInv_CToC_SC32_Sfs   (2.2.4.2.4)
 *
 * Description:
 * These functions compute an inverse FFT for a complex signal of length
 * of 2^order, where 0 <= order <= 12. Transform length is determined by the 
 * specification structure, which must be initialized prior to calling the FFT 
 * function using the appropriate helper, i.e., <FFTInit_C_sc32> or 
 * <FFTInit_C_SC16>. The relationship between the input and output sequences 
 * can be expressed in terms of the IDFT, i.e.: 
 *
 *     x[n] = (2^(-scalefactor)/N)  . SUM[k=0,...,N-1] X[k].e^(jnk.2.pi/N)
 *     n=0,1,2,...N-1
 *     N=2^order.
 *
 * Input Arguments:
 *   pSrc - pointer to the complex-valued input signal, of length 2^order ; 
 *          must be aligned on a 32-byte boundary. 
 *   pFFTSpec - pointer to the preallocated and initialized specification 
 *            structure 
 *   scaleFactor - scale factor of the output. Valid range is [0,32]. 
 *
 * Output Arguments:
 *   order 
 *   pDst - pointer to the complex-valued output signal, of length 2^order; 
 *          must be aligned on a 32-byte boundary. 
 *
 * Return Value:
 *    
 *    OMX_Sts_NoErr - no error 
 *    OMX_Sts_BadArgErr - returned if one or more of the following conditions 
 *              is true: 
 *    -   one or more of the following pointers is NULL: pSrc, pDst, or 
 *              pFFTSpec. 
 *    -   pSrc or pDst is not 32-byte aligned 
 *    -   scaleFactor<0 or scaleFactor>32
 *
 */

OMXResult omxSP_FFTInv_CToC_SC32_Sfs(
     const OMX_SC32 *pSrc,
     OMX_SC32 *pDst,
     const OMXFFTSpec_C_SC32 *pFFTSpec,
     OMX_INT scaleFactor
 )
 {
    OMX_INT     block, point;
    OMX_INT     i, j, N, NBy2;
    OMX_U16     *pRevIndex;
    OMX_FC64     *out;
    OMX_FC64    *pT1, *pT2, *pT, *pTw, T;
    ARMsFFTSpec_FC64 *pFFTStruct;

    /* Input parameter check */ 
    armRetArgErrIf(pSrc == NULL, OMX_Sts_BadArgErr)
    armRetArgErrIf(armNot32ByteAligned(pSrc), OMX_Sts_BadArgErr)
    armRetArgErrIf(pDst == NULL, OMX_Sts_BadArgErr)
    armRetArgErrIf(armNot32ByteAligned(pDst), OMX_Sts_BadArgErr)
    armRetArgErrIf(pFFTSpec == NULL, OMX_Sts_BadArgErr)
    armRetArgErrIf(scaleFactor < 0, OMX_Sts_BadArgErr)
    armRetArgErrIf(scaleFactor > 32, OMX_Sts_BadArgErr)

    /* Order range check */ 
    pFFTStruct = (ARMsFFTSpec_FC64 *) pFFTSpec;    
    N = pFFTStruct->N;
    armRetArgErrIf(N < 1, OMX_Sts_BadArgErr)
    armRetArgErrIf(N > (1 << 12), OMX_Sts_BadArgErr)
    
    /* Handle order zero case separate */
    if (N == 1)
    {
        pDst [0].Re = armSatRoundLeftShift_S32 (pSrc[0].Re, -scaleFactor);
        pDst [0].Im = armSatRoundLeftShift_S32 (pSrc[0].Im, -scaleFactor);
        return OMX_Sts_NoErr;        
    }

    /* Do fft in float */
    out = pFFTStruct->pBuf;

    /* bit reversal */    
    pRevIndex = pFFTStruct->pBitRev;
    for (i = 0; i < N; i++)
    {
        out [pRevIndex [i]].Re = (OMX_F64) pSrc [i]. Re;
        out [pRevIndex [i]].Im = (OMX_F64) -pSrc [i]. Im;
    }
    
    NBy2 = N >> 1;
    pT = &T;
    point = 2;
    for (block = NBy2; block > 0; block >>= 1)
    {
        pTw = pFFTStruct->pTwiddle;
        for (i = 0; i < point / 2; i++)
        {
            pT1 = out + i;
            pT2 = pT1 + (point / 2);
            for (j = 0; j < block; j++)
            {
                armSP_CPLX_MUL (pT, pTw, pT2);
                armSP_CPLX_SUB (pT2, pT1, pT);
                armSP_CPLX_ADD (pT1, pT1, pT);
                pT1 += point;
                pT2 += point;
            }
            pTw += block;
        }
        point <<= 1;
    }
    

    /* revert back from float */
    for (i = 0; i < N; i++)
    {
        out [i].Re /= (OMX_F64)(1LL << scaleFactor);
        out [i].Im /= (OMX_F64)(1LL << scaleFactor);
        out [i].Re /= N;
        out [i].Im /= N;
        pDst [i]. Re = armSatRoundFloatToS32 (out [i].Re);
        pDst [i]. Im = armSatRoundFloatToS32 (-out [i].Im);
    }
    
    return OMX_Sts_NoErr;
}

/*****************************************************************************
 *                              END OF FILE
 *****************************************************************************/