Update app.py

app.py

@@ -138,98 +138,82 @@ def match_loudness(audio_path, target_lufs=-14.0):
     adjusted.export(out_path, format="wav")
     return out_path
 
-# === Dynamic Range Compression Presets ===
-def apply_compression_preset(audio, preset="Radio Ready"):
-    if preset == "Radio Ready":
-        return audio.compress_dynamic_range(threshold=-5, ratio=4)
-    elif preset == "Podcast Safe":
-        return audio.compress_dynamic_range(threshold=-10, ratio=2)
-    elif preset == "Club Mix":
-        return audio.compress_dynamic_range(threshold=-3, ratio=6)
-    elif preset == "Speech":
-        return audio.compress_dynamic_range(threshold=-6, ratio=1.5)
-    return audio
-
-# === 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)
-
-# === Prompt-Based Editing ===
-def process_prompt(audio_path, prompt):
-    audio = AudioSegment.from_file(audio_path)
+# === AI Vocal Pitch Correction – Auto-Tune Style ===
+def auto_tune_vocal(audio_path, target_key="C"):
+    try:
+        # Placeholder for real-time pitch detection
+        semitones = 0.2
+        return apply_pitch_shift(AudioSegment.from_file(audio_path), semitones)
+    except Exception as e:
+        return None
 
-    if "noise" in prompt.lower() or "clean" in prompt.lower():
-        audio = apply_noise_reduction(audio)
+# === 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)
 
-    if "normalize" in prompt.lower() or "loud" in prompt.lower():
-        audio = apply_normalize(audio)
+# === Create Karaoke Video from Audio + Lyrics ===
+def create_karaoke_video(audio_path, lyrics, bg_image=None):
+    try:
+        from moviepy.editor import TextClip, CompositeVideoClip, ColorClip, AudioFileClip
 
-    if "bass" in prompt.lower() and ("boost" in prompt.lower()):
-        audio = apply_bass_boost(audio)
+        audio = AudioFileClip(audio_path)
+        video = ColorClip(size=(1280, 720), color=(0, 0, 0), duration=audio.duration_seconds)
+        words = [(word.strip(), i * 3, (i+1)*3) for i, word in enumerate(lyrics.split())]
 
-    if "treble" in prompt.lower() or "high" in prompt.lower():
-        audio = apply_treble_boost(audio)
+        text_clips = [
+            TextClip(word, fontsize=60, color='white').set_position('center').set_duration(end - start).set_start(start)
+            for word, start, end in words
+        ]
 
-    if "echo" in prompt.lower() or "reverb" in prompt.lower():
-        audio = apply_reverb(audio)
+        final_video = CompositeVideoClip([video] + text_clips).set_audio(audio)
+        out_path = os.path.join(tempfile.gettempdir(), "karaoke.mp4")
+        final_video.write_videofile(out_path, codec="libx264", audio_codec="aac")
+        return out_path
+    except Exception as e:
+        return f"⚠️ Failed: {str(e)}"
 
-    if "pitch" in prompt.lower() and "correct" in prompt.lower():
-        audio = apply_pitch_correction(audio)
+# === Save/Load Project File (.aiproj) ===
+def save_project(audio_path, preset_name, effects):
+    project_data = {
+        "audio": AudioSegment.from_file(audio_path).raw_data,
+        "preset": preset_name,
+        "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
 
-    if "harmony" in prompt.lower() or "double" in prompt.lower():
-        audio = apply_harmony(audio)
+def load_project(project_file):
+    with open(project_file.name, "rb") as f:
+        data = pickle.load(f)
+    return data["preset"], data["effects"]
 
-    out_path = os.path.join(tempfile.gettempdir(), "prompt_output.wav")
-    audio.export(out_path, format="wav")
-    return out_path
+# === Vocal Doubler / Harmonizer ===
+def vocal_doubler(audio):
+    shifted_up = apply_pitch_shift(audio, 0.3)
+    shifted_down = apply_pitch_shift(audio, -0.3)
+    return audio.overlay(shifted_up).overlay(shifted_down)
 
-# === AI Suggest Preset Based on Genre ===
+# === Genre Detection + Preset Suggestions ===
 def suggest_preset_by_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)
         genre = "Pop"
