Update app.py

app.py

@@ -4,14 +4,13 @@ import numpy as np
 import datetime
 import time
 from infer_rvc_python import BaseLoader
-import torchaudio
 
 # Initialize the model
 now = datetime.datetime.now()
 timestamp = now.strftime("%Y-%m-%d_%H-%M-%S")
 random_tag = "USER_" + str(timestamp)
 
-converter = BaseLoader(only_cpu=False, hubert_path='./hubert_base.pt', rmvpe_path='./rmvpe.pt')
+converter = BaseLoader(only_cpu=True, hubert_path='./hubert_base.pt', rmvpe_path='./rmvpe.pt')
 converter.apply_conf(
     tag=random_tag,
     file_model="./model.pth",
@@ -29,56 +28,49 @@ chunk_sec = 0.1
 sr = 16000
 chunk_len = int(sr * chunk_sec)
 L = 16
-stop_recording = False
 first_output_latency = 0
 
-# Initialize global audio buffer
-audio_buffer = torch.zeros(0, dtype=torch.float32)
-
-# Function to process audio chunks
-def process_audio_chunk(audio, buffer_state):
+# Function to process and play audio chunks
+def process_audio_chunk(audio, output_state):
     global first_output_latency
     
-    if buffer_state is None:
-        buffer_state = torch.zeros(0, dtype=torch.float32)
+    if output_state is None:
+        output_state = np.zeros(0, dtype=np.float32)
     
     if audio is None:
-        return None, buffer_state
+        return None, output_state
     
     # Convert input audio to tensor
     audio_data = torch.tensor(audio[1], dtype=torch.float32)
-    buffer_state = torch.cat((buffer_state, audio_data))
-    
-    if len(buffer_state) < chunk_len:
-        return None, buffer_state
     
-    # Process the chunk
-    previous_chunk = buffer_state[:chunk_len]
-    buffer_state = buffer_state[chunk_len:]
+    if len(audio_data) < chunk_len:
+        return None, output_state
     
-    input_chunk = torch.cat([torch.zeros(L * 2, dtype=torch.float32), previous_chunk])
+    input_chunk = torch.cat([torch.zeros(L * 2, dtype=torch.float32), audio_data])
     
     with torch.inference_mode():
         data = (input_chunk.numpy().astype(np.int16), sr)
-        result_array, sample_rate = converter.generate_from_cache(
+        result_array, _ = converter.generate_from_cache(
             audio_data=data,
             tag=random_tag,
         )
         
         if first_output_latency == 0:
-            first_output_latency = time.time()
+            first_output_latency = time.time()  # Track when the first output happens
         
-        output = torch.tensor(result_array, dtype=torch.float32)
-        output = output.squeeze(0).numpy()
+        # Convert the result array to numpy and append to the ongoing output
+        output_chunk = torch.tensor(result_array, dtype=torch.float32).squeeze(0).numpy()
+        output_state = np.concatenate((output_state, output_chunk))
     
-    return (audio[0], output), buffer_state
+    # Return the updated output state for continuous playback
+    return (sr, output_state), output_state
 
 # Gradio interface setup
 with gr.Blocks() as demo:
     audio_input = gr.Audio(sources="microphone", streaming=True, type="numpy", label="Input Audio")
     audio_output = gr.Audio(label="Output Audio")
-    buffer_state = gr.State()
+    output_state = gr.State()
     
-    audio_input.stream(process_audio_chunk, inputs=[audio_input, buffer_state], outputs=[audio_output, buffer_state])
+    audio_input.stream(process_audio_chunk, inputs=[audio_input, output_state], outputs=[audio_output, output_state])
 
 demo.launch()