mirror of
https://github.com/nagisa77/OpenIsle.git
synced 2026-02-06 23:21:16 +08:00
328 lines
9.8 KiB
JavaScript
328 lines
9.8 KiB
JavaScript
/**
|
||
* FFmpeg.wasm 视频压缩器
|
||
*
|
||
* 用法：
|
||
* const { $ffmpeg } = useNuxtApp()
|
||
* const ff = await $ffmpeg() // 插件里已完成 ffmpeg.load()
|
||
* const out = await compressVideoWithFFmpeg(ff, file, { onProgress, strictSize: false })
|
||
*
|
||
* 设计要点：
|
||
* - 本文件不再负责加载/初始化，只负责转码逻辑；和 Nuxt 插件解耦。
|
||
* - 针对【同一个 ffmpeg 实例】做串行队列，避免并发 exec 踩内存文件系统。
|
||
* - 使用 nanoid 生成唯一文件名；日志环形缓冲；默认 CRF+VBV，可选 strictSize（two-pass）。
|
||
* - 体积明显小于目标时直通返回，减少无谓重编码。
|
||
*/
|
||
|
||
import { fetchFile } from '@ffmpeg/util'
|
||
import { nanoid } from 'nanoid'
|
||
import { UPLOAD_CONFIG } from '../config/uploadConfig.js'
|
||
|
||
/*************************
|
||
* 每实例一个串行队列 *
|
||
*************************/
|
||
// WeakMap<FFmpeg, { q: (()=>Promise<any>)[], running: boolean, resolvers: {res,rej}[] }>
|
||
const queues = new WeakMap()
|
||
|
||
function enqueueOn(instance, taskFn) {
|
||
return new Promise((res, rej) => {
|
||
let st = queues.get(instance)
|
||
if (!st) {
|
||
st = { q: [], running: false, resolvers: [] }
|
||
queues.set(instance, st)
|
||
}
|
||
st.q.push(taskFn)
|
||
st.resolvers.push({ res, rej })
|
||
drain(instance)
|
||
})
|
||
}
|
||
|
||
async function drain(instance) {
|
||
const st = queues.get(instance)
|
||
if (!st || st.running) return
|
||
st.running = true
|
||
try {
|
||
while (st.q.length) {
|
||
const task = st.q.shift()
|
||
const rr = st.resolvers.shift()
|
||
try {
|
||
rr.res(await task())
|
||
} catch (e) {
|
||
rr.rej(e)
|
||
}
|
||
}
|
||
} finally {
|
||
st.running = false
|
||
}
|
||
}
|
||
|
||
/*****************
|
||
* 工具函数 *
|
||
*****************/
|
||
function decideScale(widthHint) {
|
||
if (!widthHint) return { filter: null, width: null }
|
||
const evenW = widthHint % 2 === 0 ? widthHint : widthHint - 1
|
||
return { filter: `scale=${evenW}:-2:flags=bicubic,setsar=1`, width: evenW }
|
||
}
|
||
|
||
function calculateParamsByRatio(originalSize, targetSize) {
|
||
const ratio = Math.min(targetSize / originalSize, 1)
|
||
const crf = ratio < 0.35 ? 29 : ratio < 0.5 ? 27 : ratio < 0.7 ? 25 : 23
|
||
const preset = ratio < 0.35 ? 'slow' : ratio < 0.5 ? 'medium' : 'veryfast'
|
||
const s =
|
||
ratio < 0.35
|
||
? decideScale(720)
|
||
: ratio < 0.6
|
||
? decideScale(960)
|
||
: ratio < 0.8
|
||
? decideScale(1280)
|
||
: { filter: null, width: null }
|
||
const audioBitrateK = ratio < 0.5 ? 96 : ratio < 0.7 ? 128 : 160
|
||
const profile = s.width && s.width <= 1280 ? 'main' : 'high'
|
||
return { crf, preset, scaleFilter: s.filter, scaleWidth: s.width, audioBitrateK, profile }
|
||
}
|
||
|
||
function makeRingLogger(capBytes = 4000) {
|
||
const buf = []
|
||
let total = 0
|
||
function push(s) {
|
||
if (!s) return
|
||
buf.push(s)
|
||
total += s.length
|
||
while (total > capBytes) total -= buf.shift().length
|
||
}
|
||
return { push, dump: () => buf.slice() }
|
||
}
|
||
|
||
function parseDurationFromLogs(logs) {
|
||
// 避免正则：查找 Duration: 后的 00:00:00.xx
|
||
const text = logs.join(' ')
|
||
const idx = text.indexOf('Duration:')
|
||
if (idx === -1) return null
|
||
let i = idx + 'Duration:'.length
|
||
while (i < text.length && text[i] === ' ') i++
|
||
function read2(start) {
|
||
const a = text.charCodeAt(start) - 48
|
||
const b = text.charCodeAt(start + 1) - 48
|
||
if (a < 0 || a > 9 || b < 0 || b > 9) return null
|
||
return a * 10 + b
|
||
}
|
||
const hh = read2(i)
|
||
if (hh === null) return null
|
||
i += 2
|
||
if (text[i++] !== ':') return null
|
||
const mm = read2(i)
|
||
if (mm === null) return null
|
||
i += 2
|
||
if (text[i++] !== ':') return null
|
||
const s1 = read2(i)
|
||
if (s1 === null) return null
|
||
i += 2
|
||
if (text[i++] !== '.') return null
|
||
let j = i
|
||
while (j < text.length && text.charCodeAt(j) >= 48 && text.charCodeAt(j) <= 57) j++
|
||
const frac = parseFloat('0.' + text.slice(i, j) || '0')
|
||
return hh * 3600 + mm * 60 + s1 + frac
|
||
}
|
||
|
||
export function isFFmpegSupported() {
|
||
return typeof WebAssembly !== 'undefined' && typeof Worker !== 'undefined'
|
||
}
|
||
|
||
/**
|
||
* 读取 ffmpeg 核心版本（通过 -version），会进入队列避免并发冲突
|
||
*/
|
||
export async function getFFmpegInfo(ffmpegInstance) {
|
||
return enqueueOn(ffmpegInstance, async () => {
|
||
const logs = []
|
||
const onLog = ({ type, message }) => {
|
||
if (type === 'info' || type === 'fferr') logs.push(message)
|
||
}
|
||
ffmpegInstance.on('log', onLog)
|
||
try {
|
||
await ffmpegInstance.exec(['-version'])
|
||
} finally {
|
||
ffmpegInstance.off('log', onLog)
|
||
}
|
||
const line = logs.find((l) => l.toLowerCase().includes('ffmpeg version')) || ''
|
||
const parts = line.trim().split(' ').filter(Boolean)
|
||
const version = parts.length > 2 ? parts[2] : parts[1] || null
|
||
return { version }
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 压缩：接受一个已经 load() 完成的 ffmpeg 实例
|
||
* @param {*} ffmpegInstance 已初始化的 FFmpeg 实例（来自 Nuxt 插件）
|
||
* @param {File|Blob} file 输入文件
|
||
* @param {{ onProgress?:(p:{stage:string,progress:number})=>void, signal?:AbortSignal, strictSize?:boolean, targetSize?:number }} opts
|
||
*/
|
||
export async function compressVideoWithFFmpeg(ffmpegInstance, file, opts = {}) {
|
||
return enqueueOn(ffmpegInstance, () => doCompress(ffmpegInstance, file, opts))
|
||
}
|
||
|
||
async function doCompress(ffmpegInstance, file, opts) {
|
||
const onProgress = opts.onProgress || (() => {})
|
||
const { signal, strictSize = false } = opts
|
||
|
||
onProgress({ stage: 'preparing', progress: 10 })
|
||
|
||
const targetSize = opts.targetSize ?? UPLOAD_CONFIG?.VIDEO?.TARGET_SIZE ?? 12 * 1024 * 1024
|
||
|
||
// 小体积直通
|
||
const sizeKnown = 'size' in file && typeof file.size === 'number'
|
||
if (sizeKnown && file.size <= targetSize * 0.9) {
|
||
onProgress({ stage: 'skipped', progress: 100 })
|
||
return file
|
||
}
|
||
|
||
const params = calculateParamsByRatio(sizeKnown ? file.size : targetSize * 2, targetSize)
|
||
const { crf, preset, scaleFilter, audioBitrateK, profile } = params
|
||
|
||
const name = 'name' in file && typeof file.name === 'string' ? file.name : 'input.mp4'
|
||
const dot = name.lastIndexOf('.')
|
||
const outName = (dot > -1 ? name.slice(0, dot) : name) + '.mp4'
|
||
|
||
const ext = dot > -1 ? name.slice(dot + 1).toLowerCase() : 'mp4'
|
||
const id = nanoid()
|
||
const inputName = `input-${id}.${ext}`
|
||
const outputName = `output-${id}.mp4`
|
||
const passlog = `ffpass-${id}`
|
||
|
||
// 监听
|
||
const ring = makeRingLogger()
|
||
const onFfmpegProgress = ({ progress: p }) => {
|
||
const adjusted = 20 + p * 70
|
||
onProgress({ stage: 'compressing', progress: Math.min(90, adjusted) })
|
||
}
|
||
const onFfmpegLog = ({ type, message }) => {
|
||
if (type === 'fferr' || type === 'info') ring.push(message)
|
||
}
|
||
ffmpegInstance.on('progress', onFfmpegProgress)
|
||
ffmpegInstance.on('log', onFfmpegLog)
|
||
|
||
let aborted = false
|
||
const abortHandler = () => {
|
||
aborted = true
|
||
}
|
||
if (signal) signal.addEventListener('abort', abortHandler, { once: true })
|
||
|
||
try {
|
||
await ffmpegInstance.writeFile(inputName, await fetchFile(file))
|
||
onProgress({ stage: 'analyzing', progress: 20 })
|
||
|
||
let durationSec = null
|
||
try {
|
||
await ffmpegInstance.exec(['-hide_banner', '-i', inputName, '-f', 'null', '-'])
|
||
durationSec = parseDurationFromLogs(ring.dump())
|
||
} catch {
|
||
durationSec = durationSec ?? parseDurationFromLogs(ring.dump())
|
||
}
|
||
|
||
let videoBitrate = null
|
||
if (durationSec && sizeKnown && targetSize < file.size) {
|
||
const totalTargetBits = targetSize * 8
|
||
const audioBits = audioBitrateK * 1000 * durationSec
|
||
const maxVideoBits = Math.max(totalTargetBits - audioBits, totalTargetBits * 0.7)
|
||
const bps = Math.max(180000, Math.floor(maxVideoBits / durationSec))
|
||
videoBitrate = String(Math.min(bps, 5000000))
|
||
}
|
||
|
||
const baseArgs = [
|
||
'-hide_banner',
|
||
'-i',
|
||
inputName,
|
||
'-c:v',
|
||
'libx264',
|
||
'-pix_fmt',
|
||
'yuv420p',
|
||
'-profile:v',
|
||
profile,
|
||
'-movflags',
|
||
'+faststart',
|
||
'-preset',
|
||
preset,
|
||
'-c:a',
|
||
'aac',
|
||
'-b:a',
|
||
`${audioBitrateK}k`,
|
||
'-ac',
|
||
'2',
|
||
]
|
||
if (scaleFilter) baseArgs.push('-vf', scaleFilter)
|
||
|
||
const onePassArgs = [...baseArgs, '-crf', String(crf)]
|
||
if (videoBitrate)
|
||
onePassArgs.push('-maxrate', videoBitrate, '-bufsize', String(parseInt(videoBitrate, 10) * 2))
|
||
|
||
const twoPassFirst = [
|
||
'-y',
|
||
'-hide_banner',
|
||
'-i',
|
||
inputName,
|
||
'-c:v',
|
||
'libx264',
|
||
'-b:v',
|
||
`${videoBitrate || '1000000'}`,
|
||
'-pass',
|
||
'1',
|
||
'-passlogfile',
|
||
passlog,
|
||
'-an',
|
||
'-f',
|
||
'mp4',
|
||
'/dev/null',
|
||
]
|
||
const twoPassSecond = [
|
||
...baseArgs,
|
||
'-b:v',
|
||
`${videoBitrate || '1000000'}`,
|
||
'-pass',
|
||
'2',
|
||
'-passlogfile',
|
||
passlog,
|
||
outputName,
|
||
]
|
||
|
||
if (aborted) throw new DOMException('Aborted', 'AbortError')
|
||
|
||
if (!strictSize) {
|
||
await ffmpegInstance.exec([...onePassArgs, outputName])
|
||
} else {
|
||
if (!videoBitrate) videoBitrate = '1000000'
|
||
await ffmpegInstance.exec(twoPassFirst)
|
||
onProgress({ stage: 'second-pass', progress: 85 })
|
||
await ffmpegInstance.exec(twoPassSecond)
|
||
}
|
||
|
||
if (aborted) throw new DOMException('Aborted', 'AbortError')
|
||
|
||
onProgress({ stage: 'finalizing', progress: 95 })
|
||
const out = await ffmpegInstance.readFile(outputName)
|
||
|
||
const mime = 'video/mp4'
|
||
const blob = new Blob([out], { type: mime })
|
||
const hasFileCtor = typeof File === 'function'
|
||
const result = hasFileCtor ? new File([blob], outName, { type: mime }) : blob
|
||
|
||
onProgress({ stage: 'completed', progress: 100 })
|
||
return result
|
||
} finally {
|
||
try {
|
||
await ffmpegInstance.deleteFile(inputName)
|
||
} catch {}
|
||
try {
|
||
await ffmpegInstance.deleteFile(outputName)
|
||
} catch {}
|
||
try {
|
||
await ffmpegInstance.deleteFile(`${passlog}-0.log`)
|
||
} catch {}
|
||
try {
|
||
await ffmpegInstance.deleteFile(`${passlog}-0.log.mbtree`)
|
||
} catch {}
|
||
|
||
ffmpegInstance.off('progress', onFfmpegProgress)
|
||
ffmpegInstance.off('log', onFfmpegLog)
|
||
if (signal) signal.removeEventListener('abort', abortHandler)
|
||
}
|
||
}
|