Commit cc8b71e6 authored by emerit's avatar emerit
Browse files

Merge branch... 

Merge branch '311-rendering-update-generate_crend_ivas_tables_from_sofa-to-create-a-binary-blob' into orange/ivas-codec-sym-hrir
parents 2b9e423d 6b715957

scripts/binauralRenderer_interface/Table_Format_Converter/generate_tables_from_rom_to_bin.c

+337 −84
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ 
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>



#include "ivas_rom_binauralRenderer.h"

#include "ivas_rom_binaural_crend_head.h"
@@ -42,6 +43,7 @@ 




#define FILE_HEADER

#define MIXER_CONV_BINARY_FILE_311



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

 * Constants
@@ -55,6 +57,12 @@ 


#define DEFAULT_INPUT_ROM_FILE           "ivas_binaural"

#define DEFAULT_INPUT_TD_BIN_FILE        "hrfilter_model"



#ifdef MIXER_CONV_BINARY_FILE_311

#define DEFAULT_INPUT_MIXERCONV_BIN_FILE "ivas_hrfilters_mixerconv"

#define MIXERCONV_BIN_FILE_CFG_MAX_LEN    8

#endif // MIXER_CONV_BINARY_FILE_311



#define DEFAULT_BIN_FILE_EXT             ".bin"



#define IVAS_NB_RENDERER_TYPE 7
@@ -158,6 +166,10 @@ void usage_tables_format_converter( void ) 
             "-48 : Select 48 kHz sampling frequency (no multiple values, all frequencies by default).\n" );

    fprintf( stdout, "-input_td_file_path : Path of binary files for time-domain renderer (with separator, used as flag).\n" );

    fprintf( stdout, "-input_td_file_name : Name of input td file (without extension %s, default = '%s').\n", DEFAULT_BIN_FILE_EXT, DEFAULT_INPUT_TD_BIN_FILE );

#ifdef MIXER_CONV_BINARY_FILE_311

    fprintf( stdout, "-input_mixerconv_file_path : Path of binary files for mixer_conv renderer (with separator, used as flag).\n" );

    fprintf( stdout, "-input_mixerconv_file_name : Name of input mixer_conv file (without extension %s, default = '%s').\n", DEFAULT_BIN_FILE_EXT, DEFAULT_INPUT_MIXERCONV_BIN_FILE );

#endif

    fprintf( stdout, "\n" );

}
@@ -173,6 +185,12 @@ char *input_td_bin_path = NULL; 
char *input_td_bin_file_name = NULL;

char *full_in_td_path = NULL;



#ifdef MIXER_CONV_BINARY_FILE_311

char *input_mixerconv_bin_path = NULL;

char *input_mixerconv_bin_file_name = NULL;

char *full_in_mixerconv_path = NULL;

#endif



int16_t nb_freq = IVAS_NB_SAMPLERATE;

const int32_t *freq_ptr = sample_rates;
@@ -286,6 +304,10 @@ int main( int argc, char *argv[] ) 
                break;

            case RENDERER_BINAURAL_MIXER_CONV:

            case RENDERER_BINAURAL_MIXER_CONV_ROOM:

#ifdef MIXER_CONV_BINARY_FILE_311

                if ( full_in_mixerconv_path != NULL )

#endif // MIXER_CONV_BINARY_FILE_311

                {

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

                    {

                        for ( k = 0; k < nb_freq; k++ )
@@ -314,6 +336,7 @@ int main( int argc, char *argv[] ) 
                            }

                        }

                    }

                }

                break;

            case RENDERER_BINAURAL_OBJECTS_TD:

                if ( full_in_td_path != NULL )
@@ -351,6 +374,7 @@ int main( int argc, char *argv[] ) 
    }



#ifdef FILE_HEADER



    // Create the file header and write it in the bin file



    // [Declaration of the binary file]
@@ -391,6 +415,7 @@ int main( int argc, char *argv[] ) 


    fwrite( file_header, file_header_size, 1, bin_file );

    free( file_header );



#endif



    // Write each HRTF in the bin file
@@ -441,6 +466,117 @@ int main( int argc, char *argv[] ) 
 *---------------------------------------------------------------------*/