-        return f"Suggested Preset: {genre}"
+        return ["Vocal Clarity", "Limiter", "Stereo Expansion"]
     except Exception:
-        return "Unknown"
-
-# === Vocal Pitch Correction – Auto-Tune Style ===
-def apply_pitch_correction(audio, target_key="C"):
-    # Placeholder: In real use, this would align pitch to the nearest key note
-    return apply_pitch_shift(audio, 0.2)
-
-# === Create Karaoke Video from Audio + Lyrics ===
-def create_karaoke_video(audio_path, lyrics, bg_image=None):
-    print(f"Creating karaoke video with lyrics: {lyrics}")
-    return apply_auto_gain(AudioSegment.from_file(audio_path)).export(
-        os.path.join(tempfile.gettempdir(), "karaoke_output.wav"), format="wav"
-    )
+        return ["Default"]
 
 # === Vocal Isolation Helpers ===
 def load_track_local(path, sample_rate, channels=2):
@@ -304,8 +288,6 @@ if not preset_choices:
         "ASMR Creator": ["Noise Gate", "Auto Gain", "Low-Pass Filter"],
         "Voiceover Pro": ["Vocal Isolation", "TTS", "EQ Match"],
         "8-bit Retro": ["Bitcrusher", "Echo", "Mono Downmix"],
-
-        # 🎤 Vocalist Presets
         "🎙 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"],
@@ -450,114 +432,6 @@ def generate_tts(text):
     tts.tts_to_file(text=text, file_path=out_path)
     return out_path
 
-# === Save/Load Project File (.aiproj) ===
-def save_project(audio_path, preset_name, effects):
-    project_data = {
-        "audio": AudioSegment.from_file(audio_path).raw_data,
-        "preset": preset_name,
-        "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"]
-
-# === Trim Silence Automatically (VAD) ===
-def detect_silence(audio_file, silence_threshold=-50.0, min_silence_len=1000):
-    audio = AudioSegment.from_file(audio_file)
-    
-    nonsilent_ranges = detect_nonsilent(
-        audio,
-        min_silence_len=int(min_silence_len),
-        silence_thresh=silence_threshold
-    )
-    
-    if not nonsilent_ranges:
-        return audio.export(os.path.join(tempfile.gettempdir(), "trimmed.wav"), format="wav")
-
-    trimmed = audio[nonsilent_ranges[0][0]:nonsilent_ranges[-1][1]]
-    out_path = os.path.join(tempfile.gettempdir(), "trimmed.wav")
-    trimmed.export(out_path, format="wav")
-    return out_path
-
-# === Mix Two Tracks ===
-def mix_tracks(track1, track2, volume_offset=0):
-    a1 = AudioSegment.from_file(track1)
-    a2 = AudioSegment.from_file(track2)
-    mixed = a1.overlay(a2 - volume_offset)
-    out_path = os.path.join(tempfile.gettempdir(), "mixed.wav")
-    mixed.export(out_path, format="wav")
-    return out_path
-
-# === Dummy Voice Cloning Tab – Works Locally Only ===
-def clone_voice(*args):
-    return "⚠️ Voice cloning requires local install – use Python 3.9 or below"
-
-# === Speaker Diarization ("Who Spoke When?") ===
-try:
-    from pyannote.audio import Pipeline as DiarizationPipeline
-    from huggingface_hub import login
-
-    hf_token = os.getenv("HF_TOKEN")
-    if hf_token:
-        login(token=hf_token)
-    diarize_pipeline = DiarizationPipeline.from_pretrained("pyannote/speaker-diarization", use_auth_token=hf_token or True)
-except Exception as e:
-    diarize_pipeline = None
-    print(f"⚠️ Failed to load diarization: {e}")
-
-def diarize_and_transcribe(audio_path):
-    if not diarize_pipeline:
-        return "⚠️ Diarization pipeline not loaded – check HF token or install pyannote.audio"
-
-    # Run diarization
-    audio = AudioSegment.from_file(audio_path)
-    temp_wav = os.path.join(tempfile.gettempdir(), "diarize.wav")
-    audio.export(temp_wav, format="wav")
-
-    try:
-        diarization = diarize_pipeline(temp_wav)
-
-        result = whisper.transcribe(temp_wav)
-
-        segments = []
-        for turn, _, speaker in diarization.itertracks(yield_label=True):
-            text = " ".join([seg["text"] for seg in result["segments"] if seg["start"] >= turn.start and seg["end"] <= turn.end])
-            segments.append({
-                "speaker": speaker,
-                "start": turn.start,
-                "end": turn.end,
-                "text": text
-            })
-
-        return segments
-    except Exception as e:
-        return f"⚠️ Diarization failed: {str(e)}"
-
-# === Real-Time Spectrum Analyzer + EQ 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)
-
 # === UI ===
 effect_options = [
     "Noise Reduction",
@@ -660,57 +534,10 @@ with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
             description="Ensure consistent loudness across tracks using industry-standard normalization."
         )
 
