feat: store, search, and show song lyrics
Reads lyrics tags (plain, LRC, word-timed LRC) during library scans and backfills songs scanned before. Search matches lyric lines, and the players show synced lyrics on web, phone, and tablet. Downloaded songs read lyrics from their own file. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
ed99c96f21
commit
7c7217a02e
29 files changed
+1621
-81
No files matched your search
@@ -1,5 +1,8 @@
|
||||
import { useTabletLayout } from "@/hooks/use-tablet-layout"
|
||||
import { TabletNowPlaying } from "@/components/tablet-now-playing"
|
||||
import {
|
||||
TabletNowPlaying,
|
||||
type PlayerPanel,
|
||||
} from "@/components/tablet-now-playing"
|
||||
import { atmosEnabled } from "@/lib/playback-capabilities"
|
||||
import { NavigationBar } from "expo-navigation-bar"
|
||||
import { MusicEntityView } from "@/components/music-entity-view"
|
||||
@@ -51,7 +54,9 @@ import { PlayerSymbol } from "@/components/player-symbol"
|
||||
import { useFavorites } from "@/contexts/favorites"
|
||||
import { usePlaybackActions, usePlaybackQueue } from "@/contexts/playback"
|
||||
import { useServerConfig } from "@/contexts/server-config"
|
||||
import { LyricsView } from "@/components/lyrics-view"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
import { useLyrics } from "@/hooks/use-lyrics"
|
||||
import { useCoverPalette } from "@/hooks/use-cover-palette"
|
||||
import { useMediaMenuActions } from "@/hooks/use-media-menu-actions"
|
||||
import { useSystemVolume } from "@/hooks/use-system-volume"
|
||||
@@ -93,8 +98,14 @@ export default function PlayerScreen() {
|
||||
queueSongIds,
|
||||
} = usePlaybackQueue()
|
||||
const { setIsPlaying, skipNext, skipPrevious } = usePlaybackActions()
|
||||
const { queue } = useLocalSearchParams<{ queue?: string }>()
|
||||
const [showQueue, setShowQueue] = useState(queue === "1")
|
||||
const params = useLocalSearchParams<{ queue?: string; lyrics?: string }>()
|
||||
// The queue or lyrics, shown in place of the artwork.
|
||||
const [panel, setPanel] = useState<PlayerPanel | null>(
|
||||
params.queue === "1" ? "queue" : params.lyrics === "1" ? "lyrics" : null
|
||||
)
|
||||
const showQueue = panel === "queue"
|
||||
const showLyrics = panel === "lyrics"
|
||||
const lyrics = useLyrics(currentSong?.id ?? null)
|
||||
const [isDismissing, setIsDismissing] = useState(false)
|
||||
const [stageHeight, setStageHeight] = useState(0)
|
||||
const user = useCachedQuery(api.auth.currentUser)
|
||||
@@ -187,8 +198,8 @@ export default function PlayerScreen() {
|
||||
const handleGesture = useMemo(makeDismissGesture, [makeDismissGesture])
|
||||
const controlsGesture = useMemo(makeDismissGesture, [makeDismissGesture])
|
||||
const stageGesture = useMemo(
|
||||
() => makeDismissGesture().enabled(!showQueue),
|
||||
[makeDismissGesture, showQueue]
|
||||
() => makeDismissGesture().enabled(panel === null),
|
||||
[makeDismissGesture, panel]
|
||||
)
|
||||
|
||||
const hasCover = currentSong ? currentSong.album.cover != null : false
|
||||
@@ -243,9 +254,9 @@ export default function PlayerScreen() {
|
||||
setIsPlaying(!isPlaying)
|
||||
}
|
||||
|
||||
function toggleQueue() {
|
||||
function togglePanel(next: PlayerPanel) {
|
||||
void Haptics.selectionAsync()
|
||||
setShowQueue((value) => !value)
|
||||
setPanel((value) => (value === next ? null : next))
|
||||
}
|
||||
|
||||
if (isTablet) {
|
||||
@@ -256,8 +267,9 @@ export default function PlayerScreen() {
|
||||
backgroundStyle={backgroundStyle}
|
||||
dismissStyle={dismissStyle}
|
||||
dismissGestures={{ handle: handleGesture, artwork: controlsGesture }}
|
||||
showQueue={showQueue}
|
||||
toggleQueue={toggleQueue}
|
||||
panel={panel}
|
||||
togglePanel={togglePanel}
|
||||
lyrics={lyrics}
|
||||
metadata={songMeta}
|
||||
/>
|
||||
</MusicEntityView>
|
||||
@@ -322,6 +334,20 @@ export default function PlayerScreen() {
|
||||
/>
|
||||
</Animated.View>
|
||||
) : null
|
||||
) : showLyrics ? (
|
||||
<Animated.View
|
||||
key="lyrics"
|
||||
entering={MODE_FADE_IN}
|
||||
exiting={MODE_FADE_OUT}
|
||||
style={[styles.fill, styles.artworkMode]}
|
||||
>
|
||||
{queueHeader}
|
||||
<LyricsView
|
||||
key={currentSong.id}
|
||||
lyrics={lyrics}
|
||||
colors={colors}
|
||||
/>
|
||||
</Animated.View>
|
||||
) : (
|
||||
<Animated.View
|
||||
key="artwork"
|
||||
@@ -409,18 +435,29 @@ export default function PlayerScreen() {
|
||||
|
||||
<View style={styles.footer}>
|
||||
<Pressable
|
||||
disabled
|
||||
onPress={() => togglePanel("lyrics")}
|
||||
disabled={!lyrics && !showLyrics}
|
||||
hitSlop={8}
|
||||
accessibilityRole="button"
|
||||
accessibilityLabel="Lyrics"
|
||||
accessibilityState={{ disabled: true }}
|
||||
style={[styles.queueButton, styles.unavailable]}
|
||||
accessibilityLabel={showLyrics ? "Hide lyrics" : "Show lyrics"}
|
||||
accessibilityState={{
|
||||
selected: showLyrics,
|
||||
disabled: !lyrics && !showLyrics,
|
||||
}}
|
||||
style={[
|
||||
styles.queueButton,
|
||||
!lyrics && !showLyrics && styles.unavailable,
|
||||
showLyrics && { backgroundColor: colors.selected },
|
||||
]}
|
||||
>
|
||||
<PlayerSymbol
|
||||
name="quote.bubble"
|
||||
fallback={{ material: "lyrics" }}
|
||||
size={27}
|
||||
weight="semibold"
|
||||
color={colors.foreground}
|
||||
color={
|
||||
showLyrics ? colors.selectedForeground : colors.foreground
|
||||
}
|
||||
/>
|
||||
</Pressable>
|
||||
<AudioOutputButton
|
||||
@@ -428,7 +465,7 @@ export default function PlayerScreen() {
|
||||
style={styles.queueButton}
|
||||
/>
|
||||
<Pressable
|
||||
onPress={toggleQueue}
|
||||
onPress={() => togglePanel("queue")}
|
||||
hitSlop={8}
|
||||
accessibilityRole="button"
|
||||
accessibilityLabel={showQueue ? "Hide queue" : "Show queue"}
|
||||
|
||||
@@ -0,0 +1,243 @@
|
||||
import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
|
||||
import {
|
||||
Pressable,
|
||||
ScrollView,
|
||||
StyleSheet,
|
||||
Text,
|
||||
View,
|
||||
type ScrollViewInstance,
|
||||
} from "react-native"
|
||||
|
||||
import {
|
||||
usePlaybackActions,
|
||||
usePlaybackProgress,
|
||||
usePlaybackQueue,
|
||||
} from "@/contexts/playback"
|
||||
import { useLyricsTime } from "@/hooks/use-lyrics"
|
||||
import type { NowPlayingColors } from "@/lib/now-playing-colors"
|
||||
import {
|
||||
activeLineIndex,
|
||||
type LyricLine,
|
||||
type Lyrics,
|
||||
} from "@otunes/convex/client/lyrics"
|
||||
|
||||
/** How long a manual scroll keeps the view from following the song. */
|
||||
const MANUAL_SCROLL_HOLD_MS = 3000
|
||||
/** Where the playing line sits, as a share of the view's height from the top. */
|
||||
const ACTIVE_LINE_POSITION = 0.12
|
||||
|
||||
/**
|
||||
* Lyrics in the player's own colors. Synced lines follow playback and seek
|
||||
* when tapped; `null` lyrics show a short note instead.
|
||||
*/
|
||||
export function LyricsView({
|
||||
lyrics,
|
||||
colors,
|
||||
fontSize = 30,
|
||||
}: {
|
||||
lyrics: Lyrics | null | undefined
|
||||
colors: NowPlayingColors
|
||||
fontSize?: number
|
||||
}) {
|
||||
if (lyrics === undefined) return null
|
||||
if (lyrics === null) {
|
||||
return (
|
||||
<View style={styles.empty}>
|
||||
<Text style={[styles.emptyText, { color: colors.secondaryForeground }]}>
|
||||
No lyrics
|
||||
</Text>
|
||||
</View>
|
||||
)
|
||||
}
|
||||
return <LyricsLines lyrics={lyrics} colors={colors} fontSize={fontSize} />
|
||||
}
|
||||
|
||||
function LyricsLines({
|
||||
lyrics,
|
||||
colors,
|
||||
fontSize,
|
||||
}: {
|
||||
lyrics: Lyrics
|
||||
colors: NowPlayingColors
|
||||
fontSize: number
|
||||
}) {
|
||||
const { currentTime } = usePlaybackProgress()
|
||||
const { isPlaying } = usePlaybackQueue()
|
||||
const { seekTo, setIsPlaying } = usePlaybackActions()
|
||||
const time = useLyricsTime(lyrics, currentTime, isPlaying)
|
||||
const active = activeLineIndex(lyrics, time)
|
||||
const synced = lyrics.synced !== "none"
|
||||
const scrollRef = useRef<ScrollViewInstance>(null)
|
||||
const lineOffsets = useRef<number[]>([])
|
||||
const [height, setHeight] = useState(0)
|
||||
const manualScrollAt = useRef(0)
|
||||
|
||||
const scrollToLine = useCallback(
|
||||
(index: number) => {
|
||||
const y = lineOffsets.current[Math.max(index, 0)]
|
||||
if (y === undefined || !synced || height === 0) return
|
||||
if (Date.now() - manualScrollAt.current < MANUAL_SCROLL_HOLD_MS) return
|
||||
scrollRef.current?.scrollTo({
|
||||
y: Math.max(0, y - height * ACTIVE_LINE_POSITION),
|
||||
animated: true,
|
||||
})
|
||||
},
|
||||
[height, synced]
|
||||
)
|
||||
|
||||
useEffect(() => {
|
||||
scrollToLine(active)
|
||||
}, [active, scrollToLine])
|
||||
|
||||
const activeRef = useRef(active)
|
||||
useEffect(() => {
|
||||
activeRef.current = active
|
||||
}, [active])
|
||||
const handleLineLayout = useCallback(
|
||||
(index: number, y: number) => {
|
||||
lineOffsets.current[index] = y
|
||||
// Opening mid-song: jump once the playing line has been measured.
|
||||
if (index === Math.max(activeRef.current, 0)) scrollToLine(index)
|
||||
},
|
||||
[scrollToLine]
|
||||
)
|
||||
|
||||
const playFrom = useCallback(
|
||||
(seconds: number) => {
|
||||
seekTo(seconds)
|
||||
setIsPlaying(true)
|
||||
manualScrollAt.current = 0
|
||||
},
|
||||
[seekTo, setIsPlaying]
|
||||
)
|
||||
|
||||
const lineStyle = useMemo(
|
||||
() => ({ fontSize, lineHeight: Math.round(fontSize * 1.18) }),
|
||||
[fontSize]
|
||||
)
|
||||
|
||||
return (
|
||||
<ScrollView
|
||||
ref={scrollRef}
|
||||
style={styles.fill}
|
||||
contentContainerStyle={{
|
||||
paddingTop: height * ACTIVE_LINE_POSITION,
|
||||
paddingBottom: height * 0.7,
|
||||
}}
|
||||
showsVerticalScrollIndicator={false}
|
||||
onLayout={(event) => setHeight(event.nativeEvent.layout.height)}
|
||||
onScrollBeginDrag={() => {
|
||||
manualScrollAt.current = Date.now()
|
||||
}}
|
||||
onMomentumScrollEnd={() => {
|
||||
// Hold from when the scroll settles, not when the finger lifted.
|
||||
if (manualScrollAt.current > 0) manualScrollAt.current = Date.now()
|
||||
}}
|
||||
>
|
||||
{lyrics.lines.map((line, index) =>
|
||||
synced ? (
|
||||
<SyncedLine
|
||||
key={index}
|
||||
index={index}
|
||||
line={line}
|
||||
state={
|
||||
index === active ? "active" : index < active ? "past" : "next"
|
||||
}
|
||||
time={index === active ? time : null}
|
||||
colors={colors}
|
||||
textStyle={lineStyle}
|
||||
onSelect={playFrom}
|
||||
onLayoutY={handleLineLayout}
|
||||
/>
|
||||
) : (
|
||||
<Text
|
||||
key={index}
|
||||
style={[
|
||||
styles.plainLine,
|
||||
{
|
||||
color: colors.foreground,
|
||||
fontSize: fontSize * 0.75,
|
||||
lineHeight: Math.round(fontSize * 0.75 * 1.25),
|
||||
},
|
||||
line.text === "" && styles.stanzaGap,
|
||||
]}
|
||||
>
|
||||
{line.text}
|
||||
</Text>
|
||||
)
|
||||
)}
|
||||
</ScrollView>
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* One timed line. Only the playing line gets the time, so the others skip
|
||||
* re-rendering as the song plays.
|
||||
*/
|
||||
const SyncedLine = memo(function SyncedLine({
|
||||
index,
|
||||
line,
|
||||
state,
|
||||
time,
|
||||
colors,
|
||||
textStyle,
|
||||
onSelect,
|
||||
onLayoutY,
|
||||
}: {
|
||||
index: number
|
||||
line: LyricLine
|
||||
state: "past" | "active" | "next"
|
||||
time: number | null
|
||||
colors: NowPlayingColors
|
||||
textStyle: { fontSize: number; lineHeight: number }
|
||||
onSelect: (seconds: number) => void
|
||||
onLayoutY: (index: number, y: number) => void
|
||||
}) {
|
||||
const active = state === "active"
|
||||
return (
|
||||
<Pressable
|
||||
onPress={() => onSelect(line.start ?? 0)}
|
||||
onLayout={(event) => onLayoutY(index, event.nativeEvent.layout.y)}
|
||||
accessibilityRole="button"
|
||||
accessibilityHint="Plays from this line"
|
||||
style={styles.line}
|
||||
>
|
||||
<Text
|
||||
style={[
|
||||
styles.lineText,
|
||||
textStyle,
|
||||
{
|
||||
color:
|
||||
active && !line.words ? colors.foreground : colors.lyricsInactive,
|
||||
},
|
||||
]}
|
||||
>
|
||||
{active && line.words
|
||||
? line.words.map((word, wordIndex) => (
|
||||
<Text
|
||||
key={wordIndex}
|
||||
style={{
|
||||
color:
|
||||
time !== null && time >= word.start
|
||||
? colors.foreground
|
||||
: colors.lyricsUnsung,
|
||||
}}
|
||||
>
|
||||
{word.text}
|
||||
</Text>
|
||||
))
|
||||
: line.text}
|
||||
</Text>
|
||||
</Pressable>
|
||||
)
|
||||
})
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
fill: { flex: 1 },
|
||||
empty: { flex: 1, alignItems: "center", justifyContent: "center" },
|
||||
emptyText: { fontSize: 17, fontWeight: "600" },
|
||||
line: { paddingVertical: 9 },
|
||||
lineText: { fontWeight: "800" },
|
||||
plainLine: { fontWeight: "700", paddingVertical: 2 },
|
||||
stanzaGap: { height: 18 },
|
||||
})
|
||||
@@ -10,7 +10,7 @@ import {
|
||||
} from "@/contexts/downloads"
|
||||
import type { DownloadSource } from "@otunes/convex/client/download-queue"
|
||||
import { useServerConfig } from "@/contexts/server-config"
|
||||
import type { BrowseSong } from "@otunes/convex/types"
|
||||
import type { BrowseSong, SearchSong } from "@otunes/convex/types"
|
||||
import type { CoverPalette } from "@/lib/cover-palette"
|
||||
import { formatDuration } from "@/lib/format"
|
||||
import { albumCoverUrl } from "@/lib/urls"
|
||||
@@ -41,7 +41,8 @@ export const SongRow = memo(function SongRow({
|
||||
swipe,
|
||||
downloadFrom,
|
||||
}: {
|
||||
song: BrowseSong
|
||||
/** Search results also show the lyrics line they matched. */
|
||||
song: SearchSong
|
||||
onPress?: () => void
|
||||
contextMenu?: Omit<MediaMenuConfig, "onAction"> & {
|
||||
onAction: MediaMenuConfig["onAction"]
|
||||
@@ -87,6 +88,14 @@ export const SongRow = memo(function SongRow({
|
||||
>
|
||||
{song.artist.name} · {song.album.title}
|
||||
</Text>
|
||||
{song.lyricsSnippet ? (
|
||||
<Text
|
||||
style={[styles.rowSubtitle, { color: secondaryForeground }]}
|
||||
numberOfLines={1}
|
||||
>
|
||||
Lyrics: “{song.lyricsSnippet}”
|
||||
</Text>
|
||||
) : null}
|
||||
</View>
|
||||
{downloaded || downloadState === "device" ? (
|
||||
<Ionicons
|
||||
@@ -181,7 +190,7 @@ export const SongListRow = memo(function SongListRow({
|
||||
onPlay,
|
||||
onAction,
|
||||
}: {
|
||||
song: BrowseSong
|
||||
song: SearchSong
|
||||
favorited: boolean
|
||||
playlistLabel?: string
|
||||
palette?: Pick<CoverPalette, "foreground" | "secondaryForeground" | "divider">
|
||||
|
||||
@@ -2,16 +2,23 @@ import { useCallback, useMemo } from "react"
|
||||
import { Platform } from "react-native"
|
||||
import { Stack } from "expo-router"
|
||||
|
||||
import { useQuery } from "convex/react"
|
||||
|
||||
import { useDebouncedSearch } from "@/hooks/use-debounced-search"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import { useThemeColors } from "@/lib/theme"
|
||||
import { filterSongs } from "@otunes/convex/client/song-search"
|
||||
import type { BrowseSong } from "@otunes/convex/types"
|
||||
|
||||
export function usePlaylistSearch(songs: BrowseSong[]) {
|
||||
const search = useDebouncedSearch()
|
||||
const lyricsMatches = useQuery(
|
||||
api.lyrics.matchingSongIds,
|
||||
search.searchQuery.trim() ? { query: search.searchQuery } : "skip"
|
||||
)
|
||||
const filteredSongs = useMemo(
|
||||
() => filterSongs(songs, search.searchQuery),
|
||||
[songs, search.searchQuery]
|
||||
() => filterSongs(songs, search.searchQuery, lyricsMatches),
|
||||
[songs, search.searchQuery, lyricsMatches]
|
||||
)
|
||||
|
||||
return { ...search, filteredSongs }
|
||||
|
||||
@@ -16,7 +16,7 @@ import { usePlaybackActions } from "@/contexts/playback"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
import { useMediaMenuActions } from "@/hooks/use-media-menu-actions"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { BrowseSong } from "@otunes/convex/types"
|
||||
import type { BrowseSong, SearchSong } from "@otunes/convex/types"
|
||||
import { spacing, useThemeColors } from "@/lib/theme"
|
||||
|
||||
function SearchResultsBody({ searchQuery }: { searchQuery: string }) {
|
||||
@@ -64,7 +64,7 @@ function SearchResultsBody({ searchQuery }: { searchQuery: string }) {
|
||||
[handleSongAction]
|
||||
)
|
||||
const renderItem = useCallback(
|
||||
({ item: song }: ListRenderItemInfo<BrowseSong>) => (
|
||||
({ item: song }: ListRenderItemInfo<SearchSong>) => (
|
||||
<SongListRow
|
||||
song={song}
|
||||
favorited={isSongFavorite(song.id)}
|
||||
|
||||
@@ -23,6 +23,7 @@ import { PlayerSymbol } from "@/components/player-symbol"
|
||||
import { useFavorites } from "@/contexts/favorites"
|
||||
import { usePlaybackActions, usePlaybackQueue } from "@/contexts/playback"
|
||||
import { useServerConfig } from "@/contexts/server-config"
|
||||
import { useLyrics } from "@/hooks/use-lyrics"
|
||||
import { useMediaMenuActions } from "@/hooks/use-media-menu-actions"
|
||||
import { tabletMiniPlayerHeight } from "@/lib/theme"
|
||||
import { albumCoverUrl } from "@/lib/urls"
|
||||
@@ -58,6 +59,7 @@ export function TabletMiniPlayer() {
|
||||
const { handleSongAction } = useMediaMenuActions()
|
||||
const { isSongFavorite } = useFavorites()
|
||||
const roomy = width - insets.left - insets.right >= 650
|
||||
const lyrics = useLyrics(roomy ? (currentSong?.id ?? null) : null)
|
||||
|
||||
if (!focused || !config || !currentSong || queueSongIds.length === 0)
|
||||
return null
|
||||
@@ -166,16 +168,22 @@ export function TabletMiniPlayer() {
|
||||
{roomy ? (
|
||||
<Pressable
|
||||
style={styles.control}
|
||||
disabled
|
||||
disabled={!lyrics}
|
||||
onPress={() =>
|
||||
router.push({
|
||||
pathname: "/(app)/player",
|
||||
params: { lyrics: "1" },
|
||||
})
|
||||
}
|
||||
accessibilityRole="button"
|
||||
accessibilityLabel="Lyrics"
|
||||
accessibilityState={{ disabled: true }}
|
||||
accessibilityLabel="Show lyrics"
|
||||
accessibilityState={{ disabled: !lyrics }}
|
||||
>
|
||||
<PlayerSymbol
|
||||
name="quote.bubble"
|
||||
fallback="chatbox-outline"
|
||||
size={23}
|
||||
color={inactive}
|
||||
color={lyrics ? color : inactive}
|
||||
/>
|
||||
</Pressable>
|
||||
) : null}
|
||||
|
||||
@@ -15,6 +15,7 @@ import { StatusBar } from "expo-status-bar"
|
||||
|
||||
import { AudioOutputButton } from "@/components/audio-output-button"
|
||||
import { CoverImage } from "@/components/cover-image"
|
||||
import { LyricsView } from "@/components/lyrics-view"
|
||||
import { NowPlayingQueue } from "@/components/now-playing-queue"
|
||||
import { PlayerProgress } from "@/components/player-progress"
|
||||
import { PlayerSlider } from "@/components/player-slider"
|
||||
@@ -24,6 +25,10 @@ import { useServerConfig } from "@/contexts/server-config"
|
||||
import { useSystemVolume } from "@/hooks/use-system-volume"
|
||||
import type { NowPlayingColors } from "@/lib/now-playing-colors"
|
||||
import { albumCoverUrl } from "@/lib/urls"
|
||||
import type { Lyrics } from "@otunes/convex/client/lyrics"
|
||||
|
||||
/** What the Now Playing screen shows beside or instead of the artwork. */
|
||||
export type PlayerPanel = "queue" | "lyrics"
|
||||
|
||||
const queueMotion = {
|
||||
duration: 420,
|
||||
@@ -31,14 +36,18 @@ const queueMotion = {
|
||||
reduceMotion: ReduceMotion.System,
|
||||
}
|
||||
|
||||
/** Tablet player keeps transport controls visible while the queue opens beside them. */
|
||||
/**
|
||||
* Tablet player keeps transport controls visible while the queue or lyrics
|
||||
* open beside them.
|
||||
*/
|
||||
export function TabletNowPlaying({
|
||||
colors,
|
||||
backgroundStyle,
|
||||
dismissStyle,
|
||||
dismissGestures,
|
||||
showQueue,
|
||||
toggleQueue,
|
||||
panel,
|
||||
togglePanel,
|
||||
lyrics,
|
||||
metadata,
|
||||
}: {
|
||||
colors: NowPlayingColors
|
||||
@@ -48,8 +57,9 @@ export function TabletNowPlaying({
|
||||
handle: ReturnType<typeof Gesture.Pan>
|
||||
artwork: ReturnType<typeof Gesture.Pan>
|
||||
}
|
||||
showQueue: boolean
|
||||
toggleQueue: () => void
|
||||
panel: PlayerPanel | null
|
||||
togglePanel: (panel: PlayerPanel) => void
|
||||
lyrics: Lyrics | null | undefined
|
||||
metadata: ReactNode
|
||||
}) {
|
||||
const router = useRouter()
|
||||
@@ -63,7 +73,9 @@ export function TabletNowPlaying({
|
||||
const { volume, setVolume, available: volumeAvailable } = useSystemVolume()
|
||||
const [queueHeight, setQueueHeight] = useState(0)
|
||||
const wideLayout = width >= 700
|
||||
const sideBySide = showQueue && wideLayout
|
||||
const showQueue = panel === "queue"
|
||||
const showLyrics = panel === "lyrics"
|
||||
const sideBySide = panel !== null && wideLayout
|
||||
const progress = useSharedValue(sideBySide ? 1 : 0)
|
||||
useEffect(() => {
|
||||
progress.value = withTiming(sideBySide ? 1 : 0, queueMotion)
|
||||
@@ -124,7 +136,14 @@ export function TabletNowPlaying({
|
||||
/>
|
||||
</Pressable>
|
||||
)
|
||||
const queue = (
|
||||
const panelContent = showLyrics ? (
|
||||
<LyricsView
|
||||
key={currentSong.id}
|
||||
lyrics={lyrics}
|
||||
colors={colors}
|
||||
fontSize={34}
|
||||
/>
|
||||
) : (
|
||||
<NowPlayingQueue
|
||||
tablet
|
||||
colors={colors}
|
||||
@@ -241,20 +260,18 @@ export function TabletNowPlaying({
|
||||
</Animated.View>
|
||||
{wideLayout ? (
|
||||
<Animated.View
|
||||
pointerEvents={showQueue ? "auto" : "none"}
|
||||
accessibilityElementsHidden={!showQueue}
|
||||
importantForAccessibility={
|
||||
showQueue ? "auto" : "no-hide-descendants"
|
||||
}
|
||||
pointerEvents={panel ? "auto" : "none"}
|
||||
accessibilityElementsHidden={!panel}
|
||||
importantForAccessibility={panel ? "auto" : "no-hide-descendants"}
|
||||
style={[styles.queue, queueStyle]}
|
||||
onLayout={(event) =>
|
||||
setQueueHeight(event.nativeEvent.layout.height)
|
||||
}
|
||||
>
|
||||
{queueHeight > 0 ? queue : null}
|
||||
{queueHeight > 0 ? panelContent : null}
|
||||
</Animated.View>
|
||||
) : null}
|
||||
{showQueue && !sideBySide ? (
|
||||
{panel && !sideBySide ? (
|
||||
<View
|
||||
style={[
|
||||
styles.portraitQueue,
|
||||
@@ -264,7 +281,7 @@ export function TabletNowPlaying({
|
||||
setQueueHeight(event.nativeEvent.layout.height)
|
||||
}
|
||||
>
|
||||
{queueHeight > 0 ? queue : null}
|
||||
{queueHeight > 0 ? panelContent : null}
|
||||
</View>
|
||||
) : null}
|
||||
</View>
|
||||
@@ -280,21 +297,29 @@ export function TabletNowPlaying({
|
||||
/>
|
||||
<View style={styles.footerActions}>
|
||||
<Pressable
|
||||
disabled
|
||||
onPress={() => togglePanel("lyrics")}
|
||||
disabled={!lyrics && !showLyrics}
|
||||
accessibilityRole="button"
|
||||
accessibilityLabel="Lyrics"
|
||||
accessibilityState={{ disabled: true }}
|
||||
style={[styles.footerButton, { opacity: 0.4 }]}
|
||||
accessibilityLabel={showLyrics ? "Hide lyrics" : "Show lyrics"}
|
||||
accessibilityState={{
|
||||
selected: showLyrics,
|
||||
disabled: !lyrics && !showLyrics,
|
||||
}}
|
||||
style={[
|
||||
styles.footerButton,
|
||||
!lyrics && !showLyrics && { opacity: 0.4 },
|
||||
showLyrics && { backgroundColor: colors.selected },
|
||||
]}
|
||||
>
|
||||
<PlayerSymbol
|
||||
name="quote.bubble"
|
||||
fallback="chatbox-outline"
|
||||
size={25}
|
||||
color={colors.foreground}
|
||||
color={showLyrics ? colors.selectedForeground : colors.foreground}
|
||||
/>
|
||||
</Pressable>
|
||||
<Pressable
|
||||
onPress={toggleQueue}
|
||||
onPress={() => togglePanel("queue")}
|
||||
accessibilityRole="button"
|
||||
accessibilityLabel={showQueue ? "Hide queue" : "Show queue"}
|
||||
accessibilityState={{ selected: showQueue }}
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
import { File } from "expo-file-system"
|
||||
import { useEffect, useMemo, useState, useSyncExternalStore } from "react"
|
||||
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import {
|
||||
followLyrics,
|
||||
parseLyrics,
|
||||
type Lyrics,
|
||||
} from "@otunes/convex/client/lyrics"
|
||||
import { readLyricsTag } from "@otunes/convex/client/lyrics-tags"
|
||||
import { useDownloads } from "@/contexts/downloads"
|
||||
import { useServerConfig } from "@/contexts/server-config"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
import { downloadedAudioUri } from "@/lib/downloads"
|
||||
|
||||
// Lyrics read from downloaded files, by file. Files do not change once saved.
|
||||
const localLyrics = new Map<string, Promise<string | null>>()
|
||||
|
||||
async function readFileLyrics(uri: string) {
|
||||
const handle = new File(uri).open()
|
||||
try {
|
||||
const text = await readLyricsTag({
|
||||
size: handle.size ?? 0,
|
||||
read: (offset, length) => {
|
||||
handle.offset = offset
|
||||
return handle.readBytes(length)
|
||||
},
|
||||
})
|
||||
return text?.trim() || null
|
||||
} finally {
|
||||
handle.close()
|
||||
}
|
||||
}
|
||||
|
||||
function readLocalLyrics(uri: string) {
|
||||
let lyrics = localLyrics.get(uri)
|
||||
if (!lyrics) {
|
||||
lyrics = readFileLyrics(uri).catch(() => null)
|
||||
localLyrics.set(uri, lyrics)
|
||||
}
|
||||
return lyrics
|
||||
}
|
||||
|
||||
const noopSubscribe = () => () => {}
|
||||
|
||||
/**
|
||||
* A song's lyrics: from its downloaded file when there is one, otherwise from
|
||||
* the server. `undefined` while loading, `null` when the song has none.
|
||||
*/
|
||||
export function useLyrics(songId: Id<"songs"> | null) {
|
||||
const { config } = useServerConfig()
|
||||
const { queue } = useDownloads()
|
||||
const fileUri = useSyncExternalStore(queue?.subscribe ?? noopSubscribe, () =>
|
||||
songId && config && queue?.getDownloaded(songId)
|
||||
? downloadedAudioUri(config, songId)
|
||||
: null
|
||||
)
|
||||
const [local, setLocal] = useState<{ uri: string; text: string | null }>()
|
||||
|
||||
useEffect(() => {
|
||||
if (!fileUri) return
|
||||
let current = true
|
||||
void readLocalLyrics(fileUri).then((text) => {
|
||||
if (current) setLocal({ uri: fileUri, text })
|
||||
})
|
||||
return () => {
|
||||
current = false
|
||||
}
|
||||
}, [fileUri])
|
||||
|
||||
const localText = fileUri && local?.uri === fileUri ? local.text : undefined
|
||||
// Songs without a downloaded copy, or whose copy has no lyrics tag.
|
||||
const remote = useCachedQuery(
|
||||
api.lyrics.forSong,
|
||||
songId && (!fileUri || localText === null) ? { id: songId } : "skip"
|
||||
)
|
||||
const text = localText || remote
|
||||
|
||||
return useMemo<Lyrics | null | undefined>(() => {
|
||||
if (!songId) return null
|
||||
if (text === undefined) return undefined
|
||||
return text ? parseLyrics(text) : null
|
||||
}, [songId, text])
|
||||
}
|
||||
|
||||
/**
|
||||
* The playback time for highlighting lyrics: the player's `currentTime`,
|
||||
* advanced by `followLyrics` between its progress updates.
|
||||
*/
|
||||
export function useLyricsTime(
|
||||
lyrics: Lyrics | null | undefined,
|
||||
currentTime: number,
|
||||
isPlaying: boolean
|
||||
) {
|
||||
// Time reached since the player last reported `from`.
|
||||
const [advanced, setAdvanced] = useState<{ from: number; time: number }>()
|
||||
|
||||
useEffect(() => {
|
||||
if (!lyrics || !isPlaying) return
|
||||
return followLyrics(lyrics, currentTime, (time) =>
|
||||
setAdvanced({ from: currentTime, time })
|
||||
)
|
||||
}, [lyrics, currentTime, isPlaying])
|
||||
|
||||
return isPlaying && advanced?.from === currentTime
|
||||
? advanced.time
|
||||
: currentTime
|
||||
}
|
||||
@@ -12,6 +12,10 @@ export type NowPlayingColors = {
|
||||
selected: string
|
||||
selectedForeground: string
|
||||
highlight: string
|
||||
/** Lyrics lines other than the one playing. */
|
||||
lyricsInactive: string
|
||||
/** Words of the playing line not yet sung. */
|
||||
lyricsUnsung: string
|
||||
isDark: boolean
|
||||
}
|
||||
|
||||
@@ -28,6 +32,8 @@ export function nowPlayingColors(palette: CoverPalette): NowPlayingColors {
|
||||
selected: withAlpha(foreground, 0.8),
|
||||
selectedForeground: palette.background,
|
||||
highlight: withAlpha(foreground, 0.1),
|
||||
lyricsInactive: withAlpha(foreground, 0.35),
|
||||
lyricsUnsung: withAlpha(foreground, 0.55),
|
||||
isDark: palette.isDark,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,7 +7,7 @@ import { audioInfo } from "@/lib/server-audio-info"
|
||||
import { streamFile } from "@/lib/server-audio-stream"
|
||||
import { spawnFfmpeg } from "@/lib/server-ffmpeg"
|
||||
import { seekableLosslessFile } from "@/lib/server-lossless"
|
||||
import { getSongSource } from "@/lib/server-song"
|
||||
import { getSongLyrics, getSongSource } from "@/lib/server-song"
|
||||
import { NextRequest, NextResponse, userAgent } from "next/server"
|
||||
import fs from "node:fs/promises"
|
||||
import os from "node:os"
|
||||
@@ -40,9 +40,14 @@ async function fileResponse(songId: string, file: string, contentType: string) {
|
||||
})
|
||||
}
|
||||
|
||||
/** Longest lyrics passed to ffmpeg; Linux caps one argument at 128 KiB. */
|
||||
const MAX_LYRICS_ARGUMENT_BYTES = 100 * 1024
|
||||
|
||||
/**
|
||||
* Transcodes to an AAC .m4a with its index up front, so the saved file has a
|
||||
* duration and seeks offline. The temporary file is removed once sent.
|
||||
* duration and seeks offline. Tags carry over, and the stored lyrics are
|
||||
* written too, since ffmpeg drops some formats' lyrics tags (like MP3 USLT)
|
||||
* when writing MP4. The temporary file is removed once sent.
|
||||
*/
|
||||
async function transcodeResponse(
|
||||
songId: string,
|
||||
@@ -50,6 +55,11 @@ async function transcodeResponse(
|
||||
kbps: number,
|
||||
signal: AbortSignal
|
||||
) {
|
||||
const lyrics = await getSongLyrics(songId)
|
||||
const lyricsArgs =
|
||||
lyrics && Buffer.byteLength(lyrics) <= MAX_LYRICS_ARGUMENT_BYTES
|
||||
? ["-metadata", `lyrics=${lyrics}`]
|
||||
: []
|
||||
const dir = await fs.mkdtemp(path.join(os.tmpdir(), "otunes-download-"))
|
||||
const output = path.join(dir, "audio.m4a")
|
||||
const cleanup = () => fs.rm(dir, { recursive: true, force: true })
|
||||
@@ -64,6 +74,7 @@ async function transcodeResponse(
|
||||
"aac",
|
||||
"-b:a",
|
||||
`${kbps}k`,
|
||||
...lyricsArgs,
|
||||
"-movflags",
|
||||
"+faststart",
|
||||
output,
|
||||
|
||||
@@ -8,8 +8,14 @@ const QueuePanel = dynamic(() =>
|
||||
import("@/components/queue-panel").then((module) => module.QueuePanel)
|
||||
)
|
||||
|
||||
export function LazyQueuePanel() {
|
||||
const { queueOpen } = usePlayback()
|
||||
const LyricsPanel = dynamic(() =>
|
||||
import("@/components/lyrics-panel").then((module) => module.LyricsPanel)
|
||||
)
|
||||
|
||||
/** The queue or lyrics panel beside the page, whichever is open. */
|
||||
export function LazyQueuePanel() {
|
||||
const { queueOpen, lyricsOpen } = usePlayback()
|
||||
|
||||
if (lyricsOpen) return <LyricsPanel />
|
||||
return queueOpen ? <QueuePanel /> : null
|
||||
}
|
||||
@@ -0,0 +1,164 @@
|
||||
"use client"
|
||||
|
||||
import * as React from "react"
|
||||
|
||||
import {
|
||||
useIsPlaying,
|
||||
usePlayback,
|
||||
usePlaybackProgress,
|
||||
} from "@/components/playback-provider"
|
||||
import { useLyrics, useLyricsTime } from "@/hooks/use-lyrics"
|
||||
import { cn } from "@/lib/utils"
|
||||
import {
|
||||
activeLineIndex,
|
||||
type LyricLine,
|
||||
type Lyrics,
|
||||
} from "@otunes/convex/client/lyrics"
|
||||
|
||||
/** How long a manual scroll keeps the panel from following the song. */
|
||||
const MANUAL_SCROLL_HOLD_MS = 3000
|
||||
|
||||
/** Lyrics beside the page, in the queue's place. Synced lines follow playback. */
|
||||
export function LyricsPanel() {
|
||||
const { currentSong } = usePlayback()
|
||||
const lyrics = useLyrics(currentSong?.id ?? null)
|
||||
|
||||
return (
|
||||
<aside
|
||||
aria-label="Lyrics"
|
||||
className={cn(
|
||||
"flex h-svh w-72 shrink-0 flex-col border-l bg-background",
|
||||
"max-md:fixed max-md:inset-y-0 max-md:right-0 max-md:z-20 max-md:shadow-xl"
|
||||
)}
|
||||
>
|
||||
{lyrics === null ? (
|
||||
<p className="m-auto text-sm text-muted-foreground">No lyrics</p>
|
||||
) : lyrics ? (
|
||||
<LyricsLines key={currentSong?.id} lyrics={lyrics} />
|
||||
) : null}
|
||||
</aside>
|
||||
)
|
||||
}
|
||||
|
||||
function LyricsLines({ lyrics }: { lyrics: Lyrics }) {
|
||||
const { seekTo, currentTime } = usePlaybackProgress()
|
||||
const isPlaying = useIsPlaying()
|
||||
const { setIsPlaying } = usePlayback()
|
||||
const time = useLyricsTime(lyrics, currentTime, isPlaying)
|
||||
const active = activeLineIndex(lyrics, time)
|
||||
const scrollRef = React.useRef<HTMLDivElement>(null)
|
||||
const manualScrollAt = React.useRef(0)
|
||||
const synced = lyrics.synced !== "none"
|
||||
|
||||
React.useEffect(() => {
|
||||
const container = scrollRef.current
|
||||
const line = container?.querySelector<HTMLElement>(
|
||||
`[data-line="${Math.max(active, 0)}"]`
|
||||
)
|
||||
if (
|
||||
!container ||
|
||||
!line ||
|
||||
!synced ||
|
||||
Date.now() - manualScrollAt.current < MANUAL_SCROLL_HOLD_MS
|
||||
) {
|
||||
return
|
||||
}
|
||||
container.scrollTo({
|
||||
top: line.offsetTop - container.clientHeight * 0.25,
|
||||
behavior: "smooth",
|
||||
})
|
||||
}, [active, synced])
|
||||
|
||||
const playFrom = React.useCallback(
|
||||
(seconds: number) => {
|
||||
seekTo(seconds)
|
||||
setIsPlaying(true)
|
||||
},
|
||||
[seekTo, setIsPlaying]
|
||||
)
|
||||
|
||||
const holdScroll = () => {
|
||||
manualScrollAt.current = Date.now()
|
||||
}
|
||||
|
||||
return (
|
||||
<div
|
||||
ref={scrollRef}
|
||||
onWheel={holdScroll}
|
||||
onTouchMove={holdScroll}
|
||||
className="relative min-h-0 flex-1 overflow-y-auto px-6 pt-[25svh] pb-[60svh]"
|
||||
>
|
||||
{lyrics.lines.map((line, index) =>
|
||||
synced ? (
|
||||
<SyncedLine
|
||||
key={index}
|
||||
index={index}
|
||||
line={line}
|
||||
state={
|
||||
index === active ? "active" : index < active ? "past" : "next"
|
||||
}
|
||||
time={index === active ? time : null}
|
||||
onSelect={playFrom}
|
||||
/>
|
||||
) : (
|
||||
<p
|
||||
key={index}
|
||||
className={cn(
|
||||
"text-lg leading-snug font-semibold text-foreground/85",
|
||||
line.text === "" && "h-4"
|
||||
)}
|
||||
>
|
||||
{line.text}
|
||||
</p>
|
||||
)
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* One timed line. Only the active line gets the playback time, so memoized
|
||||
* lines elsewhere skip re-rendering as the song plays.
|
||||
*/
|
||||
const SyncedLine = React.memo(function SyncedLine({
|
||||
index,
|
||||
line,
|
||||
state,
|
||||
time,
|
||||
onSelect,
|
||||
}: {
|
||||
index: number
|
||||
line: LyricLine
|
||||
state: "past" | "active" | "next"
|
||||
time: number | null
|
||||
onSelect: (seconds: number) => void
|
||||
}) {
|
||||
const active = state === "active"
|
||||
return (
|
||||
<button
|
||||
type="button"
|
||||
data-line={index}
|
||||
onClick={() => onSelect(line.start ?? 0)}
|
||||
className={cn(
|
||||
"-mx-2 my-1 block w-[calc(100%+1rem)] rounded-md px-2 py-1.5 text-left text-[22px] leading-tight font-bold transition-colors duration-300 hover:bg-foreground/5",
|
||||
active && !line.words ? "text-foreground" : "text-foreground/30"
|
||||
)}
|
||||
>
|
||||
{active && line.words
|
||||
? line.words.map((word, wordIndex) => (
|
||||
<span
|
||||
key={wordIndex}
|
||||
className={cn(
|
||||
"transition-colors duration-200",
|
||||
time !== null && time >= word.start
|
||||
? "text-foreground"
|
||||
: "text-foreground/45"
|
||||
)}
|
||||
>
|
||||
{word.text}
|
||||
</span>
|
||||
))
|
||||
: line.text}
|
||||
</button>
|
||||
)
|
||||
})
|
||||
@@ -60,10 +60,13 @@ type PlaybackContextValue = {
|
||||
shuffleEnabled: boolean
|
||||
repeatEnabled: RepeatMode
|
||||
queueOpen: boolean
|
||||
/** The lyrics panel, which shares the queue's place beside the page. */
|
||||
lyricsOpen: boolean
|
||||
isPlaying: boolean
|
||||
volume: number
|
||||
setQueueOpen: (open: boolean) => void
|
||||
toggleQueueOpen: () => void
|
||||
toggleLyricsOpen: () => void
|
||||
setIsPlaying: (playing: boolean) => void
|
||||
setVolume: (volume: number) => void
|
||||
/** An origin from `downloadsQueueOrigin` plays downloads in any quality. */
|
||||
@@ -122,6 +125,7 @@ type PlaybackActions = Omit<
|
||||
| "shuffleEnabled"
|
||||
| "repeatEnabled"
|
||||
| "queueOpen"
|
||||
| "lyricsOpen"
|
||||
| "isPlaying"
|
||||
| "volume"
|
||||
| "dolbyAtmosSupported"
|
||||
@@ -506,7 +510,12 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
const currentTimeRef = useRef(0)
|
||||
const durationRef = useRef(0)
|
||||
|
||||
const [queueOpen, setQueueOpen] = useState(false)
|
||||
const [sidePanel, setSidePanel] = useState<"queue" | "lyrics" | null>(null)
|
||||
const queueOpen = sidePanel === "queue"
|
||||
const lyricsOpen = sidePanel === "lyrics"
|
||||
const setQueueOpen = useCallback((open: boolean) => {
|
||||
setSidePanel((panel) => (open ? "queue" : panel === "queue" ? null : panel))
|
||||
}, [])
|
||||
const [isPlaying, setIsPlaying] = useState(false)
|
||||
const [playbackStartVersion, setPlaybackStartVersion] = useState(0)
|
||||
const [currentTime, setCurrentTime] = useState(0)
|
||||
@@ -1441,7 +1450,11 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
)
|
||||
|
||||
const toggleQueueOpen = useCallback(() => {
|
||||
setQueueOpen((open) => !open)
|
||||
setSidePanel((panel) => (panel === "queue" ? null : "queue"))
|
||||
}, [])
|
||||
|
||||
const toggleLyricsOpen = useCallback(() => {
|
||||
setSidePanel((panel) => (panel === "lyrics" ? null : "lyrics"))
|
||||
}, [])
|
||||
|
||||
const toggleShuffle = useCallback(async () => {
|
||||
@@ -1547,6 +1560,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
() => ({
|
||||
setQueueOpen,
|
||||
toggleQueueOpen,
|
||||
toggleLyricsOpen,
|
||||
setIsPlaying,
|
||||
setVolume,
|
||||
playInOrder,
|
||||
@@ -1572,7 +1586,9 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
skipPrevious,
|
||||
}),
|
||||
[
|
||||
setQueueOpen,
|
||||
toggleQueueOpen,
|
||||
toggleLyricsOpen,
|
||||
setVolume,
|
||||
playInOrder,
|
||||
playShuffled,
|
||||
@@ -1608,6 +1624,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
shuffleEnabled: playback.shuffleEnabled,
|
||||
repeatEnabled: playback.repeatEnabled,
|
||||
queueOpen,
|
||||
lyricsOpen,
|
||||
isPlaying: isPlaybackActive,
|
||||
volume,
|
||||
dolbyAtmosSupported,
|
||||
@@ -1618,6 +1635,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
currentSong,
|
||||
currentFormat,
|
||||
queueOpen,
|
||||
lyricsOpen,
|
||||
isPlaybackActive,
|
||||
volume,
|
||||
dolbyAtmosSupported,
|
||||
|
||||
@@ -29,6 +29,7 @@ import {
|
||||
import { Button } from "@/components/ui/button"
|
||||
import { Slider } from "@/components/ui/slider"
|
||||
import { useSidebar } from "@/components/ui/sidebar"
|
||||
import { useLyrics } from "@/hooks/use-lyrics"
|
||||
import { albumCoverUrl } from "@/lib/cover-urls"
|
||||
import { cn } from "@/lib/utils"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
@@ -73,18 +74,21 @@ export function PlayerBar() {
|
||||
shuffleEnabled,
|
||||
repeatEnabled,
|
||||
queueOpen,
|
||||
lyricsOpen,
|
||||
isPlaying,
|
||||
volume,
|
||||
queueSongIds,
|
||||
setIsPlaying,
|
||||
setVolume,
|
||||
toggleQueueOpen,
|
||||
toggleLyricsOpen,
|
||||
toggleShuffle,
|
||||
cycleRepeat,
|
||||
skipNext,
|
||||
skipPrevious,
|
||||
} = usePlayback()
|
||||
const { state, isMobile } = useSidebar()
|
||||
const lyrics = useLyrics(currentSong?.id ?? null)
|
||||
|
||||
const hasQueue = queueSongIds.length > 0
|
||||
const sidebarExpanded = !isMobile && state === "expanded"
|
||||
@@ -94,7 +98,7 @@ export function PlayerBar() {
|
||||
className={cn(
|
||||
"@container pointer-events-none fixed bottom-4 z-50 flex justify-center px-4 transition-[left,right] duration-200 ease-linear",
|
||||
sidebarExpanded ? "right-0 left-[16rem]" : "inset-x-0",
|
||||
queueOpen && !isMobile && "right-72"
|
||||
(queueOpen || lyricsOpen) && !isMobile && "right-72"
|
||||
)}
|
||||
>
|
||||
<div className="pointer-events-auto flex w-full max-w-[40rem] items-center gap-2 rounded-full border border-foreground/20 bg-(--player-background) px-3 py-2 text-card-foreground shadow-lg [--player-background:var(--card)] md:gap-3 md:py-1.5 dark:border-white/20 dark:text-white dark:[--player-background:#303033]">
|
||||
@@ -227,9 +231,14 @@ export function PlayerBar() {
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="icon"
|
||||
className="hidden @min-[640px]:inline-flex"
|
||||
aria-label="Lyrics"
|
||||
disabled
|
||||
aria-pressed={lyricsOpen}
|
||||
className={cn(
|
||||
"hidden @min-[640px]:inline-flex",
|
||||
lyricsOpen && "text-primary"
|
||||
)}
|
||||
disabled={!lyrics && !lyricsOpen}
|
||||
onClick={toggleLyricsOpen}
|
||||
>
|
||||
<MessageSquareQuote className="size-4" />
|
||||
</Button>
|
||||
|
||||
@@ -5,7 +5,7 @@ import { stationArtistId } from "@/lib/station-artist"
|
||||
import * as React from "react"
|
||||
import Image from "next/image"
|
||||
import { useRouter } from "next/navigation"
|
||||
import { useMutation } from "convex/react"
|
||||
import { useMutation, useQuery } from "convex/react"
|
||||
import {
|
||||
ImageIcon,
|
||||
Pencil,
|
||||
@@ -101,9 +101,13 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
: playlistSongs
|
||||
const [searchQuery, setSearchQuery] = React.useState("")
|
||||
const isSearching = searchQuery.trim() !== ""
|
||||
const lyricsMatches = useQuery(
|
||||
api.lyrics.matchingSongIds,
|
||||
isSearching ? { query: searchQuery } : "skip"
|
||||
)
|
||||
const filteredSongs = React.useMemo(
|
||||
() => filterSongs(songs, searchQuery),
|
||||
[songs, searchQuery]
|
||||
() => filterSongs(songs, searchQuery, lyricsMatches),
|
||||
[songs, searchQuery, lyricsMatches]
|
||||
)
|
||||
const playlistSongIds = React.useMemo(
|
||||
() => songs.map((song) => song.id as Id<"songs">),
|
||||
|
||||
@@ -14,10 +14,10 @@ import {
|
||||
type MediaContextMenuProps,
|
||||
} from "@/components/media-context-menu"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowseSong } from "@otunes/convex/types"
|
||||
import type { SearchSong } from "@otunes/convex/types"
|
||||
import { albumCoverUrl } from "@/lib/cover-urls"
|
||||
|
||||
export function SearchSongItem({ song }: { song: BrowseSong }) {
|
||||
export function SearchSongItem({ song }: { song: SearchSong }) {
|
||||
const { openAddToPlaylist } = useAddToPlaylist()
|
||||
const { isSongFavorite, toggleSongFavorite } = useFavorites()
|
||||
const { runQueueAction, createStation } = useQueueMediaActions()
|
||||
@@ -103,6 +103,11 @@ export function SearchSongItem({ song }: { song: BrowseSong }) {
|
||||
>
|
||||
<p className="truncate text-sm">{song.artist.name}</p>
|
||||
</Link>
|
||||
{song.lyricsSnippet ? (
|
||||
<p className="truncate text-xs text-muted-foreground">
|
||||
Lyrics: “{song.lyricsSnippet}”
|
||||
</p>
|
||||
) : null}
|
||||
</div>
|
||||
|
||||
<MediaContextMenu {...menu} />
|
||||
|
||||
@@ -0,0 +1,105 @@
|
||||
"use client"
|
||||
|
||||
import { useEffect, useMemo, useState, useSyncExternalStore } from "react"
|
||||
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import {
|
||||
followLyrics,
|
||||
parseLyrics,
|
||||
type Lyrics,
|
||||
} from "@otunes/convex/client/lyrics"
|
||||
import { readLyricsTag } from "@otunes/convex/client/lyrics-tags"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
import { downloadedAudioBlob, downloadQueue } from "@/lib/downloads"
|
||||
|
||||
// Lyrics read from downloaded files, by song. Files do not change once saved.
|
||||
const localLyrics = new Map<string, Promise<string | null>>()
|
||||
|
||||
function readLocalLyrics(songId: string) {
|
||||
let lyrics = localLyrics.get(songId)
|
||||
if (!lyrics) {
|
||||
lyrics = downloadedAudioBlob(songId)
|
||||
.then((blob) =>
|
||||
blob
|
||||
? readLyricsTag({
|
||||
size: blob.size,
|
||||
read: async (offset, length) =>
|
||||
new Uint8Array(
|
||||
await blob.slice(offset, offset + length).arrayBuffer()
|
||||
),
|
||||
})
|
||||
: null
|
||||
)
|
||||
.then((text) => text?.trim() || null)
|
||||
.catch(() => null)
|
||||
localLyrics.set(songId, lyrics)
|
||||
}
|
||||
return lyrics
|
||||
}
|
||||
|
||||
/**
|
||||
* A song's lyrics: from its downloaded file when there is one, otherwise from
|
||||
* the server. `undefined` while loading, `null` when the song has none.
|
||||
*/
|
||||
export function useLyrics(songId: Id<"songs"> | null) {
|
||||
const downloaded = useSyncExternalStore(
|
||||
downloadQueue.subscribe,
|
||||
() => (songId ? downloadQueue.getDownloaded(songId) !== undefined : false),
|
||||
() => false
|
||||
)
|
||||
const [local, setLocal] = useState<{
|
||||
songId: string
|
||||
text: string | null
|
||||
} | null>(null)
|
||||
|
||||
useEffect(() => {
|
||||
if (!songId || !downloaded) return
|
||||
let current = true
|
||||
void readLocalLyrics(songId).then((text) => {
|
||||
if (current) setLocal({ songId, text })
|
||||
})
|
||||
return () => {
|
||||
current = false
|
||||
}
|
||||
}, [songId, downloaded])
|
||||
|
||||
const localText =
|
||||
songId && downloaded && local?.songId === songId ? local.text : undefined
|
||||
// Songs without a downloaded copy, or whose copy has no lyrics tag.
|
||||
const remote = useCachedQuery(
|
||||
api.lyrics.forSong,
|
||||
songId && (!downloaded || localText === null) ? { id: songId } : "skip"
|
||||
)
|
||||
const text = localText || remote
|
||||
|
||||
return useMemo<Lyrics | null | undefined>(() => {
|
||||
if (!songId) return null
|
||||
if (text === undefined) return undefined
|
||||
return text ? parseLyrics(text) : null
|
||||
}, [songId, text])
|
||||
}
|
||||
|
||||
/**
|
||||
* The playback time for highlighting lyrics: the player's `currentTime`,
|
||||
* advanced by `followLyrics` between its progress updates.
|
||||
*/
|
||||
export function useLyricsTime(
|
||||
lyrics: Lyrics | null | undefined,
|
||||
currentTime: number,
|
||||
isPlaying: boolean
|
||||
) {
|
||||
// Time reached since the player last reported `from`.
|
||||
const [advanced, setAdvanced] = useState<{ from: number; time: number }>()
|
||||
|
||||
useEffect(() => {
|
||||
if (!lyrics || !isPlaying) return
|
||||
return followLyrics(lyrics, currentTime, (time) =>
|
||||
setAdvanced({ from: currentTime, time })
|
||||
)
|
||||
}, [lyrics, currentTime, isPlaying])
|
||||
|
||||
return isPlaying && advanced?.from === currentTime
|
||||
? advanced.time
|
||||
: currentTime
|
||||
}
|
||||
@@ -204,11 +204,7 @@ export async function downloadedAudioUrl(songId: string) {
|
||||
audioUrls.set(songId, existing)
|
||||
return existing
|
||||
}
|
||||
const db = await openDatabase()
|
||||
const blob = await readRequest<Blob | undefined>(
|
||||
db.transaction(AUDIO_STORE).objectStore(AUDIO_STORE),
|
||||
songId
|
||||
)
|
||||
const blob = await downloadedAudioBlob(songId)
|
||||
if (!blob) return null
|
||||
const url = URL.createObjectURL(blob)
|
||||
audioUrls.set(songId, url)
|
||||
@@ -218,6 +214,16 @@ export async function downloadedAudioUrl(songId: string) {
|
||||
return url
|
||||
}
|
||||
|
||||
/** A downloaded song's audio file, or null when it is not downloaded. */
|
||||
export async function downloadedAudioBlob(songId: string) {
|
||||
const db = await openDatabase()
|
||||
const blob = await readRequest<Blob | undefined>(
|
||||
db.transaction(AUDIO_STORE).objectStore(AUDIO_STORE),
|
||||
songId
|
||||
)
|
||||
return blob ?? null
|
||||
}
|
||||
|
||||
export function readRememberedDownloadQuality() {
|
||||
try {
|
||||
return parseDownloadQuality(localStorage.getItem(REMEMBERED_QUALITY_KEY))
|
||||
|
||||
@@ -22,6 +22,16 @@ export async function getSongSource(id: string): Promise<SongSource> {
|
||||
return song
|
||||
}
|
||||
|
||||
/** The song's stored lyrics tag, or null without lyrics. */
|
||||
export async function getSongLyrics(id: string): Promise<string | null> {
|
||||
const token = await convexAuthNextjsToken()
|
||||
return await fetchQuery(
|
||||
api.lyrics.forSong,
|
||||
{ id: id as Id<"songs"> },
|
||||
convexServerOptions(token)
|
||||
)
|
||||
}
|
||||
|
||||
const SOURCE_BATCH_SIZE = 200
|
||||
|
||||
/** `getSongSource` for many songs, in batches. Missing songs are left out. */
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
/**
|
||||
* Reads the lyrics tag from a downloaded audio file, so offline playback shows
|
||||
* the same lyrics the server has. Downloads are MP4 (`©lyr`), FLAC (`LYRICS`
|
||||
* Vorbis comment) or MP3 (ID3 `USLT`), and only the tag bytes are read.
|
||||
*/
|
||||
|
||||
export type ByteReader = {
|
||||
size: number
|
||||
read: (offset: number, length: number) => Promise<Uint8Array>
|
||||
}
|
||||
|
||||
const utf8 = new TextDecoder("utf-8")
|
||||
|
||||
function ascii(bytes: Uint8Array, start: number, length: number) {
|
||||
let text = ""
|
||||
for (let i = start; i < Math.min(start + length, bytes.length); i++) {
|
||||
text += String.fromCharCode(bytes[i])
|
||||
}
|
||||
return text
|
||||
}
|
||||
|
||||
function view(bytes: Uint8Array) {
|
||||
return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
|
||||
}
|
||||
|
||||
/** Most bytes read for a tag, so a corrupt length cannot load a whole file. */
|
||||
const MAX_TAG_BYTES = 16 * 1024 * 1024
|
||||
|
||||
type Box = { type: string; start: number; size: number; header: number }
|
||||
|
||||
/** The boxes inside `bytes[start, end)`. */
|
||||
function* boxes(bytes: Uint8Array, start: number, end: number) {
|
||||
const data = view(bytes)
|
||||
let offset = start
|
||||
while (offset + 8 <= end) {
|
||||
let size = data.getUint32(offset)
|
||||
let header = 8
|
||||
if (size === 1 && offset + 16 <= end) {
|
||||
size = Number(data.getBigUint64(offset + 8))
|
||||
header = 16
|
||||
} else if (size === 0) {
|
||||
size = end - offset
|
||||
}
|
||||
if (size < header) return
|
||||
yield { type: ascii(bytes, offset + 4, 4), start: offset, size, header }
|
||||
offset += size
|
||||
}
|
||||
}
|
||||
|
||||
function child(bytes: Uint8Array, parent: Box, type: string, skip = 0) {
|
||||
for (const box of boxes(
|
||||
bytes,
|
||||
parent.start + parent.header + skip,
|
||||
parent.start + parent.size
|
||||
)) {
|
||||
if (box.type === type) return box
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
async function mp4Lyrics(file: ByteReader) {
|
||||
// `moov` may sit after the audio, so walk the top-level box headers.
|
||||
let offset = 0
|
||||
while (offset + 8 <= file.size) {
|
||||
const head = await file.read(offset, 16)
|
||||
if (head.length < 8) return null
|
||||
const data = view(head)
|
||||
let size = data.getUint32(0)
|
||||
if (size === 1 && head.length === 16) size = Number(data.getBigUint64(8))
|
||||
else if (size === 0) size = file.size - offset
|
||||
if (size < 8) return null
|
||||
if (ascii(head, 4, 4) === "moov") {
|
||||
if (size > MAX_TAG_BYTES) return null
|
||||
const moov = await file.read(offset, size)
|
||||
const root = [...boxes(moov, 0, moov.length)][0]
|
||||
const udta = root && child(moov, root, "udta")
|
||||
const meta = udta && child(moov, udta, "meta")
|
||||
// `meta` is a full box: 4 bytes of version and flags precede children.
|
||||
const ilst = meta && child(moov, meta, "ilst", 4)
|
||||
const lyr = ilst && child(moov, ilst, "\u00a9lyr")
|
||||
const text = lyr && child(moov, lyr, "data")
|
||||
if (!text) return null
|
||||
// Type (4 bytes) and locale (4 bytes) precede the UTF-8 text.
|
||||
return utf8.decode(
|
||||
moov.subarray(text.start + text.header + 8, text.start + text.size)
|
||||
)
|
||||
}
|
||||
offset += size
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
const VORBIS_LYRICS_KEYS = new Set(["LYRICS", "UNSYNCEDLYRICS"])
|
||||
|
||||
async function flacLyrics(file: ByteReader) {
|
||||
let offset = 4
|
||||
for (;;) {
|
||||
const header = await file.read(offset, 4)
|
||||
if (header.length < 4) return null
|
||||
const last = (header[0] & 0x80) !== 0
|
||||
const type = header[0] & 0x7f
|
||||
const length = (header[1] << 16) | (header[2] << 8) | header[3]
|
||||
offset += 4
|
||||
if (type === 4) {
|
||||
const block = await file.read(offset, Math.min(length, MAX_TAG_BYTES))
|
||||
const data = view(block)
|
||||
let at = 4 + data.getUint32(0, true)
|
||||
const count = data.getUint32(at, true)
|
||||
at += 4
|
||||
for (let i = 0; i < count && at + 4 <= block.length; i++) {
|
||||
const commentLength = data.getUint32(at, true)
|
||||
const comment = utf8.decode(
|
||||
block.subarray(at + 4, at + 4 + commentLength)
|
||||
)
|
||||
at += 4 + commentLength
|
||||
const equals = comment.indexOf("=")
|
||||
if (VORBIS_LYRICS_KEYS.has(comment.slice(0, equals).toUpperCase())) {
|
||||
return comment.slice(equals + 1)
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
if (last) return null
|
||||
offset += length
|
||||
}
|
||||
}
|
||||
|
||||
function syncsafe(bytes: Uint8Array, at: number) {
|
||||
return (
|
||||
(bytes[at] << 21) |
|
||||
(bytes[at + 1] << 14) |
|
||||
(bytes[at + 2] << 7) |
|
||||
bytes[at + 3]
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Latin-1 (0), UTF-16 with a byte order mark (1) or UTF-16BE (2). Decoded by
|
||||
* hand because React Native's TextDecoder only knows UTF-8.
|
||||
*/
|
||||
function decodeLegacy(raw: Uint8Array, encoding: number) {
|
||||
let text = ""
|
||||
if (encoding === 0) {
|
||||
for (const byte of raw) text += String.fromCharCode(byte)
|
||||
return text
|
||||
}
|
||||
let start = 0
|
||||
let bigEndian = encoding === 2
|
||||
if (encoding === 1 && raw.length >= 2) {
|
||||
bigEndian = raw[0] === 0xfe && raw[1] === 0xff
|
||||
if (bigEndian || (raw[0] === 0xff && raw[1] === 0xfe)) start = 2
|
||||
}
|
||||
for (let i = start; i + 1 < raw.length; i += 2) {
|
||||
text += String.fromCharCode(
|
||||
bigEndian ? (raw[i] << 8) | raw[i + 1] : raw[i] | (raw[i + 1] << 8)
|
||||
)
|
||||
}
|
||||
return text
|
||||
}
|
||||
|
||||
/** Decodes ID3 text in `encoding`, returning it and where its terminator ends. */
|
||||
function id3Text(bytes: Uint8Array, encoding: number, terminated: boolean) {
|
||||
const wide = encoding === 1 || encoding === 2
|
||||
let end = bytes.length
|
||||
if (terminated) {
|
||||
for (let i = 0; i < bytes.length; i += wide ? 2 : 1) {
|
||||
if (bytes[i] === 0 && (!wide || bytes[i + 1] === 0)) {
|
||||
end = i
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
const raw = bytes.subarray(0, end)
|
||||
const text = encoding === 3 ? utf8.decode(raw) : decodeLegacy(raw, encoding)
|
||||
return { text, next: Math.min(bytes.length, end + (wide ? 2 : 1)) }
|
||||
}
|
||||
|
||||
async function id3Lyrics(file: ByteReader) {
|
||||
const header = await file.read(0, 10)
|
||||
const version = header[3]
|
||||
const size = syncsafe(header, 6)
|
||||
if (size > MAX_TAG_BYTES) return null
|
||||
const tag = await file.read(10, size)
|
||||
const data = view(tag)
|
||||
let at = 0
|
||||
while (at + 10 <= tag.length) {
|
||||
const id = ascii(tag, at, 4)
|
||||
if (!/^[A-Z0-9]{4}$/.test(id)) return null
|
||||
const frameSize =
|
||||
version === 4 ? syncsafe(tag, at + 4) : data.getUint32(at + 4)
|
||||
const body = tag.subarray(at + 10, at + 10 + frameSize)
|
||||
at += 10 + frameSize
|
||||
if (id !== "USLT" || body.length < 5) continue
|
||||
const encoding = body[0]
|
||||
// Encoding, a 3 letter language, then a terminated description.
|
||||
const description = id3Text(body.subarray(4), encoding, true)
|
||||
return id3Text(body.subarray(4 + description.next), encoding, false).text
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/** The raw lyrics tag of an audio file, or null when it has none. */
|
||||
export async function readLyricsTag(file: ByteReader): Promise<string | null> {
|
||||
const head = await file.read(0, 12)
|
||||
const magic = ascii(head, 0, 4)
|
||||
try {
|
||||
if (magic === "fLaC") return await flacLyrics(file)
|
||||
if (magic.startsWith("ID3")) return await id3Lyrics(file)
|
||||
if (ascii(head, 4, 4) === "ftyp") return await mp4Lyrics(file)
|
||||
} catch {
|
||||
// An unexpected layout reads as no lyrics; the server copy is used instead.
|
||||
}
|
||||
return null
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
/**
|
||||
* Lyrics as tagged in the music files: plain text, LRC (`[mm:ss.xx]line`), or
|
||||
* word-timed LRC (`<mm:ss.xx>word`). The server stores that text unchanged and
|
||||
* clients parse it here, so a downloaded file's tag and the server copy read
|
||||
* the same.
|
||||
*/
|
||||
|
||||
export type LyricWord = {
|
||||
/** Includes its trailing space, so a line's words join back into its text. */
|
||||
text: string
|
||||
start: number
|
||||
end: number
|
||||
}
|
||||
|
||||
export type LyricLine = {
|
||||
text: string
|
||||
/** Seconds; `null` for plain lyrics. */
|
||||
start: number | null
|
||||
/** Set only on word-timed lines. */
|
||||
words: LyricWord[] | null
|
||||
}
|
||||
|
||||
export type Lyrics = {
|
||||
synced: "none" | "line" | "word"
|
||||
lines: LyricLine[]
|
||||
}
|
||||
|
||||
const LINE_STAMP = /^\[(\d+):(\d+(?:[.:]\d+)?)\]/
|
||||
const WORD_STAMP = /<(\d+):(\d+(?:[.:]\d+)?)>/g
|
||||
const HAS_WORD_STAMP = /<\d+:\d+(?:[.:]\d+)?>/
|
||||
const ID_TAG = /^\[[a-z]+:.*\]$/i
|
||||
|
||||
function seconds(minutes: string, rest: string) {
|
||||
return Number(minutes) * 60 + Number(rest.replace(":", "."))
|
||||
}
|
||||
|
||||
/** Splits `<t>word <t>word<t>` into words; the last stamp ends the last word. */
|
||||
function parseWords(body: string): LyricWord[] {
|
||||
const stamps = [...body.matchAll(WORD_STAMP)]
|
||||
const words: LyricWord[] = []
|
||||
for (let i = 0; i < stamps.length; i++) {
|
||||
const stamp = stamps[i]
|
||||
const textStart = stamp.index + stamp[0].length
|
||||
const next = stamps[i + 1]
|
||||
const text = body.slice(textStart, next?.index ?? body.length)
|
||||
const start = seconds(stamp[1], stamp[2])
|
||||
if (text.trim()) {
|
||||
words.push({
|
||||
text,
|
||||
start,
|
||||
end: next ? seconds(next[1], next[2]) : start,
|
||||
})
|
||||
}
|
||||
}
|
||||
return words
|
||||
}
|
||||
|
||||
export function parseLyrics(raw: string): Lyrics | null {
|
||||
const rows = raw.replace(/\r\n?/g, "\n").split("\n")
|
||||
const timed = rows.some((row) => LINE_STAMP.test(row.trim()))
|
||||
const wordTimed = rows.some((row) => HAS_WORD_STAMP.test(row))
|
||||
|
||||
if (!timed && !wordTimed) {
|
||||
const lines = rows.map((row) => ({
|
||||
text: row.trim(),
|
||||
start: null,
|
||||
words: null,
|
||||
}))
|
||||
// Blank rows between stanzas stay as spacing; ones at the ends go.
|
||||
while (lines[0]?.text === "") lines.shift()
|
||||
while (lines.at(-1)?.text === "") lines.pop()
|
||||
return lines.length > 0 ? { synced: "none", lines } : null
|
||||
}
|
||||
|
||||
const lines: LyricLine[] = []
|
||||
for (const row of rows) {
|
||||
let body = row.trim()
|
||||
if (ID_TAG.test(body) && !LINE_STAMP.test(body)) continue
|
||||
// A line may repeat under several stamps: `[00:12.00][01:30.00]Chorus`.
|
||||
const starts: number[] = []
|
||||
for (let match = LINE_STAMP.exec(body); match;) {
|
||||
starts.push(seconds(match[1], match[2]))
|
||||
body = body.slice(match[0].length)
|
||||
match = LINE_STAMP.exec(body)
|
||||
}
|
||||
const words = wordTimed ? parseWords(body) : []
|
||||
const text = (
|
||||
words.length > 0 ? words.map((word) => word.text).join("") : body
|
||||
).trim()
|
||||
if (!text) continue
|
||||
if (starts.length === 0 && words.length > 0) starts.push(words[0].start)
|
||||
for (const start of starts) {
|
||||
const shift = words.length > 0 ? start - words[0].start : 0
|
||||
lines.push({
|
||||
text,
|
||||
start,
|
||||
words:
|
||||
words.length > 0
|
||||
? words.map((word) => ({
|
||||
...word,
|
||||
start: word.start + shift,
|
||||
end: word.end + shift,
|
||||
}))
|
||||
: null,
|
||||
})
|
||||
}
|
||||
}
|
||||
lines.sort((a, b) => a.start! - b.start!)
|
||||
if (lines.length === 0) return null
|
||||
return {
|
||||
synced: lines.every((line) => line.words) ? "word" : "line",
|
||||
lines,
|
||||
}
|
||||
}
|
||||
|
||||
/** The text without timestamps, one line per row, for search and snippets. */
|
||||
export function plainLyrics(lyrics: Lyrics) {
|
||||
return lyrics.lines.map((line) => line.text).join("\n")
|
||||
}
|
||||
|
||||
/** How well a tag's lyrics are timed, to keep the best of a song's files. */
|
||||
export function lyricsRank(raw: string | null) {
|
||||
const synced = raw ? parseLyrics(raw)?.synced : undefined
|
||||
return synced === "word" ? 3 : synced === "line" ? 2 : synced ? 1 : 0
|
||||
}
|
||||
|
||||
/**
|
||||
* The line playing at `time` (the last one started), or -1 before the first.
|
||||
* Plain lyrics never have one.
|
||||
*/
|
||||
export function activeLineIndex(lyrics: Lyrics, time: number) {
|
||||
let active = -1
|
||||
for (let i = 0; i < lyrics.lines.length; i++) {
|
||||
const start = lyrics.lines[i].start
|
||||
if (start === null || start > time) break
|
||||
active = i
|
||||
}
|
||||
return active
|
||||
}
|
||||
|
||||
/** When the highlighted line or word next changes after `time`, if ever. */
|
||||
export function nextLyricsChange(lyrics: Lyrics, time: number) {
|
||||
let next = Infinity
|
||||
for (const line of lyrics.lines) {
|
||||
if (line.start !== null && line.start > time) {
|
||||
next = Math.min(next, line.start)
|
||||
break
|
||||
}
|
||||
for (const word of line.words ?? []) {
|
||||
if (word.start > time) {
|
||||
next = Math.min(next, word.start)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return next
|
||||
}
|
||||
|
||||
/**
|
||||
* While audio plays on from `time` seconds, calls `onChange` with the playback
|
||||
* time whenever the highlighted line or word changes. Players report progress
|
||||
* only a few times a second, which is too coarse for word timing. Returns a
|
||||
* function that stops it.
|
||||
*/
|
||||
export function followLyrics(
|
||||
lyrics: Lyrics,
|
||||
time: number,
|
||||
onChange: (time: number) => void
|
||||
) {
|
||||
const startedAt = Date.now() - time * 1000
|
||||
let timer: ReturnType<typeof setTimeout> | undefined
|
||||
const schedule = (from: number) => {
|
||||
const next = nextLyricsChange(lyrics, from)
|
||||
if (!Number.isFinite(next)) return
|
||||
timer = setTimeout(
|
||||
() => {
|
||||
const now = (Date.now() - startedAt) / 1000
|
||||
onChange(now)
|
||||
schedule(now)
|
||||
},
|
||||
(next - from) * 1000
|
||||
)
|
||||
}
|
||||
if (lyrics.synced !== "none") schedule(time)
|
||||
return () => clearTimeout(timer)
|
||||
}
|
||||
|
||||
/** Lowercase words of a search, for matching lyrics the way the search index does. */
|
||||
function searchTerms(query: string): string[] {
|
||||
return query.toLowerCase().match(/[\p{L}\p{N}']+/gu) ?? []
|
||||
}
|
||||
|
||||
const SNIPPET_LEAD = 24
|
||||
|
||||
export type LyricsMatch = {
|
||||
/** The matched line, trimmed to start near the match. */
|
||||
snippet: string
|
||||
/** Whether the line holds the query as typed, not just its words. */
|
||||
exact: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* Where a search matched the lyrics: a line holding the query as typed, or
|
||||
* else a line holding every word of it (the last may be a prefix, as when
|
||||
* typing). Null when no single line does.
|
||||
*/
|
||||
export function matchLyrics(plain: string, query: string): LyricsMatch | null {
|
||||
const needle = query.trim().toLowerCase()
|
||||
const terms = searchTerms(needle)
|
||||
const last = terms.at(-1)
|
||||
if (!needle || last === undefined) return null
|
||||
|
||||
let loose: string | null = null
|
||||
for (const line of plain.split("\n")) {
|
||||
const column = line.toLowerCase().indexOf(needle)
|
||||
if (column !== -1) {
|
||||
const snippet =
|
||||
column > SNIPPET_LEAD
|
||||
? `…${line.slice(column - SNIPPET_LEAD).trimStart()}`
|
||||
: line.trim()
|
||||
return { snippet, exact: true }
|
||||
}
|
||||
if (loose === null) {
|
||||
const words = searchTerms(line)
|
||||
const hasAll =
|
||||
terms.slice(0, -1).every((term) => words.includes(term)) &&
|
||||
words.some((word) => word.startsWith(last))
|
||||
if (hasAll) loose = line.trim()
|
||||
}
|
||||
}
|
||||
return loose === null ? null : { snippet: loose, exact: false }
|
||||
}
|
||||
@@ -1,21 +1,30 @@
|
||||
type SearchableSong = {
|
||||
id: string
|
||||
title: string
|
||||
artist: { name: string }
|
||||
album: { title: string }
|
||||
}
|
||||
|
||||
/** Case-insensitive match on title, artist, or album. A blank query keeps every song. */
|
||||
/**
|
||||
* Case-insensitive match on title, artist, or album, plus the songs in
|
||||
* `lyricsMatches` (from `api.lyrics.matchingSongIds`). A blank query keeps
|
||||
* every song.
|
||||
*/
|
||||
export function filterSongs<T extends SearchableSong>(
|
||||
songs: T[],
|
||||
query: string
|
||||
query: string,
|
||||
lyricsMatches?: readonly string[]
|
||||
) {
|
||||
const normalized = query.trim().toLowerCase()
|
||||
if (!normalized) {
|
||||
return songs
|
||||
}
|
||||
return songs.filter((song) =>
|
||||
[song.title, song.artist.name, song.album.title].some((value) =>
|
||||
value.toLowerCase().includes(normalized)
|
||||
)
|
||||
const byLyrics = new Set(lyricsMatches)
|
||||
return songs.filter(
|
||||
(song) =>
|
||||
byLyrics.has(song.id) ||
|
||||
[song.title, song.artist.name, song.album.title].some((value) =>
|
||||
value.toLowerCase().includes(normalized)
|
||||
)
|
||||
)
|
||||
}
|
||||
+2
@@ -19,6 +19,7 @@ import type * as intentCatalog from "../intentCatalog.js";
|
||||
import type * as intentCatalogChanges from "../intentCatalogChanges.js";
|
||||
import type * as library from "../library.js";
|
||||
import type * as limits from "../limits.js";
|
||||
import type * as lyrics from "../lyrics.js";
|
||||
import type * as migrations from "../migrations.js";
|
||||
import type * as playback from "../playback.js";
|
||||
import type * as playbackState from "../playbackState.js";
|
||||
@@ -46,6 +47,7 @@ declare const fullApi: ApiFromModules<{
|
||||
intentCatalogChanges: typeof intentCatalogChanges;
|
||||
library: typeof library;
|
||||
limits: typeof limits;
|
||||
lyrics: typeof lyrics;
|
||||
migrations: typeof migrations;
|
||||
playback: typeof playback;
|
||||
playbackState: typeof playbackState;
|
||||
|
||||
@@ -10,6 +10,7 @@ import { ConvexError } from "convex/values"
|
||||
|
||||
import type { Id } from "./_generated/dataModel"
|
||||
import { action, internalAction, type ActionCtx } from "./_generated/server"
|
||||
import { lyricsRank } from "../client/lyrics"
|
||||
|
||||
const DATA_DIR = process.env.DATA || "/data"
|
||||
const HLS_CACHE_DIR = "/tmp/otunes"
|
||||
@@ -67,6 +68,8 @@ const SCAN_LOCK_LEASE_MS = 15 * 60 * 1000
|
||||
/** New files left unparsed after this are picked up by the next scan. */
|
||||
const SCAN_PARSE_BUDGET_MS = 6 * 60 * 1000
|
||||
const SCAN_BATCH_SIZE = 200
|
||||
/** Lyrics text per mutation, well under Convex's argument size limit. */
|
||||
const SCAN_BATCH_LYRICS_BYTES = 2 * 1024 * 1024
|
||||
const FS_CONCURRENCY = 16
|
||||
|
||||
type Page<T> = { page: T[]; isDone: boolean; continueCursor: string }
|
||||
@@ -220,6 +223,55 @@ function releaseDate(common: music.ICommonTagsResult) {
|
||||
return common.year ? `01-01-${common.year}` : ""
|
||||
}
|
||||
|
||||
const LYRICS_TAG_IDS = new Set(["©LYR", "LYRICS", "UNSYNCEDLYRICS", "USLT"])
|
||||
|
||||
function lrcStamp(milliseconds: number) {
|
||||
const totalSeconds = milliseconds / 1000
|
||||
const minutes = Math.floor(totalSeconds / 60)
|
||||
const rest = (totalSeconds - minutes * 60).toFixed(2).padStart(5, "0")
|
||||
return `[${String(minutes).padStart(2, "0")}:${rest}]`
|
||||
}
|
||||
|
||||
/** One native tag's lyrics as text; ID3 synced lyrics become LRC. */
|
||||
function lyricsTagText({ id, value }: music.ITag): string | null {
|
||||
const key = id.toUpperCase()
|
||||
if (typeof value === "string") {
|
||||
return LYRICS_TAG_IDS.has(key) ? value : null
|
||||
}
|
||||
if (
|
||||
(key !== "USLT" && key !== "SYLT") ||
|
||||
!value ||
|
||||
typeof value !== "object"
|
||||
) {
|
||||
return null
|
||||
}
|
||||
const lyrics = value as music.ILyricsTag
|
||||
const synced = lyrics.syncText ?? []
|
||||
// Timestamp format 2 is milliseconds; frame-based stamps cannot be used.
|
||||
if (synced.length > 0 && lyrics.timeStampFormat === 2) {
|
||||
return synced
|
||||
.map((line) => `${lrcStamp(line.timestamp ?? 0)}${line.text}`)
|
||||
.join("\n")
|
||||
}
|
||||
return lyrics.text ?? null
|
||||
}
|
||||
|
||||
/** The best timed lyrics tag in a file, or null without one. */
|
||||
function lyricsTag(metadata: music.IAudioMetadata): string | null {
|
||||
let best: string | null = null
|
||||
for (const tags of Object.values(metadata.native)) {
|
||||
for (const tag of tags) {
|
||||
const text = lyricsTagText(tag)?.trim() || null
|
||||
if (lyricsRank(text) > lyricsRank(best)) best = text
|
||||
}
|
||||
}
|
||||
return best
|
||||
}
|
||||
|
||||
function betterLyrics(a: string | null, b: string | null) {
|
||||
return lyricsRank(b) > lyricsRank(a) ? b : a
|
||||
}
|
||||
|
||||
type NewSong = {
|
||||
name: string
|
||||
files: Record<string, string>
|
||||
@@ -230,6 +282,7 @@ type NewSong = {
|
||||
year: number
|
||||
date: string
|
||||
genres: string[]
|
||||
lyrics: string | null
|
||||
}
|
||||
|
||||
type ImportEntry = {
|
||||
@@ -386,9 +439,11 @@ async function scanLibrary(ctx: ActionCtx) {
|
||||
imports.set(key, entry)
|
||||
}
|
||||
|
||||
const lyrics = lyricsTag(metadata)
|
||||
const pending = entry.songs.get(title)
|
||||
if (pending) {
|
||||
pending.files[codec] ??= filePath
|
||||
pending.lyrics = betterLyrics(pending.lyrics, lyrics)
|
||||
continue
|
||||
}
|
||||
entry.songs.set(title, {
|
||||
@@ -402,9 +457,39 @@ async function scanLibrary(ctx: ActionCtx) {
|
||||
year: common.year || 0,
|
||||
date: releaseDate(common),
|
||||
genres: common.genre || [],
|
||||
lyrics,
|
||||
})
|
||||
}
|
||||
|
||||
// Songs scanned before lyrics were stored, read once for their lyrics.
|
||||
const unreadLyrics = songs.filter(
|
||||
(song) =>
|
||||
song.hasLyrics === undefined &&
|
||||
Object.keys(songFiles.get(song._id)!).length > 0
|
||||
)
|
||||
const readLyrics = await mapLimit(
|
||||
unreadLyrics,
|
||||
FS_CONCURRENCY,
|
||||
async (song) => {
|
||||
let best: string | null = null
|
||||
for (const filePath of Object.values(songFiles.get(song._id)!)) {
|
||||
if (Date.now() > deadline) {
|
||||
return null
|
||||
}
|
||||
try {
|
||||
const metadata = await music.parseFile(filePath, {
|
||||
skipCovers: true,
|
||||
})
|
||||
best = betterLyrics(best, lyricsTag(metadata))
|
||||
} catch {
|
||||
// An unreadable file contributes no lyrics.
|
||||
}
|
||||
}
|
||||
return { id: song._id, lyrics: best }
|
||||
}
|
||||
)
|
||||
const songLyrics = readLyrics.filter((song) => song !== null)
|
||||
|
||||
const deletedSongs = songs.flatMap((song) =>
|
||||
Object.keys(songFiles.get(song._id)!).length === 0 ? [song._id] : []
|
||||
)
|
||||
@@ -469,6 +554,7 @@ async function scanLibrary(ctx: ActionCtx) {
|
||||
|
||||
let importBatch: ImportEntry[] = []
|
||||
let importBatchSongs = 0
|
||||
let importBatchBytes = 0
|
||||
const flushImports = async () => {
|
||||
if (importBatch.length === 0) {
|
||||
return
|
||||
@@ -481,16 +567,41 @@ async function scanLibrary(ctx: ActionCtx) {
|
||||
})
|
||||
importBatch = []
|
||||
importBatchSongs = 0
|
||||
importBatchBytes = 0
|
||||
}
|
||||
for (const entry of imports.values()) {
|
||||
importBatch.push(entry)
|
||||
importBatchSongs += entry.songs.size
|
||||
if (importBatchSongs >= SCAN_BATCH_SIZE) {
|
||||
for (const song of entry.songs.values()) {
|
||||
importBatchBytes += song.lyrics?.length ?? 0
|
||||
}
|
||||
if (
|
||||
importBatchSongs >= SCAN_BATCH_SIZE ||
|
||||
importBatchBytes >= SCAN_BATCH_LYRICS_BYTES
|
||||
) {
|
||||
await flushImports()
|
||||
}
|
||||
}
|
||||
await flushImports()
|
||||
|
||||
let lyricsBatch: typeof songLyrics = []
|
||||
let lyricsBatchBytes = 0
|
||||
for (const [index, song] of songLyrics.entries()) {
|
||||
lyricsBatch.push(song)
|
||||
lyricsBatchBytes += song.lyrics?.length ?? 0
|
||||
if (
|
||||
lyricsBatch.length >= SCAN_BATCH_SIZE ||
|
||||
lyricsBatchBytes >= SCAN_BATCH_LYRICS_BYTES ||
|
||||
index === songLyrics.length - 1
|
||||
) {
|
||||
await ctx.runMutation(internal.lyrics.setSongLyrics, {
|
||||
songs: lyricsBatch,
|
||||
})
|
||||
lyricsBatch = []
|
||||
lyricsBatchBytes = 0
|
||||
}
|
||||
}
|
||||
|
||||
for (const batch of chunk(artistCovers, SCAN_BATCH_SIZE)) {
|
||||
await ctx.runMutation(internal.library.updateArtistCovers, {
|
||||
artists: batch,
|
||||
@@ -523,7 +634,8 @@ async function scanLibrary(ctx: ActionCtx) {
|
||||
)
|
||||
const summary =
|
||||
`songs: ${importedSongs} added, ${updatedSongs.length} updated, ` +
|
||||
`${deletedSongs.length} removed; albums removed: ${removedAlbums}; ` +
|
||||
`${deletedSongs.length} removed, ${songLyrics.length} read for lyrics ` +
|
||||
`(${unreadLyrics.length - songLyrics.length} deferred); albums removed: ${removedAlbums}; ` +
|
||||
`artists removed: ${removedArtists}; covers updated: ` +
|
||||
`${artistCovers.length + albumCovers.length}; ` +
|
||||
`files deferred: ${skipped}; ${Date.now() - startedAt}ms`
|
||||
|
||||
@@ -18,6 +18,7 @@ import type {
|
||||
LibrarySearchResults,
|
||||
OwnedPlaylistForAdd,
|
||||
PlaylistSummary,
|
||||
SearchSong,
|
||||
SearchTopResultItem,
|
||||
SidebarPlaylists,
|
||||
} from "./types"
|
||||
@@ -25,6 +26,7 @@ import { purgeFavoriteEntities } from "./favoriteStore"
|
||||
import { chunk, type Chunked } from "./limits"
|
||||
import { recordIntentCatalogChanges } from "./intentCatalogChanges"
|
||||
import { playlistCoverVersion } from "./playlistCover"
|
||||
import { deleteSongLyrics, searchSongLyrics, writeSongLyrics } from "./lyrics"
|
||||
|
||||
export type {
|
||||
BrowseAlbum,
|
||||
@@ -39,6 +41,7 @@ export type {
|
||||
LibrarySearchResults,
|
||||
OwnedPlaylistForAdd,
|
||||
PlaylistSummary,
|
||||
SearchSong,
|
||||
SearchTopResultItem,
|
||||
SidebarPlaylists,
|
||||
} from "./types"
|
||||
@@ -648,6 +651,9 @@ function matchScoreSongArtists(
|
||||
*/
|
||||
const MAX_SEARCH_RESULTS = 500
|
||||
|
||||
/** Songs found by lyrics alone, listed after title, artist and album matches. */
|
||||
const MAX_LYRICS_SEARCH_RESULTS = 50
|
||||
|
||||
export const searchLibrary = query({
|
||||
args: { query: v.string() },
|
||||
handler: async (ctx, args) => {
|
||||
@@ -732,6 +738,25 @@ export const searchLibrary = query({
|
||||
(a, b) => b.score - a.score || a.item.title.localeCompare(b.item.title)
|
||||
)
|
||||
|
||||
const songById = new Map(songs.map((song) => [song._id, song]))
|
||||
const matchedSongIds = new Set(songResults.map((result) => result.item.id))
|
||||
const lyricsResults: SearchSong[] = (
|
||||
await searchSongLyrics(ctx, args.query, MAX_LYRICS_SEARCH_RESULTS)
|
||||
).flatMap(({ song: songId, snippet }) => {
|
||||
const song = songById.get(songId)
|
||||
const album = song && albumMap.get(song.album)
|
||||
const albumArtist = song && artistMap.get(song.albumArtist)
|
||||
if (!song || !album || !albumArtist || matchedSongIds.has(songId)) {
|
||||
return []
|
||||
}
|
||||
return [
|
||||
{
|
||||
...toBrowseSong(song, album, albumArtist),
|
||||
lyricsSnippet: snippet,
|
||||
},
|
||||
]
|
||||
})
|
||||
|
||||
const topResults: SearchTopResultItem[] = [
|
||||
...songResults,
|
||||
...albumResults,
|
||||
@@ -749,9 +774,10 @@ export const searchLibrary = query({
|
||||
albums: albumResults
|
||||
.slice(0, MAX_SEARCH_RESULTS)
|
||||
.map((result) => result.item),
|
||||
songs: songResults
|
||||
.slice(0, MAX_SEARCH_RESULTS)
|
||||
.map((result) => result.item),
|
||||
songs: [
|
||||
...songResults.map((result): SearchSong => result.item),
|
||||
...lyricsResults,
|
||||
].slice(0, MAX_SEARCH_RESULTS),
|
||||
}
|
||||
return result
|
||||
},
|
||||
@@ -934,11 +960,12 @@ export const scanSongsPage = internalQuery({
|
||||
const result = await ctx.db.query("songs").paginate(args.paginationOpts)
|
||||
return {
|
||||
...result,
|
||||
page: result.page.map(({ _id, name, files, album }) => ({
|
||||
page: result.page.map(({ _id, name, files, album, hasLyrics }) => ({
|
||||
_id,
|
||||
name,
|
||||
files,
|
||||
album,
|
||||
hasLyrics,
|
||||
})),
|
||||
}
|
||||
},
|
||||
@@ -1100,6 +1127,8 @@ export const importAlbums = internalMutation({
|
||||
year: v.number(),
|
||||
date: v.string(),
|
||||
genres: v.array(v.string()),
|
||||
/** The best lyrics tag among the song's files. */
|
||||
lyrics: v.nullable(v.string()),
|
||||
})
|
||||
),
|
||||
})
|
||||
@@ -1130,7 +1159,7 @@ export const importAlbums = internalMutation({
|
||||
)?._id ??
|
||||
(await ctx.db.insert("albums", { ...entry.album, artist: artistId }))
|
||||
|
||||
for (const song of entry.songs) {
|
||||
for (const { lyrics, ...song } of entry.songs) {
|
||||
const existing = await ctx.db
|
||||
.query("songs")
|
||||
.withIndex("by_all", (q) =>
|
||||
@@ -1146,11 +1175,12 @@ export const importAlbums = internalMutation({
|
||||
})
|
||||
continue
|
||||
}
|
||||
await ctx.db.insert("songs", {
|
||||
const songId = await ctx.db.insert("songs", {
|
||||
...song,
|
||||
album: albumId,
|
||||
albumArtist: artistId,
|
||||
})
|
||||
await writeSongLyrics(ctx, songId, lyrics)
|
||||
}
|
||||
}
|
||||
},
|
||||
@@ -1162,6 +1192,7 @@ export const deleteSongs = internalMutation({
|
||||
handler: async (ctx, args) => {
|
||||
for (const id of args.ids) {
|
||||
await ctx.db.delete("songs", id)
|
||||
await deleteSongLyrics(ctx, id)
|
||||
}
|
||||
await purgeSongsFromUsersAndPlaylists(ctx, new Set(args.ids))
|
||||
await recordIntentCatalogChanges(ctx, "song", args.ids, true)
|
||||
|
||||
@@ -0,0 +1,129 @@
|
||||
import { getAuthUserId } from "@convex-dev/auth/server"
|
||||
import { v } from "convex/values"
|
||||
|
||||
import type { Id } from "./_generated/dataModel"
|
||||
import {
|
||||
internalMutation,
|
||||
query,
|
||||
type MutationCtx,
|
||||
type QueryCtx,
|
||||
} from "./_generated/server"
|
||||
import { matchLyrics, parseLyrics, plainLyrics } from "../client/lyrics"
|
||||
|
||||
/** Shorter searches match too much of every song to be useful. */
|
||||
const MIN_LYRICS_QUERY_LENGTH = 3
|
||||
|
||||
/** The largest page a search index returns. */
|
||||
const MAX_LYRICS_MATCHES = 1_024
|
||||
|
||||
/**
|
||||
* Replaces a song's lyrics, or removes them when `text` is null or holds no
|
||||
* lyrics, and marks the song as read for lyrics.
|
||||
*/
|
||||
export async function writeSongLyrics(
|
||||
ctx: MutationCtx,
|
||||
songId: Id<"songs">,
|
||||
text: string | null
|
||||
) {
|
||||
const lyrics = text ? parseLyrics(text) : null
|
||||
const [stored, searchable] = await Promise.all([
|
||||
ctx.db
|
||||
.query("lyrics")
|
||||
.withIndex("by_song", (q) => q.eq("song", songId))
|
||||
.first(),
|
||||
ctx.db
|
||||
.query("lyricsSearch")
|
||||
.withIndex("by_song", (q) => q.eq("song", songId))
|
||||
.first(),
|
||||
])
|
||||
await ctx.db.patch("songs", songId, { hasLyrics: lyrics !== null })
|
||||
|
||||
if (!lyrics || !text) {
|
||||
if (stored) await ctx.db.delete("lyrics", stored._id)
|
||||
if (searchable) await ctx.db.delete("lyricsSearch", searchable._id)
|
||||
return
|
||||
}
|
||||
const plain = plainLyrics(lyrics)
|
||||
if (stored) await ctx.db.patch("lyrics", stored._id, { text })
|
||||
else await ctx.db.insert("lyrics", { song: songId, text })
|
||||
if (searchable) await ctx.db.patch("lyricsSearch", searchable._id, { plain })
|
||||
else await ctx.db.insert("lyricsSearch", { song: songId, plain })
|
||||
}
|
||||
|
||||
/** Removes a deleted song's lyrics. */
|
||||
export async function deleteSongLyrics(ctx: MutationCtx, songId: Id<"songs">) {
|
||||
for (const table of ["lyrics", "lyricsSearch"] as const) {
|
||||
const row = await ctx.db
|
||||
.query(table)
|
||||
.withIndex("by_song", (q) => q.eq("song", songId))
|
||||
.first()
|
||||
if (row) await ctx.db.delete(table, row._id)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Songs with a lyrics line matching `query` (see `matchLyrics`), with that
|
||||
* line. Lines holding the query as typed come first, then the search index's
|
||||
* relevance order. The index matches words anywhere in the lyrics, so its
|
||||
* results are checked line by line.
|
||||
*/
|
||||
export async function searchSongLyrics(
|
||||
ctx: QueryCtx,
|
||||
query: string,
|
||||
limit: number
|
||||
): Promise<{ song: Id<"songs">; snippet: string }[]> {
|
||||
const text = query.trim()
|
||||
if (text.length < MIN_LYRICS_QUERY_LENGTH) return []
|
||||
const rows = await ctx.db
|
||||
.query("lyricsSearch")
|
||||
.withSearchIndex("search_plain", (q) => q.search("plain", text))
|
||||
.take(limit)
|
||||
const matches = rows.flatMap((row) => {
|
||||
const match = matchLyrics(row.plain, text)
|
||||
return match ? [{ song: row.song, ...match }] : []
|
||||
})
|
||||
return [
|
||||
...matches.filter((match) => match.exact),
|
||||
...matches.filter((match) => !match.exact),
|
||||
].map(({ song, snippet }) => ({ song, snippet }))
|
||||
}
|
||||
|
||||
/** The song's lyrics tag (see `client/lyrics.ts`), or null without lyrics. */
|
||||
export const forSong = query({
|
||||
args: { id: v.id("songs") },
|
||||
handler: async (ctx, args): Promise<string | null> => {
|
||||
if ((await getAuthUserId(ctx)) === null) return null
|
||||
const row = await ctx.db
|
||||
.query("lyrics")
|
||||
.withIndex("by_song", (q) => q.eq("song", args.id))
|
||||
.first()
|
||||
return row?.text ?? null
|
||||
},
|
||||
})
|
||||
|
||||
/** Songs whose lyrics match a search, so in-list filters can include them. */
|
||||
export const matchingSongIds = query({
|
||||
args: { query: v.string() },
|
||||
handler: async (ctx, args): Promise<Id<"songs">[]> => {
|
||||
if ((await getAuthUserId(ctx)) === null) return []
|
||||
const matches = await searchSongLyrics(ctx, args.query, MAX_LYRICS_MATCHES)
|
||||
return matches.map((match) => match.song)
|
||||
},
|
||||
})
|
||||
|
||||
/** Stores lyrics the library scan read from files; null marks none found. */
|
||||
export const setSongLyrics = internalMutation({
|
||||
args: {
|
||||
songs: v.array(
|
||||
v.object({ id: v.id("songs"), lyrics: v.nullable(v.string()) })
|
||||
),
|
||||
},
|
||||
handler: async (ctx, args) => {
|
||||
for (const song of args.songs) {
|
||||
// The song may have been deleted since the scan read it.
|
||||
if (await ctx.db.get("songs", song.id)) {
|
||||
await writeSongLyrics(ctx, song.id, song.lyrics)
|
||||
}
|
||||
}
|
||||
},
|
||||
})
|
||||
@@ -140,11 +140,28 @@ export default defineSchema({
|
||||
year: v.number(),
|
||||
date: v.string(),
|
||||
genres: v.array(v.string()),
|
||||
/**
|
||||
* Whether the files have a lyrics tag, stored in `lyrics`. Unset until the
|
||||
* library scan has read the files for lyrics.
|
||||
*/
|
||||
hasLyrics: v.optional(v.boolean()),
|
||||
})
|
||||
.index("by_name", ["name"])
|
||||
.index("by_artist", ["albumArtist"])
|
||||
.index("by_album", ["album"])
|
||||
.index("by_all", ["name", "albumArtist", "album"]),
|
||||
/** A song's lyrics tag as written in its file: plain, LRC, or word-timed LRC. */
|
||||
lyrics: defineTable({
|
||||
song: v.id("songs"),
|
||||
text: v.string(),
|
||||
}).index("by_song", ["song"]),
|
||||
/** The same lyrics without timestamps. Kept apart so search reads only this. */
|
||||
lyricsSearch: defineTable({
|
||||
song: v.id("songs"),
|
||||
plain: v.string(),
|
||||
})
|
||||
.index("by_song", ["song"])
|
||||
.searchIndex("search_plain", { searchField: "plain" }),
|
||||
playlists: defineTable({
|
||||
name: v.string(),
|
||||
owner: v.id("users"),
|
||||
|
||||
@@ -95,11 +95,15 @@ export type SearchTopResultItem =
|
||||
| { kind: "album"; item: BrowseAlbum }
|
||||
| { kind: "artist"; item: BrowseArtist }
|
||||
|
||||
/** A song search result. Songs found only by their lyrics carry the matched line. */
|
||||
export type SearchSong = BrowseSong & { lyricsSnippet?: string }
|
||||
|
||||
export type LibrarySearchResults = {
|
||||
topResults: SearchTopResultItem[]
|
||||
artists: BrowseArtist[]
|
||||
albums: BrowseAlbum[]
|
||||
songs: BrowseSong[]
|
||||
/** Title, artist and album matches, then lyrics matches. */
|
||||
songs: SearchSong[]
|
||||
}
|
||||
|
||||
export type QueueSong = BrowseSong & { queueIndex: number }
|
||||
|
||||
@@ -51,6 +51,14 @@
|
||||
"types": "./client/favorites.ts",
|
||||
"default": "./client/favorites.ts"
|
||||
},
|
||||
"./client/lyrics": {
|
||||
"types": "./client/lyrics.ts",
|
||||
"default": "./client/lyrics.ts"
|
||||
},
|
||||
"./client/lyrics-tags": {
|
||||
"types": "./client/lyrics-tags.ts",
|
||||
"default": "./client/lyrics-tags.ts"
|
||||
},
|
||||
"./client/media-links": {
|
||||
"types": "./client/media-links.ts",
|
||||
"default": "./client/media-links.ts"
|
||||
|
||||
Reference in new issue
Block a user