Update app.py

app.py

@@ -11,9 +11,10 @@ from huggingface_hub import snapshot_download, hf_hub_download
 import subprocess
 import uuid
 import soundfile as sf
-import spaces  # این خط برای ZeroGPU ضروری است
+import spaces
+import librosa
 
-# --- تنظیمات و نصب پیش‌نیازها ---
+# --- 1. نصب و راه‌اندازی ---
 downloaded_resources = {
     "configs": False,
     "tokenizer_vq8192": False,
@@ -132,6 +133,93 @@ def get_pipeline():
     inference_pipelines["timbre"] = pipeline
     return pipeline
 
+# --- 2. الگوریتم برش فوق هوشمند ---
+def find_advanced_split_points(audio_np, sr):
+    """
+    پیدا کردن نقاط برش با استراتژی فال‌بک (Fallback Strategy):
+    ۱. تلاش برای پیدا کردن سکوت در بازه ۸ تا ۱۲ ثانیه.
+    ۲. اگر نشد، تلاش در بازه وسیع‌تر ۶ تا ۱۴ ثانیه.
+    ۳. انتخاب نقطه با کمترین انرژی (حتی اگر سکوت نباشد).
+    ۴. تنظیم دقیق روی نزدیک‌ترین Zero-Crossing.
+    """
+    total_samples = len(audio_np)
+    
+    # تنظیمات بازه جستجو
+    MIN_PREFERRED = 8.0
+    MAX_PREFERRED = 12.0
+    MIN_HARD = 6.0
+    MAX_HARD = 15.0
+    
+    split_points = [0]
+    current_pos = 0
+    
+    hop_length = 512
+    frame_length = 1024
+    
+    while current_pos < total_samples:
+        # استراتژی ۱: بازه ایده‌آل
+        start_search = current_pos + int(MIN_PREFERRED * sr)
+        end_search = current_pos + int(MAX_PREFERRED * sr)
+        
+        # اگر به انتهای فایل نزدیکیم
+        if start_search >= total_samples:
+            split_points.append(total_samples)
+            break
+        
+        end_search = min(end_search, total_samples)
+        
+        # استراتژی ۲: اگر بازه ایده‌آل خیلی کوتاه است (ته فایل)، گسترش بده
+        if end_search - start_search < sr:
+             # استفاده از بازه سخت (وسیع)
+             start_search = current_pos + int(MIN_HARD * sr)
+             end_search = current_pos + int(MAX_HARD * sr)
+             start_search = min(start_search, total_samples)
+             end_search = min(end_search, total_samples)
+
+        # برش منطقه جستجو
+        region = audio_np[start_search:end_search]
+        
+        if len(region) == 0:
+            split_points.append(total_samples)
+            break
+
+        # محاسبه انرژی
+        rms = librosa.feature.rms(y=region, frame_length=frame_length, hop_length=hop_length)[0]
+        
+        # پیدا کردن کم‌انرژی‌ترین نقطه (Local Minimum)
+        min_idx = np.argmin(rms)
+        local_cut_sample = min_idx * hop_length
+        
+        # --- تکنیک Zero Crossing ---
+        # نقطه برش تقریبی را پیدا کردیم. حالا باید دقیقاً روی محور صفر برش دهیم
+        # تا صدای "کلیک" ایجاد نشود.
+        
+        cut_absolute_approx = start_search + local_cut_sample
+        
+        # جستجو در اطراف نقطه تقریبی (±500 نمونه) برای پیدا کردن صفر
+        search_radius = 500
+        zc_start = max(0, cut_absolute_approx - search_radius)
+        zc_end = min(total_samples, cut_absolute_approx + search_radius)
+        
+        zc_region = audio_np[zc_start:zc_end]
+        
+        # پیدا کردن نزدیک‌ترین عبور از صفر
+        # (جایی که علامت عدد تغییر می‌کند)
+        zero_crossings = np.where(np.diff(np.signbit(zc_region)))[0]
+        
+        if len(zero_crossings) > 0:
+            # نزدیک‌ترین صفر به وسط بازه جستجو
+            closest_zc = zero_crossings[np.argmin(np.abs(zero_crossings - search_radius))]
+            best_cut_absolute = zc_start + closest_zc
+        else:
+            # اگر صفر پیدا نشد (خیلی بعید)، همان نقطه کم‌انرژی را بگیر
+            best_cut_absolute = cut_absolute_approx
+            
+        split_points.append(best_cut_absolute)
+        current_pos = best_cut_absolute
+        
+    return split_points
+
 @spaces.GPU()
 def vevo_timbre(content_wav, reference_wav):
     session_id = str(uuid.uuid4())[:8]
@@ -145,7 +233,7 @@ def vevo_timbre(content_wav, reference_wav):
     try:
         SR = 24000
         
-        # --- آماده‌سازی ورودی ---
+        # --- ورودی ---
         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:
@@ -158,7 +246,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()
 
-        # --- آماده‌سازی رفرنس ---
+        # --- رفرنس ---
         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:
@@ -172,40 +260,27 @@ 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)
         
