Update voice_processing.py

voice_processing.py

@@ -53,7 +53,7 @@ def model_data(model_name):
         if f.endswith(".pth")
     ][0]
     print(f"Loading {pth_path}")
-    cpt = torch.load(pth_path, map_location="cpu", weights_only=True)
+    cpt = torch.load(pth_path, map_location="cpu")
     tgt_sr = cpt["config"][-1]
     cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]  # n_spk
     if_f0 = cpt.get("f0", 1)
@@ -108,135 +108,141 @@ def load_hubert():
     return hubert_model.eval()
 
 def get_model_names():
+    model_root = "weights"  # Assuming this is where your models are stored
     return [d for d in os.listdir(model_root) if os.path.isdir(f"{model_root}/{d}")]
 
-import nest_asyncio
-nest_asyncio.apply()
-
-def get_unique_filename(extension):
-    return f"{uuid.uuid4().hex[:8]}.{extension}"
-
-class TTSProcessor:
-    def __init__(self, config):
-        self.config = config
-        self.executor = ThreadPoolExecutor(max_workers=config.n_cpu)
-        self.semaphore = asyncio.Semaphore(config.max_concurrent_tts)
-        self.last_request_time = time.time()
-        self.rate_limit = config.tts_rate_limit
-        self.temp_dir = tempfile.mkdtemp()
-
-    async def tts(self, model_name, tts_text, tts_voice, index_rate, use_uploaded_voice, uploaded_voice):
-        async with self.semaphore:
-            current_time = time.time()
-            time_since_last_request = current_time - self.last_request_time
-            if time_since_last_request < 1 / self.rate_limit:
-                await asyncio.sleep(1 / self.rate_limit - time_since_last_request)
+# Add this helper function to ensure a new event loop is created if none exists
+def run_async_in_thread(fn, *args):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    result = loop.run_until_complete(fn(*args))
+    loop.close()
+    return result
+
+def parallel_tts(tasks):
+    with ThreadPoolExecutor() as executor:
+        futures = [executor.submit(run_async_in_thread, tts, *task) for task in tasks]
+        results = [future.result() for future in futures]
+    return results
+
+async def tts(
+    model_name,
+    tts_text,
+    tts_voice,
+    index_rate,
+    use_uploaded_voice,
+    uploaded_voice,
+):
+    # Default values for parameters used in EdgeTTS
+    speed = 0  # Default speech speed
+    f0_up_key = 0  # Default pitch adjustment
+    f0_method = "rmvpe"  # Default pitch extraction method
+    protect = 0.33  # Default protect value
+    filter_radius = 3
+    resample_sr = 0
+    rms_mix_rate = 0.25
+    edge_time = 0  # Initialize edge_time
+
+    edge_output_filename = get_unique_filename("mp3")
+
+    try:
+        if use_uploaded_voice:
+            if uploaded_voice is None:
+                return "No voice file uploaded.", None, None
             
-            self.last_request_time = time.time()
-
-            loop = asyncio.get_running_loop()
-            return await loop.run_in_executor(
-                self.executor,
-                self._tts_process,
-                model_name,
-                tts_text,
-                tts_voice,
-                index_rate,
-                use_uploaded_voice,
-                uploaded_voice
-            )
+            # Process the uploaded voice file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+                tmp_file.write(uploaded_voice)
+                uploaded_file_path = tmp_file.name
 
-    def _tts_process(self, model_name, tts_text, tts_voice, index_rate, use_uploaded_voice, uploaded_voice):
-        try:
-            edge_output_filename = os.path.join(self.temp_dir, get_unique_filename("mp3"))
-
-            if use_uploaded_voice:
-                if uploaded_voice is None:
-                    return "No voice file uploaded.", None, None
-                
-                uploaded_file_path = os.path.join(self.temp_dir, get_unique_filename("wav"))
-                with open(uploaded_file_path, "wb") as f:
-                    f.write(uploaded_voice)
-
-                audio, sr = librosa.load(uploaded_file_path, sr=16000, mono=True)
-            else:
-                if limitation and len(tts_text) > 12000:
-                    return (
-                        f"Text characters should be at most 12000 in this huggingface space, but got {len(tts_text)} characters.",
-                        None,
-                        None,
-                    )
-                
-                speed = 0  # Default speech speed
-                speed_str = f"+{speed}%" if speed >= 0 else f"{speed}%"
-                
-                # Use synchronous approach for Edge TTS
-                communicate = edge_tts.Communicate(tts_text, tts_voice, rate=speed_str)
-                asyncio.get_event_loop().run_until_complete(communicate.save(edge_output_filename))
-
-                audio, sr = librosa.load(edge_output_filename, sr=16000, mono=True)
-
-            duration = len(audio) / sr
-            if limitation and duration >= 20000:
+            audio, sr = librosa.load(uploaded_file_path, sr=16000, mono=True)
+        else:
+            # EdgeTTS processing
+            if limitation and len(tts_text) > 12000:
                 return (
-                    f"Audio should be less than 20 seconds in this huggingface space, but got {duration}s.",
+                    f"Text characters should be at most 12000 in this huggingface space, but got {len(tts_text)} characters.",
                     None,
                     None,
                 )
