Add dedicated bgm separation app

app.py

@@ -343,6 +343,7 @@ class App:
                     btn_openfolder.click(fn=lambda: self.open_folder(os.path.join(self.args.output_dir, "translations")),
                                          inputs=None,
                                          outputs=None)
+
                 with gr.TabItem("BGM Separation"):
                     files_audio = gr.Files(type="filepath", label="Upload Audio Files to separate background music")
                     dd_uvr_device = gr.Dropdown(label="Device", value=self.whisper_inf.music_separator.device,
@@ -351,21 +352,30 @@ class App:
                                                     choices=self.whisper_inf.music_separator.available_models)
                     nb_uvr_segment_size = gr.Number(label="Segment Size", value=uvr_params["segment_size"], precision=0)
                     cb_uvr_save_file = gr.Checkbox(label="Save separated files to output",
-                                                   value=uvr_params["save_file"])
+                                                   value=True, visible=False)
                     btn_run = gr.Button("SEPARATE BACKGROUND MUSIC", variant="primary")
-                    with gr.Row():
-                        with gr.Column(scale=8):
-                            ad_instrumental = gr.Audio(label="Instrumental")
-                            ad_vocals = gr.Audio(label="Vocals")
-                        with gr.Column(scale=1):
-                            btn_openfolder = gr.Button('📂', scale=1)
+                    with gr.Column():
+                        with gr.Row():
+                            ad_instrumental = gr.Audio(label="Instrumental", scale=8)
+                            btn_open_instrumental_folder = gr.Button('📂', scale=1)
+                        with gr.Row():
+                            ad_vocals = gr.Audio(label="Vocals", scale=8)
+                            btn_open_vocals_folder = gr.Button('📂', scale=1)
 
-                    btn_run.click(fn=self.whisper_inf.music_separator.separate,
-                                  inputs=[files_audio, dd_uvr_device, dd_uvr_model_size, nb_uvr_segment_size, cb_uvr_save_file],
+                    btn_run.click(fn=self.whisper_inf.music_separator.separate_files,
+                                  inputs=[files_audio, dd_uvr_model_size, dd_uvr_device, nb_uvr_segment_size,
+                                          cb_uvr_save_file],
                                   outputs=[ad_instrumental, ad_vocals])
-                    btn_openfolder.click(inputs=None,
-                                         outputs=None,
-                                         fn=lambda: self.open_folder(os.path.join(self.args.output_dir, "uvr")))
+                    btn_open_instrumental_folder.click(inputs=None,
+                                                       outputs=None,
+                                                       fn=lambda: self.open_folder(os.path.join(
+                                                           self.args.output_dir, "UVR", "instrumental"
+                                                       )))
+                    btn_open_vocals_folder.click(inputs=None,
+                                                 outputs=None,
+                                                 fn=lambda: self.open_folder(os.path.join(
+                                                    self.args.output_dir, "UVR", "vocals"
+                                                 )))
 
         # Launch the app with optional gradio settings
         args = self.args
@@ -386,7 +396,8 @@ class App:
         if os.path.exists(folder_path):
             os.system(f"start {folder_path}")
         else:
-            print(f"The folder {folder_path} does not exist.")
+            os.makedirs(folder_path, exist_ok=True)
+            print(f"The directory path {folder_path} has newly created.")
 
     @staticmethod
     def on_change_models(model_size: str):

modules/uvr/music_separator.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Optional, Union, List, Dict
 import numpy as np
 import torchaudio
 import soundfile as sf
@@ -9,6 +9,8 @@ import gradio as gr
 from datetime import datetime
 
 from uvr.models import MDX, Demucs, VrNetwork, MDXC
+from modules.utils.paths import DEFAULT_PARAMETERS_CONFIG_PATH
+from modules.utils.files_manager import load_yaml, save_yaml
 
 
 class MusicSeparator:
@@ -61,7 +63,7 @@ class MusicSeparator:
                  device: Optional[str] = None,
                  segment_size: int = 256,
                  save_file: bool = False,
-                 progress: gr.Progress = gr.Progress()) -> tuple[np.ndarray, np.ndarray]:
+                 progress: gr.Progress = gr.Progress()) -> tuple[np.ndarray, np.ndarray, List]:
         """
         Separate the background music from the audio.
 
@@ -74,7 +76,10 @@ class MusicSeparator:
             progress (gr.Progress): Gradio progress indicator.
 
         Returns:
-            tuple[np.ndarray, np.ndarray]: Instrumental and vocals numpy arrays.
+            A Tuple of
+            np.ndarray: Instrumental numpy arrays.
+            np.ndarray: Vocals numpy arrays.
+            file_paths: List of file paths where the separated audio is saved. Return empty when save_file is False.
         """
         if isinstance(audio, str):
             self.audio_info = torchaudio.info(audio)
@@ -108,13 +113,37 @@ class MusicSeparator:
         result = self.model(audio)
         instrumental, vocals = result["instrumental"].T, result["vocals"].T
 
+        file_paths = []
         if save_file:
             instrumental_output_path = os.path.join(self.output_dir, "instrumental", f"{output_filename}-instrumental{ext}")
             vocals_output_path = os.path.join(self.output_dir, "vocals", f"{output_filename}-vocals{ext}")
             sf.write(instrumental_output_path, instrumental, sample_rate, format="WAV")
             sf.write(vocals_output_path, vocals, sample_rate, format="WAV")
-
-        return instrumental, vocals
+            file_paths += [instrumental_output_path, vocals_output_path]
+
+        return instrumental, vocals, file_paths
+
+    def separate_files(self,
+                       files: List,
+                       model_name: str,
+                       device: Optional[str] = None,
+                       segment_size: int = 256,
+                       save_file: bool = True,
+                       progress: gr.Progress = gr.Progress()) -> List[str]:
+        """Separate the background music from the audio files. Returns only last Instrumental and vocals file paths
+        to display into gr.Audio()"""
+        self.cache_parameters(model_size=model_name, segment_size=segment_size)
+
+        for file_path in files:
+            instrumental, vocals, file_paths = self.separate(
+                audio=file_path,
+                model_name=model_name,
+                device=device,
+                segment_size=segment_size,
+                save_file=save_file,
+                progress=progress
+            )
+        return file_paths
 
     @staticmethod
     def get_device():
@@ -130,3 +159,16 @@ class MusicSeparator:
             torch.cuda.empty_cache()
         gc.collect()
         self.audio_info = None
+
+    @staticmethod
+    def cache_parameters(model_size: str,
+                         segment_size: int):
+        cached_params = load_yaml(DEFAULT_PARAMETERS_CONFIG_PATH)
+        cached_uvr_params = cached_params["bgm_separation"]
+        uvr_params_to_cache = {
+            "model_size": model_size,
+            "segment_size": segment_size
+        }
+        cached_uvr_params = {**cached_uvr_params, **uvr_params_to_cache}
+        cached_params = {**cached_params, **cached_uvr_params}
+        save_yaml(cached_params, DEFAULT_PARAMETERS_CONFIG_PATH)

modules/whisper/whisper_base.py

@@ -111,7 +111,7 @@ class WhisperBase(ABC):
             params.lang = language_code_dict[params.lang]
 
         if params.is_bgm_separate:
-            music, audio = self.music_separator.separate(
+            music, audio, _ = self.music_separator.separate(
                 audio=audio,
                 model_name=params.uvr_model_size,
                 device=params.uvr_device,