การสร้างข้อความเป็นการอ่านออกเสียง (TTS) โดยใช้ Gemini API


คุณสามารถใช้โมเดล TTS Gemini (gemini-3.8-flash-tts หรือ gemini-3.8-flash-lite-tts) เพื่อสังเคราะห์เสียงพูด (เสียง) ที่เป็นธรรมชาติและแสดงอารมณ์จากข้อความได้ เมื่อใช้ Firebase AI Logic คุณจะส่งคำขอนี้ได้โดยตรงจากแอปบนอุปกรณ์เคลื่อนที่หรือเว็บแอป (เช่น แอป Apple (Swift), Android (Kotlin/Java), เว็บ (JavaScript), Flutter (Dart) หรือ Unity)

การสร้างการอ่านออกเสียงข้อความ (TTS) ควบคุมได้ ซึ่งหมายความว่าคุณระบุข้อความที่แน่นอนเพื่อสังเคราะห์เป็นคำพูด พร้อมกับแนะนำการนำเสนอ เช่น อารมณ์ จังหวะ เสียงของผู้พูด และเสียงที่ไม่ใช่คำพูด เช่น เสียงหัวเราะหรือเสียงถอนหายใจ โดยใช้ข้อมูลเมตาที่มีโครงสร้างและแท็กเสียงในบรรทัด คุณอาจมองว่า TTS เป็นสิ่งที่ตรงกันข้ามกับการถอดเสียงเป็นคำ (การแปลงเสียงพูดเป็นข้อความ)

ความสามารถนี้ช่วยให้คุณสร้างฟีเจอร์ต่างๆ ได้ เช่น

  • การเล่าเรื่องและหนังสือเสียงแบบอินเทอร์แอกทีฟ: บรรยายเรื่องราวแบบยาวหรือเกมสวมบทบาทที่ตัวละครเปลี่ยนเสียง โต้ตอบกันด้วยการพูดแทรก และปรับการแสดงอารมณ์ (เช่น กระซิบด้วยความตื่นเต้นหรือหัวเราะกับมุกตลก)
  • ผู้ช่วยและตัวแทนเสียงที่มีเวลาในการตอบสนองต่ำ: สตรีมเสียงพูดที่สังเคราะห์ขึ้นทันทีที่ข้อความมาจาก LLM โดยคงลักษณะเสียงที่สอดคล้องกันตลอดการสนทนา
  • โปรแกรมอ่านเนื้อหาหลายภาษาและติวเตอร์สอนภาษา: อ่านบทความ สูตรอาหาร หรือสื่อการเรียนรู้แบบออกเสียงได้มากกว่า 130 ภาษาและสำเนียงตามภูมิภาค หรือเปลี่ยนภาษาได้อย่างราบรื่นภายในบทสนทนาเดียว

คู่มือนี้แสดงวิธีสร้างเสียงพูดแบบผู้พูดคนเดียวและผู้พูดหลายคน สตรีมการตอบกลับด้วยเสียง กำหนดการพูดด้วยแท็ก SpeechMetadata และแท็กในบรรทัด รวมถึงเลือกจากเสียงที่สร้างไว้ล่วงหน้า เสียงในคลัง หรือเสียงที่กำหนดเอง

ข้ามไปที่โค้ดสำหรับผู้พูดคนเดียว ข้ามไปที่โค้ดสำหรับผู้พูดหลายคน ข้ามไปที่โค้ดสำหรับสตรีมมิง

การเปรียบเทียบระหว่าง TTS กับ Live API

ทั้งโมเดลการอ่านออกเสียงข้อความ (TTS) และโมเดล Live API เป็นโมเดลสร้างเสียงพูดที่มีเวลาในการตอบสนองต่ำ ซึ่งสามารถกำหนดค่าสำหรับเสียงและภาษาที่ตอบสนองแตกต่างกันได้ อย่างไรก็ตาม ทั้ง 2 อย่างนี้มีกรณีการใช้งานที่แตกต่างกันมาก

  • การสร้างการอ่านออกเสียงข้อความ (TTS) เป็นการโต้ตอบแบบคำขอ-คำตอบทิศทางเดียว (ข้อความเข้า เสียงออก) โดยได้รับการปรับแต่งมาสำหรับสถานการณ์ที่ต้องใช้การอ่านออกเสียงข้อความที่ระบุอย่างถูกต้อง พร้อมการควบคุมสไตล์และเสียงอย่างละเอียด เช่น การบรรยายพอดแคสต์ หนังสือเสียง หรือการอ่านบทความออกเสียง

  • Live API generation รองรับการสตรีมแบบ 2 ทิศทางสำหรับการสนทนาด้วยเสียงแบบเรียลไทม์ (เสียงเข้า เสียงออก) โดยมีความสามารถในการสนทนาแบบไดนามิกที่โมเดลจะตัดสินใจเลือกคำพูดที่เหมาะสมเพื่อตอบกลับ โปรดทราบว่าโมเดล Live API ล่าสุดยังรองรับอินพุตวิดีโอและรูปภาพด้วย

