Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages

FEAPIExamplePluginLoudness/zplVecLibGen.cpp

Go to the documentation of this file.
00001 
00002 //     /*! \file zplVecLibGen.cpp: \brief implementation of the zplVecLib generic functions. */
00003 //
00004 //        Copyright (c) 2004-2006  
00005 //        zplane.development
00006 //        Flohrer Lerch Schwerdtfeger GbR
00007 //        All rights reserved.
00008 //
00009 //    This program is free software; you can redistribute it and/or modify
00010 //    it under the terms of the GNU General Public License as published by
00011 //    the Free Software Foundation; either version 2 of the License, or
00012 //    (at your option) any later version.
00013 //
00014 //    This program is distributed in the hope that it will be useful,
00015 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017 //    GNU General Public License for more details.
00018 //
00019 //    You should have received a copy of the GNU General Public License
00020 //    along with this program; if not, write to the Free Software
00021 //    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 //
00025 
00026 #include <stdlib.h>
00027 #include <string.h>
00028 #include <math.h>
00029 
00030 #include "zplVecLib.h"
00031 
00032 #ifndef ZABS
00033 #define ZABS(a)                 (((a) > (0)) ? (a) : -(a))
00034 #endif
00035 
00036 float*   zplfMalloc_Gen      (int       iNumOfFloats)
00037 {
00038     ZASSERT (iNumOfFloats <= 0);
00039     
00040     return ((float*) malloc (iNumOfFloats * sizeof(float)));
00041 }
00042 
00043 
00044 void       zplfFree_Gen        (float   *&ppfBuffer)
00045 {
00046     ZASSERT (&ppfBuffer == 0 || ppfBuffer == 0);
00047 
00048     free (ppfBuffer);
00049     ppfBuffer   = 0;
00050 
00051     return;
00052 }
00053 
00054 
00055 void       zplfSetZero_Gen     (float   *pfBuffer, int iLengthAsPowOf4)
00056 {
00057     ZASSERT (pfBuffer == 0);
00058     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00059 
00060     if (iLengthAsPowOf4 == 0)
00061         return;
00062 
00063     memset (pfBuffer, 0, sizeof (float) * iLengthAsPowOf4);
00064     return;
00065 }
00066 
00067 
00068 void       zplfRealFindMax_Gen   (float    *pfSrc, float    *pfMax, int    *piIdx, int    iLengthAsPowOf4)
00069 {
00070     ZASSERT (pfSrc == 0 || pfMax == 0 || piIdx == 0);
00071     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00072     
00073     *piIdx = 0;
00074     *pfMax  = -1e37F;
00075 
00076     for (int i = 0; i < iLengthAsPowOf4; i++)
00077     {
00078         if (pfSrc[i] >= *pfMax)
00079         {
00080             *pfMax  = pfSrc[i];
00081             *piIdx  = i;
00082         }
00083     }
00084     return;
00085 }
00086 
00087 void       zplfRealAdd_I_Gen   (float   *pfSrcDest, float    *pfSrc, int    iLengthAsPowOf4)
00088 {
00089     ZASSERT (pfSrc == 0 || pfSrcDest == 0);
00090     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00091 
00092     for (int i = 0; i < iLengthAsPowOf4; i++)
00093         pfSrcDest[i]   += pfSrc[i];
00094 
00095     return;
00096 }
00097 
00098 void       zplfRealAddC_I_Gen   (float   *pfSrcDest, float    fValue, int    iLengthAsPowOf4)
00099 {
00100     ZASSERT (pfSrcDest == 0);
00101     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00102 
00103     for (int i = 0; i < iLengthAsPowOf4; i++)
00104         pfSrcDest[i]   += fValue;
00105 
00106     return;
00107 }
00108 
00109 void       zplfRealSub_I_Gen   (float   *pfSrcDest, float    *pfSrc, int    iLengthAsPowOf4)
00110 {
00111     ZASSERT (pfSrc == 0 || pfSrcDest == 0);
00112     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00113 
00114     for (int i = 0; i < iLengthAsPowOf4; i++)
00115         pfSrcDest[i]   -= pfSrc[i];
00116 
00117     return;
00118 }
00119 
00120 
00121 void       zplfRealMul_I_Gen   (float   *pfSrcDest, float    *pfSrc, int    iLengthAsPowOf4)
00122 {
00123     ZASSERT (pfSrc == 0 || pfSrcDest == 0);
00124     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00125 
00126     for (int i = 0; i < iLengthAsPowOf4; i++)
00127         pfSrcDest[i]   *= pfSrc[i];
00128 
00129     return;
00130 }
00131 
00132 void       zplfRealMulC_I_Gen  (float   *pfSrcDest, float    fScaleFactor, int    iLengthAsPowOf4)
00133 {
00134     ZASSERT (pfSrcDest == 0);
00135     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00136 
00137     for (int i = 0; i < iLengthAsPowOf4; i++)
00138         pfSrcDest[i]   *= fScaleFactor;
00139 
00140     return;
00141 }
00142 
00143 void       zplfRealDiv_I_Gen   (float   *pfNomSrcDest, float    *pfDenomSrc, int    iLengthAsPowOf4)
00144 {
00145     ZASSERT (pfDenomSrc == 0 || pfNomSrcDest == 0);
00146     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00147 
00148     for (int i = 0; i < iLengthAsPowOf4; i++)
00149     {
00150         ZASSERT (pfDenomSrc[i] == 0);
00151         pfNomSrcDest[i]   /= pfDenomSrc[i];
00152     }
00153 
00154     return;
00155 }
00156 
00157 
00158 void       zplfRealMac_I_Gen   (float   *pfSrcDest, float    *pfSrc1, float   *pfSrc2, int   iLengthAsPowOf4)
00159 {
00160     ZASSERT (pfSrc1 == 0 || pfSrc2 == 0 || pfSrcDest == 0);
00161     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00162 
00163     for (int i = 0; i < iLengthAsPowOf4; i++)
00164         pfSrcDest[i]   += pfSrc1[i] * pfSrc2[i];
00165 
00166     return;
00167 }
00168 
00169 
00170 void       zplfRealAbs_I_Gen   (float   *pfSrcDest, int iLengthAsPowOf4)
00171 {
00172     ZASSERT (pfSrcDest == 0);
00173     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00174 
00175     for (int i = 0; i < iLengthAsPowOf4; i++)
00176         pfSrcDest[i]    = ZABS(pfSrcDest[i]);
00177 
00178     return;
00179 }
00180 
00181 
00182 float    zplfRealSum_Gen   (float   *pfSrc, int iLengthAsPowOf4)
00183 {
00184     float fResult = 0;
00185     ZASSERT (pfSrc == 0);
00186     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00187 
00188     for (int i = 0; i < iLengthAsPowOf4; i+=4)
00189     {
00190         fResult += pfSrc[i];
00191         fResult += pfSrc[i+1];
00192         fResult += pfSrc[i+2];
00193         fResult += pfSrc[i+3];
00194     }
00195     return fResult;
00196 }
00197 
00198 
00199 void       zplfCompAdd_I_Gen   (zCOMPLEX   *pfSrcDest, zCOMPLEX    *pfSrc,  int iRealLengthAsPowOf4)
00200 {
00201     zplfRealAdd_I (pfSrcDest, pfSrc, (iRealLengthAsPowOf4<<1));
00202 }
00203 
00204 
00205 void       zplfCompMul_I_Gen   (zCOMPLEX   *pfSrcDest, zCOMPLEX    *pfSrc,  int iRealLengthAsPowOf4)
00206 {
00207     ZASSERT (1); 
00208 }
00209 
00210 
00211 void       zplfCompDiv_I_Gen   (zCOMPLEX   *pfNomSrcDest, zCOMPLEX    *pfDenomSrc, int    iRealLengthAsPowOf4)
00212 {
00213     ZASSERT (1); 
00214 }
00215 
00216 
00217 void       zplfCompMac_I_Gen   (zCOMPLEX   *pfSrcDest, zCOMPLEX    *pfSrc1, float   *pfSrc2, int   iRealLengthAsPowOf4)
00218 {
00219     int    i,
00220             iDoubleNumOfSamples = (iRealLengthAsPowOf4<<1);
00221 
00222     ZASSERT (pfSrc1 == 0 || pfSrc2 == 0 || pfSrcDest == 0);
00223     ZASSERT ((iRealLengthAsPowOf4 < 0) || (iRealLengthAsPowOf4%4 != 0));
00224 
00225     pfSrcDest[0]                    += pfSrc1[0] * pfSrc2[0];
00226     pfSrcDest[iRealLengthAsPowOf4]  += pfSrc1[iRealLengthAsPowOf4] * pfSrc2[iRealLengthAsPowOf4];
00227 
00228     //Re
00229     for (i = 1; i < iRealLengthAsPowOf4; i++)
00230         pfSrcDest[i] += pfSrc1[i] * pfSrc2[i] - pfSrc1[iDoubleNumOfSamples-i] * pfSrc2[iDoubleNumOfSamples-i];
00231     //Im
00232     for (i = iRealLengthAsPowOf4+1; i < iDoubleNumOfSamples; i++)
00233         pfSrcDest[i] += pfSrc1[i] * pfSrc2[iDoubleNumOfSamples-i] + pfSrc1[iDoubleNumOfSamples-i] * pfSrc2[i];
00234 
00235     return;
00236 }
00237 
00238 
00239 void       zplfCompAbs_Gen     (float   *pfDest,    zCOMPLEX    *pfSrc1, int iRealLengthAsPowOf4)
00240 {
00241     int    i;
00242 
00243     float  *pfImagData = pfSrc1 + iRealLengthAsPowOf4;
00244 
00245     ZASSERT (pfSrc1 == 0 || pfDest == 0);
00246     ZASSERT ((iRealLengthAsPowOf4 < 0) || (iRealLengthAsPowOf4%4 != 0));
00247 
00248     pfDest[0] = ZABS (pfSrc1[0]);
00249         
00250     for (i = 1; i < iRealLengthAsPowOf4; i++)
00251         pfDest[i]       = sqrtf (pfSrc1[i] * pfSrc1[i] + pfImagData[iRealLengthAsPowOf4-i] * pfImagData[iRealLengthAsPowOf4-i]);
00252 
00253     return;
00254 }
00255 
00256 
00257 int zplfZeroCrossings_Gen (float *pfSrc, int iLengthAsPowOf4)
00258 {
00259     ZASSERT (pfSrc == 0);
00260     ZASSERT ((iLengthAsPowOf4 < 0) || (iLengthAsPowOf4%4 != 0));
00261 
00262     int iResult = 0;
00263     for (int i = 1; i < iLengthAsPowOf4; i++)
00264     {
00265         if (pfSrc[i] * pfSrc[i-1] < 0)
00266             iResult++;
00267     }
00268     return iResult;
00269 }

Generated on Fri Mar 23 10:28:54 2007 for FEAPI Plugin Documentation by  doxygen 1.3.9.1