Add inference mode selector: Full / MDX Only / RVC Only

- Added 'inference_mode' parameter to song_cover_pipeline and process_song
with three options:
'full' - MDX separation + RVC voice conversion (default, existing behavior)
'mdx' - MDX separation only, skip RVC (outputs separated vocals)
'rvc' - RVC voice conversion only, skip MDX (uses input as vocals)
- Added Radio dropdown in webui.py for inference mode selection
- Voice model dropdown hides when MDX Only mode is selected
- Added --mode CLI argument with choices: full, mdx, rvc
- --rvc-dirname is no longer required for mdx mode
- MDX-only outputs: separated vocals without effects/mixing
- RVC-only outputs: converted vocals with effects, no instrumental mixing
- Full mode: unchanged (MDX + RVC + effects + mixing)

src/main.py

@@ -313,29 +313,64 @@ def combine_audio(audio_paths, output_path, main_gain, backup_gain, inst_gain, o
 def process_song(
     song_dir, song_input, mdx_model_params, song_id, is_webui, input_type, progress,
     keep_files, pitch_change, pitch_change_all, voice_model, index_rate, filter_radius,
-    volume_envelope, protect, f0_method, hop_length, output_format, keep_orig, orig_song_path
+    volume_envelope, protect, f0_method, hop_length, output_format, keep_orig, orig_song_path,
+    inference_mode='full'
 ):
+    """
+    Process a song through the AI cover pipeline.
 
-    if not os.path.exists(song_dir):
-        os.makedirs(song_dir)
-        orig_song_path, vocals_path, instrumentals_path, main_vocals_path, backup_vocals_path, main_vocals_dereverb_path = preprocess_song(song_input, mdx_model_params, song_id, is_webui, input_type, progress, keep_orig, orig_song_path)
-    else:
-        vocals_path, main_vocals_path = None, None
-        paths = get_audio_paths(song_dir)
+    inference_mode controls which stages are executed:
+      'full'   - MDX separation + RVC voice conversion (default)
+      'mdx'    - MDX separation only, skip RVC (outputs separated vocals)
+      'rvc'    - RVC voice conversion only, use input audio directly as vocals
+    """
+    instrumentals_path = None
+    backup_vocals_path = None
+    vocals_path = None
+    main_vocals_path = None
+    main_vocals_dereverb_path = None
 
-        # if any of the audio files aren't available or keep intermediate files, rerun preprocess
-        if any(path is None for path in paths):
+    # --- MDX Separation Stage ---
+    # Run MDX for 'full' and 'mdx' modes; skip for 'rvc' mode
+    if inference_mode in ('full', 'mdx'):
+        if not os.path.exists(song_dir):
+            os.makedirs(song_dir)
             orig_song_path, vocals_path, instrumentals_path, main_vocals_path, backup_vocals_path, main_vocals_dereverb_path = preprocess_song(song_input, mdx_model_params, song_id, is_webui, input_type, progress, keep_orig, orig_song_path)
         else:
-            orig_song_path, instrumentals_path, main_vocals_dereverb_path, backup_vocals_path = paths
+            vocals_path, main_vocals_path = None, None
+            paths = get_audio_paths(song_dir)
+
+            # if any of the audio files aren't available or keep intermediate files, rerun preprocess
+            if any(path is None for path in paths):
+                orig_song_path, vocals_path, instrumentals_path, main_vocals_path, backup_vocals_path, main_vocals_dereverb_path = preprocess_song(song_input, mdx_model_params, song_id, is_webui, input_type, progress, keep_orig, orig_song_path)
+            else:
+                orig_song_path, instrumentals_path, main_vocals_dereverb_path, backup_vocals_path = paths
+    else:
+        # RVC-only mode: use the original audio as vocals directly
+        # No MDX separation — the input audio IS the vocals
+        main_vocals_dereverb_path = orig_song_path
+        # We still need placeholder paths for the downstream pipeline
+        vocals_path = orig_song_path
+        main_vocals_path = orig_song_path
+        # Create a simple instrumental by treating the original as instrumental too
+        # (will be ignored in RVC-only output mixing)
+        instrumentals_path = orig_song_path
+        backup_vocals_path = orig_song_path
 
     pitch_change = pitch_change * 12 + pitch_change_all
     ai_vocals_path = os.path.join(song_dir, f'{os.path.splitext(os.path.basename(orig_song_path))[0]}_{voice_model}_p{pitch_change}_i{index_rate}_fr{filter_radius}_ve{volume_envelope}_pro{protect}_{f0_method}{"" if "crepe" not in f0_method else f"_{hop_length}"}.wav')
     ai_cover_path = os.path.join(song_dir, f'{os.path.splitext(os.path.basename(orig_song_path))[0]} ({voice_model} Ver).{output_format}')
 
-    if not os.path.exists(ai_vocals_path):
-        display_progress('[~] Converting voice using RVC...', 0.5, is_webui, progress)
-        voice_change(voice_model, main_vocals_dereverb_path, ai_vocals_path, pitch_change, f0_method, index_rate, filter_radius, volume_envelope, protect, hop_length, is_webui)
+    # --- RVC Voice Conversion Stage ---
+    # Run RVC for 'full' and 'rvc' modes; skip for 'mdx' mode
+    if inference_mode in ('full', 'rvc'):
+        if not os.path.exists(ai_vocals_path):
+            display_progress('[~] Converting voice using RVC...', 0.5, is_webui, progress)
+            voice_change(voice_model, main_vocals_dereverb_path, ai_vocals_path, pitch_change, f0_method, index_rate, filter_radius, volume_envelope, protect, hop_length, is_webui)
+    elif inference_mode == 'mdx':
+        # MDX-only mode: the "AI vocals" are just the dereverbed main vocals (no RVC)
+        ai_vocals_path = main_vocals_dereverb_path
+        display_progress('[~] MDX separation complete (RVC skipped).', 0.6, is_webui, progress)
 
     return ai_vocals_path, ai_cover_path, instrumentals_path, backup_vocals_path, vocals_path, main_vocals_path
 
@@ -384,7 +419,7 @@ def song_cover_pipeline(song_input, voice_model, pitch_change, keep_files,
                         is_webui=0, main_gain=0, backup_gain=0, inst_gain=0, index_rate=0.5, filter_radius=3,
                         volume_envelope=0.25, f0_method='rmvpe', hop_length=128, protect=0.33, pitch_change_all=0,
                         reverb_rm_size=0.15, reverb_wet=0.2, reverb_dry=0.8, reverb_damping=0.7, output_format='mp3',
-                        extra_denoise=False,
+                        extra_denoise=False, inference_mode='full',
                         progress=gr.Progress()):
     if not keep_files or IS_ZERO_GPU:
         clean_old_folders("./song_output", 14400)
@@ -393,8 +428,10 @@ def song_cover_pipeline(song_input, voice_model, pitch_change, keep_files,
         clean_old_folders("./rvc_models", 10800)
 
     try:
-        if not song_input or not voice_model:
-            raise_exception('Ensure that the song input field and voice model field is filled.', is_webui)
+        if not song_input:
+            raise_exception('Ensure that the song input field is filled.', is_webui)
+        if inference_mode in ('full', 'rvc') and not voice_model:
+            raise_exception('A voice model is required for Full Inference and RVC Only modes.', is_webui)
 
         display_progress('[~] Starting AI Cover Generation Pipeline...', 0, is_webui, progress)
 
@@ -455,6 +492,7 @@ def song_cover_pipeline(song_input, voice_model, pitch_change, keep_files,
             output_format,
             keep_orig,
             orig_song_path,
+            inference_mode,
         )
 
         end = time.time()
@@ -467,6 +505,27 @@ def song_cover_pipeline(song_input, voice_model, pitch_change, keep_files,
             print(f"Warning: Could not read audio duration from {ai_vocals_path}: {sf_err}")
             print("The RVC inference may have produced an invalid output file. Continuing with effects processing...")
 
+        # --- Post-processing: Effects, mixing, and output ---
+        # The post-processing differs based on inference_mode
+        if inference_mode == 'mdx':
+            # MDX-only: output the separated vocals without effects or mixing
+            # Just export the dereverbed main vocals as the final output
+            display_progress('[~] Exporting separated vocals (MDX Only mode)...', 0.8, is_webui, progress)
+            ai_cover_path = os.path.join(song_dir, f'{os.path.splitext(os.path.basename(orig_song_path))[0]} (MDX Separated).{output_format}')
+            # Export the separated vocals as the cover
+            main_vocal_audio = AudioSegment.from_wav(ai_vocals_path)
+            main_vocal_audio.export(ai_cover_path, format=output_format)
+
+            if not keep_files:
+                display_progress('[~] Removing intermediate audio files...', 0.95, is_webui, progress)
+                intermediate_files = [vocals_path, main_vocals_path]
+                for file in intermediate_files:
+                    if file and os.path.exists(file):
+                        os.remove(file)
+
+            return ai_cover_path
+
+        # For 'full' and 'rvc' modes: apply effects, mix, and output
         display_progress('[~] Applying audio effects to Vocals...', 0.8, is_webui, progress)
 
         nr_path = ai_vocals_path  # get_audio_with_suffix(song_dir, "_nr.wav")
@@ -475,6 +534,23 @@ def song_cover_pipeline(song_input, voice_model, pitch_change, keep_files,
 
         ai_vocals_mixed_path = add_audio_effects(ai_vocals_path, reverb_rm_size, reverb_wet, reverb_dry, reverb_damping)
 
+        if inference_mode == 'rvc':
+            # RVC-only: output just the converted vocals with effects, no mixing
+            display_progress('[~] Exporting RVC vocals (RVC Only mode)...', 0.9, is_webui, progress)
+            ai_cover_path = os.path.join(song_dir, f'{os.path.splitext(os.path.basename(orig_song_path))[0]} (RVC Only).{output_format}')
+            main_vocal_audio = AudioSegment.from_wav(ai_vocals_mixed_path)
+            main_vocal_audio.export(ai_cover_path, format=output_format)
+
+            if not keep_files:
+                display_progress('[~] Removing intermediate audio files...', 0.95, is_webui, progress)
+                intermediate_files = [ai_vocals_mixed_path, nr_path]
+                for file in intermediate_files:
+                    if file and os.path.exists(file):
+                        os.remove(file)
+
+            return ai_cover_path
+
+        # Full mode: mix AI vocals with instrumentals and backup vocals
         ins_path = get_audio_with_suffix(song_dir, "_Voiceless.wav")
         if not ins_path:
             instrumentals_path, _ = run_mdx(
@@ -518,7 +594,7 @@ def song_cover_pipeline(song_input, voice_model, pitch_change, keep_files,
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Generate a AI cover song in the song_output/id directory.', add_help=True)
     parser.add_argument('-i', '--song-input', type=str, required=True, help='Link to a YouTube video or the filepath to a local mp3/wav file to create an AI cover of')
-    parser.add_argument('-dir', '--rvc-dirname', type=str, required=True, help='Name of the folder in the rvc_models directory containing the RVC model file and optional index file to use')
+    parser.add_argument('-dir', '--rvc-dirname', type=str, default='', help='Name of the folder in the rvc_models directory containing the RVC model file and optional index file to use. Required for "full" and "rvc" modes.')
     parser.add_argument('-p', '--pitch-change', type=int, required=True, help='Change the pitch of AI Vocals only. Generally, use 1 for male to female and -1 for vice-versa. (Octaves)')
     parser.add_argument('-k', '--keep-files', action=argparse.BooleanOptionalAction, help='Whether to keep all intermediate audio files generated in the song_output/id directory, e.g. Isolated Vocals/Instrumentals')
     parser.add_argument('-ir', '--index-rate', type=float, default=0.5, help='A decimal number e.g. 0.5, used to reduce/resolve the timbre leakage problem. If set to 1, more biased towards the timbre quality of the training dataset')
@@ -536,11 +612,18 @@ if __name__ == '__main__':
     parser.add_argument('-rdry', '--reverb-dryness', type=float, default=0.8, help='Reverb dry level between 0 and 1')
     parser.add_argument('-rdamp', '--reverb-damping', type=float, default=0.7, help='Reverb damping between 0 and 1')
     parser.add_argument('-oformat', '--output-format', type=str, default='mp3', help='Output format of audio file. mp3 for smaller file size, wav for best quality')
+    parser.add_argument('-m', '--mode', type=str, default='full', choices=['full', 'mdx', 'rvc'],
+                        help='Inference mode: "full" = MDX separation + RVC voice conversion (default), '
+                             '"mdx" = MDX separation only (skip RVC), '
+                             '"rvc" = RVC voice conversion only (skip MDX, use input as vocals)')
     args = parser.parse_args()
 
     rvc_dirname = args.rvc_dirname
-    if not os.path.exists(os.path.join(rvc_models_dir, rvc_dirname)):
-        raise Exception(f'The folder {os.path.join(rvc_models_dir, rvc_dirname)} does not exist.')
+    if args.mode in ('full', 'rvc'):
+        if not rvc_dirname:
+            raise Exception('A voice model directory (-dir) is required for "full" and "rvc" modes.')
+        if not os.path.exists(os.path.join(rvc_models_dir, rvc_dirname)):
+            raise Exception(f'The folder {os.path.join(rvc_models_dir, rvc_dirname)} does not exist.')
 
     cover_path = song_cover_pipeline(args.song_input, rvc_dirname, args.pitch_change, args.keep_files,
                                      main_gain=args.main_vol, backup_gain=args.backup_vol, inst_gain=args.inst_vol,
@@ -550,5 +633,5 @@ if __name__ == '__main__':
                                      pitch_change_all=args.pitch_change_all,
                                      reverb_rm_size=args.reverb_size, reverb_wet=args.reverb_wetness,
                                      reverb_dry=args.reverb_dryness, reverb_damping=args.reverb_damping,
-                                     output_format=args.output_format)
+                                     output_format=args.output_format, inference_mode=args.mode)
     print(f'[+] Cover generated at {cover_path}')

src/webui.py

@@ -110,6 +110,14 @@ def show_hop_slider(pitch_detection_algo):
     else:
         return gr.update(visible=False)
 
+def update_voice_model_visibility(mode):
+    """Show/hide the voice model dropdown based on inference mode.
+    Voice model is required for 'full' and 'rvc' modes, not for 'mdx' mode."""
+    if mode == 'mdx':
+        return gr.update(visible=False)
+    else:
+        return gr.update(visible=True)
+
 def update_input_visibility(selected_method):
     if selected_method == "File Upload":
         return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
@@ -151,6 +159,16 @@ if __name__ == '__main__':
                 rvc_model = gr.Dropdown(voice_models, label='Voice Models', info='Models folder "AICoverGen --> rvc_models". After new models are added into this folder, click the refresh button')
                 ref_btn = gr.Button('Refresh Models 🔁', variant='primary')
 
+            # Inference Mode Selection
+            with gr.Row(equal_height=True):
+                inference_mode = gr.Radio(
+                    choices=['full', 'mdx', 'rvc'],
+                    value='full',
+                    label='Inference Mode',
+                    info='Full: MDX separation + RVC voice conversion | MDX Only: Separate vocals only (no RVC) | RVC Only: Convert voice only (no separation)',
+                    interactive=True
+                )
+
             
             # Input Method Selection
             with gr.Row(equal_height=True):
@@ -245,19 +263,20 @@ if __name__ == '__main__':
                 ai_cover = gr.Audio(label='AI Cover')
 
             ref_btn.click(update_models_list, None, outputs=rvc_model)
+            inference_mode.change(update_voice_model_visibility, inputs=inference_mode, outputs=rvc_model)
             is_webui = gr.Number(value=1, visible=False)
             
             generate_btn.click(song_cover_pipeline,
                                inputs=[local_file, rvc_model, pitch, keep_files, is_webui, main_gain, backup_gain,
                                        inst_gain, index_rate, filter_radius, volume_envelope, f0_method, hop_length,
                                        protect, pitch_all, reverb_rm_size, reverb_wet, reverb_dry, reverb_damping,
-                                       output_format, extra_denoise],
+                                       output_format, extra_denoise, inference_mode],
                                outputs=[ai_cover])
             
-            clear_btn.click(lambda: [0, 0, 0, 0, 0.5, 3, 0.25, 0.33, 'rmvpe', 128, 0, 0.15, 0.2, 0.8, 0.7, 'mp3', None, True],
+            clear_btn.click(lambda: [0, 0, 0, 0, 0.5, 3, 0.25, 0.33, 'rmvpe', 128, 0, 0.15, 0.2, 0.8, 0.7, 'mp3', None, True, 'full'],
                             outputs=[pitch, main_gain, backup_gain, inst_gain, index_rate, filter_radius, volume_envelope,
                                      protect, f0_method, hop_length, pitch_all, reverb_rm_size, reverb_wet,
-                                     reverb_dry, reverb_damping, output_format, ai_cover, extra_denoise])
+                                     reverb_dry, reverb_damping, output_format, ai_cover, extra_denoise, inference_mode])
 
         # Download tab
         with gr.Tab('Download model'):