/Users/richardeakin/projects/libsms/trunk/src/sms.h

Go to the documentation of this file.

/* 
 * Copyright (c) 2008 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 _SMS_H
#define _SMS_H

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <memory.h>
#include <strings.h>
#include <sndfile.h>

#define SMS_VERSION 1.1 
#define SMS_MAX_NPEAKS 400    
#ifdef DOUBLE_PRECISION
#define sfloat double
#else
#define sfloat float
#endif

typedef struct 
{
        int iSmsMagic;         
        int iHeadBSize;        
        int nFrames;             
        int iFrameBSize;      
        int iSamplingRate;     
        int iFormat;           
        int nTracks;     
        int iFrameRate;        
        int iStochasticType;   
        int nStochasticCoeff;  
        int iEnvType;            
        int nEnvCoeff;                
        int iMaxFreq;                  
/*      sfloat fAmplitude;      /\*!< average amplitude of represented sound.  *\/ */
/*      sfloat fFrequency;      /\*!< average fundamental frequency *\/ */
/*      int iBegSteadyState;   /\*!< record number of begining of steady state. *\/ */
/*      int iEndSteadyState;   /\*!< record number of end of steady state. *\/ */
        sfloat fResidualPerc;   
        int nTextCharacters;   
        char *pChTextCharacters; 
} SMS_Header;

typedef struct {
    int nSamples;       
    int iSamplingRate;   
    int channelCount;  
    int iReadChannel;  
    int sizeHeader;          
} SMS_SndHeader;

typedef struct 
{
        sfloat *pSmsData;        
        int sizeData;               
        sfloat *pFSinFreq;       
        sfloat *pFSinAmp;       
        sfloat *pFSinPha;        
        int nTracks;                     
        sfloat *pFStocGain;     
        int nCoeff;                  
        sfloat *pFStocCoeff;    
        sfloat *pResPhase;    
        int nEnvCoeff;             
        sfloat *pSpecEnv;
} SMS_Data;


typedef struct
{
        sfloat *pFBuffer;          
        int sizeBuffer;            
        int iMarker;               
        int iFirstGood;          
} SMS_SndBuffer;

/* information attached to a spectral peak */
typedef struct 
{
        sfloat fFreq;           
        sfloat fMag;           
        sfloat fPhase;        
} SMS_Peak;

typedef struct 
{
        int iFrameSample;         
        int iFrameSize;           
        int iFrameNum;            
        SMS_Peak *pSpectralPeaks;  
        int nPeaks;               
        sfloat fFundamental;       
        SMS_Data deterministic;   
        int iStatus; 
} SMS_AnalFrame;

typedef struct 
{
        sfloat fLowestFreq; 
        sfloat fHighestFreq; 
        sfloat fMinPeakMag; 
        int iSamplingRate; 
        int iMaxPeaks; 
        int nPeaksFound; 
        sfloat fHighestFundamental;
        int iRefHarmonic;   
        sfloat fMinRefHarmMag;     
        sfloat fRefHarmMagDiffFromMax; 
        int iSoundType;            
} SMS_PeakParams;

typedef struct 
{
        int iType; 
        int iOrder; 
        int iMaxFreq; 
        sfloat fLambda; 
        int nCoeff;    
        int iAnchor; 
} SMS_SEnvParams;



typedef struct 
{
        int iDebugMode; 
        int iFormat;          
        int iSoundType;            
        int iStochasticType;      
        int iFrameRate;        
        int nStochasticCoeff;  
        sfloat fLowestFundamental; 
        sfloat fHighestFundamental;
        sfloat fDefaultFundamental;
        sfloat fPeakContToGuide;   
        sfloat fFundContToGuide;   
        sfloat fFreqDeviation;     
        int iSamplingRate;        
        int iDefaultSizeWindow;   
        int sizeHop;              
        sfloat fSizeWindow;       
        int nTracks;                     
        int nGuides;              
        int iCleanTracks;           
        //int iEnvelope;           /*!< whether or not to compute spectral envelope */
        sfloat fMinRefHarmMag;     
        sfloat fRefHarmMagDiffFromMax; 
        int iRefHarmonic;              
        int iMinTrackLength;           
        int iMaxSleepingTime;      
        sfloat fHighestFreq;        
        sfloat fMinPeakMag;         
        int iAnalysisDirection;    
        int iSizeSound;             
        int nFrames;             
        int iWindowType;            
        int iMaxDelayFrames;     
        sfloat fResidualAccumPerc; 
        int sizeNextRead;     
        SMS_PeakParams peakParams; 
        SMS_Data prevFrame;   
        SMS_SEnvParams specEnvParams; 
        SMS_SndBuffer soundBuffer;    
        SMS_SndBuffer synthBuffer; 
        SMS_AnalFrame *pFrames;  
        SMS_AnalFrame **ppFrames; 
} SMS_AnalParams;