char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG input_cfg, int32_t frequency, int32_t *hrtf_size )

{

    int32_t mixerconv_hrtf_header_size, mixerconv_hrtf_data_size;

    char *mixerconv_hrtf = NULL, *mixerconv_hrtf_wptr;



#ifdef MIXER_CONV_BINARY_FILE_311



    FILE *input_mixerconv_bin_file = NULL;



    // Get the HRTF raw data



    char *renderer_type_name, *configuration_name;



    // Example : ivas_hrfilters_mixerconv_Combined_HRIR_48kHz.bin



    if ( rend_type == RENDERER_BINAURAL_MIXER_CONV )

    {

        renderer_type_name = "HRIR";



        if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )

        {

            configuration_name = "Combined";

        }

        else if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_HOA )

        {

            configuration_name = "HOA3";

        }

    }

    else if ( rend_type == RENDERER_BINAURAL_MIXER_CONV_ROOM )

    {

        renderer_type_name = "BRIR";



        if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )

        {

            configuration_name = "Combined";

        }

        else if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_HOA )

        {

            return NULL;

        }

    }



    sprintf( full_in_mixerconv_path, "%s%s_%s_%s_%dkHz%s", input_mixerconv_bin_path, input_mixerconv_bin_file_name, configuration_name, renderer_type_name, frequency / 1000, DEFAULT_BIN_FILE_EXT );

    input_mixerconv_bin_file = fopen( full_in_mixerconv_path, "rb" );



    if ( input_mixerconv_bin_file != NULL )

    {

        fseek( input_mixerconv_bin_file, 0, SEEK_END );

        mixerconv_hrtf_data_size = ftell( input_mixerconv_bin_file );

        fseek( input_mixerconv_bin_file, 0, SEEK_SET );



        // Header [Declaration of the HRTF]

        //      Renderer type         (4 bytes) : See "RENDERER_TYPE"

        //      Decoder output format (4 bytes) : See "BINAURAL_INPUT_AUDIO_CONFIG"

        //      Sampling Frequency    (4 bytes)

        //      Raw data size         (4 bytes)



        mixerconv_hrtf_header_size = sizeof( int32_t ) + sizeof( int32_t ) + sizeof( int32_t ) + sizeof( uint32_t );

        *hrtf_size = mixerconv_hrtf_header_size + mixerconv_hrtf_data_size;

        mixerconv_hrtf = (char *) malloc( *hrtf_size );



        if ( mixerconv_hrtf == NULL )

        {

            fprintf( stderr, "Memory allocation for the block failed!\n\n" );

            fclose( input_mixerconv_bin_file );

            *hrtf_size = -1;

            return NULL;

        }



        memset( mixerconv_hrtf, 0x00, *hrtf_size );

        mixerconv_hrtf_wptr = mixerconv_hrtf;



        // Get the HRTF header



        // Renderer type

        memcpy( mixerconv_hrtf_wptr, &( rend_type ), sizeof( int32_t ) );

        mixerconv_hrtf_wptr += sizeof( int32_t );



        // Decoder output format

        memcpy( mixerconv_hrtf_wptr, &( input_cfg ), sizeof( int32_t ) );

        mixerconv_hrtf_wptr += sizeof( int32_t );



        // Sampling Frequency

        memcpy( mixerconv_hrtf_wptr, &( frequency ), sizeof( int32_t ) );

        mixerconv_hrtf_wptr += sizeof( int32_t );



        // Raw data size

        memcpy( mixerconv_hrtf_wptr, &( mixerconv_hrtf_data_size ), sizeof( uint32_t ) );

        mixerconv_hrtf_wptr += sizeof( uint32_t );



        // Get the HRTF raw data



        if ( fread( mixerconv_hrtf_wptr, mixerconv_hrtf_data_size, 1, input_mixerconv_bin_file ) != 1 )

        {

            fprintf( stderr, "Reading of the mixer_conv hrtf failed!\n\n" );

            fclose( input_mixerconv_bin_file );

            free( mixerconv_hrtf );

            *hrtf_size = -1;

            return NULL;

        }



        fclose( input_mixerconv_bin_file );

        input_mixerconv_bin_file = NULL;

    }

    else

    {

        fprintf( stderr, "Opening of file %s failed!\n\n", full_in_mixerconv_path );

        *hrtf_size = -1;

        return NULL;

    }



