Envoyer des flux audio et vidéo

Ce document explique comment envoyer des flux audio et vidéo à l'API Live pour une communication bidirectionnelle en temps réel avec les modèles Gemini. Découvrez comment configurer et transmettre des données audio et vidéo pour créer des applications dynamiques et interactives.

Envoyer des flux audio

L'implémentation de l'audio en temps réel nécessite un respect strict des spécifications de fréquence d'échantillonnage et une gestion minutieuse des tampons pour garantir une faible latence et une interruptibilité naturelle.

L'API Live est compatible avec les formats audio suivants :

  • Audio d'entrée : audio PCM 16 bits brut à 16 kHz, little-endian
  • Sortie audio : audio PCM 16 bits brut à 24 kHz, little-endian

L'exemple de code suivant vous montre comment envoyer des données audio en streaming :

import asyncio
# Assumes session is an active Live API session
# and chunk_data contains bytes of raw 16-bit PCM audio at 16 kHz.
from google.genai import types
# Send audio input data in chunks
await session.send_realtime_input(
    audio=types.Blob(data=chunk_data, mime_type="audio/pcm;rate=16000")
)

Le client doit maintenir un tampon de lecture. Le serveur diffuse l'audio par blocs dans des messages server_content. Le client est responsable du décodage, de la mise en mémoire tampon et de la lecture des données.

L'exemple de code suivant vous montre comment traiter les données audio en streaming :

import asyncio
# Assumes session is an active Live API session
# and audio_queue is an asyncio.Queue for buffering audio for playback.
import numpy as np

async for msg in session.receive():
    server_content = msg.server_content
    if server_content:
        # 1. Handle Interruption
        if server_content.interrupted:
            print("\n[Interrupted] Flushing buffer...")
            # Clear the Python queue
            while not audio_queue.empty():
                try: audio_queue.get_nowait()
                except asyncio.QueueEmpty: break
            # Send signal to worker to reset hardware buffers if needed
            await audio_queue.put(None)
            continue

        # 2. Process Audio chunks
        if server_content.model_turn:
            for part in server_content.model_turn.parts:
                if part.inline_data:
                    # Add PCM data to playback queue
                    await audio_queue.put(np.frombuffer(part.inline_data.data, dtype='int16'))

Envoyer des flux vidéo

Le streaming vidéo fournit un contexte visuel. L'API Live attend une séquence d'images distinctes et accepte les images vidéo à 1 FPS. Pour de meilleurs résultats, utilisez la résolution native de 768 x 768 à 1 FPS.

L'exemple de code suivant montre comment envoyer des données vidéo en streaming :

import asyncio
# Assumes session is an active Live API session
# and chunk_data contains bytes of a JPEG image.
from google.genai import types
# Send video input data in chunks
await session.send_realtime_input(
    media=types.Blob(data=chunk_data, mime_type="image/jpeg")
)

L'implémentation du client capture un frame du flux vidéo, l'encode en tant que blob JPEG et le transmet à l'aide de la structure de message realtime_input.

import cv2
import asyncio
from google.genai import types

async def send_video_stream(session):
    # Open webcam
    cap = cv2.VideoCapture(0)

    while True:
        ret, frame = cap.read()
        if not ret: break

        # 1. Resize to optimal resolution (768x768 max)
        frame = cv2.resize(frame, (768, 768))

        # 2. Encode as JPEG
        _, buffer = cv2.imencode('.jpg', frame,)

        # 3. Send as realtime input
        await session.send_realtime_input(
            media=types.Blob(data=buffer.tobytes(), mime_type="image/jpeg")
        )

        # 4. Wait 1 second (1 FPS)
        await asyncio.sleep(1.0)

    cap.release()

Configurer la résolution du contenu multimédia

Vous pouvez spécifier la résolution du contenu multimédia d'entrée en définissant le champ media_resolution dans la configuration de la session. Une résolution plus faible réduit l'utilisation de jetons et la latence, tandis qu'une résolution plus élevée améliore la reconnaissance des détails. Les valeurs autorisées incluent low, medium et high.

config = {
    "response_modalities": ["audio"],
    "media_resolution": "low",
}

Étapes suivantes