typedef struct
{
        int ready;  
        int maxFreq;  
        int doResGain;  
        sfloat resGain;  
        int doTranspose;  
        sfloat transpose;  
        int doSinEnv;  
        sfloat sinEnvInterp;  
        int sizeSinEnv;  
        sfloat *sinEnv;  
        int doResEnv;  
        sfloat resEnvInterp;  
        int sizeResEnv;  
        sfloat *resEnv;  
} SMS_ModifyParams;

typedef struct
{
        int iStochasticType;       
        int iSynthesisType;        
        int iDetSynthType;         
        int iOriginalSRate;  
        int iSamplingRate;         
        int sizeHop;                   
        int origSizeHop;            
        sfloat *pFDetWindow;    
        sfloat *pFStocWindow; 
        sfloat *pSynthBuff;  
        sfloat *pMagBuff;  
        sfloat *pPhaseBuff;  
        sfloat *pSpectra; 
        SMS_Data prevFrame; 
        SMS_ModifyParams modParams; 
} SMS_SynthParams;

typedef struct 
{
        sfloat fFreq;                   
        sfloat fMag;                   
        sfloat fMagPerc;           
        sfloat fFreqDev;            
        sfloat fHarmRatio;         
} SMS_HarmCandidate;

typedef struct
{
        sfloat fFreqDev;       
        sfloat fMagDev;        
        int iPeak;                
} SMS_ContCandidate;        

typedef struct
{
        sfloat fFreq;          
        sfloat fMag;           
        int iStatus;          
        int iPeakChosen;    
} SMS_Guide;

enum SMS_Format
{
        SMS_FORMAT_H, 
        SMS_FORMAT_IH,      
        SMS_FORMAT_HP,     
        SMS_FORMAT_IHP    
};

enum SMS_SynthType
{
        SMS_STYPE_ALL,      
        SMS_STYPE_DET,      
        SMS_STYPE_STOC    
};

enum SMS_DetSynthType
{
        SMS_DET_IFFT,        
        SMS_DET_SIN          
};

enum SMS_StocSynthType
{
        SMS_STOC_NONE,              
        SMS_STOC_APPROX,        
        SMS_STOC_IFFT               
};

enum SMS_SpecEnvType
{
        SMS_ENV_NONE,       
        SMS_ENV_CEP,          
        SMS_ENV_FBINS       
};


/* \todo remove me */
enum SMS_ERRORS
{
        SMS_OK,              
        SMS_NOPEN,       
        SMS_NSMS ,        
        SMS_MALLOC,    
        SMS_RDERR,        
        SMS_WRERR,       
        SMS_SNDERR        
};

enum SMS_DBG
{
        SMS_DBG_NONE,                    
        SMS_DBG_DET,                       
        SMS_DBG_PEAK_DET,                 
        SMS_DBG_HARM_DET,         
        SMS_DBG_PEAK_CONT,        
        SMS_DBG_CLEAN_TRAJ,       
        SMS_DBG_SINE_SYNTH,       
        SMS_DBG_STOC_ANAL,        
        SMS_DBG_STOC_SYNTH,      
        SMS_DBG_SMS_ANAL,          
        SMS_DBG_ALL,                       
        SMS_DBG_RESIDUAL,            
        SMS_DBG_SYNC,                    
 };

#define SMS_MAX_WINDOW 8190    
/* \brief type of sound to be analyzed
 *
 * \todo explain the differences between these two 
 */
