Update app.py

app.py

@@ -1,497 +1,310 @@
-import tempfile
-
-import edge_tts
 import gradio as gr
-from gradio_client import Client
-import pyarabic.araby as araby
-
-language_dict = {
-  "English": {
-    "Jenny": "en-US-JennyNeural",
-    "Guy": "en-US-GuyNeural",
-    "Ana": "en-US-AnaNeural",
-    "Aria": "en-US-AriaNeural",
-    "Christopher": "en-US-ChristopherNeural",
-    "Eric": "en-US-EricNeural",
-    "Michelle": "en-US-MichelleNeural",
-    "Roger": "en-US-RogerNeural",
-    "Natasha": "en-AU-NatashaNeural",
-    "William": "en-AU-WilliamNeural",
-    "Clara": "en-CA-ClaraNeural",
-    "Liam": "en-CA-LiamNeural",
-    "Libby": "en-GB-LibbyNeural",
-    "Maisie": "en-GB-MaisieNeural",
-    "Ryan": "en-GB-RyanNeural",
-    "Sonia": "en-GB-SoniaNeural",
-    "Thomas": "en-GB-ThomasNeural",
-    "Sam": "en-HK-SamNeural",
-    "Yan": "en-HK-YanNeural",
-    "Connor": "en-IE-ConnorNeural",
-    "Emily": "en-IE-EmilyNeural",
-    "Neerja": "en-IN-NeerjaNeural",
-    "Prabhat": "en-IN-PrabhatNeural",
-    "Asilia": "en-KE-AsiliaNeural",
-    "Chilemba": "en-KE-ChilembaNeural",
-    "Abeo": "en-NG-AbeoNeural",
-    "Ezinne": "en-NG-EzinneNeural",
-    "Mitchell": "en-NZ-MitchellNeural",
-    "James": "en-PH-JamesNeural",
-    "Rosa": "en-PH-RosaNeural",
-    "Luna": "en-SG-LunaNeural",
-    "Wayne": "en-SG-WayneNeural",
-    "Elimu": "en-TZ-ElimuNeural",
-    "Imani": "en-TZ-ImaniNeural",
-    "Leah": "en-ZA-LeahNeural",
-    "Luke": "en-ZA-LukeNeural"
-  },
-  "Spanish": {
-    "Elena": "es-AR-ElenaNeural",
-    "Tomas": "es-AR-TomasNeural",
-    "Marcelo": "es-BO-MarceloNeural",
-    "Sofia": "es-BO-SofiaNeural",
-    "Gonzalo": "es-CO-GonzaloNeural",
-    "Salome": "es-CO-SalomeNeural",
-    "Juan": "es-CR-JuanNeural",
-    "Maria": "es-CR-MariaNeural",
-    "Belkys": "es-CU-BelkysNeural",
-    "Emilio": "es-DO-EmilioNeural",
-    "Ramona": "es-DO-RamonaNeural",
-    "Andrea": "es-EC-AndreaNeural",
-    "Luis": "es-EC-LuisNeural",
-    "Alvaro": "es-ES-AlvaroNeural",
-    "Elvira": "es-ES-ElviraNeural",
-    "Teresa": "es-GQ-TeresaNeural",
-    "Andres": "es-GT-AndresNeural",
-    "Marta": "es-GT-MartaNeural",
-    "Carlos": "es-HN-CarlosNeural",
-    "Karla": "es-HN-KarlaNeural",
-    "Federico": "es-NI-FedericoNeural",
-    "Yolanda": "es-NI-YolandaNeural",
-    "Margarita": "es-PA-MargaritaNeural",
-    "Roberto": "es-PA-RobertoNeural",
-    "Alex": "es-PE-AlexNeural",
-    "Camila": "es-PE-CamilaNeural",
-    "Karina": "es-PR-KarinaNeural",
-    "Victor": "es-PR-VictorNeural",
-    "Mario": "es-PY-MarioNeural",
-    "Tania": "es-PY-TaniaNeural",
-    "Lorena": "es-SV-LorenaNeural",
-    "Rodrigo": "es-SV-RodrigoNeural",
-    "Alonso": "es-US-AlonsoNeural",
-    "Paloma": "es-US-PalomaNeural",
-    "Mateo": "es-UY-MateoNeural",
-    "Valentina": "es-UY-ValentinaNeural",
-    "Paola": "es-VE-PaolaNeural",
-    "Sebastian": "es-VE-SebastianNeural"
-  },
-  "Arabic": {
-    "Hamed": "ar-SA-HamedNeural",
-    "Zariyah": "ar-SA-ZariyahNeural",
-    "Fatima": "ar-AE-FatimaNeural",
-    "Hamdan": "ar-AE-HamdanNeural",
-    "Ali": "ar-BH-AliNeural",
-    "Laila": "ar-BH-LailaNeural",
-    "Ismael": "ar-DZ-IsmaelNeural",
-    "Salma": "ar-EG-SalmaNeural",
-    "Shakir": "ar-EG-ShakirNeural",
-    "Bassel": "ar-IQ-BasselNeural",
-    "Rana": "ar-IQ-RanaNeural",
-    "Sana": "ar-JO-SanaNeural",
-    "Taim": "ar-JO-TaimNeural",
-    "Fahed": "ar-KW-FahedNeural",
-    "Noura": "ar-KW-NouraNeural",
-    "Layla": "ar-LB-LaylaNeural",
-    "Rami": "ar-LB-RamiNeural",
-    "Iman": "ar-LY-ImanNeural",
-    "Omar": "ar-LY-OmarNeural",
-    "Jamal": "ar-MA-JamalNeural",
-    "Mouna": "ar-MA-MounaNeural",
-    "Abdullah": "ar-OM-AbdullahNeural",
-    "Aysha": "ar-OM-AyshaNeural",
-    "Amal": "ar-QA-AmalNeural",
-    "Moaz": "ar-QA-MoazNeural",
-    "Amany": "ar-SY-AmanyNeural",
-    "Laith": "ar-SY-LaithNeural",
-    "Hedi": "ar-TN-HediNeural",
-    "Reem": "ar-TN-ReemNeural",
-    "Maryam": "ar-YE-MaryamNeural",
-    "Saleh": "ar-YE-SalehNeural"
-  },
-  "Korean": {
-    "Sun-Hi": "ko-KR-SunHiNeural",
-    "InJoon": "ko-KR-InJoonNeural"
-  },
-  "Thai": {
-    "Premwadee": "th-TH-PremwadeeNeural",
-    "Niwat": "th-TH-NiwatNeural"
-  },
-  "Vietnamese": {
-    "HoaiMy": "vi-VN-HoaiMyNeural",
-    "NamMinh": "vi-VN-NamMinhNeural"
-  },
-  "Japanese": {
-    "Nanami": "ja-JP-NanamiNeural",
-    "Keita": "ja-JP-KeitaNeural"
-  },
-  "French": {
-    "Denise": "fr-FR-DeniseNeural",
-    "Eloise": "fr-FR-EloiseNeural",
-    "Henri": "fr-FR-HenriNeural",
-    "Sylvie": "fr-CA-SylvieNeural",
-    "Antoine": "fr-CA-AntoineNeural",
-    "Jean": "fr-CA-JeanNeural",
-    "Ariane": "fr-CH-ArianeNeural",
-    "Fabrice": "fr-CH-FabriceNeural",
-    "Charline": "fr-BE-CharlineNeural",
-    "Gerard": "fr-BE-GerardNeural"
-  },
-  "Portuguese": {
-    "Francisca": "pt-BR-FranciscaNeural",
-    "Antonio": "pt-BR-AntonioNeural",
-    "Duarte": "pt-PT-DuarteNeural",
-    "Raquel": "pt-PT-RaquelNeural"
-  },
-  "Indonesian": {
-    "Ardi": "id-ID-ArdiNeural",
-    "Gadis": "id-ID-GadisNeural"
-  },
-  "Hebrew": {
-    "Avri": "he-IL-AvriNeural",
-    "Hila": "he-IL-HilaNeural"
-  },
-  "Italian": {
-    "Isabella": "it-IT-IsabellaNeural",
-    "Diego": "it-IT-DiegoNeural",
-    "Elsa": "it-IT-ElsaNeural"
-  },
-  "Dutch": {
-    "Colette": "nl-NL-ColetteNeural",
-    "Fenna": "nl-NL-FennaNeural",
-    "Maarten": "nl-NL-MaartenNeural",
-    "Arnaud": "nl-BE-ArnaudNeural",
-    "Dena": "nl-BE-DenaNeural"
-  },
-  "Malay": {
-    "Osman": "ms-MY-OsmanNeural",
-    "Yasmin": "ms-MY-YasminNeural"
-  },
-  "Norwegian": {
-    "Pernille": "nb-NO-PernilleNeural",
-    "Finn": "nb-NO-FinnNeural"
-  },
-  "Swedish": {
-    "Sofie": "sv-SE-SofieNeural",
-    "Mattias": "sv-SE-MattiasNeural"
-  },
-  "Greek": {
-    "Athina": "el-GR-AthinaNeural",
-    "Nestoras": "el-GR-NestorasNeural"
-  },
-  "German": {
-    "Katja": "de-DE-KatjaNeural",
-    "Amala": "de-DE-AmalaNeural",
-    "Conrad": "de-DE-ConradNeural",
-    "Killian": "de-DE-KillianNeural",
-    "Ingrid": "de-AT-IngridNeural",
-    "Jonas": "de-AT-JonasNeural",
-    "Jan": "de-CH-JanNeural",
-    "Leni": "de-CH-LeniNeural"
-  },
-  "Afrikaans": {
-    "Adri": "af-ZA-AdriNeural",
-    "Willem": "af-ZA-WillemNeural"
-  },
-  "Amharic": {
-    "Ameha": "am-ET-AmehaNeural",
-    "Mekdes": "am-ET-MekdesNeural"
-  },
-  "Azerbaijani": {
-    "Babek": "az-AZ-BabekNeural",
-    "Banu": "az-AZ-BanuNeural"
-  },
-  "Bulgarian": {
-    "Borislav": "bg-BG-BorislavNeural",
-    "Kalina": "bg-BG-KalinaNeural"
-  },
-  "Bengali": {
-    "Nabanita": "bn-BD-NabanitaNeural",
-    "Pradeep": "bn-BD-PradeepNeural",
-    "Bashkar": "bn-IN-BashkarNeural",
-    "Tanishaa": "bn-IN-TanishaaNeural"
-  },
-  "Bosnian": {
-    "Goran": "bs-BA-GoranNeural",
-    "Vesna": "bs-BA-VesnaNeural"
-  },
-  "Catalan": {
-    "Joana": "ca-ES-JoanaNeural",
-    "Enric": "ca-ES-EnricNeural"
-  },
-  "Czech": {
-    "Antonin": "cs-CZ-AntoninNeural",
-    "Vlasta": "cs-CZ-VlastaNeural"
-  },
-  "Welsh": {
-    "Aled": "cy-GB-AledNeural",
-    "Nia": "cy-GB-NiaNeural"
-  },
-  "Danish": {
-    "Christel": "da-DK-ChristelNeural",
-    "Jeppe": "da-DK-JeppeNeural"
-  },
-  "Estonian": {
-    "Anu": "et-EE-AnuNeural",
-    "Kert": "et-EE-KertNeural"
-  },
-  "Persian": {
-    "Dilara": "fa-IR-DilaraNeural",
-    "Farid": "fa-IR-FaridNeural"
-  },
-  "Finnish": {
-    "Harri": "fi-FI-HarriNeural",
-    "Noora": "fi-FI-NooraNeural"
-  },
-  "Irish": {
-    "Colm": "ga-IE-ColmNeural",
-    "Orla": "ga-IE-OrlaNeural"
-  },
-  "Galician": {
-    "Roi": "gl-ES-RoiNeural",
-    "Sabela": "gl-ES-SabelaNeural"
-  },
-  "Gujarati": {
-    "Dhwani": "gu-IN-DhwaniNeural",
-    "Niranjan": "gu-IN-NiranjanNeural"
-  },
-  "Hindi": {
-    "Madhur": "hi-IN-MadhurNeural",
-    "Swara": "hi-IN-SwaraNeural"
-  },
-  "Croatian": {
-    "Gabrijela": "hr-HR-GabrijelaNeural",
-    "Srecko": "hr-HR-SreckoNeural"
-  },
-  "Hungarian": {
-    "Noemi": "hu-HU-NoemiNeural",
-    "Tamas": "hu-HU-TamasNeural"
-  },
-  "Icelandic": {
-    "Gudrun": "is-IS-GudrunNeural",
-    "Gunnar": "is-IS-GunnarNeural"
-  },
-  "Javanese": {
-    "Dimas": "jv-ID-DimasNeural",
-    "Siti": "jv-ID-SitiNeural"
-  },
-  "Georgian": {
-    "Eka": "ka-GE-EkaNeural",
-    "Giorgi": "ka-GE-GiorgiNeural"
-  },
-  "Kazakh": {
-    "Aigul": "kk-KZ-AigulNeural",
-    "Daulet": "kk-KZ-DauletNeural"
-  },
-  "Khmer": {
-    "Piseth": "km-KH-PisethNeural",
-    "Sreymom": "km-KH-SreymomNeural"
-  },
-  "Kannada": {
-    "Gagan": "kn-IN-GaganNeural",
-    "Sapna": "kn-IN-SapnaNeural"
-  },
-  "Lao": {
-    "Chanthavong": "lo-LA-ChanthavongNeural",
-    "Keomany": "lo-LA-KeomanyNeural"
-  },
-  "Lithuanian": {
-    "Leonas": "lt-LT-LeonasNeural",
-    "Ona": "lt-LT-OnaNeural"
-  },
-  "Latvian": {
-    "Everita": "lv-LV-EveritaNeural",
-    "Nils": "lv-LV-NilsNeural"
-  },
-  "Macedonian": {
-    "Aleksandar": "mk-MK-AleksandarNeural",
-    "Marija": "mk-MK-MarijaNeural"
-  },
-  "Malayalam": {
-    "Midhun": "ml-IN-MidhunNeural",
-    "Sobhana": "ml-IN-SobhanaNeural"
-  },
-  "Mongolian": {
-    "Bataa": "mn-MN-BataaNeural",
-    "Yesui": "mn-MN-YesuiNeural"
-  },
-  "Marathi": {
-    "Aarohi": "mr-IN-AarohiNeural",
-    "Manohar": "mr-IN-ManoharNeural"
-  },
-  "Maltese": {
-    "Grace": "mt-MT-GraceNeural",
-    "Joseph": "mt-MT-JosephNeural"
-  },
-  "Burmese": {
-    "Nilar": "my-MM-NilarNeural",
-    "Thiha": "my-MM-ThihaNeural"
-  },
-  "Nepali": {
-    "Hemkala": "ne-NP-HemkalaNeural",
-    "Sagar": "ne-NP-SagarNeural"
-  },
-  "Polish": {
-    "Marek": "pl-PL-MarekNeural",
-    "Zofia": "pl-PL-ZofiaNeural"
-  },
-  "Pashto": {
-    "Gul Nawaz": "ps-AF-GulNawazNeural",
-    "Latifa": "ps-AF-LatifaNeural"
-  },
-  "Romanian": {
-    "Alina": "ro-RO-AlinaNeural",
-    "Emil": "ro-RO-EmilNeural"
-  },
-  "Russian": {
-    "Svetlana": "ru-RU-SvetlanaNeural",
-    "Dmitry": "ru-RU-DmitryNeural"
-  },
-  "Sinhala": {
-    "Sameera": "si-LK-SameeraNeural",
-    "Thilini": "si-LK-ThiliniNeural"
-  },
-  "Slovak": {
-    "Lukas": "sk-SK-LukasNeural",
-    "Viktoria": "sk-SK-ViktoriaNeural"
-  },
-  "Slovenian": {
-    "Petra": "sl-SI-PetraNeural",
-    "Rok": "sl-SI-RokNeural"
-  },
-  "Somali": {
-    "Muuse": "so-SO-MuuseNeural",
-    "Ubax": "so-SO-UbaxNeural"
-  },
-  "Albanian": {
-    "Anila": "sq-AL-AnilaNeural",
-    "Ilir": "sq-AL-IlirNeural"
-  },
-  "Serbian": {
-    "Nicholas": "sr-RS-NicholasNeural",
-    "Sophie": "sr-RS-SophieNeural"
-  },
-  "Sundanese": {
-    "Jajang": "su-ID-JajangNeural",
-    "Tuti": "su-ID-TutiNeural"
-  },
-  "Swahili": {
-    "Rafiki": "sw-KE-RafikiNeural",
-    "Zuri": "sw-KE-ZuriNeural",
-    "Daudi": "sw-TZ-DaudiNeural",
-    "Rehema": "sw-TZ-RehemaNeural"
-    },
-  "Tamil": {
-    "Pallavi": "ta-IN-PallaviNeural",
-    "Valluvar": "ta-IN-ValluvarNeural",
-    "Kumar": "ta-LK-KumarNeural",
-    "Saranya": "ta-LK-SaranyaNeural",
-    "Kani": "ta-MY-KaniNeural",
-    "Surya": "ta-MY-SuryaNeural",
-    "Anbu": "ta-SG-AnbuNeural"
-  },
-  "Telugu": {
-    "Mohan": "te-IN-MohanNeural",
-    "Shruti": "te-IN-ShrutiNeural"
-  },
-  "Turkish": {
-    "Ahmet": "tr-TR-AhmetNeural",
-    "Emel": "tr-TR-EmelNeural"
-  },
-  "Ukrainian": {
-    "Ostap": "uk-UA-OstapNeural",
-    "Polina": "uk-UA-PolinaNeural"
-  },
-  "Urdu": {
-    "Gul": "ur-IN-GulNeural",
-    "Salman": "ur-IN-SalmanNeural",
-    "Asad": "ur-PK-AsadNeural",
-    "Uzma": "ur-PK-UzmaNeural"
-  },
-  "Uzbek": {
-    "Madina": "uz-UZ-MadinaNeural",
-    "Sardor": "uz-UZ-SardorNeural"
-  },
-  "Mandarin": {
-    "Xiaoxiao": "zh-CN-XiaoxiaoNeural",
-    "Yunyang": "zh-CN-YunyangNeural",
-    "Yunxi": "zh-CN-YunxiNeural",
-    "Xiaoyi": "zh-CN-XiaoyiNeural",
-    "Yunjian": "zh-CN-YunjianNeural",
-    "Yunxia": "zh-CN-YunxiaNeural",
-    "Xiaobei": "zh-CN-liaoning-XiaobeiNeural",
-    "Xiaoni": "zh-CN-shaanxi-XiaoniNeural",
-    "HiuMaan": "zh-HK-HiuMaanNeural",
-    "HiuGaai": "zh-HK-HiuGaaiNeural",
-    "WanLung": "zh-HK-WanLungNeural",
-    "HsiaoChen": "zh-TW-HsiaoChenNeural",
-    "HsiaoYu": "zh-TW-HsiaoYuNeural",
-    "YunJhe": "zh-TW-YunJheNeural"
-  },
-  "Zulu": {
-    "Thando": "zu-ZA-ThandoNeural",
-    "Themba": "zu-ZA-ThembaNeural"
-  }
-}
-
-client = Client("MohamedRashad/arabic-auto-tashkeel")
-
-async def text_to_speech_edge(text, language_code, speaker, tashkeel_checkbox=False):
+import numpy as np
+import tempfile
+import librosa
+import soundfile as sf
+from scipy import signal
+import os
 
