Files
CenaForge/scripts/lib/verify.ts
T
MateuusandClaude Opus 5.5 84f30bbc2d CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 16:35:09 -03:00

107 lines
4.0 KiB
TypeScript

// Verificação do MP4 com FFprobe (contagem real de quadros decodificados).
import { runProcess, succeeded, describeFailure } from "./process.ts";
import type { Tool } from "./tools.ts";
export type ProbeSummary = {
formatName: string;
sizeBytes: number;
durationSeconds: number;
video: {
codec: string;
width: number;
height: number;
pixFmt: string;
rFrameRate: string;
avgFrameRate: string;
frames: number;
} | null;
audio: { codec: string; durationSeconds: number } | null;
};
export type Expectation = {
width?: number;
height?: number;
fps?: number;
durationSeconds?: number;
frames?: number;
audio?: boolean;
};
export type Check = { name: string; ok: boolean; detail: string };
export async function probeVideo(ffprobe: Tool, file: string): Promise<ProbeSummary> {
const r = await runProcess(ffprobe.path, [
"-v", "error",
"-count_frames",
"-show_entries", "stream=codec_type,codec_name,width,height,pix_fmt,r_frame_rate,avg_frame_rate,nb_read_frames,duration:format=duration,format_name,size",
"-of", "json",
file,
], { timeoutMs: 120_000 });
if (!succeeded(r)) throw new Error(describeFailure("ffprobe", r));
return parseProbe(r.stdout);
}
export function parseProbe(json: string): ProbeSummary {
type RawStream = Record<string, string | number | undefined>;
const raw = JSON.parse(json) as { streams?: RawStream[]; format?: Record<string, string> };
const streams = raw.streams ?? [];
const v = streams.find((s) => s.codec_type === "video");
const a = streams.find((s) => s.codec_type === "audio");
return {
formatName: raw.format?.format_name ?? "",
sizeBytes: Number(raw.format?.size ?? 0),
durationSeconds: Number(raw.format?.duration ?? NaN),
video: v
? {
codec: String(v.codec_name),
width: Number(v.width),
height: Number(v.height),
pixFmt: String(v.pix_fmt),
rFrameRate: String(v.r_frame_rate),
avgFrameRate: String(v.avg_frame_rate),
frames: Number(v.nb_read_frames),
}
: null,
audio: a ? { codec: String(a.codec_name), durationSeconds: Number(a.duration ?? NaN) } : null,
};
}
export function evaluateProbe(p: ProbeSummary, e: Expectation): Check[] {
const checks: Check[] = [];
const add = (name: string, ok: boolean, detail: string) => checks.push({ name, ok, detail });
add("arquivo não vazio", p.sizeBytes > 0, `${p.sizeBytes} bytes`);
add("contêiner MP4", p.formatName.includes("mp4"), p.formatName || "desconhecido");
if (!p.video) {
add("stream de vídeo", false, "nenhum stream de vídeo");
return checks;
}
add("codec H.264", p.video.codec === "h264", p.video.codec);
add("pixel format yuv420p", p.video.pixFmt === "yuv420p", p.video.pixFmt);
add("quadros decodificados > 0", p.video.frames > 0, `${p.video.frames}`);
if (e.width !== undefined && e.height !== undefined) {
add("dimensões", p.video.width === e.width && p.video.height === e.height, `${p.video.width}x${p.video.height} (esperado ${e.width}x${e.height})`);
}
if (e.fps !== undefined) {
const fps = ratio(p.video.rFrameRate);
add("FPS", Math.abs(fps - e.fps) < 1e-6, `${p.video.rFrameRate} (esperado ${e.fps}/1)`);
}
if (e.frames !== undefined) {
add("total de quadros", p.video.frames === e.frames, `${p.video.frames} (esperado ${e.frames})`);
}
if (e.durationSeconds !== undefined) {
// Tolerância de um quadro, conforme o critério de aceite.
const tolerance = e.fps ? 1 / e.fps : 1 / 30;
const diff = Math.abs(p.durationSeconds - e.durationSeconds);
add("duração (±1 quadro)", diff <= tolerance + 1e-9, `${p.durationSeconds.toFixed(4)} s (esperado ${e.durationSeconds} s, diferença ${diff.toFixed(4)} s)`);
}
if (e.audio !== undefined) {
add(e.audio ? "stream de áudio presente" : "sem áudio", e.audio === (p.audio !== null), p.audio ? `${p.audio.codec}, ${p.audio.durationSeconds} s` : "nenhum");
}
return checks;
}
function ratio(r: string): number {
const [n, d] = r.split("/").map(Number);
return d ? n / d : n;
}