diff --git a/src/components/core/types.d.ts b/src/components/core/types.d.ts index 9d7db96b..5e6a8eff 100644 --- a/src/components/core/types.d.ts +++ b/src/components/core/types.d.ts @@ -71,16 +71,83 @@ export interface Track { } export interface TrackStats { + /** Album gain in dB */ + albumGain?: number; + + /** Bits per second */ bitrate?: number; + + /** Bit depth */ + bitsPerSample?: number; + + /** Compression algorithm used */ + codec?: string; + + /** Encoding format used */ + container?: string; + + /** Duration in seconds */ duration?: number; + + /** Is track lossless? */ + lossless?: boolean; + + /** Number of audio channels */ + numberOfChannels?: number; + + /** Samples per second */ + sampleRate?: number; + + /** Track gain in dB */ + trackGain?: number; } export interface TrackTags { album?: string; + albumartist?: string; + albumartists?: string[]; + albumartistsort?: string; + albumsort?: string; + arranger?: string[]; artist?: string; + artists?: string[]; + artistsort?: string; + asin?: string; + averageLevel?: number; + barcode?: string; + bpm?: number; + catalognumbers?: string[]; + compilation?: boolean; + composers?: string[]; + composersort?: string; + conductors?: string[]; + date?: string; disc: { no: number; of?: number }; - genre?: string; + djmixers?: string[]; + engineers?: string[]; + gapless?: boolean; + genres?: string[]; + isrc?: string[]; + labels?: string[]; + lyricists?: string[]; + media?: string; + mixers?: string[]; + moods?: string[]; + originaldate?: string; + originalyear?: number; + peakLevel?: number; + producers?: string[]; + publishers?: string[]; + releasecountry?: string; + releasedate?: string; + releasestatus?: string; + releasetypes?: string[]; + remixers?: string[]; + technicians?: string[]; title: string; + titlesort?: string; track: { no: number; of?: number }; + work?: string; + writers?: string[]; year?: number; } diff --git a/src/components/engine/queue/element.js b/src/components/engine/queue/element.js index 17a598ef..013ad285 100644 --- a/src/components/engine/queue/element.js +++ b/src/components/engine/queue/element.js @@ -1,3 +1,5 @@ +import QS from "query-string"; + import { DiffuseElement } from "@common/element.js"; import { signal } from "@common/signal.js"; import { listen, use } from "@common/worker.js"; @@ -17,9 +19,14 @@ class QueueEngine extends DiffuseElement { constructor() { super(); + // Query + const query = QS.stringify({ + "fill-size": this.getAttribute("fill-size"), + }); + // Setup worker const name = `diffuse/engine/queue/${this.group}`; - const url = "/components/engine/queue/worker.js"; + const url = `/components/engine/queue/worker.js?${query}`; let port; diff --git a/src/components/engine/queue/worker.js b/src/components/engine/queue/worker.js index bebef074..42915fef 100644 --- a/src/components/engine/queue/worker.js +++ b/src/components/engine/queue/worker.js @@ -1,3 +1,5 @@ +import QS from "query-string"; + import { announce, define, ostiary } from "@common/worker.js"; import { effect, signal } from "@common/signal.js"; import { arrayShuffle } from "@common/index.js"; @@ -7,7 +9,15 @@ import { arrayShuffle } from "@common/index.js"; * @import {Track} from "@components/core/types.d.ts" */ -const QUEUE_SIZE = 25; +const QUERY = QS.parse(location.search); +const qFillSize = QUERY?.["fill-size"]; + +/** @type {number} */ +const FILL_SIZE = qFillSize && qFillSize !== null + ? Array.isArray(qFillSize) && qFillSize[0] !== null + ? parseInt(qFillSize[0], 10) + : parseInt(/** @type {string} */ (qFillSize), 10) + : 25; //////////////////////////////////////////// // STATE @@ -26,6 +36,7 @@ export const $past = signal(/** @type {Item[]} */ ([])); * @type {Actions['add']} */ export function add({ inFront, items }) { + // TODO: An entry is always manual and should be added in the correct place $future.value = inFront ? [...items, ...$future.value] : [...$future.value, ...items]; @@ -100,7 +111,15 @@ ostiary((port) => { * @returns {Item[]} */ function fill(future) { - if (future.length >= QUEUE_SIZE) return future; + let fillFutureCount = 0; + let manualFutureCount = 0; + + future.forEach((item) => { + if (item.manualEntry) manualFutureCount++; + else fillFutureCount++; + }); + + if (fillFutureCount >= FILL_SIZE) return future; /** @type {Item[]} */ const pool = []; @@ -125,7 +144,7 @@ function fill(future) { const poolSelection = arrayShuffle(reducedPool).slice( 0, - QUEUE_SIZE - future.length, + FILL_SIZE - fillFutureCount, ); return [...future, ...poolSelection]; diff --git a/src/components/input/opensubsonic/worker.js b/src/components/input/opensubsonic/worker.js index 02e81c9f..933a0f2f 100644 --- a/src/components/input/opensubsonic/worker.js +++ b/src/components/input/opensubsonic/worker.js @@ -153,16 +153,71 @@ export async function list(cachedTracks = []) { uri: buildURI(server, { songId: song.id, path }), stats: { - bitrate: song.bitRate, + albumGain: undefined, + bitrate: song.bitRate ? song.bitRate * 1000 : undefined, + bitsPerSample: undefined, + codec: undefined, + container: undefined, duration: song.duration, + lossless: undefined, + numberOfChannels: undefined, + sampleRate: undefined, + trackGain: undefined, }, tags: { album: song.album, - artist: song.artist, - disc: { no: song.discNumber || 1 }, - genre: song.genre, - title: song.title, - track: { no: song.track || 1 }, + albumartist: song.albumArtists?.[0]?.name, + albumartists: song.albumArtists?.map((a) => a.name), + albumartistsort: song.albumArtists?.[0]?.sortName, + albumsort: undefined, + arranger: undefined, + artist: song.artist ?? song.displayArtist, + artists: undefined, + artistsort: undefined, + asin: undefined, + averageLevel: undefined, + barcode: undefined, + bpm: song.bpm, + catalognumbers: undefined, + compilation: undefined, + composers: song.displayComposer + ? [song.displayComposer] + : undefined, + composersort: undefined, + conductors: undefined, + date: undefined, + disc: { + no: song.discNumber || 1, + }, + djmixers: undefined, + engineers: undefined, + gapless: undefined, + genres: song.genres, + isrc: undefined, + labels: undefined, + lyricists: undefined, + media: undefined, + mixers: undefined, + moods: song.moods, + originaldate: undefined, + originalyear: undefined, + peakLevel: undefined, + producers: undefined, + publishers: undefined, + releasecountry: undefined, + releasedate: undefined, + releasestatus: undefined, + releasetypes: undefined, + remixers: undefined, + technicians: undefined, + title: song.title ?? "Unknown", + titlesort: undefined, + track: { + no: song.track ?? 1, + of: song.size, + }, + work: undefined, + writers: undefined, year: song.year, }, }; diff --git a/src/components/orchestrator/queue-tracks/element.js b/src/components/orchestrator/queue-tracks/element.js index b995b3e0..977a32ae 100644 --- a/src/components/orchestrator/queue-tracks/element.js +++ b/src/components/orchestrator/queue-tracks/element.js @@ -41,7 +41,10 @@ class QueueTracksOrchestrator extends DiffuseElement { // Watch tracks collection this.effect(() => { - const tracks = this.output.tracks.collection(); + const tracks = this.output.tracks.collection().filter((t) => + t.kind !== "placeholder" + ); + untracked(() => this.poolAvailable(tracks)); }); } diff --git a/src/components/orchestrator/search-tracks/element.js b/src/components/orchestrator/search-tracks/element.js index 88ecb032..856dca8f 100644 --- a/src/components/orchestrator/search-tracks/element.js +++ b/src/components/orchestrator/search-tracks/element.js @@ -40,7 +40,10 @@ class SearchTracksOrchestrator extends DiffuseElement { // Watch tracks collection this.effect(() => { - const tracks = this.output.tracks.collection(); + const tracks = this.output.tracks.collection().filter((t) => + t.kind !== "placeholder" + ); + this.supplyAvailable(tracks); }); } diff --git a/src/components/processor/metadata/common.js b/src/components/processor/metadata/common.js index 2df23008..bfef8b82 100644 --- a/src/components/processor/metadata/common.js +++ b/src/components/processor/metadata/common.js @@ -55,25 +55,76 @@ export async function musicMetadataTags({ /** @type {TrackStats} */ const stats = { + albumGain: meta.format.albumGain, + bitrate: meta.format.bitrate, + bitsPerSample: meta.format.bitsPerSample, + codec: meta.format.codec, + container: meta.format.container, duration: meta.format.duration, + lossless: meta.format.lossless, + numberOfChannels: meta.format.numberOfChannels, + sampleRate: meta.format.sampleRate, + trackGain: meta.format.trackGain, }; /** @type {TrackTags} */ const tags = { album: meta.common.album, + albumartist: meta.common.albumartist, + albumartists: meta.common.albumartists ?? + (meta.common.albumartist ? [meta.common.albumartist] : []), + albumartistsort: meta.common.albumartistsort, + albumsort: meta.common.albumsort, + arranger: meta.common.arranger, artist: meta.common.artist, + artists: meta.common.artists ?? + (meta.common.artist ? [meta.common.artist] : []), + artistsort: meta.common.artistsort, + asin: meta.common.asin, + averageLevel: meta.common.averageLevel, + barcode: meta.common.barcode, + bpm: meta.common.bpm, + catalognumbers: meta.common.catalognumber, + compilation: meta.common.compilation, + composers: meta.common.composer, + composersort: meta.common.composersort, + conductors: meta.common.conductor, + date: meta.common.date, disc: { no: meta.common.disk.no || 1, of: meta.common.disk.of ?? undefined, }, - genre: Array.isArray(meta.common.genre) - ? meta.common.genre[0] - : meta.common.genre, + djmixers: meta.common.djmixer, + engineers: meta.common.engineer, + gapless: meta.common.gapless, + genres: Array.isArray(meta.common.genre) + ? meta.common.genre + : [meta.common.genre], + isrc: meta.common.isrc, + labels: meta.common.label, + lyricists: meta.common.lyricist, + media: meta.common.media, + mixers: meta.common.mixer, + moods: meta.common.mood, + originaldate: meta.common.originaldate, + originalyear: meta.common.originalyear, + peakLevel: meta.common.peakLevel, + producers: meta.common.producer, + publishers: meta.common.publisher, + releasecountry: meta.common.releasecountry, + releasedate: meta.common.releasedate, + releasestatus: meta.common.releasestatus, + releasetypes: meta.common.releasetype, + remixers: meta.common.remixer, + technicians: meta.common.technician, title: meta.common.title || filename || urls?.head || "Unknown", + titlesort: meta.common.titlesort, track: { no: meta.common.track.no || 1, of: meta.common.track.of ?? undefined, }, + work: meta.common.work, + writers: meta.common.writer, year: meta.common.year, }; diff --git a/src/themes/webamp/browser/element.js b/src/themes/webamp/browser/element.js index adb903cf..2920f6eb 100644 --- a/src/themes/webamp/browser/element.js +++ b/src/themes/webamp/browser/element.js @@ -20,9 +20,6 @@ class Browser extends DiffuseElement { /** @type {import("@components/engine/queue/element.js").CLASS} */ this.queue = query(this, "queue-selector"); - - /** @type {import("../webamp.js").CLASS} */ - this.amp = query(this, "webamp-selector"); } // LIFECYCLE @@ -67,16 +64,12 @@ class Browser extends DiffuseElement { * @param {Track} track */ playTrack(track) { - console.log("Play track", track); - // this.queue.add({ - // inFront: true, - // items: [ - // { ...track, manualEntry: true }, - // ], - // }); - - this.amp.addTrack(track); - this.amp.amp.setCurrentTrack(this.amp.amp.getPlaylistTracks().length - 1); + this.queue.add({ + inFront: true, + items: [ + { ...track, manualEntry: true }, + ], + }); } // RENDER diff --git a/src/themes/webamp/index.js b/src/themes/webamp/index.js index 1dfbd416..6bedb367 100644 --- a/src/themes/webamp/index.js +++ b/src/themes/webamp/index.js @@ -1,5 +1,3 @@ -import deepDiff from "@fry69/deep-diff"; - // import "@components/orchestrator/process-tracks/element.js"; import "@components/orchestrator/queue-tracks/element.js"; import "@components/output/indexed-db/element.js"; @@ -14,14 +12,7 @@ import { effect, signal, untracked } from "@common/signal.js"; import "./browser/element.js"; import "./window/element.js"; import "./window-manager/element.js"; -import WebampElement from "./webamp.js"; -import { xxh32 } from "xxh32"; - -/** - * @import {URLTrack} from "webamp" - * - * @import {Item} from "@components/engine/queue/types.d.ts" - */ +import WebampElement from "./webamp/element.js"; const input = component(Input); const queue = component(Queue); @@ -32,10 +23,12 @@ globalThis.queue = queue; // 📡 //////////////////////////////////////////// -let currBase = 0; +const currBase = 0; const $currTrack = signal(/** @type {null | number} */ (null)); -const $playlist = signal(/** @type {Item[]} */ ([])); +const $playlist = signal(/** @type {Set} */ (new Set()), { + eager: true, +}); //////////////////////////////////////////// // ⚡️ @@ -91,35 +84,31 @@ effect(() => { ...future, ]; - const hashNew = xxh32(JSON.stringify(playlist.map((i) => i.id))); - const hashOld = xxh32( - JSON.stringify(untracked($playlist.get).map((i) => i.id)), - ); - - if (hashNew === hashOld) return; - - const webampTracks = playlist.map((item, idx) => { - /** @type {URLTrack} */ - const urlTrack = { - url: item.uri, - metaData: { - title: item.tags?.title || "", - artist: item.tags?.artist || "", - album: item.tags?.album, - }, - duration: item.stats?.duration, - }; - - if (item.stats?.duration == undefined) { - throw new Error("TODO: Fetch duration"); - } - return urlTrack; + const oldSet = untracked($playlist.get); + const newSet = new Set(playlist.map((i) => i.id)); + + const addedItems = newSet.difference(oldSet); + + // TODO: Can't do removals yet without resetting the webamp instance. + // const removedItems = oldSet.difference(newSet); + + if (addedItems.size === 0) return; + + playlist.forEach((item, idx) => { + if (addedItems.has(item.id) === false) return; + + // TODO + if (item.stats?.duration == undefined) return; + + // TODO: Inserting at a specific index doesn't work + ampElement.addTrack(item); }); - // currBase = currBase + amp.getPlaylistTracks().length; - // amp.setCurrentTrack(currBase + (untracked($currTrack.get) ?? 0)); + if (untracked($currTrack.get) === null) { + amp.setCurrentTrack(past.length); + } - $playlist.value = playlist; + $playlist.value = newSet; }); /** @@ -127,11 +116,9 @@ effect(() => { * reflect the change in our queue too. */ effect(() => { - console.log("CURR", $currTrack.value); - - // if (($currTrack.value ?? 0) > untracked(queue.past).length) { - // queue.shift(); - // } + if (($currTrack.value ?? 0) > untracked(queue.past).length) { + queue.shift(); + } }); //////////////////////////////////////////// diff --git a/src/themes/webamp/index.vto b/src/themes/webamp/index.vto index c31ea4cd..a0d50f40 100644 --- a/src/themes/webamp/index.vto +++ b/src/themes/webamp/index.vto @@ -33,7 +33,6 @@ input-selector="di-opensubsonic" output-selector="do-indexed-db" queue-selector="de-queue" - webamp-selector="dtw-webamp" > @@ -71,7 +70,7 @@ COMPONENTS --> - + diff --git a/src/themes/webamp/webamp.js b/src/themes/webamp/webamp/element.js similarity index 89% rename from src/themes/webamp/webamp.js rename to src/themes/webamp/webamp/element.js index 71c41482..d368f901 100644 --- a/src/themes/webamp/webamp.js +++ b/src/themes/webamp/webamp/element.js @@ -75,12 +75,9 @@ class WebampElement extends HTMLElement { artist: track.tags?.artist, title: track.tags?.title, album: track.tags?.album, - // For now, we lie about these next three things. - // TODO: Ideally we would leave these as null and force a media data - // fetch when the user starts playing. - sampleRate: 44000, - bitrate: 192000, - numberOfChannels: 2, + sampleRate: track.stats?.sampleRate ?? 44000, + bitrate: track.stats?.bitrate ?? 192000, + numberOfChannels: 2, // TODO id: idx, }); },