-    # --- Dynamic Compression Presets ===
-    with gr.Tab("🎛 Dynamic Compression Presets"):
-        gr.Interface(
-            fn=apply_compression_preset,
-            inputs=[
-                gr.Audio(label="Upload Track", type="filepath"),
-                gr.Dropdown(choices=["Radio Ready", "Podcast Safe", "Club Mix", "Speech"], label="Preset")
-            ],
-            outputs=gr.Audio(label="Compressed Output", type="filepath"),
-            title="Apply Pre-Tuned Compression Settings",
-            description="Choose from compression presets used in radio, podcasting, club mixes, and speech editing."
-        )
-
-    # --- AI Suggest Preset Based on Genre ===
-    with gr.Tab("🧠 AI Suggest Preset"):
-        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 detected genre."
-        )
-
-    # --- Real-Time Spectrum Analyzer + EQ ===
-    with gr.Tab("📊 Frequency Spectrum"):
-        gr.Interface(
-            fn=visualize_spectrum,
-            inputs=gr.Audio(label="Upload Track", type="filepath"),
-            outputs=gr.Image(label="Spectrum Analysis"),
-            title="Real-Time Spectrum Analyzer",
-            description="See the frequency breakdown of your audio"
-        )
-
-    # --- Prompt-Based Editing Tab ===
-    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 Pitch Correction (Auto-Tune) ===
+    # --- AI Vocal Pitch Correction (Auto-Tune) ===
     with gr.Tab("🧬 Vocal Pitch Correction"):
         gr.Interface(
-            fn=apply_pitch_correction,
+            fn=auto_tune_vocal,
             inputs=[
                 gr.Audio(label="Upload Vocal Clip", type="filepath"),
                 gr.Textbox(label="Target Key", value="C", lines=1)
@@ -720,6 +547,19 @@ with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
             description="Correct vocal pitch automatically"
         )
 
+    # --- Real-Time EQ Curve Drawing ===
+    with gr.Tab("🎛 Draw Custom EQ Curve"):
+        gr.Interface(
+            fn=draw_eq_curve,
+            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)"),
+            ],
+            outputs=gr.Image(label="EQ Curve"),
+            title="Draw Your Own Frequency Curve",
+            description="Customize your sound with visual EQ curve drawing."
+        )
+
     # --- Create Karaoke Video from Audio + Lyrics ===
     with gr.Tab("📹 Create Karaoke Video"):
         gr.Interface(
@@ -734,111 +574,49 @@ with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
             description="Generate karaoke-style videos with real-time sync."
         )
 
-    # --- Vocal Presets for Singers ===
-    with gr.Tab("🎤 Vocal Presets for Singers"):
+    # --- Save/Load Project File (.aiproj) ===
+    with gr.Tab("📁 Save/Load Project"):
         gr.Interface(
-            fn=process_audio,
+            fn=save_project,
             inputs=[
-                gr.Audio(label="Upload Vocal Track", type="filepath"),
-                gr.CheckboxGroup(choices=effect_options, label="Apply Effects in Order"),
-                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)
+                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")
             ],
-            title="Create Studio-Quality Vocal Tracks",
-            description="Apply singer-friendly presets and effects to enhance vocals.",
-            allow_flagging="never"
+            outputs=gr.File(label="Project File (.aiproj)"),
+            title="Save Everything Together",
+            description="Save your session, effects, and settings in one file to reuse later."
         )
 
