Update app.py

app.py

@@ -9,12 +9,10 @@ import torchaudio
 import numpy as np
 from huggingface_hub import snapshot_download, hf_hub_download
 import subprocess
-import re
-import spaces
 import uuid
 import soundfile as sf
 
-# --- تنظیمات و نصب ---
+# --- تنظیمات و نصب پیش‌نیازها ---
 downloaded_resources = {
     "configs": False,
     "tokenizer_vq8192": False,
@@ -146,7 +144,7 @@ def vevo_timbre(content_wav, reference_wav):
     try:
         SR = 24000
         
-        # --- 1. پردازش ورودی ---
+        # --- آماده‌سازی ورودی ---
         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:
@@ -159,7 +157,7 @@ def vevo_timbre(content_wav, reference_wav):
         content_tensor = content_tensor / (torch.max(torch.abs(content_tensor)) + 1e-6) * 0.95
         content_full_np = content_tensor.squeeze().numpy()
 
-        # --- 2. پردازش رفرنس ---
+        # --- آماده‌سازی رفرنس ---
         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:
@@ -173,52 +171,43 @@ def vevo_timbre(content_wav, reference_wav):
         if ref_tensor.shape[1] > SR * 20: ref_tensor = ref_tensor[:, :SR * 20]
         save_audio_pcm16(ref_tensor, temp_reference_path, SR)
         
-        # --- 3. استراتژی جوش دادن Equal Power (500ms) ---
+        # --- استراتژی Center-Only Processing (حذف لرزش) ---
         pipeline = get_pipeline()
         
-        # تنظیمات حیاتی
-        CHUNK_DURATION = 10.0   # طول خالص هر تکه
-        CROSSFADE_SEC = 0.5     # طول هم‌پوشانی (نیم ثانیه برای حذف لرزش)
+        # تنظیمات اصلی (به ثانیه)
+        CORE_CHUNK_SEC = 10.0  # مقداری که نهایتاً نگه می‌داریم
+        PADDING_SEC = 2.0      # مقداری که از هر طرف اضافه می‌خوانیم و دور می‌ریزیم
         
-        chunk_samples = int(CHUNK_DURATION * SR)
-        crossfade_samples = int(CROSSFADE_SEC * SR)
+        core_samples = int(CORE_CHUNK_SEC * SR)
+        padding_samples = int(PADDING_SEC * SR)
         total_samples = len(content_full_np)
         
-        final_output = np.array([], dtype=np.float32)
-        
-        # ایجاد منحنی فید Equal Power (سینوسی)
-        # این منحنی باعث می‌شود حجم صدا در محل اتصال ثابت بماند
-        fade_out_curve = np.cos(np.linspace(0, np.pi/2, crossfade_samples))
-        fade_in_curve = np.sin(np.linspace(0, np.pi/2, crossfade_samples))
-        
-        # شروع حلقه پردازش
-        # ما در هر مرحله به اندازه chunk_samples جلو می‌رویم
-        # اما برای ورودی مدل، crossfade_samples را از قبل هم برمی‌داریم
+        final_output = []
         
         cursor = 0
-        print(f"[{session_id}] Processing with 500ms Equal-Power Crossfade...")
+        print(f"[{session_id}] Starting Center-Only processing...")
         
         while cursor < total_samples:
-            # تعیین بازه ورودی برای مدل
-            # اگر اولین تکه نیست، باید کمی از عقب‌تر شروع کنیم (برای هم‌پوشانی)
-            is_first_chunk = (cursor == 0)
+            # محاسبه بازه خواندن از فایل اصلی (Source)
+            # ما PADDING را از عقب و جلو اضافه می‌کنیم
+            read_start = max(0, cursor - padding_samples)
+            read_end = min(total_samples, cursor + core_samples + padding_samples)
             
-            start_idx = cursor
-            if not is_first_chunk:
-                start_idx -= crossfade_samples  # عقب‌گرد برای هم‌پوشانی
-                
-            end_idx = min(total_samples, cursor + chunk_samples)
-            
-            # اگر به انتهای فایل رسیدیم و تکه خیلی کوچک است
-            if start_idx >= end_idx:
+            # اگر به ته فایل رسیدیم و چیزی برای پردازش نمانده
+            if cursor >= total_samples:
                 break
-                
-            current_chunk_input = content_full_np[start_idx:end_idx]
             
-            # ذخیره و اجرا
-            save_audio_pcm16(torch.FloatTensor(current_chunk_input).unsqueeze(0), temp_content_path, SR)
+            # استخراج تکه "پد شده"
+            chunk_input = content_full_np[read_start:read_end]
+            
+            # اگر تکه خیلی کوچک است (انتهای فایل)، فقط پردازش کن
+            if len(chunk_input) < SR * 0.5:
+                 break
+            
+            save_audio_pcm16(torch.FloatTensor(chunk_input).unsqueeze(0), temp_content_path, SR)
             
             try:
+                # تولید صدا با حاشیه امن
                 gen = pipeline.inference_fm(
                     src_wav_path=temp_content_path,
                     timbre_ref_wav_path=temp_reference_path,
@@ -227,60 +216,75 @@ def vevo_timbre(content_wav, reference_wav):
                 if torch.isnan(gen).any(): gen = torch.nan_to_num(gen, nan=0.0)
                 gen_np = gen.detach().cpu().squeeze().numpy()
                 
-                # --- عملیات میکس هوشمند ---
+                # --- برش هوشمند (Trimming) ---
+                # حالا باید حاشیه‌های ناپایدار (لرزش دار) را حذف کنیم
                 
-                if is_first_chunk:
-                    # تکه اول: مستقیماً اضافه کن
-                    final_output = np.concatenate([final_output, gen_np])
+                # 1. محاسبه مقدار برش از ابتدا (Front Trim)
+                # اگر اولین تکه است، ما PADDING نداشتیم (چون read_start=0 بود)
+                if cursor == 0:
+                    trim_front = 0
                 else:
-                    # تکه‌های بعدی:
-                    # 1. بخش هم‌پوشانی (Crossfade Area)
-                    # 2. بخش جدید (New Area)
+                    # در غیر این صورت، دقیقاً به اندازه PADDING از جلو می‌بریم
+                    trim_front = padding_samples
+
+                # 2. محاسبه مقدار برش از انتها (End Trim)
+                # ما می‌خواهیم فقط به اندازه CORE (10 ثانیه) نگه داریم
+                # اما باید مراقب انتهای فایل باشیم
+                
+                # طول معتبر این تکه در خروجی نهایی
+                valid_length = min(core_samples, total_samples - cursor)
+                
+                # استخراج بخش مرکزی (Stable Core)
+                # از trim_front شروع کن و به اندازه valid_length بردار
+                if len(gen_np) > trim_front:
+                    core_audio = gen_np[trim_front : trim_front + valid_length]
                     
-                    if len(gen_np) < crossfade_samples:
-                        # اگر خروجی خیلی کوتاه بود (نادر)، فقط بچسبان
-                        final_output = np.concatenate([final_output, gen_np])
-                    else:
-                        # جدا کردن بخش میکس و بخش جدید از خروجی فعلی
-                        overlap_part_new = gen_np[:crossfade_samples]
-                        rest_part_new = gen_np[crossfade_samples:]
+                    # --- اتصال میکروسکوپی (Micro Crossfade 50ms) ---
+                    # این فقط برای جلوگیری از کلیک دیجیتال است، نه برای تغییر لحن
+                    fade_len = int(0.05 * SR) # 50ms
+                    
+                    if len(final_output) > 0 and len(core_audio) > fade_len:
+                        # نرم کردن اتصال
+                        fade_out = np.linspace(1, 0, fade_len)
+                        fade_in = np.linspace(0, 1, fade_len)
                         
-                        # جدا کردن بخش میکس از انتهای خروجی قبلی
-                        if len(final_output) >= crossfade_samples:
-                            overlap_part_old = final_output[-crossfade_samples:]
-                            
-                            # فرمول Equal Power Crossfade
-                            # Old * Cos + New * Sin
-                            blended = (overlap_part_old * fade_out_curve) + (overlap_part_new * fade_in_curve)
-                            
-                            # جایگزینی انتهای آرایه اصلی با بخش میکس شده
-                            final_output[-crossfade_samples:] = blended
+                        # آخرین تکه لیست
+                        prev_tail = final_output[-1][-fade_len:]
+                        curr_head = core_audio[:fade_len]
+                        
+                        # اگر سایزها یکی بود میکس کن
+                        if len(prev_tail) == fade_len:
+                            mixed = (prev_tail * fade_out) + (curr_head * fade_in)
+                            final_output[-1][-fade_len:] = mixed
+                            # حذف بخش میکس شده از تکه جدید
+                            core_audio = core_audio[fade_len:]
                             
-                            # اضافه کردن باقی‌مانده
-                            final_output = np.concatenate([final_output, rest_part_new])
-                        else:
-                            # اگر بافر قبلی خیلی کوتاه بود (نباید پیش بیاید)
-                            final_output = np.concatenate([final_output, gen_np])
-
+                    final_output.append(core_audio)
+                
             except Exception as e:
-                print(f"Error at {cursor}: {e}")
-                # در صورت خطا سکوت اضافه کن
-                missing = end_idx - start_idx
-                final_output = np.concatenate([final_output, np.zeros(missing)])
-            
-            # حرکت به جلو
-            cursor += chunk_samples
+                print(f"Error processing chunk at {cursor}: {e}")
+                missing = min(core_samples, total_samples - cursor)
+                final_output.append(np.zeros(missing))
+
+            # جلو رفتن نشانگر به اندازه هسته اصلی (بدون هم‌پوشانی منطقی)
+            cursor += core_samples
 
-        save_audio_pcm16(final_output, output_path, SR)
+        # چسباندن نهایی
+        if len(final_output) > 0:
+            full_audio = np.concatenate(final_output)
+        else:
+            full_audio = np.zeros(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 (Pro Stitch)") as demo:
+with gr.Blocks(title="Vevo-Timbre (Stable Core)") as demo:
     gr.Markdown("## Vevo-Timbre: Zero-Shot Voice Conversion")
-    gr.Markdown("Professional Stitching: 500ms Equal-Power Crossfade (No Jitter, No Ghosting).")
+    gr.Markdown("Center-Only Processing Strategy: Generates extra padding and discards unstable edges to remove jitter.")
     
     with gr.Row():
         with gr.Column():