VVAmbisonic.h

Go to the documentation of this file.

/*
 * Copyright (C) 2013 David McGriffy, all rights reserved
 */

#ifndef __VVAMBISONIC_H_INCLUDED
#define __VVAMBISONIC_H_INCLUDED

#if defined(_WIN32) || defined(_WIN64)
#ifdef dll_export
#define impexp_spec // __declspec(dllexport)  
#else
#define impexp_spec  //__declspec(dllimport) 
#endif
#else
#define impexp_spec
#endif

#include "VVFeatures.h"

#define BUFFERLEN (512)

#define NUMPROGRAMS (8)
#define MAXNAMESIZE (32)

class AVVTetra;
class AVVRotate;
class AVVDecode;
#ifdef VVHAS_PARAMETRIC_DECODER
    class AVVDecode2;
#endif
#ifdef VVHAS_SYNTH_BINAURAL
    class AVVBinaural;
#endif


namespace VVAmbisonic
{

    class impexp_spec VVPlugin
    {
    public:
        VVPlugin(long sampleRate);                              
        virtual ~VVPlugin();                                    
        virtual void setAmbiFormat(int fmt) = 0;                
        virtual bool canProcess() = 0;                          
        virtual void process(float **inBufs, float **outBufs, long numSamples) = 0; 
    };

    class impexp_spec VVTetra : public VVPlugin
    {
    public:
        VVTetra(long sampleRate, const char* calibrationFilePath);  
        ~VVTetra();                                             
        int setProgram(int program);                            
        int setProgram(const char* programName);                
        void getCurProgramName(char* programName);              
        void setAmbiFormat(int fmt);                            
        void setAddressMode(int mode);                          
        bool canProcess();                                      
        void process(float **inBufs, float **outBufs, long numSamples); 
        void generateImpulses(int blockSize, float** output);   
    private:
        AVVTetra *m_AVVTetra;                                   
    };
    
    class impexp_spec VVRotate : public VVPlugin
    {
    public:
        VVRotate(long sampleRate);                              
        ~VVRotate();                                            
        void setMirrors(bool mX, bool mY, bool mZ);             
        void setAngles(float rotate, float tilt, float tumble); 
        void setAmbiFormat(int fmt);                            
        bool canProcess();                                      
        void process(float **inBufs, float **outBufs, long numSamples); 
        void processFast(float **inBufs, float **outBufs, long numSamples); 
    private:
        AVVRotate *m_AVVRotate;                                 
    };

    class impexp_spec VVDecode : public VVPlugin
    {
    public:
        VVDecode(long sampleRate);                              
        ~VVDecode();                                            
        int setProgram(int program);                            
        int setProgram(const char* programName);                
        void getCurProgramName(char* programName);              
        void setAmbiFormat(int fmt);                            
        bool canProcess();                                      
        int getNumOutputs();                                    
        void process(float **inBufs, float **outBufs, long numSamples); 
    private:
        AVVDecode *m_AVVDecode;                                 
    };

#ifdef VVHAS_PARAMETRIC_DECODER

    class impexp_spec VVDecodeP : public VVPlugin
    {
    public:
        VVDecodeP(long sampleRate);                             
        ~VVDecodeP();                                           
        int setProgram(int program);                            
        int setProgram(const char* programName);                
        void getCurProgramName(char* programName);              
        void setAmbiFormat(int fmt);                            
        bool canProcess();                                      
        int getNumOutputs();                                    
        void setHRIRSubject(int subjBect);                      
        int getHRIRSubjects(const int **subjectList);           
        //void setBinauralParams(float headSize, float frontFreq, float lowFreq); /*!< Set the synthetic binaural parameters */
        void process(float **inBufs, float **outBufs, long numSamples); 
    private:
        AVVDecode2 *m_AVVDecodeP;                                   
    };
#endif

#ifdef VVHAS_SYNTH_BINAURAL

    class impexp_spec VVBinaural : public VVPlugin
    {
    public:
        VVBinaural(long sampleRate, const char* HRIRPath, int subjNum); 
        ~VVBinaural();                                          
        int setProgram(int program);                            
        int setProgram(const char* programName);                
        void getCurProgramName(char* programName);              
        void setAmbiFormat(int fmt);                            
        bool canProcess();                                      
        void process(float **inBufs, float **outBufs, long numSamples); 
    private:
        AVVBinaural *m_AVVBinaural;                             
    };
#endif

};

#endif