Update app.py

app.py

@@ -1,269 +1,231 @@
+import gradio as gr
+from pydub import AudioSegment
+import numpy as np
+import tempfile
+import os
+import noisereduce as nr
+import torch
+from demucs import pretrained
+from demucs.apply import apply_model
+import torchaudio
+from pathlib import Path
+import matplotlib.pyplot as plt
+from io import BytesIO
+from PIL import Image
+import zipfile
+import datetime
+import librosa
+import warnings
+import json
+import pickle
+import soundfile as sf
+
+warnings.filterwarnings("ignore")
+
+### Helper Functions ###
+
+def audiosegment_to_array(audio):
+    return np.array(audio.get_array_of_samples()), audio.frame_rate
+
+def array_to_audiosegment(samples, frame_rate, channels=1):
+    return AudioSegment(
+        samples.tobytes(),
+        frame_rate=int(frame_rate),
+        sample_width=samples.dtype.itemsize,
+        channels=channels
+    )
+
+def save_audiosegment_to_temp(audio: AudioSegment, suffix=".wav"):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as f:
+        audio.export(f.name, format=suffix.lstrip('.'))
+        return f.name
+
+def load_audiofile_to_numpy(path):
+    samples, sr = sf.read(path, dtype="int16")
+    if samples.ndim > 1 and samples.shape[1] > 2:
+        samples = samples[:, :2]
+    return samples, sr
+
+def show_waveform(audio_file):
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        samples = np.array(audio.get_array_of_samples())
+        plt.figure(figsize=(10,2))
+        plt.plot(samples[:10000], color="skyblue")
+        plt.axis('off')
+        buf = BytesIO()
+        plt.savefig(buf, format='png', bbox_inches='tight')
+        plt.close()
+        buf.seek(0)
+        return Image.open(buf)
+    except Exception:
+        return None
+
+### Effects ###
+
+def apply_normalize(audio): return audio.normalize()
+
+def apply_noise_reduction(audio):
+    samples, sr = audiosegment_to_array(audio)
+    reduced = nr.reduce_noise(y=samples, sr=sr)
+    return array_to_audiosegment(reduced, sr, audio.channels)
+
+def apply_compression(audio): return audio.compress_dynamic_range()
+
+def apply_reverb(audio):
+    reverb = audio - 10
+    return audio.overlay(reverb, position=1000)
+
+def apply_pitch_shift(audio, semitones=-2):
+    new_fr = int(audio.frame_rate * (2 ** (semitones / 12)))
+    return audio._spawn(audio.raw_data, overrides={"frame_rate": new_fr}).set_frame_rate(audio.frame_rate)
+
+def apply_echo(audio, delay_ms=500, decay=0.5):
+    echo = audio - 10
+    return audio.overlay(echo, position=delay_ms)
+
+def apply_stereo_widen(audio, pan_amount=0.3):
+    left = audio.pan(-pan_amount)
+    right = audio.pan(pan_amount)
+    return AudioSegment.from_mono_audiosegments(left, right)
+
+def apply_bass_boost(audio, gain=10): return audio.low_pass_filter(100).apply_gain(gain)
+
+def apply_treble_boost(audio, gain=10): return audio.high_pass_filter(4000).apply_gain(gain)
+
+def apply_limiter(audio, limit_dB=-1):
+    limiter = audio._spawn(audio.raw_data, overrides={"frame_rate": audio.frame_rate})
+    return limiter.apply_gain(limit_dB)
+
+def apply_auto_gain(audio, target_dB=-20):
+    change = target_dB - audio.dBFS
+    return audio.apply_gain(change)
+
+def apply_vocal_distortion(audio, intensity=0.3):
+    samples = np.array(audio.get_array_of_samples()).astype(np.float32)
+    distorted = samples + intensity * np.sin(samples * 2 * np.pi / 32768)
+    return array_to_audiosegment(distorted.astype(np.int16), audio.frame_rate, audio.channels)
+
+def apply_harmony(audio, shift_semitones=4):
+    shifted_up = apply_pitch_shift(audio, shift_semitones)
+    shifted_down = apply_pitch_shift(audio, -shift_semitones)
+    return audio.overlay(shifted_up).overlay(shifted_down)
+
+def apply_stage_mode(audio):
+    processed = apply_reverb(audio)
+    processed = apply_bass_boost(processed, gain=6)
+    return apply_limiter(processed, limit_dB=-2)
+
+def apply_bitcrush(audio, bit_depth=8):
+    samples = np.array(audio.get_array_of_samples())
+    max_value = 2 ** bit_depth - 1
+    downsampled = np.round(samples / (32768 / max_value)).astype(np.int16)
+    return array_to_audiosegment(downsampled, audio.frame_rate // 2, audio.channels)
+
+### Presets ###
+
+preset_choices = {
+    "Default": [],
+    "Clean Podcast": ["Noise Reduction", "Normalize"],
+    "Podcast Mastered": ["Noise Reduction", "Normalize", "Compress Dynamic Range"],
+    "Radio Ready": ["Bass Boost", "Treble Boost", "Limiter"],
+    "Music Production": ["Reverb", "Stereo Widening", "Pitch Shift"],
+    "ASMR Creator": ["Noise Gate", "Auto Gain", "Low-Pass Filter"],
+    "Voiceover Pro": ["Vocal Isolation", "TTS", "EQ Match"],
+    "8-bit Retro": ["Bitcrusher", "Echo", "Mono Downmix"],
+    "🎙 Clean Vocal": ["Noise Reduction", "Normalize", "High Pass Filter (80Hz)"],
+    "🧪 Vocal Distortion": ["Vocal Distortion", "Reverb", "Compress Dynamic Range"],
+    "🎶 Singer's Harmony": ["Harmony", "Stereo Widening", "Pitch Shift"],
+    "🌫 ASMR Vocal": ["Auto Gain", "Low-Pass Filter (3000Hz)", "Noise Gate"],
+    "🎼 Stage Mode": ["Reverb", "Bass Boost", "Limiter"],
+}
+
+preset_names = list(preset_choices.keys())
+
+### Main processing ###
+
+def process_audio(audio_file, selected_effects, isolate_vocals, preset_name, export_format):
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        effect_map = {
+            "Noise Reduction": apply_noise_reduction,
+            "Compress Dynamic Range": apply_compression,
+            "Add Reverb": apply_reverb,
+            "Pitch Shift": apply_pitch_shift,
+            "Echo": apply_echo,
+            "Stereo Widening": apply_stereo_widen,
+            "Bass Boost": apply_bass_boost,
+            "Treble Boost": apply_treble_boost,
+            "Normalize": apply_normalize,
+            "Limiter": lambda x: apply_limiter(x, limit_dB=-1),
+            "Auto Gain": lambda x: apply_auto_gain(x, target_dB=-20),
+            "Vocal Distortion": apply_vocal_distortion,
+            "Stage Mode": apply_stage_mode,
+            "Harmony": apply_harmony,
+            "Bitcrusher": apply_bitcrush,
+        }
+        for effect in selected_effects:
+            if effect in effect_map:
+                audio = effect_map[effect](audio)
+        if isolate_vocals:
+            temp_path = save_audiosegment_to_temp(audio, suffix=".wav")
+            vocal_path = apply_vocal_isolation(temp_path)
+            audio = AudioSegment.from_file(vocal_path)
+        output_path = save_audiosegment_to_temp(audio, suffix='.' + export_format.lower())
+        samples, sr = load_audiofile_to_numpy(output_path)
+        waveform = show_waveform(output_path)
+        session_log = json.dumps({
+            "timestamp": str(datetime.datetime.now()),
+            "filename": os.path.basename(audio_file),
+            "effects_applied": selected_effects,
+            "isolate_vocals": isolate_vocals,
+            "export_format": export_format,
+            "detected_genre": "Unknown"
+        }, indent=2)
+        return (samples, sr), waveform, session_log, "Unknown", "🎉 Done!"
+    except Exception as e:
+        return None, None, f"Error: {e}", "", f"Error: {e}"
+
+### Other necessary functions (batch, AI remaster...) would follow similar patterns.
+
+# ===================================================
+# Now, the Gradio UI:
+# Paste this after all function definitions above
+# ===================================================
+
 with gr.Blocks() as demo:
     gr.HTML('<h3 style="text-align:center;">Where Your Audio Meets Intelligence</h3>')
     gr.Markdown('### Upload, edit, export — powered by AI!')
 
-    # 1. Single File Studio
     with gr.Tab("🎵 Single File Studio"):
         with gr.Row():
             with gr.Column():
                 input_audio = gr.Audio(label="Upload Audio", type="filepath")
-                effect_checkbox = gr.CheckboxGroup(
-                    choices=list({e for effects in preset_choices.values() for e in effects}),
-                    label="Apply Effects in Order"
-                )
-                preset_dropdown = gr.Dropdown(choices=preset_names, label="Select Preset", value=preset_names[0])
+                effect_checkbox = gr.CheckboxGroup(choices=list({e for effects in preset_choices.values() for e in effects}), label="Apply Effects in Order")
+                preset_dropdown = gr.Dropdown(choices=preset_names, label="Select Preset")
                 export_format = gr.Dropdown(choices=["WAV", "MP3"], label="Export Format", value="WAV")
                 isolate_vocals = gr.Checkbox(label="Isolate Vocals After Effects")
                 process_btn = gr.Button("Process Audio")
+
             with gr.Column():
-                output_audio = gr.Audio(label="Processed Audio", type="numpy")
-                waveform_img = gr.Image(label="Waveform Preview")
-                session_log_out = gr.Textbox(label="Session Log", lines=6)
-                genre_out = gr.Textbox(label="Detected Genre")
-                status_box = gr.Textbox(label="Status", lines=1, value="Ready")
-        
-        def update_effects_for_preset(preset_name):
-            return preset_choices.get(preset_name, [])
-        
-        preset_dropdown.change(update_effects_for_preset, inputs=preset_dropdown, outputs=effect_checkbox)
-        
-        def process_wrapper(audio_path, effects, isolate, preset, fmt):
+                processed_audio = gr.Audio(label="Processed Audio", type="numpy")
+                waveform_image = gr.Image(label="Waveform Preview")
+                session_log = gr.Textbox(label="Session Log", lines=6)
+                detected_genre = gr.Textbox(label="Detected Genre")
+                status = gr.Textbox(label="Status", lines=1, value="Ready")
+
+        def update_effects(preset):
+            return preset_choices.get(preset, [])
+
+        preset_dropdown.change(update_effects, inputs=preset_dropdown, outputs=effect_checkbox)
+
+        def run_processing(audio, effects, isolate, preset, fmt):
             effs = preset_choices.get(preset, []) if preset in preset_choices else effects
-            return process_audio(audio_path, effs, isolate, preset, fmt)
-        
-        process_btn.click(process_wrapper,
-                          inputs=[input_audio, effect_checkbox, isolate_vocals, preset_dropdown, export_format],
-                          outputs=[output_audio, waveform_img, session_log_out, genre_out, status_box])
-
-    # 2. Remix Mode
-    with gr.Tab("🎛 Remix Mode"):
-        with gr.Row():
-            with gr.Column():
-                remix_input = gr.Audio(label="Upload Music Track", type="filepath")
-                split_button = gr.Button("Split Into Drums, Bass, Vocals, etc.")
-            with gr.Column():
-                vocals_file = gr.File(label="Vocals")
-                drums_file = gr.File(label="Drums")
-                bass_file = gr.File(label="Bass")
-                other_file = gr.File(label="Other")
-        split_button.click(stem_split, inputs=remix_input, outputs=[vocals_file, drums_file, bass_file, other_file])
-
-    # 3. AI Remastering
-    with gr.Tab("🔮 AI Remastering"):
-        remaster_input = gr.Audio(label="Upload Low-Quality Recording", type="filepath")
-        remaster_output = gr.Audio(label="Studio-Grade Output", type="numpy")
-        remaster_status = gr.Textbox(label="Status", value="Ready", interactive=False)
-        remaster_btn = gr.Button("Remaster")
-        remaster_btn.click(ai_remaster, inputs=remaster_input, outputs=remaster_output)
-        remaster_btn.click(lambda _: "Done!", remaster_btn, remaster_status)
-
-    # 4. Harmonic Saturation
-    with gr.Tab("🧬 Harmonic Saturation"):
-        saturation_in = gr.Audio(label="Upload Track", type="filepath")
-        saturation_type = gr.Dropdown(choices=["Tube", "Tape", "Console", "Mix Bus"], label="Saturation Type", value="Tube")
-        saturation_intensity = gr.Slider(minimum=0.1, maximum=1.0, value=0.2, label="Intensity")
-        saturation_out = gr.Audio(label="Warm Output", type="numpy")
-        sat_btn = gr.Button("Apply Saturation")
-        sat_btn.click(harmonic_saturation,
-                      inputs=[saturation_in, saturation_type, saturation_intensity],
-                      outputs=saturation_out)
-
-    # 5. Vocal Doubler / Harmonizer
-    with gr.Tab("🎧 Vocal Doubler / Harmonizer"):
-        vocal_in = gr.Audio(label="Upload Vocal Clip", type="filepath")
-        vocal_out = gr.Audio(label="Doubled Output", type="numpy")
-        vocal_status = gr.Textbox(label="Status", interactive=False)
-        vocal_btn = gr.Button("Add Vocal Doubling / Harmony")
-        vocal_btn.click(run_harmony, inputs=vocal_in, outputs=[vocal_out, vocal_status])
-
-    # 6. Batch Processing
-    with gr.Tab("🔊 Batch Processing"):
-        batch_files = gr.File(label="Upload Multiple Files", file_count="multiple")
-        batch_effects = gr.CheckboxGroup(choices=list({e for effs in preset_choices.values() for e in effs}), label="Apply Effects in Order")
-        batch_isolate = gr.Checkbox(label="Isolate Vocals After Effects")
-        batch_preset = gr.Dropdown(choices=preset_names, label="Select Preset", value=preset_names[0])
-        batch_export = gr.Dropdown(choices=["MP3", "WAV"], label="Export Format", value="MP3")
-        batch_btn = gr.Button("Process All Files")
-        batch_zip = gr.File(label="Download All Processed Files (ZIP)")
-        batch_status = gr.Textbox(label="Status", interactive=False)
-        batch_btn.click(batch_process_audio,
-                        inputs=[batch_files, batch_effects, batch_isolate, batch_preset, batch_export],
-                        outputs=[batch_zip, batch_status])
-
-    # 7. AI Auto-Tune
-    with gr.Tab("🎤 AI Auto-Tune"):
-        autotune_file = gr.File(label="Source Voice Clip")
-        autotune_key = gr.Textbox(label="Target Key", value="C", lines=1)
-        autotune_out = gr.Audio(label="Pitch-Corrected Output", type="numpy")
-        autotune_btn = gr.Button("Apply Auto-Tune")
-        autotune_btn.click(auto_tune_vocal, inputs=[autotune_file, autotune_key], outputs=autotune_out)
-
-    # 8. Frequency Spectrum
-    with gr.Tab("📊 Frequency Spectrum"):
-        spectrum_in = gr.Audio(label="Upload Track", type="filepath")
-        spectrum_out = gr.Image(label="Frequency Spectrum")
-        spectrum_btn = gr.Button("Visualize Spectrum")
-        spectrum_btn.click(visualize_spectrum, inputs=spectrum_in, outputs=spectrum_out)
-
-    # 9. Loudness Graph
-    with gr.Tab("📈 Loudness Graph"):
-        loudness_in = gr.Audio(label="Upload Track", type="filepath")
-        loudness_target = gr.Slider(minimum=-24, maximum=-6, value=-14, label="Target LUFS")
-        loudness_out = gr.Audio(label="Normalized Output", type="numpy")
-        loudness_btn = gr.Button("Match Loudness")
-        loudness_btn.click(match_loudness, inputs=[loudness_in, loudness_target], outputs=loudness_out)
-
-    # 10. Save/Load Project
-    with gr.Tab("📁 Save/Load Project"):
-        with gr.Row():
-            with gr.Column():
-                project_audio = gr.File(label="Original Audio")
-                project_preset = gr.Dropdown(choices=preset_names, label="Used Preset", value=preset_names[0])
-                project_effects = gr.CheckboxGroup(choices=list({e for effs in preset_choices.values() for e in effs}), label="Applied Effects")
-                save_proj_btn = gr.Button("Save Project")
-                project_file = gr.File(label="Project File (.aiproj)")
-            with gr.Column():
-                load_proj_file = gr.File(label="Load .aiproj File")
-                loaded_preset = gr.Dropdown(choices=preset_names, label="Loaded Preset")
-                loaded_effects = gr.CheckboxGroup(choices=list({e for effs in preset_choices.values() for e in effs}), label="Loaded Effects")
-                load_proj_btn = gr.Button("Load Project")
-        save_proj_btn.click(save_project, inputs=[project_audio, project_preset, project_effects], outputs=project_file)
-        load_proj_btn.click(load_project, inputs=load_proj_file, outputs=[loaded_preset, loaded_effects])
-
-    # 11. Prompt-Based Editing
-    with gr.Tab("🧠 Prompt-Based Editing"):
-        prompt_audio = gr.File(label="Upload Audio", file_types=[".wav", ".mp3"])
-        prompt_text = gr.Textbox(label="Describe What You Want", lines=5)
-        prompt_out = gr.Audio(label="Edited Output", type="numpy")
-        prompt_btn = gr.Button("Process Prompt")
-        prompt_btn.click(process_prompt, inputs=[prompt_audio, prompt_text], outputs=prompt_out)
-
-    # 12. Custom EQ Editor
-    with gr.Tab("🎛 Custom EQ Editor"):
-        eq_audio = gr.Audio(label="Upload Track", type="filepath")
-        eq_genre = gr.Dropdown(choices=list(eq_map.keys()), value="Pop", label="Genre")
-        eq_output = gr.Audio(label="EQ-Enhanced Output", type="numpy")
-        eq_btn = gr.Button("Apply EQ")
-        eq_btn.click(auto_eq, inputs=[eq_audio, eq_genre], outputs=eq_output)
-
-    # 13. A/B Compare
-    with gr.Tab("🎯 A/B Compare"):
-        ab_track1 = gr.Audio(label="Version A", type="filepath")
-        ab_track2 = gr.Audio(label="Version B", type="filepath")
-        ab_out1 = gr.Audio(label="Version A", type="filepath")
-        ab_out2 = gr.Audio(label="Version B", type="filepath")
-        ab_btn = gr.Button("Compare")
-        ab_btn.click(compare_ab, inputs=[ab_track1, ab_track2], outputs=[ab_out1, ab_out2])
-
-    # 14. Loop Playback
-    with gr.Tab("🔁 Loop Playback"):
-        loop_audio = gr.Audio(label="Upload Track", type="filepath")
-        loop_start = gr.Slider(minimum=0, maximum=30000, step=100, value=5000, label="Start MS")
-        loop_end = gr.Slider(minimum=100, maximum=30000, step=100, value=10000, label="End MS")
-        loop_repeat = gr.Slider(minimum=1, maximum=10, value=2, label="Repeat Loops")
-        loop_out = gr.Audio(label="Looped Output", type="numpy")
-        loop_btn = gr.Button("Loop Section")
-        loop_btn.click(loop_section, inputs=[loop_audio, loop_start, loop_end, loop_repeat], outputs=loop_out)
-
-    # 15. Share Effect Chain Tab
-    with gr.Tab("🔗 Share Effect Chain"):
-        share_effects = gr.CheckboxGroup(choices=list({e for effs in preset_choices.values() for e in effs}), label="Select Effects")
-        share_code = gr.Textbox(label="Share Code", lines=2)
-        share_btn = gr.Button("Generate Share Code")
-        share_btn.click(lambda x: json.dumps(sorted(x)), inputs=share_effects, outputs=share_code)
-
-    # 16. Load Shared Chain Tab
-    with gr.Tab("📥 Load Shared Chain"):
-        load_code = gr.Textbox(label="Paste Shared Code", lines=2)
-        loaded_effects = gr.CheckboxGroup(choices=list({e for effs in preset_choices.values() for e in effs}), label="Loaded Effects")
-        load_code_btn = gr.Button("Load Effects")
-        load_code_btn.click(lambda code: json.loads(code) if code else [], inputs=load_code, outputs=loaded_effects)
-
-    # 17. Keyboard Shortcuts Tab
-    with gr.Tab("⌨ Keyboard Shortcuts"):
-        gr.Markdown("""
-        ### Keyboard Controls
-        - `Ctrl + Z`: Undo last effect  
-        - `Ctrl + Y`: Redo  
-        - `Spacebar`: Play/Stop playback  
-        - `Ctrl + S`: Save current session  
-        - `Ctrl + O`: Open session  
-        - `Ctrl + C`: Copy effect chain  
-        - `Ctrl + V`: Paste effect chain  
-        """)
-
-    # 18. Vocal Formant Correction Tab
-    with gr.Tab("🧑‍🎤 Vocal Formant Correction"):
-        formant_audio = gr.Audio(label="Upload Vocal Track", type="filepath")
-        formant_shift = gr.Slider(minimum=-2, maximum=2, value=1.0, step=0.1, label="Formant Shift")
-        formant_output = gr.Audio(label="Natural-Sounding Vocal", type="numpy")
-        formant_btn = gr.Button("Apply Correction")
-        formant_btn.click(
-            lambda audio, shift: array_to_audiosegment(
-                librosa.effects.pitch_shift(
-                    np.array(AudioSegment.from_file(audio).get_array_of_samples()),
-                    sr=AudioSegment.from_file(audio).frame_rate,
-                    n_steps=shift
-                ).astype(np.int16),
-                AudioSegment.from_file(audio).frame_rate,
-                channels=AudioSegment.from_file(audio).channels
-            ),
-            inputs=[formant_audio, formant_shift],
-            outputs=formant_output
-        )
+            return process_audio(audio, effs, isolate, preset, fmt)
 
-    # 19. Voice Swap / Cloning Tab
-    with gr.Tab("🔁 Voice Swap / Cloning"):
-        source_voice = gr.File(label="Source Voice Clip")
-        reference_voice = gr.File(label="Reference Voice")
-        clone_output = gr.Audio(label="Converted Output", type="numpy")
-        clone_btn = gr.Button("Clone Voice")
-
-        def clone_func(source, ref):
-            s = AudioSegment.from_file(source.name)
-            r = AudioSegment.from_file(ref.name)
-            mixed = s.overlay(r - 10)
-            tmp = save_audiosegment_to_temp(mixed, ".wav")
-            return load_audiofile_to_numpy(tmp)
-
-        clone_btn.click(clone_func, inputs=[source_voice, reference_voice], outputs=clone_output)
-
-    # 20. DAW Template Export Tab
-    with gr.Tab("🎛 DAW Template Export"):
-        daw_stems = gr.File(label="Upload Stems", file_count="multiple")
-        daw_output = gr.File(label="DAW Template (.json/.als/.flp)")
-        daw_btn = gr.Button("Generate Template")
-
-        def generate_template(stems):
-            template = {
-                "format": "Ableton Live",
-                "stems": [os.path.basename(s.name) for s in stems],
-                "effects": ["Reverb", "EQ", "Compression"],
-                "tempo": 128,
-                "title": "Studio Pulse Project"
-            }
-            out_path = os.path.join(tempfile.gettempdir(), "ableton_template.json")
-            with open(out_path, "w") as f:
-                json.dump(template, f, indent=2)
-            return out_path
-
-        daw_btn.click(generate_template, inputs=daw_stems, outputs=daw_output)
-
-    # 21. Export Full Mix ZIP Tab
-    with gr.Tab("📁 Export Full Mix ZIP"):
-        stems_files = gr.File(label="Stems", file_count="multiple")
-        final_mix_file = gr.File(label="Final Mix")
-        full_zip_output = gr.File(label="Full Mix Archive (.zip)")
-        export_zip_btn = gr.Button("Export ZIP")
-
-        def export_zip(stems, final_mix):
-            zip_path = os.path.join(tempfile.gettempdir(), "full_export.zip")
-            with zipfile.ZipFile(zip_path, "w") as zipf:
-                for i, stem in enumerate(stems):
-                    zipf.write(stem.name, f"stem_{i}.wav")
-                zipf.write(final_mix.name, "final_mix.wav")
-            return zip_path
-
-        export_zip_btn.click(export_zip, inputs=[stems_files, final_mix_file], outputs=full_zip_output)
+        process_btn.click(run_processing, 
+            inputs=[input_audio, effect_checkbox, isolate_vocals, preset_dropdown, export_format],
+            outputs=[processed_audio, waveform_image, session_log, detected_genre, status]
+        )
 
 demo.launch()