-  # Remove diacritics from Arabic text then add tashkeel
-    if language_code == "Arabic" and tashkeel_checkbox:
-        text = client.predict(
-        		input_text=araby.strip_diacritics(text),
-        		api_name="/infer_shakkala"
-        )
+class AIHumanizer:
+    def __init__(self):
+        pass
     
-    # Get the voice for the selected language and speaker
-    voice = language_dict[language_code][speaker]
-    communicate = edge_tts.Communicate(text, voice)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-      tmp_path = tmp_file.name
-      await communicate.save(tmp_path)
-
-    return text, tmp_path
-
-
-def get_speakers(language):
-    print(language)
-    speakers = list(language_dict[language].keys())
-    return gr.Dropdown(choices=speakers, value=speakers[0], interactive=True), gr.Checkbox(visible=language == "Arabic", interactive=True)
+    def humanize_audio(self, audio_path, intensity=0.7):
+        """Remove AI artifacts and make audio sound human-made"""
+        try:
+            print(f"Loading audio from: {audio_path}")
+            
+            # Load the full song
+            y, sr = librosa.load(audio_path, sr=None, mono=False)
+            
+            print(f"Audio loaded: shape={y.shape if hasattr(y, 'shape') else 'mono'}, sr={sr}")
+            
+            # If stereo, process both channels
+            if len(y.shape) > 1:
+                print("Processing stereo audio...")
+                processed_channels = []
+                for i in range(y.shape[0]):
+                    print(f"Processing channel {i+1}...")
+                    processed_channel = self.process_channel(y[i], sr, intensity)
+                    processed_channels.append(processed_channel)
+                y_processed = np.array(processed_channels)
+            else:
+                print("Processing mono audio...")
+                y_processed = self.process_channel(y, sr, intensity)
+                y_processed = np.array([y_processed])
+            
+            print("Audio processing completed successfully")
+            return y_processed, sr
+            
+        except Exception as e:
+            print(f"Error in humanize_audio: {str(e)}")
+            raise Exception(f"Humanization failed: {str(e)}")
+    
+    def process_channel(self, y, sr, intensity):
+        """Process a single audio channel to remove AI artifacts"""
+        print(f"Processing channel: {len(y)} samples")
+        
+        # Store original for blending
+        y_original = y.copy()
+        
+        # 1. Reduce robotic frequencies
+        y = self.reduce_ai_artifacts(y, sr, intensity)
+        
+        # 2. Add timing variations
+        y = self.add_timing_variations(y, sr, intensity)
+        
+        # 3. Add pitch variations
+        y = self.add_pitch_variations(y, sr, intensity)
+        
+        # 4. Add room ambiance
+        y = self.add_room_ambiance(y, sr, intensity)
+        
+        # 5. Add analog warmth
+        y = self.add_analog_warmth(y, sr, intensity)
+        
+        # 6. Reduce perfect quantization
+        y = self.reduce_perfect_quantization(y, sr, intensity)
+        
+        return y
+    
+    def reduce_ai_artifacts(self, y, sr, intensity):
+        """Reduce common AI audio artifacts"""
+        if sr > 4000 and intensity > 0.1:
+            try:
+                # Reduce harsh frequencies in the 2kHz-6kHz range
+                sos = signal.butter(4, [1900, 6100], 'bandstop', fs=sr, output='sos')
+                y_filtered = signal.sosfilt(sos, y)
+                
+                # Blend with original
+                blend_factor = 0.3 * intensity
+                return y * (1 - blend_factor) + y_filtered * blend_factor
+            except:
+                return y
+        return y
+    
+    def add_timing_variations(self, y, sr, intensity):
+        """Add subtle timing variations"""
+        if intensity < 0.2:
+            return y
+            
+        try:
+            # Simple approach: small random stretches
+            segment_size = int(sr * 1.0)  # 1-second segments
+            if len(y) < segment_size * 2:
+                return y
+                
+            segments = []
+            for i in range(0, len(y), segment_size):
+                segment = y[i:i+segment_size]
+                if len(segment) == segment_size:
+                    # Small random stretch
+                    stretch = 1.0 + np.random.uniform(-0.01, 0.01) * intensity
+                    new_len = int(segment_size * stretch)
+                    
+                    # Resample
+                    x_old = np.linspace(0, 1, segment_size)
+                    x_new = np.linspace(0, 1, new_len)
+                    segment_stretched = np.interp(x_new, x_old, segment)
+                    
+                    # Trim or pad to original length
+                    if len(segment_stretched) > segment_size:
+                        segment_stretched = segment_stretched[:segment_size]
+                    else:
+                        segment_stretched = np.pad(segment_stretched, (0, segment_size - len(segment_stretched)))
+                    
+                    segments.append(segment_stretched)
+                else:
+                    segments.append(segment)
+            
+            return np.concatenate(segments)
+        except:
+            return y
+    
+    def add_pitch_variations(self, y, sr, intensity):
+        """Add subtle pitch variations"""
+        if intensity < 0.3:
+            return y
+            
+        try:
+            # Small random pitch shifts
+            n_steps = np.random.uniform(-0.2, 0.2) * intensity
+            y_shifted = librosa.effects.pitch_shift(y, sr=sr, n_steps=n_steps)
+            
+            # Blend
+            blend_factor = 0.2 * intensity
+            return y * (1 - blend_factor) + y_shifted * blend_factor
+        except:
+            return y
+    
+    def add_room_ambiance(self, y, sr, intensity):
+        """Add natural room reverb"""
+        if intensity < 0.2:
+            return y
+            
+        try:
+            # Simple reverb impulse
+            impulse_len = int(0.15 * sr)
+            if impulse_len < 10:
+                return y
+                
+            impulse = np.zeros(impulse_len)
+            # Early reflection
+            early = int(0.01 * sr)
+            if early < impulse_len:
+                impulse[early] = 0.8
+            # Reverb tail
+            tail_start = min(early + 1, impulse_len)
+            if tail_start < impulse_len:
+                tail_len = impulse_len - tail_start
+                decay = np.exp(-np.linspace(0, 6, tail_len))
+                impulse[tail_start:] = decay * 0.4
+            
+            # Apply convolution
+            y_reverb = signal.convolve(y, impulse, mode='same')
+            # Normalize
+            if np.max(np.abs(y_reverb)) > 0:
+                y_reverb = y_reverb / np.max(np.abs(y_reverb)) * np.max(np.abs(y))
+            
+            # Blend
+            blend_factor = 0.1 * intensity
+            return y * (1 - blend_factor) + y_reverb * blend_factor
+        except:
+            return y
+    
+    def add_analog_warmth(self, y, sr, intensity):
+        """Add analog-style warmth"""
+        if intensity < 0.1:
+            return y
+            
+        try:
+            # Soft clipping
+            saturation = 1.0 + 0.4 * intensity
+            y_warm = np.tanh(y * saturation) / saturation
+            
+            # Gentle low boost
+            if sr > 1000:
+                sos = signal.butter(2, 100, 'high', fs=sr, output='sos')
+                y_warm = signal.sosfilt(sos, y_warm)
+            
+            blend_factor = 0.15 * intensity
+            return y * (1 - blend_factor) + y_warm * blend_factor
+        except:
+            return y
+    
+    def reduce_perfect_quantization(self, y, sr, intensity):
+        """Reduce perfectly quantized timing"""
+        if intensity < 0.1:
+            return y
+            
+        # Add subtle amplitude variations
+        t = np.arange(len(y)) / sr
+        # Slow LFO for natural dynamics
+        lfo1 = 1.0 + np.sin(2 * np.pi * 0.3 * t) * 0.02 * intensity
+        # Faster LFO for micro-variations
+        lfo2 = 1.0 + np.sin(2 * np.pi * 2.0 * t) * 0.01 * intensity
+        # Random noise
+        noise = 1.0 + np.random.normal(0, 0.005 * intensity, len(y))
+        
+        combined = lfo1 * lfo2 * noise
+        return y * combined
 