ก่อนเริ่มต้น

คลิกผู้ให้บริการ Gemini API เพื่อดูเนื้อหาและโค้ดเฉพาะของผู้ให้บริการในหน้านี้

หากยังไม่ได้ดำเนินการ โปรดอ่านคู่มือเริ่มต้นใช้งานให้จบ ซึ่งจะอธิบายวิธีตั้งค่าโปรเจ็กต์ Firebase, เชื่อมต่อแอปกับ Firebase, เพิ่ม SDK, เริ่มต้นบริการแบ็กเอนด์สำหรับผู้ให้บริการ Gemini API ที่คุณเลือก และสร้างอินสแตนซ์ GenerativeModel

สำหรับการทดสอบและปรับปรุงพรอมต์ซ้ำๆ เราขอแนะนำให้ใช้ Google AI Studio

โมเดลที่รองรับความสามารถนี้

  • gemini-3.8-flash-tts
  • gemini-3.8-flash-lite-tts
การเปรียบเทียบโมเดล TTS

โมเดล Gemini 3.x TTS ทั้ง 2 โมเดลมีสคีมาคำขอและรูปแบบพรอมต์เหมือนกัน อย่างไรก็ตาม ต่อไปนี้คือความแตกต่างบางประการเมื่อคุณอาจใช้แต่ละโมเดล

ฟีเจอร์หรือภาระงาน gemini-3.8-flash-tts gemini-3.8-flash-lite-tts
จุดแข็งหลัก ความเที่ยงตรงของเสียงระดับสตูดิโอ ความแตกต่างเล็กน้อยในการแสดง และการครอบคลุมภาษาถิ่นที่กว้างขวาง การส่งข้อความปริมาณมาก เวลาในการตอบสนองต่ำ และความคุ้มค่า
กรณีการใช้งานที่ดีที่สุด หนังสือเสียง, การบรรยายในสตูดิโอ, บทสนทนาที่ซับซ้อนของผู้พูดหลายคน, แท็กการเปล่งเสียงบ่อยครั้ง, การออกเสียงที่ยาก, ภาษาถิ่น การสร้างเสียงปริมาณมาก, การส่งต่อข้อมูลของเอเจนต์เสียงแบบเรียลไทม์, ฟีเจอร์ UI สำหรับการอ่านออกเสียง, เสียงพูดของผู้พูดคนเดียวในชีวิตประจำวัน
ภาษาที่รองรับ 132 ภาษา 103 ภาษา

สร้างเสียงพูดจากข้อความ

คุณสามารถสร้างเสียงพูดจากข้อความที่ป้อนด้วยเสียงของผู้พูดคนเดียวหรือบทสนทนาของผู้พูด 2 คน โดยจะสร้างเป็นไฟล์ WAV ที่สมบูรณ์ (generateContent) หรือสตรีมเสียง PCM ดิบที่มีเวลาในการตอบสนองต่ำ (generateContentStream) ก็ได้

สร้างเสียงพูดด้วยผู้พูดคนเดียว

ก่อนลองใช้ตัวอย่างนี้ ให้ทำตามส่วนก่อนเริ่มต้นของคู่มือนี้เพื่อตั้งค่าโปรเจ็กต์และแอป
ในส่วนนั้น คุณจะต้องคลิกปุ่มสำหรับผู้ให้บริการ Gemini API ที่เลือกด้วยเพื่อให้เห็นเนื้อหาเฉพาะผู้ให้บริการในหน้านี้

วิธีสร้างเสียงผู้พูดคนเดียวมีดังนี้

  1. ใน GenerationConfig ให้ตั้งค่า responseModalities เป็น AUDIO และกำหนดค่า SpeechConfig ด้วยข้อมูลต่อไปนี้

  2. สร้าง TextPart โดยมีข้อมูลต่อไปนี้

    • (ต้องระบุ) ข้อความถอดเสียงแบบคำต่อคำที่จะพูด

    • (ไม่บังคับ) SpeechMetadata ที่มีคำอธิบาย style (เช่น "cheerful and friendly")

  3. โทรหา generateContent โดยค่าเริ่มต้น คำขอแบบ Unary จะแสดงผลไฟล์เสียง WAV (audio/wav) ที่สมบูรณ์ (PCM เชิงเส้น 16 บิต, 24 kHz, โมโน พร้อมส่วนหัว RIFF มาตรฐาน 44 ไบต์) ในส่วนข้อมูลในบรรทัดของการตอบกลับ

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

สำหรับ Kotlin เมธอดใน SDK นี้เป็นฟังก์ชันระงับและต้องเรียกใช้จากขอบเขต 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.
// 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

