saf_hades_internal.h

Go to the documentation of this file.

/*
 * This file is part of the saf_hades module.
 * Copyright (c) 2021 - Leo McCormack & Janani Fernandez
 *
 * The saf_hades module 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.
 *
 * The saf_hades module 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.
 *
 * See <http://www.gnu.org/licenses/> for a copy of the GNU General Public
 * License.
 */
 
#ifndef __SAF_HADES_INTERNAL_H_INCLUDED__
#define __SAF_HADES_INTERNAL_H_INCLUDED__
 
#include "saf_hades_analysis.h"
#include "saf_hades_synthesis.h"
#include "saf.h"
#include "saf_externals.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#ifdef  SAF_ENABLE_HADES_MODULE
 
#define HADES_MAX_BLOCKSIZE ( 4096 )
 
typedef struct _CxMic{
    float_complex Cx[HADES_MAX_NMICS*HADES_MAX_NMICS];
}CxMic;
 
/* ========================================================================== */
/*                           Main Internal Structs                            */
/* ========================================================================== */
 
typedef struct _hades_analysis_data
{
    /* User parameters (defined at intialisation stage) */
    float fs;                             
    HADES_FILTERBANKS fbOpt;              
    int hopsize;                          
    int blocksize;                        
    int hybridmode;                       
    float* h_array;                       
    float* grid_dirs_deg;                 
    int nGrid;                            
    int nMics;                            
    int h_len;                            
    HADES_DIFFUSENESS_ESTIMATORS diffOpt; 
    HADES_DOA_ESTIMATORS doaOpt;          
    /* Optional user parameters (that can also be manipulated at run-time) */
    float covAvgCoeff;                    
    /* Time-frequency transform and array data */
    void* hFB_enc;                        
    int nBands;                           
    int timeSlots;                        
    int filterbankDelay;                  
    float* freqVector;                    
    float_complex* DCM_array;             
    float_complex* H_array;               
    float_complex* H_array_w;             
    /* DoA and diffuseness estimator data */
    void* hEig;                           
    float_complex** T;                    
    void* hDoA;                           
    float* grid_dirs_xyz;                 
    float_complex* W;                     
    /* Run-time variables */
    float** inputBlock;                   
    CxMic* Cx;                            
    float_complex* V;                     
    float_complex* Vn;                    
    float* lambda;                        
}hades_analysis_data;
 
typedef struct _hades_synthesis_data
{
    /* User parameters */
    HADES_BEAMFORMER_TYPE beamOption; 
    int enableCM;                     
    hades_binaural_config* binConfig; 
    int refIndices[2];                
    HADES_HRTF_INTERP_OPTIONS interpOption; 
    /* Optional user parameters (that can also be manipulated at run-time) */
    float* eq;                       
    float* streamBalance;            
    float synAvgCoeff;               
    /* Things relevant to the synthesiser, which are copied from the hades_analysis_create() to keep everything aligned */
    HADES_FILTERBANKS fbOpt;         
    int nBands;                      
    int hopsize;                     
    int blocksize;                   
    int nGrid;                       
    int nMics;                       
    float_complex* H_array;          
    float* grid_dirs_deg;            
    float** grid_dirs_xyz;           
    int timeSlots;                   
    float* freqVector;               
    float_complex* DCM_array;        
    float_complex* W;                
    /* Time-frequency transform */
    void* hFB_dec;                   
    /* HRTF and diffuse rendering variables */
    float_complex* H_bin;            
    float_complex* DCM_bin_norm;     
    float* diffEQ;                   
    /* Run-time variables */
    void* hPinv;                     
    void* hLinSolve;                 
    void* hCDF;                      
    float_complex* As;               
    float_complex* As_l;             
    float_complex* As_r;             
    float_complex* Q_diff;           
    float_complex* Q_dir;            
    float_complex* Q;                
    float_complex* Cy;               
    float_complex* new_M;            
    float_complex** M;               
    /* Run-time audio buffers */
    float_complex*** outTF;          
    float** outTD;                   
}hades_synthesis_data;
 
typedef struct _hades_param_container_data {
    int nBands;                      
    /* Estimated Parameters */
    float* diffuseness;              
    int* doa_idx;                    
    int* gains_idx;                  
    /* Optional parameters */
    float* gains_dir;                
    float* gains_diff;               
} hades_param_container_data;
 
typedef struct _hades_radial_editor_data {
    int nBands;                      
    int nGrid;                       
    float* pGrid_dirs_deg;           
    float* pGrid_dirs_xyz;           
} hades_radial_editor_data;
 
typedef struct _hades_signal_container_data {
    int nMics;                       
    int nBands;                      
    int timeSlots;                   
    /* Covariance matrices and signal statistics computed during the analysis */
    CxMic* Cx;                       
    /* TF frame to carry over to a decoder */
    float_complex*** inTF;           
} hades_signal_container_data;
 
 
/* ========================================================================== */
/*                             Internal Functions                             */
/* ========================================================================== */
 
void hades_getInterpolatedHRTFs(/* Input Arguments */
                                hades_analysis_handle const hAna,
                                HADES_HRTF_INTERP_OPTIONS interpOption,
                                hades_binaural_config* binConfig,
                                float* target_dirs_deg,
                                int nTargetDirs,
                                /* Output Arguments */
                                float_complex* hrtf_interp);
 
void hades_sdMUSIC_create(void ** const phMUSIC,
                          int nMics,
                          float* grid_dirs_deg,
                          int nDirs);
 
void hades_sdMUSIC_destroy(void ** const phMUSIC);
 
void hades_sdMUSIC_compute(/* Input arguments */
                           void* const hMUSIC,
                           float_complex* A_grid,
                           float_complex* Vn,
                           int nSrcs,
                           /* Output arguments */
                           float* P_music,
                           int* peak_inds);
 
float hades_comedie(float* lambda,
                    int N);
 
#endif /* SAF_ENABLE_HADES_MODULE */
 
 
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
 
#endif /* __SAF_HADES_INTERNAL_H_INCLUDED__ */