quickspec.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 QuickSpecH
#define QuickSpecH

/*
  \file quickspec.h - TQuickSpectrogram class

  TQuickSpectrogram implements a compute-on-request spectrogram class. Every time one frame of the
  spectrogram is read from this class, it checks if the single-frame spectrogram has been computed
  already, computes it if not, and return the pointer to the spectrum.

  Further reading: "A buffering technique for real-time spectrogram displaying.pdf"
*/


#include <cstddef>
#include <stdlib.h>
#include "xcomplex.h"
#include "windowfunctions.h"
#include "fft.h"
//---------------------------------------------------------------------------

#define QSPEC_FORMAT float  //default spectral data format
#define QSpec_BufferSize 1024 //default initial buffer size, in frames, of TQuickSpectrogram


#ifndef INT24
#define INT24
struct __int24;
struct __pint24
{
  char* p;
  __fastcall __pint24(){}
  __fastcall __pint24(const void* ap){p=(char*)ap;}
  __pint24& __fastcall operator=(const void* ap){p=(char*)ap; return *this;}
  __int24& __fastcall operator*(){return *(__int24*)p;}
  __int24& __fastcall operator[](int index){return *(__int24*)&p[3*index];}
  __pint24 __fastcall operator++(int){__pint24 result=*this; p+=3; return result;}
  __pint24& __fastcall operator++(){p+=3; return *this;}
  __pint24 __fastcall operator--(int){__pint24 result=*this; p-=3; return result;}
  __pint24& __fastcall operator--(){p-=3; return *this;}
  __pint24& __fastcall operator+=(int a){p+=3*a; return *this;}
  __pint24& __fastcall operator-=(int a){p-=3*a; return *this;}
  __fastcall operator void*() const{return p;}
};
struct __int24
{
  __int16 loword;
  __int8 hibyte;
  __fastcall __int24(){}
  __fastcall __int24(const __int32 a){loword=*(__int16*)&a; hibyte=((__int16*)&a)[1];}
  __fastcall __int24(const double f){__int32 a=f; loword=*(__int16*)&a; hibyte=((__int16*)&a)[1];}
  __int24& __fastcall operator=(const __int32 a){loword=*(__int16*)&a; hibyte=((__int16*)&a)[1]; return *this;}
  __int24& __fastcall operator=(const double f){__int32 a=f; loword=*(__int16*)&a; hibyte=((__int16*)&a)[1]; return *this;}
  __fastcall operator __int32() const{__int32 result; *(__int16*)&result=loword; ((__int16*)&result)[1]=hibyte; return result;}
  __pint24 operator &(){return (__pint24)this;}
  void* operator new[](size_t count){void* result=malloc(3*count); return result;}
  void operator delete[](void* p){free(p);}
};
#endif


typedef void (*GetBuf)(int Id, cdouble* &w, cdouble* &x, double* &win, int* &hbi, void* Parent);
class TQuickSpectrogram
{
  int BufferCount;  
  int BufferSize;   
  int FrCount;      

  //internal storage of spectrogram
  QSPEC_FORMAT** fPh; 
  QSPEC_FORMAT** fA;  
  cmplx<QSPEC_FORMAT>** fSpec; 

  //internal buffers (optional) for FFT
  WindowType fwt; 
  int fWid;       
  int* fhbi;      
  double fwdp;    
  double* fwin;   
  cdouble* fw;    
  cdouble* fx;    

  //x and ph create-time switch
  bool usex;  
  bool useph; 

  //internal methods
  void AddBuffer();
  void AddBuffer(int AddFrCount);
  void __fastcall CalculateSpectrum(int fr);

public:
  //if specified, Parent is responsible to supply FFT buffers through GetFFTBuffers (optional)
  int Id;               
  void* Parent;         
  GetBuf GetFFTBuffers; 

  //index and validity arrays associated with internal storage
  int Capacity; 
  int* Frame;   
  int* Valid;   

  WindowType WinType; 
  double WinParam;    

  void* Data;         
  int DataLength;     
  int BytesPerSample; 

  int Offst;  
  int Wid;    

  __fastcall TQuickSpectrogram(void* AParent, int AnId, bool Ausex, bool Auseph, GetBuf G);
  __fastcall ~TQuickSpectrogram();

  QSPEC_FORMAT* __fastcall A(int fr);           
  void FreeBuffers();                           
  int Invalidate(int From, int To);             
  QSPEC_FORMAT* __fastcall Ph(int fr);          
  void SetFrCapacity(int AnFrCapacity);
  cmplx<QSPEC_FORMAT>* __fastcall Spec(int fr); 
};
#endif