Update app.py

app.py

@@ -138,7 +138,7 @@ def match_loudness(audio_path, target_lufs=-14.0):
     adjusted.export(out_path, format="wav")
     return out_path
 
-# === AI Mastering Chain – Genre EQ + Loudness ===
+# === AI Mastering Chain – Genre EQ + Loudness Match ===
 def ai_mastering_chain(audio_path, genre="Pop", target_lufs=-14.0):
     audio = AudioSegment.from_file(audio_path)
 
@@ -196,17 +196,17 @@ def multiband_compression(audio, low_gain=0, mid_gain=0, high_gain=0):
     # 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))
+    low_compressed = 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))
+    mid_compressed = 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))
+    high_compressed = 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)
@@ -236,26 +236,21 @@ def stereo_imaging(audio, mid_side_balance=0.5, stereo_wide=1.0):
     side = audio.pan(0.3)
     return audio.overlay(side, position=0)
 
-# === Harmonic Exciter / Saturation ===
+# === Harmonic 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 ===
+# === Sidechain Compression ===
 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
-        semitones = 0.2
-        return apply_pitch_shift(AudioSegment.from_file(audio_path), semitones)
-    except Exception as e:
-        return None
+def auto_tune_vocal(audio, target_key="C"):
+    return apply_pitch_shift(audio, 0.2)
 
 # === Create Karaoke Video from Audio + Lyrics ===
 def create_karaoke_video(audio_path, lyrics, bg_image=None):
@@ -301,96 +296,136 @@ def load_project(project_file):
     with open(project_file.name, "rb") as f:
         data = pickle.load(f)
     return (
-        data["vocals"],
-        data["drums"],
-        data["bass"],
-        data["other"],
+        array_to_audiosegment(data["vocals"], 44100),
+        array_to_audiosegment(data["drums"], 44100),
+        array_to_audiosegment(data["bass"], 44100),
+        array_to_audiosegment(data["other"], 44100),
         data["volumes"]["vocals"],
         data["volumes"]["drums"],
         data["volumes"]["bass"],
         data["volumes"]["other"]
     )
 
-# === 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)
+# === Process Audio Function (Fixed!) ===
+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 = 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)
 
-# === Genre Detection + Preset Suggestions ===
-def suggest_preset_by_genre(audio_path):
+            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
+
+# === 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)
-        genre = "Pop"
-        return ["Vocal Clarity", "Limiter", "Stereo Expansion"]
+        return "Speech"
     except Exception:
-        return ["Default"]
-
-# === Vocal Isolation 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)
-
-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
+        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)
+
+# === Load 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"]
+}
+
+preset_names = list(preset_choices.keys())
 
-# === Stem Splitting (Drums, Bass, Other, Vocals) ===
-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
-
-# === UI ===
-effect_options = [
-    "Noise Reduction",
-    "Compress Dynamic Range",
-    "Add Reverb",
-    "Pitch Shift",
-    "Echo",
-    "Stereo Widening",
-    "Bass Boost",
-    "Treble Boost",
-    "Normalize",
-    "Noise Gate",
-    "Limiter",
-    "Phaser",
-    "Flanger",
-    "Bitcrusher",
-    "Auto Gain",
-    "Vocal Distortion",
-    "Harmony",
-    "Stage Mode"
-]
+# === 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)
 
+# === Main UI ===
 with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
     gr.Markdown("## 🎧 Ultimate AI Audio Studio\nUpload, edit, export — powered by AI!")
 
@@ -400,7 +435,7 @@ with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
             fn=process_audio,
             inputs=[
                 gr.Audio(label="Upload Audio", type="filepath"),
-                gr.CheckboxGroup(choices=effect_options, label="Apply Effects in Order"),
+                gr.CheckboxGroup(choices=preset_choices.get("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] if preset_names else None),
                 gr.Dropdown(choices=["MP3", "WAV"], label="Export Format", value="MP3")
@@ -526,7 +561,7 @@ with gr.Blocks(title="AI Audio Studio", css="style.css") as demo:
                 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"),
+                gr.Slider(minimum=-10, maximum=10, value=0, label="Other Volume")
             ],
             outputs=gr.File(label="Project File (.aiproj)"),
             title="Save Your Full Mix Session",