Commit fc514b2b authored by emerit's avatar emerit
Browse files

rom TD rend 16 bits ok

parent 8e1a1a51

lib_com/options.h

+1 −1
Original line number Diff line number Diff line
@@ -169,7 +169,7 @@ 
#define FIX_1123_FASTCONV_16BIT_ROM                     /* FhG: issue 1123: update FastConv ROM tables and scripts to generate 16 bit tables instead of float */

#define FIX_1123_PARAMBIN_16BIT_ROM                     /* FhG,Nok: issue 1123: update ParamBin ROM tables and scripts to generate 16 bit tables instead of float */

#define FIX_1123_CREND_16BIT_ROM

//#define FIX_1123_TDREN_16BIT_ROM 

#define FIX_1123_TDREN_16BIT_ROM 

#define FIX_1101_CLEANING_JBM_CALL                      /* VA: issue 1101: remove obsolete call of ivas_jbm_dec_tc_buffer_open() */

#define FIX_1053_AEID_FILE_TEST                         /* Philips: Tests for the -aeid file and fix for memory error */

#define FIX_1121_MASA_DESCRIPTOR                        /* VA: issue 1121: Define 'ivasmasaFormatDescriptor' at one common place */

lib_rend/ivas_objectRenderer_hrFilt.c

+22 −0
Original line number Diff line number Diff line
@@ -516,16 +516,38 @@ 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

+205 −2
Original line number Diff line number Diff line
@@ -178,6 +178,45 @@ 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;

            *hBinRendererTd->pHrFiltSet_p = NULL;
@@ -385,9 +424,25 @@ 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;

    int32_t size_rom_table;

    float q_scale_al;

    float q_scale_ar;

    // float q_scale_el;

    // float q_scale_er;

    const int16_t *alphaL_ptr;

    const int16_t *alphaR_ptr;

    // const int16_t *elL_ptr;

    // const int16_t *elR_ptr;

#endif



    HrFiltSet_p->FilterMethod = TDREND_HRFILT_Method_BSplineModel;

    model = &( HrFiltSet_p->ModelParams );
@@ -412,15 +467,50 @@ static ivas_error DefaultBSplineModel( 
    model->azimShapeSampFactor = defaultHRIR_rom_azimShapeSampFactor;



    /* float parameters */

#ifdef FIX_1123_TDREN_16BIT_ROM

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

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

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

    {

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

    }

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



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

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

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

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

    {

        model->elevBsShape_dyn[j] = ( (float) 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 );

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

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

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

    {

        model->azimBsShape_dyn[0][j] = ( (float) 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 )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );
@@ -449,10 +539,21 @@ static ivas_error DefaultBSplineModel( 
    switch ( output_Fs )

    {

        case 48000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_al = powf( 2.f, -1.f * (float) defaultHRIR_rom_AlphaL48_Q );

            q_scale_ar = powf( 2.f, -1.f * (float) defaultHRIR_rom_AlphaR48_Q );

            // q_scale_el = powf( 2.f, -1.f * (float) defaultHRIR_rom_EL48_Q );

            // q_scale_er = powf( 2.f, -1.f * (float) defaultHRIR_rom_ER48_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 )

            {
@@ -460,10 +561,21 @@ static ivas_error DefaultBSplineModel( 
            }

            break;

        case 32000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_al = powf( 2.f, -1.f * (float) defaultHRIR_rom_AlphaL32_Q );

            q_scale_ar = powf( 2.f, -1.f * (float) defaultHRIR_rom_AlphaR32_Q );

            // q_scale_el = powf( 2.f, -1.f * (float) defaultHRIR_rom_EL32_Q );

            // q_scale_er = powf( 2.f, -1.f * (float) defaultHRIR_rom_ER32_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 )

            {
@@ -471,10 +583,21 @@ static ivas_error DefaultBSplineModel( 
            }

            break;

        case 16000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_al = powf( 2.f, -1.f * (float) defaultHRIR_rom_AlphaL16_Q );

            q_scale_ar = powf( 2.f, -1.f * (float) defaultHRIR_rom_AlphaR16_Q );

            // q_scale_el = powf( 2.f, -1.f * (float) defaultHRIR_rom_EL16_Q );

            // q_scale_er = powf( 2.f, -1.f * (float) defaultHRIR_rom_ER16_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 )

            {
@@ -484,6 +607,32 @@ static ivas_error DefaultBSplineModel( 
        default:

            break;

    }

#ifdef FIX_1123_TDREN_16BIT_ROM

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

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

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

    {

        model->AlphaL_dyn[j] = ( (float) alphaL_ptr[j] ) * q_scale_al;

        model->AlphaR_dyn[j] = ( (float) alphaR_ptr[j] ) * q_scale_ar;

    }

    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 );

    HRTF_energy_sections_precalc( model );

    // model->EL_dyn = (float *) malloc( HRTF_MODEL_N_SECTIONS * model->AlphaN * sizeof( float ) );

    // model->ER_dyn = (float *) malloc( HRTF_MODEL_N_SECTIONS * model->AlphaN * sizeof( float ) );

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

    // {

    //     model->EL_dyn[j] = ( (float) elL_ptr[j] ) * q_scale_el;

    //     model->ER_dyn[j] = ( (float) elR_ptr[j] ) * q_scale_er;

    // }





    // 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];
@@ -492,27 +641,81 @@ static ivas_error DefaultBSplineModel( 
    modelITD->elevBsLen = defaultHRIR_rom_ITD_elevBsLen;

    modelITD->elevBsStart = defaultHRIR_rom_ITD_elevBsStart;



#ifdef FIX_1123_TDREN_16BIT_ROM

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

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

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

    {

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

    }

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

#else

#ifdef FIX_TDREND_HRTF_FILE_FORMAT

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

#else

    modelITD->elevKSeq = defaultHRIR_rom_ITD_elevKSeq;

#endif

#endif



    modelITD->azimBsLen = defaultHRIR_rom_ITD_azimBsLen;

    modelITD->azimBsStart = defaultHRIR_rom_ITD_azimBsStart;



#ifdef FIX_1123_TDREN_16BIT_ROM

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

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

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

    {

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

    }

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

#else



#ifdef FIX_TDREND_HRTF_FILE_FORMAT

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

#else

    modelITD->azimKSeq = defaultHRIR_rom_ITD_azimKSeq;

#endif

#endif

#ifdef FIX_1123_TDREN_16BIT_ROM

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

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

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

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

    {

        modelITD->W_dyn[j] = ( (float) 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 );

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

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

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

    {

        modelITD->azimBsShape_dyn[j] = ( (float) 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 );

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

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

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

    {

        modelITD->elevBsShape_dyn[j] = ( (float) 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 * (float) defaultHRIR_rom_latency_s_Q );

    HrFiltSet_p->latency_s = (float) 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_prot_rend.h

+6 −0
Original line number Diff line number Diff line
@@ -697,6 +697,12 @@ void HRTF_model_precalc( 
    ModelParams_t *model                                        /* i/o: HRTF Model parameters                   */

);



#ifdef FIX_1123_TDREN_16BIT_ROM

void HRTF_energy_sections_precalc(

    ModelParams_t *model                                        /* i/o: HRTF model parameters        */

);

#endif



ivas_error TDREND_REND_RenderSourceHRFilt(

    TDREND_SRC_t *Src_p,                                        /* i/o: The source to be rendered               */

    const float *hrf_left_delta,                                /* i  : Left filter interpolation delta         */

lib_rend/ivas_rom_TdBinauralRenderer.c

+9 −375

File changed.

Preview size limit exceeded, changes collapsed.