Update app.py

app.py

@@ -3,24 +3,22 @@ import asyncio
 import base64
 import io
 import cv2
-import pyaudio
+import sounddevice as sd
+import numpy as np
 import PIL.Image
 import mss
 from google import genai
 from google.genai import types
+import soundfile as sf
 
 # Configuration
-FORMAT = pyaudio.paInt16
-CHANNELS = 1
-SEND_SAMPLE_RATE = 16000
-RECEIVE_SAMPLE_RATE = 24000
+SAMPLE_RATE = 24000
 CHUNK_SIZE = 1024
 MODEL = "models/gemini-2.0-flash-exp"
 
 class GeminiTTS:
     def __init__(self, api_key):
         self.client = genai.Client(http_options={"api_version": "v1alpha"}, api_key=api_key)
-        self.pya = pyaudio.PyAudio()
         self.audio_in_queue = asyncio.Queue()
         self.out_queue = asyncio.Queue(maxsize=5)
         self.session = None
@@ -61,6 +59,21 @@ class GeminiTTS:
         image_io.seek(0)
         return {"mime_type": "image/jpeg", "data": base64.b64encode(image_io.read()).decode()}
 
+    async def record_audio(self, duration=5):
+        """Record audio using sounddevice"""
+        print(f"Recording for {duration} seconds...")
+        recording = sd.rec(int(duration * SAMPLE_RATE), 
+                          samplerate=SAMPLE_RATE, 
+                          channels=1, 
+                          dtype='float32')
+        sd.wait()  # Wait until recording is finished
+        return recording
+
+    async def play_audio(self, audio_data):
+        """Play audio using sounddevice"""
+        sd.play(audio_data, samplerate=SAMPLE_RATE)
+        sd.wait()  # Wait until playback is finished
+
     async def process_input(self, text=None, mode="text"):
         try:
             async with self.client.aio.live.connect(model=MODEL, config=self.config) as session:
@@ -83,7 +96,11 @@ class GeminiTTS:
                 turn = session.receive()
                 async for response in turn:
                     if data := response.data:
-                        return data
+                        # Save audio to buffer
+                        with io.BytesIO() as wav_buffer:
+                            sf.write(wav_buffer, data, SAMPLE_RATE, format='WAV')
+                            wav_buffer.seek(0)
+                            return (SAMPLE_RATE, wav_buffer.read())
                     if text := response.text:
                         return text
                 
@@ -105,18 +122,27 @@ def create_gradio_interface():
         
         result = await tts_handler.process_input(text, mode)
         
-        if isinstance(result, bytes):
-            # Audio response
-            with io.BytesIO() as wav_buffer:
-                wav_buffer.write(result)
-                wav_buffer.seek(0)
-                return (RECEIVE_SAMPLE_RATE, wav_buffer.read())
+        if isinstance(result, tuple) and len(result) == 2:
+            # Audio response (sample_rate, audio_data)
+            return result
         else:
             # Text response
             return result
 
+    async def record_and_process():
+        if not tts_handler:
+            raise gr.Error("Please initialize the TTS system first with your API key")
+        
+        # Record audio
+        recording = await tts_handler.record_audio(duration=5)
+        
+        # Process audio (you would need to implement this part)
+        # For now, we'll just play it back
+        await tts_handler.play_audio(recording)
+        return (SAMPLE_RATE, recording.tobytes())
+
     with gr.Blocks(title="Gemini TTS Interface") as demo:
-        gr.Markdown("# 🎤 Gemini Text-to-Speech Interface")
+        gr.Markdown("# 🎤 Gemini Text-to-Speech Interface with SoundDevice")
         
         with gr.Row():
             api_key = gr.Textbox(label="Gemini API Key", type="password")
@@ -133,6 +159,11 @@ def create_gradio_interface():
             text_output = gr.Audio(label="Generated Speech")
             text_btn.click(generate_response, inputs=[text_input, gr.Text("text", visible=False)], outputs=text_output)
         
+        with gr.Tab("Voice Input"):
+            record_btn = gr.Button("Record and Process (5 sec)")
+            voice_output = gr.Audio(label="Processed Audio")
+            record_btn.click(record_and_process, outputs=voice_output)
+        
         with gr.Tab("Camera Input"):
             camera_btn = gr.Button("Capture and Process")
             camera_output = gr.Audio(label="Generated Speech from Camera")