Move the files around

crates/musicfs-metadata/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "musicfs-metadata"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+musicfs-core = { path = "../musicfs-core" }
+symphonia.workspace = true
+thiserror.workspace = true
+tracing.workspace = true
+image.workspace = true

crates/musicfs-metadata/src/artwork.rs

@@ -0,0 +1,116 @@
+use image::ImageFormat;
+use std::io::Cursor;
+use symphonia::core::meta::Visual;
+use tracing::debug;
+
+#[derive(Debug, Clone)]
+pub struct Artwork {
+    pub art_type: ArtType,
+    pub mime_type: String,
+    pub width: u32,
+    pub height: u32,
+    pub data: Vec<u8>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ArtType {
+    Front,
+    Back,
+    Other,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum ArtSize {
+    Thumbnail,
+    Medium,
+    Full,
+}
+
+impl ArtSize {
+    pub fn max_dimension(&self) -> Option<u32> {
+        match self {
+            ArtSize::Thumbnail => Some(150),
+            ArtSize::Medium => Some(300),
+            ArtSize::Full => None,
+        }
+    }
+}
+
+pub struct ArtworkExtractor;
+
+impl ArtworkExtractor {
+    pub fn extract_from_visual(visual: &Visual) -> Option<Artwork> {
+        let data = visual.data.to_vec();
+
+        let img = image::load_from_memory(&data).ok()?;
+
+        let art_type = match visual.usage {
+            Some(symphonia::core::meta::StandardVisualKey::FrontCover) => ArtType::Front,
+            Some(symphonia::core::meta::StandardVisualKey::BackCover) => ArtType::Back,
+            _ => ArtType::Other,
+        };
+
+        let mime_type = if visual.media_type.is_empty() {
+            "image/jpeg".to_string()
+        } else {
+            visual.media_type.clone()
+        };
+
+        Some(Artwork {
+            art_type,
+            mime_type,
+            width: img.width(),
+            height: img.height(),
+            data,
+        })
+    }
+
+    pub fn resize(artwork: &Artwork, size: ArtSize) -> Option<Artwork> {
+        let max_dim = size.max_dimension()?;
+
+        if artwork.width <= max_dim && artwork.height <= max_dim {
+            return Some(artwork.clone());
+        }
+
+        let img = image::load_from_memory(&artwork.data).ok()?;
+        let resized = img.thumbnail(max_dim, max_dim);
+
+        let mut output = Vec::new();
+        let mut cursor = Cursor::new(&mut output);
+        resized.write_to(&mut cursor, ImageFormat::Jpeg).ok()?;
+
+        debug!(
+            "Resized artwork from {}x{} to {}x{}",
+            artwork.width,
+            artwork.height,
+            resized.width(),
+            resized.height()
+        );
+
+        Some(Artwork {
+            art_type: artwork.art_type,
+            mime_type: "image/jpeg".to_string(),
+            width: resized.width(),
+            height: resized.height(),
+            data: output,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_art_size_dimensions() {
+        assert_eq!(ArtSize::Thumbnail.max_dimension(), Some(150));
+        assert_eq!(ArtSize::Medium.max_dimension(), Some(300));
+        assert_eq!(ArtSize::Full.max_dimension(), None);
+    }
+
+    #[test]
+    fn test_art_type_equality() {
+        assert_eq!(ArtType::Front, ArtType::Front);
+        assert_ne!(ArtType::Front, ArtType::Back);
+    }
+}

crates/musicfs-metadata/src/lib.rs

@@ -0,0 +1,5 @@
+pub mod artwork;
+mod parser;
+
+pub use artwork::{ArtSize, ArtType, Artwork, ArtworkExtractor};
+pub use parser::MetadataParser;

crates/musicfs-metadata/src/parser.rs

@@ -0,0 +1,132 @@
+use musicfs_core::{AudioFormat, AudioMeta, Error, Result};
+use std::fs::File;
+use std::path::Path;
+use symphonia::core::codecs::CODEC_TYPE_NULL;
+use symphonia::core::formats::FormatOptions;
+use symphonia::core::io::MediaSourceStream;
+use symphonia::core::meta::MetadataOptions;
+use symphonia::core::probe::Hint;
+use tracing::debug;
+
+pub struct MetadataParser;
+
+impl MetadataParser {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn parse_file(&self, path: &Path) -> Result<AudioMeta> {
+        let file = File::open(path)?;
+        let mss = MediaSourceStream::new(Box::new(file), Default::default());
+
+        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+
+        let mut hint = Hint::new();
+        if !ext.is_empty() {
+            hint.with_extension(ext);
+        }
+
+        let fmt_opts = FormatOptions::default();
+        let meta_opts = MetadataOptions::default();
+
+        let probed = symphonia::default::get_probe()
+            .format(&hint, mss, &fmt_opts, &meta_opts)
+            .map_err(|e| Error::Metadata(format!("Failed to probe format: {}", e)))?;
+        let mut format = probed.format;
+
+        let mut audio_meta = AudioMeta {
+            format: AudioFormat::from_extension(ext),
+            ..Default::default()
+        };
+
+        if let Some(metadata) = format.metadata().current() {
+            self.extract_tags(&mut audio_meta, metadata);
+        }
+
+        if let Some(track) = format
+            .tracks()
+            .iter()
+            .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
+        {
+            let params = &track.codec_params;
+
+            if let Some(n_frames) = params.n_frames {
+                if let Some(sample_rate) = params.sample_rate {
+                    audio_meta.duration_ms = Some((n_frames as u64 * 1000) / sample_rate as u64);
+                    audio_meta.sample_rate = Some(sample_rate);
+                }
+            }
+
+            if let Some(bits_per_sample) = params.bits_per_sample {
+                if let Some(sample_rate) = params.sample_rate {
+                    if let Some(channels) = params.channels {
+                        audio_meta.bitrate =
+                            Some(bits_per_sample * sample_rate * channels.count() as u32 / 1000);
+                    }
+                }
+            }
+        }
+
+        debug!(?audio_meta, "Parsed metadata");
+        Ok(audio_meta)
+    }
+
+    fn extract_tags(
+        &self,
+        meta: &mut AudioMeta,
+        metadata: &symphonia::core::meta::MetadataRevision,
+    ) {
+        use symphonia::core::meta::StandardTagKey;
+
+        for tag in metadata.tags() {
+            if let Some(std_key) = tag.std_key {
+                let value = tag.value.to_string();
+                match std_key {
+                    StandardTagKey::TrackTitle => meta.title = Some(value),
+                    StandardTagKey::Artist => meta.artist = Some(value),
+                    StandardTagKey::Album => meta.album = Some(value),
+                    StandardTagKey::AlbumArtist => meta.album_artist = Some(value),
+                    StandardTagKey::Genre => meta.genre = Some(value),
+                    StandardTagKey::TrackNumber => {
+                        meta.track = value.split('/').next().and_then(|s| s.parse().ok());
+                    }
+                    StandardTagKey::DiscNumber => {
+                        meta.disc = value.split('/').next().and_then(|s| s.parse().ok());
+                    }
+                    StandardTagKey::Date | StandardTagKey::ReleaseDate => {
+                        meta.year = value.chars().take(4).collect::<String>().parse().ok();
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}
+
+impl Default for MetadataParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_audio_format_detection() {
+        assert_eq!(AudioFormat::from_extension("flac"), AudioFormat::Flac);
+        assert_eq!(AudioFormat::from_extension("mp3"), AudioFormat::Mp3);
+        assert_eq!(AudioFormat::from_extension("opus"), AudioFormat::Opus);
+        assert_eq!(AudioFormat::from_extension("ogg"), AudioFormat::Vorbis);
+        assert_eq!(AudioFormat::from_extension("m4a"), AudioFormat::Aac);
+        assert_eq!(AudioFormat::from_extension("wav"), AudioFormat::Wav);
+    }
+
+    #[test]
+    fn test_parser_creation() {
+        let parser = MetadataParser::new();
+        let default_parser = MetadataParser::default();
+        assert!(std::mem::size_of_val(&parser) == std::mem::size_of_val(&default_parser));
+    }
+}