#else // MIXER_CONV_BINARY_FILE_311



    crend_hrtf_tables_dimensions tabs_dims;

    crend_hrtf_tables_pointers tabs_ptrs;
@@ -451,7 +587,6 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
    /* uint32_t total_num_fsamp_per_iteration, iIter, iIndex;

    uint32_t total_num_fsamp_per_iteration_diff; */

    float *coeff_rptr;

    char *hrtf = NULL, *hrtf_wptr;



    memset( &tabs_dims, 0x00, sizeof( crend_hrtf_tables_dimensions ) );

    memset( &tabs_ptrs, 0x00, sizeof( crend_hrtf_tables_pointers ) );
@@ -490,7 +625,7 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
    if ( get_crend_hrtf_tables( rend_type, input_cfg, frequency, &tabs_ptrs, &tabs_dims ) == -1 )

    {

        fprintf( stderr, "Get table failed!\n\n" );

        free( hrtf );

        free( mixerconv_hrtf );

        *hrtf_size = -1;

        return NULL;

    }
@@ -513,85 +648,85 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
    //      Raw data size          (4 bytes)



    *hrtf_size = sizeof( ivas_hrtfs_header_t ) + hrtf_data_size;

    hrtf = (char *) malloc( *hrtf_size );

    if ( hrtf == NULL )

    mixerconv_hrtf = (char *) malloc( *hrtf_size );

    if ( mixerconv_hrtf == NULL )

    {

        fprintf( stderr, "Memory allocation for the block failed!\n\n" );

        *hrtf_size = -1;

        return NULL;

    }



    memset( hrtf, 0x00, *hrtf_size );

    hrtf_wptr = hrtf;

    memset( mixerconv_hrtf, 0x00, *hrtf_size );

    mixerconv_hrtf_wptr = mixerconv_hrtf;



    // Write the HRTF header



    // Renderer type

    memcpy( hrtf_wptr, &( rend_type ), sizeof( int32_t ) );

    hrtf_wptr += sizeof( int32_t );

    memcpy( mixerconv_hrtf_wptr, &( rend_type ), sizeof( int32_t ) );

    mixerconv_hrtf_wptr += sizeof( int32_t );



    // Decoder output format

    memcpy( hrtf_wptr, &( input_cfg ), sizeof( int32_t ) );

    hrtf_wptr += sizeof( int32_t );

    memcpy( mixerconv_hrtf_wptr, &( input_cfg ), sizeof( int32_t ) );

    mixerconv_hrtf_wptr += sizeof( int32_t );



    // Sampling Frequency

    memcpy( hrtf_wptr, &( frequency ), sizeof( int32_t ) );

    hrtf_wptr += sizeof( int32_t );

    memcpy( mixerconv_hrtf_wptr, &( frequency ), sizeof( int32_t ) );

    mixerconv_hrtf_wptr += sizeof( int32_t );



    // Raw data size

    memcpy( hrtf_wptr, &( hrtf_data_size ), sizeof( uint32_t ) );

    hrtf_wptr += sizeof( uint32_t );

    memcpy( mixerconv_hrtf_wptr, &( hrtf_data_size ), sizeof( uint32_t ) );

    mixerconv_hrtf_wptr += sizeof( uint32_t );



    // Write the HRTF raw data



    memcpy( hrtf_wptr, tabs_ptrs.latency_s, sizeof( float ) ); // latency_s

    hrtf_wptr += sizeof( float );

    memcpy( mixerconv_hrtf_wptr, tabs_ptrs.latency_s, sizeof( float ) ); // latency_s

    mixerconv_hrtf_wptr += sizeof( float );



    memcpy( hrtf_wptr, &( tabs_dims.max_num_ir ), sizeof( uint16_t ) ); // max_num_ir

    hrtf_wptr += sizeof( uint16_t );

    memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_num_ir ), sizeof( uint16_t ) ); // max_num_ir

    mixerconv_hrtf_wptr += sizeof( uint16_t );



    uint16_t nchan_bin = BINAURAL_CHANNELS;

    memcpy( hrtf_wptr, &nchan_bin, sizeof( uint16_t ) ); // BINAURAL_CHANNELS

    hrtf_wptr += sizeof( uint16_t );

    memcpy( mixerconv_hrtf_wptr, &nchan_bin, sizeof( uint16_t ) ); // BINAURAL_CHANNELS

    mixerconv_hrtf_wptr += sizeof( uint16_t );



    memcpy( hrtf_wptr, &( tabs_dims.max_num_iterations ), sizeof( int16_t ) ); // max_num_iterations

    hrtf_wptr += sizeof( int16_t );

    memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_num_iterations ), sizeof( int16_t ) ); // max_num_iterations

    mixerconv_hrtf_wptr += sizeof( int16_t );



    data_size_tmp = tabs_dims.max_num_ir * BINAURAL_CHANNELS * sizeof( uint16_t );

    memcpy( hrtf_wptr, tabs_ptrs.num_iterations, data_size_tmp ); // num_iterations

    hrtf_wptr += data_size_tmp;

    memcpy( mixerconv_hrtf_wptr, tabs_ptrs.num_iterations, data_size_tmp ); // num_iterations

    mixerconv_hrtf_wptr += data_size_tmp;



    data_size_tmp = tabs_dims.max_num_ir * BINAURAL_CHANNELS * tabs_dims.max_num_iterations * sizeof( uint16_t );

    memcpy( hrtf_wptr, tabs_ptrs.pIndex_frequency_max, data_size_tmp ); // pIndex_frequency_max

    hrtf_wptr += data_size_tmp;

    memcpy( mixerconv_hrtf_wptr, tabs_ptrs.pIndex_frequency_max, data_size_tmp ); // pIndex_frequency_max

    mixerconv_hrtf_wptr += data_size_tmp;



    memcpy( hrtf_wptr, &( tabs_dims.max_num_iterations_diffuse ), sizeof( int16_t ) ); // max_num_iterations_diffuse

    hrtf_wptr += sizeof( int16_t );

    memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_num_iterations_diffuse ), sizeof( int16_t ) ); // max_num_iterations_diffuse

    mixerconv_hrtf_wptr += sizeof( int16_t );



    if ( tabs_dims.max_num_iterations_diffuse != 0 )

    {

        data_size_tmp = BINAURAL_CHANNELS * sizeof( uint16_t );

        memcpy( hrtf_wptr, tabs_ptrs.num_iterations_diffuse, data_size_tmp ); // num_iterations_diffuse

        hrtf_wptr += data_size_tmp;

        memcpy( mixerconv_hrtf_wptr, tabs_ptrs.num_iterations_diffuse, data_size_tmp ); // num_iterations_diffuse

        mixerconv_hrtf_wptr += data_size_tmp;



        // pIndex_frequency_max_diffuse (the size depends on num_iterations_diffuse)

        for ( iChan = 0; iChan < BINAURAL_CHANNELS; iChan++ )

        {

            data_size_tmp = tabs_ptrs.num_iterations_diffuse[iChan] * sizeof( uint16_t );

            memcpy( hrtf_wptr, tabs_ptrs.pIndex_frequency_max_diffuse, data_size_tmp );

            hrtf_wptr += data_size_tmp;

            memcpy( mixerconv_hrtf_wptr, tabs_ptrs.pIndex_frequency_max_diffuse, data_size_tmp );

            mixerconv_hrtf_wptr += data_size_tmp;

        }

    }



    memcpy( hrtf_wptr, tabs_ptrs.index_frequency_max_diffuse, sizeof( uint16_t ) ); // index_frequency_max_diffuse

    hrtf_wptr += sizeof( uint16_t );

    memcpy( mixerconv_hrtf_wptr, tabs_ptrs.index_frequency_max_diffuse, sizeof( uint16_t ) ); // index_frequency_max_diffuse

    mixerconv_hrtf_wptr += sizeof( uint16_t );



    data_size_tmp = tabs_dims.max_num_ir * sizeof( float );

    memcpy( hrtf_wptr, tabs_ptrs.inv_diffuse_weight, data_size_tmp ); // inv_diffuse_weight

    hrtf_wptr += data_size_tmp;

    memcpy( mixerconv_hrtf_wptr, tabs_ptrs.inv_diffuse_weight, data_size_tmp ); // inv_diffuse_weight

    mixerconv_hrtf_wptr += data_size_tmp;



    memcpy( hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration

    hrtf_wptr += sizeof( uint16_t );

    memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration

    mixerconv_hrtf_wptr += sizeof( uint16_t );



    // coeff_re (The size depends on pIndex_frequency_max)

    for ( iIR = 0, iIndex = 0; iIR < tabs_dims.max_num_ir; iIR++ )
@@ -602,8 +737,8 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
            for ( iIter = 0; iIter < tabs_ptrs.num_iterations[iIR * BINAURAL_CHANNELS + iChan]; iIter++ )

            {

                data_size_tmp = tabs_ptrs.pIndex_frequency_max[iIndex] * sizeof( float );

                memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );

                hrtf_wptr += data_size_tmp;

                memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );

                mixerconv_hrtf_wptr += data_size_tmp;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];

            }

        }
