/usr/include/CLAM/FFT_base.hxx is in libclam-dev 1.4.0-5.2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | /*
* Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
* UNIVERSITAT POMPEU FABRA
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _FFT_base_
#define _FFT_base_
#include <typeinfo> // for bad_cast definition
#include "Processing.hxx"
#include "AudioInPort.hxx"
#include "OutPort.hxx"
#include <string>
#include "FFTConfig.hxx"
#include "SpecTypeFlags.hxx"
#include "Spectrum.hxx"
namespace CLAM {
class Storage;
class ProcessingConfig;
class Audio;
class Spectrum;
/** Abstract base class for FFT classes */
class FFT_base: public Processing
{
protected:
/** Auxiliary flags structure, used to add the complex attribute. */
static SpecTypeFlags mComplexflags;
/** Auxiliary spectrum used if output spectrum does not have complex array */
Spectrum mComplexSpectrum;
/** FFT Configuration */
FFTConfig mConfig;
/** FFT size */
int mSize;
/* FFT possible execution states.
*/
typedef enum {
sComplex, // We just need to write the complex array.
sComplexSync, // We write the complex array and synchronize.
sOther // The complex array is not present.
} FFTState;
/** I/O Prototype state of the FFT object. */
FFTState mState;
/** When the object enters "Disabled" mode, it stores the
* previoius state here. It would have been easier to use a
* single state variable, and a "Disabled" flag outside of the
* state, but this way we can implement Do()s with a single
* switch level, which is slightly faster.
*/
FFTState mBackupState;
AudioInPort mInput;
OutPort<Spectrum> mOutput;
/** Internal output buffer */
TData* fftbuffer;
// Control change callback function
void ChangeSize(int n);
int GetSize() {return mSize;}
virtual bool ConcreteConfigure(const ProcessingConfig&) = 0;
public:
FFT_base();
virtual ~FFT_base();
/** Configuration access:
*/
const ProcessingConfig &GetConfig() const { return mConfig;}
/** Supervised-mode Do function.
*/
virtual bool Do(void) = 0;
/** Standard FFT Do function, with storage class references as
* arguments. This method implements the old conversor routines.
* The resulting spectrum will be of input audio size / 2 + 1.
* Input audio must be a power-of-two.
*/
virtual bool Do(const Audio& in, Spectrum &out)= 0;
// Input/Output configuration methods
/** FFT non-supervised mode SetPrototypes function */
bool SetPrototypes(const Audio& in,const Spectrum &out);
/** Standard supervised-mode SetPrototypes function. */
bool SetPrototypes() {return false;}
/** Standard UnsetPrototypes function. */
bool UnsetPrototypes();
void CheckTypes(const Audio& in, const Spectrum &out) const;
// Enable/Disable methods. Maybe we should not be deriving
// these ones in FFT subclasses. (FFT implementations will
// probably be always memoryless.
virtual bool MayDisableExecution() const {return false;}
virtual bool DisableExecution() {return false;}
virtual bool EnableExecution() {return false;}
// Output conversions
virtual void ToComplex(Spectrum &out) = 0;
virtual void ToOther(Spectrum &out);
};
};//namespace CLAM
#endif // _FFT_base_
|