WaVQE.h

Go to the documentation of this file.

/*
 * This file is part of the Wave Arts VQE library.
 * Copyright (C) 2011 Wave Arts, Inc. (http://wavearts.com)
 *
 * VQE is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * VQE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * A copy of the GNU General Public License is included with VQE,
 * and can be found online at <http://www.gnu.org/licenses/>.
 *
 * If you'd like to distribute a closed-source product which uses VQE,
 * you must obtain a commercial VQE license from Wave Arts.
 */
#ifndef _WA_VQE_H
#define _WA_VQE_H

#include "WaAudioDev.h"
#include "AecCal.h"
#include "AecObjects.h"
#include "AFileMaker.h"
#include "AutoGain.h"
#include "DeclipLpf.h"
#include "WaPlatform.h"

/*
@section sec_style Notes on coding style

I'm basically a old school C/assembly programmer who adopted C++ for doing difficult
object oriented tasks that demanded inheritance and virtual methods. Most low level
signal processing and utility code I write in C out of habit. I quite like C++ and should probably
start using it exclusively, but I am definitely not a C++ guru and I tend to use only a limited
subset of features, e.g., I haven't started using signals and templates routinely. I'm also
not obsessive about typing. I do strive to write readable and well commented code, because
otherwise I can't understand what I've written.
*/

//
//
#define USE_MEM_FILES           0
#define MAX_MEM_FILE_TIME       30              //!< maximum of 30 second output files

class AecInFifo {
public:
        AecInFifo(int numBufs, int bufLen, int numChan);

        ~AecInFifo();

        bool WriteBuf(float *p);

        bool ReadBuf(float *p);

        float *GetReadBuf();
        float *GetLastReadBuf();
        int GetCount();
        int GetSize();
        void Reset();

protected:
        float *buf;             
        int bufLen;             
        int numChan;    
        int bufLenSamps;        
        int numBufs;            
        int readIndex;          
        int writeIndex;         
        int count;                      
};

typedef enum {
        WaAlgNone,      
        WaAlgAEC,       
        WaAlgAES        
} WaAECAlg;

typedef struct {
        AecSyncParam syncParam; 
        WaAECAlg alg;                   

        union {
                AecParam aecParam;
                AesParam aesParam;
        } param;
        int fifoPrimeThresh;    
        int runCountThresh;     
        bool cacheLatency;      
        bool hasAutoGain;       
        AutoGainParam autoGainParam;    
        bool hasDeclip;         
        DeclipLpfParam declipParam;             
        bool matlabDump;        
        bool dumpFiles;         
        bool dumpResponse;      
        char in0Name[32];       
        char in1Name[32];       
        char out0Name[32];      
        char out1Name[32];      
        char dumpDir[256];      
} VQEParam;

#define kMaxBurst       5       //!< longest buffer burst to track

class WaVQE : public WaAudioDevPortObj {
public:
        WaVQE(WaAudioDevPort *devPort, VQEParam *vqeParam);
        ~WaVQE();

        VQEParam *GetParam();
        int Open(WadParam *param, WadCallbackFn *inFn, WadCallbackFn *outFn, void *arg);
        void Close();

        // Public so C callback can access.
        // Callbacks for normal streaming operation.
        int InCallback(float *buf, int numFrames, int numChan);
        int OutCallback(float *buf, int numFrames, int numChan);

        void SetAecEnable(bool isAecEnabled);

        void AutoGainSetFn(bool isIncr, float incr);

        static void GetDefaultParam(VQEParam *vqeParam);
        
        void SetAutoGainEnable(bool enable);

        void SetDeclipEnable(bool enable);

        void SetInjectNoise(bool enable);

protected:
        void Reset();
        bool OpenDumpFile(AFileOut **pAfo, char *name, int sampRate, int numChan);
        void OpenDumpFiles(WadParam *param);
        void PreProcess(float *buf, int numFrames, int numChan);
        void PostProcess(float *buf, int numFrames, int numChan);
        void InjectShortNoise(short *buf, int n);
        void InjectFloatNoise(float *buf, int n);
        bool DeliverInputBuf(float *buf);
        bool FetchOutputBuf(float *buf);
        void MakeDumpPath(char *path, unsigned maxLen, char *name);
        void DumpResponse();
        void SetAecProcessor(AecProcessor *aec);
        void FillAecLatData(AecLatData *data);

        WaAudioDevPortObj *resPort;     
        WadParam param;                 
        VQEParam vqeParam;      
        bool syncBuffers;       
        AecLatCalObject *aecLatCal;     
        // this is a bit messy keeping both pointers, we could have latCal delete embedded aec
        AecProcessor *aecObj;   
        AecProcessor *aecProcessor;     
        WadCallbackFn *appInFn; 
        WadCallbackFn *appOutFn;        
        void *appArg;           
        bool isAecEnabled;      
        AecInFifo *inFifo;      
        bool isInputReady;      
        int overCount;          
        int underCount;         
        // optional file dumping
        AFileOut *afoIn0;               
        AFileOut *afoIn1;               
        AFileOut *afoOut0;              
        AFileOut *afoOut1;              
        int numIn;                              
        int numOut;                             
        int inHist[kMaxBurst];  
        int outHist[kMaxBurst]; 
        int totalNumIn;                 
        int totalNumOut;                
        int totalNumAppIn;              
        int totalNumAppOut;             
        int numUnder;                   
        int numOver;                    
        short *shortOutBuf;             
        short *shortInBuf;              
        float *lastRefBuf;              
        float *recBuf;                  
        AutoGain *autoGain;             
        bool isAutoGainEnabled; 
        DeclipLpf *declip;              
        bool isDeclipEnabled;   
        // MLS noise generation
        bool injectNoise;       
        int mlsReg;                     
        int mlsMask;            
        int mlsMsbMask;         
};

#endif