kasaframe 0.1.1 → 0.1.4

package/packages/cli/src/mix.ts

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { audioDuration, findSilences } from "@kasaframe/gen";
+
+// 내레이션 + 곡 섞기 — kf.json 에 audio(섞기 값)가 있는 프로젝트만. 없으면 렌더는 예전처럼 곡만 얹는다
+export interface AudioMix {
+  musicDb: number; // 말하는 동안 곡이 목소리보다 이만큼 아래(덕킹 포함)
+  duck: boolean;
+  lufs: number;
+  truePeak: number;
+  fadeOut: number;
+}
+
+// 목소리를 먼저 이 크기로 맞춘다 — 덕킹 문턱이 목소리 크기에 묶여 있어서 공급자마다 다른 크기를 한 자리로
+const VOICE_LUFS = -18;
+// 덕킹 두 입력의 프레임 크기를 맞춘다 — 목소리 wav(1024)·곡 mp3(1152) 프레임이 도착 차례에 따라 sidechaincompress 결과가
+// 실행마다 달라졌다(같은 요청이면 바이트까지 같은 영상이어야 한다). 두 갈래를 같은 크기로 잘라 넣으면 늘 같은 값이 나온다
+const FRAMES = "asetnsamples=n=1024:p=0";
+const SIDECHAIN = "sidechaincompress=threshold=0.025:ratio=3:attack=20:release=400:knee=4";
+
+function ffmpeg(args: string[]): Promise<string> {
+  return new Promise((done, fail) => {
+    const p = spawn("ffmpeg", ["-hide_banner", "-nostats", "-y", ...args]);
+    let err = "";
+    p.stderr.on("data", (b: Buffer) => (err += b));
+    p.on("error", fail);
+    p.on("close", (code) => (code === 0 ? done(err) : fail(new Error(`ffmpeg 섞기 실패(${code}): ${err.trim().split("\n").slice(-3).join(" / ")}`))));
+  });
+}
+
+// 통합 크기(LUFS) — 무음은 게이트가 빼서 말·곡이 실제로 울리는 곳만 잰다
+async function loudness(input: string[], filter = ""): Promise<number> {
+  const err = await ffmpeg([...input, "-af", `${filter ? `${filter},` : ""}ebur128=framelog=quiet`, "-f", "null", "-"]);
+  const m = err.match(/I:\s+(-?[\d.]+|-inf) LUFS/g)?.at(-1)?.match(/(-?[\d.]+|-inf)/);
+  const v = m ? Number(m[1]) : NaN;
+  return Number.isFinite(v) ? v : -70;
+}
+
+// 말하는 구간만 고르는 aselect 식 — 목소리 한 줄에서 0.3초 넘는 숨을 뺀 자리
+async function speechSelect(voice: string): Promise<string | null> {
+  const total = await audioDuration(voice);
+  const spans: [number, number][] = [];
+  let t = 0;
+  for (const s of await findSilences(voice, { db: -40, min: 0.3 })) {
+    if (s.from > t + 0.2) spans.push([t, s.from]);
+    t = Math.min(s.to, total);
+  }
+  if (total > t + 0.2) spans.push([t, total]);
+  return spans.length ? spans.map(([a, b]) => `between(t,${a.toFixed(3)},${b.toFixed(3)})`).join("+") : null;
+}
+
+interface Sources {
+  voice?: string;
+  music?: string;
+  musicFrom: number; // 곡 시각 = musicFrom + 영상 시각
+}
+
+export function mixSettings(dir: string): { audio: AudioMix; voice?: string } | null {
+  const kf = JSON.parse(readFileSync(join(dir, "kf.json"), "utf8"));
+  if (!kf.audio) return null;
+  const voice = kf.narration ? resolve(dir, kf.narration) : undefined;
+  return { audio: kf.audio, voice: voice && existsSync(voice) ? voice : undefined };
+}
+
+// 영상 [from, from+dur) 의 소리를 out(wav)으로. total 은 영상 전체 길이 — 끝 페이드는 영상 끝에 걸린다
+export async function mixAudio(src: Sources, o: { audio: AudioMix; from: number; dur: number; total: number; out: string }): Promise<string> {
+  const { audio } = o;
+  const seg = (path: string, at: number) => ["-ss", at.toFixed(6), "-t", o.dur.toFixed(6), "-i", path];
+  const inputs: string[] = [];
+  const chains: string[] = [];
+  let k = 0;
+  let voiceLabel = "";
+  let musicLabel = "";
+  // 끝 페이드는 영상 끝 몇 초에만 — 구간만 굽을 때도 같은 자리
+  const fadeAt = o.total - audio.fadeOut - o.from;
+  const fade = audio.fadeOut > 0 && fadeAt < o.dur ? `,afade=t=out:st=${Math.max(0, fadeAt).toFixed(4)}:d=${audio.fadeOut.toFixed(4)}` : "";
+  let voiceGain = 0;
+  if (src.voice) {
+    // 크기는 영상 전체로 잰다 — 구간만 재면 구간마다 목소리 크기가 달라진다
+    voiceGain = VOICE_LUFS - (await loudness(["-i", src.voice]));
+    inputs.push(...seg(src.voice, o.from));
+    chains.push(`[${k}]aresample=48000,volume=${voiceGain.toFixed(2)}dB,pan=stereo|c0=c0|c1=c0,${FRAMES},asplit=2[v][vsc]`);
+    voiceLabel = "[v]";
+    k++;
+  }
+  if (src.music) {
+    // 말이 있으면 말하는 동안 곡이 목소리보다 |musicDb| 아래, 없으면 곡이 주인공이라 그대로 두고 정규화만
+    const gain = src.voice ? await musicGain(src as Required<Sources>, voiceGain, audio, o.total) : 0;
+    inputs.push("-stream_loop", "-1", ...seg(src.music, src.musicFrom + o.from));
+    chains.push(`[${k}]aresample=48000,aformat=channel_layouts=stereo,volume=${gain.toFixed(2)}dB${fade},${FRAMES}[m0]`);
+    musicLabel = "[m0]";
+    if (src.voice && audio.duck) {
+      chains.push(`[m0][vsc]${SIDECHAIN}[m1]`);
+      musicLabel = "[m1]";
+    }
+    k++;
+  }
+  if (!voiceLabel && !musicLabel) throw new Error("섞을 소리가 없다");
+  if (voiceLabel && !musicLabel) chains.push("[vsc]anullsink");
+  const parts = [voiceLabel, musicLabel].filter(Boolean);
+  chains.push(parts.length === 2 ? `${parts.join("")}amix=inputs=2:normalize=0:duration=longest,apad,atrim=0:${o.dur.toFixed(6)}[pre]` : `${parts[0]}apad,atrim=0:${o.dur.toFixed(6)}[pre]`);
+  const pre = o.out.replace(/\.wav$/, ".pre.wav");
+  await ffmpeg([...inputs, "-filter_complex", chains.join(";"), "-map", "[pre]", "-c:a", "pcm_s24le", "-ar", "48000", pre]);
+  // 두 번 잰다 — 한 번에 loudnorm 을 걸면 동적 모드로 들어가 덕킹 모양이 뭉개진다. 잰 값을 주고 linear 로 한 번에 올린다
+  const err = await ffmpeg(["-i", pre, "-af", `loudnorm=I=${audio.lufs}:TP=${audio.truePeak}:LRA=11:print_format=json`, "-f", "null", "-"]);
+  const j = JSON.parse(err.slice(err.lastIndexOf("{"), err.lastIndexOf("}") + 1));
+  const ln = `loudnorm=I=${audio.lufs}:TP=${audio.truePeak}:LRA=11:measured_I=${j.input_i}:measured_TP=${j.input_tp}:measured_LRA=${j.input_lra}:measured_thresh=${j.input_thresh}:offset=${j.target_offset}:linear=true`;
+  await ffmpeg(["-i", pre, "-af", `${ln},aresample=48000`, "-c:a", "pcm_s16le", o.out]);
+  return o.out;
+}
+
+// 곡 셈여림(조용한 도입·부푸는 가운데)과 덕킹 깊이(5–10dB)가 곡마다 달라 상수로는 안 맞는다 — 영상 전체에서 말하는 구간만 골라
+// 목소리와 덕킹된 곡을 한 번 재고 그 차만큼 곡을 옮긴다. 덕킹은 목소리로만 걸려 곡 크기와 무관하니 한 번이면 된다
+export async function musicGain(src: Required<Sources>, voiceGain: number, audio: AudioMix, total: number): Promise<number> {
+  const music = ["-stream_loop", "-1", "-ss", src.musicFrom.toFixed(6), "-t", total.toFixed(6), "-i", src.music];
+  const g0 = VOICE_LUFS + audio.musicDb - (await loudness(music));
+  const sel = await speechSelect(src.voice);
+  if (!sel) return g0;
+  const pick = `aselect='${sel}',asetpts=N/SR/TB`;
+  const voiceSpeech = await loudness(["-i", src.voice], `volume=${voiceGain.toFixed(2)}dB,${pick}`);
+  const duck = audio.duck ? `;[m0][vsc]${SIDECHAIN}[m1]` : "";
+  const err = await ffmpeg([
+    "-i", src.voice, ...music,
+    "-filter_complex", `[0]aresample=48000,volume=${voiceGain.toFixed(2)}dB,pan=stereo|c0=c0|c1=c0,${FRAMES}[vsc];[1]aresample=48000,aformat=channel_layouts=stereo,volume=${g0.toFixed(2)}dB,${FRAMES}[m0]${duck};[${audio.duck ? "m1" : "m0"}]${pick},ebur128=framelog=quiet[out]${audio.duck ? "" : ";[vsc]anullsink"}`,
+    "-map", "[out]", "-f", "null", "-",
+  ]);
+  const m = err.match(/I:\s+(-?[\d.]+|-inf) LUFS/g)?.at(-1)?.match(/(-?[\d.]+|-inf)/);
+  const musicSpeech = m ? Number(m[1]) : NaN;
+  return Number.isFinite(musicSpeech) ? g0 + (voiceSpeech + audio.musicDb - musicSpeech) : g0;
+}

