Claude Opus 5.5が出てから、Claude界隈はモーショングラフィックのPV作りでざわついています。
モーショングラフィックは、写真や文字、図形を動かして見せる映像表現です（PVはプロモーションビデオの略）。
手元でも試したくなって、お客様の会社の紹介PVを作りました。

この記事は、会社のWebサイトのURLから紹介PVを作るまでの手順をまとめたものです。

シナリオ、動画、BGMはClaude Code（Anthropic社のAIに、手元のパソコンでファイル操作やコマンド実行までさせられるツール）が作ります。

ナレーションは、GoogleのGemini TTS（テキストを人の声で読み上げる音声合成）をClaude Codeのスキルにして生成します。
VOICEVOXなど、ほかの音声合成でも作れます。
スキルは、作業の手順書と道具（スクリプト）をひとまとめにしてClaude Codeに持たせる仕組みです。
決まったフォルダに置くと、依頼の内容に応じて自動で使われます。

BGMは、音を聴けないClaudeが周波数の分布を測りながら作曲します。
使ったコードは、最後の付録にすべて載せています。

できあがるもの

今回作ったPVの仕様は次のとおりです（上の画像は、社名、所在地、人物をぼかしています）。

1920×1080（フルHD）、30fps（1秒あたり30コマ）、41.6秒、約16MB
ファイル形式はMP4（映像はH.264、音声はAAC。どちらも広く使われている圧縮方式で、パソコンでもスマホでも再生できる）
素材は会社のWebサイトに掲載されている写真とロゴだけ
ナレーションはGemini 3.8 Flash TTS
BGMは、Claudeがnumpy（Pythonで数値計算をするためのライブラリ）で合成したオリジナル曲

人とClaudeの分担は次のとおりです。

手順	人がやること	Claudeがやること
準備	スキルのファイルを置き、APIキーを登録する	（なし）
1. シナリオ	URLを渡し、確認事項に答える	サイトを読み、ナレーションとシーン割りを書く
2. ナレーション	声と読み方を決める	gemini-ttsスキルで音声を生成する
3. 文の区切り	（なし）	文字起こしで各文の時刻を求める
4. 画像	使ってよい画像か確かめる	サイトから画像を集め、記載と照らし合わせる
5. 動画	仕上がりを見る	静止画で確かめてから全編を書き出す
6. BGM	聴いて確かめる	作曲、合成、ナレーションとの音量調整
7. スキル化	スキルにする範囲を決める	会話の履歴から手順を拾い、スキルにまとめる

準備

環境

項目	バージョン	何に使うか
Claude Code	デスクトップアプリ、モデルはClaude Opus 5.5	作業全体
OS	macOS 27.2（Apple シリコン）	Apple シリコンは、Apple独自設計のCPU（M1以降）
Python	3.14.6	スクリプトを動かすプログラミング言語
Pillow	12.3.0	Pythonで画像を加工するライブラリ。動画の1コマずつの絵を描く
numpy	2.4.4	Pythonで数値計算をするライブラリ。BGMの波形の合成と、音の分析に使う
ffmpeg	8.1.2	動画や音声の変換、合成、測定をするコマンドラインのツール
mlx-whisper	0.4.3（モデルはwhisper-large-v3-turbo）	音声の文字起こし。whisperはOpenAIの音声認識モデルで、mlx-whisperはそれをApple シリコンで速く動かす版
フォント	ヒラギノ角ゴシック（macOS標準）	テロップの文字

gemini-ttsスキルを入れる

gemini-ttsは、Gemini TTS（モデル名は gemini-3.8-flash-tts）で、テキストから音声ファイル（WAV形式）を作るスキルです。
Pythonに最初から入っている機能（標準ライブラリ）だけで動くので、追加のインストールは要りません。

GeminiはAPI（プログラムから外部のサービスを呼び出す窓口）経由で使うので、APIキー（呼び出す人を識別するための鍵となる文字列。パスワードと同じく他人に見せない）を用意します。

付録Fの2ファイルを、~/.claude/skills/gemini-tts/SKILL.md と ~/.claude/skills/gemini-tts/scripts/tts.py に置く
Google AI Studio（GoogleのAIをブラウザで試したり、APIキーを発行したりできるサイト）のAPI Keysページで、APIキーを作る。制限を付けるなら「Restrict to Gemini API only」を選ぶ
~/.zshrc に export GEMINI_API_KEY=... を書き、source ~/.zshrc で読み込む。~/.zshrc は、macOSのターミナル（zsh）が起動するたびに読む設定ファイルで、ここに書いた値が環境変数（プログラムが読み取れる設定値）になる
Claude Codeのセッション（1回分の会話）を開き直す。キーを登録する前に起動したセッションには、キーが入らない
設定を確かめる。キーの値は画面に出さない

[ -n "$GEMINI_API_KEY" ] && echo 設定あり || echo なし

無料枠と有料枠

APIの料金は、Google AI Pro（GeminiアプリなどのGoogleの有料プラン）などのサブスクとは別です。
公式ドキュメントに書かれている仕組みは次のとおりです。

無料枠か有料枠かは、APIキーではなくプロジェクト（Google Cloud上で、APIキーや課金の設定をまとめる単位）ごとに決まる。プロジェクトにCloud Billing（Google Cloudの支払い設定）がつながっていれば有料枠になる
無料枠では、送ったテキストと生成物がGoogleの製品改善に使われる。有料枠では使われない
サブスクの特典はAI StudioのWeb画面の中だけに効き、APIキーでの利用は別に課金される
Google AI Proの加入者には、Google Developer Program（Googleの開発者向け会員制度）経由で月10ドルのGoogle Cloudクレジット（利用料に使える割引分）が付き、有料枠の利用料に先に充てられる。受け取るときは、APIのプロジェクトがつながっている請求先アカウント（支払い方法を登録したアカウント）を選ぶ
有料枠の単価は、出力音声100万トークンあたり9ドル（2027年1月から18ドル）。トークンは、AIが扱うデータの量を数える単位
2026年3月23日から、有料枠の課金は既定でプリペイド（先に入金した残高から引かれる方式）になった。プリペイドが要るのは有料枠に上げるときだけで、新しいアカウントは無料枠から始まる

音声1秒を32トークンとすると、40秒のナレーションは約0.012ドルになります。
32トークンは音声理解の公式な換算値で、TTSの出力にも当てはまるかは確かめていません。

無料枠のキーを作るときは、AI StudioのProjectsページで新しいプロジェクトを作り、課金（Set up billing）を設定しないままキーを作ります。
Google Cloudのコンソールで作ったプロジェクトは、同じページの「Import projects」で取り込めます。

課金を設定済みのプロジェクトは、課金を無効にすれば無料枠に戻ります。
公開済みのWebサイトの文章を読ませる程度なら無料枠で足りますが、未公開の原稿を扱うなら有料枠が向いています。

今回の環境では、無料枠のキーを作れず、有料枠のキーを使っています。
原因は特定できていません。上の無料枠の作り方は公式ドキュメントの記述で、この環境では試していません。

手順1 サイトからシナリオを作る

Claude Codeに、URL、テーマ、尺（動画の長さ）、文の数を渡します。
今回送ったプロンプト（Claudeへの指示文）は次のとおりです（URLだけ置き換えています）。

https://www.example.co.jp
このホームページの内容を元に３０秒の会社のプロモーション動画を作成したい。
テーマ：会社紹介
ナレーション原稿を８文程度でかいて、１文ごとに「画面に何を出すか」のシーン割利もつけたシナリオを作成して。

出典の確認まで頼むなら、次の形にすると後の手順が楽になります。

<URL>
このホームページの内容を元に、<N>秒前後の会社紹介動画のシナリオを作って。
ナレーションは<M>文程度。1文ごとに「画面に何を出すか」と「テロップ」も付けて。
数字や固有名詞は、どのページのどの記載から取ったかを添えて。

Claudeは、トップページから会社案内、選ばれる理由、設備一覧、製品実績などのページをたどります。
そのうえで、ナレーションとシーン割り（場面ごとに何を映すかの割り当て）を書きます。
トップページだけでは、設備の型番や製品の寸法がわからないためです。
今回の出力は次の8文でした。

#	ナレーション	画面に出すもの
1	静岡県〇〇市。精密切削加工のA社です。	新工場の外観
2	光学機器や医療機器の、新しい製品づくりを支えています。	光学部品と医療機器部品の物撮り
3	扱うのは、アルミや銅、ステンレスなどの非鉄金属。	材料と加工中のアップ
4	厚さ0.3ミリのフィンも、一個から削り出します。	ヒートシンクのマクロ撮影
5	開発や試作の段階から、最適な加工方法を提案します。	図面を前にした打ち合わせ、3Dプリンター
6	三次元測定機とマイクロスコープで、品質を一つずつ確かめます。	測定機のプローブ、マイクロスコープの画面
7	新工場で、30代を中心としたチームが挑み続けています。	社員の表情、協働ロボット
8	（経営理念）。A社。	集合写真からロゴへ

シナリオを受け取ったら、次の3点を確かめます。

数字の出典。今回は「0.3ミリ」が製品実績ページのヒートシンク（熱を逃がすための部品。フィンと呼ぶ薄い板が並ぶ）の備考、「一個から」が選ばれる理由のページから取られていた
Claudeが外した情報。今回は、取引先の社名（宣伝に使うには先方の許可が要る）、言い方を誤ると誇大表現になりやすい受賞関係の実績、古い従業員数が外されていた
Claudeが挙げた確認事項。今回は「部品を物撮り（商品を撮影すること）してよいか」と「『30代中心』は今も正しいか」を聞かれ、次の一行で答えた

２、４はそのまま使用して問題なし。７は現状も同じ。

手順2 ナレーション音声を作る

シナリオの各文を1行ずつ書いた原稿ファイルを用意し、gemini-ttsスキルで読ませます。

/gemini-tts
narration.txt を読み上げて。声は Kore、スタイルは "calm, warm and trustworthy corporate narration, moderate pace"。