สำหรับ Java เมธอดการสตรีมใน SDK นี้จะแสดงผลประเภท Publisher จากไลบรารี 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);
    }
  }
}

สร้างเสียงพูดที่มีผู้พูดหลายคน

ก่อนลองใช้ตัวอย่างนี้ ให้ทำตามส่วนก่อนเริ่มต้นของคู่มือนี้เพื่อตั้งค่าโปรเจ็กต์และแอป
ในส่วนนั้น คุณจะต้องคลิกปุ่มสำหรับผู้ให้บริการ Gemini API ที่เลือกด้วยเพื่อให้เห็นเนื้อหาเฉพาะผู้ให้บริการในหน้านี้

คุณสามารถสร้างบทสนทนาที่เป็นธรรมชาติระหว่างผู้พูด 2 คนในคำขอเดียวได้โดยกำหนดเสียงที่แตกต่างกันให้ผู้พูดแต่ละคน และส่งบทสนทนาแต่ละบรรทัดเป็น TextPart ของตัวเอง ดังนี้

  1. สร้าง MultiSpeakerVoiceConfig ที่แมปชื่อผู้พูด 2 ชื่อ (เช่น "Joe" และ "Jane") กับSpeakerVoiceConfigเสียงของบุคคลนั้นๆ

  2. ใน GenerationConfig ให้ตั้งค่า responseModalities เป็น AUDIO และส่ง MultiSpeakerVoiceConfig (และ languageCode ที่ไม่บังคับ) ไปยัง SpeechConfig

  3. ระบุอาร์เรย์หรือรายการออบเจ็กต์ TextPart โดยเฉพาะ TextPart 1 รายการต่อการสนทนาแต่ละรอบ ใน TextPart ทุกรายการ ให้ตั้งค่า SpeechMetadata ด้วยข้อมูลต่อไปนี้

    • (ต้องระบุ) speaker ที่ตรงกับชื่อผู้พูดที่กำหนดไว้ใน MultiSpeakerVoiceConfig
    • (ไม่บังคับ) คำอธิบาย style (เช่น "cheerful and friendly")
  4. โทรหา generateContent โมเดลจะสังเคราะห์การสนทนาทั้งหมดและแสดงผลเป็นไฟล์เสียง 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

สำหรับ Kotlin เมธอดใน SDK นี้เป็นฟังก์ชันระงับและต้องเรียกใช้จากขอบเขต Coroutine

// 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

สำหรับ Java เมธอดการสตรีมใน SDK นี้จะแสดงผลประเภท Publisher จากไลบรารี 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);
    }
  }
}

สตรีมคำตอบ

ก่อนลองใช้ตัวอย่างนี้ ให้ทำตามส่วนก่อนเริ่มต้นของคู่มือนี้เพื่อตั้งค่าโปรเจ็กต์และแอป
ในส่วนนั้น คุณจะต้องคลิกปุ่มสำหรับผู้ให้บริการ Gemini API ที่เลือกด้วยเพื่อให้เห็นเนื้อหาเฉพาะผู้ให้บริการในหน้านี้

หากต้องการลดเวลาในการตอบกลับด้วยเสียงครั้งแรก (TTFA) และเล่นแบบเรียลไทม์ คุณสามารถสตรีมการตอบกลับด้วยเสียงขณะที่สร้างขึ้นแทนที่จะรอให้คลิปทั้งหมดเสร็จสิ้น การสตรีมใช้ได้กับการกำหนดค่าทั้งแบบลำโพงเดียวและหลายลำโพง

หากต้องการสตรีมเสียงพูด ให้เรียกใช้ generateContentStream แทน generateContent ต่างจากคำขอแบบ Unary (ซึ่งแสดงผลไฟล์ WAV) คำขอสตรีมมิงจะแสดงผลเป็นกลุ่ม PCM แบบ Little-Endian แบบมีเครื่องหมาย 16 บิตดิบที่ไม่มีส่วนหัว (audio/l16, 24 kHz, โมโน) เพื่อให้คุณเพิ่มแต่ละกลุ่มต่อท้ายบัฟเฟอร์เอาต์พุตเสียงได้โดยตรง

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

สำหรับ Kotlin เมธอดใน SDK นี้เป็นฟังก์ชันระงับและต้องเรียกใช้จากขอบเขต 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"))
}

// 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

สำหรับ Java เมธอดการสตรีมใน SDK นี้จะแสดงผลประเภท Publisher จากไลบรารี 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);
    }
}



ควบคุมเอาต์พุตเสียงพูดด้วยข้อมูลเมตาและแท็กในบรรทัด

โมเดล Gemini 3.x TTS จะถือว่า text ภายใน TextPart แต่ละรายการเป็นข้อความถอดเสียงแบบคำต่อคำที่จะอ่านออกเสียงอย่างเคร่งครัด อย่าเขียนคำสั่งแบบบรรยาย (เช่น "Say cheerfully:") ไว้ในสตริงข้อความ ไม่เช่นนั้นโมเดลอาจอ่านออกเสียงคำเหล่านั้น

