powermap.h

A sound-field visualiser, which utilises spherical harmonic signals as input.

A sound-field visualiser, which utilises spherical harmonic signals as input

Files

powermap.h (include), powermap_internal.h, powermap.c, powermap_internal.c

Include Header

/*
 * Copyright 2016-2018 Leo McCormack
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef __POWERMAP_H_INCLUDED__
#define __POWERMAP_H_INCLUDED__
 
#include "_common.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
    
/* ========================================================================== */
/*                             Presets + Constants                            */
/* ========================================================================== */
 
typedef enum {
    PM_MODE_PWD = 1,     
    PM_MODE_MVDR,        
    PM_MODE_CROPAC_LCMV, 
    PM_MODE_MUSIC,       
    PM_MODE_MUSIC_LOG,   
    PM_MODE_MINNORM,     
    PM_MODE_MINNORM_LOG  
} POWERMAP_MODES;
 
 
/* ========================================================================== */
/*                               Main Functions                               */
/* ========================================================================== */
 
void powermap_create(void** const phPm);
 
void powermap_destroy(void** const phPm);
 
void powermap_init(void* const hPm,
                   float  samplerate);
    
void powermap_initCodec(void* const hPm);
 
void powermap_analysis(void* const hPm,
                       const float *const * inputs,
                       int nInputs,
                       int nSamples,
                       int isPlaying);
 
 
/* ========================================================================== */
/*                                Set Functions                               */
/* ========================================================================== */
 
void powermap_refreshSettings(void* const hPm);
 
void powermap_setPowermapMode(void* const hPm, int newMode);
 
void powermap_setMasterOrder(void* const hPm,  int newValue);
 
void powermap_setAnaOrder(void* const hPm,  int newValue, int bandIdx);
 
void powermap_setAnaOrderAllBands(void* const hPm, int newValue);
    
void powermap_setPowermapEQ(void* const hPm,  float newValue, int bandIdx);
 
void powermap_setPowermapEQAllBands(void* const hPm,  float newValue);
    
void powermap_setCovAvgCoeff(void* const hPm, float newAvg);
 
void powermap_setChOrder(void* const hPm, int newOrder);
 
void powermap_setNormType(void* const hPm, int newType);
 
void powermap_setSourcePreset(void* const hPm, int newPresetID);
 
void powermap_setNumSources(void* const hPm, int newValue);
 
void powermap_setDispFOV(void* const hPm, int newOption);
 
void powermap_setAspectRatio(void* const hPm, int newOption);
 
void powermap_setPowermapAvgCoeff(void* const hPm, float newValue);
 
void powermap_requestPmapUpdate(void* const hPm);
 
 
/* ========================================================================== */
/*                                Get Functions                               */
/* ========================================================================== */
 
int powermap_getFrameSize(void);
 
CODEC_STATUS powermap_getCodecStatus(void* const hPm);
 
float powermap_getProgressBar0_1(void* const hPm);
 
void powermap_getProgressBarText(void* const hPm, char* text);
 
int powermap_getMasterOrder(void* const hPm);
 
int powermap_getPowermapMode(void* const hPm);
 
int powermap_getSamplingRate(void* const hPm);
 
float powermap_getCovAvgCoeff(void* const hPm);
 
int powermap_getNumberOfBands(void);
    
int powermap_getNSHrequired(void* const hPm);
 
float powermap_getPowermapEQ(void* const hPm, int bandIdx);
 
float powermap_getPowermapEQAllBands(void* const hPm);
 
void powermap_getPowermapEQHandle(void* const hPm,
                                  float** pX_vector,
                                  float** pY_values,
                                  int* pNpoints);
 
int powermap_getAnaOrder(void* const hPm, int bandIdx);
 
int powermap_getAnaOrderAllBands(void* const hPm);
 
void powermap_getAnaOrderHandle(void* const hPm,
                                float** pX_vector,
                                int** pY_values,
                                int* pNpoints);
 
int powermap_getChOrder(void* const hPm);
 
int powermap_getNormType(void* const hPm);
 
int powermap_getNumSources(void* const hPm);
 
int powermap_getDispFOV(void* const hPm);
 
int powermap_getAspectRatio(void* const hPm);
 
float powermap_getPowermapAvgCoeff(void* const hPm);
 
int powermap_getPmap(void* const hPm,
                     float** grid_dirs,
                     float** pmap,
                     int* nDirs,
                     int* pmapWidth,
                     int* hfov,
                     int* aspectRatio);
 
int powermap_getProcessingDelay(void);
 
 
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
 
#endif /* __POWERMAP_H_INCLUDED__ */