maverick_os 2.0.0

#[cfg(any(target_os = "ios", target_os = "macos"))]
mod apple;
#[cfg(any(target_os = "ios", target_os = "macos"))]
use apple::OsCamera;

#[cfg(target_os = "android")]
mod android;
#[cfg(target_os = "android")]
use android::OsCamera;

#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "linux")]
use linux::OsCamera;

#[cfg(target_os = "windows")]
mod windows;
#[cfg(target_os = "windows")]
use windows::OsCamera;

use image::RgbaImage;
use std::sync::Arc;

#[derive(Clone, Default, Debug)]
pub struct Handle(Arc<bool>);

#[derive(Clone)]
pub struct Camera(OsCamera, Arc<Handle>);
impl Camera {
    pub fn new() -> Self {Camera(OsCamera::new(), Arc::new(Handle::default()))}

    pub fn start(&self) -> Handle {(*self.1).clone()}

    pub(crate) fn tick(&mut self) -> Option<RgbaImage> {
        let count = Arc::strong_count(&self.1.0);
        if count > 1 {
            self.0.start();
            self.0.frame()
        } else if count == 1 {
            self.0.stop();
            None
        } else {None}
    }
}
impl Default for Camera {fn default() -> Self {Self::new()}}

//  #[derive(Debug, Clone)]
//  pub struct CameraSettings {
//      pub exposure_mode: ExposureMode,
//      pub custom_exposure: Option<CustomExposure>,
//      pub exposure_compensation: Option<f32>,
//      pub exposure_stacking: bool,

//      pub focus_mode: FocusMode,
//      pub focus_distance: Option<f32>,
//      pub focus_point_of_interest: Option<(f32, f32)>,

//      pub white_balance_mode: WhiteBalanceMode,
//      pub white_balance_gains: Option<WhiteBalanceGains>,

//      pub zoom_factor: Option<f32>,

//      pub frame_rate: Option<f32>,
//      pub resolution: Option<Resolution>,
//      pub hdr_enabled: bool,
//      pub stabilization_enabled: bool,

//      pub low_light_boost: Option<bool>,
//      pub scene_mode_hint: Option<SceneMode>,

//      pub brightness: Option<f32>,
//      pub contrast: Option<f32>,
//      pub saturation: Option<f32>,
//      pub sharpness: Option<f32>,
//      pub hue: Option<f32>,
//      pub noise_reduction: Option<f32>,
//      pub gamma: Option<f32>,
//      pub color_filter: Option<ColorFilter>,

//      pub is_updated: bool,
//  }

//  #[derive(Debug, Clone, Copy)]
//  pub struct CustomExposure {
//      pub duration: f32,
//      pub iso: f32,
//  }

//  impl Default for CustomExposure {
//      fn default() -> Self {
//          Self {
//              iso: 0.0,
//              duration: 0.0,
//          }
//      }
//  }

//  #[derive(Debug, Clone, Copy, PartialEq)]
//  pub enum ExposureMode {
//      Auto,
//      Continuous,
//      Custom,
//  }

//  #[derive(Debug, Clone, Copy, PartialEq)]
//  pub enum FocusMode {
//      Auto,
//      Continuous,
//      Locked,
//      Manual,
//  }

//  #[derive(Debug, Clone, Copy, PartialEq)]
//  pub enum WhiteBalanceMode {
//      Auto,
//      Locked,
//      Custom,
//  }

//  #[derive(Debug, Clone, Copy, PartialEq)]
//  pub struct WhiteBalanceGains {
//      pub red: f32,
//      pub green: f32,
//      pub blue: f32,
//  }

//  impl WhiteBalanceGains {
//      pub fn from(red: f32, green: f32, blue: f32) -> Self {
//          WhiteBalanceGains { red, green, blue }
//      }
//  }

//  impl Default for WhiteBalanceGains {
//      fn default() -> Self {
//          Self {
//              red: 0.0,
//              green: 0.0,
//              blue: 0.0,
//          }
//      }
//  }

//  #[derive(Debug, Clone, Copy)]
//  pub struct Resolution {
//      pub width: u32,
//      pub height: u32,
//  }

//  #[derive(Debug, Clone, Copy)]
//  pub enum SceneMode {
//      Standard,
//      Portrait,
//      Night,
//      Action,
//      Backlit,
//      Macro,
//  }

//  #[derive(Debug, Clone, Copy)]
//  pub enum ColorFilter {
//      None,
//      Sepia,
//      Mono,
//      Vibrant,
//      Cool,
//      Warm,
//  }

//  impl Default for CameraSettings {
//      fn default() -> Self {
//          Self {
//              exposure_mode: ExposureMode::Continuous,
//              custom_exposure: None,
//              exposure_compensation: Some(0.0),
//              exposure_stacking: false,
//              focus_mode: FocusMode::Auto,
//              focus_distance: Some(0.5),
//              focus_point_of_interest: Some((0.5, 0.5)),
//              white_balance_mode: WhiteBalanceMode::Auto,
//              white_balance_gains: None,
//              zoom_factor: Some(1.0),
//              frame_rate: Some(30.0),
//              resolution: Some(Resolution {
//                  width: 1920,
//                  height: 1080,
//              }),
//              hdr_enabled: false,
//              stabilization_enabled: true,
//              low_light_boost: Some(false),
//              scene_mode_hint: Some(SceneMode::Standard),
//              brightness: Some(0.5),
//              contrast: Some(0.5),
//              saturation: Some(0.5),
//              sharpness: None,
//              hue: Some(0.5),
//              noise_reduction: None,
//              gamma: Some(0.5),
//              color_filter: None,
//              is_updated: true,
//          }
//      }
//  }

