AVVTetraInternal.h

Go to the documentation of this file.

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

#ifndef __AVVTETRAINTERNAL_H_INCLUDED
#define __AVVTETRAINTERNAL_H_INCLUDED

#include <string>

#include "ABMatrix.h"
#include "CoincidenceFilter.h"
#include "LFFilter.h"
#include "MitRegFilter.h"
#include "FilterMatrix.h"
#include "AmbiFormat.h"


#define MAXCAP (4)
#define MAXOUT (4)
#define NUMPROGRAMS (8)
#define MAXFILTER (8)
#define MAXVIEW (3)
#define MAXFREQ (20000.0)
#define LOWFREQ (250.0)
#define MINFREQ (20.0)
#define FREQRATIO (1.0 / log10(MAXFREQ / MINFREQ))
#define LOWRATIO (1.0 / log10(LOWFREQ / MINFREQ))

#define MAXNAMESIZE (32)

enum  AddressModes
{
    kAddressNormal,
    kAddressEndFireDown,
    kAddressEndFireUp,
    kAddressInvert,
    kAddressNumModes
};

short inline parm2AddressMode(float x)
{
    return (short)(x * kAddressNumModes);   
}

float inline addressMode2parm(short n)
{
    return ((float)n / kAddressNumModes);
}

using namespace std;

// parameters
enum
{
    // master
    kAmbiFormat,
    kLFEnabled,
    kLFCutOff,
    kCardioidBoost,
    kLocked,
    kCalibration,
    kCurCapCompEQFilter,
    kCurCoincidenceFilter,
    kEQEnabled,
    kEQLinked,
    kGainsLinked,
    kABMatrixEnabled,
    kAddressMode,
    kCurCap,
    kViewMode,
    kTetraDispVU,
    kTetraNumMasterParams,

    // per capsule
    kCapParams = kTetraNumMasterParams,
    // cap EQ
    kCapEQFreq = 0,
    kCapEQWidth,
    kCapEQGain,
    kNumEQParams,
    // cap gain per (cap x out)
    kCapGain = kNumEQParams,
    //kNumCapGains = (MAXCAP * MAXOUT),
    kNumCapParams = kNumEQParams + MAXOUT,

    // per output
    kOutGain = kCapParams + (MAXCAP * kNumCapParams),

    kTetraNumParams = kOutGain + MAXOUT
};

class AVVTetraInternal;

class AVVTetraProgram
{
friend class AVVTetraInternal;
public:
    AVVTetraProgram();
    ~AVVTetraProgram() {}
private:

    float fAmbiFormat;
    float fCurCapCompEQFilter;
    float fCurCoincidenceFilter;
    float fLFCutOff;
    float fCardioidBoost;
    float fLFEnabled;
    float fViewMode;
    float fDispVU;
    float fLocked;
    float fCalibration;

    float fCapGain[MAXCAP][MAXOUT];
    float fCapEQFreq[MAXCAP];
    float fCapEQWidth[MAXCAP];
    float fCapEQGain[MAXCAP];
    float fEQEnabled;
    float fEQLinked;
    float fGainsLinked;
    float fOutGain[MAXCAP];
    float fABMatrixEnabled;
    float fAddressMode;
    float fCurCap;

    char name[MAXNAMESIZE];
};

class AVVTetraInternal
{
public:
    AVVTetraInternal(long sampleRate, const char *calibrationPath);
    ~AVVTetraInternal();

    void reloadCalibrations(const char *calibrationPath);
    void getCalibrationPath(char* calibrationPath); 
    int setProgram(int program); // returns program, or -1 if out of bounds
    int getCurProgram();
    int setProgram(string programName); // returns program, or -1 if not found
    string getCurProgramName();
    int getNumPrograms();
    string getProgramName(int program);
    bool canProcess();
    void setSampleRate(long sampleRate);
    void processReplacing(float **inputs, float **outputs, int sampleFrames);
    void clearBuffers();
    void generateImpulses(int blockSize, float** output);

    virtual void setParameter(int index, float value);
    virtual float getParameter (int index);

    float getVu();
    float getVuPre(int index);
    float getVuPost(int index);

    void setAddressMode(short mode);
    short getAddressMode();
    void setOutputFormat(int fmt);
    int getOutputFormat();


private:
    void SetCapCompFilter(short newCapCompFilter);
    short GetCapCompFilter();
    void SetCoincidenceFilter(short newCoincidenceFilter);
    short GetCoincidenceFilter();
    bool CalibrationsDirectoryExists();
    void ReadCalibrations();
    void ReadTetraProcCalibrations();
    void ReadBrahmaCalibrations();

    //virtual void setSampleRate (float sampleRate);

    void initPath();
    void initFilters();
    void initDynamicFilters();
    void initPrograms();

    long sampleRate;
    char calPath[1024];
    char calName[24];

    AVVTetraProgram *programs;
    int numPrograms;
    int curProgram;
    float *buffer;

    // in internal type
    short m_nOutFormat;
    short m_nCurCapCompEQFilter;
    short m_nCurCoincidenceFilter;
    float m_fLFCutOff;
    float m_fCardioidBoost;
    bool  m_bLFEnabled;
    short m_nViewMode;
    bool  m_bDispVU;
    bool  m_bLocked;
    bool  m_bCalibration;

    float m_fCapGain[MAXCAP][MAXOUT];
    float m_fCapEQFreq[MAXCAP];
    float m_fCapEQWidth[MAXCAP];
    float m_fCapEQGain[MAXCAP];
    bool  m_bEQEnabled;
    bool  m_bEQLinked;
    bool  m_bGainsLinked;
    float m_fOutGain[MAXCAP];
    bool  m_bABMatrixEnabled;
    short m_nAddressMode;
    short m_nCurCap;

    // in vst (float 0-1) type
    float fAmbiFormat;
    float fCurCapCompEQFilter;
    float fCurCoincidenceFilter;
    float fLFCutOff;
    float fCardioidBoost;
    float fLFEnabled;
    float fViewMode;
    float fDispVU;
    float fLocked;
    float fCalibration;

    float fCapGain[MAXCAP][MAXOUT];
    float fCapEQFreq[MAXCAP];
    float fCapEQWidth[MAXCAP];
    float fCapEQGain[MAXCAP];
    float fEQEnabled;
    float fEQLinked;
    float fGainsLinked;
    float fOutGain[MAXCAP];
    float fABMatrixEnabled;
    float fAddressMode;
    float fCurCap;

    long delay;
    long size;
    long inPos;
    long outPos;

    float vu, vuSave, vuPre[MAXCAP], vuPreSave[MAXCAP], vuPost[MAXOUT], vuPostSave[MAXOUT];
    long vuCount, vuMicCountPre[MAXCAP], vuMicCountPost[MAXOUT];

    // format changer
    AmbiFormat ambFormat;
    
    // filters
    bool skipDynamicFilters;

    // LF filters
    CLFFilter *m_LFFilter[MAXCAP];

    // capsule EQ
    //CParaEQ1Band *m_filtCapEQ[MAXCAP];
    CMitRegFilter *m_filtCapEQ[MAXCAP];

    // frequency compensation filters
    short m_nNumCapCompEQFilter;
    CFilter *m_filtCapCompEQ[MAXFILTER][MAXCAP];

    CABMatrix *m_abMatrix;

    // coincidence compensation filters
    short m_nNumCoincidenceFilter;
    CFilter *m_filtCoincidence[MAXFILTER][MAXCAP];

    // filter matrix
    FilterMatrix m_filterMatrix;
};

#endif