Update app.py

app.py

@@ -1 +1,1156 @@
-86dccd97d96aa64e99e149318bfd50de40d35b27
+import gradio as gr
+from pydub import AudioSegment
+from pydub.silence import detect_nonsilent
+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
+from faster_whisper import WhisperModel
+from TTS.api import TTS
+import base64
+import pickle
+import json
+import soundfile as sf
+
+# Suppress warnings
+warnings.filterwarnings("ignore")
+
+# === Effect Map (Global) ===
+def apply_normalize(audio):
+    return audio.normalize()
+
+def apply_noise_reduction(audio):
+    samples, frame_rate = audiosegment_to_array(audio)
+    reduced = nr.reduce_noise(y=samples, sr=frame_rate)
+    return array_to_audiosegment(reduced, frame_rate, channels=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_frame_rate = int(audio.frame_rate * (2 ** (semitones / 12)))
+    samples = np.array(audio.get_array_of_samples())
+    resampled = np.interp(np.arange(0, len(samples), 2 ** (semitones / 12)), np.arange(len(samples)), samples).astype(np.int16)
+    return AudioSegment(resampled.tobytes(), frame_rate=new_frame_rate, sample_width=audio.sample_width, channels=audio.channels)
+
+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, channels=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_val = 2 ** (bit_depth) - 1
+    downsampled = np.round(samples / (32768 / max_val)).astype(np.int16)
+    return array_to_audiosegment(downsampled, audio.frame_rate // 2, channels=audio.channels)
+
+# === 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
+    )
+
+# === Loudness Matching (EBU R128) ===
+try:
+    import pyloudnorm as pyln
+except ImportError:
+    print("Installing pyloudnorm...")
+    import subprocess
+    subprocess.run(["pip", "install", "pyloudnorm"])
+    import pyloudnorm as pyln
+
+def match_loudness(audio_path, target_lufs=-14.0):
+    meter = pyln.Meter(44100)
+    wav = AudioSegment.from_file(audio_path).set_frame_rate(44100)
+    samples = np.array(wav.get_array_of_samples()).astype(np.float64) / 32768.0
+    loudness = meter.integrated_loudness(samples)
+    gain_db = target_lufs - loudness
+    adjusted = wav + gain_db
+    out_path = os.path.join(tempfile.gettempdir(), "loudness_output.wav")
+    adjusted.export(out_path, format="wav")
+    return out_path
+
+# === Auto-EQ per Genre – With R&B, Soul, Funk ===
+def auto_eq(audio, genre="Pop"):
+    eq_map = {
+        "Pop": [(200, 500, -3), (2000, 4000, +4)],
+        "EDM": [(60, 250, +6), (8000, 12000, +3)],
+        "Rock": [(1000, 3000, +4), (7000, 10000, -3)],
+        "Hip-Hop": [(20, 100, +6), (7000, 10000, -4)],
+        "Acoustic": [(100, 300, -3), (4000, 8000, +2)],
+        "Metal": [(100, 500, -4), (2000, 5000, +6), (7000, 12000, -3)],
+        "Trap": [(80, 120, +6), (3000, 6000, -4)],
+        "LoFi": [(20, 200, +3), (1000, 3000, -2)],
+        "Jazz": [(100, 400, +2), (1500, 3000, +1)],
+        "Classical": [(200, 1000, +1), (3000, 6000, +2)],
+        "Chillhop": [(50, 200, +3), (2000, 5000, +1)],
+        "Ambient": [(100, 500, +4), (6000, 12000, +2)],
+        "Jazz Piano": [(100, 1000, +3), (2000, 5000, +2)],
+        "Trap EDM": [(60, 120, +6), (2000, 5000, -3)],
+        "Indie Rock": [(150, 400, +2), (2000, 5000, +3)],
+        "Lo-Fi Jazz": [(80, 200, +3), (2000, 4000, -1)],
+        "R&B": [(100, 300, +4), (2000, 4000, +3)],
+        "Soul": [(80, 200, +3), (1500, 3500, +4)],
+        "Funk": [(80, 200, +5), (1000, 3000, +3)],
+        "Default": []
+    }
+
+    from scipy.signal import butter, sosfilt
+
+    def band_eq(samples, sr, lowcut, highcut, gain):
+        sos = butter(10, [lowcut, highcut], btype='band', output='sos', fs=sr)
+        filtered = sosfilt(sos, samples)
+        return samples + gain * filtered
+
+    samples, sr = audiosegment_to_array(audio)
+    samples = samples.astype(np.float64)
+
+    for band in eq_map.get(genre, []):
+        low, high, gain = band
+        samples = band_eq(samples, sr, low, high, gain)
+
+    return array_to_audiosegment(samples.astype(np.int16), sr, channels=audio.channels)
+
+# === Load Track Helpers ===
+def load_track_local(path, sample_rate, channels=2):
+    sig, rate = torchaudio.load(path)
+    if rate != sample_rate:
+        sig = torchaudio.functional.resample(sig, rate, sample_rate)
+    if channels == 1:
+        sig = sig.mean(0)
+    return sig
+
+def save_track(path, wav, sample_rate):
+    path = Path(path)
+    torchaudio.save(str(path), wav, sample_rate)
+
+# === Vocal Isolation Helpers ===
+def apply_vocal_isolation(audio_path):
+    model = pretrained.get_model(name='htdemucs')
+    wav = load_track_local(audio_path, model.samplerate, channels=2)
+    ref = wav.mean(0)
+    wav -= ref[:, None]
+    sources = apply_model(model, wav[None])[0]
+    wav += ref[:, None]
+
+    vocal_track = sources[3].cpu()
+    out_path = os.path.join(tempfile.gettempdir(), "vocals.wav")
+    save_track(out_path, vocal_track, model.samplerate)
+    return out_path
+
+# === Stem Splitting Function (Now Defined!) ===
+def stem_split(audio_path):
+    model = pretrained.get_model(name='htdemucs')
+    wav = load_track_local(audio_path, model.samplerate, channels=2)
+    sources = apply_model(model, wav[None])[0]
+
+    output_dir = tempfile.mkdtemp()
+    stem_paths = []
+
+    for i, name in enumerate(['drums', 'bass', 'other', 'vocals']):
+        path = os.path.join(output_dir, f"{name}.wav")
+        save_track(path, sources[i].cpu(), model.samplerate)
+        stem_paths.append(gr.File(value=path))
+
+    return stem_paths
+
+# === Process Audio Function – Fully Featured ===
+def process_audio(audio_file, selected_effects, isolate_vocals, preset_name, export_format):
+    status = "🔊 Loading audio..."
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        status = "🛠 Applying effects..."
+
+        effect_map_real = {
+            "Noise Reduction": apply_noise_reduction,
+            "Compress Dynamic Range": apply_compression,
+            "Add Reverb": apply_reverb,
+            "Pitch Shift": lambda x: apply_pitch_shift(x),
+            "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": lambda x: apply_vocal_distortion(x),
+            "Stage Mode": apply_stage_mode
+        }
+
+        history = [audio]  # Undo stack
+
+        for effect_name in selected_effects:
+            if effect_name in effect_map_real:
+                audio = effect_map_real[effect_name](audio)
+                history.append(audio)
+
+        status = "💾 Saving final audio..."
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as f:
+            if isolate_vocals:
+                temp_input = os.path.join(tempfile.gettempdir(), "input.wav")
+                audio.export(temp_input, format="wav")
+                vocal_path = apply_vocal_isolation(temp_input)
+                final_audio = AudioSegment.from_wav(vocal_path)
+            else:
+                final_audio = audio
+
+            output_path = f.name
+            final_audio.export(output_path, format=export_format.lower())
+
+            waveform_image = show_waveform(output_path)
+            genre = detect_genre(output_path)
+            session_log = generate_session_log(audio_file, selected_effects, isolate_vocals, export_format, genre)
+
+            status = "🎉 Done!"
+            return output_path, waveform_image, session_log, genre, status, history
+
+    except Exception as e:
+        status = f"❌ Error: {str(e)}"
+        return None, None, status, "", status, []
+
+# === Waveform Generator ===
+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", dpi=100)
+        plt.close()
+        buf.seek(0)
+        return Image.open(buf)
+    except Exception:
+        return None
+
+# === Genre Detection ===
+def detect_genre(audio_path):
+    try:
+        y, sr = torchaudio.load(audio_path)
+        mfccs = librosa.feature.mfcc(y=y.numpy().flatten(), sr=sr, n_mfcc=13).mean(axis=1).reshape(1, -1)
+        return "Speech"
+    except Exception:
+        return "Unknown"
+
+# === Session Log Generator ===
+def generate_session_log(audio_path, effects, isolate_vocals, export_format, genre):
+    log = {
+        "timestamp": str(datetime.datetime.now()),
+        "filename": os.path.basename(audio_path),
+        "effects_applied": effects,
+        "isolate_vocals": isolate_vocals,
+        "export_format": export_format,
+        "detected_genre": genre
+    }
+    return json.dumps(log, indent=2)
+
+# === 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"],
+    "🎵 Auto-Tune Style": ["Pitch Shift (+1 semitone)", "Normalize", "Treble Boost"],
+    "🎤 R&B Vocal": ["Noise Reduction", "Bass Boost (100-300Hz)", "Treble Boost (2000-4000Hz)"],
+    "💃 Soul Vocal": ["Noise Reduction", "Bass Boost (80-200Hz)", "Treble Boost (1500-3500Hz)"],
+    "🕺 Funk Groove": ["Bass Boost (80-200Hz)", "Treble Boost (1000-3000Hz)"]
+}
+
+preset_names = list(preset_choices.keys())
+
+# === Batch Processing Function ===
+def batch_process_audio(files, selected_effects, isolate_vocals, preset_name, export_format):
+    status = "🔊 Loading files..."
+    try:
+        output_dir = tempfile.mkdtemp()
+        results = []
+        session_logs = []
+
+        for file in files:
+            processed_path, _, log, _, _ = process_audio(file.name, selected_effects, isolate_vocals, preset_name, export_format)[0:5]
+            results.append(processed_path)
+            session_logs.append(log)
+
+        zip_path = os.path.join(tempfile.gettempdir(), "batch_output.zip")
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
+            for i, res in enumerate(results):
+                filename = f"processed_{i}.{export_format.lower()}"
+                zipf.write(res, filename)
+                zipf.writestr(f"session_info_{i}.json", session_logs[i])
+
+        return zip_path, "📦 ZIP created successfully!"
+
+    except Exception as e:
+        return None, f"❌ Batch processing failed: {str(e)}"
+
+# === Vocal Pitch Correction – Auto-Tune Style ===
+def auto_tune_vocal(audio_path, target_key="C"):
+    try:
+        audio = AudioSegment.from_file(audio_path)
+        semitones = key_to_semitone(target_key)
+        tuned_audio = apply_pitch_shift(audio, semitones)
+        out_path = os.path.join(tempfile.gettempdir(), "autotuned_output.wav")
+        tuned_audio.export(out_path, format="wav")
+        return out_path
+    except Exception as e:
+        print(f"Auto-Tune Error: {e}")
+        return None
+
+def key_to_semitone(key="C"):
+    keys = {"C": 0, "C#": 1, "D": 2, "D#": 3, "E": 4, "F": 5,
+            "F#": 6, "G": 7, "G#": 8, "A": 9, "A#": 10, "B": 11}
+    return keys.get(key, 0)
+
+# === Apply Effects to Stems ===
+def apply_effects_to_stem(stem_path, selected_effects):
+    try:
+        audio = AudioSegment.from_file(stem_path)
+        effect_map_real = {
+            "Noise Reduction": apply_noise_reduction,
+            "Normalize": apply_normalize,
+            "Add Reverb": apply_reverb,
+            "Bass Boost": apply_bass_boost,
+            "Treble Boost": apply_treble_boost,
+            "Stereo Widening": apply_stereo_widen,
+            "Limiter": lambda x: apply_limiter(x, limit_dB=-1),
+            "Compress Dynamic Range": apply_compression,
+            "Vocal Distortion": lambda x: apply_vocal_distortion(x),
+            "Stage Mode": apply_stage_mode
+        }
+
+        for effect_name in selected_effects:
+            if effect_name in effect_map_real:
+                audio = effect_map_real[effect_name](audio)
+
+        out_path = os.path.join(tempfile.gettempdir(), f"remixed_{Path(stem_path).stem}_processed.wav")
+        audio.export(out_path, format="wav")
+        return out_path
+
+    except Exception as e:
+        print(f"Error applying effects: {e}")
+        return None
+
+# === Live Stream Preview ===
+def live_effect_preview(stream, selected_effect):
+    try:
+        samples, sr = stream
+        audio = array_to_audiosegment(samples, sr, channels=1)
+        effect_map_real = {
+            "Reverb": apply_reverb,
+            "Pitch Shift": lambda x: apply_pitch_shift(x),
+            "Saturation": lambda x: harmonic_saturation(x, saturation_type="Tube", intensity=0.2),
+            "Normalize": apply_normalize
+        }
+
+        if selected_effect in effect_map_real:
+            processed = effect_map_real[selected_effect](audio)
+        else:
+            processed = audio
+
+        out_path = os.path.join(tempfile.gettempdir(), "live_processed.wav")
+        processed.export(out_path, format="wav")
+        return out_path
+
+    except Exception as e:
+        return None
+
+# === Voice Command Parsing ===
+def voice_to_effect(command):
+    command = command.lower()
+    if "noise reduction" in command or "remove noise" in command:
+        return ["Noise Reduction", "Normalize"]
+    elif "bass" in command:
+        return ["Bass Boost"]
+    elif "treble" in command:
+        return ["Treble Boost"]
+    elif "echo" in command:
+        return ["Echo"]
+    elif "pitch shift" in command or "tune" in command:
+        return ["Pitch Shift"]
+    elif "reverb" in command:
+        return ["Reverb"]
+    else:
+        return ["Noise Reduction"]
+
+# === AI Suggest Effects Based on Genre ===
+def suggest_by_genre(audio_path):
+    genre = detect_genre(audio_path)
+    return preset_choices.get(genre, [])
+
+# === Time-Stretch & BPM Match ===
+def stretch_to_bpm(audio_path, target_bpm=128):
+    y, sr = torchaudio.load(audio_path)
+    y_np = y.numpy().flatten()
+    tempo, _ = librosa.beat.beat_track(y=y_np, sr=sr)
+    ratio = target_bpm / tempo
+    stretched = librosa.effects.time_stretch(y_np, ratio)
+    out_path = os.path.join(tempfile.gettempdir(), "stretched_output.wav")
+    sf.write(out_path, stretched, sr, format="WAV")
+    return out_path
+
+# === Harmonic Saturation / Exciter – Now Included ===
+def harmonic_saturation(audio, saturation_type="Tube", intensity=0.2):
+    samples = np.array(audio.get_array_of_samples()).astype(np.float32)
+
+    if saturation_type == "Tube":
+        saturated = np.tanh(intensity * samples)
+    elif saturation_type == "Tape":
+        saturated = np.where(samples > 0, 1 - np.exp(-intensity * samples), -1 + np.exp(intensity * samples))
+    elif saturation_type == "Console":
+        saturated = np.clip(samples, -32768, 32768) * intensity
+    elif saturation_type == "Mix Bus":
+        saturated = np.log1p(np.abs(samples)) * np.sign(samples) * intensity
+    else:
+        saturated = samples
+
+    return array_to_audiosegment(saturated.astype(np.int16), audio.frame_rate, channels=audio.channels)
+
+# === A/B Compare Two Tracks ===
+def compare_ab(track1_path, track2_path):
+    return track1_path, track2_path
+
+# === Loop Section ===
+def loop_section(audio_path, start_ms, end_ms, loops=2):
+    audio = AudioSegment.from_file(audio_path)
+    section = audio[start_ms:end_ms]
+    looped = section * loops
+    out_path = os.path.join(tempfile.gettempdir(), "looped_output.wav")
+    looped.export(out_path, format="wav")
+    return out_path
+
+# === Save/Load Mix Session (.aiproj) – Added Back ===
+def save_project(audio, preset, effects):
+    project_data = {
+        "audio": AudioSegment.from_file(audio).raw_data,
+        "preset": preset,
+        "effects": effects
+    }
+    out_path = os.path.join(tempfile.gettempdir(), "project.aiproj")
+    with open(out_path, "wb") as f:
+        pickle.dump(project_data, f)
+    return out_path
+
+def load_project(project_file):
+    with open(project_file.name, "rb") as f:
+        data = pickle.load(f)
+    return data["preset"], data["effects"]
+
+# === Prompt-Based Editing Tab – Added Back ===
+def process_prompt(audio, prompt):
+    return apply_noise_reduction(audio)
+
+# === Vocal Formant Correction (AI Voice Tuning) ===
+def formant_correct(audio, shift=1.0):
+    samples, sr = audiosegment_to_array(audio)
+    corrected = librosa.effects.pitch_shift(samples, sr=sr, n_steps=shift)
+    return array_to_audiosegment(corrected.astype(np.int16), sr, channels=audio.channels)
+
+# === DAW Template Export ===
+def generate_ableton_template(stems):
+    template = {
+        "format": "Ableton Live",
+        "stems": [os.path.basename(s) 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
+
+# === Multi-stem ZIP Export ===
+def export_full_mix(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, f"stem_{i}.wav")
+        zipf.write(final_mix, "final_mix.wav")
+    return zip_path
+
+# === AI Sound Design (Text-to-Sound) ===
+def text_to_sound(prompt):
+    tts = TTS(model="tts_models/en/vctk/vits")
+    out_path = os.path.join(tempfile.gettempdir(), "generated_sound.wav")
+    tts.tts_to_file(text=prompt, speaker="p225", file_path=out_path)
+    return out_path
+
+# === Voice Cloning via OpenVoice (Simulated) ===
+def clone_voice(source_audio, reference_audio):
+    source = AudioSegment.from_file(source_audio)
+    ref = AudioSegment.from_file(reference_audio)
+    mixed = source.overlay(ref - 10)
+    out_path = os.path.join(tempfile.gettempdir(), "cloned_output.wav")
+    mixed.export(out_path, format="wav")
+    return out_path
+
+# === AI Remastering – Now Fixed! ===
+def ai_remaster(audio_path):
+    try:
+        audio = AudioSegment.from_file(audio_path)
+        samples, sr = audiosegment_to_array(audio)
+        reduced = nr.reduce_noise(y=samples, sr=sr)
+        cleaned = array_to_audiosegment(reduced, sr, channels=audio.channels)
+        cleaned_wav_path = os.path.join(tempfile.gettempdir(), "cleaned.wav")
+        cleaned.export(cleaned_wav_path, format="wav")
+        isolated_path = apply_vocal_isolation(cleaned_wav_path)
+        final_path = ai_mastering_chain(isolated_path, genre="Pop", target_lufs=-14.0)
+        return final_path
+    except Exception as e:
+        print(f"Remastering Error: {str(e)}")
+        return None
+
+def ai_mastering_chain(audio_path, genre="Pop", target_lufs=-14.0):
+    audio = AudioSegment.from_file(audio_path)
+    audio = auto_eq(audio, genre=genre)
+    audio = match_loudness(audio_path, target_lufs=target_lufs)
+    audio = apply_stereo_widen(audio, pan_amount=0.3)
+    out_path = os.path.join(tempfile.gettempdir(), "mastered_output.wav")
+    audio.export(out_path, format="wav")
+    return out_path
+
+# === Generate PDF Report ===
+try:
+    from fpdf import FPDF
+except ImportError:
+    print("FPDF not found – skipping PDF report for now")
+
+class PDFReport(FPDF):
+    def header(self):
+        self.set_font('Arial', 'B', 12)
+        self.cell(0, 10, 'Studio Pulse AI - Session Report', ln=True, align='C')
+
+def export_session_report(session_data):
+    pdf = PDFReport()
+    pdf.add_page()
+    pdf.set_font("Arial", size=10)
+    pdf.multi_cell(0, 10, txt=session_data)
+    out_path = os.path.join(tempfile.gettempdir(), "session_report.pdf")
+    pdf.output(out_path)
+    return out_path
+
+# === Main UI – With Studio Pulse Branding ===
+with gr.Blocks(css="""
+    body {
+        font-family: 'Segoe UI', sans-serif;
+        background-color: #1f2937;
+        color: white;
+        padding: 20px;
+    }
+
+    .studio-header {
+        text-align: center;
+        margin-bottom: 30px;
+        animation: float 3s ease-in-out infinite;
+    }
+
+    @keyframes float {
+        0%, 100% { transform: translateY(0); }
+        50% { transform: translateY(-10px); }
+    }
+
+    .gr-button {
+        background-color: #2563eb !important;
+        color: white !important;
+        border-radius: 10px;
+        padding: 10px 20px;
+        font-weight: bold;
+        box-shadow: 0 0 10px #2563eb44;
+        border: none;
+    }
+
+    .gr-button:hover {
+        background-color: #3b82f6 !important;
+        box-shadow: 0 0 15px #3b82f6aa;
+    }
+
+    input[type="text"], input[type="number"], select, textarea {
+        background-color: #334155 !important;
+        color: white !important;
+        border: 1px solid #475569 !important;
+        width: 100%;
+        padding: 10px;
+    }
+
+    .gr-checkboxgroup label {
+        background: #334155;
+        color: white;
+        border: 1px solid #475569;
+        border-radius: 6px;
+        padding: 8px 12px;
+        transition: background 0.3s;
+    }
+
+    .gr-checkboxgroup label:hover {
+        background: #475569;
+        cursor: pointer;
+    }
+
+    .gr-gallery__items > div {
+        border-radius: 12px;
+        overflow: hidden;
+        transition: transform 0.3s ease, box-shadow 0.3s ease;
+    }
+
+    .gr-gallery__items > div:hover {
+        transform: scale(1.02);
+        box-shadow: 0 0 12px #2563eb44;
+    }
+
+    @media (max-width: 768px) {
+        .gr-column {
+            min-width: 100%;
+        }
+
+        .gr-row {
+            flex-direction: column;
+        }
+
+        .studio-header img {
+            width: 90%;
+        }
+
+        .gr-button {
+            width: 100%;
+        }
+    }
+""") as demo:
+
+    # Header
+    gr.HTML('''
+    <div class="studio-header">
+        <img src="logo.png" width="400" />
+        <h3>Where Your Audio Meets Intelligence</h3>
+    </div>
+    ''')
+
+    gr.Markdown("### Upload, edit, export — powered by AI!")
+
+    # --- Single File Studio Tab ---
+    with gr.Tab("🎵 Single File Studio"):
+        with gr.Row():
+            with gr.Column(min_width=300):
+                input_audio = gr.Audio(label="Upload Audio", type="filepath")
+                effect_checkbox = gr.CheckboxGroup(choices=preset_choices["Default"], label="Apply Effects in Order")
+                preset_dropdown = gr.Dropdown(choices=preset_names, label="Select Preset", value=preset_names[0])
+                export_format = gr.Dropdown(choices=["MP3", "WAV"], label="Export Format", value="MP3")
+                isolate_vocals = gr.Checkbox(label="Isolate Vocals After Effects")
+                submit_btn = gr.Button("Process Audio")
+            with gr.Column(min_width=300):
+                output_audio = gr.Audio(label="Processed Audio", type="filepath")
+                waveform_img = gr.Image(label="Waveform Preview")
+                session_log_out = gr.Textbox(label="Session Log", lines=5)
+                genre_out = gr.Textbox(label="Detected Genre", lines=1)
+                status_box = gr.Textbox(label="Status", value="✅ Ready", lines=1)
+
+        submit_btn.click(fn=process_audio, inputs=[
+            input_audio, effect_checkbox, isolate_vocals, preset_dropdown, export_format
+        ], outputs=[
+            output_audio, waveform_img, session_log_out, genre_out, status_box
+        ])
+
+    # --- Remix Mode – Stem Splitting + Per-Stem Effects ===
+    with gr.Tab("🎛 Remix Mode"):
+        with gr.Row():
+            with gr.Column(min_width=200):
+                input_audio_remix = gr.Audio(label="Upload Music Track", type="filepath")
+                split_button = gr.Button("Split Into Drums, Bass, Vocals, etc.")
+            with gr.Column(min_width=400):
+                stem_outputs = [
+                    gr.File(label="Vocals"),
+                    gr.File(label="Drums"),
+                    gr.File(label="Bass"),
+                    gr.File(label="Other")
+                ]
+
+        split_button.click(fn=stem_split, inputs=[input_audio_remix], outputs=stem_outputs)
+
+        gr.Markdown("#### Apply Effects to Individual Stems")
+        with gr.Row():
+            with gr.Column(min_width=200):
+                vocals_path = gr.File(label="Vocals Track")
+                vocal_effects = gr.CheckboxGroup([
+                    "Noise Reduction",
+                    "Normalize",
+                    "Bass Boost",
+                    "Treble Boost",
+                    "Reverb",
+                    "Vocal Distortion",
+                    "Auto Gain"
+                ])
+                btn_vocals = gr.Button("Process Vocals")
+                output_vocals = gr.Audio(label="Processed Vocals", type="filepath")
+                btn_vocals.click(fn=apply_effects_to_stem, inputs=[vocals_path, vocal_effects], outputs=output_vocals)
+
+            with gr.Column(min_width=200):
+                drums_path = gr.File(label="Drums Track")
+                drum_effects = gr.CheckboxGroup([
+                    "Bass Boost",
+                    "Compress Dynamic Range",
+                    "Limiter",
+                    "Bitcrusher",
+                    "Stereo Widening"
+                ])
+                btn_drums = gr.Button("Process Drums")
+                output_drums = gr.Audio(label="Processed Drums", type="filepath")
+                btn_drums.click(fn=apply_effects_to_stem, inputs=[drums_path, drum_effects], outputs=output_drums)
+
+            with gr.Column(min_width=200):
+                bass_path = gr.File(label="Bass Track")
+                bass_effects = gr.CheckboxGroup([
+                    "Bass Boost",
+                    "Saturation (Tape)",
+                    "Limiter"
+                ])
+                btn_bass = gr.Button("Process Bass")
+                output_bass = gr.Audio(label="Processed Bass", type="filepath")
+                btn_bass.click(fn=apply_effects_to_stem, inputs=[bass_path, bass_effects], outputs=output_bass)
+
+            with gr.Column(min_width=200):
+                other_path = gr.File(label="Other Track")
+                other_effects = gr.CheckboxGroup([
+                    "Noise Gate",
+                    "Reverb",
+                    "Treble Boost"
+                ])
+                btn_other = gr.Button("Process Other")
+                output_other = gr.Audio(label="Processed Other", type="filepath")
+                btn_other.click(fn=apply_effects_to_stem, inputs=[other_path, other_effects], outputs=output_other)
+
+    # --- AI Remastering Tab – Now Fixed & Working ===
+    with gr.Tab("🔮 AI Remastering"):
+        gr.Interface(
+            fn=ai_remaster,
+            inputs=gr.Audio(label="Upload Low-Quality Recording", type="filepath"),
+            outputs=gr.Audio(label="Studio-Grade Output", type="filepath"),
+            title="Transform Low-Quality Recordings to Studio Sound",
+            description="Uses noise reduction, vocal isolation, and mastering to enhance old recordings."
+        )
+
+    # --- Harmonic Saturation / Exciter – Now Included ===
+    with gr.Tab("🧬 Harmonic Saturation"):
+        gr.Interface(
+            fn=harmonic_saturation,
+            inputs=[
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Dropdown(choices=["Tube", "Tape", "Console", "Mix Bus"], label="Saturation Type", value="Tube"),
+                gr.Slider(minimum=0.1, maximum=1.0, value=0.2, label="Intensity")
+            ],
+            outputs=gr.Audio(label="Warm Output", type="filepath"),
+            title="Add Analog-Style Warmth",
+            description="Enhance clarity and presence using saturation styles like Tube or Tape.",
+            allow_flagging="never"
+        )
+
+    # --- Vocal Doubler / Harmonizer – Added ===
+    with gr.Tab("🎧 Vocal Doubler / Harmonizer"):
+        gr.Interface(
+            fn=lambda x: apply_harmony(x),
+            inputs=gr.Audio(label="Upload Vocal Clip", type="filepath"),
+            outputs=gr.Audio(label="Doubled Output", type="filepath"),
+            title="Add Vocal Doubling / Harmony",
+            description="Enhance vocals with doubling or harmony"
+        )
+
+    # --- Batch Processing – Full Support ===
+    with gr.Tab("🔊 Batch Processing"):
+        gr.Interface(
+            fn=batch_process_audio,
+            inputs=[
+                gr.File(label="Upload Multiple Files", file_count="multiple"),
+                gr.CheckboxGroup(choices=preset_choices["Default"], label="Apply Effects in Order"),
+                gr.Checkbox(label="Isolate Vocals After Effects"),
+                gr.Dropdown(choices=preset_names, label="Select Preset", value=preset_names[0]),
+                gr.Dropdown(choices=["MP3", "WAV"], label="Export Format", value="MP3")
+            ],
+            outputs=[
+                gr.File(label="Download ZIP of All Processed Files"),
+                gr.Textbox(label="Status", value="✅ Ready", lines=1)
+            ],
+            title="Batch Audio Processor",
+            description="Upload multiple files, apply effects in bulk, and download all results in a single ZIP.",
+            flagging_mode="never",
+            submit_btn="Process All Files"
+        )
+
+    # --- Vocal Pitch Correction – Auto-Tune Style ===
+    with gr.Tab("🎤 AI Auto-Tune"):
+        gr.Interface(
+            fn=auto_tune_vocal,
+            inputs=[
+                gr.File(label="Source Voice Clip"),
+                gr.Textbox(label="Target Key", value="C", lines=1)
+            ],
+            outputs=gr.Audio(label="Pitch-Corrected Output", type="filepath"),
+            title="AI Auto-Tune",
+            description="Correct vocal pitch automatically using AI"
+        )
+
+    # --- Frequency Spectrum Tab – Real-time Visualizer ===
+    def visualize_spectrum(audio_path):
+        y, sr = torchaudio.load(audio_path)
+        y_np = y.numpy().flatten()
+        stft = librosa.stft(y_np)
+        db = librosa.amplitude_to_db(abs(stft))
+        plt.figure(figsize=(10, 4))
+        img = librosa.display.specshow(db, sr=sr, x_axis="time", y_axis="hz", cmap="magma")
+        plt.colorbar(img, format="%+2.0f dB")
+        plt.title("Frequency Spectrum")
+        plt.tight_layout()
+        buf = BytesIO()
+        plt.savefig(buf, format="png")
+        plt.close()
+        buf.seek(0)
+        return Image.open(buf)
+
+    with gr.Tab("📊 Frequency Spectrum"):
+        gr.Interface(
+            fn=visualize_spectrum,
+            inputs=gr.Audio(label="Upload Track", type="filepath"),
+            outputs=gr.Image(label="Spectrum Analysis")
+        )
+
+    # --- Loudness Graph Tab – EBU R128 Matching ===
+    with gr.Tab("📈 Loudness Graph"):
+        gr.Interface(
+            fn=match_loudness,
+            inputs=[
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Slider(minimum=-24, maximum=-6, value=-14, label="Target LUFS")
+            ],
+            outputs=gr.Audio(label="Normalized Output", type="filepath"),
+            title="Match Loudness Across Tracks",
+            description="Ensure consistent volume using EBU R128 standard"
+        )
+
+    # --- Save/Load Mix Session (.aiproj) – Added Back ===
+    with gr.Tab("📁 Save/Load Project"):
+        with gr.Row():
+            with gr.Column(min_width=300):
+                gr.Interface(
+                    fn=save_project,
+                    inputs=[
+                        gr.File(label="Original Audio"),
+                        gr.Dropdown(choices=preset_names, label="Used Preset", value=preset_names[0]),
+                        gr.CheckboxGroup(choices=preset_choices["Default"], label="Applied Effects")
+                    ],
+                    outputs=gr.File(label="Project File (.aiproj)")
+                )
+            with gr.Column(min_width=300):
+                gr.Interface(
+                    fn=load_project,
+                    inputs=gr.File(label="Upload .aiproj File"),
+                    outputs=[
+                        gr.Dropdown(choices=preset_names, label="Loaded Preset"),
+                        gr.CheckboxGroup(choices=preset_choices["Default"], label="Loaded Effects")
+                    ],
+                    title="Resume Last Project",
+                    description="Load your saved session"
+                )
+
+    # --- Prompt-Based Editing Tab – Added Back ===
+    with gr.Tab("🧠 Prompt-Based Editing"):
+        gr.Interface(
+            fn=process_prompt,
+            inputs=[
+                gr.File(label="Upload Audio", type="filepath"),
+                gr.Textbox(label="Describe What You Want", lines=5)
+            ],
+            outputs=gr.Audio(label="Edited Output", type="filepath"),
+            title="Type Your Edits – AI Does the Rest",
+            description="Say what you want done and let AI handle it.",
+            allow_flagging="never"
+        )
+
+    # --- Vocal Presets for Singers – Added Back ===
+    with gr.Tab("🎤 Vocal Presets for Singers"):
+        gr.Interface(
+            fn=process_audio,
+            inputs=[
+                gr.Audio(label="Upload Vocal Track", type="filepath"),
+                gr.CheckboxGroup(choices=[
+                    "Noise Reduction",
+                    "Normalize",
+                    "Compress Dynamic Range",
+                    "Bass Boost",
+                    "Treble Boost",
+                    "Reverb",
+                    "Auto Gain",
+                    "Vocal Distortion",
+                    "Harmony",
+                    "Stage Mode"
+                ]),
+                gr.Checkbox(label="Isolate Vocals After Effects"),
+                gr.Dropdown(choices=preset_names, label="Select Vocal Preset", value=preset_names[0]),
+                gr.Dropdown(choices=["MP3", "WAV"], label="Export Format", value="MP3")
+            ],
+            outputs=[
+                gr.Audio(label="Processed Vocal", type="filepath"),
+                gr.Image(label="Waveform Preview"),
+                gr.Textbox(label="Session Log (JSON)", lines=5),
+                gr.Textbox(label="Detected Genre", lines=1),
+                gr.Textbox(label="Status", value="✅ Ready", lines=1)
+            ],
+            title="Create Studio-Quality Vocal Tracks",
+            description="Apply singer-friendly presets and effects to enhance vocals.",
+            allow_flagging="never"
+        )
+
+    # --- Real-Time Streaming Preview ===
+    with gr.Tab("🎧 Real-Time Preview"):
+        gr.Interface(
+            fn=live_effect_preview,
+            inputs=[
+                gr.Audio(sources=["microphone"], streaming=True, label="Live Mic Input"),
+                gr.Dropdown(choices=["Normalize", "Reverb", "Pitch Shift", "Saturation"], label="Effect", value="Normalize")
+            ],
+            outputs=gr.Audio(label="Live Output", type="filepath"),
+            title="Preview Effects in Real-Time",
+            description="Try effects live before exporting"
+        )
+
+    # --- Custom EQ Editor ===
+    with gr.Tab("🎛 Custom EQ Editor"):
+        gr.Interface(
+            fn=auto_eq,
+            inputs=[
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Dropdown(choices=["Pop", "EDM", "Rock", "Hip-Hop", "Acoustic", "Metal", "Trap", "LoFi",
+                                 "Jazz", "Classical", "Chillhop", "Ambient", "Jazz Piano", "Trap EDM",
+                                 "Indie Rock", "Lo-Fi Jazz", "R&B", "Soul", "Funk"],
+                       label="Genre", value="Pop")
+            ],
+            outputs=gr.Audio(label="EQ-Enhanced Output", type="filepath"),
+            title="Custom EQ by Genre",
+            description="Apply custom EQ based on genre"
+        )
+
+    # --- AI Suggest Effects Based on Genre ===
+    with gr.Tab("🧩 AI Effect Suggestions"):
+        gr.Interface(
+            fn=suggest_by_genre,
+            inputs=gr.Audio(label="Upload Track", type="filepath"),
+            outputs=gr.CheckboxGroup(choices=preset_choices["Default"], label="Suggested Effects")
+        )
+
+    # --- Time-Stretch & BPM Match ===
+    with gr.Tab("⏱ Time-Stretch & BPM Match"):
+        gr.Interface(
+            fn=stretch_to_bpm,
+            inputs=[
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Slider(minimum=60, maximum=200, value=128, label="Target BPM")
+            ],
+            outputs=gr.Audio(label="Stretched Output", type="filepath"),
+            title="Match Track to BPM",
+            description="Stretch or shrink audio to match a specific tempo"
+        )
+
+    # --- A/B Compare ===
+    with gr.Tab("🎯 A/B Compare"):
+        gr.Interface(
+            fn=compare_ab,
+            inputs=[
+                gr.Audio(label="Version A", type="filepath"),
+                gr.Audio(label="Version B", type="filepath")
+            ],
+            outputs=[
+                gr.Audio(label="Version A", type="filepath"),
+                gr.Audio(label="Version B", type="filepath")
+            ],
+            title="Compare Two Versions",
+            description="Hear two mixes side-by-side",
+            allow_flagging="never"
+        )
+
+    # --- Loop Playback ===
+    with gr.Tab("🔁 Loop Playback"):
+        gr.Interface(
+            fn=loop_section,
+            inputs=[
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Slider(minimum=0, maximum=30000, step=100, value=5000, label="Start MS"),
+                gr.Slider(minimum=100, maximum=30000, step=100, value=10000, label="End MS"),
+                gr.Slider(minimum=1, maximum=10, value=2, label="Repeat Loops")
+            ],
+            outputs=gr.Audio(label="Looped Output", type="filepath"),
+            title="Repeat a Section",
+            description="Useful for editing a specific part"
+        )
+
+    # --- Share Effect Chain Tab – Now Defined! ===
+    with gr.Tab("🔗 Share Effect Chain"):
+        gr.Interface(
+            fn=lambda x: json.dumps(x),
+            inputs=gr.CheckboxGroup(choices=preset_choices["Default"]),
+            outputs=gr.Textbox(label="Share Code", lines=2),
+            title="Copy/Paste Effect Chain",
+            description="Share your setup via link/code"
+        )
+
+    with gr.Tab("📥 Load Shared Chain"):
+        gr.Interface(
+            fn=json.loads,
+            inputs=gr.Textbox(label="Paste Shared Code", lines=2),
+            outputs=gr.CheckboxGroup(choices=preset_choices["Default"], label="Loaded Effects"),
+            title="Restore From Shared Chain",
+            description="Paste shared effect chain JSON to restore settings"
+        )
+
+    # --- 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  
+        """)
+
+    # --- Vocal Formant Correction – Now Defined! ===
+    with gr.Tab("🧑‍🎤 Vocal Formant Correction"):
+        gr.Interface(
+            fn=formant_correct,
+            inputs=[
+                gr.Audio(label="Upload Vocal Track", type="filepath"),
+                gr.Slider(minimum=-2, maximum=2, value=1.0, label="Formant Shift")
+            ],
+            outputs=gr.Audio(label="Natural-Sounding Vocal", type="filepath"),
+            title="Preserve Vocal Quality During Pitch Shift",
+            description="Make pitch-shifted vocals sound more human"
+        )
+
+    # --- Voice Swap / Cloning – New Tab ===
+    with gr.Tab("🔁 Voice Swap / Cloning"):
+        gr.Interface(
+            fn=clone_voice,
+            inputs=[
+                gr.File(label="Source Voice Clip"),
+                gr.File(label="Reference Voice")
+            ],
+            outputs=gr.Audio(label="Converted Output", type="filepath"),
+            title="Swap Voices Using AI",
+            description="Clone or convert voice from one to another"
+        )
+
+    # --- DAW Template Export – Now Included ===
+    with gr.Tab("🎛 DAW Template Export"):
+        gr.Interface(
+            fn=generate_ableton_template,
+            inputs=[gr.File(label="Upload Stems", file_count="multiple")],
+            outputs=gr.File(label="DAW Template (.json/.als/.flp)")
+        )
+
+    # --- Export Full Mix ZIP – Added Back ===
+    with gr.Tab("📁 Export Full Mix ZIP"):
+        gr.Interface(
+            fn=export_full_mix,
+            inputs=[
+                gr.File(label="Stems", file_count="multiple"),
+                gr.File(label="Final Mix")
+            ],
+            outputs=gr.File(label="Full Mix Archive (.zip)"),
+            title="Export Stems + Final Mix Together",
+            description="Perfect for sharing with producers or archiving"
+        )
+
+    # --- Session Report Export (PDF) ===
+    with gr.Tab("📄 Session Report"):
+        gr.Interface(
+            fn=export_session_report,
+            inputs=gr.Textbox(label="Session Data (JSON)", lines=10),
+            outputs=gr.File(label="Download PDF Report"),
+            title="Export Detailed Session Report",
+            description="For professional use or sharing with collaborators"
+        )
+
+    # --- Effect Chains Marketplace – New Tab ===
+    with gr.Tab("🧩 Effect Chain Marketplace"):
+        gr.Interface(
+            fn=publish_effect_chain,
+            inputs=[
+                gr.Textbox(label="Effect Chain (JSON)", lines=2),
+                gr.Textbox(label="Name", value="My Chain"),
+                gr.CheckboxGroup(choices=["music", "vocals", "podcast", "radio", "edm"], label="Tags")
+            ],
+            outputs=gr.JSON(label="Published Chain Info"),
+            title="Publish Your Effect Chain",
+            description="Share your setup with others"
+        )
+
+    with gr.Tab("🧩 Search Chains"):
+        gr.Interface(
+            fn=search_effect_chains,
+            inputs=gr.Textbox(label="Search Query", value="vocal"),
+            outputs=gr.JSON(label="Matching Chains")
+        )
+
+demo.launch()