enum SMS_SOUND_TYPE
{
        SMS_SOUND_TYPE_MELODY,    
        SMS_SOUND_TYPE_NOTE          
};

/* \brief direction of analysis
 *
 * Sometimes a signal can be clearer at the end than at
 * the beginning.  If the signal is very harmonic at the end then
 * doing the analysis in reverse could provide better results.
 */
enum SMS_DIRECTION
{
        SMS_DIR_FWD,           
        SMS_DIR_REV           
};

/* \brief window selection
 */
enum SMS_WINDOWS
{
        SMS_WIN_HAMMING,     
        SMS_WIN_BH_62,            
        SMS_WIN_BH_70,            
        SMS_WIN_BH_74,            
        SMS_WIN_BH_92,             
        SMS_WIN_HANNING,      
        SMS_WIN_IFFT              
};

/* re-analyze and clean tracks */

#define SMS_MIN_GOOD_FRAMES 3  
#define SMS_MAX_DEVIATION .01   
#define SMS_ANAL_DELAY     100 
#define SMS_DELAY_FRAMES (SMS_MIN_GOOD_FRAMES + SMS_ANAL_DELAY)

enum SMS_FRAME_STATUS 
{
        SMS_FRAME_EMPTY,
        SMS_FRAME_READY,
        SMS_FRAME_PEAKS_FOUND,
        SMS_FRAME_FUND_FOUND,
        SMS_FRAME_TRAJ_FOUND,
        SMS_FRAME_CLEANED, 
        SMS_FRAME_RECOMPUTED,
        SMS_FRAME_DETER_SYNTH,
        SMS_FRAME_STOC_COMPUTED, 
        SMS_FRAME_DONE,
        SMS_FRAME_END
};


#define SMS_MIN_SIZE_FRAME  128   /* size of synthesis frame */

#define PI 3.141592653589793238462643    
#define TWO_PI 6.28318530717958647692 
#define INV_TWO_PI (1 / TWO_PI) 
#define PI_2 1.57079632679489661923        
#define LOG2 0.69314718055994529 
#define LOG10 2.3025850929940459  
#define EXP 2.7182818284590451 
sfloat sms_magToDB(sfloat x); 
sfloat sms_dBToMag(sfloat x);
void sms_arrayMagToDB(int sizeArray, sfloat *pArray);
void sms_arrayDBToMag(int sizeArray, sfloat *pArray);
void sms_setMagThresh(sfloat x);
sfloat sms_rms ( int sizeArray, sfloat *pArray );
sfloat sms_sine (sfloat fTheta);
sfloat sms_sinc (sfloat fTheta);
sfloat sms_random ( void );
int sms_power2(int n);
//sfloat sms_temperedToFreq( float x ); /*!< raise frequency to the 12th root of 2 */
//inline sfloat sms_temperedToFreq( float x ){ return(powf(1.0594630943592953, x)); }

//#define TEMPERED_TO_FREQ( x ) (powf(1.0594630943592953, x)) /*!< raise frequency to the 12th root of 2 */
sfloat sms_scalarTempered( float x);
void sms_arrayScalarTempered( int sizeArray, sfloat *pArray);

#ifndef MAX

#define MAX(a,b)        ((a) > (b) ? (a) : (b))
#endif
#ifndef MIN

#define MIN(a,b)        ((a) < (b) ? (a) : (b))
#endif

/* function declarations */ 
int sms_analyze (int sizeWaveform, sfloat *pWaveform, SMS_Data *pSmsFrame,
                 SMS_AnalParams *pAnalParams);

void sms_analyzeFrame (int iCurrentFrame, SMS_AnalParams *pAnalParams, sfloat fRefFundamental );

int sms_init( void );  

void sms_free( void );  

int sms_initAnalysis (  SMS_AnalParams *pAnalParams, SMS_SndHeader *pSoundHeader);

void sms_initAnalParams (SMS_AnalParams *pAnalParams);

void sms_initSynthParams(SMS_SynthParams *synthParams);

int sms_initSynth( SMS_Header *pSmsHeader, SMS_SynthParams *pSynthParams );

int sms_changeSynthHop( SMS_SynthParams *pSynthParams, int sizeHop);

