various improvements

package.json

@@ -8,7 +8,7 @@
     "test:submitVideo": "node --loader ts-node/esm src/tests/submitVideo.mts",
     "test:checkStatus": "node --loader ts-node/esm src/tests/checkStatus.mts",
     "test:downloadFileToTmp": "node --loader ts-node/esm src/tests/downloadFileToTmp.mts",
-    "test:stuff": "node --loader ts-node/esm src/stuff.mts",
+    "test:stuff": "node --loader ts-node/esm src/utils/segmentImage.mts",
     "docker": "npm run docker:build && npm run docker:run",
     "docker:build": "docker build -t videochain-api .",
     "docker:run": "docker run -it -p 7860:7860 videochain-api"

src/index.mts

@@ -4,7 +4,7 @@ import path from "node:path"
 import { validate as uuidValidate } from "uuid"
 import express from "express"
 
-import { Video, VideoStatus, VideoAPIRequest } from "./types.mts"
+import { Video, VideoStatus, VideoAPIRequest, RenderRequest, RenderAPIResponse } from "./types.mts"
 import { parseVideoRequest } from "./utils/parseVideoRequest.mts"
 import { savePendingVideo } from "./scheduler/savePendingVideo.mts"
 import { getVideo } from "./scheduler/getVideo.mts"
