Pembuatan text-to-speech (TTS) menggunakan Gemini API


Anda dapat meminta model TTS Gemini untuk menghasilkan output ucapan (audio) dari perintah teks. Saat menggunakan Firebase AI Logic, Anda dapat membuat permintaan ini langsung dari aplikasi Anda.

Pembuatan text-to-speech (TTS) dapat dikontrol, yang berarti Anda memberikan teks yang sama persis untuk disintesis menjadi ucapan. Selain itu, Anda dapat menggunakan bahasa alami dalam perintah untuk memandu gaya, aksen, kecepatan, dan nada output audio. Anda dapat menganggap TTS sebagai kebalikan dari transkripsi (speech-to-text).

Fitur ini tersedia menggunakan salah satu model Gemini -tts, yang dioptimalkan untuk pembuatan ucapan berkualitas tinggi dengan latensi rendah.

Dengan kemampuan ini, Anda dapat melakukan hal-hal seperti:

  • Penceritaan interaktif: Buat buku audio atau game bermain peran yang imersif, di mana model mengganti suara untuk karakter yang berbeda atau menyesuaikan nada suaranya (seperti berbisik dalam ketegangan atau tertawa saat mendengar lelucon) agar sesuai dengan narasi.

  • Pembelajaran bahasa: Buat panduan pengucapan yang dapat membaca teks dengan aksen regional tertentu atau dengan kecepatan yang lebih lambat untuk membantu pelajar berlatih pengucapan yang sulit.

  • Pembaca konten yang sadar konteks: Membaca artikel berita, resep, atau postingan blog dengan keras menggunakan persona suara dan nada emosional yang sesuai dengan konten (seperti nada serius untuk berita terbaru atau nada hangat dan sabar untuk petunjuk memasak langkah demi langkah).

Panduan ini menunjukkan cara menghasilkan ucapan dari input teks dengan satu atau beberapa pembicara dan cara melakukan streaming respons audio.

Langsung ke kode untuk speaker tunggal Langsung ke kode untuk multi-speaker Langsung ke kode untuk respons yang di-streaming

Perbandingan antara TTS dan Live API

Model text-to-speech (TTS) dan model Live API adalah model pembuatan ucapan dengan latensi rendah yang dapat dikonfigurasi untuk berbagai suara dan bahasa respons. Namun, keduanya melayani kasus penggunaan yang sangat berbeda.

  • Pembuatan text-to-speech (TTS) adalah interaksi permintaan-respons satu arah (teks masuk, audio keluar). Fitur ini dibuat khusus untuk skenario yang memerlukan pembacaan kata demi kata dari teks yang diberikan dengan kontrol terperinci atas gaya dan suara, seperti narasi podcast, buku audio, atau pembacaan artikel.

  • Pembuatan Live API mendukung streaming dua arah untuk percakapan suara real-time (suara masuk, suara keluar). Model ini unggul dalam konteks percakapan dinamis di mana model memutuskan ucapan yang sesuai untuk diberikan. Perhatikan bahwa model Live API terbaru juga mendukung input video dan gambar.

Sebelum memulai

Klik penyedia Gemini API untuk melihat konten dan kode khusus penyedia di halaman ini.

Jika belum melakukannya, selesaikan panduan memulai, yang menjelaskan cara menyiapkan project Firebase, menghubungkan aplikasi ke Firebase, menambahkan SDK, menginisialisasi layanan backend untuk penyedia Gemini API yang Anda pilih, dan membuat instance GenerativeModel.

Untuk menguji dan melakukan iterasi pada perintah Anda, sebaiknya gunakan Google AI Studio.

Model yang mendukung kemampuan ini

  • gemini-3.1-flash-tts-preview

Membuat ucapan dari teks

Anda dapat menghasilkan ucapan dari teks yang diberikan menggunakan model TTS Gemini.

Membuat ucapan dengan satu pembicara

Sebelum mencoba sampel ini, selesaikan bagian Sebelum memulai dalam panduan ini untuk menyiapkan project dan aplikasi Anda.
Di bagian tersebut, Anda juga akan mengklik tombol untuk penyedia Gemini API yang Anda pilih sehingga Anda dapat melihat konten khusus penyedia di halaman ini.

Anda dapat mengonfigurasi model untuk menghasilkan output audio menggunakan satu suara.

Di GenerationConfig Anda, sertakan kode berikut:

Panggil generateContent dengan perintah teks Anda. Model menampilkan data audio PCM mentah di bagian respons.

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.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt.
let prompt = "Say cheerfully: Have a wonderful day!"

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

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

  // To play back raw PCM audio bytes, you'll need to write your own `playRawPcm` function.
  playRawPcm(data: data)
}

Kotlin

Untuk Kotlin, metode dalam SDK ini adalah fungsi penangguhan dan perlu dipanggil dari cakupan Coroutine. 

// 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.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt.
val prompt = "Say cheerfully: Have a wonderful day!"

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

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

    // To play back PCM audio data, you'll need to write your own `playAudio` function.
    playAudio(pcmData)
}

Java

Untuk Java, metode streaming di SDK ini menampilkan jenis Publisher dari library 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.1-flash-tts-preview", config);

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

// Provide a text prompt.
String prompt = "Say cheerfully: Have a wonderful day!";
Content content = new Content.Builder().addText(prompt).build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output based on your text prompt.
// Extract the 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