void sms_freeAnalysis (SMS_AnalParams *pAnalParams);

void sms_freeSynth( SMS_SynthParams *pSynthParams );

void sms_fillSoundBuffer (int sizeWaveform, sfloat *pWaveform,  SMS_AnalParams *pAnalParams);

void sms_windowCentered (int sizeWindow, sfloat *pWaveform, float *pWindow, int sizeFft, float *pFftBuffer);

void sms_getWindow (int sizeWindow, sfloat *pWindow, int iWindowType);

void sms_scaleWindow (int sizeWindow, sfloat *pWindow);

int sms_spectrum (int sizeWindow, sfloat *pWaveform, float *pWindow, int sizeMag, 
                  sfloat *pMag, float *pPhase);

int sms_invSpectrum (int sizeWaveform, sfloat *pWaveform, float *pWindow ,
                     int sizeMag, sfloat *pMag, float *pPhase);

/* \todo remove this once invSpectrum is completely implemented */
int sms_invQuickSpectrumW (sfloat *pFMagSpectrum, float *pFPhaseSpectrum, 
                           int sizeFft, sfloat *pFWaveform, int sizeWave,
                           sfloat *pFWindow);

int sms_spectralApprox (sfloat *pSpec1, int sizeSpec1, int sizeSpec1Used,
                    sfloat *pSpec2, int sizeSpec2, int nCoefficients);

int sms_spectrumMag (int sizeWindow, sfloat *pWaveform, float *pWindow,  
                     int sizeMag, sfloat *pMag);
                  
void sms_dCepstrum( int sizeCepstrum, sfloat *pCepstrum, int sizeFreq, float *pFreq, float *pMag, 
                    sfloat fLambda, int iSamplingRate);

void sms_dCepstrumEnvelope (int sizeCepstrum, sfloat *pCepstrum, int sizeEnv, float *pEnv);

void sms_spectralEnvelope ( SMS_Data *pSmsData, SMS_SEnvParams *pSpecEnvParams);

int sms_sizeNextWindow (int iCurrentFrame, SMS_AnalParams *pAnalParams);

sfloat sms_fundDeviation (SMS_AnalParams *pAnalParams, int iCurrentFrame);

int sms_detectPeaks (int sizeSpec, sfloat *pFMag, float *pPhase,
                     SMS_Peak *pSpectralPeaks, SMS_PeakParams *pPeakParams);

void sms_harmDetection (SMS_AnalFrame *pFrame, sfloat fRefFundamental,
                    SMS_PeakParams *pPeakParams);

int sms_peakContinuation (int iFrame, SMS_AnalParams *pAnalParams);

sfloat sms_preEmphasis (float fInput);

sfloat sms_deEmphasis (float fInput);

void sms_cleanTracks (int iCurrentFrame, SMS_AnalParams *pAnalParams);

void sms_scaleDet (sfloat *pSynthBuffer, float *pOriginalBuffer,
                         sfloat *pSinAmp, SMS_AnalParams *pAnalParams, int nTracks);
                        
int sms_prepSine (int nTableSize);

int sms_prepSinc (int nTableSize);

void sms_clearSine( void );

void sms_clearSinc( void );

void sms_synthesize (SMS_Data *pSmsFrame, sfloat*pSynthesis, 
                  SMS_SynthParams *pSynthParams);
                
void sms_sineSynthFrame (SMS_Data *pSmsFrame, sfloat *pBuffer, 
                    int sizeBuffer, SMS_Data *pLastFrame,
                    int iSamplingRate);

void sms_initHeader (SMS_Header *pSmsHeader);

int sms_getHeader (char *pChFileName, SMS_Header **ppSmsHeader,
                        FILE **ppInputFile);

void sms_fillHeader (SMS_Header *pSmsHeader, SMS_AnalParams *pAnalParams,
                     char *pProgramString);

int sms_writeHeader (char *pFileName, SMS_Header *pSmsHeader, 
                    FILE **ppOutSmsFile);

int sms_writeFile (FILE *pSmsFile, SMS_Header *pSmsHeader);

int sms_initFrame (int iCurrentFrame, SMS_AnalParams *pAnalParams, 
                      int sizeWindow);
                     
