Create app.py

app.py

@@ -0,0 +1,152 @@
+import os
+import tempfile
+import numpy as np
+import soundfile as sf
+import librosa
+import pyloudnorm as pyln
+import noisereduce as nr
+from scipy.signal import butter, sosfiltfilt
+import gradio as gr
+from pydub import AudioSegment
+
+
+# ----------------- Utility Filters -----------------
+def butter_bandpass(lowcut, highcut, sr, order=4):
+    sos = butter(order, [lowcut / (sr/2), highcut / (sr/2)], btype='band', output='sos')
+    return sos
+
+def butter_highpass(cutoff, sr, order=4):
+    sos = butter(order, cutoff / (sr/2), btype='highpass', output='sos')
+    return sos
+
+def butter_lowpass(cutoff, sr, order=4):
+    sos = butter(order, cutoff / (sr/2), btype='lowpass', output='sos')
+    return sos
+
+
+# ----------------- DSP Core -----------------
+class VoiceProcessor:
+    def __init__(self, sr):
+        self.sr = sr
+        self.meter = pyln.Meter(sr)
+
+    def to_mono(self, x):
+        return np.mean(x, axis=1) if x.ndim > 1 else x
+
+    def dc_remove_and_peak_norm(self, x, target_peak=0.98):
+        x = x - np.mean(x)
+        peak = np.max(np.abs(x)) + 1e-12
+        return x * (target_peak / peak)
+
+    def adaptive_noise_reduction(self, x, amount=0.6):
+        # نویز ثابت: حالت stationary
+        return nr.reduce_noise(y=x, sr=self.sr, stationary=True, prop_decrease=amount)
+
+    def dynamic_deesser(self, x, band=(5000, 9000), reduction_db=8):
+        # تشخیص سیبلانس با انرژی باند بالا
+        sos = butter_bandpass(band[0], band[1], self.sr, order=2)
+        sib_energy = np.abs(sosfiltfilt(sos, x))
+        threshold = np.percentile(sib_energy, 85)  # بالاترین ۱۵٪
+        gain = np.ones_like(x)
+        idx = sib_energy > threshold
+        gain[idx] = 10 ** (-reduction_db / 20.0)
+        return x * gain
+
+    def multiband_compression(self, x, low_band=(80, 300), mid_band=(300, 4000), high_band=(4000, 16000),
+                              ratios=(2, 2.5, 1.5), thresholds=(-24, -20, -18)):
+        def band_compress(signal, band, ratio, thr_db):
+            sos = butter_bandpass(band[0], band[1], self.sr, order=2)
+            b = sosfiltfilt(sos, signal)
+            rms = np.sqrt(np.convolve(b**2, np.ones(1024)/1024, mode='same') + 1e-12)
+            level_db = 20 * np.log10(rms + 1e-12)
+            over_db = level_db - thr_db
+            gain_db = np.where(over_db > 0, -over_db * (1 - 1/ratio), 0)
+            gain_lin = 10 ** (gain_db / 20)
+            return b * gain_lin
+
+        low = band_compress(x, low_band, ratios[0], thresholds[0])
+        mid = band_compress(x, mid_band, ratios[1], thresholds[1])
+        high = band_compress(x, high_band, ratios[2], thresholds[2])
+
+        return low + mid + high
+
+    def eq_tone_shaping(self, x):
+        # HPF
+        sos_hp = butter_highpass(80, self.sr, order=2)
+        x = sosfiltfilt(sos_hp, x)
+        # LPF
+        sos_lp = butter_lowpass(16000, self.sr, order=2)
+        x = sosfiltfilt(sos_lp, x)
+        return x
+
+    def loudness_normalize(self, x, target_lufs=-16.0):
+        loudness = self.meter.integrated_loudness(x)
+        return pyln.normalize.loudness(x, loudness, target_lufs)
+
+    def true_peak_limiter(self, x, ceiling=0.97):
+        peak = np.max(np.abs(x))
+        if peak > ceiling:
+            x = x * (ceiling / peak)
+        return x
+
+    def process(self, audio_path, nr_amount=0.6, target_lufs=-16.0):
+        x, _ = librosa.load(audio_path, sr=self.sr, mono=False)
+        x = self.to_mono(x)
+        x = self.dc_remove_and_peak_norm(x)
+        x = self.adaptive_noise_reduction(x, amount=nr_amount)
+        x = self.eq_tone_shaping(x)
+        x = self.dynamic_deesser(x)
+        x = self.multiband_compression(x)
+        x = self.loudness_normalize(x, target_lufs=target_lufs)
+        x = self.true_peak_limiter(x)
+        return x
+
+
+# ----------------- File Save -----------------
+def save_outputs(y, sr, export_mp3=True, export_flac=True):
+    files = []
+
+    # WAV
+    out_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+    sf.write(out_wav.name, y, sr)
+    files.append(out_wav.name)
+
+    # MP3
+    if export_mp3:
+        mp3_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+        AudioSegment.from_wav(out_wav.name).export(mp3_file.name, format="mp3", bitrate="192k")
+        files.append(mp3_file.name)
+
+    # FLAC
+    if export_flac:
+        flac_file = tempfile.NamedTemporaryFile(delete=False, suffix=".flac")
+        AudioSegment.from_wav(out_wav.name).export(flac_file.name, format="flac")
+        files.append(flac_file.name)
+
+    return files
+
+
+# ----------------- Gradio Interface -----------------
+def process_audio(input_file, nr_amount, target_lufs, export_mp3, export_flac):
+    proc = VoiceProcessor(sr=48000)
+    y = proc.process(input_file, nr_amount=nr_amount, target_lufs=target_lufs)
+    outputs = save_outputs(y, proc.sr, export_mp3, export_flac)
+    return (proc.sr, y.astype(np.float32)), outputs
+
+
+with gr.Blocks(title="Voice Softener Studio Pro") as demo:
+    gr.Markdown("# 🎙️ Voice Softener Studio Pro")
+    with gr.Tab("حالت ساده"):
+        audio_in = gr.Audio(sources=["upload", "microphone"], type="filepath", label="آپلود یا ضبط صدا")
+        nr_amount = gr.Slider(0.0, 1.0, value=0.6, step=0.05, label="شدت کاهش نویز")
+        target_lufs = gr.Slider(-28, -12, value=-16, step=1, label="هدف لودنس (LUFS)")
+        export_mp3 = gr.Checkbox(value=True, label="MP3 خروجی")
+        export_flac = gr.Checkbox(value=False, label="FLAC خروجی")
+        btn = gr.Button("پردازش کن", variant="primary")
+        out_audio = gr.Audio(label="خروجی پردازش‌شده", type="numpy")
+        out_files = gr.Files(label="دانلود فایل‌ها")
+        btn.click(process_audio, [audio_in, nr_amount, target_lufs, export_mp3, export_flac],
+                  [out_audio, out_files])
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))