straight_to_video 0.0.7 → 0.0.9

data/app/assets/javascripts/straight-to-video.js

@@ -1,11 +1,11 @@
-// straight-to-video@0.0.7 vendored by the straight_to_video gem
+// straight-to-video@0.0.9 vendored by the straight_to_video gem
 // straight-to-video - https://github.com/searlsco/straight-to-video
 
 // ----- External imports -----
 import {
   Input, ALL_FORMATS, BlobSource, AudioBufferSink,
   Output, Mp4OutputFormat, BufferTarget,
-  AudioSampleSource, AudioSample, EncodedVideoPacketSource, EncodedPacket
+  AudioSampleSource, AudioSample, EncodedVideoPacketSource, EncodedPacket, EncodedPacketSink, VideoSampleSink
 } from 'mediabunny'
 
 // ----- Constants -----
@@ -33,6 +33,36 @@ async function probeVideo (file) {
   })
 }
 
+async function estimateSourceVideoFps (file) {
+  try {
+    const input = new Input({ source: new BlobSource(file), formats: ALL_FORMATS })
+    const tracks = await input.getTracks()
+    const video = tracks.find(t => typeof t.isVideoTrack === 'function' && t.isVideoTrack())
+    if (!video) return 0
+    const sink = new EncodedPacketSink(video)
+    const durations = []
+    for await (const packet of sink.packets(undefined, undefined, { metadataOnly: true })) {
+      const dur = Number(packet?.duration)
+      if (packet.timestamp >= 0 && Number.isFinite(dur) && dur > 0) durations.push(dur)
+      if (durations.length >= 120) break
+    }
+    if (!durations.length) return 0
+    durations.sort((a, b) => a - b)
+    const dur = durations[Math.floor(durations.length / 2)]
+    return Number.isFinite(dur) && dur > 0 ? (1 / dur) : 0
+  } catch (_) {
+    return 0
+  }
+}
+
+async function determineTargetFps (file, { width, height }) {
+  const maxFps = Math.max(width, height) <= 1920 ? 30 : 60
+  if (maxFps === 30) return 30
+
+  const fps = await estimateSourceVideoFps(file)
+  return fps >= 45 ? 60 : 30
+}
+
 // ----- Audio helpers -----
 async function decodeAudioPCM (file, { duration }) {
   const totalFrames = Math.max(1, Math.ceil(Number(duration) * TARGET_AUDIO_SR))
@@ -94,7 +124,7 @@ async function canOptimizeVideo (file) {
     const scale = Math.min(1, MAX_LONG_SIDE / Math.max(2, long))
     const targetWidth = Math.max(2, Math.round(width * scale))
     const targetHeight = Math.max(2, Math.round(height * scale))
-    const fps = Math.max(width, height) <= 1920 ? 30 : 60
+    const fps = await determineTargetFps(file, { width, height })
     const sup = await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps }).then(() => true).catch(() => false)
     if (!sup) return { ok: false, reason: 'unsupported-video-config', message: 'No supported encoder configuration for this resolution on this device.' }
 
@@ -111,7 +141,7 @@ async function canOptimizeVideo (file) {
       const hasEbml = buf.length >= 4 && buf[0] === 0x1A && buf[1] === 0x45 && buf[2] === 0xDF && buf[3] === 0xA3
       if (!(hasFtyp || hasEbml)) return { ok: false, reason: 'unknown-container', message: 'Unrecognized container; expected MP4/MOV or WebM.' }
     }
-    return { ok: true, reason: 'ok', message: 'ok' }
+    return { ok: true, reason: 'ok', message: 'ok', plan: { width: targetWidth, height: targetHeight, fps } }
   } catch (e) {
     return { ok: false, reason: 'probe-failed', message: String(e?.message || e) }
   }