คุณสามารถกำกับการร้องโดยใช้เทคนิคต่อไปนี้

แท็กเสียงร้องระดับเทิร์น style และแท็กเสียงร้องในบรรทัด

แยกคำสั่งประสิทธิภาพตามขอบเขตระหว่าง SpeechMetadata และแท็กวงเล็บมุมแบบอินไลน์ (<...>)

ขอบเขต ตำแหน่งที่ควรวาง สิ่งที่ควบคุม ตัวอย่าง
ระดับการเลี้ยว
(คงที่ตลอดการเลี้ยว)
SpeechMetadata.style อารมณ์ บุคลิกภาพ น้ำเสียง การขึ้นลงของเสียง ระดับเสียง และอัตราการพูดโดยรวม "cheerful and friendly",
"whispered, nervous",
"speaking rapidly",
"out of breath",
"sarcastic"
จุดเวลา
(แปลเป็นภาษาท้องถิ่นตามช่วงเวลาที่เจาะจงในประโยค)
แทรกในบรรทัดข้อความภาษาTextPartโดยใช้<...> เสียงร้องของมนุษย์ที่ไม่ใช่คำพูด เสียงหายใจ การหยุดชั่วคราว หรือการเปลี่ยนการพูดชั่วขณะ "Wait... <short pause> did you hear that? <gasp> Someone's at the door."

จังหวะ การหยุดชั่วคราว ระดับเสียง และการเน้นเสียง

  • เครื่องหมายวรรคตอนและจุดไข่ปลา: ใช้คอมมา ขีดกลาง (--) และจุดไข่ปลา (...) ในข้อความถอดเสียงเพื่อสร้างการเรียบเรียงประโยคและการลังเลที่เป็นธรรมชาติ

  • แท็กหยุดชั่วคราวที่ชัดเจน: แทรก <short pause> หรือ <long pause> ในบรรทัด ณ จุดที่ผู้พูดควรหยุดชั่วคราว ดังนี้

    Hold on, let me think... <short pause> Alright, I've got it.
    
  • ความเร็วและระดับเสียงในการพูด: ตั้งค่า style ใน SpeechMetadata เพื่อควบคุมความเร็ว ระดับเสียง หรือการผันเสียงโดยรวมสำหรับเทิร์น (เช่น "speaking rapidly and excitedly", "speaking slowly" หรือ "monotone and flat") หากอารมณ์หรือความเร็วเปลี่ยนไปในระหว่างการพูดคนเดียว ให้แบ่งสคริปต์ออกเป็นเทิร์น TextPart แยกกัน โดยแต่ละเทิร์นจะมี style ของตัวเอง

  • การเน้นคำ: เขียนคำที่ต้องการเน้นในข้อความถอดเสียงด้วยอักษรตัวพิมพ์ใหญ่

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

เสียงร้องและเสียงที่ไม่ใช่เสียงพูด

แทรกเสียงร้องของมนุษย์ที่ไม่ใช่คำพูดในบรรทัดโดยใช้วงเล็บมุม (<...>) ที่ขอบเขตคำที่แน่นอนซึ่งควรมีเสียงเกิดขึ้น ใช้เสียงร้องของมนุษย์แทนเอฟเฟกต์เสียงที่ไม่ใช่เสียงร้อง แท็กที่แนะนำให้ใช้มีดังนี้

<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>

การตอบรับและเสียงพูดทับซ้อนกัน

ในบทสนทนาที่มีผู้พูดหลายคน คุณสามารถรวมปฏิกิริยาของผู้ฟังแบบสั้นๆ ไว้ในอักขระไปป์ (|reaction|) ภายในข้อความถอดเสียงของผู้พูดที่กำลังพูดอยู่ได้ ผู้ที่ไม่ได้พูดจะแทรกขึ้นมาอย่างเป็นธรรมชาติ ณ จุดนั้นโดยไม่ต้องรอให้ถึงตาของตนเอง

  • การตอบรับสั้นๆ ของผู้ฟัง

    • ตาที่ 1 (speaker: "Joe"): "So the launch is Thursday |oh hmm| Are we actually ready?"
    • เทิร์นที่ 2 (speaker: "Jane"): "Ready enough |oh really?| The last blocker cleared this morning."
  • เสียงพูดที่ทับซ้อนกัน: คุณสามารถใช้ Pipe Segment หลายรายการเพื่อจำลองเสียงพูดที่เกิดขึ้นพร้อมกันได้ (ทำงานได้ดีที่สุดกับ gemini-3.8-flash-tts) เช่น

    • ตาที่ 1 (speaker: "Joe"): "Let's surprise him on three |ok| ready?"
    • เทิร์นที่ 2 (speaker: "Jane"): "one. two. three. |happy| happy |birthday| birthday!"

