diff --git a/app/api/song/[id]/play/hls/route.ts b/app/api/song/[id]/play/hls/route.ts
new file mode 100644
index 0000000..0ff0ae4
--- /dev/null
+++ b/app/api/song/[id]/play/hls/route.ts
@@ -0,0 +1,58 @@
+import { api } from "@/convex/_generated/api"
+import type { Id } from "@/convex/_generated/dataModel"
+import { getConvexClient } from "@/lib/convex-server"
+import { ensureHlsJob, HLS_SEGMENT_SECONDS } from "@/lib/server-hls"
+import { NextRequest } from "next/server"
+
+function hlsSegmentUrl(request: NextRequest, index: number) {
+ const url = new URL(request.url)
+ url.pathname = `${url.pathname.replace(/\/$/, "")}/segment/${index}.ts`
+ return `${url.pathname}${url.search}`
+}
+
+export async function GET(
+ request: NextRequest,
+ { params }: { params: Promise<{ id: string }> }
+) {
+ const { id } = await params
+
+ try {
+ const song = (await getConvexClient().query(api.library.getSong, {
+ id: id as Id<"songs">,
+ }))!
+
+ const quality = request.nextUrl.searchParams.get("quality")
+ const preferAtmos =
+ request.nextUrl.searchParams.get("preferAtmos") === "true"
+ const job = await ensureHlsJob(song, quality, preferAtmos)
+ const { duration, segmentCount } = job
+ const targetDuration = Math.ceil(HLS_SEGMENT_SECONDS)
+
+ const lines = [
+ "#EXTM3U",
+ "#EXT-X-VERSION:3",
+ `#EXT-X-TARGETDURATION:${targetDuration}`,
+ "#EXT-X-MEDIA-SEQUENCE:0",
+ "#EXT-X-PLAYLIST-TYPE:VOD",
+ ]
+
+ for (let index = 0; index < segmentCount; index += 1) {
+ const start = index * HLS_SEGMENT_SECONDS
+ const segmentDuration = Math.min(HLS_SEGMENT_SECONDS, duration - start)
+ lines.push(`#EXTINF:${segmentDuration.toFixed(3)},`)
+ lines.push(hlsSegmentUrl(request, index))
+ }
+
+ lines.push("#EXT-X-ENDLIST")
+
+ return new Response(`${lines.join("\n")}\n`, {
+ status: 200,
+ headers: {
+ "Cache-Control": "no-cache",
+ "Content-Type": "application/vnd.apple.mpegurl",
+ },
+ })
+ } catch {
+ return new Response("Not found", { status: 404 })
+ }
+}
diff --git a/app/api/song/[id]/play/hls/segment/[segment]/route.ts b/app/api/song/[id]/play/hls/segment/[segment]/route.ts
new file mode 100644
index 0000000..cbc3d58
--- /dev/null
+++ b/app/api/song/[id]/play/hls/segment/[segment]/route.ts
@@ -0,0 +1,58 @@
+import { api } from "@/convex/_generated/api"
+import type { Id } from "@/convex/_generated/dataModel"
+import { getConvexClient } from "@/lib/convex-server"
+import { ensureHlsJob, waitForHlsSegment } from "@/lib/server-hls"
+import { streamFile } from "@/lib/server-audio-stream"
+import { NextRequest, NextResponse } from "next/server"
+import fs from "node:fs/promises"
+
+function parseSegmentIndex(segment: string) {
+ const indexText = segment.endsWith(".ts") ? segment.slice(0, -3) : segment
+ const index = Number(indexText)
+
+ if (!Number.isInteger(index) || index < 0) {
+ return null
+ }
+
+ return index
+}
+
+export async function GET(
+ request: NextRequest,
+ { params }: { params: Promise<{ id: string; segment: string }> }
+) {
+ const { id, segment } = await params
+ const segmentIndex = parseSegmentIndex(segment)
+
+ if (segmentIndex === null) {
+ return new Response("Invalid segment", { status: 400 })
+ }
+
+ try {
+ const song = (await getConvexClient().query(api.library.getSong, {
+ id: id as Id<"songs">,
+ }))!
+
+ const quality = request.nextUrl.searchParams.get("quality")
+ const preferAtmos =
+ request.nextUrl.searchParams.get("preferAtmos") === "true"
+ const job = await ensureHlsJob(song, quality, preferAtmos)
+ if (segmentIndex >= job.segmentCount) {
+ return new Response("Segment not found", { status: 404 })
+ }
+
+ const segmentPath = await waitForHlsSegment(job, segmentIndex)
+ const { size } = await fs.stat(segmentPath)
+
+ return new NextResponse(streamFile(segmentPath), {
+ status: 200,
+ headers: {
+ "Cache-Control": "no-cache",
+ "Content-Length": String(size),
+ "Content-Type": "video/mp2t",
+ },
+ })
+ } catch {
+ return new Response("Not found", { status: 404 })
+ }
+}
diff --git a/app/api/song/[id]/play/route.ts b/app/api/song/[id]/play/route.ts
index 648dcde..942b3be 100644
--- a/app/api/song/[id]/play/route.ts
+++ b/app/api/song/[id]/play/route.ts
@@ -2,96 +2,110 @@ import { api } from "@/convex/_generated/api"
import type { Id } from "@/convex/_generated/dataModel"
import { audioContentTypeForPath } from "@/lib/audio-content-type"
import { getConvexClient } from "@/lib/convex-server"
+import { ffmpegToReadableStream, streamFile } from "@/lib/server-audio-stream"
import { NextRequest, NextResponse, userAgent } from "next/server"
-import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process"
+import { spawn } from "node:child_process"
import fs from "node:fs/promises"
-import { createReadStream, ReadStream } from "node:fs"
import * as music from "music-metadata"
-async function* nodeStreamToIterator(stream: ReadStream) {
- for await (const chunk of stream) {
- yield new Uint8Array(chunk)
+function parseByteRange(rangeHeader: string | null, fileSize: number) {
+ if (!rangeHeader) {
+ return null
+ }
+
+ if (!rangeHeader.startsWith("bytes=")) {
+ return "invalid" as const
+ }
+
+ const rangeSpec = rangeHeader.slice("bytes=".length)
+ if (rangeSpec.includes(",")) {
+ return "invalid" as const
+ }
+
+ const [startText, endText] = rangeSpec.split("-")
+ if (startText === undefined || endText === undefined) {
+ return "invalid" as const
+ }
+
+ if (startText === "" && endText === "") {
+ return "invalid" as const
+ }
+
+ let start: number
+ let end: number
+
+ if (startText === "") {
+ const suffixLength = Number(endText)
+ if (!Number.isInteger(suffixLength) || suffixLength <= 0) {
+ return "invalid" as const
+ }
+
+ start = Math.max(fileSize - suffixLength, 0)
+ end = fileSize - 1
+ } else {
+ start = Number(startText)
+ end = endText === "" ? fileSize - 1 : Number(endText)
+
+ if (
+ !Number.isInteger(start) ||
+ !Number.isInteger(end) ||
+ start < 0 ||
+ end < start
+ ) {
+ return "invalid" as const
+ }
+ }
+
+ if (start >= fileSize) {
+ return "invalid" as const
+ }
+
+ return {
+ start,
+ end: Math.min(end, fileSize - 1),
}
}
-// @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)
- }
- },
+async function streamFileResponse(
+ request: NextRequest,
+ path: string,
+ contentType: string
+) {
+ const { size } = await fs.stat(path)
+ const range = parseByteRange(request.headers.get("range"), size)
+
+ if (range === "invalid") {
+ return new Response(null, {
+ status: 416,
+ headers: {
+ "Accept-Ranges": "bytes",
+ "Cache-Control": "no-cache",
+ "Content-Range": `bytes */${size}`,
+ },
+ })
+ }
+
+ const headers = new Headers({
+ "Accept-Ranges": "bytes",
+ "Cache-Control": "no-cache",
+ "Content-Type": contentType,
})
-}
-export function streamFile(path: string): ReadableStream {
- const nodeStream = createReadStream(path)
- return iteratorToStream(nodeStreamToIterator(nodeStream))
-}
+ if (range) {
+ headers.set("Content-Length", String(range.end - range.start + 1))
+ headers.set("Content-Range", `bytes ${range.start}-${range.end}/${size}`)
-function ffmpegToReadableStream(ffmpegProcess: ChildProcessWithoutNullStreams) {
- let closed = false
+ return new NextResponse(streamFile(path, range), {
+ status: 206,
+ headers,
+ })
+ }
- return new ReadableStream({
- start(controller) {
- const finalize = (err?: Error) => {
- if (closed) {
- return
- }
- closed = true
+ headers.set("Content-Length", String(size))
- 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")
- },
+ return new NextResponse(streamFile(path), {
+ status: 200,
+ headers,
})
}
@@ -145,14 +159,11 @@ export async function GET(
if (!transcodeNeeded && originalCodec === "lossless") {
if (browser.name === "Safari" && metadata.format.codec === "ALAC") {
try {
- return new NextResponse(streamFile(song.files[originalCodec]), {
- status: 200,
- headers: {
- "Content-Type": `${audioContentTypeForPath(song.files[originalCodec])}`,
- "Transfer-Encoding": "chunked",
- "Cache-Control": "no-cache",
- },
- })
+ return await streamFileResponse(
+ request,
+ song.files[originalCodec],
+ audioContentTypeForPath(song.files[originalCodec])
+ )
} catch {
return new Response("Server Error", { status: 500 })
}
@@ -168,20 +179,14 @@ export async function GET(
]
try {
- // TODO: Fix seeking for this
const ffmpegProcess = spawn("ffmpeg", ffmpegArgs)
const stream = ffmpegToReadableStream(ffmpegProcess)
- const bytes = (metadata.format.duration! * metadata.format.bitrate!) / 8
return new NextResponse(stream, {
status: 200,
headers: {
- "Content-Type": "audio/mpeg",
- "Transfer-Encoding": "chunked",
+ "Content-Type": "audio/flac",
"Cache-Control": "no-cache",
- "Accept-Ranges": "bytes",
- "Content-Length": `${bytes}`,
- "Content-Range": `bytes 0-${bytes - 1}/${bytes}`,
},
})
} catch {
@@ -200,14 +205,11 @@ export async function GET(
metadata.format.codecProfile
)
try {
- return new NextResponse(streamFile(song.files[originalCodec]), {
- status: 200,
- headers: {
- "Content-Type": `${audioContentTypeForPath(song.files[originalCodec])}`,
- "Transfer-Encoding": "chunked",
- "Cache-Control": "no-cache",
- },
- })
+ return await streamFileResponse(
+ request,
+ song.files[originalCodec],
+ audioContentTypeForPath(song.files[originalCodec])
+ )
} catch {
return new Response("Server Error", { status: 500 })
}
@@ -235,7 +237,6 @@ export async function GET(
status: 200,
headers: {
"Content-Type": "audio/aac",
- "Transfer-Encoding": "chunked",
"Cache-Control": "no-cache",
},
})
diff --git a/components/options-modal.tsx b/components/options-modal.tsx
index 6546115..301acd0 100644
--- a/components/options-modal.tsx
+++ b/components/options-modal.tsx
@@ -719,7 +719,9 @@ function UserRowActions({
function LibrarySection() {
const updateLibrary = useAction(api.actions.updateLibrary)
+ const cleanupHlsStreams = useAction(api.actions.adminCleanupHlsStreams)
const [updating, setUpdating] = useState(false)
+ const [cleaningHls, setCleaningHls] = useState(false)
async function handleUpdateLibrary() {
setUpdating(true)
@@ -735,6 +737,31 @@ function LibrarySection() {
}
}
+ async function handleCleanupHlsStreams() {
+ setCleaningHls(true)
+ try {
+ const result = await cleanupHlsStreams({})
+ toast.success(
+ result.removed === 1
+ ? "Removed 1 idle HLS stream"
+ : `Removed ${result.removed} idle HLS streams`
+ )
+ if (result.failed > 0) {
+ toast.warning(
+ result.failed === 1
+ ? "1 HLS stream could not be removed"
+ : `${result.failed} HLS streams could not be removed`
+ )
+ }
+ } catch (error) {
+ toast.error(
+ error instanceof Error ? error.message : "Failed to clean HLS streams"
+ )
+ } finally {
+ setCleaningHls(false)
+ }
+ }
+
return (
@@ -744,14 +771,25 @@ function LibrarySection() {
-
+
+
+
+
)
}
diff --git a/components/playback-provider.tsx b/components/playback-provider.tsx
index 136f3d7..d1275eb 100644
--- a/components/playback-provider.tsx
+++ b/components/playback-provider.tsx
@@ -2,13 +2,14 @@
import * as React from "react"
import { useConvex, useMutation, useQuery } from "convex/react"
+import Hls from "hls.js"
import { toast } from "sonner"
import { api } from "@/convex/_generated/api"
import type { Id } from "@/convex/_generated/dataModel"
import type { BrowseSong } from "@/convex/library"
import { supportsDolbyAtmosPlayback } from "@/lib/dolby-atmos-support"
-import { songPlayUrl } from "@/lib/song-play-url"
+import { songHlsPlaylistUrl, songPlayUrl } from "@/lib/song-play-url"
type RepeatMode = "none" | "once" | "always"
@@ -110,6 +111,7 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
const user = useQuery(api.auth.currentUser)
const playback = useQuery(api.playback.getPlaybackState)
const audioRef = React.useRef(null)
+ const hlsRef = React.useRef(null)
const loadedSongKeyRef = React.useRef(null)
const playbackErrorHandledRef = React.useRef(false)
const isPlayingRef = React.useRef(false)
@@ -189,6 +191,11 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
}
}, [])
+ const destroyHls = React.useCallback(() => {
+ hlsRef.current?.destroy()
+ hlsRef.current = null
+ }, [])
+
React.useEffect(() => {
const audio = new Audio()
audioRef.current = audio
@@ -207,12 +214,13 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
return () => {
audio.removeEventListener("play", syncPlayingFromAudio)
audio.removeEventListener("pause", syncPlayingFromAudio)
+ destroyHls()
audio.pause()
audio.removeAttribute("src")
audioRef.current = null
loadedSongKeyRef.current = null
}
- }, [])
+ }, [destroyHls])
React.useEffect(() => {
const audio = audioRef.current
@@ -229,6 +237,7 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
}
if (!currentSong) {
+ destroyHls()
audio.pause()
audio.removeAttribute("src")
loadedSongKeyRef.current = null
@@ -241,22 +250,26 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
const preferAtmos =
dolbyAtmosSupported === true && (user.preferAtmos ?? false)
- const loadKey = `${currentSong.id}:${preferAtmos}:${user.playbackQuality ?? "medium"}`
+ const playbackQuality = user.playbackQuality ?? "medium"
+ const useHls = playbackQuality !== "lossless" && !preferAtmos
+ const loadKey = `${currentSong.id}:${preferAtmos}:${playbackQuality}:${useHls ? "hls" : "file"}`
if (loadedSongKeyRef.current === loadKey) {
return
}
- const url = songPlayUrl(
+ const directUrl = songPlayUrl(
currentSong.id,
- user.playbackQuality ?? "medium",
+ playbackQuality,
preferAtmos
)
+ const hlsUrl = songHlsPlaylistUrl(currentSong.id, playbackQuality, preferAtmos)
playbackErrorHandledRef.current = false
runWithoutAudioSync(() => {
audio.pause()
})
+ destroyHls()
const onCanPlay = () => {
audio.removeEventListener("canplay", onCanPlay)
@@ -268,8 +281,18 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
}
audio.addEventListener("canplay", onCanPlay)
- audio.src = url
- audio.load()
+ if (useHls && audio.canPlayType("application/vnd.apple.mpegurl")) {
+ audio.src = hlsUrl
+ audio.load()
+ } else if (useHls && Hls.isSupported()) {
+ const hls = new Hls()
+ hlsRef.current = hls
+ hls.loadSource(hlsUrl)
+ hls.attachMedia(audio)
+ } else {
+ audio.src = directUrl
+ audio.load()
+ }
loadedSongKeyRef.current = loadKey
return () => {
@@ -282,6 +305,7 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
user?.preferAtmos,
dolbyAtmosSupported,
runWithoutAudioSync,
+ destroyHls,
])
React.useEffect(() => {
@@ -349,6 +373,7 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
}
audio.pause()
+ destroyHls()
audio.removeAttribute("src")
loadedSongKeyRef.current = null
setIsPlaying(false)
@@ -366,7 +391,7 @@ export function PlaybackProvider({ children }: { children: React.ReactNode }) {
audio.removeEventListener("ended", handleEnded)
audio.removeEventListener("error", handleError)
}
- }, [repeatEnabled, currentSong, skipNextMutation, clearQueueMutation])
+ }, [repeatEnabled, currentSong, skipNextMutation, clearQueueMutation, destroyHls])
React.useEffect(() => {
const audio = audioRef.current
diff --git a/convex/actions.ts b/convex/actions.ts
index 6cc8347..0f1f93b 100644
--- a/convex/actions.ts
+++ b/convex/actions.ts
@@ -5,6 +5,9 @@ import { api } from "@/convex/_generated/api"
import * as fs from "node:fs/promises"
import * as fsSync from "node:fs"
import * as music from "music-metadata"
+import * as os from "node:os"
+import * as path from "node:path"
+import { ConvexError } from "convex/values"
import type { Id } from "./_generated/dataModel"
import { action, type ActionCtx } from "./_generated/server"
@@ -12,6 +15,48 @@ import { action, type ActionCtx } from "./_generated/server"
const DATA_DIR = process.env.CONVEX_SITE_URL?.includes("127.0.0.1")
? "/Volumes/FastStorage/Apple Music"
: process.env.DATA || "/data"
+const HLS_CACHE_DIR = path.join(os.tmpdir(), "../otunes-hls")
+const HLS_MAX_IDLE_MS = 30 * 60 * 1000
+
+async function cleanHlsStreamsOlderThan(maxIdleMs: number) {
+ const now = Date.now()
+ let checked = 0
+ let removed = 0
+ let failed = 0
+ console.log(os.tmpdir())
+ console.log(HLS_CACHE_DIR)
+
+ let entries: fsSync.Dirent[] = []
+ try {
+ entries = await fs.readdir(HLS_CACHE_DIR, { withFileTypes: true })
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+ throw error
+ }
+ }
+
+ for (const entry of entries) {
+ if (!entry.isDirectory()) {
+ continue
+ }
+
+ checked += 1
+ const entryPath = path.join(HLS_CACHE_DIR, entry.name)
+ try {
+ const stat = await fs.stat(entryPath)
+ if (now - stat.mtimeMs <= maxIdleMs) {
+ continue
+ }
+
+ await fs.rm(entryPath, { recursive: true, force: true })
+ removed += 1
+ } catch {
+ failed += 1
+ }
+ }
+
+ return { checked, removed, failed }
+}
async function coverPathIfExists(path: string): Promise {
return fs
@@ -492,3 +537,22 @@ export const updateLibrary = action({
return "success"
},
})
+
+export const cleanupHlsStreams = action({
+ args: {},
+ handler: async () => {
+ return await cleanHlsStreamsOlderThan(HLS_MAX_IDLE_MS)
+ },
+})
+
+export const adminCleanupHlsStreams = action({
+ args: {},
+ handler: async (ctx) => {
+ const user = await ctx.runQuery(api.auth.currentUser)
+ if (!user?.isAdmin) {
+ throw new ConvexError("Not authorized")
+ }
+
+ return await cleanHlsStreamsOlderThan(HLS_MAX_IDLE_MS)
+ },
+})
diff --git a/convex/crons.ts b/convex/crons.ts
index cce8411..604dfea 100644
--- a/convex/crons.ts
+++ b/convex/crons.ts
@@ -9,4 +9,10 @@ crons.interval(
api.actions.updateLibrary
)
+crons.interval(
+ "cleanup idle hls streams",
+ { minutes: 15 },
+ api.actions.cleanupHlsStreams
+)
+
export default crons
diff --git a/lib/server-audio-stream.ts b/lib/server-audio-stream.ts
new file mode 100644
index 0000000..f1c9d8b
--- /dev/null
+++ b/lib/server-audio-stream.ts
@@ -0,0 +1,96 @@
+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")
+ },
+ })
+}
diff --git a/lib/server-hls.ts b/lib/server-hls.ts
new file mode 100644
index 0000000..e166aed
--- /dev/null
+++ b/lib/server-hls.ts
@@ -0,0 +1,187 @@
+import type { Doc } from "@/convex/_generated/dataModel"
+import crypto from "node:crypto"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { spawn } from "node:child_process"
+import * as music from "music-metadata"
+
+export const HLS_SEGMENT_SECONDS = 6
+
+type HlsJob = {
+ dir: string
+ duration: number
+ segmentCount: number
+ startedAt: number
+ processExited: boolean
+ processExitCode: number | null
+}
+
+const jobs = new Map()
+
+export function qualityKbps(quality: string | null) {
+ if (quality === "low") {
+ return 64
+ }
+
+ if (quality === "high") {
+ return 256
+ }
+
+ return 128
+}
+
+export function selectHlsSourceCodec(
+ song: Doc<"songs">,
+ quality: string | null,
+ preferAtmos: boolean
+) {
+ let sourceCodec = "lossless" in song.files ? "lossless" : "normal"
+ if (preferAtmos && "atmos" in song.files) {
+ sourceCodec = "atmos"
+ } else if (quality === "high" && "normal" in song.files) {
+ sourceCodec = "normal"
+ }
+
+ return sourceCodec
+}
+
+function hlsCacheRoot() {
+ return path.join(os.tmpdir(), "otunes-hls")
+}
+
+async function hlsJobKey(
+ song: Doc<"songs">,
+ sourcePath: string,
+ kbps: number
+) {
+ const stat = await fs.stat(sourcePath)
+ return crypto
+ .createHash("sha256")
+ .update(song._id)
+ .update("\0")
+ .update(sourcePath)
+ .update("\0")
+ .update(String(stat.size))
+ .update("\0")
+ .update(String(stat.mtimeMs))
+ .update("\0")
+ .update(String(kbps))
+ .digest("hex")
+}
+
+export function hlsSegmentPath(job: HlsJob, segmentIndex: number) {
+ return path.join(job.dir, `segment_${segmentIndex.toString().padStart(5, "0")}.ts`)
+}
+
+async function touchHlsJob(job: HlsJob) {
+ const now = new Date()
+ await fs.utimes(job.dir, now, now).catch(() => {})
+}
+
+export async function waitForHlsSegment(
+ job: HlsJob,
+ segmentIndex: number,
+ timeoutMs = 30000
+) {
+ await touchHlsJob(job)
+ const segmentPath = hlsSegmentPath(job, segmentIndex)
+ const startedAt = Date.now()
+
+ while (Date.now() - startedAt < timeoutMs) {
+ try {
+ const firstStat = await fs.stat(segmentPath)
+ if (firstStat.size > 0) {
+ await new Promise((resolve) => setTimeout(resolve, 100))
+ const secondStat = await fs.stat(segmentPath)
+ if (firstStat.size === secondStat.size) {
+ return segmentPath
+ }
+ }
+ } catch {
+ if (job.processExited && job.processExitCode !== 0) {
+ throw new Error(`HLS transcode failed with code ${job.processExitCode}`)
+ }
+ }
+ await new Promise((resolve) => setTimeout(resolve, 100))
+ }
+
+ throw new Error("Timed out waiting for HLS segment")
+}
+
+export async function ensureHlsJob(
+ song: Doc<"songs">,
+ quality: string | null,
+ preferAtmos: boolean
+) {
+ const kbps = qualityKbps(quality)
+ const sourceCodec = selectHlsSourceCodec(song, quality, preferAtmos)
+ const sourcePath = song.files[sourceCodec]
+ const key = await hlsJobKey(song, sourcePath, kbps)
+ const existingJob = jobs.get(key)
+
+ if (existingJob) {
+ await touchHlsJob(existingJob)
+ return existingJob
+ }
+
+ const metadata = await music.parseFile(sourcePath)
+ const duration = metadata.format.duration ?? song.length
+ const segmentCount = Math.max(1, Math.ceil(duration / HLS_SEGMENT_SECONDS))
+ const dir = path.join(hlsCacheRoot(), key)
+ await fs.mkdir(dir, { recursive: true })
+
+ const job: HlsJob = {
+ dir,
+ duration,
+ segmentCount,
+ startedAt: Date.now(),
+ processExited: false,
+ processExitCode: null,
+ }
+ jobs.set(key, job)
+ await touchHlsJob(job)
+
+ const ffmpegArgs = [
+ "-nostdin",
+ "-i",
+ sourcePath,
+ "-vn",
+ "-c:a",
+ "aac",
+ "-b:a",
+ `${kbps}k`,
+ "-ac",
+ "2",
+ "-f",
+ "hls",
+ "-hls_time",
+ String(HLS_SEGMENT_SECONDS),
+ "-hls_playlist_type",
+ "vod",
+ "-hls_list_size",
+ "0",
+ "-hls_segment_type",
+ "mpegts",
+ "-hls_segment_filename",
+ path.join(dir, "segment_%05d.ts"),
+ path.join(dir, "index.m3u8"),
+ ]
+ const ffmpegProcess = spawn("ffmpeg", ffmpegArgs)
+
+ ffmpegProcess.stderr.on("data", (data) => {
+ console.error(`FFmpeg HLS log: ${data.toString()}`)
+ })
+
+ ffmpegProcess.on("close", (code) => {
+ job.processExited = true
+ job.processExitCode = code
+ })
+
+ ffmpegProcess.on("error", () => {
+ job.processExited = true
+ job.processExitCode = 1
+ })
+
+ return job
+}
diff --git a/lib/song-play-url.ts b/lib/song-play-url.ts
index 5a1b67c..a61c00e 100644
--- a/lib/song-play-url.ts
+++ b/lib/song-play-url.ts
@@ -15,3 +15,19 @@ export function songPlayUrl(
const query = params.toString()
return `/api/song/${songId}/play${query ? `?${query}` : ""}`
}
+
+export function songHlsPlaylistUrl(
+ songId: string,
+ quality: PlaybackQuality | undefined,
+ preferAtmos: boolean | undefined
+) {
+ const params = new URLSearchParams()
+ if (quality) {
+ params.set("quality", quality)
+ }
+ if (preferAtmos) {
+ params.set("preferAtmos", "true")
+ }
+ const query = params.toString()
+ return `/api/song/${songId}/play/hls${query ? `?${query}` : ""}`
+}
diff --git a/package-lock.json b/package-lock.json
index 4fa6bbd..abde3e5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -17,6 +17,7 @@
"convex": "^1.40.0",
"date-fns": "^4.4.0",
"embla-carousel-react": "^8.6.0",
+ "hls.js": "^1.6.16",
"input-otp": "^1.4.2",
"lucide-react": "^1.17.0",
"music-metadata": "11.12.3",
@@ -8394,6 +8395,12 @@
"hermes-estree": "0.25.1"
}
},
+ "node_modules/hls.js": {
+ "version": "1.6.16",
+ "resolved": "https://registry.npmjs.org/hls.js/-/hls.js-1.6.16.tgz",
+ "integrity": "sha512-VSIRpLfRwlAAdGL4wiTucx2ScRipo0ed1FBatWkyt832jC4CReKstga6yIhYVwGu9LOBjuX9wzmRMeQdBJtzEA==",
+ "license": "Apache-2.0"
+ },
"node_modules/hono": {
"version": "4.12.23",
"resolved": "https://registry.npmjs.org/hono/-/hono-4.12.23.tgz",
diff --git a/package.json b/package.json
index 13d17e1..015613d 100644
--- a/package.json
+++ b/package.json
@@ -21,6 +21,7 @@
"convex": "^1.40.0",
"date-fns": "^4.4.0",
"embla-carousel-react": "^8.6.0",
+ "hls.js": "1.6.16",
"input-otp": "^1.4.2",
"lucide-react": "^1.17.0",
"music-metadata": "11.12.3",