Update app.py

app.py

@@ -14,7 +14,7 @@ import spaces
 import uuid
 import soundfile as sf
 
-# --- بخش نصب و راه‌اندازی اولیه ---
+# --- تنظیمات اولیه و نصب پکیج‌ها ---
 downloaded_resources = {
     "configs": False,
     "tokenizer_vq8192": False,
@@ -34,6 +34,7 @@ def install_espeak():
 
 install_espeak()
 
+# پچ کردن مشکل LangSegment
 def patch_langsegment_init():
     try:
         spec = importlib.util.find_spec("LangSegment")
@@ -71,6 +72,7 @@ def patch_langsegment_init():
 
 patch_langsegment_init()
 
+# دریافت ریپازیتوری Amphion
 if not os.path.exists("Amphion"):
     subprocess.run(["git", "clone", "https://github.com/open-mmlab/Amphion.git"])
     os.chdir("Amphion")
@@ -174,26 +176,25 @@ def vevo_timbre(content_wav, reference_wav):
         raise ValueError("Please upload audio files")
     
     try:
-        # --- 1. پردازش ورودی (Content) ---
+        # --- 1. آماده‌سازی فایل ورودی (Content) ---
         if isinstance(content_wav, tuple):
             content_sr, content_data = content_wav if isinstance(content_wav[0], int) else (content_wav[1], content_wav[0])
         else:
             content_sr, content_data = content_wav
 
-        # تبدیل استریو به مونو
         if len(content_data.shape) > 1 and content_data.shape[1] > 1:
             content_data = np.mean(content_data, axis=1)
         
-        # نرمال‌سازی و ریسمپل
         content_tensor = torch.FloatTensor(content_data).unsqueeze(0)
         if content_sr != 24000:
             content_tensor = torchaudio.functional.resample(content_tensor, content_sr, 24000)
             content_sr = 24000
         
+        # نرمال‌سازی
         content_tensor = content_tensor / (torch.max(torch.abs(content_tensor)) + 1e-6) * 0.95
-        content_audio_np = content_tensor.squeeze().numpy()
+        content_full_np = content_tensor.squeeze().numpy()
 
-        # --- 2. پردازش رفرنس (Reference) ---
+        # --- 2. آماده‌سازی فایل رفرنس (Reference) ---
         if isinstance(reference_wav, tuple):
             ref_sr, ref_data = reference_wav if isinstance(reference_wav[0], int) else (reference_wav[1], reference_wav[0])
         else:
@@ -210,142 +211,119 @@ def vevo_timbre(content_wav, reference_wav):
         ref_max = torch.max(torch.abs(ref_tensor)) + 1e-6
         ref_tensor = ref_tensor / ref_max * 0.95
         
-        # محدود کردن طول رفرنس برای جلوگیری از خطای حافظه
         if ref_tensor.shape[1] > 24000 * 20:
              ref_tensor = ref_tensor[:, :24000 * 20]
 
         save_audio_pcm16(ref_tensor, temp_reference_path, ref_sr)
         
-        # --- 3. منطق Overlap-Add برای اتصال بدون لرزش ---
+        # --- 3. منطق جدید: Pre-roll Context (بدون هم‌پوشانی طولانی) ---
         pipeline = get_pipeline()
         SR = 24000
         
-        # تنظیمات تکه‌بندی
-        PROCESS_CHUNK_SEC = 12   # طول هر تکه برای پردازش (۱۲ ثانیه)
-        OVERLAP_SEC = 2          # میزان هم‌پوشانی برای میکس (۲ ثانیه)
-        # میزان پیشروی موثر در هر گام (۱۰ ثانیه)
-        HOP_SEC = PROCESS_CHUNK_SEC - OVERLAP_SEC 
+        # استراتژی: 
+        # ما می‌خواهیم ۱۰ ثانیه جدید بسازیم.
+        # اما برای اینکه لحن نپرد، ۳ ثانیه از صدای قبلی را هم به ورودی اضافه می‌کنیم.
+        # بعد از تولید، آن ۳ ثانیه اول را دور می‌ریزیم.
         
-        hop_samples = HOP_SEC * SR
-        chunk_samples = PROCESS_CHUNK_SEC * SR
-        overlap_samples = OVERLAP_SEC * SR
+        NEW_CHUNK_SEC = 10.0  # مقدار صدای جدید در هر مرحله
+        CONTEXT_SEC = 3.0     # مقدار صدای قدیمی برای حفظ لحن
         
-        total_length = len(content_audio_np)
-        final_output_audio = np.array([], dtype=np.float32)
+        new_chunk_samples = int(NEW_CHUNK_SEC * SR)
+        context_samples = int(CONTEXT_SEC * SR)
+        total_samples = len(content_full_np)
         
-        print(f"[{session_id}] Starting seamless processing. Total length: {total_length/SR:.2f}s")
+        final_output = []
         
-        # حلقه روی فایل با گام ۱۰ ثانیه
-        for start_idx in range(0, total_length, hop_samples):
-            end_idx = min(start_idx + chunk_samples, total_length)
-            
-            # استخراج تکه فعلی
-            current_chunk_np = content_audio_np[start_idx:end_idx]
+        # نشانگر: تا کجای فایل را "نهایی" و تولید کرده‌ایم
+        current_cursor = 0
+        
+        print(f"[{session_id}] Starting processing with Context-Discard strategy...")
+        
+        while current_cursor < total_samples:
+            # تعیین محدوده برش از فایل اصلی
+            # شروع: کمی عقب‌تر از جایی که هستیم (برای کانتکست)
+            start_slice = max(0, current_cursor - context_samples)
+            # پایان: ۱۰ ثانیه جلوتر از جایی که هستیم
+            end_slice = min(total_samples, current_cursor + new_chunk_samples)
             
-            # اگر تکه خیلی کوتاه باشد (کمتر از نیم ثانیه)، صرف نظر کن
-            if len(current_chunk_np) < SR * 0.5:
-                continue
+            # اگر چیزی برای پردازش نمانده
+            if start_slice >= end_slice:
+                break
                 
+            # استخراج تکه از فایل اصلی
+            chunk_np = content_full_np[start_slice:end_slice]
+            
             # ذخیره موقت برای مدل
-            save_audio_pcm16(torch.FloatTensor(current_chunk_np).unsqueeze(0), temp_content_path, SR)
+            save_audio_pcm16(torch.FloatTensor(chunk_np).unsqueeze(0), temp_content_path, SR)
             
             try:
-                # اجرای مدل
+                # تولید صدا توسط مدل
                 gen = pipeline.inference_fm(
                     src_wav_path=temp_content_path,
                     timbre_ref_wav_path=temp_reference_path,
                     flow_matching_steps=64,
                 )
                 
-                # تبدیل خروجی به numpy
                 if torch.isnan(gen).any(): gen = torch.nan_to_num(gen, nan=0.0)
                 if gen.dim() == 1: gen = gen.unsqueeze(0)
                 gen_np = gen.cpu().squeeze(0).numpy()
                 
-                # --- میکس (Cross-Fade) ---
-                if len(final_output_audio) == 0:
-                    # اولین تکه: مستقیماً اضافه کن
-                    final_output_audio = gen_np
-                else:
-                    # تکه‌های بعدی
-                    # ۱. محاسبه طول هم‌پوشانی واقعی
-                    # انتظار داریم خروجی مدل تقریباً هم‌اندازه ورودی باشد
-                    # انتهای صدای فعلی در final_output_audio کجاست؟ 
-                    # ما در هر دور hop_samples جلو می‌رویم.
-                    
-                    # روش ایمن:
-                    # دو ثانیه آخر صدای قبلی را با دو ثانیه اول صدای جدید ترکیب می‌کنیم
-                    
-                    prev_audio_len = len(final_output_audio)
-                    new_audio_len = len(gen_np)
-                    
-                    # اگر خروجی مدل خیلی کوتاه بود، فقط بچسبان
-                    if new_audio_len < overlap_samples:
-                         final_output_audio = np.concatenate([final_output_audio, gen_np])
-                         continue
-
-                    # برش بخش هم‌پوشانی
-                    # ما قبلاً در دور قبل، تمام خروجی (۱۲ ثانیه) را ذخیره کردیم.
-                    # اما الان ۱۰ ثانیه جلو آمدیم. پس ۲ ثانیه آخر دور قبلی، با ۲ ثانیه اول دور جدید هم‌پوشانی دارد.
-                    # (توجه: این منطق فرض می‌کند خروجی مدل دقیقا هم‌طول ورودی است که در VC تقریبا درست است)
-                    
-                    # حذف ۲ ثانیه آخر از بافر نهایی (برای آماده‌سازی میکس)
-                    # اما صبر کن، ما در دور قبل کامل اضافه کردیم. پس الان بافر نهایی شامل Overlap هم هست.
-                    # بخش غیر اورلپ قبلی: تا سرِ overlap
-                    # بخش اورلپ قبلی: از سرِ overlap تا آخر
-                    
-                    # منطق ساده‌تر Overlap-Add:
-                    # همیشه فقط بخش "جدید" (۱۰ ثانیه) را نگه نداریم، بلکه همیشه میکس کنیم.
-                    
-                    # پیاده‌سازی دقیق Cross-Fade:
-                    fade_out = np.linspace(1, 0, overlap_samples)
-                    fade_in = np.linspace(0, 1, overlap_samples)
-                    
-                    # ۲ ثانیه آخر بافر فعلی
-                    prev_tail = final_output_audio[-overlap_samples:]
-                    # ۲ ثانیه اول صدای جدید
-                    curr_head = gen_np[:overlap_samples]
-                    
-                    # اطمینان از هم‌اندازه بودن (ممکن است مدل خروجی کمی متفاوت بدهد)
-                    min_len = min(len(prev_tail), len(curr_head))
-                    if min_len < overlap_samples:
-                        # اگر به هر دلیلی سایزها نخواند (نادر)، برش بزن
-                        prev_tail = prev_tail[:min_len]
-                        curr_head = curr_head[:min_len]
-                        fade_out = fade_out[:min_len]
-                        fade_in = fade_in[:min_len]
-                        # اصلاح بافر اصلی
-                        final_output_audio = final_output_audio[:len(final_output_audio)-(overlap_samples-min_len)]
+                # --- برش هوشمند (Trimming) ---
+                # ما (current_cursor - start_slice) مقدار سمپل را قبلا تولید کرده بودیم (کانتکست)
+                # پس باید این مقدار را از ابتدای خروجی جدید حذف کنیم تا صدای دو نفره نشود.
+                trim_amount = current_cursor - start_slice
+                
+                if len(gen_np) > trim_amount:
+                    valid_audio = gen_np[trim_amount:]
                     
-                    # انجام میکس
-                    blended_overlap = (prev_tail * fade_out) + (curr_head * fade_in)
+                    # --- اتصال نرم (Micro Cross-fade) ---
+                    # فقط ۱۰ میلی ثانیه فید می‌کنیم تا صدای "تیک" ندهد.
+                    # این مقدار آنقدر کم است که گوش انسان صدای دو نفره نمی‌شنود.
+                    if len(final_output) > 0:
+                        # 10ms fade
+                        fade_len = int(0.01 * SR) 
+                        if len(final_output[-1]) > fade_len and len(valid_audio) > fade_len:
+                            fade_out_curve = np.linspace(1, 0, fade_len)
+                            fade_in_curve = np.linspace(0, 1, fade_len)
+                            
+                            # میکس فقط روی ۱۰ میلی ثانیه مرز
+                            prev_tail = final_output[-1][-fade_len:]
+                            curr_head = valid_audio[:fade_len]
+                            
+                            blended = (prev_tail * fade_out_curve) + (curr_head * fade_in_curve)
+                            
+                            # جایگزینی
+                            final_output[-1][-fade_len:] = blended
+                            valid_audio = valid_audio[fade_len:]
                     
-                    # بروزرسانی بافر نهایی:
-                    # ۱. حذف بخش Overlap خام قبلی
-                    final_output_audio = final_output_audio[:-len(blended_overlap)]
-                    # ۲. اضافه کردن بخش میکس شده
-                    final_output_audio = np.concatenate([final_output_audio, blended_overlap])
-                    # ۳. اضافه کردن باقی‌مانده صدای جدید (بعد از بخش Overlap)
-                    remaining_new = gen_np[len(blended_overlap):]
-                    final_output_audio = np.concatenate([final_output_audio, remaining_new])
-
+                    final_output.append(valid_audio)
+                
+                # مکان‌نما را جلو می‌بریم
+                current_cursor = end_slice
+                
             except Exception as e:
-                print(f"Error generating chunk at {start_idx}: {e}")
-                # در صورت خطا، سکوت اضافه کن تا تایمینگ به هم نریزد
-                silence_len = chunk_samples if start_idx + chunk_samples < total_length else total_length - start_idx
-                final_output_audio = np.concatenate([final_output_audio, np.zeros(silence_len)])
+                print(f"Error in chunk: {e}")
+                # در صورت خطا، سکوت اضافه می‌کنیم تا زمان‌بندی به هم نریزد
+                missing_len = end_slice - current_cursor
+                final_output.append(np.zeros(missing_len))
+                current_cursor = end_slice
+
+        # چسباندن نهایی
+        if len(final_output) > 0:
+            full_audio = np.concatenate(final_output)
+        else:
+            full_audio = np.zeros(SR)
 
-        # ذخیره نهایی
-        save_audio_pcm16(final_output_audio, output_path, SR)
+        save_audio_pcm16(full_audio, output_path, SR)
         return output_path
 
     finally:
         if os.path.exists(temp_content_path): os.remove(temp_content_path)
         if os.path.exists(temp_reference_path): os.remove(temp_reference_path)
 
-with gr.Blocks(title="Vevo-Timbre (Seamless Overlap)") as demo:
+with gr.Blocks(title="Vevo-Timbre (Clean Stitch)") as demo:
     gr.Markdown("## Vevo-Timbre: Zero-Shot Voice Conversion")
-    gr.Markdown("Fixed Seamless Version: Uses 2s Cross-Fade Overlap to eliminate glitches.")
+    gr.Markdown("No Ghosting Version: Uses Context-Discard buffering to ensure single voice playback.")
     
     with gr.Row():
         with gr.Column():