@@ -120,13 +150,13 @@ async function canOptimizeVideo (file) {
 async function optimizeVideo (file, { onProgress } = {}) {
   if (!(file instanceof File)) return { changed: false, file }
   const type = file.type || ''
-  if (!/^video\//i.test(type)) return { changed: false, file }
+  if (type && !/^video\//i.test(type)) return { changed: false, file }
   if (typeof window === 'undefined' || !('VideoEncoder' in window)) return { changed: false, file }
   const feas = await canOptimizeVideo(file)
   if (!feas.ok) return { changed: false, file }
 
   const srcMeta = await probeVideo(file)
-  const newFile = await encodeVideo({ file, srcMeta: { w: srcMeta.width, h: srcMeta.height, duration: srcMeta.duration }, onProgress })
+  const newFile = await encodeVideo({ file, srcMeta: { w: srcMeta.width, h: srcMeta.height, duration: srcMeta.duration }, plan: feas.plan, onProgress })
   return { changed: true, file: newFile }
 }
 
@@ -140,6 +170,10 @@ async function selectVideoEncoderConfig ({ width, height, fps }) {
   return { codecId: 'avc', config: supA.config }
 }
 
+function shouldDecodeViaVideoElement () {
+  return (navigator?.vendor || '').includes('Apple')
+}
+
 async function waitForFrameReady (video, budgetMs) {
   if (typeof video.requestVideoFrameCallback !== 'function') return false
   return await new Promise((resolve) => {
@@ -163,16 +197,144 @@ async function seekOnce (video, time) {
   })
 }
 
-async function encodeVideo ({ file, srcMeta, onProgress }) {
+async function encodeFramesViaVideoElement ({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }) {
+  const url = URL.createObjectURL(file)
+  const v = document.createElement('video')
+  v.muted = true; v.preload = 'auto'; v.playsInline = true
+  await new Promise((resolve, reject) => {
+    const onLoaded = () => {
+      v.removeEventListener('loadedmetadata', onLoaded)
+      v.removeEventListener('error', onError)
+      resolve()
+    }
+    const onError = () => {
+      v.removeEventListener('loadedmetadata', onLoaded)
+      v.removeEventListener('error', onError)
+      reject(new Error('video load failed'))
+    }
+    v.addEventListener('loadedmetadata', onLoaded)
+    v.addEventListener('error', onError)
+    v.src = url
+    try {
+      v.load()
+    } catch (err) {
+      console.warn('straight-to-video: video.load() threw; continuing without explicit load()', err)
+    }
+  })
+
+  for (let i = 0; i < frames; i++) {
+    const t = i * step
+    const drawTime = Math.min(Math.max(0, t + (step * 0.5)), Math.max(0.000001, durationCfr - 0.000001))
+    await seekOnce(v, drawTime)
+    const budgetMs = Math.min(34, Math.max(17, Math.round(step * 1000)))
+    const presented = await waitForFrameReady(v, budgetMs)
+    if (!presented && i === 0) {
+      const nudge = Math.min(step * 0.25, 0.004)
+      const target = Math.min(drawTime + nudge, Math.max(0.000001, durationCfr - 0.000001))
+      await seekOnce(v, target)
+    }
+
+    ctx.drawImage(v, 0, 0, canvas.width, canvas.height)
+    const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
+    ve.encode(vf, { keyFrame: i === 0 })
+    vf.close()
+
+    if (typeof onProgress === 'function') {
+      try {
+        onProgress(Math.min(1, (i + 1) / frames))
+      } catch (err) {
+        console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+      }
+    }
+  }
+
+  URL.revokeObjectURL(url)
+}
+
+async function encodeFramesViaVideoSampleSink ({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }) {
+  const input = new Input({ source: new BlobSource(file), formats: ALL_FORMATS })
+  const tracks = await input.getTracks()
+  const video = tracks.find(t => typeof t.isVideoTrack === 'function' && t.isVideoTrack())
+  if (!video || !(await video.canDecode())) throw new Error('video track is not decodable by this browser')
+  const sink = new VideoSampleSink(video)
+  const draw = (sample) => {
+    if (ctx.resetTransform) ctx.resetTransform()
+    else ctx.setTransform(1, 0, 0, 1, 0, 0)
+    ctx.fillStyle = 'black'
+    ctx.fillRect(0, 0, canvas.width, canvas.height)
+    sample.drawWithFit(ctx, { fit: 'fill' })
+  }
+
+  let i = 0
+  let prev = null
+  let prevStart = 0
+
+  for await (const sample of sink.samples(0, durationCfr + step)) {
+    const ts = Math.max(0, Number(sample.timestamp))
+    if (!prev) { prev = sample; prevStart = ts; continue }
+
+    const end = Math.max(prevStart, ts)
+    const displayTime = (i + 0.5) * step
+    if (displayTime < end) {
+      draw(prev)
+      while (i < frames) {
+        const displayTime = (i + 0.5) * step
+        if (displayTime < prevStart || displayTime >= end) break
+        const t = i * step
+        const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
+        ve.encode(vf, { keyFrame: i === 0 })
+        vf.close()
+
+        if (typeof onProgress === 'function') {
+          try {
+            onProgress(Math.min(1, (i + 1) / frames))
+          } catch (err) {
+            console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+          }
+        }
+
+        i++
+      }
+    }
+
+    if (typeof prev.close === 'function') prev.close()
+    prev = sample
+    prevStart = ts
+    if (i >= frames) break
+  }
+
+  if (prev) {
+    draw(prev)
+    while (i < frames) {
+      const t = i * step
+      const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
+      ve.encode(vf, { keyFrame: i === 0 })
+      vf.close()
+
+      if (typeof onProgress === 'function') {
+        try {
+          onProgress(Math.min(1, (i + 1) / frames))
+        } catch (err) {
+          console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+        }
+      }
+
+      i++
+    }
+    if (typeof prev.close === 'function') prev.close()
+  }
+}
+
+async function encodeVideo ({ file, srcMeta, plan, onProgress }) {
   const w = srcMeta.w
   const h = srcMeta.h
   const durationCfr = Number(srcMeta.duration)
   const long = Math.max(w, h)
   const scale = Math.min(1, MAX_LONG_SIDE / Math.max(2, long))
-  const targetWidth = Math.max(2, Math.round(w * scale))
-  const targetHeight = Math.max(2, Math.round(h * scale))
+  const targetWidth = Math.max(2, Number(plan?.width) || Math.round(w * scale))
+  const targetHeight = Math.max(2, Number(plan?.height) || Math.round(h * scale))
 
-  const targetFps = Math.max(w, h) <= 1920 ? 30 : 60
+  const targetFps = Math.max(1, Number(plan?.fps) || await determineTargetFps(file, { width: w, height: h }))
   const step = 1 / Math.max(1, targetFps)
   const frames = Math.max(1, Math.floor(durationCfr / step))
 
@@ -216,62 +378,13 @@ async function encodeVideo ({ file, srcMeta, onProgress }) {
   })
   ve.configure(usedCfg)
 
-  const url = URL.createObjectURL(file)
-  const v = document.createElement('video')
-  v.muted = true; v.preload = 'auto'; v.playsInline = true
-  await new Promise((resolve, reject) => {
-    const onLoaded = () => {
-      v.removeEventListener('loadedmetadata', onLoaded)
-      v.removeEventListener('error', onError)
-      resolve()
-    }
-    const onError = () => {
-      v.removeEventListener('loadedmetadata', onLoaded)
-      v.removeEventListener('error', onError)
-      reject(new Error('video load failed'))
-    }
-    v.addEventListener('loadedmetadata', onLoaded)
-    v.addEventListener('error', onError)
-    v.src = url
-    try {
-      v.load()
-    } catch (err) {
-      console.warn('straight-to-video: video.load() threw; continuing without explicit load()', err)
-    }
-  })
   const canvas = document.createElement('canvas'); canvas.width = targetWidth; canvas.height = targetHeight
   const ctx = canvas.getContext('2d', { alpha: false })
 
-  for (let i = 0; i < frames; i++) {
-    const t = i * step
-    const targetTime = Math.min(Math.max(0, t), Math.max(0.000001, durationCfr - 0.000001))
-    const drawTime = i === 0
-      ? Math.min(Math.max(0, t + (step * 0.5)), Math.max(0.000001, durationCfr - 0.000001))
-      : targetTime
-    await seekOnce(v, drawTime)
-    const budgetMs = Math.min(34, Math.max(17, Math.round(step * 1000)))
-    const presented = await waitForFrameReady(v, budgetMs)
-    if (!presented && i === 0) {
-      const nudge = Math.min(step * 0.25, 0.004)
-      const target = Math.min(drawTime + nudge, Math.max(0.000001, durationCfr - 0.000001))
-      await seekOnce(v, target)
-    }
-
-    ctx.drawImage(v, 0, 0, canvas.width, canvas.height)
-    const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
-    ve.encode(vf, { keyFrame: i === 0 })
-    vf.close()
-
-    if (typeof onProgress === 'function') {
-      try {
-        onProgress(Math.min(1, (i + 1) / frames))
-      } catch (err) {
-        console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
-      }
-    }
-  }
+  await (shouldDecodeViaVideoElement()
+    ? encodeFramesViaVideoElement({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress })
+    : encodeFramesViaVideoSampleSink({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }))
   await ve.flush()
-  URL.revokeObjectURL(url)
 
   const muxCount = Math.min(frames, pendingPackets.length)
 

data/index.js

@@ -4,7 +4,7 @@
 import {
   Input, ALL_FORMATS, BlobSource, AudioBufferSink,
   Output, Mp4OutputFormat, BufferTarget,
-  AudioSampleSource, AudioSample, EncodedVideoPacketSource, EncodedPacket
+  AudioSampleSource, AudioSample, EncodedVideoPacketSource, EncodedPacket, EncodedPacketSink, VideoSampleSink
 } from 'mediabunny'
 
 // ----- Constants -----
@@ -32,6 +32,36 @@ async function probeVideo (file) {
   })
 }
 
+async function estimateSourceVideoFps (file) {
+  try {
+    const input = new Input({ source: new BlobSource(file), formats: ALL_FORMATS })
+    const tracks = await input.getTracks()
+    const video = tracks.find(t => typeof t.isVideoTrack === 'function' && t.isVideoTrack())
+    if (!video) return 0
+    const sink = new EncodedPacketSink(video)
+    const durations = []
+    for await (const packet of sink.packets(undefined, undefined, { metadataOnly: true })) {
+      const dur = Number(packet?.duration)
+      if (packet.timestamp >= 0 && Number.isFinite(dur) && dur > 0) durations.push(dur)
+      if (durations.length >= 120) break
+    }
+    if (!durations.length) return 0
+    durations.sort((a, b) => a - b)
+    const dur = durations[Math.floor(durations.length / 2)]
+    return Number.isFinite(dur) && dur > 0 ? (1 / dur) : 0
+  } catch (_) {
+    return 0
+  }
+}
+
+async function determineTargetFps (file, { width, height }) {
+  const maxFps = Math.max(width, height) <= 1920 ? 30 : 60
+  if (maxFps === 30) return 30
+
+  const fps = await estimateSourceVideoFps(file)
+  return fps >= 45 ? 60 : 30
+}
+
 // ----- Audio helpers -----
 async function decodeAudioPCM (file, { duration }) {
   const totalFrames = Math.max(1, Math.ceil(Number(duration) * TARGET_AUDIO_SR))
@@ -93,7 +123,7 @@ async function canOptimizeVideo (file) {
     const scale = Math.min(1, MAX_LONG_SIDE / Math.max(2, long))
     const targetWidth = Math.max(2, Math.round(width * scale))
     const targetHeight = Math.max(2, Math.round(height * scale))
-    const fps = Math.max(width, height) <= 1920 ? 30 : 60
+    const fps = await determineTargetFps(file, { width, height })
     const sup = await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps }).then(() => true).catch(() => false)
     if (!sup) return { ok: false, reason: 'unsupported-video-config', message: 'No supported encoder configuration for this resolution on this device.' }
 
@@ -110,7 +140,7 @@ async function canOptimizeVideo (file) {
       const hasEbml = buf.length >= 4 && buf[0] === 0x1A && buf[1] === 0x45 && buf[2] === 0xDF && buf[3] === 0xA3
       if (!(hasFtyp || hasEbml)) return { ok: false, reason: 'unknown-container', message: 'Unrecognized container; expected MP4/MOV or WebM.' }
     }
-    return { ok: true, reason: 'ok', message: 'ok' }
+    return { ok: true, reason: 'ok', message: 'ok', plan: { width: targetWidth, height: targetHeight, fps } }
   } catch (e) {
     return { ok: false, reason: 'probe-failed', message: String(e?.message || e) }
   }
@@ -119,13 +149,13 @@ async function canOptimizeVideo (file) {
 async function optimizeVideo (file, { onProgress } = {}) {
   if (!(file instanceof File)) return { changed: false, file }
   const type = file.type || ''
-  if (!/^video\//i.test(type)) return { changed: false, file }
+  if (type && !/^video\//i.test(type)) return { changed: false, file }
   if (typeof window === 'undefined' || !('VideoEncoder' in window)) return { changed: false, file }
   const feas = await canOptimizeVideo(file)
   if (!feas.ok) return { changed: false, file }
 
   const srcMeta = await probeVideo(file)
-  const newFile = await encodeVideo({ file, srcMeta: { w: srcMeta.width, h: srcMeta.height, duration: srcMeta.duration }, onProgress })
+  const newFile = await encodeVideo({ file, srcMeta: { w: srcMeta.width, h: srcMeta.height, duration: srcMeta.duration }, plan: feas.plan, onProgress })
   return { changed: true, file: newFile }
 }
 
@@ -139,6 +169,10 @@ async function selectVideoEncoderConfig ({ width, height, fps }) {
   return { codecId: 'avc', config: supA.config }
 }
 
+function shouldDecodeViaVideoElement () {
+  return (navigator?.vendor || '').includes('Apple')
+}
+
 async function waitForFrameReady (video, budgetMs) {
   if (typeof video.requestVideoFrameCallback !== 'function') return false
   return await new Promise((resolve) => {
@@ -162,16 +196,144 @@ async function seekOnce (video, time) {
   })
 }
 
-async function encodeVideo ({ file, srcMeta, onProgress }) {
+async function encodeFramesViaVideoElement ({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }) {
+  const url = URL.createObjectURL(file)
+  const v = document.createElement('video')
+  v.muted = true; v.preload = 'auto'; v.playsInline = true
+  await new Promise((resolve, reject) => {
+    const onLoaded = () => {
+      v.removeEventListener('loadedmetadata', onLoaded)
+      v.removeEventListener('error', onError)
+      resolve()
+    }
+    const onError = () => {
+      v.removeEventListener('loadedmetadata', onLoaded)
+      v.removeEventListener('error', onError)
+      reject(new Error('video load failed'))
+    }
+    v.addEventListener('loadedmetadata', onLoaded)
+    v.addEventListener('error', onError)
+    v.src = url
+    try {
+      v.load()
+    } catch (err) {
+      console.warn('straight-to-video: video.load() threw; continuing without explicit load()', err)
+    }
+  })
+
+  for (let i = 0; i < frames; i++) {
+    const t = i * step
+    const drawTime = Math.min(Math.max(0, t + (step * 0.5)), Math.max(0.000001, durationCfr - 0.000001))
+    await seekOnce(v, drawTime)
+    const budgetMs = Math.min(34, Math.max(17, Math.round(step * 1000)))
+    const presented = await waitForFrameReady(v, budgetMs)
+    if (!presented && i === 0) {
+      const nudge = Math.min(step * 0.25, 0.004)
+      const target = Math.min(drawTime + nudge, Math.max(0.000001, durationCfr - 0.000001))
+      await seekOnce(v, target)
+    }
+
+    ctx.drawImage(v, 0, 0, canvas.width, canvas.height)
+    const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
+    ve.encode(vf, { keyFrame: i === 0 })
+    vf.close()
+
+    if (typeof onProgress === 'function') {
+      try {
+        onProgress(Math.min(1, (i + 1) / frames))
+      } catch (err) {
+        console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+      }
+    }
+  }
+
+  URL.revokeObjectURL(url)
+}
+
+async function encodeFramesViaVideoSampleSink ({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }) {
+  const input = new Input({ source: new BlobSource(file), formats: ALL_FORMATS })
+  const tracks = await input.getTracks()
+  const video = tracks.find(t => typeof t.isVideoTrack === 'function' && t.isVideoTrack())
+  if (!video || !(await video.canDecode())) throw new Error('video track is not decodable by this browser')
+  const sink = new VideoSampleSink(video)
+  const draw = (sample) => {
+    if (ctx.resetTransform) ctx.resetTransform()
+    else ctx.setTransform(1, 0, 0, 1, 0, 0)
+    ctx.fillStyle = 'black'
+    ctx.fillRect(0, 0, canvas.width, canvas.height)
+    sample.drawWithFit(ctx, { fit: 'fill' })
+  }
+
+  let i = 0
+  let prev = null
+  let prevStart = 0
+
+  for await (const sample of sink.samples(0, durationCfr + step)) {
+    const ts = Math.max(0, Number(sample.timestamp))
+    if (!prev) { prev = sample; prevStart = ts; continue }
+
+    const end = Math.max(prevStart, ts)
+    const displayTime = (i + 0.5) * step
+    if (displayTime < end) {
+      draw(prev)
+      while (i < frames) {
+        const displayTime = (i + 0.5) * step
+        if (displayTime < prevStart || displayTime >= end) break
+        const t = i * step
+        const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
+        ve.encode(vf, { keyFrame: i === 0 })
+        vf.close()
+
+        if (typeof onProgress === 'function') {
+          try {
+            onProgress(Math.min(1, (i + 1) / frames))
+          } catch (err) {
+            console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+          }
+        }
+
+        i++
+      }
+    }
+
+    if (typeof prev.close === 'function') prev.close()
+    prev = sample
+    prevStart = ts
+    if (i >= frames) break
+  }
+
+  if (prev) {
+    draw(prev)
+    while (i < frames) {
+      const t = i * step
+      const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
+      ve.encode(vf, { keyFrame: i === 0 })
+      vf.close()
+
+      if (typeof onProgress === 'function') {
+        try {
+          onProgress(Math.min(1, (i + 1) / frames))
+        } catch (err) {
+          console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+        }
+      }
+
+      i++
+    }
+    if (typeof prev.close === 'function') prev.close()
+  }
+}
+
+async function encodeVideo ({ file, srcMeta, plan, onProgress }) {
   const w = srcMeta.w
   const h = srcMeta.h
   const durationCfr = Number(srcMeta.duration)
   const long = Math.max(w, h)
   const scale = Math.min(1, MAX_LONG_SIDE / Math.max(2, long))
-  const targetWidth = Math.max(2, Math.round(w * scale))
-  const targetHeight = Math.max(2, Math.round(h * scale))
+  const targetWidth = Math.max(2, Number(plan?.width) || Math.round(w * scale))
+  const targetHeight = Math.max(2, Number(plan?.height) || Math.round(h * scale))
 
-  const targetFps = Math.max(w, h) <= 1920 ? 30 : 60
+  const targetFps = Math.max(1, Number(plan?.fps) || await determineTargetFps(file, { width: w, height: h }))
   const step = 1 / Math.max(1, targetFps)
   const frames = Math.max(1, Math.floor(durationCfr / step))
 
@@ -215,62 +377,13 @@ async function encodeVideo ({ file, srcMeta, onProgress }) {
   })
   ve.configure(usedCfg)
 
-  const url = URL.createObjectURL(file)
-  const v = document.createElement('video')
-  v.muted = true; v.preload = 'auto'; v.playsInline = true
-  await new Promise((resolve, reject) => {
-    const onLoaded = () => {
-      v.removeEventListener('loadedmetadata', onLoaded)
-      v.removeEventListener('error', onError)
-      resolve()
-    }
-    const onError = () => {
-      v.removeEventListener('loadedmetadata', onLoaded)
-      v.removeEventListener('error', onError)
-      reject(new Error('video load failed'))
-    }
-    v.addEventListener('loadedmetadata', onLoaded)
-    v.addEventListener('error', onError)
-    v.src = url
-    try {
-      v.load()
-    } catch (err) {
-      console.warn('straight-to-video: video.load() threw; continuing without explicit load()', err)
-    }
-  })
   const canvas = document.createElement('canvas'); canvas.width = targetWidth; canvas.height = targetHeight
   const ctx = canvas.getContext('2d', { alpha: false })
 
-  for (let i = 0; i < frames; i++) {
-    const t = i * step
-    const targetTime = Math.min(Math.max(0, t), Math.max(0.000001, durationCfr - 0.000001))
-    const drawTime = i === 0
-      ? Math.min(Math.max(0, t + (step * 0.5)), Math.max(0.000001, durationCfr - 0.000001))
-      : targetTime
-    await seekOnce(v, drawTime)
-    const budgetMs = Math.min(34, Math.max(17, Math.round(step * 1000)))
-    const presented = await waitForFrameReady(v, budgetMs)
-    if (!presented && i === 0) {
-      const nudge = Math.min(step * 0.25, 0.004)
-      const target = Math.min(drawTime + nudge, Math.max(0.000001, durationCfr - 0.000001))
-      await seekOnce(v, target)
-    }
-
-    ctx.drawImage(v, 0, 0, canvas.width, canvas.height)
-    const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
-    ve.encode(vf, { keyFrame: i === 0 })
-    vf.close()
-
-    if (typeof onProgress === 'function') {
-      try {
-        onProgress(Math.min(1, (i + 1) / frames))
-      } catch (err) {
-        console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
-      }
-    }
-  }
+  await (shouldDecodeViaVideoElement()
+    ? encodeFramesViaVideoElement({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress })
+    : encodeFramesViaVideoSampleSink({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }))
   await ve.flush()
-  URL.revokeObjectURL(url)
 
   const muxCount = Math.min(frames, pendingPackets.length)
 

data/lib/straight_to_video/version.rb

@@ -1,3 +1,3 @@
 module StraightToVideo
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 end