straight_to_video 0.0.11 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4783067cfef03451a12e35404133f518b5e73fedd306c99e47d02791022300b1
-  data.tar.gz: 8cabcf1177d87439fd41ac63be9dc88fddecca8123f7efc70c5a849061096340
+  metadata.gz: db199c55c9da4fd2927332a51b0bacc98c8ee0c4422218f9bdbbf2f280dd5648
+  data.tar.gz: 67c67d5170d3d7be451f2d050d2f6b2063f225f1c7dbbd8b3fc82462ddccee2f
 SHA512:
-  metadata.gz: 26e1e12b9fb1cfcfcece442b49fcde59b5e19b429f70914286b59bc9efa8423761f98fccd0992807bdecbf5b50f97584e6e83ccaefd88a761d5cef2c52e8e4a8
-  data.tar.gz: 1980a0f482a87965ef98d3287fc2ccdfe51edd3d9127d3f0903c5d0a0336bc9b19d81785a012fb8dfddcf10b444d462af666f28d02c8e11eacafb8b4484da1d9
+  metadata.gz: 7a85c866bf129896f1c49d5ae9e323f7e7e13cd52f8e92c8aa64d80bc716c1f5545f7f9376f3c4c9ca5a3fcfa188cd247f04cc90650c0b1a66f09eb23dd7cf22
+  data.tar.gz: ec227f671fd6e10196b91cbd9ccc46abed79a317ea0d822ebccf5aa36488098d2a52efe7770081e225c95d4c1e2c91b225642632e3c8e837b616121ab75fe135

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.0.13
+
+* Fast-start already-compliant MP4 and MOV uploads without re-encoding their media packets.
+* Preserve compatible 44.1 kHz and 48 kHz AAC audio on the compliant-media path.
+
+## 0.0.12
+
+* Bound the WebCodecs encoder queue so long videos cannot exhaust WebKit memory.
+* Keep browser encoding at or below the source video's bitrate.
+
 ## 0.0.11
 
 * Work around WebKit labeling the requested first HEVC keyframe as a delta packet.

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

@@ -1,11 +1,12 @@
-// straight-to-video@0.0.11 vendored by the straight_to_video gem
+// straight-to-video@0.0.13 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, EncodedPacketSink, VideoSampleSink
+  AudioSampleSource, AudioSample, EncodedVideoPacketSource, EncodedPacket, EncodedPacketSink, VideoSampleSink,
+  EncodedAudioPacketSource
 } from 'mediabunny'
 
 // ----- Constants -----
@@ -14,6 +15,7 @@ const TARGET_VIDEO_BITRATE = 12_000_000
 const TARGET_AUDIO_BITRATE = 96_000
 const TARGET_AUDIO_SR = 48_000
 const TARGET_AUDIO_CHANNELS = 2
+const MAX_VIDEO_ENCODER_QUEUE_SIZE = 4
 
 // ----- Video metadata probe -----
 async function probeVideo (file) {
@@ -34,34 +36,55 @@ async function probeVideo (file) {
   })
 }
 
-async function estimateSourceVideoFps (file) {
+async function estimateSourceVideoStats (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
+    if (!video) return { fps: 0, bitrate: 0, codec: null, rotation: 0 }
     const sink = new EncodedPacketSink(video)
     const durations = []
+    let firstTimestamp = Infinity
+    let lastTimestamp = -Infinity
+    let totalBytes = 0
     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)
+      const duration = Number(packet?.duration)
+      if (packet.timestamp >= 0 && Number.isFinite(duration) && duration > 0) {
+        durations.push(duration)
+        firstTimestamp = Math.min(firstTimestamp, packet.timestamp)
+        lastTimestamp = Math.max(lastTimestamp, packet.timestamp + duration)
+        totalBytes += packet.byteLength
+      }
       if (durations.length >= 120) break
     }
-    if (!durations.length) return 0
+    if (!durations.length) return { fps: 0, bitrate: 0, codec: video.codec, rotation: video.rotation }
     durations.sort((a, b) => a - b)
-    const dur = durations[Math.floor(durations.length / 2)]
-    return Number.isFinite(dur) && dur > 0 ? (1 / dur) : 0
+    const duration = durations[Math.floor(durations.length / 2)]
+    const sampledDuration = lastTimestamp - firstTimestamp
+    return {
+      fps: Number.isFinite(duration) && duration > 0 ? (1 / duration) : 0,
+      bitrate: sampledDuration > 0 ? (totalBytes * 8 / sampledDuration) : 0,
+      codec: video.codec,
+      rotation: video.rotation
+    }
   } catch (_) {
-    return 0
+    return { fps: 0, bitrate: 0, codec: null, rotation: 0 }
   }
 }
 
-async function determineTargetFps (file, { width, height }) {
+async function determineEncodingPlan (file, { width, height, duration }) {
   const maxFps = Math.max(width, height) <= 1920 ? 30 : 60
-  if (maxFps === 30) return 30
-
-  const fps = await estimateSourceVideoFps(file)
-  return fps >= 45 ? 60 : 30
+  const source = await estimateSourceVideoStats(file)
+  const copyVideo = ['avc', 'hevc'].includes(source.codec) &&
+    source.rotation === 0 &&
+    Math.max(width, height) <= MAX_LONG_SIDE &&
+    source.fps >= 23 && source.fps <= 60.1 &&
+    Number(duration) > 0 && (file.size * 8 / Number(duration)) <= TARGET_VIDEO_BITRATE
+  return {
+    fps: copyVideo ? source.fps : (maxFps === 30 ? 30 : (source.fps >= 45 ? 60 : 30)),
+    bitrate: source.bitrate > 0 ? Math.min(TARGET_VIDEO_BITRATE, Math.round(source.bitrate)) : TARGET_VIDEO_BITRATE,
+    copyVideo
+  }
 }
 
 // ----- Audio helpers -----
@@ -125,8 +148,8 @@ 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 = await determineTargetFps(file, { width, height })
-    const sup = await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps }).then(() => true).catch(() => false)
+    const plan = await determineEncodingPlan(file, { width, height, duration })
+    const sup = plan.copyVideo || await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, ...plan }).then(() => true).catch(() => false)
     if (!sup) return { ok: false, reason: 'unsupported-video-config', message: 'No supported encoder configuration for this resolution on this device.' }
 
     // Header sniffing when file.type is empty/incorrect
