feat(player): update SDL2 renderer

src/player/renderer.rs

@@ -3,58 +3,42 @@
 use anyhow::Result;
 use sdl2::pixels::PixelFormatEnum;
 use sdl2::rect::Rect;
-use std::sync::{Arc, Mutex};
 
 pub struct Renderer {
     sdl: sdl2::Sdl,
-    video_subsystem: sdl2::VideoSubsystem,
-    window: sdl2::video::Window,
     canvas: sdl2::render::Canvas<sdl2::video::Window>,
-    texture_creator: sdl2::render::TextureCreator<sdl2::video::WindowContext>,
-    texture: Option<sdl2::render::Texture>,
     width: u32,
     height: u32,
 }
 
 impl Renderer {
     pub fn new(title: &str, width: u32, height: u32) -> Result<Self> {
-        let sdl = sdl2::init()?;
+        let sdl = sdl2::init().map_err(|e| anyhow::anyhow!("SDL init failed: {}", e))?;
-        let video_subsystem = sdl.video()?;
+        let video_subsystem = sdl
+            .video()
+            .map_err(|e| anyhow::anyhow!("Video subsystem failed: {}", e))?;
 
         let window = video_subsystem
             .window(title, width, height)
             .position_centered()
-            .build()?;
+            .build()
+            .map_err(|e| anyhow::anyhow!("Window creation failed: {}", e))?;
 
-        let canvas = window.into_canvas().build()?;
+        let canvas = window
-        let texture_creator = canvas.texture_creator();
+            .into_canvas()
+            .build()
+            .map_err(|e| anyhow::anyhow!("Canvas creation failed: {}", e))?;
 
         Ok(Self {
             sdl,
-            video_subsystem,
-            window,
             canvas,
-            texture_creator,
-            texture: None,
             width,
             height,
         })
     }
 
-    pub fn create_texture(&mut self, width: u32, height: u32) -> Result<()> {
+    pub fn update_frame(&mut self, texture: &sdl2::render::Texture) -> Result<()> {
-        self.texture = Some(
+        let _ = self.canvas.copy(texture, None, None);
-            self.texture_creator
-                .create_texture_streaming(PixelFormatEnum::RGB24, width, height)?
-        );
-        self.width = width;
-        self.height = height;
-        Ok(())
-    }
-
-    pub fn update_texture(&mut self, data: &[u8]) -> Result<()> {
-        if let Some(ref mut texture) = self.texture {
-            texture.update(None, data, self.width as usize * 3)?;
-        }
         Ok(())
     }
 
@@ -63,53 +47,43 @@ impl Renderer {
         self.canvas.clear();
     }
 
-    pub fn draw_bbox(&mut self, x: i32, y: i32, w: u32, h: u32, label: &str) {
+    pub fn draw_bbox(&mut self, x: i32, y: i32, w: u32, h: u32, _label: &str) {
-        // Draw rectangle border
+        self.canvas
-        self.canvas.set_draw_color(sdl2::pixels::Color::RGB(0, 255, 0));
+            .set_draw_color(sdl2::pixels::Color::RGB(0, 255, 0));
         let _ = self.canvas.draw_rect(Rect::new(x, y, w, h));
-        
-        // Draw label background
         let label_rect = Rect::new(x, y - 20, 100, 20);
-        self.canvas.set_draw_color(sdl2::pixels::Color::RGBA(0, 0, 0, 180));
+        self.canvas
+            .set_draw_color(sdl2::pixels::Color::RGBA(0, 0, 0, 180));
         let _ = self.canvas.fill_rect(label_rect);
     }
 
     pub fn present(&mut self) {
-        // Draw texture if available
-        if let Some(ref texture) = self.texture {
-            self.canvas.copy(texture, None, None).ok();
-        }
         self.canvas.present();
     }
 
-    pub fn set_fullscreen(&mut self, fullscreen: bool) -> Result<()> {
-        if fullscreen {
-            self.window.set_fullscreen(sdl2::video::FullscreenType::Desktop)?;
-        } else {
-            self.window.set_fullscreen(sdl2::video::FullscreenType::Off)?;
-        }
-        Ok(())
-    }
-
-    pub fn resize(&mut self, width: u32, height: u32) -> Result<()> {
-        self.window.set_size(width, height)?;
-        Ok(())
-    }
-
     pub fn poll_events(&mut self) -> Vec<sdl2::event::Event> {
         let mut events = Vec::new();
-        let pump = self.sdl.event_pump();
+        if let Ok(mut pump) = self.sdl.event_pump() {
-        if let Ok(pump) = pump {
             for event in pump.poll_iter() {
                 events.push(event);
             }
         }
         events
     }
+
+    pub fn canvas(&mut self) -> &mut sdl2::render::Canvas<sdl2::video::Window> {
+        &mut self.canvas
+    }
+
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.height
+    }
 }
 
 impl Drop for Renderer {
-    fn drop(&mut self) {
+    fn drop(&mut self) {}
-        // Cleanup handled automatically
-    }
 }