kasaframe 0.0.0-stage → 0.1.3

package/packages/check/src/rules/layout.ts

@@ -0,0 +1,281 @@
+import type { Thumb } from "../image.ts";
+import type { Finding, SafeArea } from "../types.ts";
+
+// 멈춤·빈 화면 검사를 다 통과하고도 「화면이 비었다」가 나온다 — 9:16 에 그림·글이 가운데 20% 만 차지하거나,
+// 흐르는 바탕 위에 같은 구도가 9초씩 가는 경우. 둘 다 엄지만 한 썸네일(160px 회색조)로 잰다.
+
+export interface SceneSpan {
+  id: string;
+  from: number;
+  dur: number;
+}
+
+interface Thumbish extends Thumb {
+  width?: number;
+  height?: number;
+}
+
+const THUMB_W = 160;
+
+function dims(t: Thumbish, aspect: number): { w: number; h: number } {
+  const w = t.width ?? THUMB_W;
+  return { w, h: t.height ?? (Math.round(t.luma.length / w) || Math.round(w / aspect)) };
+}
+
+// 가장 흔한 밝기(±3)를 바탕으로 본다 — 생성 그림처럼 바탕이 고르지 않으면 바탕 몫이 작아 「꽉 참」으로 나온다
+function background(l: Uint8Array): { value: number; share: number } {
+  const hist = new Uint32Array(256);
+  for (const v of l) hist[v]++;
+  let best = 0;
+  let value = 0;
+  for (let v = 0; v < 256; v++) {
+    let n = 0;
+    for (let d = -3; d <= 3; d++) n += hist[v + d] ?? 0;
+    if (n > best) {
+      best = n;
+      value = v;
+    }
+  }
+  return { value, share: best / l.length };
+}
+
+// 내용 상자 — 바탕과 다른 픽셀의 가로·세로 분포에서 양 끝 3% 씩 떼어 낸 범위(구석의 작은 로고 하나가 상자를 키우지 않게)
+export function contentBox(l: Uint8Array, w: number, h: number, safe: { x0: number; y0: number; x1: number; y1: number }): { wFrac: number; hFrac: number; area: number } {
+  const bg = background(l);
+  if (bg.share < 0.45) return { wFrac: 1, hFrac: 1, area: 1 };
+  const cols = new Float64Array(w);
+  const rows = new Float64Array(h);
+  let total = 0;
+  for (let y = safe.y0; y < safe.y1; y++) {
+    for (let x = safe.x0; x < safe.x1; x++) {
+      if (Math.abs(l[y * w + x] - bg.value) > 14) {
+        cols[x]++;
+        rows[y]++;
+        total++;
+      }
+    }
+  }
+  const sw = safe.x1 - safe.x0;
+  const sh = safe.y1 - safe.y0;
+  if (total < 4) return { wFrac: 0, hFrac: 0, area: 0 };
+  const span = (arr: Float64Array, lo: number, hi: number) => {
+    let acc = 0;
+    let a = lo;
+    while (a < hi && acc + arr[a] <= total * 0.03) acc += arr[a++];
+    acc = 0;
+    let b = hi - 1;
+    while (b > a && acc + arr[b] <= total * 0.03) acc += arr[b--];
+    return b - a + 1;
+  };
+  const wFrac = span(cols, safe.x0, safe.x1) / sw;
+  const hFrac = span(rows, safe.y0, safe.y1) / sh;
+  return { wFrac, hFrac, area: wFrac * hFrac };
+}
+
+export interface FillOptions {
+  width: number;
+  height: number;
+  safe?: SafeArea;
+  // 세로 화면은 주 요소가 안전 영역 폭의 이만큼은 차야 한다
+  minWidthVertical?: number;
+  // 세로 화면은 위아래로도 써야 한다 — 내용이 위쪽에만 몰려 아래가 비면 경고(자막 띠는 빼고 잰다)
+  minHeightVertical?: number;
+  minArea?: number;
+  // 화면 자막 판의 윗변(영상 px) — 그 아래는 장면 내용이 아니라서 채움에서 뺀다
+  captionTop?: number;
+}
+
+// 판정에 쓸 만큼 그 장면을 봤나 — 구간 검사가 장면 경계에서 시작하면 앞 장면의 마지막 프레임 한두 장(덮기·전환 중)만
+// 그 장면 몫으로 들어와 「채움 0%」로 잡혔다
+const MIN_SAMPLES = 3;
+const enoughOf = (times: number[], dur: number): boolean => times.length >= MIN_SAMPLES && times[times.length - 1] - times[0] >= Math.min(0.5, dur * 0.4);
+
+// 시작이 t 이하인 마지막 장면 — kf.json 시각은 넷째 자리에서 반올림돼 경계에 0.0001초 틈이 날 수 있다
+function sceneOf(t: number, scenes: SceneSpan[]): SceneSpan | undefined {
+  let hit: SceneSpan | undefined;
+  for (const s of scenes) if (s.from <= t + 1e-3) hit = s;
+  return hit;
+}
+
+function median(xs: number[]): number {
+  const s = [...xs].sort((a, b) => a - b);
+  return s.length ? s[Math.floor(s.length / 2)] : 0;
+}
+
+// 화면 채움 — 장면마다 내용 상자의 가운데값. 넓이 12% 아래면 오류, 세로 화면은 폭 70%·높이 55% 아래면 경고
+export function fill(thumbs: Thumbish[], scenes: SceneSpan[], o: FillOptions): Finding[] {
+  if (!thumbs.length) return [];
+  const aspect = o.width / o.height;
+  const vertical = o.height > o.width;
+  const minW = o.minWidthVertical ?? 0.7;
+  const minH = o.minHeightVertical ?? 0.55;
+  const minArea = o.minArea ?? 0.12;
+  const groups = new Map<string, { span: SceneSpan; w: number[]; h: number[]; a: number[]; t: number[] }>();
+  for (const t of thumbs) {
+    const s = sceneOf(t.t, scenes) ?? { id: "영상", from: 0, dur: Infinity };
+    const { w, h } = dims(t, aspect);
+    const k = w / o.width;
+    const sa = o.safe ?? { top: 0, bottom: 0, left: 0, right: 0 };
+    const y0 = Math.max(0, Math.round(sa.top * k));
+    const box = contentBox(t.luma, w, h, {
+      x0: Math.max(0, Math.round(sa.left * k)),
+      y0,
+      x1: Math.min(w, w - Math.round(sa.right * k)),
+      y1: Math.max(y0 + 1, Math.min(h, h - Math.round(sa.bottom * k), o.captionTop !== undefined ? Math.round(o.captionTop * k) : h)),
+    });
+    const g = groups.get(s.id) ?? { span: s, w: [], h: [], a: [], t: [] };
+    g.w.push(box.wFrac);
+    g.h.push(box.hFrac);
+    g.a.push(box.area);
+    g.t.push(t.t);
+    groups.set(s.id, g);
+  }
+  const out: Finding[] = [];
+  for (const { span, w, h, a, t } of groups.values()) {
+    if (!enoughOf(t, span.dur)) continue;
+    const mw = median(w);
+    const mh = median(h);
+    const ma = median(a);
+    const to = Number.isFinite(span.dur) ? span.from + span.dur : thumbs.at(-1)!.t;
+    if (ma < minArea) {
+      out.push({
+        rule: "layout.fill",
+        severity: "error",
+        from: span.from,
+        to,
+        message: `장면 ${span.id} 의 내용이 안전 영역의 ${(ma * 100).toFixed(0)}% 만 차지한다 — 화면이 비어 보인다. 주 요소를 키우거나(큰 글자 단계·도식 확대) 화면을 채우는 바탕·요소를 더한다`,
+        detail: { scene: span.id, area: Math.round(ma * 1000) / 1000, width: Math.round(mw * 1000) / 1000 },
+      });
+    } else if (vertical && mw < minW) {
+      out.push({
+        rule: "layout.fill",
+        severity: "warn",
+        from: span.from,
+        to,
+        message: `장면 ${span.id} 의 주 요소 폭이 안전 영역의 ${(mw * 100).toFixed(0)}% — 세로 화면은 ${Math.round(minW * 100)}% 넘게 채운다`,
+        detail: { scene: span.id, area: Math.round(ma * 1000) / 1000, width: Math.round(mw * 1000) / 1000 },
+      });
+    } else if (vertical && mh < minH) {
+      out.push({
+        rule: "layout.fill",
+        severity: "warn",
+        from: span.from,
+        to,
+        message: `장면 ${span.id} 의 내용이 안전 영역 높이의 ${(mh * 100).toFixed(0)}% 에 몰렸다(자막 띠 빼고) — 세로 화면은 위아래로 써서 ${Math.round(minH * 100)}% 넘게 채운다(큰 숫자 아래 자·막대, 목록은 세로로 쌓기)`,
+        detail: { scene: span.id, area: Math.round(ma * 1000) / 1000, width: Math.round(mw * 1000) / 1000, height: Math.round(mh * 1000) / 1000 },
+      });
+    }
+  }
+  return out;
+}
+
+// 구도 — 썸네일을 16×N 칸으로 줄인 평균 밝기. 흐르는 점무늬처럼 잔 움직임은 칸 평균에 묻히고, 카메라·확대·새 요소는 칸을 바꾼다
+function layoutSig(t: Thumbish, aspect: number, cols = 16): Float32Array {
+  const { w, h } = dims(t, aspect);
+  const rows = Math.max(4, Math.round((cols * h) / w));
+  const sig = new Float32Array(cols * rows);
+  const cnt = new Uint32Array(cols * rows);
+  for (let y = 0; y < h; y++) {
+    const r = Math.min(rows - 1, Math.floor((y * rows) / h));
+    for (let x = 0; x < w; x++) {
+      const c = Math.min(cols - 1, Math.floor((x * cols) / w));
+      sig[r * cols + c] += t.luma[y * w + x];
+      cnt[r * cols + c]++;
+    }
+  }
+  for (let i = 0; i < sig.length; i++) sig[i] /= cnt[i] || 1;
+  return sig;
+}
+
+function sigDiff(a: Float32Array, b: Float32Array): number {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += Math.abs(a[i] - b[i]);
+  return s / a.length;
+}
+
+// 화면 안 내용 — 칸마다 센 가장자리(이웃 픽셀 밝기 차 합이 24 넘는 픽셀) 수와 평균 밝기. 숫자가 구르고 칸이 차고 줄이 붙으면 이 지도가 바뀐다.
+// 칸 평균 밝기만 보면 이런 변화가 묻혀 모델이 카메라 샷을 박아 넘겼다. 빛 방울·모눈처럼 부드럽거나 가는 바탕 흐름은 센 가장자리를 거의 안 만든다
+interface ContentSig {
+  edges: Uint16Array;
+  mean: Float32Array;
+}
+
+export function contentSig(t: Thumbish, aspect: number, cols = 32): ContentSig {
+  const { w, h } = dims(t, aspect);
+  const rows = Math.max(4, Math.round((cols * h) / w));
+  const edges = new Uint16Array(cols * rows);
+  const mean = new Float32Array(cols * rows);
+  const cnt = new Uint16Array(cols * rows);
+  const l = t.luma;
+  for (let y = 0; y < h; y++) {
+    const r = Math.min(rows - 1, Math.floor((y * rows) / h));
+    for (let x = 0; x < w; x++) {
+      const k = r * cols + Math.min(cols - 1, Math.floor((x * cols) / w));
+      const i = y * w + x;
+      mean[k] += l[i];
+      cnt[k]++;
+      if (x < w - 1 && y < h - 1 && Math.abs(l[i] - l[i + 1]) + Math.abs(l[i] - l[i + w]) > 24) edges[k]++;
+    }
+  }
+  for (let k = 0; k < mean.length; k++) mean[k] /= cnt[k] || 1;
+  return { edges, mean };
+}
+
+// 바뀐 칸의 몫 — 가장자리 수가 3 넘게 달라졌거나, 가장자리가 있는 칸(글·칸·막대)의 밝기가 20 넘게 달라졌다(회색 칸이 검게 차는 것).
+// 가장자리 없는 칸의 밝기 변화(부드러운 바탕 흐름)는 세지 않는다
+export function contentChange(a: ContentSig, b: ContentSig): number {
+  let n = 0;
+  for (let i = 0; i < a.edges.length; i++) {
+    if (Math.abs(a.edges[i] - b.edges[i]) > 3 || ((a.edges[i] > 3 || b.edges[i] > 3) && Math.abs(a.mean[i] - b.mean[i]) > 20)) n++;
+  }
+  return n / a.edges.length;
+}
+
+export interface StaticOptions {
+  width: number;
+  height: number;
+  warnSec?: number;
+  errorSec?: number;
+  // 칸 평균 밝기 차(0..255). 이보다 덜 바뀌고
+  threshold?: number;
+  // 화면 안 내용이 바뀐 칸의 몫도 이보다 작으면 같은 구도로 본다
+  contentThreshold?: number;
+}
+
+// 장면 안 변화량 — 같은 구도가 1.5초 넘게 가면 경고, 3초 넘으면 오류. 칸 평균 밝기(컷·확대·새 면)와 화면 안 내용(숫자·칸·줄)
+// 둘 다 닻 프레임에서 안 바뀌어야 같은 구도다 — 카메라 컷 없이도 내용이 움직이면 넘는다. 카메라로 메우면 camera.wander
+export function staticLayout(thumbs: Thumbish[], scenes: SceneSpan[], o: StaticOptions): Finding[] {
+  const aspect = o.width / o.height;
+  const warnSec = o.warnSec ?? 1.5;
+  const errorSec = o.errorSec ?? 3;
+  const thr = o.threshold ?? 2.5;
+  const cthr = o.contentThreshold ?? 0.015;
+  const out: Finding[] = [];
+  const spans = scenes.length ? scenes : [{ id: "영상", from: 0, dur: Infinity }];
+  for (const s of spans) {
+    const ts = thumbs.filter((t) => sceneOf(t.t, spans) === s);
+    if (ts.length < 2) continue;
+    const sigs = ts.map((t) => layoutSig(t, aspect));
+    const content = ts.map((t) => contentSig(t, aspect));
+    let a = 0;
+    while (a < ts.length - 1) {
+      let j = a + 1;
+      while (j < ts.length && sigDiff(sigs[a], sigs[j]) < thr && contentChange(content[a], content[j]) < cthr) j++;
+      const end = j - 1;
+      const len = ts[end].t - ts[a].t;
+      if (len > warnSec + 1e-6) {
+        const severity = len > errorSec + 1e-6 ? "error" : "warn";
+        out.push({
+          rule: "layout.static",
+          severity,
+          from: ts[a].t,
+          to: ts[end].t,
+          message: `장면 ${s.id} 에서 같은 구도가 ${len.toFixed(1)}초 간다 — ${warnSec}초 안에 새 요소·칸 채우기·숫자 키우기·컷·전환으로 구도를 바꾼다(카메라를 이유 없이 옮겨 메우지 않는다)`,
+          detail: { scene: s.id, seconds: Math.round(len * 10) / 10 },
+        });
+      }
+      a = Math.max(end, a + 1);
+    }
+  }
+  return out;
+}

