Commit 885d16e8 authored by multrus's avatar multrus
Browse files

Merge branch... 

Merge branch '1398-compilation-errors-for-split-rendering-code-when-debugging-is-enabled' into 'main'

Resolve "Compilation errors for split-rendering code when DEBUGGING is enabled"

See merge request !2252
parents a0a09106 903b5aff

.gitignore

+2 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ IVAS_cod 
IVAS_dec

IVAS_rend

ISAR_post_rend

ambi_converter

obj/

*.a

*.o
@@ -18,6 +19,7 @@ IVAS_cod.exe 
IVAS_dec.exe

IVAS_rend.exe

ISAR_post_rend.exe

ambi_converter.exe

*.user

.vs/

Debug_*/

apps/decoder.c

+0 −61
Original line number Diff line number Diff line
@@ -127,7 +127,6 @@ typedef struct 
    bool tsmEnabled;

    IVAS_RENDER_FRAMESIZE renderFramesize;

#ifdef DEBUGGING

    IVAS_DEC_FORCED_REND_MODE forcedRendMode;

#ifdef DEBUG_FOA_AGC

    FILE *agcBitstream; /* temporary */

#endif
@@ -180,7 +179,6 @@ static ivas_error load_hrtf_from_file( IVAS_DEC_HRTF_BINARY_WRAPPER *hHrtfBinary 
#ifdef DEBUGGING

static ivas_error printBitstreamInfoVoip( DecArguments arg, BS_READER_HANDLE hBsReader, IVAS_DEC_HANDLE hIvasDec );

static int16_t app_own_random( int16_t *seed );

static IVAS_DEC_FORCED_REND_MODE parseForcedRendModeDec( char *forcedRendModeChar );

#endif

static void do_object_editing( IVAS_EDITABLE_PARAMETERS *editableParameters, ObjectEditFileReader *objectEditFileReader );
@@ -537,28 +535,6 @@ int main( 
#endif

    }



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

     * Binaural rendering mode: set and print info

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



    if ( arg.forcedRendMode != IVAS_DEC_FORCE_REND_UNFORCED )

    {

        if ( ( error = IVAS_DEC_SetForcedRendMode( hIvasDec, arg.forcedRendMode ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nError: Forcing binaural rendering mode failed (only TDREND and CLDFBREND are expected).\n\n" );

            goto cleanup;

        }



        if ( arg.forcedRendMode == IVAS_DEC_FORCE_REND_TD_RENDERER )

        {

            fprintf( stdout, "Forcing rendering to:   TD renderer\n" );

        }

        else if ( arg.forcedRendMode == IVAS_DEC_FORCE_REND_CLDFB_RENDERER )

        {

            fprintf( stdout, "Forcing rendering to:   CLDFB renderer\n" );

        }

    }



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

     * Open Error pattern file for simulation

     *-----------------------------------------------------------------*/
@@ -965,7 +941,6 @@ static bool parseCmdlIVAS_dec( 
#ifdef DEBUGGING

    float ftmp;



    arg->forcedRendMode = IVAS_DEC_FORCE_REND_UNFORCED;

#ifdef DEBUG_FOA_AGC

    arg->agcBitstream = NULL;

#endif
@@ -1135,17 +1110,6 @@ static bool parseCmdlIVAS_dec( 
            }

            i += 2;

        }

        else if ( strcmp( argv_to_upper, "-FORCE" ) == 0 )

        {

            i++;

            if ( i < argc - 3 )

            {

                strncpy( argv_to_upper, argv[i], sizeof( argv_to_upper ) - 1 );

                argv_to_upper[sizeof( argv_to_upper ) - 1] = '\0';

                arg->forcedRendMode = parseForcedRendModeDec( argv_to_upper );

                i++;

            }

        }

#ifdef DEBUG_MODE_INFO

#ifdef DEBUG_MODE_INFO_TWEAK

        /* Define additional subfolder for debug info output in ./res */
@@ -3900,31 +3864,6 @@ static void do_object_editing( 
}





#ifdef DEBUGGING



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

 * parseForcedRendModeDec()

 *

 *

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



static IVAS_DEC_FORCED_REND_MODE parseForcedRendModeDec(

    char *forcedRendModeChar )

{

    if ( ( strcmp( to_upper( forcedRendModeChar ), "TDREND" ) == 0 ) )

    {

        return IVAS_DEC_FORCE_REND_TD_RENDERER;

    }

    if ( ( strcmp( to_upper( forcedRendModeChar ), "CLDFBREND" ) == 0 ) )

    {

        return IVAS_DEC_FORCE_REND_CLDFB_RENDERER;

    }



    return IVAS_DEC_FORCE_REND_UNDEFINED;

}

#endif





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

 * load_hrtf_from_file()

 *

lib_com/ivas_prot.h

+0 −14
Original line number Diff line number Diff line
@@ -5161,20 +5161,6 @@ ivas_error ivas_allocate_binaural_hrtf( 
    const int16_t allocate_init_flag                            /* i  : Memory allocation flag                          */

);



#ifdef DEBUGGING

void ivas_binaural_cldfb(

    Decoder_Struct *st_ivas,                                    /* i/o: IVAS decoder structure                                  */

    float *output_f[]                                           /* i/o: synthesized core-coder transport channels/DirAC output  */

);



void ivas_binaural_cldfb_sf(

    Decoder_Struct *st_ivas,                                    /* i/o: IVAS decoder structure                                  */

    const int16_t n_samples_to_render,                          /* i  : output frame length per channel                         */

    const int16_t slot_size,                                    /* i  : JBM slot size                                           */

    float *output_f[]                                           /* i/o: synthesized core-coder transport channels/DirAC output  */

);

#endif



void ivas_binRenderer(

    BINAURAL_RENDERER_HANDLE hBinRenderer,                      /* i/o: binaural renderer handle                                */

    const MULTI_BIN_REND_POSE_DATA *pMultiBinPoseData,          /* i/o: pose correction data handle                             */

lib_dec/ivas_binRenderer_internal.c

+0 −287
Original line number Diff line number Diff line
@@ -1281,293 +1281,6 @@ void ivas_binaural_add_LFE( 
}





#ifdef DEBUGGING

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

 * ivas_binaural_cldfb()

 *

 * Perform CLDFB analysis, fastconv binaural rendering and CLDFB synthesis

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



void ivas_binaural_cldfb(

    Decoder_Struct *st_ivas, /* i/o: IVAS decoder structure                                  */

    float *output_f[]        /* i/o: synthesized core-coder transport channels/DirAC output  */

)

{

    float Cldfb_RealBuffer[MAX_INTERN_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    float Cldfb_ImagBuffer[MAX_INTERN_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    float Cldfb_RealBuffer_Binaural[MAX_HEAD_ROT_POSES][BINAURAL_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    float Cldfb_ImagBuffer_Binaural[MAX_HEAD_ROT_POSES][BINAURAL_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    int16_t slot_idx, subframeIdx, index_slot, idx_in, idx_lfe, maxBand, ch;



    /* Implement a 5 msec loops */

    maxBand = (int16_t) ( ( CLDFB_NO_CHANNELS_MAX * st_ivas->hDecoderConfig->output_Fs ) / 48000 );



    for ( subframeIdx = 0; subframeIdx < ( CLDFB_NO_COL_MAX / MAX_PARAM_SPATIAL_SUBFRAMES ); subframeIdx++ )

    {

        for ( slot_idx = 0; slot_idx < MAX_PARAM_SPATIAL_SUBFRAMES; slot_idx++ )

        {

            index_slot = subframeIdx * MAX_PARAM_SPATIAL_SUBFRAMES + slot_idx;



            /* Implement CLDFB analysis */

            idx_in = 0;

            idx_lfe = 0;



            for ( ch = 0; ch < ( st_ivas->hIntSetup.nchan_out_woLFE + st_ivas->hIntSetup.num_lfe ); ch++ )

            {

                if ( ( st_ivas->hIntSetup.num_lfe > 0 ) && ( st_ivas->hIntSetup.index_lfe[idx_lfe] == ch ) )

                {

                    if ( idx_lfe < ( st_ivas->hIntSetup.num_lfe - 1 ) )

                    {

                        idx_lfe++;

                    }

                }

                else

                {

                    cldfbAnalysis_ts( &( output_f[ch][maxBand * index_slot] ), Cldfb_RealBuffer[idx_in][slot_idx], Cldfb_ImagBuffer[idx_in][slot_idx], maxBand, st_ivas->cldfbAnaDec[idx_in] );

                    idx_in++;

                }

            }

            /*LFE handling for split rendering cases*/

            if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM )

            {

                for ( idx_lfe = 0; idx_lfe < st_ivas->hIntSetup.num_lfe; idx_lfe++ )

                {

                    ch = st_ivas->hIntSetup.index_lfe[idx_lfe];

                    cldfbAnalysis_ts( &( output_f[ch][maxBand * index_slot] ), Cldfb_RealBuffer[idx_in][slot_idx], Cldfb_ImagBuffer[idx_in][slot_idx], maxBand, st_ivas->cldfbAnaDec[idx_in] );

                    idx_in++;

                }



                if ( st_ivas->hSplitBinRend->hCldfbDataOut != NULL )

                {

                    for ( ch = 0; ch < ( st_ivas->hIntSetup.nchan_out_woLFE + st_ivas->hIntSetup.num_lfe ); ch++ )

                    {

                        mvr2r( Cldfb_RealBuffer[ch][slot_idx], st_ivas->hSplitBinRend->hCldfbDataOut->Cldfb_RealBuffer[ch][( subframeIdx * JBM_CLDFB_SLOTS_IN_SUBFRAME ) + slot_idx], maxBand );

                        mvr2r( Cldfb_ImagBuffer[ch][slot_idx], st_ivas->hSplitBinRend->hCldfbDataOut->Cldfb_ImagBuffer[ch][( subframeIdx * JBM_CLDFB_SLOTS_IN_SUBFRAME ) + slot_idx], maxBand );

                    }

                    st_ivas->hSplitBinRend->hCldfbDataOut->config = st_ivas->hIntSetup.output_config;

                }

            }

        }



        /* Implement binaural rendering */

        ivas_binRenderer(

            st_ivas->hBinRenderer,

            &st_ivas->hSplitBinRend->splitrend.multiBinPoseData,

            st_ivas->hCombinedOrientationData,

            JBM_CLDFB_SLOTS_IN_SUBFRAME,

#ifdef SPLIT_REND_WITH_HEAD_ROT_DEBUG

            NULL,

#endif

            Cldfb_RealBuffer_Binaural, Cldfb_ImagBuffer_Binaural,

            Cldfb_RealBuffer, Cldfb_ImagBuffer );



        if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM )

        {

            int16_t pos_idx;

            for ( slot_idx = 0; slot_idx < JBM_CLDFB_SLOTS_IN_SUBFRAME; slot_idx++ )

            {

                if ( st_ivas->hIntSetup.num_lfe > 0 )

                {

                    v_multc( Cldfb_RealBuffer[st_ivas->hIntSetup.nchan_out_woLFE][slot_idx], GAIN_LFE, Cldfb_RealBuffer[st_ivas->hIntSetup.nchan_out_woLFE][slot_idx], maxBand );

                    v_multc( Cldfb_ImagBuffer[st_ivas->hIntSetup.nchan_out_woLFE][slot_idx], GAIN_LFE, Cldfb_ImagBuffer[st_ivas->hIntSetup.nchan_out_woLFE][slot_idx], maxBand );

                }

            }



            for ( pos_idx = 0; pos_idx < st_ivas->hBinRenderer->numPoses; pos_idx++ )

            {

                for ( slot_idx = 0; slot_idx < JBM_CLDFB_SLOTS_IN_SUBFRAME; slot_idx++ )

                {

                    for ( ch = 0; ch < st_ivas->hDecoderConfig->nchan_out; ch++ )

                    {

                        if ( st_ivas->hIntSetup.num_lfe > 0 )

                        {

                            v_add( Cldfb_RealBuffer_Binaural[pos_idx][ch][slot_idx],

                                   Cldfb_RealBuffer[st_ivas->hIntSetup.nchan_out_woLFE][slot_idx],

                                   Cldfb_RealBuffer_Binaural[pos_idx][ch][slot_idx],

                                   maxBand );



                            v_add( Cldfb_ImagBuffer_Binaural[pos_idx][ch][slot_idx],

                                   Cldfb_ImagBuffer[st_ivas->hIntSetup.nchan_out_woLFE][slot_idx],

                                   Cldfb_ImagBuffer_Binaural[pos_idx][ch][slot_idx],

                                   maxBand );

                        }



                        mvr2r( Cldfb_RealBuffer_Binaural[pos_idx][ch][slot_idx], st_ivas->hSplitBinRend->hMultiBinCldfbData->Cldfb_RealBuffer_Binaural[( pos_idx * BINAURAL_CHANNELS ) + ch][( subframeIdx * JBM_CLDFB_SLOTS_IN_SUBFRAME ) + slot_idx], maxBand );

                        mvr2r( Cldfb_ImagBuffer_Binaural[pos_idx][ch][slot_idx], st_ivas->hSplitBinRend->hMultiBinCldfbData->Cldfb_ImagBuffer_Binaural[( pos_idx * BINAURAL_CHANNELS ) + ch][( subframeIdx * JBM_CLDFB_SLOTS_IN_SUBFRAME ) + slot_idx], maxBand );

                    }

                }

            }

        }



        /* update combined orientation access index */

        ivas_combined_orientation_update_index( st_ivas->hCombinedOrientationData, maxBand * MAX_PARAM_SPATIAL_SUBFRAMES );



        /* Implement CLDFB synthesis */

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

        {

            float *RealBuffer[MAX_PARAM_SPATIAL_SUBFRAMES];

            float *ImagBuffer[MAX_PARAM_SPATIAL_SUBFRAMES];



            index_slot = subframeIdx * MAX_PARAM_SPATIAL_SUBFRAMES;



            for ( slot_idx = 0; slot_idx < MAX_PARAM_SPATIAL_SUBFRAMES; slot_idx++ )

            {

                RealBuffer[slot_idx] = Cldfb_RealBuffer_Binaural[0][ch][slot_idx];

                ImagBuffer[slot_idx] = Cldfb_ImagBuffer_Binaural[0][ch][slot_idx];

            }



            cldfbSynthesis( RealBuffer, ImagBuffer, &( output_f[ch][index_slot * maxBand] ), maxBand * MAX_PARAM_SPATIAL_SUBFRAMES, st_ivas->cldfbSynDec[ch] );

        }

    }



    return;

}





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

 * ivas_binaural_cldfb_sf()

 *

 * Perform CLDFB analysis, fastconv binaural rendering and CLDFB synthesis

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



void ivas_binaural_cldfb_sf(

    Decoder_Struct *st_ivas,           /* i/o: IVAS decoder structure                                  */

    const int16_t n_samples_to_render, /* i  : output frame length per channel                         */

    const int16_t slot_size,           /* i  : JBM slot size                                           */

    float *output_f[]                  /* i/o: synthesized core-coder transport channels/DirAC output  */

)

{

    float Cldfb_RealBuffer[MAX_INTERN_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    float Cldfb_ImagBuffer[MAX_INTERN_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    float Cldfb_RealBuffer_Binaural[MAX_HEAD_ROT_POSES][BINAURAL_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    float Cldfb_ImagBuffer_Binaural[MAX_HEAD_ROT_POSES][BINAURAL_CHANNELS][MAX_PARAM_SPATIAL_SUBFRAMES][CLDFB_NO_CHANNELS_MAX];

    int16_t slot_idx, subframeIdx, index_slot, idx_in, idx_lfe, maxBand, ch;

    int16_t slots_to_render, first_sf, last_sf;

    int16_t slot_index_start, slot_index_start_cldfb;



    /* Implement a 5 msec loops */

    maxBand = (int16_t) ( ( CLDFB_NO_CHANNELS_MAX * st_ivas->hDecoderConfig->output_Fs ) / 48000 );



    /* loop for synthesis, assume we always have to render in multiples of 5ms subframes with spills */

    slots_to_render = min( st_ivas->hTcBuffer->num_slots - st_ivas->hTcBuffer->slots_rendered, n_samples_to_render / slot_size );

    first_sf = st_ivas->hTcBuffer->subframes_rendered;

    last_sf = first_sf;

    slot_index_start = st_ivas->hTcBuffer->slots_rendered;

    slot_index_start_cldfb = 0;

    st_ivas->hTcBuffer->slots_rendered += slots_to_render;



    while ( slots_to_render > 0 )

    {

        slots_to_render -= st_ivas->hTcBuffer->subframe_nbslots[last_sf];

        last_sf++;

    }

    for ( subframeIdx = first_sf; subframeIdx < last_sf; subframeIdx++ )

    {

        for ( slot_idx = 0; slot_idx < st_ivas->hTcBuffer->subframe_nbslots[subframeIdx]; slot_idx++ )

        {

            index_slot = slot_index_start + slot_idx;



            /* Implement CLDFB analysis */

            idx_in = 0;

            idx_lfe = 0;



            for ( ch = 0; ch < ( st_ivas->hIntSetup.nchan_out_woLFE + st_ivas->hIntSetup.num_lfe ); ch++ )

            {

                if ( ( st_ivas->hIntSetup.num_lfe > 0 ) && ( st_ivas->hIntSetup.index_lfe[idx_lfe] == ch ) )

                {

                    if ( idx_lfe < ( st_ivas->hIntSetup.num_lfe - 1 ) )

                    {

                        idx_lfe++;

                    }

                }

                else

                {

                    cldfbAnalysis_ts( &( st_ivas->hTcBuffer->tc[ch][maxBand * index_slot] ), Cldfb_RealBuffer[idx_in][slot_idx], Cldfb_ImagBuffer[idx_in][slot_idx], maxBand, st_ivas->cldfbAnaDec[idx_in] );

                    idx_in++;

                }

            }



            /*LFE handling for split rendering cases*/

            if ( ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED ) ||

                 ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM ) )

            {

                for ( idx_lfe = 0; idx_lfe < st_ivas->hIntSetup.num_lfe; idx_lfe++ )

                {

                    ch = st_ivas->hIntSetup.index_lfe[idx_lfe];

                    cldfbAnalysis_ts( &( output_f[ch][maxBand * index_slot] ), Cldfb_RealBuffer[idx_in][slot_idx], Cldfb_ImagBuffer[idx_in][slot_idx], maxBand, st_ivas->cldfbAnaDec[idx_in] );

                    idx_in++;

                }



                if ( st_ivas->hSplitBinRend->hCldfbDataOut != NULL )

                {

                    for ( ch = 0; ch < ( st_ivas->hIntSetup.nchan_out_woLFE + st_ivas->hIntSetup.num_lfe ); ch++ )

                    {

                        mvr2r( Cldfb_RealBuffer[ch][slot_idx], st_ivas->hSplitBinRend->hCldfbDataOut->Cldfb_RealBuffer[ch][slot_index_start + slot_idx], maxBand );

                        mvr2r( Cldfb_ImagBuffer[ch][slot_idx], st_ivas->hSplitBinRend->hCldfbDataOut->Cldfb_ImagBuffer[ch][slot_index_start + slot_idx], maxBand );

                    }

                    st_ivas->hSplitBinRend->hCldfbDataOut->config = st_ivas->hIntSetup.output_config;

                }

            }

        }



        /* Implement binaural rendering */

        ivas_binRenderer(

            st_ivas->hBinRenderer,

            &st_ivas->hSplitBinRend->splitrend.multiBinPoseData,

            st_ivas->hCombinedOrientationData,

            st_ivas->hTcBuffer->subframe_nbslots[subframeIdx],

#ifdef SPLIT_REND_WITH_HEAD_ROT_DEBUG

            NULL,

#endif

            Cldfb_RealBuffer_Binaural,

            Cldfb_ImagBuffer_Binaural,

            Cldfb_RealBuffer,

            Cldfb_ImagBuffer );



        if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED || st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM )

        {

            int16_t pos_idx;

            for ( pos_idx = 0; pos_idx < st_ivas->hBinRenderer->numPoses; pos_idx++ )

            {

                for ( slot_idx = 0; slot_idx < st_ivas->hTcBuffer->subframe_nbslots[subframeIdx]; slot_idx++ )

                {

                    for ( ch = 0; ch < st_ivas->hDecoderConfig->nchan_out; ch++ )

                    {

                        mvr2r( Cldfb_RealBuffer_Binaural[pos_idx][ch][slot_idx], st_ivas->hSplitBinRend->hMultiBinCldfbData->Cldfb_RealBuffer_Binaural[( pos_idx * BINAURAL_CHANNELS ) + ch][slot_index_start + slot_idx], maxBand );

                        mvr2r( Cldfb_ImagBuffer_Binaural[pos_idx][ch][slot_idx], st_ivas->hSplitBinRend->hMultiBinCldfbData->Cldfb_ImagBuffer_Binaural[( pos_idx * BINAURAL_CHANNELS ) + ch][slot_index_start + slot_idx], maxBand );

                    }

                }

            }

        }



        /* update combined orientation access index */

        ivas_combined_orientation_update_index( st_ivas->hCombinedOrientationData, maxBand * st_ivas->hTcBuffer->subframe_nbslots[subframeIdx] );



        /* Implement CLDFB synthesis */

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

        {

            float *RealBuffer[MAX_PARAM_SPATIAL_SUBFRAMES];

            float *ImagBuffer[MAX_PARAM_SPATIAL_SUBFRAMES];



            for ( slot_idx = 0; slot_idx < st_ivas->hTcBuffer->subframe_nbslots[subframeIdx]; slot_idx++ )

            {

                RealBuffer[slot_idx] = Cldfb_RealBuffer_Binaural[0][ch][slot_idx];

                ImagBuffer[slot_idx] = Cldfb_ImagBuffer_Binaural[0][ch][slot_idx];

            }



            cldfbSynthesis( RealBuffer, ImagBuffer, &( output_f[ch][slot_index_start_cldfb * maxBand] ), maxBand * st_ivas->hTcBuffer->subframe_nbslots[subframeIdx], st_ivas->cldfbSynDec[ch] );

        }

        slot_index_start += st_ivas->hTcBuffer->subframe_nbslots[subframeIdx];

        slot_index_start_cldfb += st_ivas->hTcBuffer->subframe_nbslots[subframeIdx];

    }



    st_ivas->hTcBuffer->subframes_rendered = last_sf;



    return;

}

#endif





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

 * ivas_binRenderer()

 *

lib_dec/ivas_init_dec.c

+0 −13
Original line number Diff line number Diff line
@@ -1164,8 +1164,6 @@ ivas_error ivas_init_decoder_front( 


#ifdef DEBUGGING

    st_ivas->noClipping = 0;



    st_ivas->hDecoderConfig->force_rend = -1;

#endif

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

     * Allocate and initialize Custom loudspeaker layout handle
@@ -3206,17 +3204,6 @@ static ivas_error doSanityChecks_IVAS( 
    {

        return IVAS_ERROR( IVAS_ERR_OBJECTS_EDITING_AND_PANNING_NOT_SUPPORTED, "Wrong set-up: Only object editing or Non-diegetic panning can be used." );

    }

#ifdef DEBUGGING

    if ( ( st_ivas->hDecoderConfig->force_rend == FORCE_TD_RENDERER ) && ( ( st_ivas->ivas_format != MC_FORMAT && st_ivas->ivas_format != ISM_FORMAT ) || ( output_config != IVAS_AUDIO_CONFIG_BINAURAL && output_config != IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB ) || ( st_ivas->ivas_format == ISM_FORMAT && st_ivas->ism_mode == ISM_MODE_PARAM ) || ( st_ivas->ivas_format == MC_FORMAT && st_ivas->mc_mode != MC_MODE_MCT ) ) )

    {

        return IVAS_ERROR( IVAS_ERR_INVALID_OUTPUT_FORMAT, "Incorrect output configuration: Time Domain object renderer not supported in this configuration" );

    }



    if ( ( st_ivas->hHrtfTD != NULL && st_ivas->hDecoderConfig->force_rend == FORCE_CLDFB_RENDERER ) )

    {

        return IVAS_ERROR( IVAS_ERR_INVALID_FORCE_MODE, "Incorrect debug configuration: Cannot force CLDFB renderer in combination with TD renderer HRTF file" );

    }

#endif



    return IVAS_ERR_OK;

}