xxx

app.py

@@ -42,39 +42,54 @@ conversation = ConversationChain(
     memory=memory,
 )
 
-def play_mp3(file_path):
-    pygame.mixer.init()
-    pygame.mixer.music.load(file_path)
-    pygame.mixer.music.play()
-
-def play_mp3_audio(path):
-    with open(path, 'rb') as f:
-        audio_data = f.read()
-    gr.Audio(audio_data)
-
-def play_wav_audio(wav_file):
-    # open the wave file
-    wf = wave.open(wav_file, 'rb')
-
-    # instantiate PyAudio
-    p = pyaudio.PyAudio()
-
-    # open a stream
-    stream = p.open(format=p.get_format_from_width(wf.getsampwidth()),
-                    channels=wf.getnchannels(),
-                    rate=wf.getframerate(),
-                    output=True)
-
-    # read data from the wave file and play it
-    data = wf.readframes(1024)
-    while data:
-        stream.write(data)
-        data = wf.readframes(1024)
-
-    # close the stream and terminate PyAudio
-    stream.stop_stream()
-    stream.close()
-    p.terminate()
+AUDIO_PATH = ''
+CHUNK_SIZE = 1024 * 8
+REGION = "us-west-2"
+transcript_text = ''
+transcriptions = []
+
+class MyEventHandler(TranscriptResultStreamHandler):
+    def __init__(self, transcript_result_stream):
+            super().__init__(transcript_result_stream)
+            self.transcriptions = []
+    async def handle_transcript_event(self, transcript_event: TranscriptEvent):
+        # This handler can be implemented to handle transcriptions as needed.
+        # Here's an example to get started.
+        results = transcript_event.transcript.results
+        for result in results:
+            for alt in result.alternatives:
+                print(alt.transcript)
+                transcriptions.append(alt.transcript)
+
+
+async def basic_transcribe():
+    # Setup up our client with our chosen AWS region
+    client = TranscribeStreamingClient(region=REGION)
+
+    # Start transcription to generate our async stream
+    stream = await client.start_stream_transcription(
+        language_code="zh-CN",
+        media_sample_rate_hz=SAMPLE_RATE,
+        media_encoding="pcm",
+    )
+
+    async def write_chunks():
+        # NOTE: For pre-recorded files longer than 5 minutes, the sent audio
+        # chunks should be rate limited to match the realtime bitrate of the
+        # audio stream to avoid signing issues.
+        async with aiofile.AIOFile(AUDIO_PATH, "rb") as afp:
+            reader = aiofile.Reader(afp, chunk_size=CHUNK_SIZE)
+            await apply_realtime_delay(
+                stream, reader, BYTES_PER_SAMPLE, SAMPLE_RATE, CHANNEL_NUMS
+            )
+        await stream.input_stream.end_stream()
+
+    # Instantiate our handler and start processing events
+    handler = MyEventHandler(stream.output_stream)
+    await asyncio.gather(write_chunks(), handler.handle_events())
+    # Retrieve the transcriptions from the handler
+    #transcriptions = handler.transcriptions
+
 
 def download_file(bucket_name, object_key, file_path):
     try:
@@ -151,7 +166,27 @@ def predict(input, history=[]):
     print("all historical responses: "+str(responses))
     return responses, audio_file, history
 
-def transcribe_func(audio):
+def transcribe_func_new(audio):
+    audio_file = open(audio, "rb")
+    wav_file = audio_file.name
+    print("audio_file: "+wav_file)
+    #transcript = openai.Audio.transcribe("whisper-1", audio_file)
+    #return transcript['text']
+    
+    pcm_file = os.path.splitext(wav_file)[0] + ".pcm"
+
+    wav_to_pcm(wav_file, pcm_file)
+    AUDIO_PATH=pcm_file
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(basic_transcribe())
+    loop.close()
+
+    transcript_text = transcriptions[-1]
+    print("final transcribe script: "+transcript_text)
+    return transcript_text    
+
+def transcribe_func_old(audio):
     audio_file = open(audio, "rb")
     file_name = audio_file.name
     #file_directory = os.path.dirname(audio_file.name)