annotate procedures.h @ 13:de3961f74f30 tip

Add Linux/gcc Makefile; build fix

/*
    Harmonic sinusoidal modelling and tools

    C++ code package for harmonic sinusoidal modelling and relevant signal processing.
    Centre for Digital Music, Queen Mary, University of London.
    This file copyright 2011 Wen Xue.

    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.
*/
#ifndef proceduresH
#define proceduresH

/**
  \file procedures.h - this file collects miscellaneous structures and functions. Not all of these are
  referenced somewhere else.
*/


//---------------------------------------------------------------------------
#include <memory.h>
#include <stdlib.h>
#include <values.h>
#include "fft.h"
#include "windowfunctions.h"

/**
  macro testnn: non-negative test. This macro throws out an exception if the value of x is negative.
*/
#ifndef testnn
#define testnn(x) {try{if (x<0) throw("testnn");}catch(...){x=0;}}
#endif

/*
  macro AllocateGMM and ReleaseGMM: allocates and frees buffers that hosts descriptors of a Gaussian-
  mixture model.
*/
#define AllocateGMM(_MIXS, _DIM, _P, _M, _DEV) \
  double* _P=new double[_MIXS]; double** _M=new double*[_MIXS]; double ** _DEV=new double*[_MIXS]; \
  _M[0]=new double[(_MIXS)*(_DIM)]; _DEV[0]=new double[(_MIXS)*(_DIM)]; \
  for (int _MIX=1; _MIX<_MIXS; _MIX++) _M[_MIX]=&_M[0][_MIX*(_DIM)], _DEV[_MIX]=&_DEV[0][_MIX*(_DIM)];
#define ReleaseGMM(_P, _M, _DEV) \
  delete[] _P; if (_M) {delete[] _M[0]; delete[] _M;} if (_DEV) {delete[] _DEV[0]; delete[] _DEV;}


//---------------------------------------------------------------------------
/**
  Tick count tool (stop watch) is made up of a TickClock struct and three macros that uses this
  structure as augument.

  Use of TickClock: declare the instance directly. Use StartClock() and StopClock() to start and stop
  tick counting. Each time the clock is stopped the interval between last start and stop operations is
  added to run-time t. Clear the recorded run-time with ResetClock().
*/
struct TickClock  //tick counter struct
{
  double t;       //accumulated run time
  __int64 Ticks;  //tick count recorded at start trigger
  __int64 Ticks2; //tick count recorded at stop trigger
};
#define ResetClock(AClock) {AClock.t=0;}
#define StartClock(AClock) {AClock.Ticks=GetTickCount();}
#define StopClock(AClock) {AClock.Ticks2=GetTickCount(); AClock.t+=0.001*(AClock.Ticks2-AClock.Ticks);}

//---------------------------------------------------------------------------

struct fftparams  //buffers used by FFT routines
{
  double* Amp;    //amplitude output buffer
  double* Arg;    //phase angle output buffer
  cdouble* w;     //twiddle factor buffer
  cdouble* x;     //data buffer
};

struct TGMM        //Gaussian mixture model
{
public:
  bool mcs;
  int mixs;       //number of mixtures
  int dim;        //data dimension
  double* p;      //mixture weights
  double** m;     //mixture component centres
  double** dev;   //diagonal mixture component correlation
  double acct;
  TGMM();
  ~TGMM();
};

struct TTFSpan  //a rectanguar area in the T-F plane
{
  int T1;       //start time
  int T2;       //finish time
  double F1;    //lowest frequency
  double F2;    //highest frequency
};

struct TSpecPeak  //spectral peak
{
  int t;          //time in samples
  int tres;       //time resolution
  double f;       //digital frequency
  double fres;    //frequency resolution
  double df;      //derivative of f
  double am;      //amplitude
  double ph;      //phase angle
};