スキルは、音声の narration.wav と、長さや声を記録した narration.json（JSONはデータを書き留める形式の一つ）を出力します。
声は30種類から選べます（一覧は付録FのSKILL.mdにあります）。
スタイルは読み方の指示で、話し方の雰囲気や速さを英語で書きます。

尺はTTSの読む速さで決まります。
今回は30秒のつもりで8文（約200字）にしましたが、音声は39.6秒になりました。
動画は音声に合わせて延ばすので、最初から「尺は音声に合わせてよい」と伝えておきます。

今回のPVのナレーションは、AI StudioのWeb画面で同じモデルを使って生成したものです。
スキルでも、8文程度の原稿を一度に読ませてナレーションを作れることを確かめています。
原稿を1行ずつ生成して各行の時刻をJSONに出す --split は、APIの応答を偽物に差し替えたテストでしか確かめていません。

ほかの音声合成を使う場合

この手順ではGemini 3.8 Flash TTSを使いましたが、音声合成はほかのものに替えられます。
手順3以降に必要なのは、ナレーションの音声ファイル（WAVなど）だけだからです。

たとえばVOICEVOX（無料で使える日本語の音声合成ソフト）は、手元のパソコンで動くので、APIキーも利用料も要りません。
VOICEVOXを起動しておくと、音声を作るエンジンが http://localhost:50021 で呼び出しを受け付けます。
Claude Codeに「VOICEVOXのエンジンで narration.txt を読み上げて、WAVで保存して」と頼めば、この窓口を使って音声を作れます。

使うときは、利用規約を確かめてください。
VOICEVOXは商用、非商用を問わず使えますが、VOICEVOXを使ったことがわかるクレジット表記が必要です。
さらに、声（キャラクター）ごとにも規約があります。

手順3 文の区切りの時刻を求める

テロップ（画面に重ねて出す文字）とシーンの切り替えを読み上げに合わせるため、各文の開始と終了の時刻を求めます。

ffmpegの無音検出（silencedetect）だけでは、読点の間と文の間を区別できません。
今回のナレーションでは、無音が21か所見つかりました。
そこで、mlx-whisper（Apple シリコン向けのwhisper）で単語ごとの時刻を取ります（コマンドは付録B）。
文字起こしは多少の誤変換（「光学機器」が「工学機器」になるなど）があっても、時刻を取る用途には支障がありません。

シーンの切り替え位置は、文と文の間の無音の中央に置きます。
今回は、音声上の時刻で4.93秒、10.15秒、15.03秒、19.25秒、24.06秒、29.80秒、34.66秒、37.27秒でした。
動画の冒頭には0.4秒の間を入れるので、映像上の時刻はそれぞれ0.4秒ずつ後ろになります。

--split で生成した音声なら、narration.json の時刻をそのまま使えます（上の注意書きのとおり、実際のAPIでは未検証です）。

手順4 サイトの画像を集める

手順5のプロンプトに「ホームページの画像も使って」と書くと、Claudeが画像を集めます。
Webページの画像は、HTML（ページの文章と構造）の画像タグ <img> か、CSS（ページの見た目の設定）の背景指定 url() に書かれています。
Claudeはこの両方から画像のURLを一覧にしてダウンロードし（今回は70枚）、縮小一覧（コンタクトシート）を作って中身を確かめます。

テロップに出す材質名なども、製品実績ページの記載と照らし合わせます。
今回は、土台の部品がA5052、LEDを固定する部品がC1020、筒状の部品がSUS316Lでした。
どれも材料の規格記号で、順にアルミ合金、純度の高い銅、ステンレスです。

人が確かめることは次の3点です。

画像を動画に使ってよいか。サイトの写真でも、使ってよいかは事前に先方に確かめる
写真と読み上げの内容が合っているか。今回は「マイクロスコープ」の場面で、サイトの人物写真に写っていたのが実体顕微鏡（両目でのぞく低倍率の顕微鏡）だったため、Claudeが設備一覧のデジタルマイクロスコープ（拡大した像をカメラで撮ってモニターに映す顕微鏡）の写真を使った
解像度。今回のサイトの写真は幅750〜1000pxが多く、1920pxの画面いっぱいに引き伸ばすとぼける。そのため手順5では、写真を全画面ではなくカードとして置いた

手順5 動画を書き出す

ナレーション音声を渡して、動画を頼みます。
今回送ったプロンプトは次のとおりです（ファイル名だけ置き換えています）。

@ナレーション.wav
シナリオを元にナレーション用の音声ファイルを作りました。
ホームページの画像も使って、シナリオに沿ったモーショングラフィック動画をプロモーションビデオとして作成してください。

尺と確認の仕方も指定するなら、次の形にします。

@<ナレーション>.wav
この音声に合わせて、ホームページの画像を使ったモーショングラフィック動画を作って。
尺は音声に合わせてよい。全編を書き出す前に、各シーンの静止画を見せて。

今回のPVで、Claudeが作った画面の構成は次のとおりです。

写真は白いフチと影を付けたカードにし、背景にはサイトの白地に緑の曲線の画像（幅4000px）か、同じ写真を強くぼかして暗くしたものを敷く
ブランドカラー（その会社のロゴなどに使われる決まった色）は、ロゴ画像の色を集計して取る（今回は緑の #1E964D とグレーの #595A5C。#で始まる値は色を表すコード）
テロップは手順3の単語の時刻に合わせて出す。たとえば「アルミ」11.14秒、「銅」12.16秒、「ステンレス」12.68秒と間が約0.5秒しかない箇所は、文字を0.25秒で出し切る
シーンの切り替えは、ブランドカラーの斜めの帯が横切る0.4秒のワイプ（画面を拭うように次の場面へ移る切り替え効果）にし、文と文の間の無音の中央に置く
写真のゆっくりしたズームは、Pillowで画像の拡大縮小をする resize() の box 引数に小数の座標を渡して、1ピクセル未満の単位で切り出す（整数座標だと絵がカクつく）

bw, bh = self.cw / zoom, self.ch / zoom
box = (self.cx - bw / 2, self.cy - bh / 2, self.cx + bw / 2, self.cy + bh / 2)
photo = self.src.resize((self.w, self.h), Image.BICUBIC, box=box)

描画はPillowで1フレーム（1コマ）ずつ行います。
描いた絵は、圧縮していない画素のデータのまま、パイプ（プログラムの出力を別のプログラムへ直接流す仕組み）でffmpegに渡します。
書き出しは次の順で進めます。

静止画を書き出して確かめる（python3 render.py preview 4.6 9.5 14.2 ...）。今回はこの段階で、4シーン目の「mm」が画面の右端で切れていることと、7シーン目の下半分が空きすぎていることが見つかった
直してから全編を書き出す（python3 render.py render promo.mp4）。今回は1,248フレームで、手元のMacで約45秒だった
ffprobe（ffmpegに付属する、動画ファイルの中身を調べるツール）で尺と、映像と音声のトラックがそろっていることを確かめ、完成した動画からフレームを抜き出してテロップのタイミングを確かめる

付録Cのrender.pyにある時刻（CUTS や T(11.10) など）は今回のナレーション専用の値なので、手順3で求めた時刻に置き換えます。

手順6 BGMを付ける

最後にBGMを頼みます。
今回は、動画を受け取ったあとで次のように聞きました。

これBGMつけられない？

既存の曲を使うとライセンスの確認が要るので、Claudeはnumpyで作曲から合成までを行います（付録D）。

今回の曲は、120BPM（1分間に120拍の速さ）の長調（明るい響きの調）で、コード進行（和音の並び）はD、A、Bm、Gの繰り返しです。
楽器は、ピアノ風のアルペジオ（和音を1音ずつ順に鳴らす弾き方）、パッド（背景で長く鳴る柔らかい和音）、ベース、軽いドラムです。
冒頭4秒はドラムを入れず、エンドカード（最後にロゴを出す画面）の38秒で主和音（曲の中心になる和音）に落ち着いて、フェードアウトします。

Claudeは音を聴けません。
そこで耳の代わりに、スペクトログラム（音の高さごとの強さを、時間に沿って色で描いた図）と、帯域（音の高さの範囲）ごとのエネルギーを測って調整します。

下の表のdBは全体に対する比で、0に近いほどその帯域の音が大きく、マイナスが大きいほど小さいことを表します。
kHz（キロヘルツ）は音の高さの単位で、数字が大きいほど高い音です。

今回は、最初の合成で12kHz以上の高い音が全体に対して-7.2dBもあり、ハイハット（シャンシャンと刻むシンバル）の音が強すぎました。
Claudeはハイハットとクラップ（手拍子の音）の高さの範囲を絞りました。
次に低い音が大半を占めたので、キック（ドンと鳴る低い太鼓）とベースを下げています。

帯域（10〜20秒の区間）	初回	ハイハットの帯域を制限	キックとベースを下げる
0〜250Hz	-2.3dB	-1.3dB	-2.5dB
250Hz〜2kHz	-7.1dB	-6.0dB	-3.8dB
2〜6kHz	-20.4dB	-21.5dB	-19.3dB
6〜12kHz	-16.7dB	-25.6dB	-23.4dB
12〜24kHz	-7.2dB	-56.5dB	-54.3dB

ナレーションとの合成は、次の2点を目安にします（コマンドは付録E）。

ffmpegの sidechaincompress（別の音が鳴っている間だけ音量を下げるフィルタ）で、ナレーションが鳴っている間だけBGMを下げる。この処理をダッキングと呼ぶ。台詞中の声とBGMの差は12〜16dBほど取る。今回は最初の設定で8.6〜12.2dBしかなく、BGMをさらに4dB下げて12.8〜16.4dBにした
全体の音量をLUFSでそろえる。LUFSは人が感じる音の大きさの単位で、放送局や動画配信サービスは、この値で番組ごとの音量をそろえている。目安は、話し声が中心の配信なら-16 LUFS前後、YouTubeなら-14 LUFS前後
今回は元のナレーションが-22.8 LUFSと小さめだったので、リミッター（音が一定の大きさを超えないように抑える処理）で最大音量を抑えながら、-16.1 LUFSまで持ち上げた

