Utage Manual

GROQ_API_KEY=your_groq_api_key_here

#!/usr/bin/env python3
"""
UTAGE HLS動画ダウンローダー

UTAGE/Wasabi S3のHLS動画をダウンロードする専用スクリプト。
高速なHTTP persistent接続を使用。

Usage:
    python hls_downloader.py <m3u8_url> <output_path>

Example:
    python hls_downloader.py "https://s3.ap-northeast-1.wasabisys.com/.../video.m3u8" "videos/01_intro.mp4"
"""

import subprocess
import sys
import shutil
from pathlib import Path
from typing import Optional


def download_hls_video(
    m3u8_url: str,
    output_path: str,
    timeout: int = 600
) -> bool:
    """
    UTAGE/Wasabi S3向けのHLS動画ダウンロード

    Args:
        m3u8_url: HLSプレイリストのURL（.m3u8）
        output_path: 出力先MP4ファイルパス
        timeout: タイムアウト秒数（デフォルト10分）

    Returns:
        bool: 成功した場合True
    """
    output = Path(output_path)
    output.parent.mkdir(parents=True, exist_ok=True)

    ffmpeg_path = shutil.which("ffmpeg")
    if not ffmpeg_path:
        print("Error: ffmpeg not found. Please install ffmpeg first.")
        print("  macOS: brew install ffmpeg")
        print("  Linux: apt install ffmpeg")
        return False

    # UTAGE/Wasabi S3向け高速設定
    cmd = [
        ffmpeg_path,
        "-y",
        # HTTP persistent接続（高速化のキー）
        "-http_persistent", "1",
        "-multiple_requests", "1",
        "-reconnect", "1",
        "-protocol_whitelist", "file,http,https,tcp,tls,crypto",
        "-i", m3u8_url,
        # コピーモード（再エンコードなし）
        "-c", "copy",
        "-bsf:a", "aac_adtstoasc",
        str(output),
    ]

    try:
        print(f"Downloading: {m3u8_url[:80]}...")
        print(f"Output: {output}")

        result = subprocess.run(
            cmd,
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            timeout=timeout
        )

        if output.exists():
            size_mb = output.stat().st_size / (1024 * 1024)
            print(f"Download complete: {size_mb:.1f} MB")
            return True
        else:
            print("Error: Output file not created")
            return False

    except subprocess.TimeoutExpired:
        print(f"Error: Download timed out after {timeout} seconds")
        return False
    except subprocess.CalledProcessError as e:
        err = e.stderr if e.stderr else ""
        if "HTTP error 403" in err:
            print("Error: Access denied (403)")
            print("The URL token may have expired. Please get a new URL.")
        elif "HTTP error 404" in err:
            print("Error: Video not found (404)")
            print("The video may have been removed or the URL is invalid.")
        else:
            print(f"Error: ffmpeg failed")
            print(err[:300] if err else "Unknown error")
        return False


def extract_audio(
    video_path: str,
    audio_path: str,
    sample_rate: int = 16000
) -> bool:
    """
    動画から音声を抽出（MP3形式）

    Args:
        video_path: 入力動画ファイルパス
        audio_path: 出力音声ファイルパス
        sample_rate: サンプリングレート

    Returns:
        bool: 成功した場合True
    """
    video = Path(video_path)
    audio = Path(audio_path)

    if not video.exists():
        print(f"Error: Video file not found: {video}")
        return False

    audio.parent.mkdir(parents=True, exist_ok=True)

    ffmpeg_path = shutil.which("ffmpeg")
    if not ffmpeg_path:
        print("Error: ffmpeg not found")
        return False

    cmd = [
        ffmpeg_path,
        "-y",
        "-i", str(video),
        "-vn",  # 映像なし
        "-acodec", "libmp3lame",
        "-ar", str(sample_rate),
        "-ac", "1",  # モノラル
        "-q:a", "2",  # 高品質
        str(audio),
    ]

    try:
        print(f"Extracting audio: {video.name} -> {audio.name}")

        subprocess.run(
            cmd,
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            timeout=300
        )

        if audio.exists():
            size_mb = audio.stat().st_size / (1024 * 1024)
            print(f"Audio extracted: {size_mb:.1f} MB")
            return True
        else:
            print("Error: Audio file not created")
            return False

    except subprocess.CalledProcessError as e:
        print(f"Error: Audio extraction failed")
        print(e.stderr[:200] if e.stderr else "Unknown error")
        return False


