@matjash/pixi-native-win32-x64 0.2.0 → 0.2.2

package/native/audio/src/audio_impl.rs

@@ -7,10 +7,13 @@ use std::thread;
 use std::time::{Duration, Instant};
 
 use maudio::audio::sample_rate::SampleRate;
-use maudio::data_source::sources::buffer::{AudioBuffer, AudioBufferBuilder};
+use maudio::data_source::data_source_builder::DataSourceBuilder;
+use maudio::data_source::pcm_source::PcmSource;
 use maudio::data_source::sources::pcm_ring_buffer::{PcmRbRecv, PcmRbSend, PcmRingBuffer};
+use maudio::data_source::{DataSource, SourceContext};
 use maudio::engine::{engine_builder::EngineBuilder, Engine};
 use maudio::sound::{notifier::EndNotifier, sound_builder::SoundBuilder, Sound};
+use maudio::{ErrorKinds, MaResult, MaudioError};
 use napi::bindgen_prelude::*;
 use napi::threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode};
 use napi_derive::napi;
@@ -112,9 +115,64 @@ impl StreamingControl {
     }
 }
 
+struct SharedPcmSource {
+    samples: Arc<Vec<f32>>,
+}
+
+impl SharedPcmSource {
+    fn new(samples: Arc<Vec<f32>>) -> Self {
+        Self { samples }
+    }
+}
+
+impl PcmSource<f32> for SharedPcmSource {
+    fn fill_pcm_frames(
+        &mut self,
+        output: &mut [f32],
+        context: &mut SourceContext,
+    ) -> MaResult<usize> {
+        let channels = context.data_format.channels as usize;
+        let frame_count = self.samples.len() / channels;
+        let cursor = usize::try_from(context.cursor).unwrap_or(usize::MAX);
+        if cursor >= frame_count {
+            return Ok(0);
+        }
+
+        let output_frames = output.len() / channels;
+        let frames_to_copy = output_frames.min(frame_count - cursor);
+        let sample_start = cursor * channels;
+        let samples_to_copy = frames_to_copy * channels;
+        output[..samples_to_copy]
+            .copy_from_slice(&self.samples[sample_start..sample_start + samples_to_copy]);
+        context.cursor += frames_to_copy as u64;
+        Ok(frames_to_copy)
+    }
+
+    fn seek_to_pcm_frame(&mut self, frame_index: u64, context: &mut SourceContext) -> MaResult<()> {
+        let frame_count = self.samples.len() / context.data_format.channels as usize;
+        if frame_index > frame_count as u64 {
+            return Err(MaudioError::new_ma_error(ErrorKinds::InvalidOperation(
+                "Audio seek is outside the cached PCM source",
+            )));
+        }
+        context.cursor = frame_index;
+        Ok(())
+    }
+
+    fn cursor_in_pcm_frames(&self, context: &SourceContext) -> MaResult<u64> {
+        Ok(context.cursor)
+    }
+
+    fn length_in_pcm_frames(&self, context: &SourceContext) -> MaResult<u64> {
+        Ok((self.samples.len() / context.data_format.channels as usize) as u64)
+    }
+}
+
+type StaticDataSource = DataSource<f32, SharedPcmSource>;
+
 enum VoiceSource {
     Loading,
-    Static(Box<AudioBuffer<f32>>),
+    Static(Box<StaticDataSource>),
     Streaming {
         receiver: Box<PcmRbRecv<f32>>,
         control: Arc<StreamingControl>,
@@ -170,15 +228,51 @@ impl Voice {
             self.timeline_updated_at = now;
             return;
         }
-        self.timeline_seconds +=
-            now.duration_since(self.timeline_updated_at).as_secs_f64() * self.playback_rate;
-        if self.looped {
-            if let Some(duration_seconds) = self.duration_seconds {
-                self.timeline_seconds %= duration_seconds;
-            }
-        }
+        self.timeline_seconds = advance_timeline(
+            self.timeline_seconds,
+            now.duration_since(self.timeline_updated_at).as_secs_f64(),
+            self.playback_rate,
+            self.duration_seconds,
+            self.looped,
+        );
         self.timeline_updated_at = now;
     }
+
+    fn store_snapshot_time(&self, elapsed_seconds: f64) {
+        if let Some(time) = finite_absolute_time(self.offset_seconds, elapsed_seconds) {
+            self.snapshot
+                .time_bits
+                .store(time.to_bits(), Ordering::Release);
+        }
+    }
+}
+
+fn advance_timeline(
+    current_seconds: f64,
+    elapsed_seconds: f64,
+    playback_rate: f64,
+    duration_seconds: Option<f64>,
+    looped: bool,
+) -> f64 {
+    let current_seconds = if current_seconds.is_finite() {
+        current_seconds.max(0.0)
+    } else {
+        0.0
+    };
+    let advanced_seconds = current_seconds + elapsed_seconds * playback_rate;
+    if !advanced_seconds.is_finite() {
+        return current_seconds;
+    }
+    match duration_seconds {
+        Some(duration) if looped => advanced_seconds % duration,
+        Some(duration) => advanced_seconds.min(duration),
+        None => advanced_seconds,
+    }
+}
+
+fn finite_absolute_time(offset_seconds: f64, elapsed_seconds: f64) -> Option<f64> {
+    let time = offset_seconds + elapsed_seconds;
+    time.is_finite().then_some(time)
 }
 
 enum EngineCommand {
@@ -449,7 +543,8 @@ impl NativeAudioEngine {
     #[napi]
     pub fn current_time(&self, id: u32) -> Option<f64> {
         let snapshot = self.state.snapshots.lock().ok()?.get(&id).cloned()?;
-        Some(f64::from_bits(snapshot.time_bits.load(Ordering::Acquire)))
+        let time = f64::from_bits(snapshot.time_bits.load(Ordering::Acquire));
+        time.is_finite().then_some(time)
     }
 
     #[napi]
@@ -643,8 +738,8 @@ impl EngineRuntime {
                     let Some(mut voice) = self.voices.remove(&id) else {
                         continue;
                     };
-                    let result = AudioBufferBuilder::build_f32(CHANNELS as u32, &samples)
-                        .map_err(|error| format!("Cannot create miniaudio buffer: {error}"))
+                    let result = build_static_data_source(samples)
+                        .map_err(|error| format!("Cannot create miniaudio data source: {error}"))
                         .and_then(|buffer| {
                             voice.source = VoiceSource::Static(Box::new(buffer));
                             self.attach_sound(&mut voice)
@@ -830,11 +925,12 @@ impl EngineRuntime {
                     .snapshot
                     .queued_frames
                     .store(queued, Ordering::Release);
-                if control.ready.load(Ordering::Acquire) && !voice.play_announced {
-                    if sound.play_sound().is_ok() {
-                        voice.play_announced = true;
-                        state.queue_event(voice.owner_id, "play", Some(*id), None, None);
-                    }
+                if control.ready.load(Ordering::Acquire)
+                    && !voice.play_announced
+                    && sound.play_sound().is_ok()
+                {
+                    voice.play_announced = true;
+                    state.queue_event(voice.owner_id, "play", Some(*id), None, None);
                 }
                 let starved = voice.play_announced
                     && voice.playing
@@ -858,11 +954,7 @@ impl EngineRuntime {
             } else {
                 voice.timeline_seconds
             };
-            let time = voice.offset_seconds + elapsed_seconds;
-            voice
-                .snapshot
-                .time_bits
-                .store(time.to_bits(), Ordering::Release);
+            voice.store_snapshot_time(elapsed_seconds);
             let current_volume = if voice.fade.is_some() {
                 sound.current_fade_volume()
             } else {
@@ -913,30 +1005,25 @@ fn start_static_decode(
     preload: bool,
     request_id: Option<u32>,
 ) {
+    let key = cache_key(&options);
+    if let Some(samples) = state
+        .cache
+        .lock()
+        .ok()
+        .and_then(|cache| cache.get(&key).cloned())
+    {
+        complete_static_decode(&state, &options, preload, request_id, samples);
+        return;
+    }
+
     thread::spawn(move || {
-        let key = cache_key(&options);
-        let decoded = state
-            .cache
-            .lock()
-            .ok()
-            .and_then(|cache| cache.get(&key).cloned())
-            .map_or_else(
-                || decode_static(&options, state.sample_rate).map(Arc::new),
-                Ok,
-            );
+        let decoded = decode_static(&options, state.sample_rate).map(Arc::new);
         match decoded {
             Ok(samples) => {
                 if let Ok(mut cache) = state.cache.lock() {
                     cache.insert(key, Arc::clone(&samples));
                 }
-                if preload {
-                    state.queue_event(options.owner_id, "load", request_id, None, None);
-                } else {
-                    state.push_command(EngineCommand::AttachStatic {
-                        id: options.id,
-                        samples,
-                    });
-                }
+                complete_static_decode(&state, &options, preload, request_id, samples);
             }
             Err(message) => {
                 if !preload {
@@ -954,6 +1041,28 @@ fn start_static_decode(
     });
 }
 
+fn complete_static_decode(
+    state: &SharedState,
+    options: &NativeVoiceOptions,
+    preload: bool,
+    request_id: Option<u32>,
+    samples: Arc<Vec<f32>>,
+) {
+    if preload {
+        state.queue_event(options.owner_id, "load", request_id, None, None);
+    } else {
+        state.push_command(EngineCommand::AttachStatic {
+            id: options.id,
+            samples,
+        });
+    }
+}
+
+fn build_static_data_source(samples: Arc<Vec<f32>>) -> MaResult<StaticDataSource> {
+    DataSourceBuilder::new(CHANNELS as u32, SampleRate::Sr48000)
+        .build_f32(SharedPcmSource::new(samples))
+}
+
 fn start_streaming_decode(
     state: Arc<SharedState>,
     options: NativeVoiceOptions,
@@ -1233,6 +1342,29 @@ fn redact_credentials(message: &str) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn static_voices_share_pcm_with_independent_cursors() {
+        let samples = Arc::new(vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6]);
+        let mut first = build_static_data_source(Arc::clone(&samples)).unwrap();
+        let second = build_static_data_source(Arc::clone(&samples)).unwrap();
+
+        assert_eq!(Arc::strong_count(&samples), 3);
+        assert_eq!(first.cursor_in_pcm_frames().unwrap(), 0);
+        assert_eq!(second.cursor_in_pcm_frames().unwrap(), 0);
+
+        assert_eq!(first.read_pcm_frames(1).unwrap().frames(), 1);
+        assert_eq!(first.cursor_in_pcm_frames().unwrap(), 1);
+        assert_eq!(second.cursor_in_pcm_frames().unwrap(), 0);
+
+        first.seek_to_pcm_frame(0).unwrap();
+        assert_eq!(first.cursor_in_pcm_frames().unwrap(), 0);
+        assert!(first.seek_to_pcm_frame(4).is_err());
+
+        drop(first);
+        drop(second);
+        assert_eq!(Arc::strong_count(&samples), 1);
+    }
+
     #[test]
     fn atempo_decomposes_extreme_rates() {
         assert_eq!(build_atempo_filter(4.0).unwrap(), "atempo=2,atempo=2");
@@ -1246,4 +1378,27 @@ mod tests {
             "https://***:***@example.test/audio.mp3"
         );
     }
+
+    #[test]
+    fn static_timeline_stays_finite_and_within_sprite_duration() {
+        assert_eq!(advance_timeline(0.2, 0.05, 1.0, Some(0.8), false), 0.25);
+        assert_eq!(advance_timeline(0.7, 0.2, 1.0, Some(0.8), false), 0.8);
+        let looped = advance_timeline(0.7, 0.2, 1.0, Some(0.8), true);
+        assert!((looped - 0.1).abs() < f64::EPSILON);
+        assert_eq!(
+            advance_timeline(f64::INFINITY, 0.05, 1.0, Some(0.8), false),
+            0.05
+        );
+        assert_eq!(
+            advance_timeline(0.2, f64::INFINITY, 1.0, Some(0.8), false),
+            0.2
+        );
+    }
+
+    #[test]
+    fn snapshot_time_rejects_non_finite_values() {
+        assert_eq!(finite_absolute_time(1.0, 0.2), Some(1.2));
+        assert_eq!(finite_absolute_time(0.0, f64::INFINITY), None);
+        assert_eq!(finite_absolute_time(f64::INFINITY, 0.0), None);
+    }
 }

package/native/video/src/index.d.ts

@@ -19,11 +19,20 @@ export interface VideoFrame {
   data: Uint8Array;
 }
 
+export interface VideoFrameInfo {
+  width: number;
+  height: number;
+  timestampUs: number;
+}
+
 export class NativeVideoDecoder {
   public constructor(options: DecoderOptions);
   public open(source: string): void;
   public pollLatest(): VideoFrame | null;
   public pollNext(): VideoFrame | null;
+  public supportsFrameBufferReuse(): boolean;
+  public pollLatestInto(target: Buffer): VideoFrameInfo | null;
+  public pollNextInto(target: Buffer): VideoFrameInfo | null;
   public queuedFrames(): number;
   public catchUpTo(timestampUs: number): void;
   public pollError(): string | null;
@@ -31,6 +40,9 @@ export class NativeVideoDecoder {
   public decodedFrames(): number;
   public droppedFrames(): number;
   public skippedFrames(): number;
+  public frameBufferAllocations(): number;
+  public frameBufferReuses(): number;
+  public recycledFrameBuffers(): number;
   public isFinished(): boolean;
   public close(): void;
 }

package/native/video/src/index.js

@@ -21,6 +21,18 @@ class NativeVideoDecoder {
     return this.decoder.pollNext();
   }
 
+  supportsFrameBufferReuse() {
+    return typeof this.decoder.pollNextInto === "function";
+  }
+
+  pollLatestInto(target) {
+    return this.pollIntoFallback("pollLatest", "pollLatestInto", target);
+  }
+
+  pollNextInto(target) {
+    return this.pollIntoFallback("pollNext", "pollNextInto", target);
+  }
+
   queuedFrames() {
     return this.decoder.queuedFrames();
   }
@@ -49,6 +61,18 @@ class NativeVideoDecoder {
     return this.decoder.skippedFrames();
   }
 
+  frameBufferAllocations() {
+    return this.decoder.frameBufferAllocations?.() ?? 0;
+  }
+
+  frameBufferReuses() {
+    return this.decoder.frameBufferReuses?.() ?? 0;
+  }
+
+  recycledFrameBuffers() {
+    return this.decoder.recycledFrameBuffers?.() ?? 0;
+  }
+
   isFinished() {
     return this.decoder.isFinished();
   }
@@ -56,6 +80,25 @@ class NativeVideoDecoder {
   close() {
     this.decoder.close();
   }
+
+  pollIntoFallback(pollName, pollIntoName, target) {
+    if (typeof this.decoder[pollIntoName] === "function") {
+      return this.decoder[pollIntoName](target);
+    }
+    const frame = this.decoder[pollName]();
+    if (!frame) return null;
+    if (target.byteLength !== frame.data.byteLength) {
+      throw new RangeError(
+        `NV12 target has ${target.byteLength} bytes; expected ${frame.data.byteLength}`,
+      );
+    }
+    target.set(frame.data);
+    return {
+      width: frame.width,
+      height: frame.height,
+      timestampUs: frame.timestampUs,
+    };
+  }
 }
 
 module.exports = { NativeVideoDecoder };

package/native/video/src/lib.rs

@@ -38,6 +38,13 @@ pub struct VideoFrame {
     pub data: Buffer,
 }
 
+#[napi(object)]
+pub struct VideoFrameInfo {
+    pub width: i64,
+    pub height: i64,
+    pub timestamp_us: i64,
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum DecoderBackend {
     D3d11va,
@@ -84,7 +91,10 @@ struct DecoderState {
     decoded_frames: Arc<AtomicU64>,
     dropped_frames: Arc<AtomicU64>,
     skipped_frames: Arc<AtomicU64>,
+    frame_buffer_allocations: Arc<AtomicU64>,
+    frame_buffer_reuses: Arc<AtomicU64>,
     backend: Arc<Mutex<String>>,
+    stderr_workers: Arc<Mutex<Vec<thread::JoinHandle<()>>>>,
 }
 
 struct PendingFrame {
@@ -95,6 +105,7 @@ struct PendingFrame {
 #[derive(Default)]
 struct FrameQueue {
     frames: VecDeque<PendingFrame>,
+    recycled: Vec<Vec<u8>>,
 }
 
 impl FrameQueue {
@@ -108,6 +119,19 @@ impl FrameQueue {
         recycled
     }
 
+    fn take_recycled(&mut self, frame_bytes: usize) -> Option<Vec<u8>> {
+        while let Some(buffer) = self.recycled.pop() {
+            if buffer.len() == frame_bytes {
+                return Some(buffer);
+            }
+        }
+        None
+    }
+
+    fn recycle(&mut self, buffer: Vec<u8>) {
+        self.recycled.push(buffer);
+    }
+
     fn push_back(&mut self, frame: PendingFrame) {
         self.frames.push_back(frame);
     }
@@ -119,7 +143,9 @@ impl FrameQueue {
     fn pop_latest(&mut self) -> (Option<PendingFrame>, usize) {
         let latest = self.frames.pop_back();
         let skipped = self.frames.len();
-        self.frames.clear();
+        while let Some(frame) = self.frames.pop_front() {
+            self.recycle(frame.data);
+        }
         (latest, skipped)
     }
 
@@ -127,14 +153,22 @@ impl FrameQueue {
         self.frames.len()
     }
 
+    fn recycle_queued(&mut self) {
+        while let Some(frame) = self.frames.pop_front() {
+            self.recycle(frame.data);
+        }
+    }
+
     fn clear(&mut self) {
         self.frames.clear();
+        self.recycled.clear();
     }
 }
 
 struct SpawnedFfmpeg {
     child: Child,
     stdout: ChildStdout,
+    stderr_worker: Option<thread::JoinHandle<()>>,
 }
 
 #[derive(Clone)]
@@ -155,6 +189,7 @@ struct FfmpegRequest {
 pub struct NativeVideoDecoder {
     options: DecoderOptions,
     state: DecoderState,
+    worker: Option<thread::JoinHandle<()>>,
 }
 
 #[napi]
@@ -171,6 +206,7 @@ impl NativeVideoDecoder {
 
         Ok(Self {
             options,
+            worker: None,
             state: DecoderState {
                 closed: Arc::new(AtomicBool::new(true)),
                 finished: Arc::new(AtomicBool::new(false)),
@@ -182,13 +218,19 @@ impl NativeVideoDecoder {
                 decoded_frames: Arc::new(AtomicU64::new(0)),
                 dropped_frames: Arc::new(AtomicU64::new(0)),
                 skipped_frames: Arc::new(AtomicU64::new(0)),
+                frame_buffer_allocations: Arc::new(AtomicU64::new(0)),
+                frame_buffer_reuses: Arc::new(AtomicU64::new(0)),
                 backend: Arc::new(Mutex::new(backend)),
+                stderr_workers: Arc::new(Mutex::new(Vec::new())),
             },
         })
     }
 
     #[napi]
     pub fn open(&mut self, source: String) -> Result<()> {
+        if self.state.closed.load(Ordering::SeqCst) {
+            self.join_worker();
+        }
         if !self.state.closed.swap(false, Ordering::SeqCst) {
             return Err(Error::from_reason("Video decoder is already open"));
         }
@@ -197,6 +239,10 @@ impl NativeVideoDecoder {
         self.state.decoded_frames.store(0, Ordering::SeqCst);
         self.state.dropped_frames.store(0, Ordering::SeqCst);
         self.state.skipped_frames.store(0, Ordering::SeqCst);
+        self.state
+            .frame_buffer_allocations
+            .store(0, Ordering::SeqCst);
+        self.state.frame_buffer_reuses.store(0, Ordering::SeqCst);
 
         if let Ok(mut error) = self.state.error.lock() {
             *error = None;
@@ -268,7 +314,7 @@ impl NativeVideoDecoder {
         let initial_stdout = install_child(&state, spawned)
             .map_err(|error| Error::from_reason(error.to_string()))?;
 
-        thread::spawn(move || {
+        self.worker = Some(thread::spawn(move || {
             let mut result =
                 consume_decoder_attempt(initial_stdout, width, height, fps, start_time, &state);
 
@@ -334,7 +380,7 @@ impl NativeVideoDecoder {
                 state.finished.store(true, Ordering::SeqCst);
             }
             state.closed.store(true, Ordering::SeqCst);
-        });
+        }));
 
         Ok(())
     }
@@ -360,6 +406,41 @@ impl NativeVideoDecoder {
         self.to_video_frame(pending)
     }
 
+    #[napi]
+    pub fn poll_latest_into(&self, mut target: BufferSlice) -> Result<Option<VideoFrameInfo>> {
+        let (frames, available) = &*self.state.frames;
+        let (pending, skipped) = frames
+            .lock()
+            .map_err(|_| Error::from_reason("Video frame queue lock poisoned"))?
+            .pop_latest();
+        if skipped > 0 {
+            self.state
+                .skipped_frames
+                .fetch_add(skipped as u64, Ordering::SeqCst);
+        }
+        let result = pending
+            .map(|pending| self.copy_video_frame_into(pending, &mut target))
+            .transpose();
+        available.notify_all();
+        result
+    }
+
+    #[napi]
+    pub fn poll_next_into(&self, mut target: BufferSlice) -> Result<Option<VideoFrameInfo>> {
+        let (frames, available) = &*self.state.frames;
+        let pending = frames
+            .lock()
+            .map_err(|_| Error::from_reason("Video frame queue lock poisoned"))?
+            .pop_next();
+        let result = pending
+            .map(|pending| self.copy_video_frame_into(pending, &mut target))
+            .transpose();
+        if result.as_ref().is_ok_and(Option::is_some) {
+            available.notify_one();
+        }
+        result
+    }
+
     #[napi]
     pub fn queued_frames(&self) -> i64 {
         let (frames, _) = &*self.state.frames;
@@ -383,7 +464,7 @@ impl NativeVideoDecoder {
         let (frames, available) = &*self.state.frames;
         if let Ok(mut frames) = frames.lock() {
             let skipped = frames.len();
-            frames.clear();
+            frames.recycle_queued();
             self.state
                 .skipped_frames
                 .fetch_add(skipped as u64, Ordering::SeqCst);
@@ -430,6 +511,26 @@ impl NativeVideoDecoder {
         i64::try_from(self.state.skipped_frames.load(Ordering::SeqCst)).unwrap_or(i64::MAX)
     }
 
+    #[napi]
+    pub fn frame_buffer_allocations(&self) -> i64 {
+        i64::try_from(self.state.frame_buffer_allocations.load(Ordering::SeqCst))
+            .unwrap_or(i64::MAX)
+    }
+
+    #[napi]
+    pub fn frame_buffer_reuses(&self) -> i64 {
+        i64::try_from(self.state.frame_buffer_reuses.load(Ordering::SeqCst)).unwrap_or(i64::MAX)
+    }
+
+    #[napi]
+    pub fn recycled_frame_buffers(&self) -> i64 {
+        let (frames, _) = &*self.state.frames;
+        frames
+            .lock()
+            .map(|frames| i64::try_from(frames.recycled.len()).unwrap_or(i64::MAX))
+            .unwrap_or(0)
+    }
+
     #[napi]
     pub fn is_finished(&self) -> bool {
         self.state.finished.load(Ordering::SeqCst)
@@ -438,12 +539,46 @@ impl NativeVideoDecoder {
     #[napi]
     pub fn close(&mut self) {
         close_state(&self.state);
+        self.join_worker();
+    }
+
+    fn join_worker(&mut self) {
+        if let Some(worker) = self.worker.take() {
+            let _ = worker.join();
+        }
+    }
+
+    fn copy_video_frame_into(
+        &self,
+        pending: PendingFrame,
+        target: &mut [u8],
+    ) -> Result<VideoFrameInfo> {
+        if target.len() != pending.data.len() {
+            let actual = target.len();
+            let expected = pending.data.len();
+            if let Ok(mut frames) = self.state.frames.0.lock() {
+                frames.recycle(pending.data);
+            }
+            return Err(Error::from_reason(format!(
+                "NV12 target has {actual} bytes; expected {expected}"
+            )));
+        }
+        target.copy_from_slice(&pending.data);
+        if let Ok(mut frames) = self.state.frames.0.lock() {
+            frames.recycle(pending.data);
+        }
+        Ok(VideoFrameInfo {
+            width: self.options.width,
+            height: self.options.height,
+            timestamp_us: pending.timestamp_us,
+        })
     }
 }
 
 impl Drop for NativeVideoDecoder {
     fn drop(&mut self) {
         close_state(&self.state);
+        self.join_worker();
     }
 }
 
@@ -582,14 +717,18 @@ fn spawn_ffmpeg(request: &FfmpegRequest, backend: DecoderBackend) -> io::Result<
         .stdout
         .take()
         .ok_or_else(|| io::Error::other("FFmpeg stdout unavailable"))?;
-    if let Some(stderr) = child.stderr.take() {
+    let stderr_worker = child.stderr.take().map(|stderr| {
         thread::spawn(move || {
             for line in BufReader::new(stderr).lines().map_while(|line| line.ok()) {
                 eprintln!("{}", redact_url_credentials(&line));
             }
-        });
-    }
-    Ok(SpawnedFfmpeg { child, stdout })
+        })
+    });
+    Ok(SpawnedFfmpeg {
+        child,
+        stdout,
+        stderr_worker,
+    })
 }
 
 fn redact_url_credentials(value: &str) -> String {
@@ -613,6 +752,13 @@ fn redact_url_credentials(value: &str) -> String {
 }
 
 fn install_child(state: &DecoderState, spawned: SpawnedFfmpeg) -> io::Result<ChildStdout> {
+    if let Some(worker) = spawned.stderr_worker {
+        state
+            .stderr_workers
+            .lock()
+            .map_err(|_| io::Error::other("FFmpeg stderr worker lock poisoned"))?
+            .push(worker);
+    }
     *state
         .child
         .lock()
@@ -631,7 +777,7 @@ fn consume_ffmpeg_output(
     let frame_bytes = nv12_frame_bytes(width, height)?;
     let start_timestamp_us = (start_time * 1_000_000.0).round() as i64;
     let mut frame_index = 0_i64;
-    let mut data = vec![0_u8; frame_bytes];
+    let mut data = acquire_frame_buffer(frame_bytes, state)?;
     let read_result = loop {
         if state.closed.load(Ordering::SeqCst) {
             break Ok(());
@@ -644,7 +790,8 @@ fn consume_ffmpeg_output(
                 frame_index += 1;
                 state.decoded_frames.fetch_add(1, Ordering::SeqCst);
 
-                data = enqueue_frame(PendingFrame { timestamp_us, data }, frame_bytes, state)?;
+                enqueue_frame(PendingFrame { timestamp_us, data }, state)?;
+                data = acquire_frame_buffer(frame_bytes, state)?;
             }
             Err(error) if error.kind() == io::ErrorKind::UnexpectedEof => break Ok(()),
             Err(error) => break Err(error),
@@ -658,6 +805,7 @@ fn consume_ffmpeg_output(
         .take()
         .map(|mut process| process.wait())
         .transpose()?;
+    join_stderr_workers(state);
 
     read_result?;
     if !state.closed.load(Ordering::SeqCst) && status.is_some_and(|status| !status.success()) {
@@ -709,15 +857,16 @@ fn wait_for_hardware_retry(state: &DecoderState) -> io::Result<bool> {
     Ok(!state.closed.load(Ordering::SeqCst))
 }
 
-fn enqueue_frame(
-    frame: PendingFrame,
-    frame_bytes: usize,
-    state: &DecoderState,
-) -> io::Result<Vec<u8>> {
+fn enqueue_frame(frame: PendingFrame, state: &DecoderState) -> io::Result<()> {
     let catch_up_timestamp_us = state.catch_up_timestamp_us.load(Ordering::SeqCst);
     if catch_up_timestamp_us >= 0 && frame.timestamp_us < catch_up_timestamp_us {
         state.skipped_frames.fetch_add(1, Ordering::SeqCst);
-        return Ok(frame.data);
+        let (frames, _) = &*state.frames;
+        frames
+            .lock()
+            .map_err(|_| io::Error::other("Video frame queue lock poisoned"))?
+            .recycle(frame.data);
+        return Ok(());
     }
     if catch_up_timestamp_us >= 0 {
         state.catch_up_timestamp_us.store(-1, Ordering::SeqCst);
@@ -731,7 +880,7 @@ fn enqueue_frame(
     if state.source_paced {
         if let Some(recycled) = frames.push_latest(frame) {
             state.dropped_frames.fetch_add(1, Ordering::SeqCst);
-            return Ok(recycled);
+            frames.recycle(recycled);
         }
     } else {
         while frames.len() >= FRAME_QUEUE_CAPACITY
@@ -743,12 +892,14 @@ fn enqueue_frame(
                 .map_err(|_| io::Error::other("Video frame queue lock poisoned"))?;
         }
         if state.closed.load(Ordering::SeqCst) {
-            return Ok(frame.data);
+            frames.recycle(frame.data);
+            return Ok(());
         }
         let target = state.catch_up_timestamp_us.load(Ordering::SeqCst);
         if target >= 0 && frame.timestamp_us < target {
             state.skipped_frames.fetch_add(1, Ordering::SeqCst);
-            return Ok(frame.data);
+            frames.recycle(frame.data);
+            return Ok(());
         }
         if target >= 0 {
             state.catch_up_timestamp_us.store(-1, Ordering::SeqCst);
@@ -756,9 +907,36 @@ fn enqueue_frame(
         frames.push_back(frame);
     }
 
+    Ok(())
+}
+
+fn acquire_frame_buffer(frame_bytes: usize, state: &DecoderState) -> io::Result<Vec<u8>> {
+    let (frames, _) = &*state.frames;
+    if let Some(buffer) = frames
+        .lock()
+        .map_err(|_| io::Error::other("Video frame queue lock poisoned"))?
+        .take_recycled(frame_bytes)
+    {
+        state.frame_buffer_reuses.fetch_add(1, Ordering::SeqCst);
+        return Ok(buffer);
+    }
+    state
+        .frame_buffer_allocations
+        .fetch_add(1, Ordering::SeqCst);
     Ok(vec![0_u8; frame_bytes])
 }
 
+fn join_stderr_workers(state: &DecoderState) {
+    let workers = state
+        .stderr_workers
+        .lock()
+        .map(|mut workers| workers.drain(..).collect::<Vec<_>>())
+        .unwrap_or_default();
+    for worker in workers {
+        let _ = worker.join();
+    }
+}
+
 fn set_backend_name(state: &DecoderState, name: &str) {
     if let Ok(mut backend) = state.backend.lock() {
         *backend = name.to_string();
@@ -779,11 +957,13 @@ fn close_state(state: &DecoderState) {
     if let Ok(mut child) = state.child.lock() {
         if let Some(mut process) = child.take() {
             let _ = process.kill();
+            let _ = process.wait();
         }
     }
     if let Ok(mut frames) = frames.lock() {
         frames.clear();
     }
+    join_stderr_workers(state);
 }
 
 #[cfg(test)]
@@ -906,13 +1086,13 @@ mod tests {
     fn file_queue_applies_backpressure_until_a_frame_is_consumed() {
         let state = decoder_state(false);
         for timestamp_us in 0..FRAME_QUEUE_CAPACITY as i64 {
-            enqueue_frame(pending(timestamp_us), 1, &state).unwrap();
+            enqueue_frame(pending(timestamp_us), &state).unwrap();
         }
 
         let producer_state = state.clone();
         let (sent, received) = mpsc::channel();
         thread::spawn(move || {
-            let result = enqueue_frame(pending(99), 1, &producer_state);
+            let result = enqueue_frame(pending(99), &producer_state);
             sent.send(result.is_ok()).unwrap();
         });
 
@@ -928,14 +1108,76 @@ mod tests {
         let state = decoder_state(false);
         state.catch_up_timestamp_us.store(30, Ordering::SeqCst);
 
-        assert_eq!(enqueue_frame(pending(10), 1, &state).unwrap(), vec![10]);
-        assert_eq!(enqueue_frame(pending(20), 1, &state).unwrap(), vec![20]);
-        enqueue_frame(pending(30), 1, &state).unwrap();
+        enqueue_frame(pending(10), &state).unwrap();
+        enqueue_frame(pending(20), &state).unwrap();
+        enqueue_frame(pending(30), &state).unwrap();
 
         assert_eq!(state.skipped_frames.load(Ordering::SeqCst), 2);
         let (frames, _) = &*state.frames;
         let mut frames = frames.lock().unwrap();
         assert_eq!(frames.pop_next().unwrap().timestamp_us, 30);
+        assert_eq!(frames.recycled.len(), 2);
+    }
+
+    #[test]
+    fn copies_frame_into_caller_buffer_and_recycles_native_storage() {
+        let decoder = NativeVideoDecoder::new(DecoderOptions {
+            width: 2,
+            height: 2,
+            fps: Some(30.0),
+            start_time: None,
+            ffmpeg_path: None,
+            vaapi_device: None,
+            playback_rate: None,
+            end_time: None,
+            source_paced: None,
+            input_args: None,
+            output_args: None,
+        })
+        .unwrap();
+        let mut target = vec![0; 6];
+        let info = decoder
+            .copy_video_frame_into(
+                PendingFrame {
+                    timestamp_us: 42,
+                    data: vec![1, 2, 3, 4, 5, 6],
+                },
+                &mut target,
+            )
+            .unwrap();
+
+        assert_eq!(target, vec![1, 2, 3, 4, 5, 6]);
+        assert_eq!(info.timestamp_us, 42);
+        assert_eq!(decoder.state.frames.0.lock().unwrap().recycled.len(), 1);
+    }
+
+    #[test]
+    fn rejects_wrong_caller_buffer_size_without_losing_native_storage() {
+        let decoder = NativeVideoDecoder::new(DecoderOptions {
+            width: 2,
+            height: 2,
+            fps: Some(30.0),
+            start_time: None,
+            ffmpeg_path: None,
+            vaapi_device: None,
+            playback_rate: None,
+            end_time: None,
+            source_paced: None,
+            input_args: None,
+            output_args: None,
+        })
+        .unwrap();
+        let mut target = vec![0; 5];
+        let result = decoder.copy_video_frame_into(
+            PendingFrame {
+                timestamp_us: 42,
+                data: vec![1, 2, 3, 4, 5, 6],
+            },
+            &mut target,
+        );
+
+        assert!(result.is_err());
+        assert_eq!(decoder.state.frames.0.lock().unwrap().recycled.len(), 1);
     }
 
     #[test]
@@ -973,7 +1215,10 @@ mod tests {
             decoded_frames: Arc::new(AtomicU64::new(0)),
             dropped_frames: Arc::new(AtomicU64::new(0)),
             skipped_frames: Arc::new(AtomicU64::new(0)),
+            frame_buffer_allocations: Arc::new(AtomicU64::new(0)),
+            frame_buffer_reuses: Arc::new(AtomicU64::new(0)),
             backend: Arc::new(Mutex::new("test".to_string())),
+            stderr_workers: Arc::new(Mutex::new(Vec::new())),
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matjash/pixi-native-win32-x64",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "commonjs",
   "description": "Windows x64 native binaries for @matjash/pixi-native",
   "license": "MIT",