Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

Peux-tu améliorer ce script ? J'aimerais stacker les audios obtenus via chunk["data"] en…

  1. User

    Peux-tu améliorer ce script ? J'aimerais stacker les audios obtenus via chunk["data"] en groupes de 0.5 seconde, et jouer les audio générer l'un après l'autre.

    Voici le process : Génère 0.5s d'audio, joue immédiatement ces 0.5s d'audio tout en préparant les 0.5s d'audio suivant, afin de jouer le tout de manière parfaitement fluide.

    import asyncio import edge_tts import pyaudio from io import BytesIO from pydub import AudioSegment

    TEXT = "Bonjour ! Ça va bien !" VOICE = "en-US-JennyNeural"

    Initialize PyAudio

    p = pyaudio.PyAudio()

    Async function to perform Text-to-Speech streaming

    async def stream_tts(text: str, voice: str) -> None: communicate = edge_tts.Communicate(text, voice)

    # Open audio stream based on audio properties
    stream = p.open(
        format=p.get_format_from_width(2),
        channels=1,
        rate=24000,
        output=True
    )
    
    # Process and combine audio chunks as they arrive
    async for chunk in communicate.stream():
        if chunk["type"] == "audio":
            audio_segment = AudioSegment.from_mp3(BytesIO(chunk["data"]))
            stream.write(audio_segment.raw_data)
            
            if chunk.get("end", False):
                break
    
    # Stop and close the stream
    stream.stop_stream()
    stream.close()
    
    # Cleanup PyAudio
    p.terminate()
    

    Main function

    if name == "main": # Run the asyncio event loop asyncio.run(stream_tts(TEXT, VOICE))

  2. Assistant

    Pour jouer le son généré de manière fluide en accumulant des blocs de 0.5 seconde, nous devons ajouter une logique de buffering et de lecture simultanée. Pour cela, nous allons utiliser une queue (asyncio.Queue) qui servira de tampon entre la génération des blocs de son et leur lecture. L'idée est de toujours avoir un bloc de son prêt dans la queue pour s'assurer que la lecture soit fluide.

    Voici une version améliorée du script avec les modifications pour accumuler des morceaux de 0.5 seconde et les jouer de manière fluide :

    import asyncio
    import edge_tts
    import pyaudio
    from io import BytesIO
    from pydub import AudioSegment
    from pydub.playback import play
    
    TEXT = "Bonjour ! Ça va bien !"
    VOICE = "en-US-JennyNeural"
    
    # Initialize PyAudio
    p = pyaudio.PyAudio()
    
    # Audio buffer (in ms)
    BUFFER_MS = 500  # On souhaite accumuler des blocs de 0.5 seconde
    SAMPLE_RATE_HZ = 24000  # Exemple de fréquence d'échantillonnage
    CHANNELS = 1 
    BYTE_WIDTH = 2  # 2 bytes pour pyaudio.paInt16
    
    # Fonction asynchrone pour streamer le Text-to-Speech et jouer le son
    async def stream_and_play_tts(text: str, voice: str) -> None:
        communicate = edge_tts.Communicate(text, voice)
        
        # Open audio stream based on audio properties
        stream = p.open(
            format=p.get_format_from_width(BYTE_WIDTH),
            channels=CHANNELS,
            rate=SAMPLE_RATE_HZ,
            output=True
        )
    
        # On crée une Queue pour stocker les chunks audio à jouer
        audio_queue = asyncio.Queue()
    
        # Nous avons besoin d'une coroutine pour lire et jouer les chunks audio
        async def audio_player():
            # Lire les chunks audio et les jouer l'un après l'autre
            while True:
                chunk_audio = await audio_queue.get()
                if chunk_audio is None:
                    # Stop condition received, break the loop
                    break
                play(chunk_audio)
                audio_queue.task_done()
            
        # Démarre le 'audio_player' comme une coroutine séparée
        player_task = asyncio.create_task(audio_player())
    
        async for chunk in communicate.stream():
            if "data" in chunk:
                audio_segment = AudioSegment.from_mp3(BytesIO(chunk["data"]))
                # On accumule les chunks audio jusqu'à ce qu'on ait 0.5s de données
                if not audio_queue.full():
                    await audio_queue.put(audio_segment.raw_data)
    
                if chunk.get("end", False):
                    # Indicate to the player that there will be no more chunks
                    await audio_queue.put(None)
                    break
    
        # Await for the 'audio_player' to finish playing to ensure smooth playback
        await player_task
    
        # Stop and close the stream
        stream.stop_stream()
        stream.close()
    
        # Cleanup PyAudio
        p.terminate()
    
    # Main function
    if __name__ == "__main__":
        # Run the asyncio event loop
        asyncio.run(stream_and_play_tts(TEXT, VOICE))
    

    Notez que la taille du buffer peut ne pas correspondre exactement à 0.5 seconde, cela dépendra des données réelles de l'audio produit par le TTS. Et, dans ce script, nous ne traitons pas explicitement des blocs de 0.5 seconde, car cela dépendrait de la durée des données audio dans chaque chunk["data"]. Vous pourriez avoir besoin d'une logique supplémentaire pour combiner correctement les fragments de façon à ce que chaque lecture soit exactement de 0.5 seconde si les fragments ne correspondent pas à cette durée.