子ども向けサイトの読み上げに Gemini TTS・Google Cloud TTS・Azure TTS・edge-tts を試した話

const utterance = new SpeechSynthesisUtterance("きりん");
utterance.lang = "ja-JP";
utterance.rate = 0.9;  // ゆっくりめ
utterance.pitch = 1.1; // 少し高めの声
 
// 高品質なネットワーク音声があれば優先
const voices = window.speechSynthesis.getVoices();
const networkVoice = voices.find(
  (v) => v.lang.startsWith("ja") && !v.localService
);
if (networkVoice) utterance.voice = networkVoice;
 
window.speechSynthesis.speak(utterance);

const VOICE = "ja-JP-Wavenet-B";
 
async function generateMp3(text: string, apiKey: string): Promise<Buffer> {
  const res = await fetch(
    `https://texttospeech.googleapis.com/v1/text:synthesize?key=${apiKey}`,
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        input: { text },
        voice: {
          languageCode: "ja-JP",
          name: VOICE,
        },
        audioConfig: {
          audioEncoding: "MP3",
          speakingRate: 0.9,
          pitch: 1.0,
        },
      }),
    }
  );
 
  if (!res.ok) {
    throw new Error(`API エラー ${res.status}: ${await res.text()}`);
  }
 
  const json = await res.json();
  return Buffer.from(json.audioContent, "base64");
}

const items = getAllItems(); // 全211アイテム
const total = items.length;
 
for (let i = 0; i < items.length; i++) {
  const { text, filePath } = items[i];
 
  // 既存ファイルはスキップ
  if (existsSync(filePath)) {
    console.log(`[${i+1}/${total}] スキップ`);
    continue;
  }
 
  const mp3 = await generateMp3(text, apiKey);
  await writeFile(filePath, mp3);
 
  // レート制限対策
  await new Promise(r => setTimeout(r, 200));
}

async function generateWithGemini(
  text: string,
  apiKey: string,
  voice: string = "Kore"
): Promise<Buffer> {
  const res = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-tts:generateContent`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-goog-api-key": apiKey,
      },
      body: JSON.stringify({
        contents: [{
          parts: [{
            text: `次のテキストをそのまま読み上げてください：${text}`
          }]
        }],
        generationConfig: {
          responseModalities: ["AUDIO"],
          speechConfig: {
            voiceConfig: {
              prebuiltVoiceConfig: { voiceName: voice },
            },
          },
        },
      }),
    }
  );
 
  if (!res.ok) throw new Error(`Gemini API エラー: ${await res.text()}`);
 
  const json = await res.json();
  const b64 = json.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
  if (!b64) throw new Error("音声データが取得できませんでした");
 
  // Gemini TTSはPCM（24kHz, mono, 16bit）を返すのでWAVヘッダーを付与
  const pcm = Buffer.from(b64, "base64");
  return Buffer.concat([buildWavHeader(pcm.byteLength), pcm]);
}

function buildWavHeader(pcmByteLength: number): Buffer {
  const sampleRate = 24000;
  const channels = 1;
  const bitsPerSample = 16;
  const byteRate = (sampleRate * channels * bitsPerSample) / 8;
  const blockAlign = (channels * bitsPerSample) / 8;
 
  const header = Buffer.alloc(44);
  header.write("RIFF", 0);
  header.writeUInt32LE(36 + pcmByteLength, 4);
  header.write("WAVE", 8);
  header.write("fmt ", 12);
  header.writeUInt32LE(16, 16);     // fmt チャンクサイズ
  header.writeUInt16LE(1, 20);      // PCM
  header.writeUInt16LE(channels, 22);
  header.writeUInt32LE(sampleRate, 24);
  header.writeUInt32LE(byteRate, 28);
  header.writeUInt16LE(blockAlign, 32);
  header.writeUInt16LE(bitsPerSample, 34);
  header.write("data", 36);
  header.writeUInt32LE(pcmByteLength, 40);
 
  return header;
}

const DELAY_MS = 2000; // リクエスト間の待機時間（レートリミット対策）
 
// クォータ超過時は翌日に再実行
if (res.status === 429) {
  console.log("クォータ超過。明日以降に再実行してください");
  process.exit(0);
}

function cacheFilePath(provider: string, voice: string, text: string): string {
  const hash = createHash("sha256")
    .update(`${provider}:${voice}:${text}`)
    .digest("hex");
  const ext = provider === "gemini" ? "wav" : "mp3";
  return path.join(CACHE_DIR, `${hash}.${ext}`);
}

const res = await fetch("/api/tts", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ text, provider: "gemini", voice: "Kore" }),
});
const blob = await res.blob();
const url = URL.createObjectURL(blob);
const audio = new Audio(url);
audio.onended = () => URL.revokeObjectURL(url);
audio.play();

const REGION = "japaneast";
const VOICE = "ja-JP-NanamiNeural";
 
async function generateWithAzure(
  text: string,
  apiKey: string
): Promise<Buffer> {
  const ssml = `
    <speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="ja-JP">
      <voice name="${VOICE}">
        <prosody rate="-10%" pitch="+5%">
          ${text}
        </prosody>
      </voice>
    </speak>`;
 
  const res = await fetch(
    `https://${REGION}.tts.speech.microsoft.com/cognitiveservices/v1`,
    {
      method: "POST",
      headers: {
        "Ocp-Apim-Subscription-Key": apiKey,
        "Content-Type": "application/ssml+xml",
        "X-Microsoft-OutputFormat": "audio-16khz-128kbitrate-mono-mp3",
      },
      body: ssml,
    }
  );
 
  if (!res.ok) {
    throw new Error(`Azure TTS エラー ${res.status}: ${await res.text()}`);
  }
 
  return Buffer.from(await res.arrayBuffer());
}

