Update app.py

app.py

@@ -14,7 +14,7 @@ import spaces
 import uuid
 import soundfile as sf
 
-# منابع ضروری
+# --- بخش نصب و راه‌اندازی اولیه ---
 downloaded_resources = {
     "configs": False,
     "tokenizer_vq8192": False,
@@ -174,23 +174,26 @@ def vevo_timbre(content_wav, reference_wav):
         raise ValueError("Please upload audio files")
     
     try:
-        # --- پردازش ورودی ---
+        # --- 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()
 
-        # --- پردازش رفرنس ---
+        # --- 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:
@@ -207,109 +210,142 @@ 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)
         
-        # --- منطق Pre-roll Chunking (حفظ لحن پیوسته) ---
+        # --- 3. منطق Overlap-Add برای اتصال بدون لرزش ---
         pipeline = get_pipeline()
-        
         SR = 24000
-        TARGET_CHUNK_LEN = 10 * SR  # طول هدف برای هر تکه جدید (۱۰ ثانیه)
-        CONTEXT_LEN = int(2.5 * SR) # مقدار پیش‌خوانی (۲.۵ ثانیه)
         
-        total_samples = content_tensor.shape[1]
-        print(f"[{session_id}] Processing with Pre-roll context...")
+        # تنظیمات تکه‌بندی
+        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
         
-        final_output = []
+        total_length = len(content_audio_np)
+        final_output_audio = np.array([], dtype=np.float32)
         
-        # مکان‌نما: نشان می‌دهد تا کجای فایل را "نهایی" کرده‌ایم
-        current_cursor = 0
+        print(f"[{session_id}] Starting seamless processing. Total length: {total_length/SR:.2f}s")
         
-        while current_cursor < total_samples:
-            # تعیین بازه ورودی به مدل
-            # شروع: از ۲.۵ ثانیه قبل (اگر وجود داشته باشد)
-            start_input = max(0, current_cursor - CONTEXT_LEN)
-            # پایان: ۱۰ ثانیه جلوتر از مکان‌نما
-            end_input = min(current_cursor + TARGET_CHUNK_LEN, total_samples)
+        # حلقه روی فایل با گام ۱۰ ثانیه
+        for start_idx in range(0, total_length, hop_samples):
+            end_idx = min(start_idx + chunk_samples, total_length)
             
-            # اگر به ته فایل رسیدیم و چیزی نمانده
-            if start_input >= end_input:
-                break
+            # استخراج تکه فعلی
+            current_chunk_np = content_audio_np[start_idx:end_idx]
             
-            # استخراج تکه (شامل کانتکست + دیتای جدید)
-            chunk_tensor = content_tensor[:, start_input:end_input]
-            save_audio_pcm16(chunk_tensor, temp_content_path, SR)
+            # اگر تکه خیلی کوتاه باشد (کمتر از نیم ثانیه)، صرف نظر کن
+            if len(current_chunk_np) < SR * 0.5:
+                continue
+                
+            # ذخیره موقت برای مدل
+            save_audio_pcm16(torch.FloatTensor(current_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 = gen.cpu().squeeze(0).numpy()
-                
-                # --- برش هوشمند ---
-                # ما به مدل (start_input تا end_input) را دادیم.
-                # اما فقط قسمت (current_cursor تا end_input) را می‌خواهیم.
-                # پس باید قسمت اول (که مربوط به کانتکست است) را ببریم.
-                
-                cut_amount = current_cursor - start_input
+                gen_np = gen.cpu().squeeze(0).numpy()
                 
-                if len(gen) > cut_amount:
-                    valid_part = gen[cut_amount:]
+                # --- میکس (Cross-Fade) ---
+                if len(final_output_audio) == 0:
+                    # اولین تکه: مستقیماً اضافه کن
+                    final_output_audio = gen_np
+                else:
+                    # تکه‌های بعدی
+                    # ۱. محاسبه طول هم‌پوشانی واقعی
+                    # انتظار داریم خروجی مدل تقریباً هم‌اندازه ورودی باشد
+                    # انتهای صدای فعلی در final_output_audio کجاست؟ 
+                    # ما در هر دور hop_samples جلو می‌رویم.
                     
-                    # اعمال یک میکرو-فید خیلی کوتاه (10 میلی ثانیه) فقط برای رفع نویز اتصال PCM
-                    # این Cross-fade نیست، فقط De-click است
-                    if len(final_output) > 0:
-                        fade_samples = int(0.01 * SR) # 10ms
-                        if len(valid_part) > fade_samples and len(final_output[-1]) > fade_samples:
-                            # نرم کردن اتصال
-                            fade_in = np.linspace(0, 1, fade_samples)
-                            fade_out = np.linspace(1, 0, fade_samples)
-                            
-                            # میکس ۱۰ میلی ثانیه آخرِ قبلی با ۱۰ میلی ثانیه اولِ جدید
-                            prev_tail = final_output[-1][-fade_samples:]
-                            curr_head = valid_part[:fade_samples]
-                            
-                            # جایگزینی دم قبلی (میکس شده)
-                            final_output[-1][-fade_samples:] = (prev_tail * fade_out) + (curr_head * fade_in)
-                            # حذف سرِ فعلی (چون میکس شد)
-                            valid_part = valid_part[fade_samples:]
-
-                    final_output.append(valid_part)
-                
-                # آپدیت مکان‌نما
-                current_cursor = end_input
-                
+                    # روش ایمن:
+                    # دو ثانیه آخر صدای قبلی را با دو ثانیه اول صدای جدید ترکیب می‌کنیم
+                    
+                    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)]
+                    
+                    # انجام میکس
+                    blended_overlap = (prev_tail * fade_out) + (curr_head * fade_in)
+                    
+                    # بروزرسانی بافر نهایی:
+                    # ۱. حذف بخش 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])
+
             except Exception as e:
-                print(f"Error: {e}")
-                # مدیریت خطا
-                missing = end_input - current_cursor
-                final_output.append(np.zeros(missing))
-                current_cursor = end_input
-
-        # چسباندن
-        if len(final_output) > 0:
-            full_audio = np.concatenate(final_output)
-        else:
-            full_audio = np.zeros(24000)
+                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)])
 
-        save_audio_pcm16(full_audio, output_path, SR)
+        # ذخیره نهایی
+        save_audio_pcm16(final_output_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)") as demo:
+with gr.Blocks(title="Vevo-Timbre (Seamless Overlap)") as demo:
     gr.Markdown("## Vevo-Timbre: Zero-Shot Voice Conversion")
-    gr.Markdown("نسخه نهایی: اتصال کاملاً پیوسته و بدون شوک (Pre-roll Context).")
+    gr.Markdown("Fixed Seamless Version: Uses 2s Cross-Fade Overlap to eliminate glitches.")
     
     with gr.Row():
         with gr.Column():