Update app.py

app.py

@@ -1,76 +1,27 @@
 import gradio as gr
-import torch
 import numpy as np
-import datetime
 import time
-from infer_rvc_python import BaseLoader
 
-# Initialize the model
-now = datetime.datetime.now()
-timestamp = now.strftime("%Y-%m-%d_%H-%M-%S")
-random_tag = "USER_" + str(timestamp)
+def add_to_stream(audio, instream):
+    time.sleep(1)
+    if audio is None:
+        return gr.update(), instream
+    if instream is None:
+        ret = audio
+    else:
+        ret = (audio[0], np.concatenate((instream[1], audio[1])))
+    return ret, ret
 
-converter = BaseLoader(only_cpu=True, hubert_path='./hubert_base.pt', rmvpe_path='./rmvpe.pt')
-converter.apply_conf(
-    tag=random_tag,
-    file_model="./model.pth",
-    pitch_algo="rmvpe+",
-    pitch_lvl=0,
-    file_index="./model.index",
-    index_influence=0.80,
-    respiration_median_filtering=3,
-    envelope_ratio=0.25,
-    consonant_breath_protection=0.5,
-    resample_sr=0, 
-)
 
-chunk_sec = 0.1
-sr = 16000
-chunk_len = int(sr * chunk_sec)
-L = 16
-first_output_latency = 0
+with gr.Blocks() as demo:
+    inp = gr.Audio(source="microphone")
+    out = gr.Audio()
+    stream = gr.State()
+    clear = gr.Button("Clear")
 
-# Function to process and play audio chunks
-def process_audio_chunk(audio, output_state):
-    global first_output_latency
-    
-    if output_state is None:
-        output_state = np.zeros(0, dtype=np.float32)
-    
-    if audio is None:
-        return None, output_state
-    
-    # Convert input audio to tensor
-    audio_data = torch.tensor(audio[1], dtype=torch.float32)
-    
-    if len(audio_data) < chunk_len:
-        return None, output_state
-    
-    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, _ = converter.generate_from_cache(
-            audio_data=data,
-            tag=random_tag,
-        )
-        
-        if first_output_latency == 0:
-            first_output_latency = time.time()  # Track when the first output happens
-        
-        # 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 the updated output state for continuous playback
-    return (sr, output_state), output_state
+    inp.stream(add_to_stream, [inp, stream], [out, stream])
+    clear.click(lambda: [None, None, None], None, [inp, out, stream])
 
-# 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")
-    output_state = gr.State()
-    
-    audio_input.stream(process_audio_chunk, inputs=[audio_input, output_state], outputs=[audio_output, output_state])
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()