-
-            f0_up_key = 0
-            tgt_sr, net_g, vc, version, index_file, if_f0 = model_data(model_name)
-
-            if hasattr(self, 'model_rmvpe'):
-                vc.model_rmvpe = self.model_rmvpe
-
-            times = [0, 0, 0]
-            audio_opt = vc.pipeline(
-                hubert_model,
-                net_g,
-                0,
-                audio,
-                edge_output_filename if not use_uploaded_voice else uploaded_file_path,
-                times,
-                f0_up_key,
-                "rmvpe",
-                index_file,
-                index_rate,
-                if_f0,
-                3,  # filter_radius
-                tgt_sr,
-                0,  # resample_sr
-                0.25,  # rms_mix_rate
-                version,
-                0.33,  # protect
-                None,
-            )
-
-            info = f"Success. Time: tts: {times[0]}s, npy: {times[1]}s, f0: {times[2]}s"
-            print(info)
+            
+            # Invoke Edge TTS
+            t0 = time.time()
+            speed_str = f"+{speed}%" if speed >= 0 else f"{speed}%"
+            await edge_tts.Communicate(
+                tts_text, tts_voice, rate=speed_str
+            ).save(edge_output_filename)
+            t1 = time.time()
+            edge_time = t1 - t0
+
+            audio, sr = librosa.load(edge_output_filename, sr=16000, mono=True)
+
+        # Common processing after loading the audio
+        duration = len(audio) / sr
+        print(f"Audio duration: {duration}s")
+        if limitation and duration >= 20000:
             return (
-                info,
-                edge_output_filename if not use_uploaded_voice else None,   
-                (tgt_sr, audio_opt),
+                f"Audio should be less than 20 seconds in this huggingface space, but got {duration}s.",
+                None,
+                None,
             )
 
-        except Exception as e:
-            logging.error(f"Error in TTS processing: {str(e)}")
-            logging.error(traceback.format_exc())
-            return str(e), None, None
-
-    def __del__(self):
-        # Clean up temporary directory
-        import shutil
-        shutil.rmtree(self.temp_dir, ignore_errors=True)
-
-# Initialize global variables
-tts_processor = TTSProcessor(config)
-hubert_model = load_hubert()
-rmvpe_model = RMVPE("rmvpe.pt", config.is_half, config.device)
-tts_processor.model_rmvpe = rmvpe_model
+        f0_up_key = int(f0_up_key)
+        tgt_sr, net_g, vc, version, index_file, if_f0 = model_data(model_name)
+
+        # Setup for RMVPE or other pitch extraction methods
+        if f0_method == "rmvpe":
+            vc.model_rmvpe = rmvpe_model
+
+        # Perform voice conversion pipeline
+        times = [0, 0, 0]
+        audio_opt = vc.pipeline(
+            hubert_model,
+            net_g,
+            0,
+            audio,
+            edge_output_filename if not use_uploaded_voice else uploaded_file_path,
+            times,
+            f0_up_key,
+            f0_method,
+            index_file,
+            index_rate,
+            if_f0,
+            filter_radius,
+            tgt_sr,
+            resample_sr,
+            rms_mix_rate,
+            version,
+            protect,
+            None,
+        )
+
+        if tgt_sr != resample_sr and resample_sr >= 16000:
+            tgt_sr = resample_sr
+        
+        info = f"Success. Time: tts: {edge_time}s, npy: {times[0]}s, f0: {times[1]}s, infer: {times[2]}s"
+        print(info)
+        return (
+            info,
+            edge_output_filename if not use_uploaded_voice else None,   
+            (tgt_sr, audio_opt),
+        )
+
+    except EOFError:
+        info = (
+            "output not valid. This may occur when input text and speaker do not match."
+        )
+        print(info)
+        return info, None, None
+    except Exception as e:
+        traceback_info = traceback.format_exc()
+        print(traceback_info)
+        return str(e), None, None
 
 voice_mapping = {
     "Mongolian Male": "mn-MN-BataaNeural",
     "Mongolian Female": "mn-MN-YesuiNeural"
-}
+}
+
+hubert_model = load_hubert()
+
+rmvpe_model = RMVPE("rmvpe.pt", config.is_half, config.device)