CL/CL_PitchDetect.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Alexander
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        CL_PitchDetect.h ( Clip Library, C++)
 *
 * COMMENTS:
 *      
 *      Detects the most dominant frequency in an audio sample
 *
 */

#ifndef __CL_PitchDetect__
#define __CL_PitchDetect__

#include "CL_API.h"
#include <UT/UT_RefArray.h>
#include "CL_SlidingWindow.h"

class UT_FFT;
class cl_PitchNode;

class CL_API CL_PitchDetect : public CL_SlidingWindow
{
public:

                 CL_PitchDetect(int size, float freqres);
    virtual     ~CL_PitchDetect();

            void        setPitchMode(int multi);

            void        setMultiParms(float start, float end, int divs,
                                      int log, float *results);

            void        setBandwidth(float low, float high);
            void        setMinLevel(float min);
            void        setFloatingBandwidth(int on, float bandwidth);
            void        setHarmonicCompensation(int on, int correct,float error);
            void        setSmoothJumps(int on, float minjump);
            void        setFrequencyHint(int on, float hint, float bandwidth);

            void        getPitchResult(float &pitch, float &volume);
            float      *getPitchResult();
    
    virtual void        reset(float val=0.0F);
    virtual int         maxFilterSamples();

            void        clearSamples(int from);
private:

    // override this function to do the operation you want
    virtual void        doWindowOp(int nsamples,float *dest);

    void        selectBand();
    void        selectMultipleBands();
    void        detectHarmonics();
    void        designFilter(int size);

    void        setupPitch();
    void        cleanupPitch();
    
protected:

    float       myMinLevel;
    float       myFreqRes;
    
    
    float       myLowFreq;
    float       myHighFreq;
    
    int         myFloatingBandwidthOn;
    float       myFloatingBandwidth;
    
    int         myHarmonicCompensation;
    float       myHarmonicError;
    int         myHarmonicCorrect;
        
    int         mySmoothJumps;
    float       myMinJumpLevel;
    
    int         myUseHint;
    float       myFrequencyHint;
    float       myHintBandwidth;

    float       myLastFreq;
    float       myPitchFreq;
    float       myPitchVolume;

    int         myMode;
    int         myLogMode;
    int         myDivisions;
    float       *myMultiResults;
    
    float       *myWindow;
    float       *myData;
    float       *myReal;
    float       *myImag;
    float       *myKernel;
    float       *myFiltered;
    int          myKernelSize;
    UT_FFT      *myTransform;

    UT_RefArray<cl_PitchNode>   myHarmonics;
};

class CL_API cl_PitchNode
{
public:

    cl_PitchNode()
        { myFrequency = mySingleMag = myMag = 0.0F; myNextHarmonic = 0;
         myPrevHarmonic = 0; myAmAHarmonic = 0; }
    
    cl_PitchNode(float freq, float mag)
        { myFrequency = freq; mySingleMag = myMag = mag; myNextHarmonic = 0;
          myAmAHarmonic = 0; myPrevHarmonic = 0; }

    cl_PitchNode & operator=(const cl_PitchNode &);
    int           operator==(const cl_PitchNode &);
        
    float         myFrequency;
    float         myMag;
    float         mySingleMag;
    cl_PitchNode *myNextHarmonic;
    cl_PitchNode *myPrevHarmonic;
    int           myAmAHarmonic;
};

#endif

---