Merge remote-tracking branch 'remotes/origin/main' into 1322-correction_of_float_buffers_number

    if ( arg.hrtfReaderEnabled )

    {

        /* sanity check */

#ifdef NONBE_1293_SR_HRTF

        if ( arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL && arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR && arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB && arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED && arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM )

#else

        if ( arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL && arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR && arg.outputConfig != IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )

#endif

        {

            arg.hrtfReaderEnabled = false;

            fprintf( stderr, "\nError: HRTF binary file cannot be used in this output configuration.\n\n" );

#define NONBE_1244_FIX_SWB_BWE_MEMORY                   /* VA: issue 1244: fix to SWB BWE memory in case of switching from FB coding - pending a review by Huawei */ 

#define NONBE_1122_KEEP_EVS_MODE_UNCHANGED              /* FhG: Disables fix for issue 1122 in EVS mode to keep BE tests green. This switch should be removed once the 1122 fix is added to EVS via a CR.  */

#define NONBE_1300_TDREND_LARGE_ITD                     /* Eri: issue 1300: There was a bug feeding 1.25 ms frames to the TD renderer, causing out-of-buffer access. This was resolved. However, it is still possible that modeled HRTF with large ITDs could trigger out-of-buffer access. This adds a check to prevent this.*/

#define NONBE_1293_SR_HRTF                              /* VA: issue 1293: add support of external HRTFs in split rendering */

/* ##################### End NON-BE switches ########################### */

            )

        search_path = toolsdir.joinpath(curr_platform.replace("Windows", "Win32"))

        wdiff = search_path.joinpath("wav-diff").with_suffix(".exe" if curr_platform == "Windows" else "")

        wdiff = search_path.joinpath("wav-diff").with_suffix(

            ".exe" if curr_platform == "Windows" else ""

        )

        if not wdiff.exists():

            wdiff = shutil.which("wav-diff")

                wavfile.write(str(tmpfile_test), 48000, test_tmp)

                del test_tmp

            else:

                wavfile.write(str(tmpfile_ref), 48000, ref)

                wavfile.write(str(tmpfile_test), 48000, test)

                wavfile.write(str(tmpfile_ref), 48000, ref.astype(np.int16))

                wavfile.write(str(tmpfile_test), 48000, test.astype(np.int16))

            cmd = [

                str(wdiff),

        result["MLD"] = mld_max

    # Run remanining tests after checking if the lenght differs

    lengths_differ = ref.shape[0] != test.shape[0]

        fr_sig[idx_min] = -32768

def get_framewise(x: np.ndarray, chunk_size: int, zero_pad=False) -> np.ndarray:

def get_framewise(

    x: np.ndarray, chunk_size: int, zero_pad=False, scale_fac=1.0

) -> np.ndarray:

    """Generator to yield a signal frame by frame

        If array size is not a multiple of chunk_size, last frame contains the remainder

        Size of frames to yield

    zero_pad: bool

        Whether to zero pad the last chunk if there are not enough samples

    scale_fac: float

        scale returned chunks with this factor

    Yields

    -------

    """

    n_frames = x.shape[0] // chunk_size

    for i in range(n_frames):

        yield x[i * chunk_size : (i + 1) * chunk_size, :]

        yield x[i * chunk_size : (i + 1) * chunk_size, :] * scale_fac

    if x.shape[0] % chunk_size:

        last_chunk = x[n_frames * chunk_size :, :]

        last_chunk = x[n_frames * chunk_size :, :] * scale_fac

        if zero_pad:

            yield np.pad(

                last_chunk, [[0, chunk_size - (x.shape[0] % chunk_size)], [0, 0]]

    """

    Calculate Segmental SNR for test_sig to ref_sig as defined in ISO/IEC 14496-4

    """

    ss = list()

    ref_sig_norm = ref_sig / -np.iinfo(np.int16).min

    test_sig_norm = test_sig / -np.iinfo(np.int16).min

    # check if diff of signal is zero already, then SNR is infinite, since no noise

    diff_sig_norm = ref_sig_norm - test_sig_norm

    if np.all(diff_sig_norm == 0):

        return np.asarray([np.inf] * ref_sig_norm.shape[1])

    signals_equal = (ref_sig == test_sig).all()

    if signals_equal:

        return np.asarray([np.inf] * ref_sig.shape[1])

    channels_identical_idx = np.sum(np.abs(diff_sig_norm), axis=0) == 0

    n_channels = ref_sig.shape[1]

    channels_identical_idx = np.asarray(

        [(ref_sig[:, c] == test_sig[:, c]).all() for c in range(n_channels)]

    )

    # iterate over test signal too to allow power comparison to threshold

    ss = list()

    denom_add = 10**-13 * len_seg

    segment_counter = np.zeros(ref_sig.shape[1])

    # iterate over test signal too to allow power comparison to threshold

    for ref_seg, diff_seg, test_seg in zip(

        get_framewise(ref_sig_norm, len_seg, zero_pad=True),

        get_framewise(diff_sig_norm, len_seg, zero_pad=True),

        get_framewise(test_sig_norm, len_seg, zero_pad=True),

    # apply normalization factor on the chunks to avoid big reallocation of the whole signal

    norm_fac = 1 / -np.iinfo(np.int16).min

    for ref_seg, test_seg in zip(

        get_framewise(ref_sig, len_seg, zero_pad=True, scale_fac=norm_fac),

        get_framewise(test_sig, len_seg, zero_pad=True, scale_fac=norm_fac),

    ):

        nrg_ref = np.sum(ref_seg**2, axis=0)

        nrg_diff = np.sum(diff_seg**2, axis=0)

        nrg_diff = np.sum((test_seg - ref_seg) ** 2, axis=0)

        ss_seg = np.log10(1 + nrg_ref / (denom_add + nrg_diff))