hyperframes 0.8.70 → 0.8.72

package/dist/fontLocalizeCli.js

@@ -54528,6 +54528,10 @@ uniform vec2 u_size;
 uniform float u_t;
 uniform float u_fps;
 uniform sampler2D u_src;
+uniform sampler2D u_src2;
+// 1 when the map ref named another element, 0 when the map is the layer
+// itself. Set by the runtime for every pass, from whether a ref resolved.
+uniform float u_hasSrc2;
 uniform float u_useH;
 uniform float u_maxH;
 uniform float u_useV;
@@ -54555,7 +54559,7 @@ float hfMapChannel(vec4 premultiplied, float selector) {
 }
 
 void main() {
-  vec4 mapTexel = texture(u_src, v_uv);
+  vec4 mapTexel = u_hasSrc2 > 0.5 ? texture(u_src2, v_uv) : texture(u_src, v_uv);
   float h = hfMapChannel(mapTexel, u_useH);
   float v = hfMapChannel(mapTexel, u_useV);
   vec2 d = vec2((h - 0.5) * 2.0 * u_maxH, (v - 0.5) * 2.0 * u_maxV);
@@ -54565,6 +54569,135 @@ void main() {
   }
 });
 
+// ../core/dist/vfx/lumaMatte.frag.js
+var lumaR2, lumaG2, lumaB2, LUMA_MATTE_FRAG;
+var init_lumaMatte_frag = __esm({
+  "../core/dist/vfx/lumaMatte.frag.js"() {
+    "use strict";
+    init_displacementMap_frag();
+    ({ lumaR: lumaR2, lumaG: lumaG2, lumaB: lumaB2 } = DISPLACEMENT_MAP_CONSTANTS);
+    LUMA_MATTE_FRAG = `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform vec2 u_size;
+uniform float u_t;
+uniform float u_fps;
+uniform sampler2D u_src;
+uniform sampler2D u_src2;
+uniform float u_mode;
+
+// The matte texel is premultiplied, so its rgb is already "over black" \u2014 the
+// composite After Effects reads a luma matte through.
+float hfCoverage(vec4 matte, float mode) {
+  if (mode < 1.5) return matte.a;
+  if (mode < 2.5) return 1.0 - matte.a;
+  float luma = dot(matte.rgb, vec3(${lumaR2}, ${lumaG2}, ${lumaB2}));
+  if (mode < 3.5) return luma;
+  return 1.0 - luma;
+}
+
+void main() {
+  vec4 src = texture(u_src, v_uv);
+  vec4 matte = texture(u_src2, v_uv);
+  fragColor = src * clamp(hfCoverage(matte, u_mode), 0.0, 1.0);
+}
+`;
+  }
+});
+
+// ../core/dist/vfx/noise.frag.js
+var NOISE_CONSTANTS, lcgMulA, lcgMulB, lcgAdd, highMask, lowMask, byteScale, NOISE_FRAG;
+var init_noise_frag = __esm({
+  "../core/dist/vfx/noise.frag.js"() {
+    "use strict";
+    NOISE_CONSTANTS = {
+      lcgMulA: 1103515245,
+      lcgMulB: 12996205,
+      lcgAdd: 12345,
+      highMask: 32640,
+      lowMask: 255,
+      byteScale: 32704
+    };
+    ({ lcgMulA, lcgMulB, lcgAdd, highMask, lowMask, byteScale } = NOISE_CONSTANTS);
+    NOISE_FRAG = `#version 300 es
+precision highp float;
+// NOT decoration: a fragment shader's default integer precision is mediump,
+// and a mediump uint is only guaranteed 16 bits (ESSL 3.00 \xA74.5.2). Every step
+// below \u2014 the Jenkins mix, both LCG rounds \u2014 is defined by 32-bit wraparound,
+// so without this the hash is a different function on any implementation that
+// honours the minimum. ANGLE and SwiftShader both use 32-bit ints, which is
+// exactly why no test on this machine would catch it.
+precision highp int;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform vec2 u_size;
+uniform float u_t;
+uniform float u_fps;
+uniform sampler2D u_src;
+uniform float u_amount;
+uniform float u_useColorNoise;
+uniform float u_clipping;
+
+// Bob Jenkins' 1997 integer mix, the six-round shift/xor/subtract sequence the
+// metallib runs verbatim. uint arithmetic wraps in GLSL ES 3.00, which is what
+// makes this bit-identical to the C original.
+uint hfJenkinsMix(uint a, uint b, uint c) {
+  a -= b; a -= c; a ^= (c >> 13u);
+  b -= c; b -= a; b ^= (a << 8u);
+  c -= a; c -= b; c ^= (b >> 13u);
+  a -= b; a -= c; a ^= (c >> 12u);
+  b -= c; b -= a; b ^= (a << 16u);
+  c -= a; c -= b; c ^= (b >> 5u);
+  a -= b; a -= c; a ^= (c >> 3u);
+  b -= c; b -= a; b ^= (a << 10u);
+  c -= a; c -= b; c ^= (b >> 15u);
+  return c;
+}
+
+// The hash's 15-bit output byte for one channel.
+float hfNoiseByte(uint a, uint y, uint seed) {
+  uint h = hfJenkinsMix(a, y, seed);
+  uint t2 = h * ${lcgMulA}u + ${lcgAdd}u;
+  uint t4 = t2 * ${lcgMulB}u + ${lcgAdd}u;
+  return float(((t4 >> 16u) & ${lowMask}u) ^ ((t2 >> 9u) & ${highMask}u));
+}
+
+void main() {
+  vec4 src = texture(u_src, v_uv);
+  vec2 px = floor(v_uv * u_size);
+  uint x = uint(max(px.x, 0.0));
+  // After Effects indexes rows from the top; v_uv is y-up.
+  uint y = uint(max(u_size.y - 1.0 - px.y, 0.0));
+  float frame = floor(u_t * u_fps + 0.5);
+  uint seed = uint(max(frame, 0.0)) & 0xFFFFu;
+
+  float amount = u_amount * 0.01;
+  vec3 nz;
+  if (u_useColorNoise > 0.5) {
+    uint a = x * 3u;
+    nz = vec3(hfNoiseByte(a, y, seed), hfNoiseByte(a + 1u, y, seed), hfNoiseByte(a + 2u, y, seed));
+  } else {
+    nz = vec3(hfNoiseByte(x, y, seed));
+  }
+  nz = amount * (nz / ${byteScale}.0 - 0.5);
+
+  vec4 out4 = vec4(src.rgb + nz, src.a);
+  // A valid premultiplied colour needs rgb <= a component-wise; noise on a
+  // near-transparent texel can push rgb above it, which our fixed 8-bit RGBA
+  // storage cannot carry safely the way AE's float pipeline can (see the doc
+  // comment above). This runs before, and independently of, u_clipping.
+  out4.rgb = min(out4.rgb, out4.a);
+  fragColor = u_clipping > 0.5 ? clamp(out4, 0.0, 1.0) : out4;
+}
+`;
+  }
+});
+
 // ../core/dist/vfx/waveWarp.frag.js
 var WAVE_WARP_CONSTANTS, tau, degreesPerTurn, WAVE_WARP_FRAG;
 var init_waveWarp_frag = __esm({
@@ -54690,6 +54823,8 @@ var init_vfx = __esm({
     "use strict";
     init_fractalNoise_frag();
     init_displacementMap_frag();
+    init_lumaMatte_frag();
+    init_noise_frag();
     init_waveWarp_frag();
     HF_VFX_ATTR = "data-vfx-chain";
     HF_VFX_CHAIN_VERSION = 1;
@@ -54914,6 +55049,14 @@ var init_vfx = __esm({
         capture: "self",
         frag: DISPLACEMENT_MAP_FRAG,
         params: [
+          {
+            kind: "ref",
+            key: "map",
+            label: "Displacement Map Layer",
+            // Optional: empty means the AE default the corpus uses, a map layer
+            // pointing at the layer itself, which `u_src` already holds.
+            optional: true
+          },
           {
             kind: "enum",
             key: "useH",
@@ -54975,6 +55118,67 @@ var init_vfx = __esm({
             default: true
           }
         ]
+      },
+      {
+        id: "luma-matte",
+        label: "Matte",
+        // Not one AE effect: the runtime form of every matte the exporter cannot
+        // express as CSS — unsupported track-matte sources, stencils and
+        // silhouettes, Set Matte. Which element is the source and which the matte
+        // is the exporter's choice of what to wrap and what to name in `matte`.
+        capture: "self",
+        frag: LUMA_MATTE_FRAG,
+        params: [
+          { kind: "ref", key: "matte", label: "Matte Layer" },
+          {
+            kind: "enum",
+            key: "mode",
+            label: "Matte Mode",
+            options: [
+              { value: 1, label: "Alpha" },
+              { value: 2, label: "Alpha Inverted" },
+              { value: 3, label: "Luma" },
+              { value: 4, label: "Luma Inverted" }
+            ],
+            default: 1
+          }
+        ]
+      },
+      {
+        id: "noise",
+        label: "Noise",
+        ae: "ADBE Noise",
+        // `self` on a content layer and `backdrop` on an adjustment layer are the
+        // same kernel reading the same `u_src`; the runtime resolves which from
+        // the DOM (a `data-vfx-for` wrapper), so the def declares only that a
+        // texture is needed.
+        capture: "self",
+        frag: NOISE_FRAG,
+        params: [
+          {
+            kind: "number",
+            key: "amount",
+            label: "Amount of Noise",
+            unit: "%",
+            min: 0,
+            max: 400,
+            step: 0.1,
+            default: 0,
+            animatable: true
+          },
+          {
+            kind: "bool",
+            key: "useColorNoise",
+            label: "Use Color Noise",
+            default: false
+          },
+          {
+            kind: "bool",
+            key: "clipping",
+            label: "Clip Result Values",
+            default: true
+          }
+        ]
       }
     ];
     BY_ID2 = new Map(HF_VFX.map((d) => [d.id, d]));
@@ -63342,9 +63546,18 @@ async function extractMediaMetadata(filePath) {
     const streamStart = Number.isFinite(parsedStreamStart) ? parsedStreamStart : 0;
     const parsedNbFrames = videoStream.nb_frames ? parseInt(videoStream.nb_frames, 10) : NaN;
     const frames = Number.isFinite(parsedNbFrames) && parsedNbFrames > 0 ? parsedNbFrames : void 0;
+    let effectiveStreamDuration;
+    if (streamDuration > 0) {
+      effectiveStreamDuration = streamDuration;
+    } else if (frames !== void 0 && fps > 0 && containerDuration > 0) {
+      const frameDerivedDuration = frames / fps;
+      effectiveStreamDuration = frameDerivedDuration < containerDuration * 0.9 ? frameDerivedDuration : containerDuration;
+    } else {
+      effectiveStreamDuration = containerDuration;
+    }
     return {
       durationSeconds: containerDuration,
-      videoStreamDurationSeconds: streamDuration > 0 ? streamDuration : containerDuration,
+      videoStreamDurationSeconds: effectiveStreamDuration,
       videoStreamStartSeconds: streamStart,
       width: videoStream.width || stillImage()?.width || 0,
       height: videoStream.height || stillImage()?.height || 0,
@@ -103737,8 +103950,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.70" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.70" : "0.0.0-dev";
+var VERSION = true ? "0.8.72" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.72" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {