procedures.h

Go to the documentation of this file.

/*
    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

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

#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;}


//---------------------------------------------------------------------------
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
};

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);
};

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