@@ -618,15 +753,15 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
            for ( iIter = 0; iIter < tabs_ptrs.num_iterations[iIR * BINAURAL_CHANNELS + iChan]; iIter++ )

            {

                data_size_tmp = tabs_ptrs.pIndex_frequency_max[iIndex] * sizeof( float );

                memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );

                hrtf_wptr += data_size_tmp;

                memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );

                mixerconv_hrtf_wptr += data_size_tmp;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];

            }

        }

    }



    memcpy( hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration_diff ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration_diff

    hrtf_wptr += sizeof( uint16_t );

    memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration_diff ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration_diff

    mixerconv_hrtf_wptr += sizeof( uint16_t );



    if ( tabs_dims.max_total_num_fsamp_per_iteration_diff != 0 )

    {
@@ -637,8 +772,8 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
            for ( iIter = 0; iIter < tabs_ptrs.num_iterations_diffuse[iChan]; iIter++ )

            {

                data_size_tmp = tabs_ptrs.pIndex_frequency_max_diffuse[iIndex] * sizeof( float );

                memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );

                hrtf_wptr += data_size_tmp;

                memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );

                mixerconv_hrtf_wptr += data_size_tmp;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];

            }

        }
@@ -650,14 +785,16 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
            for ( iIter = 0; iIter < tabs_ptrs.num_iterations_diffuse[iChan]; iIter++ )

            {

                data_size_tmp = tabs_ptrs.pIndex_frequency_max_diffuse[iIndex] * sizeof( float );

                memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );

                hrtf_wptr += data_size_tmp;

                memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );

                mixerconv_hrtf_wptr += data_size_tmp;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];

            }

        }

    }



    return hrtf;

