1 files changed, 56 insertions, 0 deletions

diff --git a/src/audio.rs b/src/audio.rs
index 8bac26f..5ce00ae 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -123,6 +123,7 @@ pub enum AudioCommand {
     Pause,
     Resume,
     Stop,
+    Seek(f64),
     SetVolume(f32),
 }
 
@@ -193,6 +194,11 @@ impl AudioEngine {
         let _ = self.command_tx.send(AudioCommand::Stop);
     }
 
+    /// Jump to `position` seconds into the current track.
+    pub fn seek(&self, position: f64) {
+        let _ = self.command_tx.send(AudioCommand::Seek(position));
+    }
+
     pub fn set_volume(&self, volume: f32) {
         let _ = self.command_tx.send(AudioCommand::SetVolume(volume));
     }
@@ -799,6 +805,22 @@ fn audio_thread(
                         *track = None;
                     }
                 }
+                AudioCommand::Seek(seconds) => {
+                    let target = seconds.max(0.0);
+                    if let Ok(mut d) = ctx.audio_data.lock()
+                        && let Some(data) = d.as_mut()
+                    {
+                        match seek_audio(data, target) {
+                            Ok(()) => {
+                                if let Ok(mut pos) = position.lock() {
+                                    *pos = target;
+                                }
+                                crate::debug_eprintln(format_args!("Seeked to {:.1}s", target));
+                            }
+                            Err(e) => eprintln!("Failed to seek: {}", e),
+                        }
+                    }
+                }
                 AudioCommand::SetVolume(vol) => {
                     if let Ok(mut volume_ref) = volume.lock() {
                         *volume_ref = vol;
@@ -865,6 +887,40 @@ fn audio_thread(
     }
 }
 
+/// Moves the decoder to `seconds` into the current track.
+///
+/// Symphonia's accurate seek lands on the packet *before* the requested
+/// position, so packets short of the required timestamp are dropped before
+/// playback resumes. The cpal stream itself keeps running: only the decoded
+/// buffers are flushed, so there is no gap beyond the dropped packet.
+fn seek_audio(data: &mut AudioData, seconds: f64) -> Result<(), String> {
+    use symphonia::core::formats::{SeekMode, SeekTo};
+    use symphonia::core::units::Time;
+
+    let time = Time::try_from_secs_f64(seconds).ok_or("invalid seek position")?;
+    let seeked = data
+        .format
+        .seek(
+            SeekMode::Accurate,
+            SeekTo::Time {
+                time,
+                track_id: None,
+            },
+        )
+        .map_err(|e| e.to_string())?;
+
+    data.decoder.reset();
+    data.sample_buffer.clear();
+    data.buffer_pos = 0;
+    while let Ok(Some(packet)) = data.format.next_packet() {
+        if packet.pts >= seeked.required_ts {
+            break;
+        }
+    }
+
+    Ok(())
+}
+
 fn open_audio_file(path: &PathBuf) -> Result<AudioData, Box<dyn std::error::Error>> {
     use symphonia::core::audio::layouts::CHANNEL_LAYOUT_STEREO;
     use symphonia::core::codecs::audio::AudioDecoderOptions;