Update app.py

app.py

@@ -204,34 +204,36 @@ def vevo_timbre(content_wav, reference_wav):
             ref_sr = 24000
         ref_tensor = ref_tensor / (torch.max(torch.abs(ref_tensor)) + 1e-6) * 0.95
         
+        # برش رفرنس به 20 ثانیه برای سرعت
         if ref_tensor.shape[1] > 24000 * 20:
              ref_tensor = ref_tensor[:, :24000 * 20]
 
         save_audio_pcm16(ref_tensor, temp_reference_path, ref_sr)
         
-        # --- منطق Cross-Fade Chunking ---
+        # --- منطق دقیق Seamless Chunking ---
         pipeline = get_pipeline()
         
         SR = 24000
-        MAIN_CHUNK = 10 * SR       # 10 ثانیه اصلی
-        OVERLAP = 1 * SR           # 1 ثانیه هم‌پوشانی (برای میکس)
-        STEP = MAIN_CHUNK          # قدم حرکت (10 ثانیه)
+        CHUNK_LEN = 10 * SR      # 10 ثانیه اصلی
+        OVERLAP = 1 * SR          # 1 ثانیه همپوشانی
+        # مقدار ورودی به مدل = 10 ثانیه + 1 ثانیه اورلپ = 11 ثانیه
+        INPUT_SIZE = CHUNK_LEN + OVERLAP 
         
         total_samples = content_tensor.shape[1]
-        print(f"[{session_id}] Duration: {total_samples/SR:.2f}s. Chunking 10s with Cross-fade...")
+        print(f"[{session_id}] Duration: {total_samples/SR:.2f}s. Seamless Chunking...")
         
-        final_output = []
+        final_parts = []
+        overlap_buffer = None
         
-        # حلقه روی تکه‌ها با هم‌پوشانی
-        # ما هر بار 'MAIN_CHUNK + OVERLAP' را پردازش می‌کنیم (یعنی 11 ثانیه)
-        # مگر اینکه به آخر فایل رسیده باشیم
-        for start in range(0, total_samples, STEP):
-            end = min(start + MAIN_CHUNK + OVERLAP, total_samples)
+        # حرکت با قدم‌های 10 ثانیه‌ای
+        for start in range(0, total_samples, CHUNK_LEN):
+            # انتخاب بازه: از شروع تا 11 ثانیه جلوتر (یا تا آخر فایل)
+            end_input = min(start + INPUT_SIZE, total_samples)
             
-            current_input_chunk = content_tensor[:, start:end]
+            current_input_chunk = content_tensor[:, start:end_input]
             save_audio_pcm16(current_input_chunk, temp_content_path, SR)
             
-            print(f"[{session_id}] Processing {start/SR:.1f}s to {end/SR:.1f}s")
+            print(f"[{session_id}] Processing input {start/SR:.1f}s to {end_input/SR:.1f}s")
             
             try:
                 gen = pipeline.inference_fm(
@@ -239,64 +241,97 @@ def vevo_timbre(content_wav, reference_wav):
                     timbre_ref_wav_path=temp_reference_path,
                     flow_matching_steps=32,
                 )
+                # تمیزکاری داده‌ها
                 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() # تبدیل به numpy
+                gen = gen.cpu().squeeze(0).numpy()
                 
-                # منطق میکس (Cross-fade)
-                if start == 0:
-                    # تکه اول: فعلاً نگه می‌داریم (هنوز چیزی برای میکس نیست)
-                    # اگر فایل کوتاه باشد و به هم‌پوشانی نرسد، کلش را اضافه می‌کنیم
-                    if len(gen) <= MAIN_CHUNK:
-                        final_output.append(gen)
-                    else:
-                        # قسمت اصلی را اضافه کن، قسمت اورلپ را برای میکس با بعدی نگه دار
-                        final_output.append(gen[:-OVERLAP])
-                        overlap_buffer = gen[-OVERLAP:]
-                else:
-                    # تکه‌های بعدی:
-                    # 1. قسمت اورلپ قبلی را با شروع این تکه میکس کن
-                    current_overlap = gen[:OVERLAP]
-                    if len(current_overlap) == len(overlap_buffer):
-                        # ایجاد منحنی فید (Fade Curves)
-                        alpha = np.linspace(0, 1, len(overlap_buffer))
-                        # فرمول: (قبلی * نزولی) + (جدید * صعودی)
-                        blended = (overlap_buffer * (1 - alpha)) + (current_overlap * alpha)
-                        final_output.append(blended)
-                    else:
-                        # اگر سایزها نخواند (خیلی نادر)، فقط قبلی را بچسبان
-                        final_output.append(overlap_buffer)
+                # --- الگوریتم میکس دقیق ---
+                # gen اکنون شامل [بدنه اصلی (10s)] + [دم (1s)] است (مگر اینکه تکه آخر باشد)
+                
+                current_len = len(gen)
+                
+                # اگر بافر از دور قبلی داریم (یعنی تکه اول نیستیم)
+                if overlap_buffer is not None:
+                    # باید بافر قبلی را با ابتدای این تکه میکس کنیم
+                    # طول ناحیه میکس = طول بافر
+                    mix_len = len(overlap_buffer)
+                    
+                    # اگر تکه جاری کوتاه‌تر از بافر است (خیلی نادر)، برش بزن
+                    if current_len < mix_len:
+                        mix_len = current_len
+                        overlap_buffer = overlap_buffer[:mix_len]
+                    
+                    # جدا کردن سرِ تکه جاری برای میکس
+                    head_to_mix = gen[:mix_len]
+                    body_rest = gen[mix_len:]
+                    
+                    # ایجاد منحنی فید (Fade In/Out)
+                    alpha = np.linspace(0, 1, mix_len)
+                    # فرمول: (دم قبلی * پایین‌رونده) + (سر فعلی * بالا‌رونده)
+                    blended_segment = (overlap_buffer * (1 - alpha)) + (head_to_mix * alpha)
+                    
+                    # اضافه کردن بخش میکس شده به خروجی
+                    final_parts.append(blended_segment)
                     