-        # --- استراتژی Center-Only Processing (حذف لرزش) ---
         pipeline = get_pipeline()
         
-        # تنظیمات: ۱۰ ثانیه تمیز نگه می‌داریم، ۲ ثانیه از هر طرف دور می‌ریزیم
-        CORE_CHUNK_SEC = 10.0  
-        PADDING_SEC = 2.0      
-        
-        core_samples = int(CORE_CHUNK_SEC * SR)
-        padding_samples = int(PADDING_SEC * SR)
-        total_samples = len(content_full_np)
+        # --- تقسیم‌بندی پیشرفته ---
+        print(f"[{session_id}] Finding best energy split points (Zero-Crossing)...")
+        split_points = find_advanced_split_points(content_full_np, SR)
+        print(f"[{session_id}] Split into {len(split_points)-1} chunks.")
         
         final_output = []
+        PADDING_SAMPLES = int(2.5 * SR) # کمی پدینگ بیشتر برای اطمینان
         
-        cursor = 0
-        print(f"[{session_id}] Starting Center-Only processing...")
-        
-        while cursor < total_samples:
-            # ۱. خواندن بازه وسیع‌تر (شامل پدینگ)
-            read_start = max(0, cursor - padding_samples)
-            read_end = min(total_samples, cursor + core_samples + padding_samples)
+        for i in range(len(split_points) - 1):
+            start = split_points[i]
+            end = split_points[i+1]
             
-            if cursor >= total_samples:
-                break
+            read_start = max(0, start - PADDING_SAMPLES)
+            read_end = end
             
             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,
@@ -214,47 +289,35 @@ 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)
+                trim_amount = start - read_start
                 
-                # محاسبه برش از جلو
-                if cursor == 0:
-                    trim_front = 0  # در اولین تکه، پدینگ جلو نداریم
-                else:
-                    trim_front = padding_samples # در بقیه، به اندازه پدینگ جلو می‌بریم
-
-                # محاسبه طول مفید
-                valid_length = min(core_samples, total_samples - cursor)
-                
-                if len(gen_np) > trim_front:
-                    # استخراج فقط هسته مرکزی (بدون لرزش)
-                    core_audio = gen_np[trim_front : trim_front + valid_length]
-                    
-                    # ۴. اتصال میکروسکوپی (۵۰ میلی ثانیه) فقط برای حذف کلیک
-                    fade_len = int(0.05 * SR) 
+                if len(gen_np) > trim_amount:
+                    valid_audio = gen_np[trim_amount:]
                     
-                    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) > 0:
+                        # اگر برش روی سکوت نبوده (اجباری)، باید کمی بیشتر کراس‌فید کنیم
+                        # تا تغییر ناگهانی لحن مخفی شود.
+                        fade_len = int(0.03 * SR) # 30ms standard
                         
-                        prev_tail = final_output[-1][-fade_len:]
-                        curr_head = core_audio[:fade_len]
-                        
-                        if len(prev_tail) == fade_len:
+                        if len(final_output[-1]) > fade_len and len(valid_audio) > fade_len:
+                            fade_out = np.linspace(1, 0, fade_len)
+                            fade_in = np.linspace(0, 1, fade_len)
+                            
+                            prev_tail = final_output[-1][-fade_len:]
+                            curr_head = valid_audio[:fade_len]
+                            
                             mixed = (prev_tail * fade_out) + (curr_head * fade_in)
                             final_output[-1][-fade_len:] = mixed
-                            core_audio = core_audio[fade_len:]
+                            valid_audio = valid_audio[fade_len:]
                             
-                    final_output.append(core_audio)
-                
+                    final_output.append(valid_audio)
+                    
             except Exception as e:
-                print(f"Error processing chunk at {cursor}: {e}")
-                missing = min(core_samples, total_samples - cursor)
-                final_output.append(np.zeros(missing))
-
-            # ۵. جلو رفتن دقیق به اندازه ۱۰ ثانیه
-            cursor += core_samples
+                print(f"Error segment {i}: {e}")
+                # پر کردن جای خالی با سکوت برای به هم نریختن تایم
+                final_output.append(np.zeros(end - start))
 
-        # چسباندن نهایی
         if len(final_output) > 0:
             full_audio = np.concatenate(final_output)
         else:
@@ -267,9 +330,9 @@ def vevo_timbre(content_wav, reference_wav):
         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 (Stable Core)") as demo:
+with gr.Blocks(title="Vevo-Timbre (Pro Logic)") as demo:
     gr.Markdown("## Vevo-Timbre: Zero-Shot Voice Conversion")
-    gr.Markdown("Stable Core Logic: Removes generated artifacts at boundaries.")
+    gr.Markdown("Robust Splitting: Uses Minimum Energy + Zero Crossing detection to handle fast speech without glitches.")
     
     with gr.Row():
         with gr.Column():