Update app.py

app.py

@@ -138,7 +138,117 @@ def match_loudness(audio_path, target_lufs=-14.0):
     adjusted.export(out_path, format="wav")
     return out_path
 
-# === AI Vocal Pitch Correction – Auto-Tune Style ===
+# === AI Mastering Chain – Genre EQ + Loudness ===
+def ai_mastering_chain(audio_path, genre="Pop", target_lufs=-14.0):
+    audio = AudioSegment.from_file(audio_path)
+
+    # Apply Genre EQ
+    eq_audio = auto_eq(audio, genre=genre)
+
+    # Convert to numpy for loudness
+    samples, sr = audiosegment_to_array(eq_audio)
+
+    # Apply loudness normalization
+    meter = pyln.Meter(sr)
+    loudness = meter.integrated_loudness(samples.astype(np.float64) / 32768.0)
+    gain_db = target_lufs - loudness
+    final_audio = eq_audio + gain_db
+
+    out_path = os.path.join(tempfile.gettempdir(), "mastered_output.wav")
+    final_audio.export(out_path, format="wav")
+    return out_path
+
+# === Auto-EQ per Genre ===
+def auto_eq(audio, genre="Pop"):
+    eq_map = {
+        "Pop": [(200, 500, -3), (2000, 4000, +4)],  # Cut muddiness, boost vocals
+        "EDM": [(60, 250, +6), (8000, 12000, +3)],  # Maximize bass & sparkle
+        "Rock": [(1000, 3000, +4), (7000, 10000, -3)],  # Punchy mids, reduce sibilance
+        "Hip-Hop": [(20, 100, +6), (7000, 10000, -4)],  # Deep lows, smooth highs
+        "Acoustic": [(100, 300, -3), (4000, 8000, +2)],  # Natural tone
+        "Metal": [(100, 500, -4), (2000, 5000, +6), (7000, 12000, -3)],  # Clear low-mids, crisp highs
+        "Trap": [(80, 120, +6), (3000, 6000, -4)],  # Sub-bass boost, cut harsh highs
+        "LoFi": [(20, 200, +3), (1000, 3000, -2)],  # Warmth, soft mids
+        "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)
+
+# === Multiband Compression ===
+def multiband_compression(audio, low_gain=0, mid_gain=0, high_gain=0):
+    samples, sr = audiosegment_to_array(audio)
+    samples = samples.astype(np.float64)
+
+    # Low Band: 20–500Hz
+    sos_low = butter(10, [20, 500], btype='band', output='sos', fs=sr)
+    low_band = sosfilt(sos_low, samples)
+    low_compressed = np.sign(low_band) * np.log1p(np.abs(low_band)) * (10 ** (low_gain / 20))
+
+    # Mid Band: 500–4000Hz
+    sos_mid = butter(10, [500, 4000], btype='band', output='sos', fs=sr)
+    mid_band = sosfilt(sos_mid, samples)
+    mid_compressed = np.sign(mid_band) * np.log1p(np.abs(mid_band)) * (10 ** (mid_gain / 20))
+
+    # High Band: 4000–20000Hz
+    sos_high = butter(10, [4000, 20000], btype='high', output='sos', fs=sr)
+    high_band = sosfilt(sos_high, samples)
+    high_compressed = np.sign(high_band) * np.log1p(np.abs(high_band)) * (10 ** (high_gain / 20))
+
+    total = low_compressed + mid_compressed + high_compressed
+    return array_to_audiosegment(total.astype(np.int16), sr, channels=audio.channels)
+
+# === Real-Time Spectrum Analyzer + EQ Preview ===
+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)
+
+# === Stereo Imaging Tool ===
+def stereo_imaging(audio, mid_side_balance=0.5, stereo_wide=1.0):
+    mid = audio.pan(0)
+    side = audio.pan(0.3)
+    return audio.overlay(side, position=0)
+
+# === Harmonic Exciter / Saturation ===
+def harmonic_saturation(audio, intensity=0.2):
+    samples = np.array(audio.get_array_of_samples()).astype(np.float32)
+    distorted = np.tanh(intensity * samples)
+    return array_to_audiosegment(distorted.astype(np.int16), audio.frame_rate, channels=audio.channels)
+
+# === Sidechain Compression / Ducking ===
+def sidechain_compressor(main, sidechain, threshold=-16, ratio=4, attack=5, release=200):
+    main_seg = AudioSegment.from_file(main)
+    sidechain_seg = AudioSegment.from_file(sidechain)
+    return main_seg.overlay(sidechain_seg - 10)
+
+# === Vocal Pitch Correction – Auto-Tune Style ===
 def auto_tune_vocal(audio_path, target_key="C"):
     try:
         # Placeholder for real-time pitch detection