-                    # 2. بقیه فایل را مدیریت کن
-                    if len(gen) <= OVERLAP + MAIN_CHUNK: # اگر تکه آخر است
-                        final_output.append(gen[OVERLAP:])
-                        overlap_buffer = None # تمام شد
+                    # حالا باید بدنه اصلی را مدیریت کنیم
+                    # اگر به اندازه کافی دیتا داریم که 1 ثانیه آخر را برای دور بعد نگه داریم
+                    if len(body_rest) > OVERLAP:
+                        # بخش خالص وسط
+                        pure_body = body_rest[:-OVERLAP]
+                        final_parts.append(pure_body)
+                        # آپدیت بافر برای دور بعد
+                        overlap_buffer = body_rest[-OVERLAP:]
                     else:
-                        # قسمت وسط را اضافه کن
-                        final_output.append(gen[OVERLAP:-OVERLAP])
-                        # اورلپ جدید را ذخیره کن
+                        # تکه آخر است و اورلپ ندارد، کلش را اضافه کن
+                        final_parts.append(body_rest)
+                        overlap_buffer = None
+                
+                else:
+                    # تکه اول است (هنوز بافری نداریم)
+                    if current_len > OVERLAP:
+                        # بخش اصلی را اضافه کن
+                        final_parts.append(gen[:-OVERLAP])
+                        # بخش آخر را بفرست توی بافر
                         overlap_buffer = gen[-OVERLAP:]
-                        
+                    else:
+                        # فایل خیلی کوتاه است، کلش را اضافه کن
+                        final_parts.append(gen)
+                        overlap_buffer = None
+
             except Exception as e:
                 print(f"Error: {e}")
-                silence_len = end - start
-                final_output.append(np.zeros(silence_len))
-                overlap_buffer = np.zeros(OVERLAP)
+                # در صورت خطا، سکوت جایگزین کن تا تایمینگ به هم نریزد
+                missing_len = end_input - start
+                # اگر تکه اول نبود، اورلپ را کم کن
+                if overlap_buffer is not None:
+                    missing_len -= len(overlap_buffer)
+                    final_parts.append(overlap_buffer) # بافر قبلی را خالی کن
+                    overlap_buffer = None
+                
+                final_parts.append(np.zeros(max(0, missing_len)))
 
-        # چسباندن همه آرایه‌ها
-        full_audio = np.concatenate(final_output)
-        
-        # ذخیره نهایی
-        sf.write(output_path, full_audio, SR, subtype='PCM_16')
+        # اگر بافری باقی مانده (از تکه آخر)، اضافه‌اش کن
+        if overlap_buffer is not None:
+            final_parts.append(overlap_buffer)
+            
+        # چسباندن نهایی
+        if len(final_parts) > 0:
+            full_audio = np.concatenate(final_parts)
+        else:
+            full_audio = np.zeros(24000) # Fallback
+
+        # ذخیره
+        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 (Professional)") as demo:
+with gr.Blocks(title="Vevo-Timbre (Perfect Stitch)") as demo:
     gr.Markdown("## Vevo-Timbre: Zero-Shot Voice Conversion")
-    gr.Markdown("پشتیبانی از فایل‌های نامحدود با کیفیت بالا (10s Chunking + Smooth Cross-Fade)")
+    gr.Markdown("نسخه نهایی: کیفیت ۱۶ بیتی، بدون نویز، زمان‌بندی دقیق، بدون سکوت بین تکه‌ها.")
     
     with gr.Row():
         with gr.Column():