Upload main.rs

src/main.rs

@@ -24,6 +24,12 @@ use cbc::Decryptor;
 use reqwest::{cookie::Jar, Url};
 use reqwest::cookie::CookieStore;
 use reqwest::header::ACCEPT;
+use lofty::{
+    config::WriteOptions,
+    picture::{Picture, PictureType},
+    tag::{Accessor, Tag, TagExt, TagType},
+};
+use std::io::Cursor;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::sync::{Mutex, RwLock};
 use tokio::time::{timeout, Duration};
@@ -709,7 +715,38 @@ struct StreamParams {
     id: u64,
     format: Option<String>,
     arl: Option<String>,
+    title: Option<String>,
+    performer: Option<String>,
+    duration: Option<u64>,
+    album: Option<String>,
+    cover_url: Option<String>,
 }
+
+#[derive(Debug, Clone, Default)]
+struct AudioTagMeta {
+    title: Option<String>,
+    performer: Option<String>,
+    album: Option<String>,
+    cover_url: Option<String>,
+}
+
+fn normalized_opt(value: &Option<String>) -> Option<String> {
+    value
+        .as_ref()
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+}
+
+impl From<&StreamParams> for AudioTagMeta {
+    fn from(params: &StreamParams) -> Self {
+        Self {
+            title: normalized_opt(&params.title),
+            performer: normalized_opt(&params.performer),
+            album: normalized_opt(&params.album),
+            cover_url: normalized_opt(&params.cover_url),
+        }
+    }
+}
 
 async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams>) -> impl IntoResponse {
     let _ = std::fs::remove_file("debug_dzmedia.log");
@@ -832,7 +869,97 @@ struct SendAudioParams {
     title: Option<String>,
     performer: Option<String>,
     duration: Option<u64>,
+    album: Option<String>,
+    cover_url: Option<String>,
 }
+
+impl From<&SendAudioParams> for AudioTagMeta {
+    fn from(params: &SendAudioParams) -> Self {
+        Self {
+            title: normalized_opt(&params.title),
+            performer: normalized_opt(&params.performer),
+            album: normalized_opt(&params.album),
+            cover_url: normalized_opt(&params.cover_url),
+        }
+    }
+}
+
+async fn fetch_cover_picture(cover_url: &str) -> Option<Picture> {
+    let http = reqwest::Client::builder()
+        .timeout(Duration::from_secs(20))
+        .build()
+        .ok()?;
+    let resp = http.get(cover_url).send().await.ok()?;
+    if !resp.status().is_success() {
+        return None;
+    }
+    let bytes = resp.bytes().await.ok()?;
+    let mut picture = Picture::from_reader(&mut Cursor::new(bytes.to_vec())).ok()?;
+    picture.set_pic_type(PictureType::CoverFront);
+    Some(picture)
+}
+
+async fn inject_audio_metadata(mut bytes: Vec<u8>, ext: &str, meta: &AudioTagMeta) -> Vec<u8> {
+    let has_text = meta.title.is_some() || meta.performer.is_some() || meta.album.is_some();
+    let cover = match meta.cover_url.as_deref() {
+        Some(url) => fetch_cover_picture(url).await,
+        None => None,
+    };
+
+    if !has_text && cover.is_none() {
+        return bytes;
+    }
+
+    let tag_type = if ext.eq_ignore_ascii_case("flac") {
+        TagType::VorbisComments
+    } else {
+        TagType::Id3v2
+    };
+
+    let mut tag = Tag::new(tag_type);
+    if let Some(title) = meta.title.clone() {
+        tag.set_title(title);
+    }
+    if let Some(performer) = meta.performer.clone() {
+        tag.set_artist(performer);
+    }
+    if let Some(album) = meta.album.clone() {
+        tag.set_album(album);
+    }
+    if let Some(picture) = cover {
+        tag.push_picture(picture);
+    }
+
+    let unique = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    let temp_path = std::env::temp_dir().join(format!("dzmedia_tagged_{}.{}", unique, ext));
+    if let Err(e) = std::fs::write(&temp_path, &bytes) {
+        tracing::warn!("metadata temp write failed: {}", e);
+        return bytes;
+    }
+
+    let write_options = if ext.eq_ignore_ascii_case("mp3") {
+        WriteOptions::new().use_id3v23(true)
+    } else {
+        WriteOptions::new()
+    };
+
+    let write_result = tag.save_to_path(&temp_path, write_options);
+    if let Err(e) = write_result {
+        let _ = std::fs::remove_file(&temp_path);
+        tracing::warn!("metadata tagging failed: {}", e);
+        return bytes;
+    }
+
+    match std::fs::read(&temp_path) {
+        Ok(tagged) => bytes = tagged,
+        Err(e) => tracing::warn!("metadata temp read failed: {}", e),
+    }
+    let _ = std::fs::remove_file(&temp_path);
+    bytes
+}
 
 async fn send_audio(
     State(state): State<AppState>,
@@ -939,7 +1066,9 @@ async fn send_audio(
         bi += 1; pos += bs;
     }
 
-    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let meta = AudioTagMeta::from(&q);
+    dec = inject_audio_metadata(dec, ext, &meta).await;
     let mime = if ext == "flac" { "audio/flac" } else { "audio/mpeg" };
     let filename = format!("track_{}.{}", q.id, ext);
 
@@ -1153,7 +1282,9 @@ async fn download(
     }
 
     // Determine file extension
-    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let meta = AudioTagMeta::from(&q);
+    dec = inject_audio_metadata(dec, ext, &meta).await;
     let filename = format!("track_{}.{}", q.id, ext);
     let ct = if ext == "flac" { "audio/flac" } else { "audio/mpeg" };