แนวทางปฏิบัติแนะนำเพื่อความสม่ำเสมอ

  • ทดสอบโดยไม่ใช้ style ก่อน จากนั้นจึงเพิ่มการปรับแต่ง style ที่กระชับ: คำขอส่วนใหญ่จะฟังดูเป็นธรรมชาติเมื่อช่อง style ว่างเปล่า เพิ่มวลีสั้นๆ style (เช่น "casual, friendly" หรือ "reflective and awe-inspired") เฉพาะ เมื่อเทิร์นต้องการการปรับการแสดงผลที่เฉพาะเจาะจง และใช้สตริงสั้นๆ เดียวกันนั้นซ้ำในเทิร์นต่างๆ เมื่อคุณต้องการให้มีเกณฑ์พื้นฐานที่สอดคล้องกัน

  • เขียนข้อความถอดเสียงที่พูดอย่างเป็นธรรมชาติ: ใส่คำย่อที่ใช้ในการสนทนาและความไม่คล่องแคล่วตามธรรมชาติ (เช่น "Oh, uh, yeah I think... hm, that's interesting") ลงในข้อความถอดเสียงโดยตรง

  • หลีกเลี่ยงบล็อก [Audio Profile] และคำสั่งเมตาแบบเดิม: ย่อหน้าบุคลิกที่ยาว บล็อก [Director's Notes] หรือคำสั่งเมตา เช่น "maintain identical timbre" จะเพิ่มความคลาดเคลื่อนของเสียง แต่ให้เลือกเสียงที่ตรงกันจากคลังเสียงเพิ่มเติมหรือสร้างเสียงตัวละครที่สอดคล้องกันด้วยการออกแบบเสียงแทน

  • อย่าพยายามลบล้างลักษณะเสียงที่เปลี่ยนแปลงไม่ได้ใน style: หลีกเลี่ยงการใช้ SpeechMetadata.style เพื่อเปลี่ยนอายุ เพศ หรือสำเนียงถาวรของเสียง แต่ให้เลือกหรือออกแบบเสียงที่มีลักษณะเหล่านั้นแทน



เสียงที่รองรับ

โมเดล Gemini 3.x TTS รองรับการระบุเสียง 3 วิธีดังนี้

เสียงทั้งหมดเป็นแบบหลายภาษา ซึ่งหมายความว่าคุณสามารถใช้เสียงเดียวกันเพื่อสร้างคำพูดในภาษาที่รองรับได้ โดยยังคงรักษาเอกลักษณ์ของผู้พูดที่สอดคล้องกันไว้ เช่น หากคุณตั้งค่าเสียงเป็นเสียง Kore ที่สร้างไว้ล่วงหน้าและส่งพรอมต์เป็นภาษาสเปน ฮินดี และเวียดนาม คำตอบทั้งหมดจะใช้เสียง Kore ในแต่ละภาษาเหล่านั้น แม้ว่าเสียงที่สร้างไว้ล่วงหน้าหลัก 30 เสียงจะเป็นเสียงที่รองรับหลายภาษาและใช้งานได้อเนกประสงค์ แต่เสียงในคลังเสียงเพิ่มเติมและเสียงที่กำหนดเองจะยึดตามภาษาหลักหรือสำเนียงประจำภูมิภาค ซึ่งหมายความว่าเสียงเหล่านี้ยังคงพูดภาษาอื่นๆ ได้ แต่จะฟังดูเป็นธรรมชาติที่สุดในภาษาหลัก

เสียงหลักที่สร้างไว้ล่วงหน้า

โมเดล TTS ของ Gemini รองรับเสียงที่สร้างไว้ล่วงหน้า 30 เสียง (เช่น Kore, Puck, Zephyr, Charon และ Fenrir) โดยแต่ละเสียงมีลักษณะเสียงที่แตกต่างกัน ส่งชื่อเสียงใน SpeechConfig (ตามที่แสดงในตัวอย่างลำโพงเดี่ยวและลำโพงหลายตัวก่อนหน้านี้ในหน้านี้)

เสียงที่กำหนดไว้ล่วงหน้าจากคลังเสียงเพิ่มเติม

นอกเหนือจากเสียงที่สร้างไว้ล่วงหน้า 30 เสียงแล้ว คลังเสียงเพิ่มเติมยังมีเสียงที่กำหนดล่วงหน้าที่คัดสรรมาแล้วมากกว่า 2,000 เสียง ซึ่งครอบคลุมภาษา สำเนียงตามภูมิภาค ช่วงอายุ บุคลิกของตัวละคร และกรณีการใช้งานที่หลากหลาย (เช่น หนังสือเสียง ตัวแทนฝ่ายสนับสนุนลูกค้า และผู้อ่านข่าว)

วิธีใช้เสียงจากคลังเสียงเพิ่มเติมในแอปมีดังนี้

  1. เรียกดูและฟังตัวอย่างเสียงโดยใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้

  2. ส่งสตริง id ของเสียงในคลังเป็นชื่อเสียงใน SpeechConfig (คล้ายกับที่แสดงในตัวอย่างผู้พูดคนเดียวก่อนหน้านี้ในหน้านี้)

เสียงที่กำหนดเอง: การออกแบบเสียงและการจำลองเสียง

โมเดล Gemini 3.x TTS ยังรองรับเสียงที่กำหนดเองโดยใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้ด้วย

  • การออกแบบเสียง (เวอร์ชันตัวอย่าง): สร้างเสียงที่กำหนดเองซึ่งไม่ซ้ำใครจากคำอธิบายภาษาธรรมชาติเกี่ยวกับอายุของผู้พูด คุณภาพเสียง สำเนียง และบุคลิก (โดยไม่ต้องใช้เสียงอ้างอิง) แสดงผลรหัสเสียงที่จัดเก็บไว้ (voice_...)

  • การจำลองเสียง (เวอร์ชันตัวอย่าง): จำลองเสียง โทนเสียง และจังหวะของผู้พูดจากไฟล์บันทึกเสียงอ้างอิงและไฟล์บันทึกเสียงที่ให้ความยินยอม แสดงรหัสเสียงที่จัดเก็บไว้ในโปรเจ็กต์ (voice_...) หรือคีย์การจำลองเสียงแบบไม่เก็บสถานะที่จัดการโดยแอป (voicekey_...)

ใช้เสียงที่กำหนดเองในแอป Firebase AI Logic

การสร้างและจัดการเสียงที่กำหนดเองเป็นการดำเนินการด้านการดูแลระบบหรือฝั่งเซิร์ฟเวอร์ ดังนั้น SDK ไคลเอ็นต์ Firebase AI Logic จึงไม่แสดงปลายทางการจัดการเสียง (CreateVoice, ListVoices, DeleteVoice) โดยตรง

แต่หากต้องการใช้เสียงที่กำหนดเอง คุณต้องทำดังนี้

  1. สร้างเสียงที่กำหนดเอง 1 ครั้งโดยใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้

  2. ส่งสตริง voice_<id> หรือ voicekey_<id> เป็นชื่อเสียงใน SpeechConfig (คล้ายกับที่แสดงในตัวอย่างผู้พูดคนเดียวก่อนหน้านี้ในหน้านี้)

โปรดคำนึงถึงข้อกำหนดต่อไปนี้เมื่อใช้เสียงที่กำหนดเอง

  • สถานที่ (Agent Platform Gemini API (formerly Vertex AI)): เสียงที่กำหนดเอง (voice_... และ voicekey_...) รองรับเฉพาะในสถานที่ global (ซึ่งเป็นตำแหน่งเริ่มต้นเมื่อใช้ Firebase AI Logic)

  • คำขอเสียงผู้พูดคนเดียว: MultiSpeakerVoiceConfig รองรับเฉพาะเสียงหลักที่สร้างไว้ล่วงหน้า หากต้องการใช้เสียงที่ออกแบบเองหรือเสียงที่จำลองขึ้นในการสนทนาที่มีตัวละครหลายตัว ให้สังเคราะห์เสียงของตัวละครแต่ละตัวในคำขอแบบผู้พูดคนเดียวแยกกัน

  • การเก็บรักษาและการหมดอายุ: เสียงที่กำหนดเองที่จัดเก็บไว้ (voice_...) จะหมดอายุหากไม่ได้ใช้เป็นเวลา 1 ปี (คำขอการสังเคราะห์แต่ละรายการจะรีเซ็ตตัวจับเวลาการเก็บรักษา 1 ปี) คีย์การจำลองเสียงแบบไม่เก็บสถานะ (voicekey_...) จะหมดอายุ 7 วันหลังจากสร้าง

ภาษาที่สนับสนุน

โมเดล Gemini 3.x TTS จะตรวจหาภาษาจากข้อความที่คุณป้อนโดยอัตโนมัติ รวมถึงเมื่อพรอมต์เปลี่ยนภาษาในแต่ละเทิร์นในบทสนทนาที่มีผู้พูดหลายคน

  • Gemini 3.8 Flash TTS (gemini-3.8-flash-tts): รองรับ 132 ภาษา
  • Gemini 3.8 Flash‑Lite TTS (gemini-3.8-flash-lite-tts): รองรับ 103 ภาษา

(ไม่บังคับ) ตั้งค่ารหัสภาษาอย่างชัดเจน

หากต้องการจำกัดการสังเคราะห์เสียงพูดให้อยู่ในภาษาที่เฉพาะเจาะจงอย่างชัดเจน คุณสามารถส่ง languageCode BCP-47 ใน SpeechConfig ได้ ดังนี้



รูปแบบเอาต์พุตเสียง

รูปแบบเสียงเริ่มต้นที่แสดงใน InlineDataPart จะขึ้นอยู่กับว่าคุณส่งคำขอแบบ Unary หรือแบบสตรีมมิง ดังนี้

เมธอดคำขอ ประเภท MIME เริ่มต้นที่แสดงผล รายละเอียดรูปแบบเสียง
Unary
(generateContent)
audio/wav ไฟล์ WAV ที่สมบูรณ์ (PCM เชิงเส้น 16 บิต, 24 kHz, โมโน, Little-Endian) พร้อมส่วนหัว RIFF ขนาด 44 ไบต์มาตรฐาน

เล่นได้โดยตรงด้วยโปรแกรมเล่นเสียงมาตรฐานของแพลตฟอร์ม (เช่น AVAudioPlayer บนแพลตฟอร์ม Apple, Web Audio decodeAudioData หรือโปรแกรมเล่นแบบอิงตามไฟล์)

สตรีมมิง
(generateContentStream)
audio/l16 ส่วนย่อย PCM แบบ Little-Endian ที่มีเครื่องหมาย 16 บิตแบบข้อมูลดิบที่ไม่มีส่วนหัวที่ 24 kHz, โมโน

ออกแบบมาสำหรับการจัดคิวบัฟเฟอร์ที่มีเวลาในการตอบสนองต่ำและการเชื่อมโยงโดยไม่มีส่วนหัวของไฟล์ต่อกลุ่ม



ข้อจำกัดและข้อกำหนด

โปรดคำนึงถึงข้อจำกัดและข้อกำหนดต่อไปนี้เมื่อใช้โมเดล Gemini 3.x TTS

  • อินพุตแบบข้อความเท่านั้น เอาต์พุตแบบเสียงเท่านั้น: โมเดล TTS จะยอมรับอินพุตแบบข้อความเท่านั้น (TextPart) และต้องตั้งค่า responseModalities เป็น AUDIO

  • การสังเคราะห์แบบคำต่อคำเท่านั้น: โมเดลจะอ่านข้อความถอดเสียงที่ให้มาแบบคำต่อคำ และไม่สร้างการตอบกลับด้วยข้อความแบบสนทนา

  • ขีดจำกัดโทเค็น: อินพุตสูงสุดคือ 8,192 โทเค็น และเอาต์พุตสูงสุดคือ 16,384 โทเค็นต่อคำขอ

  • ขีดจำกัดสำหรับผู้พูดหลายคน: MultiSpeakerVoiceConfig ต้องใช้ผู้พูด 2 คนและรองรับเฉพาะเสียงที่สร้างไว้ล่วงหน้าหลักเท่านั้น TextPart ทุกรายการในคำขอแบบหลายลำโพงต้องมี SpeechMetadata.speaker ที่ตรงกับลำโพงที่กำหนดค่าไว้รายการใดรายการหนึ่ง

  • พารามิเตอร์และเมธอดที่ไม่รองรับ

    • SDK ของ Firebase AI Logic ยังไม่รองรับการตั้งค่า responseFormat ใน GenerationConfig เพื่อลบล้างรูปแบบเอาต์พุตเสียงเริ่มต้น
    • ระบบไม่รองรับการตั้งค่า systemInstruction, temperature, topP, topK, candidateCount, presencePenalty หรือ frequencyPenalty และจะทำให้คำขอไม่สำเร็จพร้อมข้อผิดพลาด 400 INVALID_ARGUMENT
    • ไม่รองรับการเรียก countTokens สำหรับโมเดล TTS (ระบบจะแสดงผลจำนวนโทเค็นใน usageMetadata ในการตอบกลับ)
  • ตำแหน่ง (Agent Platform Gemini API (formerly Vertex AI)): เสียงที่กำหนดเอง (voice_... และ voicekey_...) ต้องใช้ตำแหน่ง global (ซึ่งเป็นตำแหน่งเริ่มต้นเมื่อใช้ Firebase AI Logic)



ย้ายข้อมูลจาก gemini-3.1-flash-tts-preview

ทั้ง gemini-3.8-flash-tts และ gemini-3.8-flash-lite-tts ใช้โครงสร้างคำขอเดียวกัน ดูตารางเปรียบเทียบโมเดลเพื่อเลือกโมเดลทดแทนที่ดีที่สุดสำหรับภาระงานของคุณ และอัปเดตโค้ดดังนี้

พื้นที่ gemini-3.1-flash-tts-preview (เดิม) gemini-3.8-flash-tts และ
gemini-3.8-flash-lite-tts
สไตล์และทิศทางการนำเสนอ ฝังอยู่ในข้อความพรอมต์ ตัวอย่างเช่น
"Say cheerfully: ...",
[Audio Profile],
[Director's Notes]
ผ่านใน SpeechMetadata(style: "...") ในแต่ละ TextPart

โปรดตรวจสอบว่าข้อความ TextPart ตรงกับข้อความถอดเสียงคำต่อคำทุกประการ

บทสนทนาที่มีผู้พูดหลายคน สตริงข้อความเดียวที่มีคำนำหน้า "Speaker: ..." ในบรรทัด TextPart 1 รายการต่อการสนทนา 1 รอบ โดยมี SpeechMetadata(speaker: "...", style: "...") ในแต่ละ TextPart
แท็กเสียงร้องในบรรทัด วงเล็บเหลี่ยม เช่น
[sigh] หรือ [laughs]
วงเล็บสามเหลี่ยม เช่น
<sigh> หรือ <laugh> หรือ <short pause>

เขียนคำพูดที่ติดขัด เช่น "uhm" ลงในข้อความโดยตรง

รูปแบบเสียงแบบ Unary เริ่มต้น (generateContent) PCM 16 บิตแบบข้อมูลดิบที่ไม่มีส่วนหัว (audio/pcm, 24 kHz, โมโน) ไฟล์ WAV ที่สมบูรณ์ (audio/wav, 16-bit PCM, 24 kHz, โมโน, พร้อมส่วนหัว RIFF ขนาด 44 ไบต์)

สตรีมมิง (generateContentStream) ยังคงเป็น PCM 16 บิตแบบข้อมูลดิบที่ไม่มีส่วนหัว (audio/l16)

คำสั่งของระบบ, อุณหภูมิ, top-P, top-K ละเว้นแล้ว ถูกปฏิเสธเนื่องจากข้อผิดพลาด 400 INVALID_ARGUMENT นำพารามิเตอร์เหล่านี้ออกจากการกำหนดค่าโมเดล

รายการตรวจสอบการย้ายข้อมูล

  • อัปเกรดเป็น Firebase AI Logic SDK เวอร์ชันล่าสุด และอัปเดตชื่อโมเดลเป็น gemini-3.8-flash-tts หรือ gemini-3.8-flash-lite-tts

  • ย้ายวิธีการจัดรูปแบบไปยัง SpeechMetadata.style: นำคำนำหน้า "Say cheerfully:", [Audio Profile], [Scene] และบล็อก [Director's Notes] ออกจากสตริงพรอมต์เพื่อให้โมเดลไม่อ่านออกเสียง ส่งคำอธิบายสไตล์ที่กระชับใน SpeechMetadata.style แทน

  • แยกสคริปต์ที่มีผู้พูดหลายคนออกเป็นเทิร์น TextPart แยกกัน: แทนที่บล็อกข้อความ "Joe: ... \n Jane: ..." ด้วยอาร์เรย์/รายการออบเจ็กต์ TextPart โดยแต่ละเทิร์นจะตั้งค่า SpeechMetadata.speaker

  • แปลงแท็ก [...] เป็นแท็ก <...>: แทนที่แท็กเสียงในวงเล็บเหลี่ยม (เช่น [whispers], [sighs], [laughs]) ด้วยแท็กเสียงร้องในวงเล็บมุม (เช่น <whispers>, <sigh>, <laugh>, <short pause>)

  • อัปเดตการเล่นเสียงแบบ Unary: เนื่องจากตอนนี้ generateContent แสดงผลไฟล์ WAV ที่สมบูรณ์ (พร้อมส่วนหัว RIFF ขนาด 44 ไบต์) แทน PCM ดิบที่ไม่มีส่วนหัว ให้นำโค้ดที่เพิ่มส่วนหัว WAV ไว้หน้าการตอบกลับแบบ Unary ด้วยตนเองออก (หรือข้ามส่วนหัวขนาด 44 ไบต์หากป้อนตัวอย่าง PCM ดิบลงใน API บัฟเฟอร์ระดับต่ำ เช่น AudioTrack ของ Android หรือ AudioClip ของ Unity)

  • นำพารามิเตอร์การกำหนดค่าที่ไม่รองรับออก: นำ temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty และ systemInstruction ออกจากการกำหนดค่า TTS GenerativeModel



คุณทำอะไรได้อีกบ้าง

ลองใช้ความสามารถอื่นๆ

ดูวิธีควบคุมการสร้างเนื้อหา

นอกจากนี้ คุณยังทดลองใช้พรอมต์และการกำหนดค่าโมเดล รวมถึงรับข้อมูลโค้ดที่สร้างขึ้นโดยใช้ Google AI Studio ได้ด้วย

ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลที่รองรับ

ดูข้อมูลเกี่ยวกับโมเดลที่พร้อมใช้งานสำหรับกรณีการใช้งานต่างๆ รวมถึงโควต้าและราคาของโมเดลเหล่านั้น


แสดงความคิดเห็นเกี่ยวกับประสบการณ์การใช้งาน Firebase AI Logic