Generowanie tekstu na mowę (TTS) za pomocą interfejsu Gemini API


Możesz użyć modelu TTS Gemini (gemini-3.8-flash-tts lub gemini-3.8-flash-lite-tts), aby syntetyzować naturalną, ekspresyjną mowę (dźwięk) z tekstu. Gdy używasz Firebase AI Logic, możesz wysłać to żądanie bezpośrednio z aplikacji mobilnej lub internetowej (np. Apple (Swift), Android (Kotlin/Java), Web (JavaScript), Flutter (Dart) lub Unity).

Generowanie zamiany tekstu na mowę (TTS) jest kontrolowane, co oznacza, że podajesz dokładny tekst do syntezy mowy, jednocześnie kierując sposobem przekazywania – np. emocjami, tempem, głosami mówiących i dźwiękami innymi niż mowa, takimi jak śmiech czy westchnienia – za pomocą uporządkowanych metadanych i wbudowanych tagów głosowych. Można powiedzieć, że TTS to przeciwieństwo transkrypcji (zamiany mowy na tekst).

Dzięki tej funkcji możesz tworzyć takie funkcje jak:

  • Interaktywne opowiadanie historii i audiobooki: czytaj długie opowiadania lub prowadź gry fabularne, w których postacie zmieniają głosy, reagują na siebie, wchodząc sobie w słowo, i dostosowują sposób wypowiedzi do emocji (np. szepczą w momencie napięcia lub śmieją się z żartu).
  • Agenty głosowe i asystenci o krótkim czasie oczekiwania: przesyłaj strumieniowo syntezowaną mowę, gdy tylko tekst zostanie wygenerowany przez LLM, zachowując spójny głos podczas rozmowy.
  • Czytniki treści wielojęzycznych i nauczyciele języków: czytaj na głos artykuły, przepisy lub materiały do nauki w ponad 130 językach i akcentach regionalnych lub płynnie przełączaj języki w ramach jednej rozmowy.

Z tego przewodnika dowiesz się, jak generować mowę jednego lub wielu rozmówców, przesyłać strumieniowo odpowiedzi audio, kierować wypowiedziami za pomocą tagów SpeechMetadata i tagów wbudowanych oraz wybierać głosy gotowe, z biblioteki lub niestandardowe.

Przejdź do kodu dla jednego rozmówcy Przejdź do kodu dla wielu rozmówców Przejdź do kodu strumieniowego

Porównanie TTS i Live API

Zarówno modele zamiany tekstu na mowę (TTS), jak i modele Live API to modele generujące mowę o niskim opóźnieniu, które można skonfigurować pod kątem różnych głosów i języków odpowiedzi. Służą jednak do bardzo różnych celów.

  • Generowanie zamiany tekstu na mowę (TTS) to jednokierunkowa interakcja typu żądanie-odpowiedź (tekst na wejściu, dźwięk na wyjściu). Jest on dostosowany do scenariuszy, które wymagają dokładnego odczytania podanego tekstu z precyzyjną kontrolą nad stylem i dźwiękiem, takich jak narracja podcastu, audiobooki czy czytanie artykułów na głos.

  • Generowanie Live API obsługuje dwukierunkowe strumieniowanie na potrzeby rozmów głosowych w czasie rzeczywistym (głos na wejściu i wyjściu). Doskonale sprawdza się w dynamicznych kontekstach konwersacyjnych, w których model decyduje o tym, jaką mowę zwrócić. Pamiętaj, że najnowsze modele Live API obsługują też dane wejściowe w postaci filmów i obrazów.

Zanim zaczniesz

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dotyczące tego dostawcy.

Jeśli jeszcze nie korzystasz z Firebase, zapoznaj się z przewodnikiem dla początkujących, który opisuje, jak skonfigurować projekt w Firebase, połączyć aplikację z Firebase, dodać pakiet SDK, zainicjować usługę backendu dla wybranego dostawcy Gemini API i utworzyć instancję GenerativeModel.

Do testowania i ulepszania promptów zalecamy używanie Google AI Studio.

Modele obsługujące tę funkcję

  • gemini-3.8-flash-tts
  • gemini-3.8-flash-lite-tts
Porównanie modeli TTS

Oba modele Gemini 3.x TTS mają ten sam schemat żądania i format promptu. Oto kilka różnic, które mogą wpłynąć na wybór modelu.

Funkcja lub zbiór zadań gemini-3.8-flash-tts gemini-3.8-flash-lite-tts
Główna zaleta Głos o jakości studyjnej, niuanse aktorskie i szeroki zakres dialektów Wysoka przepustowość, krótki czas oczekiwania i opłacalność
Najlepsze zastosowania Audiobooki, narracja studyjna, złożone dialogi z wieloma rozmówcami, częste tagi wybuchów wokalnych, trudna wymowa, dialekty regionalne Produkcja na dużą skalę, kaskady agentów głosowych działających w czasie rzeczywistym, funkcje interfejsu do czytania na głos, codzienna mowa jednego mówcy
Obsługiwane języki 132 języki 103 języki

Generowanie mowy na podstawie tekstu

Możesz wygenerować mowę z tekstu wprowadzonego w postaci głosu jednego mówcy lub dialogu 2 mówców, jako kompletny plik WAV (generateContent) lub jako nieprzetworzony strumień audio PCM o niskim opóźnieniu (generateContentStream).

Generowanie mowy z jednym rozmówcą

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji kliknij też przycisk wybranego dostawcy Gemini API, aby na tej stronie wyświetlić treści dotyczące tego dostawcy.

Aby wygenerować dźwięk z jednym rozmówcą:

  1. W pliku GenerationConfig ustaw responseModalities na AUDIO i skonfiguruj SpeechConfig w ten sposób:

  2. Utwórz TextPart z tymi ustawieniami:

    • (Wymagane) Dosłowna transkrypcja tekstu, który ma zostać odczytany.

    • (Opcjonalnie) SpeechMetadata z opisem style (na przykład "cheerful and friendly").

  3. Zadzwoń pod numer generateContent. Domyślnie żądania jednoargumentowe zwracają kompletny plik audio WAV (audio/wav) (16-bitowy liniowy PCM, 24 kHz, mono, ze standardowym 44-bajtowym nagłówkiem RIFF) we wbudowanych częściach danych odpowiedzi.

Swift


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Set `responseModalities` to include `.audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: SpeechConfig(voiceName: "Kore", languageCode: "en-US")
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
)

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
  "Have a wonderful day!",
  speechMetadata: SpeechMetadata(style: "cheerful and friendly")
)

// Call `generateContent` to generate the speech output.
let response = try await model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let wavData = part.data       // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  let mimeType = part.mimeType  // for example: "audio/wav"
  print("Received audio data with MIME type: \(mimeType)")

  // Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
  playAudio(data: wavData)
}

Kotlin

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszania i muszą być wywoływane z zakresu współprogramu.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = SpeechConfig(
        voice = Voice("Kore"),
        languageCode = "en-US"
    )
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.8-flash-tts",
        generationConfig = config
    )

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
    text(
        text = "Have a wonderful day!",
        speechMetadata = SpeechMetadata(style = "cheerful and friendly")
    )
}

// Call `generateContent` to generate the speech output.
val response = model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val wavData = part.inlineData  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

    // Pass the audio data to your audio player or playback helper (which you'll need to implement).
    playAudio(wavData)
}

Java

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki Reactive Streams.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(new SpeechConfig(new Voice("Kore"), "en-US"))
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash-tts", config);

// Use the GenerativeModelFutures Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
    .addText("Have a wonderful day!", new SpeechMetadata(null, "cheerful and friendly"))
    .build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output.
// Extract the WAV audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        Part part = result.getCandidates().get(0).getContent().getParts().get(0);
        if (part instanceof InlineDataPart) {
            byte[] wavData = ((InlineDataPart) part).getInlineData();  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

            // Pass the audio data to your audio player or playback helper (which you'll need to implement).
            playAudio(wavData);
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } },
    languageCode: "en-US"
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.8-flash-tts",
  generationConfig
});

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
  {
    type: "text",
    text: "Have a wonderful day!",
    speechMetadata: { style: "cheerful and friendly" }
  }
];

// Call `generateContent` to generate the speech output.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the WAV audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const wavBase64 = inlineDataParts[0].inlineData.data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  // Decode base64 to ArrayBuffer
  const wavBuffer = Uint8Array.from(atob(wavBase64), c => c.charCodeAt(0)).buffer;

  // The response is a complete WAV file, so the Web Audio API can decode and play it directly.
  const audioCtx = new AudioContext();
  const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
  const source = audioCtx.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioCtx.destination);
  source.start();
}

Dart


import 'package:firebase_ai/firebase_ai.dart';

// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
  responseModalities: [ResponseModalities.audio],
  speechConfig: SpeechConfig(voiceName: 'Kore', languageCode: 'en-US'),
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.8-flash-tts',
  generationConfig: config,
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
  TextPart(
    'Have a wonderful day!',
    speechMetadata: SpeechMetadata(style: 'cheerful and friendly'),
  ),
]);

// Call `generateContent` to generate the speech output.
final response = await model.generateContent([prompt]);

// Extract the WAV audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
  final Uint8List wavData = part.bytes;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

  // Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
  await playAudio(wavData);
}

Unity


using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Set `responseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name and language code.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: SpeechConfig.UsePrebuiltVoice("Kore", "en-US")
);

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
  new ModelContent.TextPart(
    "Have a wonderful day!",
    new SpeechMetadata(speaker: null, style: "cheerful and friendly")
  )
);

// Call `GenerateContentAsync` to generate the speech output.
var response = await model.GenerateContentAsync(prompt);

// Extract the WAV audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
  foreach (var part in response.Candidates[0].Content.Parts) {
    if (part is ModelContent.InlineDataPart inlineData) {
      byte[] wavData = inlineData.Data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

      // Pass the audio data to your audio player or playback helper (which you'll need to implement).
      PlayAudio(wavData);
    }
  }
}

Generowanie mowy z wieloma rozmówcami

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji kliknij też przycisk wybranego dostawcy Gemini API, aby na tej stronie wyświetlić treści dotyczące tego dostawcy.

