97 lines
2.2 KiB
TypeScript
97 lines
2.2 KiB
TypeScript
import { type ChildProcessWithoutNullStreams } from "node:child_process"
|
|
import { createReadStream, ReadStream } from "node:fs"
|
|
|
|
export type ByteRange = {
|
|
start: number
|
|
end: number
|
|
}
|
|
|
|
async function* nodeStreamToIterator(stream: ReadStream) {
|
|
for await (const chunk of stream) {
|
|
yield new Uint8Array(chunk)
|
|
}
|
|
}
|
|
|
|
// @ts-expect-error trust me bro
|
|
function iteratorToStream(iterator) {
|
|
return new ReadableStream({
|
|
async pull(controller) {
|
|
const { value, done } = await iterator.next()
|
|
if (done) {
|
|
controller.close()
|
|
} else {
|
|
controller.enqueue(value)
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
export function streamFile(path: string, range?: ByteRange): ReadableStream {
|
|
const nodeStream = createReadStream(path, range)
|
|
return iteratorToStream(nodeStreamToIterator(nodeStream))
|
|
}
|
|
|
|
export function ffmpegToReadableStream(
|
|
ffmpegProcess: ChildProcessWithoutNullStreams
|
|
) {
|
|
let closed = false
|
|
|
|
return new ReadableStream({
|
|
start(controller) {
|
|
const finalize = (err?: Error) => {
|
|
if (closed) {
|
|
return
|
|
}
|
|
closed = true
|
|
|
|
try {
|
|
if (err) {
|
|
controller.error(err)
|
|
} else {
|
|
controller.close()
|
|
}
|
|
} catch {
|
|
// Consumer may have already closed the stream (e.g. track change).
|
|
}
|
|
}
|
|
|
|
ffmpegProcess.stdout.on("data", (chunk: Buffer) => {
|
|
if (closed) {
|
|
return
|
|
}
|
|
|
|
try {
|
|
controller.enqueue(new Uint8Array(chunk))
|
|
} catch {
|
|
closed = true
|
|
ffmpegProcess.kill("SIGKILL")
|
|
}
|
|
})
|
|
|
|
ffmpegProcess.stderr.on("data", (data) => {
|
|
console.error(`FFmpeg log: ${data.toString()}`)
|
|
})
|
|
|
|
ffmpegProcess.stdout.on("end", () => finalize())
|
|
ffmpegProcess.stdout.on("error", (err) => finalize(err))
|
|
|
|
ffmpegProcess.on("close", (code) => {
|
|
if (code !== 0 && !closed) {
|
|
finalize(new Error(`ffmpeg exited with code ${code}`))
|
|
} else {
|
|
finalize()
|
|
}
|
|
})
|
|
|
|
ffmpegProcess.on("error", (err) => finalize(err))
|
|
},
|
|
cancel() {
|
|
if (closed) {
|
|
return
|
|
}
|
|
closed = true
|
|
ffmpegProcess.kill("SIGKILL")
|
|
},
|
|
})
|
|
}
|