package/packages/check/src/rules/page.ts

@@ -0,0 +1,87 @@
+import type { ContrastSample, RepeatSample } from "../scan.ts";
+import type { Finding } from "../types.ts";
+import { roundBox } from "./text.ts";
+import { runs } from "./runs.ts";
+
+// 페이드 중인 글은 낮은 대비가 당연하다. 같은 글이 minSec 넘게 낮은 대비로 머물 때만 말한다.
+// 장식으로 흐리게 깐 작은 글은 일부러일 수 있어 경고에 그친다. 읽으라고 크게 쓴 글이 거의 안 보이면 오류.
+export function contrast(samples: ContrastSample[], o: { shotFps: number; minSec?: number; warnBelow?: number; errorBelow?: number; errorMinPx?: number }): Finding[] {
+  const minSec = o.minSec ?? 0.9;
+  const warnBelow = o.warnBelow ?? 3;
+  const errorBelow = o.errorBelow ?? 1.5;
+  const errorMinPx = o.errorMinPx ?? 24;
+  const byText = new Map<string, ContrastSample[]>();
+  for (const s of samples) {
+    if (s.ratio >= warnBelow) continue;
+    const key = s.text;
+    if (!byText.has(key)) byText.set(key, []);
+    byText.get(key)!.push(s);
+  }
+  const each: { from: number; to: number; text: string; worst: ContrastSample; severe: boolean }[] = [];
+  for (const [text, list] of byText) {
+    for (const r of runs(list.map((s) => s.t), 1.5 / o.shotFps)) {
+      if (r.to - r.from + 1 / o.shotFps < minSec) continue;
+      const inRun = list.filter((s) => s.t >= r.from && s.t <= r.to);
+      const worst = inRun.reduce((a, b) => (b.ratio < a.ratio ? b : a));
+      each.push({ from: r.from, to: r.to + 1 / o.shotFps, text, worst, severe: worst.ratio < errorBelow && worst.sizePx >= errorMinPx });
+    }
+  }
+  // 한 화면에 흐린 글이 여럿이면 한 줄로 — 고칠 곳은 대개 그 화면의 바탕이나 덮개 하나다.
+  each.sort((a, b) => a.from - b.from);
+  const groups: (typeof each)[] = [];
+  for (const e of each) {
+    const g = groups.find((x) => x[0].severe === e.severe && e.from < Math.max(...x.map((y) => y.to)) && e.to > x[0].from);
+    if (g) g.push(e);
+    else groups.push([e]);
+  }
+  return groups.map((g) => {
+    const worst = g.reduce((a, b) => (b.worst.ratio < a.worst.ratio ? b : a)).worst;
+    const severe = g[0].severe;
+    const names = g.slice(0, 4).map((x) => `"${x.text.trim()}"`).join(" · ");
+    return {
+      rule: "text.contrast",
+      severity: severe ? ("error" as const) : ("warn" as const),
+      from: Math.min(...g.map((x) => x.from)),
+      to: Math.max(...g.map((x) => x.to)),
+      message: `글자 대비가 낮다 — 가장 낮은 ${worst.ratio}:1 (${worst.sizePx}px) · 글 ${g.length}개: ${names}${g.length > 4 ? " …" : ""}${severe ? " — 거의 안 보인다" : " — 바탕과 3:1 이상 벌린다"}`,
+      detail: { ratio: worst.ratio, sizePx: worst.sizePx, box: roundBox(worst.box), texts: g.map((x) => ({ text: x.text, ratio: x.worst.ratio, from: x.from, to: x.to })) },
+    };
+  });
+}
+
+export function repeatable(samples: RepeatSample[]): Finding[] {
+  const bad = samples.filter((s) => s.diff > 0.5 || !s.textSame);
+  return bad.map((s) => ({
+    rule: "frame.nondeterministic",
+    severity: "error" as const,
+    from: s.t,
+    to: s.t,
+    message: `같은 시각을 두 번 그렸더니 달랐다(차 ${s.diff}${s.textSame ? "" : ", 글도 다름"}) — Math.random·Date.now·누적 상태를 t 의 함수로 바꾼다`,
+    detail: { diff: s.diff, textSame: s.textSame },
+  }));
+}
+
+export function pageErrors(errors: { t: number; text: string }[], fps: number): Finding[] {
+  const byText = new Map<string, number[]>();
+  for (const e of errors) {
+    // 시각만 다른 같은 오류(「@7.300」 따위)는 한데 묶는다.
+    const key = e.text.replace(/@?\d+\.\d+/g, "#").slice(0, 300);
+    if (!byText.has(key)) byText.set(key, []);
+    byText.get(key)!.push(e.t);
+  }
+  const out: Finding[] = [];
+  for (const [key, times] of byText) {
+    const first = errors.find((e) => e.text.replace(/@?\d+\.\d+/g, "#").slice(0, 300) === key)!;
+    const valid = times.filter((t) => t >= 0);
+    const rs = valid.length ? runs(valid, 1.5 / fps) : [{ from: 0, to: 0, count: times.length }];
+    out.push({
+      rule: "page.error",
+      severity: "error",
+      from: rs[0].from,
+      to: rs[rs.length - 1].to,
+      message: `페이지 오류 ${times.length}번${valid.length ? "" : "(불러올 때)"} — ${first.text.slice(0, 200)}`,
+      detail: { count: times.length, spans: rs.length },
+    });
+  }
+  return out;
+}

package/packages/check/src/rules/runs.ts

@@ -0,0 +1,20 @@
+export interface Run {
+  from: number;
+  to: number;
+  count: number;
+}
+
+// 정렬된 시각들을 maxGap 보다 가까운 것끼리 묶는다 — 「연속 프레임 묶음 = 한 번」.
+export function runs(times: number[], maxGap: number): Run[] {
+  const out: Run[] = [];
+  for (const t of [...times].sort((a, b) => a - b)) {
+    const last = out[out.length - 1];
+    if (last && t - last.to <= maxGap) {
+      last.to = t;
+      last.count++;
+    } else {
+      out.push({ from: t, to: t, count: 1 });
+    }
+  }
+  return out;
+}