-    # --- Voice Cloning (Local Only) ===
-    with gr.Tab("🎭 Voice Cloning (Local Only)"):
         gr.Interface(
-            fn=clone_voice,
-            inputs=[
-                gr.File(label="Source Voice Clip"),
-                gr.File(label="Target Voice Clip"),
-                gr.Textbox(label="Text to Clone", lines=5)
+            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")
             ],
-            outputs=gr.Audio(label="Cloned Output", type="filepath"),
-            title="Replace One Voice With Another",
-            description="Clone voice from source to target speaker using AI"
+            title="Resume Last Project",
+            description="Load your saved session"
         )
 
-    # --- Speaker Diarization ("Who Spoke When?") ===
-    if "diarize_pipeline" in locals():
-        with gr.Tab("🧏‍♂️ Who Spoke When?"):
-            gr.Interface(
-                fn=diarize_and_transcribe,
-                inputs=gr.Audio(label="Upload Interview/Podcast", type="filepath"),
-                outputs=gr.JSON(label="Diarized Transcript"),
-                title="Split By Speaker + Transcribe",
-                description="Detect speakers and transcribe their speech automatically."
-            )
-
-    # --- TTS Voice Generator ===
-    with gr.Tab("💬 TTS Voice Generator"):
+    # --- Vocal Doubler / Harmonizer ===
+    with gr.Tab("🎧 Vocal Doubler / Harmonizer"):
         gr.Interface(
-            fn=generate_tts,
-            inputs=gr.Textbox(label="Enter Text", lines=5),
-            outputs=gr.Audio(label="Generated Speech", type="filepath"),
-            title="Text-to-Speech Generator",
-            description="Type anything and turn it into natural-sounding speech."
-        )
-
-    # --- Auto-Save / Resume Sessions ===
-    session_state = gr.State()
-
-    def save_or_resume_session(audio, preset, effects, action="save"):
-        if action == "save":
-            return {"audio": audio, "preset": preset, "effects": effects}, None, None, None
-        elif action == "load" and isinstance(audio, dict):
-            return (
-                None,
-                audio.get("audio"),
-                audio.get("preset"),
-                audio.get("effects")
-            )
-        return None, None, None, None
-
-    with gr.Tab("🧾 Auto-Save & Resume"):
-        gr.Markdown("Save your current state and resume later.")
-
-        action_radio = gr.Radio(["save", "load"], label="Action", value="save")
-        audio_input = gr.Audio(label="Upload or Load Audio", type="filepath")
-        preset_dropdown = gr.Dropdown(choices=preset_names, label="Used Preset", value=preset_names[0] if preset_names else None)
-        effect_checkbox = gr.CheckboxGroup(choices=effect_options, label="Applied Effects")
-        action_btn = gr.Button("Save or Load Session")
-
-        session_data = gr.State()
-        loaded_audio = gr.Audio(label="Loaded Audio", type="filepath")
-        loaded_preset = gr.Dropdown(choices=preset_names, label="Loaded Preset")
-        loaded_effects = gr.CheckboxGroup(choices=effect_options, label="Loaded Effects")
-
-        action_btn.click(
-            fn=save_or_resume_session,
-            inputs=[audio_input, preset_dropdown, effect_checkbox, action_radio],
-            outputs=[session_data, loaded_audio, loaded_preset, loaded_effects]
+            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"
         )
 
-    # --- VAD – Detect & Remove Silence ===
-    with gr.Tab("✂️ Trim Silence Automatically"):
+    # --- AI Suggest Preset Based on Genre ===
+    with gr.Tab("🧠 AI Suggest Preset"):
         gr.Interface(
-            fn=detect_silence,
-            inputs=[
-                gr.File(label="Upload Track"),
-                gr.Slider(minimum=-100, maximum=-10, value=-50, label="Silence Threshold (dB)"),
-                gr.Number(label="Min Silence Length (ms)", value=1000)
-            ],
-            outputs=gr.File(label="Trimmed Output"),
-            title="Auto-Detect & Remove Silence",
-            description="Detect and trim silence at start/end or between words"
+            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."
         )
 
 demo.launch()