#include <stdio.h>
#include <ipps.h>

//void
//test_fir(
//  unsigned D,
//  unsigned M,
//  unsigned N)
//{
//     IppStatus status;
//     Ipp64f pSrc[N];
//     Ipp64f pDst[N+M-1];
//     Ipp64f pDst_f[N+M-1];
//     Ipp64f pTaps[M]; 
//     Ipp64f pDlyLine[2*M];
//     int pDlyLineIndex = M-1; 
//     for (int i=0; i< N;i++)
//	pSrc[i]= (float) i;
//     for (int j=0; j<M;j++)
//	pTaps[j] = 0.0f;
//     pTaps[M/2 -1] = 1.0f;
//     for (int j=0; j< 2*M; j++)
//         pDlyLine[j]=0.0f;
//
//     printf("Calling IPP fir function \r\n");
//     status = ippsFIR_Direct_64f(pSrc, pDst_f, N+M-1, pTaps,M, pDlyLine,&pDlyLineIndex);    
//     //status = ippsFIR_Direct_32f(pSrc, pDst, N, pTaps,M, pDlyLine,&pDlyLineIndex);    
//     if (status != ippStsNoErr)
//	printf("Error in IPP FIR Call %d \r\n",status);
//     else
//	printf("Succesful FIR Call %d \r\n",status);
//
//     status = ippsConv_64f(pSrc, N, pTaps, M, pDst);
//
//     if (status != ippStsNoErr)
//	printf("Error in IPP Convolution Call %d \r\n",status);
//     else
//	printf("Succesful convolution Call %d \r\n",status);
//
//    for (int k=0; k<N+M-1;k++)
//    {
//	if (pDst[k] != pDst_f[k])
//	  printf("Conv and FIR output not same at index %d C:%3.6f F:%3.6f\r\n",k,pDst[k],pDst_f[k]); 
//    }
//}
//  
//int
//main(int argc, char** argv)
//{
//
//  printf("***Starting FIR IPP tests **** \r\n");
//
//  test_fir(1,7,11);
//  test_fir(1,32,1024);
//
//  printf("***Ending FIR IPP tests ****\r\n");
//  return 0;
//}

void main( void )
{
	const int N = 7;
	const int M = 11;

	Ipp32f pSrc[N];
	Ipp32f pDstC[N+M-1];
	Ipp32f pDstF[N+M-1];
	Ipp32f pTaps[M];
	Ipp32f pDlyLine[2*M];

	int iDlyLineIndex;
	int iTapsPos;

	int i;
	int j;
	int k;

	IppStatus st = ippStsNoErr;

	// Initialization
	for( i = 0; i < N; i++ )
		pSrc[i]= ( float )i;

	for( j = 0; j < ( N+M-1 ); j++ )
	{
		pDstC[j] = 0.0f;
		pDstF[j] = 0.0f;
	}

	for( j = 0; j < M; j++ )
		pTaps[j] = 0.0f;

	for( j = 0; j < ( 2*M ); j++ )
		pDlyLine[j] = 0.0f;

	iTapsPos = 0;
	printf( "Taps Position: %ld\n\n", iTapsPos );

	pTaps[ iTapsPos ] = 1.0f;
	iDlyLineIndex = 0;

	// Processing with [ ippsConv_32f       ]
	printf( "Calling IPP [ ippsConv_32f       ] function\n" );
	st = ::ippsConv_32f( pSrc, N, pTaps, M, pDstC );
	if( st == ippStsNoErr )
		printf( "Succesful: Status = %ld\n", ( int )st );
	else
		printf( "Error    : Status = %ld\n", ( int )st );

	// Processing with [ ippsFIR_Direct_32f ]
//	[ ippsFIR_Direct_32f ]		[ ippsFIR_Direct_64f ]			Directly filters a block of samples through a single-rate
//																FIR filter
//		const Ipp32f* pSrc			const Ipp64f* pSrc			- pointer to the input array
//		Ipp32f* pDst				Ipp64f* pDst				- pointer to the output array
//		int numIters				int numIters				- number of samples in the input array
//		const Ipp32f* pTaps			const Ipp64f* pTaps			- pointer to the array containing the taps values,
//																  the number of elements in the array is tapsLen
//		int tapsLen					int tapsLen					- number of elements in the array containing the taps values
//		Ipp32f* pDlyLine			Ipp64f* pDlyLine			- pointer to the array containing the delay line values
//																  the number of elements in the array is 2*tapsLen
//		int* pDlyLineIndex			int* pDlyLineIndex			- pointer to the current delay line index

	printf( "Calling IPP [ ippsFIR_Direct_32f ] function\n" );
	st = ::ippsFIR_Direct_32f( pSrc, pDstF, N+iTapsPos, pTaps, M, pDlyLine, &iDlyLineIndex );
	if( st == ippStsNoErr )
		printf( "Succesful: Status = %ld\n", ( int )st );
	else
		printf( "Error    : Status = %ld\n", ( int )st );

	// Verifications
	printf( "\n" );
	printf( "Displaying Convolution and FIR results:\n" );
	for( k = 0; k < ( N+M-1 ); k++ )
	{
			printf( "\tIndex %4ld [ CONV = %f           FIR = %f ] DIFF = %.24f\n",
					( int )k, pDstC[k], pDstF[k], ( pDstC[k] - pDstF[k] ) );
	}

	printf( "\n" );
	printf( "Comparison of Convolution and FIR results:\n" );
	for( k = 0; k < ( N+M-1 ); k++ )
	{
		// Regular Verification
//		if( pDstC[k] != pDstF[k] )
//			printf( "\tIndex %4ld [ CONV = %f Not Equal FIR = %f ] DIFF = %.24f\n",
//					( int )k, pDstC[k], pDstF[k], ( pDstC[k] - pDstF[k] ) );

		// Verification if a difference is greater than an Eplsilon for
		// the Single-Precision Floating-Point type
		if( fabs( pDstC[k] - pDstF[k] ) > IPP_EPS23 )
			printf( "\tIndex %4ld [ CONV = %f Not Equal FIR = %f ] DIFF = %.24f\n",
					( int )k, pDstC[k], pDstF[k], ( pDstC[k] - pDstF[k] ) );
	}
}