@@ -142,7 +165,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', plan: { width: targetWidth, height: targetHeight, fps } }
+    return { ok: true, reason: 'ok', message: 'ok', plan: { width: targetWidth, height: targetHeight, ...plan } }
   } catch (e) {
     return { ok: false, reason: 'probe-failed', message: String(e?.message || e) }
   }
@@ -156,17 +179,25 @@ async function optimizeVideo (file, { onProgress } = {}) {
   const feas = await canOptimizeVideo(file)
   if (!feas.ok) return { changed: false, file }
 
+  if (feas.plan.copyVideo) {
+    const fastStarted = await fastStartMp4(file)
+    if (fastStarted) {
+      if (typeof onProgress === 'function') onProgress(1)
+      return { changed: true, file: fastStarted }
+    }
+  }
+
   const srcMeta = await probeVideo(file)
   const newFile = await encodeVideo({ file, srcMeta: { w: srcMeta.width, h: srcMeta.height, duration: srcMeta.duration }, plan: feas.plan, onProgress })
   return { changed: true, file: newFile }
 }
 
-async function selectVideoEncoderConfig ({ width, height, fps }) {
-  const hevc = { codec: 'hvc1.1.4.L123.B0', width, height, framerate: fps, bitrate: TARGET_VIDEO_BITRATE, hardwareAcceleration: 'prefer-hardware', hevc: { format: 'hevc' } }
+async function selectVideoEncoderConfig ({ width, height, fps, bitrate = TARGET_VIDEO_BITRATE }) {
+  const hevc = { codec: 'hvc1.1.4.L123.B0', width, height, framerate: fps, bitrate, hardwareAcceleration: 'prefer-hardware', hevc: { format: 'hevc' } }
   const supH = await VideoEncoder.isConfigSupported(hevc).catch(() => ({ supported: false }))
   if (supH.supported) return { codecId: 'hevc', config: supH.config }
 
-  const avc = { codec: 'avc1.64002A', width, height, framerate: fps, bitrate: TARGET_VIDEO_BITRATE, hardwareAcceleration: 'prefer-hardware', avc: { format: 'avc' } }
+  const avc = { codec: 'avc1.64002A', width, height, framerate: fps, bitrate, hardwareAcceleration: 'prefer-hardware', avc: { format: 'avc' } }
   const supA = await VideoEncoder.isConfigSupported(avc)
   return { codecId: 'avc', config: supA.config }
 }
@@ -175,6 +206,12 @@ function shouldDecodeViaVideoElement () {
   return (navigator?.vendor || '').includes('Apple')
 }
 
+async function applyVideoEncoderBackpressure (encoder) {
+  while (encoder.encodeQueueSize > MAX_VIDEO_ENCODER_QUEUE_SIZE) {
+    await new Promise(resolve => setTimeout(resolve, 0))
+  }
+}
+
 async function waitForFrameReady (video, budgetMs) {
   if (typeof video.requestVideoFrameCallback !== 'function') return false
   return await new Promise((resolve) => {
@@ -239,6 +276,7 @@ async function encodeFramesViaVideoElement ({ file, durationCfr, step, frames, c
     const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
     ve.encode(vf, { keyFrame: i === 0 })
     vf.close()
+    await applyVideoEncoderBackpressure(ve)
 
     if (typeof onProgress === 'function') {
       try {
@@ -285,6 +323,7 @@ async function encodeFramesViaVideoSampleSink ({ file, durationCfr, step, frames
         const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
         ve.encode(vf, { keyFrame: i === 0 })
         vf.close()
+        await applyVideoEncoderBackpressure(ve)
 
         if (typeof onProgress === 'function') {
           try {
@@ -311,6 +350,7 @@ async function encodeFramesViaVideoSampleSink ({ file, durationCfr, step, frames
       const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
       ve.encode(vf, { keyFrame: i === 0 })
       vf.close()
+      await applyVideoEncoderBackpressure(ve)
 
       if (typeof onProgress === 'function') {
         try {
@@ -373,6 +413,35 @@ function _scanBoxes (u8, start, end) {
   return out
 }
 
+async function fastStartMp4 (file) {
+  const u8 = new Uint8Array(await file.arrayBuffer())
+  const boxes = _scanBoxes(u8, 0, u8.byteLength)
+  const ftyp = boxes.find(b => b.type === 'ftyp')
+  const mdat = boxes.find(b => b.type === 'mdat')
+  const moov = boxes.find(b => b.type === 'moov')
+  if (!ftyp || !mdat || !moov || ftyp.offset !== 0 || moov.offset < mdat.offset) return null
+
+  const relocatedMoov = u8.slice(moov.offset, moov.offset + moov.size)
+  const dv = new DataView(relocatedMoov.buffer, relocatedMoov.byteOffset, relocatedMoov.byteLength)
+  for (let i = 0; i < relocatedMoov.byteLength - 16; i++) {
+    if (relocatedMoov[i + 4] !== 0x73 || relocatedMoov[i + 5] !== 0x74 || relocatedMoov[i + 6] !== 0x63 || relocatedMoov[i + 7] !== 0x6f) continue
+    const count = dv.getUint32(i + 12)
+    if (i + 16 + count * 4 > relocatedMoov.byteLength) return null
+    for (let j = 0; j < count; j++) {
+      const offset = i + 16 + j * 4
+      dv.setUint32(offset, dv.getUint32(offset) + moov.size)
+    }
+  }
+
+  const payload = _concat(
+    u8.slice(ftyp.offset, ftyp.offset + ftyp.size),
+    relocatedMoov,
+    ...boxes.filter(box => box !== ftyp && box !== moov).map(box => u8.slice(box.offset, box.offset + box.size))
+  )
+  const dot = file.name.lastIndexOf('.')
+  return new File([payload], `${file.name.substring(0, dot)}-optimized.mp4`, { type: 'video/mp4', lastModified: Date.now() })
+}
+
 function _esdTag (tag, payload) {
   return _concat(new Uint8Array([tag, 0x80, 0x80, 0x80, payload.byteLength]), payload)
 }
@@ -628,76 +697,122 @@ async function encodeVideo ({ file, srcMeta, plan, onProgress }) {
   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(1, Number(plan?.fps) || await determineTargetFps(file, { width: w, height: h }))
+  const fallbackPlan = plan || await determineEncodingPlan(file, { width: w, height: h, duration: durationCfr })
+  const targetFps = Math.max(1, Number(fallbackPlan.fps))
   const step = 1 / Math.max(1, targetFps)
   const frames = Math.max(1, Math.floor(durationCfr / step))
 
   const output = new Output({ format: new Mp4OutputFormat({ fastStart: 'in-memory' }), target: new BufferTarget() })
-  const { codecId, config: usedCfg } = await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps: targetFps })
-  const videoTrack = new EncodedVideoPacketSource(codecId)
-  output.addVideoTrack(videoTrack, { frameRate: targetFps })
-
-  const _warn = console.warn
-  console.warn = (...args) => {
-    const m = args && args[0]
-    if (typeof m === 'string' && m.includes('Unsupported audio codec') && m.includes('apac')) return
-    _warn.apply(console, args)
-  }
-  const audioBuffer = await decodeAudioPCM(file, { duration: durationCfr })
-  console.warn = _warn
-
-  const audioSource = new AudioSampleSource({
-    codec: 'aac',
-    bitrate: TARGET_AUDIO_BITRATE,
-    bitrateMode: 'constant',
-    numberOfChannels: TARGET_AUDIO_CHANNELS,
-    sampleRate: TARGET_AUDIO_SR,
-    onEncodedPacket: (_packet, meta) => {
-      const aot = 2; const idx = 3; const b0 = (aot << 3) | (idx >> 1); const b1 = ((idx & 1) << 7) | (TARGET_AUDIO_CHANNELS << 3)
-      meta.decoderConfig = { codec: 'mp4a.40.2', numberOfChannels: TARGET_AUDIO_CHANNELS, sampleRate: TARGET_AUDIO_SR, description: new Uint8Array([b0, b1]) }
+  const passthroughInput = fallbackPlan.copyVideo ? new Input({ source: new BlobSource(file), formats: ALL_FORMATS }) : null
+  const passthroughTracks = passthroughInput ? await passthroughInput.getTracks() : []
+  const passthroughTrack = passthroughTracks.find(t => typeof t.isVideoTrack === 'function' && t.isVideoTrack())
+  const passthroughAudioTrack = passthroughTrack && passthroughTracks.find(t =>
+    typeof t.isAudioTrack === 'function' && t.isAudioTrack() &&
+    t.codec === 'aac' && [1, 2].includes(t.numberOfChannels) && [44_100, 48_000].includes(t.sampleRate)
+  )
+  const encoder = passthroughTrack ? null : await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps: targetFps, bitrate: fallbackPlan.bitrate })
+  const videoTrack = new EncodedVideoPacketSource(passthroughTrack?.codec || encoder.codecId)
+  output.addVideoTrack(videoTrack, passthroughTrack ? { rotation: passthroughTrack.rotation } : { frameRate: targetFps })
+
+  let audioBuffer = null
+  if (!passthroughAudioTrack) {
+    const _warn = console.warn
+    console.warn = (...args) => {
+      const m = args && args[0]
+      if (typeof m === 'string' && m.includes('Unsupported audio codec') && m.includes('apac')) return
+      _warn.apply(console, args)
     }
-  })
+    audioBuffer = await decodeAudioPCM(file, { duration: durationCfr })
+    console.warn = _warn
+  }
+
+  const audioSource = passthroughAudioTrack
+    ? new EncodedAudioPacketSource('aac')
+    : new AudioSampleSource({
+        codec: 'aac',
+        bitrate: TARGET_AUDIO_BITRATE,
+        bitrateMode: 'constant',
+        numberOfChannels: TARGET_AUDIO_CHANNELS,
+        sampleRate: TARGET_AUDIO_SR,
+        onEncodedPacket: (_packet, meta) => {
+          const aot = 2; const idx = 3; const b0 = (aot << 3) | (idx >> 1); const b1 = ((idx & 1) << 7) | (TARGET_AUDIO_CHANNELS << 3)
+          meta.decoderConfig = { codec: 'mp4a.40.2', numberOfChannels: TARGET_AUDIO_CHANNELS, sampleRate: TARGET_AUDIO_SR, description: new Uint8Array([b0, b1]) }
+        }
+      })
   output.addAudioTrack(audioSource)
 
   await output.start()
+  const passthroughAudioPromise = passthroughAudioTrack && (async () => {
+    const sink = new EncodedPacketSink(passthroughAudioTrack)
+    const decoderConfig = await passthroughAudioTrack.getDecoderConfig()
+    const firstTimestamp = await passthroughAudioTrack.getFirstTimestamp()
+    for await (const packet of sink.packets()) {
+      await audioSource.add(packet.clone({ timestamp: Math.max(0, packet.timestamp - firstTimestamp) }), { decoderConfig: decoderConfig || undefined })
+    }
+    audioSource.close()
+  })()
 
-  let codecDesc = null
-  const pendingPackets = []
-  const ve = new VideoEncoder({
-    output: (chunk, meta) => {
-      if (!codecDesc && meta?.decoderConfig?.description) codecDesc = meta.decoderConfig.description
-      pendingPackets.push({ chunk })
-    },
-    error: () => {}
-  })
-  ve.configure(usedCfg)
-
-  const canvas = document.createElement('canvas'); canvas.width = targetWidth; canvas.height = targetHeight
-  const ctx = canvas.getContext('2d', { alpha: false })
-
-  await (shouldDecodeViaVideoElement()
-    ? encodeFramesViaVideoElement({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress })
-    : encodeFramesViaVideoSampleSink({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }))
-  await ve.flush()
-
-  const muxCount = Math.min(frames, pendingPackets.length)
-
-  for (let i = 0; i < muxCount; i++) {
-    const { chunk } = pendingPackets[i]
-    const data = new Uint8Array(chunk.byteLength); chunk.copyTo(data)
-    const ts = i * step; const dur = step
-    const pkt = new EncodedPacket(data, i === 0 || chunk.type === 'key' ? 'key' : 'delta', ts, dur)
-    await videoTrack.add(pkt, { decoderConfig: { codec: usedCfg.codec, codedWidth: targetWidth, codedHeight: targetHeight, description: codecDesc } })
+  let videoDuration = durationCfr
+  if (passthroughTrack) {
+    const sink = new EncodedPacketSink(passthroughTrack)
+    const decoderConfig = await passthroughTrack.getDecoderConfig()
+    const firstTimestamp = await passthroughTrack.getFirstTimestamp()
+    videoDuration = 0
+    for await (const packet of sink.packets(undefined, undefined, { verifyKeyPackets: true })) {
+      const normalizedPacket = packet.clone({ timestamp: Math.max(0, packet.timestamp - firstTimestamp) })
+      await videoTrack.add(normalizedPacket, { decoderConfig: decoderConfig || undefined })
+      videoDuration = Math.max(videoDuration, normalizedPacket.timestamp + normalizedPacket.duration)
+      if (typeof onProgress === 'function') {
+        try {
+          onProgress(Math.min(1, videoDuration / durationCfr))
+        } catch (err) {
+          console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+        }
+      }
+    }
+    videoTrack.close()
+  } else {
+    let codecDesc = null
+    const pendingPackets = []
+    const ve = new VideoEncoder({
+      output: (chunk, meta) => {
+        if (!codecDesc && meta?.decoderConfig?.description) codecDesc = meta.decoderConfig.description
+        pendingPackets.push({ chunk })
+      },
+      error: () => {}
+    })
+    ve.configure(encoder.config)
+
+    const canvas = document.createElement('canvas'); canvas.width = targetWidth; canvas.height = targetHeight
+    const ctx = canvas.getContext('2d', { alpha: false })
+
+    await (shouldDecodeViaVideoElement()
+      ? encodeFramesViaVideoElement({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress })
+      : encodeFramesViaVideoSampleSink({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }))
+    await ve.flush()
+
+    const muxCount = Math.min(frames, pendingPackets.length)
+    videoDuration = muxCount * step
+    for (let i = 0; i < muxCount; i++) {
+      const { chunk } = pendingPackets[i]
+      const data = new Uint8Array(chunk.byteLength); chunk.copyTo(data)
+      const ts = i * step; const dur = step
+      const pkt = new EncodedPacket(data, i === 0 || chunk.type === 'key' ? 'key' : 'delta', ts, dur)
+      await videoTrack.add(pkt, { decoderConfig: { codec: encoder.config.codec, codedWidth: targetWidth, codedHeight: targetHeight, description: codecDesc } })
+    }
   }
 
-  const samplesPerVideoFrame = TARGET_AUDIO_SR / targetFps
-  const totalVideoSamples = muxCount * samplesPerVideoFrame
-  const targetSamples = Math.max(1024, Math.floor(totalVideoSamples / 1024) * 1024 - 2048)
-  const audioExact = await renderStereo48kExact(audioBuffer, targetSamples)
-  const interleaved = interleaveStereoF32(audioExact)
-  const sample = new AudioSample({ format: 'f32', sampleRate: TARGET_AUDIO_SR, numberOfChannels: TARGET_AUDIO_CHANNELS, timestamp: 0, data: interleaved })
-  await audioSource.add(sample)
-  audioSource.close()
+  if (passthroughAudioPromise) {
+    await passthroughAudioPromise
+  } else {
+    const totalVideoSamples = videoDuration * TARGET_AUDIO_SR
+    const targetSamples = Math.max(1024, Math.floor(totalVideoSamples / 1024) * 1024 - 2048)
+    const audioExact = await renderStereo48kExact(audioBuffer, targetSamples)
+    const interleaved = interleaveStereoF32(audioExact)
+    const sample = new AudioSample({ format: 'f32', sampleRate: TARGET_AUDIO_SR, numberOfChannels: TARGET_AUDIO_CHANNELS, timestamp: 0, data: interleaved })
+    await audioSource.add(sample)
+    audioSource.close()
+  }
   await output.finalize()
   const normalized = await normalizeMp4Container(output.target.buffer)
   const payload = new Uint8Array(normalized)

data/index.js

@@ -4,7 +4,8 @@
 import {
   Input, ALL_FORMATS, BlobSource, AudioBufferSink,
   Output, Mp4OutputFormat, BufferTarget,
-  AudioSampleSource, AudioSample, EncodedVideoPacketSource, EncodedPacket, EncodedPacketSink, VideoSampleSink
+  AudioSampleSource, AudioSample, EncodedVideoPacketSource, EncodedPacket, EncodedPacketSink, VideoSampleSink,
+  EncodedAudioPacketSource
 } from 'mediabunny'
 
 // ----- Constants -----
@@ -13,6 +14,7 @@ const TARGET_VIDEO_BITRATE = 12_000_000
 const TARGET_AUDIO_BITRATE = 96_000
 const TARGET_AUDIO_SR = 48_000
 const TARGET_AUDIO_CHANNELS = 2
+const MAX_VIDEO_ENCODER_QUEUE_SIZE = 4
 
 // ----- Video metadata probe -----
 async function probeVideo (file) {
@@ -33,34 +35,55 @@ async function probeVideo (file) {
   })
 }
 
-async function estimateSourceVideoFps (file) {
+async function estimateSourceVideoStats (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
+    if (!video) return { fps: 0, bitrate: 0, codec: null, rotation: 0 }
     const sink = new EncodedPacketSink(video)
     const durations = []
+    let firstTimestamp = Infinity
+    let lastTimestamp = -Infinity
+    let totalBytes = 0
     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)
+      const duration = Number(packet?.duration)
+      if (packet.timestamp >= 0 && Number.isFinite(duration) && duration > 0) {
+        durations.push(duration)
+        firstTimestamp = Math.min(firstTimestamp, packet.timestamp)
+        lastTimestamp = Math.max(lastTimestamp, packet.timestamp + duration)
+        totalBytes += packet.byteLength
+      }
       if (durations.length >= 120) break
     }
-    if (!durations.length) return 0
+    if (!durations.length) return { fps: 0, bitrate: 0, codec: video.codec, rotation: video.rotation }
     durations.sort((a, b) => a - b)
-    const dur = durations[Math.floor(durations.length / 2)]
-    return Number.isFinite(dur) && dur > 0 ? (1 / dur) : 0
+    const duration = durations[Math.floor(durations.length / 2)]
+    const sampledDuration = lastTimestamp - firstTimestamp
+    return {
+      fps: Number.isFinite(duration) && duration > 0 ? (1 / duration) : 0,
+      bitrate: sampledDuration > 0 ? (totalBytes * 8 / sampledDuration) : 0,
+      codec: video.codec,
+      rotation: video.rotation
+    }
   } catch (_) {
-    return 0
+    return { fps: 0, bitrate: 0, codec: null, rotation: 0 }
   }
 }
 
-async function determineTargetFps (file, { width, height }) {
+async function determineEncodingPlan (file, { width, height, duration }) {
   const maxFps = Math.max(width, height) <= 1920 ? 30 : 60
-  if (maxFps === 30) return 30
-
-  const fps = await estimateSourceVideoFps(file)
-  return fps >= 45 ? 60 : 30
+  const source = await estimateSourceVideoStats(file)
+  const copyVideo = ['avc', 'hevc'].includes(source.codec) &&
+    source.rotation === 0 &&
+    Math.max(width, height) <= MAX_LONG_SIDE &&
+    source.fps >= 23 && source.fps <= 60.1 &&
+    Number(duration) > 0 && (file.size * 8 / Number(duration)) <= TARGET_VIDEO_BITRATE
+  return {
+    fps: copyVideo ? source.fps : (maxFps === 30 ? 30 : (source.fps >= 45 ? 60 : 30)),
+    bitrate: source.bitrate > 0 ? Math.min(TARGET_VIDEO_BITRATE, Math.round(source.bitrate)) : TARGET_VIDEO_BITRATE,
+    copyVideo
+  }
 }
 
 // ----- Audio helpers -----
@@ -124,8 +147,8 @@ 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 = await determineTargetFps(file, { width, height })
-    const sup = await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps }).then(() => true).catch(() => false)
+    const plan = await determineEncodingPlan(file, { width, height, duration })
+    const sup = plan.copyVideo || await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, ...plan }).then(() => true).catch(() => false)
     if (!sup) return { ok: false, reason: 'unsupported-video-config', message: 'No supported encoder configuration for this resolution on this device.' }
 
     // Header sniffing when file.type is empty/incorrect
@@ -141,7 +164,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', plan: { width: targetWidth, height: targetHeight, fps } }
+    return { ok: true, reason: 'ok', message: 'ok', plan: { width: targetWidth, height: targetHeight, ...plan } }
   } catch (e) {
     return { ok: false, reason: 'probe-failed', message: String(e?.message || e) }
   }
@@ -155,17 +178,25 @@ async function optimizeVideo (file, { onProgress } = {}) {
   const feas = await canOptimizeVideo(file)
   if (!feas.ok) return { changed: false, file }
 
+  if (feas.plan.copyVideo) {
+    const fastStarted = await fastStartMp4(file)
+    if (fastStarted) {
+      if (typeof onProgress === 'function') onProgress(1)
+      return { changed: true, file: fastStarted }
+    }
+  }
+
   const srcMeta = await probeVideo(file)
   const newFile = await encodeVideo({ file, srcMeta: { w: srcMeta.width, h: srcMeta.height, duration: srcMeta.duration }, plan: feas.plan, onProgress })
   return { changed: true, file: newFile }
 }
 
-async function selectVideoEncoderConfig ({ width, height, fps }) {
-  const hevc = { codec: 'hvc1.1.4.L123.B0', width, height, framerate: fps, bitrate: TARGET_VIDEO_BITRATE, hardwareAcceleration: 'prefer-hardware', hevc: { format: 'hevc' } }
+async function selectVideoEncoderConfig ({ width, height, fps, bitrate = TARGET_VIDEO_BITRATE }) {
+  const hevc = { codec: 'hvc1.1.4.L123.B0', width, height, framerate: fps, bitrate, hardwareAcceleration: 'prefer-hardware', hevc: { format: 'hevc' } }
   const supH = await VideoEncoder.isConfigSupported(hevc).catch(() => ({ supported: false }))
   if (supH.supported) return { codecId: 'hevc', config: supH.config }
 
-  const avc = { codec: 'avc1.64002A', width, height, framerate: fps, bitrate: TARGET_VIDEO_BITRATE, hardwareAcceleration: 'prefer-hardware', avc: { format: 'avc' } }
+  const avc = { codec: 'avc1.64002A', width, height, framerate: fps, bitrate, hardwareAcceleration: 'prefer-hardware', avc: { format: 'avc' } }
   const supA = await VideoEncoder.isConfigSupported(avc)
   return { codecId: 'avc', config: supA.config }
 }
@@ -174,6 +205,12 @@ function shouldDecodeViaVideoElement () {
   return (navigator?.vendor || '').includes('Apple')
 }
 
+async function applyVideoEncoderBackpressure (encoder) {
+  while (encoder.encodeQueueSize > MAX_VIDEO_ENCODER_QUEUE_SIZE) {
+    await new Promise(resolve => setTimeout(resolve, 0))
+  }
+}
+
 async function waitForFrameReady (video, budgetMs) {
   if (typeof video.requestVideoFrameCallback !== 'function') return false
   return await new Promise((resolve) => {
@@ -238,6 +275,7 @@ async function encodeFramesViaVideoElement ({ file, durationCfr, step, frames, c
     const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
     ve.encode(vf, { keyFrame: i === 0 })
     vf.close()
+    await applyVideoEncoderBackpressure(ve)
 
     if (typeof onProgress === 'function') {
       try {
@@ -284,6 +322,7 @@ async function encodeFramesViaVideoSampleSink ({ file, durationCfr, step, frames
         const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
         ve.encode(vf, { keyFrame: i === 0 })
         vf.close()
+        await applyVideoEncoderBackpressure(ve)
 
         if (typeof onProgress === 'function') {
           try {
@@ -310,6 +349,7 @@ async function encodeFramesViaVideoSampleSink ({ file, durationCfr, step, frames
       const vf = new VideoFrame(canvas, { timestamp: Math.round(t * 1e6), duration: Math.round(step * 1e6) })
       ve.encode(vf, { keyFrame: i === 0 })
       vf.close()
+      await applyVideoEncoderBackpressure(ve)
 
       if (typeof onProgress === 'function') {
         try {
@@ -372,6 +412,35 @@ function _scanBoxes (u8, start, end) {
   return out
 }
 
+async function fastStartMp4 (file) {
+  const u8 = new Uint8Array(await file.arrayBuffer())
+  const boxes = _scanBoxes(u8, 0, u8.byteLength)
+  const ftyp = boxes.find(b => b.type === 'ftyp')
+  const mdat = boxes.find(b => b.type === 'mdat')
+  const moov = boxes.find(b => b.type === 'moov')
+  if (!ftyp || !mdat || !moov || ftyp.offset !== 0 || moov.offset < mdat.offset) return null
+
+  const relocatedMoov = u8.slice(moov.offset, moov.offset + moov.size)
+  const dv = new DataView(relocatedMoov.buffer, relocatedMoov.byteOffset, relocatedMoov.byteLength)
+  for (let i = 0; i < relocatedMoov.byteLength - 16; i++) {
+    if (relocatedMoov[i + 4] !== 0x73 || relocatedMoov[i + 5] !== 0x74 || relocatedMoov[i + 6] !== 0x63 || relocatedMoov[i + 7] !== 0x6f) continue
+    const count = dv.getUint32(i + 12)
+    if (i + 16 + count * 4 > relocatedMoov.byteLength) return null
+    for (let j = 0; j < count; j++) {
+      const offset = i + 16 + j * 4
+      dv.setUint32(offset, dv.getUint32(offset) + moov.size)
+    }
+  }
+
+  const payload = _concat(
+    u8.slice(ftyp.offset, ftyp.offset + ftyp.size),
+    relocatedMoov,
+    ...boxes.filter(box => box !== ftyp && box !== moov).map(box => u8.slice(box.offset, box.offset + box.size))
+  )
+  const dot = file.name.lastIndexOf('.')
+  return new File([payload], `${file.name.substring(0, dot)}-optimized.mp4`, { type: 'video/mp4', lastModified: Date.now() })
+}
+
 function _esdTag (tag, payload) {
   return _concat(new Uint8Array([tag, 0x80, 0x80, 0x80, payload.byteLength]), payload)
 }
@@ -627,76 +696,122 @@ async function encodeVideo ({ file, srcMeta, plan, onProgress }) {
   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(1, Number(plan?.fps) || await determineTargetFps(file, { width: w, height: h }))
+  const fallbackPlan = plan || await determineEncodingPlan(file, { width: w, height: h, duration: durationCfr })
+  const targetFps = Math.max(1, Number(fallbackPlan.fps))
   const step = 1 / Math.max(1, targetFps)
   const frames = Math.max(1, Math.floor(durationCfr / step))
 
   const output = new Output({ format: new Mp4OutputFormat({ fastStart: 'in-memory' }), target: new BufferTarget() })
-  const { codecId, config: usedCfg } = await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps: targetFps })
-  const videoTrack = new EncodedVideoPacketSource(codecId)
-  output.addVideoTrack(videoTrack, { frameRate: targetFps })
-
-  const _warn = console.warn
-  console.warn = (...args) => {
-    const m = args && args[0]
-    if (typeof m === 'string' && m.includes('Unsupported audio codec') && m.includes('apac')) return
-    _warn.apply(console, args)
-  }
-  const audioBuffer = await decodeAudioPCM(file, { duration: durationCfr })
-  console.warn = _warn
-
-  const audioSource = new AudioSampleSource({
-    codec: 'aac',
-    bitrate: TARGET_AUDIO_BITRATE,
-    bitrateMode: 'constant',
-    numberOfChannels: TARGET_AUDIO_CHANNELS,
-    sampleRate: TARGET_AUDIO_SR,
-    onEncodedPacket: (_packet, meta) => {
-      const aot = 2; const idx = 3; const b0 = (aot << 3) | (idx >> 1); const b1 = ((idx & 1) << 7) | (TARGET_AUDIO_CHANNELS << 3)
-      meta.decoderConfig = { codec: 'mp4a.40.2', numberOfChannels: TARGET_AUDIO_CHANNELS, sampleRate: TARGET_AUDIO_SR, description: new Uint8Array([b0, b1]) }
+  const passthroughInput = fallbackPlan.copyVideo ? new Input({ source: new BlobSource(file), formats: ALL_FORMATS }) : null
+  const passthroughTracks = passthroughInput ? await passthroughInput.getTracks() : []
+  const passthroughTrack = passthroughTracks.find(t => typeof t.isVideoTrack === 'function' && t.isVideoTrack())
+  const passthroughAudioTrack = passthroughTrack && passthroughTracks.find(t =>
+    typeof t.isAudioTrack === 'function' && t.isAudioTrack() &&
+    t.codec === 'aac' && [1, 2].includes(t.numberOfChannels) && [44_100, 48_000].includes(t.sampleRate)
+  )
+  const encoder = passthroughTrack ? null : await selectVideoEncoderConfig({ width: targetWidth, height: targetHeight, fps: targetFps, bitrate: fallbackPlan.bitrate })
+  const videoTrack = new EncodedVideoPacketSource(passthroughTrack?.codec || encoder.codecId)
+  output.addVideoTrack(videoTrack, passthroughTrack ? { rotation: passthroughTrack.rotation } : { frameRate: targetFps })
+
+  let audioBuffer = null
+  if (!passthroughAudioTrack) {
+    const _warn = console.warn
+    console.warn = (...args) => {
+      const m = args && args[0]
+      if (typeof m === 'string' && m.includes('Unsupported audio codec') && m.includes('apac')) return
+      _warn.apply(console, args)
     }
-  })
+    audioBuffer = await decodeAudioPCM(file, { duration: durationCfr })
+    console.warn = _warn
+  }
+
+  const audioSource = passthroughAudioTrack
+    ? new EncodedAudioPacketSource('aac')
+    : new AudioSampleSource({
+        codec: 'aac',
+        bitrate: TARGET_AUDIO_BITRATE,
+        bitrateMode: 'constant',
+        numberOfChannels: TARGET_AUDIO_CHANNELS,
+        sampleRate: TARGET_AUDIO_SR,
+        onEncodedPacket: (_packet, meta) => {
+          const aot = 2; const idx = 3; const b0 = (aot << 3) | (idx >> 1); const b1 = ((idx & 1) << 7) | (TARGET_AUDIO_CHANNELS << 3)
+          meta.decoderConfig = { codec: 'mp4a.40.2', numberOfChannels: TARGET_AUDIO_CHANNELS, sampleRate: TARGET_AUDIO_SR, description: new Uint8Array([b0, b1]) }
+        }
+      })
   output.addAudioTrack(audioSource)
 
   await output.start()
+  const passthroughAudioPromise = passthroughAudioTrack && (async () => {
+    const sink = new EncodedPacketSink(passthroughAudioTrack)
+    const decoderConfig = await passthroughAudioTrack.getDecoderConfig()
+    const firstTimestamp = await passthroughAudioTrack.getFirstTimestamp()
+    for await (const packet of sink.packets()) {
+      await audioSource.add(packet.clone({ timestamp: Math.max(0, packet.timestamp - firstTimestamp) }), { decoderConfig: decoderConfig || undefined })
+    }
+    audioSource.close()
+  })()
 
-  let codecDesc = null
-  const pendingPackets = []
-  const ve = new VideoEncoder({
-    output: (chunk, meta) => {
-      if (!codecDesc && meta?.decoderConfig?.description) codecDesc = meta.decoderConfig.description
-      pendingPackets.push({ chunk })
-    },
-    error: () => {}
-  })
-  ve.configure(usedCfg)
-
-  const canvas = document.createElement('canvas'); canvas.width = targetWidth; canvas.height = targetHeight
-  const ctx = canvas.getContext('2d', { alpha: false })
-
-  await (shouldDecodeViaVideoElement()
-    ? encodeFramesViaVideoElement({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress })
-    : encodeFramesViaVideoSampleSink({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }))
-  await ve.flush()
-
-  const muxCount = Math.min(frames, pendingPackets.length)
-
-  for (let i = 0; i < muxCount; i++) {
-    const { chunk } = pendingPackets[i]
-    const data = new Uint8Array(chunk.byteLength); chunk.copyTo(data)
-    const ts = i * step; const dur = step
-    const pkt = new EncodedPacket(data, i === 0 || chunk.type === 'key' ? 'key' : 'delta', ts, dur)
-    await videoTrack.add(pkt, { decoderConfig: { codec: usedCfg.codec, codedWidth: targetWidth, codedHeight: targetHeight, description: codecDesc } })
+  let videoDuration = durationCfr
+  if (passthroughTrack) {
+    const sink = new EncodedPacketSink(passthroughTrack)
+    const decoderConfig = await passthroughTrack.getDecoderConfig()
+    const firstTimestamp = await passthroughTrack.getFirstTimestamp()
+    videoDuration = 0
+    for await (const packet of sink.packets(undefined, undefined, { verifyKeyPackets: true })) {
+      const normalizedPacket = packet.clone({ timestamp: Math.max(0, packet.timestamp - firstTimestamp) })
+      await videoTrack.add(normalizedPacket, { decoderConfig: decoderConfig || undefined })
+      videoDuration = Math.max(videoDuration, normalizedPacket.timestamp + normalizedPacket.duration)
+      if (typeof onProgress === 'function') {
+        try {
+          onProgress(Math.min(1, videoDuration / durationCfr))
+        } catch (err) {
+          console.warn('straight-to-video: onProgress callback threw; ignoring error', err)
+        }
+      }
+    }
+    videoTrack.close()
+  } else {
+    let codecDesc = null
+    const pendingPackets = []
+    const ve = new VideoEncoder({
+      output: (chunk, meta) => {
+        if (!codecDesc && meta?.decoderConfig?.description) codecDesc = meta.decoderConfig.description
+        pendingPackets.push({ chunk })
+      },
+      error: () => {}
+    })
+    ve.configure(encoder.config)
+
+    const canvas = document.createElement('canvas'); canvas.width = targetWidth; canvas.height = targetHeight
+    const ctx = canvas.getContext('2d', { alpha: false })
+
+    await (shouldDecodeViaVideoElement()
+      ? encodeFramesViaVideoElement({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress })
+      : encodeFramesViaVideoSampleSink({ file, durationCfr, step, frames, canvas, ctx, ve, onProgress }))
+    await ve.flush()
+
+    const muxCount = Math.min(frames, pendingPackets.length)
+    videoDuration = muxCount * step
+    for (let i = 0; i < muxCount; i++) {
+      const { chunk } = pendingPackets[i]
+      const data = new Uint8Array(chunk.byteLength); chunk.copyTo(data)
+      const ts = i * step; const dur = step
+      const pkt = new EncodedPacket(data, i === 0 || chunk.type === 'key' ? 'key' : 'delta', ts, dur)
+      await videoTrack.add(pkt, { decoderConfig: { codec: encoder.config.codec, codedWidth: targetWidth, codedHeight: targetHeight, description: codecDesc } })
+    }
   }
 
-  const samplesPerVideoFrame = TARGET_AUDIO_SR / targetFps
-  const totalVideoSamples = muxCount * samplesPerVideoFrame
-  const targetSamples = Math.max(1024, Math.floor(totalVideoSamples / 1024) * 1024 - 2048)
-  const audioExact = await renderStereo48kExact(audioBuffer, targetSamples)
-  const interleaved = interleaveStereoF32(audioExact)
-  const sample = new AudioSample({ format: 'f32', sampleRate: TARGET_AUDIO_SR, numberOfChannels: TARGET_AUDIO_CHANNELS, timestamp: 0, data: interleaved })
-  await audioSource.add(sample)
-  audioSource.close()
+  if (passthroughAudioPromise) {
+    await passthroughAudioPromise
+  } else {
+    const totalVideoSamples = videoDuration * TARGET_AUDIO_SR
+    const targetSamples = Math.max(1024, Math.floor(totalVideoSamples / 1024) * 1024 - 2048)
+    const audioExact = await renderStereo48kExact(audioBuffer, targetSamples)
+    const interleaved = interleaveStereoF32(audioExact)
+    const sample = new AudioSample({ format: 'f32', sampleRate: TARGET_AUDIO_SR, numberOfChannels: TARGET_AUDIO_CHANNELS, timestamp: 0, data: interleaved })
+    await audioSource.add(sample)
+    audioSource.close()
+  }
   await output.finalize()
   const normalized = await normalizeMp4Container(output.target.buffer)
   const payload = new Uint8Array(normalized)

data/lib/straight_to_video/version.rb

@@ -1,3 +1,3 @@
 module StraightToVideo
-  VERSION = "0.0.11"
+  VERSION = "0.0.13"
 end

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "straight-to-video",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "straight-to-video",
-      "version": "0.0.11",
+      "version": "0.0.13",
       "license": "MIT",
       "dependencies": {
         "mediabunny": "^1.27.3"

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "straight-to-video",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Browser-based, hardware-accelerated video upload optimization",
   "type": "module",
   "exports": {
@@ -26,7 +26,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/searlsco/straight-to-video.git"
+    "url": "git+https://github.com/searlsco/straight-to-video.git"
   },
   "license": "MIT",
   "files": [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: straight_to_video
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.13
 platform: ruby
 authors:
 - Justin Searls