bump

src/bug-in-bun/aitube_ffmpeg/analyze/extractFirstFrame.ts

@@ -0,0 +1,81 @@
+import { promises as fs, existsSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+import { v4 as uuidv4 } from 'uuid';
+import ffmpeg from 'fluent-ffmpeg';
+
+const validFormats = ['jpeg', 'png', 'webp'];
+
+/**
+ * Extract the first frame from a video
+ * 
+ * @param param0
+ * @returns 
+ */
+export async function extractFirstFrame({
+  inputVideo,
+  outputFormat = 'jpeg'
+}: {
+  inputVideo?: string
+  outputFormat?: "jpeg" | "png" | "webp"
+
+}) {
+  if (!inputVideo) {
+    throw new Error(`inputVideo must be a file path or a base64 data-uri`);
+  }
+
+  // Validate output format
+  if (!validFormats.includes(outputFormat)) {
+    throw new Error(`Invalid output format. Choose one of: ${validFormats.join(', ')}`);
+  }
+
+  // Handle base64 input
+  let videoFilePath = inputVideo;
+  if (inputVideo.startsWith('data:')) {
+    const matches = inputVideo.match(/^data:video\/(\w+);base64,(.*)$/);
+    if (!matches) {
+      throw new Error('Invalid base64 input provided.');
+    }
+    const extension = matches[1];
+    const base64Content = matches[2];
+    
+    videoFilePath = path.join(os.tmpdir(), `${uuidv4()}_inputVideo.${extension}`);
+    await fs.writeFile(videoFilePath, base64Content, 'base64');
+  } else if (!existsSync(videoFilePath)) {
+    throw new Error('Video file does not exist.');
+  }
+
+  // Create a temporary output file
+  const outputImagePath = path.join(os.tmpdir(), `${uuidv4()}.${outputFormat}`);
+
+  return new Promise((resolve, reject) => {
+    ffmpeg()
+      .input(videoFilePath)
+      .outputOptions([
+        '-vframes', '1',  // Extract only one frame
+        '-f', 'image2',   // Output format for the frame as image
+        '-an'             // Disable audio
+      ])
+      .output(outputImagePath)
+      .on('error', (err) => {
+        reject(new Error(`FFmpeg error: ${err.message}`));
+      })
+      .on('end', async () => {
+        try {
+          const imageBuffer = await fs.readFile(outputImagePath);
+          const imageBase64 = `data:image/${outputFormat};base64,${imageBuffer.toString('base64')}`;
+          resolve(imageBase64);
+        } catch (error) {
+          reject(new Error(`Error reading the image file: ${error}`));
+        } finally {
+          // Clean up temporary files
+          if (inputVideo.startsWith('data:')) {
+            await fs.unlink(videoFilePath);
+          }
+          await fs.unlink(outputImagePath);
+        }
+      })
+      .run();
+  });
+}

src/bug-in-bun/aitube_ffmpeg/overlay/htmlToBase64PngClient.ts

@@ -0,0 +1,30 @@
+import { spawn } from 'child_process';
+import path from 'node:path';
+const __dirname = path.resolve();
+
+export async function htmlToBase64PnClient(input) {
+  const jsonData = JSON.stringify(input)
+  const b64Data = Buffer.from(jsonData).toString('base64');
+  let stdoutData = '';
+
+  return await new Promise((resolve) => {
+    const proc = spawn('node', [
+      path.resolve(__dirname, 'htmlToBase64PngWorker.js'),
+      `--input-data${b64Data}`,
+      '--tagprocess'
+    ], { shell: false });
+
+    proc.stdout.on('data', (data) => {
+      stdoutData += data;
+    });
+
+    proc.stderr.on('data', (data) => {
+      console.error(`NodeERR: ${data}`);
+    });
+
+    proc.on('exit', function () {
+      proc.kill();
+      resolve(JSON.parse(stdoutData));
+    });
+  });
+}

src/bug-in-bun/aitube_ffmpeg/overlay/htmlToBase64PngWorker.js

@@ -0,0 +1,61 @@
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+import { v4 as uuidv4 } from "uuid"
+import puppeteer from "puppeteer"
+
+const inpDataB64 = process.argv.find((a) => a.startsWith('--input-data')).replace('--input-data', '')
+const input = JSON.parse(Buffer.from(inpDataB64, 'base64').toString())
+
+async function htmlToBase64PngWorker(input) {
+
+    let { outputImagePath, html, width, height } = input
+
+    // If no output path is provided, create a temporary file for output
+    if (!outputImagePath) {
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), uuidv4()))
+        outputImagePath = path.join(tempDir, `${uuidv4()}.png`)
+    }
+
+    const browser = await puppeteer.launch({
+        headless: true,
+        executablePath: os.type() === "Darwin"
+        ? '/opt/homebrew/bin/chromium'
+        : '/usr/bin/chromium-browser',
+        args: ['--no-sandbox', '--headless', '--disable-gpu', '--disable-dev-shm-usage']
+    });
+
+    const page = await browser.newPage()
+
+    page.setViewport({ width, height })
+
+    try {
+        await page.setContent(html)
+
+        const content = await page.$("body")
+
+        if (!content) { throw new Error (`Couldn't find body content`) }
+        
+        const buffer = await content.screenshot({
+            path: outputImagePath,
+            omitBackground: true,
+            captureBeyondViewport: false,
+            type: "png",
+        })
+
+        const outputData = {
+            filePath: outputImagePath,
+            buffer
+        }
+    
+        console.log(JSON.stringify(outputData))
+    } catch (err) {
+        console.error(err)
+    } finally {
+        await page.close()
+        await browser.close()
+    }
+};
+
+htmlToBase64PngWorker(input);