@@ -38,9 +38,9 @@ let isRendering = false
 // a "fast track" pipeline
 app.post("/render", async (req, res) => {
 
-  const prompt = req.body.prompt as string
-  console.log(`/render: "${prompt}"`)
-  if (!prompt) {
+  const request = req.body as RenderRequest
+  console.log(req.body)
+  if (!request.prompt) {
     console.log("Invalid prompt")
     res.status(400)
     res.write(JSON.stringify({ url: "", error: "invalid prompt" }))
@@ -48,9 +48,15 @@ app.post("/render", async (req, res) => {
     return
   }
 
-  let result = { url: "", error: "" }
+  let result: RenderAPIResponse = {
+    videoUrl: "",
+    maskBase64: "",
+    error: "",
+    segments: []
+  }
+  
   try {
-    result = await renderScene(prompt)
+    result = await renderScene(request)
   } catch (err) {
     // console.log("failed to render scene!")
     result.error = `failed to render scene: ${err}`

src/production/generateAudioLegacy.mts

@@ -18,7 +18,9 @@ export const generateAudio = async (prompt: string, options?: {
   const instance = instances.shift()
   instances.push(instance)
 
-  const api = await client(instance)
+  const api = await client(instance, {
+        hf_token: `${process.env.VC_HF_API_TOKEN}` as any
+  })
 
   const rawResponse = await api.predict('/run', [		
     prompt, // string  in 'Prompt' Textbox component		

src/production/generateVideo.mts

@@ -3,8 +3,9 @@ import { client } from "@gradio/client"
 import { generateSeed } from "../utils/generateSeed.mts"
 
 const instances: string[] = [
-  `${process.env.VC_VIDEO_GENERATION_SPACE_API_URL || ""}`,
-  `${process.env.VC_RENDERING_ENGINE_SPACE_API_URL || ""}`,
+  `${process.env.VC_ZEROSCOPE_SPACE_API_URL_1 || ""}`,
+  // `${process.env.VC_ZEROSCOPE_SPACE_API_URL_2 || ""}`,
+  // `${process.env.VC_ZEROSCOPE_SPACE_API_URL_3 || ""}`,
 ].filter(instance => instance?.length > 0)
 
 export const generateVideo = async (prompt: string, options?: {
@@ -19,7 +20,9 @@ export const generateVideo = async (prompt: string, options?: {
   const instance = instances.shift()
   instances.push(instance)
 
-  const api = await client(instance)
+  const api = await client(instance, {
+    hf_token: `${process.env.VC_HF_API_TOKEN}` as any
+  })
 
   const rawResponse = await api.predict('/run', [		
     prompt, // string  in 'Prompt' Textbox component		

src/production/interpolateVideoLegacy.mts

@@ -18,7 +18,9 @@ export const interpolateVideo = async (fileName: string, steps: number, fps: num
   const instance = instances.shift()
   instances.push(instance)
 
-  const api = await client(instance)
+  const api = await client(instance, {
+    hf_token: `${process.env.VC_HF_API_TOKEN}` as any
+  })
 
   const video = await fs.readFile(inputFilePath)
 

src/production/renderScene.mts

@@ -1,5 +1,12 @@
+import { v4 as uuidv4 } from "uuid"
+
+import { ImageSegment, RenderAPIResponse, RenderRequest } from "../types.mts"
+import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
 import { generateSeed } from "../utils/generateSeed.mts"
+import { getValidNumber } from "../utils/getValidNumber.mts"
 import { generateVideo } from "./generateVideo.mts"
+import { getFirstVideoFrame } from "../utils/getFirstVideoFrame.mts"
+import { segmentImage } from "../utils/segmentImage.mts"
 
 const state = {
   isRendering: false
@@ -7,15 +14,22 @@ const state = {
 
 const seed = generateSeed()
 
-export async function renderScene(prompt: string) {
+export async function renderScene(scene: RenderRequest): Promise<RenderAPIResponse> {
   // console.log("renderScene")
+
+  // let's disable this for now
+  // this is only reliable if nothing crashes anyway..
+  /*
   if (state.isRendering) {
     // console.log("renderScene: isRendering")
     return {
-      url: "",
-      error: "already rendering"
+      videoUrl: "",
+      error: "already rendering",
+      maskBase64: "",
+      segments: [],
     }
   }
+  */
 
   // onsole.log("marking as isRendering")
   state.isRendering = true
@@ -24,11 +38,10 @@ export async function renderScene(prompt: string) {
   let error = ""
 
   try {
-    url = await generateVideo(prompt, {
-      seed: generateSeed(),
-      // seed,
-      nbFrames: 16,
-      nbSteps: 10,
+    url = await generateVideo(scene.prompt, {
+      seed: getValidNumber(scene.seed, 0, 4294967295, generateSeed()),
+      nbFrames: getValidNumber(scene.nbFrames, 8, 24, 16), // 2 seconds by default
+      nbSteps: getValidNumber(scene.nbSteps, 1, 50, 10), // use 10 by default to go fast, but not too sloppy
     })
     // console.log("successfull generation")
     error = ""
@@ -36,12 +49,56 @@ export async function renderScene(prompt: string) {
     error = `failed to render scene: ${err}`
   }
 
+
+
+  // TODO add segmentation here
+  const actionnables = Array.isArray(scene.actionnables) ? scene.actionnables : []
+
+  let mask = ""
+  let segments: ImageSegment[] = []
+
+  if (actionnables.length > 0) {
+    console.log("we have some actionnables:", actionnables)
+    if (scene.segmentation === "firstframe") {
+      console.log("going to grab the first frame")
+      const tmpVideoFilePath = await downloadFileToTmp(url, `${uuidv4()}`)
+      console.log("downloaded the first frame to ", tmpVideoFilePath)
+      const firstFrameFilePath = await getFirstVideoFrame(tmpVideoFilePath)
+      console.log("downloaded the first frame to ", firstFrameFilePath)
+      
+      if (!firstFrameFilePath) {
+        console.error("failed to get the image")
+        error = "failed to segment the image"
+      } else {
+        console.log("got the first frame! segmenting..")
+        const result = await segmentImage(firstFrameFilePath, actionnables)
+        mask = result.pngInBase64
+        segments = result.segments
+        // console.log("success!", {  segments })
+      }
+      /*
+      const jpgBase64 = await getFirstVideoFrame(tmpVideoFileName)
+      if (!jpgBase64) {
+        console.error("failed to get the image")
+        error = "failed to segment the image"
+      } else {
+        console.log(`got the first frame (${jpgBase64.length})`)
+
+        console.log("TODO: call segmentImage with the base64 image")
+        await segmentImage()
+      }
+      */
+    }
+  }
+
   // console.log("marking as not rendering anymore")
   state.isRendering = false
   error = ""
 
   return {
-    url,
-    error
-  }
+    videoUrl: url,
+    error,
+    maskBase64: mask,
+    segments
+  } as RenderAPIResponse
 }

src/types.mts

@@ -269,8 +269,46 @@ export type Video = VideoSequence & {
   shots: VideoShot[]
 }
 
+export interface RenderRequest {
+  prompt: string
+
+  // whether to use video segmentation
+  // disabled (default)
+  // firstframe: we only analyze the first frame
+  // allframes: we analyze all the frames
+  segmentation: 'disabled' | 'firstframe' | 'allframes'
+
+  // segmentation will only be executed if we have a non-empty list of actionnables
+  // actionnables are names of things like "chest", "key", "tree", "chair" etc
+  actionnables: string[]
+
+  // note: this is the number of frames for Zeroscope,
+  // which is currently configured to only output 3 seconds, so:
+  // nbFrames=8 -> 1 sec
+  // nbFrames=16 -> 2 sec
+  // nbFrames=24 -> 3 sec
+  nbFrames: number // min: 8, max: 24
+
+  nbSteps: number // min: 1, max: 50
+
+  seed: number
+}
 
 export interface ImageSegmentationRequest {
   image: string // in base64
   keywords: string[]
+}
+
+export interface ImageSegment {
+  id: number
+  box: number[]
+  label: string
+  score: number 
+}
+
+export interface RenderAPIResponse {
+  videoUrl: string 
+  error: string
+  maskBase64: string
+  segments: ImageSegment[]
 }

src/utils/downloadFileAsBase64.mts

@@ -0,0 +1,17 @@
+export const downloadImageAsBase64 = async (remoteUrl: string): Promise<string> => {
+  const controller = new AbortController()
+
+  // download the image
+  const response = await fetch(remoteUrl, {
+    signal: controller.signal
+  })
+
+  // get as Buffer
+  const arrayBuffer = await response.arrayBuffer()
+  const buffer = Buffer.from(arrayBuffer)
+
+  // convert it to base64
+  const base64 = buffer.toString('base64')
+
+  return base64
+};

src/utils/downloadFileToTmp.mts

@@ -24,4 +24,6 @@ export const downloadFileToTmp = async (remoteUrl: string, fileName: string) =>
     filePath,
     Buffer.from(arrayBuffer)
   )
+
+  return filePath
 }

src/utils/getFirstVideoFrame.mts

@@ -0,0 +1,22 @@
+import path from "node:path"
+
+import ffmpeg from "fluent-ffmpeg"
+import { v4 as uuidv4 } from "uuid"
+import tmpDir from "temp-dir"
+
+export async function getFirstVideoFrame(videoFilePath: string): Promise<string | void> {
+  const tmpFileName = `${uuidv4()}.jpg`
+
+  const tmpFilePath = path.resolve(tmpDir, tmpFileName)
+
+    return new Promise((resolve, reject) => {
+        ffmpeg(videoFilePath)
+            .outputOptions("-vframes 1")
+            .output(tmpFilePath)
+            .on("end", async () => {
+                resolve(tmpFilePath)
+            })
+            .on("error", reject)
+            .run()
+    })
+}

src/utils/getFirstVideoFrameAsBase64.mts

@@ -0,0 +1,33 @@
+import fs from "node:fs"
+import util from "node:util"
+import path from "node:path"
+
+import ffmpeg from "fluent-ffmpeg"
+import { v4 as uuidv4 } from "uuid"
+import tmpDir from "temp-dir"
+
+const unlinkAsync = util.promisify(fs.unlink)
+
+export async function getFirstVideoFrameAsBase64(videoPath: string): Promise<string | void> {
+  const tmpFileName = `${uuidv4()}.jpg`
+
+  const tmpFilePath = path.resolve(tmpDir, tmpFileName)
+
+    return new Promise((resolve, reject) => {
+        ffmpeg(videoPath)
+            .outputOptions("-vframes 1")
+            .output(tmpFilePath)
+            .on("end", async () => {
+                let base64;
+                try {
+                  base64 = await fs.promises.readFile(tmpFilePath, { encoding: "base64" });
+                  await unlinkAsync(tmpFilePath)
+                } catch(err) {
+                   return reject(err)
+                }
+                resolve(base64)
+            })
+            .on("error", reject)
+            .run()
+    })
+}

src/utils/segmentImage.mts

@@ -1,15 +1,97 @@
-import { client } from "@gradio/client"
-
-const response_0 = await fetch("https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png")
-const exampleImage = await response_0.blob()
-						
-const app = await client("https://jbilcke-hf-grounded-segment-anything.hf.space/")
-const result = await app.predict(0, [
-  exampleImage, 	// blob in 'Upload' Image component		
-  "Howdy!", // string  in 'Detection Prompt[To detect multiple objects, seperating each name with '.', like this: cat . dog . chair ]' Textbox component		
-  0, // number (numeric value between 0.0 and 1.0) in 'Box Threshold' Slider component		
-  0, // number (numeric value between 0.0 and 1.0) in 'Text Threshold' Slider component		
-  0, // number (numeric value between 0.0 and 1.0) in 'IOU Threshold' Slider component
-]) as any
-
-console.log(result.data)
+import puppeteer from "puppeteer"
+
+import { sleep } from "./sleep.mts"
+import { ImageSegment } from "../types.mts"
+import { downloadImageAsBase64 } from "./downloadFileAsBase64.mts"
+
+const instances: string[] = [
+  `${process.env.VC_SEGMENTATION_MODULE_SPACE_API_URL_1 || ""}`,
+  `${process.env.VC_SEGMENTATION_MODULE_SPACE_API_URL_2 || ""}`,
+]
+
+// TODO we should use an inference endpoint instead
+
+// note: on a large T4 (8 vCPU)
+// it takes about 30 seconds to compute
+export async function segmentImage(
+  inputImageFilePath: string,
+  actionnables: string[]
+): Promise<{
+  pngInBase64: string
+  segments: ImageSegment[]
+}> {
+
+  console.log(`segmenting image..`)
+
+  const instance = instances.shift()
+  instances.push(instance)
+
+  const browser = await puppeteer.launch({
+    headless: true,
+    protocolTimeout: 70000,
+  })
+
+  const page = await browser.newPage()
+  await page.goto(instance, { waitUntil: 'networkidle2' })
+  
+  await new Promise(r => setTimeout(r, 3000))
+
+  const fileField = await page.$('input[type="file"]')
+
+  // console.log(`uploading file..`)
+  await fileField.uploadFile(inputImageFilePath)
+
+  await sleep(500)
+
+  const firstTextarea = await page.$('textarea[data-testid="textbox"]')
+
+  const conceptsToDetect = actionnables.join(" . ")
+  await firstTextarea.type(conceptsToDetect)
+
+  // console.log('looking for the button to submit')
+  const submitButton = await page.$('button.lg')
+
+  await sleep(500)
+
+  // console.log('clicking on the button')
+  await submitButton.click()
+
+  await page.waitForSelector('img[data-testid="detailed-image"]', {
+    timeout: 70000, // need to be large enough in case someone else attemps to use our space
+  })
+
+  const maskUrl = await page.$$eval('img[data-testid="detailed-image"]', el => el.map(x => x.getAttribute("src"))[0])
+
+  let segments: ImageSegment[] = []
+  
+  try {
+    segments = JSON.parse(await page.$$eval('textarea', el => el.map(x => x.value)[1]))
+  } catch (err) {
+    console.log(`failed to parse JSON: ${err}`)
+    segments = []
+  }
+
+  // const tmpMaskFileName = `${uuidv4()}.png`
+  // await downloadFileToTmp(maskUrl, tmpMaskFileName)
+
+  const pngInBase64 = await downloadImageAsBase64(maskUrl)
+  return {
+    pngInBase64,
+    segments,
+  }
+}
+
+/*
+
+If you want to try:
+
+/ note: must be a jpg and not jpeg it seems
+// (probably a playwright bug)
+const results = await segmentImage("./barn.jpg", [
+  "roof",
+  "door",
+  "window"
+])
+
+console.log("results:", results)
+*/

src/utils/segmentImageApi.mts

@@ -0,0 +1,18 @@
+import { client } from "@gradio/client"
+
+
+const response_0 = await fetch("https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png")
+const exampleImage = await response_0.blob()
+						
+const app = await client("https://jbilcke-hf-image-segmentation.hf.space", {
+  hf_token: `${process.env.VC_HF_API_TOKEN}` as any
+})
+const result = await app.predict(0, [
+  exampleImage, // "data:image/jpeg;base64,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", 	// blob in 'Upload' Image component		
+  "Howdy!", // string  in 'Detection Prompt[To detect multiple objects, seperating each name with '.', like this: cat . dog . chair ]' Textbox component		
+  0.3, // number (numeric value between 0.0 and 1.0) in 'Box Threshold' Slider component		
+  0.25, // number (numeric value between 0.0 and 1.0) in 'Text Threshold' Slider component		
+  0.8, // number (numeric value between 0.0 and 1.0) in 'IOU Threshold' Slider component
+]) as any
+
+console.log(result)