Commit bc5aead1 authored by Archit Tamarapu's avatar Archit Tamarapu
Browse files

[strip] FIX_1123_TDREN_16BIT_ROM

parent 61af208c

lib_rend/ivas_objectRenderer_hrFilt.c

+0 −21
Original line number Diff line number Diff line
@@ -516,40 +516,19 @@ void BSplineModelEvalDealloc( 


    if ( model->modelROM )

    {

#ifdef FIX_1123_TDREN_16BIT_ROM

        for ( i = 0; i < model->num_unique_azim_splines; i++ )

        {

            free( model->azimBsShape_dyn[i] );

        }

        free( model->azimBsShape_dyn );

        model->azimBsShape_dyn = NULL;

#endif



        free( (void *) model->azimBsShape ); /* void* cast needed to please both gcc and Visual studio compilers. Deallocating const float** should be fine and gcc agrees, but Visual studio complains. */

#ifdef FIX_1123_TDREN_16BIT_ROM

        model->azimBsShape = NULL;

#endif



        for ( i = 0; i < model->elevDim3; i++ )

        {

            free( model->azimKSeq[i] );

#ifdef FIX_1123_TDREN_16BIT_ROM

            model->azimKSeq[i] = NULL;

#endif

        }

        free( model->azimKSeq );

#ifdef FIX_1123_TDREN_16BIT_ROM

        model->azimKSeq = NULL;

#endif



        if ( modelEval != NULL )

        {

            free( modelEval->hrfModL );

            free( modelEval->hrfModR );

#ifdef FIX_1123_TDREN_16BIT_ROM

            modelEval->hrfModL = NULL;

            modelEval->hrfModR = NULL;

#endif

        }

    }

lib_rend/ivas_objectRenderer_mix.c

+0 −234
Original line number Diff line number Diff line
@@ -170,45 +170,6 @@ void TDREND_MIX_Dealloc( 


        if ( hBinRendererTd->HrFiltSet_p->ModelParams.modelROM == 1 )

        {

#ifdef FIX_1123_TDREN_16BIT_ROM

            if ( hBinRendererTd->HrFiltSet_p->ModelParams.UseItdModel )

            {

                free( hBinRendererTd->HrFiltSet_p->ModelParamsITD.elevKSeq_dyn );

                free( hBinRendererTd->HrFiltSet_p->ModelParamsITD.azimKSeq_dyn );

                free( hBinRendererTd->HrFiltSet_p->ModelParamsITD.W_dyn );

                free( hBinRendererTd->HrFiltSet_p->ModelParamsITD.azimBsShape_dyn );

                free( hBinRendererTd->HrFiltSet_p->ModelParamsITD.elevBsShape_dyn );

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.elevKSeq_dyn = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.azimKSeq_dyn = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.W_dyn = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.azimBsShape_dyn = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.elevBsShape_dyn = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.elevKSeq = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.azimKSeq = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.W = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.azimBsShape = NULL;

                hBinRendererTd->HrFiltSet_p->ModelParamsITD.elevBsShape = NULL;

            }



            free( hBinRendererTd->HrFiltSet_p->ModelParams.AlphaL_dyn );

            free( hBinRendererTd->HrFiltSet_p->ModelParams.AlphaR_dyn );

            free( hBinRendererTd->HrFiltSet_p->ModelParams.EL_dyn );

            free( hBinRendererTd->HrFiltSet_p->ModelParams.ER_dyn );

            free( hBinRendererTd->HrFiltSet_p->ModelParams.elevKSeq_dyn );

            free( hBinRendererTd->HrFiltSet_p->ModelParams.elevBsShape_dyn );

            hBinRendererTd->HrFiltSet_p->ModelParams.AlphaL_dyn = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.AlphaR_dyn = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.EL_dyn = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.ER_dyn = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.elevKSeq_dyn = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.elevBsShape_dyn = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.AlphaL = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.AlphaR = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.EL = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.ER = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.elevKSeq = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.elevBsShape = NULL;

#endif



            free( hBinRendererTd->HrFiltSet_p );

            hBinRendererTd->HrFiltSet_p = NULL;
@@ -415,23 +376,9 @@ static ivas_error DefaultBSplineModel( 
{

    ModelParams_t *model;

    ModelParamsITD_t *modelITD;

#ifdef FIX_1123_TDREN_16BIT_ROM

    int32_t i, j;

#else

    int16_t i, j;

#endif

    ivas_error error;

    float azimSegSamples;

#ifdef FIX_1123_TDREN_16BIT_ROM

    float q_scale = 0;

    int32_t size_rom_table;

    float q_scale_a = 0;

    float q_scale_e = 0;

    const int16_t *alphaL_ptr = NULL;

    const int16_t *alphaR_ptr = NULL;

    const int32_t *elL_ptr = NULL;

    const int32_t *elR_ptr = NULL;

#endif



    HrFiltSet_p->FilterMethod = TDREND_HRFILT_Method_BSplineModel;

    model = &( HrFiltSet_p->ModelParams );
@@ -455,60 +402,15 @@ static ivas_error DefaultBSplineModel( 
    model->azimShapeSampFactor = defaultHRIR_rom_azimShapeSampFactor;



    /* float parameters */

#ifdef FIX_1123_TDREN_16BIT_ROM

    if ( ( model->elevKSeq_dyn = (float *) malloc( ( model->elevDim3 - 2 ) * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }



    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_elevKSeq_Q );

    for ( j = 0; j < model->elevDim3 - 2; j++ )

    {

        model->elevKSeq_dyn[j] = defaultHRIR_rom_elevKSeq[j] * q_scale;

    }

    model->elevKSeq = (const float *) model->elevKSeq_dyn;



    size_rom_table = sizeof( defaultHRIR_rom_elevBsShape ) / sizeof( int16_t );

    if ( ( model->elevBsShape_dyn = (float *) malloc( size_rom_table * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }



    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_elevBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        model->elevBsShape_dyn[j] = defaultHRIR_rom_elevBsShape[j] * q_scale;

    }

    model->elevBsShape = (const float *) model->elevBsShape_dyn;

#else

    model->elevKSeq = (const float *) defaultHRIR_rom_elevKSeq;

    model->elevBsShape = (const float *) defaultHRIR_rom_elevBsShape;

#endif



    if ( ( model->azimBsShape = (const float **) malloc( model->num_unique_azim_splines * sizeof( float * ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }



#ifdef FIX_1123_TDREN_16BIT_ROM

    if ( ( model->azimBsShape_dyn = (float **) malloc( model->num_unique_azim_splines * sizeof( float * ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    size_rom_table = sizeof( defaultHRIR_rom_azimBsShape ) / sizeof( int16_t );

    if ( ( model->azimBsShape_dyn[0] = (float *) malloc( size_rom_table * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_azimBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        model->azimBsShape_dyn[0][j] = defaultHRIR_rom_azimBsShape[j] * q_scale;

    }

    model->azimBsShape[0] = (const float *) model->azimBsShape_dyn[0];

#else

    model->azimBsShape[0] = (const float *) defaultHRIR_rom_azimBsShape;

#endif



    if ( ( model->azimKSeq = (float **) malloc( model->elevDim3 * sizeof( float * ) ) ) == NULL )

    {
@@ -541,19 +443,10 @@ static ivas_error DefaultBSplineModel( 
    switch ( output_Fs )

    {

        case 48000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_a = powf( 2.f, -1.f * defaultHRIR_rom_Alpha48_Q );

            q_scale_e = powf( 2.f, -1.f * defaultHRIR_rom_E48_Q );

            alphaL_ptr = defaultHRIR_rom_AlphaL48;

            alphaR_ptr = defaultHRIR_rom_AlphaR48;

            elL_ptr = defaultHRIR_rom_EL48;

            elR_ptr = defaultHRIR_rom_ER48;

#else

            model->AlphaL = (const float *) defaultHRIR_rom_AlphaL48;

            model->AlphaR = (const float *) defaultHRIR_rom_AlphaR48;

            model->EL = (const float *) defaultHRIR_rom_EL48;

            model->ER = (const float *) defaultHRIR_rom_ER48;

#endif

            model->K = defaultHRIR_rom_model_configuration[5];

            if ( HrFiltSet_p->ModelParams.UseItdModel )

            {
@@ -561,19 +454,10 @@ static ivas_error DefaultBSplineModel( 
            }

            break;

        case 32000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_a = powf( 2.f, -1.f * defaultHRIR_rom_Alpha32_Q );

            q_scale_e = powf( 2.f, -1.f * defaultHRIR_rom_E32_Q );

            alphaL_ptr = defaultHRIR_rom_AlphaL32;

            alphaR_ptr = defaultHRIR_rom_AlphaR32;

            elL_ptr = defaultHRIR_rom_EL32;

            elR_ptr = defaultHRIR_rom_ER32;

#else

            model->AlphaL = (const float *) defaultHRIR_rom_AlphaL32;

            model->AlphaR = (const float *) defaultHRIR_rom_AlphaR32;

            model->EL = (const float *) defaultHRIR_rom_EL32;

            model->ER = (const float *) defaultHRIR_rom_ER32;

#endif

            model->K = (int16_t) ceilf( RESAMPLE_FACTOR_32_48 * defaultHRIR_rom_model_configuration[5] );

            if ( HrFiltSet_p->ModelParams.UseItdModel )

            {
@@ -581,19 +465,10 @@ static ivas_error DefaultBSplineModel( 
            }

            break;

        case 16000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_a = powf( 2.f, -1.f * defaultHRIR_rom_Alpha16_Q );

            q_scale_e = powf( 2.f, -1.f * defaultHRIR_rom_E16_Q );

            alphaL_ptr = defaultHRIR_rom_AlphaL16;

            alphaR_ptr = defaultHRIR_rom_AlphaR16;

            elL_ptr = defaultHRIR_rom_EL16;

            elR_ptr = defaultHRIR_rom_ER16;

#else

            model->AlphaL = (const float *) defaultHRIR_rom_AlphaL16;

            model->AlphaR = (const float *) defaultHRIR_rom_AlphaR16;

            model->EL = (const float *) defaultHRIR_rom_EL16;

            model->ER = (const float *) defaultHRIR_rom_ER16;

#endif

            model->K = (int16_t) ceilf( RESAMPLE_FACTOR_16_48 * defaultHRIR_rom_model_configuration[5] );

            if ( HrFiltSet_p->ModelParams.UseItdModel )

            {
@@ -603,46 +478,6 @@ static ivas_error DefaultBSplineModel( 
        default:

            break;

    }

#ifdef FIX_1123_TDREN_16BIT_ROM

    if ( ( model->AlphaL_dyn = (float *) malloc( model->AlphaN * model->K * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    if ( ( model->AlphaR_dyn = (float *) malloc( model->AlphaN * model->K * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    for ( j = 0; j < model->AlphaN * model->K; j++ )

    {

        model->AlphaL_dyn[j] = alphaL_ptr[j] * q_scale_a;

        model->AlphaR_dyn[j] = alphaR_ptr[j] * q_scale_a;

    }

    model->AlphaL = (const float *) model->AlphaL_dyn;

    model->AlphaR = (const float *) model->AlphaR_dyn;



    /* Precalculated energies for each section and each row of the alpha matrices */

    HRTF_model_precalc( model );

#ifndef FIX_1123_TDREN_16BIT_ROM

    HRTF_energy_sections_precalc( model );

#endif



    if ( ( model->EL_dyn = (float *) malloc( HRTF_MODEL_N_SECTIONS * model->AlphaN * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    if ( ( model->ER_dyn = (float *) malloc( HRTF_MODEL_N_SECTIONS * model->AlphaN * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    for ( j = 0; j < HRTF_MODEL_N_SECTIONS * model->AlphaN; j++ )

    {

        model->EL_dyn[j] = elL_ptr[j] * q_scale_e;

        model->ER_dyn[j] = elR_ptr[j] * q_scale_e;

    }



    model->EL = (const float *) model->EL_dyn;

    model->ER = (const float *) model->ER_dyn;

#endif



    modelITD->elevDim3 = defaultHRIR_rom_ITD_model_configuration[0];

    modelITD->azimDim3 = defaultHRIR_rom_ITD_model_configuration[1];
@@ -651,88 +486,19 @@ static ivas_error DefaultBSplineModel( 
    modelITD->elevBsLen = defaultHRIR_rom_ITD_elevBsLen;

    modelITD->elevBsStart = defaultHRIR_rom_ITD_elevBsStart;



#ifdef FIX_1123_TDREN_16BIT_ROM

    if ( ( modelITD->elevKSeq_dyn = (float *) malloc( ( modelITD->elevDim3 - 2 ) * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_elevKSeq_Q );

    for ( j = 0; j < modelITD->elevDim3 - 2; j++ )

    {

        modelITD->elevKSeq_dyn[j] = defaultHRIR_rom_ITD_elevKSeq[j] * q_scale;

    }

    modelITD->elevKSeq = (const float *) modelITD->elevKSeq_dyn;

#else

    modelITD->elevKSeq = defaultHRIR_rom_ITD_elevKSeq;

#endif



    modelITD->azimBsLen = defaultHRIR_rom_ITD_azimBsLen;

    modelITD->azimBsStart = defaultHRIR_rom_ITD_azimBsStart;



#ifdef FIX_1123_TDREN_16BIT_ROM

    if ( ( modelITD->azimKSeq_dyn = (float *) malloc( ( ( modelITD->azimDim3 + 1 ) / 2 - 2 ) * sizeof( float ) ) ) == NULL ) /* basis functions are flipped around 180 deg, number of basis functions above/below is (N+1)/2 */

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_azimKSeq_Q );

    for ( j = 0; j < ( modelITD->azimDim3 + 1 ) / 2 - 2; j++ )

    {

        modelITD->azimKSeq_dyn[j] = defaultHRIR_rom_ITD_azimKSeq[j] * q_scale;

    }

    modelITD->azimKSeq = (const float *) modelITD->azimKSeq_dyn;

#else

    modelITD->azimKSeq = defaultHRIR_rom_ITD_azimKSeq;

#endif

#ifdef FIX_1123_TDREN_16BIT_ROM

    size_rom_table = sizeof( defaultHRIR_rom_ITD_W ) / sizeof( int16_t );

    if ( ( modelITD->W_dyn = (float *) malloc( size_rom_table * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_W_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        modelITD->W_dyn[j] = defaultHRIR_rom_ITD_W[j] * q_scale;

    }

    modelITD->W = (const float *) modelITD->W_dyn;



    size_rom_table = sizeof( defaultHRIR_rom_ITD_azimBsShape ) / sizeof( int16_t );

    if ( ( modelITD->azimBsShape_dyn = (float *) malloc( size_rom_table * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_azimBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        modelITD->azimBsShape_dyn[j] = defaultHRIR_rom_ITD_azimBsShape[j] * q_scale;

    }

    modelITD->azimBsShape = (const float *) modelITD->azimBsShape_dyn;



    size_rom_table = sizeof( defaultHRIR_rom_ITD_elevBsShape ) / sizeof( int16_t );

    if ( ( modelITD->elevBsShape_dyn = (float *) malloc( size_rom_table * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_elevBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        modelITD->elevBsShape_dyn[j] = defaultHRIR_rom_ITD_elevBsShape[j] * q_scale;

    }

    modelITD->elevBsShape = (const float *) modelITD->elevBsShape_dyn;

#else

    modelITD->W = (const float *) defaultHRIR_rom_ITD_W;

    modelITD->azimBsShape = (const float *) defaultHRIR_rom_ITD_azimBsShape;

    modelITD->elevBsShape = (const float *) defaultHRIR_rom_ITD_elevBsShape;

#endif



    HRTF_model_precalc( model );



#ifdef FIX_1123_TDREN_16BIT_ROM

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_latency_s_Q );

    HrFiltSet_p->latency_s = defaultHRIR_rom_latency_s * q_scale;

#else

    HrFiltSet_p->latency_s = defaultHRIR_rom_latency_s;

#endif



    HrFiltSet_p->SampleRate = output_Fs;

    HrFiltSet_p->FiltLength = HrFiltSet_p->ModelParams.K;

lib_rend/ivas_rom_TdBinauralRenderer.c

+0 −10165

File changed.

Preview size limit exceeded, changes collapsed.

lib_rend/ivas_rom_TdBinauralRenderer.h

+0 −55
Original line number Diff line number Diff line
@@ -46,36 +46,6 @@ 
 * TD Binaural rendering related ROM tables

 *------------------------------------------------------------------------*/

/* TD renderer default HRIR model */

#ifdef FIX_1123_TDREN_16BIT_ROM

extern const int16_t defaultHRIR_rom_latency_s_Q;

extern const int32_t defaultHRIR_rom_latency_s;

extern const int16_t defaultHRIR_rom_model_configuration[6];

extern const int16_t defaultHRIR_rom_azimDim3[15];

extern const int16_t defaultHRIR_rom_azim_start_idx[15];

extern const int16_t defaultHRIR_rom_azimSegSamples[1];

extern const int16_t defaultHRIR_rom_azimShapeIdx[15];

extern const int16_t defaultHRIR_rom_azimShapeSampFactor[15];

extern const int16_t defaultHRIR_rom_elevKSeq_Q;

extern const int16_t defaultHRIR_rom_elevKSeq[13];

extern const int16_t defaultHRIR_rom_Alpha48_Q;

extern const int16_t defaultHRIR_rom_AlphaL48[470 * 128];

extern const int16_t defaultHRIR_rom_AlphaR48[470 * 128];

extern const int16_t defaultHRIR_rom_Alpha32_Q;

extern const int16_t defaultHRIR_rom_AlphaL32[470 * 86];

extern const int16_t defaultHRIR_rom_AlphaR32[470 * 86];

extern const int16_t defaultHRIR_rom_Alpha16_Q;

extern const int16_t defaultHRIR_rom_AlphaL16[470 * 43];

extern const int16_t defaultHRIR_rom_AlphaR16[470 * 43];

extern const int16_t defaultHRIR_rom_E48_Q;

extern const int32_t defaultHRIR_rom_EL48[HRTF_MODEL_N_SECTIONS * 470];

extern const int32_t defaultHRIR_rom_ER48[HRTF_MODEL_N_SECTIONS * 470];

extern const int16_t defaultHRIR_rom_E32_Q;

extern const int32_t defaultHRIR_rom_EL32[HRTF_MODEL_N_SECTIONS * 470];

extern const int32_t defaultHRIR_rom_ER32[HRTF_MODEL_N_SECTIONS * 470];

extern const int16_t defaultHRIR_rom_E16_Q;

extern const int32_t defaultHRIR_rom_EL16[HRTF_MODEL_N_SECTIONS * 470];

extern const int32_t defaultHRIR_rom_ER16[HRTF_MODEL_N_SECTIONS * 470];

#else

extern const float defaultHRIR_rom_latency_s;

extern const int16_t defaultHRIR_rom_model_configuration[6];

extern const int16_t defaultHRIR_rom_azimDim3[15];
@@ -96,30 +66,6 @@ extern const uint32_t defaultHRIR_rom_EL32[HRTF_MODEL_N_SECTIONS * 470]; 
extern const uint32_t defaultHRIR_rom_ER32[HRTF_MODEL_N_SECTIONS * 470];

extern const uint32_t defaultHRIR_rom_EL16[HRTF_MODEL_N_SECTIONS * 470];

extern const uint32_t defaultHRIR_rom_ER16[HRTF_MODEL_N_SECTIONS * 470];

#endif

#ifdef FIX_1123_TDREN_16BIT_ROM

extern const int16_t defaultHRIR_rom_elevBsLen[4];

extern const int16_t defaultHRIR_rom_elevBsStart[4];

extern const int16_t defaultHRIR_rom_elevBsShape_Q;

extern const int16_t defaultHRIR_rom_elevBsShape[36];

extern const int16_t defaultHRIR_rom_azimBsShape_Q;

extern const int16_t defaultHRIR_rom_azimBsShape[21];

extern const int16_t defaultHRIR_rom_ITD_W_Q;

extern const int16_t defaultHRIR_rom_ITD_W[658];

extern const int16_t defaultHRIR_rom_ITD_azimBsShape_Q;

extern const int16_t defaultHRIR_rom_ITD_azimBsShape[84];

extern const int16_t defaultHRIR_rom_ITD_azimKSeq_Q;

extern const int16_t defaultHRIR_rom_ITD_azimKSeq[19];

extern const int16_t defaultHRIR_rom_ITD_elevBsShape_Q;

extern const int16_t defaultHRIR_rom_ITD_elevBsShape[28];

extern const int16_t defaultHRIR_rom_ITD_elevKSeq_Q;

extern const int16_t defaultHRIR_rom_ITD_elevKSeq[16];

extern const int16_t defaultHRIR_rom_ITD_model_configuration[4];

extern const int16_t defaultHRIR_rom_ITD_elevBsLen[4];

extern const int16_t defaultHRIR_rom_ITD_elevBsStart[4];

extern const int16_t defaultHRIR_rom_ITD_azimBsLen[4];

extern const int16_t defaultHRIR_rom_ITD_azimBsStart[4];

#else

extern const int16_t defaultHRIR_rom_elevBsLen[4];

extern const int16_t defaultHRIR_rom_elevBsStart[4];

extern const uint32_t defaultHRIR_rom_elevBsShape[36];
@@ -135,4 +81,3 @@ extern const int16_t defaultHRIR_rom_ITD_elevBsStart[4]; 
extern const int16_t defaultHRIR_rom_ITD_azimBsLen[4];

extern const int16_t defaultHRIR_rom_ITD_azimBsStart[4];

#endif
 
#endif