package/packages/cli/src/pick.ts

@@ -0,0 +1,110 @@
+// kf make 테마 고르기 — 후보 넷만 담은 견본 시트를 그 자리에서(칸은 캐시), 레퍼런스 그림·주소에서 생김새 읽기, 터미널에서 분위기 한 마디로 다시 고르기
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import type { Question } from "@kasaframe/gen";
+import { cellsDir, loadTheme } from "@kasaframe/themes";
+import { refFromPixels, type RefLook } from "@kasaframe/themes/look";
+import { launch } from "./browser.ts";
+import { cellFrame, cellOf, ensureCells, gridSheet } from "./cells.ts";
+
+const IMAGE = /\.(png|jpe?g|webp|gif|bmp|avif)(\?.*)?$/i;
+
+function pixels(file: string): Uint8Array {
+  const r = spawnSync("ffmpeg", ["-v", "error", "-i", file, "-frames:v", "1", "-vf", "scale=48:48:flags=area", "-f", "rawvideo", "-pix_fmt", "rgb24", "-"], { maxBuffer: 1 << 20 });
+  if (r.status !== 0 || !r.stdout?.length) throw new Error(`레퍼런스 ${file} 를 못 읽었다 — ${String(r.stderr ?? "").trim().split("\n").pop()}`);
+  return new Uint8Array(r.stdout);
+}
+
+/** 그림 파일·그림 주소·웹 페이지 주소(첫 화면을 찍는다) → 생김새 */
+export async function refLook(src: string): Promise<RefLook> {
+  if (!/^https?:\/\//.test(src)) {
+    const file = resolve(src);
+    if (!existsSync(file)) throw new Error(`레퍼런스 ${src} 가 없다`);
+    return refFromPixels(pixels(file), src);
+  }
+  const tmp = mkdtempSync(join(tmpdir(), "kf-ref-"));
+  try {
+    const file = join(tmp, "ref.png");
+    const head = await fetch(src, { method: "GET" }).catch(() => null);
+    const type = head?.headers.get("content-type") ?? "";
+    if (head?.ok && (type.startsWith("image/") || IMAGE.test(src))) writeFileSync(join(tmp, "ref"), Buffer.from(await head.arrayBuffer()));
+    else {
+      const browser = await launch();
+      try {
+        const page = await browser.newPage({ viewport: { width: 1280, height: 800 } });
+        await page.goto(src, { waitUntil: "load", timeout: 30_000 });
+        await page.waitForTimeout(800);
+        writeFileSync(file, await page.screenshot({ type: "png" }));
+      } finally {
+        await browser.close();
+      }
+    }
+    return refFromPixels(pixels(existsSync(file) ? file : join(tmp, "ref")), src);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+const candidatesOf = (q: Question) => q.choices.map((c) => c.value).filter((v) => v !== "auto" && v !== "none");
+
+/** 후보 넷 견본 시트 — 칸이 없거나 낡은 후보만 그 자리에서 찍고, 시트 경로를 질문 글에 붙인다 */
+export async function candidateSheet(q: Question, log: (l: string) => void = () => {}): Promise<string | null> {
+  const ids = candidatesOf(q);
+  if (!ids.length) return null;
+  const tmp = mkdtempSync(join(tmpdir(), "kf-pick-"));
+  try {
+    const cells = ensureCells(ids, tmp, log);
+    const have = ids.filter((id) => cells.has(id));
+    if (!have.length) return null;
+    const out = join(cellsDir, "picks", `${createHash("sha256").update(have.join("|")).digest("hex").slice(0, 12)}.png`);
+    const frame = cellFrame(have[0]) ?? { width: 1080, height: 1920, safe: { top: 230, bottom: 460, left: 40, right: 40 } };
+    await gridSheet(
+      have.map((id, i) => {
+        const t = loadTheme(id);
+        return { ...cellOf(t, cells.get(id)!), title: `${i + 1}. ${t.name}` };
+      }),
+      out,
+      { heading: "테마 후보 — 같은 문장 한 장면(쇼츠 9:16) 끝 프레임. 번호는 보기 차례", cols: have.length, w: 300, frame },
+    );
+    q.ask = `${q.ask} — 후보 견본 시트 ${out}`;
+    return out;
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+export interface Retry {
+  mood?: string;
+  ref?: RefLook;
+}
+
+/**
+ * 터미널 테마 묻기 — 번호로 고르거나, 분위기 한 마디·그림 경로·주소를 치면 그걸로 후보를 다시 고른다(again 이 새 질문을 돌려준다).
+ * 터미널이 아니면 null
+ */
+export async function askThemeTerminal(first: Question, again: (r: Retry) => Promise<Question>): Promise<string | null> {
+  if (!process.stdin.isTTY) return null;
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  let q = first;
+  try {
+    for (;;) {
+      const lines = q.choices.map((c, i) => `  ${i + 1}) ${c.label}${c.value === q.default ? " (권장)" : ""}${c.note ? ` — ${c.note}` : ""}`).join("\n");
+      const a = (await rl.question(`\n${q.ask}\n${lines}\n번호(엔터 = 알아서) · 분위기 한 마디 · 그림 경로·주소: `)).trim();
+      if (a === "") return q.default;
+      if (/^\d+$/.test(a) && q.choices[Number(a) - 1]) return q.choices[Number(a) - 1].value;
+      if (q.accepts?.(a)) return a;
+      const isRef = /^https?:\/\//.test(a) || IMAGE.test(a) || existsSync(resolve(a));
+      try {
+        q = await again(isRef ? { ref: await refLook(a) } : { mood: a });
+      } catch (e) {
+        process.stderr.write(`${(e as Error).message}\n`);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}

package/packages/cli/src/pool.ts

@@ -0,0 +1,34 @@
+// 장면별 일(장면 쓰기·그림·목소리)을 동시에 — 모델·공급자 호출이 대부분 기다림이라 겹치면 장면 수만큼 빨라진다.
+// 동시 수는 KF_JOBS 로 누른다(요금 한도·속도 제한이 빡빡한 키). 돈 드는 호출의 묻기·예산은 부르는 쪽 그대로다
+
+export const jobLimit = (fallback: number): number => Math.max(1, Math.floor(Number(process.env.KF_JOBS) || fallback));
+
+/** n 개까지 동시에. 결과는 넣은 순서대로 */
+export async function pool<T, R>(items: readonly T[], n: number, fn: (item: T, i: number) => Promise<R>): Promise<R[]> {
+  const out: R[] = new Array(items.length);
+  let next = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(n, items.length) }, async () => {
+      for (let i = next++; i < items.length; i = next++) out[i] = await fn(items[i], i);
+    }),
+  );
+  return out;
+}
+
+/** 한 번에 n 개만 지나가는 문 — 크롬을 띄우는 일처럼 기계가 감당할 만큼만 */
+export function gate(n: number): <R>(fn: () => Promise<R>) => Promise<R> {
+  let busy = 0;
+  const wait: (() => void)[] = [];
+  return async (fn) => {
+    // 자리를 기다리던 쪽에 바로 넘긴다 — 풀었다 다시 잡는 사이에 새로 온 쪽이 끼어들면 n 을 넘는다
+    if (busy < n) busy++;
+    else await new Promise<void>((r) => wait.push(r));
+    try {
+      return await fn();
+    } finally {
+      const w = wait.shift();
+      if (w) w();
+      else busy--;
+    }
+  };
+}