Możesz wygenerować naturalną rozmowę między 2 osobami w jednym żądaniu, przypisując każdemu rozmówcy inny głos i przekazując każdą kwestię dialogową jako osobny element TextPart:

  1. Utwórz obiekt MultiSpeakerVoiceConfig, który mapuje 2 nazwy rozmówców (np. "Joe" i "Jane") na ich SpeakerVoiceConfig głosy.

  2. W pliku GenerationConfig ustaw responseModalities na AUDIO i przekaż MultiSpeakerVoiceConfig (oraz opcjonalnie languageCode) do SpeechConfig.

  3. Podaj tablicę lub listę obiektów TextPart, konkretnie po jednym obiekcie TextPart na każdą turę dialogu. Na każdym urządzeniu TextPart ustaw SpeechMetadata w ten sposób:

    • (Wymagany) speaker, który pasuje do jednej z nazw rozmówców zdefiniowanych w MultiSpeakerVoiceConfig.
    • (Opcjonalnie) Opis style (np. "cheerful and friendly").
  4. Zadzwoń pod numer generateContent. Model syntetyzuje całą rozmowę i zwraca pełny plik audio WAV (audio/wav).

Swift


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
let multiSpeechConfig = SpeechConfig(
  multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
    speakerVoiceConfigs: [
      SpeakerVoiceConfig(speaker: "Joe", voiceName: "Puck"),
      SpeakerVoiceConfig(speaker: "Jane", voiceName: "Kore")
    ]
  ),
  languageCode: "en-US"
)

// Set `responseModalities` to include `.audio`.
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: multiSpeechConfig
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
)

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
let prompt: [any PartsRepresentable] = [
  TextPart(
    "How's it going today, Jane?",
    speechMetadata: SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
  ),
  TextPart(
    "Not too bad, how about you?",
    speechMetadata: SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
  )
]

// Call `generateContent` to generate the multi-speaker speech output.
let response = try await model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let wavData = part.data       // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  let mimeType = part.mimeType  // for example: "audio/wav"
  print("Received audio data with MIME type: \(mimeType)")

  // Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
  playAudio(data: wavData)
}

Kotlin

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszania i muszą być wywoływane z zakresu współprogramu.

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
val multiSpeechConfig = SpeechConfig(
    multiSpeakerVoiceConfig = MultiSpeakerVoiceConfig(
        speakerVoiceConfigs = listOf(
            SpeakerVoiceConfig(speaker = "Joe", voice = Voice("Puck")),
            SpeakerVoiceConfig(speaker = "Jane", voice = Voice("Kore"))
        )
    ),
    languageCode = "en-US"
)

// Set `responseModalities` to include `AUDIO`.
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = multiSpeechConfig
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.8-flash-tts",
        generationConfig = config
    )

// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
val prompt = content {
    text(
        text = "How's it going today, Jane?",
        speechMetadata = SpeechMetadata(speaker = "Joe", style = "cheerful and friendly")
    )
    text(
        text = "Not too bad, how about you?",
        speechMetadata = SpeechMetadata(speaker = "Jane", style = "calm and relaxed")
    )
}

// Call `generateContent` to generate the multi-speaker speech output.
val response = model.generateContent(prompt)

// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val wavData = part.inlineData  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

    // Pass the audio data to your audio player or playback helper (which you'll need to implement).
    playAudio(wavData)
}

Java

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki Reactive Streams.

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
MultiSpeakerVoiceConfig multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
    Arrays.asList(
        new SpeakerVoiceConfig("Joe", new Voice("Puck")),
        new SpeakerVoiceConfig("Jane", new Voice("Kore"))
    )
);

SpeechConfig multiSpeechConfig = new SpeechConfig(multiSpeakerVoiceConfig, "en-US");

// Set `responseModalities` to include `AUDIO`.
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(multiSpeechConfig)
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash-tts", config);

// Use the `GenerativeModelFutures` Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
Content content = new Content.Builder()
    .addText(
        "How's it going today, Jane?",
        new SpeechMetadata("Joe", "cheerful and friendly"))
    .addText(
        "Not too bad, how about you?",
        new SpeechMetadata("Jane", "calm and relaxed"))
    .build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the multi-speaker speech output.
// Extract the WAV audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        Part part = result.getCandidates().get(0).getContent().getParts().get(0);
        if (part instanceof InlineDataPart) {
            byte[] wavData = ((InlineDataPart) part).getInlineData();  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

            // Pass the audio data to your audio player or playback helper (which you'll need to implement).
            playAudio(wavData);
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    multiSpeakerVoiceConfig: {
      speakerVoiceConfigs: [
        { speaker: "Joe", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Puck" } } },
        { speaker: "Jane", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } } }
      ]
    },
    languageCode: "en-US"
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.8-flash-tts",
  generationConfig
});

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `speechMetadata`.
const prompt = [
  {
    type: "text",
    text: "How's it going today, Jane?",
    speechMetadata: { speaker: "Joe", style: "cheerful and friendly" }
  },
  {
    type: "text",
    text: "Not too bad, how about you?",
    speechMetadata: { speaker: "Jane", style: "calm and relaxed" }
  }
];

// Call `generateContent` to generate the multi-speaker speech output.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the WAV audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const wavBase64 = inlineDataParts[0].inlineData.data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
  // Decode base64 to ArrayBuffer
  const wavBuffer = Uint8Array.from(atob(wavBase64), c => c.charCodeAt(0)).buffer;

  // The response is a complete WAV file, so the Web Audio API can decode and play it directly.
  const audioCtx = new AudioContext();
  const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
  const source = audioCtx.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioCtx.destination);
  source.start();
}

Dart


import 'package:firebase_ai/firebase_ai.dart';

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
final multiSpeechConfig = SpeechConfig.multiSpeaker(
  multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
    speakerVoiceConfigs: [
      SpeakerVoiceConfig(speaker: 'Joe', voiceName: 'Puck'),
      SpeakerVoiceConfig(speaker: 'Jane', voiceName: 'Kore'),
    ],
  ),
  languageCode: 'en-US',
);

// Set `responseModalities` to include `audio`.
final config = GenerationConfig(
  responseModalities: [ResponseModalities.audio],
  speechConfig: multiSpeechConfig,
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.8-flash-tts',
  generationConfig: config,
);

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
final prompt = Content.multi([
  TextPart(
    "How's it going today, Jane?",
    speechMetadata: SpeechMetadata(speaker: 'Joe', style: 'cheerful and friendly'),
  ),
  TextPart(
    'Not too bad, how about you?',
    speechMetadata: SpeechMetadata(speaker: 'Jane', style: 'calm and relaxed'),
  ),
]);

// Call `generateContent` to generate the multi-speaker speech output.
final response = await model.generateContent([prompt]);

// Extract the WAV audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
  final Uint8List wavData = part.bytes;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

  // Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
  await playAudio(wavData);
}

Unity


using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
var multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
  new System.Collections.Generic.List<SpeakerVoiceConfig> {
    SpeakerVoiceConfig.UsePrebuiltVoice("Joe", "Puck"),
    SpeakerVoiceConfig.UsePrebuiltVoice("Jane", "Kore")
  }
);

var multiSpeechConfig = SpeechConfig.UseMultiSpeakerVoice(multiSpeakerVoiceConfig, "en-US");

// Set `responseModalities` to include `Audio`.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: multiSpeechConfig
);

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
);

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
var prompt = new ModelContent(
  new ModelContent.TextPart(
    "How's it going today, Jane?",
    new SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
  ),
  new ModelContent.TextPart(
    "Not too bad, how about you?",
    new SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
  )
);

// Call `GenerateContentAsync` to generate the multi-speaker speech output.
var response = await model.GenerateContentAsync(prompt);

// Extract the WAV audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
  foreach (var part in response.Candidates[0].Content.Parts) {
    if (part is ModelContent.InlineDataPart inlineData) {
      byte[] wavData = inlineData.Data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

      // Pass the audio data to your audio player or playback helper (which you'll need to implement).
      PlayAudio(wavData);
    }
  }
}

Odpowiadaj na bieżąco

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji kliknij też przycisk wybranego dostawcy Gemini API, aby na tej stronie wyświetlić treści dotyczące tego dostawcy.

Aby skrócić czas do pierwszego dźwięku (TTFA) i odtwarzać dźwięk w czasie rzeczywistym, możesz przesyłać strumieniowo odpowiedź audio w miarę jej generowania, zamiast czekać na zakończenie całego klipu. Strumieniowanie działa zarówno w przypadku konfiguracji z 1 głośnikiem, jak i z wieloma głośnikami.

Aby przesyłać mowę, wywołaj generateContentStream zamiast generateContent. W przeciwieństwie do żądań jednoargumentowych (które zwracają plik WAV) żądania strumieniowe zwracają nieprzetworzone 16-bitowe fragmenty PCM bez nagłówka (audio/l16, 24 kHz, mono), dzięki czemu możesz dołączyć każdy fragment bezpośrednio do bufora wyjściowego audio.

