@omelhorsite/video-sdk 0.2.0 → 0.3.0

package/README.md

@@ -64,7 +64,14 @@ export by construction.
 - Captions live in the project in source time (`project.captions[].words`,
   `{ t0, t1, text }`), so cutting or reordering never invalidates them.
   `timelineWords(project)` brings the words onto the timeline; `groupWords`
-  and `captionStates` do the karaoke grouping.
+  and `captionStates` do the karaoke grouping. A word belongs to the piece
+  that holds its **centre**: a word said before a cut has it on one side, one
+  said after has it on the other, and a few hundredths of drift in a speech
+  model's timings cannot change that.
+- `sourceCaptions(project, words)` is the way back, for captioning an edit
+  rather than the raw material: give it words in timeline time and it returns
+  them in source time, grouped by asset. `audibleSpans(project)` lists the
+  pieces whose own sound is in the mix — a silent overlay carries no words.
 - `sliceProject(project, from, to)` cuts a window out of a project for a fast
   partial render.
 

package/dist/index.js

@@ -449,7 +449,40 @@ var DEFAULT_CAPTION_STYLE = {
   highlight: "#ffd600",
   stroke: "#000000",
   maxWidth: 0.9,
-  fontFamily: "Montserrat, Helvetica, Arial, sans-serif"
+  fontFamily: "Montserrat, Helvetica, Arial, sans-serif",
+  fontWeight: 800,
+  lineHeight: 1.24,
+  letterSpacing: 0,
+  wordSpacing: 0,
+  shadow: "",
+  punctuation: true,
+  box: false,
+  boxPadX: 0.27,
+  boxPadY: 0.26,
+  boxRadius: 0.12,
+  boxPop: 0.95,
+  boxPopTime: 0.1
+};
+var CAPTION_PRESETS = {
+  karaoke: {},
+  box: {
+    fontScale: 0.046,
+    strokeScale: 0,
+    pos: 0.78,
+    maxWords: 4,
+    maxChars: 24,
+    maxWidth: 0.6,
+    color: "#ffffff",
+    highlight: "#036cf0",
+    fontFamily: "Poppins, Montserrat, Helvetica, Arial, sans-serif",
+    fontWeight: 700,
+    lineHeight: 0.92,
+    letterSpacing: -0.02,
+    wordSpacing: 0.15,
+    shadow: "rgba(0,0,0,0.55)",
+    punctuation: false,
+    box: true
+  }
 };
 var SENT_END = ".?!:;,";
 var groupWords = (words, style) => {
@@ -492,6 +525,32 @@ var captionStates = (chunks, tail) => {
   });
   return states;
 };
