fix(audio): refill sink on loop end instead of repeat_infinite

rodio 0.17's `repeat_infinite()` wraps the source in `Buffered`, which
retains every decoded sample in RAM so the loop can replay from cache.
For long file-backed tracks (e.g. a multi-hour archived YouTube video)
this grows unbounded — observed ~7 GB RSS on a ~6-hour video.

For `PlaybackInput::File` repeating tracks, skip `repeat_infinite()` and
add `AudioPlayer::try_refill_loop()`: when the sink drains, reopen the
file, decode fresh, and append to the sink. `play_loop` polls this on
each tick and bumps the real loop counter when a refill happens.

Non-file repeating sources (SoundCloud / HypeM stream-first) still go
through `repeat_infinite()` since a consumed network stream can't be
cheaply re-opened, and keep their existing wall-clock loop estimate as
a fallback branch.

Author: program247365

src/audio.rs

@@ -85,6 +85,8 @@ pub struct AudioPlayer {
     pub sample_buf: Arc<Mutex<VecDeque<f32>>>,
     pub sample_rate: u32,
     pub channels: u16,
+    input: PlaybackInput,
+    refillable: bool,
 }
 
 trait MediaReader: Read + Seek + Send + Sync {}
@@ -103,8 +105,14 @@ impl AudioPlayer {
         let sample_rate = source.sample_rate();
         let channels = source.channels();
 
+        // File-backed sources can be cheaply re-opened from disk, so we play
+        // them once and refill the sink on each loop boundary instead of using
+        // rodio's `repeat_infinite()` — which materializes the entire decoded
+        // PCM in RAM via `Buffered`. For long tracks that grows unbounded.
+        let refillable = repeat && matches!(input, PlaybackInput::File(_));
+
         let buf = Arc::new(Mutex::new(VecDeque::with_capacity(BUF_CAP)));
-        if repeat {
+        if repeat && !refillable {
             let tapped = SampleTap {
                 inner: source.repeat_infinite(),
                 buf: buf.clone(),
@@ -127,6 +135,8 @@ impl AudioPlayer {
             sample_buf: buf,
             sample_rate,
             channels,
+            input,
+            refillable,
         })
     }
 
@@ -141,6 +151,23 @@ impl AudioPlayer {
     pub fn skip(&self) {
         self.sink.stop();
     }
+
+    /// If this player loops a file-backed source and the sink has drained,
+    /// reopen the file, decode a fresh source, and queue it. Returns true
+    /// when a refill happened so the caller can advance its loop counter.
+    pub fn try_refill_loop(&self) -> Result<bool> {
+        if !self.refillable || !self.sink.empty() {
+            return Ok(false);
+        }
+        let (reader, _, _) = open_input(&self.input)?;
+        let source = decode_input(reader, &self.input)?.convert_samples::<f32>();
+        let tapped = SampleTap {
+            inner: source,
+            buf: self.sample_buf.clone(),
+        };
+        self.sink.append(tapped);
+        Ok(true)
+    }
 }
 
 fn decode_input(

src/play_loop.rs

@@ -346,7 +346,15 @@ fn run_loop(
                 if player.sink.empty() {
                     return Ok(LoopAction::NextTrack);
                 }
+            } else if player.try_refill_loop()? {
+                state.loop_count += 1;
+                state.loop_start = Instant::now();
+                needs_render = true;
             } else if let Some(dur) = state.duration {
+                // Fallback for non-file repeating sources (e.g. SoundCloud
+                // stream-first) which still go through `repeat_infinite()`:
+                // the sink never empties so we estimate loop boundaries from
+                // wall-clock elapsed vs. known duration.
                 if state.elapsed() >= dur {
                     state.loop_count += 1;
                     state.loop_start = Instant::now();