Swift


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Set `responseModalities` to include `.audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: SpeechConfig(voiceName: "Kore")
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.8-flash-tts",
  generationConfig: config
)

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
  "Tell me a story about a brave knight.",
  speechMetadata: SpeechMetadata(style: "warm, engaging audiobook narrator")
)

// Call `generateContentStream` to stream the speech output as it is generated.
let responseStream = try model.generateContentStream(prompt)

// Extract the raw PCM audio chunks and queue them for playback:
for try await chunk in responseStream {
  for part in chunk.inlineDataParts {
    let pcmChunk = part.data  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
    appendAudioChunk(pcmChunk)
  }
}

Kotlin

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszania i muszą być wywoływane z zakresu współprogramu.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = SpeechConfig(voice = Voice("Kore"))
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.8-flash-tts",
        generationConfig = config
    )

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
    text(
        text = "Tell me a story about a brave knight.",
        speechMetadata = SpeechMetadata(style = "warm, engaging audiobook narrator")
    )
}

// Call `generateContentStream` to stream the speech output as it is generated.
// Extract the raw PCM audio chunks and queue them for playback.
model.generateContentStream(prompt).collect { chunk ->
    val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
    if (part is InlineDataPart) {
        val pcmChunk = part.inlineData  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
        appendAudioChunk(pcmChunk)
    }
}

Java

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki Reactive Streams.

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(new SpeechConfig(new Voice("Kore")))
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash-tts", config);

// Use the `GenerativeModelFutures` Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
    .addText(
        "Tell me a story about a brave knight.",
        new SpeechMetadata(null, "warm, engaging audiobook narrator"))
    .build();

// Call `generateContentStream` to stream the speech output as it is generated.
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

// Extract the raw PCM audio chunks and queue them for playback.
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onSubscribe(Subscription s) {
      s.request(Long.MAX_VALUE);
  }

  @Override
  public void onNext(GenerateContentResponse chunk) {
      Part part = chunk.getCandidates().get(0).getContent().getParts().get(0);
      if (part instanceof InlineDataPart) {
          byte[] pcmChunk = ((InlineDataPart) part).getInlineData();  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

          // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
          appendAudioChunk(pcmChunk);
      }
  }

  @Override
  public void onComplete() {
      // Audio stream complete.
  }

  @Override
  public void onError(Throwable t) {
      t.printStackTrace();
  }
});

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } }
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.8-flash-tts",
  generationConfig
});

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
  {
    type: "text",
    text: "Tell me a story about a brave knight.",
    speechMetadata: { style: "warm, engaging audiobook narrator" }
  }
];

// Call `generateContentStream` to stream the speech output as it is generated.
const result = await model.generateContentStream(prompt);

// Extract the raw PCM audio chunks and queue them for playback:
const playbackQueue = [];
for await (const chunk of result.stream) {
  const inlineDataParts = chunk.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const pcmBase64 = inlineDataParts[0].inlineData.data;  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
    const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

    // Append the audio chunk to your audio queue/buffer for playback.
    // In a real app, start playing chunks as they arrive (rather than waiting for
    // the whole stream to finish) to get the low-latency benefit of streaming.
    playbackQueue.push(pcmBuffer);
  }
}

// To play back an array of PCM buffers in sequence, pass them to your playback helper (which you'll need to write).
processPlaybackQueue(playbackQueue);

Dart


import 'package:firebase_ai/firebase_ai.dart';

// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
  responseModalities: [ResponseModalities.audio],
  speechConfig: SpeechConfig(voiceName: 'Kore'),
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.8-flash-tts',
  generationConfig: config,
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
  TextPart(
    'Tell me a story about a brave knight.',
    speechMetadata: SpeechMetadata(style: 'warm, engaging audiobook narrator'),
  ),
]);

// Call `generateContentStream` to stream the speech output as it is generated.
final responseStream = model.generateContentStream([prompt]);

// Extract the raw PCM audio chunks and queue them for playback:
await for (final chunk in responseStream) {
  final part = chunk.candidates.first.content.parts.first;
  if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
    final Uint8List pcmChunk = part.bytes;  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
    appendAudioChunk(pcmChunk);
  }
}

Unity


using System.Collections.Generic;
using System.Linq;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Set `ResponseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
var config = new GenerationConfig(
    responseModalities: new List<ResponseModality> { ResponseModality.Audio },
    speechConfig: SpeechConfig.UsePrebuiltVoice("Kore")
);

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
    modelName: "gemini-3.8-flash-tts",
    generationConfig: config
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
    new ModelContent.TextPart(
        "Tell me a story about a brave knight.",
        new SpeechMetadata(speaker: null, style: "warm, engaging audiobook narrator")
    )
);

// Call `GenerateContentStreamAsync` to stream the speech output as it is generated.
var responseStream = model.GenerateContentStreamAsync(prompt);

// Extract the raw PCM audio chunks and queue them for playback:
await foreach (var response in responseStream)
{
    var audioParts = response.Candidates.FirstOrDefault().Content.Parts
                            .OfType<ModelContent.InlineDataPart>();

    foreach (var part in audioParts)
    {
        byte[] pcmChunk = part.Data; // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
        AppendAudioChunk(pcmChunk);
    }
}



Sterowanie odpowiedzią głosową za pomocą metadanych i tagów w tekście

Modele Gemini 3.x TTS traktują text wewnątrz każdego elementu TextPart ściśle jako dosłowną transkrypcję, która ma zostać odczytana na głos. Nie umieszczaj w ciągu tekstowym instrukcji narracyjnych (takich jak "Say cheerfully:"), ponieważ model może odczytać te słowa na głos.

Możesz kierować wykonaniem utworu, korzystając z tych technik:

Tagi głosowe wbudowane i na poziomie tury style

Podziel wskazówki dotyczące wykonania według zakresu między SpeechMetadata a tagi w nawiasach ostrych (<...>).

Zakres Gdzie umieścić Co kontroluje Przykłady
Na poziomie skrętu
(utrzymywane przez cały skręt)
SpeechMetadata.style emocje, osobowość, ton, fleksja, wysokość głosu i ogólne tempo mowy; "cheerful and friendly",
"whispered, nervous",
"speaking rapidly",
"out of breath",
"sarcastic"
Punkt w czasie
(zlokalizowany w konkretnym momencie w zdaniu)
Wbudowane w tekst TextPart za pomocą <...> odgłosy wydawane przez ludzi, które nie są mową, oddechy, pauzy lub chwilowe zmiany sposobu mówienia; "Wait... <short pause> did you hear that? <gasp> Someone's at the door."

tempo, pauzy, ton i akcent;

  • Interpunkcja i wielokropki: używaj w transkrypcji przecinków, myślników (--) i wielokropków (...), aby uzyskać naturalne sformułowania i pauzy.

  • Jawne tagi pauzy: wstaw <short pause> lub <long pause> w tekście w miejscu, w którym lektor powinien zrobić przerwę:

    Hold on, let me think... <short pause> Alright, I've got it.
    
  • Szybkość i wysokość głosu: ustaw style w SpeechMetadata, aby kontrolować ogólne tempo, wysokość lub intonację wypowiedzi (np. "speaking rapidly and excitedly", "speaking slowly" lub "monotone and flat"). Jeśli emocje lub tempo zmieniają się w trakcie monologu, podziel skrypt na osobne wypowiedzi TextPart, z których każda będzie miała własne ustawienie style.

  • Wyróżnienie słowa: zapisz określone słowa w transkrypcji wielkimi literami, aby je podkreślić:

    It was a VERY long day <sigh> ... nobody listens anymore.
    

