動画AI・LLM開発｜ffmpegを使った動画チャンク(chunking)の落とし穴

指定時間: 60.00秒
実際のキーフレーム: 59.73秒 または 60.27秒
結果: 59.73秒 または 60.27秒でカット

GOP途中でカット → 参照フレームが不完全 → 再生エラーまたは品質劣化

// ❌ 問題のあるアプローチ
ffmpeg(inputPath)
  .seekInput(startTime) // 開始時刻
  .duration(chunkDuration) // 長さ
  .save(outputPath)

期待値: 1:00:00, 1:00:00, 1:00:00...
実際  : 54:10,   59:28,   59:29...

// ✅ 正しいアプローチ：フレーム単位での計算
function calculateFramesForNTSC(targetDurationSeconds: number): number {
  // 29.97fps = 30000/1001fps
  // Premiere互換性のため、30フレーム/秒として計算
  return Math.round(targetDurationSeconds * 30)
}

// 例：60秒 = 1800フレーム（Premiere Proで1:00:00と表示）
const framesFor60s = calculateFramesForNTSC(60) // 1800
const framesFor30s = calculateFramesForNTSC(30) // 900
const framesFor90s = calculateFramesForNTSC(90) // 2700

export function calculateOptimalFrameCount(fps: number, targetDuration: number): number {
  if (Math.abs(fps - 29.97002997) < 0.001) {
    // NTSC 29.97fps: Premiere互換のため30フレーム/秒
    return Math.round(targetDuration * 30)
  } else if (Math.abs(fps - 30) < 0.001) {
    // 30fps: 正確に秒数 × 30フレーム
    return Math.round(targetDuration * 30)
  } else if (Math.abs(fps - 23.976023976) < 0.001) {
    // NTSC Film 23.976fps: 24フレーム/秒として計算
    return Math.round(targetDuration * 24)
  } else if (Math.abs(fps - 24) < 0.001) {
    // Film 24fps
    return Math.round(targetDuration * 24)
  } else {
    // その他: 実際のFPS
    return Math.round(targetDuration * fps)
  }
}

export async function cutVideoByFrames(
  inputPath: string,
  chunkIndex: number,
  targetDuration: number,
  outputPath: string,
  fps: number,
): Promise<void> {
  const framesPerChunk = calculateOptimalFrameCount(fps, targetDuration)
  const startFrame = chunkIndex * framesPerChunk
  const endFrame = startFrame + framesPerChunk

  console.log(
    `📹 Frame-based cut: ${startFrame}-${endFrame} (${framesPerChunk} frames @ ${fps.toFixed(2)}fps)`,
  )

  return new Promise((resolve, reject) => {
    ffmpeg(inputPath)
      .videoFilters([
        `trim=start_frame=${startFrame}:end_frame=${endFrame}`,
        'setpts=PTS-STARTPTS', // タイムスタンプをリセット
      ])
      .audioFilters([
        `atrim=start=${startFrame / fps}:end=${endFrame / fps}`,
        'asetpts=PTS-STARTPTS', // 音声タイムスタンプもリセット
      ])
      .outputOptions([
        '-c:v libx264', // H.264エンコード
        '-preset medium', // バランス重視
        '-crf 18', // 高品質設定
        '-pix_fmt yuv420p', // 互換性確保
        '-r 30000/1001', // 正確なNTSCフレームレート
        '-c:a aac', // AAC音声
        '-ar 48000', // サンプリングレート
        '-ac 2', // ステレオ
        '-b:a 192k', // 音声ビットレート
        '-map_metadata -1', // メタデータクリア
        '-movflags +faststart', // Web配信最適化
        '-y', // 上書き確認なし
      ])
      .output(outputPath)
      .on('end', () => {
        console.log(`✅ Frame-accurate cut complete → ${outputPath}`)
        resolve()
      })
      .on('error', (err) => {
        console.error(`❌ Frame-based cut failed: ${err.message}`)
        reject(err)
      })
      .run()
  })
}

// fluent-ffmpegの-ss 0バグを回避
if (startTime === 0) {
  // 最初のチャンク: -ssを使わない
  ffmpegCommand.outputOptions([`-t ${duration}`])
} else {
  // 2番目以降: 通常通り-ssを使用
  ffmpegCommand.inputOptions([`-ss ${startTime}`]).outputOptions([`-t ${duration}`])
}

