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-ttsgemini-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ą:
W pliku
GenerationConfigustawresponseModalitiesnaAUDIOi skonfigurujSpeechConfigw ten sposób:(Wymagany) Nazwa lub identyfikator głosu. Może to być gotowy głos, taki jak
Kore, identyfikator głosu z rozszerzonej biblioteki głosów lub identyfikatorvoice_.../voicekey_...głosu niestandardowego.(Opcjonalnie) Kod języka BCP-47. Jeśli go pominiesz, model automatycznie wykryje język.
Utwórz
TextPartz tymi ustawieniami:(Wymagane) Dosłowna transkrypcja tekstu, który ma zostać odczytany.
(Opcjonalnie)
SpeechMetadataz opisemstyle(na przykład"cheerful and friendly").
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ą typPublisher 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:
Utwórz obiekt
MultiSpeakerVoiceConfig, który mapuje 2 nazwy rozmówców (np."Joe"i"Jane") na ichSpeakerVoiceConfiggłosy.W pliku
GenerationConfigustawresponseModalitiesnaAUDIOi przekażMultiSpeakerVoiceConfig(oraz opcjonalnielanguageCode) doSpeechConfig.Podaj tablicę lub listę obiektów
TextPart, konkretnie po jednym obiekcieTextPartna każdą turę dialogu. Na każdym urządzeniuTextPartustawSpeechMetadataw ten sposób:- (Wymagany)
speaker, który pasuje do jednej z nazw rozmówców zdefiniowanych wMultiSpeakerVoiceConfig. - (Opcjonalnie) Opis
style(np."cheerful and friendly").
- (Wymagany)
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ą typPublisher 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ą typPublisher 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
stylewSpeechMetadata, 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 wypowiedziTextPart, z których każda będzie miała własne ustawieniestyle.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."
- Tura 1 (
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!"
- Tura 1 (
Sprawdzone metody dotyczące spójności
Najpierw przetestuj bez
style, a potem dodaj zwięzłe poprawkistyle: większość próśb brzmi naturalnie, gdy polestylejest 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żywaniaSpeechMetadata.styledo 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:
Przeglądaj i odsłuchuj głosy, korzystając z jednej z tych opcji:
Aby uzyskać głos
id, użyj Google AI Studio lub Agent Studio.Wyślij zapytanie do metody
listinterfejsu Voices API (ListVoicesztype=prebuilti opcjonalnym zapytaniemsearch), aby uzyskać głosid. Więcej informacji znajdziesz w dokumentacji Gemini Developer API lub dokumentacji Agent Platform Gemini API (formerly Vertex AI).
Przekaż ciąg znaków
idgłosu z biblioteki jako nazwę głosu wSpeechConfig(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:
Utwórz głos niestandardowy, korzystając z jednej z tych opcji:
Użyj Google AI Studio lub Agent Studio, aby uzyskać identyfikator
voice_<id>lubvoicekey_<id>.Użyj interfejsu Voices API, aby uzyskać identyfikator
voice_<id>lubvoicekey_<id>. Więcej informacji znajdziesz w dokumentacji wybranego dostawcy Gemini API:Gemini Developer API: Generowanie mowy
Agent Platform Gemini API (formerly Vertex AI): Projektowanie głosu i Replikacja głosu
Przekaż ciąg
voice_<id>lubvoicekey_<id>jako nazwę głosu wSpeechConfig(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_...ivoicekey_...) są obsługiwane tylko w lokalizacjiglobal(która jest domyślną lokalizacją w przypadku korzystania z Firebase AI Logic).Żądania dotyczące pojedynczego rozmówcy:
MultiSpeakerVoiceConfigobsł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 |
|
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ą ustawieniaresponseModalitiesnaAUDIO.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:
MultiSpeakerVoiceConfigwymaga 2 rozmówców i obsługuje tylko podstawowe gotowe głosy. Każdy elementTextPartw żądaniu z wieloma rozmówcami musi zawierać elementSpeechMetadata.speakerpasujący do jednego ze skonfigurowanych rozmówców.Nieobsługiwane parametry i metody:
- Pakiety SDK Firebase AI Logic nie obsługują jeszcze ustawienia
responseFormatwGenerationConfig, które zastępuje domyślny format wyjściowy dźwięku. - Ustawienie
systemInstruction,temperature,topP,topK,candidateCount,presencePenaltylubfrequencyPenaltynie jest obsługiwane i powoduje błąd400 INVALID_ARGUMENT. - Wywoływanie funkcji
countTokensnie jest obsługiwane w przypadku modeli TTS (liczba tokenów jest zwracana w odpowiedzi w poluusageMetadata).
- Pakiety SDK Firebase AI Logic nie obsługują jeszcze ustawienia
Lokalizacja (Agent Platform Gemini API (formerly Vertex AI)): głosy niestandardowe (
voice_...ivoicekey_...) wymagają lokalizacjiglobal(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 |
| 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 |
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 ( |
| 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-ttslubgemini-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 parametrzeSpeechMetadata.style.Podziel skrypty z wieloma rozmówcami na osobne tury
TextPart: zastąp bloki tekstu"Joe: ... \n Jane: ..."tablicą/listą obiektówTextPart, w której każda tura ustawiaSpeechMetadata.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ż
generateContentzwraca 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 jakAudioTrackna Androidzie lubAudioClipw Unity).Usuń nieobsługiwane parametry konfiguracji: usuń
temperature,topP,topK,candidateCount,presencePenalty,frequencyPenaltyisystemInstructionz konfiguracji TTSGenerativeModel.
Co jeszcze możesz zrobić?
-
Zacznij przygotowywać się do wdrożenia wersji produkcyjnej (zobacz listę kontrolną dotyczącą wersji produkcyjnej):
- Wymuś Firebase App Check jak najwcześniej, aby chronić Gemini API przed nadużyciami ze strony nieautoryzowanych klientów.
- Używaj Firebase Remote Config lub szablonów promptów serwera, aby móc wprowadzać zmiany na żądanie w konfiguracjach funkcji AI (np. nazwy modelu) bez konieczności wydawania nowej wersji aplikacji.
Wypróbuj inne funkcje
- tworzyć wieloetapowe rozmowy (czat);
- generować tekst na podstawie promptów tekstowych;
- generować uporządkowane dane wyjściowe (np. JSON) zarówno z promptów tekstowych, jak i multimodalnych;
- Generowanie i edytowanie obrazów na podstawie promptów tekstowych i multimodalnych.
- Przesyłaj strumieniowo dane wejściowe i wyjściowe (w tym dźwięk) za pomocą Gemini Live API.
-
Używaj narzędzi (takich jak wywoływanie funkcji i Grounding z
Google Search lubGoogle Maps ), aby połączyć model Gemini z innymi częściami aplikacji oraz zewnętrznymi systemami i informacjami.
Dowiedz się, jak kontrolować generowanie treści
- Dowiedz się, jak projektować prompty, poznaj sprawdzone metody i strategie oraz przykładowe prompty.
- Skonfiguruj parametry modelu, takie jak maksymalna liczba tokenów wyjściowych, prawdopodobieństwo powtarzania tokenów wyjściowych itp.
- Użyj ustawień bezpieczeństwa, aby dostosować prawdopodobieństwo otrzymania odpowiedzi, które mogą zostać uznane za szkodliwe.
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