Dźwięki wokalne i inne niż mowa

Wstawiaj niewerbalne dźwięki wydawane przez człowieka w tekście, używając nawiasów ostrych (<...>) dokładnie w miejscu, w którym dany dźwięk powinien się pojawić. Używaj ludzkich odgłosów, a nie efektów dźwiękowych. Oto zalecane tagi:

<argh> <exhales> <heavy breath> <scream> <snort>
<breath> <gasp> <hiss> <short pause> <sob>
<cackle> <giggle> <laugh> /
<laughter>
<shout> <throat-clearing>
<cheer> <groan> <long pause> <shriek> <tsk>
<chuckle> /
<chuckles>
<growl> <moan> <sigh> /
<sighs>
<whimper>
<cough> <grr> <pant> <sneeze> <whispers> /
<whispering>
<cry> <grunt> <pff> /
<phew>
<snicker> <yawn>

Wtrącenia i nakładające się wypowiedzi

W dialogu z wieloma rozmówcami możesz umieścić krótkie reakcje słuchacza w znakach pionowej kreski (|reaction|) w transkrypcji aktywnego rozmówcy. Osoba, która nie mówi, wtrąca się naturalnie w tym momencie, nie czekając na swoją kolej:

  • Krótkie komunikaty zwrotne słuchacza:

    • Tura 1 (speaker: "Joe"): "So the launch is Thursday |oh hmm| Are we actually ready?"
    • Turn 2 (speaker: "Jane"): "Ready enough |oh really?| The last blocker cleared this morning."
  • Nakładające się wypowiedzi: możesz użyć kilku segmentów potoku, aby zasymulować jednoczesne wypowiedzi (najlepiej działa z gemini-3.8-flash-tts), na przykład:

    • Tura 1 (speaker: "Joe"): "Let's surprise him on three |ok| ready?"
    • Turn 2 (speaker: "Jane"): "one. two. three. |happy| happy |birthday| birthday!"