+var easeOut = (p) => 1 - (1 - p) * (1 - p);
+var boxScale = (state, t, style, fps) => {
+  if (style.boxPopTime <= 0)
+    return 1;
+  const entrada = easeOut(Math.min(1, Math.max(0, (t - state.t0) / style.boxPopTime)));
+  const saida = easeOut(Math.min(1, Math.max(0, (state.t1 - (t + 1 / fps)) / style.boxPopTime)));
+  return style.boxPop + (1 - style.boxPop) * Math.min(entrada, saida);
+};
+var captionFrames = (states, style, fps) => {
+  if (!style.box)
+    return states.map((state) => ({ state, t0: state.t0, t1: state.t1, scale: 1 }));
+  const out = [];
+  for (const state of states) {
+    const n0 = Math.round(state.t0 * fps);
+    const n1 = Math.round(state.t1 * fps);
+    for (let n2 = n0;n2 < n1; n2++) {
+      const scale = Math.round(boxScale(state, n2 / fps, style, fps) * 1000) / 1000;
+      const last = out[out.length - 1];
+      if (last && last.state === state && last.scale === scale)
+        last.t1 = (n2 + 1) / fps;
+      else
+        out.push({ state, t0: n2 / fps, t1: (n2 + 1) / fps, scale });
+    }
+  }
+  return out;
+};
 var sourceSpans = (project, assetId) => {
   const spans = [];
   for (const track of project.tracks) {
@@ -508,21 +567,13 @@ var sourceSpans = (project, assetId) => {
   }
   return spans.sort((a, b) => a.start - b.start);
 };
-var BORDA = 0.12;
-var remapWords = (words, spans, borda = BORDA) => {
+var remapWords = (words, spans) => {
   const out = [];
   for (const w of words) {
-    let best;
-    for (const span2 of spans) {
-      const overlap = Math.min(w.t1, span2.out + borda) - Math.max(w.t0, span2.in - borda);
-      if (overlap <= 0)
-        continue;
-      if (!best || overlap > best.overlap)
-        best = { span: span2, overlap };
-    }
-    if (!best)
+    const meio = (w.t0 + w.t1) / 2;
+    const span = spans.find((s) => meio >= s.in && meio <= s.out);
+    if (!span)
       continue;
-    const { span } = best;
     const t0 = Math.min(Math.max(w.t0, span.in), span.out) - span.in + span.start;
     const t1 = Math.min(Math.max(w.t1, span.in), span.out) - span.in + span.start;
     if (t1 > t0)
@@ -536,6 +587,44 @@ var timelineWords = (project) => {
     all.push(...remapWords(src.words, sourceSpans(project, src.assetId)));
   return all.sort((a, b) => a.t0 - b.t0);
 };
+var audibleSpans = (project) => {
+  const spans = [];
+  for (const track of project.tracks) {
+    if (track.kind !== "video" || track.muted)
+      continue;
+    for (const clip of track.clips) {
+      if (clip.kind !== "video")
+        continue;
+      const v = clip;
+      if (v.muted)
+        continue;
+      spans.push({ assetId: v.assetId, start: v.start, end: v.start + v.duration, in: v.in });
+    }
+  }
+  return spans.sort((a, b) => a.start - b.start);
+};
+var sourceCaptions = (project, words, language) => {
+  const spans = audibleSpans(project);
+  const porAsset = new Map;
+  for (const w of words) {
+    const meio = (w.t0 + w.t1) / 2;
+    const s = spans.find((x) => meio >= x.start && meio <= x.end);
+    if (!s)
+      continue;
+    const t0 = Math.min(Math.max(w.t0, s.start), s.end) - s.start + s.in;
+    const t1 = Math.min(Math.max(w.t1, s.start), s.end) - s.start + s.in;
+    if (t1 <= t0)
+      continue;
+    const lista = porAsset.get(s.assetId) ?? [];
+    lista.push({ t0, t1, text: w.text });
+    porAsset.set(s.assetId, lista);
+  }
+  return [...porAsset.entries()].map(([assetId, ws]) => ({
+    assetId,
+    words: ws.sort((a, b) => a.t0 - b.t0),
+    ...language ? { language } : {}
+  }));
+};
 // src/slice.ts
 var temSource = (c) => c.kind === "video" || c.kind === "image" || c.kind === "audio";
 var sliceClip = (clip, from, to) => {
@@ -1139,6 +1228,7 @@ export {
   timelineWords,
   stringTokenStore,
   sourceSpans,
+  sourceCaptions,
   sliceProject,
   sliceClip,
   shadowMargin,
@@ -1170,6 +1260,9 @@ export {
   compile,
   cloudCaptionStyle,
   captionStates,
+  captionFrames,
+  boxScale,
+  audibleSpans,
   assetEntryName,
   SHADOW_OPACITY,
   SHADOW_DROP,
@@ -1193,5 +1286,6 @@ export {
   DEFAULT_CAPTION_STYLE,
   DEFAULT_BASE_URL,
   Cloud,
-  CREDENTIALS_VERSION
+  CREDENTIALS_VERSION,
+  CAPTION_PRESETS
 };

package/dist/types/captions.d.ts

@@ -45,8 +45,40 @@ export interface CaptionStyle {
     /** Largura maxima do texto como fraccao da largura do projecto. */
     maxWidth: number;
     fontFamily: string;
+    fontWeight: number;
+    /** Distancia entre linhas, em fraccao da fonte. */
+    lineHeight: number;
+    /** Espaco extra entre letras e entre palavras, em fraccao da fonte. */
+    letterSpacing: number;
+    wordSpacing: number;
+    /** Sombra suave por baixo do texto (cor CSS); "" = sem sombra. */
+    shadow: string;
+    /** Mostra a pontuacao colada a`s palavras; o agrupamento corta nela na mesma. */
+    punctuation: boolean;
+    /**
+     * Realce em caixa: a palavra activa fica com a cor do texto, sobre um
+     * rectangulo arredondado da cor `highlight`, em vez de mudar de cor.
+     */
+    box: boolean;
+    /** Folga da caixa a` volta das maiusculas e raio dos cantos, em fraccao da fonte. */
+    boxPadX: number;
+    boxPadY: number;
+    boxRadius: number;
+    /**
+     * A caixa entra a esta escala e cresce ate' 1 em `boxPopTime` segundos, e
+     * encolhe de volta no fim da palavra. So' a caixa: o texto nao mexe.
+     */
+    boxPop: number;
+    boxPopTime: number;
 }
 export declare const DEFAULT_CAPTION_STYLE: CaptionStyle;
+/**
+ * Estilos prontos. `box` e' o realce em caixa azul, medido frame a frame de
+ * um video de referencia a 1080 de largura: maiusculas com 36 px, linhas a
+ * 46 px, caixa 13 px para fora das maiusculas, que entra a 95% do tamanho,
+ * assenta em ~0.1 s e sai pelo mesmo caminho.
+ */
+export declare const CAPTION_PRESETS: Record<string, Partial<CaptionStyle>>;
 /** Corta a lista de palavras em grupos curtos (o que aparece de cada vez). */
 export declare const groupWords: (words: CaptionWord[], style: CaptionStyle) => CaptionWord[][];
 /** Um grupo no ecra com uma palavra realcada. */
@@ -63,6 +95,26 @@ export interface CaptionState {
  * entra pelo grupo seguinte adentro.
  */
 export declare const captionStates: (chunks: CaptionWord[][], tail: number) => CaptionState[];
+/** Um troco de um estado em que a caixa tem uma escala so'. */
+export interface CaptionFrame {
+    state: CaptionState;
+    t0: number;
+    t1: number;
+    scale: number;
+}
+/**
+ * Escala da caixa no frame `[t, t + 1/fps)` de um estado. A entrada mede-se
+ * no inicio do frame e a saida no fim, para o primeiro e o ultimo frame de
+ * cada palavra ficarem ambos em `boxPop`, como na referencia.
+ */
+export declare const boxScale: (state: CaptionState, t: number, style: CaptionStyle, fps: number) => number;
+/**
+ * Os estados partidos em trocos de escala constante, com as fronteiras na
+ * grelha de frames do projecto. Sem caixa, um troco por estado, intacto.
+ * Escalas iguais ao milesimo juntam-se: nao se distinguem, e cada troco e'
+ * mais uma imagem a rasterizar.
+ */
+export declare const captionFrames: (states: CaptionState[], style: CaptionStyle, fps: number) => CaptionFrame[];
 /**
  * Um pedaco do source que sobreviveu a` montagem: `[in, out]` no material
  * bruto, a comecar em `start` na timeline.
@@ -74,6 +126,48 @@ export interface SourceSpan {
 }
 /** Os pedacos de um asset que estao na timeline, por ordem de montagem. */
 export declare const sourceSpans: (project: Project, assetId: string) => SourceSpan[];
-export declare const remapWords: (words: CaptionWord[], spans: SourceSpan[], borda?: number) => CaptionWord[];
+/**
+ * Traz as palavras do tempo do source para o tempo da timeline.
+ *
+ * Uma palavra pertence ao pedaco que contem o seu CENTRO, e os tempos sao
+ * depois apertados a esse pedaco. Palavras cujo centro nao cai em pedaco
+ * nenhum desaparecem, que e' o que se quer.
+ *
+ * O centro em vez da sobreposicao: quem decide por sobreposicao tem de
+ * escolher uma tolerancia, e nenhuma serve. Curta, perde a primeira palavra a
+ * seguir a um corte, porque os tempos de um modelo de fala andam uns
+ * centesimos ao lado. Larga, deixa entrar palavras de takes deitadas fora que
+ * encostam a` fronteira pelo lado de fora: ficam com uma lasca de 50 ms e
+ * legendam um som que ninguem diz. O centro nao tem esse dilema - uma palavra
+ * dita antes do corte tem-no de um lado, uma dita depois tem-no do outro, e
+ * uns centesimos de desvio nao mudam o lado.
+ */
+export declare const remapWords: (words: CaptionWord[], spans: SourceSpan[]) => CaptionWord[];
 /** Todas as legendas do projecto, ja em tempo de timeline e por ordem. */
 export declare const timelineWords: (project: Project) => CaptionWord[];
+/** Um pedaco cujo audio proprio entra na mistura, e de onde vem. */
+export interface AudibleSpan {
+    assetId: string;
+    /** Onde comeca e acaba na timeline. */
+    start: number;
+    end: number;
+    /** Ponto do source a que `start` corresponde. */
+    in: number;
+}
+/**
+ * Os pedacos que se OUVEM, por ordem de timeline. Um clip sem som proprio
+ * (uma ilustracao por cima) nao entra: nada do que ele mostra e' dito.
+ */
+export declare const audibleSpans: (project: Project) => AudibleSpan[];
+/**
+ * O caminho inverso de `remapWords`: palavras em tempo de TIMELINE voltam ao
+ * tempo do source de onde vieram, agrupadas por asset.
+ *
+ * Serve para legendar a partir do montado. Transcrever o material bruto e
+ * depois esperar que as palavras caiam nos pedacos certos falha assim que uma
+ * frase e' dita duas vezes: o modelo funde as tentativas numa so' e os tempos
+ * que devolve nao dizem qual delas ficou. Transcrever o que se ouve nao tem
+ * esse problema, e isto devolve o resultado ao formato, que guarda as palavras
+ * em tempo do source para sobreviverem a` proxima edicao.
+ */
+export declare const sourceCaptions: (project: Project, words: CaptionWord[], language?: string) => CaptionSource[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omelhorsite/video-sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The engine of the omelhorsite video editor: the .omsv project model, placement math, effects, karaoke captions, compilation to ffmpeg arguments, and the omelhorsite cloud client. Isolate-safe: no node builtins, no environment access, no stdout.",
   "type": "module",
   "license": "UNLICENSED",