WUP

server-plugins/apply.js

@@ -6,6 +6,7 @@ import { CaptionPlugin } from './generate-captions.js';
 import { CropPlugin } from './crop.js';
 import { FlattenPathsPlugin } from './flatten-paths.js';
 import { SpeedPlugin } from './speed.js';
+import { OverlayPlugin } from './overlay.js';
 
 const pluginRegistry = {
   'split-media-render': SplitRenderPlugin,
@@ -14,6 +15,7 @@ const pluginRegistry = {
   'crop': CropPlugin,
   'flatten-paths': FlattenPathsPlugin,
   'speed': SpeedPlugin,
+  'overlay': OverlayPlugin,
 };
 
 export async function applyPluginsPrerender(plugins, originalManuscript, originalManuscriptPath, jobId) {

server-plugins/crop.js

@@ -8,9 +8,6 @@ export class CropPlugin extends Plugin {
     super(name, options);
   }
 
-  mediaPathFlatten(mediaPath) {
-    return path.join('public', path.basename(mediaPath));
-  }
 
   async applyPrerender(originalManuscript, jobId) {
     const transcript = originalManuscript.transcript || [];

server-plugins/overlay.js

@@ -0,0 +1,98 @@
+import path from 'path';
+import fs from 'fs';
+import { Plugin } from './plugin.js';
+import { FFMpegUtils } from 'common-utils';
+
+export class OverlayPlugin extends Plugin {
+  constructor(name, options) {
+    super(name, options);
+  }
+
+  async applyPrerender(originalManuscript, jobId) {
+    const transcript = originalManuscript.transcript || [];
+    const overlayOpt = this.options.overlay;
+
+    if (!overlayOpt) {
+      this.log('No overlay option provided, skipping overlay plugin.');
+      return;
+    }
+
+    let overlayPath = null;
+    // if option looks like a file path
+    if (/\.(mp4|webm)$/i.test(overlayOpt)) {
+      const flattened = this.mediaPathFlatten(overlayOpt);
+      if (fs.existsSync(flattened)) overlayPath = flattened;
+      else if (fs.existsSync(overlayOpt)) overlayPath = overlayOpt;
+      else {
+        this.log(`Overlay path does not exist: ${overlayOpt}`);
+        return;
+      }
+    } else {
+      // look inside public/assets/effects for mp4 or webm
+      const effectsDir = path.join('public', 'assets', 'effects');
+      const mp4Path = path.join(effectsDir, `${overlayOpt}.mp4`);
+      const webmPath = path.join(effectsDir, `${overlayOpt}.webm`);
+      if (fs.existsSync(mp4Path)) overlayPath = mp4Path;
+      else if (fs.existsSync(webmPath)) overlayPath = webmPath;
+      else {
+        this.log(`No overlay found for '${overlayOpt}' in ${effectsDir}`);
+        return;
+      }
+    }
+
+    const overlayExt = path.extname(overlayPath).toLowerCase();
+    this.log(`Using overlay: ${overlayPath}`);
+
+    for (let item of transcript) {
+      if (!item.mediaAbsPaths || !item.mediaAbsPaths.length) continue;
+      for (let mediaObj of item.mediaAbsPaths) {
+        try {
+          let mediaPath = mediaObj.path;
+          if (!mediaPath || !fs.existsSync(mediaPath)) {
+            const flattenedPath = this.mediaPathFlatten(mediaPath);
+            if (fs.existsSync(flattenedPath)) {
+              mediaObj.path = flattenedPath;
+              mediaPath = flattenedPath;
+              this.log(`Using flattened media path: ${flattenedPath}`);
+            } else {
+              this.log(`Media path does not exist: ${mediaPath}. Tried flattened: ${flattenedPath}`);
+              continue;
+            }
+          }
+
+          const meta = await FFMpegUtils.getMediaMetadata(mediaPath);
+          if (!meta || !meta.video || !meta.video.width || !meta.video.height) {
+            this.log(`No video stream found for ${mediaPath}`);
+            continue;
+          }
+
+          const srcW = parseInt(meta.video.width);
+          const srcH = parseInt(meta.video.height);
+
+          const ext = path.extname(mediaPath);
+          const base = path.basename(mediaPath, ext);
+          const outPath = path.join(path.dirname(mediaPath), `${base}.overlay${ext}`);
+
+          let cmd = null;
+
+          if (overlayExt === '.mp4') {
+            // mp4 uses green-screen (chroma key) -> remove green then overlay
+            // chromakey params: color (green), similarity, blend
+            cmd = `ffmpeg -i "${mediaPath}" -i "${overlayPath}" -filter_complex "[1:v]scale=${srcW}:${srcH},chromakey=0x00FF00:0.3:0.1[ovr];[0:v][ovr]overlay=0:0:format=auto,format=yuv420p" -c:v libx264 -preset veryfast -crf 23 -c:a copy -shortest "${outPath}" -y`;
+          } else {
+            // webm assumed to have alpha (transparent video)
+            cmd = `ffmpeg -i "${mediaPath}" -i "${overlayPath}" -filter_complex "[1:v]scale=${srcW}:${srcH}[ovr];[0:v][ovr]overlay=0:0:format=auto,format=yuv420p" -c:v libx264 -preset veryfast -crf 23 -c:a copy -shortest "${outPath}" -y`;
+          }
+
+          this.log(`Applying overlay ${overlayPath} -> ${outPath} on ${mediaPath}`);
+          await FFMpegUtils.execute(cmd);
+
+          mediaObj._originalPath = mediaObj.path;
+          mediaObj.path = outPath;
+        } catch (err) {
+          this.log(`Error applying overlay to ${mediaObj?.path}: ${err}`);
+        }
+      }
+    }
+  }
+}

server-plugins/plugin.js

@@ -1,3 +1,4 @@
+import path from "path";
 
 export class Plugin {
   constructor(name, options) {
@@ -15,5 +16,9 @@ export class Plugin {
   log(...args) {
     console.log(`[Plugin: ${this.name}]`, ...args);
   }
+
+  mediaPathFlatten(mediaPath) {
+    return path.join('public', path.basename(mediaPath));
+  }
 }