fix compile errors except for ffmpeg

Author: l1npengtul

nokhwa-core/src/decoder.rs

@@ -8,7 +8,7 @@ use bytemuck::try_cast_slice_mut;
 use crate::pixel_destination::PixelDestination;
 
 pub trait Decoder {
-    type Config: Clone + Debug;
+    type Config: Clone + Debug + ConfigHasResolution;
     type OutputMeta: Clone + Debug;
     const SUPPORTED_DESTINATIONS: &'static [PixelDestination];
 
@@ -27,10 +27,7 @@ pub trait Decoder {
     where
         <P as Pixel>::Subpixel: NonFloatScalarWidth
     {
-        let destination = match PixelDestination::get_by_pixel::<P>() {
-            Some(dest) => dest,
-            None => return Err(NokhwaError::DecoderUnknownDestinationPixelFormat(P::COLOR_MODEL, P::Subpixel::WIDTH_BYTES))
-        };
+        let Some(destination) = PixelDestination::get_by_pixel::<P>() else { return Err(NokhwaError::DecoderUnknownDestinationPixelFormat(P::COLOR_MODEL, P::Subpixel::WIDTH_BYTES)) };
 
         if !Self::supports_destination(destination) {
             return Err(NokhwaError::DecoderUnsupportedDestinationPixelFormat(destination))
@@ -43,13 +40,29 @@ pub trait Decoder {
 
         self.decode_to_buffer(to_decode, cast_slice, destination)
     }
-
     fn decode<P: Pixel>(
         &mut self,
-        to_decode: FrameBuffer,
+        to_decode: FrameBuffer<'_>,
     ) -> Result<DecodedImage<P, Self::OutputMeta>, NokhwaError>
     where
-        <P as Pixel>::Subpixel: NonFloatScalarWidth;
+        <P as Pixel>::Subpixel: NonFloatScalarWidth,
+    {
+        let resolution = self.config().resolution();
+        let min_size_alloc = self.output_decoder_min_size_pixel::<P>(resolution)?;
+        let mut out_buffer: Vec<P::Subpixel> = vec![P::Subpixel::DEFAULT_MIN_VALUE; min_size_alloc];
+        let meta = self.decode_to_pixel_buffer::<P>(to_decode, &mut out_buffer)?;
+        Ok(DecodedImage::new(
+            ImageBuffer::from_vec(
+                resolution.width(),
+                resolution.height(),
+                out_buffer,
+            )
+                .ok_or(NokhwaError::Decoder(
+                    "failed to convert into an image buffer".to_string(),
+                ))?,
+            meta,
+        ))
+    }
 
     fn output_decoder_min_size_pixel<P>(&self, resolution: Resolution) -> Result<usize, NokhwaError> where
         P: Pixel,
@@ -58,9 +71,29 @@ pub trait Decoder {
 
     }
 
-    fn output_decoder_min_size(&self, resolution: Resolution, destination_format: PixelDestination) -> Result<usize, NokhwaError>;
+    fn output_decoder_min_size(&self, resolution: Resolution, destination_format: PixelDestination) -> Result<usize, NokhwaError> {
+        if !Self::supports_destination(destination_format) {
+            return Err(NokhwaError::DecoderUnsupportedDestinationPixelFormat(destination_format))
+        }
 
+        let px_size = match destination_format {
+            PixelDestination::Rgb8 | PixelDestination::Bgr8 => 3_u32,
+            PixelDestination::Rgba8 | PixelDestination::Bgra8 | PixelDestination::LumaA16 => 4_u32,
+            PixelDestination::Rgb16 | PixelDestination::Bgr16 => 3_u32 * 2_u32,
+            PixelDestination::Rgba16 | PixelDestination::Bgra16 => 4_u32 * 2_u32,
+            PixelDestination::Luma8 => 1_u32,
+            PixelDestination::LumaA8 | PixelDestination::Luma16 => 2_u32,
+            };
+        let reso = resolution.width() * resolution.height();
+        Ok((reso as usize) * (px_size as usize))
+    }
+
+    #[must_use]
     fn supports_destination(pixel_destination: PixelDestination) -> bool {
         Self::SUPPORTED_DESTINATIONS.contains(&pixel_destination)
     }
 }
+
+pub trait ConfigHasResolution {
+    fn resolution(&self) -> Resolution;
+}

nokhwa-core/src/frame_format.rs

@@ -206,6 +206,7 @@ define_frame_format_with_groups! {
 }
 
 impl FrameFormat {
+    #[must_use]
     pub fn is_custom(&self) -> bool {
         if let FrameFormat::Custom(_) = self {
             return true

nokhwa-core/src/pixel_destination.rs

@@ -19,6 +19,7 @@ pub enum PixelDestination {
 }
 
 impl PixelDestination {
+    #[must_use]
     pub fn get_by_pixel<P>() -> Option<Self>
     where
         P: Pixel,

nokhwa-core/src/stream.rs

@@ -165,7 +165,7 @@ impl<'a> StreamHandle<'a> {
                         return Err(NokhwaError::ReadFrameError(why));
                     }
                 }
-                Event::Error(e) => return Err(NokhwaError::ReadFrameError(e.to_string())),
+                Event::Error(e) => return Err(NokhwaError::ReadFrameError(e.clone())),
                 _ => {}
             }
         }

nokhwa-core/src/types.rs

@@ -43,7 +43,7 @@ impl CameraIndex {
     pub fn as_string(&self) -> String {
         match self {
             CameraIndex::Index(i) => i.to_string(),
-            CameraIndex::String(s) | CameraIndex::Stable(s) => s.to_string(),
+            CameraIndex::String(s) | CameraIndex::Stable(s) => s.clone(),
             }
     }
 

nokhwa-decoders/Cargo.toml

@@ -7,8 +7,8 @@ edition = "2024"
 ffmpeg = ["ffmpeg-the-third"]
 yuyv = ["dcv-color-primitives", "yuv"]
 mjpeg = ["zune-jpeg", "zune-core"]
-luma = ["itertools", "nokhwa-iter-extensions", "itermore"]
-#static = ["ffmpeg-the-third/static"]
+luma = ["nokhwa-iter-extensions", "itermore"]
+static = ["ffmpeg-the-third/static"]
 #async = []
 
 [dependencies]
@@ -19,7 +19,7 @@ version = "0.2"
 path = "../nokhwa-core"
 
 [dependencies.ffmpeg-the-third]
-version = "4.0.0+ffmpeg-8.0"
+version = "4.0.0"
 optional = true
 
 [dependencies.yuv]
@@ -38,10 +38,6 @@ optional = true
 version = "0.5.0-rc2"
 optional = true
 
-[dependencies.itertools]
-version = "0.14"
-optional = true
-
 [dependencies.itermore]
 version = "0.8"
 features = ["array_chunks"]

nokhwa-decoders/src/ffmpeg.rs

@@ -12,11 +12,12 @@ use ffmpeg_the_third::ffi::{
 use ffmpeg_the_third::packet::{Borrow, Ref};
 use ffmpeg_the_third::{Frame, decoder, packet::Packet};
 use nokhwa_core::codec::Codec;
-use nokhwa_core::decoder::{Decoder, ImageBuffer, Pixel, Primitive};
+use nokhwa_core::decoder::{ConfigHasResolution, Decoder, Pixel};
 use nokhwa_core::error::NokhwaError;
 use nokhwa_core::frame_buffer::FrameBuffer;
 use nokhwa_core::frame_format::{CustomFrameFormat, FrameFormat};
-use nokhwa_core::image::{DecodedImage, NonFloatScalarWidth};
+use nokhwa_core::image::{NonFloatScalarWidth};
+use nokhwa_core::pixel_destination::PixelDestination;
 use nokhwa_core::types::{CameraFormat, FrameRate, Resolution};
 
 pub struct FfmpegDecoder {
@@ -56,7 +57,8 @@ impl FfmpegDecoder {
 impl Decoder for FfmpegDecoder {
     type Config = <FfmpegCodec as Codec>::Config;
     type OutputMeta = <FfmpegCodec as Codec>::WrittenMeta;
-    type DestinationFormatHint = AVPixelFormat;
+    const SUPPORTED_DESTINATIONS: &'static [PixelDestination] = &[];
+
 
     fn config(&self) -> &Self::Config {
         self.codec.config()
@@ -71,7 +73,7 @@ impl Decoder for FfmpegDecoder {
         &mut self,
         to_decode: FrameBuffer,
         mut buffer: impl AsMut<[u8]>,
-        _destination_format: Option<Self::DestinationFormatHint>,
+        _destination_format: PixelDestination,
     ) -> Result<Self::OutputMeta, NokhwaError> {
         // TODO: add an extra zippy happy path for rgb/bgr/luma
         let (frame, metadata) = self.receive_decoded_frame(to_decode)?;
@@ -188,54 +190,6 @@ impl Decoder for FfmpegDecoder {
             Ok(decoded_meta)
         }
     }
-
-    fn decode<P: Pixel>(
-        &mut self,
-        to_decode: FrameBuffer,
-    ) -> Result<DecodedImage<P, Self::OutputMeta>, NokhwaError>
-    where
-        <P as Pixel>::Subpixel: NonFloatScalarWidth,
-    {
-        let min_size = self.output_decoder_min_size_pixel::<P>(self.config().resolution);
-        let mut buffer: Vec<P::Subpixel> = vec![<P::Subpixel>::DEFAULT_MIN_VALUE; min_size];
-        let meta = self.decode_to_buffer(
-            to_decode,
-            try_cast_slice_mut(&mut buffer)
-                .map_err(|why| NokhwaError::DecoderInvalidBuffer(why.to_string()))?,
-            None,
-        )?;
-        Ok(DecodedImage::new(
-            ImageBuffer::from_vec(
-                self.codec.config.resolution.width(),
-                self.codec.config.resolution.height(),
-                buffer,
-            )
-            .ok_or(NokhwaError::Decoder(
-                "Failed to create Image Buffer".to_string(),
-            ))?,
-            meta,
-        ))
-    }
-
-    fn output_decoder_min_size(
-        &self,
-        resolution: Resolution,
-        destination_format: Self::DestinationFormatHint,
-    ) -> usize {
-        let size = unsafe {
-            av_image_get_buffer_size(
-                destination_format,
-                resolution.width() as i32,
-                resolution.height() as i32,
-                1,
-            )
-        };
-        size as usize
-    }
-
-    fn buffer_takes_destination_hint(&self) -> bool {
-        false
-    }
 }
 
 fn create_sws_context(
@@ -261,53 +215,6 @@ fn create_sws_context(
     Ok(new_sws)
 }
 
-fn pixel_to_destination_px_fmt<P: Pixel>() -> Option<AVPixelFormat>
-where
-    <P as Pixel>::Subpixel: NonFloatScalarWidth,
-{
-    match P::COLOR_MODEL {
-        "RGB" => match <<P as Pixel>::Subpixel>::WIDTH_BYTES {
-            1 => Some(AVPixelFormat::AV_PIX_FMT_RGB24),
-            _ => None,
-        },
-
-        "RGBA" => match <<P as Pixel>::Subpixel>::WIDTH_BYTES {
-            1 => Some(AVPixelFormat::AV_PIX_FMT_RGBA),
-            2 => Some(switch_endian(
-                AVPixelFormat::AV_PIX_FMT_RGBA64LE,
-                AVPixelFormat::AV_PIX_FMT_RGBA64BE,
-            )),
-            _ => None,
-        },
-        "BGR" => match <<P as Pixel>::Subpixel>::WIDTH_BYTES {
-            1 => Some(AVPixelFormat::AV_PIX_FMT_BGR24),
-            _ => None,
-        },
-
-        "BGRA" => match <<P as Pixel>::Subpixel>::WIDTH_BYTES {
-            1 => Some(AVPixelFormat::AV_PIX_FMT_BGRA),
-            2 => Some(switch_endian(
-                AVPixelFormat::AV_PIX_FMT_BGRA64LE,
-                AVPixelFormat::AV_PIX_FMT_BGRA64BE,
-            )),
-            _ => None,
-        },
-        "Y" => match <<P as Pixel>::Subpixel>::WIDTH_BYTES {
-            1 => Some(AVPixelFormat::AV_PIX_FMT_GRAY8),
-            2 => Some(switch_endian(
-                AVPixelFormat::AV_PIX_FMT_GRAY16LE,
-                AVPixelFormat::AV_PIX_FMT_GRAY16BE,
-            )),
-            _ => None,
-        },
-        "YA" => match <<P as Pixel>::Subpixel>::WIDTH_BYTES {
-            1 => Some(AVPixelFormat::AV_PIX_FMT_GRAY8A),
-            _ => None,
-        },
-        _ => None,
-    }
-}
-
 pub struct Sws {
     pub sws: *mut SwsContext,
     pub source_pixel_format: AVPixelFormat,
@@ -686,6 +593,12 @@ pub struct FfmpegDecoderConfig {
     pub video_delay: i32,
 }
 
+impl ConfigHasResolution for FfmpegDecoderConfig {
+    fn resolution(&self) -> Resolution {
+        self.resolution
+    }
+}
+
 impl FfmpegDecoderConfig {
     pub fn with_camera_format(camera_format: &CameraFormat) -> Self {
         FfmpegDecoderConfig::from(*camera_format)