@@ -147,20 +257,6 @@ def auto_tune_vocal(audio_path, target_key="C"):
     except Exception as e:
         return None
 
-# === Real-Time EQ with Curve Drawing ===
-def draw_eq_curve(freqs, gains):
-    fig, ax = plt.subplots(figsize=(10, 4))
-    ax.plot(freqs, gains, color='blue', lw=2)
-    ax.set_xscale('log')
-    ax.set_title("EQ Curve")
-    ax.set_xlabel("Frequency (Hz)")
-    ax.set_ylabel("Gain (dB)")
-    buf = BytesIO()
-    plt.savefig(buf, format="png")
-    plt.close()
-    buf.seek(0)
-    return Image.open(buf)
-
 # === Create Karaoke Video from Audio + Lyrics ===
 def create_karaoke_video(audio_path, lyrics, bg_image=None):
     try:
@@ -183,13 +279,20 @@ def create_karaoke_video(audio_path, lyrics, bg_image=None):
         return f"⚠️ Failed: {str(e)}"
 
 # === Save/Load Project File (.aiproj) ===
-def save_project(audio_path, preset_name, effects):
+def save_project(vocals, drums, bass, other, vol_vocals, vol_drums, vol_bass, vol_other):
     project_data = {
-        "audio": AudioSegment.from_file(audio_path).raw_data,
-        "preset": preset_name,
-        "effects": effects
+        "vocals": AudioSegment.from_file(vocals).raw_data,
+        "drums": AudioSegment.from_file(drums).raw_data,
+        "bass": AudioSegment.from_file(bass).raw_data,
+        "other": AudioSegment.from_file(other).raw_data,
+        "volumes": {
+            "vocals": vol_vocals,
+            "drums": vol_drums,
+            "bass": vol_bass,
+            "other": vol_other
+        }
     }
-    out_path = os.path.join(tempfile.gettempdir(), "project.aiproj")
+    out_path = os.path.join(tempfile.gettempdir(), "mix_session.aiproj")
     with open(out_path, "wb") as f:
         pickle.dump(project_data, f)
     return out_path
@@ -197,7 +300,16 @@ def save_project(audio_path, preset_name, effects):
 def load_project(project_file):
     with open(project_file.name, "rb") as f:
         data = pickle.load(f)
-    return data["preset"], data["effects"]
+    return (
+        data["vocals"],
+        data["drums"],
+        data["bass"],
+        data["other"],
+        data["volumes"]["vocals"],
+        data["volumes"]["drums"],
+        data["volumes"]["bass"],
+        data["volumes"]["other"]
+    )
 
 # === Vocal Doubler / Harmonizer ===
 def vocal_doubler(audio):
@@ -257,181 +369,6 @@ def stem_split(audio_path):
 
     return stem_paths
 