+def humanize_song(input_audio, intensity):
+    """Main humanization function"""
+    if input_audio is None:
+        return None, "Please upload an audio file"
+    
+    humanizer = AIHumanizer()
+    
+    try:
+        print("Starting humanization...")
+        
+        # Get the file path from the audio input
+        audio_path = input_audio
+        
+        # Process the audio
+        audio_data, sr = humanizer.humanize_audio(audio_path, intensity)
+        
+        print(f"Processing complete. Saving audio...")
+        
+        # Save as WAV
+        output_path = tempfile.mktemp(suffix='_humanized.wav')
+        
+        # Handle stereo/mono properly
+        if audio_data.shape[0] == 1:
+            # Mono
+            sf.write(output_path, audio_data[0], sr)
+        else:
+            # Stereo - transpose for soundfile
+            sf.write(output_path, audio_data.T, sr)
+        
+        print(f"Saved to: {output_path}")
+        return output_path, "✅ Success! Your song now sounds human-made. Download below."
+        
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        print(f"Error details: {error_msg}")
+        return None, error_msg
 
-default_language = None
-default_speaker = None
-with gr.Blocks(title="Multilingual TTS") as demo:
-    gr.HTML("<center><h1>Multilingual TTS (Edge TTS)</h1></center>")
-    gr.HTML(f"<h2 style='color:Tomato;'> {len(language_dict)} languages supported</h3>")
-    gr.HTML(f"<p> {', '.join(language_dict.keys())} </h3>")
-    gr.Markdown("**Note:** A special feature is added for Arabic language only.")
+# Simple and compatible interface
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Song Humanizer") as demo:
+    gr.Markdown("""
+    # 🎵 AI Song Humanizer
+    **Remove AI Detection - Make Songs Sound Human-Made**
+    
+    *Upload AI song → Remove robotic sound → Download human version*
+    """)
+    
     with gr.Row():
