leaving for diff country. in prog commit.

nokhwa-core/Cargo.toml

@@ -24,6 +24,7 @@ test-fail-warnings = []
 [dependencies]
 thiserror = "1.0"
 bytes = "1.3"
+paste = "1.0"
 
 [dependencies.image]
 version = "0.24"
@@ -35,11 +36,11 @@ features = ["derive"]
 optional = true
 
 [dependencies.wgpu]
-version = "0.16"
+version = "0.17"
 optional = true
 
 [dependencies.opencv]
-version = "0.80"
+version = "0.84"
 default-features = false
 optional = true
 

nokhwa-core/src/format_request.rs

@@ -4,8 +4,136 @@ use crate::{
     frame_format::FrameFormat,
     types::{ApiBackend, CameraFormat, Resolution},
 };
+use paste::paste;
 use std::collections::{BTreeMap, BTreeSet};
 
+macro_rules! range_set_fields {
+    ($(($range_type:ty, $name:ident),)*) => {
+        $(
+        paste! {
+            pub fn [< with_maximum_ $name >](mut self, $name: $range_type) -> Self {
+                match &mut self.$name {
+                    Some(r) => {
+                        r.set_maximum(Some($name))
+                    }
+                    None => {
+                        self.$name: Option<Range<$range_type>> = Some(Range {
+                            maximum: Some($name),
+                            minimum: None,
+                            preferred: $range_type::default()
+                        });
+                    }
+                }
+                self
+            }
+
+            pub fn [< reset_maximum_ $name >](mut self) -> Self {
+                if let Some(r) = self.$name {
+                    self.$name.set_maximum(None)
+                }
+
+                self
+            }
+
+
+            pub fn [< set_maximum_ $name >](&mut self, $name: Option<$range_type>) {
+                match &mut self.$name {
+                    Some(r) => {
+                        r.set_maximum($name)
+                    }
+                    None => {
+                        self.$name: Option<Range<$range_type>> = Some(Range {
+                            maximum: $name,
+                            minimum: None,
+                            preferred: $range_type::default()
+                        });
+                    }
+                }
+            }
+
+            pub fn [< with_preferred_ $name >](mut self, $name: $range_type) -> Self {
+                match self.$name {
+                    Some(r) => {
+                        r.set_preferred(Some($name))
+                    }
+                    None => {
+                        self.$name: Option<Range<$range_type>> = Some(Range {
+                            maximum: None,
+                            minimum: None,
+                            preferred: $range_type::default()
+                        });
+                    }
+                }
+                self
+            }
+
+            pub fn [< set_preferred_ $name >](&mut self, $name: $range_type) {
+                match &mut self.$name {
+                    Some(r) => {
+                        r.set_preferred($name)
+                    }
+                    None => {
+                        self.$name: Option<Range<$range_type>> = Some(Range {
+                            maximum: None,
+                            minimum: None,
+                            preferred: $range_type
+                        });
+                    }
+                }
+            }
+
+            pub fn [< with_minimum_ $name >](mut self, $name: $range_type) -> Self {
+                match self.$name {
+                    Some(r) => {
+                        r.set_minimum(Some($name))
+                    }
+                    None => {
+                        self.$name: Option<Range<$range_type>> = Some(Range {
+                            maximum: None,
+                            minimum: Some($name),
+                            preferred: $range_type::default()
+                        });
+                    }
+                }
+                self
+            }
+
+            pub fn [< reset_minimum_ $name >](mut self) -> Self {
+                if let Some(r) = self.$name {
+                    self.$name.set_minimum(None)
+                }
+
+                self
+            }
+
+            pub fn [< set_minimum_ $name >](&mut self, $name: Option<$range_type>) {
+                match &mut self.$name {
+                    Some(r) => {
+                        r.set_minimum($name)
+                    }
+                    None => {
+                        self.$name: Option<Range<$range_type>> = Some(Range {
+                            maximum: None,
+                            minimum: $name,
+                            preferred: $range_type::default()
+                        });
+                    }
+                }
+            }
+
+            pub fn [< with_ $name _range >](mut self, $name: Option<Range<$range_type>>) -> Self {
+                self.$name = $name
+                Self
+            }
+
+            pub fn [< set_ $name _range >](&mut self, $name: Option<Range<$range_type>>) {
+                self.$name = $name
+            }
+        }
+        )*
+    };
+}
+
 #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
 pub enum CustomFormatRequestType {
     HighestFPS,
@@ -26,35 +154,6 @@ impl FormatRequest {
         Self::default()
     }
 
-    pub fn with_resolution(mut self, resolution: Resolution, exact: bool) -> Self {
-        self.resolution = Some(resolution);
-        self.resolution_exact = exact;
-        self
-    }
-
-    pub fn reset_resolution(mut self) -> Self {
-        self.resolution = None;
-        self.resolution_exact = false;
-        self
-    }
-    pub fn with_frame_rate(mut self, frame_rate: u32, exact: bool) -> Self {
-        self.frame_rate = Some(frame_rate);
-        self.frame_rate_exact = exact;
-        self
-    }
-
-    pub fn with_standard_frame_rate() {}
-
-    pub fn reset_frame_rate(mut self) -> Self {
-        self.frame_rate = None;
-        self.frame_rate_exact = false;
-        self
-    }
-    pub fn with_frame_formats(mut self, frame_formats: Vec<FrameFormat>) -> Self {
-        self.frame_format = Some(frame_formats);
-        self
-    }
-
     pub fn with_standard_frame_formats(mut self) -> Self {
         self.append_frame_formats(&mut vec![
             FrameFormat::MJpeg,
@@ -108,9 +207,12 @@ impl FormatRequest {
     }
 }
 
+range_set_fields!((Resolution, resolution), (u32, frame_rate),);
+
+// tomorrow wont come for those without FRAME FORMATS
 pub fn resolve_format_request(
     request: FormatRequest,
     availible_formats: Vec<CameraFormat>,
 ) -> CameraFormat {
-    // filter out by
+    // filter out by parts first
 }

nokhwa-core/src/types.rs

@@ -53,6 +53,16 @@ where
         }
     }
 
+    pub fn with_preferred(preferred: T) -> Self {
+        Self {
+            minimum: None,
+            lower_inclusive: true,
+            maximum: None,
+            upper_inclusive: false,
+            preferred,
+        }
+    }
+
     pub fn does_fit(&self, item: T) -> bool {
         if item == self.preferred {
             true
@@ -82,6 +92,39 @@ where
 
         true
     }
+
+
+    pub fn set_minimum(&mut self, minimum: Option<T>) {
+        self.minimum = minimum;
+    }
+    pub fn set_lower_inclusive(&mut self, lower_inclusive: bool) {
+        self.lower_inclusive = lower_inclusive;
+    }
+    pub fn set_maximum(&mut self, maximum: Option<T>) {
+        self.maximum = maximum;
+    }
+    pub fn set_upper_inclusive(&mut self, upper_inclusive: bool) {
+        self.upper_inclusive = upper_inclusive;
+    }
+    pub fn set_preferred(&mut self, preferred: T) {
+        self.preferred = preferred;
+    }
+
+    pub fn minimum(&self) -> Option<T> {
+        self.minimum
+    }
+    pub fn lower_inclusive(&self) -> bool {
+        self.lower_inclusive
+    }
+    pub fn maximum(&self) -> Option<T> {
+        self.maximum
+    }
+    pub fn upper_inclusive(&self) -> bool {
+        self.upper_inclusive
+    }
+    pub fn preferred(&self) -> T {
+        self.preferred
+    }
 }
 
 impl<T> Default for Range<T>

nokhwa-core/src/utils.rs

@@ -0,0 +1,18 @@
+use core::ops::AddAssign;
+
+pub fn min_max_range<N: Copy + PartialOrd + AddAssign<N> + Sized>(min: N, max: N, step: N) -> Vec<N> {
+    let mut counter = min;
+    let mut nums = vec![min];
+
+    loop {
+        counter += step;
+
+        if counter > max {
+            break
+        }
+
+        nums.push(counter)
+    }
+
+    nums
+}