/**
  TSpecTrack is a class that maintains a list of TSpecPeak objects that form a spectral track. It models
  a sinusid track in sinusoid modeling.
*/
class TSpecTrack
{
private:
  int Capacity;     //number of peaks the current storage space is allocated to host
public:
  int t1;           //time of first peak
  int t2;           //time of last peak
  double fmin;      //minimum peak frequency
  double fmax;      //maximum peak frequency

  int Count;        //number of peaks in the track
  TSpecPeak* Peaks; //peaks in the track, ordered by time

  TSpecTrack(int ACapacity=50);
  ~TSpecTrack();

  void InsertPeak(TSpecPeak& APeak, int index);
  int LocatePeak(TSpecPeak& APeak);
  int Add(TSpecPeak& APeak);
};

/**
  TTFSpans is a class that maintains a list of TFSpans. This is used to mark selected areas in the time-
  frequency plane for further processing.
*/
class TTFSpans
{
public:
  int Count;      //number of spans
  int Capacity;   //number of spans the current storage space is allocated to host
  TTFSpan* Items; //the hosted spans

  TTFSpans();
  ~TTFSpans();
  void Add(TTFSpan& ATFSpan);
  void Clear();
  int Delete(int Index);
};

double ACPower(double* data, int Count, void*);
void Add(double* dest, double* source, int Count);
void Add(double* out, double* addend, double* adder, int count);
void ApplyWindow(double* OutBuffer, double* Buffer, double* Weights, int Size);
double Avg(double*, int, void*);
void AvgFilter(double* dataout, double* data, int Count, int HWid);
int BitInv(int value, int order);
void CalculateSpectrogram(double* data, int Count, int start, int end, int Wid, int Offst, double* Window=0, double** Spec=0, double** Ph=0, double amp=1, bool half=true);
void Conv(double* out, int N1, double* in1, int N2, double* in2);
void DCT( double* output, double* input, int N);
void IDCT( double* output, double* input, int N);
double DCAmplitude(double*, int, void*);
double DCPower(double*, int, void*);
double ddIPHann(double, void*);
void DeDC(double* data, int Count, int HWid);
void DeDC_static(double* data, int Count);
void DoubleToInt(void* out, int BytesPerSample, double* in, int Count);
void DoubleToIntAdd(void* out, int BytesPerSample, double* in, int Count);
double DPower(double* data, int Count, void*);
double Energy(double* data, int Count);
double ExpOnsetFilter(double* dataout, double* data, int Count, double Tr, double Ta);
double ExpOnsetFilter_balanced(double* dataout, double* data, int Count, double Tr, double Ta, int bal=5);
double ExtractLinearComponent(double* dataout, double* data, int Count);
void FFTConv(double* dest, double* source1, int size1, double* source2, int size2, int zero=0, double* pre_buffer=NULL, double* post_buffer=NULL);
void FFTConv(unsigned char* dest, unsigned char* source1, int bps, int size1, double* source2, int size2, int zero=0, unsigned char* pre_buffer=NULL, unsigned char* post_buffer=NULL);
void FFTConv(double* dest, double* source1, int size1, double* source2, int size2, double* pre_buffer=NULL);
void FFTFilter(double* dataout, double* data, int Count, int Wid, int On, int Off);
void FFTFilterOLA(double* dataout, double* data, int Count, int Wid, int On, int Off, double* pre_buffer=NULL);
void FFTFilterOLA(unsigned char* dataout, unsigned char* data, int BytesPerSample, int Count, int Wid, int On, int Off, unsigned char* pre_buffer=NULL);
void FFTFilterOLA(double* dataout, double* data, int Count, double* amp, double* ph, int Wid, double* pre_buffer=NULL);
double FFTMask(double* dataout, double* data, int Count, int Wid, double DigiOn, double DigiOff, double maskcoef=1);
int FindInc(double value, double* data, int Count);
double Gaussian(int Dim, double* Vector, double* Mean, double* Dev, bool StartFrom1);
void HalfDCT(double* data, int Count, double* CC, int order);
double Hamming(double f, double T);
double Hann(double x, double N);
double HannSq(double x, double N);
int HxPeak2(double*& hps, double*& vhps, double (*F)(double, void*), double (*dF)(double, void*), double(*ddF)(double, void*), void* params, double st, double en, double epf=1e-6);
double I0(double x);
int InsertDec(double value, double* data, int Count);
int InsertDec(int value, int* data, int Count);
int InsertDec(double value, int index, double* data, int* indices, int Count);
int InsertInc(void* value, void** data, int Count, int (*Compare)(void*, void*));
int InsertInc(double value, double* data, int Count, bool doinsert=true);
int InsertInc(double value, int index, double* data, int* indices, int Count);
int InsertInc(double value, double index, double* data, double* indices, int Count);
int InsertInc(double value, int* data, int Count, bool doinsert=true);
int InsertIncApp(double value, double* data, int Count);
double InstantFreq(int k, int hwid, cdouble* x, int mode=1);
void InstantFreq(double* freqspec, int hwid, cdouble* x, int mode=1);
void IntToDouble(double* out, void* in, int BytesPerSample, int Count);
double IPHannC(double f, cdouble* x, int N, int K1, int K2);
double IPHannC(double f, void* params);
double IPHannCP(double f, void* params);
void lse(double* x, double* y, int Count, double& a, double& b);
void memdoubleadd(double* dest, double* source, int count);
void MFCC(int FrameWidth, int NumBands, int Ceps_Order, double* Data, double* Bands, double* C, double* Amps, cdouble* W, cdouble* X);
double* MFCCPrepareBands(int NumberOfBands, int SamplesPerSec, int NumberOfBins);
void Multi(double* data, int count, double mul);
void Multi(double* out, double* in, int count, double mul);
void MultiAdd(double* out, double* in, double* adder, int count, double mul);
int NearestPeak(double* data, int count, int anindex);
double NegativeExp(double* x, double* y, int Count, double& lmd, int sample=1, double step=0.05, double eps=1e-6, int maxiter=50);
double NL(double* data, int Count, int Wid);
double Normalize(double* data, int Count, double Maxi=1);
double Normalize2(double* data, int Count, double Norm=1);
double nextdouble(double x, double dir);
double PhaseSpan(double* data, int Count, void*);
void PolyFit(int P, double* a, int N, double* x, double* y);
void Pow(double* data, int Count, double ex);
//int prevcand(candid** cands, int p, int n, int ap);
int Rectify(double* data, int Count, double th=0);
double Res(double in, double mod);
double Romberg(int n, double(*f)(double, void*), double a, double b, void* params=0);
double Romberg(double(*f)(double, void*), double a, double b, void* params=0, int maxiter=50, double ep=1e-6);
double sinca(double x);
double sincd_unn(double x, int N);
double SmoothPhase(double* Arg, int Count, int mpi=2);
//int SortCandid(candid cand, candid* cands, int newN);
double StiffB(double f0, double fm, int m);
double StiffFm(double f0, int m, double B);
double StiffF0(double fm, int m, double B);
double StiffM(double f0, double fm, double B);
void TFFilter(double* data, double* dataout, int Count, int Wid, TTFSpans* Spans, bool Pass, WindowType wt, double windp, int Sps, int TOffst=0);
void TFFilter(void* data, void* dataout, int BytesPerSample, int Count, int Wid, TTFSpans* Spans, bool Pass, WindowType wt, double windp, int Sps, int TOffst);
void TFMask(double* data, double* dataout, int Count, int Wid, TTFSpans* Spans, double masklevel, WindowType wt, double windp, int Sps, int TOffst);
void TFMask(void* data, void* dataout, int BytesPerSec, int Count, int Wid, TTFSpans* Spans, double masklevel, WindowType wt, double windp, int Sps, int TOffst);

#endif