if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Usage: python hls_downloader.py <m3u8_url> <output_path>")
        print("       python hls_downloader.py --extract-audio <video_path> <audio_path>")
        sys.exit(1)

    if sys.argv[1] == "--extract-audio":
        if len(sys.argv) < 4:
            print("Usage: python hls_downloader.py --extract-audio <video_path> <audio_path>")
            sys.exit(1)
        success = extract_audio(sys.argv[2], sys.argv[3])
    else:
        success = download_hls_video(sys.argv[1], sys.argv[2])

    sys.exit(0 if success else 1)

#!/usr/bin/env python3
"""
スクリーンショット抽出スクリプト

動画からスクリーンショットを抽出する。
- 一定間隔での抽出
- シーン変化検出での抽出（オプション）

Usage:
    python screenshot_extractor.py <video_path> <output_dir> [--interval SECONDS] [--scene]

Example:
    python screenshot_extractor.py "videos/01_intro.mp4" "screenshots/01" --interval 30
    python screenshot_extractor.py "videos/01_intro.mp4" "screenshots/01" --scene
"""

import subprocess
import sys
import shutil
import argparse
from pathlib import Path
from typing import List, Optional


def get_video_duration(video_path: Path) -> float:
    """動画の長さを取得（秒）"""
    cmd = [
        "ffprobe", "-v", "error",
        "-show_entries", "format=duration",
        "-of", "default=noprint_wrappers=1:nokey=1",
        str(video_path)
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    return float(result.stdout.strip())


def extract_title_frame(video_path: Path, output_dir: Path) -> Optional[Path]:
    """
    タイトル画像を抽出（1秒目）

    Returns:
        出力ファイルパス（成功時）
    """
    output_file = output_dir / "title.jpg"

    cmd = [
        "ffmpeg", "-y",
        "-i", str(video_path),
        "-ss", "00:00:01",
        "-vframes", "1",
        "-q:v", "2",
        str(output_file)
    ]

    try:
        subprocess.run(cmd, capture_output=True, check=True)
        if output_file.exists():
            print(f"Title frame: {output_file.name}")
            return output_file
    except subprocess.CalledProcessError:
        pass

    return None


def extract_interval_frames(
    video_path: Path,
    output_dir: Path,
    interval: int = 30
) -> List[Path]:
    """
    一定間隔でフレームを抽出

    Args:
        video_path: 入力動画
        output_dir: 出力ディレクトリ
        interval: 抽出間隔（秒）

    Returns:
        抽出されたファイルパスのリスト
    """
    pattern = str(output_dir / "frame_%03d.jpg")

    # fps=1/interval で指定間隔ごとに抽出
    cmd = [
        "ffmpeg", "-y",
        "-i", str(video_path),
        "-vf", f"fps=1/{interval}",
        "-q:v", "2",
        pattern
    ]

    try:
        subprocess.run(cmd, capture_output=True, check=True)
    except subprocess.CalledProcessError as e:
        print(f"Error extracting frames: {e.stderr[:200] if e.stderr else 'Unknown'}")
        return []

    # 生成されたファイルを収集
    frames = sorted(output_dir.glob("frame_*.jpg"))
    print(f"Extracted {len(frames)} frames at {interval}s intervals")

    return frames


def extract_scene_frames(
    video_path: Path,
    output_dir: Path,
    threshold: float = 0.3
) -> List[Path]:
    """
    シーン変化検出でフレームを抽出

    Args:
        video_path: 入力動画
        output_dir: 出力ディレクトリ
        threshold: シーン変化しきい値（0.0-1.0、小さいほど敏感）

    Returns:
        抽出されたファイルパスのリスト
    """
    pattern = str(output_dir / "scene_%03d.jpg")

    cmd = [
        "ffmpeg", "-y",
        "-i", str(video_path),
        "-vf", f"select='gt(scene,{threshold})',showinfo",
        "-vsync", "vfr",
        "-q:v", "2",
        pattern
    ]

    try:
        result = subprocess.run(cmd, capture_output=True, text=True)
    except subprocess.CalledProcessError as e:
        print(f"Error detecting scenes: {e.stderr[:200] if e.stderr else 'Unknown'}")
        return []

    # 生成されたファイルを収集
    frames = sorted(output_dir.glob("scene_*.jpg"))
    print(f"Detected {len(frames)} scene changes (threshold: {threshold})")

    return frames


def extract_timestamps_frames(
    video_path: Path,
    output_dir: Path,
    timestamps: List[float]
) -> List[Path]:
    """
    指定したタイムスタンプでフレームを抽出

    Args:
        video_path: 入力動画
        output_dir: 出力ディレクトリ
        timestamps: 抽出する時間（秒）のリスト

    Returns:
        抽出されたファイルパスのリスト
    """
    frames = []

    for i, ts in enumerate(timestamps):
        output_file = output_dir / f"ts_{i:03d}_{int(ts):05d}.jpg"

        # 時間を HH:MM:SS 形式に変換
        hours = int(ts // 3600)
        minutes = int((ts % 3600) // 60)
        seconds = ts % 60

        cmd = [
            "ffmpeg", "-y",
            "-ss", f"{hours:02d}:{minutes:02d}:{seconds:06.3f}",
            "-i", str(video_path),
            "-vframes", "1",
            "-q:v", "2",
            str(output_file)
        ]

        try:
            subprocess.run(cmd, capture_output=True, check=True)
            if output_file.exists():
                frames.append(output_file)
        except subprocess.CalledProcessError:
            print(f"Failed to extract frame at {ts}s")

    print(f"Extracted {len(frames)} frames at specified timestamps")
    return frames


def extract_phash_frames(
    video: Path,
    output_dir: Path,
    sample_interval: int = 2,
    phash_threshold: int = 8
) -> List[Path]:
    """
    pHash（Perceptual Hash）方式でフレーム抽出

    細かい間隔で候補フレームを抽出し、連続するフレームのpHash距離が
    閾値を超えた場合のみ採用する（重複排除）。

    Args:
        video: 入力動画
        output_dir: 出力ディレクトリ
        sample_interval: 候補抽出間隔（秒、細かいほど精度↑、処理↑）
        phash_threshold: pHashハミング距離の閾値（大きいほど選別厳しい）

    Returns:
        採用されたフレームファイルパスのリスト
    """
    try:
        import imagehash
        from PIL import Image
    except ImportError:
        print("Error: imagehash and Pillow required for --phash mode")
        print("Install: pip install imagehash Pillow")
        return []

    # 一時ディレクトリで候補フレームを抽出
    import tempfile
    temp_dir = Path(tempfile.mkdtemp(prefix="phash_candidates_"))

    try:
        pattern = str(temp_dir / "cand_%05d.jpg")
        cmd = [
            "ffmpeg", "-y",
            "-i", str(video),
            "-vf", f"fps=1/{sample_interval}",
            "-q:v", "3",
            "-loglevel", "error",
            pattern
        ]
        subprocess.run(cmd, check=True)

        candidates = sorted(temp_dir.glob("cand_*.jpg"))
        print(f"Extracted {len(candidates)} candidate frames at {sample_interval}s intervals")

        # pHashでデデュープ
        kept = []
        prev_hash = None
        for c in candidates:
            try:
                h = imagehash.phash(Image.open(c))
            except Exception as e:
                print(f"Failed to hash {c.name}: {e}")
                continue
            if prev_hash is None or (h - prev_hash) > phash_threshold:
                kept.append(c)
                prev_hash = h

        print(f"Deduped: {len(kept)} unique frames (threshold={phash_threshold})")

        # 採用分を出力ディレクトリに連番コピー
        output_frames = []
        for i, src in enumerate(kept, 1):
            dst = output_dir / f"frame_{i:03d}.jpg"
            shutil.copy2(src, dst)
            output_frames.append(dst)

        return output_frames

    finally:
        try:
            shutil.rmtree(temp_dir)
        except Exception:
            pass


def extract_screenshots(
    video_path: str,
    output_dir: str,
    interval: int = 30,
    use_scene_detection: bool = False,
    scene_threshold: float = 0.3,
    include_title: bool = True,
    use_phash: bool = False,
    phash_sample_interval: int = 2,
    phash_threshold: int = 8
) -> List[Path]:
    """
    動画からスクリーンショットを抽出

    Args:
        video_path: 入力動画ファイル
        output_dir: 出力ディレクトリ
        interval: 抽出間隔（秒、シーン検出時は無視）
        use_scene_detection: シーン検出を使用
        scene_threshold: シーン変化しきい値
        include_title: タイトル画像を含める

    Returns:
        抽出されたファイルパスのリスト
    """
    video = Path(video_path)
    output = Path(output_dir)

    # ffmpegチェック
    if not shutil.which("ffmpeg"):
        print("Error: ffmpeg not found. Please install ffmpeg first.")
        return []

    if not video.exists():
        print(f"Error: Video file not found: {video}")
        return []

    # 出力ディレクトリ作成
    output.mkdir(parents=True, exist_ok=True)

    duration = get_video_duration(video)
    print(f"Video: {video.name}")
    print(f"Duration: {duration:.1f}s ({duration/60:.1f} min)")

    frames = []

    # タイトル画像を抽出
    if include_title:
        title = extract_title_frame(video, output)
        if title:
            frames.append(title)

    # メインの抽出処理
    if use_phash:
        phash_frames = extract_phash_frames(
            video, output,
            sample_interval=phash_sample_interval,
            phash_threshold=phash_threshold
        )
        frames.extend(phash_frames)

        # pHashで少なすぎる場合は間隔抽出も併用
        if len(phash_frames) < 5:
            print("Too few phash frames, falling back to interval...")
            interval_frames = extract_interval_frames(video, output, interval)
            frames.extend(interval_frames)
    elif use_scene_detection:
        scene_frames = extract_scene_frames(video, output, scene_threshold)
        frames.extend(scene_frames)

        # シーン検出で少なすぎる場合は間隔抽出も併用
        if len(scene_frames) < 5:
            print("Too few scenes detected, adding interval frames...")
            interval_frames = extract_interval_frames(video, output, interval)
            frames.extend(interval_frames)
    else:
        interval_frames = extract_interval_frames(video, output, interval)
        frames.extend(interval_frames)

    print(f"\nTotal: {len(frames)} screenshots extracted to {output}")
    return frames


def main():
    parser = argparse.ArgumentParser(
        description="Extract screenshots from video"
    )
    parser.add_argument("video_path", help="Input video file")
    parser.add_argument("output_dir", help="Output directory for screenshots")
    parser.add_argument(
        "--interval", "-i",
        type=int,
        default=30,
        help="Extraction interval in seconds (default: 30)"
    )
    parser.add_argument(
        "--scene", "-s",
        action="store_true",
        help="Use scene change detection"
    )
    parser.add_argument(
        "--threshold", "-t",
        type=float,
        default=0.3,
        help="Scene detection threshold 0.0-1.0 (default: 0.3)"
    )
    parser.add_argument(
        "--no-title",
        action="store_true",
        help="Don't extract title frame"
    )
    parser.add_argument(
        "--timestamps",
        type=str,
        help="Extract frames at specific timestamps (comma-separated seconds, e.g., '60,120,180')"
    )
    parser.add_argument(
        "--phash",
        action="store_true",
        default=True,
        help="Use perceptual hash dedup mode (DEFAULT - catches slide changes, removes duplicates)"
    )
    parser.add_argument(
        "--no-phash",
        dest="phash",
        action="store_false",
        help="Disable pHash mode and use the legacy interval/scene mode"
    )
    parser.add_argument(
        "--phash-sample",
        type=int,
        default=2,
        help="pHash candidate sampling interval in seconds (default: 2)"
    )
    parser.add_argument(
        "--phash-threshold",
        type=int,
        default=8,
        help="pHash hamming distance threshold 0-64 (default: 8, lower=more frames)"
    )

    args = parser.parse_args()

    # タイムスタンプ指定モード
    if args.timestamps:
        video = Path(args.video_path)
        output = Path(args.output_dir)
        output.mkdir(parents=True, exist_ok=True)

        timestamps = [float(t.strip()) for t in args.timestamps.split(",")]
        print(f"Extracting {len(timestamps)} frames at specified timestamps...")
        frames = extract_timestamps_frames(video, output, timestamps)
        sys.exit(0 if frames else 1)

    # 通常モード
    frames = extract_screenshots(
        video_path=args.video_path,
        output_dir=args.output_dir,
        interval=args.interval,
        use_scene_detection=args.scene,
        scene_threshold=args.threshold,
        include_title=not args.no_title,
        use_phash=args.phash,
        phash_sample_interval=args.phash_sample,
        phash_threshold=args.phash_threshold
    )

    sys.exit(0 if frames else 1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Groq Whisper 文字起こしスクリプト

音声ファイルをチャンク分割してGroq Whisper APIで文字起こしする。
3分チャンク + 並列処理で高速化。

Usage:
    python transcribe.py <audio_path> <output_path>
    python transcribe.py <audio_path> <output_path> --timestamps <ts_output_path>

Example:
    python transcribe.py "audio/01.mp3" "transcripts/01.txt"
    python transcribe.py "audio/01.mp3" "transcripts/01.txt" --timestamps "transcripts/01_ts.json"

Environment:
    GROQ_API_KEY: Groq APIキー（必須）
"""

import json
import os
import sys
import time
import subprocess
import tempfile
import shutil
from pathlib import Path
from typing import List, Tuple, Optional
from concurrent.futures import ThreadPoolExecutor, as_completed

try:
    import requests
    from requests.adapters import HTTPAdapter
    from urllib3.util.retry import Retry
except ImportError:
    print("Error: requests library not found")
    print("Install: pip install requests")
    sys.exit(1)


def get_api_key() -> str:
    """APIキーを取得（環境変数または.envファイル）"""
    api_key = os.getenv("GROQ_API_KEY")

    if not api_key:
        # .envファイルを探す
        env_paths = [
            Path(__file__).parent.parent / ".env",
            Path.home() / ".claude/skills/utage-manual/.env",
            Path.cwd() / ".env",
        ]

        for env_path in env_paths:
            if env_path.exists():
                with open(env_path) as f:
                    for line in f:
                        if line.startswith("GROQ_API_KEY="):
                            api_key = line.split("=", 1)[1].strip().strip('"').strip("'")
                            break
                if api_key:
                    break

    return api_key or ""


def create_session() -> requests.Session:
    """リトライ付きセッションを作成"""
    sess = requests.Session()
    retry = Retry(
        total=3,
        backoff_factor=0.5,
        status_forcelist=[429, 500, 502, 503, 504]
    )
    adapter = HTTPAdapter(
        max_retries=retry,
        pool_connections=10,
        pool_maxsize=10
    )
    sess.mount("https://", adapter)
    sess.mount("http://", adapter)
    return sess


def get_audio_duration(audio_path: Path) -> float:
    """音声ファイルの長さを取得（秒）"""
    cmd = [
        "ffprobe", "-v", "error",
        "-show_entries", "format=duration",
        "-of", "default=noprint_wrappers=1:nokey=1",
        str(audio_path)
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    return float(result.stdout.strip())


def split_audio_to_chunks(
    audio_path: Path,
    chunk_seconds: int = 180,
    temp_dir: Optional[Path] = None
) -> List[Path]:
    """
    音声ファイルをチャンクファイルに分割

    Args:
        audio_path: 入力音声ファイル
        chunk_seconds: チャンク秒数（デフォルト3分）
        temp_dir: 一時ディレクトリ（Noneの場合自動作成）

    Returns:
        チャンクファイルパスのリスト
    """
    if temp_dir is None:
        temp_dir = Path(tempfile.mkdtemp(prefix="utage_chunks_"))
    else:
        temp_dir.mkdir(parents=True, exist_ok=True)

    # 音声長を取得
    duration = get_audio_duration(audio_path)
    num_chunks = int(duration / chunk_seconds) + (1 if duration % chunk_seconds > 0 else 0)

    print(f"Audio duration: {duration:.1f}s, splitting into {num_chunks} chunks")

    # ffmpeg segmentモードで分割
    pattern = str(temp_dir / "chunk_%04d.mp3")
    cmd = [
        "ffmpeg", "-y",
        "-i", str(audio_path),
        "-f", "segment",
        "-segment_time", str(chunk_seconds),
        "-vn",
        "-ar", "16000",
        "-ac", "1",
        "-b:a", "64k",
        "-acodec", "libmp3lame",
        "-reset_timestamps", "1",
        "-loglevel", "error",
        pattern
    ]

    subprocess.run(cmd, capture_output=True, check=True)

    # 生成されたチャンクを収集
    chunks = []
    for i in range(num_chunks):
        chunk_path = temp_dir / f"chunk_{i:04d}.mp3"
        if chunk_path.exists():
            chunks.append(chunk_path)

    print(f"Created {len(chunks)} chunk files")
    return chunks


def transcribe_chunk(
    session: requests.Session,
    api_key: str,
    chunk_path: Path,
    model: str = "whisper-large-v3",
    language: str = "ja",
    max_retries: int = 3,
    response_format: str = "text"
):
    """
    単一チャンクを文字起こし

    Args:
        session: リクエストセッション
        api_key: Groq APIキー
        chunk_path: チャンクファイルパス
        model: Whisperモデル
        language: 言語コード
        max_retries: リトライ回数
        response_format: "text" or "verbose_json"

    Returns:
        文字起こしテキスト（text形式）またはdict（verbose_json形式）
    """
    url = "https://api.groq.com/openai/v1/audio/transcriptions"

    for attempt in range(max_retries):
        try:
            with open(chunk_path, "rb") as f:
                files = {"file": (chunk_path.name, f, "audio/mpeg")}
                headers = {"Authorization": f"Bearer {api_key}"}
                data = {
                    "model": model,
                    "response_format": response_format,
                    "language": language,
                }
                if response_format == "verbose_json":
                    data["timestamp_granularities[]"] = "segment"

                resp = session.post(
                    url,
                    headers=headers,
                    files=files,
                    data=data,
                    timeout=120
                )

                if resp.status_code == 200:
                    if response_format == "verbose_json":
                        return resp.json()
                    return resp.text.strip()

                if resp.status_code == 429:
                    wait = min(30, 2 ** attempt)
                    print(f"Rate limit, waiting {wait}s...")
                    time.sleep(wait)
                elif resp.status_code in [500, 502, 503, 504]:
                    wait = min(30, 5 * (2 ** attempt))
                    print(f"Server error {resp.status_code}, waiting {wait}s...")
                    time.sleep(wait)
                else:
                    print(f"API error {resp.status_code}: {resp.text[:200]}")

        except Exception as e:
            print(f"Request failed (attempt {attempt+1}/{max_retries}): {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)

    return {} if response_format == "verbose_json" else ""


def transcribe_audio(
    audio_path: str,
    output_path: str,
    chunk_seconds: int = 180,
    max_workers: int = 10,
    model: str = "whisper-large-v3",
    language: str = "ja",
    timestamps_path: Optional[str] = None
) -> Tuple[bool, str]:
    """
    音声ファイルを文字起こし

    Args:
        audio_path: 入力音声ファイル
        output_path: 出力テキストファイル
        chunk_seconds: チャンク秒数
        max_workers: 並列ワーカー数
        model: Whisperモデル
        language: 言語
        timestamps_path: タイムスタンプJSON出力パス（Noneの場合は出力しない）

    Returns:
        (成功フラグ, 文字起こしテキスト)
    """
    audio = Path(audio_path)
    output = Path(output_path)
    want_timestamps = timestamps_path is not None

    if not audio.exists():
        print(f"Error: Audio file not found: {audio}")
        return False, ""

    api_key = get_api_key()
    if not api_key:
        print("Error: GROQ_API_KEY not found")
        print("Set environment variable or add to .env file")
        return False, ""

    output.parent.mkdir(parents=True, exist_ok=True)
    if timestamps_path:
        Path(timestamps_path).parent.mkdir(parents=True, exist_ok=True)

    start_time = time.time()
    temp_dir = None

    try:
        # チャンク分割
        chunks = split_audio_to_chunks(audio, chunk_seconds)
        temp_dir = chunks[0].parent if chunks else None

        total_chunks = len(chunks)

        # 動的並列数調整
        if total_chunks <= 10:
            workers = total_chunks
        elif total_chunks <= 30:
            workers = min(max_workers, 10)
        elif total_chunks <= 50:
            workers = min(max_workers, 8)
        else:
            workers = min(max_workers, 5)

        print(f"Processing {total_chunks} chunks with {workers} workers")

        # セッション作成
        session = create_session()

        # 並列処理
        resp_format = "verbose_json" if want_timestamps else "text"
        results = [None] * total_chunks
        completed = 0

        def process_chunk(idx: int, chunk_path: Path):
            result = transcribe_chunk(
                session, api_key, chunk_path, model, language,
                response_format=resp_format
            )
            try:
                chunk_path.unlink()
            except:
                pass
            return idx, result

        with ThreadPoolExecutor(max_workers=workers) as executor:
            futures = {
                executor.submit(process_chunk, i, chunk): i
                for i, chunk in enumerate(chunks)
            }

            for future in as_completed(futures):
                try:
                    idx, result = future.result()
                    results[idx] = result
                    completed += 1
                    print(f"Completed {completed}/{total_chunks}")
                except Exception as e:
                    idx = futures[future]
                    results[idx] = "" if not want_timestamps else {}
                    completed += 1
                    print(f"Chunk {idx} failed: {e}")

        if want_timestamps:
            # verbose_json: テキスト結合 + タイムスタンプJSON生成
            text_parts = []
            all_segments = []
            for idx, result in enumerate(results):
                if not result:
                    continue
                text_parts.append(result.get("text", ""))
                chunk_offset = idx * chunk_seconds
                for seg in result.get("segments", []):
                    all_segments.append({
                        "start": round(seg.get("start", 0) + chunk_offset, 2),
                        "end": round(seg.get("end", 0) + chunk_offset, 2),
                        "text": seg.get("text", "").strip()
                    })
            combined_text = "\n".join([t for t in text_parts if t])

            # タイムスタンプJSONを保存
            ts_data = {
                "segments": all_segments,
                "total_segments": len(all_segments)
            }
            Path(timestamps_path).write_text(
                json.dumps(ts_data, ensure_ascii=False, indent=2),
                encoding="utf-8"
            )
            print(f"  Timestamps: {timestamps_path} ({len(all_segments)} segments)")
        else:
            # text形式: そのまま結合
            combined_text = "\n".join([r for r in results if r])

        # ファイルに保存
        output.write_text(combined_text, encoding="utf-8")

        elapsed = time.time() - start_time
        duration = get_audio_duration(audio)
        speed = duration / elapsed if elapsed > 0 else 0

        print(f"Transcription complete!")
        print(f"  Duration: {duration:.1f}s")
        print(f"  Time: {elapsed:.1f}s")
        print(f"  Speed: {speed:.1f}x realtime")
        print(f"  Output: {output}")

        return True, combined_text

    finally:
        # 一時ディレクトリを削除
        if temp_dir and temp_dir.exists():
            try:
                shutil.rmtree(temp_dir)
            except:
                pass


if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser(description="Groq Whisper文字起こし")
    parser.add_argument("audio_path", help="入力音声ファイル")
    parser.add_argument("output_path", help="出力テキストファイル")
    parser.add_argument("--timestamps", help="タイムスタンプJSON出力パス", default=None)
    args = parser.parse_args()

    success, _ = transcribe_audio(args.audio_path, args.output_path, timestamps_path=args.timestamps)
    sys.exit(0 if success else 1)