<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis"
       xmlns:mstts="http://www.w3.org/2001/mstts" xml:lang="ja-JP">
  <voice name="ja-JP-NanamiNeural">
    <prosody rate="-15%" pitch="+10%">
      きりん
    </prosody>
  </voice>
</speak>

pip install edge-tts

# 日本語の音声ファイルを生成
edge-tts --voice ja-JP-NanamiNeural --text "きりん" --write-media kirin.mp3
 
# 字幕ファイル（SRT）も同時に生成
edge-tts --voice ja-JP-NanamiNeural --text "こんにちは、世界！" \
  --write-media hello.mp3 --write-subtitles hello.srt
 
# 利用可能な音声一覧を表示
edge-tts --list-voices

import asyncio
import edge_tts
 
VOICE = "ja-JP-NanamiNeural"
 
async def generate_audio(text: str, output_file: str) -> None:
    communicate = edge_tts.Communicate(text, VOICE)
    await communicate.save(output_file)
 
asyncio.run(generate_audio("きりん", "kirin.mp3"))

# ゆっくり読み上げ
edge-tts --voice ja-JP-NanamiNeural --rate=-30% --text "きりん" --write-media slow.mp3
 
# 高い声で
edge-tts --voice ja-JP-NanamiNeural --pitch=+20Hz --text "きりん" --write-media high.mp3

import asyncio
import os
import edge_tts
 
VOICE = "ja-JP-NanamiNeural"
OUTPUT_DIR = "audio"
 
items = [
    {"text": "きりん", "file": "kirin.mp3"},
    {"text": "ぞう", "file": "zou.mp3"},
    {"text": "らいおん", "file": "lion.mp3"},
]
 
async def generate_all():
    os.makedirs(OUTPUT_DIR, exist_ok=True)
    for i, item in enumerate(items):
        path = os.path.join(OUTPUT_DIR, item["file"])
        if os.path.exists(path):
            print(f"[{i+1}/{len(items)}] スキップ: {item['text']}")
            continue
 
        communicate = edge_tts.Communicate(item["text"], VOICE)
        await communicate.save(path)
        print(f"[{i+1}/{len(items)}] 生成完了: {item['text']}")
 
asyncio.run(generate_all())