#endif // MIXER_CONV_BINARY_FILE_311



    return mixerconv_hrtf;

}



/*---------------------------------------------------------------------*
@@ -1169,6 +1306,7 @@ char *create_hrtf_parametric( int32_t *hrtf_size ) 
    return hrtf;

}





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

 * get_crend_hrtf_tables()

 *
@@ -1536,6 +1674,7 @@ int32_t compute_crend_hrtf_data_size( crend_hrtf_tables_pointers *hrtf_table_ptr 
    return hrtf_data_size;

}





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

 * check_bin_file()

 *
@@ -1687,14 +1826,6 @@ int16_t check_bin_file( FILE *hrtf_bin_file ) 


int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG input_cfg, int32_t frequency, char *hrtf_data_in, int32_t hrtf_size_in )

{

    int16_t result;

    int32_t hrtf_data_size, ctrl_size, iChan, iIR, iIndex, iIter;

    float *coeff_rptr;

    char *hrtf_data_in_rptr;



    crend_hrtf_tables_dimensions tabs_dims;

    crend_hrtf_tables_pointers tabs_ptrs;



    if ( rend_type == RENDERER_BINAURAL_OBJECTS_TD ||

         rend_type == RENDERER_BINAURAL_FASTCONV || rend_type == RENDERER_BINAURAL_FASTCONV_ROOM ||

         rend_type == RENDERER_BINAURAL_PARAMETRIC || rend_type == RENDERER_BINAURAL_PARAMETRIC_ROOM )
@@ -1702,6 +1833,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
        return 0;

    }



    int16_t result;

    int32_t hrtf_data_size, ctrl_size, iChan, iIR, iIndex, iIter, iCtrl;

    float *coeff_rptr;

    char *hrtf_data_in_rptr;



    crend_hrtf_tables_dimensions tabs_dims;

    crend_hrtf_tables_pointers tabs_ptrs;



    memset( &tabs_dims, 0x00, sizeof( crend_hrtf_tables_dimensions ) );

    memset( &tabs_ptrs, 0x00, sizeof( crend_hrtf_tables_pointers ) );
@@ -1830,6 +1969,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
        fprintf( stderr, "check_hrtf_data of binary file failed: bad inv_diffuse_weight!\n\n" );

        return -1;

    }

    /*for ( iCtrl = 0; iCtrl < tabs_dims.max_num_ir;  iCtrl++)

    {

        if ( fabs( tabs_ptrs.inv_diffuse_weight[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )

        {

            fprintf( stderr, "check_hrtf_data of binary file failed: bad inv_diffuse_weight!\n\n" );

            return -1;

        }

    }*/

    hrtf_data_in_rptr += ctrl_size;



    // max_total_num_fsamp_per_iteration