//  impl CameraSettings {
//      pub fn set_brightness(&mut self, value: f32) {
//          self.brightness = Some(value.clamp(0.0, 1.0));
//          self.is_updated = true;
//      }

//      pub fn set_contrast(&mut self, value: f32) {
//          self.contrast = Some(value.clamp(0.0, 1.0));
//          self.is_updated = true;
//      }

//      pub fn set_saturation(&mut self, value: f32) {
//          self.saturation = Some(value.clamp(0.0, 1.0));
//          self.is_updated = true;
//      }

//      pub fn set_sharpness(&mut self, value: f32) {
//          let v = value.clamp(0.0, 1.0);
//          self.sharpness = if v < 0.1 { None } else { Some(v) };
//          self.is_updated = true;
//      }

//      pub fn set_hue(&mut self, value: f32) {
//          self.hue = Some(value.clamp(0.0, 1.0));
//          self.is_updated = true;
//      }

//      pub fn set_noise_reduction(&mut self, value: f32) {
//          let v = value.clamp(0.0, 1.0);
//          self.noise_reduction = if v < 0.1 { None } else { Some(v) };
//          self.is_updated = true;
//      }

//      pub fn set_gamma(&mut self, value: f32) {
//          self.gamma = Some(value.clamp(0.0, 1.0));
//          self.is_updated = true;
//      }

//      pub fn set_focus_mode(&mut self, mode: FocusMode) {
//          if mode != FocusMode::Manual {
//              self.focus_distance = Some(0.5)
//          };
//          self.focus_mode = mode;
//          self.is_updated = true;
//      }

//      pub fn set_focus_distance(&mut self, value: f32) {
//          if self.focus_mode == FocusMode::Manual {
//              self.focus_distance = Some(value.clamp(0.0, 1.0));
//              self.is_updated = true;
//          }
//      }

//      pub fn set_exposure_compensation(&mut self, value: f32) {
//          self.exposure_compensation = Some((value.clamp(0.0, 1.0) * 4.0) - 2.0);
//          self.is_updated = true;
//      }

//      pub fn set_custom_exposure(&mut self, duration_percentage: f32, iso_percentage: f32) {
//          self.custom_exposure = Some(CustomExposure {
//              duration: duration_percentage.clamp(0.0, 1.0),
//              iso: iso_percentage.clamp(0.0, 1.0),
//          });
//          self.exposure_mode = ExposureMode::Custom;
//          self.is_updated = true;
//      }

//      pub fn set_exposure_mode(&mut self, mode: ExposureMode) {
//          if mode != ExposureMode::Custom {
//              self.custom_exposure = None
//          };
//          self.exposure_mode = mode;
//          self.is_updated = true;
//      }

//      pub fn set_white_balance_mode(&mut self, mode: WhiteBalanceMode) {
//          if mode != WhiteBalanceMode::Custom {
//              self.white_balance_gains = None
//          };
//          self.white_balance_mode = mode;
//          self.is_updated = true;
//      }

//      pub fn set_white_balance_gains_red(&mut self, red: f32) {
//          let g = self.white_balance_gains.unwrap_or_default();
//          self.white_balance_gains =
//              Some(WhiteBalanceGains::from(red.clamp(0.0, 1.0), g.green, g.blue));
//          self.white_balance_mode = WhiteBalanceMode::Custom;
//          self.is_updated = true;
//      }

//      pub fn set_white_balance_gains_green(&mut self, green: f32) {
//          let g = self.white_balance_gains.unwrap_or_default();
//          self.white_balance_gains = Some(WhiteBalanceGains::from(
//              g.red,
//              green.clamp(0.0, 1.0),
//              g.blue,
//          ));
//          self.white_balance_mode = WhiteBalanceMode::Custom;
//          self.is_updated = true;
//      }

//      pub fn set_white_balance_gains_blue(&mut self, blue: f32) {
//          let g = self.white_balance_gains.unwrap_or_default();
//          self.white_balance_gains = Some(WhiteBalanceGains::from(
//              g.red,
//              g.green,
//              blue.clamp(0.0, 1.0),
//          ));
//          self.white_balance_mode = WhiteBalanceMode::Custom;
//          self.is_updated = true;
//      }

//      pub fn set_zoom_factor(&mut self, value: f32) {
//          self.zoom_factor = Some(1.0 + value.clamp(0.0, 1.0) * 9.0);
//          self.is_updated = true;
//      }

//      pub fn set_hdr_enabled(&mut self, enabled: bool) {
//          self.hdr_enabled = enabled;
//          self.is_updated = true;
//      }

//      pub fn set_stabilization_enabled(&mut self, enabled: bool) {
//          self.stabilization_enabled = enabled;
//          self.is_updated = true;
//      }

//      pub fn set_low_light_boost(&mut self, enabled: bool) {
//          self.low_light_boost = Some(enabled);
//          self.is_updated = true;
//      }

//      pub fn set_scene_mode(&mut self, scene: SceneMode) {
//          self.scene_mode_hint = Some(scene);
//          self.is_updated = true;
//      }

//      pub fn set_focus_point_of_interest(&mut self, x: f32, y: f32) {
//          self.focus_point_of_interest = Some((x.clamp(0.0, 1.0), y.clamp(0.0, 1.0)));
//          self.is_updated = true;
//      }
//  }