数値で合わせられるのは、ここまでです。
曲の雰囲気が合っているか、BGMの音量が聴いて心地よいかは、人が再生して確かめます。

手順7 スキルにして繰り返し使う

ここまでの手順を一通り終えたら、同じ会話の最後で /skill-creator を使うと、この流れをスキルにできます。
skill-creatorは、スキルを作るためのスキルです。
会話の履歴から、使ったツール、作業の順序、途中で入れた修正を拾い、SKILL.mdにまとめます。

/skill-creator この会話の、サイトのURLから紹介PVを作る流れをスキルにして

skill-creatorは、作り始める前に作り方を確かめてきます。
ほかのサイトにも使えるスキルにするなら、次のように答えます。

1本のPV専用に書いた動画のプログラムは、場面の構成を設定ファイルで渡せる汎用の形に作り直す
画面の形は、横長と縦長の両方に対応させる
音量の標準を決める（YouTubeに載せるなら-14 LUFS）
題材にしたのとは別のサイトで、1本通しで作って確かめる

できあがるスキルは、手順書のSKILL.mdと、次のようなスクリプトの組み合わせになります。

スクリプト	役割
collect_images.py	サイトの各ページから画像とロゴを集め、縮小一覧を作る
word_times.py	ナレーションを文字起こしし、文の区切りとシーンの切り替え位置を求める
render.py	場面の構成を書いた設定ファイル（scenes.json）から、動画を1コマずつ描いて書き出す
bgm.py	長さ、テンポ、調を指定してBGMを作曲し、音の高さの範囲ごとのエネルギーを測る
mix.py	ナレーションとBGMを合成し、全体の音量をそろえ、声とBGMの音量差を報告する

スキルにしておけば、以後は「このURLからPVを作成して」と頼むだけで、画像集めからBGMまでを同じ流れで進められます。
ただし、次の2か所では、Claudeが手を止めて人の返事を待ちます。
サイトの事実や権利、音の聴こえ方は、Claudeには判断できないためです。

シナリオができたところで、確認事項（写真を使ってよいか、今も正しい記載か、料金の条件、連絡先を載せるかなど）に答え、シナリオを承認する
最後に、BGM入りの動画を聴いて確かめる

スキルを使うときに気をつけること

別のサイトで1本作ると、題材にしたサイトでは起きなかった問題が見つかる。ロゴ画像の形、HTMLの書き方、ナレーションの音量はサイトや音声合成ごとに違うためで、見つかった問題はその会話でClaudeに直させる
スキルは、画像集めをシナリオより先に行う。画面に出す写真は、サイトに実在するものでしか決められないため
Claude Codeを開いているフォルダがgitのリポジトリ（変更履歴を管理しているフォルダ）なら、スキルは一時フォルダで作業する。試作の画像や動画がリポジトリに混ざり、誤って公開するのを防ぐため
文の区切りを求めたあとは、Claudeが表示する聞き取りの結果と原稿を1文ずつ見比べる。英字の製品名がカタカナで聞き取られるなどの聞き違いで、切り替えの位置がずれることがある

振り返り

聴けない音源を、スペクトログラムと帯域ごとのエネルギーを測って調整する。
こういう進め方は初めて見ました。
ハイハットのシャーという音を「12kHz以上が-7.2dB」という数字で見つけてきたときは、おおっと思いました。

それ以上に感じたのは、Opus 5.5のモーショングラフィックを作る力のすごさです。
こちらが渡したのは、URLとナレーション音声、あとは数回の短い返事だけでした。
それで、読み上げに合わせてテロップが出る41.6秒のPVができあがります。
全編の書き出しも、手元のMacで約45秒でした。

ここまで手軽になると、YouTubeのショート動画は、こうして作られた動画であふれていくと思います。
見た目だけ整った中身の薄い動画が大量に流れる、いわゆるスロップ（AIで大量生産された質の低いコンテンツ）の現象が、動画でも起きるのではないか。
今回PVを作ってみて、いちばん強く残ったのはその予感でした。

付録：全コードと再現手順

A. サイトの画像を集める

各ページのHTMLを取得し、<img> タグとCSSの url() から画像のURLを一覧にします。

画像URLの一覧を作るコマンド

mkdir -p html img
cd html
for p in "" precision technology quality reverse-engineering elected facility product company recruit; do
    n=${p:-top}
    curl -sL -A "Mozilla/5.0" "https://www.example.co.jp/$p/" -o $n.html
done

python3 - <<'EOF'
import re, glob
seen = {}
for f in sorted(glob.glob('*.html')):
    h = open(f, encoding='utf-8', errors='ignore').read()
    for m in re.finditer(r'<img[^>]*>', h):
        t = m.group(0)
        src = re.search(r'(?:data-src|src)="([^"]+)"', t)
        alt = re.search(r'alt="([^"]*)"', t)
        if src and not src.group(1).startswith('data:'):
            seen.setdefault(src.group(1), (f, alt.group(1) if alt else ''))
    for m in re.finditer(r'url\(["\']?([^)"\']+\.(?:jpe?g|png|webp))', h):
        seen.setdefault(m.group(1), (f, '(css bg)'))
for u, (f, a) in seen.items():
    print(f"{f:22s} {a[:30]:30s} {u}")
EOF

一覧とalt属性を見て、使う画像をダウンロードします。
トップのメインビジュアルなどはCSSの背景画像なので、テーマのCSS（style_base.css、style_skin.css）の url() も調べます。

画像をダウンロードするコマンド

cd ../img
B=https://www.example.co.jp/wp-content/themes/example/images
for n in logo.jpg access.jpg back_image.jpg message_1.jpg message_2.jpg message_3.jpg recruit_back.jpg technology_main.jpg top_back_processing.jpg top_back_technology.jpg top_back_quality.jpg top_back_strong.jpg top_back_recruit.jpg top_processing.jpg top_facility.jpg top_company.jpg elected-main.jpg elected-GoAction.jpg elected-1.jpg elected-2.jpg elected-3.jpg elected-4.jpg facility-01.jpg facility-02.jpg facility-03.jpg facility-04.jpg facility-05.jpg facility-06.jpg facility-07.jpg facility-08.jpg precision-1.jpg precision-2.jpg precision-3.jpg precision-4.jpg precision-circle-3.jpg product-01.jpg product-02.jpg product-03.jpg product-04.jpg product-05.jpg product-06.jpg product-07.jpg product-08.jpg product-09.jpg product-10.jpg product-11.jpg product-12.jpg product-13.jpg quality_circle-1.jpg quality_circle-2.jpg quality-1.jpg quality-2.jpg quality-3.jpg quality-4.jpg quality-5.jpg recruit-1.jpg recruit-2.jpg recruit-3.jpg recruit-4.jpg recruit-5.jpg recruit-6.jpg recruit-7.jpg recruit-8.jpg recruit-9.jpg technology_circle-1.jpg technology_circle-2.jpg technology-1.jpg technology-2.jpg technology-3.jpg; do
    curl -sfL -A "Mozilla/5.0" "$B/$n" -o "$n" || echo "fail $n"
done
# トップページの外観画像（アップロード領域にある）
curl -sfL -A "Mozilla/5.0" "https://www.example.co.jp/wp-content/uploads/2022/12/%E5%A4%96%E8%A6%B32.png" -o gaikan2_full.png

B. 文の区切りの時刻を取る

無音検出だけでは読点の間と文の間を区別できないので、単語ごとの時刻を文字起こしで取ります。

無音検出と文字起こしのコマンド

# 無音の区間を出す（候補が多すぎて、これだけでは文の区切りを決められない）
ffmpeg -hide_banner -i narration.wav -af silencedetect=noise=-35dB:d=0.25 -f null - 2>&1 | grep -E "silence_(start|end)"

