Binaural.h

Go to the documentation of this file.

/*
 *  Binaural.h
 *  CSL
 *
 *  Created by Jorge Castellanos on 7/19/06.
 *  Copyright 2006 Jorge Castellanos. All rights reserved.
 *
 */


#ifndef CSL_BINAURAL_H
#define CSL_BINAURAL_H

#include "CSL_Core.h"
#include "Panner.h"
#include <fftw3.h>
#include <sndfile.h>                // libsndfile header file

namespace csl {

class BinauralSourceCache;

class BinauralPanner : public Panner {
friend class BinauralSourceCache; 
public:
    BinauralPanner ();
    ~BinauralPanner ();

    virtual void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);

protected:

    virtual void *cache();      

    unsigned numFFTBlocks;      
    unsigned mFramesPerBlock;       
    unsigned mCurrentBlockIdx;

    float mInvFramesPerBlock;  
    
    sample *mTempInBuffer;
    sample *mInverseFFTOutL;    
    sample *mInverseFFTOutR;    
            
    fftwf_complex *mHOutL, *mHOutR; 
    fftwf_plan mInversePlanL, mInversePlanR;
    
};

class BinauralSourceCache {
public:
    BinauralSourceCache(BinauralPanner *parent);
    ~BinauralSourceCache();
        
    sample *mPrevOutL;          
    sample *mPrevOutR;          
    fftwf_complex **h_in;
    fftwf_plan *mFFTPlans;
    unsigned *mCurrentHRTF;  // The current block of the "split" hrtf
    unsigned mNumBlocks;
};


class HRTF {
public:
    HRTF(unsigned hrtfLength, unsigned numBlocks, float theta = 0.f, float phi = 0.f);
    ~HRTF();
    
    void dump(); 
    
    CPoint mPosition;       
    fftwf_complex **mHrtfL, **mHrtfR; 
    
};


class HRTFDatabase {
public:
    ~HRTFDatabase() {};
    static HRTFDatabase* Database();
    static void Destroy();
    
    unsigned numHRTFs() { return mHRTFVector.size(); }; 
    unsigned windowSize() { return mWindowSize; }; 
    unsigned hrtfLength() { return mHRTFLength; }; 
    unsigned hrirLength() { return mHRIRLength; }; 
    
    HRTF *hrtfAtIndex(unsigned index) { return mHRTFVector[index]; };
    
    void dump(); 
    
protected:
    HRTFDatabase();
    
private:

    vector<HRTF *> mHRTFVector;     
    
    static HRTFDatabase* mDatabase; 

    unsigned mWindowSize;
    unsigned mHRTFLength;
    unsigned mHRIRLength;           
    
    void loadFromFile(const char *folder) throw (CException);
    
//public:
//
//  HRTF *operator [] (unsigned idx) const;

};


// THE PANNER BELOW HAS SOME CODE TO SPECIFY BLOCK SIZES INDEPENDENT FROM THE CALLBACK RATE.
// NOT FULLY IMPLEMENTED, AND CHOSE THE METHOD ABOVE AS THIS NEEDS LOTS OF BUFFERING (AND MEMORY USAGE)
//
//class BinauralPanner : public Panner {
//public:
//  BinauralPanner ();
//  ~BinauralPanner ();
//
//  virtual void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);
//
//protected:
//  void selectHRTF(CPoint *position);
//  virtual void *cache();      ///< Returns an instance of it's cache data per sound source.
//          
//  sample *mTempInBuffer;
//  sample *mInputRingBuffer;   
//  sample *mOutputRingBufferL; ///< Holds the output samples, used in case callbacks differ, so it can buffer data.
//  sample *mOutputRingBufferR; ///< Holds the output samples, used in case callbacks differ, so it can buffer data.
//  sample *mInverseFFTOutL;    ///< The Output of the Inverse FFT Plan, after input data has been multiplied by the HRTF
//  sample *mInverseFFTOutR;    ///< The Output of the Inverse FFT Plan, after input data has been multiplied by the HRTF
//  sample *mPrevOutL;          ///< The Cached mInverseFFTOutL. It holds the prevous out from the Inverse FFT Plan
//  sample *mPrevOutR;          ///< The Cached mInverseFFTOutR. It holds the prevous out from the Inverse FFT Plan
//
//  float mInvFramesPerBlock;  ///< The inverse of the number of frames per block, used for normalization
//
//  unsigned numFFTBlocks;      ///< 
//  unsigned mFramesPerBlock;       ///< 
//  unsigned mCurrentBlockIdx;
//          
//  unsigned currOutSampleRead;
//  unsigned currOutSampleWrite; 
//  unsigned currInSampleRead;
//  unsigned currInSampleWrite; 
//  unsigned mBigBufferSize;
//
//  unsigned *mCurrentHRTF;  // The current block of the "split" hrtf
//  int samplesDone;
//
//  fftwf_complex **h_in, *mHOutL, *mHOutR;
//  fftwf_plan *mFFTPlans, mInversePlanL, mInversePlanR;
//
//  int preBuffer;
//  
//};



} // end namespace

#endif

---