saf_reverb_internal.h

Go to the documentation of this file.

/*
 * Copyright 2020 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 __REVERB_INTERNAL_H_INCLUDED__
#define __REVERB_INTERNAL_H_INCLUDED__
 
#include "saf_reverb.h"
#include "saf_externals.h"
#include "../saf_utilities/saf_utilities.h"
#include "../saf_sh/saf_sh.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
/* ========================================================================== */
/*                         IMS Shoebox Room Simulator                         */
/* ========================================================================== */
 
#define IMS_NUM_WALLS_SHOEBOX ( 6 )
#define IMS_FIR_FILTERBANK_ORDER ( 400 )
#define IMS_IIR_FILTERBANK_ORDER ( 3 )
#define IMS_CIRC_BUFFER_LENGTH ( 4*8192U )
#define IMS_CIRC_BUFFER_LENGTH_MASK ( IMS_CIRC_BUFFER_LENGTH - 1U )
#define IMS_MAX_NSAMPLES_PER_FRAME ( 20000 )
#define IMS_LAGRANGE_ORDER ( 2 )
#define IMS_LAGRANGE_LOOKUP_TABLE_SIZE ( 100 )
#define IMS_EG_CURRENT ( 0 )
#define IMS_EG_PREV ( 1 )
#define IMS_EG_NUM_SLOTS ( 2 )
#define IMS_UNASSIGNED ( -1 )
 
typedef void* voidPtr;
 
typedef struct _ims_pos_xyz {
    union {
        struct { float x; 
                 float y; 
                 float z; 
        };
        float v[3]; 
    };
} ims_pos_xyz;
 
typedef enum {
    RECEIVER_SH   
    // RECEIVER_ARRAY /**< Microphone array/HRIR measurements-based receiver */
 
} RECEIVER_TYPES;
 
typedef struct _ims_src_obj
{
    float* sig;      
    ims_pos_xyz pos; 
    int ID;          
} ims_src_obj;
 
typedef struct _ims_rec_obj
{
    float** sigs;        
    RECEIVER_TYPES type; 
    int nChannels;       
    ims_pos_xyz pos;     
    int ID;              
} ims_rec_obj;
 
typedef struct _echogram_data
{
    /* The echogram data: */
    int numImageSources;     
    int nChannels;           
    float** value;           
    float* time;             
    int** order;             
    ims_pos_xyz* coords;     
    int* sortedIdx;          
    /* Optional helper variables for run-time speed-ups */
    int include_rt_vars;     
    float* tmp1;             
    float* tmp2;             
    int* rIdx;               
    int* rIdx_frac[IMS_LAGRANGE_ORDER]; 
    float** h_frac;          
    float** cb_vals;         
    float** contrib;         
    float* ones_dummy;       
} echogram_data;
 
typedef struct _ims_core_workspace
{
    /* Locals */
    float room[3];        
    float d_max;          
    int N_max;            
    ims_pos_xyz src;      
    ims_pos_xyz rec;      
    int nBands;           
    /* Internal */
    int Nx, Ny, Nz;
    int lengthVec, numImageSources;
    int* validIDs;
    int* s_ord;
    float* II, *JJ, *KK;
    int* iII, *iJJ, *iKK;
    float* s_x, *s_y, *s_z, *s_d, *s_t, *s_att;
 
    /* Echograms */
    int refreshEchogramFLAG;    
    void* hEchogram;            
    void* hEchogram_rec;        
    voidPtr* hEchogram_abs;     
    voidPtr* hPrevEchogram_abs; 
    /* Room impulse responses (only used/allocated when a render function is
     * called) */
    int refreshRIRFLAG;
    int rir_len_samples;
    float rir_len_seconds;
    float*** rir_bands; /* nBands x nChannels x rir_len_samples */
 
} ims_core_workspace;
 
typedef struct _ims_scene_data
{
    /* Locals */
    float room_dims[3];       
    float c_ms;               
    float fs;                 
    int nBands;               
    float** abs_wall;         
    /* Source and receiver positions */
    ims_src_obj srcs[IMS_MAX_NUM_SOURCES];   
    ims_rec_obj recs[IMS_MAX_NUM_RECEIVERS]; 
    long nSources;            
    long nReceivers;          
    /* Internal */
    voidPtr** hCoreWrkSpc;    
    float* band_centerfreqs;  
    float* band_cutofffreqs;  
    float** H_filt;           
    ims_rir** rirs;           
    /* Circular buffers (only used/allocated when applyEchogramTD() function is
     * called for the first time) */
    unsigned long wIdx[IMS_EG_NUM_SLOTS][IMS_MAX_NUM_RECEIVERS][IMS_MAX_NUM_SOURCES];  
    float*** circ_buffer[IMS_EG_NUM_SLOTS];  
    /* IIR filterbank (only used/allocated when applyEchogramTD() function is
     * called for the first time) */
    voidPtr* hFaFbank;          
    float*** src_sigs_bands;    
    /* Temporary receiver frame used for cross-fading (only used/allocated when
     * applyEchogramTD() function is called for the first time) */
    float*** rec_sig_tmp[IMS_EG_NUM_SLOTS]; 
    float* interpolator_fIn;  
    float* interpolator_fOut; 
    float* tmp_frame;         
    int applyCrossFadeFLAG[IMS_MAX_NUM_RECEIVERS][IMS_MAX_NUM_SOURCES];
    int framesize;            
    /* Lagrange interpolator look-up table */
    float lookup_fractions[IMS_LAGRANGE_LOOKUP_TABLE_SIZE];
    float lookup_H_frac[IMS_LAGRANGE_ORDER+1][IMS_LAGRANGE_LOOKUP_TABLE_SIZE];
 
} ims_scene_data;
 
 
/* =========================== Internal Functions =========================== */
 
void ims_shoebox_coreWorkspaceCreate(void** phWork,
                                     int nBands);
 
void ims_shoebox_coreWorkspaceDestroy(void** phWork);
 
void ims_shoebox_echogramCreate(void** phEcho,
                                int include_rt_vars);
 
void ims_shoebox_echogramResize(void* hEcho,
                                int numImageSources,
                                int nChannels);
 
void ims_shoebox_echogramCopy(void* hEchoX,
                              void* hEchoY);
 
void ims_shoebox_echogramDestroy(void** phEcho);
 
void ims_shoebox_coreInitT(void* hWork,
                           float room[3],
                           ims_pos_xyz src,
                           ims_pos_xyz rec,
                           float maxTime,
                           float c_ms);
 
void ims_shoebox_coreInitN(void* hWork,
                           float room[3],
                           ims_pos_xyz src,
                           ims_pos_xyz rec,
                           int maxN,
                           float c_ms);
 
void ims_shoebox_coreRecModuleSH(void* hWork,
                                 int sh_order);
 
void ims_shoebox_coreAbsorptionModule(void* hWork,
                                      float** abs_wall);
 
void ims_shoebox_renderRIR(void* hWork,
                           int fractionalDelayFLAG,
                           float fs,
                           float** H_filt,
                           ims_rir* rir);
 
 
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
 
#endif /* __REVERB_INTERNAL_H_INCLUDED__ */