added background noise

        tmp_sta_file = tmp_dir.joinpath("sta")

        # compute seed

        seed = random_seed(master_seed, prerun_seed)

        seed = random_seed((0, 99999999), master_seed, prerun_seed)

        # open file and modify

        lines = []

#  the United Nations Convention on Contracts on the International Sales of Goods.

#

from typing import Optional

from typing import Optional, Tuple

from ivas_processing_scripts.utils import find_binary, run

def random_seed(

    range: Tuple[int, int],

    master_seed: Optional[int] = 0,

    prerun_seed: Optional[int] = 0,

    hexa: Optional[bool] = True,

        "-d",

        str(prerun_seed),

        "-r",  # value range for results

        str(0),

        str(99999999),

        str(range[0]),

        str(range[1]),

    ]

    # run command

            "snr": background_cfg.get("snr", None),

            "background_noise_path": background_cfg.get("background_noise_path", None),

            "seed_delay": background_cfg.get("seed_delay", 0),

            "master_seed": cfg.master_seed,

            "output_fmt": cfg.postprocessing["fmt"],

        }

    else:

            {

                "in_fs": tmp_in_fs,

                "in_fmt": tmp_in_fmt,

                "out_fmt": cfg.postprocessing["fmt"],

                "concatenate_input": pre2_cfg.get("concatenate_input", False),

                "concatenation_order": pre2_cfg.get("concatenation_order", None),

                "preamble": pre2_cfg.get("preamble", 0),

import logging

from pathlib import Path

import numpy as np

from warnings import warn

from ivas_processing_scripts.processing.processing import Processing

from ivas_processing_scripts.audiotools.audiofile import read, write

from ivas_processing_scripts.audiotools.audioarray import trim

from ivas_processing_scripts.audiotools.audioarray import trim, delay

from ivas_processing_scripts.audiotools import audio

from ivas_processing_scripts.audiotools.metadata import add_remove_preamble, write_ISM_metadata_in_file

from ivas_processing_scripts.audiotools.wrappers.bs1770 import get_loudness, loudness_norm

from ivas_processing_scripts.audiotools.wrappers.random_seed import random_seed

class Preprocessing2(Processing):

        logger.debug(f"Preprocessing2 {in_file.absolute()} -> {out_file.absolute()}")

        # load in file

        number_channels = audio.fromtype(self.in_fmt).num_channels

        x, fs = read(in_file, fs=self.in_fs, nchannels=number_channels)

        audio_object = audio.fromfile(self.in_fmt, in_file, fs=self.in_fs, in_meta=in_meta)

        # add preamble

        if self.preamble:

            # also apply preamble to ISM metadata

            if self.in_fmt.startswith("ISM"):

                # read out old

                metadata = []

                for meta in in_meta:

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

                # modify metadata

                metadata = add_remove_preamble(metadata, self.preamble)

                write_ISM_metadata_in_file(metadata, [out_file], True)

            x = trim(x, fs, (-self.preamble, 0), self.pad_noise_preamble)

                meta_files = write_ISM_metadata_in_file(metadata, [out_file], True)

                # modify audio object

                audio_object.metadata_files = meta_files

                audio_object.obect_pos = metadata

            # add preamble to actual signal

            audio_object.audio = trim(audio_object.audio, audio_object.fs, (-self.preamble, 0), self.pad_noise_preamble)

        # add background noise

        if self.background_noise:

            x = self.add_background_noise(x)

            audio_object.audio = self.add_background_noise(audio_object, in_meta)

        # save file

        write(out_file, x, fs=fs)

        write(out_file, audio_object.audio, fs=audio_object.fs)

        return

    def add_background_noise(self, audio_array) -> np.ndarray:

        # TODO

        return np.zeros()

    def add_background_noise(self, audio_object: audio.Audio, in_meta) -> np.ndarray:

        # range for random delay

        range_delay = (1, 2400000)

        # load background noise

        noise_object = audio.fromfile(self.in_fmt, self.background_noise["background_noise_path"], fs=self.in_fs, in_meta=in_meta)

        # if noise is too short raise error

        if len(noise_object.audio) < len(audio_object.audio):

            raise ValueError("Background noise too short for audio signal")

        if len(noise_object.audio) - range_delay[1] < len(audio_object.audio):

            warn("Background noise may be to short for audio signal when considering the random delay")

        # measure loudness of audio signal based on output format

        tmp_object = audio.fromtype(self.out_fmt)

        if isinstance(tmp_object, audio.ObjectBasedAudio) or isinstance(tmp_object, audio.SceneBasedAudio) or isinstance(tmp_object, audio.MetadataAssistedSpatialAudio):

            out_format = None

        else:

            out_format = self.out_fmt

        loudness_signal, _ = get_loudness(audio_object, loudness_format=out_format)

        # compute desired loudness of background noise

        loudness_noise = loudness_signal - self.background_noise["snr"]

        # apply random delay and cut signal

        rand_delay = random_seed(range=range_delay, master_seed=self.background_noise["master_seed"], prerun_seed=self.background_noise["seed_delay"], hexa=False)

        noise_object.audio = delay(noise_object.audio, delay=-rand_delay, samples=True, fs=noise_object.fs)[:len(audio_object.audio)]

        # scale background noise to desired loudness based on output format

        noise_object.audio = loudness_norm(noise_object, loudness_noise, out_format)

        # add array to signal

        audio_object.audio = noise_object.audio + audio_object.audio

        return audio_object.audio

                cfg.split_names,

                cfg.splits,

                output_format,

                meta_files=cfg.metadata_path[0]

            )

            out_meta.append(out_meta_paths)

def reverse_process_2(cfg, logger):

    # remove preamble

    if cfg.pre2.preamble:  # TODO: remove preamble for ISM

    if cfg.pre2.preamble:

        remove_preamble(cfg)

    # reverse concatenation