-        with gr.Column():
-            input_text = gr.Textbox(lines=5, label="Input Text", placeholder="Enter text to convert to speech")
-            language = gr.Dropdown(
-                choices=list(language_dict.keys()), value=default_language, label="Languages", interactive=True
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Upload AI Song")
+            input_audio = gr.Audio(
+                sources=["upload"],
+                type="filepath",
+                label="Upload your AI-generated song"
             )
-            speaker = gr.Dropdown(choices=[], value=default_speaker, label="Speakers", interactive=False)
-            tashkeel_checkbox = gr.Checkbox(label="Tashkeel", value=False, visible=False, interactive=False)
-            run_btn = gr.Button(value="Generate Audio", variant="primary")
-
-        with gr.Column():
-            output_text = gr.Textbox(label="Output Text")
-            output_audio = gr.Audio(type="filepath", label="Audio Output")
-
-    language.change(get_speakers, inputs=[language], outputs=[speaker, tashkeel_checkbox])
-    run_btn.click(text_to_speech_edge, inputs=[input_text, language, speaker, tashkeel_checkbox], outputs=[output_text, output_audio])
+            
+            gr.Markdown("### 2. Humanization Strength")
+            intensity = gr.Slider(
+                0.1, 1.0, value=0.7,
+                label="How much human feel to add"
+            )
+            
+            process_btn = gr.Button(
+                "✨ Humanize Song",
+                variant="primary",
+                size="lg"
+            )
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### 3. Download Result")
+            output_audio = gr.Audio(
+                label="Human-Sounding Version",
+                type="filepath"
+            )
+            
+            status = gr.Textbox(
+                label="Status",
+                interactive=False
+            )
+    
+    with gr.Accordion("📖 How It Works", open=False):
+        gr.Markdown("""
+        **This tool:**
+        - Takes your complete AI-generated song
+        - Removes robotic/AI artifacts  
+        - Adds natural human performance variations
+        - Keeps your original music intact
+        - Makes it sound like humans performed it
+        
+        **Perfect for making AI music undetectable!**
+        """)
+    
+    process_btn.click(
+        fn=humanize_song,
+        inputs=[input_audio, intensity],
+        outputs=[output_audio, status]
+    )
 
 if __name__ == "__main__":
-    demo.queue().launch(share=True)
+    demo.launch()