Sprawdzone metody dotyczące spójności

  • Najpierw przetestuj bez style, a potem dodaj zwięzłe poprawki style: większość próśb brzmi naturalnie, gdy pole style jest puste. Dodaj krótką frazę style (np. "casual, friendly" lub "reflective and awe-inspired") tylko wtedy, gdy wypowiedź wymaga określonej korekty, i używaj tego samego krótkiego ciągu znaków w różnych wypowiedziach, gdy chcesz uzyskać spójny punkt odniesienia.

  • Pisz naturalne transkrypcje wypowiedzi: uwzględniaj w tekście transkrypcji skróty konwersacyjne i naturalne zakłócenia płynności (takie jak "Oh, uh, yeah I think... hm, that's interesting").

  • Unikaj starszych bloków [Audio Profile] i metainstrukcji: długie akapity dotyczące persony, bloki [Director's Notes] lub metainstrukcje takie jak "maintain identical timbre" zwiększają dryf głosu. Zamiast tego wybierz pasujący głos z rozszerzonej biblioteki głosów lub utwórz stały głos postaci za pomocą funkcji Projektowanie głosu.

  • Nie próbuj zastępować niezmiennych cech głosu w style: unikaj używania SpeechMetadata.style do zmiany wieku, płci lub stałego akcentu głosu. Zamiast tego wybierz lub zaprojektuj głos o tych cechach.



Obsługiwane głosy

Modele Gemini 3.x TTS obsługują 3 sposoby określania głosu:

Wszystkie głosy są wielojęzyczne, co oznacza, że możesz używać tego samego głosu do generowania mowy w dowolnym z obsługiwanych języków, zachowując spójną tożsamość mówcy. Jeśli na przykład ustawisz gotowy głos Kore i wyślesz prompty w języku hiszpańskim, hindi i wietnamskim, odpowiedzi będą generowane w tych językach przy użyciu głosu Kore. 30 podstawowych gotowych głosów to głosy wielojęzyczne do ogólnych zastosowań, natomiast głosy z rozszerzonej biblioteki głosów i głosy niestandardowe są powiązane z podstawowym regionem lub akcentem regionalnym. Oznacza to, że mogą mówić w innych językach, ale najbardziej autentycznie brzmią w swoim głównym języku.

Podstawowe gotowe głosy

Modele zamiany tekstu na mowę Gemini obsługują 30 podstawowych gotowych głosów (takich jak Kore, Puck, Zephyr, Charon i Fenrir), z których każdy ma inne cechy wokalne. Przekaż nazwę głosu w SpeechConfig (jak pokazano w przykładach z jednym głosem i wieloma głosami wcześniej na tej stronie).

Gotowe głosy z rozszerzonej biblioteki głosów

Oprócz 30 gotowych głosów rozszerzona biblioteka głosów zawiera ponad 2000 wyselekcjonowanych gotowych głosów w różnych językach, z różnymi akcentami regionalnymi, w różnych przedziałach wiekowych, z różnymi osobowościami i do różnych zastosowań (np. audiobooki, agenci obsługi klienta i prezenterzy wiadomości).

Aby użyć dowolnego głosu z rozszerzonej biblioteki głosów w aplikacji:

  1. Przeglądaj i odsłuchuj głosy, korzystając z jednej z tych opcji:

  2. Przekaż ciąg znaków id głosu z biblioteki jako nazwę głosu w SpeechConfig (podobnie jak w przykładzie z jednym rozmówcą powyżej na tej stronie).

Głosy niestandardowe: projektowanie i replikacja głosu

Modele Gemini 3.x TTS obsługują też głosy niestandardowe, korzystając z jednej z tych opcji:

  • Projektowanie głosu (wersja testowa): wygeneruj unikalny głos niestandardowy na podstawie opisu w języku naturalnym, który zawiera wiek, barwę głosu, akcent i osobowość mówcy (bez konieczności podawania referencyjnego pliku audio). Zwraca zapisany identyfikator głosu (voice_...).

  • Replikacja głosu (wersja testowa): replikuj głos, ton i kadencję mówcy na podstawie nagrania referencyjnego i nagrania zgody. Zwraca identyfikator głosu przechowywany w projekcie (voice_...) lub bezstanowy klucz replikacji głosu zarządzany przez aplikację (voicekey_...).

Używanie głosu niestandardowego w aplikacji Firebase AI Logic

Tworzenie niestandardowych głosów i zarządzanie nimi to operacja administracyjna lub po stronie serwera, więc pakiety SDK klienta Firebase AI Logic nie udostępniają bezpośrednio punktów końcowych zarządzania głosami (CreateVoice, ListVoices, DeleteVoice).

Aby użyć głosu niestandardowego, musisz wykonać te czynności:

  1. Utwórz głos niestandardowy, korzystając z jednej z tych opcji:

  2. Przekaż ciąg voice_<id> lub voicekey_<id> jako nazwę głosu w SpeechConfig (podobnie jak w przykładzie z jednym rozmówcą wcześniej na tej stronie).

Podczas korzystania z głosów niestandardowych pamiętaj o tych wymaganiach:

  • Lokalizacja (Agent Platform Gemini API (formerly Vertex AI)): głosy niestandardowe (voice_... i voicekey_...) są obsługiwane tylko w lokalizacji global (która jest domyślną lokalizacją w przypadku korzystania z Firebase AI Logic).

  • Żądania dotyczące pojedynczego rozmówcy: MultiSpeakerVoiceConfig obsługuje tylko podstawowe gotowe głosy. Aby używać niestandardowych lub replikowanych głosów w dialogu z wieloma postaciami, zsyntetyzuj wypowiedź każdej postaci w osobnym żądaniu dotyczącym jednego rozmówcy.

  • Przechowywanie i wygasanie: przechowywane głosy niestandardowe (voice_...) wygasają, jeśli nie są używane przez rok (każde żądanie syntezy resetuje roczny licznik przechowywania). Bezstanowe klucze replikacji głosu (voicekey_...) wygasają po 7 dniach od utworzenia.

Obsługiwane języki

Modele Gemini 3.x TTS automatycznie wykrywają język tekstu wejściowego, w tym przypadku, gdy prompt zmienia język w trakcie rozmowy z wieloma rozmówcami.

  • Gemini 3.8 Flash TTS (gemini-3.8-flash-tts): obsługuje 132 języki.
  • Gemini 3.8 Flash‑Lite TTS (gemini-3.8-flash-lite-tts): obsługuje 103 języki.

(Opcjonalnie) Wyraźne ustawianie kodu języka

Jeśli chcesz wyraźnie ograniczyć syntezę mowy do określonego regionu, możesz przekazać parametr BCP-47 languageCode w SpeechConfig:



Formaty wyjściowe audio

Domyślny format audio zwracany w InlineDataPart zależy od tego, czy wysyłasz żądanie jednoargumentowe czy strumieniowe:

Metoda żądania Domyślny zwracany typ MIME Szczegóły formatu audio
Unary
(generateContent)
audio/wav Kompletny plik WAV (16-bitowy liniowy PCM, 24 kHz, mono, little-endian) ze standardowym 44-bajtowym nagłówkiem RIFF.

Można je odtwarzać bezpośrednio za pomocą standardowych odtwarzaczy audio na platformie (takich jak AVAudioPlayer na platformach Apple, Web Audio decodeAudioData lub odtwarzacze plików).

Strumieniowanie
(generateContentStream)
audio/l16 Nieprzetworzone 16-bitowe fragmenty PCM bez nagłówka, ze znakiem, w formacie little-endian, 24 kHz, mono.

Zaprojektowany z myślą o kolejkowaniu bufora z niskim czasem oczekiwania i konkatenacji bez nagłówków plików na fragment.



Ograniczenia i wymagania

Podczas korzystania z modeli Gemini 3.x TTS pamiętaj o tych ograniczeniach i wymaganiach:

  • Dane wejściowe tylko w postaci tekstu, dane wyjściowe tylko w postaci dźwięku: modele TTS akceptują tylko dane wejściowe w postaci tekstu (TextPart) i wymagają ustawienia responseModalities na AUDIO.

  • Tylko synteza dosłowna: modele odczytują podaną transkrypcję dosłownie i nie generują odpowiedzi tekstowych w formie rozmowy.

  • Limity tokenów: maksymalna liczba tokenów wejściowych to 8192, a maksymalna liczba tokenów wyjściowych to 16 384 na żądanie.

  • Limit liczby rozmówców: MultiSpeakerVoiceConfig wymaga 2 rozmówców i obsługuje tylko podstawowe gotowe głosy. Każdy element TextPart w żądaniu z wieloma rozmówcami musi zawierać element SpeechMetadata.speaker pasujący do jednego ze skonfigurowanych rozmówców.

  • Nieobsługiwane parametry i metody:

    • Pakiety SDK Firebase AI Logic nie obsługują jeszcze ustawienia responseFormat w GenerationConfig, które zastępuje domyślny format wyjściowy dźwięku.
    • Ustawienie systemInstruction, temperature, topP, topK, candidateCount, presencePenalty lub frequencyPenalty nie jest obsługiwane i powoduje błąd 400 INVALID_ARGUMENT.
    • Wywoływanie funkcji countTokens nie jest obsługiwane w przypadku modeli TTS (liczba tokenów jest zwracana w odpowiedzi w polu usageMetadata).
  • Lokalizacja (Agent Platform Gemini API (formerly Vertex AI)): głosy niestandardowe (voice_... i voicekey_...) wymagają lokalizacji global (która jest domyślną lokalizacją w przypadku korzystania z Firebase AI Logic).



Przenieś z gemini-3.1-flash-tts-preview

Zarówno gemini-3.8-flash-tts, jak i gemini-3.8-flash-lite-tts używają tej samej struktury żądania. Zapoznaj się z tabelą porównawczą modeli, aby wybrać najlepszy zamiennik dla swojego zbioru zadań, i zaktualizuj kod w następujący sposób:

Obszar gemini-3.1-flash-tts-preview (starsza wersja) gemini-3.8-flash-tts i 
gemini-3.8-flash-lite-tts
Styl i kierunek dostawy osadzony w tekście prompta, Na przykład:
"Say cheerfully: ...",
[Audio Profile],
[Director's Notes]
Przekazano w SpeechMetadata(style: "...") w każdym TextPart

Tekst TextPart powinien być dokładną transkrypcją wypowiedzi.

Rozmowa wielu osób Pojedynczy ciąg tekstowy z prefiksami "Speaker: ..." w tekście Jedna wartość TextPart na turę dialogu, z SpeechMetadata(speaker: "...", style: "...") w każdym TextPart
Wbudowane tagi głosowe Nawiasy kwadratowe. Na przykład:
[sigh] lub [laughs]
Nawiasy ostrokątne. Na przykład:
<sigh>, <laugh> lub <short pause>

Zapisuj wahania w mowie, takie jak "uhm", bezpośrednio w tekście.

Domyślny format audio dla żądań jednoargumentowych (generateContent) 16-bitowy nieprzetworzony plik PCM bez nagłówka (audio/pcm, 24 kHz, mono) Kompletny plik WAV (audio/wav, 16-bitowy PCM, 24 kHz, mono, z 44-bajtowym nagłówkiem RIFF)

Strumieniowanie (generateContentStream) pozostaje nieprzetworzonym 16-bitowym formatem PCM bez nagłówka (audio/l16).

Instrukcje systemowe, temperatura, top-P, top-K Zignorowano Odrzucono z błędem 400 INVALID_ARGUMENT. Usuń te parametry z konfiguracji modelu.

Lista kontrolna migracji

  • Przejdź na najnowszą wersję pakietu SDK Firebase AI Logic i zaktualizuj nazwę modelu na gemini-3.8-flash-tts lub gemini-3.8-flash-lite-tts.

  • Przenieś instrukcje dotyczące stylu do SpeechMetadata.style: usuń prefiksy "Say cheerfully:", [Audio Profile], [Scene] i bloki [Director's Notes] z promptów, aby model nie odczytywał ich na głos. Zamiast tego podaj zwięzły opis stylu w parametrze SpeechMetadata.style.

  • Podziel skrypty z wieloma rozmówcami na osobne tury TextPart: zastąp bloki tekstu "Joe: ... \n Jane: ..." tablicą/listą obiektów TextPart, w której każda tura ustawia SpeechMetadata.speaker.

  • Konwertuj tagi [...] na tagi <...>: zastąp tagi audio w nawiasach kwadratowych (np. [whispers], [sighs], [laughs]) tagami wokalnymi w nawiasach ostrych (np. <whispers>, <sigh>, <laugh>, <short pause>).

  • Zaktualizuj odtwarzanie dźwięku w przypadku wywołań jednoargumentowych: ponieważ generateContent zwraca teraz kompletny plik WAV (z 44-bajtowym nagłówkiem RIFF) zamiast nieprzetworzonego pliku PCM bez nagłówka, usuń kod, który ręcznie dodaje nagłówek WAV do odpowiedzi jednoargumentowych (lub pomiń 44-bajtowy nagłówek, jeśli przekazujesz nieprzetworzone próbki PCM do interfejsu API bufora niskiego poziomu, takiego jak AudioTrack na Androidzie lub AudioClip w Unity).

  • Usuń nieobsługiwane parametry konfiguracji: usuń temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty i systemInstruction z konfiguracji TTS GenerativeModel.



Co jeszcze możesz zrobić?

Wypróbuj inne funkcje

Dowiedz się, jak kontrolować generowanie treści

Możesz też eksperymentować z promptami i konfiguracjami modeli, a nawet uzyskać wygenerowany fragment kodu za pomocą Google AI Studio.

Więcej informacji o obsługiwanych modelach

Dowiedz się więcej o modelach dostępnych w różnych przypadkach użycia oraz o ich limitach i cenach.


Prześlij opinię o korzystaniu z usługi Firebase AI Logic