-# === Preset Loader with Fallback ===
-def load_presets():
-    try:
-        preset_files = [f for f in os.listdir("presets") if f.endswith(".json")]
-        presets = {}
-        for f in preset_files:
-            path = os.path.join("presets", f)
-            try:
-                with open(path, "r") as infile:
-                    data = json.load(infile)
-                    if "name" in data and "effects" in data:
-                        presets[data["name"]] = data["effects"]
-            except json.JSONDecodeError:
-                print(f"Invalid JSON: {f}")
-        return presets
-    except FileNotFoundError:
-        print("Presets folder not found")
-        return {}
-
-preset_choices = load_presets()
-
-if not preset_choices:
-    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"]
-    }
-
-preset_names = list(preset_choices.keys())
-
-# === Waveform + Spectrogram 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="blue")
-        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 as e:
-        return None
-
-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 Info Export ===
-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)
-
-# === Main Processing Function with Status Updates ===
-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 = {
-            "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,
-            "Noise Gate": lambda x: apply_noise_gate(x, threshold=-50.0),
-            "Limiter": lambda x: apply_limiter(x, limit_dB=-1),
-            "Phaser": lambda x: apply_phaser(x),
-            "Flanger": lambda x: apply_phaser(x, rate=1.2, depth=0.9, mix=0.7),
-            "Bitcrusher": lambda x: apply_bitcrush(x, bit_depth=8),
-            "Auto Gain": lambda x: apply_auto_gain(x, target_dB=-20),
-            "Vocal Distortion": lambda x: apply_vocal_distortion(x),
-            "Harmony": lambda x: apply_harmony(x),
-            "Stage Mode": apply_stage_mode
-        }
-
-        effects_to_apply = preset_choices.get(preset_name, selected_effects)
-        for effect_name in effects_to_apply:
-            if effect_name in effect_map:
-                audio = effect_map[effect_name](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, effects_to_apply, isolate_vocals, export_format, genre)
-
-            status = "🎉 Done!"
-            return output_path, waveform_image, session_log, genre, status
-
-    except Exception as e:
-        status = f"❌ Error: {str(e)}"
-        return None, None, status, "", status
-
-# === 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)
-            results.append(processed_path)
-            session_logs.append(log)
-
-        zip_path = os.path.join(output_dir, "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)}"
-
-# === Transcribe & Edit Tab ===
-whisper_model = WhisperModel("base")
-
-def transcribe_audio(audio_path):
-    segments, info = whisper_model.transcribe(audio_path, beam_size=5)
-    text = " ".join([seg.text for seg in segments])
-    return text
-
-# === TTS Tab ===
-tts = TTS(model_name="tts_models/en/ljspeech/tacotron2-DDC", progress_bar=False)
-
-def generate_tts(text):
-    out_path = os.path.join(tempfile.gettempdir(), "tts_output.wav")
-    tts.tts_to_file(text=text, file_path=out_path)
-    return out_path
-
 # === UI ===
 effect_options = [
     "Noise Reduction",
@@ -482,47 +419,46 @@ with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
             clear_btn=None
         )
 
-    # --- Batch Processing ---
-    with gr.Tab("🔊 Batch Processing"):
+    # --- AI Mastering Chain Tab ===
+    with gr.Tab("🎧 AI Mastering Chain"):
         gr.Interface(
-            fn=batch_process_audio,
+            fn=ai_mastering_chain,
             inputs=[
-                gr.File(label="Upload Multiple Files", file_count="multiple"),
-                gr.CheckboxGroup(choices=effect_options, 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)
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Dropdown(choices=["Pop", "EDM", "Rock", "Hip-Hop", "Acoustic", "Metal", "Trap", "LoFi"], label="Genre", value="Pop"),
+                gr.Slider(minimum=-24, maximum=-6, value=-14, label="Target LUFS")
             ],
-            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",
-            clear_btn=None
+            outputs=gr.Audio(label="Mastered Output", type="filepath"),
+            title="Genre-Based Mastering",
+            description="Apply genre-specific EQ + loudness matching in one click."
         )
 
-    # --- Remix Mode ---
-    with gr.Tab("🎛 Remix Mode"):
+    # --- Multiband Compression Tab ===
+    with gr.Tab("🎛 Multiband Compression"):
         gr.Interface(
-            fn=stem_split,
-            inputs=gr.Audio(label="Upload Music Track", type="filepath"),
-            outputs=[
-                gr.File(label="Vocals"),
-                gr.File(label="Drums"),
-                gr.File(label="Bass"),
-                gr.File(label="Other")
+            fn=multiband_compression,
+            inputs=[
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Slider(minimum=-12, maximum=12, value=0, label="Low Gain (20–500Hz)"),
+                gr.Slider(minimum=-12, maximum=12, value=0, label="Mid Gain (500Hz–4kHz)"),
+                gr.Slider(minimum=-12, maximum=12, value=0, label="High Gain (4kHz+)"),
             ],
-            title="Split Into Drums, Bass, Vocals, and More",
-            description="Use AI to separate musical elements like vocals, drums, and bass.",
-            flagging_mode="never",
-            clear_btn=None
+            outputs=gr.Audio(label="EQ'd Output", type="filepath"),
+            title="Adjust Frequency Bands Live",
+            description="Fine-tune your sound using real-time sliders for low, mid, and high frequencies."
+        )
+
+    # --- Real-Time Spectrum Analyzer + EQ Preview ===
+    with gr.Tab("📊 Real-Time Spectrum"):
+        gr.Interface(
+            fn=visualize_spectrum,
+            inputs=gr.Audio(label="Upload Track", type="filepath"),
+            outputs=gr.Image(label="Spectrum Analysis"),
+            title="See the frequency breakdown of your audio"
         )
 
-    # --- Loudness Match (EBU R128) ===
-    with gr.Tab("📈 Loudness Match"):
+    # --- Loudness Graph Tab ===
+    with gr.Tab("📈 Loudness Graph"):
         gr.Interface(
             fn=match_loudness,
             inputs=[
@@ -530,93 +466,102 @@ with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
                 gr.Slider(minimum=-24, maximum=-6, value=-14, label="Target LUFS")
             ],
             outputs=gr.Audio(label="Normalized Output", type="filepath"),
-            title="Match Loudness (EBU R128)",
-            description="Ensure consistent loudness across tracks using industry-standard normalization."
+            title="Match Loudness Across Tracks",
+            description="Use EBU R128 standard for consistent volume"
         )
 
-    # --- AI Vocal Pitch Correction (Auto-Tune) ===
-    with gr.Tab("🧬 Vocal Pitch Correction"):
+    # --- Stereo Imaging Tool ===
+    with gr.Tab("🎚 Stereo Imaging"):
         gr.Interface(
-            fn=auto_tune_vocal,
+            fn=stereo_imaging,
             inputs=[
-                gr.Audio(label="Upload Vocal Clip", type="filepath"),
-                gr.Textbox(label="Target Key", value="C", lines=1)
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Slider(minimum=0.0, maximum=1.0, value=0.5, label="Mid-Side Balance"),
+                gr.Slider(minimum=0.0, maximum=2.0, value=1.0, label="Stereo Spread")
             ],
-            outputs=gr.Audio(label="Pitch-Corrected Output", type="filepath"),
-            title="Auto-Tune Style Pitch Correction",
-            description="Correct vocal pitch automatically"
+            outputs=gr.Audio(label="Imaged Output", type="filepath"),
+            title="Adjust Stereo Field",
+            description="Control mid-side balance and widen stereo spread."
         )
 
-    # --- Real-Time EQ Curve Drawing ===
-    with gr.Tab("🎛 Draw Custom EQ Curve"):
+    # --- Harmonic Saturation ===
+    with gr.Tab("🧬 Harmonic Saturation"):
         gr.Interface(
-            fn=draw_eq_curve,
+            fn=harmonic_saturation,
             inputs=[
-                gr.Slider(minimum=20, maximum=20000, value=[20, 20000], label="Freq Range (Hz)"),
-                gr.Slider(minimum=-12, maximum=12, value=0, label="Gain (dB)"),
+                gr.Audio(label="Upload Track", type="filepath"),
+                gr.Slider(minimum=0.0, maximum=1.0, value=0.2, label="Saturation Intensity")
             ],
-            outputs=gr.Image(label="EQ Curve"),
-            title="Draw Your Own Frequency Curve",
-            description="Customize your sound with visual EQ curve drawing."
+            outputs=gr.Audio(label="Warm Output", type="filepath"),
+            title="Add Analog-Style Warmth",
+            description="Apply subtle distortion to enhance clarity and presence."
         )
 
-    # --- Create Karaoke Video from Audio + Lyrics ===
-    with gr.Tab("📹 Create Karaoke Video"):
+    # --- Sidechain Compression ===
+    with gr.Tab("🔁 Sidechain Compression"):
         gr.Interface(
-            fn=create_karaoke_video,
+            fn=sidechain_compressor,
             inputs=[
-                gr.Audio(label="Upload Track", type="filepath"),
-                gr.Textbox(label="Lyrics", lines=10),
-                gr.File(label="Background (Optional)")
+                gr.File(label="Main Track"),
+                gr.File(label="Sidechain Track"),
+                gr.Slider(minimum=-24, maximum=0, value=-16, label="Threshold (dB)"),
+                gr.Number(label="Ratio", value=4),
+                gr.Number(label="Attack (ms)", value=5),
+                gr.Number(label="Release (ms)", value=200)
             ],
-            outputs=gr.Video(label="Karaoke Video"),
-            title="Make Karaoke Videos from Audio + Lyrics",
-            description="Generate karaoke-style videos with real-time sync."
+            outputs=gr.Audio(label="Ducked Output", type="filepath"),
+            title="Sidechain Compression",
+            description="Automatically duck background under voice or kick"
         )
 
-    # --- Save/Load Project File (.aiproj) ===
-    with gr.Tab("📁 Save/Load Project"):
+    # --- Save/Load Mix Session (.aiproj) ===
+    with gr.Tab("📁 Save/Load Mix Session"):
         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=effect_options, label="Applied Effects")
+                gr.File(label="Vocals"),
+                gr.File(label="Drums"),
+                gr.File(label="Bass"),
+                gr.File(label="Other"),
+                gr.Slider(minimum=-10, maximum=10, value=0, label="Vocals Volume"),
+                gr.Slider(minimum=-10, maximum=10, value=0, label="Drums Volume"),
+                gr.Slider(minimum=-10, maximum=10, value=0, label="Bass Volume"),
+                gr.Slider(minimum=-10, maximum=10, value=0, label="Other Volume"),
             ],
             outputs=gr.File(label="Project File (.aiproj)"),