@@ -1854,6 +2001,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
                    fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_re!\n\n" );

                    return -1;

                }                

                /*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max[iIndex];  iCtrl++)

                {

                    if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )

                    {

                        fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_re!\n\n" );

                        return -1;

                    }

                }*/

                hrtf_data_in_rptr += ctrl_size;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];

            }
@@ -1875,6 +2030,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
                    fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_re!\n\n" );

                    return -1;

                }     

                /*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max[iIndex];  iCtrl++)

                {

                    if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )

                    {

                        fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_im!\n\n" );

                        return -1;

                    }

                }*/

                hrtf_data_in_rptr += ctrl_size;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];

            }
@@ -1903,6 +2066,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
                    fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_re!\n\n" );

                    return -1;

                }

                /*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max_diffuse[iIndex];  iCtrl++)

                {

                    if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )

                    {

                        fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_re!\n\n" );

                        return -1;

                    }

                }*/

                hrtf_data_in_rptr += ctrl_size;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];

            }
@@ -1916,10 +2087,18 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in 
            {

                ctrl_size = tabs_ptrs.pIndex_frequency_max_diffuse[iIndex] * sizeof( float );

                if ( memcmp( coeff_rptr, hrtf_data_in_rptr, ctrl_size ) != 0 )

                {

                    fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_re!\n\n" );

                    return -1;

                }

                /*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max_diffuse[iIndex];  iCtrl++)

                {

                    if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )

                    {

                        fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_im!\n\n" );

                        return -1;

                    }

                }*/

                hrtf_data_in_rptr += ctrl_size;

                coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];

            }
@@ -2049,6 +2228,21 @@ int rom2bin_init( int argc, char *argv[] ) 
            strcpy( input_td_bin_path, argv[i] );

            i++;

        }

#ifdef MIXER_CONV_BINARY_FILE_311

        else if ( strcmp( to_upper( argv[i] ), "-INPUT_MIXERCONV_FILE_PATH" ) == 0 )

        {

            i++;

            if ( strlen( argv[i] ) == 0 )

            {

                fprintf( stderr, "Wrong input mixer_conv file path: %s\n\n", argv[i] );

                usage_tables_format_converter();

                return -1;

            }

            input_mixerconv_bin_path = malloc( strlen( argv[i] ) + 1 );

            strcpy( input_mixerconv_bin_path, argv[i] );

            i++;

        }

