Merge branch 'main' of https://forge.3gpp.org/rep/ivas-codec-pc/ivas-codec

    framesize = fs // 50

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

    test_orig = test.copy()

    ref_orig = ref.copy()

    if lengths_differ:

        if handle_differing_lengths == "fail":

            raise RuntimeError(

                f"Input signals have different lengths: ref - {ref.shape[0]}, test - {test.shape[0]}"

            )

        elif handle_differing_lengths == "cut":

            min_len = min(ref.shape[0], test.shape[0])

            ref = ref[:min_len, :]

            test = test[:min_len, :]

        elif handle_differing_lengths == "pad":

            max_len = max(ref.shape[0], test.shape[0])

            ref = np.pad(

                ref,

                ((0, max_len - ref.shape[0]), (0, 0)),

                mode="constant",

                constant_values=0,

            )

            test = np.pad(

                test,

                ((0, max_len - test.shape[0]), (0, 0)),

                mode="constant",

                constant_values=0,

            )

    diff = abs(test - ref)

    max_diff = int(diff.max())

    # Init result dict

    result = {

        "bitexact": True,

        "max_abs_diff": 0,

        result["nframes_diff"] = 0

        result["nframes_diff_percentage"] = 0.0

    if max_diff != 0:

        if diff.ndim == 1:

            nsamples_total = diff.shape

            nchannels = 1

        else:

            nsamples_total, nchannels = diff.shape

        max_diff_pos = np.nonzero(diff == max_diff)

        max_diff_pos = [

            max_diff_pos[0][0],

            max_diff_pos[0][0] // framesize,

            max_diff_pos[1][0],

        ]

        first_diff_pos = np.nonzero(diff)

        first_diff_pos = [

            first_diff_pos[0][0],

            first_diff_pos[0][0] // framesize,

            first_diff_pos[1][0],

        ]

        nsamples_diff = np.nonzero(diff)[0].size

        nsamples_diff_percentage = nsamples_diff / (nsamples_total * nchannels) * 100.0

        nframes = nsamples_total // framesize

        nframes_diff = 0

        result = {

            "bitexact": False,

            "max_abs_diff": max_diff,

            "max_abs_diff_pos_sample": max_diff_pos[0],

            "max_abs_diff_pos_channel": max_diff_pos[2],

            "nsamples_diff": nsamples_diff,

            "nsamples_diff_percentage": nsamples_diff_percentage,

            "first_diff_pos_sample": first_diff_pos[0],

            "first_diff_pos_channel": first_diff_pos[2],

            "first_diff_pos_frame": first_diff_pos[1],

        }

        if per_frame:

            for fr in range(nframes):

                diff_fr = diff[fr * framesize : ((fr + 1) * framesize), :]

                nframes_diff += 1 if diff_fr.nonzero()[0].size > 0 else 0

            nframes_diff_percentage = nframes_diff / nframes * 100.0

            result["max_abs_diff_pos_frame"] = max_diff_pos[1]

            result["nframes_diff"] = nframes_diff

            result["nframes_diff_percentage"] = nframes_diff_percentage

    # MLD (wav-diff) tool is run first, since it uses the input signals without length difference check for JBM test cases.

    if get_mld:

        def parse_wav_diff(proc: subprocess.CompletedProcess) -> float:

            tmpfile_test = Path(tmpdir).joinpath("test.wav")

            ### need to resample to 48kHz for MLD computation to be correct

            ### write out and delete tmp variables to reduce memory usage

            if fs != 48000:

                ref_tmp = np.clip(

                        resample(ref_orig.astype(float), fs, 48000), -32768, 32767

                    )

                    resample(ref.astype(float), fs, 48000), -32768, 32767

                ).astype(np.int16)

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

                del ref_tmp

                test_tmp = np.clip(

                        resample(test_orig.astype(float), fs, 48000), -32768, 32767

                    )

                    resample(test.astype(float), fs, 48000), -32768, 32767

                ).astype(np.int16)

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

                del test_tmp

            else:

                    ref_tmp = ref_orig.copy()

                    test_tmp = test_orig.copy()

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

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

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

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

            cmd = [

                str(wdiff),

        result["MLD"] = mld_max

    # Run remanining tests after checking if the lenght differs

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

    if lengths_differ:

        if handle_differing_lengths == "fail":

            raise RuntimeError(

                f"Input signals have different lengths: ref - {ref.shape[0]}, test - {test.shape[0]}"

            )

        elif handle_differing_lengths == "cut":

            min_len = min(ref.shape[0], test.shape[0])

            ref = ref[:min_len, :]

            test = test[:min_len, :]

        elif handle_differing_lengths == "pad":

            max_len = max(ref.shape[0], test.shape[0])

            ref = np.pad(

                ref,

                ((0, max_len - ref.shape[0]), (0, 0)),

                mode="constant",

                constant_values=0,

            )

            test = np.pad(

                test,

                ((0, max_len - test.shape[0]), (0, 0)),

                mode="constant",

                constant_values=0,

            )

    diff = abs(test - ref)

    max_diff = int(diff.max())

    if max_diff != 0:

        if diff.ndim == 1:

            nsamples_total = diff.shape

            nchannels = 1

        else:

            nsamples_total, nchannels = diff.shape

        max_diff_pos = np.nonzero(diff == max_diff)

        max_diff_pos = [

            max_diff_pos[0][0],

            max_diff_pos[0][0] // framesize,

            max_diff_pos[1][0],

        ]

        first_diff_pos = np.nonzero(diff)

        first_diff_pos = [

            first_diff_pos[0][0],

            first_diff_pos[0][0] // framesize,

            first_diff_pos[1][0],

        ]

        nsamples_diff = np.nonzero(diff)[0].size

        nsamples_diff_percentage = nsamples_diff / (nsamples_total * nchannels) * 100.0

        nframes = nsamples_total // framesize

        nframes_diff = 0

        result["bitexact"] = False

        result["max_abs_diff"] = max_diff

        result["max_abs_diff_pos_sample"] = max_diff_pos[0]

        result["max_abs_diff_pos_channel"] = max_diff_pos[2]

        result["nsamples_diff"] = nsamples_diff

        result["nsamples_diff_percentage"] = nsamples_diff_percentage

        result["first_diff_pos_sample"] = first_diff_pos[0]

        result["first_diff_pos_channel"] = first_diff_pos[2]

        result["first_diff_pos_frame"] = first_diff_pos[1]

        if per_frame:

            for fr in range(nframes):

                diff_fr = diff[fr * framesize : ((fr + 1) * framesize), :]

                nframes_diff += 1 if diff_fr.nonzero()[0].size > 0 else 0

            nframes_diff_percentage = nframes_diff / nframes * 100.0

            result["max_abs_diff_pos_frame"] = max_diff_pos[1]

            result["nframes_diff"] = nframes_diff

            result["nframes_diff_percentage"] = nframes_diff_percentage

        if get_ssnr:

            # length of segment is always 20ms

            len_seg = int(0.02 * fs)