From b9eaa579dac2ae912e3be9a3aa3e73ddcb3416e1 Mon Sep 17 00:00:00 2001
From: salmonik <salmonik@tuta.io>
Date: Wed, 4 Nov 2026 01:31:11 +0100
Subject: music: decode compressed playback without a temp file

---
 src/music.rs     | 10 ++--------
 src/voice/mod.rs | 36 ++++++++++++++++++++++++++++++++----
 2 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/music.rs b/src/music.rs
index ac88631..acec278 100644
--- a/src/music.rs
+++ b/src/music.rs
@@ -575,14 +575,8 @@ async fn build_input(request: &TrackRequest, http: &reqwest::Client) -> Result<I
         info!("compressed to {} bytes", compressed_bytes.len());
 
         // Decode the compressed OGG via ffmpeg (symphonia lacks Opus support).
-        let compressed_path = format!(
-            "{}/play_compressed_{}.ogg",
-            crate::config::TEMP_PATH,
-            Uuid::new_v4()
-        );
-        let _ = tokio::fs::create_dir_all(crate::config::TEMP_PATH).await;
-        tokio::fs::write(&compressed_path, &compressed_bytes).await?;
-        let input = voice::ffmpeg_decode_file(&compressed_path).await?;
+        // Piping keeps the intermediate out of TEMP_PATH entirely.
+        let input = voice::ffmpeg_decode_bytes(compressed_bytes).await?;
         Ok(input)
     } else {
         match request.kind {
diff --git a/src/voice/mod.rs b/src/voice/mod.rs
index d8308eb..2866f54 100644
--- a/src/voice/mod.rs
+++ b/src/voice/mod.rs
@@ -342,15 +342,17 @@ impl tokio::io::AsyncRead for FfmpegChild {
     }
 }
 
-/// Decode a local audio file via ffmpeg to raw f32 PCM at 48 kHz stereo.
-/// No reconnect flags (those are for HTTP streams only).
-pub async fn ffmpeg_decode_file(path: &str) -> Result<songbird::input::Input> {
+/// Decode an in-memory audio file via ffmpeg to raw f32 PCM at 48 kHz stereo.
+///
+/// Used for compressed playback so the intermediate file never has to touch
+/// disk (and therefore cannot leak into `TEMP_PATH`).
+pub async fn ffmpeg_decode_bytes(data: Vec<u8>) -> Result<songbird::input::Input> {
     use std::process::Stdio;
 
     let mut child = tokio::process::Command::new("ffmpeg")
         .args([
             "-i",
-            path,
+            "pipe:0",
             "-vn",
             "-f",
             "f32le",
@@ -360,17 +362,43 @@ pub async fn ffmpeg_decode_file(path: &str) -> Result<songbird::input::Input> {
             "2",
             "pipe:1",
         ])
+        .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .kill_on_drop(true)
         .spawn()
         .map_err(|e| Error::Custom(format!("ffmpeg decode spawn: {e}")))?;
 
+    let mut stdin = child
+        .stdin
+        .take()
+        .ok_or_else(|| Error::Custom("ffmpeg stdin not captured".into()))?;
     let stdout = child
         .stdout
         .take()
         .ok_or_else(|| Error::Custom("ffmpeg stdout not captured".into()))?;
 
+    tokio::spawn(async move {
+        use tokio::io::AsyncWriteExt;
+        let _ = stdin.write_all(&data).await;
+        // Dropping stdin gives ffmpeg EOF.
+    });
+
+    if let Some(stderr) = child.stderr.take() {
+        tokio::spawn(async move {
+            use tokio::io::AsyncReadExt;
+            let mut buf = Vec::with_capacity(4096);
+            let mut reader = tokio::io::BufReader::new(stderr);
+            let _ = reader.read_to_end(&mut buf).await;
+            if !buf.is_empty() {
+                warn!(
+                    "ffmpeg (decode) stderr: {}",
+                    String::from_utf8_lossy(&buf).trim_end()
+                );
+            }
+        });
+    }
+
     let ffmpeg_child = FfmpegChild {
         _child: child,
         stdout,
-- 
cgit v1.2.3