int sms_allocFrame (SMS_Data *pSmsFrame, int nTracks, int nCoeff, 
                    int iPhase, int stochType, int nEnvCoeff);

int sms_allocFrameH (SMS_Header *pSmsHeader, SMS_Data *pSmsFrame);

int sms_getFrame (FILE *pInputFile, SMS_Header *pSmsHeader, int iFrame,
                  SMS_Data *pSmsFrame);

int sms_writeFrame (FILE *pSmsFile, SMS_Header *pSmsHeader, 
                    SMS_Data *pSmsFrame);

void sms_freeFrame (SMS_Data *pSmsFrame);

void sms_clearFrame (SMS_Data *pSmsFrame);

void sms_copyFrame (SMS_Data *pCopySmsFrame, SMS_Data *pOriginalSmsFrame);

int sms_frameSizeB (SMS_Header *pSmsHeader);

int sms_residual ( int sizeWindow, sfloat *pSynthesis, float *pOriginal, float *pResidual, float *pWindow);

void sms_filterHighPass ( int sizeResidual, sfloat *pResidual, int iSamplingRate);

int sms_stocAnalysis ( int sizeWindow, sfloat *pResidual, float *pWindow,
                  SMS_Data *pSmsFrame);

void sms_interpolateFrames (SMS_Data *pSmsFrame1, SMS_Data *pSmsFrame2,
                           SMS_Data *pSmsFrameOut, sfloat fInterpFactor);

int sms_openSF (char *pChInputSoundFile, SMS_SndHeader *pSoundHeader);

void sms_closeSF();

int sms_getSound (SMS_SndHeader *pSoundHeader, long sizeSound, sfloat *pSound,
                  long offset);

int sms_createSF (char *pChOutputSoundFile, int iSamplingRate, int iType);

void sms_writeSound (sfloat *pBuffer, int sizeBuffer);

void sms_writeSF ( void );

void sms_fft(int sizeFft, sfloat *pArray);

void sms_ifft(int sizeFft, sfloat *pArray);

void sms_RectToPolar( int sizeSpec, sfloat *pReal, float *pMag, float *pPhase);

void sms_PolarToRect( int sizeSpec, sfloat *pReal, float *pMag, float *pPhase);

void sms_spectrumRMS( int sizeMag, sfloat *pReal, float *pMag);

void sms_initModify(SMS_Header *header, SMS_ModifyParams *params);

void sms_initModifyParams(SMS_ModifyParams *params);

void sms_freeModify(SMS_ModifyParams *params);

void sms_modify(SMS_Data *frame, SMS_ModifyParams *params);

/***********************************************************************************/
/************* debug functions: ******************************************************/
int sms_createResSF (int iSamplingRate);

int sms_writeResSound (sfloat *pBuffer, int sizeBuffer);

void sms_writeResSF ( void );

int sms_createDebugFile (SMS_AnalParams *pAnalParams);

void sms_writeDebugData (sfloat *pBuffer1, float *pBuffer2, 
                             sfloat *pBuffer3, int sizeBuffer);

void sms_writeDebugFile ( void );

void sms_error( char *pErrorMessage );

int sms_errorCheck( void );

char* sms_errorString( void );

/***********************************************************************************/
/************ things for hybrid program that are not currently used **********************/
/* (this is because they were utilized with the MusicKit package that is out of date now) */

/* /\*! \struct SMS_HybParams */
/*  * \brief structure for hybrid program  */
/*  *\/ */
/* typedef struct */
/* { */
/*   int nCoefficients; */
/*   sfloat fGain; */
/*   sfloat fMagBalance; */
/*   int iSmoothOrder; */
/*   sfloat *pCompressionEnv; */
/*   int sizeCompressionEnv; */
/* } SMS_HybParams; */

/* void sms_hybridize (sfloat *pFWaveform1, int sizeWave1, float *pFWaveform2,  */
/*                int sizeWave2, sfloat *pFWaveform, SMS_HybParams *pHybParams); */

/* void sms_filterArray (sfloat *pFArray, int size1, int size2, float *pFOutArray); */

#endif /* _SMS_H */

---