normal mode works for ISM now

from ivas_processing_scripts.audiotools import audio

from ivas_processing_scripts.audiotools.audiofile import write, read

from ivas_processing_scripts.audiotools.wrappers.bs1770 import loudness_norm

from ivas_processing_scripts.audiotools.metadata import write_ISM_metadata_in_file

class Processing_splitting_scaling(Processing):

            out_file_noerror = Path(f"{out_file.with_suffix('')}.noerror.wav")

            x_noerror, _ = read(in_file_noerror, nchannels=num_channels, fs=self.fs)

        # read metadata

        if isinstance(audio.fromtype(self.out_fmt), audio.ObjectBasedAudio):

            meta_arrays = []

            for meta in in_meta:

                meta_arrays.append(np.genfromtxt(meta, delimiter=","))

        else:

            meta_arrays = None

        # cut preamble and split file

        out_files, file_splits, out_meta, meta_splits = self.revert_preamble_concatenation(x, fs, in_file, out_file, meta_arrays, False, logger)

        if self.tx_condition:

            in_meta_noerror = None  # TODO

            out_files_noerror, file_splits_noerror, meta_splits_noerror = self.revert_preamble_concatenation(x_noerror, fs, in_file_noerror, out_file_noerror, in_meta_noerror, True)

            out_files_noerror, file_splits_noerror, out_meta_noerror, meta_splits_noerror = self.revert_preamble_concatenation(x_noerror, fs, in_file_noerror, out_file_noerror, in_meta_noerror, True)

        # scale splitted files

        if self.loudness:

            if self.tx_condition:

                # do special scaling -> measure noerror loudness and apply scaling to signal with error

                scaling_splits = measure_loudness(file_splits_noerror, self.out_fmt, fs, self.loudness, self.loudness_fmt, meta_splits, logger)

                scaling_splits = measure_loudness(file_splits_noerror, self.out_fmt, fs, self.loudness, self.loudness_fmt, meta_splits_noerror, logger)

                file_splits = [f*loud for f, loud in zip(file_splits, scaling_splits)]

            else:

                file_splits = adjust_loudness(file_splits, self.out_fmt, fs, self.loudness, self.loudness_fmt, meta_splits, logger)

            else:

                f_out = Path(str(f).replace(tmp_name, out_name).replace(".processing_splitting_scaling.", "."))

            out_out_files.append(f_out)

            if meta_splits:

                # TODO ISM

                pass

        if isinstance(audio.fromtype(self.out_fmt), audio.ObjectBasedAudio):

            out_out_meta = []

            for f in out_out_files:

                oom = []

                for idx in range(num_channels):

                    f_out = f.with_suffix(f".wav.{idx}.csv")

                    oom.append(f_out)

                out_out_meta.append(oom)

        else:

            out_out_meta = repeat(None)

        # write file(s) in tmp and output folder

        for of, oof, file_s, meta_s in zip(out_files, out_out_files, file_splits, meta_splits):

        for of, oof, file_s, om, oom, meta_s in zip(out_files, out_out_files, file_splits, out_meta, out_out_meta, meta_splits):

            write(of, file_s, fs)

            write(oof, file_s, fs)

            if meta_s:

                pass  # TODO ISM

            if isinstance(audio.fromtype(self.out_fmt), audio.ObjectBasedAudio):

                write_ISM_metadata_in_file(meta_s, om)

                write_ISM_metadata_in_file(meta_s, oom)

    def revert_preamble_concatenation(self, x, fs, in_file, out_file, in_meta, noerror=False, logger=None):

        # remove preamble and first half of signal due to repetition

            # set new out_files

            out_files = [in_file.parent.joinpath(sn).with_suffix(f".{self.name}.wav") for sn in split_names]

            out_meta = [in_file.parent.joinpath(sn).with_suffix(f".{self.name}.wav") for sn in split_names]  # TODO ISM

            if isinstance(audio.fromtype(self.out_fmt), audio.ObjectBasedAudio):

                out_meta = []

                for of in out_files:

                    of_list = []

                    for idx in range(x.shape[1]):

                        of_list.append(of.with_suffix(f".wav.{idx}.csv"))

                    out_meta.append(of_list)

            else:

                out_meta = repeat(None)

            if self.tx_condition:

                file_splits_noerror, meta_splits_noerror = concat_teardown(x, splits, self.out_fmt, fs, split_fs, logger)

        else:

            out_files = [out_file]

            file_splits = [x]

            meta_splits = repeat(None)  # TODO

            out_meta = repeat(None)  # TODO

            if isinstance(audio.fromtype(self.out_fmt), audio.ObjectBasedAudio):

                meta_splits = [in_meta]

                out_meta = [[out_file.with_suffix(f".wav.{idx}.csv") for idx in range(x.shape[1])]]

            else:

                meta_splits = repeat(None)

                out_meta = repeat(None)

            if self.tx_condition:

                file_splits_noerror = None  # TODO

                meta_splits_noerror = None  # TODO