Alexander
532 lines
17 KiB
Rust
532 lines
17 KiB
Rust
use std::{
|
|
fs,
|
|
io::{Cursor, Read, Seek, SeekFrom},
|
|
path::Path,
|
|
};
|
|
|
|
use symphonia::core::{
|
|
formats::FormatOptions,
|
|
io::MediaSourceStream,
|
|
meta::{Metadata, MetadataOptions, MetadataRevision, StandardTagKey},
|
|
probe::Hint,
|
|
};
|
|
|
|
const BLOCK_PADDING: u8 = 1;
|
|
const BLOCK_VORBIS_COMMENT: u8 = 4;
|
|
const BLOCK_PICTURE: u8 = 6;
|
|
const BLOCK_LAST_FLAG: u8 = 0x80;
|
|
const BLOCK_TYPE_MASK: u8 = 0x7f;
|
|
|
|
/// Parse a 4-byte FLAC metadata block header into (is_last, block_type, data_length).
|
|
fn read_block_header(hdr: &[u8; 4]) -> (bool, u8, u64) {
|
|
let is_last = (hdr[0] & BLOCK_LAST_FLAG) != 0;
|
|
let block_type = hdr[0] & BLOCK_TYPE_MASK;
|
|
let length = u32::from_be_bytes([0, hdr[1], hdr[2], hdr[3]]) as u64;
|
|
(is_last, block_type, length)
|
|
}
|
|
|
|
#[derive(Debug, Default, Clone)]
|
|
pub struct MusicMetadata {
|
|
pub artist: Vec<String>,
|
|
pub album: String,
|
|
pub track_number: i32,
|
|
pub track_title: String,
|
|
pub other_tags: Vec<String>,
|
|
pub header: Vec<u8>,
|
|
pub picture_block_headers: Vec<[u8; 4]>,
|
|
pub picture_data_ranges: Vec<(u64, u64)>,
|
|
pub real_audio_start: u64,
|
|
pub vorbis_comment_offset: u64,
|
|
pub vorbis_comment_length: u64,
|
|
}
|
|
|
|
impl MusicMetadata {
|
|
pub fn virtual_size(&self, real_file_size: u64) -> u64 {
|
|
let pictures_size: u64 = self
|
|
.picture_data_ranges
|
|
.iter()
|
|
.map(|(_, len)| 4 + len)
|
|
.sum();
|
|
self.header.len() as u64 + pictures_size + (real_file_size - self.real_audio_start)
|
|
}
|
|
|
|
pub fn parse_music_metadata(path: &Path) -> Option<MusicMetadata> {
|
|
let src = fs::File::open(path).expect("failed to open media");
|
|
let mss = MediaSourceStream::new(Box::new(src), Default::default());
|
|
let mut hint = Hint::new();
|
|
hint.with_extension("flac");
|
|
|
|
let meta_opts: MetadataOptions = Default::default();
|
|
let fmt_opts: FormatOptions = Default::default();
|
|
|
|
let mut format = symphonia::default::get_probe()
|
|
.format(&hint, mss, &fmt_opts, &meta_opts)
|
|
.expect("unsupported format");
|
|
|
|
let metadata: Metadata = format.format.metadata();
|
|
let revision: &MetadataRevision = metadata.current().unwrap();
|
|
|
|
let mut music_metadata = MusicMetadata::default();
|
|
|
|
for tag in revision.tags() {
|
|
let value = tag.value.to_string();
|
|
match tag.std_key {
|
|
Some(StandardTagKey::Artist) => music_metadata.artist.push(value),
|
|
Some(StandardTagKey::Album) => music_metadata.album = value,
|
|
Some(StandardTagKey::TrackNumber) => {
|
|
music_metadata.track_number = value.parse::<i32>().unwrap_or(0)
|
|
}
|
|
Some(StandardTagKey::TrackTitle) => music_metadata.track_title = value,
|
|
_ => music_metadata
|
|
.other_tags
|
|
.push(format!("{}={}", tag.key, value)),
|
|
}
|
|
}
|
|
|
|
if let Some(parsed) = parse_flac(path) {
|
|
music_metadata.real_audio_start = parsed.audio_start;
|
|
music_metadata.picture_block_headers = parsed.picture_block_headers;
|
|
music_metadata.picture_data_ranges = parsed.picture_data_ranges;
|
|
let (header, vorbis_comment_offset, vorbis_comment_length) =
|
|
build_flac_header(parsed.other_blocks, &music_metadata);
|
|
music_metadata.header = header;
|
|
music_metadata.vorbis_comment_offset = vorbis_comment_offset;
|
|
music_metadata.vorbis_comment_length = vorbis_comment_length;
|
|
}
|
|
|
|
Some(music_metadata)
|
|
}
|
|
|
|
pub fn find_vorbis_offsets(&mut self) {
|
|
let mut cursor = Cursor::new(&self.header);
|
|
let mut magic = [0u8; 4];
|
|
if cursor.read_exact(&mut magic).is_err() {
|
|
return;
|
|
}
|
|
loop {
|
|
let mut hdr = [0u8; 4];
|
|
if cursor.read_exact(&mut hdr).is_err() {
|
|
break;
|
|
}
|
|
let (is_last, block_type, length) = read_block_header(&hdr);
|
|
if block_type == BLOCK_VORBIS_COMMENT {
|
|
self.vorbis_comment_offset = cursor.position();
|
|
self.vorbis_comment_length = length;
|
|
return;
|
|
}
|
|
if cursor.seek(SeekFrom::Current(length as i64)).is_err() {
|
|
break;
|
|
}
|
|
if is_last {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn update_from_vorbis_comment_data(&mut self, data: &[u8]) {
|
|
parse_vorbis_comment_block(data, self);
|
|
let other_blocks = extract_non_vorbis_blocks(&self.header);
|
|
let (header, vorbis_comment_offset, vorbis_comment_length) =
|
|
build_flac_header(other_blocks, self);
|
|
self.header = header;
|
|
self.vorbis_comment_offset = vorbis_comment_offset;
|
|
self.vorbis_comment_length = vorbis_comment_length;
|
|
}
|
|
}
|
|
|
|
struct FlacParsed {
|
|
other_blocks: Vec<(u8, Vec<u8>)>,
|
|
picture_block_headers: Vec<[u8; 4]>,
|
|
picture_data_ranges: Vec<(u64, u64)>,
|
|
audio_start: u64,
|
|
}
|
|
|
|
fn parse_flac(path: &Path) -> Option<FlacParsed> {
|
|
let mut f = fs::File::open(path).ok()?;
|
|
|
|
let mut magic = [0u8; 4];
|
|
f.read_exact(&mut magic).ok()?;
|
|
if &magic != b"fLaC" {
|
|
return None;
|
|
}
|
|
|
|
let mut other_blocks: Vec<(u8, Vec<u8>)> = vec![];
|
|
let mut picture_block_headers: Vec<[u8; 4]> = vec![];
|
|
let mut picture_data_ranges: Vec<(u64, u64)> = vec![];
|
|
let mut pos = 4u64;
|
|
|
|
loop {
|
|
let mut hdr = [0u8; 4];
|
|
f.read_exact(&mut hdr).ok()?;
|
|
let (is_last, block_type, length) = read_block_header(&hdr);
|
|
pos += 4;
|
|
|
|
if block_type == BLOCK_PICTURE {
|
|
// PICTURE: keep block header (we'll fix is_last later), record data range
|
|
picture_block_headers.push(hdr);
|
|
picture_data_ranges.push((pos, length));
|
|
f.seek(SeekFrom::Current(length as i64)).ok()?;
|
|
} else {
|
|
let mut data = vec![0u8; length as usize];
|
|
f.read_exact(&mut data).ok()?;
|
|
// Skip VORBIS_COMMENT — we rebuild it
|
|
if block_type != BLOCK_VORBIS_COMMENT {
|
|
other_blocks.push((block_type, data));
|
|
}
|
|
}
|
|
|
|
pos += length;
|
|
if is_last {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Fix is_last on the last picture block header: it must be 1 when audio follows
|
|
if let Some(last_hdr) = picture_block_headers.last_mut() {
|
|
last_hdr[0] = BLOCK_LAST_FLAG | (last_hdr[0] & BLOCK_TYPE_MASK);
|
|
}
|
|
|
|
Some(FlacParsed {
|
|
other_blocks,
|
|
picture_block_headers,
|
|
picture_data_ranges,
|
|
audio_start: pos,
|
|
})
|
|
}
|
|
|
|
const PADDING_SIZE: usize = 8192;
|
|
|
|
fn build_flac_header(blocks: Vec<(u8, Vec<u8>)>, metadata: &MusicMetadata) -> (Vec<u8>, u64, u64) {
|
|
let vorbis = build_vorbis_comment(metadata);
|
|
let vorbis_len = vorbis.len() as u64;
|
|
|
|
let mut patched: Vec<(u8, Vec<u8>)> = blocks;
|
|
patched.push((BLOCK_VORBIS_COMMENT, vorbis));
|
|
patched.push((BLOCK_PADDING, vec![0u8; PADDING_SIZE])); // allows metaflac in-place writes
|
|
|
|
let vorbis_idx = patched.len() - 2;
|
|
let has_pictures = !metadata.picture_data_ranges.is_empty();
|
|
let mut out = Vec::new();
|
|
out.extend_from_slice(b"fLaC");
|
|
|
|
let last = patched.len() - 1;
|
|
let mut vorbis_offset = 0u64;
|
|
for (i, (block_type, data)) in patched.iter().enumerate() {
|
|
let is_last_block = i == last && !has_pictures;
|
|
let flag: u8 = if is_last_block { BLOCK_LAST_FLAG } else { 0x00 };
|
|
let length = data.len() as u32;
|
|
if i == vorbis_idx {
|
|
vorbis_offset = out.len() as u64 + 4; // data starts after 4-byte block header
|
|
}
|
|
out.push(flag | block_type);
|
|
out.push((length >> 16) as u8);
|
|
out.push((length >> 8) as u8);
|
|
out.push(length as u8);
|
|
out.extend_from_slice(data);
|
|
}
|
|
|
|
(out, vorbis_offset, vorbis_len)
|
|
}
|
|
|
|
fn parse_vorbis_comment_block(data: &[u8], out: &mut MusicMetadata) {
|
|
let mut cursor = Cursor::new(data);
|
|
let mut len_bytes = [0u8; 4];
|
|
|
|
if cursor.read_exact(&mut len_bytes).is_err() {
|
|
return;
|
|
}
|
|
let vendor_len = u32::from_le_bytes(len_bytes) as i64;
|
|
if cursor.seek(SeekFrom::Current(vendor_len)).is_err() {
|
|
return;
|
|
}
|
|
if cursor.read_exact(&mut len_bytes).is_err() {
|
|
return;
|
|
}
|
|
let count = u32::from_le_bytes(len_bytes);
|
|
|
|
out.artist.clear();
|
|
out.other_tags.clear();
|
|
|
|
for _ in 0..count {
|
|
if cursor.read_exact(&mut len_bytes).is_err() {
|
|
break;
|
|
}
|
|
let comment_len = u32::from_le_bytes(len_bytes) as usize;
|
|
let mut comment_bytes = vec![0u8; comment_len];
|
|
if cursor.read_exact(&mut comment_bytes).is_err() {
|
|
break;
|
|
}
|
|
let comment = String::from_utf8_lossy(&comment_bytes).into_owned();
|
|
if let Some((key, value)) = comment.split_once('=') {
|
|
match key.to_ascii_uppercase().as_str() {
|
|
"TITLE" => out.track_title = value.to_string(),
|
|
"ALBUM" => out.album = value.to_string(),
|
|
"TRACKNUMBER" => out.track_number = value.parse().unwrap_or(0),
|
|
"ARTIST" => out.artist.push(value.to_string()),
|
|
_ => out.other_tags.push(comment),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn extract_non_vorbis_blocks(header: &[u8]) -> Vec<(u8, Vec<u8>)> {
|
|
let mut cursor = Cursor::new(header);
|
|
let mut blocks = vec![];
|
|
|
|
let mut magic = [0u8; 4];
|
|
if cursor.read_exact(&mut magic).is_err() {
|
|
return blocks;
|
|
}
|
|
|
|
loop {
|
|
let mut hdr = [0u8; 4];
|
|
if cursor.read_exact(&mut hdr).is_err() {
|
|
break;
|
|
}
|
|
let (is_last, block_type, length) = read_block_header(&hdr);
|
|
let mut data = vec![0u8; length as usize];
|
|
if cursor.read_exact(&mut data).is_err() {
|
|
break;
|
|
}
|
|
if block_type != BLOCK_VORBIS_COMMENT && block_type != BLOCK_PADDING {
|
|
blocks.push((block_type, data));
|
|
}
|
|
if is_last {
|
|
break;
|
|
}
|
|
}
|
|
|
|
blocks
|
|
}
|
|
|
|
pub mod db {
|
|
pub mod music_metadata {
|
|
use sea_orm::entity::prelude::*;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
|
|
#[sea_orm(table_name = "music_metadata")]
|
|
pub struct Model {
|
|
#[sea_orm(primary_key, auto_increment = false)]
|
|
pub inode: i64,
|
|
pub track_title: String,
|
|
pub album: String,
|
|
pub track_number: i32,
|
|
#[sea_orm(column_type = "Blob")]
|
|
pub header: Vec<u8>,
|
|
pub real_audio_start: i64,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
|
|
pub enum Relation {}
|
|
|
|
impl ActiveModelBehavior for ActiveModel {}
|
|
}
|
|
|
|
pub mod artists {
|
|
use sea_orm::entity::prelude::*;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
|
|
#[sea_orm(table_name = "music_metadata_artists")]
|
|
pub struct Model {
|
|
#[sea_orm(primary_key, auto_increment = false)]
|
|
pub inode: i64,
|
|
#[sea_orm(primary_key, auto_increment = false)]
|
|
pub artist: String,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
|
|
pub enum Relation {}
|
|
|
|
impl ActiveModelBehavior for ActiveModel {}
|
|
}
|
|
|
|
pub mod other_tags {
|
|
use sea_orm::entity::prelude::*;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
|
|
#[sea_orm(table_name = "music_metadata_other_tags")]
|
|
pub struct Model {
|
|
#[sea_orm(primary_key, auto_increment = false)]
|
|
pub inode: i64,
|
|
#[sea_orm(primary_key, auto_increment = false)]
|
|
pub position: i32,
|
|
pub tag: String,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
|
|
pub enum Relation {}
|
|
|
|
impl ActiveModelBehavior for ActiveModel {}
|
|
}
|
|
|
|
pub mod pictures {
|
|
use sea_orm::entity::prelude::*;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
|
|
#[sea_orm(table_name = "music_metadata_pictures")]
|
|
pub struct Model {
|
|
#[sea_orm(primary_key, auto_increment = false)]
|
|
pub inode: i64,
|
|
#[sea_orm(primary_key, auto_increment = false)]
|
|
pub position: i32,
|
|
#[sea_orm(column_type = "Blob")]
|
|
pub block_header: Vec<u8>,
|
|
pub data_offset: i64,
|
|
pub data_length: i64,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
|
|
pub enum Relation {}
|
|
|
|
impl ActiveModelBehavior for ActiveModel {}
|
|
}
|
|
}
|
|
|
|
fn build_vorbis_comment(metadata: &MusicMetadata) -> Vec<u8> {
|
|
let vendor = b"musicfs";
|
|
let mut out = Vec::new();
|
|
|
|
out.extend_from_slice(&(vendor.len() as u32).to_le_bytes());
|
|
out.extend_from_slice(vendor);
|
|
|
|
let mut comments: Vec<String> = vec![
|
|
format!("TITLE={}", metadata.track_title),
|
|
format!("ALBUM={}", metadata.album),
|
|
format!("TRACKNUMBER={}", metadata.track_number),
|
|
];
|
|
for artist in &metadata.artist {
|
|
comments.push(format!("ARTIST={}", artist));
|
|
}
|
|
comments.extend(metadata.other_tags.iter().cloned());
|
|
|
|
out.extend_from_slice(&(comments.len() as u32).to_le_bytes());
|
|
for comment in &comments {
|
|
let bytes = comment.as_bytes();
|
|
out.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
|
|
out.extend_from_slice(bytes);
|
|
}
|
|
|
|
out
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn read_block_header_normal() {
|
|
let hdr = [0x04, 0x00, 0x01, 0x00];
|
|
let (is_last, block_type, length) = read_block_header(&hdr);
|
|
assert!(!is_last);
|
|
assert_eq!(block_type, 4);
|
|
assert_eq!(length, 256);
|
|
}
|
|
|
|
#[test]
|
|
fn read_block_header_last() {
|
|
let hdr = [0x84, 0x00, 0x00, 0x10];
|
|
let (is_last, block_type, length) = read_block_header(&hdr);
|
|
assert!(is_last);
|
|
assert_eq!(block_type, 4);
|
|
assert_eq!(length, 16);
|
|
}
|
|
|
|
#[test]
|
|
fn virtual_size_calculation() {
|
|
let mut metadata = MusicMetadata::default();
|
|
metadata.header = vec![0u8; 100];
|
|
metadata.picture_data_ranges = vec![(0, 50)];
|
|
metadata.real_audio_start = 200;
|
|
let file_size = 1000u64;
|
|
let virtual_size = metadata.virtual_size(file_size);
|
|
assert_eq!(virtual_size, 954);
|
|
}
|
|
|
|
#[test]
|
|
fn build_vorbis_comment_roundtrip() {
|
|
let mut metadata = MusicMetadata::default();
|
|
metadata.artist = vec!["Artist1".to_string(), "Artist2".to_string()];
|
|
metadata.album = "Album".to_string();
|
|
metadata.track_number = 3;
|
|
metadata.track_title = "Title".to_string();
|
|
metadata.other_tags = vec!["GENRE=Rock".to_string()];
|
|
|
|
let vorbis_bytes = build_vorbis_comment(&metadata);
|
|
let mut parsed = MusicMetadata::default();
|
|
parse_vorbis_comment_block(&vorbis_bytes, &mut parsed);
|
|
|
|
assert_eq!(parsed.artist, vec!["Artist1", "Artist2"]);
|
|
assert_eq!(parsed.album, "Album");
|
|
assert_eq!(parsed.track_number, 3);
|
|
assert_eq!(parsed.track_title, "Title");
|
|
assert_eq!(parsed.other_tags, vec!["GENRE=Rock"]);
|
|
}
|
|
|
|
#[test]
|
|
fn parse_vorbis_comment_multi_artist() {
|
|
let mut vorbis_bytes = Vec::new();
|
|
let vendor = b"test";
|
|
vorbis_bytes.extend_from_slice(&(vendor.len() as u32).to_le_bytes());
|
|
vorbis_bytes.extend_from_slice(vendor);
|
|
|
|
let comments = vec!["ARTIST=Artist1", "ARTIST=Artist2"];
|
|
vorbis_bytes.extend_from_slice(&(comments.len() as u32).to_le_bytes());
|
|
for comment in &comments {
|
|
let bytes = comment.as_bytes();
|
|
vorbis_bytes.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
|
|
vorbis_bytes.extend_from_slice(bytes);
|
|
}
|
|
|
|
let mut metadata = MusicMetadata::default();
|
|
parse_vorbis_comment_block(&vorbis_bytes, &mut metadata);
|
|
|
|
assert_eq!(metadata.artist.len(), 2);
|
|
assert_eq!(metadata.artist[0], "Artist1");
|
|
assert_eq!(metadata.artist[1], "Artist2");
|
|
}
|
|
|
|
#[test]
|
|
fn extract_non_vorbis_blocks_strips_vc_and_padding() {
|
|
let mut header = Vec::new();
|
|
header.extend_from_slice(b"fLaC");
|
|
|
|
let streaminfo_data = vec![0u8; 34];
|
|
header.push(0x00);
|
|
header.extend_from_slice(&[0x00, 0x00, 0x22]);
|
|
header.extend_from_slice(&streaminfo_data);
|
|
|
|
let vorbis_data = vec![0u8; 50];
|
|
header.push(0x04);
|
|
header.extend_from_slice(&[0x00, 0x00, 0x32]);
|
|
header.extend_from_slice(&vorbis_data);
|
|
|
|
let padding_data = vec![0u8; 100];
|
|
header.push(0x81);
|
|
header.extend_from_slice(&[0x00, 0x00, 0x64]);
|
|
header.extend_from_slice(&padding_data);
|
|
|
|
let blocks = extract_non_vorbis_blocks(&header);
|
|
assert_eq!(blocks.len(), 1);
|
|
assert_eq!(blocks[0].0, 0);
|
|
assert_eq!(blocks[0].1.len(), 34);
|
|
}
|
|
|
|
#[test]
|
|
fn find_vorbis_offsets_correct() {
|
|
let mut metadata = MusicMetadata::default();
|
|
metadata.artist = vec!["TestArtist".to_string()];
|
|
metadata.album = "TestAlbum".to_string();
|
|
metadata.track_number = 1;
|
|
metadata.track_title = "TestTitle".to_string();
|
|
|
|
let other_blocks = vec![(0, vec![0u8; 34])];
|
|
let (header, expected_offset, expected_length) = build_flac_header(other_blocks, &metadata);
|
|
metadata.header = header;
|
|
|
|
metadata.find_vorbis_offsets();
|
|
|
|
assert_eq!(metadata.vorbis_comment_offset, expected_offset);
|
|
assert_eq!(metadata.vorbis_comment_length, expected_length);
|
|
}
|
|
}
|