#endif

        else if ( strcmp( to_upper( argv[i] ), "-INPUT_TD_FILE_NAME" ) == 0 )

        {

            i++;
@@ -2062,6 +2256,21 @@ int rom2bin_init( int argc, char *argv[] ) 
            strcpy( input_td_bin_file_name, argv[i] );

            i++;

        }

#ifdef MIXER_CONV_BINARY_FILE_311

        else if ( strcmp( to_upper( argv[i] ), "-INPUT_MIXERCONV_FILE_NAME" ) == 0 )

        {

            i++;

            if ( strlen( argv[i] ) == 0 )

            {

                fprintf( stderr, "Wrong input mixer_conv file name: %s\n\n", argv[i] );

                usage_tables_format_converter();

                return -1;

            }

            input_mixerconv_bin_file_name = malloc( strlen( argv[i] ) + 1 );

            strcpy( input_mixerconv_bin_file_name, argv[i] );

            i++;

        }

#endif

        else

        {

            fprintf( stderr, "Unknown option: %s\n\n", argv[i] );
@@ -2102,13 +2311,11 @@ int rom2bin_init( int argc, char *argv[] ) 


    if ( selected_frequency == 0 )

    {



        full_out_path = (char *) malloc( sizeof( char ) * ( strlen( output_path ) + strlen( output_file_name ) + strlen( DEFAULT_BIN_FILE_EXT ) + 1 ) );

        sprintf( full_out_path, "%s%s%s", output_path, output_file_name, DEFAULT_BIN_FILE_EXT );

    }

    else

    {



        nb_freq = 1;

        for ( i = 0; i < IVAS_NB_SAMPLERATE; i++ )

        {
@@ -2133,7 +2340,6 @@ int rom2bin_init( int argc, char *argv[] ) 


    if ( input_td_bin_path != NULL )

    {



        if ( input_td_bin_file_name == NULL )

        {

            input_td_bin_file_name = (char *) malloc( sizeof( char ) * ( strlen( DEFAULT_INPUT_TD_BIN_FILE ) + 1 ) );
@@ -2158,6 +2364,34 @@ int rom2bin_init( int argc, char *argv[] ) 
        }

    }



#ifdef MIXER_CONV_BINARY_FILE_311

    if ( input_mixerconv_bin_path != NULL )

    {

        if ( input_mixerconv_bin_file_name == NULL )

        {

            input_mixerconv_bin_file_name = (char *) malloc( sizeof( char ) * ( strlen( DEFAULT_INPUT_MIXERCONV_BIN_FILE ) + 1 ) );

            if ( input_mixerconv_bin_file_name )

            {

                strcpy( input_mixerconv_bin_file_name, DEFAULT_INPUT_MIXERCONV_BIN_FILE );

            }

            else

            {

                fprintf( stderr, "Memory issue for input mixer_conv bin file name!\n\n" );

                rom2bin_terminat();

                return -1;

            }

        }



        full_in_mixerconv_path = (char *) malloc( sizeof( char ) * ( strlen( input_mixerconv_bin_path ) + strlen( input_mixerconv_bin_file_name ) + 3 + 2*MIXERCONV_BIN_FILE_CFG_MAX_LEN + 5 + strlen( DEFAULT_BIN_FILE_EXT ) + 1 ) );

        if ( full_in_mixerconv_path == NULL )

        {

            fprintf( stderr, "Memory issue for full input mixer_conv path!\n\n" );

            rom2bin_terminat();

            return -1;

        }

    }

#endif



    return 0;

}
@@ -2197,6 +2431,25 @@ void rom2bin_terminat( void ) 
    {

        free( full_in_td_path );

    }



#ifdef MIXER_CONV_BINARY_FILE_311



    if ( input_mixerconv_bin_path != NULL )

    {

        free( input_mixerconv_bin_path );

    }



    if ( input_mixerconv_bin_file_name != NULL )

    {

        free( input_mixerconv_bin_file_name );

    }



    if ( full_in_mixerconv_path != NULL )

    {

        free( full_in_mixerconv_path );

    }



#endif

}



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

scripts/binauralRenderer_interface/generate_crend_ivas_tables_from_sofa.c

+756 −7

File changed.

Preview size limit exceeded, changes collapsed.