use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use prolink_proto::Slot;
use prolink_rekordbox::{AnlzFile, Library};
use crate::media::MediaDescription;
use crate::serve::folder::{FolderTree, WalkLimits};
use crate::serve::tags::{self, FileTags};
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct ServedSlot(Slot);
impl ServedSlot {
pub const SD: Self = Self(Slot::SD);
pub const USB: Self = Self(Slot::USB);
pub const fn new(slot: Slot) -> Option<Self> {
match slot {
Slot::SD | Slot::USB => Some(Self(slot)),
_ => None,
}
}
pub const fn slot(self) -> Slot {
self.0
}
pub const fn export_path(self) -> &'static str {
match self.0 {
Slot::SD => "/B/",
_ => "/C/",
}
}
pub const fn vfs_prefix(self) -> &'static str {
match self.0 {
Slot::SD => "B",
_ => "C",
}
}
}
#[derive(Debug, Default)]
pub struct Analysis {
pub dat: Option<AnlzFile>,
pub ext: Option<AnlzFile>,
}
impl Analysis {
pub fn payload(&self, fourcc: prolink_rekordbox::FourCc) -> &[u8] {
self.dat
.as_ref()
.and_then(|file| file.payload(fourcc))
.or_else(|| self.ext.as_ref().and_then(|file| file.payload(fourcc)))
.unwrap_or_default()
}
}
#[derive(Debug)]
pub struct Medium {
slot: ServedSlot,
library: Library,
folders: Option<FolderTree>,
root: Option<PathBuf>,
volume_name: String,
created: String,
settings: Vec<u8>,
size: Option<(u64, u64)>,
tags: Mutex<BTreeMap<u32, Arc<FileTags>>>,
covers: Mutex<Covers>,
analysis: Mutex<BTreeMap<u32, Arc<Analysis>>>,
artwork: Mutex<BTreeMap<u32, Arc<Vec<u8>>>>,
phantom: AtomicBool,
}
pub const COVER_BUDGET: usize = 4 * 1024 * 1024;
#[derive(Debug, Default)]
struct Covers {
recent: Vec<(u32, Arc<Vec<u8>>)>,
recent_bytes: usize,
loaded: BTreeMap<u32, Arc<Vec<u8>>>,
}
impl Covers {
fn get(&mut self, file_id: u32) -> Option<Arc<Vec<u8>>> {
if let Some(held) = self.loaded.get(&file_id) {
return Some(Arc::clone(held));
}
let at = self.recent.iter().position(|(id, _)| *id == file_id)?;
let entry = self.recent.remove(at);
let held = Arc::clone(&entry.1);
self.recent.push(entry);
Some(held)
}
fn remember(&mut self, file_id: u32, cover: Arc<Vec<u8>>) {
if self.loaded.contains_key(&file_id) || self.recent.iter().any(|(id, _)| *id == file_id) {
return;
}
self.recent_bytes += cover.len();
self.recent.push((file_id, cover));
while self.recent_bytes > COVER_BUDGET && self.recent.len() > 1 {
let (_, gone) = self.recent.remove(0);
self.recent_bytes -= gone.len();
}
}
fn keep(&mut self, file_id: u32, cover: Arc<Vec<u8>>) {
if let Some(at) = self.recent.iter().position(|(id, _)| *id == file_id) {
let (_, moved) = self.recent.remove(at);
self.recent_bytes -= moved.len();
}
self.loaded.insert(file_id, cover);
}
fn bytes(&self) -> usize {
self.recent_bytes + self.loaded.values().map(|cover| cover.len()).sum::<usize>()
}
}
impl Medium {
pub const PDB_PATH: &'static str = "PIONEER/rekordbox/export.pdb";
pub const SETTINGS_PATH: &'static str = "PIONEER/MYSETTING.DAT";
pub fn open(volume: &Path, slot: ServedSlot) -> crate::Result<Self> {
if volume.join(Self::PDB_PATH).is_file() {
Self::from_volume(volume, slot)
} else {
Self::from_folders(volume, slot)
}
}
pub fn from_volume(volume: &Path, slot: ServedSlot) -> crate::Result<Self> {
let pdb = std::fs::read(volume.join(Self::PDB_PATH))
.map_err(crate::Error::io("reading export.pdb"))?;
let library = Library::parse(&pdb)?;
let settings = Self::read_settings(volume);
let volume_name = volume
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_default();
Ok(Self {
slot,
library,
folders: None,
root: Some(volume.to_path_buf()),
volume_name,
created: String::new(),
settings,
size: crate::volumes::size_of(volume),
tags: Mutex::new(BTreeMap::new()),
covers: Mutex::new(Covers::default()),
analysis: Mutex::new(BTreeMap::new()),
artwork: Mutex::new(BTreeMap::new()),
phantom: AtomicBool::new(false),
})
}
pub fn from_folders(volume: &Path, slot: ServedSlot) -> crate::Result<Self> {
let folders = FolderTree::walk(volume, WalkLimits::default())
.map_err(crate::Error::io("listing a plain medium"))?;
if folders.is_empty() {
return Err(crate::Error::NoMusic {
path: volume.to_path_buf(),
});
}
if folders.is_truncated() {
tracing::warn!(
path = %volume.display(),
files = folders.file_count(),
"a plain medium past the walk's limits; serving what was found"
);
}
Ok(Self {
slot,
library: Library::default(),
folders: Some(folders),
root: Some(volume.to_path_buf()),
volume_name: crate::volumes::label_of(volume),
created: String::new(),
settings: Self::read_settings(volume),
size: crate::volumes::size_of(volume),
tags: Mutex::new(BTreeMap::new()),
covers: Mutex::new(Covers::default()),
analysis: Mutex::new(BTreeMap::new()),
artwork: Mutex::new(BTreeMap::new()),
phantom: AtomicBool::new(false),
})
}
pub fn synthetic(slot: ServedSlot, library: Library, volume_name: &str) -> Self {
Self {
slot,
library,
folders: None,
root: None,
volume_name: volume_name.to_owned(),
created: String::new(),
settings: Vec::new(),
size: None,
tags: Mutex::new(BTreeMap::new()),
covers: Mutex::new(Covers::default()),
analysis: Mutex::new(BTreeMap::new()),
artwork: Mutex::new(BTreeMap::new()),
phantom: AtomicBool::new(false),
}
}
fn read_settings(volume: &Path) -> Vec<u8> {
std::fs::read(volume.join(Self::SETTINGS_PATH))
.ok()
.and_then(|raw| prolink_rekordbox::SettingsFile::parse(&raw).ok())
.map(|file| file.wire_settings().to_vec())
.unwrap_or_default()
}
pub fn slot(&self) -> ServedSlot {
self.slot
}
pub fn library(&self) -> &Library {
&self.library
}
pub fn folders(&self) -> Option<&FolderTree> {
self.folders.as_ref()
}
pub fn is_plain(&self) -> bool {
self.folders.is_some()
}
pub fn track_count(&self) -> usize {
self.folders
.as_ref()
.map_or(self.library.tracks.len(), FolderTree::file_count)
}
pub fn tags(&self, file_id: u32) -> Option<Arc<FileTags>> {
let file = self.folders.as_ref()?.file(file_id)?;
if let Ok(cache) = self.tags.lock()
&& let Some(held) = cache.get(&file_id)
{
return Some(Arc::clone(held));
}
let read = Arc::new(match self.root.as_deref() {
Some(root) if !self.is_phantom() => tags::read(&root.join(&file.relative), file),
_ => FileTags::untagged(file),
});
if read.is_read()
&& let Ok(mut cache) = self.tags.lock()
{
cache.insert(file_id, Arc::clone(&read));
}
Some(read)
}
pub fn track_files(&self, track_id: u32) -> Vec<String> {
if let Some(folders) = &self.folders {
return folders
.file(track_id)
.map(|file| vec![file.relative.clone()])
.unwrap_or_default();
}
let Some(track) = self.library.tracks.get(&track_id) else {
return Vec::new();
};
let mut wanted = vec![track.file_path.clone(), track.analyze_path.clone()];
if let Some(ext) = track.analyze_ext_path() {
wanted.push(ext);
}
wanted
.into_iter()
.map(|path| path.trim_start_matches('/').to_owned())
.filter(|path| !path.is_empty())
.collect()
}
pub fn root(&self) -> Option<&Path> {
self.root.as_deref()
}
pub fn volume_name(&self) -> &str {
&self.volume_name
}
pub fn settings(&self) -> &[u8] {
&self.settings
}
pub fn description(&self) -> MediaDescription {
MediaDescription {
volume_name: self.volume_name.clone(),
created: self.created.clone(),
track_count: if self.is_plain() {
0
} else {
u32::try_from(self.library.tracks.len()).unwrap_or(u32::MAX)
},
playlist_count: u32::try_from(
self.library
.playlists
.values()
.filter(|playlist| !playlist.is_folder)
.count(),
)
.unwrap_or(u32::MAX),
total_bytes: self.size.map(|(total, _)| total),
free_bytes: self.size.map(|(_, free)| free),
plain: self.is_plain(),
}
}
fn cover(&self, file_id: u32) -> Option<Arc<Vec<u8>>> {
let file = self.folders.as_ref()?.file(file_id)?;
if let Ok(mut covers) = self.covers.lock()
&& let Some(held) = covers.get(file_id)
{
return Some(held);
}
let cover = Arc::new(match self.root.as_deref() {
Some(root) if !self.is_phantom() => tags::cover(&root.join(&file.relative)),
_ => Vec::new(),
});
if !cover.is_empty()
&& let Ok(mut covers) = self.covers.lock()
{
covers.remember(file_id, Arc::clone(&cover));
}
Some(cover)
}
pub fn cover_bytes(&self) -> usize {
self.covers.lock().map_or(0, |covers| covers.bytes())
}
pub fn artwork(&self, artwork_id: u32) -> Vec<u8> {
if self.folders.is_some() {
return self
.cover(artwork_id)
.map(|cover| cover.as_ref().clone())
.unwrap_or_default();
}
if let Ok(cache) = self.artwork.lock()
&& let Some(held) = cache.get(&artwork_id)
{
return held.as_ref().clone();
}
let (Some(root), Some(path)) =
(self.root.as_deref(), self.library.artwork.get(&artwork_id))
else {
return Vec::new();
};
let bytes = std::fs::read(root.join(path.trim_start_matches('/'))).unwrap_or_default();
if !bytes.is_empty()
&& let Ok(mut cache) = self.artwork.lock()
{
cache.insert(artwork_id, Arc::new(bytes.clone()));
}
bytes
}
pub fn warm(&self, track_id: u32) {
if self.folders.is_some() {
let _ = self.tags(track_id);
if let Some(cover) = self.cover(track_id)
&& !cover.is_empty()
&& let Ok(mut covers) = self.covers.lock()
{
covers.keep(track_id, cover);
}
return;
}
let _ = self.analysis(track_id);
if let Some(track) = self.library.tracks.get(&track_id)
&& track.artwork_id != 0
{
let _ = self.artwork(track.artwork_id);
}
}
pub fn is_phantom(&self) -> bool {
self.phantom.load(Ordering::Relaxed)
}
pub fn go_phantom(&self) {
self.phantom.store(true, Ordering::Relaxed);
}
pub fn analysis(&self, track_id: u32) -> Arc<Analysis> {
if let Ok(cache) = self.analysis.lock()
&& let Some(cached) = cache.get(&track_id)
{
return Arc::clone(cached);
}
let parsed = Arc::new(self.read_analysis(track_id));
if let Ok(mut cache) = self.analysis.lock() {
cache.insert(track_id, Arc::clone(&parsed));
}
parsed
}
fn read_analysis(&self, track_id: u32) -> Analysis {
let (Some(root), Some(track)) = (self.root.as_deref(), self.library.tracks.get(&track_id))
else {
return Analysis::default();
};
let load = |relative: &str| {
if relative.is_empty() {
return None;
}
let bytes = std::fs::read(root.join(relative.trim_start_matches('/'))).ok()?;
AnlzFile::parse(&bytes).ok()
};
Analysis {
dat: load(&track.analyze_path),
ext: track.analyze_ext_path().as_deref().and_then(load),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_sd_and_usb_can_be_served() {
assert_eq!(ServedSlot::new(Slot::USB), Some(ServedSlot::USB));
assert_eq!(ServedSlot::new(Slot::SD), Some(ServedSlot::SD));
assert_eq!(
ServedSlot::new(Slot::CD),
None,
"a CD has no rekordbox export"
);
assert_eq!(ServedSlot::new(Slot::REKORDBOX), None);
assert_eq!(ServedSlot::new(Slot::NONE), None);
}
#[test]
fn a_slot_knows_where_it_is_exported_from() {
assert_eq!(ServedSlot::SD.export_path(), "/B/");
assert_eq!(ServedSlot::USB.export_path(), "/C/");
}
fn wav() -> Vec<u8> {
fn chunk(id: [u8; 4], body: &[u8]) -> Vec<u8> {
let mut out = id.to_vec();
let len = u32::try_from(body.len()).expect("a small chunk");
out.extend_from_slice(&len.to_le_bytes());
out.extend_from_slice(body);
out
}
let mut format = Vec::new();
for word in [1u16, 2] {
format.extend_from_slice(&word.to_le_bytes());
}
format.extend_from_slice(&44_100u32.to_le_bytes());
format.extend_from_slice(&(44_100u32 * 4).to_le_bytes());
format.extend_from_slice(&4u16.to_le_bytes());
format.extend_from_slice(&16u16.to_le_bytes());
let mut body = b"WAVE".to_vec();
body.extend(chunk(*b"fmt ", &format));
body.extend(chunk(*b"data", &[0u8; 1764]));
chunk(*b"RIFF", &body)
}
fn plain_stick(test: &str, files: usize, cover: usize) -> PathBuf {
let root =
std::env::temp_dir().join(format!("prolink-medium-{test}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).expect("a temporary stick");
let audio = wav();
for n in 0..files {
std::fs::write(root.join(format!("{n:04}.wav")), &audio).expect("a file");
}
let mut jpeg = vec![0xff, 0xd8, 0xff, 0xe0];
jpeg.resize(cover, 0x5a);
std::fs::write(root.join("cover.jpg"), &jpeg).expect("a cover");
root
}
fn file_ids(medium: &Medium) -> Vec<u32> {
medium
.folders()
.expect("a plain medium's folders")
.files()
.map(|file| file.id)
.collect()
}
#[test]
fn a_plain_files_tags_hold_no_picture() {
let root = plain_stick("tags", 40, 200_000);
let medium = Medium::from_folders(&root, ServedSlot::USB).expect("a plain medium");
let ids = file_ids(&medium);
assert_eq!(ids.len(), 40);
for &id in &ids {
let tags = medium.tags(id).expect("a file of the stick");
assert!(tags.is_read(), "file {id} reads");
}
assert_eq!(
medium.cover_bytes(),
0,
"the tags of every file hold no cover"
);
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn a_plain_mediums_covers_are_few_and_a_loaded_files_stays() {
let root = plain_stick("covers", 60, 200_000);
let medium = Medium::from_folders(&root, ServedSlot::USB).expect("a plain medium");
let ids = file_ids(&medium);
for &id in &ids {
assert_eq!(medium.artwork(id).len(), 200_000, "the folder's picture");
}
assert!(
medium.cover_bytes() <= COVER_BUDGET,
"{} bytes of covers held",
medium.cover_bytes()
);
let loaded = ids[0];
medium.warm(loaded);
medium.go_phantom();
assert_eq!(
medium.artwork(loaded).len(),
200_000,
"kept for the phantom"
);
assert!(
medium.artwork(ids[1]).is_empty(),
"asked for long ago: not kept, and a phantom reads nothing"
);
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn two_media_occupy_different_subtrees() {
assert_ne!(ServedSlot::SD.vfs_prefix(), ServedSlot::USB.vfs_prefix());
}
}