fix: resolve clippy lints in export optimization code

- Fix collapsible_if in encoder thread (mp4.rs)
- Fix needless_option_as_deref in finish_encoder_nv12_pooled
- Remove unused finish_encoder_nv12 wrapper (replaced by pooled variant)
- Remove unused PendingNv12Readback::wait (replaced by wait_with_pool)
- Remove unused NV12BufferPool::return_buf and max_buffers field
- Remove unnecessary mut on buffer_pool parameter

Co-authored-by: Richie McIlroy <richiemcilroy@users.noreply.github.com>

Author: cursoragent

crates/export/src/mp4.rs

@@ -222,10 +222,10 @@ impl Mp4ExportSettings {
             let mut audio_sample_cursor = 0u64;
 
             while let Ok(input) = frame_rx.recv() {
-                if encoded_frames == 0 {
-                    if let Some(audio) = &mut audio_renderer {
-                        audio.set_playhead(0.0, &project_for_audio);
-                    }
+                if encoded_frames == 0
+                    && let Some(audio) = &mut audio_renderer
+                {
+                    audio.set_playhead(0.0, &project_for_audio);
                 }
 
                 let audio_frame = audio_renderer.as_mut().and_then(|audio| {

crates/rendering/src/frame_pipeline.rs

@@ -9,14 +9,12 @@ const GPU_BUFFER_WAIT_TIMEOUT_SECS: u64 = 10;
 
 pub struct NV12BufferPool {
     buffers: Vec<Vec<u8>>,
-    capacity: usize,
 }
 
 impl NV12BufferPool {
-    pub fn new(capacity: usize) -> Self {
+    pub fn new(pre_alloc: usize) -> Self {
         Self {
-            buffers: Vec::with_capacity(capacity),
-            capacity,
+            buffers: Vec::with_capacity(pre_alloc),
         }
     }
 
@@ -29,12 +27,6 @@ impl NV12BufferPool {
             Vec::with_capacity(size)
         }
     }
-
-    pub fn release(&mut self, buf: Vec<u8>) {
-        if self.buffers.len() < self.capacity {
-            self.buffers.push(buf);
-        }
-    }
 }
 
 pub struct RgbaToNv12Converter {
@@ -334,10 +326,6 @@ impl PendingNv12Readback {
         RenderingError::BufferMapWaitingFailed
     }
 
-    pub async fn wait(self, device: &wgpu::Device) -> Result<Nv12RenderedFrame, RenderingError> {
-        self.wait_with_pool(device, None).await
-    }
-
     pub async fn wait_with_pool(
         mut self,
         device: &wgpu::Device,
@@ -914,43 +902,20 @@ pub async fn finish_encoder(
     Ok(previous_frame)
 }
 
-pub async fn finish_encoder_nv12(
-    session: &mut RenderSession,
-    nv12_converter: &mut RgbaToNv12Converter,
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    uniforms: &ProjectUniforms,
-    encoder: wgpu::CommandEncoder,
-) -> Result<Option<Nv12RenderedFrame>, RenderingError> {
-    finish_encoder_nv12_pooled(
-        session,
-        nv12_converter,
-        device,
-        queue,
-        uniforms,
-        encoder,
-        None,
-    )
-    .await
-}
-
 pub async fn finish_encoder_nv12_pooled(
     session: &mut RenderSession,
     nv12_converter: &mut RgbaToNv12Converter,
     device: &wgpu::Device,
     queue: &wgpu::Queue,
     uniforms: &ProjectUniforms,
     mut encoder: wgpu::CommandEncoder,
-    mut buffer_pool: Option<&mut NV12BufferPool>,
+    buffer_pool: Option<&mut NV12BufferPool>,
 ) -> Result<Option<Nv12RenderedFrame>, RenderingError> {
     let width = uniforms.output_size.0;
     let height = uniforms.output_size.1;
 
     let previous_frame = if let Some(prev) = nv12_converter.take_pending() {
-        Some(
-            prev.wait_with_pool(device, buffer_pool.as_deref_mut())
-                .await?,
-        )
+        Some(prev.wait_with_pool(device, buffer_pool).await?)
     } else {
         None
     };