Messages.hh

Go to the documentation of this file.

/*

    Messaging
    Copyright (C) 1999-2002 Jussi Laako

    This program 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.

    This program 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.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/


#include <sys/time.h>


#ifndef MESSAGES_HH
    #define MESSAGES_HH

    #define MSG_FALSE               0
    #define MSG_TRUE                1


    enum
    {
        MSG_SOUND_COMPRESS_NONE = 0,
        MSG_SOUND_COMPRESS_FLAC = 1
    };

    enum
    {
        MSG_SPECT_TYPE_FFT = 0,
        MSG_SPECT_TYPE_MRFFT = 1,
        MSG_SPECT_TYPE_GABOR = 2,
        MSG_SPECT_TYPE_WVD = 3,
        MSG_SPECT_TYPE_HANKEL = 4,
        MSG_SPECT_TYPE_AUTOCORR = 5,
        MSG_SPECT_TYPE_CEPSTRUM = 6
    };

    enum
    {
        MSG_SPECT_WND_RECT = 0,
        MSG_SPECT_WND_BARTLETT = 1,
        MSG_SPECT_WND_BLACKMAN = 2,
        MSG_SPECT_WND_BM_HAR = 3,
        MSG_SPECT_WND_COS_TAPER = 4,
        MSG_SPECT_WND_EXP = 5,
        MSG_SPECT_WND_FLATTOP = 6,
        MSG_SPECT_WND_GEN_COS = 7,
        MSG_SPECT_WND_HAMMING = 8,
        MSG_SPECT_WND_HANNING = 9,
        MSG_SPECT_WND_KAISER = 10,
        MSG_SPECT_WND_KAI_BES = 11,
        MSG_SPECT_WND_TUKEY = 12
    };

    enum
    {
        MSG_SPECT_BNER_NONE = 0,
        MSG_SPECT_BNER_TPSW = 1,
        MSG_SPECT_BNER_OTA = 2,
        MSG_SPECT_BNER_DIFF = 3,
        MSG_SPECT_BNER_IDIFF = 4
    };

    enum
    {
        MSG_DIR_ALG_BEAM = 1,
        MSG_DIR_ALG_CORR = 2,
        MSG_DIR_ALG_SPECT = 4
    };

    enum
    {
        MSG_DIR_SCAL_LIN = 0,
        MSG_DIR_SCAL_LOG = 1,
        MSG_DIR_SCAL_EXP = 2,
        MSG_DIR_SCAL_SIN = 3
    };

    enum
    {
        MSG_DIR_BNER_NONE = 0,
        MSG_DIR_BNER_TPSW = 1,
        MSG_DIR_BNER_OTA = 2,
        MSG_DIR_BNER_DIFF = 3,
        MSG_DIR_BNER_IDIFF = 4
    };

    enum
    {
        MSG_LOFAR_TYPE_FFT = 0,
        MSG_LOFAR_TYPE_CEPSTRUM = 1,
        MSG_LOFAR_TYPE_AUTOCORR = 2
    };

    enum
    {
        MSG_LOFAR_WIN_RECT = 0,
        MSG_LOFAR_WIN_BARTLETT = 1,
        MSG_LOFAR_WIN_BLACKMAN = 2,
        MSG_LOFAR_WIN_BM_HARRIS = 3,
        MSG_LOFAR_WIN_COS_TAPER = 4,
        MSG_LOFAR_WIN_EXP = 5,
        MSG_LOFAR_WIN_FLATTOP = 6,
        MSG_LOFAR_WIN_HAMMING = 7,
        MSG_LOFAR_WIN_HANNING = 8,
        MSG_LOFAR_WIN_KAISER = 9,
        MSG_LOFAR_WIN_KAI_BES = 10,
        MSG_LOFAR_WIN_TUKEY = 11
    };

    enum
    {
        MSG_LOFAR_BNER_NONE = 0,
        MSG_LOFAR_BNER_TPSW = 1,
        MSG_LOFAR_BNER_OTA = 2,
        MSG_LOFAR_BNER_DIFF = 3,
        MSG_LOFAR_BNER_IDIFF = 4,
        MSG_LOFAR_BNER_STDDEV = 5
    };

    enum
    {
        MSG_LOFAR_CLIP_NONE = 0,
        MSG_LOFAR_CLIP_LOW = 1,
        MSG_LOFAR_CLIP_BOTH = 2,
        MSG_LOFAR_CLIP_MEAN = 3,
        MSG_LOFAR_CLIP_MEDIAN = 4,
        MSG_LOFAR_CLIP_10DB = 5,
        MSG_LOFAR_CLIP_20DB = 6,
        MSG_LOFAR_CLIP_50P = 7,
        MSG_LOFAR_CLIP_75P = 8,
        MSG_LOFAR_CLIP_OFFSET = 9,
        MSG_LOFAR_CLIP_OFFSET2 = 10,
        MSG_LOFAR_CLIP_OFFSET3 = 11,
        MSG_LOFAR_CLIP_SLIDING = 12
    };

    enum
    {
        MSG_LEVEL_ALG_PEAK = 0,
        MSG_LEVEL_ALG_RMS = 1,
        MSG_LEVEL_ALG_MEAN = 2,
        MSG_LEVEL_ALG_MEDIAN = 3,
        MSG_LEVEL_ALG_STDDEV = 4
    };


    typedef struct _stSoundStart
    {
        int iChannels;          
        double dSampleRate;     
        int iFragmentSize;      
        int iCompress;          
    } stSoundStart, *stpSoundStart;

    typedef struct _stSpectReq
    {
        int iChannel;           
        int iType;              
        int iWindow;            
        float fWinParam;        
        long lLength;           
        int iLowFreq;           
        int iHighFreq;          
        float fGain;            
        float fSlope;           
        int iOverlap;           
        bool bLinear;           
        bool bNormalize;        
        int iRemoveNoise;       
        float fAlpha;           
        long lMeanLength;       
        long lGapLength;        
        float fDynRange;        
    } stSpectReq, *stpSpectReq;

    typedef struct _stSpectRes
    {
        struct timeval sTimeStamp;  
        int iChannel;           
        long lLength;           
        int iLowFreq;           
        int iHighFreq;          
        int iSampleRate;        
        bool bLinear;           
        float fPeakLevel;       
        float fLineTime;        
    } stSpectRes, *stpSpectRes;

    typedef struct _stDirReq
    {
        int iAlgorithm;         
        float fSoundSpeed;      
        float fLowFreqLimit;    
        float fIntegrationTime; 
        int iScaling;           
        float fScalingExp;      
        bool bNormalize;        
        float fLeftDir;         
        float fRightDir;        
        long lSectorCount;      
        int iRemoveNoise;       
        float fAlpha;           
        long lMeanLength;       
        long lGapLength;        
        bool bDisableFilter;    
    } stDirReq, *stpDirReq;

    typedef struct _stDirRes
    {
        struct timeval sTimeStamp;  
        float fIntegrationTime; 
        float fHighFreqLimit;   
        float fPeakLevel;       
        long lSectorCount;      
        bool b3DArray;          
    } stDirRes, *stpDirRes;

    typedef struct _stDirReq2
    {
        long lWindowSize;       
        float fSoundSpeed;      
        float fLowFreqLimit;    
        float fIntegrationTime; 
        int iScaling;           
        float fScalingExp;      
        int iRemoveNoise;       
        float fAlpha;           
        long lMeanLength;       
        long lGapLength;        
    } stDirReq2, *stpDirReq2;

    typedef struct _stDirRes2
    {
        struct timeval sTimeStamp; 
        long lMinBin;           
        long lMaxBin;           
        float fFreqResolution;  
        long lResultCount;      
        float fPeakLevel;       
        float fIntegrationTime; 
    } stDirRes2, *stpDirRes2;

    typedef struct _stLofarReq
    {
        int iChannel;           
        int iType;              
        int iWindow;            
        float fWinParameter;    
        long lWinLength;        
        float fLowFreq;         
        float fHighFreq;        
        int iOverlap;           
        bool bLinear;           
        int iRemoveNoise;       
        float fAlpha;           
        long lMeanLength;       
        long lGapLength;        
        bool bDemon;            
        int iClip;              
        long lAvgCount;         
    } stLofarReq, *stpLofarReq;

    typedef struct _stLofarRes
    {
        struct timeval sTimeStamp; 
        long lSpectLength;      
        float fLowFreq;         
        float fHighFreq;        
        float fDemonBand;       
        float fLineTime;        
        float fPeakLevel;       
    } stLofarRes, *stpLofarRes;

    typedef struct _stBeamAudioReq
    {
        float fDirection;       
        float fSoundSpeed;      
        bool bHighFreq;         
    } stBeamAudioReq, *stpBeamAudioReq;

    typedef struct _stBeamAudioFirst
    {
        long lBufLength;        
        int iSampleRate;        
    } stBeamAudioFirst, *stpBeamAudioFirst;

    typedef struct _stBeamAudioRes
    {
        struct timeval sTimeStamp; 
        long lBufLength;        
        float fPeakLevel;       
        float fDirection;       
    } stBeamAudioRes, *stpBeamAudioRes;

    typedef struct _stLevelReq
    {
        int iChannel;           
        int iAlgorithm;         
        float fIntegrationTime; 
        float fLowFrequency;    
        float fHighFrequency;   
    } stLevelReq, *stpLevelReq;

    typedef struct _stLevelRes
    {
        struct timeval sTimeStamp; 
        float fIntegrationTime; 
        float fPeakLevel;       
        float fResult;          
    } stLevelRes, *stpLevelRes;

    typedef struct _stLocateHdr
    {
        int iWidth;             
        int iHeight;            
    } stLocateHdr, *stpLocateHdr;

    typedef struct _stLocateRes
    {
        long lPointCount;       
    } stLocateRes, *stpLocateRes;


    class clBaseMsg
    {
        protected:
            inline void EndianConv (float *, const float *);
            inline void EndianConv (double *, const double *);
    };


    class clSoundMsg : public clBaseMsg
    {
        public:
            void SetStart (char *, const stpSoundStart);
            void GetStart (const char *, stpSoundStart);
            void SetData (void *, const struct timeval *, const float *,
                int);
            void SetData (void *, const struct timeval *, const double *,
                int);
            void SetData (void *, const float *, int);
            void SetData (void *, const double *, int);
            int GetData (const void *, struct timeval *, float *);
            int GetData (const void *, struct timeval *, double *);
            void GetData (const void *, float *, int);
            void GetData (const void *, double *, int);
    };


    class clSpectMsg : public clBaseMsg
    {
        public:
            // Request message to server
            void SetRequest (char *, const stpSpectReq);
            void GetRequest (const char *, stpSpectReq);
            // Result message from server
            void SetResult (void *, const stpSpectRes, const float *);
            void SetResult (void *, const stpSpectRes, const double *);
            void GetResult (const void *, stpSpectRes, float *);
            void GetResult (const void *, stpSpectRes, double *);
    };


    class clDirMsg : public clBaseMsg
    {
        public:
            // Request message to server
            void SetRequest (char *, const stpDirReq);
            void GetRequest (const char *, stpDirReq);
            // Result message from server
            void SetResult (void *, const stpDirRes, const float *);
            void SetResult (void *, const stpDirRes, const double *);
            void GetResult (const void *, stpDirRes, float *);
            void GetResult (const void *, stpDirRes, double *);
    };


    class clDirMsg2 : public clBaseMsg
    {
        public:
            // Request message to server
            void SetRequest (char *, const stpDirReq2);
            void GetRequest (const char *, stpDirReq2);
            // Result message from server
            void SetResult (void *, const stpDirRes2, 
                const float *, const float *);
            void SetResult (void *, const stpDirRes2,
                const double *, const double *);
            void GetResult (const void *, stpDirRes2, float *, float *);
            void GetResult (const void *, stpDirRes2, double *, double *);
    };


    class clLofarMsg : public clBaseMsg
    {
        public:
            // Request message to server
            void SetRequest (char *, const stpLofarReq);
            void GetRequest (const char *, stpLofarReq);
            // Result message from server
            void SetResult (void *, const stpLofarRes, const float *);
            void SetResult (void *, const stpLofarRes, const double *);
            void GetResult (const void *, stpLofarRes, float *);
            void GetResult (const void *, stpLofarRes, double *);
    };


    class clBeamAudioMsg : public clBaseMsg
    {
        public:
            // Request message to server
            void SetRequest (char *, const stpBeamAudioReq);
            void GetRequest (const char *, stpBeamAudioReq);
            // First message from server
            void SetFirst (char *, const stpBeamAudioFirst);
            void GetFirst (const char *, stpBeamAudioFirst);
            // Result message from server
            void SetResult (void *, const stpBeamAudioRes, const float *);
            void SetResult (void *, const stpBeamAudioRes, const double *);
            void GetResult (const void *, stpBeamAudioRes, float *);
            void GetResult (const void *, stpBeamAudioRes, double *);
    };


    class clLevelMsg : public clBaseMsg
    {
        public:
            // Request message to server
            void SetRequest (char *, const stpLevelReq);
            void GetRequest (const char *, stpLevelReq);
            // Result message from server
            void SetResult (void *, const stpLevelRes);
            void GetResult (const void *, stpLevelRes);
    };


    class clLocateMsg : public clBaseMsg
    {
        public:
            // Header message from server
            void SetHeader (char *, const stpLocateHdr);
            void GetHeader (const char *, stpLocateHdr);
            // Result message from server
            void SetResult (void *, const stpLocateRes, const float *);
            void SetResult (void *, const stpLocateRes, const double *);
            void GetResult (const void *, stpLocateRes, float *);
            void GetResult (const void *, stpLocateRes, double *);
    };            

#endif

---