Frame-accurate FFmpeg trimming without re-encoding the whole file

# fast, and wrong
ffmpeg -ss 12.4 -i input.mp4 -t 20 -c copy fast.mp4
ffprobe -v error -show_entries format=start_time,duration -of default=nw=1 fast.mp4
# start_time=0.000000
# duration=20.388000        <- we asked for 20, starting at 12.4

# accurate, and slow on a long source
ffmpeg -ss 12.4 -i input.mp4 -t 20 -c:v libx264 -crf 20 -c:a aac slow.mp4

ffprobe -v error -select_streams v:0 \
  -show_entries packet=pts_time,flags \
  -of csv=print_section=0 input.mp4 | grep 'K' | head -20

0.000000,K__
2.002000,K__
4.004000,K__
6.006000,K__

// keyframes.js
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
const run = promisify(execFile);

export async function keyframeTimes(input) {
  const { stdout } = await run('ffprobe', [
    '-v', 'error',
    '-select_streams', 'v:0',
    '-show_entries', 'packet=pts_time,flags',
    '-of', 'csv=print_section=0',
    input
  ], { maxBuffer: 64 * 1024 * 1024 });

  return stdout.trim().split('\n')
    .map(l => l.split(','))
    .filter(([, flags]) => flags && flags.includes('K'))
    .map(([t]) => Number(t))
    .filter(Number.isFinite)
    .sort((a, b) => a - b);
}

// first keyframe at or after t
export const kfCeil  = (kfs, t) => kfs.find(k => k >= t - 1e-6) ?? null;
// last keyframe at or before t
export const kfFloor = (kfs, t) => [...kfs].reverse().find(k => k <= t + 1e-6) ?? null;

// probe.js
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
const run = promisify(execFile);

export async function probe(input) {
  const { stdout } = await run('ffprobe', [
    '-v', 'error', '-print_format', 'json',
    '-show_format', '-show_streams', input
  ]);
  const j = JSON.parse(stdout);
  const v = j.streams.find(s => s.codec_type === 'video');
  const a = j.streams.find(s => s.codec_type === 'audio');
  if (!v) throw new Error('no video stream');

  const [num, den] = (v.r_frame_rate ?? '0/1').split('/').map(Number);

  return {
    duration: Number(j.format.duration),
    width: v.width, height: v.height,
    pixFmt: v.pix_fmt,
    fps: den ? num / den : null,          // "30000/1001" -> 29.97, no eval()
    vCodec: v.codec_name,
    aCodec: a?.codec_name ?? null,
    aRate: a ? Number(a.sample_rate) : null,
    aChannels: a?.channels ?? null
  };
}

// smart-trim.js
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
import { writeFile, mkdtemp, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { keyframeTimes, kfCeil, kfFloor } from './keyframes.js';
import { probe } from './probe.js';

const run = promisify(execFile);
const ff = args => run('ffmpeg', ['-hide_banner', '-loglevel', 'error', '-y', ...args]);

// The head/tail have to concat-demux with the copied middle, so they must come out
// in the same codec the source is already in. Extend this map as your library needs.
const ENCODER_FOR = {
  h264: ['-c:v', 'libx264', '-preset', 'veryfast', '-crf', '18'],
  hevc: ['-c:v', 'libx265', '-preset', 'veryfast', '-crf', '22'],
  vp9:  ['-c:v', 'libvpx-vp9', '-crf', '30', '-b:v', '0'],
  av1:  ['-c:v', 'libsvtav1', '-preset', '8', '-crf', '30'],
};

function encodeArgs(meta) {
  const venc = ENCODER_FOR[meta.vCodec];
  if (!venc) throw new Error(`no encoder mapped for source codec ${meta.vCodec}`);

  const a = [
    ...venc,
    '-pix_fmt', meta.pixFmt,
    '-vf', `scale=${meta.width}:${meta.height}`
  ];
  if (meta.aCodec) {
    a.push('-c:a', 'aac', '-ar', String(meta.aRate), '-ac', String(meta.aChannels), '-b:a', '192k');
  } else {
    a.push('-an');
  }
  return a;
}

export async function smartTrim(input, start, end, output) {
  const [kfs, meta] = await Promise.all([keyframeTimes(input), probe(input)]);
  const work = await mkdtemp(path.join(tmpdir(), 'trim-'));

  const midStart = kfCeil(kfs, start);
  const midEnd   = kfFloor(kfs, end);
  const hasMiddle = midStart !== null && midEnd !== null && midEnd - midStart > 0.05;

  try {
    if (!hasMiddle) {
      // start and end share a GOP: one short re-encode, done
      await ff(['-ss', String(start), '-i', input, '-t', String(end - start),
                ...encodeArgs(meta), output]);
      return { mode: 'reencode-only', reencodedSeconds: end - start };
    }

    const parts = [];

    if (midStart - start > 0.01) {
      const head = path.join(work, 'head.mp4');
      await ff(['-ss', String(start), '-i', input, '-t', String(midStart - start),
                ...encodeArgs(meta), head]);
      parts.push(head);
    }

    const mid = path.join(work, 'mid.mp4');
    await ff(['-ss', String(midStart), '-i', input, '-t', String(midEnd - midStart),
              '-c', 'copy', '-avoid_negative_ts', 'make_zero', mid]);
    parts.push(mid);

    if (end - midEnd > 0.01) {
      const tail = path.join(work, 'tail.mp4');
      await ff(['-ss', String(midEnd), '-i', input, '-t', String(end - midEnd),
                ...encodeArgs(meta), tail]);
      parts.push(tail);
    }

    const list = path.join(work, 'concat.txt');
    await writeFile(list, parts.map(p => `file '${p}'`).join('\n'));
    await ff(['-f', 'concat', '-safe', '0', '-i', list, '-c', 'copy',
              '-movflags', '+faststart', output]);

    return {
      mode: 'hybrid',
      reencodedSeconds: (midStart - start) + (end - midEnd),
      copiedSeconds: midEnd - midStart
    };
  } finally {
    await rm(work, { recursive: true, force: true });
  }
}

$ node -e "import('./smart-trim.js').then(m=>m.smartTrim('input.mp4',12.4,32.4,'out.mp4').then(console.log))"
{ mode: 'hybrid', reencodedSeconds: 1.982, copiedSeconds: 18.018 }

$ ffprobe -v error -show_entries format=duration -of csv=p=0 out.mp4
20.033000

ffmpeg -i source.mov \
  -c:v libx264 -crf 20 -preset medium \
  -force_key_frames "expr:gte(t,n_forced*2)" \
  -c:a aac -b:a 192k \
  mezzanine.mp4