-            title="Save Everything Together",
-            description="Save your session, effects, and settings in one file to reuse later."
+            title="Save Your Full Mix Session",
+            description="Save stems, volumes, and settings in one file."
         )
 
         gr.Interface(
             fn=load_project,
             inputs=gr.File(label="Upload .aiproj File"),
             outputs=[
-                gr.Dropdown(choices=preset_names, label="Loaded Preset"),
-                gr.CheckboxGroup(choices=effect_options, label="Loaded Effects")
+                gr.File(label="Vocals"),
+                gr.File(label="Drums"),
+                gr.File(label="Bass"),
+                gr.File(label="Other"),
+                gr.Slider(label="Vocals Volume"),
+                gr.Slider(label="Drums Volume"),
+                gr.Slider(label="Bass Volume"),
+                gr.Slider(label="Other Volume")
             ],
-            title="Resume Last Project",
-            description="Load your saved session"
+            title="Resume Last Mix",
+            description="Load saved mix session",
+            allow_flagging="never"
         )
 
-    # --- Vocal Doubler / Harmonizer ===
-    with gr.Tab("🎧 Vocal Doubler / Harmonizer"):
-        gr.Interface(
-            fn=vocal_doubler,
-            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"
-        )
-
-    # --- AI Suggest Preset Based on Genre ===
-    with gr.Tab("🧠 AI Suggest Preset"):
+    # --- Vocal Pitch Correction (Auto-Tune) ===
+    with gr.Tab("🧬 Vocal Pitch Correction"):
         gr.Interface(
-            fn=suggest_preset_by_genre,
-            inputs=gr.Audio(label="Upload Track", type="filepath"),
-            outputs=gr.Dropdown(choices=preset_names, label="Recommended Preset"),
-            title="AI Recommends Best Preset",
-            description="Upload a track and let AI recommend the best preset based on genre."
+            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="Auto-Tune Style Pitch Correction",
+            description="Correct vocal pitch automatically"
         )
 
 demo.launch()