Spaces:
Paused
Paused
File size: 8,999 Bytes
4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 c5a2609 4b7c857 44d2dac c5a2609 44d2dac 4b7c857 44d2dac c5a2609 44d2dac c5a2609 44d2dac c5a2609 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 c5a2609 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 c5a2609 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 44d2dac 4b7c857 c5a2609 4b7c857 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 | // In-browser MP4 export: deterministic frame-by-frame rendering → WebCodecs
// H.264 (+ AAC / Opus audio) → mp4-muxer. Nothing leaves the user's device.
//
// v3: every frame is verified before encoding (see frame.ts), the H.264 level is the lowest
// one that fits the picture (phones / WeChat / 视频号 players reject level 5.x streams and
// show a black picture with sound), bitrates are raised, and the picture is supersampled.
import { ArrayBufferTarget, Muxer } from 'mp4-muxer'
import type { Film } from '../engine/Film'
import { DURATION } from '../engine/timeline'
import { drawOverlay, OverlayOpts } from '../player/overlay'
import { createGrabber, GrabStats, yieldToBrowser } from './frame'
export interface ExportOptions {
width: number
height: number
fps: 24 | 30 | 60
audio: AudioBuffer | null
overlay: OverlayOpts
onProgress: (p: number, info: { frame: number; total: number; eta: number; stage: string }) => void
signal: { cancelled: boolean }
duration?: number
start?: number
/**
* auto: hardware encoder first, keyframe every 2 s.
* compatible: software encoder first, 'realtime' latency mode (no frame re-ordering), keyframes
* only every 10 s — for GPUs / drivers whose hardware H.264 encoder emits broken (black) frames.
*/
encoder?: 'auto' | 'compatible'
}
export interface ExportResult {
blob: Blob
audioCodec: string | null
videoCodec: string
bitrate: number
stats: GrabStats
encoder: 'auto' | 'compatible'
hardware: string
keyInterval: number
}
export function exportSupport() {
return {
video: typeof window !== 'undefined' && 'VideoEncoder' in window,
audio: typeof window !== 'undefined' && 'AudioEncoder' in window,
}
}
// H.264 levels: [level_idc, MaxFS (macroblocks), MaxMBPS (macroblocks / s), MaxBR kbit/s (Main; High = ×1.25)]
const AVC_LEVELS: [number, number, number, number][] = [
[0x1f, 3600, 108000, 14000], // 3.1 720p30
[0x20, 5120, 216000, 20000], // 3.2 720p60
[0x28, 8192, 245760, 20000], // 4.0 1080p30
[0x29, 8192, 245760, 50000], // 4.1
[0x2a, 8704, 522240, 50000], // 4.2 1080p60
[0x32, 22080, 589824, 135000], // 5.0 1440p30
[0x33, 36864, 983040, 240000], // 5.1 1440p60 / 2160p30
[0x34, 36864, 2073600, 240000], // 5.2 2160p60
]
/** The lowest H.264 level that can carry w × h @ fps at the given bitrate. */
export function avcLevelFor(w: number, h: number, fps: number, bitrate: number) {
const mbs = Math.ceil(w / 16) * Math.ceil(h / 16)
const mbps = mbs * fps
for (const [idc, maxFS, maxMBPS, maxBR] of AVC_LEVELS) {
if (mbs <= maxFS && mbps <= maxMBPS && bitrate <= maxBR * 1000 * 1.25) return idc
}
return 0x34
}
export function codecName(cfg: VideoEncoderConfig) {
const c = cfg.codec
const p = c.slice(5, 7), l = parseInt(c.slice(9, 11), 16)
const prof = p === '64' ? 'High' : p === '4D' ? 'Main' : 'Baseline'
return `H.264 ${prof} @ L${(l / 10).toFixed(1)}`
}
async function pickVideoCodec(w: number, h: number, fps: number, bitrate: number, mode: 'auto' | 'compatible') {
const minIdc = avcLevelFor(w, h, fps, bitrate)
const levels = AVC_LEVELS.map((l) => l[0]).filter((l) => l >= minIdc)
// High → Main → Constrained Baseline; at each profile, the lowest level first
const profiles = ['6400', '4D40', '42E0']
const hwOrder = mode === 'compatible' ? (['prefer-software', 'no-preference', 'prefer-hardware'] as const) : (['prefer-hardware', 'no-preference'] as const)
let lastErr: unknown = null
for (const hw of hwOrder) {
for (const prof of profiles) {
for (const lvl of levels) {
const codec = `avc1.${prof}${lvl.toString(16).padStart(2, '0').toUpperCase()}`
const cfg: VideoEncoderConfig = { codec, width: w, height: h, bitrate, framerate: fps, hardwareAcceleration: hw, avc: { format: 'avc' }, latencyMode: mode === 'compatible' ? 'realtime' : 'quality', bitrateMode: 'variable' }
try {
const s = await VideoEncoder.isConfigSupported(cfg)
if (s.supported) return cfg
} catch (e) { lastErr = e }
}
}
}
throw new Error('当前浏览器不支持 H.264 编码,请使用最新版 Chrome / Edge / Safari' + (lastErr ? `(${(lastErr as Error).message})` : ''))
}
async function pickAudioCodec() {
if (!('AudioEncoder' in window)) return null
for (const [codec, mux] of [['mp4a.40.2', 'aac'], ['opus', 'opus']] as const) {
const cfg: AudioEncoderConfig = { codec, sampleRate: 48000, numberOfChannels: 2, bitrate: 256000 }
try {
const s = await AudioEncoder.isConfigSupported(cfg)
if (s.supported) return { cfg, mux }
} catch { /* next */ }
}
return null
}
/** Target bitrate: generous, because film grain, mist and water glitter are expensive to encode. */
export function suggestedBitrate(w: number, h: number, fps: number) {
const px = w * h
const base = px >= 2560 * 1440 * 0.9 ? 40e6 : px >= 1920 * 1080 * 0.9 ? 24e6 : 12e6
return Math.round(base * (fps >= 50 ? 1.5 : fps <= 24 ? 0.9 : 1))
}
export async function exportMp4(film: Film, o: ExportOptions): Promise<ExportResult> {
const { width: W, height: H, fps } = o
const start = o.start ?? 0
const dur = o.duration ?? DURATION
const total = Math.round(dur * fps)
const bitrate = suggestedBitrate(W, H, fps)
const mode = o.encoder ?? 'auto'
const vcfg = await pickVideoCodec(W, H, fps, bitrate, mode)
const keyInterval = mode === 'compatible' ? 10 : 2
const acodec = o.audio ? await pickAudioCodec() : null
const target = new ArrayBufferTarget()
const muxer = new Muxer({
target,
video: { codec: 'avc', width: W, height: H, frameRate: fps },
...(acodec ? { audio: { codec: acodec.mux, sampleRate: 48000, numberOfChannels: 2 } } : {}),
fastStart: 'in-memory',
firstTimestampBehavior: 'offset',
})
let encErr: unknown = null
// ---- audio first (fast)
if (acodec && o.audio) {
o.onProgress(0, { frame: 0, total, eta: 0, stage: '编码音轨' })
const ae = new AudioEncoder({ output: (c, m) => muxer.addAudioChunk(c, m), error: (e) => { encErr = e } })
ae.configure(acodec.cfg)
const buf = o.audio
const L = buf.getChannelData(0), R = buf.numberOfChannels > 1 ? buf.getChannelData(1) : L
const s0 = Math.floor(start * 48000)
const len = Math.min(L.length - s0, Math.round(dur * 48000))
const block = 4800
for (let i = 0; i < len; i += block) {
const n = Math.min(block, len - i)
const data = new Float32Array(n * 2)
data.set(L.subarray(s0 + i, s0 + i + n), 0)
data.set(R.subarray(s0 + i, s0 + i + n), n)
const ad = new AudioData({ format: 'f32-planar', sampleRate: 48000, numberOfFrames: n, numberOfChannels: 2, timestamp: Math.round((i / 48000) * 1e6), data })
ae.encode(ad)
ad.close()
if (ae.encodeQueueSize > 20) await yieldToBrowser()
}
await ae.flush()
ae.close()
}
// ---- video
const ve = new VideoEncoder({ output: (c, m) => muxer.addVideoChunk(c, m), error: (e) => { encErr = e } })
ve.configure(vcfg)
const grabber = createGrabber(film, W, H, { sharpen: 0.18 })
const { comp, g } = grabber
const t0 = performance.now()
try {
// probe frame: make sure the whole chain (render → copy → verify) works before we start
o.onProgress(0, { frame: 0, total, eta: 0, stage: '检查渲染链路' })
await grabber.grab(start + Math.min(dur, 3) * 0.5)
for (let i = 0; i < total; i++) {
if (o.signal.cancelled) throw new Error('已取消')
if (encErr) throw encErr
const t = start + i / fps
await grabber.grab(t)
drawOverlay(g, t, W, H, o.overlay)
const frame = new VideoFrame(comp, { timestamp: Math.round((i * 1e6) / fps), duration: Math.round(1e6 / fps) })
ve.encode(frame, { keyFrame: i % (fps * keyInterval) === 0 })
frame.close()
while (ve.encodeQueueSize > 3) { await yieldToBrowser(); if (ve.encodeQueueSize > 3) await new Promise((r) => setTimeout(r, 2)) }
if (i % 3 === 0) {
const el = (performance.now() - t0) / 1000
const note = grabber.stats.retries ? `(已自动修复 ${grabber.stats.retries} 帧)` : ''
o.onProgress((i + 1) / total, { frame: i + 1, total, eta: (el / (i + 1)) * (total - i - 1), stage: `渲染画面 ${grabber.stats.ss}×超采样${note}` })
await yieldToBrowser()
}
}
o.onProgress(1, { frame: total, total, eta: 0, stage: '封装 MP4' })
await ve.flush()
ve.close()
if (encErr) throw encErr
muxer.finalize()
} finally {
grabber.release()
if (ve.state !== 'closed') try { ve.close() } catch { /* ignore */ }
}
return {
blob: new Blob([target.buffer], { type: 'video/mp4' }), audioCodec: acodec?.mux ?? null, videoCodec: codecName(vcfg), bitrate, stats: grabber.stats,
encoder: mode, hardware: vcfg.hardwareAcceleration === 'prefer-software' ? '软件编码' : vcfg.hardwareAcceleration === 'prefer-hardware' ? '硬件编码' : '自动', keyInterval,
}
}
|