# mlx-whisper で単語ごとの時刻を出す（Apple シリコン向け）
python3 -m venv venv
./venv/bin/pip install mlx-whisper
./venv/bin/python -c "
import mlx_whisper, json
r = mlx_whisper.transcribe('narration.wav', path_or_hf_repo='mlx-community/whisper-large-v3-turbo', language='ja', word_timestamps=True)
json.dump(r, open('asr.json', 'w'), ensure_ascii=False)
for s in r['segments']:
    print(f\"{s['start']:6.2f}-{s['end']:6.2f} {s['text']}\")
    print('   ', ' '.join(f\"{w['word']}@{w['start']:.2f}\" for w in s['words']))
"

C. 動画のレンダラー

img/ に画像、同じフォルダに narration.wav を置いて実行します。
CUTS や T(11.10) などの時刻は、今回のナレーション専用の値です。

python3 render.py preview 4.6 9.5 14.2   # 指定した秒の静止画を書き出す
python3 render.py render promo.mp4  # 全編を書き出す

render.py（全文）

render.py

#!/usr/bin/env python3
"""A社 会社紹介モーショングラフィック動画のレンダラー

使い方:
    python3 render.py preview 1.0 12.5 ...   # 指定秒のフレームを preview_*.png に書き出す
    python3 render.py render out.mp4         # 全編をレンダリングして音声と合成する
"""
import subprocess
import sys
from pathlib import Path

import numpy as np
from PIL import Image, ImageDraw, ImageFilter, ImageFont

BASE = Path(__file__).resolve().parent
IMG = BASE / "img"
AUDIO = BASE / "narration.wav"

W, H, FPS = 1920, 1080, 30
LEAD = 0.4           # 音声の前に入れる無音（秒）
TOTAL = 41.6         # 音声 39.56 秒 + リード + エンドカード保持
MX, MY = 96, 60      # セーフマージン

GREEN = (30, 150, 77)
LIME = (141, 198, 63)
GRAY = (89, 90, 92)
DARK = (40, 42, 44)
WHITE = (255, 255, 255)

F_W3 = "/System/Library/Fonts/ヒラギノ角ゴシック W3.ttc"
F_W6 = "/System/Library/Fonts/ヒラギノ角ゴシック W6.ttc"
F_W8 = "/System/Library/Fonts/ヒラギノ角ゴシック W8.ttc"

_font_cache = {}


def font(path, size):
    key = (path, size)
    if key not in _font_cache:
        _font_cache[key] = ImageFont.truetype(path, size)
    return _font_cache[key]


def T(a):
    """音声上の時刻を動画上の時刻に変換する"""
    return LEAD + a


# 文と文の間の無音の中央（音声時刻）。ここでシーンを切り替える
CUTS = [T(x) for x in (4.93, 10.15, 15.03, 19.25, 24.06, 29.80, 34.66, 37.27)]
TRANS = 0.4


def clamp(v, lo=0.0, hi=1.0):
    return max(lo, min(hi, v))


def ease_out(p):
    p = clamp(p)
    return 1 - (1 - p) ** 3


def ease_in_out(p):
    p = clamp(p)
    return 4 * p ** 3 if p < 0.5 else 1 - (-2 * p + 2) ** 3 / 2


def lerp(a, b, p):
    return a + (b - a) * p


# ---------------------------------------------------------------- 部品の生成

def text_img(text, fpath, size, fill, shadow=False):
    f = font(fpath, size)
    l, t, r, b = f.getbbox(text)
    pad = 16 if shadow else 2
    img = Image.new("RGBA", (r - l + pad * 2, b - t + pad * 2), (0, 0, 0, 0))
    if shadow:
        sh = Image.new("RGBA", img.size, (0, 0, 0, 0))
        ImageDraw.Draw(sh).text((pad - l + 2, pad - t + 3), text, font=f, fill=(0, 0, 0, 160))
        img = Image.alpha_composite(img, sh.filter(ImageFilter.GaussianBlur(6)))
    ImageDraw.Draw(img).text((pad - l, pad - t), text, font=f, fill=fill)
    return img


def chip(text, fpath, size, fg, bg, padx=28, pady=16, radius=10, accent=None):
    f = font(fpath, size)
    l, t, r, b = f.getbbox(text)
    acc_w = 14 if accent else 0
    w = r - l + padx * 2 + acc_w
    h = size + pady * 2
    img = Image.new("RGBA", (w, h), (0, 0, 0, 0))
    d = ImageDraw.Draw(img)
    d.rounded_rectangle((0, 0, w - 1, h - 1), radius=radius, fill=bg)
    if accent:
        d.rounded_rectangle((0, 0, acc_w + radius, h - 1), radius=radius, fill=accent)
        d.rectangle((acc_w, 0, acc_w + radius, h - 1), fill=bg)
    # 字面の縦位置をボックス中央に合わせる
    d.text((padx + acc_w - l, (h - (b - t)) / 2 - t), text, font=f, fill=fg)
    return add_shadow(img, blur=10, offset=(0, 6), opacity=70)


def add_shadow(img, blur=16, offset=(0, 10), opacity=90):
    m = blur * 2
    w, h = img.size
    canvas = Image.new("RGBA", (w + m * 2, h + m * 2), (0, 0, 0, 0))
    a = img.getchannel("A").point(lambda v: v * opacity // 255)
    sh = Image.new("RGBA", img.size, (0, 0, 0, 255))
    sh.putalpha(a)
    canvas.paste(sh, (m + offset[0], m + offset[1]), sh)
    canvas = canvas.filter(ImageFilter.GaussianBlur(blur))
    canvas.alpha_composite(img, (m, m))
    canvas.info["shadow_margin"] = m
    return canvas


def telop(text, size=56):
    """下部テロップ：緑の帯＋ライムのアクセント"""
    return chip(text, F_W6, size, WHITE, GREEN + (240,), padx=40, pady=24, radius=8, accent=LIME)


def keyed_logo(width):
    """ロゴJPEGの白地を透過にする"""
    src = Image.open(IMG / "logo.jpg").convert("RGB")
    src = src.resize((width, round(src.height * width / src.width)), Image.LANCZOS)
    arr = np.asarray(src).astype(np.float32)
    mn = arr.min(axis=2)
    a = np.clip((255 - mn) / 255 * 1.6, 0, 1)
    rgb = np.where(a[..., None] > 0.01, (arr - (1 - a[..., None]) * 255) / np.maximum(a[..., None], 0.01), 0)
    out = np.dstack([np.clip(rgb, 0, 255), a * 255]).astype(np.uint8)
    return Image.fromarray(out, "RGBA")


def logo_bug():
    logo = keyed_logo(250)
    w, h = logo.width + 36, logo.height + 24
    img = Image.new("RGBA", (w, h), (0, 0, 0, 0))
    ImageDraw.Draw(img).rounded_rectangle((0, 0, w - 1, h - 1), radius=10, fill=(255, 255, 255, 235))
    img.alpha_composite(logo, (18, 12))
    return add_shadow(img, blur=8, offset=(0, 4), opacity=50)


# ---------------------------------------------------------------- 背景

class BrandBG:
    """サイトの白地＋緑スウッシュ画像をゆっくり流す"""

    def __init__(self, name="top_back_strong.jpg", flip=False):
        src = Image.open(IMG / name).convert("RGB")
        if flip:
            src = src.transpose(Image.FLIP_LEFT_RIGHT)
        sw = int(W * 1.08)
        self.src = src.resize((sw, round(src.height * sw / src.width)), Image.LANCZOS)
        if self.src.height < H * 1.04:
            sh = int(H * 1.08)
            self.src = src.resize((round(src.width * sh / src.height), sh), Image.LANCZOS)

    def frame(self, p):
        sw, sh = self.src.size
        x = lerp(0, sw - W, p)
        y = (sh - H) / 2
        return self.src.resize((W, H), Image.BICUBIC, box=(x, y, x + W, y + H))


class BlurBG:
    """写真をぼかし、暗く緑がかった色にして敷く"""

    def __init__(self, name, darken=0.45, tint=0.22):
        src = Image.open(IMG / name).convert("RGB")
        sw, sh = int(W * 1.12), int(H * 1.12)
        s = max(sw / src.width, sh / src.height)
        src = src.resize((round(src.width * s), round(src.height * s)), Image.LANCZOS)
        src = src.filter(ImageFilter.GaussianBlur(30))
        arr = np.asarray(src).astype(np.float32) * darken
        arr = arr * (1 - tint) + np.array((10, 70, 40), np.float32) * tint
        self.src = Image.fromarray(np.clip(arr, 0, 255).astype(np.uint8))

    def frame(self, p):
        sw, sh = self.src.size
        z = lerp(1.0, 1.06, p)
        bw = min(sw, W * 1.12 / z)
        bh = bw * H / W
        x = (sw - bw) / 2
        y = (sh - bh) / 2
        return self.src.resize((W, H), Image.BICUBIC, box=(x, y, x + bw, y + bh))


# ---------------------------------------------------------------- 要素

def with_alpha(img, p):
    if p >= 0.999:
        return img
    out = img.copy()
    out.putalpha(img.getchannel("A").point(lambda v: int(v * p)))
    return out


class El:
    """静止RGBAレイヤーの登場アニメーション"""

    def __init__(self, img, x, y, t_in, anim="up", dur=0.35):
        self.img, self.x, self.y, self.t_in, self.anim, self.dur = img, x, y, t_in, anim, dur
        # add_shadow した画像は余白ぶん左上にずらして置く
        self.m = img.info.get("shadow_margin", 0)

    def draw(self, canvas, t):
        if t < self.t_in:
            return
        p = ease_out((t - self.t_in) / self.dur)
        img = self.img
        x, y = self.x - self.m, self.y - self.m
        if self.anim == "up":
            y += (1 - p) * 40
            img = with_alpha(img, p)
        elif self.anim == "left":
            x -= (1 - p) * 90
            img = with_alpha(img, p)
        elif self.anim == "right":
            x += (1 - p) * 90
            img = with_alpha(img, p)
        elif self.anim == "fade":
            img = with_alpha(img, p)
        elif self.anim == "scale":
            s = 0.82 + 0.18 * p
            if s < 0.999:
                w, h = img.size
                nw, nh = max(1, round(w * s)), max(1, round(h * s))
                img = img.resize((nw, nh), Image.BICUBIC)
                x += (w - nw) / 2
                y += (h - nh) / 2
            img = with_alpha(img, p)
        elif self.anim == "wipe":
            w = round(img.width * p)
            if w <= 0:
                return
            img = img.crop((0, 0, w, img.height))
        canvas.paste(img, (round(x), round(y)), img)


class Typing(El):
    """背景の帯は一気に出し、文字は1字ずつ出す"""

    def __init__(self, text, fpath, size, x, y, t0, t1):
        self.text, self.f, self.t0, self.t1 = text, font(fpath, size), t0, t1
        l, t, r, b = self.f.getbbox(text)
        padx, pady = 56, 34
        w, h = r - l + padx * 2, size + pady * 2
        band = Image.new("RGBA", (w, h), (0, 0, 0, 0))
        ImageDraw.Draw(band).rounded_rectangle((0, 0, w - 1, h - 1), radius=12, fill=GREEN + (242,))
        self.band = add_shadow(band, blur=14, offset=(0, 8), opacity=90)
        self.txt = Image.new("RGBA", (w, h), (0, 0, 0, 0))
        ImageDraw.Draw(self.txt).text((padx - l, (h - (b - t)) / 2 - t), text, font=self.f, fill=WHITE)
        self.padx, self.l = padx, l
        super().__init__(self.band, x, y, t0 - 0.2, "fade", 0.25)

    def draw(self, canvas, t):
        if t < self.t_in:
            return
        super().draw(canvas, t)
        n = int(len(self.text) * clamp((t - self.t0) / (self.t1 - self.t0))) + (1 if t >= self.t0 else 0)
        n = min(n, len(self.text))
        if n <= 0:
            return
        cw = self.padx + round(self.f.getlength(self.text[:n]))
        part = self.txt.crop((0, 0, cw, self.txt.height))
        canvas.paste(part, (self.x, self.y), part)


class Card:
    """白フチ＋影つきの写真カード。中身はゆっくりズームする"""

    def __init__(self, name, x, y, w, h, t_in, span, anim="up", z=(1.0, 1.08), focus=(0.5, 0.5), border=10):
        src = Image.open(IMG / name).convert("RGB")
        self.src, self.x, self.y, self.w, self.h = src, x, y, w, h
        self.t_in, self.span, self.anim, self.z, self.b = t_in, span, anim, z, border
        sw, sh = src.size
        ar = w / h
        self.cw, self.ch = (sh * ar, sh) if sw / sh > ar else (sw, sw / ar)
        self.cx = clamp(sw * focus[0], self.cw / 2, sw - self.cw / 2)
        self.cy = clamp(sh * focus[1], self.ch / 2, sh - self.ch / 2)
        frame = Image.new("RGBA", (w + border * 2, h + border * 2), WHITE + (255,))
        self.shadow = add_shadow(frame, blur=20, offset=(0, 14), opacity=110)
        self.m = self.shadow.info["shadow_margin"]

    def draw(self, canvas, t):
        if t < self.t_in:
            return
        p = ease_out((t - self.t_in) / 0.4)
        zp = clamp((t - self.span[0]) / (self.span[1] - self.span[0]))
        zoom = lerp(self.z[0], self.z[1], zp)
        bw, bh = self.cw / zoom, self.ch / zoom
        box = (self.cx - bw / 2, self.cy - bh / 2, self.cx + bw / 2, self.cy + bh / 2)
        photo = self.src.resize((self.w, self.h), Image.BICUBIC, box=box)
        x, y = self.x, self.y
        if self.anim == "up":
            y += (1 - p) * 60
        elif self.anim == "left":
            x -= (1 - p) * 120
        elif self.anim == "right":
            x += (1 - p) * 120
        x, y = round(x), round(y)
        sh = with_alpha(self.shadow, p)
        canvas.paste(sh, (x - self.m, y - self.m), sh)
        framed = Image.new("RGB", (self.w + self.b * 2, self.h + self.b * 2), WHITE)
        framed.paste(photo, (self.b, self.b))
        mask = Image.new("L", framed.size, round(255 * p))
        canvas.paste(framed, (x, y), mask)


# ---------------------------------------------------------------- シーン

class Scene:
    def __init__(self, t0, t1, bg, elements, bug=True):
        self.t0, self.t1, self.bg, self.els, self.bug = t0, t1, bg, elements, bug

    def render(self, t):
        p = clamp((t - self.t0) / (self.t1 - self.t0 + TRANS))
        canvas = self.bg.frame(p).copy()
        for el in self.els:
            el.draw(canvas, t)
        if self.bug:
            canvas.paste(BUG, (W - MX - BUG.width + BUG.info["shadow_margin"], MY - BUG.info["shadow_margin"]), BUG)
        return canvas


def build_scenes():
    c = [0.0] + CUTS + [TOTAL]
    sc = []

    # 1. 静岡県〇〇市。精密切削加工のA社です。
    s0, s1 = c[0], c[1]
    logo = keyed_logo(560)
    sc.append(Scene(s0, s1, BrandBG(), [
        Card("access.jpg", MX, 170, 1120, 730, s0 + 0.05, (s0, s1 + TRANS), "left", z=(1.0, 1.1), focus=(0.55, 0.5)),
        El(chip("静岡県〇〇市", F_W6, 42, WHITE, GREEN), 1290, 330, T(0.05), "left"),
        El(text_img("精密切削加工の", F_W6, 66, DARK), 1290, 440, T(1.85), "up"),
        El(logo, 1285, 545, T(3.35), "scale", 0.4),
    ], bug=False))

    # 2. 光学機器や医療機器の、新しい製品づくりを支えています。
    s0, s1 = c[1], c[2]
    cw, ch = 788, 536
    x0 = (W - (cw * 2 + 70)) // 2
    sc.append(Scene(s0, s1, BrandBG(flip=True), [
        Card("product-03.jpg", x0, 170, cw, ch, T(5.25), (s0, s1 + TRANS), "up"),
        El(chip("光学機器", F_W6, 40, WHITE, GREEN), x0 + 24, 170 + ch - 50, T(5.44), "left"),
        Card("product-01.jpg", x0 + cw + 70, 170, cw, ch, T(6.10), (s0, s1 + TRANS), "up"),
        El(chip("医療機器", F_W6, 40, WHITE, GREEN), x0 + cw + 70 + 24, 170 + ch - 50, T(6.28), "left"),
        El(telop("光学機器・医療機器業界をサポート"), x0, 860, T(7.30), "wipe", 0.4),
    ]))

    # 3. 扱うのは、アルミや銅、ステンレスなどの非鉄金属。
    s0, s1 = c[2], c[3]
    cw, ch, gap = 540, 367, 50
    x0 = (W - (cw * 3 + gap * 2)) // 2
    y0 = 200
    mats = [
        ("product-04.jpg", "アルミ", "A5052", 11.10),
        ("product-05.jpg", "銅", "C1020", 12.10),
        ("product-06.jpg", "ステンレス", "SUS316L", 12.62),
    ]
    els = []
    for i, (name, label, grade, ta) in enumerate(mats):
        x = x0 + i * (cw + gap)
        els.append(Card(name, x, y0, cw, ch, T(ta), (s0, s1 + TRANS), "up", z=(1.0, 1.06)))
        els.append(El(text_img(label, F_W8, 64, DARK), x + 4, y0 + ch + 44, T(ta + 0.05), "up", 0.25))
        els.append(El(text_img(grade, F_W3, 34, GRAY), x + 8, y0 + ch + 134, T(ta + 0.12), "up", 0.25))
    els.append(El(telop("非鉄金属の精密切削加工"), x0, 880, T(13.55), "wipe", 0.35))
    sc.append(Scene(s0, s1, BrandBG(), els))

    # 4. 厚さ0.3ミリのフィンも、一個から削り出します。
    s0, s1 = c[3], c[4]
    big = text_img("0.3", F_W8, 230, GREEN)
    unit = text_img("mm", F_W6, 96, GREEN)
    num = Image.new("RGBA", (big.width + unit.width + 10, big.height), (0, 0, 0, 0))
    num.alpha_composite(big, (0, 0))
    num.alpha_composite(unit, (big.width + 6, big.height - unit.height - 8))
    sc.append(Scene(s0, s1, BrandBG(flip=True), [
        Card("product-02.jpg", MX, 196, 1012, 688, s0 + 0.05, (s0, s1 + TRANS), "left", z=(1.0, 1.14), focus=(0.5, 0.45)),
        El(chip("ヒートシンク｜A1050", F_W6, 32, WHITE, GREEN), MX + 28, 196 + 688 - 44, T(15.40), "left"),
        El(text_img("フィン厚", F_W6, 54, DARK), 1210, 250, T(15.35), "up"),
        El(num, 1200, 330, T(15.72), "scale", 0.3),
        El(chip("1個から対応", F_W6, 60, WHITE, GREEN, padx=40, pady=22), 1210, 660, T(17.10), "left"),
    ]))

    # 5. 開発や試作の段階から、最適な加工方法を提案します。
    s0, s1 = c[4], c[5]
    sc.append(Scene(s0, s1, BlurBG("elected-2.jpg"), [
        Card("elected-2.jpg", MX, 150, 1060, 685, s0 + 0.05, (s0, s1 + TRANS), "left", z=(1.0, 1.08), focus=(0.5, 0.4)),
        Card("technology-1.jpg", W - MX - 640, 400, 640, 421, T(20.15), (s0, s1 + TRANS), "right", z=(1.0, 1.06)),
        El(chip("3Dプリンターで試作", F_W6, 34, WHITE, GREEN), W - MX - 640 + 24, 400 + 421 - 44, T(20.35), "left"),
        El(telop("試作・開発段階から、最適な加工方法をご提案"), MX, 880, T(21.20), "wipe", 0.45),
    ]))

    # 6. 三次元測定機とマイクロスコープで、品質を一つずつ確かめます。
    s0, s1 = c[5], c[6]
    cw, ch = 840, 560
    xr = W - MX - cw
    sc.append(Scene(s0, s1, BlurBG("quality-2.jpg"), [
        Card("quality-2.jpg", MX, 160, cw, ch, s0 + 0.05, (s0, s1 + TRANS), "up", z=(1.0, 1.08), focus=(0.5, 0.45)),
        El(chip("三次元測定機", F_W6, 40, WHITE, GREEN), MX + 24, 160 + ch - 50, T(24.40), "left"),
        El(text_img("幾何公差を保証", F_W6, 36, WHITE, shadow=True), MX + 6, 160 + ch + 40, T(24.60), "up"),
        Card("facility-08.jpg", xr, 160, cw, ch, T(25.50), (s0, s1 + TRANS), "up", z=(1.0, 1.06)),
        El(chip("マイクロスコープ", F_W6, 40, WHITE, GREEN), xr + 24, 160 + ch - 50, T(25.60), "left"),
        El(text_img("ミクロン単位でバリを確認", F_W6, 36, WHITE, shadow=True), xr + 6, 160 + ch + 40, T(25.80), "up"),
        El(telop("品質を、ひとつずつ確かめる"), MX, 880, T(26.92), "wipe", 0.4),
    ]))

    # 7. 新工場で、30代を中心としたチームが挑み続けています。
    s0, s1 = c[6], c[7]
    cw, ch, gap = 548, 440, 42
    x0 = (W - (cw * 3 + gap * 2)) // 2
    sc.append(Scene(s0, s1, BlurBG("elected-4.jpg"), [
        El(chip("新工場「〇〇」", F_W6, 42, GREEN, WHITE + (245,), accent=LIME), x0, 170, T(30.05), "left"),
        Card("elected-4.jpg", x0, 290, cw, ch, T(30.00), (s0, s1 + TRANS), "up", focus=(0.75, 0.5)),
        Card("recruit-6.jpg", x0 + cw + gap, 290, cw, ch, T(30.35), (s0, s1 + TRANS), "up"),
        Card("facility-01.jpg", x0 + (cw + gap) * 2, 290, cw, ch, T(30.70), (s0, s1 + TRANS), "up"),
        El(text_img("30代中心のチーム", F_W8, 100, WHITE, shadow=True), x0 - 14, 790, T(30.86), "up", 0.35),
    ]))

    # 8. （経営理念）。
    s0, s1 = c[7], c[8]
    slogan = Typing("（経営理念）", F_W8, 92, 0, 0, T(34.84), T(36.70))
    slogan.x = (W - slogan.band.width + slogan.m * 2) // 2
    slogan.y = 820
    sc.append(Scene(s0, s1, BlurBG("recruit-9.jpg"), [
        Card("recruit-9.jpg", (W - 1080) // 2, 60, 1080, 711, s0 + 0.05, (s0, s1 + TRANS), "up", z=(1.0, 1.08)),
        slogan,
    ]))

    # エンドカード：A社。
    s0, s1 = c[8], c[9]
    end_logo = keyed_logo(900)
    lx = (W - end_logo.width) // 2
    info = text_img("www.example.co.jp　｜　TEL 000-000-0000", F_W6, 44, DARK)
    addr = text_img("〒000-0000 静岡県〇〇市〇〇", F_W3, 32, GRAY)
    sl = text_img("（経営理念）", F_W6, 44, GREEN)
    sc.append(Scene(s0, s1, BrandBG(), [
        El(sl, (W - sl.width) // 2, 250, T(37.35), "up"),
        El(end_logo, lx, 340, T(37.50), "scale", 0.45),
        El(info, (W - info.width) // 2, 650, T(38.30), "up"),
        El(addr, (W - addr.width) // 2, 730, T(38.45), "up"),
    ], bug=False))
    return sc


# ---------------------------------------------------------------- 合成

YY, XX = np.mgrid[0:H, 0:W].astype(np.float32)


def wipe(a, b, p):
    """左から右へ流れる斜めの緑帯で a→b に切り替える"""
    e = lerp(-500, W + 500, ease_in_out(p)) - (YY - H / 2) * 0.35
    A = np.asarray(a)
    B = np.asarray(b)
    out = np.where((XX < e)[..., None], B, A).copy()
    out[(XX >= e) & (XX < e + 90)] = GREEN
    out[(XX >= e + 90) & (XX < e + 118)] = LIME
    return Image.fromarray(out)


def render_frame(scenes, t):
    for i, cut in enumerate(CUTS):
        if abs(t - cut) < TRANS / 2:
            p = (t - (cut - TRANS / 2)) / TRANS
            return wipe(scenes[i].render(t), scenes[i + 1].render(t), p)
    idx = sum(1 for cut in CUTS if t >= cut)
    img = scenes[idx].render(t)
    if t < 0.3:
        img = Image.blend(Image.new("RGB", (W, H), WHITE), img, t / 0.3)
    return img


def main():
    global BUG
    BUG = logo_bug()
    scenes = build_scenes()
    mode = sys.argv[1]
    if mode == "preview":
        for s in sys.argv[2:]:
            render_frame(scenes, float(s)).save(BASE / f"preview_{s}.png")
        return
    out = sys.argv[2]
    n = round(TOTAL * FPS)
    delay = int(LEAD * 1000)
    cmd = [
        "ffmpeg", "-y", "-loglevel", "error",
        "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{W}x{H}", "-r", str(FPS), "-i", "-",
        "-i", str(AUDIO),
        "-filter:a", f"adelay={delay}:all=1,apad",
        "-t", f"{TOTAL}",
        "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "18", "-preset", "medium",
        "-c:a", "aac", "-b:a", "192k", "-ar", "48000",
        "-movflags", "+faststart", out,
    ]
    proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
    for i in range(n):
        frame = render_frame(scenes, i / FPS)
        proc.stdin.write(frame.tobytes())
        if i % 150 == 0:
            print(f"{i}/{n}", flush=True)
    proc.stdin.close()
    proc.wait()
    print("done", proc.returncode)


if __name__ == "__main__":
    main()

D. BGMの合成

bgm.py（全文）

bgm.py

#!/usr/bin/env python3
"""A社PV用のBGMを合成する（オリジナル曲・外部音源なし）

120BPM、4/4、1小節 = 2秒。D - A - Bm - G の進行を繰り返し、
エンドカード（動画 38 秒付近）で D に解決してフェードアウトする。
"""
import wave
from pathlib import Path

import numpy as np

SR = 48000
TOTAL = 41.6
BPM = 120
BEAT = 60 / BPM
BAR = BEAT * 4
OUT = Path(__file__).resolve().parent / "bgm.wav"

rng = np.random.default_rng(7)
N = int(TOTAL * SR)
L = np.zeros(N)
R = np.zeros(N)


def midi_hz(m):
    return 440.0 * 2 ** ((m - 69) / 12)


def add(sig, t0, gain=1.0, pan=0.0):
    """pan: -1 = 左, +1 = 右"""
    i0 = int(t0 * SR)
    if i0 >= N:
        return
    sig = sig[: N - i0]
    gl = gain * np.cos((pan + 1) * np.pi / 4)
    gr = gain * np.sin((pan + 1) * np.pi / 4)
    L[i0:i0 + len(sig)] += sig * gl
    R[i0:i0 + len(sig)] += sig * gr


def env_adsr(n, a, d, s, r):
    """a/d/r は秒、s はサステインレベル。n サンプルの長さに合わせる"""
    t = np.arange(n) / SR
    dur = n / SR
    e = np.where(t < a, t / a, s + (1 - s) * np.exp(-(t - a) / max(d, 1e-3)))
    rel = np.clip((dur - t) / r, 0, 1)
    return e * rel


def pluck(m, dur=1.2):
    """エレピ風：倍音ごとに減衰の速さを変える"""
    n = int(dur * SR)
    t = np.arange(n) / SR
    f = midi_hz(m)
    sig = np.zeros(n)
    for k, amp in ((1, 1.0), (2, 0.45), (3, 0.22), (4, 0.12), (6, 0.05)):
        sig += amp * np.sin(2 * np.pi * f * k * t) * np.exp(-t * (2.2 + 1.8 * k))
    attack = np.clip(t / 0.004, 0, 1)
    return sig * attack


def pad(notes, dur):
    """ゆっくり立ち上がる柔らかいパッド（デチューンした倍音合成）"""
    n = int(dur * SR)
    t = np.arange(n) / SR
    sig = np.zeros(n)
    for m in notes:
        f = midi_hz(m)
        for det in (-0.12, 0.12):
            ff = f * 2 ** (det / 12)
            for k in range(1, 7):
                sig += np.sin(2 * np.pi * ff * k * t + rng.uniform(0, 6.28)) / k ** 2.0
    trem = 1 + 0.06 * np.sin(2 * np.pi * 0.5 * t)
    return sig * trem * env_adsr(n, 0.45, 1.0, 0.85, 0.5) / (len(notes) * 4)


def bass(m, dur):
    n = int(dur * SR)
    t = np.arange(n) / SR
    f = midi_hz(m)
    sig = np.sin(2 * np.pi * f * t) + 0.3 * np.sin(2 * np.pi * 2 * f * t)
    return sig * env_adsr(n, 0.008, 0.18, 0.45, 0.05)


def kick():
    n = int(0.35 * SR)
    t = np.arange(n) / SR
    f = 45 + 85 * np.exp(-t * 28)
    ph = 2 * np.pi * np.cumsum(f) / SR
    return np.sin(ph) * np.exp(-t * 9)


def band_noise(n, lo, hi):
    """帯域を絞ったノイズ（FFT 上で対数周波数のなだらかな窓をかける）"""
    x = np.fft.rfft(rng.standard_normal(n))
    f = np.fft.rfftfreq(n, 1 / SR)
    lf = np.log2(np.maximum(f, 1))
    c, bw = (np.log2(lo) + np.log2(hi)) / 2, (np.log2(hi) - np.log2(lo)) / 2
    x *= np.exp(-((lf - c) / bw) ** 4)
    y = np.fft.irfft(x, n)
    return y / (np.std(y) + 1e-9)


def hat(open_=False):
    n = int((0.18 if open_ else 0.06) * SR)
    t = np.arange(n) / SR
    x = band_noise(n, 5000, 10000)
    return x * np.exp(-t * (18 if open_ else 70)) * 0.07


def clap():
    n = int(0.25 * SR)
    t = np.arange(n) / SR
    x = band_noise(n, 900, 3500) * 0.3
    bursts = sum(np.exp(-np.clip(t - d, 0, None) * 180) * (t >= d) for d in (0, 0.011, 0.022))
    return x * (bursts * 0.5 + np.exp(-t * 16)) * 0.35


def swell(dur):
    """終止前のノイズの吸い上げ"""
    n = int(dur * SR)
    t = np.arange(n) / SR
    x = band_noise(n, 1500, 7000)
    return x * (t / dur) ** 2.5 * 0.04


def crash():
    n = int(2.5 * SR)
    t = np.arange(n) / SR
    x = band_noise(n, 3000, 9000)
    return x * np.exp(-t * 2.2) * 0.05


# D - A - Bm - G（D メジャー）
CHORDS = [
    {"pad": [62, 66, 69], "arp": [74, 78, 81, 86], "bass": 38},   # D
    {"pad": [61, 64, 69], "arp": [73, 76, 81, 85], "bass": 45},   # A
    {"pad": [62, 66, 71], "arp": [74, 78, 83, 86], "bass": 47},   # Bm
    {"pad": [62, 67, 71], "arp": [74, 79, 83, 86], "bass": 43},   # G
]
ARP_ORDER = [0, 1, 2, 3, 2, 1, 2, 3]
N_BARS = 19          # 0〜38 秒。最終小節（38 秒〜）は D の全音符で締める

for b in range(N_BARS):
    t0 = b * BAR
    ch = CHORDS[b % 4]
    add(pad(ch["pad"], BAR + 0.5), t0, 0.55)

    # アルペジオ：イントロ2小節は4分、以降は8分
    step = BEAT if b < 2 else BEAT / 2
    for i in range(int(BAR / step)):
        m = ch["arp"][ARP_ORDER[(i * (2 if b < 2 else 1)) % 8]]
        vel = 0.9 if i % 2 == 0 else 0.65
        add(pluck(m), t0 + i * step, 0.16 * vel, pan=-0.35 if i % 2 else 0.35)

    if b >= 2:
        for i in range(8):
            add(bass(ch["bass"], BEAT / 2 * 0.95), t0 + i * BEAT / 2, 0.20 * (1.0 if i % 2 == 0 else 0.7))
        for i in range(4):
            if b < N_BARS - 1 or i < 2:
                add(kick(), t0 + i * BEAT, 0.38 if i in (0, 2) else 0.24)
        for i in range(8):
            add(hat(open_=(i % 2 == 1 and b % 2 == 1)), t0 + i * BEAT / 2, 0.8 if i % 2 else 0.45, pan=0.25)
        if b >= 4:
            add(clap(), t0 + BEAT, 0.5, pan=-0.1)
            add(clap(), t0 + BEAT * 3, 0.5, pan=-0.1)

# 最終小節前のフィル → 38 秒で D に解決
add(swell(BEAT * 2), (N_BARS - 1) * BAR + BEAT * 2, 1.0)
t_end = N_BARS * BAR
add(pad([62, 66, 69, 74], TOTAL - t_end), t_end, 0.7)
add(bass(38, 2.0), t_end, 0.35)
add(kick(), t_end, 0.6)
add(crash(), t_end, 1.0)
for i, m in enumerate([74, 78, 81, 86]):
    add(pluck(m, 2.5), t_end + i * 0.06, 0.16)

# 簡易リバーブ（減衰ノイズとの畳み込み）
ir_n = int(1.4 * SR)
ir_t = np.arange(ir_n) / SR
for ch_sig in (L, R):
    ir = rng.standard_normal(ir_n) * np.exp(-ir_t * 4.5)
    ir[0] = 0
    wet = np.fft.irfft(np.fft.rfft(ch_sig, 2 ** 22) * np.fft.rfft(ir, 2 ** 22))[:N]
    ch_sig += wet * (0.25 / np.sqrt(np.sum(ir ** 2)))

# 頭のクリック防止と、最後の 1.8 秒のフェードアウト
fade_in = np.clip(np.arange(N) / (0.02 * SR), 0, 1)
fade_out = np.clip((TOTAL - np.arange(N) / SR) / 1.8, 0, 1) ** 1.5
mix = np.stack([L, R], axis=1) * (fade_in * fade_out)[:, None]
mix /= np.max(np.abs(mix)) / 0.89       # ピーク -1 dBFS
pcm = (mix * 32767).astype(np.int16)

with wave.open(str(OUT), "wb") as w:
    w.setnchannels(2)
    w.setsampwidth(2)
    w.setframerate(SR)
    w.writeframes(pcm.tobytes())
print("wrote", OUT, f"{N / SR:.2f}s")

E. ナレーションとBGMの合成

1本目で、ナレーションを0.4秒遅らせてステレオにし、BGMをダッキングして混ぜます。
2本目で、全体を-16 LUFS前後に持ち上げ、映像を再エンコードせずに音声だけ差し替えます。

ffmpegのコマンド

ffmpeg -y -i narration.wav -i bgm.wav -filter_complex "[0:a]aresample=48000,pan=stereo|c0=c0|c1=c0,adelay=400:all=1,apad,atrim=0:41.6,asplit=2[nar][sc];[1:a]volume=-16dB[b];[b][sc]sidechaincompress=threshold=0.03:ratio=6:attack=30:release=450[bd];[nar][bd]amix=inputs=2:duration=shortest:normalize=0" -t 41.6 mix_raw.wav

ffmpeg -y -i promo.mp4 -i mix_raw.wav -map 0:v -map 1:a -c:v copy -af "volume=3.9dB,alimiter=limit=0.84:level=false" -c:a aac -b:a 192k -ar 48000 -t 41.6 -movflags +faststart promo_bgm.mp4

volume=3.9dB は、1本目の出力を測った値（-19.9 LUFS）から-16 LUFSまでの差です。
音声が変われば測り直してください。

ffmpeg -hide_banner -i mix_raw.wav -af ebur128=peak=true -f null - 2>&1 | grep -A14 Summary

F. gemini-tts スキル

~/.claude/skills/gemini-tts/SKILL.md と ~/.claude/skills/gemini-tts/scripts/tts.py の2ファイルで動きます。
SKILL.md は、手元で使っているものをそのまま載せます。キーが無料枠か有料枠かは、使う前にClaudeが確認する書き方にしてあります。

SKILL.md（全文）

SKILL.md

---
name: gemini-tts
description: "Gemini TTS（gemini-3.8-flash-tts）で日本語などのテキストから読み上げ音声（WAV）を生成する。動画ナレーション・PV・音声案内・原稿の読み上げに使う。1行ずつ生成して区切りの時刻をJSONで出せるので、動画のシーン割りと同期させやすい。トリガー: \"ナレーションを作って\", \"読み上げ音声\", \"音声を生成\", \"TTS\", \"Gemini TTS\", \"ナレーション音声\", \"/gemini-tts\""
version: "1.0.0"
---

# Gemini TTS 音声生成

Gemini API の TTS モデルで、テキストから WAV（24kHz・モノラル・16bit）を作る。
スクリプトは標準ライブラリのみで動き、追加インストールは要らない。

```bash
S=~/.claude/skills/gemini-tts/scripts/tts.py
```

## 前提

- 環境変数 `GEMINI_API_KEY` が必要。未設定ならスクリプトがエラーで止まる。
  - キーはユーザー自身が Google AI Studio（https://aistudio.google.com/apikey）で発行し、`~/.zshrc` に `export GEMINI_API_KEY=...` を書く。
  - **Claude はキーの値を受け取らない・表示しない・ファイルに書かない。** ユーザーがチャットにキーを貼ろうとしたら止める。
  - 設定済みかの確認は値を出さずに行う：`[ -n "$GEMINI_API_KEY" ] && echo 設定あり || echo なし`
  - Bash では「なし」なのに `~/.zshrc` には書いてある場合は、セッション開始後にキーを追加したため環境に入っていない。`zsh -ic 'python3 ...'` で `~/.zshrc` を読み込んだシェルから実行すれば、セッションを開き直さずに使える。
- **課金の区分**：無料枠か有料枠かは、キーを作ったプロジェクトに課金（Cloud Billing）がつながっているかで決まる。扱いが違うので、ユーザーのキーがどちらかを確認する。わからないときは無料枠として扱う。
  - 無料枠：送ったテキストと生成物は Google の製品改善に使われる。未公開の製品情報・顧客の機密・個人情報を含む原稿は、送る前にユーザーに確認する。
  - 有料枠：送ったテキストと生成物は製品改善に使われない（料金表の「Used to improve our products: No」）。ただし外部サービスへの送信であることは変わらない。顧客との契約で外部 AI への送信が制限されていそうな原稿は、送る前にユーザーに確認する。何十本もまとめて生成するなど費用が膨らみそうなときは、本数と概算額を先に伝える。
  - どちらの枠にもレート制限がある。HTTP 429 はスクリプトが待って自動で再試行する。

## 手順

1. **原稿を確定する。** 動画用なら 1 文 1 行にする（`--split` で行ごとに生成するため）。
2. **声とスタイルを決める。** ユーザーの指定がなければ既定（`Kore`、スタイルなし）で作り、その旨を報告する。
3. **送信前チェック。** 上の課金の区分に沿って、原稿の中身と費用を確かめる。迷ったら `--dry-run` でリクエスト内容を見せる。
4. **生成する。**
5. **報告する。** 出力パス、長さ、区切り数、使った声とスタイル。必要ならラウドネスも測る（下記）。

## コマンド

```bash
# 1文だけ
python3 $S "本日はご来場いただき、ありがとうございます。" -o out.wav

# 原稿ファイル全体を1回で読ませる（自然な抑揚になりやすい）
python3 $S -f script.txt -o narration.wav --voice Kore \
    --style "calm, warm and trustworthy corporate narration, moderate pace"

# 1行ずつ生成して無音 0.6 秒でつなぐ（動画のシーン割りと同期させたいとき）
python3 $S -f script.txt -o narration.wav --split --gap 0.6

# 軽量版モデル（安い・対応言語がやや少ない）
python3 $S -f script.txt -o narration.wav --model lite

# APIを呼ばずにリクエストだけ確認
python3 $S -f script.txt -o narration.wav --split --dry-run
```

出力：
- `narration.wav`
- `narration.json`：モデル、声、スタイル、総尺と、各行の `start` / `end`（秒）。`--split` のときは各行の区切り時刻をそのまま動画のシーン切り替えに使える。`--split` なしでは全体が 1 区切りになる。

### 1回生成と `--split` の使い分け

| | 1回生成 | `--split` |
|---|---|---|
| 抑揚 | 文をまたいで自然につながる | 行ごとに独立するので、文頭の調子が毎回リセットされやすい |
| 区切り時刻 | 分からない（無音検出や文字起こしで後から求める） | JSON に正確に出る |
| 間の長さ | モデル任せ | `--gap` で一定にできる |
| 作り直し | 全体をやり直す | 同じ行を作り直せば済む（現状は全行を再生成する） |

## 声（30種・公式の特徴）

Zephyr（Bright）、Puck（Upbeat）、Charon（Informative）、Kore（Firm）、Fenrir（Excitable）、Leda（Youthful）、Orus（Firm）、Aoede（Breezy）、Callirrhoe（Easy-going）、Autonoe（Bright）、Enceladus（Breathy）、Iapetus（Clear）、Umbriel（Easy-going）、Algieba（Smooth）、Despina（Smooth）、Erinome（Clear）、Algenib（Gravelly）、Rasalgethi（Informative）、Laomedeia（Upbeat）、Achernar（Soft）、Alnilam（Firm）、Schedar（Even）、Gacrux（Mature）、Pulcherrima（Forward）、Achird（Friendly）、Zubenelgenubi（Casual）、Vindemiatrix（Gentle）、Sadachbia（Lively）、Sadaltager（Knowledgeable）、Sulafat（Warm）

どれが男声・女声かは公式の一覧に書かれていない。聞き比べが必要なら、同じ 1 文を候補の声で生成して並べる。

## スタイルと記法

- `--style`：発話全体に効く指示（感情、話し方、テンポ、声量）。公式例は英語。日本語で書いても効くかは未検証なので、確実さを取るなら英語で書く。
- 原稿中のタグ：一瞬の声の演出は本文に英語タグで入れる。原稿が日本語でもタグは英語が推奨。
  - 間：`<short pause>` `<long pause>`
  - その他：`<breath>` `<sigh>` `<laugh>` `<chuckle>` `<whispers>` `<throat-clearing>` など
- 言語は本文から自動判定される。

## 生成後の確認（任意）

```bash
# 長さ
ffprobe -v error -show_entries format=duration -of csv=p=0 narration.wav
# ラウドネス（Web 動画に使うなら全体で -16 LUFS 前後が目安）
ffmpeg -hide_banner -i narration.wav -af ebur128=peak=true -f null - 2>&1 | grep -A12 Summary
```

## 料金（参考・2026-09 時点の公式料金表）

- 無料枠：入出力とも無料（データは製品改善に使われる）。
- 有料枠：gemini-3.8-flash-tts は入力 0.50ドル / 出力（音声）9.00ドル（100万トークンあたり。2027-01-01 から 1.00ドル / 18.00ドル）。データは製品改善に使われない。
- 目安：音声 1 秒 ≒ 32 トークン（音声理解の公式換算値。TTS 出力にもそのまま当てはまるかは未確認）で、40 秒のナレーションが約 0.012ドル。

## 出典

- https://ai.google.dev/gemini-api/docs/speech-generation
- https://ai.google.dev/gemini-api/docs/pricing
- https://ai.google.dev/gemini-api/docs/google-ai-plans

scripts/tts.py（全文）

tts.py

#!/usr/bin/env python3
"""Gemini TTS（gemini-3.8-flash-tts）で読み上げ音声を生成する

標準ライブラリのみで動く。APIキーは環境変数 GEMINI_API_KEY から読む。

使い方:
    tts.py "読み上げる文" -o out.wav
    tts.py -f script.txt -o out.wav --voice Kore --style "calm, warm corporate narration"
    tts.py -f script.txt -o out.wav --split --gap 0.6    # 1行ずつ生成してつなぐ
    tts.py -f script.txt -o out.wav --dry-run           # APIを呼ばずにリクエストを表示
"""
import argparse
import base64
import io
import json
import os
import sys
import time
import urllib.error
import urllib.request
import wave
from pathlib import Path

ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/interactions"
MODELS = {
    "flash": "gemini-3.8-flash-tts",
    "lite": "gemini-3.8-flash-lite-tts",
}
DEFAULT_VOICE = "Kore"
VOICES = {
    "Zephyr", "Puck", "Charon", "Kore", "Fenrir", "Leda", "Orus", "Aoede", "Callirrhoe",
    "Autonoe", "Enceladus", "Iapetus", "Umbriel", "Algieba", "Despina", "Erinome", "Algenib",
    "Rasalgethi", "Laomedeia", "Achernar", "Alnilam", "Schedar", "Gacrux", "Pulcherrima",
    "Achird", "Zubenelgenubi", "Vindemiatrix", "Sadachbia", "Sadaltager", "Sulafat",
}
# ヘッダーなしPCMが返ったときの形式（仕様：24kHz・モノラル・16bit）
RAW_PARAMS = (24000, 1, 2)
RETRY_STATUS = {429, 500, 502, 503, 504}


def build_request(text, voice, style, model):
    content = {"type": "text", "text": text}
    if style:
        content["annotations"] = [{"type": "speech_metadata", "style": style}]
    return {
        "model": model,
        "input": [{"type": "user_input", "content": [content]}],
        "response_format": {"type": "audio"},
        "generation_config": {"speech_config": [{"voice": voice}]},
    }


def call_api(body, api_key, retries=4):
    data = json.dumps(body).encode("utf-8")
    for attempt in range(retries + 1):
        req = urllib.request.Request(
            ENDPOINT,
            data=data,
            headers={"x-goog-api-key": api_key, "Content-Type": "application/json"},
            method="POST",
        )
        try:
            with urllib.request.urlopen(req, timeout=180) as res:
                return json.loads(res.read().decode("utf-8"))
        except urllib.error.HTTPError as e:
            detail = e.read().decode("utf-8", errors="replace")[:800]
            if e.code in RETRY_STATUS and attempt < retries:
                wait = float(e.headers.get("Retry-After") or 0) or 2 ** (attempt + 1)
                print(f"  HTTP {e.code}、{wait:.0f}秒待って再試行します（{attempt + 1}/{retries}）", file=sys.stderr)
                time.sleep(wait)
                continue
            raise RuntimeError(f"Gemini API エラー HTTP {e.code}: {detail}") from None
        except urllib.error.URLError as e:
            if attempt < retries:
                time.sleep(2 ** (attempt + 1))
                continue
            raise RuntimeError(f"接続エラー: {e.reason}") from None


def extract_audio(resp):
    """レスポンスの最後の音声ブロックを取り出し、(PCM, (rate, ch, width)) を返す"""
    audios = [
        c
        for step in resp.get("steps", [])
        if step.get("type") == "model_output"
        for c in step.get("content", [])
        if c.get("type") == "audio"
    ]
    if not audios:
        raise RuntimeError("レスポンスに音声が含まれていません: " + json.dumps(resp, ensure_ascii=False)[:800])
    raw = base64.b64decode(audios[-1]["data"])
    if raw[:4] == b"RIFF":
        with wave.open(io.BytesIO(raw)) as w:
            return w.readframes(w.getnframes()), (w.getframerate(), w.getnchannels(), w.getsampwidth())
    return raw, RAW_PARAMS


def silence(seconds, params):
    rate, ch, width = params
    return b"\x00" * (int(seconds * rate) * ch * width)


def write_wav(path, pcm, params):
    rate, ch, width = params
    with wave.open(str(path), "wb") as w:
        w.setnchannels(ch)
        w.setsampwidth(width)
        w.setframerate(rate)
        w.writeframes(pcm)


def seconds_of(pcm, params):
    rate, ch, width = params
    return len(pcm) / (rate * ch * width)


def main():
    ap = argparse.ArgumentParser(description="Gemini TTS で読み上げ音声（WAV）を生成する")
    src = ap.add_mutually_exclusive_group(required=True)
    src.add_argument("text", nargs="?", help="読み上げるテキスト")
    src.add_argument("-f", "--file", help="原稿ファイル（UTF-8）")
    ap.add_argument("-o", "--out", required=True, help="出力WAVのパス")
    ap.add_argument("--voice", default=DEFAULT_VOICE, help=f"声の名前（既定: {DEFAULT_VOICE}）")
    ap.add_argument("--style", help="読み方の指示（例: \"calm, warm corporate narration, moderate pace\"）")
    ap.add_argument("--model", default="flash", help="flash / lite / またはモデルIDをそのまま指定")
    ap.add_argument("--split", action="store_true", help="空行以外の1行を1区切りとして個別に生成し、つなぐ")
    ap.add_argument("--gap", type=float, default=0.5, help="--split 時の区切り間の無音（秒、既定 0.5）")
    ap.add_argument("--lead", type=float, default=0.0, help="先頭に入れる無音（秒）")
    ap.add_argument("--dry-run", action="store_true", help="APIを呼ばずにリクエスト内容だけ表示する")
    args = ap.parse_args()

    text = Path(args.file).read_text(encoding="utf-8") if args.file else args.text
    text = text.strip()
    if not text:
        sys.exit("エラー: テキストが空です")
    if args.voice not in VOICES:
        print(f"注意: '{args.voice}' は既知の30音声にありません。そのまま送信します", file=sys.stderr)
    model = MODELS.get(args.model, args.model)
    segments = [line.strip() for line in text.splitlines() if line.strip()] if args.split else [text]
    bodies = [build_request(s, args.voice, args.style, model) for s in segments]

    if args.dry_run:
        print(json.dumps(bodies if args.split else bodies[0], ensure_ascii=False, indent=4))
        return

    api_key = os.environ.get("GEMINI_API_KEY")
    if not api_key:
        sys.exit(
            "エラー: 環境変数 GEMINI_API_KEY が設定されていません。\n"
            "Google AI Studio（https://aistudio.google.com/apikey）でキーを発行し、\n"
            "~/.zshrc に export GEMINI_API_KEY=... を追記してください（キーはClaudeに貼らないこと）。"
        )

    out = Path(args.out)
    out.parent.mkdir(parents=True, exist_ok=True)
    params = None
    chunks, timeline = [], []
    cursor = args.lead
    for i, (seg, body) in enumerate(zip(segments, bodies), 1):
        print(f"[{i}/{len(segments)}] {seg[:40]}{'…' if len(seg) > 40 else ''}", file=sys.stderr)
        pcm, p = extract_audio(call_api(body, api_key))
        if params is None:
            params = p
            chunks.append(silence(args.lead, params))
        elif p != params:
            raise RuntimeError(f"区切りごとの音声形式が一致しません: {params} と {p}")
        if i > 1:
            chunks.append(silence(args.gap, params))
            cursor += args.gap
        dur = seconds_of(pcm, params)
        timeline.append({"index": i, "text": seg, "start": round(cursor, 3), "end": round(cursor + dur, 3)})
        cursor += dur
        chunks.append(pcm)

    pcm_all = b"".join(chunks)
    write_wav(out, pcm_all, params)
    meta = {
        "model": model,
        "voice": args.voice,
        "style": args.style,
        "sample_rate": params[0],
        "duration": round(seconds_of(pcm_all, params), 3),
        "segments": timeline,
    }
    meta_path = out.with_suffix(".json")
    meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=4), encoding="utf-8")
    print(f"出力: {out}（{meta['duration']:.2f}秒、{len(segments)}区切り、{model} / {args.voice}）")
    print(f"区切りの時刻: {meta_path}")


if __name__ == "__main__":
    main()