async function splitVideoIntelligently(
  inputPath: string,
  chunkDuration: number,
  outputDir: string,
) {
  // 動画のFPSを取得
  const fps = await getVideoFPS(inputPath)

  // NTSC 29.97fpsの場合はフレーム単位分割
  const useFrameBasedCutting = Math.abs(fps - 29.97002997) < 0.001

  if (useFrameBasedCutting) {
    console.log('🎯 NTSC動画を検出：フレーム単位分割を使用')
    const framesPerChunk = Math.round(chunkDuration * 30)
    const timeDisplay = formatTimeDisplay(chunkDuration)
    console.log(`   ${framesPerChunk}フレーム = Premiere ${timeDisplay}`)

    return await splitByFrames(inputPath, chunkDuration, outputDir, fps)
  } else {
    console.log('📺 標準動画：時間ベース分割を使用')
    return await splitByTime(inputPath, chunkDuration, outputDir)
  }
}

interface VideoChunk {
  chunkId: number
  startFrame: number
  endFrame: number
  actualDurationSeconds: number
  filePath: string
}

// LLMプロンプトでの時間情報
function createAnalysisPrompt(chunk: VideoChunk, fps: number): string {
  const startTime = chunk.startFrame / fps
  const endTime = chunk.endFrame / fps

  return `
この動画チャンクを分析してください：
- 開始時刻: ${startTime.toFixed(2)}秒
- 終了時刻: ${endTime.toFixed(2)}秒  
- 総時間: ${chunk.actualDurationSeconds.toFixed(2)}秒
- フレーム範囲: ${chunk.startFrame} - ${chunk.endFrame}

各分析セグメントの時間は10秒間隔で正確に区切られています。
`
}

async function verifyChunkQuality(chunks: VideoChunk[]) {
  console.log('🔍 チャンク品質検証を開始...')

  for (const chunk of chunks) {
    // 実際のフレーム数を確認
    const actualFrameCount = await getVideoFrameCount(chunk.filePath)
    const expectedFrames = chunk.endFrame - chunk.startFrame

    // 時間精度を確認
    const actualDuration = await getVideoDuration(chunk.filePath)
    const expectedDuration = expectedFrames / 30 // NTSC基準

    const frameAccuracy = Math.abs(actualFrameCount - expectedFrames)
    const timeAccuracy = Math.abs(actualDuration - expectedDuration)

    if (frameAccuracy === 0 && timeAccuracy < 0.1) {
      console.log(`✅ チャンク${chunk.chunkId}: フレーム精度完璧`)
    } else {
      console.warn(`⚠️ チャンク${chunk.chunkId}: 精度に問題あり`)
      console.warn(`   フレーム差分: ${frameAccuracy}`)
      console.warn(`   時間差分: ${timeAccuracy.toFixed(3)}秒`)
    }
  }
}

# チャンクのフレーム数確認
ffprobe -v error -select_streams v:0 -count_packets \
  -show_entries stream=nb_read_packets -of csv=p=0 chunk.mp4

# 期待値: 1800フレーム（60秒チャンクの場合）

async function splitVideoParallel(
  inputPath: string,
  chunkDuration: number,
  outputDir: string,
  concurrency: number = 3,
): Promise<VideoChunk[]> {
  const totalDuration = await getVideoDuration(inputPath)
  const numChunks = Math.ceil(totalDuration / chunkDuration)
  const fps = await getVideoFPS(inputPath)

  console.log(`🚀 ${numChunks}個のチャンクを${concurrency}並列で処理開始`)

  // チャンク作成タスクを生成
  const tasks = Array.from(
    { length: numChunks },
    (_, i) => () =>
      cutVideoByFrames(
        inputPath,
        i,
        chunkDuration,
        path.join(outputDir, `chunk_${i.toString().padStart(4, '0')}.mp4`),
        fps,
      ),
  )

  // 並列実行（concurrency制限付き）
  const results = await Promise.allSettled(
    tasks.map(
      (task, i) =>
        new Promise((resolve) => {
          setTimeout(() => resolve(task()), i * 100) // 100ms間隔でスタート
        }),
    ),
  )

  // 結果の集計
  const successCount = results.filter((r) => r.status === 'fulfilled').length
  console.log(`✅ ${successCount}/${numChunks}個のチャンク作成完了`)

  return chunks
}

// 解決策: startTimeが0の場合の特別処理
if (startTime === 0) {
  // -ssオプションを使わない
  ffmpegCommand.outputOptions([`-t ${duration}`])
} else {
  ffmpegCommand.inputOptions([`-ss ${startTime}`])
}

// 解決策: 音声フィルターも同時に適用
.audioFilters([
  `atrim=start=${startFrame / fps}:end=${endFrame / fps}`,
  'asetpts=PTS-STARTPTS'
])

// 解決策: 高品質設定の使用
.outputOptions([
  '-c:v libx264',
  '-crf 18',           // 高品質（0-51、低いほど高品質）
  '-preset medium',    // エンコード速度と品質のバランス
  '-pix_fmt yuv420p'   // 互換性確保
])