Ambisonic.h

Go to the documentation of this file.

#ifndef CSL_AMBISONIC_H
#define CSL_AMBISONIC_H

#include "CSL_Core.h"
#include "CPoint.h"
#include "SpatialSource.h"
#include "SpeakerLayout.h"

#define HOA_MAX_ORDER 2 // maximum order that the CSL HOA will handle

namespace csl {

class AmbisonicOrder { 
public:
    AmbisonicOrder(unsigned hOrder = 0, unsigned vOrder = 0) : horizontalOrder(hOrder), verticalOrder(vOrder) {};
    ~AmbisonicOrder() {};
    
    unsigned horizontalOrder;
    unsigned verticalOrder;     
    bool isUniform;             
};

class AmbisonicUnitGenerator : public UnitGenerator {
public:
    
    // Constructors & destructor:
    AmbisonicUnitGenerator(unsigned order = 0);                 
    AmbisonicUnitGenerator(unsigned horder, unsigned vorder);   
    AmbisonicUnitGenerator(AmbisonicOrder order); 
    virtual ~AmbisonicUnitGenerator();
    
    AmbisonicOrder order() { return mOrder; }; 

protected:
    void setOrder(AmbisonicOrder order);
    
    AmbisonicOrder mOrder;              

    // returns the Ambisonic order from the number of Ambisonic channels: M = floor(sqrt(N) - 1)
    // NOTE - only works for uniform horizontal and vertical order (whereas ambiguity occurs in hybrid order systems)!
    unsigned channelsToUniformOrder(const unsigned channels);

    unsigned greaterOrder(const AmbisonicOrder order);

    unsigned orderToChannels(const AmbisonicOrder order);

    unsigned orderToChannels(unsigned order);

    unsigned orderToHorizontalChannels(const AmbisonicOrder order);

    unsigned orderToVerticalChannels(const AmbisonicOrder order);

    void channelIndexer(unsigned *indexArray);

    void invChannelIndexer(unsigned *indexArray);
                

private:

    void initOrder();   // generic initialisation function

};


class AmbisonicEncoder : public AmbisonicUnitGenerator {
public:
    
    AmbisonicEncoder();         
    AmbisonicEncoder(SpatSource &input, unsigned order = 1);    
    AmbisonicEncoder(SpatSource &input, unsigned horder, unsigned vorder); 
    
    virtual ~AmbisonicEncoder();    

    void setInput(SpatSource &input);   
    SpatSource *input() { return (SpatSource *)mInputPort->mUGen; };
    
    virtual void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);
        
protected:
    sample *mWeights;           
    UGenPort *mInputPort;       
    void initialize();          

};



typedef enum {
    kPSEUDOINVERSE = 0, 
    kPROJECTION
} AmbisonicDecoderMethod;

typedef enum {
    kBASIC = 0, 
    kINPHASE, 
    kMAXRE
} AmbisonicDecoderFlavour;

class AmbisonicDecoder : public AmbisonicUnitGenerator {
public:
    // Constructors & destructor:
    AmbisonicDecoder(AmbisonicUnitGenerator &input, SpeakerLayout *layout = SpeakerLayout::defaultSpeakerLayout(), AmbisonicDecoderMethod method = kPROJECTION, AmbisonicDecoderFlavour flavour = kBASIC);
    AmbisonicDecoder(UnitGenerator &input, unsigned order, SpeakerLayout *layout = SpeakerLayout::defaultSpeakerLayout(), AmbisonicDecoderMethod method = kPROJECTION, AmbisonicDecoderFlavour flavour = kBASIC);
    AmbisonicDecoder(UnitGenerator &input, unsigned hOrder, unsigned vOrder, SpeakerLayout *layout = SpeakerLayout::defaultSpeakerLayout(), AmbisonicDecoderMethod method = kPROJECTION, AmbisonicDecoderFlavour flavour = kBASIC);
    
    ~AmbisonicDecoder();    
        
    virtual void nextBuffer(Buffer &outputBuffer, unsigned outBufNum) throw (CException);

protected:

    UGenPort *mInputPort;
    float mNumChannelsInv;      // inverse of the numbers of loudspeakers (used for normalization)
    int *mIOChannelMap;         // lookup table from index of actually used Ambisonic channel input Ambisonic channel index
    sample **mDecodingMatrix;   // deccoding matrix D
    SpeakerLayout *mSpeakerLayout;              // loudspeaker layout provided by "HOA_SpeakerLayout" class
    AmbisonicDecoderMethod mDecodingMethod;     // decoding method: projection or pseudoinverse
    AmbisonicDecoderFlavour mDecoderFlavour;    // decoder flavour: basic, in-phase or max-rE


    void initialize(UnitGenerator &input, AmbisonicDecoderMethod method, AmbisonicDecoderFlavour flavour);
    
    void asProjection();    
    void asPseudoInverse(); 
        
    void makeInPhase(unsigned greaterOrder);    
    void makeMaxRE(unsigned greaterOrder);      

    void makeTransposedReEncodingMatrix(float **transposeMatrix); 

};

}

#endif

---