diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index 6d64c0c..0000000
Binary files a/.DS_Store and /dev/null differ
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..a036c24
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: [l1npengtul]
+# patreon: # Replace with a single Patreon username
+# open_collective: # Replace with a single Open Collective username
+# ko_fi: # Replace with a single Ko-fi username
+# tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+# community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+# liberapay: # Replace with a single Liberapay username
+# issuehunt: # Replace with a single IssueHunt username
+# otechie: # Replace with a single Otechie username
+# lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+# custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
diff --git a/.gitignore b/.gitignore
index b5226e7..d45a211 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,6 @@ nokhwa.iml
 
 /pkg
 
-target
\ No newline at end of file
+target
+
+.DS_STORE
diff --git a/.run/Clippy Main.run.xml b/.run/Clippy Main.run.xml
new file mode 100644
index 0000000..bd75d7a
--- /dev/null
+++ b/.run/Clippy Main.run.xml	
@@ -0,0 +1,19 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Clippy Main" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="command" value="clippy --features &quot;output-wgpu, input-avfoundation&quot;" />
+    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <option name="channel" value="STABLE" />
+    <option name="requiredFeatures" value="true" />
+    <option name="allFeatures" value="false" />
+    <option name="emulateTerminal" value="true" />
+    <option name="withSudo" value="false" />
+    <option name="buildTarget" value="REMOTE" />
+    <option name="backtrace" value="SHORT" />
+    <envs />
+    <option name="isRedirectInput" value="false" />
+    <option name="redirectInputPath" value="" />
+    <method v="2">
+      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 326ed34..428a9a7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,69 +1,70 @@
 [package]
 name = "nokhwa"
-version = "0.9.4"
+version = "0.10.0"
 authors = ["l1npengtul <l1npengtul@protonmail.com>"]
-edition = "2018"
+edition = "2021"
 description = "A Simple-to-use, cross-platform Rust Webcam Capture Library"
 keywords = ["camera", "webcam", "capture", "cross-platform"]
-resolver = "2"
 license = "Apache-2.0"
 repository = "https://github.com/l1npengtul/nokhwa"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[workspace]
+members = ["nokhwa-bindings-macos", "nokhwa-bindings-windows", "nokhwa-core", "examples/*"]
+exclude = ["examples/jscam"]
+
 [lib]
 crate-type = ["cdylib", "rlib"]
 
 [features]
-default = ["decoding", "flume"]
-decoding = ["mozjpeg"]
+default = ["flume", "decoding"]
+serialize = ["serde", "nokhwa-core/serialize"]
+decoding = ["nokhwa-core/mjpeg"]
 input-v4l = ["v4l", "v4l2-sys-mit"]
 input-msmf = ["nokhwa-bindings-windows"]
 input-avfoundation = ["nokhwa-bindings-macos"]
-input-uvc = ["uvc", "uvc/vendor", "ouroboros", "usb_enumeration"]
-input-opencv = ["opencv", "opencv/clang-runtime"]
+# Re-enable it once soundness has been proven + mozjpeg is updated to 0.9.x
+# input-uvc = ["uvc", "uvc/vendor", "usb_enumeration", "lazy_static"]
+input-opencv = ["opencv", "opencv/rgb", "rgb"]
 input-ipcam = ["input-opencv"]
-input-gst = ["gstreamer", "glib", "gstreamer-app", "gstreamer-video", "regex"]
-input-jscam = ["web-sys", "js-sys", "wasm-bindgen-futures", "wasm-bindgen"]
-output-wgpu = ["wgpu"]
+input-gst = ["gstreamer", "glib", "gstreamer-app", "gstreamer-video", "regex", "parking_lot"]
+input-jscam = ["web-sys", "js-sys", "wasm-bindgen-futures", "wasm-bindgen", "wasm-rs-async-executor"]
+output-wgpu = ["wgpu", "nokhwa-core/wgpu-types"]
 output-wasm = ["input-jscam"]
-output-threaded = ["parking_lot"]
-small-wasm = ["wee_alloc"]
-docs-only = ["input-uvc", "input-v4l", "input-opencv", "input-ipcam", "input-gst", "input-msmf", "input-avfoundation", "input-jscam","output-wgpu", "output-wasm", "output-threaded"]
+output-threaded = []
+small-wasm = []
+docs-only = ["input-v4l", "input-opencv", "input-ipcam", "input-gst", "input-msmf", "input-avfoundation", "input-jscam","output-wgpu", "output-wasm", "output-threaded"]
 docs-nolink = ["glib/dox", "gstreamer-app/dox", "gstreamer/dox", "gstreamer-video/dox", "opencv/docs-only"]
 docs-features = []
 test-fail-warning = []
 
 [dependencies]
-thiserror = "1.0.26"
-paste = "1.0.5"
+thiserror = "1.0"
+paste = "1.0"
 
-[dependencies.flume]
-version = "0.10.8"
+[dependencies.nokhwa-core]
+version = "0.1.0"
+path = "nokhwa-core"
+
+[dependencies.serde]
+version = "1.0"
 optional = true
 
-[target.'cfg(not(target_family = "wasm"))'.dependencies.mozjpeg]
-version = "0.8.24"
+[dependencies.flume]
+version = "0.10"
 optional = true
 
 [dependencies.image]
-version = "^0.23"
+version = "0.24"
 default-features = false
 
-[target.'cfg(target_os = "linux")'.dependencies.v4l]
-version = "0.12.1"
+[dependencies.v4l]
+version = "0.13"
 optional = true
 
-[target.'cfg(target_os = "linux")'.dependencies.v4l2-sys-mit]
-version = "0.2.0"
-optional = true
-
-[dependencies.ouroboros]
-version = "^0.13"
-optional = true
-
-[dependencies.uvc]
-version = "0.2.0"
+[dependencies.v4l2-sys-mit]
+version = "0.2"
 optional = true
 
 [dependencies.usb_enumeration]
@@ -71,36 +72,41 @@ version = "0.1.2"
 optional = true
 
 [dependencies.wgpu]
-version = "^0.11"
+version = "0.13"
 optional = true
 
 [dependencies.opencv]
-version = "0.60.0"
-features = ["clang-runtime"]
+version = "0.67"
+optional = true
+
+[dependencies.rgb]
+version = "0.8"
 optional = true
 
 [dependencies.nokhwa-bindings-windows]
-version = "0.3.4"
+version = "0.4"
+path = "nokhwa-bindings-windows"
 optional = true
 
 [dependencies.nokhwa-bindings-macos]
-version = "0.1.1"
+version = "0.2"
+path = "nokhwa-bindings-macos"
 optional = true
 
 [dependencies.gstreamer]
-version = "0.17.0"
+version = "0.18"
 optional = true
 
 [dependencies.gstreamer-app]
-version = "0.17.0"
+version = "0.18"
 optional = true
 
 [dependencies.gstreamer-video]
-version = "0.17.0"
+version = "0.18"
 optional = true
 
 [dependencies.glib]
-version = "0.14.0"
+version = "0.15"
 optional = true
 
 [dependencies.regex]
@@ -108,8 +114,7 @@ version = "1.4.6"
 optional = true
 
 [dependencies.web-sys]
-version = "^0.3"
-# why
+version = "0.3"
 features = [
     "console",
     "CanvasRenderingContext2d",
@@ -129,23 +134,27 @@ features = [
 optional = true
 
 [dependencies.js-sys]
-version = "^0.3"
+version = "0.3"
 optional = true
 
 [dependencies.wasm-bindgen]
-version = "^0.2"
+version = "0.2"
 optional = true
 
 [dependencies.wasm-bindgen-futures]
-version = "^0.4"
+version = "0.4"
 optional = true
 
-[dependencies.wee_alloc]
-version = "0.4.5"
+[dependencies.wasm-rs-async-executor]
+version = "0.9"
 optional = true
 
 [dependencies.parking_lot]
-version = "^0.11"
+version = "0.12"
+optional = true
+
+[dependencies.lazy_static]
+version = "1.4"
 optional = true
 
 [profile.release]
diff --git a/Jenkinsfile b/Jenkinsfile
deleted file mode 100644
index ac1bcf0..0000000
--- a/Jenkinsfile
+++ /dev/null
@@ -1,127 +0,0 @@
-pipeline {
-  agent {
-    node {
-      label 'ci_linux'
-    }
-
-  }
-  stages {
-    stage('Sanity Check') {
-      steps {
-        echo '$BUILD_TAG'
-        scmSkip(deleteBuild: true, skipPattern: '.*\\[ci skip\\].*')
-      }
-    }
-
-    stage('Cargo RustFMT') {
-      agent {
-        node {
-          label 'ci_linux'
-        }
-
-      }
-      steps {
-        sh 'rustup update stable'
-        sh 'cargo fmt --all -- --check'
-      }
-    }
-
-    stage('Build, Clippy') {
-      parallel {
-        stage('V4L2') {
-          agent {
-            node {
-              label 'ci_linux'
-            }
-
-          }
-          steps {
-            sh 'rustup update stable'
-            sh 'cargo clippy --features "input-v4l, output-wgpu, test-fail-warning"'
-          }
-        }
-
-        stage('Media Foundation') {
-          agent {
-            node {
-              label 'ci_windows'
-            }
-
-          }
-          steps {
-            pwsh(script: 'rustup update stable', returnStatus: true)
-            pwsh(script: 'cargo clippy --features "input-msmf, output-wgpu, test-fail-warning"', returnStatus: true, returnStdout: true)
-          }
-        }
-
-        stage('AVFoundation') {
-          steps {
-            sh 'echo TODO'
-          }
-        }
-
-        stage('libUVC') {
-          agent {
-            node {
-              label 'ci_linux'
-            }
-
-          }
-          steps {
-            sh 'rustup update stable'
-            sh 'cargo clippy --features "input-uvc, output-wgpu, test-fail-warning"'
-          }
-        }
-
-        stage('OpenCV IPCamera') {
-          agent {
-            node {
-              label 'ci_linux'
-            }
-
-          }
-          steps {
-            sh 'rustup update stable'
-            sh 'cargo +nightly clippy --features "input-opencv, input-ipcam, output-wgpu, test-fail-warning"'
-          }
-        }
-
-        stage('GStreamer') {
-          agent {
-            node {
-              label 'ci_linux'
-            }
-
-          }
-          steps {
-            sh 'rustup update nightly'
-            sh 'cargo clippy --features "input-gst, output-wgpu, test-fail-warning"'
-          }
-        }
-
-        stage('JSCamera/WASM') {
-          steps {
-            sh 'rustup update stable'
-            sh 'wasm-pack build --release -- --features "input-jscam, output-wasm,  test-fail-warning" --no-default-features'
-            sh 'cargo clippy --features "input-jscam, output-wasm,  test-fail-warning" --no-default-features'
-          }
-        }
-
-      }
-    }
-
-    stage('RustDOC') {
-      agent {
-        node {
-          label 'ci_linux'
-        }
-
-      }
-      steps {
-        sh 'rustup update nightly'
-        sh 'cargo +nightly doc --features "docs-only, docs-nolink, docs-features, test-fail-warning" --no-deps --release'
-      }
-    }
-
-  }
-}
\ No newline at end of file
diff --git a/README.md b/README.md
index 7ce8107..19e3a6c 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+[![cargo version](https://img.shields.io/crates/v/nokhwa.svg)](https://crates.io/crates/nokhwa) [![docs.rs version](https://img.shields.io/docsrs/nokhwa)](https://docs.rs/nokhwa/latest/nokhwa/)
 # nokhwa
 Nokhwa(녹화): Korean word meaning "to record".
 
@@ -5,11 +6,11 @@ A Simple-to-use, cross-platform Rust Webcam Capture Library
 
 ## Using nokhwa
 Nokhwa can be added to your crate by adding it to your `Cargo.toml`:
-```.ignore
+```toml
 [dependencies.nokhwa]
-// TODO: replace the "*" with the latest version of `nokhwa`
+# TODO: replace the "*" with the latest version of `nokhwa`
 version = "*"
-// TODO: add some features
+# TODO: add some features
 features = [""]
 ```
 
@@ -17,7 +18,7 @@ Most likely, you will only use functionality provided by the `Camera` struct. If
 
 ## Example
 
-```.ignore
+```rust
 // set up the Camera
 let mut camera = Camera::new(
     0, // index
@@ -27,7 +28,7 @@ let mut camera = Camera::new(
 // open stream
 camera.open_stream().unwrap();
 loop {
-    let frame = camera.get_frame().unwrap();
+    let frame = camera.frame().unwrap();
     println!("{}, {}", frame.width(), frame.height());
 }
 ```
@@ -41,16 +42,16 @@ The table below lists current Nokhwa API support.
 - The `Query-Device` column signifies reading device capabilities
 - The `Platform` column signifies what Platform this is availible on.
 
- | Backend                             | Input              | Query             | Query-Device       | Platform            |
- |-------------------------------------|--------------------|-------------------|--------------------|---------------------|
- | Video4Linux(`input-v4l`)            | ✅                 | ✅                 | ✅                 | Linux               |
- | MSMF(`input-msmf`)                  | ✅                 | ✅                 | ✅                 | Windows             |
- | AVFoundation(`input-avfoundatuin`)^^| ✅                 | ✅                 | ✅                 | Mac                 |
- | libuvc(`input-uvc`)^^^              | ❌                 | ✅                 | ❌                 | Linux, Windows, Mac |
- | OpenCV(`input-opencv`)^             | ✅                 | ❌                 | ❌                 | Linux, Windows, Mac |
- | IPCamera(`input-ipcam`/OpenCV)^     | ✅                 | ❌                 | ❌                 | Linux, Windows, Mac |
- | GStreamer(`input-gst`)              | ✅                 | ✅                 | ✅                 | Linux, Windows, Mac |
- | JS/WASM(`input-wasm`)               | ✅                 | ✅                 | ✅                 | Browser(Web)        |
+ | Backend                                | Input              | Query             | Query-Device       | Platform            |
+ |----------------------------------------|--------------------|-------------------|--------------------|---------------------|
+ | Video4Linux(`input-v4l`)               | ✅                 | ✅                 | ✅                 | Linux               |
+ | MSMF(`input-msmf`)                     | ✅                 | ✅                 | ✅                 | Windows             |
+ | AVFoundation(`input-avfoundation`)^^   | ✅                 | ✅                 | ✅                 | Mac                 |
+ | libuvc(`input-uvc`) (**DEPRECATED**)^^^| ❌                 | ✅                 | ❌                 | Linux, Windows, Mac |
+ | OpenCV(`input-opencv`)^                | ✅                 | ❌                 | ❌                 | Linux, Windows, Mac |
+ | IPCamera(`input-ipcam`/OpenCV)^        | ✅                 | ❌                 | ❌                 | Linux, Windows, Mac |
+ | GStreamer(`input-gst`)(**DEPRECATED**) | ✅                 | ✅                 | ✅                 | Linux, Windows, Mac |
+ | JS/WASM(`input-wasm`)                  | ✅                 | ✅                 | ✅                 | Browser(Web)        |
 
  ✅: Working, 🔮 : Experimental, ❌ : Not Supported, 🚧: Planned/WIP
 
@@ -63,14 +64,16 @@ The table below lists current Nokhwa API support.
 The default feature includes nothing. Anything starting with `input-*` is a feature that enables the specific backend. 
 As a general rule of thumb, you would want to keep at least `input-uvc` or other backend that has querying enabled so you can get device information from `nokhwa`.
 
+### ***NOTE: It is safe to have `input-v4l`, `input-msmf`, and `input-avfoundation` all enabled at the same time since it is platform gated as well!***
+
 `input-*` features:
  - `input-v4l`: Enables the `Video4Linux` backend. (linux)
  - `input-msmf`: Enables the `MediaFoundation` backennd. (Windows 7 or newer)
  - `input-avfoundation`: Enables the `AVFoundation` backend. (MacOSX 10.7)
- - `input-uvc`: Enables the `libuvc` backend. (cross-platform, libuvc statically-linked)
+ - `input-uvc`: **[DEPRECATED]** Enables the `libuvc` backend. (cross-platform, libuvc statically-linked) 
  - `input-opencv`: Enables the `opencv` backend. (cross-platform) 
  - `input-ipcam`: Enables the use of IP Cameras, please see the `NetworkCamera` struct. Note that this relies on `opencv`, so it will automatically enable the `input-opencv` feature.
- - `input-gst`: Enables the `gstreamer` backend. (cross-platform)
+ - `input-gst`: **[DEPRECATED]** Enables the `gstreamer` backend. 
  - `input-jscam`: Enables the use of the `JSCamera` struct, which uses browser APIs. (Web)
 
 Conversely, anything that starts with `output-*` controls a feature that controls the output of something (usually a frame from the camera)
@@ -107,3 +110,7 @@ Contributions are welcome!
 
 ## Minimum Service Rust Version
 `nokhwa` may build on older versions of `rustc`, but there is no guarantee except for the latest stable rust. 
+
+## Sponsors
+- $5/mo sponsors:
+  - [remifluff](https://github.com/remifluff)
diff --git a/examples/capture/Cargo.toml b/examples/capture/Cargo.toml
index f2b4593..77438ce 100644
--- a/examples/capture/Cargo.toml
+++ b/examples/capture/Cargo.toml
@@ -10,14 +10,13 @@ edition = "2018"
 default = ["nokhwa/default"]
 input-msmf = ["nokhwa/input-msmf"]
 input-v4l = ["nokhwa/input-v4l"]
-input-uvc = ["nokhwa/input-uvc"]
 input-opencv = ["nokhwa/input-opencv"]
 input-gst = ["nokhwa/input-gst"]
 input-avfoundation = ["nokhwa/input-avfoundation"]
 
 [dependencies]
 clap = "2.33.3"
-glium = "0.30.0"
+glium = "0.31.0"
 glutin = "0.27.0"
 flume = "0.10.9"
 
diff --git a/examples/capture/example-capture/example-capture.xcodeproj/project.xcworkspace/xcuserdata/pengg.xcuserdatad/UserInterfaceState.xcuserstate b/examples/capture/example-capture/example-capture.xcodeproj/project.xcworkspace/xcuserdata/pengg.xcuserdatad/UserInterfaceState.xcuserstate
index 1ffedf4..bc42ece 100644
Binary files a/examples/capture/example-capture/example-capture.xcodeproj/project.xcworkspace/xcuserdata/pengg.xcuserdatad/UserInterfaceState.xcuserstate and b/examples/capture/example-capture/example-capture.xcodeproj/project.xcworkspace/xcuserdata/pengg.xcuserdatad/UserInterfaceState.xcuserstate differ
diff --git a/examples/capture/src/main.rs b/examples/capture/src/main.rs
index cf906a9..3f6d453 100644
--- a/examples/capture/src/main.rs
+++ b/examples/capture/src/main.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,8 +21,13 @@ use glium::{
     implement_vertex, index::PrimitiveType, program, texture::RawImage2d, uniform, Display,
     IndexBuffer, Surface, Texture2d, VertexBuffer,
 };
-use glutin::{event_loop::EventLoop, window::WindowBuilder, ContextBuilder};
-use nokhwa::{nokhwa_initialize, query_devices, Camera, CaptureAPIBackend, FrameFormat};
+use glutin::{
+    event::{Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+    ContextBuilder,
+};
+use nokhwa::{nokhwa_initialize, query, ApiBackend, Camera, FrameFormat};
 use std::time::Instant;
 
 #[derive(Copy, Clone)]
@@ -111,33 +116,33 @@ fn main() {
     // Query example
     if matches.is_present("query") {
         let backend_value = matches.value_of("query").unwrap();
-        let mut use_backend = CaptureAPIBackend::Auto;
+        let mut use_backend = ApiBackend::Auto;
         // AUTO
         if backend_value == "AUTO" {
-            use_backend = CaptureAPIBackend::Auto;
+            use_backend = ApiBackend::Auto;
         } else if backend_value == "UVC" {
-            use_backend = CaptureAPIBackend::UniversalVideoClass;
+            use_backend = ApiBackend::UniversalVideoClass;
         } else if backend_value == "GST" {
-            use_backend = CaptureAPIBackend::GStreamer;
+            use_backend = ApiBackend::GStreamer;
         } else if backend_value == "V4L" {
-            use_backend = CaptureAPIBackend::Video4Linux;
+            use_backend = ApiBackend::Video4Linux;
         } else if backend_value == "MSMF" {
-            use_backend = CaptureAPIBackend::MediaFoundation;
+            use_backend = ApiBackend::MediaFoundation;
         } else if backend_value == "AVF" {
             nokhwa_initialize(|x| {
                 println!("{}", x);
             });
-            use_backend = CaptureAPIBackend::AVFoundation;
+            use_backend = ApiBackend::AVFoundation;
         }
 
-        match query_devices(use_backend) {
+        match query(use_backend) {
             Ok(devs) => {
                 for (idx, camera) in devs.iter().enumerate() {
                     println!("Device at index {}: {}", idx, camera)
                 }
             }
             Err(why) => {
-                println!("Failed to query: {}", why.to_string())
+                println!("Failed to query: {why}")
             }
         }
     }
@@ -145,13 +150,13 @@ fn main() {
     if matches.is_present("capture") {
         let backend_value = {
             match matches.value_of("capture-backend").unwrap() {
-                "UVC" => CaptureAPIBackend::UniversalVideoClass,
-                "GST" => CaptureAPIBackend::GStreamer,
-                "V4L" => CaptureAPIBackend::Video4Linux,
-                "OPENCV" => CaptureAPIBackend::OpenCv,
-                "MSMF" => CaptureAPIBackend::MediaFoundation,
-                "AVF" => CaptureAPIBackend::AVFoundation,
-                _ => CaptureAPIBackend::Auto,
+                "UVC" => ApiBackend::UniversalVideoClass,
+                "GST" => ApiBackend::GStreamer,
+                "V4L" => ApiBackend::Video4Linux,
+                "OPENCV" => ApiBackend::OpenCv,
+                "MSMF" => ApiBackend::MediaFoundation,
+                "AVF" => ApiBackend::AVFoundation,
+                _ => ApiBackend::Auto,
             }
         };
         let width = matches
@@ -206,13 +211,13 @@ fn main() {
                                         }
                                     }
                                     Err(why) => {
-                                        println!("Failed to get compatible resolution/FPS list for FrameFormat {}: {}", ff, why.to_string())
+                                        println!("Failed to get compatible resolution/FPS list for FrameFormat {ff}: {why}")
                                     }
                                 }
                             }
                         }
                         Err(why) => {
-                            println!("Failed to get compatible FourCC: {}", why.to_string())
+                            println!("Failed to get compatible FourCC: {why}")
                         }
                     }
                 }
@@ -226,7 +231,7 @@ fn main() {
                             }
                         }
                         Err(why) => {
-                            println!("Failed to get camera controls: {}", why.to_string())
+                            println!("Failed to get camera controls: {why}")
                         }
                     }
                 }
@@ -237,7 +242,7 @@ fn main() {
                     let supported = match camera.camera_controls_string() {
                         Ok(cc) => cc,
                         Err(why) => {
-                            println!("Failed to get camera controls: {}", why.to_string());
+                            println!("Failed to get camera controls: {why}");
                             return;
                         }
                     };
@@ -330,7 +335,7 @@ fn main() {
                     v_tex_coords = tex_coords;
                 }
             ",
-
+                    outputs_srgb: true,
                     fragment: "
                 #version 140
                 uniform sampler2D tex;
@@ -347,49 +352,49 @@ fn main() {
             // run the event loop
 
             gl_event_loop.run(move |event, _window, ctrl| {
-                let before_capture = Instant::now();
-                let frame = recv.recv().unwrap();
-                let after_capture = Instant::now();
+                *ctrl = match event {
+                    Event::MainEventsCleared => {
+                        let instant = Instant::now();
+                        let frame = recv.recv().unwrap();
+                        let capture_elapsed = instant.elapsed().as_millis();
 
-                let width = &frame.width();
-                let height = &frame.height();
+                        let frame_size = (frame.width(), frame.height());
 
-                let raw_data = RawImage2d::from_raw_rgb(frame.into_raw(), (*width, *height));
-                let gl_texture = Texture2d::new(&gl_display, raw_data).unwrap();
+                        let raw_data = RawImage2d::from_raw_rgb(frame.into_raw(), frame_size);
+                        let gl_texture = Texture2d::new(&gl_display, raw_data).unwrap();
 
-                let uniforms = uniform! {
-                    matrix: [
-                        [1.0, 0.0, 0.0, 0.0],
-                        [0.0, -1.0, 0.0, 0.0],
-                        [0.0, 0.0, 1.0, 0.0],
-                        [0.0, 0.0, 0.0, 1.0f32]
-                    ],
-                    tex: &gl_texture
-                };
+                        let uniforms = uniform! {
+                            matrix: [
+                                [1.0, 0.0, 0.0, 0.0],
+                                [0.0, -1.0, 0.0, 0.0],
+                                [0.0, 0.0, 1.0, 0.0],
+                                [0.0, 0.0, 0.0, 1.0f32]
+                            ],
+                            tex: &gl_texture
+                        };
 
-                let mut target = gl_display.draw();
-                target.clear_color(0.0, 0.0, 0.0, 0.0);
-                target
-                    .draw(
-                        &vert_buffer,
-                        &idx_buf,
-                        &program,
-                        &uniforms,
-                        &Default::default(),
-                    )
-                    .unwrap();
-                target.finish().unwrap();
+                        let mut target = gl_display.draw();
+                        target.clear_color(0.0, 0.0, 0.0, 0.0);
+                        target
+                            .draw(
+                                &vert_buffer,
+                                &idx_buf,
+                                &program,
+                                &uniforms,
+                                &Default::default(),
+                            )
+                            .unwrap();
+                        target.finish().unwrap();
 
-                if let glutin::event::Event::WindowEvent { event, .. } = event {
-                    if event == glutin::event::WindowEvent::CloseRequested {
-                        *ctrl = glutin::event_loop::ControlFlow::Exit;
+                        println!("Took {capture_elapsed}ms to capture",);
+                        ControlFlow::Poll
                     }
+                    Event::WindowEvent {
+                        event: WindowEvent::CloseRequested,
+                        ..
+                    } => ControlFlow::Exit,
+                    _ => ControlFlow::Poll,
                 }
-
-                println!(
-                    "Took {}ms to capture",
-                    after_capture.duration_since(before_capture).as_millis()
-                )
             })
         }
         // dont
diff --git a/examples/jscam/setup.sh b/examples/jscam/setup.sh
index 501ffa0..0178410 100644
--- a/examples/jscam/setup.sh
+++ b/examples/jscam/setup.sh
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+# Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
diff --git a/examples/jscam/src/index.html b/examples/jscam/src/index.html
index 0f6f3f0..e9a8a76 100644
--- a/examples/jscam/src/index.html
+++ b/examples/jscam/src/index.html
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+  ~ Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/examples/setting/Cargo.toml b/examples/setting/Cargo.toml
index 30c218a..b9d84ee 100644
--- a/examples/setting/Cargo.toml
+++ b/examples/setting/Cargo.toml
@@ -9,7 +9,7 @@ edition = "2021"
 
 [dependencies.image]
 version = "0.23.14"
-no-default-features = true
+default-features = false
 
 [dependencies.nokhwa]
 path = "../../../nokhwa"
diff --git a/examples/setting/src/main.rs b/examples/setting/src/main.rs
index e9b9db5..a3bd2dc 100644
--- a/examples/setting/src/main.rs
+++ b/examples/setting/src/main.rs
@@ -1,9 +1,9 @@
-use nokhwa::{Camera, CameraFormat, KnownCameraControls};
+use nokhwa::{Camera, CameraFormat, KnownCameraControl};
 
 fn main() {
     let mut camera = Camera::new(0, None).unwrap();
     let known = camera.camera_controls_known_camera_controls().unwrap();
-    let mut control = *known.get(&KnownCameraControls::Gamma).unwrap();
+    let mut control = *known.get(&KnownCameraControl::Gamma).unwrap();
     control.set_value(101).unwrap();
     camera.set_camera_control(control).unwrap();
 }
diff --git a/examples/threaded-capture/Cargo.toml b/examples/threaded-capture/Cargo.toml
index 9cb829c..d8c48cb 100644
--- a/examples/threaded-capture/Cargo.toml
+++ b/examples/threaded-capture/Cargo.toml
@@ -9,7 +9,7 @@ edition = "2018"
 
 [dependencies.image]
 version = "0.23.14"
-no-default-features = true
+default-features = false
 
 [dependencies.nokhwa]
 path = "../../../nokhwa"
diff --git a/examples/threaded-capture/src/main.rs b/examples/threaded-capture/src/main.rs
index 7b95cb4..327b6ab 100644
--- a/examples/threaded-capture/src/main.rs
+++ b/examples/threaded-capture/src/main.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,11 +15,10 @@
  */
 
 use image::{ImageBuffer, Rgb};
-use nokhwa::{query_devices, CaptureAPIBackend, ThreadedCamera};
-use std::time::Duration;
+use nokhwa::{query, ApiBackend, ThreadedCamera};
 
 fn main() {
-    let cameras = query_devices(CaptureAPIBackend::Auto).unwrap();
+    let cameras = query(ApiBackend::Auto).unwrap();
     cameras.iter().for_each(|cam| println!("{:?}", cam));
 
     let mut threaded = ThreadedCamera::new(0, None).unwrap();
diff --git a/make-npm.sh b/make-npm.sh
index 7e931d3..6c2ba77 100755
--- a/make-npm.sh
+++ b/make-npm.sh
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+# Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
diff --git a/nokhwa-bindings-macos/Cargo.toml b/nokhwa-bindings-macos/Cargo.toml
index 018f745..9fbb26a 100644
--- a/nokhwa-bindings-macos/Cargo.toml
+++ b/nokhwa-bindings-macos/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "nokhwa-bindings-macos"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2018"
 authors = ["l1npengtul"]
 license = "Apache-2.0"
@@ -10,13 +10,13 @@ keywords = ["avfoundation", "macos", "capture", "webcam"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-thiserror = "1.0.26"
-flume = "0.10.9"
+flume = "0.10"
+core-media-sys = "0.1"
+cocoa-foundation = "0.1"
+objc = { version = "0.2", features = ["exception"] }
+block = "0.1"
+once_cell = "1.14"
 
-[target.'cfg(any(target_os = "macos", target_os = "ios"))'.dependencies]
-core-media-sys = "0.1.2"
-cocoa-foundation = "0.1.0"
-objc = { version = "0.2.7", features = ["exception"] }
-block = "0.1.6"
-dashmap = "4.0.2"
-lazy_static = "1.4.0"
\ No newline at end of file
+[dependencies.nokhwa-core]
+version = "0.1"
+path = "../nokhwa-core"
diff --git a/nokhwa-bindings-macos/build.rs b/nokhwa-bindings-macos/build.rs
index f4b50fd..d01268b 100644
--- a/nokhwa-bindings-macos/build.rs
+++ b/nokhwa-bindings-macos/build.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@
 fn main() {
     println!("cargo:rustc-link-lib=framework=CoreMedia");
     println!("cargo:rustc-link-lib=framework=AVFoundation");
+    println!("cargo:rustc-link-lib=framework=CoreVideo");
 }
 
 #[cfg(not(any(target_os = "macos", target_os = "ios")))]
diff --git a/nokhwa-bindings-macos/src/lib.rs b/nokhwa-bindings-macos/src/lib.rs
index 32f9a18..de856b9 100644
--- a/nokhwa-bindings-macos/src/lib.rs
+++ b/nokhwa-bindings-macos/src/lib.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,64 +14,22 @@
  * limitations under the License.
  */
 
-#![cfg_attr(
-    any(target_os = "macos", target_os = "ios"),
-    link(name = "AVFoundation", kind = "framework")
-)]
-#![cfg_attr(
-    any(target_os = "macos", target_os = "ios"),
-    link(name = "CoreMedia", kind = "framework")
-)]
+// hello, future peng here
+// whatever is written here will induce horrors uncomprehendable.
+// save yourselves. write apple code in swift and bind it to rust.
+
 #![allow(clippy::not_unsafe_ptr_arg_deref)]
 
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[macro_use]
 extern crate objc;
-#[cfg(any(target_os = "macos", target_os = "ios"))]
-#[macro_use]
-extern crate lazy_static;
-
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum AVFError {
-    #[error("Invalid: Expected {expected} Found {found}")]
-    InvalidType { expected: String, found: String },
-    #[error("Invalid Value: {found}")]
-    InvalidValue { found: String },
-    #[error("Already Busy: {0}")]
-    AlreadyBusy(String),
-    #[error("Failed to open device {index}: {why}")]
-    FailedToOpenDevice { index: usize, why: String },
-    #[error("Config Not Accepted")]
-    ConfigNotAccepted,
-    #[error("General Error: {0}")]
-    General(String),
-    #[error("Cannot add input to session: Rejected")]
-    RejectedInput,
-    #[error("Cannot add output to session: Rejected")]
-    RejectedOutput,
-    #[error("Failed to open stream: {0}")]
-    StreamOpen(String),
-    #[error("Failed to read frame: {0}")]
-    ReadFrame(String),
-    #[error("Unsupported")]
-    NotSupported,
-}
 
 #[cfg(any(target_os = "macos", target_os = "ios"))]
-#[cfg_attr(
-    any(target_os = "macos", target_os = "ios"),
-    link(name = "CoreMedia", kind = "framework")
-)]
-#[cfg_attr(
-    any(target_os = "macos", target_os = "ios"),
-    link(name = "AVFoundation", kind = "framework")
-)]
 #[allow(non_snake_case)]
 pub mod core_media {
     // all of this is stolen from bindgen
     // steal it idc
+    use crate::CGFloat;
     use core_media_sys::{
         CMBlockBufferRef, CMFormatDescriptionRef, CMSampleBufferRef, CMTime, CMVideoDimensions,
         FourCharCode,
@@ -85,7 +43,7 @@ pub mod core_media {
     #[derive(Clone)]
     pub struct NSObject(pub Id);
     impl Deref for NSObject {
-        type Target = objc::runtime::Object;
+        type Target = Object;
         fn deref(&self) -> &Self::Target {
             unsafe { &*self.0 }
         }
@@ -101,7 +59,7 @@ pub mod core_media {
     #[derive(Clone)]
     pub struct NSString(pub Id);
     impl Deref for NSString {
-        type Target = objc::runtime::Object;
+        type Target = Object;
         fn deref(&self) -> &Self::Target {
             unsafe { &*self.0 }
         }
@@ -115,20 +73,8 @@ pub mod core_media {
 
     pub type AVMediaType = NSString;
 
-    extern "C" {
-        pub static AVMediaTypeVideo: AVMediaType;
-        pub static AVMediaTypeAudio: AVMediaType;
-        pub static AVMediaTypeText: AVMediaType;
-        pub static AVMediaTypeClosedCaption: AVMediaType;
-        pub static AVMediaTypeSubtitle: AVMediaType;
-        pub static AVMediaTypeTimecode: AVMediaType;
-        pub static AVMediaTypeMetadata: AVMediaType;
-        pub static AVMediaTypeMuxed: AVMediaType;
-        pub static AVMediaTypeMetadataObject: AVMediaType;
-        pub static AVMediaTypeDepthData: AVMediaType;
-    }
-
     #[allow(non_snake_case)]
+    #[link(name = "CoreMedia", kind = "framework")]
     extern "C" {
         pub fn CMVideoFormatDescriptionGetDimensions(
             videoDesc: CMFormatDescriptionRef,
@@ -142,42 +88,20 @@ pub mod core_media {
             theSourceBuffer: CMBlockBufferRef,
             offsetToData: usize,
             dataLength: usize,
-            destination: *mut ::std::os::raw::c_void,
+            destination: *mut std::os::raw::c_void,
         ) -> std::os::raw::c_int;
 
         pub fn CMSampleBufferGetDataBuffer(sbuf: CMSampleBufferRef) -> CMBlockBufferRef;
-    }
 
-    extern "C" {
         pub fn dispatch_queue_create(
-            label: *const ::std::os::raw::c_char,
+            label: *const std::os::raw::c_char,
             attr: NSObject,
         ) -> NSObject;
-    }
 
-    extern "C" {
         pub fn dispatch_release(object: NSObject);
-    }
 
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
-    pub struct __CVBuffer {
-        _unused: [u8; 0],
-    }
-    pub type CVBufferRef = *mut __CVBuffer;
-
-    #[allow(non_snake_case)]
-    extern "C" {
         pub fn CMSampleBufferGetImageBuffer(sbuf: CMSampleBufferRef) -> CVImageBufferRef;
-    }
 
-    pub type CVImageBufferRef = CVBufferRef;
-    pub type CVPixelBufferRef = CVImageBufferRef;
-    pub type CVPixelBufferLockFlags = u64;
-    pub type CVReturn = i32;
-
-    #[allow(non_snake_case)]
-    extern "C" {
         pub fn CVPixelBufferLockBaseAddress(
             pixelBuffer: CVPixelBufferRef,
             lockFlags: CVPixelBufferLockFlags,
@@ -192,15 +116,46 @@ pub mod core_media {
 
         pub fn CVPixelBufferGetBaseAddress(
             pixelBuffer: CVPixelBufferRef,
-        ) -> *mut ::std::os::raw::c_void;
+        ) -> *mut std::os::raw::c_void;
+
+        pub fn CVPixelBufferGetPixelFormatType(pixelBuffer: CVPixelBufferRef) -> OSType;
     }
 
-    extern "C" {
-        pub static AVVideoCodecKey: NSString;
+    #[repr(C)]
+    #[derive(Clone, Debug, PartialEq, PartialOrd)]
+    pub struct CGPoint {
+        pub x: CGFloat,
+        pub y: CGFloat,
     }
+
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct __CVBuffer {
+        _unused: [u8; 0],
+    }
+
+    #[allow(non_snake_case)]
+    #[derive(Copy, Clone, Debug, PartialOrd, PartialEq)]
+    #[repr(C)]
+    pub struct AVCaptureWhiteBalanceGains {
+        pub blueGain: f32,
+        pub greenGain: f32,
+        pub redGain: f32,
+    }
+
+    pub type CVBufferRef = *mut __CVBuffer;
+
+    pub type CVImageBufferRef = CVBufferRef;
+    pub type CVPixelBufferRef = CVImageBufferRef;
+    pub type CVPixelBufferLockFlags = u64;
+    pub type CVReturn = i32;
+
     pub type OSType = FourCharCode;
     pub type AVVideoCodecType = NSString;
+
+    #[link(name = "AVFoundation", kind = "framework")]
     extern "C" {
+        pub static AVVideoCodecKey: NSString;
         pub static AVVideoCodecTypeHEVC: AVVideoCodecType;
         pub static AVVideoCodecTypeH264: AVVideoCodecType;
         pub static AVVideoCodecTypeJPEG: AVVideoCodecType;
@@ -218,55 +173,72 @@ pub mod core_media {
         pub static AVVideoWidthKey: NSString;
         pub static AVVideoHeightKey: NSString;
         pub static AVVideoExpectedSourceFrameRateKey: NSString;
-        pub fn CVPixelBufferGetPixelFormatType(pixelBuffer: CVPixelBufferRef) -> OSType;
 
+        pub static AVMediaTypeVideo: AVMediaType;
+        pub static AVMediaTypeAudio: AVMediaType;
+        pub static AVMediaTypeText: AVMediaType;
+        pub static AVMediaTypeClosedCaption: AVMediaType;
+        pub static AVMediaTypeSubtitle: AVMediaType;
+        pub static AVMediaTypeTimecode: AVMediaType;
+        pub static AVMediaTypeMetadata: AVMediaType;
+        pub static AVMediaTypeMuxed: AVMediaType;
+        pub static AVMediaTypeMetadataObject: AVMediaType;
+        pub static AVMediaTypeDepthData: AVMediaType;
+
+        pub static AVCaptureLensPositionCurrent: f32;
+        pub static AVCaptureExposureTargetBiasCurrent: f32;
+        pub static AVCaptureExposureDurationCurrent: CMTime;
+        pub static AVCaptureISOCurrent: f32;
     }
 }
 
-#[cfg(any(target_os = "macos", target_os = "ios"))]
-pub mod avfoundation {
-    use crate::core_media::{
-        AVMediaTypeAudio, AVMediaTypeClosedCaption, AVMediaTypeDepthData, AVMediaTypeMetadata,
-        AVMediaTypeMetadataObject, AVMediaTypeMuxed, AVMediaTypeSubtitle, AVMediaTypeText,
-        AVMediaTypeTimecode, CVPixelBufferGetPixelFormatType,
-    };
-    use crate::{
-        core_media::{
-            dispatch_queue_create, AVMediaTypeVideo, CMSampleBufferGetImageBuffer,
-            CMVideoFormatDescriptionGetDimensions, CVImageBufferRef, CVPixelBufferGetBaseAddress,
-            CVPixelBufferGetDataSize, CVPixelBufferLockBaseAddress, CVPixelBufferUnlockBaseAddress,
-            NSObject,
-        },
-        AVFError,
-    };
-    use block::ConcreteBlock;
-    use cocoa_foundation::foundation::{NSArray, NSInteger, NSString, NSUInteger};
-    use core_media_sys::{
-        kCMPixelFormat_422YpCbCr8_yuvs, kCMVideoCodecType_422YpCbCr8, kCMVideoCodecType_JPEG,
-        kCMVideoCodecType_JPEG_OpenDML, CMFormatDescriptionGetMediaSubType, CMSampleBufferRef,
-        CMVideoDimensions,
-    };
-    use dashmap::DashMap;
-    use flume::{Receiver, Sender};
-    use objc::{
-        declare::ClassDecl,
-        runtime::{Class, Object, Protocol, Sel, BOOL, YES},
-    };
-    use std::{
-        borrow::Cow,
-        cmp::Ordering,
-        convert::TryFrom,
-        error::Error,
-        ffi::{c_void, CStr, CString},
-        sync::{
-            atomic::{AtomicBool, Ordering as MemOrdering},
-            Arc, Mutex, TryLockError,
-        },
-    };
+use crate::core_media::{
+    dispatch_queue_create, AVCaptureExposureDurationCurrent, AVCaptureExposureTargetBiasCurrent,
+    AVCaptureISOCurrent, AVCaptureWhiteBalanceGains, AVMediaTypeAudio, AVMediaTypeClosedCaption,
+    AVMediaTypeDepthData, AVMediaTypeMetadata, AVMediaTypeMetadataObject, AVMediaTypeMuxed,
+    AVMediaTypeSubtitle, AVMediaTypeText, AVMediaTypeTimecode, AVMediaTypeVideo, CGPoint,
+    CMSampleBufferGetImageBuffer, CMVideoFormatDescriptionGetDimensions, CVImageBufferRef,
+    CVPixelBufferGetBaseAddress, CVPixelBufferGetDataSize, CVPixelBufferGetPixelFormatType,
+    CVPixelBufferLockBaseAddress, CVPixelBufferUnlockBaseAddress, NSObject,
+};
+use block::ConcreteBlock;
+use cocoa_foundation::base::Nil;
+use cocoa_foundation::foundation::{NSArray, NSInteger, NSString, NSUInteger};
+use core_media_sys::{
+    kCMPixelFormat_422YpCbCr8_yuvs, kCMPixelFormat_8IndexedGray_WhiteIsZero,
+    kCMVideoCodecType_422YpCbCr8, kCMVideoCodecType_JPEG, kCMVideoCodecType_JPEG_OpenDML,
+    CMFormatDescriptionGetMediaSubType, CMFormatDescriptionRef, CMSampleBufferRef, CMTime,
+    CMVideoDimensions,
+};
+use flume::{Receiver, Sender};
+use nokhwa_core::types::ControlValueSetter;
+use nokhwa_core::{
+    error::NokhwaError,
+    types::{
+        ApiBackend, CameraControl, CameraFormat, CameraIndex, CameraInfo, ControlValueDescription,
+        FrameFormat, KnownCameraControl, KnownCameraControlFlag, Resolution,
+    },
+};
+use objc::{
+    declare::ClassDecl,
+    runtime::{Class, Object, Protocol, Sel, BOOL, NO, YES},
+};
+use once_cell::sync::Lazy;
+use std::collections::BTreeMap;
+use std::{
+    borrow::Cow,
+    cmp::Ordering,
+    collections::HashSet,
+    convert::TryFrom,
+    error::Error,
+    ffi::{c_float, c_void, CStr},
+    sync::{Arc, Mutex},
+};
 
-    const UTF8_ENCODING: usize = 4;
+const UTF8_ENCODING: usize = 4;
+type CGFloat = c_float;
 
-    macro_rules! create_boilerplate_impl {
+macro_rules! create_boilerplate_impl {
         {
             $( [$class_vis:vis $class_name:ident : $( {$field_vis:vis $field_name:ident : $field_type:ty} ),*] ),+
         } => {
@@ -311,1224 +283,2125 @@ pub mod avfoundation {
         };
     }
 
-    fn str_to_nsstr(string: &str) -> *mut Object {
-        let cls = class!(NSString);
-        let bytes = string.as_ptr() as *const c_void;
-        unsafe {
-            let obj: *mut Object = msg_send![cls, alloc];
-            let obj: *mut Object = msg_send![
-                obj,
-                initWithBytes:bytes
-                length:string.len()
-                encoding:UTF8_ENCODING
-            ];
-            let _: *mut std::ffi::c_void = msg_send![obj, autorelease];
-            obj
-        }
+fn str_to_nsstr(string: &str) -> *mut Object {
+    let cls = class!(NSString);
+    let bytes = string.as_ptr() as *const c_void;
+    unsafe {
+        let obj: *mut Object = msg_send![cls, alloc];
+        let obj: *mut Object = msg_send![
+            obj,
+            initWithBytes:bytes
+            length:string.len()
+            encoding:UTF8_ENCODING
+        ];
+        let _: *mut c_void = msg_send![obj, autorelease];
+        obj
     }
+}
 
-    fn nsstr_to_str<'a>(nsstr: *mut Object) -> Cow<'a, str> {
-        let data = unsafe { CStr::from_ptr(nsstr.UTF8String()) };
-        data.to_string_lossy()
+fn nsstr_to_str<'a>(nsstr: *mut Object) -> Cow<'a, str> {
+    let data = unsafe { CStr::from_ptr(nsstr.UTF8String()) };
+    data.to_string_lossy()
+}
+
+fn vec_to_ns_arr<T: Into<*mut Object>>(data: Vec<T>) -> *mut Object {
+    let ns_mut_array_cls = class!(NSMutableArray);
+    let ns_array_cls = class!(NSArray);
+    let mutable_array: *mut Object = unsafe { msg_send![ns_mut_array_cls, array] };
+    data.into_iter().for_each(|item| {
+        let item_obj: *mut Object = item.into();
+        let _: *mut c_void = unsafe { msg_send![mutable_array, addObject: item_obj] };
+    });
+    let immutable_array: *mut Object =
+        unsafe { msg_send![ns_array_cls, arrayWithArray: mutable_array] };
+    let _: *mut c_void = unsafe { msg_send![mutable_array, autorelease] };
+    let _: *mut c_void = unsafe { msg_send![immutable_array, autorelease] };
+    immutable_array
+}
+
+fn ns_arr_to_vec<T: From<*mut Object>>(data: *mut Object) -> Vec<T> {
+    let length = unsafe { NSArray::count(data) };
+
+    let mut out_vec: Vec<T> = Vec::with_capacity(length as usize);
+    for index in 0..length {
+        let item = unsafe { NSArray::objectAtIndex(data, index) };
+        out_vec.push(T::from(item));
     }
+    let _: *mut c_void = unsafe { msg_send![data, autorelease] };
+    out_vec
+}
 
-    fn vec_to_ns_arr<T: Into<*mut Object>>(data: Vec<T>) -> *mut Object {
-        let ns_mut_array_cls = class!(NSMutableArray);
-        let ns_array_cls = class!(NSArray);
-        let mutable_array: *mut Object = unsafe { msg_send![ns_mut_array_cls, array] };
-        data.into_iter().for_each(|item| {
-            let item_obj: *mut Object = item.into();
-            let _: *mut c_void = unsafe { msg_send![mutable_array, addObject: item_obj] };
-        });
-        let immutable_array: *mut Object =
-            unsafe { msg_send![ns_array_cls, arrayWithArray: mutable_array] };
-        let _: *mut std::ffi::c_void = unsafe { msg_send![mutable_array, autorelease] };
-        let _: *mut std::ffi::c_void = unsafe { msg_send![immutable_array, autorelease] };
-        immutable_array
+fn try_ns_arr_to_vec<T, TE>(data: *mut Object) -> Result<Vec<T>, TE>
+where
+    TE: Error,
+    T: TryFrom<*mut Object, Error = TE>,
+{
+    let length = unsafe { NSArray::count(data) };
+
+    let mut out_vec: Vec<T> = Vec::with_capacity(length as usize);
+    for index in 0..length {
+        let item = unsafe { NSArray::objectAtIndex(data, index) };
+        out_vec.push(T::try_from(item)?);
     }
+    let _: *mut c_void = unsafe { msg_send![data, autorelease] };
+    Ok(out_vec)
+}
 
-    fn ns_arr_to_vec<T: From<*mut Object>>(data: *mut Object) -> Vec<T> {
-        let length = unsafe { NSArray::count(data) };
-
-        let mut out_vec: Vec<T> = Vec::with_capacity(length as usize);
-        for index in 0..length {
-            let item = unsafe { NSArray::objectAtIndex(data, index) };
-            out_vec.push(T::from(item));
-        }
-        let _: *mut std::ffi::c_void = unsafe { msg_send![data, autorelease] };
-        out_vec
+fn compare_ns_string(this: *mut Object, other: core_media::NSString) -> bool {
+    unsafe {
+        let equal: BOOL = msg_send![this, isEqualToString: other];
+        equal == YES
     }
+}
 
-    fn try_ns_arr_to_vec<T, TE>(data: *mut Object) -> Result<Vec<T>, TE>
-    where
-        TE: Error,
-        T: TryFrom<*mut Object, Error = TE>,
+pub type CompressionData<'a> = (Cow<'a, [u8]>, FrameFormat);
+pub type DataPipe<'a> = (Sender<CompressionData<'a>>, Receiver<CompressionData<'a>>);
+
+static CALLBACK_CLASS: Lazy<&'static Class> = Lazy::new(|| {
     {
-        let length = unsafe { NSArray::count(data) };
+        let mut decl = ClassDecl::new("MyCaptureCallback", class!(NSObject)).unwrap();
 
-        let mut out_vec: Vec<T> = Vec::with_capacity(length as usize);
-        for index in 0..length {
-            let item = unsafe { NSArray::objectAtIndex(data, index) };
-            out_vec.push(T::try_from(item)?);
+        // frame stack
+        // oooh scary provenannce-breaking BULLSHIT AAAAAA I LOVE TYPE ERASURE
+        decl.add_ivar::<*const c_void>("_arcmutptr"); // ArkMutex, the not-arknights totally not gacha totally not ripoff new vidya game from l-pleasestop-npengtul
+
+        extern "C" fn my_callback_get_arcmutptr(this: &Object, _: Sel) -> *const c_void {
+            unsafe { *this.get_ivar("_arcmutptr") }
         }
-        let _: *mut std::ffi::c_void = unsafe { msg_send![data, autorelease] };
-        Ok(out_vec)
-    }
-
-    fn compare_ns_string(this: *mut Object, other: crate::core_media::NSString) -> bool {
-        unsafe {
-            let equal: BOOL = msg_send![this, isEqualToString: other];
-            equal == YES
-        }
-    }
-
-    fn default_callback(_: bool) {}
-
-    pub type CompressionData<'a> = (Cow<'a, [u8]>, AVFourCC);
-    pub type DataPipe<'a> = (Sender<CompressionData<'a>>, Receiver<CompressionData<'a>>);
-
-    lazy_static! {
-        static ref CAMERA_AUTHORIZED: Arc<AtomicBool> = Arc::new(AtomicBool::new(false));
-        static ref USER_CALLBACK_FN: Arc<Mutex<fn(bool)>> = Arc::new(Mutex::new(default_callback));
-        static ref PIPE_MAP: Arc<DashMap<usize, DataPipe<'static>>> = Arc::new(DashMap::new());
-        static ref CALLBACK_CLASS: &'static Class = {
-            let mut decl = ClassDecl::new("MyCaptureCallback", class!(NSObject)).unwrap();
-
-            // frame stack
-            decl.add_ivar::<usize>("_index");
-
-            extern "C" fn my_callback_get_index(this: &Object, _: Sel) -> usize {
-                unsafe {
-                    *this.get_ivar("_index")
-                }
-            }
-
-            extern "C" fn my_callback_set_index(this: &mut Object, _: Sel, new_index: usize) {
-                unsafe {
-                    this.set_ivar("_index", new_index);
-                }
-            }
-
-            // Delegate compliance method
-            // SAFETY: This assumes that the buffer byte size is a u8. Any other size will cause unsafety.
-            #[allow(non_snake_case)]
-            #[allow(non_upper_case_globals)]
-            extern fn capture_out_callback(this: &mut Object, _: Sel, _: *mut Object, didOutputSampleBuffer: CMSampleBufferRef, _: *mut Object) {
-                let image_buffer: CVImageBufferRef = unsafe { CMSampleBufferGetImageBuffer(didOutputSampleBuffer) };
-                unsafe { CVPixelBufferLockBaseAddress(image_buffer, 0); };
-
-                let buffer_codec = unsafe { CVPixelBufferGetPixelFormatType(image_buffer) };
-
-                let fourcc = match buffer_codec {
-                    kCMVideoCodecType_422YpCbCr8 | kCMPixelFormat_422YpCbCr8_yuvs => AVFourCC::YUV2,
-                    kCMVideoCodecType_JPEG | kCMVideoCodecType_JPEG_OpenDML => AVFourCC::MJPEG,
-                    _ => {
-                        return;
-                    }
-                };
-
-                let buffer_length = unsafe { CVPixelBufferGetDataSize(image_buffer) };
-                let buffer_ptr = unsafe { CVPixelBufferGetBaseAddress(image_buffer) };
-                let buffer_as_vec = unsafe { std::slice::from_raw_parts_mut(buffer_ptr as *mut u8, buffer_length as usize).to_vec() };
-
-                unsafe { CVPixelBufferUnlockBaseAddress(image_buffer, 0) };
-                let index: usize = unsafe { msg_send![this, index] };
-                let pipes = &PIPE_MAP.get(&index);
-                if let Some(pipe) = pipes {
-                    let _ = pipe.value().0.send((Cow::from(buffer_as_vec), fourcc));
-                }
-            }
-
-            #[allow(non_snake_case)]
-            extern fn capture_drop_callback(_: &mut Object, _: Sel, _: *mut Object, _: *mut Object, _: *mut Object) {
-            }
-
+        extern "C" fn my_callback_set_arcmutptr(
+            this: &mut Object,
+            _: Sel,
+            new_arcmutptr: *const c_void,
+        ) {
             unsafe {
-                decl.add_method(
-                    sel!(index), my_callback_get_index as extern "C" fn(&Object, Sel) -> usize
-                );
-                decl.add_method(
-                    sel!(setIndex:), my_callback_set_index as extern "C" fn(&mut Object, Sel, usize)
-                );
-                decl.add_method(
-                    sel!(captureOutput:didOutputSampleBuffer:fromConnection:), capture_out_callback as extern "C" fn(&mut Object, Sel, *mut Object, CMSampleBufferRef, *mut Object)
-                );
-                decl.add_method(
-                    sel!(captureOutput:didDropSampleBuffer:fromConnection:), capture_drop_callback as extern "C" fn(&mut Object, Sel, *mut Object, *mut Object, *mut Object)
-                );
-
-                decl.add_protocol(Protocol::get("AVCaptureVideoDataOutputSampleBufferDelegate").unwrap());
-            }
-
-            decl.register()
-        };
-    }
-
-    fn objc_authorization_event_callback_fn(result: BOOL) {
-        let result = if result == YES {
-            CAMERA_AUTHORIZED.store(true, MemOrdering::SeqCst);
-            true
-        } else {
-            CAMERA_AUTHORIZED.store(false, MemOrdering::SeqCst);
-            false
-        };
-
-        loop {
-            match USER_CALLBACK_FN.try_lock() {
-                Ok(callback) => {
-                    callback(result);
-                    break;
-                }
-                Err(why) => match why {
-                    TryLockError::Poisoned(_) => {
-                        break;
-                    }
-                    TryLockError::WouldBlock => {
-                        continue;
-                    }
-                },
-            }
-        }
-    }
-
-    pub fn request_permission_with_callback(callback: fn(bool)) {
-        let cls = class!(AVCaptureDevice);
-        loop {
-            match USER_CALLBACK_FN.try_lock() {
-                Ok(mut cb) => {
-                    *cb = callback;
-                    break;
-                }
-                Err(why) => match why {
-                    TryLockError::Poisoned(_) => {
-                        break;
-                    }
-                    TryLockError::WouldBlock => {
-                        continue;
-                    }
-                },
+                this.set_ivar("_arcmutptr", new_arcmutptr);
             }
         }
 
-        let objc_fn_block: ConcreteBlock<(BOOL,), (), fn(BOOL)> =
-            ConcreteBlock::new(objc_authorization_event_callback_fn);
-        let objc_fn_pass = objc_fn_block.copy();
-
-        unsafe {
-            let _: () = msg_send![cls, requestAccessForMediaType:(AVMediaTypeVideo.clone()) completionHandler:objc_fn_pass];
-        }
-    }
-
-    pub fn current_authorization_status() -> AVAuthorizationStatus {
-        let cls = class!(AVCaptureDevice);
-        let status: AVAuthorizationStatus = unsafe {
-            msg_send![cls, authorizationStatusForMediaType:AVMediaType::Video.into_ns_str()]
-        };
-        match status {
-            AVAuthorizationStatus::Authorized => CAMERA_AUTHORIZED.store(true, MemOrdering::SeqCst),
-            _ => CAMERA_AUTHORIZED.store(false, MemOrdering::SeqCst),
-        }
-        status
-    }
-
-    // fuck it, use deprecated APIs
-    pub fn query_avfoundation() -> Result<Vec<AVCaptureDeviceDescriptor>, AVFError> {
-        Ok(AVCaptureDevice::devices_with_type(AVMediaType::Video)
-            .into_iter()
-            .enumerate()
-            .map(|(idx, dev)| AVCaptureDeviceDescriptor::from_capture_device(dev, idx))
-            .collect::<Vec<AVCaptureDeviceDescriptor>>())
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    pub enum AVCaptureDeviceType {
-        Dual,
-        DualWide,
-        Triple,
-        WideAngle,
-        UltraWide,
-        Telephoto,
-        TrueDepth,
-        ExternalUnknown,
-    }
-
-    impl From<AVCaptureDeviceType> for *mut Object {
-        fn from(device_type: AVCaptureDeviceType) -> Self {
-            match device_type {
-                AVCaptureDeviceType::Dual => str_to_nsstr("AVCaptureDeviceTypeBuiltInDualCamera"),
-                AVCaptureDeviceType::DualWide => {
-                    str_to_nsstr("AVCaptureDeviceTypeBuiltInDualWideCamera")
-                }
-                AVCaptureDeviceType::Triple => {
-                    str_to_nsstr("AVCaptureDeviceTypeBuiltInTripleCamera")
-                }
-                AVCaptureDeviceType::WideAngle => {
-                    str_to_nsstr("AVCaptureDeviceTypeBuiltInWideAngleCamera")
-                }
-                AVCaptureDeviceType::UltraWide => {
-                    str_to_nsstr("AVCaptureDeviceTypeBuiltInUltraWideCamera")
-                }
-                AVCaptureDeviceType::Telephoto => {
-                    str_to_nsstr("AVCaptureDeviceTypeBuiltInTelephotoCamera")
-                }
-                AVCaptureDeviceType::TrueDepth => {
-                    str_to_nsstr("AVCaptureDeviceTypeBuiltInTrueDepthCamera")
-                }
-                AVCaptureDeviceType::ExternalUnknown => {
-                    str_to_nsstr("AVCaptureDeviceTypeBuiltInExternalUnknown")
-                }
-            }
-        }
-    }
-
-    impl AVCaptureDeviceType {
-        pub fn into_ns_str(self) -> *mut Object {
-            <*mut Object>::from(self)
-        }
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    pub enum AVMediaType {
-        Audio,
-        ClosedCaption,
-        DepthData,
-        Metadata,
-        MetadataObject,
-        Muxed,
-        Subtitle,
-        Text,
-        Timecode,
-        Video,
-    }
-
-    impl From<AVMediaType> for *mut Object {
-        fn from(media_type: AVMediaType) -> Self {
-            match media_type {
-                AVMediaType::Audio => unsafe { AVMediaTypeAudio.0 },
-                AVMediaType::ClosedCaption => unsafe { AVMediaTypeClosedCaption.0 },
-                AVMediaType::DepthData => unsafe { AVMediaTypeDepthData.0 },
-                AVMediaType::Metadata => unsafe { AVMediaTypeMetadata.0 },
-                AVMediaType::MetadataObject => unsafe { AVMediaTypeMetadataObject.0 },
-                AVMediaType::Muxed => unsafe { AVMediaTypeMuxed.0 },
-                AVMediaType::Subtitle => unsafe { AVMediaTypeSubtitle.0 },
-                AVMediaType::Text => unsafe { AVMediaTypeText.0 },
-                AVMediaType::Timecode => unsafe { AVMediaTypeTimecode.0 },
-                AVMediaType::Video => unsafe { AVMediaTypeVideo.0 },
-            }
-        }
-    }
-
-    impl TryFrom<*mut Object> for AVMediaType {
-        type Error = AVFError;
-
-        fn try_from(value: *mut Object) -> Result<Self, Self::Error> {
+        // Delegate compliance method
+        // SAFETY: This assumes that the buffer byte size is a u8. Any other size will cause unsafety.
+        #[allow(non_snake_case)]
+        #[allow(non_upper_case_globals)]
+        extern "C" fn capture_out_callback(
+            this: &mut Object,
+            _: Sel,
+            _: *mut Object,
+            didOutputSampleBuffer: CMSampleBufferRef,
+            _: *mut Object,
+        ) {
+            let image_buffer: CVImageBufferRef =
+                unsafe { CMSampleBufferGetImageBuffer(didOutputSampleBuffer) };
             unsafe {
-                if compare_ns_string(value, (AVMediaTypeAudio).clone()) {
-                    Ok(AVMediaType::Audio)
-                } else if compare_ns_string(value, (AVMediaTypeClosedCaption).clone()) {
-                    Ok(AVMediaType::ClosedCaption)
-                } else if compare_ns_string(value, (AVMediaTypeDepthData).clone()) {
-                    Ok(AVMediaType::DepthData)
-                } else if compare_ns_string(value, (AVMediaTypeMetadata).clone()) {
-                    Ok(AVMediaType::Metadata)
-                } else if compare_ns_string(value, (AVMediaTypeMetadataObject).clone()) {
-                    Ok(AVMediaType::MetadataObject)
-                } else if compare_ns_string(value, (AVMediaTypeMuxed).clone()) {
-                    Ok(AVMediaType::Muxed)
-                } else if compare_ns_string(value, (AVMediaTypeSubtitle).clone()) {
-                    Ok(AVMediaType::Subtitle)
-                } else if compare_ns_string(value, (AVMediaTypeText).clone()) {
-                    Ok(AVMediaType::Text)
-                } else if compare_ns_string(value, (AVMediaTypeTimecode).clone()) {
-                    Ok(AVMediaType::Timecode)
-                } else if compare_ns_string(value, (AVMediaTypeVideo).clone()) {
-                    Ok(AVMediaType::Video)
-                } else {
-                    let name = nsstr_to_str(value);
-                    Err(AVFError::InvalidValue {
-                        found: name.to_string(),
-                    })
-                }
-            }
-        }
-    }
-
-    impl AVMediaType {
-        pub fn into_ns_str(self) -> *mut Object {
-            <*mut Object>::from(self)
-        }
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    #[repr(isize)]
-    pub enum AVCaptureDevicePosition {
-        Unspecified = 0,
-        Back = 1,
-        Front = 2,
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    #[repr(isize)]
-    pub enum AVAuthorizationStatus {
-        NotDetermined = 0,
-        Restricted = 1,
-        Denied = 2,
-        Authorized = 3,
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    #[repr(u32)]
-    pub enum AVFourCC {
-        YUV2,
-        MJPEG,
-    }
-
-    // Localized Name
-    //
-    #[derive(Clone, Debug, Default, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    pub struct AVCaptureDeviceDescriptor {
-        pub name: String,
-        pub description: String,
-        pub misc: String,
-        pub index: u64,
-    }
-
-    impl AVCaptureDeviceDescriptor {
-        pub fn from_capture_device(
-            device: AVCaptureDevice,
-            index: usize,
-        ) -> AVCaptureDeviceDescriptor {
-            let device = device.inner();
-            let name = nsstr_to_str(unsafe { msg_send![device, localizedName] }).to_string();
-            let manufacturer = nsstr_to_str(unsafe { msg_send![device, manufacturer] });
-            let position: AVCaptureDevicePosition = unsafe { msg_send![device, position] };
-            let lens_aperture: f64 = unsafe { msg_send![device, lensAperture] };
-            let device_type = nsstr_to_str(unsafe { msg_send![device, deviceType] });
-            let model_id = nsstr_to_str(unsafe { msg_send![device, modelID] });
-            let description = format!(
-                "{}: {} - {}, {:?} f{}",
-                manufacturer, model_id, device_type, position, lens_aperture
-            );
-            let misc = nsstr_to_str(unsafe { msg_send![device, uniqueID] }).to_string();
-            AVCaptureDeviceDescriptor {
-                name,
-                description,
-                misc,
-                index: index as u64,
-            }
-        }
-    }
-
-    pub struct AVCaptureVideoCallback {
-        index: usize,
-        delegate: *mut Object,
-    }
-
-    impl AVCaptureVideoCallback {
-        pub fn new(index: usize) -> Self {
-            let cls = &CALLBACK_CLASS as &Class;
-            let delegate: *mut Object = unsafe { msg_send![cls, alloc] };
-            let delegate: *mut Object = unsafe { msg_send![delegate, init] };
-
-            let data_pipe: DataPipe = flume::unbounded();
-            let _ = &PIPE_MAP.insert(index, data_pipe);
-
-            AVCaptureVideoCallback { index, delegate }
-        }
-
-        pub fn index(&self) -> usize {
-            self.index
-        }
-
-        pub fn data_len(&self) -> usize {
-            unsafe { msg_send![self.delegate, dataLength] }
-        }
-
-        pub fn frame_to_slice<'a>(&self) -> Result<CompressionData<'a>, AVFError> {
-            let pipe_map = &PIPE_MAP.get(&self.index); // why rust
-            let pipe_recv = match pipe_map {
-                Some(pipe) => &pipe.value().1,
-                None => return Err(AVFError::ReadFrame("Data Pipe None".to_string())),
+                CVPixelBufferLockBaseAddress(image_buffer, 0);
             };
-            let data = match pipe_recv.drain().last() {
-                Some(frame) => frame,
-                None => match pipe_recv.recv() {
-                    Ok(f) => f,
-                    Err(why) => {
-                        return Err(AVFError::ReadFrame(format!(
-                            "Failed to read frame from pipe: {}",
-                            why.to_string()
-                        )))
-                    }
-                },
-            };
-            Ok(data)
-        }
 
-        pub fn frame_to_slice_no_block<'a>(&self) -> Result<CompressionData<'a>, AVFError> {
-            let pipe_map = &PIPE_MAP.get(&self.index); // why rust
-            let pipe_recv = match pipe_map {
-                Some(pipe) => &pipe.value().1,
-                None => return Err(AVFError::ReadFrame("Data Pipe None".to_string())),
-            };
-            let data = match pipe_recv.drain().last() {
-                Some(frame) => frame,
-                None => {
-                    return Err(AVFError::ReadFrame(
-                        "Failed to read frame from pipe: None".to_string(),
-                    ))
-                }
-            };
-            Ok(data)
-        }
+            let buffer_codec = unsafe { CVPixelBufferGetPixelFormatType(image_buffer) };
 
-        pub fn inner(&self) -> *mut Object {
-            self.delegate
-        }
-    }
-
-    impl Drop for AVCaptureVideoCallback {
-        fn drop(&mut self) {
-            unsafe {
-                let _: () = msg_send![self.delegate, autorelease];
-            }
-        }
-    }
-
-    create_boilerplate_impl! {
-        [pub AVFrameRateRange],
-        [pub AVCaptureDeviceDiscoverySession],
-        [pub AVCaptureDevice],
-        [pub AVCaptureDeviceInput],
-        [pub AVCaptureSession]
-    }
-
-    impl AVFrameRateRange {
-        pub fn max(&self) -> f64 {
-            unsafe { msg_send![self.inner, maxFrameRate] }
-        }
-
-        pub fn min(&self) -> f64 {
-            unsafe { msg_send![self.inner, minFrameRate] }
-        }
-    }
-
-    pub type AVVideoResolution = CMVideoDimensions;
-
-    #[derive(Copy, Clone, Debug)]
-    pub struct CaptureDeviceFormatDescriptor {
-        pub resolution: AVVideoResolution,
-        pub fps: u32,
-        pub fourcc: AVFourCC,
-    }
-
-    impl CaptureDeviceFormatDescriptor {
-        pub fn compatible_with_capture_format(&self, other: &AVCaptureDeviceFormat) -> bool {
-            for fps in &other.fps_list {
-                if self.resolution.height == other.resolution.height
-                    && self.resolution.width == other.resolution.width
-                    && self.fourcc == other.fourcc
-                    && (*fps as u32) == self.fps
-                {
-                    return true;
-                }
-            }
-            false
-        }
-    }
-
-    #[derive(Debug)]
-    pub struct AVCaptureDeviceFormat {
-        internal: *mut Object,
-        pub resolution: CMVideoDimensions,
-        pub fps_list: Vec<f64>,
-        pub fourcc: AVFourCC,
-    }
-
-    impl TryFrom<*mut Object> for AVCaptureDeviceFormat {
-        type Error = AVFError;
-
-        fn try_from(value: *mut Object) -> Result<Self, Self::Error> {
-            let media_type_raw: *mut Object = unsafe { msg_send![value, mediaType] };
-            let media_type = AVMediaType::try_from(media_type_raw)?;
-            if media_type != AVMediaType::Video {
-                return Err(AVFError::InvalidType {
-                    expected: "AVMediaTypeVideo".to_string(),
-                    found: format!("{:?}", media_type),
-                });
-            }
-            let mut fps_list = ns_arr_to_vec::<AVFrameRateRange>(unsafe {
-                msg_send![value, videoSupportedFrameRateRanges]
-            })
-            .into_iter()
-            .map(|v| [v.min(), v.max()])
-            .flatten()
-            .collect::<Vec<f64>>();
-            fps_list.sort_by(|n, m| n.partial_cmp(m).unwrap_or(Ordering::Equal));
-            fps_list.dedup();
-            let description_obj: *mut Object = unsafe { msg_send![value, formatDescription] };
-            let resolution =
-                unsafe { CMVideoFormatDescriptionGetDimensions(description_obj as *mut c_void) };
-            let fcc_raw =
-                unsafe { CMFormatDescriptionGetMediaSubType(description_obj as *mut c_void) };
-            #[allow(non_upper_case_globals)]
-            let fourcc = match fcc_raw {
-                kCMVideoCodecType_422YpCbCr8 | kCMPixelFormat_422YpCbCr8_yuvs => AVFourCC::YUV2,
-                kCMVideoCodecType_JPEG | kCMVideoCodecType_JPEG_OpenDML => AVFourCC::MJPEG,
+            let fourcc = match buffer_codec {
+                kCMVideoCodecType_422YpCbCr8 | kCMPixelFormat_422YpCbCr8_yuvs => FrameFormat::YUYV,
+                kCMVideoCodecType_JPEG | kCMVideoCodecType_JPEG_OpenDML => FrameFormat::MJPEG,
+                kCMPixelFormat_8IndexedGray_WhiteIsZero => FrameFormat::GRAY,
                 _ => {
-                    return Err(AVFError::InvalidValue {
-                        found: fcc_raw.to_string(),
-                    })
+                    return;
                 }
             };
-            let _: *mut std::ffi::c_void = unsafe { msg_send![description_obj, autorelease] };
-            Ok(AVCaptureDeviceFormat {
-                internal: value,
-                resolution,
-                fps_list,
-                fourcc,
-            })
-        }
-    }
 
-    impl Drop for AVCaptureDeviceFormat {
-        fn drop(&mut self) {
-            unsafe { msg_send![self.internal, autorelease] }
-        }
-    }
-
-    impl AVCaptureDeviceDiscoverySession {
-        pub fn new(
-            device_types: Vec<AVCaptureDeviceType>,
-            media_type: AVMediaType,
-            position: AVCaptureDevicePosition,
-        ) -> Result<Self, AVFError> {
-            let device_types = vec_to_ns_arr(device_types);
-            let media_type: *mut Object = media_type.into();
-            let position = position as NSInteger;
-
-            let discovery_session_cls = class!(AVCaptureDeviceDiscoverySession);
-            let discovery_session: *mut Object = unsafe {
-                msg_send![discovery_session_cls, discoverySessionWithDeviceTypes:device_types mediaType:media_type position:position]
+            let buffer_length = unsafe { CVPixelBufferGetDataSize(image_buffer) };
+            let buffer_ptr = unsafe { CVPixelBufferGetBaseAddress(image_buffer) };
+            let buffer_as_vec = unsafe {
+                std::slice::from_raw_parts_mut(buffer_ptr as *mut u8, buffer_length as usize)
+                    .to_vec()
             };
-            Ok(AVCaptureDeviceDiscoverySession {
-                inner: discovery_session,
-            })
+
+            unsafe { CVPixelBufferUnlockBaseAddress(image_buffer, 0) };
+            // oooooh scarey unsafe
+            // AAAAAAAAAAAAAAAAAAAAAAAAA
+            // https://c.tenor.com/0e_zWtFLOzQAAAAC/needy-streamer-overload-needy-girl-overdose.gif
+            let bufferlck_cv: *mut c_void = unsafe { msg_send![this, bufferPtr] };
+            let buffer_mutex = unsafe {
+                std::mem::transmute::<*const c_void, Arc<Mutex<(Vec<u8>, FrameFormat)>>>(
+                    bufferlck_cv,
+                )
+            };
+            let lock = buffer_mutex.lock();
+            if let Ok(mut buffer) = lock {
+                *buffer = (buffer_as_vec, fourcc);
+            }
         }
 
-        pub fn default() -> Result<Self, AVFError> {
-            AVCaptureDeviceDiscoverySession::new(
-                vec![
-                    AVCaptureDeviceType::UltraWide,
-                    AVCaptureDeviceType::Telephoto,
-                    AVCaptureDeviceType::ExternalUnknown,
-                    AVCaptureDeviceType::Dual,
-                    AVCaptureDeviceType::DualWide,
-                    AVCaptureDeviceType::Triple,
-                ],
-                AVMediaType::Video,
-                AVCaptureDevicePosition::Unspecified,
-            )
+        #[allow(non_snake_case)]
+        extern "C" fn capture_drop_callback(
+            _: &mut Object,
+            _: Sel,
+            _: *mut Object,
+            _: *mut Object,
+            _: *mut Object,
+        ) {
         }
 
-        pub fn devices(&self) -> Vec<AVCaptureDeviceDescriptor> {
-            let device_ns_array: *mut Object = unsafe { msg_send![self.inner, devices] };
-            let objects_len: NSUInteger = unsafe { NSArray::count(device_ns_array) };
-            let mut devices = vec![AVCaptureDeviceDescriptor::default(); objects_len as usize];
-            for index in 0..objects_len {
-                let device = unsafe { device_ns_array.objectAtIndex(index) };
-                let name = nsstr_to_str(unsafe { msg_send![device, localizedName] }).to_string();
-                let manufacturer = nsstr_to_str(unsafe { msg_send![device, manufacturer] });
-                let position: AVCaptureDevicePosition = unsafe { msg_send![device, position] };
-                let lens_aperture: f64 = unsafe { msg_send![device, lensAperture] };
-                let device_type = nsstr_to_str(unsafe { msg_send![device, deviceType] });
-                let model_id = nsstr_to_str(unsafe { msg_send![device, modelID] });
-                let description = format!(
-                    "{}: {} - {}, {:?} f{}",
-                    manufacturer, model_id, device_type, position, lens_aperture
-                );
-                let misc = nsstr_to_str(unsafe { msg_send![device, uniqueID] }).to_string();
+        unsafe {
+            decl.add_method(
+                sel!(bufferPtr),
+                my_callback_get_arcmutptr as extern "C" fn(&Object, Sel) -> *const c_void,
+            );
+            decl.add_method(
+                sel!(SetBufferPtr:),
+                my_callback_set_arcmutptr as extern "C" fn(&mut Object, Sel, *const c_void),
+            );
+            decl.add_method(
+                sel!(captureOutput:didOutputSampleBuffer:fromConnection:),
+                capture_out_callback
+                    as extern "C" fn(&mut Object, Sel, *mut Object, CMSampleBufferRef, *mut Object),
+            );
+            decl.add_method(
+                sel!(captureOutput:didDropSampleBuffer:fromConnection:),
+                capture_drop_callback
+                    as extern "C" fn(&mut Object, Sel, *mut Object, *mut Object, *mut Object),
+            );
 
-                devices.push(AVCaptureDeviceDescriptor {
-                    name,
-                    description,
-                    misc,
-                    index,
+            decl.add_protocol(
+                Protocol::get("AVCaptureVideoDataOutputSampleBufferDelegate").unwrap(),
+            );
+        }
+
+        decl.register()
+    }
+});
+
+pub fn request_permission_with_callback(callback: Box<dyn Fn(bool) + Send + Sync + 'static>) {
+    let cls = class!(AVCaptureDevice);
+    let objc_fn_block = ConcreteBlock::new(callback);
+    let objc_fn_pass = objc_fn_block.copy();
+
+    unsafe {
+        let _: () = msg_send![cls, requestAccessForMediaType:(AVMediaTypeVideo.clone()) completionHandler:objc_fn_pass];
+    }
+}
+
+pub fn current_authorization_status() -> AVAuthorizationStatus {
+    let cls = class!(AVCaptureDevice);
+    let status: AVAuthorizationStatus =
+        unsafe { msg_send![cls, authorizationStatusForMediaType:AVMediaType::Video.into_ns_str()] };
+    status
+}
+
+// fuck it, use deprecated APIs
+pub fn query_avfoundation() -> Result<Vec<CameraInfo>, NokhwaError> {
+    let front = AVCaptureDeviceDiscoverySession::new(
+        vec![
+            AVCaptureDeviceType::UltraWide,
+            AVCaptureDeviceType::WideAngle,
+            AVCaptureDeviceType::Telephoto,
+            AVCaptureDeviceType::TrueDepth,
+            AVCaptureDeviceType::ExternalUnknown,
+        ],
+        AVMediaType::Video,
+        AVCaptureDevicePosition::Front,
+    )?
+    .devices();
+    let back = AVCaptureDeviceDiscoverySession::new(
+        vec![
+            AVCaptureDeviceType::UltraWide,
+            AVCaptureDeviceType::WideAngle,
+            AVCaptureDeviceType::Telephoto,
+            AVCaptureDeviceType::TrueDepth,
+            AVCaptureDeviceType::ExternalUnknown,
+        ],
+        AVMediaType::Video,
+        AVCaptureDevicePosition::Back,
+    )?
+    .devices();
+    let unspecified = AVCaptureDeviceDiscoverySession::new(
+        vec![
+            AVCaptureDeviceType::UltraWide,
+            AVCaptureDeviceType::WideAngle,
+            AVCaptureDeviceType::Telephoto,
+            AVCaptureDeviceType::TrueDepth,
+            AVCaptureDeviceType::ExternalUnknown,
+        ],
+        AVMediaType::Video,
+        AVCaptureDevicePosition::Unspecified,
+    )?
+    .devices();
+
+    let mut device_set = HashSet::with_capacity(front.len() + back.len() + unspecified.len());
+    device_set.extend(front);
+    device_set.extend(back);
+    device_set.extend(unspecified);
+
+    Ok(device_set.into_iter().collect())
+}
+
+pub fn get_raw_device_info(index: CameraIndex, device: *mut Object) -> CameraInfo {
+    let name = nsstr_to_str(unsafe { msg_send![device, localizedName] });
+    let manufacturer = nsstr_to_str(unsafe { msg_send![device, manufacturer] });
+    let position: AVCaptureDevicePosition = unsafe { msg_send![device, position] };
+    let lens_aperture: f64 = unsafe { msg_send![device, lensAperture] };
+    let device_type = nsstr_to_str(unsafe { msg_send![device, deviceType] });
+    let model_id = nsstr_to_str(unsafe { msg_send![device, modelID] });
+    let description = format!(
+        "{}: {} - {}, {:?} f{}",
+        manufacturer, model_id, device_type, position, lens_aperture
+    );
+    let misc = nsstr_to_str(unsafe { msg_send![device, uniqueID] });
+
+    CameraInfo::new(name.as_ref(), &description, misc.as_ref(), index)
+}
+
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub enum AVCaptureDeviceType {
+    Dual,
+    DualWide,
+    Triple,
+    WideAngle,
+    UltraWide,
+    Telephoto,
+    TrueDepth,
+    ExternalUnknown,
+}
+
+impl From<AVCaptureDeviceType> for *mut Object {
+    fn from(device_type: AVCaptureDeviceType) -> Self {
+        match device_type {
+            AVCaptureDeviceType::Dual => str_to_nsstr("AVCaptureDeviceTypeBuiltInDualCamera"),
+            AVCaptureDeviceType::DualWide => {
+                str_to_nsstr("AVCaptureDeviceTypeBuiltInDualWideCamera")
+            }
+            AVCaptureDeviceType::Triple => str_to_nsstr("AVCaptureDeviceTypeBuiltInTripleCamera"),
+            AVCaptureDeviceType::WideAngle => {
+                str_to_nsstr("AVCaptureDeviceTypeBuiltInWideAngleCamera")
+            }
+            AVCaptureDeviceType::UltraWide => {
+                str_to_nsstr("AVCaptureDeviceTypeBuiltInUltraWideCamera")
+            }
+            AVCaptureDeviceType::Telephoto => {
+                str_to_nsstr("AVCaptureDeviceTypeBuiltInTelephotoCamera")
+            }
+            AVCaptureDeviceType::TrueDepth => {
+                str_to_nsstr("AVCaptureDeviceTypeBuiltInTrueDepthCamera")
+            }
+            AVCaptureDeviceType::ExternalUnknown => {
+                str_to_nsstr("AVCaptureDeviceTypeBuiltInExternalUnknown")
+            }
+        }
+    }
+}
+
+impl AVCaptureDeviceType {
+    pub fn into_ns_str(self) -> *mut Object {
+        <*mut Object>::from(self)
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub enum AVMediaType {
+    Audio,
+    ClosedCaption,
+    DepthData,
+    Metadata,
+    MetadataObject,
+    Muxed,
+    Subtitle,
+    Text,
+    Timecode,
+    Video,
+}
+
+impl From<AVMediaType> for *mut Object {
+    fn from(media_type: AVMediaType) -> Self {
+        match media_type {
+            AVMediaType::Audio => unsafe { AVMediaTypeAudio.0 },
+            AVMediaType::ClosedCaption => unsafe { AVMediaTypeClosedCaption.0 },
+            AVMediaType::DepthData => unsafe { AVMediaTypeDepthData.0 },
+            AVMediaType::Metadata => unsafe { AVMediaTypeMetadata.0 },
+            AVMediaType::MetadataObject => unsafe { AVMediaTypeMetadataObject.0 },
+            AVMediaType::Muxed => unsafe { AVMediaTypeMuxed.0 },
+            AVMediaType::Subtitle => unsafe { AVMediaTypeSubtitle.0 },
+            AVMediaType::Text => unsafe { AVMediaTypeText.0 },
+            AVMediaType::Timecode => unsafe { AVMediaTypeTimecode.0 },
+            AVMediaType::Video => unsafe { AVMediaTypeVideo.0 },
+        }
+    }
+}
+
+impl TryFrom<*mut Object> for AVMediaType {
+    type Error = NokhwaError;
+
+    fn try_from(value: *mut Object) -> Result<Self, Self::Error> {
+        unsafe {
+            if compare_ns_string(value, (AVMediaTypeAudio).clone()) {
+                Ok(AVMediaType::Audio)
+            } else if compare_ns_string(value, (AVMediaTypeClosedCaption).clone()) {
+                Ok(AVMediaType::ClosedCaption)
+            } else if compare_ns_string(value, (AVMediaTypeDepthData).clone()) {
+                Ok(AVMediaType::DepthData)
+            } else if compare_ns_string(value, (AVMediaTypeMetadata).clone()) {
+                Ok(AVMediaType::Metadata)
+            } else if compare_ns_string(value, (AVMediaTypeMetadataObject).clone()) {
+                Ok(AVMediaType::MetadataObject)
+            } else if compare_ns_string(value, (AVMediaTypeMuxed).clone()) {
+                Ok(AVMediaType::Muxed)
+            } else if compare_ns_string(value, (AVMediaTypeSubtitle).clone()) {
+                Ok(AVMediaType::Subtitle)
+            } else if compare_ns_string(value, (AVMediaTypeText).clone()) {
+                Ok(AVMediaType::Text)
+            } else if compare_ns_string(value, (AVMediaTypeTimecode).clone()) {
+                Ok(AVMediaType::Timecode)
+            } else if compare_ns_string(value, (AVMediaTypeVideo).clone()) {
+                Ok(AVMediaType::Video)
+            } else {
+                let name = nsstr_to_str(value);
+                Err(NokhwaError::GetPropertyError {
+                    property: "AVMediaType".to_string(),
+                    error: format!("Invalid AVMediaType {name}"),
                 })
             }
-            let _: *mut std::ffi::c_void = unsafe { msg_send![device_ns_array, release] };
-            devices
         }
     }
+}
 
-    impl Drop for AVCaptureDeviceDiscoverySession {
-        fn drop(&mut self) {
-            unsafe { msg_send![self.inner, autorelease] }
+impl AVMediaType {
+    pub fn into_ns_str(self) -> *mut Object {
+        <*mut Object>::from(self)
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[repr(isize)]
+pub enum AVCaptureDevicePosition {
+    Unspecified = 0,
+    Back = 1,
+    Front = 2,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[repr(isize)]
+pub enum AVAuthorizationStatus {
+    NotDetermined = 0,
+    Restricted = 1,
+    Denied = 2,
+    Authorized = 3,
+}
+
+pub struct AVCaptureVideoCallback {
+    delegate: *mut Object,
+    queue: NSObject,
+}
+
+impl AVCaptureVideoCallback {
+    pub fn new(
+        device_spec: &CStr,
+        buffer: Arc<Mutex<(Vec<u8>, FrameFormat)>>,
+    ) -> Result<Self, NokhwaError> {
+        let cls = &CALLBACK_CLASS as &Class;
+        let delegate: *mut Object = unsafe { msg_send![cls, alloc] };
+        let delegate: *mut Object = unsafe { msg_send![delegate, init] };
+        let buffer_as_ptr = unsafe {
+            std::mem::transmute::<*const Mutex<(Vec<u8>, FrameFormat)>, *const c_void>(
+                Arc::into_raw(buffer),
+            )
+        };
+        unsafe {
+            let _: () = msg_send![delegate, setBufferPtr: buffer_as_ptr];
         }
+
+        let queue =
+            unsafe { dispatch_queue_create(device_spec.as_ptr(), NSObject(std::ptr::null_mut())) };
+
+        Ok(AVCaptureVideoCallback { delegate, queue })
     }
 
-    impl AVCaptureDevice {
-        pub fn devices_with_type(_: AVMediaType) -> Vec<AVCaptureDevice> {
-            let cls = class!(AVCaptureDevice);
-            let video_type = unsafe { AVMediaTypeVideo.clone() };
-            let devices: *mut Object = unsafe { msg_send![cls, devicesWithMediaType: video_type] };
-            ns_arr_to_vec(devices)
-        }
+    pub fn data_len(&self) -> usize {
+        unsafe { msg_send![self.delegate, dataLength] }
+    }
 
-        pub fn new(index: usize) -> Result<Self, AVFError> {
-            let devices = AVCaptureDeviceDiscoverySession::new(
-                vec![
-                    AVCaptureDeviceType::UltraWide,
-                    AVCaptureDeviceType::Telephoto,
-                    AVCaptureDeviceType::ExternalUnknown,
-                ],
-                AVMediaType::Video,
-                AVCaptureDevicePosition::Unspecified,
-            )?
-            .devices();
-            match devices.get(index) {
-                Some(device) => Ok(AVCaptureDevice::from_id(&device.misc)?),
-                None => Err(AVFError::FailedToOpenDevice {
-                    index,
-                    why: "No device at index".to_string(),
-                }),
+    pub fn inner(&self) -> *mut Object {
+        self.delegate
+    }
+
+    pub fn queue(&self) -> &NSObject {
+        &self.queue
+    }
+}
+
+impl Drop for AVCaptureVideoCallback {
+    fn drop(&mut self) {
+        unsafe {
+            let fnptr: *mut c_void = msg_send![self.delegate, fnptr];
+            let _boxed = Box::from_raw(fnptr); // drop the value
+            let _: () = msg_send![self.delegate, autorelease];
+        }
+    }
+}
+
+create_boilerplate_impl! {
+    [pub AVFrameRateRange],
+    [pub AVCaptureDeviceDiscoverySession],
+    [pub AVCaptureDeviceInput],
+    [pub AVCaptureSession]
+}
+
+impl AVFrameRateRange {
+    pub fn max(&self) -> f64 {
+        unsafe { msg_send![self.inner, maxFrameRate] }
+    }
+
+    pub fn min(&self) -> f64 {
+        unsafe { msg_send![self.inner, minFrameRate] }
+    }
+}
+
+#[derive(Debug)]
+pub struct AVCaptureDeviceFormat {
+    pub(crate) internal: *mut Object,
+    pub resolution: CMVideoDimensions,
+    pub fps_list: Vec<f64>,
+    pub fourcc: FrameFormat,
+}
+
+impl TryFrom<*mut Object> for AVCaptureDeviceFormat {
+    type Error = NokhwaError;
+
+    fn try_from(value: *mut Object) -> Result<Self, Self::Error> {
+        let media_type_raw: *mut Object = unsafe { msg_send![value, mediaType] };
+        let media_type = AVMediaType::try_from(media_type_raw)?;
+        if media_type != AVMediaType::Video {
+            return Err(NokhwaError::StructureError {
+                structure: "AVMediaType".to_string(),
+                error: "Not Video".to_string(),
+            });
+        }
+        let mut fps_list = ns_arr_to_vec::<AVFrameRateRange>(unsafe {
+            msg_send![value, videoSupportedFrameRateRanges]
+        })
+        .into_iter()
+        .flat_map(|v| [v.min(), v.max()])
+        .collect::<Vec<f64>>();
+        fps_list.sort_by(|n, m| n.partial_cmp(m).unwrap_or(Ordering::Equal));
+        fps_list.dedup();
+        let description_obj: *mut Object = unsafe { msg_send![value, formatDescription] };
+        let resolution =
+            unsafe { CMVideoFormatDescriptionGetDimensions(description_obj as *mut c_void) };
+        let fcc_raw = unsafe { CMFormatDescriptionGetMediaSubType(description_obj as *mut c_void) };
+        #[allow(non_upper_case_globals)]
+        let fourcc = match fcc_raw {
+            kCMVideoCodecType_422YpCbCr8 | kCMPixelFormat_422YpCbCr8_yuvs => FrameFormat::YUYV,
+            kCMVideoCodecType_JPEG | kCMVideoCodecType_JPEG_OpenDML => FrameFormat::MJPEG,
+            kCMPixelFormat_8IndexedGray_WhiteIsZero => FrameFormat::GRAY,
+            fcc => {
+                return Err(NokhwaError::StructureError {
+                    structure: "FourCharCode".to_string(),
+                    error: format!("Unknown FourCharCode {fcc:?}"),
+                })
             }
-        }
+        };
+        let _: *mut c_void = unsafe { msg_send![description_obj, autorelease] };
+        Ok(AVCaptureDeviceFormat {
+            internal: value,
+            resolution,
+            fps_list,
+            fourcc,
+        })
+    }
+}
 
-        pub fn from_id(id: &str) -> Result<Self, AVFError> {
-            let nsstr_id = str_to_nsstr(id);
-            let avfoundation_capture_cls = class!(AVCaptureDevice);
-            let capture: *mut Object =
-                unsafe { msg_send![avfoundation_capture_cls, deviceWithUniqueID: nsstr_id] };
-            Ok(AVCaptureDevice { inner: capture })
-        }
+impl Drop for AVCaptureDeviceFormat {
+    fn drop(&mut self) {
+        unsafe { msg_send![self.internal, autorelease] }
+    }
+}
 
-        pub fn supported_formats(&self) -> Result<Vec<AVCaptureDeviceFormat>, AVFError> {
-            try_ns_arr_to_vec::<AVCaptureDeviceFormat, AVFError>(unsafe {
-                msg_send![self.inner, formats]
+impl AVCaptureDeviceDiscoverySession {
+    pub fn new(
+        device_types: Vec<AVCaptureDeviceType>,
+        media_type: AVMediaType,
+        position: AVCaptureDevicePosition,
+    ) -> Result<Self, NokhwaError> {
+        let device_types = vec_to_ns_arr(device_types);
+        let media_type: *mut Object = media_type.into();
+        let position = position as NSInteger;
+
+        let discovery_session_cls = class!(AVCaptureDeviceDiscoverySession);
+        let discovery_session: *mut Object = unsafe {
+            msg_send![discovery_session_cls, discoverySessionWithDeviceTypes:device_types mediaType:media_type position:position]
+        };
+        Ok(AVCaptureDeviceDiscoverySession {
+            inner: discovery_session,
+        })
+    }
+
+    pub fn default() -> Result<Self, NokhwaError> {
+        AVCaptureDeviceDiscoverySession::new(
+            vec![
+                AVCaptureDeviceType::UltraWide,
+                AVCaptureDeviceType::Telephoto,
+                AVCaptureDeviceType::ExternalUnknown,
+                AVCaptureDeviceType::Dual,
+                AVCaptureDeviceType::DualWide,
+                AVCaptureDeviceType::Triple,
+            ],
+            AVMediaType::Video,
+            AVCaptureDevicePosition::Unspecified,
+        )
+    }
+
+    pub fn devices(&self) -> Vec<CameraInfo> {
+        let device_ns_array: *mut Object = unsafe { msg_send![self.inner, devices] };
+        let objects_len: NSUInteger = unsafe { NSArray::count(device_ns_array) };
+        let mut devices = Vec::with_capacity(objects_len as usize);
+        for index in 0..objects_len {
+            let device = unsafe { device_ns_array.objectAtIndex(index) };
+            devices.push(get_raw_device_info(
+                CameraIndex::Index(index as u32),
+                device,
+            ));
+        }
+        let _: *mut c_void = unsafe { msg_send![device_ns_array, release] };
+        devices
+    }
+}
+
+impl Drop for AVCaptureDeviceDiscoverySession {
+    fn drop(&mut self) {
+        unsafe { msg_send![self.inner, autorelease] }
+    }
+}
+pub struct AVCaptureDevice {
+    inner: *mut Object,
+    device: CameraInfo,
+}
+
+impl AVCaptureDevice {
+    pub fn inner(&self) -> *mut Object {
+        self.inner
+    }
+}
+
+impl AVCaptureDevice {
+    pub fn new(index: &CameraIndex) -> Result<Self, NokhwaError> {
+        match &index {
+            CameraIndex::Index(idx) => {
+                let devices = AVCaptureDeviceDiscoverySession::new(
+                    vec![
+                        AVCaptureDeviceType::UltraWide,
+                        AVCaptureDeviceType::Telephoto,
+                        AVCaptureDeviceType::ExternalUnknown,
+                    ],
+                    AVMediaType::Video,
+                    AVCaptureDevicePosition::Unspecified,
+                )?
+                .devices();
+
+                match devices.get(*idx as usize) {
+                    Some(device) => Ok(AVCaptureDevice::from_id(
+                        &device.misc(),
+                        Some(index.clone()),
+                    )?),
+                    None => Err(NokhwaError::OpenDeviceError(
+                        idx.to_string(),
+                        "Not Found".to_string(),
+                    )),
+                }
+            }
+            CameraIndex::String(id) => Ok(AVCaptureDevice::from_id(id, None)?),
+        }
+    }
+
+    pub fn from_id(id: &str, index_hint: Option<CameraIndex>) -> Result<Self, NokhwaError> {
+        let nsstr_id = str_to_nsstr(id);
+        let avfoundation_capture_cls = class!(AVCaptureDevice);
+        let capture: *mut Object =
+            unsafe { msg_send![avfoundation_capture_cls, deviceWithUniqueID: nsstr_id] };
+        if capture.is_null() {
+            return Err(NokhwaError::OpenDeviceError(
+                id.to_string(),
+                "Device is null".to_string(),
+            ));
+        }
+        let camera_info = get_raw_device_info(
+            index_hint.unwrap_or_else(|| CameraIndex::String(id.to_string())),
+            capture,
+        );
+        Ok(AVCaptureDevice {
+            inner: capture,
+            device: camera_info,
+        })
+    }
+
+    pub fn info(&self) -> &CameraInfo {
+        &self.device
+    }
+
+    pub fn supported_formats_raw(&self) -> Result<Vec<AVCaptureDeviceFormat>, NokhwaError> {
+        try_ns_arr_to_vec::<AVCaptureDeviceFormat, NokhwaError>(unsafe {
+            msg_send![self.inner, formats]
+        })
+    }
+
+    pub fn supported_formats(&self) -> Result<Vec<CameraFormat>, NokhwaError> {
+        Ok(self
+            .supported_formats_raw()?
+            .iter()
+            .flat_map(|av_fmt| {
+                let resolution = av_fmt.resolution;
+                av_fmt.fps_list.iter().map(move |fps_f64| {
+                    let fps = if fps_f64.fract() != 0.0 {
+                        0
+                    } else {
+                        *fps_f64 as u32
+                    };
+
+                    let resolution =
+                        Resolution::new(resolution.height as u32, resolution.width as u32);
+
+                    CameraFormat::new(resolution, av_fmt.fourcc, fps)
+                })
             })
-        }
+            .filter(|x| x.frame_rate() != 0)
+            .collect())
+    }
 
-        pub fn already_in_use(&self) -> bool {
-            unsafe {
-                let result: BOOL = msg_send![self.inner(), isInUseByAnotherApplication];
-                result == YES
+    pub fn already_in_use(&self) -> bool {
+        unsafe {
+            let result: BOOL = msg_send![self.inner(), isInUseByAnotherApplication];
+            result == YES
+        }
+    }
+
+    pub fn is_suspended(&self) -> bool {
+        unsafe {
+            let result: BOOL = msg_send![self.inner, isSuspended];
+            result == YES
+        }
+    }
+
+    pub fn lock(&self) -> Result<(), NokhwaError> {
+        if self.already_in_use() {
+            return Err(NokhwaError::InitializeError {
+                backend: ApiBackend::AVFoundation,
+                error: "Already in use".to_string(),
+            });
+        }
+        let err_ptr: *mut c_void = std::ptr::null_mut();
+        let accepted: BOOL = unsafe { msg_send![self.inner, lockForConfiguration: err_ptr] };
+        if !err_ptr.is_null() {
+            return Err(NokhwaError::SetPropertyError {
+                property: "lockForConfiguration".to_string(),
+                value: "Locked".to_string(),
+                error: "Cannot lock for configuration".to_string(),
+            });
+        }
+        // Space these out for debug purposes
+        if !accepted == YES {
+            return Err(NokhwaError::SetPropertyError {
+                property: "lockForConfiguration".to_string(),
+                value: "Locked".to_string(),
+                error: "Lock Rejected".to_string(),
+            });
+        }
+        Ok(())
+    }
+
+    pub fn unlock(&self) {
+        unsafe { msg_send![self.inner, unlockForConfiguration] }
+    }
+
+    // thank you ffmpeg
+    pub fn set_all(&mut self, descriptor: CameraFormat) -> Result<(), NokhwaError> {
+        let format_list = try_ns_arr_to_vec::<AVCaptureDeviceFormat, NokhwaError>(unsafe {
+            msg_send![self.inner, formats]
+        })?;
+        let format_description_sel = sel!(formatDescription);
+
+        let mut selected_format: *mut Object = std::ptr::null_mut();
+        let mut selected_range: *mut Object = std::ptr::null_mut();
+
+        for format in format_list {
+            let format_desc_ref: CMFormatDescriptionRef =
+                unsafe { msg_send![format.internal, performSelector: format_description_sel] };
+            let dimensions = unsafe { CMVideoFormatDescriptionGetDimensions(format_desc_ref) };
+
+            if dimensions.height == descriptor.resolution().height() as i32
+                && dimensions.width == descriptor.resolution().width() as i32
+            {
+                selected_format = format.internal;
+
+                for range in ns_arr_to_vec::<AVFrameRateRange>(unsafe {
+                    msg_send![format.internal, valueForKey:"videoSupportedFrameRateRanges"]
+                }) {
+                    let max_fps: f64 =
+                        unsafe { msg_send![range.inner, valueForKey:"maxFrameRate"] };
+
+                    if (f64::from(descriptor.frame_rate()) - max_fps).abs() < 0.01 {
+                        selected_range = range.inner;
+                        break;
+                    }
+                }
             }
         }
 
-        pub fn is_suspended(&self) -> bool {
-            unsafe { msg_send![self.inner, isSuspended] }
+        if selected_range.is_null() || selected_format.is_null() {
+            return Err(NokhwaError::SetPropertyError {
+                property: "CameraFormat".to_string(),
+                value: descriptor.to_string(),
+                error: "Not Found/Rejected/Unsupported".to_string(),
+            });
         }
 
-        pub fn lock(&self) -> Result<(), AVFError> {
-            if self.already_in_use() {
-                return Err(AVFError::AlreadyBusy("In Use".to_string()));
+        self.lock()?;
+        let _: () =
+            unsafe { msg_send![self.inner, setValue:selected_format forKey:"activeFormat"] };
+        let min_frame_duration: *mut Object =
+            unsafe { msg_send![selected_range, valueForKey:"minFrameDuration"] };
+        let _: () = unsafe {
+            msg_send![self.inner, setValue:min_frame_duration forKey:"activeVideoMinFrameDuration"]
+        };
+        let _: () = unsafe {
+            msg_send![self.inner, setValue:min_frame_duration forKey:"activeVideoMaxFrameDuration"]
+        };
+        self.unlock();
+        Ok(())
+    }
+
+    // 0 => Focus POI
+    // 1 => Focus Manual Setting
+    // 2 => Exposure POI
+    // 3 => Exposure Face Driven
+    // 4 => Exposure Target Bias
+    // 5 => Exposure ISO
+    // 6 => Exposure Duration
+    pub fn get_controls(&self) -> Result<Vec<CameraControl>, NokhwaError> {
+        let active_format: *mut Object = unsafe { msg_send![self.inner, activeFormat] };
+
+        let mut controls = vec![];
+        // get focus modes
+
+        let focus_current: NSInteger = unsafe { msg_send![self.inner, focusMode] };
+        let focus_locked: BOOL =
+            unsafe { msg_send![self.inner, isFocusModeSupported:NSInteger::from(0)] };
+        let focus_auto: BOOL =
+            unsafe { msg_send![self.inner, isFocusModeSupported:NSInteger::from(1)] };
+        let focus_continuous: BOOL =
+            unsafe { msg_send![self.inner, isFocusModeSupported:NSInteger::from(2)] };
+
+        {
+            let mut supported_focus_values = vec![];
+
+            if focus_locked == YES {
+                supported_focus_values.push(0)
             }
-            let err_ptr: *mut c_void = std::ptr::null_mut();
-            let accepted: BOOL = unsafe { msg_send![self.inner, lockForConfiguration: err_ptr] };
-            if !err_ptr.is_null() {
-                return Err(AVFError::ConfigNotAccepted);
+            if focus_auto == YES {
+                supported_focus_values.push(1)
             }
-            // Space these out for debug purposes
-            if !accepted == YES {
-                return Err(AVFError::ConfigNotAccepted);
+            if focus_continuous == YES {
+                supported_focus_values.push(2)
             }
-            Ok(())
+
+            controls.push(CameraControl::new(
+                KnownCameraControl::Focus,
+                "FocusMode".to_string(),
+                ControlValueDescription::Enum {
+                    value: focus_current,
+                    possible: supported_focus_values,
+                    default: focus_current,
+                },
+                vec![],
+                true,
+            ));
         }
 
-        pub fn unlock(&self) {
-            unsafe { msg_send![self.inner, unlockForConfiguration] }
+        let focus_poi_supported: BOOL =
+            unsafe { msg_send![self.inner, isFocusPointOfInterestSupported] };
+        let focus_poi: CGPoint = unsafe { msg_send![self.inner, focusPointOfInterest] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Other(0),
+            "FocusPointOfInterest".to_string(),
+            ControlValueDescription::Point {
+                value: (focus_poi.x as f64, focus_poi.y as f64),
+                default: (0.5, 0.5),
+            },
+            if focus_poi_supported == NO {
+                vec![
+                    KnownCameraControlFlag::Disabled,
+                    KnownCameraControlFlag::ReadOnly,
+                ]
+            } else {
+                vec![]
+            },
+            focus_auto == YES || focus_continuous == YES,
+        ));
+
+        let focus_manual: BOOL =
+            unsafe { msg_send![self.inner, isLockingFocusWithCustomLensPositionSupported] };
+        let focus_lenspos: f32 = unsafe { msg_send![self.inner, lensPosition] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Other(1),
+            "FocusManualLensPosition".to_string(),
+            ControlValueDescription::FloatRange {
+                min: 0.0,
+                max: 1.0,
+                value: focus_lenspos as f64,
+                step: f64::MIN_POSITIVE,
+                default: 1.0,
+            },
+            if focus_manual == YES {
+                vec![]
+            } else {
+                vec![
+                    KnownCameraControlFlag::Disabled,
+                    KnownCameraControlFlag::ReadOnly,
+                ]
+            },
+            focus_manual == YES,
+        ));
+
+        // get exposures
+        let exposure_current: NSInteger = unsafe { msg_send![self.inner, exposureMode] };
+        let exposure_locked: BOOL =
+            unsafe { msg_send![self.inner, isExposureModeSupported:NSInteger::from(0)] };
+        let exposure_auto: BOOL =
+            unsafe { msg_send![self.inner, isExposureModeSupported:NSInteger::from(1)] };
+        let exposure_continuous: BOOL =
+            unsafe { msg_send![self.inner, isExposureModeSupported:NSInteger::from(2)] };
+        let exposure_custom: BOOL =
+            unsafe { msg_send![self.inner, isExposureModeSupported:NSInteger::from(3)] };
+
+        {
+            let mut supported_exposure_values = vec![];
+
+            if exposure_locked == YES {
+                supported_exposure_values.push(0);
+            }
+            if exposure_auto == YES {
+                supported_exposure_values.push(1);
+            }
+            if exposure_continuous == YES {
+                supported_exposure_values.push(2);
+            }
+            if exposure_custom == YES {
+                supported_exposure_values.push(3);
+            }
+
+            controls.push(CameraControl::new(
+                KnownCameraControl::Exposure,
+                "ExposureMode".to_string(),
+                ControlValueDescription::Enum {
+                    value: exposure_current,
+                    possible: supported_exposure_values,
+                    default: exposure_current,
+                },
+                vec![],
+                true,
+            ));
         }
 
-        pub fn set_frame_rate(&mut self, _: u32) {}
+        let exposure_poi_supported: BOOL =
+            unsafe { msg_send![self.inner, isExposurePointOfInterestSupported] };
+        let exposure_poi: CGPoint = unsafe { msg_send![self.inner, exposurePointOfInterest] };
 
-        pub fn set_all(
-            &mut self,
-            descriptor: CaptureDeviceFormatDescriptor,
-        ) -> Result<(), AVFError> {
-            let format_list = self.supported_formats()?;
-            for format in format_list {
-                if descriptor.compatible_with_capture_format(&format) {
-                    unsafe {
+        controls.push(CameraControl::new(
+            KnownCameraControl::Other(2),
+            "ExposurePointOfInterest".to_string(),
+            ControlValueDescription::Point {
+                value: (exposure_poi.x as f64, exposure_poi.y as f64),
+                default: (0.5, 0.5),
+            },
+            if exposure_poi_supported == NO {
+                vec![
+                    KnownCameraControlFlag::Disabled,
+                    KnownCameraControlFlag::ReadOnly,
+                ]
+            } else {
+                vec![]
+            },
+            focus_auto == YES || focus_continuous == YES,
+        ));
+
+        let expposure_face_driven_supported: BOOL =
+            unsafe { msg_send![self.inner, isFaceDrivenAutoExposureEnabled] };
+        let exposure_face_driven: BOOL = unsafe {
+            msg_send![
+                self.inner,
+                automaticallyAdjustsFaceDrivenAutoExposureEnabled
+            ]
+        };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Other(3),
+            "ExposureFaceDriven".to_string(),
+            ControlValueDescription::Boolean {
+                value: exposure_face_driven == YES,
+                default: false,
+            },
+            if expposure_face_driven_supported == NO {
+                vec![
+                    KnownCameraControlFlag::Disabled,
+                    KnownCameraControlFlag::ReadOnly,
+                ]
+            } else {
+                vec![]
+            },
+            exposure_poi_supported == YES,
+        ));
+
+        let exposure_bias: f32 = unsafe { msg_send![self.inner, exposureTargetBias] };
+        let exposure_bias_min: f32 = unsafe { msg_send![self.inner, minExposureTargetBias] };
+        let exposure_bias_max: f32 = unsafe { msg_send![self.inner, maxExposureTargetBias] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Other(4),
+            "ExposureBiasTarget".to_string(),
+            ControlValueDescription::FloatRange {
+                min: exposure_bias_min as f64,
+                max: exposure_bias_max as f64,
+                value: exposure_bias as f64,
+                step: f32::MIN_POSITIVE as f64,
+                default: unsafe { AVCaptureExposureTargetBiasCurrent } as f64,
+            },
+            vec![],
+            true,
+        ));
+
+        let exposure_duration: CMTime = unsafe { msg_send![self.inner, exposureDuration] };
+        let exposure_duration_min: CMTime =
+            unsafe { msg_send![active_format, minExposureDuration] };
+        let exposure_duration_max: CMTime =
+            unsafe { msg_send![active_format, maxExposureDuration] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Gamma,
+            "ExposureDuration".to_string(),
+            ControlValueDescription::IntegerRange {
+                min: exposure_duration_min.value,
+                max: exposure_duration_max.value,
+                value: exposure_duration.value,
+                step: 1,
+                default: unsafe { AVCaptureExposureDurationCurrent.value },
+            },
+            if exposure_custom == YES {
+                vec![
+                    KnownCameraControlFlag::ReadOnly,
+                    KnownCameraControlFlag::Volatile,
+                ]
+            } else {
+                vec![KnownCameraControlFlag::Volatile]
+            },
+            exposure_custom == YES,
+        ));
+
+        let exposure_iso: f32 = unsafe { msg_send![self.inner, ISO] };
+        let exposure_iso_min: f32 = unsafe { msg_send![active_format, minISO] };
+        let exposure_iso_max: f32 = unsafe { msg_send![active_format, maxISO] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Brightness,
+            "ExposureISO".to_string(),
+            ControlValueDescription::FloatRange {
+                min: exposure_iso_min as f64,
+                max: exposure_iso_max as f64,
+                value: exposure_iso as f64,
+                step: f32::MIN_POSITIVE as f64,
+                default: unsafe { AVCaptureISOCurrent } as f64,
+            },
+            if exposure_custom == YES {
+                vec![
+                    KnownCameraControlFlag::ReadOnly,
+                    KnownCameraControlFlag::Volatile,
+                ]
+            } else {
+                vec![KnownCameraControlFlag::Volatile]
+            },
+            exposure_custom == YES,
+        ));
+
+        let lens_aperture: f32 = unsafe { msg_send![self.inner, lensAperture] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Iris,
+            "LensAperture".to_string(),
+            ControlValueDescription::Float {
+                value: lens_aperture as f64,
+                default: lens_aperture as f64,
+                step: lens_aperture as f64,
+            },
+            vec![KnownCameraControlFlag::ReadOnly],
+            false,
+        ));
+
+        // get whiteblaance
+        let white_balance_current: NSInteger = unsafe { msg_send![self.inner, whiteBalanceMode] };
+        let white_balance_manual: BOOL =
+            unsafe { msg_send![self.inner, isWhiteBalanceModeSupported:NSInteger::from(0)] };
+        let white_balance_auto: BOOL =
+            unsafe { msg_send![self.inner, isWhiteBalanceModeSupported:NSInteger::from(1)] };
+        let white_balance_continuous: BOOL =
+            unsafe { msg_send![self.inner, isWhiteBalanceModeSupported:NSInteger::from(2)] };
+
+        {
+            let mut possible = vec![];
+
+            if white_balance_manual == YES {
+                possible.push(0);
+            }
+            if white_balance_auto == YES {
+                possible.push(1);
+            }
+            if white_balance_continuous == YES {
+                possible.push(2);
+            }
+
+            controls.push(CameraControl::new(
+                KnownCameraControl::WhiteBalance,
+                "WhiteBalanceMode".to_string(),
+                ControlValueDescription::Enum {
+                    value: white_balance_current as i64,
+                    possible,
+                    default: 0,
+                },
+                vec![],
+                true,
+            ));
+        }
+
+        let white_balance_gains: AVCaptureWhiteBalanceGains =
+            unsafe { msg_send![self.inner, deviceWhiteBalanceGains] };
+        let white_balance_default: AVCaptureWhiteBalanceGains =
+            unsafe { msg_send![self.inner, grayWorldDeviceWhiteBalanceGains] };
+        let white_balancne_max: AVCaptureWhiteBalanceGains =
+            unsafe { msg_send![self.inner, maxWhiteBalanceGain] };
+        let white_balance_gain_supported: BOOL = unsafe {
+            msg_send![
+                self.inner,
+                isLockingWhiteBalanceWithCustomDeviceGainsSupported
+            ]
+        };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Gain,
+            "WhiteBalanceGain".to_string(),
+            ControlValueDescription::RGB {
+                value: (
+                    white_balance_gains.redGain as f64,
+                    white_balance_gains.greenGain as f64,
+                    white_balance_gains.blueGain as f64,
+                ),
+                max: (
+                    white_balancne_max.redGain as f64,
+                    white_balancne_max.greenGain as f64,
+                    white_balancne_max.blueGain as f64,
+                ),
+                default: (
+                    white_balance_default.redGain as f64,
+                    white_balance_default.greenGain as f64,
+                    white_balance_default.blueGain as f64,
+                ),
+            },
+            if white_balance_gain_supported == YES {
+                vec![
+                    KnownCameraControlFlag::Disabled,
+                    KnownCameraControlFlag::ReadOnly,
+                ]
+            } else {
+                vec![]
+            },
+            white_balance_gain_supported == YES,
+        ));
+
+        // get flash
+        let has_torch: BOOL = unsafe { msg_send![self.inner, torchAvailible] };
+        let torch_active: BOOL = unsafe { msg_send![self.inner, isTorchActive] };
+        let torch_off: BOOL =
+            unsafe { msg_send![self.inner, isTorchModeSupported:NSInteger::from(0)] };
+        let torch_on: BOOL =
+            unsafe { msg_send![self.inner, isTorchModeSupported:NSInteger::from(1)] };
+        let torch_auto: BOOL =
+            unsafe { msg_send![self.inner, isTorchModeSupported:NSInteger::from(2)] };
+
+        {
+            let mut possible = vec![];
+
+            if torch_off == YES {
+                possible.push(0);
+            }
+            if torch_on == YES {
+                possible.push(1);
+            }
+            if torch_auto == YES {
+                possible.push(2);
+            }
+
+            controls.push(CameraControl::new(
+                KnownCameraControl::Other(5),
+                "TorchMode".to_string(),
+                ControlValueDescription::Enum {
+                    value: (torch_active == YES) as i64,
+                    possible,
+                    default: 0,
+                },
+                if has_torch == YES {
+                    vec![
+                        KnownCameraControlFlag::Disabled,
+                        KnownCameraControlFlag::ReadOnly,
+                    ]
+                } else {
+                    vec![]
+                },
+                has_torch == YES,
+            ));
+        }
+
+        // get low light boost
+        let has_llb: BOOL = unsafe { msg_send![self.inner, lowLightBoostSupported] };
+        let llb_enabled: BOOL = unsafe { msg_send![self.inner, lowLightBoostEnabled] };
+
+        {
+            controls.push(CameraControl::new(
+                KnownCameraControl::BacklightComp,
+                "LowLightCompensation".to_string(),
+                ControlValueDescription::Boolean {
+                    value: llb_enabled == YES,
+                    default: false,
+                },
+                if has_llb == NO {
+                    vec![
+                        KnownCameraControlFlag::Disabled,
+                        KnownCameraControlFlag::ReadOnly,
+                    ]
+                } else {
+                    vec![]
+                },
+                has_llb == YES,
+            ));
+        }
+
+        // get zoom factor
+        let zoom_current: CGFloat = unsafe { msg_send![self.inner, videoZoomFactor] };
+        let zoom_min: CGFloat = unsafe { msg_send![self.inner, minAvailableVideoZoomFactor] };
+        let zoom_max: CGFloat = unsafe { msg_send![self.inner, maxAvailableVideoZoomFactor] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Zoom,
+            "Zoom".to_string(),
+            ControlValueDescription::FloatRange {
+                min: zoom_min as f64,
+                max: zoom_max as f64,
+                value: zoom_current as f64,
+                step: f32::MIN_POSITIVE as f64,
+                default: 1.0,
+            },
+            vec![],
+            true,
+        ));
+
+        // zoom distortion correction
+        let distortion_correction_supported: BOOL =
+            unsafe { msg_send![self.inner, geometricDistortionCorrectionSupported] };
+        let distortion_correction_current_value: BOOL =
+            unsafe { msg_send![self.inner, geometricDistortionCorrectionEnabled] };
+
+        controls.push(CameraControl::new(
+            KnownCameraControl::Other(6),
+            "DistortionCorrection".to_string(),
+            ControlValueDescription::Boolean {
+                value: distortion_correction_current_value == YES,
+                default: false,
+            },
+            if distortion_correction_supported == YES {
+                vec![
+                    KnownCameraControlFlag::ReadOnly,
+                    KnownCameraControlFlag::Disabled,
+                ]
+            } else {
+                vec![]
+            },
+            distortion_correction_supported == YES,
+        ));
+
+        Ok(controls)
+    }
+
+    pub fn set_control(
+        &mut self,
+        id: KnownCameraControl,
+        value: ControlValueSetter,
+    ) -> Result<(), NokhwaError> {
+        let rc = self.get_controls()?;
+        let controls = rc
+            .iter()
+            .map(|cc| (cc.control(), cc))
+            .collect::<BTreeMap<_, _>>();
+
+        match id {
+            KnownCameraControl::Brightness => {
+                let isoctrl = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if isoctrl.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Exposure is in improper state to set ISO (Please set to `custom`!)"
+                            .to_string(),
+                    });
+                }
+
+                if isoctrl.flag().contains(&KnownCameraControlFlag::Disabled) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+
+                let current_duration = unsafe { AVCaptureExposureDurationCurrent };
+                let new_iso = *value.as_float().ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Expected float".to_string(),
+                })? as f32;
+
+                if !isoctrl.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe {
+                    msg_send![self.inner, setExposureModeCustomWithDuration:current_duration ISO:new_iso completionHandler:Nil]
+                };
+
+                Ok(())
+            }
+            KnownCameraControl::Gamma => {
+                let duration_ctrl = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if duration_ctrl
+                    .flag()
+                    .contains(&KnownCameraControlFlag::ReadOnly)
+                {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Exposure is in improper state to set Duration (Please set to `custom`!)"
+                            .to_string(),
+                    });
+                }
+
+                if duration_ctrl
+                    .flag()
+                    .contains(&KnownCameraControlFlag::Disabled)
+                {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+                let current_duration: CMTime = unsafe { msg_send![self.inner, exposureDuration] };
+
+                let current_iso = unsafe { AVCaptureISOCurrent };
+                let new_duration = CMTime {
+                    value: *value.as_integer().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected i64".to_string(),
+                    })?,
+                    timescale: current_duration.timescale,
+                    flags: current_duration.flags,
+                    epoch: current_duration.epoch,
+                };
+
+                if !duration_ctrl.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe {
+                    msg_send![self.inner, setExposureModeCustomWithDuration:new_duration ISO:current_iso completionHandler:Nil]
+                };
+
+                Ok(())
+            }
+            KnownCameraControl::WhiteBalance => {
+                let wb_enum_value = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if wb_enum_value
+                    .flag()
+                    .contains(&KnownCameraControlFlag::ReadOnly)
+                {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Read Only".to_string(),
+                    });
+                }
+
+                if wb_enum_value
+                    .flag()
+                    .contains(&KnownCameraControlFlag::Disabled)
+                {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+                let setter =
+                    NSInteger::from(*value.as_enum().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Enum".to_string(),
+                    })? as i32);
+
+                if !wb_enum_value.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe { msg_send![self.inner, whiteBalanceMode: setter] };
+
+                Ok(())
+            }
+            KnownCameraControl::BacklightComp => {
+                let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Read Only".to_string(),
+                    });
+                }
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+
+                let setter =
+                    NSInteger::from(*value.as_enum().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Enum".to_string(),
+                    })? as i32);
+
+                if !ctrlvalue.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe { msg_send![self.inner, whiteBalanceMode: setter] };
+
+                Ok(())
+            }
+            KnownCameraControl::Gain => {
+                let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Read Only".to_string(),
+                    });
+                }
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+
+                let setter =
+                    NSInteger::from(*value.as_boolean().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Boolean".to_string(),
+                    })? as i32);
+
+                if !ctrlvalue.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe { msg_send![self.inner, whiteBalanceMode: setter] };
+
+                Ok(())
+            }
+            KnownCameraControl::Zoom => {
+                let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Read Only".to_string(),
+                    });
+                }
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+
+                let setter = *value.as_float().ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Expected float".to_string(),
+                })? as c_float;
+
+                if !ctrlvalue.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe {
+                    msg_send![self.inner, rampToVideoZoomFactor: setter withRate: 1.0_f32]
+                };
+
+                Ok(())
+            }
+            KnownCameraControl::Exposure => {
+                let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Read Only".to_string(),
+                    });
+                }
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+
+                let setter =
+                    NSInteger::from(*value.as_enum().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Enum".to_string(),
+                    })? as i32);
+
+                if !ctrlvalue.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe { msg_send![self.inner, exposureMode: setter] };
+
+                Ok(())
+            }
+            KnownCameraControl::Iris => Err(NokhwaError::SetPropertyError {
+                property: id.to_string(),
+                value: value.to_string(),
+                error: "Read Only".to_string(),
+            }),
+            KnownCameraControl::Focus => {
+                let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Control does not exist".to_string(),
+                })?;
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Read Only".to_string(),
+                    });
+                }
+
+                if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Disabled".to_string(),
+                    });
+                }
+
+                let setter =
+                    NSInteger::from(*value.as_enum().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Enum".to_string(),
+                    })? as i32);
+
+                if !ctrlvalue.description().verify_setter(&value) {
+                    return Err(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Failed to verify value".to_string(),
+                    });
+                }
+
+                let _: () = unsafe { msg_send![self.inner, focusMode: setter] };
+
+                Ok(())
+            }
+            KnownCameraControl::Other(i) => match i {
+                0 => {
+                    let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Control does not exist".to_string(),
+                    })?;
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Read Only".to_string(),
+                        });
+                    }
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Disabled".to_string(),
+                        });
+                    }
+
+                    let setter = value
+                        .as_point()
+                        .ok_or(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Expected Point".to_string(),
+                        })
+                        .map(|(x, y)| CGPoint {
+                            x: *x as f32,
+                            y: *y as f32,
+                        })?;
+
+                    if !ctrlvalue.description().verify_setter(&value) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Failed to verify value".to_string(),
+                        });
+                    }
+
+                    let _: () = unsafe { msg_send![self.inner, focusPointOfInterest: setter] };
+
+                    Ok(())
+                }
+                1 => {
+                    let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Control does not exist".to_string(),
+                    })?;
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Read Only".to_string(),
+                        });
+                    }
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Disabled".to_string(),
+                        });
+                    }
+
+                    let setter = *value.as_float().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected float".to_string(),
+                    })? as c_float;
+
+                    if !ctrlvalue.description().verify_setter(&value) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Failed to verify value".to_string(),
+                        });
+                    }
+
+                    let _: () = unsafe {
+                        msg_send![self.inner, setFocusModeLockedWithLensPosition: setter handler: Nil]
+                    };
+
+                    Ok(())
+                }
+                2 => {
+                    let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Control does not exist".to_string(),
+                    })?;
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Read Only".to_string(),
+                        });
+                    }
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Disabled".to_string(),
+                        });
+                    }
+
+                    let setter = value
+                        .as_point()
+                        .ok_or(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Expected Point".to_string(),
+                        })
+                        .map(|(x, y)| CGPoint {
+                            x: *x as f32,
+                            y: *y as f32,
+                        })?;
+
+                    if !ctrlvalue.description().verify_setter(&value) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Failed to verify value".to_string(),
+                        });
+                    }
+
+                    let _: () = unsafe { msg_send![self.inner, exposurePointOfInterest: setter] };
+
+                    Ok(())
+                }
+                3 => {
+                    let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Control does not exist".to_string(),
+                    })?;
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Read Only".to_string(),
+                        });
+                    }
+
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Disabled".to_string(),
+                        });
+                    }
+
+                    let setter = if *value.as_boolean().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Boolean".to_string(),
+                    })? {
+                        YES
+                    } else {
+                        NO
+                    };
+
+                    if !ctrlvalue.description().verify_setter(&value) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Failed to verify value".to_string(),
+                        });
+                    }
+
+                    let _: () = unsafe {
                         msg_send![
                             self.inner,
-                            setActiveFormat:format.internal
+                            automaticallyAdjustsFaceDrivenAutoExposureEnabled: setter
                         ]
-                    }
-                    self.set_frame_rate(descriptor.fps as u32);
-                    return Ok(());
+                    };
+
+                    Ok(())
                 }
-            }
-            Err(AVFError::ConfigNotAccepted)
-        }
-    }
+                4 => {
+                    let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Control does not exist".to_string(),
+                    })?;
 
-    impl Drop for AVCaptureDevice {
-        fn drop(&mut self) {
-            unsafe {
-                let _: () = msg_send![self.inner, release];
-            }
-        }
-    }
-
-    impl AVCaptureDeviceInput {
-        pub fn new(capture_device: &AVCaptureDevice) -> Result<Self, AVFError> {
-            let cls = class!(AVCaptureDeviceInput);
-            let err_ptr: *mut c_void = std::ptr::null_mut();
-            let capture_input: *mut Object = unsafe {
-                let allocated: *mut Object = msg_send![cls, alloc];
-                msg_send![allocated, initWithDevice:capture_device.inner() error:err_ptr]
-            };
-            if !err_ptr.is_null() {
-                return Err(AVFError::General("Failed to create input".to_string()));
-            }
-
-            Ok(AVCaptureDeviceInput {
-                inner: capture_input,
-            })
-        }
-    }
-
-    impl Drop for AVCaptureDeviceInput {
-        fn drop(&mut self) {
-            unsafe { msg_send![self.inner, autorelease] }
-        }
-    }
-
-    pub struct AVCaptureVideoDataOutput {
-        inner: *mut Object,
-    }
-
-    impl AVCaptureVideoDataOutput {
-        pub fn new() -> Self {
-            AVCaptureVideoDataOutput::default()
-        }
-
-        pub fn add_delegate(&self, delegate: &AVCaptureVideoCallback) -> Result<(), AVFError> {
-            unsafe {
-                let avf_queue_str = match CString::new("avf_queue") {
-                    Ok(avf) => avf.into_raw(),
-                    Err(_) => {
-                        // should not happen
-                        return Err(AVFError::StreamOpen("String contains null? This is a bug, please report it https://github.com/l1npengtul/nokhwa".to_string()));
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Read Only".to_string(),
+                        });
                     }
-                };
-                let queue = dispatch_queue_create(avf_queue_str, NSObject(std::ptr::null_mut()));
 
-                let _: () = msg_send![
-                    self.inner,
-                    setSampleBufferDelegate: delegate.delegate
-                    queue: queue
-                ];
-            };
-            Ok(())
-        }
-    }
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Disabled".to_string(),
+                        });
+                    }
 
-    impl Default for AVCaptureVideoDataOutput {
-        fn default() -> Self {
-            let cls = class!(AVCaptureVideoDataOutput);
-            let inner: *mut Object = unsafe { msg_send![cls, new] };
+                    let setter = *value.as_float().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Float".to_string(),
+                    })? as f32;
 
-            AVCaptureVideoDataOutput { inner }
-        }
-    }
+                    if !ctrlvalue.description().verify_setter(&value) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Failed to verify value".to_string(),
+                        });
+                    }
 
-    impl Drop for AVCaptureVideoDataOutput {
-        fn drop(&mut self) {
-            unsafe { msg_send![self.inner, autorelease] }
-        }
-    }
+                    let _: () = unsafe {
+                        msg_send![self.inner, setExposureTargetBias: setter handler: Nil]
+                    };
 
-    impl AVCaptureSession {
-        pub fn new() -> Self {
-            AVCaptureSession::default()
-        }
+                    Ok(())
+                }
+                5 => {
+                    let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Control does not exist".to_string(),
+                    })?;
 
-        pub fn begin_configuration(&self) {
-            unsafe { msg_send![self.inner, beginConfiguration] }
-        }
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Read Only".to_string(),
+                        });
+                    }
 
-        pub fn commit_configuration(&self) {
-            unsafe { msg_send![self.inner, commitConfiguration] }
-        }
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Disabled".to_string(),
+                        });
+                    }
 
-        pub fn can_add_input(&self, input: &AVCaptureDeviceInput) -> bool {
-            let result: BOOL = unsafe { msg_send![self.inner, canAddInput:input.inner] };
-            result == YES
-        }
+                    let setter =
+                        NSInteger::from(*value.as_enum().ok_or(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Expected Enum".to_string(),
+                        })? as i32);
 
-        pub fn add_input(&self, input: &AVCaptureDeviceInput) -> Result<(), AVFError> {
-            if self.can_add_input(input) {
-                let _: () = unsafe { msg_send![self.inner, addInput:input.inner] };
-                return Ok(());
-            }
-            Err(AVFError::RejectedInput)
-        }
+                    if !ctrlvalue.description().verify_setter(&value) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Failed to verify value".to_string(),
+                        });
+                    }
 
-        pub fn remove_input(&self, input: &AVCaptureDeviceInput) {
-            unsafe { msg_send![self.inner, removeInput:input.inner] }
-        }
+                    let _: () = unsafe { msg_send![self.inner, torchMode: setter] };
 
-        pub fn can_add_output(&self, output: &AVCaptureVideoDataOutput) -> bool {
-            let result: BOOL = unsafe { msg_send![self.inner, canAddOutput:output.inner] };
-            result == YES
-        }
+                    Ok(())
+                }
+                6 => {
+                    let ctrlvalue = controls.get(&id).ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Control does not exist".to_string(),
+                    })?;
 
-        pub fn add_output(&self, output: &AVCaptureVideoDataOutput) -> Result<(), AVFError> {
-            if self.can_add_output(output) {
-                let _: () = unsafe { msg_send![self.inner, addOutput:output.inner] };
-                return Ok(());
-            }
-            Err(AVFError::RejectedInput)
-        }
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::ReadOnly) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Read Only".to_string(),
+                        });
+                    }
 
-        pub fn remove_output(&self, output: &AVCaptureVideoDataOutput) {
-            unsafe { msg_send![self.inner, removeOutput:output.inner] }
-        }
+                    if ctrlvalue.flag().contains(&KnownCameraControlFlag::Disabled) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Disabled".to_string(),
+                        });
+                    }
 
-        pub fn is_running(&self) -> bool {
-            let running: BOOL = unsafe { msg_send![self.inner, isRunning] };
-            running == YES
-        }
+                    let setter = if *value.as_boolean().ok_or(NokhwaError::SetPropertyError {
+                        property: id.to_string(),
+                        value: value.to_string(),
+                        error: "Expected Boolean".to_string(),
+                    })? {
+                        YES
+                    } else {
+                        NO
+                    };
 
-        pub fn start(&self) -> Result<(), AVFError> {
-            let start_stream_fn = || {
-                let _: () = unsafe { msg_send![self.inner, startRunning] };
-            };
+                    if !ctrlvalue.description().verify_setter(&value) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: id.to_string(),
+                            value: value.to_string(),
+                            error: "Failed to verify value".to_string(),
+                        });
+                    }
 
-            if std::panic::catch_unwind(start_stream_fn).is_err() {
-                return Err(AVFError::StreamOpen(
-                    "Cannot run AVCaptureSession".to_string(),
-                ));
-            }
-            Ok(())
-        }
+                    let _: () = unsafe {
+                        msg_send![self.inner, geometricDistortionCorrectionEnabled: setter]
+                    };
 
-        pub fn stop(&self) {
-            unsafe { msg_send![self.inner, stopRunning] }
-        }
-
-        pub fn is_interrupted(&self) -> bool {
-            let interrupted: BOOL = unsafe { msg_send![self.inner, isInterrupted] };
-            interrupted == YES
-        }
-    }
-
-    impl Drop for AVCaptureSession {
-        fn drop(&mut self) {
-            self.stop();
-            unsafe { msg_send![self.inner, autorelease] }
-        }
-    }
-
-    impl Default for AVCaptureSession {
-        fn default() -> Self {
-            let cls = class!(AVCaptureSession);
-            let session: *mut Object = {
-                let alloc: *mut Object = unsafe { msg_send![cls, alloc] };
-                unsafe { msg_send![alloc, init] }
-            };
-            AVCaptureSession { inner: session }
+                    Ok(())
+                }
+                _ => Err(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: value.to_string(),
+                    error: "Unknown Control".to_string(),
+                }),
+            },
+            _ => Err(NokhwaError::SetPropertyError {
+                property: id.to_string(),
+                value: value.to_string(),
+                error: "Unknown Control".to_string(),
+            }),
         }
     }
 }
 
-#[cfg(not(any(target_os = "macos", target_os = "ios")))]
-pub mod avfoundation {
-    use crate::AVFError;
-    use flume::{Receiver, Sender};
-    use std::borrow::Cow;
-
-    pub type CompressionData<'a> = (Cow<'a, [u8]>, AVFourCC);
-    pub type DataPipe<'a> = (Sender<CompressionData<'a>>, Receiver<CompressionData<'a>>);
-
-    pub fn request_permission_with_callback(_: fn(bool)) {}
-
-    pub fn current_authorization_status() -> AVAuthorizationStatus {
-        AVAuthorizationStatus::NotDetermined
-    }
-
-    // fuck it, use deprecated APIs
-    pub fn query_avfoundation() -> Result<Vec<AVCaptureDeviceDescriptor>, AVFError> {
-        Err(AVFError::NotSupported)
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    pub enum AVCaptureDeviceType {
-        Dual,
-        DualWide,
-        Triple,
-        WideAngle,
-        UltraWide,
-        Telephoto,
-        TrueDepth,
-        ExternalUnknown,
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    pub enum AVMediaType {
-        Audio,
-        ClosedCaption,
-        DepthData,
-        Metadata,
-        MetadataObject,
-        Muxed,
-        Subtitle,
-        Text,
-        Timecode,
-        Video,
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    #[repr(isize)]
-    pub enum AVCaptureDevicePosition {
-        Unspecified = 0,
-        Back = 1,
-        Front = 2,
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    #[repr(isize)]
-    pub enum AVAuthorizationStatus {
-        NotDetermined = 0,
-        Restricted = 1,
-        Denied = 2,
-        Authorized = 3,
-    }
-
-    #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    #[repr(u32)]
-    pub enum AVFourCC {
-        YUV2,
-        MJPEG,
-    }
-
-    // Localized Name
-    //
-    #[derive(Clone, Debug, Default, Hash, Ord, PartialOrd, Eq, PartialEq)]
-    pub struct AVCaptureDeviceDescriptor {
-        pub name: String,
-        pub description: String,
-        pub misc: String,
-        pub index: u64,
-    }
-
-    pub struct AVCaptureVideoCallback {}
-
-    impl AVCaptureVideoCallback {
-        pub fn new(_: usize) -> Self {
-            AVCaptureVideoCallback {}
-        }
-
-        pub fn index(&self) -> usize {
-            0
-        }
-
-        pub fn data_len(&self) -> usize {
-            0
-        }
-
-        pub fn frame_to_slice<'a>(&self) -> Result<CompressionData<'a>, AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn frame_to_slice_no_block<'a>(&self) -> Result<CompressionData<'a>, AVFError> {
-            Err(AVFError::NotSupported)
-        }
-    }
-
-    pub struct AVFrameRateRange {}
-    pub struct AVCaptureDeviceDiscoverySession {}
-    pub struct AVCaptureDevice {}
-    pub struct AVCaptureDeviceInput {}
-    pub struct AVCaptureSession {}
-
-    impl AVFrameRateRange {
-        pub fn max(&self) -> f64 {
-            0_f64
-        }
-
-        pub fn min(&self) -> f64 {
-            0_f64
-        }
-    }
-
-    #[derive(Copy, Clone, Debug)]
-    pub struct CMVideoDimensions {
-        pub width: i32,
-        pub height: i32,
-    }
-
-    pub type AVVideoResolution = CMVideoDimensions;
-
-    #[derive(Copy, Clone, Debug)]
-    pub struct CaptureDeviceFormatDescriptor {
-        pub resolution: AVVideoResolution,
-        pub fps: u32,
-        pub fourcc: AVFourCC,
-    }
-
-    impl CaptureDeviceFormatDescriptor {
-        pub fn compatible_with_capture_format(&self, other: &AVCaptureDeviceFormat) -> bool {
-            for fps in &other.fps_list {
-                if self.resolution.height == other.resolution.height
-                    && self.resolution.width == other.resolution.width
-                    && self.fourcc == other.fourcc
-                    && (*fps as u32) == self.fps
-                {
-                    return true;
-                }
-            }
-            false
-        }
-    }
-
-    #[derive(Debug)]
-    pub struct AVCaptureDeviceFormat {
-        pub resolution: CMVideoDimensions,
-        pub fps_list: Vec<f64>,
-        pub fourcc: AVFourCC,
-    }
-
-    impl AVCaptureDeviceDiscoverySession {
-        pub fn new(
-            _: Vec<AVCaptureDeviceType>,
-            _: AVMediaType,
-            _: AVCaptureDevicePosition,
-        ) -> Result<Self, AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn default() -> Result<Self, AVFError> {
-            AVCaptureDeviceDiscoverySession::new(
-                vec![
-                    AVCaptureDeviceType::UltraWide,
-                    AVCaptureDeviceType::Telephoto,
-                    AVCaptureDeviceType::ExternalUnknown,
-                    AVCaptureDeviceType::Dual,
-                    AVCaptureDeviceType::DualWide,
-                    AVCaptureDeviceType::Triple,
-                ],
-                AVMediaType::Video,
-                AVCaptureDevicePosition::Unspecified,
-            )
-        }
-
-        pub fn devices(&self) -> Vec<AVCaptureDeviceDescriptor> {
-            vec![]
-        }
-    }
-
-    impl AVCaptureDevice {
-        pub fn devices_with_type(_: AVMediaType) -> Vec<AVCaptureDevice> {
-            vec![]
-        }
-
-        pub fn new(_: usize) -> Result<Self, AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn from_id(_: &str) -> Result<Self, AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn supported_formats(&self) -> Result<Vec<AVCaptureDeviceFormat>, AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn already_in_use(&self) -> bool {
-            false
-        }
-
-        pub fn is_suspended(&self) -> bool {
-            false
-        }
-
-        pub fn lock(&self) -> Result<(), AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn unlock(&self) {}
-
-        pub fn set_frame_rate(&mut self, _: u32) {}
-
-        pub fn set_all(&mut self, _: CaptureDeviceFormatDescriptor) -> Result<(), AVFError> {
-            Err(AVFError::NotSupported)
-        }
-    }
-
-    impl AVCaptureDeviceInput {
-        pub fn new(_: &AVCaptureDevice) -> Result<Self, AVFError> {
-            Err(AVFError::NotSupported)
-        }
-    }
-
-    pub struct AVCaptureVideoDataOutput {}
-
-    impl AVCaptureVideoDataOutput {
-        pub fn new() -> Self {
-            AVCaptureVideoDataOutput::default()
-        }
-
-        pub fn add_delegate(&self, _: &AVCaptureVideoCallback) -> Result<(), AVFError> {
-            Err(AVFError::NotSupported)
-        }
-    }
-
-    impl Default for AVCaptureVideoDataOutput {
-        fn default() -> Self {
-            AVCaptureVideoDataOutput {}
-        }
-    }
-
-    impl AVCaptureSession {
-        pub fn new() -> Self {
-            AVCaptureSession::default()
-        }
-
-        pub fn begin_configuration(&self) {}
-
-        pub fn commit_configuration(&self) {}
-
-        pub fn can_add_input(&self, _: &AVCaptureDeviceInput) -> bool {
-            false
-        }
-
-        pub fn add_input(&self, _: &AVCaptureDeviceInput) -> Result<(), AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn remove_input(&self, _: &AVCaptureDeviceInput) {}
-
-        pub fn can_add_output(&self, _: &AVCaptureVideoDataOutput) -> bool {
-            false
-        }
-
-        pub fn add_output(&self, _: &AVCaptureVideoDataOutput) -> Result<(), AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn remove_output(&self, _: &AVCaptureVideoDataOutput) {}
-
-        pub fn is_running(&self) -> bool {
-            false
-        }
-
-        pub fn start(&self) -> Result<(), AVFError> {
-            Err(AVFError::NotSupported)
-        }
-
-        pub fn stop(&self) {}
-
-        pub fn is_interrupted(&self) -> bool {
-            false
-        }
-    }
-
-    impl Default for AVCaptureSession {
-        fn default() -> Self {
-            AVCaptureSession {}
+impl Drop for AVCaptureDevice {
+    fn drop(&mut self) {
+        unsafe {
+            let _: () = msg_send![self.inner, release];
         }
     }
 }
+
+impl AVCaptureDeviceInput {
+    pub fn new(capture_device: &AVCaptureDevice) -> Result<Self, NokhwaError> {
+        let cls = class!(AVCaptureDeviceInput);
+        let err_ptr: *mut c_void = std::ptr::null_mut();
+        let capture_input: *mut Object = unsafe {
+            let allocated: *mut Object = msg_send![cls, alloc];
+            msg_send![allocated, initWithDevice:capture_device.inner() error:err_ptr]
+        };
+        if !err_ptr.is_null() {
+            return Err(NokhwaError::InitializeError {
+                backend: ApiBackend::AVFoundation,
+                error: "Failed to create input".to_string(),
+            });
+        }
+
+        Ok(AVCaptureDeviceInput {
+            inner: capture_input,
+        })
+    }
+}
+
+impl Drop for AVCaptureDeviceInput {
+    fn drop(&mut self) {
+        unsafe { msg_send![self.inner, autorelease] }
+    }
+}
+
+pub struct AVCaptureVideoDataOutput {
+    inner: *mut Object,
+}
+
+impl AVCaptureVideoDataOutput {
+    pub fn new() -> Self {
+        AVCaptureVideoDataOutput::default()
+    }
+
+    pub fn add_delegate(&self, delegate: &AVCaptureVideoCallback) -> Result<(), NokhwaError> {
+        unsafe {
+            let _: () = msg_send![
+                self.inner,
+                setSampleBufferDelegate: delegate.delegate
+                queue: delegate.queue().0
+            ];
+        };
+        Ok(())
+    }
+}
+
+impl Default for AVCaptureVideoDataOutput {
+    fn default() -> Self {
+        let cls = class!(AVCaptureVideoDataOutput);
+        let inner: *mut Object = unsafe { msg_send![cls, new] };
+
+        AVCaptureVideoDataOutput { inner }
+    }
+}
+
+impl Drop for AVCaptureVideoDataOutput {
+    fn drop(&mut self) {
+        unsafe { msg_send![self.inner, autorelease] }
+    }
+}
+
+impl AVCaptureSession {
+    pub fn new() -> Self {
+        AVCaptureSession::default()
+    }
+
+    pub fn begin_configuration(&self) {
+        unsafe { msg_send![self.inner, beginConfiguration] }
+    }
+
+    pub fn commit_configuration(&self) {
+        unsafe { msg_send![self.inner, commitConfiguration] }
+    }
+
+    pub fn can_add_input(&self, input: &AVCaptureDeviceInput) -> bool {
+        let result: BOOL = unsafe { msg_send![self.inner, canAddInput:input.inner] };
+        result == YES
+    }
+
+    pub fn add_input(&self, input: &AVCaptureDeviceInput) -> Result<(), NokhwaError> {
+        if self.can_add_input(input) {
+            let _: () = unsafe { msg_send![self.inner, addInput:input.inner] };
+            return Ok(());
+        }
+        Err(NokhwaError::SetPropertyError {
+            property: "AVCaptureDeviceInput".to_string(),
+            value: "add new input".to_string(),
+            error: "Rejected".to_string(),
+        })
+    }
+
+    pub fn remove_input(&self, input: &AVCaptureDeviceInput) {
+        unsafe { msg_send![self.inner, removeInput:input.inner] }
+    }
+
+    pub fn can_add_output(&self, output: &AVCaptureVideoDataOutput) -> bool {
+        let result: BOOL = unsafe { msg_send![self.inner, canAddOutput:output.inner] };
+        result == YES
+    }
+
+    pub fn add_output(&self, output: &AVCaptureVideoDataOutput) -> Result<(), NokhwaError> {
+        if self.can_add_output(output) {
+            let _: () = unsafe { msg_send![self.inner, addOutput:output.inner] };
+            return Ok(());
+        }
+        Err(NokhwaError::SetPropertyError {
+            property: "AVCaptureVideoDataOutput".to_string(),
+            value: "add new output".to_string(),
+            error: "Rejected".to_string(),
+        })
+    }
+
+    pub fn remove_output(&self, output: &AVCaptureVideoDataOutput) {
+        unsafe { msg_send![self.inner, removeOutput:output.inner] }
+    }
+
+    pub fn is_running(&self) -> bool {
+        let running: BOOL = unsafe { msg_send![self.inner, isRunning] };
+        running == YES
+    }
+
+    pub fn start(&self) -> Result<(), NokhwaError> {
+        let start_stream_fn = || {
+            let _: () = unsafe { msg_send![self.inner, startRunning] };
+        };
+
+        if std::panic::catch_unwind(start_stream_fn).is_err() {
+            return Err(NokhwaError::OpenStreamError(
+                "Cannot run AVCaptureSession".to_string(),
+            ));
+        }
+        Ok(())
+    }
+
+    pub fn stop(&self) {
+        unsafe { msg_send![self.inner, stopRunning] }
+    }
+
+    pub fn is_interrupted(&self) -> bool {
+        let interrupted: BOOL = unsafe { msg_send![self.inner, isInterrupted] };
+        interrupted == YES
+    }
+}
+
+impl Drop for AVCaptureSession {
+    fn drop(&mut self) {
+        self.stop();
+        unsafe { msg_send![self.inner, autorelease] }
+    }
+}
+
+impl Default for AVCaptureSession {
+    fn default() -> Self {
+        let cls = class!(AVCaptureSession);
+        let session: *mut Object = {
+            let alloc: *mut Object = unsafe { msg_send![cls, alloc] };
+            unsafe { msg_send![alloc, init] }
+        };
+        AVCaptureSession { inner: session }
+    }
+}
diff --git a/nokhwa-bindings-windows/Cargo.toml b/nokhwa-bindings-windows/Cargo.toml
index e3f3fff..54b2885 100644
--- a/nokhwa-bindings-windows/Cargo.toml
+++ b/nokhwa-bindings-windows/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "nokhwa-bindings-windows"
-version = "0.3.4"
+version = "0.4.0"
 authors = ["l1npengtul"]
 edition = "2021"
 license = "Apache-2.0"
@@ -11,11 +11,12 @@ keywords = ["media-foundation", "windows", "capture", "webcam"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-thiserror = "^1.0"
-
-[target.'cfg(all(target_os = "windows", windows))'.dependencies]
 lazy_static = "1.4.0"
 
-[target.'cfg(all(target_os = "windows", windows))'.dependencies.windows]
-version = "^0.28"
-features = ["alloc", "Win32_Media_MediaFoundation", "Win32_System_Com", "Win32_Foundation", "Win32_Media_DirectShow","Win32_Media_KernelStreaming"]
\ No newline at end of file
+[dependencies.nokhwa-core]
+version = "0.1"
+path = "../nokhwa-core"
+
+[dependencies.windows]
+version = "0.39.0"
+features = ["Win32_Media_MediaFoundation", "Win32_System_Com", "Win32_Foundation", "Win32_Media_DirectShow", "Win32_Media", "Win32", "Win32_Media_KernelStreaming"]
diff --git a/nokhwa-bindings-windows/src/lib.rs b/nokhwa-bindings-windows/src/lib.rs
index 84b1ba3..7a86185 100644
--- a/nokhwa-bindings-windows/src/lib.rs
+++ b/nokhwa-bindings-windows/src/lib.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -36,341 +36,17 @@ use std::{
     cmp::Ordering,
     slice::from_raw_parts,
 };
-use thiserror::Error;
-
-#[allow(clippy::module_name_repetitions)]
-#[derive(Error, Debug, Clone)]
-pub enum BindingError {
-    #[error("Failed to initialize Media Foundation: {0}")]
-    InitializeError(String),
-    #[error("Failed to de-initialize Media Foundation: {0}")]
-    DeInitializeError(String),
-    #[error("Failed to set GUID {0} to {1}: {2}")]
-    GUIDSetError(String, String, String),
-    #[error("Failed to Read GUID {0}: {1}")]
-    GUIDReadError(String, String),
-    #[error("Attribute Error: {0}")]
-    AttributeError(String),
-    #[error("Failed to enumerate: {0}")]
-    EnumerateError(String),
-    #[error("Failed to open device {0}: {1}")]
-    DeviceOpenFailError(String, String),
-    #[error("Failed to read frame: {0}")]
-    ReadFrameError(String),
-    #[error("Not Implemented!")]
-    NotImplementedError,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct MFResolution {
-    pub width_x: u32,
-    pub height_y: u32,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Hash, PartialOrd, Ord, Eq)]
-pub enum MFFrameFormat {
-    MJPEG,
-    YUYV,
-}
-
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Ord, PartialOrd)]
-pub struct MFCameraFormat {
-    resolution: MFResolution,
-    format: MFFrameFormat,
-    frame_rate: u32,
-}
-
-impl Default for MFCameraFormat {
-    fn default() -> Self {
-        MFCameraFormat {
-            resolution: MFResolution {
-                width_x: 640,
-                height_y: 480,
-            },
-            format: MFFrameFormat::MJPEG,
-            frame_rate: 15,
-        }
-    }
-}
-
-impl MFCameraFormat {
-    #[must_use]
-    pub fn new(resolution: MFResolution, format: MFFrameFormat, frame_rate: u32) -> Self {
-        MFCameraFormat {
-            resolution,
-            format,
-            frame_rate,
-        }
-    }
-
-    #[must_use]
-    pub fn new_from(res_x: u32, res_y: u32, format: MFFrameFormat, fps: u32) -> Self {
-        MFCameraFormat {
-            resolution: MFResolution {
-                width_x: res_x,
-                height_y: res_y,
-            },
-            format,
-            frame_rate: fps,
-        }
-    }
-
-    #[must_use]
-    pub fn resolution(&self) -> MFResolution {
-        self.resolution
-    }
-
-    #[must_use]
-    pub fn width(&self) -> u32 {
-        self.resolution.width_x
-    }
-
-    #[must_use]
-    pub fn height(&self) -> u32 {
-        self.resolution.height_y
-    }
-
-    pub fn set_resolution(&mut self, resolution: MFResolution) {
-        self.resolution = resolution;
-    }
-
-    #[must_use]
-    pub fn frame_rate(&self) -> u32 {
-        self.frame_rate
-    }
-
-    pub fn set_frame_rate(&mut self, frame_rate: u32) {
-        self.frame_rate = frame_rate;
-    }
-
-    #[must_use]
-    pub fn format(&self) -> MFFrameFormat {
-        self.format
-    }
-
-    pub fn set_format(&mut self, format: MFFrameFormat) {
-        self.format = format;
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MediaFoundationDeviceDescriptor<'a> {
-    index: usize,
-    name: Cow<'a, [u16]>,
-    symlink: Cow<'a, [u16]>,
-}
-
-impl<'a> MediaFoundationDeviceDescriptor<'a> {
-    /// # Errors
-    /// If name or symlink is a nullptr, this will error.
-    /// # Safety
-    /// name and symlink must not be null
-    pub unsafe fn new(
-        index: usize,
-        name: *mut u16,
-        symlink: *mut u16,
-        name_len: u32,
-        symlink_len: u32,
-    ) -> Result<Self, BindingError> {
-        let name = if name.is_null() {
-            return Err(BindingError::AttributeError("name nullptr".to_string()));
-        } else {
-            Cow::from(from_raw_parts(name, name_len as usize))
-        };
-
-        let symlink = if symlink.is_null() {
-            return Err(BindingError::AttributeError("symlink nullptr".to_string()));
-        } else {
-            Cow::from(from_raw_parts(symlink, symlink_len as usize))
-        };
-
-        Ok(MediaFoundationDeviceDescriptor {
-            index,
-            name,
-            symlink,
-        })
-    }
-
-    #[must_use]
-    pub fn index(&self) -> usize {
-        self.index
-    }
-
-    #[must_use]
-    pub fn name(&self) -> &Cow<[u16]> {
-        &self.name
-    }
-
-    #[must_use]
-    pub fn symlink(&self) -> &Cow<[u16]> {
-        &self.symlink
-    }
-
-    #[must_use]
-    pub fn name_as_string(&self) -> String {
-        String::from_utf16_lossy(self.name.borrow())
-    }
-
-    #[must_use]
-    pub fn link_as_string(&self) -> String {
-        String::from_utf16_lossy(self.symlink.borrow())
-    }
-}
-
-impl<'a> PartialOrd for MediaFoundationDeviceDescriptor<'a> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl<'a> Ord for MediaFoundationDeviceDescriptor<'a> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.index.cmp(&other.index)
-    }
-}
-
-#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-pub enum MediaFoundationControls {
-    Brightness,
-    Contrast,
-    Hue,
-    Saturation,
-    Sharpness,
-    Gamma,
-    ColorEnable,
-    WhiteBalance,
-    BacklightComp,
-    Gain,
-    Pan,
-    Tilt,
-    Roll,
-    Zoom,
-    Exposure,
-    Iris,
-    Focus,
-}
-
-#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-pub struct MFControl {
-    control: MediaFoundationControls,
-    min: i32,
-    max: i32,
-    step: i32,
-    current: i32,
-    default: i32,
-    manual: bool,
-    active: bool,
-}
-
-impl MFControl {
-    #[allow(clippy::too_many_arguments)]
-    #[must_use]
-    pub fn new(
-        control: MediaFoundationControls,
-        min: i32,
-        max: i32,
-        step: i32,
-        current: i32,
-        default: i32,
-        manual: bool,
-        active: bool,
-    ) -> Self {
-        MFControl {
-            control,
-            min,
-            max,
-            step,
-            current,
-            default,
-            manual,
-            active,
-        }
-    }
-
-    #[must_use]
-    pub fn control(&self) -> MediaFoundationControls {
-        self.control
-    }
-
-    pub fn set_control(&mut self, control: MediaFoundationControls) {
-        self.control = control;
-    }
-
-    #[must_use]
-    pub fn min(&self) -> i32 {
-        self.min
-    }
-
-    pub fn set_min(&mut self, min: i32) {
-        self.min = min;
-    }
-
-    #[must_use]
-    pub fn max(&self) -> i32 {
-        self.max
-    }
-
-    pub fn set_max(&mut self, max: i32) {
-        self.max = max;
-    }
-
-    #[must_use]
-    pub fn step(&self) -> i32 {
-        self.step
-    }
-
-    pub fn set_step(&mut self, step: i32) {
-        self.step = step;
-    }
-
-    #[must_use]
-    pub fn current(&self) -> i32 {
-        self.current
-    }
-
-    pub fn set_current(&mut self, current: i32) {
-        self.current = current;
-    }
-    #[must_use]
-    pub fn default(&self) -> i32 {
-        self.default
-    }
-
-    pub fn set_default(&mut self, default: i32) {
-        self.default = default;
-    }
-
-    #[must_use]
-    pub fn manual(&self) -> bool {
-        self.manual
-    }
-
-    pub fn set_manual(&mut self, manual: bool) {
-        self.manual = manual;
-    }
-
-    #[must_use]
-    pub fn active(&self) -> bool {
-        self.active
-    }
-
-    pub fn set_active(&mut self, active: bool) {
-        self.active = active;
-    }
-}
 
 #[cfg(all(windows, not(feature = "docs-only")))]
 pub mod wmf {
-    #![windows_subsystem = "windows"]
-    use crate::{
-        BindingError, MFCameraFormat, MFControl, MFFrameFormat, MFResolution,
-        MediaFoundationControls, MediaFoundationDeviceDescriptor,
+    use nokhwa_core::error::NokhwaError;
+    use nokhwa_core::types::{
+        ApiBackend, CameraControl, CameraFormat, CameraIndex, CameraInfo, ControlValueDescription,
+        ControlValueSetter, FrameFormat, KnownCameraControl, KnownCameraControlFlag, Resolution,
     };
-    use std::ptr::null_mut;
     use std::{
         borrow::Cow,
         cell::Cell,
-        collections::HashMap,
         mem::MaybeUninit,
         slice::from_raw_parts,
         sync::{
@@ -378,10 +54,13 @@ pub mod wmf {
             Arc,
         },
     };
+    use windows::Win32::Media::DirectShow::{CameraControl_Flags_Auto, CameraControl_Flags_Manual};
+    use windows::Win32::Media::MediaFoundation::{
+        IMFMediaType, MF_SOURCE_READER_FIRST_VIDEO_STREAM,
+    };
     use windows::{
-        core::{Interface, GUID},
+        core::{Interface, GUID, PWSTR},
         Win32::{
-            Foundation::PWSTR,
             Media::{
                 KernelStreaming::GUID_NULL,
                 DirectShow::{
@@ -393,14 +72,15 @@ pub mod wmf {
                     VideoProcAmp_Saturation, VideoProcAmp_Sharpness, VideoProcAmp_WhiteBalance,
                 },
                 MediaFoundation::{
-                    IMFActivate, IMFAttributes, IMFMediaSource, IMFMediaType, IMFSample,
-                    IMFSourceReader, MFCreateAttributes, MFCreateSourceReaderFromMediaSource,
-                    MFEnumDeviceSources, MFShutdown, MFStartup, MFSTARTUP_NOSOCKET, MF_API_VERSION,
-                    MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
+                    IMFActivate, IMFAttributes, IMFMediaSource, IMFSample, IMFSourceReader,
+                    MFCreateAttributes, MFCreateMediaType, MFCreateSourceReaderFromMediaSource,
+                    MFEnumDeviceSources, MFMediaType_Video, MFShutdown, MFStartup,
+                    MFSTARTUP_NOSOCKET, MF_API_VERSION, MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME,
+                    MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
                     MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID,
                     MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
                     MF_MT_FRAME_RATE, MF_MT_FRAME_RATE_RANGE_MAX,
-                    MF_MT_FRAME_RATE_RANGE_MIN, MF_MT_FRAME_SIZE, MF_MT_SUBTYPE,
+                    MF_MT_FRAME_RATE_RANGE_MIN, MF_MT_FRAME_SIZE, MF_MT_MAJOR_TYPE, MF_MT_SUBTYPE,
                     MF_READWRITE_DISABLE_CONVERTERS,
                 },
             },
@@ -430,6 +110,12 @@ pub mod wmf {
         0x0010,
         [0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71],
     );
+    const MF_VIDEO_FORMAT_GRAY: GUID = GUID::from_values(
+        0x3030_3859,
+        0x0000,
+        0x0010,
+        [0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71],
+    );
 
     const MEDIA_FOUNDATION_FIRST_VIDEO_STREAM: u32 = 0xFFFF_FFFC;
     const MF_SOURCE_READER_MEDIASOURCE: u32 = 0xFFFF_FFFF;
@@ -437,31 +123,78 @@ pub mod wmf {
     const CAM_CTRL_AUTO: i32 = 0x0001;
     const CAM_CTRL_MANUAL: i32 = 0x0002;
 
-    pub fn initialize_mf() -> Result<(), BindingError> {
+    macro_rules! define_controls {
+        ( $( ($key:expr => ($property:ident, $min:ident, $max:ident, $step:ident, $default:ident, $flag:ident)) )* ) => {
+            $(
+            $key => {
+                if let Err(why) = unsafe {
+                        video_proc_amp.GetRange(
+                            $property.0,
+                            &mut $min,
+                            &mut $max,
+                            &mut $step,
+                            &mut $default,
+                            &mut $flag,
+                        )
+                    } {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: stringify!($key).to_string(),
+                            error: why.to_string()
+                        });
+                    }
+            }
+            )*
+        };
+        ( $( ($key:expr : ($property:ident, $value:ident, $flag:ident)) )* ) => {
+            $(
+            $key => {
+                if let Err(why) = unsafe {
+                    video_proc_amp.Get($property.0, &mut $value, &mut $flag)
+                    } {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: stringify!($key).to_string(),
+                            error: why.to_string()
+                        });
+                    }
+            }
+            )*
+        };
+    }
+
+    pub fn initialize_mf() -> Result<(), NokhwaError> {
         if !(INITIALIZED.load(Ordering::SeqCst)) {
             let a = std::ptr::null_mut();
             if let Err(why) =
                 unsafe { CoInitializeEx(a, CO_INIT_APARTMENT_THREADED | CO_INIT_DISABLE_OLE1DDE) }
             {
-                return Err(BindingError::InitializeError(why.to_string()));
+                return Err(NokhwaError::InitializeError {
+                    backend: ApiBackend::MediaFoundation,
+                    error: why.to_string(),
+                });
             }
 
             if let Err(why) = unsafe { MFStartup(MF_API_VERSION, MFSTARTUP_NOSOCKET) } {
                 unsafe {
                     CoUninitialize();
                 }
-                return Err(BindingError::InitializeError(why.to_string()));
+                return Err(NokhwaError::InitializeError {
+                    backend: ApiBackend::MediaFoundation,
+                    error: why.to_string(),
+                });
             }
             INITIALIZED.store(true, Ordering::SeqCst);
         }
         Ok(())
     }
 
-    pub fn de_initialize_mf() -> Result<(), BindingError> {
+    pub fn de_initialize_mf() -> Result<(), NokhwaError> {
         if INITIALIZED.load(Ordering::SeqCst) {
             unsafe {
                 if let Err(why) = MFShutdown() {
-                    return Err(BindingError::DeInitializeError(why.to_string()));
+                    return Err(NokhwaError::ShutdownError {
+                        backend: ApiBackend::MediaFoundation,
+                        error: why.to_string(),
+                    });
                 }
                 CoUninitialize();
                 INITIALIZED.store(false, Ordering::SeqCst);
@@ -470,12 +203,15 @@ pub mod wmf {
         Ok(())
     }
 
-    fn query_activate_pointers() -> Result<Vec<IMFActivate>, BindingError> {
+    fn query_activate_pointers() -> Result<Vec<IMFActivate>, NokhwaError> {
         initialize_mf()?;
 
         let mut attributes: Option<IMFAttributes> = None;
         if let Err(why) = unsafe { MFCreateAttributes(&mut attributes, 1) } {
-            return Err(BindingError::AttributeError(why.to_string()));
+            return Err(NokhwaError::GetPropertyError {
+                property: "IMFAttributes".to_string(),
+                error: why.to_string(),
+            });
         }
 
         let attributes = match attributes {
@@ -486,24 +222,34 @@ pub mod wmf {
                         &MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID,
                     )
                 } {
-                    return Err(BindingError::AttributeError(why.to_string()));
+                    return Err(NokhwaError::SetPropertyError {
+                        property: "GUID MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE".to_string(),
+                        value: "MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID".to_string(),
+                        error: why.to_string(),
+                    });
                 }
                 attr
             }
             None => {
-                return Err(BindingError::AttributeError(
-                    "Attributes is null!".to_string(),
-                ));
+                return Err(NokhwaError::SetPropertyError {
+                    property: "GUID MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE".to_string(),
+                    value: "MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID".to_string(),
+                    error: "Call to IMFAttributes::SetGUID failed - IMFAttributes is None"
+                        .to_string(),
+                });
             }
         };
 
         let mut count: u32 = 0;
-        let mut unused_mf_activate: MaybeUninit<*mut Option<IMFActivate>> = MaybeUninit::uninit(); // WTF?
+        let mut unused_mf_activate: MaybeUninit<*mut Option<IMFActivate>> = MaybeUninit::uninit();
 
         if let Err(why) =
-            unsafe { MFEnumDeviceSources(attributes, unused_mf_activate.as_mut_ptr(), &mut count) }
+            unsafe { MFEnumDeviceSources(&attributes, unused_mf_activate.as_mut_ptr(), &mut count) }
         {
-            return Err(BindingError::EnumerateError(why.to_string()));
+            return Err(NokhwaError::StructureError {
+                structure: "MFEnumDeviceSources".to_string(),
+                error: why.to_string(),
+            });
         }
 
         let mut device_list = vec![];
@@ -520,202 +266,295 @@ pub mod wmf {
     }
 
     fn activate_to_descriptors(
-        index: usize,
+        index: CameraIndex,
         imf_activate: &IMFActivate,
-    ) -> Result<MediaFoundationDeviceDescriptor<'static>, BindingError> {
-        let mut name: PWSTR = PWSTR(&mut 0_u16);
-        let mut len_name = 0;
-        let mut symlink: PWSTR = PWSTR(&mut 0_u16);
-        let mut len_symlink = 0;
+    ) -> Result<CameraInfo, NokhwaError> {
+        let mut pwstr_name = PWSTR(&mut 0_u16);
+        let mut _len_pwstrname = 0;
+        let mut pwstr_symlink = PWSTR(&mut 0_u16);
+        let mut _len_pwstrsymlink = 0;
 
         if let Err(why) = unsafe {
             imf_activate.GetAllocatedString(
                 &MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME,
-                &mut name,
-                &mut len_name,
+                &mut pwstr_name,
+                &mut _len_pwstrname,
             )
         } {
-            return Err(BindingError::GUIDReadError(
-                "MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME".to_string(),
-                why.to_string(),
-            ));
+            return Err(NokhwaError::GetPropertyError {
+                property: "MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME".to_string(),
+                error: why.to_string(),
+            });
         }
 
         if let Err(why) = unsafe {
             imf_activate.GetAllocatedString(
                 &MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
-                &mut symlink,
-                &mut len_symlink,
+                &mut pwstr_symlink,
+                &mut _len_pwstrsymlink,
             )
         } {
-            return Err(BindingError::GUIDReadError(
-                "MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK".to_string(),
-                why.to_string(),
-            ));
+            return Err(NokhwaError::GetPropertyError {
+                property: "MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK".to_string(),
+                error: why.to_string(),
+            });
         }
 
-        unsafe {
-            MediaFoundationDeviceDescriptor::new(index, name.0, symlink.0, len_name, len_symlink)
+        if pwstr_name.is_null() {
+            return Err(NokhwaError::GetPropertyError {
+                property: "MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME".to_string(),
+                error: "Call to IMFActivate::GetAllocatedString failed - PWSTR is null".to_string(),
+            });
         }
+        if pwstr_symlink.is_null() {
+            return Err(NokhwaError::GetPropertyError {
+                property: "MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK".to_string(),
+                error: "Call to IMFActivate::GetAllocatedString failed - PWSTR is null".to_string(),
+            });
+        }
+
+        let name = unsafe {
+            pwstr_name
+                .to_string()
+                .map_err(|x| NokhwaError::StructureError {
+                    structure: "PWSTR/String - Name".to_string(),
+                    error: x.to_string(),
+                })?
+        };
+        let symlink = unsafe {
+            pwstr_symlink
+                .to_string()
+                .map_err(|x| NokhwaError::StructureError {
+                    structure: "PWSTR/String - Symlink".to_string(),
+                    error: x.to_string(),
+                })?
+        };
+
+        Ok(CameraInfo::new(
+            &name,
+            "MediaFoundation Camera",
+            &symlink,
+            index,
+        ))
     }
 
-    pub fn query_media_foundation_descriptors(
-    ) -> Result<Vec<MediaFoundationDeviceDescriptor<'static>>, BindingError> {
+    pub fn query_media_foundation_descriptors() -> Result<Vec<CameraInfo>, NokhwaError> {
         let mut device_list = vec![];
 
         for (index, activate_ptr) in query_activate_pointers()?.into_iter().enumerate() {
-            device_list.push(activate_to_descriptors(index, &activate_ptr)?);
+            device_list.push(activate_to_descriptors(
+                CameraIndex::Index(index as u32),
+                &activate_ptr,
+            )?);
         }
         Ok(device_list)
     }
 
+    #[derive(Copy, Clone, Debug, PartialOrd, PartialEq, Eq)]
+    enum MFControlId {
+        ProcAmpBoolean(i32),
+        ProcAmpRange(i32),
+        CCValue(i32),
+        CCRange(i32),
+    }
+
+    pub fn kcc_to_i32(kcc: KnownCameraControl) -> Option<MFControlId> {
+        let control_id = match kcc {
+            KnownCameraControl::Brightness => MFControlId::ProcAmpRange(VideoProcAmp_Brightness.0),
+            KnownCameraControl::Contrast => MFControlId::ProcAmpRange(VideoProcAmp_Contrast.0),
+            KnownCameraControl::Hue => MFControlId::ProcAmpRange(VideoProcAmp_Hue.0),
+            KnownCameraControl::Saturation => MFControlId::ProcAmpRange(VideoProcAmp_Saturation.0),
+            KnownCameraControl::Sharpness => MFControlId::ProcAmpRange(VideoProcAmp_Sharpness.0),
+            KnownCameraControl::Gamma => MFControlId::ProcAmpRange(VideoProcAmp_Gamma.0),
+            KnownCameraControl::WhiteBalance => {
+                MFControlId::ProcAmpRange(VideoProcAmp_WhiteBalance.0)
+            }
+            KnownCameraControl::BacklightComp => {
+                MFControlId::ProcAmpBoolean(VideoProcAmp_BacklightCompensation.0)
+            }
+            KnownCameraControl::Gain => MFControlId::ProcAmpRange(VideoProcAmp_Gain.0),
+            KnownCameraControl::Pan => MFControlId::CCRange(CameraControl_Pan.0),
+            KnownCameraControl::Tilt => MFControlId::CCRange(CameraControl_Tilt.0),
+            KnownCameraControl::Zoom => MFControlId::CCRange(CameraControl_Zoom.0),
+            KnownCameraControl::Exposure => MFControlId::CCValue(CameraControl_Exposure.0),
+            KnownCameraControl::Iris => MFControlId::CCValue(CameraControl_Iris.0),
+            KnownCameraControl::Focus => MFControlId::CCValue(CameraControl_Focus.0),
+            KnownCameraControl::Other(o) => {
+                if o == VideoProcAmp_ColorEnable as u128 {
+                    MFControlId::ProcAmpRange(o as i32)
+                } else {
+                    return None;
+                }
+            }
+        };
+
+        Some(control_id)
+    }
+
     pub struct MediaFoundationDevice<'a> {
         is_open: Cell<bool>,
-        device_specifier: MediaFoundationDeviceDescriptor<'a>,
-        device_format: MFCameraFormat,
+        device_specifier: CameraInfo,
+        device_format: CameraFormat,
         source_reader: IMFSourceReader,
     }
 
     impl<'a> MediaFoundationDevice<'a> {
-        fn internal(index: usize) -> Result<Self, BindingError> {
-            let (media_source, device_descriptor) = match query_activate_pointers()?
-                .into_iter()
-                .nth(index)
-            {
-                Some(activate) => match unsafe { activate.ActivateObject::<IMFMediaSource>() } {
-                    Ok(media_source) => (media_source, activate_to_descriptors(index, &activate)?),
-                    Err(why) => {
-                        return Err(BindingError::DeviceOpenFailError(
-                            index.to_string(),
-                            why.to_string(),
-                        ))
-                    }
-                },
-                None => {
-                    return Err(BindingError::DeviceOpenFailError(
-                        index.to_string(),
-                        "Not Found".to_string(),
-                    ))
+        pub fn new(index: CameraIndex) -> Result<Self, NokhwaError> {
+            match index {
+                CameraIndex::Index(i) => {
+                    let (media_source, device_descriptor) =
+                        match query_activate_pointers()?.into_iter().nth(i as usize) {
+                            Some(activate) => {
+                                match unsafe { activate.ActivateObject::<IMFMediaSource>() } {
+                                    Ok(media_source) => {
+                                        (media_source, activate_to_descriptors(index, &activate)?)
+                                    }
+                                    Err(why) => {
+                                        return Err(NokhwaError::OpenDeviceError(
+                                            index.to_string(),
+                                            why.to_string(),
+                                        ))
+                                    }
+                                }
+                            }
+                            None => {
+                                return Err(NokhwaError::OpenDeviceError(
+                                    index.to_string(),
+                                    "No device".to_string(),
+                                ))
+                            }
+                        };
+
+                    let source_reader_attr = {
+                        let attr = match {
+                            let mut attr: Option<IMFAttributes> = None;
+
+                            if let Err(why) = unsafe { MFCreateAttributes(&mut attr, 3) } {
+                                return Err(NokhwaError::StructureError {
+                                    structure: "MFCreateAttributes".to_string(),
+                                    error: why.to_string(),
+                                });
+                            }
+                            attr
+                        } {
+                            Some(imf_attr) => imf_attr,
+                            None => {
+                                return Err(NokhwaError::StructureError {
+                                    structure: "MFCreateAttributes".to_string(),
+                                    error: "Attributee Alloc Failure".to_string(),
+                                });
+                            }
+                        };
+
+                        if let Err(why) = unsafe {
+                            attr.SetUINT32(&MF_READWRITE_DISABLE_CONVERTERS, u32::from(true))
+                        } {
+                            return Err(NokhwaError::SetPropertyError {
+                                property: "MF_READWRITE_DISABLE_CONVERTERS".to_string(),
+                                value: u32::from(true).to_string(),
+                                error: why.to_string(),
+                            });
+                        }
+
+                        attr
+                    };
+
+                    let source_reader = match unsafe {
+                        MFCreateSourceReaderFromMediaSource(&media_source, &source_reader_attr)
+                    } {
+                        Ok(sr) => sr,
+                        Err(why) => {
+                            return Err(NokhwaError::StructureError {
+                                structure: "MFCreateSourceReaderFromMediaSource".to_string(),
+                                error: why.to_string(),
+                            })
+                        }
+                    };
+
+                    // increment refcnt
+                    CAMERA_REFCNT.store(CAMERA_REFCNT.load(Ordering::SeqCst) + 1, Ordering::SeqCst);
+
+                    Ok(MediaFoundationDevice {
+                        is_open: Cell::new(false),
+                        device_specifier: device_descriptor,
+                        device_format: MFCameraFormat::default(),
+                        source_reader,
+                    })
                 }
-            };
+                CameraIndex::String(s) => {
+                    let devicelist = query_media_foundation_descriptors()?;
+                    let mut id_eq = None;
 
-            let source_reader_attr: Option<IMFAttributes> = {
-                let attr = match {
-                    let mut attr: Option<IMFAttributes> = None;
-
-                    if let Err(why) = unsafe { MFCreateAttributes(&mut attr, 3) } {
-                        return Err(BindingError::AttributeError(why.to_string()));
+                    for mfdev in devicelist {
+                        if mfdev.misc() == s {
+                            id_eq = Some(mfdev.index().as_index()?);
+                            break;
+                        }
                     }
 
-                    attr
-                } {
-                    Some(imf_attr) => imf_attr,
-                    None => {
-                        return Err(BindingError::AttributeError(
-                            "Attribute Alloc Fail".to_string(),
-                        ))
+                    match id_eq {
+                        Some(index) => Self::new(CameraIndex::Index(index)),
+                        None => {
+                            return Err(NokhwaError::OpenDeviceError(s, "Not Found".to_string()))
+                        }
                     }
-                };
-
-                if let Err(why) =
-                    unsafe { attr.SetUINT32(&MF_READWRITE_DISABLE_CONVERTERS, true as u32) }
-                {
-                    return Err(BindingError::AttributeError(why.to_string()));
-                }
-
-                Some(attr)
-            };
-
-            let source_reader = match unsafe {
-                MFCreateSourceReaderFromMediaSource(&media_source, source_reader_attr)
-            } {
-                Ok(sr) => sr,
-                Err(why) => {
-                    return Err(BindingError::DeviceOpenFailError(
-                        index.to_string(),
-                        why.to_string(),
-                    ))
-                }
-            };
-
-            // increment refcnt
-            CAMERA_REFCNT.store(CAMERA_REFCNT.load(Ordering::SeqCst) + 1, Ordering::SeqCst);
-
-            Ok(MediaFoundationDevice {
-                is_open: Cell::new(false),
-                device_specifier: device_descriptor,
-                device_format: MFCameraFormat::default(),
-                source_reader,
-            })
-        }
-
-        pub fn new(index: usize, format: MFCameraFormat) -> Result<Self, BindingError> {
-            let mut camera = MediaFoundationDevice::internal(index)?;
-            camera.set_format(format)?;
-            Ok(camera)
-        }
-
-        pub fn with_string(unique_id: &[u16]) -> Result<Self, BindingError> {
-            let device_list = query_media_foundation_descriptors()?;
-            let mut id_eq = None;
-
-            for media_foundation_device in device_list {
-                if (media_foundation_device.symlink() as &[u16]) == unique_id {
-                    id_eq = Some(media_foundation_device.index);
-                    break;
-                }
-            }
-
-            match id_eq {
-                Some(index) => Self::internal(index),
-                None => {
-                    return Err(BindingError::DeviceOpenFailError(
-                        std::str::from_utf8(
-                            &unique_id.iter().map(|x| *x as u8).collect::<Vec<u8>>(),
-                        )
-                        .unwrap_or("")
-                        .to_string(),
-                        "Not Found".to_string(),
-                    ))
                 }
             }
         }
+        //
+        // pub fn with_string(unique_id: &[u16]) -> Result<Self, NokhwaError> {
+        //     let devicelist = query_media_foundation_descriptors()?;
+        //     let mut id_eq = None;
+        //
+        //     for mfdev in devicelist {
+        //         if (mfdev.symlink() as &[u16]) == unique_id {
+        //             id_eq = Some(mfdev.index().as_index()?);
+        //             break;
+        //         }
+        //     }
+        //
+        //     match id_eq {
+        //         Some(index) => Self::new(index),
+        //         None => {
+        //             return Err(BindingError::DeviceOpenFailError(
+        //                 std::str::from_utf8(
+        //                     &unique_id.iter().map(|x| *x as u8).collect::<Vec<u8>>(),
+        //                 )
+        //                 .unwrap_or("")
+        //                 .to_string(),
+        //                 "Not Found".to_string(),
+        //             ))
+        //         }
+        //     }
+        // }
 
-        pub fn index(&self) -> usize {
-            self.device_specifier.index
+        pub fn index(&self) -> &CameraIndex {
+            self.device_specifier.index()
         }
 
         pub fn name(&self) -> String {
-            self.device_specifier.name_as_string()
+            self.device_specifier.human_name()
         }
 
         pub fn symlink(&self) -> String {
-            self.device_specifier.link_as_string()
+            self.device_specifier.misc()
         }
 
-        fn internal_format_list(
-            &mut self,
-        ) -> Result<HashMap<MFCameraFormat, IMFMediaType>, BindingError> {
-            let mut camera_format_map = HashMap::new();
+        pub fn compatible_format_list(&mut self) -> Result<Vec<CameraFormat>, NokhwaError> {
+            let mut camera_format_list = vec![];
             let mut index = 0;
 
             while let Ok(media_type) = unsafe {
                 self.source_reader
                     .GetNativeMediaType(MEDIA_FOUNDATION_FIRST_VIDEO_STREAM, index)
             } {
-                index += 1;
-
                 let fourcc = match unsafe { media_type.GetGUID(&MF_MT_SUBTYPE) } {
-                    Ok(fcc) => match fcc {
-                        MF_VIDEO_FORMAT_YUY2 => MFFrameFormat::YUYV,
-                        MF_VIDEO_FORMAT_MJPEG => MFFrameFormat::MJPEG,
-                        _ => continue,
-                    },
+                    Ok(fcc) => fcc,
                     Err(why) => {
-                        return Err(BindingError::GUIDReadError(
-                            "MF_MT_SUBTYPE".to_string(),
-                            why.to_string(),
-                        ))
+                        return Err(NokhwaError::GetPropertyError {
+                            property: "MF_MT_SUBTYPE".to_string(),
+                            error: why.to_string(),
+                        })
                     }
                 };
 
@@ -726,10 +565,10 @@ pub mod wmf {
                         (width, height)
                     }
                     Err(why) => {
-                        return Err(BindingError::GUIDReadError(
-                            "MF_MT_FRAME_SIZE".to_string(),
-                            why.to_string(),
-                        ))
+                        return Err(NokhwaError::GetPropertyError {
+                            property: "MF_MT_FRAME_SIZE".to_string(),
+                            error: why.to_string(),
+                        })
                     }
                 };
 
@@ -745,10 +584,10 @@ pub mod wmf {
                             numerator
                         }
                         Err(why) => {
-                            return Err(BindingError::GUIDReadError(
-                                "MF_MT_FRAME_RATE_RANGE_MAX".to_string(),
-                                why.to_string(),
-                            ))
+                            return Err(NokhwaError::GetPropertyError {
+                                property: "MF_MT_FRAME_RATE_RANGE_MAX".to_string(),
+                                error: why.to_string(),
+                            })
                         }
                     };
 
@@ -762,10 +601,10 @@ pub mod wmf {
                         numerator
                     }
                     Err(why) => {
-                        return Err(BindingError::GUIDReadError(
-                            "MF_MT_FRAME_RATE".to_string(),
-                            why.to_string(),
-                        ))
+                        return Err(NokhwaError::GetPropertyError {
+                            property: "MF_MT_FRAME_RATE".to_string(),
+                            error: why.to_string(),
+                        })
                     }
                 };
 
@@ -780,70 +619,53 @@ pub mod wmf {
                             numerator
                         }
                         Err(why) => {
-                            return Err(BindingError::GUIDReadError(
-                                "MF_MT_FRAME_RATE_RANGE_MIN".to_string(),
-                                why.to_string(),
-                            ))
+                            return Err(NokhwaError::GetPropertyError {
+                                property: "MF_MT_FRAME_RATE_RANGE_MIN".to_string(),
+                                error: why.to_string(),
+                            })
                         }
                     };
 
+                let frame_fmt = if fourcc == MF_VIDEO_FORMAT_MJPEG {
+                    FrameFormat::MJPEG
+                } else if fourcc == MF_VIDEO_FORMAT_YUY2 {
+                    FrameFormat::YUYV
+                } else if fourcc == MF_VIDEO_FORMAT_GRAY {
+                    FrameFormat::GRAY
+                } else {
+                    continue;
+                };
+
                 if frame_rate_min != 0 {
-                    camera_format_map.insert(
-                        MFCameraFormat {
-                            resolution: MFResolution {
-                                width_x: width,
-                                height_y: height,
-                            },
-                            format: fourcc,
-                            frame_rate: frame_rate_min,
-                        },
-                        media_type.clone(),
-                    );
+                    camera_format_list.push(CameraFormat::new(
+                        Resolution::new(width, height),
+                        frame_fmt,
+                        frame_rate_min,
+                    ));
                 }
 
-                if frame_rate != frame_rate_min && frame_rate != 0 {
-                    camera_format_map.insert(
-                        MFCameraFormat {
-                            resolution: MFResolution {
-                                width_x: width,
-                                height_y: height,
-                            },
-                            format: fourcc,
-                            frame_rate,
-                        },
-                        media_type.clone(),
-                    );
+                if frame_rate != 0 && frame_rate_min != frame_rate {
+                    camera_format_list.push(CameraFormat::new(
+                        Resolution::new(width, height),
+                        frame_fmt,
+                        frame_rate,
+                    ));
                 }
 
-                if frame_rate_max != frame_rate
-                    && frame_rate_max != frame_rate_min
-                    && frame_rate_max != 0
-                {
-                    camera_format_map.insert(
-                        MFCameraFormat {
-                            resolution: MFResolution {
-                                width_x: width,
-                                height_y: height,
-                            },
-                            format: fourcc,
-                            frame_rate: frame_rate_max,
-                        },
-                        media_type.clone(),
-                    );
+                if frame_rate_max != 0 && frame_rate != frame_rate_max {
+                    camera_format_list.push(CameraFormat::new(
+                        Resolution::new(width, height),
+                        frame_fmt,
+                        frame_rate_max,
+                    ));
                 }
+
+                index += 1;
             }
-            Ok(camera_format_map)
+            Ok(camera_format_list)
         }
 
-        pub fn compatible_format_list(&mut self) -> Result<Vec<MFCameraFormat>, BindingError> {
-            Ok(self
-                .internal_format_list()?
-                .into_keys()
-                .into_iter()
-                .collect())
-        }
-
-        pub fn control(&self, control: MediaFoundationControls) -> Result<MFControl, BindingError> {
+        pub fn control(&self, control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
             let camera_control = unsafe {
                 let mut receiver: MaybeUninit<IAMCameraControl> = MaybeUninit::uninit();
                 let ptr_receiver = receiver.as_mut_ptr();
@@ -886,463 +708,148 @@ pub mod wmf {
             let mut value = 0;
             let mut flag = 0;
 
-            match control {
-                MediaFoundationControls::Brightness => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_Brightness.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Brightness-Range".to_string(),
-                            why.to_string(),
-                        ));
+            let control_id = kcc_to_i32(control).ok_or(NokhwaError::SetPropertyError {
+                property: "CameraControl".to_string(),
+                value: control.to_string(),
+                error: "Does not exist".to_string(),
+            })?;
+
+            let ctrl_value_set = match control_id {
+                MFControlId::ProcAmpBoolean(id) => unsafe {
+                    if let Err(why) = video_proc_amp.GetRange(
+                        id,
+                        &mut min,
+                        &mut max,
+                        &mut step,
+                        &mut default,
+                        &mut flag,
+                    ) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Range", control_id, control),
+                            error: why.to_string(),
+                        });
+                    }
+                    if let Err(why) = video_proc_amp.Get(id, &mut value, &mut flag) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Value", control_id, control),
+                            error: why.to_string(),
+                        });
                     }
 
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Get(VideoProcAmp_Brightness.0, &mut value, &mut flag)
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Brightness-Value".to_string(),
-                            why.to_string(),
-                        ));
+                    let boolval = value != 0;
+                    let booldef = default != 0;
+                    ControlValueDescription::Boolean {
+                        value: boolval,
+                        default: booldef,
                     }
-                }
-                MediaFoundationControls::Contrast => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_Contrast.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Contrast-Range".to_string(),
-                            why.to_string(),
-                        ));
+                },
+                MFControlId::ProcAmpRange(id) => unsafe {
+                    if let Err(why) = video_proc_amp.GetRange(
+                        id,
+                        &mut min,
+                        &mut max,
+                        &mut step,
+                        &mut default,
+                        &mut flag,
+                    ) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Range", control_id, control),
+                            error: why.to_string(),
+                        });
+                    }
+                    if let Err(why) = video_proc_amp.Get(id, &mut value, &mut flag) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Value", control_id, control),
+                            error: why.to_string(),
+                        });
+                    }
+                    ControlValueDescription::IntegerRange {
+                        min: min as i64,
+                        max: max as i64,
+                        value: value as i64,
+                        step: step as i64,
+                        default: default as i64,
+                    }
+                },
+                MFControlId::CCValue(id) => unsafe {
+                    if let Err(why) = camera_control.GetRange(
+                        id,
+                        &mut min,
+                        &mut max,
+                        &mut step,
+                        &mut default,
+                        &mut flag,
+                    ) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Range", control_id, control),
+                            error: why.to_string(),
+                        });
+                    }
+                    if let Err(why) = camera_control.Get(id, &mut value, &mut flag) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Value", control_id, control),
+                            error: why.to_string(),
+                        });
                     }
 
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Get(VideoProcAmp_Contrast.0, &mut value, &mut flag)
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Contrast-Value".to_string(),
-                            why.to_string(),
-                        ));
+                    ControlValueDescription::Integer {
+                        value: value as i64,
+                        default: default as i64,
+                        step: step as i64,
                     }
-                }
-                MediaFoundationControls::Hue => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_Hue.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Hue-Range".to_string(),
-                            why.to_string(),
-                        ));
+                },
+                MFControlId::CCRange(id) => unsafe {
+                    if let Err(why) = camera_control.GetRange(
+                        id,
+                        &mut min,
+                        &mut max,
+                        &mut step,
+                        &mut default,
+                        &mut flag,
+                    ) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Range", control_id, control),
+                            error: why.to_string(),
+                        });
                     }
+                    if let Err(why) = camera_control.Get(id, &mut value, &mut flag) {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: format!("{:?}: {} - Value", control_id, control),
+                            error: why.to_string(),
+                        });
+                    }
+                    ControlValueDescription::IntegerRange {
+                        min: min as i64,
+                        max: max as i64,
+                        value: value as i64,
+                        step: step as i64,
+                        default: default as i64,
+                    }
+                },
+            };
 
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Get(VideoProcAmp_Hue.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Hue-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Saturation => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_Saturation.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Saturation-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
+            let is_manual = if matches!(flag, CameraControl_Flags_Manual) {
+                KnownCameraControlFlag::Manual
+            } else {
+                KnownCameraControlFlag::Automatic
+            };
 
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Get(VideoProcAmp_Saturation.0, &mut value, &mut flag)
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Saturation-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Sharpness => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_Sharpness.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Sharpness-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Get(VideoProcAmp_Sharpness.0, &mut value, &mut flag)
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Sharpness-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Gamma => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_Gamma.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Gamma-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Get(VideoProcAmp_Gamma.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Gamma-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::ColorEnable => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_ColorEnable.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_ColorEnable-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Get(VideoProcAmp_ColorEnable.0, &mut value, &mut flag)
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_ColorEnable-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::WhiteBalance => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_WhiteBalance.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_WhiteBalance-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Get(VideoProcAmp_WhiteBalance.0, &mut value, &mut flag)
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_WhiteBalance-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::BacklightComp => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_BacklightCompensation.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_BacklightCompensation-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Get(
-                            VideoProcAmp_BacklightCompensation.0,
-                            &mut value,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_BacklightCompensation-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Gain => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.GetRange(
-                            VideoProcAmp_Gain.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Gain-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Get(VideoProcAmp_Gain.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "VideoProcAmp_Gain-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Pan => {
-                    if let Err(why) = unsafe {
-                        camera_control.GetRange(
-                            CameraControl_Pan.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Pan-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { camera_control.Get(CameraControl_Pan.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Pan-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Tilt => {
-                    if let Err(why) = unsafe {
-                        camera_control.GetRange(
-                            CameraControl_Tilt.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Tilt-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { camera_control.Get(CameraControl_Tilt.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Tilt-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Roll => {
-                    if let Err(why) = unsafe {
-                        camera_control.GetRange(
-                            CameraControl_Roll.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Roll-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { camera_control.Get(CameraControl_Roll.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Roll-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Zoom => {
-                    if let Err(why) = unsafe {
-                        camera_control.GetRange(
-                            CameraControl_Zoom.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Zoom-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { camera_control.Get(CameraControl_Zoom.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Zoom-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Exposure => {
-                    if let Err(why) = unsafe {
-                        camera_control.GetRange(
-                            CameraControl_Exposure.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Exposure-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) = unsafe {
-                        camera_control.Get(CameraControl_Exposure.0, &mut value, &mut flag)
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Exposure-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Iris => {
-                    if let Err(why) = unsafe {
-                        camera_control.GetRange(
-                            CameraControl_Iris.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Iris-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { camera_control.Get(CameraControl_Iris.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Iris-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Focus => {
-                    if let Err(why) = unsafe {
-                        camera_control.GetRange(
-                            CameraControl_Focus.0,
-                            &mut min,
-                            &mut max,
-                            &mut step,
-                            &mut default,
-                            &mut flag,
-                        )
-                    } {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Focus-Range".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-
-                    if let Err(why) =
-                        unsafe { camera_control.Get(CameraControl_Focus.0, &mut value, &mut flag) }
-                    {
-                        return Err(BindingError::GUIDReadError(
-                            "CameraControl_Focus-Value".to_string(),
-                            why.to_string(),
-                        ));
-                    }
-                }
-            }
-
-            let is_manual = matches!(flag, CAM_CTRL_MANUAL);
-
-            Ok(MFControl::new(
-                control, min, max, step, value, default, is_manual, true,
+            Ok(CameraControl::new(
+                control,
+                control.to_string(),
+                ctrl_value_set,
+                vec![is_manual],
+                true,
             ))
         }
 
-        pub fn set_control(&mut self, control: MFControl) -> Result<(), BindingError> {
+        pub fn set_control(
+            &mut self,
+            control: KnownCameraControl,
+            value: ControlValueSetter,
+        ) -> Result<(), NokhwaError> {
+            let current_value = self.control(control)?;
+
             let camera_control = unsafe {
                 let mut receiver: MaybeUninit<IAMCameraControl> = MaybeUninit::uninit();
                 let ptr_receiver = receiver.as_mut_ptr();
@@ -1374,350 +881,242 @@ pub mod wmf {
                         "IAMVideoProcAmp".to_string(),
                         why.to_string(),
                     ));
+
+            let control_id = kcc_to_i32(control).ok_or(NokhwaError::SetPropertyError {
+                property: "CameraControl".to_string(),
+                value: control.to_string(),
+                error: "Does not exist".to_string(),
+            })?;
+
+            let ctrl_value = match value {
+                ControlValueSetter::Integer(i) => i as i32,
+                ControlValueSetter::Boolean(b) => b as i32,
+                v => {
+                    return Err(NokhwaError::StructureError {
+                        structure: format!("ControlValueSetter {}", v),
+                        error: "invalid value type".to_string(),
+                    })
                 }
                 receiver.assume_init()
             };
 
-            let value = control.current;
-            let flags = if control.manual {
-                CAM_CTRL_MANUAL
-            } else {
-                CAM_CTRL_AUTO
-            };
-            let flag_str = if control.manual {
-                "CAM_CTRL_MANUAL"
-            } else {
-                "CAM_CTRL_AUTO"
-            };
+            let flag = current_value
+                .flag()
+                .get(0)
+                .map(|x| {
+                    if x == KnownCameraControlFlag::Automatic {
+                        CameraControl_Flags_Auto
+                    } else {
+                        CameraControl_Flags_Manual
+                    }
+                })
+                .ok_or(NokhwaError::StructureError {
+                    structure: "KnownCameraControlFlag".to_string(),
+                    error: "could not cast to i32".to_string(),
+                })?;
 
-            match control.control {
-                MediaFoundationControls::Brightness => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_Brightness.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_Brightness".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
+            match control_id {
+                MFControlId::ProcAmpBoolean(id) | MFControlId::ProcAmpRange(id) => unsafe {
+                    if let Err(why) = video_proc_amp.Set(id, ctrl_value, flag.0) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: control.to_string(),
+                            value: ctrl_value.to_string(),
+                            error: why.to_string(),
+                        });
                     }
-                }
-                MediaFoundationControls::Contrast => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_Contrast.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_Contrast".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
+                },
+                MFControlId::CCValue(id) | MFControlId::CCRange(id) => unsafe {
+                    if let Err(why) = camera_control.Set(id, ctrl_value, flag.0) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: control.to_string(),
+                            value: ctrl_value.to_string(),
+                            error: why.to_string(),
+                        });
                     }
-                }
-                MediaFoundationControls::Hue => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_Hue.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_Hue".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Saturation => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_Saturation.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_Saturation".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Sharpness => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_Sharpness.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_Sharpness".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Gamma => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_Gamma.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_Gamma".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::ColorEnable => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_ColorEnable.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_ColorEnable".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::WhiteBalance => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_WhiteBalance.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_WhiteBalance".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::BacklightComp => {
-                    if let Err(why) = unsafe {
-                        video_proc_amp.Set(VideoProcAmp_BacklightCompensation.0, value, flags)
-                    } {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_BacklightCompensation".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Gain => {
-                    if let Err(why) =
-                        unsafe { video_proc_amp.Set(VideoProcAmp_Gain.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "VideoProcAmp_Gain".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Pan => {
-                    if let Err(why) =
-                        unsafe { camera_control.Set(CameraControl_Pan.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "CameraControl_Pan".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Tilt => {
-                    if let Err(why) =
-                        unsafe { camera_control.Set(CameraControl_Tilt.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "CameraControl_Tilt".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Roll => {
-                    if let Err(why) =
-                        unsafe { camera_control.Set(CameraControl_Roll.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "CameraControl_Roll".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Zoom => {
-                    if let Err(why) =
-                        unsafe { camera_control.Set(CameraControl_Zoom.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "CameraControl_Zoom".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Exposure => {
-                    if let Err(why) =
-                        unsafe { camera_control.Set(CameraControl_Exposure.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "CameraControl_Exposure".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Iris => {
-                    if let Err(why) =
-                        unsafe { camera_control.Set(CameraControl_Iris.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "CameraControl_Iris".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
-                MediaFoundationControls::Focus => {
-                    if let Err(why) =
-                        unsafe { camera_control.Set(CameraControl_Focus.0, value, flags) }
-                    {
-                        return Err(BindingError::GUIDSetError(
-                            "CameraControl_Focus".to_string(),
-                            format!("{} {}", value, flag_str),
-                            why.to_string(),
-                        ));
-                    }
-                }
+                },
             }
 
             Ok(())
         }
 
-        pub fn format(&self) -> MFCameraFormat {
+        pub fn format_refreshed(&mut self) -> Result<CameraFormat, NokhwaError> {
+            match unsafe {
+                self.source_reader
+                    .GetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM.0 as u32)
+            } {
+                Ok(media_type) => {
+                    let resolution = match unsafe { media_type.GetUINT64(&MF_MT_FRAME_SIZE) } {
+                        Ok(res) => {
+                            let width = (res >> 32) as u32;
+                            let height = ((res << 32) >> 32) as u32;
+
+                            Resolution {
+                                width_x: width,
+                                height_y: height,
+                            }
+                        }
+                        Err(why) => {
+                            return Err(NokhwaError::GetPropertyError {
+                                property: "MF_MT_FRAME_SIZE".to_string(),
+                                error: why.to_string(),
+                            })
+                        }
+                    };
+
+                    let frame_rate = match unsafe { media_type.GetUINT64(&MF_MT_FRAME_RATE) } {
+                        Ok(fps) => fps as u32,
+                        Err(why) => {
+                            return Err(NokhwaError::GetPropertyError {
+                                property: "MF_MT_FRAME_RATE".to_string(),
+                                error: why.to_string(),
+                            })
+                        }
+                    };
+
+                    let format = match unsafe { media_type.GetGUID(&MF_MT_SUBTYPE) } {
+                        Ok(fcc) => match fcc {
+                            MF_VIDEO_FORMAT_YUY2 => FrameFormat::YUYV,
+                            MF_VIDEO_FORMAT_GRAY => FrameFormat::GRAY,
+                            MF_VIDEO_FORMAT_MJPEG => FrameFormat::MJPEG,
+                            _ => {
+                                return Err(NokhwaError::GetPropertyError {
+                                    property: "MF_MT_SUBTYPE".to_string(),
+                                    error: why.to_string(),
+                                })
+                            }
+                        },
+                        Err(why) => {
+                            return Err(NokhwaError::GetPropertyError {
+                                property: "MF_MT_SUBTYPE".to_string(),
+                                error: why.to_string(),
+                            })
+                        }
+                    };
+
+                    let cfmt = CameraFormat::new(resolution, format, frame_rate);
+                    self.device_format = cfmt;
+
+                    Ok(cfmt)
+                }
+                Err(why) => Err(NokhwaError::GetPropertyError {
+                    property: "MF_SOURCE_READER_FIRST_VIDEO_STREAM".to_string(),
+                    error: why.to_string(),
+                }),
+            }
+        }
+
+        pub fn format(&self) -> CameraFormat {
             self.device_format
         }
 
-        pub fn set_format(&mut self, format: MFCameraFormat) -> Result<(), BindingError> {
-            let mut index = 0;
-
-            while let Ok(media_type) = unsafe {
-                self.source_reader
-                    .GetNativeMediaType(MEDIA_FOUNDATION_FIRST_VIDEO_STREAM, index)
-            } {
-                index += 1;
-
-                let fourcc = match unsafe { media_type.GetGUID(&MF_MT_SUBTYPE) } {
-                    Ok(fcc) => match fcc {
-                        MF_VIDEO_FORMAT_YUY2 => MFFrameFormat::YUYV,
-                        MF_VIDEO_FORMAT_MJPEG => MFFrameFormat::MJPEG,
-                        _ => continue,
-                    },
-                    Err(why) => {
-                        return Err(BindingError::GUIDReadError(
-                            "MF_MT_SUBTYPE".to_string(),
-                            why.to_string(),
-                        ))
-                    }
-                };
-
-                let (width, height) = match unsafe { media_type.GetUINT64(&MF_MT_FRAME_SIZE) } {
-                    Ok(res_u64) => {
-                        let width = (res_u64 >> 32) as u32;
-                        let height = res_u64 as u32; // the cast will truncate the upper bits
-                        (width, height)
-                    }
-                    Err(why) => {
-                        return Err(BindingError::GUIDReadError(
-                            "MF_MT_FRAME_SIZE".to_string(),
-                            why.to_string(),
-                        ))
-                    }
-                };
-
-                // MFRatio is represented as 2 u32s in memory. This means we cann convert it to 2
-                let frame_rate_max =
-                    match unsafe { media_type.GetUINT64(&MF_MT_FRAME_RATE_RANGE_MAX) } {
-                        Ok(fraction_u64) => {
-                            let mut numerator = (fraction_u64 >> 32) as u32;
-                            let denominator = fraction_u64 as u32;
-                            if denominator != 1 {
-                                numerator = 0;
-                            }
-                            numerator
-                        }
-                        Err(why) => {
-                            return Err(BindingError::GUIDReadError(
-                                "MF_MT_FRAME_RATE_RANGE_MAX".to_string(),
-                                why.to_string(),
-                            ))
-                        }
-                    };
-
-                let frame_rate = match unsafe { media_type.GetUINT64(&MF_MT_FRAME_RATE) } {
-                    Ok(fraction_u64) => {
-                        let mut numerator = (fraction_u64 >> 32) as u32;
-                        let denominator = fraction_u64 as u32;
-                        if denominator != 1 {
-                            numerator = 0;
-                        }
-                        numerator
-                    }
-                    Err(why) => {
-                        return Err(BindingError::GUIDReadError(
-                            "MF_MT_FRAME_RATE".to_string(),
-                            why.to_string(),
-                        ))
-                    }
-                };
-
-                let frame_rate_min =
-                    match unsafe { media_type.GetUINT64(&MF_MT_FRAME_RATE_RANGE_MIN) } {
-                        Ok(fraction_u64) => {
-                            let mut numerator = (fraction_u64 >> 32) as u32;
-                            let denominator = fraction_u64 as u32;
-                            if denominator != 1 {
-                                numerator = 0;
-                            }
-                            numerator
-                        }
-                        Err(why) => {
-                            return Err(BindingError::GUIDReadError(
-                                "MF_MT_FRAME_RATE_RANGE_MIN".to_string(),
-                                why.to_string(),
-                            ))
-                        }
-                    };
-
-                if format.width() == width
-                    && format.height() == height
-                    && [frame_rate_max, frame_rate, frame_rate_min].contains(&format.frame_rate)
-                    && format.format == fourcc
-                {
-                    return match unsafe {
-                        self.source_reader.SetCurrentMediaType(
-                            MEDIA_FOUNDATION_FIRST_VIDEO_STREAM,
-                            null_mut(),
-                            media_type,
-                        )
-                    } {
-                        Ok(_) => {
-                            self.device_format = format;
-                            Ok(())
-                        }
-                        Err(why) => Err(BindingError::AttributeError(why.to_string())),
-                    };
+        pub fn set_format(&mut self, format: CameraFormat) -> Result<(), NokhwaError> {
+            // convert to media_type
+            let media_type: IMFMediaType = match unsafe { MFCreateMediaType() } {
+                Ok(mt) => mt,
+                Err(why) => {
+                    return Err(NokhwaError::StructureError {
+                        structure: "IMFMediaType".to_string(),
+                        error: why.to_string(),
+                    })
                 }
+            };
+
+            // set relevant things
+            let resolution = (u64::from(format.resolution().width_x) << 32_u64)
+                + u64::from(format.resolution().height_y);
+            let fps = {
+                let frame_rate_u64 = 0_u64;
+                let mut bytes: [u8; 8] = frame_rate_u64.to_le_bytes();
+                bytes[7] = format.frame_rate() as u8;
+                bytes[3] = 0x01;
+                println!("{:?}", bytes);
+                u64::from_le_bytes(bytes)
+            };
+            let fourcc = match format.format() {
+                FrameFormat::MJPEG => MF_VIDEO_FORMAT_MJPEG,
+                FrameFormat::YUYV => MF_VIDEO_FORMAT_YUY2,
+                FrameFormat::GRAY => MF_VIDEO_FORMAT_GRAY,
+            };
+            // setting to the new media_type
+            if let Err(why) = unsafe { media_type.SetGUID(&MF_MT_MAJOR_TYPE, &MFMediaType_Video) } {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "MF_MT_MAJOR_TYPE".to_string(),
+                    value: "MFMediaType_Video".to_string(),
+                    error: why.to_string(),
+                });
             }
-            Err(BindingError::EnumerateError("Not Found".to_string()))
+            if let Err(why) = unsafe { media_type.SetGUID(&MF_MT_SUBTYPE, &fourcc) } {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "MF_MT_SUBTYPE".to_string(),
+                    value: fourcc.to_string(),
+                    error: why.to_string(),
+                });
+            }
+            if let Err(why) = unsafe { media_type.SetUINT64(&MF_MT_FRAME_SIZE, resolution) } {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "MF_MT_FRAME_SIZE".to_string(),
+                    value: resolution.to_string(),
+                    error: why.to_string(),
+                });
+            }
+            if let Err(why) = unsafe { media_type.SetUINT64(&MF_MT_FRAME_RATE, fps) } {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "MF_MT_FRAME_RATE".to_string(),
+                    value: fps.to_string(),
+                    error: why.to_string(),
+                });
+            }
+            if let Err(why) = unsafe { media_type.SetUINT64(&MF_MT_FRAME_RATE_RANGE_MIN, fps) } {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "MF_MT_FRAME_RATE_RANGE_MIN".to_string(),
+                    value: fps.to_string(),
+                    error: why.to_string(),
+                });
+            }
+            if let Err(why) = unsafe { media_type.SetUINT64(&MF_MT_FRAME_RATE_RANGE_MAX, fps) } {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "MF_MT_FRAME_RATE_RANGE_MAX".to_string(),
+                    value: fps.to_string(),
+                    error: why.to_string(),
+                });
+            }
+
+            let reserved = std::ptr::null_mut();
+            if let Err(why) = unsafe {
+                self.source_reader.SetCurrentMediaType(
+                    MEDIA_FOUNDATION_FIRST_VIDEO_STREAM,
+                    reserved,
+                    &media_type,
+                )
+            } {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "MEDIA_FOUNDATION_FIRST_VIDEO_STREAM".to_string(),
+                    value: format!("{media_type:?}"),
+                    error: why.to_string(),
+                });
+            }
+            self.device_format = format;
+            self.format_refreshed()?;
+            Ok(())
         }
 
         pub fn is_stream_open(&self) -> bool {
             self.is_open.get()
         }
 
-        pub fn start_stream(&mut self) -> Result<(), BindingError> {
+        pub fn start_stream(&mut self) -> Result<(), NokhwaError> {
             if let Err(why) = unsafe {
                 self.source_reader
                     .SetStreamSelection(MEDIA_FOUNDATION_FIRST_VIDEO_STREAM, true)
             } {
-                return Err(BindingError::ReadFrameError(why.to_string()));
+                return Err(NokhwaError::OpenStreamError(why.to_string()));
             }
 
             self.is_open.set(true);
             Ok(())
         }
 
-        pub fn raw_bytes(&mut self) -> Result<Cow<'a, [u8]>, BindingError> {
+        pub fn raw_bytes(&mut self) -> Result<Cow<'a, [u8]>, NokhwaError> {
             let mut flags: u32 = 0;
             let mut imf_sample: Option<IMFSample> = None;
 
@@ -1733,7 +1132,7 @@ pub mod wmf {
                             &mut imf_sample,
                         )
                     } {
-                        return Err(BindingError::ReadFrameError(why.to_string()));
+                        return Err(NokhwaError::ReadFrameError(why.to_string()));
                     }
 
                     if imf_sample.is_some() {
@@ -1746,13 +1145,13 @@ pub mod wmf {
                 Some(sample) => sample,
                 None => {
                     // shouldn't happen
-                    return Err(BindingError::ReadFrameError("why".to_string()));
+                    return Err(NokhwaError::ReadFrameError(why.to_string()));
                 }
             };
 
             let buffer = match unsafe { imf_sample.ConvertToContiguousBuffer() } {
                 Ok(buf) => buf,
-                Err(why) => return Err(BindingError::ReadFrameError(why.to_string())),
+                Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
             };
 
             let mut buffer_valid_length = 0;
@@ -1765,17 +1164,17 @@ pub mod wmf {
                     &mut buffer_valid_length,
                 )
             } {
-                return Err(BindingError::ReadFrameError(why.to_string()));
+                return Err(NokhwaError::ReadFrameError(why.to_string()));
             }
 
             if buffer_start_ptr.is_null() {
-                return Err(BindingError::ReadFrameError(
+                return Err(NokhwaError::ReadFrameError(
                     "Buffer Pointer Null".to_string(),
                 ));
             }
 
             if buffer_valid_length == 0 {
-                return Err(BindingError::ReadFrameError("No Data Size".to_string()));
+                return Err(NokhwaError::ReadFrameError("Buffer Size is 0".to_string()));
             }
 
             let mut data_slice = Vec::with_capacity(buffer_valid_length as usize);
@@ -1832,37 +1231,44 @@ pub mod wmf {
 #[allow(clippy::missing_errors_doc)]
 #[allow(clippy::unused_self)]
 pub mod wmf {
-    use crate::{
-        BindingError, MFCameraFormat, MFControl, MediaFoundationControls,
-        MediaFoundationDeviceDescriptor,
+    use nokhwa_core::error::NokhwaError;
+    use nokhwa_core::types::{
+        CameraControl, CameraFormat, CameraIndex, CameraInfo, ControlValueSetter,
+        KnownCameraControl,
     };
     use std::borrow::Cow;
 
-    pub fn initialize_mf() -> Result<(), BindingError> {
-        Err(BindingError::NotImplementedError)
+    pub fn initialize_mf() -> Result<(), NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not on windows".to_string(),
+        ))
     }
 
-    pub fn de_initialize_mf() -> Result<(), BindingError> {
-        Err(BindingError::NotImplementedError)
+    pub fn de_initialize_mf() -> Result<(), NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not on windows".to_string(),
+        ))
     }
 
-    pub fn query_msmf() -> Result<Vec<MediaFoundationDeviceDescriptor<'static>>, BindingError> {
-        Err(BindingError::NotImplementedError)
+    pub fn query_msmf() -> Result<Vec<CameraInfo>, NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not on windows".to_string(),
+        ))
     }
 
-    struct Empty();
+    struct Empty;
 
     pub struct MediaFoundationDevice<'a> {
         phantom: &'a Empty,
     }
 
     impl<'a> MediaFoundationDevice<'a> {
-        pub fn new(_: usize) -> Result<Self, BindingError> {
-            Ok(MediaFoundationDevice { phantom: &Empty() })
+        pub fn new(_index: CameraIndex) -> Result<Self, NokhwaError> {
+            Ok(MediaFoundationDevice { phantom: &Empty })
         }
 
-        pub fn index(&self) -> usize {
-            usize::MAX
+        pub fn index(&self) -> &CameraIndex {
+            &CameraIndex::default()
         }
 
         pub fn name(&self) -> String {
@@ -1873,44 +1279,61 @@ pub mod wmf {
             "".to_string()
         }
 
-        pub fn compatible_format_list(&mut self) -> Result<Vec<MFCameraFormat>, BindingError> {
-            Err(BindingError::NotImplementedError)
+        pub fn compatible_format_list(&mut self) -> Result<Vec<CameraFormat>, NokhwaError> {
+            Err(NokhwaError::NotImplementedError(
+                "Only on Windows".to_string(),
+            ))
         }
 
-        pub fn control(
-            &self,
-            _control: MediaFoundationControls,
-        ) -> Result<MFControl, BindingError> {
-            Err(BindingError::NotImplementedError)
+        pub fn control(&self, _control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
+            Err(NokhwaError::NotImplementedError(
+                "Only on Windows".to_string(),
+            ))
         }
 
-        pub fn set_control(&mut self, _control: MFControl) -> Result<(), BindingError> {
-            Err(BindingError::NotImplementedError)
+        pub fn set_control(
+            &mut self,
+            _control: KnownCameraControl,
+            _value: ControlValueSetter,
+        ) -> Result<(), NokhwaError> {
+            Err(NokhwaError::NotImplementedError(
+                "Only on Windows".to_string(),
+            ))
         }
 
-        pub fn format(&self) -> MFCameraFormat {
-            MFCameraFormat::default()
+        pub fn format_refreshed(&mut self) -> Result<CameraFormat, NokhwaError> {
+            Err(NokhwaError::NotImplementedError(
+                "Only on Windows".to_string(),
+            ))
         }
 
-        pub fn set_format(&mut self, _format: MFCameraFormat) -> Result<(), BindingError> {
-            Err(BindingError::NotImplementedError)
+        pub fn format(&self) -> CameraFormat {
+            CameraFormat::default()
+        }
+
+        pub fn set_format(&mut self, _format: CameraFormat) -> Result<(), NokhwaError> {
+            Err(NokhwaError::NotImplementedError(
+                "Only on Windows".to_string(),
+            ))
         }
 
         pub fn is_stream_open(&self) -> bool {
             false
         }
 
-        pub fn start_stream(&mut self) -> Result<(), BindingError> {
-            Err(BindingError::NotImplementedError)
+        pub fn start_stream(&mut self) -> Result<(), NokhwaError> {
+            Err(NokhwaError::NotImplementedError(
+                "Only on Windows".to_string(),
+            ))
         }
 
-        pub fn raw_bytes(&mut self) -> Result<Cow<[u8]>, BindingError> {
-            Err(BindingError::NotImplementedError)
+        pub fn raw_bytes(&mut self) -> Result<Cow<'a, [u8]>, NokhwaError> {
+            Err(NokhwaError::NotImplementedError(
+                "Only on Windows".to_string(),
+            ))
         }
 
-        pub fn stop_stream(&mut self) {
-            self.phantom = &Empty();
-        }
+        pub fn stop_stream(&mut self) {}
     }
 
     impl<'a> Drop for MediaFoundationDevice<'a> {
diff --git a/nokhwa-core/Cargo.toml b/nokhwa-core/Cargo.toml
new file mode 100644
index 0000000..0ea8b7a
--- /dev/null
+++ b/nokhwa-core/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "nokhwa-core"
+version = "0.1.0"
+authors = ["l1npengtul <l1npengtul@protonmail.com>"]
+edition = "2021"
+description = "Core type definitions for nokhwa"
+keywords = ["camera", "webcam", "capture", "cross-platform"]
+license = "Apache-2.0"
+repository = "https://github.com/l1npengtul/nokhwa"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = []
+serialize = ["serde"]
+wgpu-types = ["wgpu"]
+mjpeg = ["mozjpeg"]
+docs-features = []
+
+
+[dependencies]
+thiserror = "1.0"
+bytes = "1.2"
+
+[dependencies.image]
+version = "0.24"
+default-features = false
+
+[dependencies.serde]
+version = "1.0"
+features = ["derive"]
+optional = true
+
+[dependencies.wgpu]
+version = "0.13"
+optional = true
+
+[dependencies.mozjpeg]
+version = "0.9"
+optional = true
diff --git a/nokhwa-core/src/buffer.rs b/nokhwa-core/src/buffer.rs
new file mode 100644
index 0000000..6422bfb
--- /dev/null
+++ b/nokhwa-core/src/buffer.rs
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use crate::{
+    error::NokhwaError,
+    pixel_format::FormatDecoder,
+    types::{FrameFormat, Resolution},
+};
+use bytes::Bytes;
+use image::ImageBuffer;
+#[cfg(feature = "serialize")]
+use serde::{Deserialize, Serialize};
+
+/// A buffer returned by a camera to accomodate custom decoding.
+/// Contains information of Resolution, the buffer's [`FrameFormat`], and the buffer.
+#[derive(Clone, Debug, Hash, PartialOrd, PartialEq, Eq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub struct Buffer {
+    resolution: Resolution,
+    buffer: Bytes,
+    source_frame_format: FrameFormat,
+}
+
+impl Buffer {
+    /// Creates a new buffer with a [`&[u8]`].
+    #[must_use]
+    pub fn new(res: Resolution, buf: &[u8], source_frame_format: FrameFormat) -> Self {
+        Self {
+            resolution: res,
+            buffer: Bytes::copy_from_slice(buf),
+            source_frame_format,
+        }
+    }
+
+    /// Get the [`Resolution`] of this buffer.
+    #[must_use]
+    pub fn resolution(&self) -> Resolution {
+        self.resolution
+    }
+
+    /// Get the data of this buffer.
+    #[must_use]
+    pub fn buffer(&self) -> &[u8] {
+        &self.buffer
+    }
+
+    /// Get the [`FrameFormat`] of this buffer.
+    #[must_use]
+    pub fn source_frame_format(&self) -> FrameFormat {
+        self.source_frame_format
+    }
+
+    /// Decodes a image with allocation using the provided [`FormatDecoder`].
+    /// # Errors
+    /// Will error when the decoding fails.
+    pub fn decode_image<F: FormatDecoder>(
+        &self,
+    ) -> Result<ImageBuffer<F::Output, Vec<u8>>, NokhwaError> {
+        let new_data = F::write_output(self.source_frame_format, &self.buffer)?;
+        let image =
+            ImageBuffer::from_raw(self.resolution.width_x, self.resolution.height_y, new_data)
+                .ok_or(NokhwaError::ProcessFrameError {
+                    src: self.source_frame_format,
+                    destination: stringify!(F).to_string(),
+                    error: "Failed to create buffer".to_string(),
+                })?;
+        Ok(image)
+    }
+
+    /// Decodes a image with allocation using the provided [`FormatDecoder`] into a `buffer`.
+    /// # Errors
+    /// Will error when the decoding fails, or the provided buffer is too small.
+    pub fn decode_image_to_buffer<F: FormatDecoder>(
+        &self,
+        buffer: &mut [u8],
+    ) -> Result<(), NokhwaError> {
+        F::write_output_buffer(self.source_frame_format, &self.buffer, buffer)
+    }
+
+    /// Decodes a image with allocation using the provided [`FormatDecoder`] into a [`Mat`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html).
+    ///
+    /// Note that this does a clone when creating the buffer, to decouple the lifetime of the internal data to the temporary Buffer. If you want to avoid this, please see [`decode_as_opencv_mat`](Self::decode_as_opencv_mat).
+    /// # Errors
+    /// Will error when the decoding fails, or `OpenCV` failed to create/copy the [`Mat`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html).
+    /// # Safety
+    /// This function uses `unsafe` in order to create the [`Mat`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html). Please see [`Mat::new_rows_cols_with_data`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html#method.new_rows_cols_with_data) for more.
+    #[cfg(feature = "input-opencv")]
+    #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-opencv")))]
+    pub fn decode_opencv_mat<F: FormatDecoder>(&self) -> Result<Mat, NokhwaError> {
+        let mut buffer = F::write_output(self.source_frame_format, &self.buffer)?;
+
+        let array_type = match F::Output::CHANNEL_COUNT {
+            1 => CV_8UC1,
+            2 => CV_8UC2,
+            3 => CV_8UC3,
+            4 => CV_8UC4,
+            _ => {
+                return Err(NokhwaError::ProcessFrameError {
+                    src: self.source_frame_format,
+                    destination: "OpenCV Mat".to_string(),
+                    error: "Invalid Decoder FormatDecoder Channel Count".to_string(),
+                })
+            }
+        };
+
+        unsafe {
+            // TODO: Look into removing this unnecessary copy.
+            let mat1 = Mat::new_rows_cols_with_data(
+                self.resolution.height_y as i32,
+                self.resolution.width_x as i32,
+                array_type,
+                &mut buffer as *mut std::os::raw::c_void,
+                Mat_AUTO_STEP,
+            )
+            .map_err(|why| NokhwaError::ProcessFrameError {
+                src: self.source_frame_format,
+                destination: "OpenCV Mat".to_string(),
+                error: why.to_string(),
+            })?;
+
+            Ok(mat1.clone().map_err(|why| NokhwaError::ProcessFrameError {
+                src: self.source_frame_format,
+                destination: "OpenCV Mat".to_string(),
+                error: why.to_string(),
+            })?)
+        }
+    }
+
+    /// Decodes a image with allocation using the provided [`FormatDecoder`] into a [`Mat`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html).
+    /// # Errors
+    /// Will error when the decoding fails, or `OpenCV` failed to create/copy the [`Mat`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html).
+    /// # Safety
+    /// This function uses `unsafe` in order to create the [`Mat`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html). Please see [`Mat::new_rows_cols_with_data`](https://docs.rs/opencv/latest/opencv/core/struct.Mat.html#method.new_rows_cols_with_data) for more.
+    ///
+    /// THIS WILL CAUSE UNSOUNDNESS IF YOU USE THE MAT WHILE THE BUFFER ITSELF IS DROPPED.
+    #[cfg(feature = "input-opencv")]
+    #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-opencv")))]
+    pub unsafe fn decode_as_opencv_mat<F: FormatDecoder>(&mut self) -> Result<Mat, NokhwaError> {
+        let resolution = self.resolution();
+        let frame_format = self.source_frame_format();
+
+        let array_type = match F::Output::CHANNEL_COUNT {
+            1 => CV_8UC1,
+            2 => CV_8UC2,
+            3 => CV_8UC3,
+            4 => CV_8UC4,
+            _ => {
+                return Err(NokhwaError::ProcessFrameError {
+                    src: frame_format,
+                    destination: "OpenCV Mat".to_string(),
+                    error: "Invalid Decoder FormatDecoder Channel Count".to_string(),
+                })
+            }
+        };
+
+        unsafe {
+            Ok(Mat::new_rows_cols_with_data(
+                resolution.height_y as i32,
+                resolution.width_x as i32,
+                array_type,
+                self.buffer_mut() as *mut std::os::raw::c_void,
+                Mat_AUTO_STEP,
+            )
+            .map_err(|why| NokhwaError::ProcessFrameError {
+                src: frame_format,
+                destination: "OpenCV Mat".to_string(),
+                error: why.to_string(),
+            })?)
+        }
+    }
+}
diff --git a/nokhwa-core/src/error.rs b/nokhwa-core/src/error.rs
new file mode 100644
index 0000000..e1523a5
--- /dev/null
+++ b/nokhwa-core/src/error.rs
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use crate::types::{ApiBackend, FrameFormat};
+use thiserror::Error;
+
+/// All errors in `nokhwa`.
+#[allow(clippy::module_name_repetitions)]
+#[derive(Error, Debug, Clone)]
+pub enum NokhwaError {
+    #[error("Unitialized Camera. Call `init()` first!")]
+    UnitializedError,
+    #[error("Could not initialize {backend}: {error}")]
+    InitializeError { backend: ApiBackend, error: String },
+    #[error("Could not shutdown {backend}: {error}")]
+    ShutdownError { backend: ApiBackend, error: String },
+    #[error("Error: {0}")]
+    GeneralError(String),
+    #[error("Could not generate required structure {structure}: {error}")]
+    StructureError { structure: String, error: String },
+    #[error("Could not open device {0}: {1}")]
+    OpenDeviceError(String, String),
+    #[error("Could not get device property {property}: {error}")]
+    GetPropertyError { property: String, error: String },
+    #[error("Could not set device property {property} with value {value}: {error}")]
+    SetPropertyError {
+        property: String,
+        value: String,
+        error: String,
+    },
+    #[error("Could not open device stream: {0}")]
+    OpenStreamError(String),
+    #[error("Could not capture frame: {0}")]
+    ReadFrameError(String),
+    #[error("Could not process frame {src} to {destination}: {error}")]
+    ProcessFrameError {
+        src: FrameFormat,
+        destination: String,
+        error: String,
+    },
+    #[error("Could not stop stream: {0}")]
+    StreamShutdownError(String),
+    #[error("This operation is not supported by backend {0}.")]
+    UnsupportedOperationError(ApiBackend),
+    #[error("This operation is not implemented yet: {0}")]
+    NotImplementedError(String),
+}
diff --git a/nokhwa-core/src/lib.rs b/nokhwa-core/src/lib.rs
new file mode 100644
index 0000000..d339a33
--- /dev/null
+++ b/nokhwa-core/src/lib.rs
@@ -0,0 +1,10 @@
+//! Core type definitions for `nokhwa`
+
+extern crate core;
+extern crate core;
+
+pub mod buffer;
+pub mod error;
+pub mod pixel_format;
+pub mod traits;
+pub mod types;
diff --git a/nokhwa-core/src/pixel_format.rs b/nokhwa-core/src/pixel_format.rs
new file mode 100644
index 0000000..8f70b66
--- /dev/null
+++ b/nokhwa-core/src/pixel_format.rs
@@ -0,0 +1,306 @@
+/*
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+use crate::error::NokhwaError;
+use crate::types::{
+    buf_mjpeg_to_rgb, buf_yuyv422_to_rgb, mjpeg_to_rgb, yuyv422_to_rgb, FrameFormat,
+};
+use image::{Luma, LumaA, Pixel, Rgb, Rgba};
+use std::fmt::Debug;
+
+/// Trait that has methods to convert raw data from the webcam to a proper raw image.
+pub trait FormatDecoder: Copy + Clone + Debug + Default + Sized + Send + Sync {
+    type Output: Pixel<Subpixel = u8>;
+    const FORMATS: &'static [FrameFormat];
+
+    /// Allocates and returns a `Vec`
+    /// # Errors
+    /// If the data is malformed, or the source [`FrameFormat`] is incompatible, this will error.
+    fn write_output(fcc: FrameFormat, data: &[u8]) -> Result<Vec<u8>, NokhwaError>;
+
+    /// Writes to a user provided buffer.
+    /// # Errors
+    /// If the data is malformed, the source [`FrameFormat`] is incompatible, or the user-alloted buffer is not large enough, this will error.
+    fn write_output_buffer(
+        fcc: FrameFormat,
+        data: &[u8],
+        dest: &mut [u8],
+    ) -> Result<(), NokhwaError>;
+}
+
+/// A Zero-Size-Type that contains the definition to convert a given image stream to an RGB888 in the [`Buffer`](crate::buffer::Buffer)'s [`.to_image()`](crate::buffer::Buffer::to_image)
+///
+/// ```.ignore
+/// use image::{ImageBuffer, Rgb};
+/// let image: ImageBuffer<Rgb<u8>, Vec<u8>> = buffer.to_image::<RgbFormat>();
+/// ```
+#[derive(Copy, Clone, Debug, Default, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct RgbFormat;
+
+impl FormatDecoder for RgbFormat {
+    type Output = Rgb<u8>;
+    const FORMATS: &'static [FrameFormat] = &[FrameFormat::MJPEG, FrameFormat::YUYV];
+
+    fn write_output(fcc: FrameFormat, data: &[u8]) -> Result<Vec<u8>, NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => mjpeg_to_rgb(data, false),
+            FrameFormat::YUYV => yuyv422_to_rgb(data, false),
+            FrameFormat::GRAY => Ok(data
+                .iter()
+                .flat_map(|x| {
+                    let pxv = *x;
+                    [pxv, pxv, pxv]
+                })
+                .collect()),
+        }
+    }
+
+    fn write_output_buffer(
+        fcc: FrameFormat,
+        data: &[u8],
+        dest: &mut [u8],
+    ) -> Result<(), NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => buf_mjpeg_to_rgb(data, dest, false),
+            FrameFormat::YUYV => buf_yuyv422_to_rgb(data, dest, false),
+            FrameFormat::GRAY => {
+                if dest.len() != data.len() * 3 {
+                    return Err(NokhwaError::ProcessFrameError {
+                        src: fcc,
+                        destination: "Luma => RGB".to_string(),
+                        error: "Bad buffer length".to_string(),
+                    });
+                }
+
+                data.iter().enumerate().for_each(|(idx, pixel_value)| {
+                    let index = idx * 3;
+                    dest[index] = *pixel_value;
+                    dest[index + 1] = *pixel_value;
+                    dest[index + 2] = *pixel_value;
+                });
+                Ok(())
+            }
+        }
+    }
+}
+
+/// A Zero-Size-Type that contains the definition to convert a given image stream to an RGBA8888 in the [`Buffer`](crate::buffer::Buffer)'s [`.to_image()`](crate::buffer::Buffer::to_image)
+///
+/// ```.ignore
+/// use image::{ImageBuffer, Rgba};
+/// let image: ImageBuffer<Rgba<u8>, Vec<u8>> = buffer.to_image::<RgbAFormat>();
+/// ```
+#[derive(Copy, Clone, Debug, Default, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct RgbAFormat;
+
+impl FormatDecoder for RgbAFormat {
+    type Output = Rgba<u8>;
+
+    const FORMATS: &'static [FrameFormat] = &[FrameFormat::MJPEG, FrameFormat::YUYV];
+
+    fn write_output(fcc: FrameFormat, data: &[u8]) -> Result<Vec<u8>, NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => mjpeg_to_rgb(data, true),
+            FrameFormat::YUYV => yuyv422_to_rgb(data, true),
+            FrameFormat::GRAY => Ok(data
+                .iter()
+                .flat_map(|x| {
+                    let pxv = *x;
+                    [pxv, pxv, pxv, 255]
+                })
+                .collect()),
+        }
+    }
+
+    fn write_output_buffer(
+        fcc: FrameFormat,
+        data: &[u8],
+        dest: &mut [u8],
+    ) -> Result<(), NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => buf_mjpeg_to_rgb(data, dest, true),
+            FrameFormat::YUYV => buf_yuyv422_to_rgb(data, dest, true),
+            FrameFormat::GRAY => {
+                if dest.len() != data.len() * 4 {
+                    return Err(NokhwaError::ProcessFrameError {
+                        src: fcc,
+                        destination: "Luma => RGBA".to_string(),
+                        error: "Bad buffer length".to_string(),
+                    });
+                }
+
+                data.iter().enumerate().for_each(|(idx, pixel_value)| {
+                    let index = idx * 4;
+                    dest[index] = *pixel_value;
+                    dest[index + 1] = *pixel_value;
+                    dest[index + 2] = *pixel_value;
+                    dest[index + 3] = 255;
+                });
+                Ok(())
+            }
+        }
+    }
+}
+
+/// A Zero-Size-Type that contains the definition to convert a given image stream to an Luma8(Grayscale 8-bit) in the [`Buffer`](crate::buffer::Buffer)'s [`.to_image()`](crate::buffer::Buffer::to_image)
+///
+/// ```.ignore
+/// use image::{ImageBuffer, Luma};
+/// let image: ImageBuffer<Luma<u8>, Vec<u8>> = buffer.to_image::<LumaFormat>();
+/// ```
+#[derive(Copy, Clone, Debug, Default, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct LumaFormat;
+
+impl FormatDecoder for LumaFormat {
+    type Output = Luma<u8>;
+
+    const FORMATS: &'static [FrameFormat] =
+        &[FrameFormat::MJPEG, FrameFormat::YUYV, FrameFormat::GRAY];
+
+    #[allow(clippy::cast_possible_truncation)]
+    fn write_output(fcc: FrameFormat, data: &[u8]) -> Result<Vec<u8>, NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => Ok(mjpeg_to_rgb(data, false)?
+                .as_slice()
+                .chunks_exact(3)
+                .map(|x| {
+                    let mut avg = 0;
+                    x.iter().for_each(|v| avg += u16::from(*v));
+                    (avg / 3) as u8
+                })
+                .collect()),
+            FrameFormat::YUYV => Ok(yuyv422_to_rgb(data, false)?
+                .as_slice()
+                .chunks_exact(3)
+                .map(|x| {
+                    let mut avg = 0;
+                    x.iter().for_each(|v| avg += u16::from(*v));
+                    (avg / 3) as u8
+                })
+                .collect()),
+            FrameFormat::GRAY => Ok(data.to_vec()),
+        }
+    }
+
+    fn write_output_buffer(
+        fcc: FrameFormat,
+        data: &[u8],
+        dest: &mut [u8],
+    ) -> Result<(), NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => {
+                // FIXME: implement!
+                Err(NokhwaError::ProcessFrameError {
+                    src: fcc,
+                    destination: "Luma => RGB".to_string(),
+                    error: "Conversion Error".to_string(),
+                })
+            }
+            FrameFormat::YUYV => Err(NokhwaError::ProcessFrameError {
+                src: fcc,
+                destination: "Luma => RGB".to_string(),
+                error: "Conversion Error".to_string(),
+            }),
+            FrameFormat::GRAY => {
+                data.iter().zip(dest.iter_mut()).for_each(|(pxv, d)| {
+                    *d = *pxv;
+                });
+                Ok(())
+            }
+        }
+    }
+}
+
+/// A Zero-Size-Type that contains the definition to convert a given image stream to an LumaA8(Grayscale 8-bit with 8-bit alpha) in the [`Buffer`](crate::buffer::Buffer)'s [`.to_image()`](crate::buffer::Buffer::to_image)
+///
+/// ```.ignore
+/// use image::{ImageBuffer, LumaA};
+/// let image: ImageBuffer<LumaA<u8>, Vec<u8>> = buffer.to_image::<LumaAFormat>();
+/// ```
+#[derive(Copy, Clone, Debug, Default, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct LumaAFormat;
+
+impl FormatDecoder for LumaAFormat {
+    type Output = LumaA<u8>;
+
+    const FORMATS: &'static [FrameFormat] =
+        &[FrameFormat::MJPEG, FrameFormat::YUYV, FrameFormat::GRAY];
+
+    #[allow(clippy::cast_possible_truncation)]
+    fn write_output(fcc: FrameFormat, data: &[u8]) -> Result<Vec<u8>, NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => Ok(mjpeg_to_rgb(data, false)?
+                .as_slice()
+                .chunks_exact(3)
+                .flat_map(|x| {
+                    let mut avg = 0;
+                    x.iter().for_each(|v| avg += u16::from(*v));
+                    [(avg / 3) as u8, 255]
+                })
+                .collect()),
+            FrameFormat::YUYV => Ok(yuyv422_to_rgb(data, false)?
+                .as_slice()
+                .chunks_exact(3)
+                .flat_map(|x| {
+                    let mut avg = 0;
+                    x.iter().for_each(|v| avg += u16::from(*v));
+                    [(avg / 3) as u8, 255]
+                })
+                .collect()),
+            FrameFormat::GRAY => Ok(data.iter().flat_map(|x| [*x, 255]).collect()),
+        }
+    }
+
+    fn write_output_buffer(
+        fcc: FrameFormat,
+        data: &[u8],
+        dest: &mut [u8],
+    ) -> Result<(), NokhwaError> {
+        match fcc {
+            FrameFormat::MJPEG => {
+                // FIXME: implement!
+                Err(NokhwaError::ProcessFrameError {
+                    src: fcc,
+                    destination: "MJPEG => LumaA".to_string(),
+                    error: "Conversion Error".to_string(),
+                })
+            }
+            FrameFormat::YUYV => Err(NokhwaError::ProcessFrameError {
+                src: fcc,
+                destination: "YUYV => LumaA".to_string(),
+                error: "Conversion Error".to_string(),
+            }),
+            FrameFormat::GRAY => {
+                if dest.len() != data.len() * 2 {
+                    return Err(NokhwaError::ProcessFrameError {
+                        src: fcc,
+                        destination: "GRAY8 => LumaA".to_string(),
+                        error: "Conversion Error".to_string(),
+                    });
+                }
+
+                data.iter()
+                    .zip(dest.chunks_exact_mut(2))
+                    .enumerate()
+                    .for_each(|(idx, (pxv, d))| {
+                        let index = idx * 2;
+                        d[index] = *pxv;
+                        d[index + 1] = 255;
+                    });
+                Ok(())
+            }
+        }
+    }
+}
diff --git a/src/camera_traits.rs b/nokhwa-core/src/traits.rs
similarity index 61%
rename from src/camera_traits.rs
rename to nokhwa-core/src/traits.rs
index 01ac17a..ee674ac 100644
--- a/src/camera_traits.rs
+++ b/nokhwa-core/src/traits.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,15 +14,17 @@
  * limitations under the License.
  */
 
+use crate::types::KnownCameraControlFlag;
 use crate::{
+    buffer::Buffer,
     error::NokhwaError,
-    utils::{CameraFormat, CameraInfo, FrameFormat, Resolution},
-    CameraControl, CaptureAPIBackend, KnownCameraControls,
+    types::{
+        ApiBackend, CameraControl, CameraFormat, CameraInfo, ControlValueSetter, FrameFormat,
+        KnownCameraControl, Resolution,
+    },
 };
-use image::{buffer::ConvertBuffer, ImageBuffer, Rgb, RgbaImage};
-
-use std::{any::Any, borrow::Cow, collections::HashMap};
-#[cfg(feature = "output-wgpu")]
+use std::{borrow::Cow, collections::HashMap};
+#[cfg(feature = "wgpu-types")]
 use wgpu::{
     Device as WgpuDevice, Extent3d, ImageCopyTexture, ImageDataLayout, Queue as WgpuQueue,
     Texture as WgpuTexture, TextureAspect, TextureDescriptor, TextureDimension, TextureFormat,
@@ -38,16 +40,23 @@ use wgpu::{
 /// - If you call [`stop_stream()`](CaptureBackendTrait::stop_stream()), you will usually need to call [`open_stream()`](CaptureBackendTrait::open_stream()) to get more frames from the camera.
 pub trait CaptureBackendTrait {
     /// Returns the current backend used.
-    fn backend(&self) -> CaptureAPIBackend;
+    fn backend(&self) -> ApiBackend;
 
     /// Gets the camera information such as Name and Index as a [`CameraInfo`].
     fn camera_info(&self) -> &CameraInfo;
 
-    /// Gets the current [`CameraFormat`].
+    /// Forcefully refreshes the stored camera format, bringing it into sync with "reality" (current camera state)
+    /// # Errors
+    /// If the camera can not get its most recent [`CameraFormat`]. this will error.
+    fn refresh_camera_format(&mut self) -> Result<(), NokhwaError>;
+
+    /// Gets the current [`CameraFormat`]. This will force refresh to the current latest if it has changed.
     fn camera_format(&self) -> CameraFormat;
 
     /// Will set the current [`CameraFormat`]
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new camera format, this will return an error.
     fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError>;
@@ -60,82 +69,81 @@ pub trait CaptureBackendTrait {
         fourcc: FrameFormat,
     ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError>;
 
+    /// Gets the compatible [`CameraFormat`] of the camera
+    /// # Errors
+    /// If it fails to get, this will error.
+    fn compatible_camera_formats(&mut self) -> Result<Vec<CameraFormat>, NokhwaError> {
+        let mut compatible_formats = vec![];
+        for fourcc in self.compatible_fourcc()? {
+            for (resolution, fps_list) in self.compatible_list_by_resolution(fourcc)? {
+                for fps in fps_list {
+                    compatible_formats.push(CameraFormat::new(resolution, fourcc, fps));
+                }
+            }
+        }
+
+        Ok(compatible_formats)
+    }
+
     /// A Vector of compatible [`FrameFormat`]s. Will only return 2 elements at most.
     /// # Errors
     /// This will error if the camera is not queryable or a query operation has failed. Some backends will error this out as a Unsupported Operation ([`UnsupportedOperationError`](crate::NokhwaError::UnsupportedOperationError)).
     fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError>;
 
-    /// Gets the current camera resolution (See: [`Resolution`], [`CameraFormat`]).
+    /// Gets the current camera resolution (See: [`Resolution`], [`CameraFormat`]). This will force refresh to the current latest if it has changed.
     fn resolution(&self) -> Resolution;
 
     /// Will set the current [`Resolution`]
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new resolution, this will return an error.
     fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError>;
 
-    /// Gets the current camera framerate (See: [`CameraFormat`]).
+    /// Gets the current camera framerate (See: [`CameraFormat`]). This will force refresh to the current latest if it has changed.
     fn frame_rate(&self) -> u32;
 
     /// Will set the current framerate
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new framerate, this will return an error.
     fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError>;
 
-    /// Gets the current camera's frame format (See: [`FrameFormat`], [`CameraFormat`]).
+    /// Gets the current camera's frame format (See: [`FrameFormat`], [`CameraFormat`]). This will force refresh to the current latest if it has changed.
     fn frame_format(&self) -> FrameFormat;
 
     /// Will set the current [`FrameFormat`]
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new frame format, this will return an error.
     fn set_frame_format(&mut self, fourcc: FrameFormat) -> Result<(), NokhwaError>;
 
-    /// Gets the current supported list of [`KnownCameraControls`]
-    /// # Errors
-    /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
-    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError>;
-
-    /// Gets the value of [`KnownCameraControls`].
+    /// Gets the value of [`KnownCameraControl`].
     /// # Errors
     /// If the `control` is not supported or there is an error while getting the camera control values (e.g. unexpected value, too high, etc)
     /// this will error.
-    fn camera_control(&self, control: KnownCameraControls) -> Result<CameraControl, NokhwaError>;
+    fn camera_control(&self, control: KnownCameraControl) -> Result<CameraControl, NokhwaError>;
+
+    /// Gets the current supported list of [`KnownCameraControl`]
+    /// # Errors
+    /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
+    fn camera_controls(&self) -> Result<Vec<CameraControl>, NokhwaError>;
 
     /// Sets the control to `control` in the camera.
     /// Usually, the pipeline is calling [`camera_control()`](CaptureBackendTrait::camera_control), getting a camera control that way
-    /// then calling one of the methods to set the value: [`set_value()`](CameraControl::set_value()) or [`with_value()`](CameraControl::with_value()).
+    /// then calling [`set_value()`](CameraControl::set_value())
     /// # Errors
     /// If the `control` is not supported, the value is invalid (less than min, greater than max, not in step), or there was an error setting the control,
     /// this will error.
-    fn set_camera_control(&mut self, control: CameraControl) -> Result<(), NokhwaError>;
-
-    /// Gets the current supported list of Controls as an `Any` from the backend.
-    /// The `Any`'s type is defined by the backend itself, please check each of the backend's documentation.
-    /// # Errors
-    /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
-    fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError>;
-
-    /// Sets the control to `control` in the camera.
-    /// The control's type is defined the backend itself. It may be a string, or more likely its a integer ID.
-    /// The backend itself has documentation of the proper input/return values, please check each of the backend's documentation.
-    /// # Errors
-    /// If the `control` is not supported or there is an error while getting the camera control values (e.g. unexpected value, too high, wrong Any type)
-    /// this will error.
-    fn raw_camera_control(&self, control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError>;
-
-    /// Sets the control to `control` in the camera.
-    /// The `control`/`value`'s type is defined the backend itself. It may be a string, or more likely its a integer ID/Value.
-    /// Usually, the pipeline is calling [`camera_control()`](CaptureBackendTrait::camera_control), getting a camera control that way
-    /// then calling one of the methods to set the value: [`set_value()`](CameraControl::set_value()) or [`with_value()`](CameraControl::with_value()).
-    /// # Errors
-    /// If the `control` is not supported, the value is invalid (wrong Any type, backend refusal), or there was an error setting the control,
-    /// this will error.
-    fn set_raw_camera_control(
+    fn set_camera_control(
         &mut self,
-        control: &dyn Any,
-        value: &dyn Any,
+        id: KnownCameraControl,
+        value: ControlValueSetter,
     ) -> Result<(), NokhwaError>;
 
     /// Will open the camera stream with set parameters. This will be called internally if you try and call [`frame()`](CaptureBackendTrait::frame()) before you call [`open_stream()`](CaptureBackendTrait::open_stream()).
@@ -146,60 +154,36 @@ pub trait CaptureBackendTrait {
     /// Checks if stream if open. If it is, it will return true.
     fn is_stream_open(&self) -> bool;
 
-    /// Will get a frame from the camera as a Raw RGB image buffer. Depending on the backend, if you have not called [`open_stream()`](CaptureBackendTrait::open_stream()) before you called this,
+    /// Will get a frame from the camera as a [`Buffer`]. Depending on the backend, if you have not called [`open_stream()`](CaptureBackendTrait::open_stream()) before you called this,
     /// it will either return an error.
     /// # Errors
     /// If the backend fails to get the frame (e.g. already taken, busy, doesn't exist anymore), the decoding fails (e.g. MJPEG -> u8), or [`open_stream()`](CaptureBackendTrait::open_stream()) has not been called yet,
     /// this will error.
-    fn frame(&mut self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError>;
+    fn frame(&mut self) -> Result<Buffer, NokhwaError>;
 
     /// Will get a frame from the camera **without** any processing applied, meaning you will usually get a frame you need to decode yourself.
     /// # Errors
     /// If the backend fails to get the frame (e.g. already taken, busy, doesn't exist anymore), or [`open_stream()`](CaptureBackendTrait::open_stream()) has not been called yet, this will error.
     fn frame_raw(&mut self) -> Result<Cow<[u8]>, NokhwaError>;
 
-    /// The minimum buffer size needed to write the current frame (RGB24). If `rgba` is true, it will instead return the minimum size of the RGBA buffer needed.
-    fn min_buffer_size(&self, rgba: bool) -> usize {
-        let resolution = self.resolution();
-        if rgba {
-            return (resolution.width() * resolution.height() * 4) as usize;
+    /// The minimum buffer size needed to write the current frame. If `alpha` is true, it will instead return the minimum size of the buffer with an alpha channel as well.
+    /// This assumes that you are decoding to RGB/RGBA for [`FrameFormat::MJPEG`] or [`FrameFormat::YUYV`] and Luma8/LumaA8 for [`FrameFormat::GRAY`]
+    #[must_use]
+    fn decoded_buffer_size(&self, alpha: bool) -> usize {
+        let cfmt = self.camera_format();
+        let resolution = cfmt.resolution();
+        let pxwidth = match cfmt.format() {
+            FrameFormat::MJPEG | FrameFormat::YUYV => 3,
+            FrameFormat::GRAY => 1,
+        };
+        if alpha {
+            return (resolution.width() * resolution.height() * (pxwidth + 1)) as usize;
         }
-        (resolution.width() * resolution.height() * 3) as usize
+        (resolution.width() * resolution.height() * pxwidth) as usize
     }
 
-    /// Directly writes the current frame(RGB24) into said `buffer`. If `convert_rgba` is true, the buffer written will be written as an RGBA frame instead of a RGB frame. Returns the amount of bytes written on successful capture.
-    /// # Errors
-    /// If the backend fails to get the frame (e.g. already taken, busy, doesn't exist anymore), or [`open_stream()`](CaptureBackendTrait::open_stream()) has not been called yet, this will error.
-    fn write_frame_to_buffer(
-        &mut self,
-        buffer: &mut [u8],
-        convert_rgba: bool,
-    ) -> Result<usize, NokhwaError> {
-        let resolution = self.resolution();
-        let frame = self.frame_raw()?;
-        if convert_rgba {
-            let image_data =
-                match ImageBuffer::from_raw(resolution.width(), resolution.height(), frame) {
-                    Some(image) => {
-                        let image: ImageBuffer<Rgb<u8>, Cow<[u8]>> = image;
-                        image
-                    }
-                    None => {
-                        return Err(NokhwaError::ReadFrameError(
-                            "Frame Cow Too Small".to_string(),
-                        ))
-                    }
-                };
-            let rgba_image: RgbaImage = image_data.convert();
-            buffer.copy_from_slice(rgba_image.as_raw());
-            return Ok(rgba_image.len());
-        }
-        buffer.copy_from_slice(frame.as_ref());
-        Ok(frame.len())
-    }
-
-    #[cfg(feature = "output-wgpu")]
-    #[cfg_attr(feature = "docs-features", doc(cfg(feature = "output-wgpu")))]
+    #[cfg(feature = "wgpu-types")]
+    #[cfg_attr(feature = "docs-features", doc(cfg(feature = "wgpu-types")))]
     /// Directly copies a frame to a Wgpu texture. This will automatically convert the frame into a RGBA frame.
     /// # Errors
     /// If the frame cannot be captured or the resolution is 0 on any axis, this will error.
@@ -209,9 +193,9 @@ pub trait CaptureBackendTrait {
         queue: &WgpuQueue,
         label: Option<&'a str>,
     ) -> Result<WgpuTexture, NokhwaError> {
-        use std::{convert::TryFrom, num::NonZeroU32};
-        let frame = self.frame()?;
-        let rgba_frame: RgbaImage = frame.convert();
+        use crate::pixel_format::RgbAFormat;
+        use std::num::NonZeroU32;
+        let frame = self.frame()?.decode_image::<RgbAFormat>()?;
 
         let texture_size = Extent3d {
             width: frame.width(),
@@ -229,12 +213,12 @@ pub trait CaptureBackendTrait {
             usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
         });
 
-        let width_nonzero = match NonZeroU32::try_from(4 * rgba_frame.width()) {
+        let width_nonzero = match NonZeroU32::try_from(4 * frame.width()) {
             Ok(w) => Some(w),
             Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
         };
 
-        let height_nonzero = match NonZeroU32::try_from(rgba_frame.height()) {
+        let height_nonzero = match NonZeroU32::try_from(frame.height()) {
             Ok(h) => Some(h),
             Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
         };
@@ -246,7 +230,7 @@ pub trait CaptureBackendTrait {
                 origin: wgpu::Origin3d::ZERO,
                 aspect: TextureAspect::All,
             },
-            &rgba_frame.to_vec(),
+            &frame,
             ImageDataLayout {
                 offset: 0,
                 bytes_per_row: width_nonzero,
@@ -264,4 +248,13 @@ pub trait CaptureBackendTrait {
     fn stop_stream(&mut self) -> Result<(), NokhwaError>;
 }
 
+impl<T> From<T> for Box<dyn CaptureBackendTrait>
+where
+    T: CaptureBackendTrait + 'static,
+{
+    fn from(capbackend: T) -> Self {
+        Box::new(capbackend)
+    }
+}
+
 pub trait VirtualBackendTrait {}
diff --git a/nokhwa-core/src/types.rs b/nokhwa-core/src/types.rs
new file mode 100644
index 0000000..e6a22d2
--- /dev/null
+++ b/nokhwa-core/src/types.rs
@@ -0,0 +1,1604 @@
+use crate::error::NokhwaError;
+use crate::pixel_format::FormatDecoder;
+#[cfg(feature = "serialize")]
+use serde::{Deserialize, Serialize};
+use std::{
+    borrow::Borrow,
+    cmp::Ordering,
+    fmt::{Display, Formatter},
+};
+
+/// Tells the init function what camera format to pick.
+/// - `HighestResolution(Option<u32>)`: Pick the highest [`Resolution`] for the given framerate (the `Option<u32>`). If its `None`, it will pick the highest possible [`Resolution`]
+/// - `HighestFrameRate(Option<Resolution>)`: Pick the highest frame rate for the given [`Resolution`] (the `Option<Resolution>`). If it is `None`, it will pick the highest possinle framerate.
+/// - `Exact`: Pick the exact [`CameraFormat`] provided.
+/// - `Closest`: Pick the closest [`CameraFormat`] provided in order of [`FrameFormat`], [`Resolution`], and FPS. Note that if the [`FrameFormat`] does not exist, this will fail to resolve.
+/// - `None`: Pick a random [`CameraFormat`]
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub enum RequestedFormatType {
+    HighestResolution,
+    HighestFrameRate,
+    Exact(CameraFormat),
+    Closest(CameraFormat),
+    None,
+}
+
+impl Default for RequestedFormatType {
+    fn default() -> Self {
+        RequestedFormatType::None
+    }
+}
+
+impl Display for RequestedFormatType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct RequestedFormat {
+    requested_format: RequestedFormatType,
+    wanted_decoder: &'static [FrameFormat],
+}
+
+impl RequestedFormat {
+    pub fn new<Decoder: FormatDecoder>(requested: RequestedFormatType) -> RequestedFormat {
+        RequestedFormat {
+            requested_format: requested,
+            wanted_decoder: Decoder::FORMATS,
+        }
+    }
+
+    pub fn with_formats(
+        requested: RequestedFormatType,
+        decoder: &'static [FrameFormat],
+    ) -> RequestedFormat {
+        RequestedFormat {
+            requested_format: requested,
+            wanted_decoder: decoder,
+        }
+    }
+
+    /// Fulfill the requested using a list of all available formats.
+    pub fn fulfill(&self, all_formats: &[CameraFormat]) -> Option<CameraFormat> {
+        match self.requested_format {
+            RequestedFormatType::HighestResolution => {
+                let mut formats = all_formats.to_vec();
+                formats.sort_by_key(|a| a.resolution());
+                let resolution = *formats.iter().last()?;
+                let mut format_resolutions = formats
+                    .into_iter()
+                    .filter(|fmt| {
+                        fmt.resolution() == resolution.resolution()
+                            && self.wanted_decoder.contains(&fmt.format())
+                    })
+                    .collect::<Vec<CameraFormat>>();
+                format_resolutions.sort_by_key(|a| a.frame_rate());
+                format_resolutions.last().copied()
+            }
+            RequestedFormatType::HighestFrameRate => {
+                let mut formats = all_formats.to_vec();
+                formats.sort_by_key(|a| a.frame_rate());
+                let frame_rate = *formats.iter().last()?;
+                let mut format_framerates = formats
+                    .into_iter()
+                    .filter(|fmt| {
+                        fmt.frame_rate() == frame_rate.frame_rate()
+                            && self.wanted_decoder.contains(&fmt.format())
+                    })
+                    .collect::<Vec<CameraFormat>>();
+                format_framerates.sort_by_key(|a| a.resolution());
+                format_framerates.last().copied()
+            }
+            RequestedFormatType::Exact(fmt) => {
+                if self.wanted_decoder.contains(&fmt.format()) {
+                    Some(fmt)
+                } else {
+                    None
+                }
+            }
+            RequestedFormatType::Closest(c) => {
+                let same_fmt_formats = all_formats
+                    .iter()
+                    .filter(|x| {
+                        x.format() == c.format() && self.wanted_decoder.contains(&x.format())
+                    })
+                    .copied()
+                    .collect::<Vec<CameraFormat>>();
+                let mut resolution_map = same_fmt_formats
+                    .iter()
+                    .map(|x| {
+                        let res = x.resolution();
+                        let x_diff = res.x() as i32 - c.resolution().x() as i32;
+                        let y_diff = res.y() as i32 - c.resolution().y() as i32;
+                        let dist_no_sqrt = (x_diff.abs()).pow(2) + (y_diff.abs()).pow(2);
+                        (dist_no_sqrt, res)
+                    })
+                    .collect::<Vec<(i32, Resolution)>>();
+                resolution_map.sort_by(|a, b| a.0.cmp(&b.0));
+                resolution_map.dedup_by(|a, b| a.0.eq(&b.0));
+                let resolution = resolution_map.first()?.1;
+
+                let frame_rates = all_formats
+                    .iter()
+                    .filter_map(|cfmt| {
+                        if cfmt.format() == c.format() && cfmt.resolution() == c.resolution() {
+                            return Some(cfmt.frame_rate());
+                        }
+                        None
+                    })
+                    .collect::<Vec<u32>>();
+                // sort FPSes
+                let mut framerate_map = frame_rates
+                    .iter()
+                    .map(|x| {
+                        let abs = *x as i32 - c.frame_rate() as i32;
+                        (abs.unsigned_abs(), *x)
+                    })
+                    .collect::<Vec<(u32, u32)>>();
+                framerate_map.sort();
+                let frame_rate = framerate_map.first()?.1;
+                Some(CameraFormat::new(resolution, c.format(), frame_rate))
+            }
+            RequestedFormatType::None => all_formats
+                .iter()
+                .filter(|fmt| self.wanted_decoder.contains(&fmt.format()))
+                .nth(0)
+                .copied(),
+        }
+    }
+}
+
+impl Display for RequestedFormat {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+/// Describes the index of the camera.
+/// - Index: A numbered index
+/// - String: A string, used for IPCameras.
+#[derive(Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub enum CameraIndex {
+    Index(u32),
+    String(String),
+}
+
+impl CameraIndex {
+    /// Turns this value into a number. If it is a string, it will attempt to parse it as a `u32`.
+    /// # Errors
+    /// Fails if the value is not a number.
+    pub fn as_index(&self) -> Result<u32, NokhwaError> {
+        match self {
+            CameraIndex::Index(i) => Ok(*i),
+            CameraIndex::String(s) => s
+                .parse::<u32>()
+                .map_err(|why| NokhwaError::GeneralError(why.to_string())),
+        }
+    }
+
+    /// Turns this value into a `String`. If it is a number, it will be automatically converted.
+    #[must_use]
+    pub fn as_string(&self) -> String {
+        match self {
+            CameraIndex::Index(i) => i.to_string(),
+            CameraIndex::String(s) => s.to_string(),
+        }
+    }
+
+    /// Returns true if this [`CameraIndex`] contains an [`CameraIndex::Index`]
+    #[must_use]
+    pub fn is_index(&self) -> bool {
+        match self {
+            CameraIndex::Index(_) => true,
+            CameraIndex::String(_) => false,
+        }
+    }
+
+    /// Returns true if this [`CameraIndex`] contains an [`CameraIndex::String`]
+    #[must_use]
+    pub fn is_string(&self) -> bool {
+        !self.is_index()
+    }
+}
+
+impl Display for CameraIndex {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_string())
+    }
+}
+
+impl Default for CameraIndex {
+    fn default() -> Self {
+        CameraIndex::Index(0)
+    }
+}
+
+impl TryFrom<CameraIndex> for u32 {
+    type Error = NokhwaError;
+
+    fn try_from(value: CameraIndex) -> Result<Self, Self::Error> {
+        value.as_index()
+    }
+}
+
+impl TryFrom<CameraIndex> for usize {
+    type Error = NokhwaError;
+
+    fn try_from(value: CameraIndex) -> Result<Self, Self::Error> {
+        value.as_index().map(|i| i as usize)
+    }
+}
+
+/// Describes a frame format (i.e. how the bytes themselves are encoded). Often called `FourCC`.
+/// - YUYV is a mathematical color space. You can read more [here.](https://en.wikipedia.org/wiki/YCbCr)
+/// - MJPEG is a motion-jpeg compressed frame, it allows for high frame rates.
+/// - GRAY is a grayscale image format, usually for specialized cameras such as IR Cameras.
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub enum FrameFormat {
+    MJPEG,
+    YUYV,
+    GRAY,
+}
+
+impl Display for FrameFormat {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FrameFormat::MJPEG => {
+                write!(f, "MJPG")
+            }
+            FrameFormat::YUYV => {
+                write!(f, "YUYV")
+            }
+            FrameFormat::GRAY => {
+                write!(f, "GRAY")
+            }
+        }
+    }
+}
+
+#[must_use]
+pub const fn frame_formats() -> [FrameFormat; 3] {
+    [FrameFormat::MJPEG, FrameFormat::YUYV, FrameFormat::GRAY]
+}
+
+/// Describes a Resolution.
+/// This struct consists of a Width and a Height value (x,y). <br>
+/// Note: the [`Ord`] implementation of this struct is flipped from highest to lowest.
+/// # JS-WASM
+/// This is exported as `JSResolution`
+#[cfg_attr(feature = "output-wasm", wasm_bindgen)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, Default, Hash, Eq, PartialEq)]
+pub struct Resolution {
+    pub width_x: u32,
+    pub height_y: u32,
+}
+
+#[cfg_attr(feature = "output-wasm", wasm_bindgen)]
+impl Resolution {
+    /// Create a new resolution from 2 image size coordinates.
+    /// # JS-WASM
+    /// This is exported as a constructor for [`Resolution`].
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(constructor))]
+    pub fn new(x: u32, y: u32) -> Self {
+        Resolution {
+            width_x: x,
+            height_y: y,
+        }
+    }
+
+    /// Get the width of Resolution
+    /// # JS-WASM
+    /// This is exported as `get_Width`.
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Width))]
+    pub fn width(self) -> u32 {
+        self.width_x
+    }
+
+    /// Get the height of Resolution
+    /// # JS-WASM
+    /// This is exported as `get_Height`.
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Height))]
+    pub fn height(self) -> u32 {
+        self.height_y
+    }
+
+    /// Get the x (width) of Resolution
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(skip))]
+    pub fn x(self) -> u32 {
+        self.width_x
+    }
+
+    /// Get the y (height) of Resolution
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(skip))]
+    pub fn y(self) -> u32 {
+        self.height_y
+    }
+}
+
+impl Display for Resolution {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}x{}", self.x(), self.y())
+    }
+}
+
+impl PartialOrd for Resolution {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Resolution {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self.x().cmp(&other.x()) {
+            Ordering::Less => Ordering::Less,
+            Ordering::Equal => self.y().cmp(&other.y()),
+            Ordering::Greater => Ordering::Greater,
+        }
+    }
+}
+
+/// This is a convenience struct that holds all information about the format of a webcam stream.
+/// It consists of a [`Resolution`], [`FrameFormat`], and a frame rate(u8).
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub struct CameraFormat {
+    resolution: Resolution,
+    format: FrameFormat,
+    frame_rate: u32,
+}
+
+impl CameraFormat {
+    /// Construct a new [`CameraFormat`]
+    #[must_use]
+    pub fn new(resolution: Resolution, format: FrameFormat, frame_rate: u32) -> Self {
+        CameraFormat {
+            resolution,
+            format,
+            frame_rate,
+        }
+    }
+
+    /// [`CameraFormat::new()`], but raw.
+    #[must_use]
+    pub fn new_from(res_x: u32, res_y: u32, format: FrameFormat, fps: u32) -> Self {
+        CameraFormat {
+            resolution: Resolution {
+                width_x: res_x,
+                height_y: res_y,
+            },
+            format,
+            frame_rate: fps,
+        }
+    }
+
+    /// Get the resolution of the current [`CameraFormat`]
+    #[must_use]
+    pub fn resolution(&self) -> Resolution {
+        self.resolution
+    }
+
+    /// Get the width of the resolution of the current [`CameraFormat`]
+    #[must_use]
+    pub fn width(&self) -> u32 {
+        self.resolution.width()
+    }
+
+    /// Get the height of the resolution of the current [`CameraFormat`]
+    #[must_use]
+    pub fn height(&self) -> u32 {
+        self.resolution.height()
+    }
+
+    /// Set the [`CameraFormat`]'s resolution.
+    pub fn set_resolution(&mut self, resolution: Resolution) {
+        self.resolution = resolution;
+    }
+
+    /// Get the frame rate of the current [`CameraFormat`]
+    #[must_use]
+    pub fn frame_rate(&self) -> u32 {
+        self.frame_rate
+    }
+
+    /// Set the [`CameraFormat`]'s frame rate.
+    pub fn set_frame_rate(&mut self, frame_rate: u32) {
+        self.frame_rate = frame_rate;
+    }
+
+    /// Get the [`CameraFormat`]'s format.
+    #[must_use]
+    pub fn format(&self) -> FrameFormat {
+        self.format
+    }
+
+    /// Set the [`CameraFormat`]'s format.
+    pub fn set_format(&mut self, format: FrameFormat) {
+        self.format = format;
+    }
+}
+
+impl Default for CameraFormat {
+    fn default() -> Self {
+        CameraFormat {
+            resolution: Resolution::new(640, 480),
+            format: FrameFormat::MJPEG,
+            frame_rate: 30,
+        }
+    }
+}
+
+impl Display for CameraFormat {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}@{}FPS, {} Format",
+            self.resolution, self.frame_rate, self.format
+        )
+    }
+}
+
+/// Information about a Camera e.g. its name.
+/// `description` amd `misc` may contain information that may differ from backend to backend. Refer to each backend for details.
+/// `index` is a camera's index given to it by (usually) the OS usually in the order it is known to the system.
+#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd)]
+#[cfg_attr(feature = "output-wasm", wasm_bindgen)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub struct CameraInfo {
+    human_name: String,
+    description: String,
+    misc: String,
+    index: CameraIndex,
+}
+
+#[cfg_attr(feature = "output-wasm", wasm_bindgen(js_class = CameraInfo))]
+impl CameraInfo {
+    /// Create a new [`CameraInfo`].
+    /// # JS-WASM
+    /// This is exported as a constructor for [`CameraInfo`].
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(constructor))]
+    // OK, i just checkeed back on this code. WTF was I on when I wrote `&(impl AsRef<str> + ?Sized)` ????
+    // I need to get on the same shit that my previous self was on, because holy shit that stuff is strong as FUCK!
+    // Finally fixed this insanity. Hopefully I didnt torment anyone by actually putting this in a stable release.
+    pub fn new(human_name: &str, description: &str, misc: &str, index: CameraIndex) -> Self {
+        CameraInfo {
+            human_name: human_name.to_string(),
+            description: description.to_string(),
+            misc: misc.to_string(),
+            index,
+        }
+    }
+
+    /// Get a reference to the device info's human readable name.
+    /// # JS-WASM
+    /// This is exported as a `get_HumanReadableName`.
+    #[must_use]
+    #[cfg_attr(
+    feature = "output-wasm",
+    wasm_bindgen(getter = HumanReadableName)
+    )]
+    // yes, i know, unnecessary alloc this, unnecessary alloc that
+    // but wasm bindgen
+    pub fn human_name(&self) -> String {
+        self.human_name.clone()
+    }
+
+    /// Set the device info's human name.
+    /// # JS-WASM
+    /// This is exported as a `set_HumanReadableName`.
+    #[cfg_attr(
+    feature = "output-wasm",
+    wasm_bindgen(setter = HumanReadableName)
+    )]
+    pub fn set_human_name(&mut self, human_name: &str) {
+        self.human_name = human_name.to_string();
+    }
+
+    /// Get a reference to the device info's description.
+    /// # JS-WASM
+    /// This is exported as a `get_Description`.
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Description))]
+    pub fn description(&self) -> &str {
+        self.description.borrow()
+    }
+
+    /// Set the device info's description.
+    /// # JS-WASM
+    /// This is exported as a `set_Description`.
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(setter = Description))]
+    pub fn set_description(&mut self, description: &str) {
+        self.description = description.to_string();
+    }
+
+    /// Get a reference to the device info's misc.
+    /// # JS-WASM
+    /// This is exported as a `get_MiscString`.
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = MiscString))]
+    pub fn misc(&self) -> String {
+        self.misc.clone()
+    }
+
+    /// Set the device info's misc.
+    /// # JS-WASM
+    /// This is exported as a `set_MiscString`.
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(setter = MiscString))]
+    pub fn set_misc(&mut self, misc: &str) {
+        self.misc = misc.to_string();
+    }
+
+    /// Get a reference to the device info's index.
+    /// # JS-WASM
+    /// This is exported as a `get_Index`.
+    #[must_use]
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Index))]
+    pub fn index(&self) -> &CameraIndex {
+        &self.index
+    }
+
+    /// Set the device info's index.
+    /// # JS-WASM
+    /// This is exported as a `set_Index`.
+    #[cfg_attr(feature = "output-wasm", wasm_bindgen(setter = Index))]
+    pub fn set_index(&mut self, index: CameraIndex) {
+        self.index = index;
+    }
+
+    // /// Gets the device info's index as an `u32`.
+    // /// # Errors
+    // /// If the index is not parsable as a `u32`, this will error.
+    // /// # JS-WASM
+    // /// This is exported as `get_Index_Int`
+    // #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Index_Int))]
+    // pub fn index_num(&self) -> Result<u32, NokhwaError> {
+    //     match &self.index {
+    //         CameraIndex::Index(i) => Ok(*i),
+    //         CameraIndex::String(s) => match s.parse::<u32>() {
+    //             Ok(p) => Ok(p),
+    //             Err(why) => Err(NokhwaError::GetPropertyError {
+    //                 property: "index-int".to_string(),
+    //                 error: why.to_string(),
+    //             }),
+    //         },
+    //     }
+    // }
+}
+
+impl Display for CameraInfo {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Name: {}, Description: {}, Extra: {}, Index: {}",
+            self.human_name, self.description, self.misc, self.index
+        )
+    }
+}
+
+/// The list of known camera controls to the library. <br>
+/// These can control the picture brightness, etc. <br>
+/// Note that not all backends/devices support all these. Run [`supported_camera_controls()`](crate::CaptureBackendTrait::camera_controls) to see which ones can be set.
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub enum KnownCameraControl {
+    Brightness,
+    Contrast,
+    Hue,
+    Saturation,
+    Sharpness,
+    Gamma,
+    WhiteBalance,
+    BacklightComp,
+    Gain,
+    Pan,
+    Tilt,
+    Zoom,
+    Exposure,
+    Iris,
+    Focus,
+    /// Other camera control. Listed is the ID.
+    /// Wasteful, however is needed for a unified API across Windows, Linux, and MacOSX due to Microsoft's usage of GUIDs.
+    ///
+    /// THIS SHOULD ONLY BE USED WHEN YOU KNOW THE PLATFORM THAT YOU ARE RUNNING ON.
+    Other(u128),
+}
+
+/// All camera controls in an array.
+#[must_use]
+pub const fn all_known_camera_controls() -> [KnownCameraControl; 15] {
+    [
+        KnownCameraControl::Brightness,
+        KnownCameraControl::Contrast,
+        KnownCameraControl::Hue,
+        KnownCameraControl::Saturation,
+        KnownCameraControl::Sharpness,
+        KnownCameraControl::Gamma,
+        KnownCameraControl::WhiteBalance,
+        KnownCameraControl::BacklightComp,
+        KnownCameraControl::Gain,
+        KnownCameraControl::Pan,
+        KnownCameraControl::Tilt,
+        KnownCameraControl::Zoom,
+        KnownCameraControl::Exposure,
+        KnownCameraControl::Iris,
+        KnownCameraControl::Focus,
+    ]
+}
+
+impl Display for KnownCameraControl {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", &self)
+    }
+}
+
+/// This tells you weather a [`KnownCameraControl`] is automatically managed by the OS/Driver
+/// or manually managed by you, the programmer.
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub enum KnownCameraControlFlag {
+    Automatic,
+    Manual,
+    Continuous,
+    ReadOnly,
+    WriteOnly,
+    Volatile,
+    Disabled,
+}
+
+impl Display for KnownCameraControlFlag {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+// TODO: use in CameraControl
+/// The values for a [`CameraControl`].
+///
+/// This provides a wide range of values that can be used to control a camera.
+pub enum ControlValueDescription {
+    None,
+    Integer {
+        value: i64,
+        default: i64,
+        step: i64,
+    },
+    IntegerRange {
+        min: i64,
+        max: i64,
+        value: i64,
+        step: i64,
+        default: i64,
+    },
+    Float {
+        value: f64,
+        default: f64,
+        step: f64,
+    },
+    FloatRange {
+        min: f64,
+        max: f64,
+        value: f64,
+        step: f64,
+        default: f64,
+    },
+    Boolean {
+        value: bool,
+        default: bool,
+    },
+    String {
+        value: String,
+        default: Option<String>,
+    },
+    Bytes {
+        value: Vec<u8>,
+        default: Vec<u8>,
+    },
+    KeyValuePair {
+        key: i128,
+        value: i128,
+        default: (i128, i128),
+    },
+    Point {
+        value: (f64, f64),
+        default: (f64, f64),
+    },
+    Enum {
+        value: i64,
+        possible: Vec<i64>,
+        default: i64,
+    },
+    RGB {
+        value: (f64, f64, f64),
+        max: (f64, f64, f64),
+        default: (f64, f64, f64),
+    },
+}
+
+impl ControlValueDescription {
+    /// Get the value of this [`ControlValueDescription`]
+    #[must_use]
+    pub fn value(&self) -> ControlValueSetter {
+        match self {
+            ControlValueDescription::None => ControlValueSetter::None,
+            ControlValueDescription::Integer { value, .. }
+            | ControlValueDescription::IntegerRange { value, .. } => {
+                ControlValueSetter::Integer(*value)
+            }
+            ControlValueDescription::Float { value, .. }
+            | ControlValueDescription::FloatRange { value, .. } => {
+                ControlValueSetter::Float(*value)
+            }
+            ControlValueDescription::Boolean { value, .. } => ControlValueSetter::Boolean(*value),
+            ControlValueDescription::String { value, .. } => {
+                ControlValueSetter::String(value.clone())
+            }
+            ControlValueDescription::Bytes { value, .. } => {
+                ControlValueSetter::Bytes(value.clone())
+            }
+            ControlValueDescription::KeyValuePair { key, value, .. } => {
+                ControlValueSetter::KeyValue(*key, *value)
+            }
+            ControlValueDescription::Point { value, .. } => {
+                ControlValueSetter::Point(value.0, value.1)
+            }
+            ControlValueDescription::Enum { value, .. } => ControlValueSetter::EnumValue(*value),
+            ControlValueDescription::RGB { value, .. } => {
+                ControlValueSetter::RGB(value.0, value.1, value.2)
+            }
+        }
+    }
+
+    /// Verifies if the [setter](crate::utils::ControlValueSetter) is valid for the provided [`ControlValueDescription`].
+    /// - `true` => Is valid.
+    /// - `false` => Is not valid.
+    #[must_use]
+    pub fn verify_setter(&self, setter: &ControlValueSetter) -> bool {
+        match self {
+            ControlValueDescription::None => return setter.as_none().is_some(),
+            ControlValueDescription::Integer {
+                value,
+                default,
+                step,
+            } => match setter.as_integer() {
+                Some(i) => (i + default) % step == 0 || (i + value) % step == 0,
+                None => false,
+            },
+            ControlValueDescription::IntegerRange {
+                min,
+                max,
+                value,
+                step,
+                default,
+            } => match setter.as_integer() {
+                Some(i) => {
+                    ((i + default) % step == 0 || (i + value) % step == 0) && i >= min && i <= max
+                }
+                None => false,
+            },
+            ControlValueDescription::Float {
+                value,
+                default,
+                step,
+            } => match setter.as_float() {
+                Some(f) => (f - default).abs() % step == 0_f64 || (f - value) % step == 0_f64,
+                None => false,
+            },
+            ControlValueDescription::FloatRange {
+                min,
+                max,
+                value,
+                step,
+                default,
+            } => match setter.as_float() {
+                Some(f) => {
+                    ((f - default).abs() % step == 0_f64 || (f - value) % step == 0_f64)
+                        && f >= min
+                        && f <= max
+                }
+                None => false,
+            },
+            ControlValueDescription::Boolean { .. } => setter.as_boolean().is_some(),
+            ControlValueDescription::String { .. } => setter.as_str().is_some(),
+            ControlValueDescription::Bytes { .. } => setter.as_bytes().is_some(),
+            ControlValueDescription::KeyValuePair { .. } => setter.as_key_value().is_some(),
+            ControlValueDescription::Point { .. } => match setter.as_point() {
+                Some(pt) => {
+                    !pt.0.is_nan() && !pt.1.is_nan() && pt.0.is_finite() && pt.1.is_finite()
+                }
+                None => false,
+            },
+            ControlValueDescription::Enum { possible, .. } => match setter.as_enum() {
+                Some(e) => possible.contains(e),
+                None => false,
+            },
+            ControlValueDescription::RGB { max, .. } => match setter.as_rgb() {
+                Some(v) => *v.0 >= max.0 && *v.1 >= max.1 && *v.2 >= max.2,
+                None => false,
+            },
+        }
+
+        // match setter {
+        //     ControlValueSetter::None => {
+        //         matches!(self, ControlValueDescription::None)
+        //     }
+        //     ControlValueSetter::Integer(i) => match self {
+        //         ControlValueDescription::Integer {
+        //             value,
+        //             default,
+        //             step,
+        //         } => (i - default).abs() % step == 0 || (i - value) % step == 0,
+        //         ControlValueDescription::IntegerRange {
+        //             min,
+        //             max,
+        //             value,
+        //             step,
+        //             default,
+        //         } => {
+        //             if value > max || value < min {
+        //                 return false;
+        //             }
+        //
+        //             (i - default) % step == 0 || (i - value) % step == 0
+        //         }
+        //         _ => false,
+        //     },
+        //     ControlValueSetter::Float(f) => match self {
+        //         ControlValueDescription::Float {
+        //             value,
+        //             default,
+        //             step,
+        //         } => (f - default).abs() % step == 0_f64 || (f - value) % step == 0_f64,
+        //         ControlValueDescription::FloatRange {
+        //             min,
+        //             max,
+        //             value,
+        //             step,
+        //             default,
+        //         } => {
+        //             if value > max || value < min {
+        //                 return false;
+        //             }
+        //
+        //             (f - default) % step == 0_f64 || (f - value) % step == 0_f64
+        //         }
+        //         _ => false,
+        //     },
+        //     ControlValueSetter::Boolean(b) => {
+        //
+        //     }
+        //     ControlValueSetter::String(_) => {
+        //         matches!(self, ControlValueDescription::String { .. })
+        //     }
+        //     ControlValueSetter::Bytes(_) => {
+        //         matches!(self, ControlValueDescription::Bytes { .. })
+        //     }
+        //     ControlValueSetter::KeyValue(_, _) => {
+        //         matches!(self, ControlValueDescription::KeyValuePair { .. })
+        //     }
+        //     ControlValueSetter::Point(_, _) => {
+        //         matches!(self, ControlValueDescription::Point { .. })
+        //     }
+        //     ControlValueSetter::EnumValue(_) => {
+        //         matches!(self, ControlValueDescription::Enum { .. })
+        //     }
+        //     ControlValueSetter::RGB(_, _, _) => {
+        //         matches!(self, ControlValueDescription::RGB { .. })
+        //     }
+        // }
+    }
+}
+
+impl Display for ControlValueDescription {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ControlValueDescription::None => {
+                write!(f, "(None)")
+            }
+            ControlValueDescription::Integer {
+                value,
+                default,
+                step,
+            } => {
+                write!(
+                    f,
+                    "(Current: {}, Default: {}, Step: {})",
+                    value, default, step
+                )
+            }
+            ControlValueDescription::IntegerRange {
+                min,
+                max,
+                value,
+                step,
+                default,
+            } => {
+                write!(
+                    f,
+                    "(Current: {}, Default: {}, Step: {}, Range: ({}, {}))",
+                    value, default, step, min, max
+                )
+            }
+            ControlValueDescription::Float {
+                value,
+                default,
+                step,
+            } => {
+                write!(
+                    f,
+                    "(Current: {}, Default: {}, Step: {})",
+                    value, default, step
+                )
+            }
+            ControlValueDescription::FloatRange {
+                min,
+                max,
+                value,
+                step,
+                default,
+            } => {
+                write!(
+                    f,
+                    "(Current: {}, Default: {}, Step: {}, Range: ({}, {}))",
+                    value, default, step, min, max
+                )
+            }
+            ControlValueDescription::Boolean { value, default } => {
+                write!(f, "(Current: {}, Default: {})", value, default)
+            }
+            ControlValueDescription::String { value, default } => {
+                write!(f, "(Current: {}, Default: {:?})", value, default)
+            }
+            ControlValueDescription::Bytes { value, default } => {
+                write!(f, "(Current: {:x?}, Default: {:x?})", value, default)
+            }
+            ControlValueDescription::KeyValuePair {
+                key,
+                value,
+                default,
+            } => {
+                write!(
+                    f,
+                    "Current: ({}, {}), Default: ({}, {})",
+                    key, value, default.0, default.1
+                )
+            }
+            ControlValueDescription::Point { value, default } => {
+                write!(
+                    f,
+                    "Current: ({}, {}), Default: ({}, {})",
+                    value.0, value.1, default.0, default.1
+                )
+            }
+            ControlValueDescription::Enum {
+                value,
+                possible,
+                default,
+            } => {
+                write!(
+                    f,
+                    "Current: {}, Possible Values: {:?}, Default: {}",
+                    value, possible, default
+                )
+            }
+            ControlValueDescription::RGB {
+                value,
+                max,
+                default,
+            } => {
+                write!(
+                    f,
+                    "Current: ({}, {}, {}), Max: ({}, {}, {}), Default: ({}, {}, {})",
+                    value.0, value.1, value.2, max.0, max.1, max.2, default.0, default.1, default.2
+                )
+            }
+        }
+    }
+}
+
+// fn step_chk(val: i64, default: i64, step: i64) -> Result<(), NokhwaError> {
+//     if (val - default) % step != 0 {
+//         return Err(NokhwaError::StructureError {
+//             structure: "Value".to_string(),
+//             error: "Doesnt fit step".to_string(),
+//         });
+//     }
+//     Ok(())
+// }
+
+/// This struct tells you everything about a particular [`KnownCameraControl`].
+///
+/// However, you should never need to instantiate this struct, since its usually generated for you by `nokhwa`.
+/// The only time you should be modifying this struct is when you need to set a value and pass it back to the camera.
+/// NOTE: Assume the values for `min` and `max` as **non-inclusive**!.
+/// E.g. if the [`CameraControl`] says `min` is 100, the minimum is actually 101.
+#[derive(Clone, Debug, PartialOrd, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub struct CameraControl {
+    control: KnownCameraControl,
+    name: String,
+    description: ControlValueDescription,
+    flag: Vec<KnownCameraControlFlag>,
+    active: bool,
+}
+
+impl CameraControl {
+    /// Creates a new [`CameraControl`]
+    #[must_use]
+    pub fn new(
+        control: KnownCameraControl,
+        name: String,
+        description: ControlValueDescription,
+        flag: Vec<KnownCameraControlFlag>,
+        active: bool,
+    ) -> Self {
+        CameraControl {
+            control,
+            name,
+            description,
+            flag,
+            active,
+        }
+    }
+
+    /// Gets the name of this [`CameraControl`]
+    #[must_use]
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Gets the [`ControlValueDescription`] of this [`CameraControl`]
+    #[must_use]
+    pub fn description(&self) -> &ControlValueDescription {
+        &self.description
+    }
+
+    /// Gets the [`ControlValueSetter`] of the [`ControlValueDescription`] of this [`CameraControl`]
+    #[must_use]
+    pub fn value(&self) -> ControlValueSetter {
+        self.description.value()
+    }
+
+    /// Gets the [`KnownCameraControl`] of this [`CameraControl`]
+    #[must_use]
+    pub fn control(&self) -> KnownCameraControl {
+        self.control
+    }
+
+    /// Gets the [`KnownCameraControlFlag`] of this [`CameraControl`],
+    /// telling you weather this control is automatically set or manually set.
+    #[must_use]
+    pub fn flag(&self) -> &[KnownCameraControlFlag] {
+        &self.flag
+    }
+
+    /// Gets `active` of this [`CameraControl`],
+    /// telling you weather this control is currently active(in-use).
+    #[must_use]
+    pub fn active(&self) -> bool {
+        self.active
+    }
+
+    /// Gets `active` of this [`CameraControl`],
+    /// telling you weather this control is currently active(in-use).
+    pub fn set_active(&mut self, active: bool) {
+        self.active = active;
+    }
+}
+
+impl Display for CameraControl {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Control: {}, Name: {}, Value: {}, Flag: {:?}, Active: {}",
+            self.control, self.name, self.description, self.flag, self.active
+        )
+    }
+}
+
+/// The setter for a control value
+#[derive(Clone, Debug, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub enum ControlValueSetter {
+    None,
+    Integer(i64),
+    Float(f64),
+    Boolean(bool),
+    String(String),
+    Bytes(Vec<u8>),
+    KeyValue(i128, i128),
+    Point(f64, f64),
+    EnumValue(i64),
+    RGB(f64, f64, f64),
+}
+
+impl ControlValueSetter {
+    pub fn as_none(&self) -> Option<()> {
+        if let ControlValueSetter::None = self {
+            Some(())
+        } else {
+            None
+        }
+    }
+
+    pub fn as_integer(&self) -> Option<&i64> {
+        if let ControlValueSetter::Integer(i) = self {
+            Some(i)
+        } else {
+            None
+        }
+    }
+
+    pub fn as_float(&self) -> Option<&f64> {
+        if let ControlValueSetter::Float(f) = self {
+            Some(f)
+        } else {
+            None
+        }
+    }
+    pub fn as_boolean(&self) -> Option<&bool> {
+        if let ControlValueSetter::Boolean(f) = self {
+            Some(f)
+        } else {
+            None
+        }
+    }
+    pub fn as_str(&self) -> Option<&str> {
+        if let ControlValueSetter::String(s) = self {
+            Some(s)
+        } else {
+            None
+        }
+    }
+    pub fn as_bytes(&self) -> Option<&[u8]> {
+        if let ControlValueSetter::Bytes(b) = self {
+            Some(b)
+        } else {
+            None
+        }
+    }
+    pub fn as_key_value(&self) -> Option<(&i128, &i128)> {
+        if let ControlValueSetter::KeyValue(k, v) = self {
+            Some((k, v))
+        } else {
+            None
+        }
+    }
+
+    pub fn as_point(&self) -> Option<(&f64, &f64)> {
+        if let ControlValueSetter::Point(x, y) = self {
+            Some((x, y))
+        } else {
+            None
+        }
+    }
+
+    pub fn as_enum(&self) -> Option<&i64> {
+        if let ControlValueSetter::EnumValue(e) = self {
+            Some(e)
+        } else {
+            None
+        }
+    }
+
+    pub fn as_rgb(&self) -> Option<(&f64, &f64, &f64)> {
+        if let ControlValueSetter::RGB(r, g, b) = self {
+            Some((r, g, b))
+        } else {
+            None
+        }
+    }
+}
+
+impl Display for ControlValueSetter {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ControlValueSetter::None => {
+                write!(f, "Value: None")
+            }
+            ControlValueSetter::Integer(i) => {
+                write!(f, "IntegerValue: {}", i)
+            }
+            ControlValueSetter::Float(d) => {
+                write!(f, "FloatValue: {}", d)
+            }
+            ControlValueSetter::Boolean(b) => {
+                write!(f, "BoolValue: {}", b)
+            }
+            ControlValueSetter::String(s) => {
+                write!(f, "StrValue: {}", s)
+            }
+            ControlValueSetter::Bytes(b) => {
+                write!(f, "BytesValue: {:x?}", b)
+            }
+            ControlValueSetter::KeyValue(k, v) => {
+                write!(f, "KVValue: ({}, {})", k, v)
+            }
+            ControlValueSetter::Point(x, y) => {
+                write!(f, "PointValue: ({}, {})", x, y)
+            }
+            ControlValueSetter::EnumValue(v) => {
+                write!(f, "EnumValue: {}", v)
+            }
+            ControlValueSetter::RGB(r, g, b) => {
+                write!(f, "RGBValue: ({}, {}, {})", r, g, b)
+            }
+        }
+    }
+}
+
+/// The list of known capture backends to the library. <br>
+/// - `AUTO` is special - it tells the Camera struct to automatically choose a backend most suited for the current platform.
+/// - `AVFoundation` - Uses `AVFoundation` on `MacOSX`
+/// - `Video4Linux` - `Video4Linux2`, a linux specific backend.
+/// - `UniversalVideoClass` -  ***DEPRECATED*** Universal Video Class (please check [libuvc](https://github.com/libuvc/libuvc)). Platform agnostic, although on linux it needs `sudo` permissions or similar to use.
+/// - `MediaFoundation` - Microsoft Media Foundation, Windows only,
+/// - `OpenCv` - Uses `OpenCV` to capture. Platform agnostic.
+/// - `GStreamer` - ***DEPRECATED*** Uses `GStreamer` RTP to capture. Platform agnostic.
+/// - `Network` - Uses `OpenCV` to capture from an IP.
+/// - `Browser` - Uses browser APIs to capture from a webcam.
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+pub enum ApiBackend {
+    Auto,
+    AVFoundation,
+    Video4Linux,
+    #[deprecated]
+    UniversalVideoClass,
+    MediaFoundation,
+    OpenCv,
+    #[deprecated]
+    GStreamer,
+    Network,
+    Browser,
+}
+
+impl Display for ApiBackend {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let self_str = format!("{:?}", self);
+        write!(f, "{}", self_str)
+    }
+}
+
+// /// A webcam index that supports both strings and integers. Most backends take an int, but `IPCamera`s take a URL (string).
+// #[derive(Clone, Debug, Hash, PartialEq, PartialOrd)]
+// pub enum CameraIndex {
+//     Index(u32),
+//     String(String),
+// }
+
+// impl CameraIndex {
+//     /// Gets the device info's index as an `u32`.
+//     /// # Errors
+//     /// If the index is not parsable as a `u32`, this will error.
+//     pub fn as_index(&self) -> Result<u32, NokhwaError> {
+//         match self {
+//             CameraIndex::Index(i) => Ok(*i),
+//             CameraIndex::String(s) => match s.parse::<u32>() {
+//                 Ok(p) => Ok(p),
+//                 Err(why) => Err(NokhwaError::GetPropertyError {
+//                     property: "index-int".to_string(),
+//                     error: why.to_string(),
+//                 }),
+//             },
+//         }
+//     }
+// }
+
+// impl Display for CameraIndex {
+//     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+//         match self {
+//             CameraIndex::Index(idx) => {
+//                 write!(f, "{}", idx)
+//             }
+//             CameraIndex::String(ip) => {
+//                 write!(f, "{}", ip)
+//             }
+//         }
+//     }
+// }
+
+// impl From<u32> for CameraIndex {
+//     fn from(v: u32) -> Self {
+//         CameraIndex::Index(v)
+//     }
+// }
+
+// /// Trait for strings that can be converted to [`CameraIndex`]es.
+// pub trait ValidString: AsRef<str> {}
+//
+// impl ValidString for String {}
+// impl<'a> ValidString for &'a String {}
+// impl<'a> ValidString for &'a mut String {}
+// impl<'a> ValidString for Cow<'a, str> {}
+// impl<'a> ValidString for &'a Cow<'a, str> {}
+// impl<'a> ValidString for &'a mut Cow<'a, str> {}
+// impl<'a> ValidString for &'a str {}
+// impl<'a> ValidString for &'a mut str {}
+
+// impl<T> From<T> for CameraIndex
+// where
+//     T: ValidString,
+// {
+//     fn from(v: T) -> Self {
+//         CameraIndex::String(v.as_ref().to_string())
+//     }
+// }
+
+/// Converts a MJPEG stream of [u8] into a Vec<u8> of RGB888. (R,G,B,R,G,B,...)
+/// # Errors
+/// If `mozjpeg` fails to read scanlines or setup the decompressor, this will error.
+/// # Safety
+/// This function uses `unsafe`. The caller must ensure that:
+/// - The input data is of the right size, does not exceed bounds, and/or the final size matches with the initial size.
+#[cfg(all(feature = "mjpeg", not(target_arch = "wasm")))]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "mjpeg")))]
+pub fn mjpeg_to_rgb(data: &[u8], rgba: bool) -> Result<Vec<u8>, NokhwaError> {
+    use mozjpeg::Decompress;
+
+    let mut jpeg_decompress = match Decompress::new_mem(data) {
+        Ok(decompress) => {
+            let decompressor_res = if rgba {
+                decompress.rgba()
+            } else {
+                decompress.rgb()
+            };
+            match decompressor_res {
+                Ok(decompressor) => decompressor,
+                Err(why) => {
+                    return Err(NokhwaError::ProcessFrameError {
+                        src: FrameFormat::MJPEG,
+                        destination: "RGB888".to_string(),
+                        error: why.to_string(),
+                    })
+                }
+            }
+        }
+        Err(why) => {
+            return Err(NokhwaError::ProcessFrameError {
+                src: FrameFormat::MJPEG,
+                destination: "RGB888".to_string(),
+                error: why.to_string(),
+            })
+        }
+    };
+
+    let scanlines_res: Option<Vec<u8>> = jpeg_decompress.read_scanlines_flat();
+    // assert!(jpeg_decompress.finish_decompress());
+    if !jpeg_decompress.finish_decompress() {
+        return Err(NokhwaError::ProcessFrameError {
+            src: FrameFormat::MJPEG,
+            destination: "RGB888".to_string(),
+            error: "JPEG Decompressor did not finish.".to_string(),
+        });
+    }
+
+    match scanlines_res {
+        Some(pixels) => Ok(pixels),
+        None => Err(NokhwaError::ProcessFrameError {
+            src: FrameFormat::MJPEG,
+            destination: "RGB888".to_string(),
+            error: "Failed to get read readlines into RGB888 pixels!".to_string(),
+        }),
+    }
+}
+
+#[cfg(not(all(feature = "mjpeg", not(target_arch = "wasm"))))]
+pub fn mjpeg_to_rgb(data: &[u8], rgba: bool) -> Result<Vec<u8>, NokhwaError> {
+    Err(NokhwaError::NotImplementedError(
+        "Not available on WASM".to_string(),
+    ))
+}
+
+/// Equivalent to [`mjpeg_to_rgb`] except with a destination buffer.
+/// # Errors
+/// If the decoding fails (e.g. invalid MJPEG stream), the buffer is not large enough, or you are doing this on `WebAssembly`, this will error.
+#[cfg(all(feature = "mjpeg", not(target_arch = "wasm")))]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "mjpeg")))]
+pub fn buf_mjpeg_to_rgb(data: &[u8], dest: &mut [u8], rgba: bool) -> Result<(), NokhwaError> {
+    use mozjpeg::Decompress;
+
+    let mut jpeg_decompress = match Decompress::new_mem(data) {
+        Ok(decompress) => {
+            let decompressor_res = if rgba {
+                decompress.rgba()
+            } else {
+                decompress.rgb()
+            };
+            match decompressor_res {
+                Ok(decompressor) => decompressor,
+                Err(why) => {
+                    return Err(NokhwaError::ProcessFrameError {
+                        src: FrameFormat::MJPEG,
+                        destination: "RGB888".to_string(),
+                        error: why.to_string(),
+                    })
+                }
+            }
+        }
+        Err(why) => {
+            return Err(NokhwaError::ProcessFrameError {
+                src: FrameFormat::MJPEG,
+                destination: "RGB888".to_string(),
+                error: why.to_string(),
+            })
+        }
+    };
+
+    // assert_eq!(dest.len(), jpeg_decompress.min_flat_buffer_size());
+    if dest.len() != jpeg_decompress.min_flat_buffer_size() {
+        return Err(NokhwaError::ProcessFrameError {
+            src: FrameFormat::MJPEG,
+            destination: "RGB888".to_string(),
+            error: "Bad decoded buffer size".to_string(),
+        });
+    }
+
+    jpeg_decompress.read_scanlines_flat_into(dest);
+    // assert!(jpeg_decompress.finish_decompress());
+    if !jpeg_decompress.finish_decompress() {
+        return Err(NokhwaError::ProcessFrameError {
+            src: FrameFormat::MJPEG,
+            destination: "RGB888".to_string(),
+            error: "JPEG Decompressor did not finish.".to_string(),
+        });
+    }
+    Ok(())
+}
+
+#[cfg(not(all(feature = "mjpeg", not(target_arch = "wasm"))))]
+pub fn buf_mjpeg_to_rgb(data: &[u8], dest: &mut [u8], rgba: bool) -> Result<(), NokhwaError> {
+    Err(NokhwaError::NotImplementedError(
+        "Not available on WASM".to_string(),
+    ))
+}
+
+// For those maintaining this, I recommend you read: https://docs.microsoft.com/en-us/windows/win32/medfound/recommended-8-bit-yuv-formats-for-video-rendering#yuy2
+// https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB
+// and this too: https://stackoverflow.com/questions/16107165/convert-from-yuv-420-to-imagebgr-byte
+// The YUY2(YUYV) format is a 16 bit format. We read 4 bytes at a time to get 6 bytes of RGB888.
+// First, the YUY2 is converted to YCbCr 4:4:4 (4:2:2 -> 4:4:4)
+// then it is converted to 6 bytes (2 pixels) of RGB888
+/// Converts a YUYV 4:2:2 datastream to a RGB888 Stream. [For further reading](https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB)
+/// # Errors
+/// This may error when the data stream size is not divisible by 4, a i32 -> u8 conversion fails, or it fails to read from a certain index.
+pub fn yuyv422_to_rgb(data: &[u8], rgba: bool) -> Result<Vec<u8>, NokhwaError> {
+    if data.len() % 4 != 0 {
+        return Err(NokhwaError::ProcessFrameError {
+            src: FrameFormat::YUYV,
+            destination: "RGB888".to_string(),
+            error: "Assertion failure, the YUV stream isn't 4:2:2! (wrong number of bytes)"
+                .to_string(),
+        });
+    }
+
+    let pixel_size = if rgba { 4 } else { 3 };
+    // yuyv yields 2 3-byte pixels per yuyv chunk
+    let rgb_buf_size = (data.len() / 4) * (2 * pixel_size);
+
+    let mut dest = vec![0; rgb_buf_size];
+    buf_yuyv422_to_rgb(data, &mut dest, rgba)?;
+
+    Ok(dest)
+}
+
+/// Same as [`yuyv422_to_rgb`] but with a destination buffer instead of a return `Vec<u8>`
+/// # Errors
+/// If the stream is invalid YUYV, or the destination buffer is not large enough, this will error.
+pub fn buf_yuyv422_to_rgb(data: &[u8], dest: &mut [u8], rgba: bool) -> Result<(), NokhwaError> {
+    if data.len() % 4 != 0 {
+        return Err(NokhwaError::ProcessFrameError {
+            src: FrameFormat::YUYV,
+            destination: "RGB888".to_string(),
+            error: "Assertion failure, the YUV stream isn't 4:2:2! (wrong number of bytes)"
+                .to_string(),
+        });
+    }
+
+    let pixel_size = if rgba { 4 } else { 3 };
+    // yuyv yields 2 3-byte pixels per yuyv chunk
+    let rgb_buf_size = (data.len() / 4) * (2 * pixel_size);
+
+    if dest.len() != rgb_buf_size {
+        return Err(NokhwaError::ProcessFrameError {
+            src: FrameFormat::YUYV,
+            destination: "RGB888".to_string(),
+            error: format!("Assertion failure, the destination RGB buffer is of the wrong size! [expected: {rgb_buf_size}, actual: {}]", dest.len()),
+        });
+    }
+
+    let iter = data.chunks_exact(4);
+
+    if rgba {
+        let mut iter = iter
+            .flat_map(|yuyv| {
+                let y1 = i32::from(yuyv[0]);
+                let u = i32::from(yuyv[1]);
+                let y2 = i32::from(yuyv[2]);
+                let v = i32::from(yuyv[3]);
+                let pixel1 = yuyv444_to_rgba(y1, u, v);
+                let pixel2 = yuyv444_to_rgba(y2, u, v);
+                [pixel1, pixel2]
+            })
+            .flatten();
+        for i in dest.iter_mut().take(rgb_buf_size) {
+            *i = match iter.next() {
+                Some(v) => v,
+                None => {
+                    return Err(NokhwaError::ProcessFrameError {
+                        src: FrameFormat::YUYV,
+                        destination: "RGBA8888".to_string(),
+                        error: "Ran out of RGBA YUYV values! (this should not happen, please file an issue: l1npengtul/nokhwa)".to_string()
+                    })
+                }
+            }
+        }
+    } else {
+        let mut iter = iter
+            .flat_map(|yuyv| {
+                let y1 = i32::from(yuyv[0]);
+                let u = i32::from(yuyv[1]);
+                let y2 = i32::from(yuyv[2]);
+                let v = i32::from(yuyv[3]);
+                let pixel1 = yuyv444_to_rgb(y1, u, v);
+                let pixel2 = yuyv444_to_rgb(y2, u, v);
+                [pixel1, pixel2]
+            })
+            .flatten();
+
+        for i in dest.iter_mut().take(rgb_buf_size) {
+            *i = match iter.next() {
+                Some(v) => v,
+                None => {
+                    return Err(NokhwaError::ProcessFrameError {
+                        src: FrameFormat::YUYV,
+                        destination: "RGB888".to_string(),
+                        error: "Ran out of RGB YUYV values! (this should not happen, please file an issue: l1npengtul/nokhwa)".to_string()
+                    })
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+// equation from https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB
+/// Convert `YCbCr` 4:4:4 to a RGB888. [For further reading](https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB)
+#[allow(clippy::many_single_char_names)]
+#[allow(clippy::cast_possible_truncation)]
+#[allow(clippy::cast_sign_loss)]
+#[must_use]
+#[inline]
+pub fn yuyv444_to_rgb(y: i32, u: i32, v: i32) -> [u8; 3] {
+    let c298 = (y - 16) * 298;
+    let d = u - 128;
+    let e = v - 128;
+    let r = ((c298 + 409 * e + 128) >> 8) as u8;
+    let g = ((c298 - 100 * d - 208 * e + 128) >> 8) as u8;
+    let b = ((c298 + 516 * d + 128) >> 8) as u8;
+    [r, g, b]
+}
+
+// equation from https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB
+/// Convert `YCbCr` 4:4:4 to a RGBA8888. [For further reading](https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB)
+///
+/// Equivalent to [`yuyv444_to_rgb`] but with an alpha channel attached.
+#[allow(clippy::many_single_char_names)]
+#[must_use]
+#[inline]
+pub fn yuyv444_to_rgba(y: i32, u: i32, v: i32) -> [u8; 4] {
+    let [r, g, b] = yuyv444_to_rgb(y, u, v);
+    [r, g, b, 255]
+}
diff --git a/nokhwajs/LICENSE b/nokhwajs/LICENSE
deleted file mode 100644
index a612ad9..0000000
--- a/nokhwajs/LICENSE
+++ /dev/null
@@ -1,373 +0,0 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
-    means each individual or legal entity that creates, contributes to
-    the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-    means the combination of the Contributions of others (if any) used
-    by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-    means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-    means Source Code Form to which the initial Contributor has attached
-    the notice in Exhibit A, the Executable Form of such Source Code
-    Form, and Modifications of such Source Code Form, in each case
-    including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-    means
-
-    (a) that the initial Contributor has attached the notice described
-        in Exhibit B to the Covered Software; or
-
-    (b) that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the
-        terms of a Secondary License.
-
-1.6. "Executable Form"
-    means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-    means a work that combines Covered Software with other material, in
-    a separate file or files, that is not Covered Software.
-
-1.8. "License"
-    means this document.
-
-1.9. "Licensable"
-    means having the right to grant, to the maximum extent possible,
-    whether at the time of the initial grant or subsequently, any and
-    all of the rights conveyed by this License.
-
-1.10. "Modifications"
-    means any of the following:
-
-    (a) any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered
-        Software; or
-
-    (b) any new file in Source Code Form that contains any Covered
-        Software.
-
-1.11. "Patent Claims" of a Contributor
-    means any patent claim(s), including without limitation, method,
-    process, and apparatus claims, in any patent Licensable by such
-    Contributor that would be infringed, but for the grant of the
-    License, by the making, using, selling, offering for sale, having
-    made, import, or transfer of either its Contributions or its
-    Contributor Version.
-
-1.12. "Secondary License"
-    means either the GNU General Public License, Version 2.0, the GNU
-    Lesser General Public License, Version 2.1, the GNU Affero General
-    Public License, Version 3.0, or any later versions of those
-    licenses.
-
-1.13. "Source Code Form"
-    means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-    means an individual or a legal entity exercising rights under this
-    License. For legal entities, "You" includes any entity that
-    controls, is controlled by, or is under common control with You. For
-    purposes of this definition, "control" means (a) the power, direct
-    or indirect, to cause the direction or management of such entity,
-    whether by contract or otherwise, or (b) ownership of more than
-    fifty percent (50%) of the outstanding shares or beneficial
-    ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
-    Licensable by such Contributor to use, reproduce, make available,
-    modify, display, perform, distribute, and otherwise exploit its
-    Contributions, either on an unmodified basis, with Modifications, or
-    as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
-    for sale, have made, import, and otherwise transfer either its
-    Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
-    or
-
-(b) for infringements caused by: (i) Your and any other third party's
-    modifications of Covered Software, or (ii) the combination of its
-    Contributions with other software (except as part of its Contributor
-    Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
-    its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
-    Form, as described in Section 3.1, and You must inform recipients of
-    the Executable Form how they can obtain a copy of such Source Code
-    Form by reasonable means in a timely manner, at a charge no more
-    than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
-    License, or sublicense it under different terms, provided that the
-    license for the Executable Form does not attempt to limit or alter
-    the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-*                                                                      *
-*  6. Disclaimer of Warranty                                           *
-*  -------------------------                                           *
-*                                                                      *
-*  Covered Software is provided under this License on an "as is"       *
-*  basis, without warranty of any kind, either expressed, implied, or  *
-*  statutory, including, without limitation, warranties that the       *
-*  Covered Software is free of defects, merchantable, fit for a        *
-*  particular purpose or non-infringing. The entire risk as to the     *
-*  quality and performance of the Covered Software is with You.        *
-*  Should any Covered Software prove defective in any respect, You     *
-*  (not any Contributor) assume the cost of any necessary servicing,   *
-*  repair, or correction. This disclaimer of warranty constitutes an   *
-*  essential part of this License. No use of any Covered Software is   *
-*  authorized under this License except under this disclaimer.         *
-*                                                                      *
-************************************************************************
-
-************************************************************************
-*                                                                      *
-*  7. Limitation of Liability                                          *
-*  --------------------------                                          *
-*                                                                      *
-*  Under no circumstances and under no legal theory, whether tort      *
-*  (including negligence), contract, or otherwise, shall any           *
-*  Contributor, or anyone who distributes Covered Software as          *
-*  permitted above, be liable to You for any direct, indirect,         *
-*  special, incidental, or consequential damages of any character      *
-*  including, without limitation, damages for lost profits, loss of    *
-*  goodwill, work stoppage, computer failure or malfunction, or any    *
-*  and all other commercial damages or losses, even if such party      *
-*  shall have been informed of the possibility of such damages. This   *
-*  limitation of liability shall not apply to liability for death or   *
-*  personal injury resulting from such party's negligence to the       *
-*  extent applicable law prohibits such limitation. Some               *
-*  jurisdictions do not allow the exclusion or limitation of           *
-*  incidental or consequential damages, so this exclusion and          *
-*  limitation may not apply to You.                                    *
-*                                                                      *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
-  This Source Code Form is subject to the terms of the Mozilla Public
-  License, v. 2.0. If a copy of the MPL was not distributed with this
-  file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
-  This Source Code Form is "Incompatible With Secondary Licenses", as
-  defined by the Mozilla Public License, v. 2.0.
diff --git a/nokhwajs/README.md b/nokhwajs/README.md
deleted file mode 100644
index 99d4f2c..0000000
--- a/nokhwajs/README.md
+++ /dev/null
@@ -1,105 +0,0 @@
-# nokhwa
-Nokhwa(녹화): Korean word meaning "to record".
-
-A Simple-to-use, cross-platform Rust Webcam Capture Library
-
-## Using nokhwa
-Nokhwa can be added to your crate by adding it to your `Cargo.toml`:
-```.ignore
-[dependencies.nokhwa]
-// TODO: replace the "*" with the latest version of `nokhwa`
-version = "*"
-// TODO: add some features
-features = [""]
-```
-
-Most likely, you will only use functionality provided by the `Camera` struct. If you need lower-level access, you may instead opt to use the raw capture backends found at `nokhwa::backends::capture::*`.
-
-## Example
-
-```.ignore
-// set up the Camera
-let mut camera = Camera::new(
-    0, // index
-    Some(CameraFormat::new_from(640, 480, FrameFormat::MJPEG, 30)), // format
-)
-.unwrap();
-// open stream
-camera.open_stream().unwrap();
-loop {
-    let frame = camera.get_frame().unwrap();
-    println!("{}, {}", frame.width(), frame.height());
-}
-```
-A command line app made with `nokhwa` can be found in the `examples` folder.
-
-## API Support
-The table below lists current Nokhwa API support.
-- The `Backend` column signifies the backend.
-- The `Input` column signifies reading frames from the camera
-- The `Query` column signifies system device list support
-- The `Query-Device` column signifies reading device capabilities
-- The `Platform` column signifies what Platform this is availible on.
-
- | Backend                             | Input              | Query             | Query-Device       | Platform            |
- |-------------------------------------|--------------------|-------------------|--------------------|---------------------|
- | Video4Linux(`input-v4l`)            | ✅                 | ✅                 | ✅                 | Linux               |
- | MSMF(`input-msmf`)                  | ✅                 | ✅                 | ✅                 | Windows             |
- | AVFoundation(`input-avfoundatuin`)^^| ✅                 | ✅                 | ✅                 | Mac                 |
- | libuvc(`input-uvc`)                 | ✅                 | ✅                 | ✅                 | Linux, Windows, Mac |
- | OpenCV(`input-opencv`)^             | ✅                 | ❌                 | ❌                 | Linux, Windows, Mac |
- | IPCamera(`input-ipcam`/OpenCV)^     | ✅                 | ❌                 | ❌                 | Linux, Windows, Mac |
- | GStreamer(`input-gst`)              | ✅                 | ✅                 | ✅                 | Linux, Windows, Mac |
- | JS/WASM(`input-wasm`)               | ✅                 | ✅                 | ✅                 | Browser(Web)        |
-
- ✅: Working, 🔮 : Experimental, ❌ : Not Supported, 🚧: Planned/WIP
-
-  ^ = No CameraFormat setting support.
-  ^^ = No FPS setting support.
-## Feature
-The default feature includes nothing. Anything starting with `input-*` is a feature that enables the specific backend. 
-As a general rule of thumb, you would want to keep at least `input-uvc` or other backend that has querying enabled so you can get device information from `nokhwa`.
-
-`input-*` features:
- - `input-v4l`: Enables the `Video4Linux` backend. (linux)
- - `input-msmf`: Enables the `MediaFoundation` backennd. (Windows 7 or newer)
- - `input-avfoundation`: Enables the `AVFoundation` backend. (MacOSX 10.7)
- - `input-uvc`: Enables the `libuvc` backend. (cross-platform, libuvc statically-linked)
- - `input-opencv`: Enables the `opencv` backend. (cross-platform) 
- - `input-ipcam`: Enables the use of IP Cameras, please see the `NetworkCamera` struct. Note that this relies on `opencv`, so it will automatically enable the `input-opencv` feature.
- - `input-gst`: Enables the `gstreamer` backend. (cross-platform)
- - `input-jscam`: Enables the use of the `JSCamera` struct, which uses browser APIs. (Web)
-
-Conversely, anything that starts with `output-*` controls a feature that controls the output of something (usually a frame from the camera)
-
-`output-*` features:
- - `output-wgpu`: Enables the API to copy a frame directly into a `wgpu` texture.
- - `output-wasm`: Generate WASM API binding specific functions.
- - `output-threaded`: Enable the threaded/callback based camera. 
-
-Other features:
- - `decoding`: Enables `mozjpeg` decoding. Enabled by default.
-
- Please use the following command for `wasm-pack` in order to get a functional WASM binary:
- ```.ignore
- wasm-pack build --release -- --features "input-jscam, output-wasm,  test-fail-warning" --no-default-features 
- ```
- - `docs-only`: Documentation feature. Enabled for docs.rs builds.
- - `docs-nolink`: Build documentation **without** linking to any libraries. Enabled for docs.rs builds.
- - `test-fail-warning`: Fails on warning. Enabled in CI.
-You many want to pick and choose to reduce bloat.
-
-## Issues
-If you are making an issue, please make sure that
- - It has not been made yet
- - Attach what you were doing, your environment, steps to reproduce, and backtrace.
-Thank you!
-
-## Contributing
-Contributions are welcome!
- - Please `rustfmt` all your code and adhere to the clippy lints (unless necessary not to do so)
- - Please limit use of `unsafe`
- - All contributions are under the MPL 2.0 license unless otherwise specified
-
-## Minimum Service Rust Version
-`nokhwa` may build on older versions of `rustc`, but there is no guarantee except for the latest stable rust. 
diff --git a/nokhwajs/nokhwa.d.ts b/nokhwajs/nokhwa.d.ts
deleted file mode 100644
index 76fba7c..0000000
--- a/nokhwajs/nokhwa.d.ts
+++ /dev/null
@@ -1,824 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/**
-* Requests Webcam permissions from the browser using [`MediaDevices::get_user_media()`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaDevices.html#method.get_user_media) [MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* In exported JS bindings, the name of the function is `requestPermissions`. It may throw an exception.
-* @returns {any}
-*/
-export function requestPermissions(): any;
-/**
-* Queries Cameras using [`MediaDevices::enumerate_devices()`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaDevices.html#method.enumerate_devices) [MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* This is exported as `queryCameras`. It may throw an exception.
-* @returns {any}
-*/
-export function queryCameras(): any;
-/**
-* Queries the browser's supported constraints using [`navigator.mediaDevices.getSupportedConstraints()`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getSupportedConstraints)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* This is exported as `queryConstraints` and returns an array of strings.
-* @returns {Array<any>}
-*/
-export function queryConstraints(): Array<any>;
-/**
-* The enum describing the possible constraints for video in the browser.
-* - `DeviceID`: The ID of the device
-* - `GroupID`: The ID of the group that the device is in
-* - `AspectRatio`: The Aspect Ratio of the final stream
-* - `FacingMode`: What direction the camera is facing. This is more common on mobile. See [`JSCameraFacingMode`]
-* - `FrameRate`: The Frame Rate of the final stream
-* - `Height`: The height of the final stream in pixels
-* - `Width`: The width of the final stream in pixels
-* - `ResizeMode`: Whether the client can crop and/or scale the stream to match the resolution (width, height). See [`JSCameraResizeMode`]
-* See More: [`MediaTrackConstraints`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints) [`Capabilities, constraints, and settings`](https://developer.mozilla.org/en-US/docs/Web/API/Media_Streams_API/Constraints)
-* # JS-WASM
-* This is exported as `CameraSupportedCapabilities`.
-*/
-export enum CameraSupportedCapabilities {
-  DeviceID,
-  GroupID,
-  AspectRatio,
-  FacingMode,
-  FrameRate,
-  Height,
-  Width,
-  ResizeMode,
-}
-/**
-* The Facing Mode of the camera
-* - Any: Make no particular choice.
-* - Environment: The camera that shows the user's environment, such as the back camera of a smartphone
-* - User: The camera that shows the user, such as the front camera of a smartphone
-* - Left: The camera that shows the user but to their left, such as a camera that shows a user but to their left shoulder
-* - Right: The camera that shows the user but to their right, such as a camera that shows a user but to their right shoulder
-* See More: [`facingMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode)
-* # JS-WASM
-* This is exported as `CameraFacingMode`.
-*/
-export enum CameraFacingMode {
-  Any,
-  Environment,
-  User,
-  Left,
-  Right,
-}
-/**
-* Whether the browser can crop and/or scale to match the requested resolution.
-* - `Any`: Make no particular choice.
-* - `None`: Do not crop and/or scale.
-* - `CropAndScale`: Crop and/or scale to match the requested resolution.
-* See More: [`resizeMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#resizemode)
-* # JS-WASM
-* This is exported as `CameraResizeMode`.
-*/
-export enum CameraResizeMode {
-  Any,
-  None,
-  CropAndScale,
-}
-/**
-* Constraints to create a [`JSCamera`]
-*
-* If you want more options, see [`JSCameraConstraintsBuilder`]
-* # JS-WASM
-* This is exported as `CameraConstraints`.
-*/
-export class CameraConstraints {
-  free(): void;
-/**
-* Applies any modified constraints.
-* # JS-WASM
-* This is exported as `applyConstraints`.
-*/
-  applyConstraints(): void;
-/**
-* Gets the internal aspect ratio.
-* # JS-WASM
-* This is exported as `get_AspectRatio`.
-* @returns {number}
-*/
-  AspectRatio: number;
-/**
-* Gets the internal aspect ratio exact.
-* # JS-WASM
-* This is exported as `get_AspectRatioExact`.
-* @returns {boolean}
-*/
-  AspectRatioExact: boolean;
-/**
-* Gets the internal device id.
-* # JS-WASM
-* This is exported as `get_DeviceId`.
-* @returns {string}
-*/
-  DeviceId: string;
-/**
-* Gets the internal device id exact.
-* # JS-WASM
-* This is exported as `get_DeviceIdExact`.
-* @returns {boolean}
-*/
-  DeviceIdExact: boolean;
-/**
-* Gets the internal [`JSCameraFacingMode`].
-* # JS-WASM
-* This is exported as `get_FacingMode`.
-* @returns {number}
-*/
-  FacingMode: number;
-/**
-* Gets the internal facing mode exact.
-* # JS-WASM
-* This is exported as `get_FacingModeExact`.
-* @returns {boolean}
-*/
-  FacingModeExact: boolean;
-/**
-* Gets the internal frame rate.
-* # JS-WASM
-* This is exported as `get_FrameRate`.
-* @returns {number}
-*/
-  FrameRate: number;
-/**
-* Gets the internal frame rate exact.
-* # JS-WASM
-* This is exported as `get_FrameRateExact`.
-* @returns {boolean}
-*/
-  FrameRateExact: boolean;
-/**
-* Gets the internal group id.
-* # JS-WASM
-* This is exported as `get_GroupId`.
-* @returns {string}
-*/
-  GroupId: string;
-/**
-* Gets the internal group id exact.
-* # JS-WASM
-* This is exported as `get_GroupIdExact`.
-* @returns {boolean}
-*/
-  GroupIdExact: boolean;
-/**
-* Gets the maximum aspect ratio.
-* # JS-WASM
-* This is exported as `get_MaxAspectRatio`.
-* @returns {number | undefined}
-*/
-  MaxAspectRatio: number;
-/**
-* Gets the maximum internal frame rate.
-* # JS-WASM
-* This is exported as `get_MaxFrameRate`.
-* @returns {number | undefined}
-*/
-  MaxFrameRate: number;
-/**
-* Gets the maximum [`Resolution`].
-* # JS-WASM
-* This is exported as `get_MaxResolution`.
-* @returns {JSResolution | undefined}
-*/
-  MaxResolution: JSResolution;
-/**
-* Gets the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html)
-* # JS-WASM
-* This is exported as `get_MediaStreamConstraints`.
-* @returns {any}
-*/
-  readonly MediaStreamConstraints: any;
-/**
-* Gets the minimum aspect ratio of the [`JSCameraConstraints`].
-* # JS-WASM
-* This is exported as `get_MinAspectRatio`.
-* @returns {number | undefined}
-*/
-  MinAspectRatio: number;
-/**
-* Gets the minimum internal frame rate.
-* # JS-WASM
-* This is exported as `get_MinFrameRate`.
-* @returns {number | undefined}
-*/
-  MinFrameRate: number;
-/**
-* Gets the minimum [`Resolution`].
-* # JS-WASM
-* This is exported as `get_MinResolution`.
-* @returns {JSResolution | undefined}
-*/
-  MinResolution: JSResolution;
-/**
-* Gets the internal [`JSCameraResizeMode`].
-* # JS-WASM
-* This is exported as `get_ResizeMode`.
-* @returns {number}
-*/
-  ResizeMode: number;
-/**
-* Gets the internal resize mode exact.
-* # JS-WASM
-* This is exported as `get_ResizeModeExact`.
-* @returns {boolean}
-*/
-  ResizeModeExact: boolean;
-/**
-* Gets the internal [`Resolution`]
-* # JS-WASM
-* This is exported as `get_Resolution`.
-* @returns {JSResolution}
-*/
-  Resolution: JSResolution;
-/**
-* Gets the internal resolution exact.
-* # JS-WASM
-* This is exported as `get_ResolutionExact`.
-* @returns {boolean}
-*/
-  ResolutionExact: boolean;
-}
-/**
-* A builder that builds a [`JSCameraConstraints`] that is used to construct a [`JSCamera`].
-* See More: [`Constraints MDN`](https://developer.mozilla.org/en-US/docs/Web/API/Media_Streams_API/Constraints), [`Properties of Media Tracks MDN`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints)
-* # JS-WASM
-* This is exported as `CameraConstraintsBuilder`.
-*/
-export class CameraConstraintsBuilder {
-  free(): void;
-/**
-* Constructs a default [`JSCameraConstraintsBuilder`].
-* The constructed default [`JSCameraConstraintsBuilder`] has these settings:
-* - 480x234 min, 640x360 ideal, 1920x1080 max
-* - 10 FPS min, 15 FPS ideal, 30 FPS max
-* - 1.0 aspect ratio min, 1.77777777778 aspect ratio ideal, 2.0 aspect ratio max
-* - No `exact`s
-* # JS-WASM
-* This is exported as a constructor.
-*/
-  constructor();
-/**
-* Sets the minimum resolution for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-* # JS-WASM
-* This is exported as `set_MinResolution`.
-* @param {JSResolution} min_resolution
-* @returns {CameraConstraintsBuilder}
-*/
-  MinResolution(min_resolution: JSResolution): CameraConstraintsBuilder;
-/**
-* Sets the preferred resolution for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-* # JS-WASM
-* This is exported as `set_Resolution`.
-* @param {JSResolution} new_resolution
-* @returns {CameraConstraintsBuilder}
-*/
-  Resolution(new_resolution: JSResolution): CameraConstraintsBuilder;
-/**
-* Sets the maximum resolution for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-* # JS-WASM
-* This is exported as `set_MaxResolution`.
-* @param {JSResolution} max_resolution
-* @returns {CameraConstraintsBuilder}
-*/
-  MaxResolution(max_resolution: JSResolution): CameraConstraintsBuilder;
-/**
-* Sets whether the resolution fields ([`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width), [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height)/[`resolution`](crate::js_camera::JSCameraConstraintsBuilder::resolution))
-* should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-* Note that this will make the builder ignore [`min_resolution`](crate::js_camera::JSCameraConstraintsBuilder::min_resolution) and [`max_resolution`](crate::js_camera::JSCameraConstraintsBuilder::max_resolution).
-* # JS-WASM
-* This is exported as `set_ResolutionExact`.
-* @param {boolean} value
-* @returns {CameraConstraintsBuilder}
-*/
-  ResolutionExact(value: boolean): CameraConstraintsBuilder;
-/**
-* Sets the minimum aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-* # JS-WASM
-* This is exported as `set_MinAspectRatio`.
-* @param {number} ratio
-* @returns {CameraConstraintsBuilder}
-*/
-  MinAspectRatio(ratio: number): CameraConstraintsBuilder;
-/**
-* Sets the aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-* # JS-WASM
-* This is exported as `set_AspectRatio`.
-* @param {number} ratio
-* @returns {CameraConstraintsBuilder}
-*/
-  AspectRatio(ratio: number): CameraConstraintsBuilder;
-/**
-* Sets the maximum aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-* # JS-WASM
-* This is exported as `set_MaxAspectRatio`.
-* @param {number} ratio
-* @returns {CameraConstraintsBuilder}
-*/
-  MaxAspectRatio(ratio: number): CameraConstraintsBuilder;
-/**
-* Sets whether the [`aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::aspect_ratio) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-* Note that this will make the builder ignore [`min_aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::min_aspect_ratio) and [`max_aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::max_aspect_ratio).
-* # JS-WASM
-* This is exported as `set_AspectRatioExact`.
-* @param {boolean} value
-* @returns {CameraConstraintsBuilder}
-*/
-  AspectRatioExact(value: boolean): CameraConstraintsBuilder;
-/**
-* Sets the facing mode of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`facingMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode).
-* # JS-WASM
-* This is exported as `set_FacingMode`.
-* @param {number} facing_mode
-* @returns {CameraConstraintsBuilder}
-*/
-  FacingMode(facing_mode: number): CameraConstraintsBuilder;
-/**
-* Sets whether the [`facing_mode`](crate::js_camera::JSCameraConstraintsBuilder::facing_mode) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-* # JS-WASM
-* This is exported as `set_FacingModeExact`.
-* @param {boolean} value
-* @returns {CameraConstraintsBuilder}
-*/
-  FacingModeExact(value: boolean): CameraConstraintsBuilder;
-/**
-* Sets the minimum frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-* # JS-WASM
-* This is exported as `set_MinFrameRate`.
-* @param {number} fps
-* @returns {CameraConstraintsBuilder}
-*/
-  MinFrameRate(fps: number): CameraConstraintsBuilder;
-/**
-* Sets the frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-* # JS-WASM
-* This is exported as `set_FrameRate`.
-* @param {number} fps
-* @returns {CameraConstraintsBuilder}
-*/
-  FrameRate(fps: number): CameraConstraintsBuilder;
-/**
-* Sets the maximum frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-* # JS-WASM
-* This is exported as `set_MaxFrameRate`.
-* @param {number} fps
-* @returns {CameraConstraintsBuilder}
-*/
-  MaxFrameRate(fps: number): CameraConstraintsBuilder;
-/**
-* Sets whether the [`frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::frame_rate) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-* Note that this will make the builder ignore [`min_frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::min_frame_rate) and [`max_frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::max_frame_rate).
-* # JS-WASM
-* This is exported as `set_FrameRateExact`.
-* @param {boolean} value
-* @returns {CameraConstraintsBuilder}
-*/
-  FrameRateExact(value: boolean): CameraConstraintsBuilder;
-/**
-* Sets the resize mode of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`resizeMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#resizemode).
-* # JS-WASM
-* This is exported as `set_ResizeMode`.
-* @param {number} resize_mode
-* @returns {CameraConstraintsBuilder}
-*/
-  ResizeMode(resize_mode: number): CameraConstraintsBuilder;
-/**
-* Sets whether the [`resize_mode`](crate::js_camera::JSCameraConstraintsBuilder::resize_mode) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-* # JS-WASM
-* This is exported as `set_ResizeModeExact`.
-* @param {boolean} value
-* @returns {CameraConstraintsBuilder}
-*/
-  ResizeModeExact(value: boolean): CameraConstraintsBuilder;
-/**
-* Sets the device ID of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`deviceId`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/deviceId).
-* # JS-WASM
-* This is exported as `set_DeviceId`.
-* @param {string} id
-* @returns {CameraConstraintsBuilder}
-*/
-  DeviceId(id: string): CameraConstraintsBuilder;
-/**
-* Sets whether the [`device_id`](crate::js_camera::JSCameraConstraintsBuilder::device_id) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-* # JS-WASM
-* This is exported as `set_DeviceIdExact`.
-* @param {boolean} value
-* @returns {CameraConstraintsBuilder}
-*/
-  DeviceIdExact(value: boolean): CameraConstraintsBuilder;
-/**
-* Sets the group ID of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-*
-* Sets [`groupId`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/groupId).
-* # JS-WASM
-* This is exported as `set_GroupId`.
-* @param {string} id
-* @returns {CameraConstraintsBuilder}
-*/
-  GroupId(id: string): CameraConstraintsBuilder;
-/**
-* Sets whether the [`group_id`](crate::js_camera::JSCameraConstraintsBuilder::group_id) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-* # JS-WASM
-* This is exported as `set_GroupIdExact`.
-* @param {boolean} value
-* @returns {CameraConstraintsBuilder}
-*/
-  GroupIdExact(value: boolean): CameraConstraintsBuilder;
-/**
-* Builds the [`JSCameraConstraints`]. Wrapper for [`build`](crate::js_camera::JSCameraConstraintsBuilder::build)
-*
-* Fields that use exact are marked `exact`, otherwise are marked with `ideal`. If min-max are involved, they will use `min` and `max` accordingly.
-* # JS-WASM
-* This is exported as `buildCameraConstraints`.
-* @returns {CameraConstraints}
-*/
-  buildCameraConstraints(): CameraConstraints;
-}
-/**
-* Information about a Camera e.g. its name.
-* `description` amd `misc` may contain information that may differ from backend to backend. Refer to each backend for details.
-* `index` is a camera's index given to it by (usually) the OS usually in the order it is known to the system.
-* # JS-WASM
-* This is exported as a `JSCameraInfo`.
-*/
-export class JSCameraInfo {
-  free(): void;
-/**
-* Create a new [`CameraInfo`].
-* # JS-WASM
-* This is exported as a constructor for [`CameraInfo`].
-* @param {string} human_name
-* @param {string} description
-* @param {string} misc
-* @param {number} index
-*/
-  constructor(human_name: string, description: string, misc: string, index: number);
-/**
-* Get a reference to the device info's description.
-* # JS-WASM
-* This is exported as a `get_Description`.
-* @returns {string}
-*/
-  Description: string;
-/**
-* Get a reference to the device info's human readable name.
-* # JS-WASM
-* This is exported as a `get_HumanReadableName`.
-* @returns {string}
-*/
-  HumanReadableName: string;
-/**
-* Get a reference to the device info's index.
-* # JS-WASM
-* This is exported as a `get_Index`.
-* @returns {number}
-*/
-  Index: number;
-/**
-* Get a reference to the device info's misc.
-* # JS-WASM
-* This is exported as a `get_MiscString`.
-* @returns {string}
-*/
-  MiscString: string;
-}
-/**
-* Describes a Resolution.
-* This struct consists of a Width and a Height value (x,y). <br>
-* Note: the [`Ord`] implementation of this struct is flipped from highest to lowest.
-* # JS-WASM
-* This is exported as `JSResolution`
-*/
-export class JSResolution {
-  free(): void;
-/**
-* Create a new resolution from 2 image size coordinates.
-* # JS-WASM
-* This is exported as a constructor for [`Resolution`].
-* @param {number} x
-* @param {number} y
-*/
-  constructor(x: number, y: number);
-/**
-* Get the x (width) of Resolution
-* @returns {number}
-*/
-  x(): number;
-/**
-* Get the y (height) of Resolution
-* @returns {number}
-*/
-  y(): number;
-/**
-* Get the height of Resolution
-* # JS-WASM
-* This is exported as `get_Height`.
-* @returns {number}
-*/
-  readonly Height: number;
-/**
-* Get the width of Resolution
-* # JS-WASM
-* This is exported as `get_Width`.
-* @returns {number}
-*/
-  readonly Width: number;
-/**
-* @returns {number}
-*/
-  height_y: number;
-/**
-* @returns {number}
-*/
-  width_x: number;
-}
-/**
-* A wrapper around a [`MediaStream`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStream.html)
-* # JS-WASM
-* This is exported as `NokhwaCamera`.
-*/
-export class NokhwaCamera {
-  free(): void;
-/**
-* Creates a new [`JSCamera`] using [`JSCameraConstraints`].
-*
-* # Errors
-* This may error if permission is not granted, or the constraints are invalid.
-* # JS-WASM
-* This is the constructor for `NokhwaCamera`. It returns a promise and may throw an error.
-* @param {CameraConstraints} constraints
-*/
-  constructor(constraints: CameraConstraints);
-/**
-* Measures the [`Resolution`] of the internal stream. You usually do not need to call this.
-*
-* # Errors
-* If the camera fails to attach to the created `<video>`, this will error.
-*
-* # JS-WASM
-* This is exported as `measureResolution`. It may throw an error.
-*/
-  measureResolution(): void;
-/**
-* Applies any modified constraints.
-* # Errors
-* This function may return an error on failing to measure the resolution. Please check [`measure_resolution()`](crate::js_camera::JSCamera::measure_resolution) for details.
-* # JS-WASM
-* This is exported as `applyConstraints`. It may throw an error.
-*/
-  applyConstraints(): void;
-/**
-* Captures an [`ImageData`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.ImageData.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/ImageData) by drawing the image to a non-existent canvas.
-*
-* # Errors
-* If drawing to the canvas fails this will error.
-* # JS-WASM
-* This is exported as `captureImageData`. It may throw an error.
-* @returns {ImageData}
-*/
-  captureImageData(): ImageData;
-/**
-* Captures an [`ImageData`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.ImageData.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/ImageData) and then returns its `URL` as a string.
-* - `mime_type`: The mime type of the resulting URI. It is `image/png` by default (lossless) but can be set to `image/jpeg` or `image/webp` (lossy). Anything else is ignored.
-* - `image_quality`: A number between `0` and `1` indicating the resulting image quality in case you are using a lossy image mime type. The default value is 0.92, and all other values are ignored.
-*
-* # Errors
-* If drawing to the canvas fails or URI generation is not supported or fails this will error.
-* # JS-WASM
-* This is exported as `captureImageURI`. It may throw an error
-* @param {string} mime_type
-* @param {number} image_quality
-* @returns {string}
-*/
-  captureImageURI(mime_type: string, image_quality: number): string;
-/**
-* Creates an off-screen canvas and a `<video>` element (if not already attached) and returns a raw `Cow<[u8]>` RGBA frame.
-* # Errors
-* If a cast fails, the camera fails to attach, the currently attached node is invalid, or writing/reading from the canvas fails, this will error.
-* # JS-WASM
-* This is exported as `captureFrameRawData`. This may throw an error.
-* @returns {Uint8Array}
-*/
-  captureFrameRawData(): Uint8Array;
-/**
-* Copies camera frame to a `html_id`(by-id, canvas).
-*
-* If `generate_new` is true, the generated element will have an Id of `html_id`+`-canvas`. For example, if you pass "nokhwaisbest" for `html_id`, the new `<canvas>`'s ID will be "nokhwaisbest-canvas".
-* # Errors
-* If the internal canvas is not here, drawing fails, or a cast fails, this will error.
-* # JS-WASM
-* This is exported as `copyToCanvas`. It may error.
-* @param {string} html_id
-* @param {boolean} generate_new
-*/
-  copyToCanvas(html_id: string, generate_new: boolean): void;
-/**
-* Attaches camera to a `html_id`(by-id).
-*
-* If `generate_new` is true, the generated element will have an Id of `html_id`+`-video`. For example, if you pass "nokhwaisbest" for `html_id`, the new `<video>`'s ID will be "nokhwaisbest-video".
-* # Errors
-* If the camera fails to attach, fails to generate the video element, or a cast fails, this will error.
-* # JS-WASM
-* This is exported as `attachToElement`. It may throw an error.
-* @param {string} html_id
-* @param {boolean} generate_new
-*/
-  attachToElement(html_id: string, generate_new: boolean): void;
-/**
-* Detaches the camera from the `<video>` node.
-* # Errors
-* If the casting fails (the stored node is not a `<video>`) this will error.
-* # JS-WASM
-* This is exported as `detachCamera`. This may throw an error.
-*/
-  detachCamera(): void;
-/**
-* Stops all streams and detaches the camera.
-* # Errors
-* There may be an error while detaching the camera. Please see [`detach()`](crate::js_camera::JSCamera::detach) for more details.
-*/
-  stopAll(): void;
-/**
-* Gets the internal [`JSCameraConstraints`].
-* Most likely, you will edit this value by taking ownership of it, then feed it back into [`set_constraints`](crate::js_camera::JSCamera::set_constraints).
-* # JS-WASM
-* This is exported as `get_Constraints`.
-* @returns {CameraConstraints}
-*/
-  Constraints: CameraConstraints;
-/**
-* Gets the internal [`MediaStream`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStream.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream)
-* # JS-WASM
-* This is exported as `MediaStream`.
-* @returns {MediaStream}
-*/
-  readonly MediaStream: MediaStream;
-/**
-* Gets the internal [`Resolution`].
-*
-* Note: This value is only updated after you call [`measure_resolution`](crate::js_camera::JSCamera::measure_resolution)
-* # JS-WASM
-* This is exported as `get_Resolution`.
-* @returns {JSResolution}
-*/
-  readonly Resolution: JSResolution;
-}
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly requestPermissions: () => number;
-  readonly queryCameras: () => number;
-  readonly queryConstraints: () => number;
-  readonly __wbg_cameraconstraintsbuilder_free: (a: number) => void;
-  readonly cameraconstraintsbuilder_new: () => number;
-  readonly cameraconstraintsbuilder_Resolution: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_MaxResolution: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_ResolutionExact: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_MinAspectRatio: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_AspectRatio: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_MaxAspectRatio: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_AspectRatioExact: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_FacingMode: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_FacingModeExact: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_MinFrameRate: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_FrameRate: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_MaxFrameRate: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_FrameRateExact: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_ResizeMode: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_ResizeModeExact: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_DeviceId: (a: number, b: number, c: number) => number;
-  readonly cameraconstraintsbuilder_DeviceIdExact: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_GroupId: (a: number, b: number, c: number) => number;
-  readonly cameraconstraintsbuilder_GroupIdExact: (a: number, b: number) => number;
-  readonly cameraconstraintsbuilder_buildCameraConstraints: (a: number) => number;
-  readonly __wbg_cameraconstraints_free: (a: number) => void;
-  readonly cameraconstraints_media_constraints: (a: number) => number;
-  readonly cameraconstraints_min_resolution: (a: number) => number;
-  readonly cameraconstraints_set_min_resolution: (a: number, b: number) => void;
-  readonly cameraconstraints_resolution: (a: number) => number;
-  readonly cameraconstraints_set_resolution: (a: number, b: number) => void;
-  readonly cameraconstraints_max_resolution: (a: number) => number;
-  readonly cameraconstraints_set_max_resolution: (a: number, b: number) => void;
-  readonly cameraconstraints_resolution_exact: (a: number) => number;
-  readonly cameraconstraints_set_resolution_exact: (a: number, b: number) => void;
-  readonly cameraconstraints_min_aspect_ratio: (a: number, b: number) => void;
-  readonly cameraconstraints_set_min_aspect_ratio: (a: number, b: number) => void;
-  readonly cameraconstraints_aspect_ratio: (a: number) => number;
-  readonly cameraconstraints_set_aspect_ratio: (a: number, b: number) => void;
-  readonly cameraconstraints_max_aspect_ratio: (a: number, b: number) => void;
-  readonly cameraconstraints_set_max_aspect_ratio: (a: number, b: number) => void;
-  readonly cameraconstraints_aspect_ratio_exact: (a: number) => number;
-  readonly cameraconstraints_set_aspect_ratio_exact: (a: number, b: number) => void;
-  readonly cameraconstraints_facing_mode: (a: number) => number;
-  readonly cameraconstraints_set_facing_mode: (a: number, b: number) => void;
-  readonly cameraconstraints_facing_mode_exact: (a: number) => number;
-  readonly cameraconstraints_set_facing_mode_exact: (a: number, b: number) => void;
-  readonly cameraconstraints_min_frame_rate: (a: number, b: number) => void;
-  readonly cameraconstraints_set_min_frame_rate: (a: number, b: number) => void;
-  readonly cameraconstraints_frame_rate: (a: number) => number;
-  readonly cameraconstraints_set_frame_rate: (a: number, b: number) => void;
-  readonly cameraconstraints_max_frame_rate: (a: number, b: number) => void;
-  readonly cameraconstraints_set_max_frame_rate: (a: number, b: number) => void;
-  readonly cameraconstraints_frame_rate_exact: (a: number) => number;
-  readonly cameraconstraints_set_frame_rate_exact: (a: number, b: number) => void;
-  readonly cameraconstraints_resize_mode: (a: number) => number;
-  readonly cameraconstraints_set_resize_mode: (a: number, b: number) => void;
-  readonly cameraconstraints_resize_mode_exact: (a: number) => number;
-  readonly cameraconstraints_set_resize_mode_exact: (a: number, b: number) => void;
-  readonly cameraconstraints_device_id: (a: number, b: number) => void;
-  readonly cameraconstraints_set_device_id: (a: number, b: number, c: number) => void;
-  readonly cameraconstraints_device_id_exact: (a: number) => number;
-  readonly cameraconstraints_set_device_id_exact: (a: number, b: number) => void;
-  readonly cameraconstraints_group_id: (a: number, b: number) => void;
-  readonly cameraconstraints_set_group_id: (a: number, b: number, c: number) => void;
-  readonly cameraconstraints_group_id_exact: (a: number) => number;
-  readonly cameraconstraints_set_group_id_exact: (a: number, b: number) => void;
-  readonly cameraconstraints_applyConstraints: (a: number) => void;
-  readonly __wbg_nokhwacamera_free: (a: number) => void;
-  readonly nokhwacamera_js_new: (a: number) => number;
-  readonly nokhwacamera_constraints: (a: number) => number;
-  readonly nokhwacamera_js_set_constraints: (a: number, b: number) => void;
-  readonly nokhwacamera_resolution: (a: number) => number;
-  readonly nokhwacamera_measureResolution: (a: number) => void;
-  readonly nokhwacamera_applyConstraints: (a: number) => void;
-  readonly nokhwacamera_media_stream: (a: number) => number;
-  readonly nokhwacamera_captureImageData: (a: number) => number;
-  readonly nokhwacamera_captureImageURI: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly nokhwacamera_captureFrameRawData: (a: number, b: number) => void;
-  readonly nokhwacamera_copyToCanvas: (a: number, b: number, c: number, d: number) => void;
-  readonly nokhwacamera_attachToElement: (a: number, b: number, c: number, d: number) => void;
-  readonly nokhwacamera_detachCamera: (a: number) => void;
-  readonly nokhwacamera_stopAll: (a: number) => void;
-  readonly cameraconstraintsbuilder_MinResolution: (a: number, b: number) => number;
-  readonly __wbg_jsresolution_free: (a: number) => void;
-  readonly __wbg_get_jsresolution_width_x: (a: number) => number;
-  readonly __wbg_set_jsresolution_width_x: (a: number, b: number) => void;
-  readonly __wbg_get_jsresolution_height_y: (a: number) => number;
-  readonly __wbg_set_jsresolution_height_y: (a: number, b: number) => void;
-  readonly jsresolution_width: (a: number) => number;
-  readonly jsresolution_height: (a: number) => number;
-  readonly __wbg_jscamerainfo_free: (a: number) => void;
-  readonly jscamerainfo_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly jscamerainfo_human_name: (a: number, b: number) => void;
-  readonly jscamerainfo_set_human_name: (a: number, b: number, c: number) => void;
-  readonly jscamerainfo_description: (a: number, b: number) => void;
-  readonly jscamerainfo_set_description: (a: number, b: number, c: number) => void;
-  readonly jscamerainfo_misc: (a: number, b: number) => void;
-  readonly jscamerainfo_set_misc: (a: number, b: number, c: number) => void;
-  readonly jscamerainfo_index: (a: number) => number;
-  readonly jscamerainfo_set_index: (a: number, b: number) => void;
-  readonly jsresolution_new: (a: number, b: number) => number;
-  readonly jsresolution_x: (a: number) => number;
-  readonly jsresolution_y: (a: number) => number;
-  readonly __wbindgen_malloc: (a: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;
-  readonly __wbindgen_export_2: WebAssembly.Table;
-  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4e37a62ffa13b731: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
-  readonly __wbindgen_free: (a: number, b: number) => void;
-  readonly __wbindgen_exn_store: (a: number) => void;
-  readonly wasm_bindgen__convert__closures__invoke2_mut__h4d59381e7733ca36: (a: number, b: number, c: number, d: number) => void;
-}
-
-/**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {InitInput | Promise<InitInput>} module_or_path
-*
-* @returns {Promise<InitOutput>}
-*/
-export default function init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
diff --git a/nokhwajs/nokhwa.js b/nokhwajs/nokhwa.js
deleted file mode 100644
index af2006b..0000000
--- a/nokhwajs/nokhwa.js
+++ /dev/null
@@ -1,2055 +0,0 @@
-
-let wasm;
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-let cachegetUint8Memory0 = null;
-function getUint8Memory0() {
-    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
-        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachegetUint8Memory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
-}
-
-const heap = new Array(32).fill(undefined);
-
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
-function getObject(idx) { return heap[idx]; }
-
-function dropObject(idx) {
-    if (idx < 36) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-let cachegetFloat64Memory0 = null;
-function getFloat64Memory0() {
-    if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
-        cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachegetFloat64Memory0;
-}
-
-let cachegetInt32Memory0 = null;
-function getInt32Memory0() {
-    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
-        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
-    }
-    return cachegetInt32Memory0;
-}
-
-let WASM_VECTOR_LEN = 0;
-
-let cachedTextEncoder = new TextEncoder('utf-8');
-
-const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
-    ? function (arg, view) {
-    return cachedTextEncoder.encodeInto(arg, view);
-}
-    : function (arg, view) {
-    const buf = cachedTextEncoder.encode(arg);
-    view.set(buf);
-    return {
-        read: arg.length,
-        written: buf.length
-    };
-});
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length);
-        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len);
-
-    const mem = getUint8Memory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
-        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
-        const ret = encodeString(arg, view);
-
-        offset += ret.written;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
-}
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
-
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
-
-    return real;
-}
-function __wbg_adapter_26(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4e37a62ffa13b731(arg0, arg1, addHeapObject(arg2));
-}
-
-/**
-* Requests Webcam permissions from the browser using [`MediaDevices::get_user_media()`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaDevices.html#method.get_user_media) [MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* In exported JS bindings, the name of the function is `requestPermissions`. It may throw an exception.
-* @returns {any}
-*/
-export function requestPermissions() {
-    var ret = wasm.requestPermissions();
-    return takeObject(ret);
-}
-
-/**
-* Queries Cameras using [`MediaDevices::enumerate_devices()`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaDevices.html#method.enumerate_devices) [MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* This is exported as `queryCameras`. It may throw an exception.
-* @returns {any}
-*/
-export function queryCameras() {
-    var ret = wasm.queryCameras();
-    return takeObject(ret);
-}
-
-/**
-* Queries the browser's supported constraints using [`navigator.mediaDevices.getSupportedConstraints()`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getSupportedConstraints)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* This is exported as `queryConstraints` and returns an array of strings.
-* @returns {Array<any>}
-*/
-export function queryConstraints() {
-    var ret = wasm.queryConstraints();
-    return takeObject(ret);
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-    return instance.ptr;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_exn_store(addHeapObject(e));
-    }
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
-    getUint8Memory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-function __wbg_adapter_240(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures__invoke2_mut__h4d59381e7733ca36(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
-}
-
-/**
-* The enum describing the possible constraints for video in the browser.
-* - `DeviceID`: The ID of the device
-* - `GroupID`: The ID of the group that the device is in
-* - `AspectRatio`: The Aspect Ratio of the final stream
-* - `FacingMode`: What direction the camera is facing. This is more common on mobile. See [`JSCameraFacingMode`]
-* - `FrameRate`: The Frame Rate of the final stream
-* - `Height`: The height of the final stream in pixels
-* - `Width`: The width of the final stream in pixels
-* - `ResizeMode`: Whether the client can crop and/or scale the stream to match the resolution (width, height). See [`JSCameraResizeMode`]
-* See More: [`MediaTrackConstraints`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints) [`Capabilities, constraints, and settings`](https://developer.mozilla.org/en-US/docs/Web/API/Media_Streams_API/Constraints)
-* # JS-WASM
-* This is exported as `CameraSupportedCapabilities`.
-*/
-export const CameraSupportedCapabilities = Object.freeze({ DeviceID:0,"0":"DeviceID",GroupID:1,"1":"GroupID",AspectRatio:2,"2":"AspectRatio",FacingMode:3,"3":"FacingMode",FrameRate:4,"4":"FrameRate",Height:5,"5":"Height",Width:6,"6":"Width",ResizeMode:7,"7":"ResizeMode", });
-/**
-* The Facing Mode of the camera
-* - Any: Make no particular choice.
-* - Environment: The camera that shows the user's environment, such as the back camera of a smartphone
-* - User: The camera that shows the user, such as the front camera of a smartphone
-* - Left: The camera that shows the user but to their left, such as a camera that shows a user but to their left shoulder
-* - Right: The camera that shows the user but to their right, such as a camera that shows a user but to their right shoulder
-* See More: [`facingMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode)
-* # JS-WASM
-* This is exported as `CameraFacingMode`.
-*/
-export const CameraFacingMode = Object.freeze({ Any:0,"0":"Any",Environment:1,"1":"Environment",User:2,"2":"User",Left:3,"3":"Left",Right:4,"4":"Right", });
-/**
-* Whether the browser can crop and/or scale to match the requested resolution.
-* - `Any`: Make no particular choice.
-* - `None`: Do not crop and/or scale.
-* - `CropAndScale`: Crop and/or scale to match the requested resolution.
-* See More: [`resizeMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#resizemode)
-* # JS-WASM
-* This is exported as `CameraResizeMode`.
-*/
-export const CameraResizeMode = Object.freeze({ Any:0,"0":"Any",None:1,"1":"None",CropAndScale:2,"2":"CropAndScale", });
-/**
-* Constraints to create a [`JSCamera`]
-*
-* If you want more options, see [`JSCameraConstraintsBuilder`]
-* # JS-WASM
-* This is exported as `CameraConstraints`.
-*/
-export class CameraConstraints {
-
-    static __wrap(ptr) {
-        const obj = Object.create(CameraConstraints.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_cameraconstraints_free(ptr);
-    }
-    /**
-    * Gets the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html)
-    * # JS-WASM
-    * This is exported as `get_MediaStreamConstraints`.
-    * @returns {any}
-    */
-    get MediaStreamConstraints() {
-        var ret = wasm.cameraconstraints_media_constraints(this.ptr);
-        return takeObject(ret);
-    }
-    /**
-    * Gets the minimum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `get_MinResolution`.
-    * @returns {JSResolution | undefined}
-    */
-    get MinResolution() {
-        var ret = wasm.cameraconstraints_min_resolution(this.ptr);
-        return ret === 0 ? undefined : JSResolution.__wrap(ret);
-    }
-    /**
-    * Gets the minimum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `set_MinResolution`.
-    * @param {JSResolution} min_resolution
-    */
-    set MinResolution(min_resolution) {
-        _assertClass(min_resolution, JSResolution);
-        var ptr0 = min_resolution.ptr;
-        min_resolution.ptr = 0;
-        wasm.cameraconstraints_set_min_resolution(this.ptr, ptr0);
-    }
-    /**
-    * Gets the internal [`Resolution`]
-    * # JS-WASM
-    * This is exported as `get_Resolution`.
-    * @returns {JSResolution}
-    */
-    get Resolution() {
-        var ret = wasm.cameraconstraints_resolution(this.ptr);
-        return JSResolution.__wrap(ret);
-    }
-    /**
-    * Sets the internal [`Resolution`]
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_Resolution`.
-    * @param {JSResolution} preferred_resolution
-    */
-    set Resolution(preferred_resolution) {
-        _assertClass(preferred_resolution, JSResolution);
-        var ptr0 = preferred_resolution.ptr;
-        preferred_resolution.ptr = 0;
-        wasm.cameraconstraints_set_resolution(this.ptr, ptr0);
-    }
-    /**
-    * Gets the maximum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `get_MaxResolution`.
-    * @returns {JSResolution | undefined}
-    */
-    get MaxResolution() {
-        var ret = wasm.cameraconstraints_max_resolution(this.ptr);
-        return ret === 0 ? undefined : JSResolution.__wrap(ret);
-    }
-    /**
-    * Gets the maximum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `set_MaxResolution`.
-    * @param {JSResolution} max_resolution
-    */
-    set MaxResolution(max_resolution) {
-        _assertClass(max_resolution, JSResolution);
-        var ptr0 = max_resolution.ptr;
-        max_resolution.ptr = 0;
-        wasm.cameraconstraints_set_max_resolution(this.ptr, ptr0);
-    }
-    /**
-    * Gets the internal resolution exact.
-    * # JS-WASM
-    * This is exported as `get_ResolutionExact`.
-    * @returns {boolean}
-    */
-    get ResolutionExact() {
-        var ret = wasm.cameraconstraints_resolution_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal resolution exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_ResolutionExact`.
-    * @param {boolean} resolution_exact
-    */
-    set ResolutionExact(resolution_exact) {
-        wasm.cameraconstraints_set_resolution_exact(this.ptr, resolution_exact);
-    }
-    /**
-    * Gets the minimum aspect ratio of the [`JSCameraConstraints`].
-    * # JS-WASM
-    * This is exported as `get_MinAspectRatio`.
-    * @returns {number | undefined}
-    */
-    get MinAspectRatio() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_min_aspect_ratio(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getFloat64Memory0()[retptr / 8 + 1];
-            return r0 === 0 ? undefined : r1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the minimum aspect ratio of the [`JSCameraConstraints`].
-    * # JS-WASM
-    * This is exported as `set_MinAspectRatio`.
-    * @param {number} min_aspect_ratio
-    */
-    set MinAspectRatio(min_aspect_ratio) {
-        wasm.cameraconstraints_set_min_aspect_ratio(this.ptr, min_aspect_ratio);
-    }
-    /**
-    * Gets the internal aspect ratio.
-    * # JS-WASM
-    * This is exported as `get_AspectRatio`.
-    * @returns {number}
-    */
-    get AspectRatio() {
-        var ret = wasm.cameraconstraints_aspect_ratio(this.ptr);
-        return ret;
-    }
-    /**
-    * Sets the internal aspect ratio.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_AspectRatio`.
-    * @param {number} aspect_ratio
-    */
-    set AspectRatio(aspect_ratio) {
-        wasm.cameraconstraints_set_aspect_ratio(this.ptr, aspect_ratio);
-    }
-    /**
-    * Gets the maximum aspect ratio.
-    * # JS-WASM
-    * This is exported as `get_MaxAspectRatio`.
-    * @returns {number | undefined}
-    */
-    get MaxAspectRatio() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_max_aspect_ratio(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getFloat64Memory0()[retptr / 8 + 1];
-            return r0 === 0 ? undefined : r1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the maximum internal aspect ratio.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_MaxAspectRatio`.
-    * @param {number} max_aspect_ratio
-    */
-    set MaxAspectRatio(max_aspect_ratio) {
-        wasm.cameraconstraints_set_max_aspect_ratio(this.ptr, max_aspect_ratio);
-    }
-    /**
-    * Gets the internal aspect ratio exact.
-    * # JS-WASM
-    * This is exported as `get_AspectRatioExact`.
-    * @returns {boolean}
-    */
-    get AspectRatioExact() {
-        var ret = wasm.cameraconstraints_aspect_ratio_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal aspect ratio exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_AspectRatioExact`.
-    * @param {boolean} aspect_ratio_exact
-    */
-    set AspectRatioExact(aspect_ratio_exact) {
-        wasm.cameraconstraints_set_aspect_ratio_exact(this.ptr, aspect_ratio_exact);
-    }
-    /**
-    * Gets the internal [`JSCameraFacingMode`].
-    * # JS-WASM
-    * This is exported as `get_FacingMode`.
-    * @returns {number}
-    */
-    get FacingMode() {
-        var ret = wasm.cameraconstraints_facing_mode(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Sets the internal [`JSCameraFacingMode`]
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FacingMode`.
-    * @param {number} facing_mode
-    */
-    set FacingMode(facing_mode) {
-        wasm.cameraconstraints_set_facing_mode(this.ptr, facing_mode);
-    }
-    /**
-    * Gets the internal facing mode exact.
-    * # JS-WASM
-    * This is exported as `get_FacingModeExact`.
-    * @returns {boolean}
-    */
-    get FacingModeExact() {
-        var ret = wasm.cameraconstraints_facing_mode_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal facing mode exact
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FacingModeExact`.
-    * @param {boolean} facing_mode_exact
-    */
-    set FacingModeExact(facing_mode_exact) {
-        wasm.cameraconstraints_set_facing_mode_exact(this.ptr, facing_mode_exact);
-    }
-    /**
-    * Gets the minimum internal frame rate.
-    * # JS-WASM
-    * This is exported as `get_MinFrameRate`.
-    * @returns {number | undefined}
-    */
-    get MinFrameRate() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_min_frame_rate(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return r0 === 0 ? undefined : r1 >>> 0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the minimum internal frame rate
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_MinFrameRate`.
-    * @param {number} min_frame_rate
-    */
-    set MinFrameRate(min_frame_rate) {
-        wasm.cameraconstraints_set_min_frame_rate(this.ptr, min_frame_rate);
-    }
-    /**
-    * Gets the internal frame rate.
-    * # JS-WASM
-    * This is exported as `get_FrameRate`.
-    * @returns {number}
-    */
-    get FrameRate() {
-        var ret = wasm.cameraconstraints_frame_rate(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Sets the internal frame rate
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FrameRate`.
-    * @param {number} frame_rate
-    */
-    set FrameRate(frame_rate) {
-        wasm.cameraconstraints_set_frame_rate(this.ptr, frame_rate);
-    }
-    /**
-    * Gets the maximum internal frame rate.
-    * # JS-WASM
-    * This is exported as `get_MaxFrameRate`.
-    * @returns {number | undefined}
-    */
-    get MaxFrameRate() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_max_frame_rate(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return r0 === 0 ? undefined : r1 >>> 0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the maximum internal frame rate
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_MaxFrameRate`.
-    * @param {number} max_frame_rate
-    */
-    set MaxFrameRate(max_frame_rate) {
-        wasm.cameraconstraints_set_max_frame_rate(this.ptr, max_frame_rate);
-    }
-    /**
-    * Gets the internal frame rate exact.
-    * # JS-WASM
-    * This is exported as `get_FrameRateExact`.
-    * @returns {boolean}
-    */
-    get FrameRateExact() {
-        var ret = wasm.cameraconstraints_frame_rate_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal frame rate exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FrameRateExact`.
-    * @param {boolean} frame_rate_exact
-    */
-    set FrameRateExact(frame_rate_exact) {
-        wasm.cameraconstraints_set_frame_rate_exact(this.ptr, frame_rate_exact);
-    }
-    /**
-    * Gets the internal [`JSCameraResizeMode`].
-    * # JS-WASM
-    * This is exported as `get_ResizeMode`.
-    * @returns {number}
-    */
-    get ResizeMode() {
-        var ret = wasm.cameraconstraints_resize_mode(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Sets the internal [`JSCameraResizeMode`]
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_ResizeMode`.
-    * @param {number} resize_mode
-    */
-    set ResizeMode(resize_mode) {
-        wasm.cameraconstraints_set_resize_mode(this.ptr, resize_mode);
-    }
-    /**
-    * Gets the internal resize mode exact.
-    * # JS-WASM
-    * This is exported as `get_ResizeModeExact`.
-    * @returns {boolean}
-    */
-    get ResizeModeExact() {
-        var ret = wasm.cameraconstraints_resize_mode_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal resize mode exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_ResizeModeExact`.
-    * @param {boolean} resize_mode_exact
-    */
-    set ResizeModeExact(resize_mode_exact) {
-        wasm.cameraconstraints_set_resize_mode_exact(this.ptr, resize_mode_exact);
-    }
-    /**
-    * Gets the internal device id.
-    * # JS-WASM
-    * This is exported as `get_DeviceId`.
-    * @returns {string}
-    */
-    get DeviceId() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_device_id(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Sets the internal device ID.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_DeviceId`.
-    * @param {string} device_id
-    */
-    set DeviceId(device_id) {
-        var ptr0 = passStringToWasm0(device_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.cameraconstraints_set_device_id(this.ptr, ptr0, len0);
-    }
-    /**
-    * Gets the internal device id exact.
-    * # JS-WASM
-    * This is exported as `get_DeviceIdExact`.
-    * @returns {boolean}
-    */
-    get DeviceIdExact() {
-        var ret = wasm.cameraconstraints_device_id_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal device ID exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_DeviceIdExact`.
-    * @param {boolean} device_id_exact
-    */
-    set DeviceIdExact(device_id_exact) {
-        wasm.cameraconstraints_set_device_id_exact(this.ptr, device_id_exact);
-    }
-    /**
-    * Gets the internal group id.
-    * # JS-WASM
-    * This is exported as `get_GroupId`.
-    * @returns {string}
-    */
-    get GroupId() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_group_id(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Sets the internal group ID.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_GroupId`.
-    * @param {string} group_id
-    */
-    set GroupId(group_id) {
-        var ptr0 = passStringToWasm0(group_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.cameraconstraints_set_group_id(this.ptr, ptr0, len0);
-    }
-    /**
-    * Gets the internal group id exact.
-    * # JS-WASM
-    * This is exported as `get_GroupIdExact`.
-    * @returns {boolean}
-    */
-    get GroupIdExact() {
-        var ret = wasm.cameraconstraints_group_id_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal group ID exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_GroupIdExact`.
-    * @param {boolean} group_id_exact
-    */
-    set GroupIdExact(group_id_exact) {
-        wasm.cameraconstraints_set_group_id_exact(this.ptr, group_id_exact);
-    }
-    /**
-    * Applies any modified constraints.
-    * # JS-WASM
-    * This is exported as `applyConstraints`.
-    */
-    applyConstraints() {
-        wasm.cameraconstraints_applyConstraints(this.ptr);
-    }
-}
-/**
-* A builder that builds a [`JSCameraConstraints`] that is used to construct a [`JSCamera`].
-* See More: [`Constraints MDN`](https://developer.mozilla.org/en-US/docs/Web/API/Media_Streams_API/Constraints), [`Properties of Media Tracks MDN`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints)
-* # JS-WASM
-* This is exported as `CameraConstraintsBuilder`.
-*/
-export class CameraConstraintsBuilder {
-
-    static __wrap(ptr) {
-        const obj = Object.create(CameraConstraintsBuilder.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_cameraconstraintsbuilder_free(ptr);
-    }
-    /**
-    * Constructs a default [`JSCameraConstraintsBuilder`].
-    * The constructed default [`JSCameraConstraintsBuilder`] has these settings:
-    * - 480x234 min, 640x360 ideal, 1920x1080 max
-    * - 10 FPS min, 15 FPS ideal, 30 FPS max
-    * - 1.0 aspect ratio min, 1.77777777778 aspect ratio ideal, 2.0 aspect ratio max
-    * - No `exact`s
-    * # JS-WASM
-    * This is exported as a constructor.
-    */
-    constructor() {
-        var ret = wasm.cameraconstraintsbuilder_new();
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the minimum resolution for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-    * # JS-WASM
-    * This is exported as `set_MinResolution`.
-    * @param {JSResolution} min_resolution
-    * @returns {CameraConstraintsBuilder}
-    */
-    MinResolution(min_resolution) {
-        const ptr = this.__destroy_into_raw();
-        _assertClass(min_resolution, JSResolution);
-        var ptr0 = min_resolution.ptr;
-        min_resolution.ptr = 0;
-        var ret = wasm.cameraconstraintsbuilder_MaxResolution(ptr, ptr0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the preferred resolution for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-    * # JS-WASM
-    * This is exported as `set_Resolution`.
-    * @param {JSResolution} new_resolution
-    * @returns {CameraConstraintsBuilder}
-    */
-    Resolution(new_resolution) {
-        const ptr = this.__destroy_into_raw();
-        _assertClass(new_resolution, JSResolution);
-        var ptr0 = new_resolution.ptr;
-        new_resolution.ptr = 0;
-        var ret = wasm.cameraconstraintsbuilder_Resolution(ptr, ptr0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the maximum resolution for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-    * # JS-WASM
-    * This is exported as `set_MaxResolution`.
-    * @param {JSResolution} max_resolution
-    * @returns {CameraConstraintsBuilder}
-    */
-    MaxResolution(max_resolution) {
-        const ptr = this.__destroy_into_raw();
-        _assertClass(max_resolution, JSResolution);
-        var ptr0 = max_resolution.ptr;
-        max_resolution.ptr = 0;
-        var ret = wasm.cameraconstraintsbuilder_MaxResolution(ptr, ptr0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the resolution fields ([`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width), [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height)/[`resolution`](crate::js_camera::JSCameraConstraintsBuilder::resolution))
-    * should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * Note that this will make the builder ignore [`min_resolution`](crate::js_camera::JSCameraConstraintsBuilder::min_resolution) and [`max_resolution`](crate::js_camera::JSCameraConstraintsBuilder::max_resolution).
-    * # JS-WASM
-    * This is exported as `set_ResolutionExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    ResolutionExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_ResolutionExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the minimum aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-    * # JS-WASM
-    * This is exported as `set_MinAspectRatio`.
-    * @param {number} ratio
-    * @returns {CameraConstraintsBuilder}
-    */
-    MinAspectRatio(ratio) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MinAspectRatio(ptr, ratio);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-    * # JS-WASM
-    * This is exported as `set_AspectRatio`.
-    * @param {number} ratio
-    * @returns {CameraConstraintsBuilder}
-    */
-    AspectRatio(ratio) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_AspectRatio(ptr, ratio);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the maximum aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-    * # JS-WASM
-    * This is exported as `set_MaxAspectRatio`.
-    * @param {number} ratio
-    * @returns {CameraConstraintsBuilder}
-    */
-    MaxAspectRatio(ratio) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MaxAspectRatio(ptr, ratio);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::aspect_ratio) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * Note that this will make the builder ignore [`min_aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::min_aspect_ratio) and [`max_aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::max_aspect_ratio).
-    * # JS-WASM
-    * This is exported as `set_AspectRatioExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    AspectRatioExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_AspectRatioExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the facing mode of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`facingMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode).
-    * # JS-WASM
-    * This is exported as `set_FacingMode`.
-    * @param {number} facing_mode
-    * @returns {CameraConstraintsBuilder}
-    */
-    FacingMode(facing_mode) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FacingMode(ptr, facing_mode);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`facing_mode`](crate::js_camera::JSCameraConstraintsBuilder::facing_mode) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_FacingModeExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    FacingModeExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FacingModeExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the minimum frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-    * # JS-WASM
-    * This is exported as `set_MinFrameRate`.
-    * @param {number} fps
-    * @returns {CameraConstraintsBuilder}
-    */
-    MinFrameRate(fps) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MinFrameRate(ptr, fps);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-    * # JS-WASM
-    * This is exported as `set_FrameRate`.
-    * @param {number} fps
-    * @returns {CameraConstraintsBuilder}
-    */
-    FrameRate(fps) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FrameRate(ptr, fps);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the maximum frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-    * # JS-WASM
-    * This is exported as `set_MaxFrameRate`.
-    * @param {number} fps
-    * @returns {CameraConstraintsBuilder}
-    */
-    MaxFrameRate(fps) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MaxFrameRate(ptr, fps);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::frame_rate) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * Note that this will make the builder ignore [`min_frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::min_frame_rate) and [`max_frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::max_frame_rate).
-    * # JS-WASM
-    * This is exported as `set_FrameRateExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    FrameRateExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FrameRateExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the resize mode of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`resizeMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#resizemode).
-    * # JS-WASM
-    * This is exported as `set_ResizeMode`.
-    * @param {number} resize_mode
-    * @returns {CameraConstraintsBuilder}
-    */
-    ResizeMode(resize_mode) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_ResizeMode(ptr, resize_mode);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`resize_mode`](crate::js_camera::JSCameraConstraintsBuilder::resize_mode) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_ResizeModeExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    ResizeModeExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_ResizeModeExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the device ID of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`deviceId`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/deviceId).
-    * # JS-WASM
-    * This is exported as `set_DeviceId`.
-    * @param {string} id
-    * @returns {CameraConstraintsBuilder}
-    */
-    DeviceId(id) {
-        const ptr = this.__destroy_into_raw();
-        var ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        var ret = wasm.cameraconstraintsbuilder_DeviceId(ptr, ptr0, len0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`device_id`](crate::js_camera::JSCameraConstraintsBuilder::device_id) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_DeviceIdExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    DeviceIdExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_DeviceIdExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the group ID of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`groupId`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/groupId).
-    * # JS-WASM
-    * This is exported as `set_GroupId`.
-    * @param {string} id
-    * @returns {CameraConstraintsBuilder}
-    */
-    GroupId(id) {
-        const ptr = this.__destroy_into_raw();
-        var ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        var ret = wasm.cameraconstraintsbuilder_GroupId(ptr, ptr0, len0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`group_id`](crate::js_camera::JSCameraConstraintsBuilder::group_id) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_GroupIdExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    GroupIdExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_GroupIdExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Builds the [`JSCameraConstraints`]. Wrapper for [`build`](crate::js_camera::JSCameraConstraintsBuilder::build)
-    *
-    * Fields that use exact are marked `exact`, otherwise are marked with `ideal`. If min-max are involved, they will use `min` and `max` accordingly.
-    * # JS-WASM
-    * This is exported as `buildCameraConstraints`.
-    * @returns {CameraConstraints}
-    */
-    buildCameraConstraints() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_buildCameraConstraints(ptr);
-        return CameraConstraints.__wrap(ret);
-    }
-}
-/**
-* Information about a Camera e.g. its name.
-* `description` amd `misc` may contain information that may differ from backend to backend. Refer to each backend for details.
-* `index` is a camera's index given to it by (usually) the OS usually in the order it is known to the system.
-* # JS-WASM
-* This is exported as a `JSCameraInfo`.
-*/
-export class JSCameraInfo {
-
-    static __wrap(ptr) {
-        const obj = Object.create(JSCameraInfo.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jscamerainfo_free(ptr);
-    }
-    /**
-    * Create a new [`CameraInfo`].
-    * # JS-WASM
-    * This is exported as a constructor for [`CameraInfo`].
-    * @param {string} human_name
-    * @param {string} description
-    * @param {string} misc
-    * @param {number} index
-    */
-    constructor(human_name, description, misc, index) {
-        var ptr0 = passStringToWasm0(human_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        var ptr1 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = passStringToWasm0(misc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len2 = WASM_VECTOR_LEN;
-        var ret = wasm.jscamerainfo_new(ptr0, len0, ptr1, len1, ptr2, len2, index);
-        return JSCameraInfo.__wrap(ret);
-    }
-    /**
-    * Get a reference to the device info's human readable name.
-    * # JS-WASM
-    * This is exported as a `get_HumanReadableName`.
-    * @returns {string}
-    */
-    get HumanReadableName() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.jscamerainfo_human_name(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Set the device info's human name.
-    * # JS-WASM
-    * This is exported as a `set_HumanReadableName`.
-    * @param {string} human_name
-    */
-    set HumanReadableName(human_name) {
-        var ptr0 = passStringToWasm0(human_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.jscamerainfo_set_human_name(this.ptr, ptr0, len0);
-    }
-    /**
-    * Get a reference to the device info's description.
-    * # JS-WASM
-    * This is exported as a `get_Description`.
-    * @returns {string}
-    */
-    get Description() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.jscamerainfo_description(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Set the device info's description.
-    * # JS-WASM
-    * This is exported as a `set_Description`.
-    * @param {string} description
-    */
-    set Description(description) {
-        var ptr0 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.jscamerainfo_set_description(this.ptr, ptr0, len0);
-    }
-    /**
-    * Get a reference to the device info's misc.
-    * # JS-WASM
-    * This is exported as a `get_MiscString`.
-    * @returns {string}
-    */
-    get MiscString() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.jscamerainfo_misc(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Set the device info's misc.
-    * # JS-WASM
-    * This is exported as a `set_MiscString`.
-    * @param {string} misc
-    */
-    set MiscString(misc) {
-        var ptr0 = passStringToWasm0(misc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.jscamerainfo_set_misc(this.ptr, ptr0, len0);
-    }
-    /**
-    * Get a reference to the device info's index.
-    * # JS-WASM
-    * This is exported as a `get_Index`.
-    * @returns {number}
-    */
-    get Index() {
-        var ret = wasm.jscamerainfo_index(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Set the device info's index.
-    * # JS-WASM
-    * This is exported as a `set_Index`.
-    * @param {number} index
-    */
-    set Index(index) {
-        wasm.jscamerainfo_set_index(this.ptr, index);
-    }
-}
-/**
-* Describes a Resolution.
-* This struct consists of a Width and a Height value (x,y). <br>
-* Note: the [`Ord`] implementation of this struct is flipped from highest to lowest.
-* # JS-WASM
-* This is exported as `JSResolution`
-*/
-export class JSResolution {
-
-    static __wrap(ptr) {
-        const obj = Object.create(JSResolution.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsresolution_free(ptr);
-    }
-    /**
-    * @returns {number}
-    */
-    get width_x() {
-        var ret = wasm.__wbg_get_jsresolution_width_x(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * @param {number} arg0
-    */
-    set width_x(arg0) {
-        wasm.__wbg_set_jsresolution_width_x(this.ptr, arg0);
-    }
-    /**
-    * @returns {number}
-    */
-    get height_y() {
-        var ret = wasm.__wbg_get_jsresolution_height_y(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * @param {number} arg0
-    */
-    set height_y(arg0) {
-        wasm.__wbg_set_jsresolution_height_y(this.ptr, arg0);
-    }
-    /**
-    * Create a new resolution from 2 image size coordinates.
-    * # JS-WASM
-    * This is exported as a constructor for [`Resolution`].
-    * @param {number} x
-    * @param {number} y
-    */
-    constructor(x, y) {
-        var ret = wasm.jsresolution_new(x, y);
-        return JSResolution.__wrap(ret);
-    }
-    /**
-    * Get the width of Resolution
-    * # JS-WASM
-    * This is exported as `get_Width`.
-    * @returns {number}
-    */
-    get Width() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.jsresolution_width(ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Get the height of Resolution
-    * # JS-WASM
-    * This is exported as `get_Height`.
-    * @returns {number}
-    */
-    get Height() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.jsresolution_height(ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Get the x (width) of Resolution
-    * @returns {number}
-    */
-    x() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.jsresolution_width(ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Get the y (height) of Resolution
-    * @returns {number}
-    */
-    y() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.jsresolution_height(ptr);
-        return ret >>> 0;
-    }
-}
-/**
-* A wrapper around a [`MediaStream`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStream.html)
-* # JS-WASM
-* This is exported as `NokhwaCamera`.
-*/
-export class NokhwaCamera {
-
-    static __wrap(ptr) {
-        const obj = Object.create(NokhwaCamera.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_nokhwacamera_free(ptr);
-    }
-    /**
-    * Creates a new [`JSCamera`] using [`JSCameraConstraints`].
-    *
-    * # Errors
-    * This may error if permission is not granted, or the constraints are invalid.
-    * # JS-WASM
-    * This is the constructor for `NokhwaCamera`. It returns a promise and may throw an error.
-    * @param {CameraConstraints} constraints
-    */
-    constructor(constraints) {
-        _assertClass(constraints, CameraConstraints);
-        var ptr0 = constraints.ptr;
-        constraints.ptr = 0;
-        var ret = wasm.nokhwacamera_js_new(ptr0);
-        return takeObject(ret);
-    }
-    /**
-    * Gets the internal [`JSCameraConstraints`].
-    * Most likely, you will edit this value by taking ownership of it, then feed it back into [`set_constraints`](crate::js_camera::JSCamera::set_constraints).
-    * # JS-WASM
-    * This is exported as `get_Constraints`.
-    * @returns {CameraConstraints}
-    */
-    get Constraints() {
-        var ret = wasm.nokhwacamera_constraints(this.ptr);
-        return CameraConstraints.__wrap(ret);
-    }
-    /**
-    * Sets the [`JSCameraConstraints`]. This calls [`apply_constraints`](crate::js_camera::JSCamera::apply_constraints) internally.
-    *
-    * # Errors
-    * See [`apply_constraints`](crate::js_camera::JSCamera::apply_constraints).
-    * # JS-WASM
-    * This is exported as `set_Constraints`. It may throw an error.
-    * @param {CameraConstraints} constraints
-    */
-    set Constraints(constraints) {
-        _assertClass(constraints, CameraConstraints);
-        var ptr0 = constraints.ptr;
-        constraints.ptr = 0;
-        wasm.nokhwacamera_js_set_constraints(this.ptr, ptr0);
-    }
-    /**
-    * Gets the internal [`Resolution`].
-    *
-    * Note: This value is only updated after you call [`measure_resolution`](crate::js_camera::JSCamera::measure_resolution)
-    * # JS-WASM
-    * This is exported as `get_Resolution`.
-    * @returns {JSResolution}
-    */
-    get Resolution() {
-        var ret = wasm.nokhwacamera_resolution(this.ptr);
-        return JSResolution.__wrap(ret);
-    }
-    /**
-    * Measures the [`Resolution`] of the internal stream. You usually do not need to call this.
-    *
-    * # Errors
-    * If the camera fails to attach to the created `<video>`, this will error.
-    *
-    * # JS-WASM
-    * This is exported as `measureResolution`. It may throw an error.
-    */
-    measureResolution() {
-        wasm.nokhwacamera_measureResolution(this.ptr);
-    }
-    /**
-    * Applies any modified constraints.
-    * # Errors
-    * This function may return an error on failing to measure the resolution. Please check [`measure_resolution()`](crate::js_camera::JSCamera::measure_resolution) for details.
-    * # JS-WASM
-    * This is exported as `applyConstraints`. It may throw an error.
-    */
-    applyConstraints() {
-        wasm.nokhwacamera_applyConstraints(this.ptr);
-    }
-    /**
-    * Gets the internal [`MediaStream`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStream.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream)
-    * # JS-WASM
-    * This is exported as `MediaStream`.
-    * @returns {MediaStream}
-    */
-    get MediaStream() {
-        var ret = wasm.nokhwacamera_media_stream(this.ptr);
-        return takeObject(ret);
-    }
-    /**
-    * Captures an [`ImageData`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.ImageData.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/ImageData) by drawing the image to a non-existent canvas.
-    *
-    * # Errors
-    * If drawing to the canvas fails this will error.
-    * # JS-WASM
-    * This is exported as `captureImageData`. It may throw an error.
-    * @returns {ImageData}
-    */
-    captureImageData() {
-        var ret = wasm.nokhwacamera_captureImageData(this.ptr);
-        return takeObject(ret);
-    }
-    /**
-    * Captures an [`ImageData`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.ImageData.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/ImageData) and then returns its `URL` as a string.
-    * - `mime_type`: The mime type of the resulting URI. It is `image/png` by default (lossless) but can be set to `image/jpeg` or `image/webp` (lossy). Anything else is ignored.
-    * - `image_quality`: A number between `0` and `1` indicating the resulting image quality in case you are using a lossy image mime type. The default value is 0.92, and all other values are ignored.
-    *
-    * # Errors
-    * If drawing to the canvas fails or URI generation is not supported or fails this will error.
-    * # JS-WASM
-    * This is exported as `captureImageURI`. It may throw an error
-    * @param {string} mime_type
-    * @param {number} image_quality
-    * @returns {string}
-    */
-    captureImageURI(mime_type, image_quality) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            var ptr0 = passStringToWasm0(mime_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            var len0 = WASM_VECTOR_LEN;
-            wasm.nokhwacamera_captureImageURI(retptr, this.ptr, ptr0, len0, image_quality);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Creates an off-screen canvas and a `<video>` element (if not already attached) and returns a raw `Cow<[u8]>` RGBA frame.
-    * # Errors
-    * If a cast fails, the camera fails to attach, the currently attached node is invalid, or writing/reading from the canvas fails, this will error.
-    * # JS-WASM
-    * This is exported as `captureFrameRawData`. This may throw an error.
-    * @returns {Uint8Array}
-    */
-    captureFrameRawData() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.nokhwacamera_captureFrameRawData(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Copies camera frame to a `html_id`(by-id, canvas).
-    *
-    * If `generate_new` is true, the generated element will have an Id of `html_id`+`-canvas`. For example, if you pass "nokhwaisbest" for `html_id`, the new `<canvas>`'s ID will be "nokhwaisbest-canvas".
-    * # Errors
-    * If the internal canvas is not here, drawing fails, or a cast fails, this will error.
-    * # JS-WASM
-    * This is exported as `copyToCanvas`. It may error.
-    * @param {string} html_id
-    * @param {boolean} generate_new
-    */
-    copyToCanvas(html_id, generate_new) {
-        var ptr0 = passStringToWasm0(html_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.nokhwacamera_copyToCanvas(this.ptr, ptr0, len0, generate_new);
-    }
-    /**
-    * Attaches camera to a `html_id`(by-id).
-    *
-    * If `generate_new` is true, the generated element will have an Id of `html_id`+`-video`. For example, if you pass "nokhwaisbest" for `html_id`, the new `<video>`'s ID will be "nokhwaisbest-video".
-    * # Errors
-    * If the camera fails to attach, fails to generate the video element, or a cast fails, this will error.
-    * # JS-WASM
-    * This is exported as `attachToElement`. It may throw an error.
-    * @param {string} html_id
-    * @param {boolean} generate_new
-    */
-    attachToElement(html_id, generate_new) {
-        var ptr0 = passStringToWasm0(html_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.nokhwacamera_attachToElement(this.ptr, ptr0, len0, generate_new);
-    }
-    /**
-    * Detaches the camera from the `<video>` node.
-    * # Errors
-    * If the casting fails (the stored node is not a `<video>`) this will error.
-    * # JS-WASM
-    * This is exported as `detachCamera`. This may throw an error.
-    */
-    detachCamera() {
-        wasm.nokhwacamera_detachCamera(this.ptr);
-    }
-    /**
-    * Stops all streams and detaches the camera.
-    * # Errors
-    * There may be an error while detaching the camera. Please see [`detach()`](crate::js_camera::JSCamera::detach) for more details.
-    */
-    stopAll() {
-        wasm.nokhwacamera_stopAll(this.ptr);
-    }
-}
-
-async function load(module, imports) {
-    if (typeof Response === 'function' && module instanceof Response) {
-        if (typeof WebAssembly.instantiateStreaming === 'function') {
-            try {
-                return await WebAssembly.instantiateStreaming(module, imports);
-
-            } catch (e) {
-                if (module.headers.get('Content-Type') != 'application/wasm') {
-                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-
-                } else {
-                    throw e;
-                }
-            }
-        }
-
-        const bytes = await module.arrayBuffer();
-        return await WebAssembly.instantiate(bytes, imports);
-
-    } else {
-        const instance = await WebAssembly.instantiate(module, imports);
-
-        if (instance instanceof WebAssembly.Instance) {
-            return { instance, module };
-
-        } else {
-            return instance;
-        }
-    }
-}
-
-async function init(input) {
-    if (typeof input === 'undefined') {
-        input = new URL('nokhwa_bg.wasm', import.meta.url);
-    }
-    const imports = {};
-    imports.wbg = {};
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        var ret = getStringFromWasm0(arg0, arg1);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_nokhwacamera_new = function(arg0) {
-        var ret = NokhwaCamera.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
-        takeObject(arg0);
-    };
-    imports.wbg.__wbindgen_number_new = function(arg0) {
-        var ret = arg0;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        var ret = getObject(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        var ret = getObject(arg0) === undefined;
-        return ret;
-    };
-    imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
-        var ret = getObject(arg0) === getObject(arg1);
-        return ret;
-    };
-    imports.wbg.__wbg_jscamerainfo_new = function(arg0) {
-        var ret = JSCameraInfo.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cb_drop = function(arg0) {
-        const obj = takeObject(arg0).original;
-        if (obj.cnt-- == 1) {
-            obj.a = 0;
-            return true;
-        }
-        var ret = false;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Window_fac4f1f8e3c61c1f = function(arg0) {
-        var ret = getObject(arg0) instanceof Window;
-        return ret;
-    };
-    imports.wbg.__wbg_document_29fb71d7cea23553 = function(arg0) {
-        var ret = getObject(arg0).document;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_navigator_f92994fb618b3c03 = function(arg0) {
-        var ret = getObject(arg0).navigator;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_body_3f92bb47323529c7 = function(arg0) {
-        var ret = getObject(arg0).body;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_createElement_8a4eea3a05d8804d = function() { return handleError(function (arg0, arg1, arg2) {
-        var ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_getElementById_8ef24477d541ac87 = function(arg0, arg1, arg2) {
-        var ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_clone_d5865137805e11f0 = function(arg0) {
-        var ret = getObject(arg0).clone();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_getTracks_b3a13f4ac20b87c3 = function(arg0) {
-        var ret = getObject(arg0).getTracks();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_getVideoTracks_0756ff6c988b94ca = function(arg0) {
-        var ret = getObject(arg0).getVideoTracks();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_appendChild_f52907370cfda116 = function() { return handleError(function (arg0, arg1) {
-        var ret = getObject(arg0).appendChild(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_removeChild_a5b181d3ef9e42e8 = function() { return handleError(function (arg0, arg1) {
-        var ret = getObject(arg0).removeChild(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_instanceof_MediaDeviceInfo_40c073339e661eaf = function(arg0) {
-        var ret = getObject(arg0) instanceof MediaDeviceInfo;
-        return ret;
-    };
-    imports.wbg.__wbg_deviceId_e0d2b92a301e4559 = function(arg0, arg1) {
-        var ret = getObject(arg1).deviceId;
-        var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    };
-    imports.wbg.__wbg_kind_b07d33c74c81012a = function(arg0) {
-        var ret = getObject(arg0).kind;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_groupId_014e664b0dd834e2 = function(arg0, arg1) {
-        var ret = getObject(arg1).groupId;
-        var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    };
-    imports.wbg.__wbg_enumerateDevices_9072d82313d22f95 = function() { return handleError(function (arg0) {
-        var ret = getObject(arg0).enumerateDevices();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_getSupportedConstraints_64e60b65d4d85a84 = function(arg0) {
-        var ret = getObject(arg0).getSupportedConstraints();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_getUserMedia_e6eae49c6d7ada49 = function() { return handleError(function (arg0, arg1) {
-        var ret = getObject(arg0).getUserMedia(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_setid_53f28f9ba86fa773 = function(arg0, arg1, arg2) {
-        getObject(arg0).id = getStringFromWasm0(arg1, arg2);
-    };
-    imports.wbg.__wbg_setAttribute_936a229ff5ccc5c9 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-        getObject(arg0).setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-    }, arguments) };
-    imports.wbg.__wbg_log_4989d5b00a0cc297 = function(arg0) {
-        console.log(getObject(arg0));
-    };
-    imports.wbg.__wbg_sethidden_ee4d19afe8cd207b = function(arg0, arg1) {
-        getObject(arg0).hidden = arg1 !== 0;
-    };
-    imports.wbg.__wbg_instanceof_CanvasRenderingContext2d_c3096464126a8635 = function(arg0) {
-        var ret = getObject(arg0) instanceof CanvasRenderingContext2D;
-        return ret;
-    };
-    imports.wbg.__wbg_drawImage_05c14fd60955efe6 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-        getObject(arg0).drawImage(getObject(arg1), arg2, arg3, arg4, arg5);
-    }, arguments) };
-    imports.wbg.__wbg_drawImage_369314fa18826781 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-        getObject(arg0).drawImage(getObject(arg1), arg2, arg3, arg4, arg5);
-    }, arguments) };
-    imports.wbg.__wbg_getImageData_95d4ea9a3956ff99 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-        var ret = getObject(arg0).getImageData(arg1, arg2, arg3, arg4);
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_setsrcObject_84ea10d6459b8777 = function(arg0, arg1) {
-        getObject(arg0).srcObject = getObject(arg1);
-    };
-    imports.wbg.__wbg_mediaDevices_95a03876999ceedf = function() { return handleError(function (arg0) {
-        var ret = getObject(arg0).mediaDevices;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_instanceof_HtmlCanvasElement_f6c37daa8caa628a = function(arg0) {
-        var ret = getObject(arg0) instanceof HTMLCanvasElement;
-        return ret;
-    };
-    imports.wbg.__wbg_setwidth_6ffbc02dcd566284 = function(arg0, arg1) {
-        getObject(arg0).width = arg1 >>> 0;
-    };
-    imports.wbg.__wbg_setheight_dade0779787da2d7 = function(arg0, arg1) {
-        getObject(arg0).height = arg1 >>> 0;
-    };
-    imports.wbg.__wbg_getContext_591a34067d6e74f2 = function() { return handleError(function (arg0, arg1, arg2) {
-        var ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_toDataURL_506af7317355ef50 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-        var ret = getObject(arg1).toDataURL(getStringFromWasm0(arg2, arg3), getObject(arg4));
-        var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    }, arguments) };
-    imports.wbg.__wbg_data_3b5132cf708f3fa5 = function(arg0, arg1) {
-        var ret = getObject(arg1).data;
-        var ptr0 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    };
-    imports.wbg.__wbg_instanceof_HtmlVideoElement_fc0a10eaf320d2aa = function(arg0) {
-        var ret = getObject(arg0) instanceof HTMLVideoElement;
-        return ret;
-    };
-    imports.wbg.__wbg_setwidth_2f7483815ec07834 = function(arg0, arg1) {
-        getObject(arg0).width = arg1 >>> 0;
-    };
-    imports.wbg.__wbg_setheight_2b2cb0447984d19f = function(arg0, arg1) {
-        getObject(arg0).height = arg1 >>> 0;
-    };
-    imports.wbg.__wbg_label_b3c3caf2db14bc2f = function(arg0, arg1) {
-        var ret = getObject(arg1).label;
-        var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    };
-    imports.wbg.__wbg_getSettings_9ae79ab256250296 = function(arg0) {
-        var ret = getObject(arg0).getSettings();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_stop_b2e5a05e9a386ba1 = function(arg0) {
-        getObject(arg0).stop();
-    };
-    imports.wbg.__wbg_get_73c087db0a496c21 = function(arg0, arg1) {
-        var ret = getObject(arg0)[arg1 >>> 0];
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_length_c5fa152b8c3f311f = function(arg0) {
-        var ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbg_new_ec75d0d5815be736 = function() {
-        var ret = new Array();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_newnoargs_1a11e7e8c906996c = function(arg0, arg1) {
-        var ret = new Function(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_193281ce8fd4b1c8 = function() {
-        var ret = new Map();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_call_e91f71ddf1f45cff = function() { return handleError(function (arg0, arg1) {
-        var ret = getObject(arg0).call(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_new_4b48f9f8159fea77 = function() {
-        var ret = new Object();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_from_28631399e1e647cb = function(arg0) {
-        var ret = Array.from(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_push_0daae9343162dbe7 = function(arg0, arg1) {
-        var ret = getObject(arg0).push(getObject(arg1));
-        return ret;
-    };
-    imports.wbg.__wbg_call_e3c72355d091d5d4 = function() { return handleError(function (arg0, arg1, arg2) {
-        var ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_get_55c6cc12fb6a83f9 = function(arg0, arg1) {
-        var ret = getObject(arg0).get(getObject(arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_b9dad32fc360b408 = function(arg0, arg1, arg2) {
-        var ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_assign_39a180d12d813399 = function(arg0, arg1) {
-        var ret = Object.assign(getObject(arg0), getObject(arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_entries_a3fad9ebd955672b = function(arg0) {
-        var ret = Object.entries(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_keys_9f3a5511f779059c = function(arg0) {
-        var ret = Object.keys(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_119f8177d8717c43 = function(arg0, arg1) {
-        try {
-            var state0 = {a: arg0, b: arg1};
-            var cb0 = (arg0, arg1) => {
-                const a = state0.a;
-                state0.a = 0;
-                try {
-                    return __wbg_adapter_240(a, state0.b, arg0, arg1);
-                } finally {
-                    state0.a = a;
-                }
-            };
-            var ret = new Promise(cb0);
-            return addHeapObject(ret);
-        } finally {
-            state0.a = state0.b = 0;
-        }
-    };
-    imports.wbg.__wbg_resolve_7161ec6fd5b1cd29 = function(arg0) {
-        var ret = Promise.resolve(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_then_6d5072fec3fdb237 = function(arg0, arg1) {
-        var ret = getObject(arg0).then(getObject(arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_then_4f3c7f6f3d36634a = function(arg0, arg1, arg2) {
-        var ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_self_b4546ea7b590539e = function() { return handleError(function () {
-        var ret = self.self;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_window_c279fea81f426a68 = function() { return handleError(function () {
-        var ret = window.window;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_globalThis_038a6ea0ff17789f = function() { return handleError(function () {
-        var ret = globalThis.globalThis;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_global_4f93ce884bcee597 = function() { return handleError(function () {
-        var ret = global.global;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_set_d29a397c9cc5d746 = function() { return handleError(function (arg0, arg1, arg2) {
-        var ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
-        const obj = getObject(arg1);
-        var ret = typeof(obj) === 'number' ? obj : undefined;
-        getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
-        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
-    };
-    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
-        const obj = getObject(arg1);
-        var ret = typeof(obj) === 'string' ? obj : undefined;
-        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    };
-    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
-        var ret = debugString(getObject(arg1));
-        var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    };
-    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbindgen_rethrow = function(arg0) {
-        throw takeObject(arg0);
-    };
-    imports.wbg.__wbindgen_closure_wrapper767 = function(arg0, arg1, arg2) {
-        var ret = makeMutClosure(arg0, arg1, 65, __wbg_adapter_26);
-        return addHeapObject(ret);
-    };
-
-    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
-        input = fetch(input);
-    }
-
-
-
-    const { instance, module } = await load(await input, imports);
-
-    wasm = instance.exports;
-    init.__wbindgen_wasm_module = module;
-
-    return wasm;
-}
-
-export default init;
-
diff --git a/nokhwajs/nokhwa_bg.js b/nokhwajs/nokhwa_bg.js
deleted file mode 100644
index bab4a27..0000000
--- a/nokhwajs/nokhwa_bg.js
+++ /dev/null
@@ -1,2083 +0,0 @@
-import * as wasm from './nokhwa_bg.wasm';
-
-const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
-
-let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-let cachegetUint8Memory0 = null;
-function getUint8Memory0() {
-    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
-        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachegetUint8Memory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
-}
-
-const heap = new Array(32).fill(undefined);
-
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
-function getObject(idx) { return heap[idx]; }
-
-function dropObject(idx) {
-    if (idx < 36) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-let cachegetFloat64Memory0 = null;
-function getFloat64Memory0() {
-    if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
-        cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachegetFloat64Memory0;
-}
-
-let cachegetInt32Memory0 = null;
-function getInt32Memory0() {
-    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
-        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
-    }
-    return cachegetInt32Memory0;
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
-
-let cachedTextEncoder = new lTextEncoder('utf-8');
-
-const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
-    ? function (arg, view) {
-    return cachedTextEncoder.encodeInto(arg, view);
-}
-    : function (arg, view) {
-    const buf = cachedTextEncoder.encode(arg);
-    view.set(buf);
-    return {
-        read: arg.length,
-        written: buf.length
-    };
-});
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length);
-        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len);
-
-    const mem = getUint8Memory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
-        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
-        const ret = encodeString(arg, view);
-
-        offset += ret.written;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
-}
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
-
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
-
-    return real;
-}
-function __wbg_adapter_26(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha79fab5af65c7d0b(arg0, arg1, addHeapObject(arg2));
-}
-
-/**
-* Requests Webcam permissions from the browser using [`MediaDevices::get_user_media()`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaDevices.html#method.get_user_media) [MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* In exported JS bindings, the name of the function is `requestPermissions`. It may throw an exception.
-* @returns {any}
-*/
-export function requestPermissions() {
-    var ret = wasm.requestPermissions();
-    return takeObject(ret);
-}
-
-/**
-* Queries Cameras using [`MediaDevices::enumerate_devices()`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaDevices.html#method.enumerate_devices) [MDN](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* This is exported as `queryCameras`. It may throw an exception.
-* @returns {any}
-*/
-export function queryCameras() {
-    var ret = wasm.queryCameras();
-    return takeObject(ret);
-}
-
-/**
-* Queries the browser's supported constraints using [`navigator.mediaDevices.getSupportedConstraints()`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getSupportedConstraints)
-* # Errors
-* This will error if there is no valid web context or the web API is not supported
-* # JS-WASM
-* This is exported as `queryConstraints` and returns an array of strings.
-* @returns {Array<any>}
-*/
-export function queryConstraints() {
-    var ret = wasm.queryConstraints();
-    return takeObject(ret);
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-    return instance.ptr;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_exn_store(addHeapObject(e));
-    }
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
-    getUint8Memory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-function __wbg_adapter_240(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures__invoke2_mut__hf03b20e2f7b10743(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
-}
-
-/**
-* The enum describing the possible constraints for video in the browser.
-* - `DeviceID`: The ID of the device
-* - `GroupID`: The ID of the group that the device is in
-* - `AspectRatio`: The Aspect Ratio of the final stream
-* - `FacingMode`: What direction the camera is facing. This is more common on mobile. See [`JSCameraFacingMode`]
-* - `FrameRate`: The Frame Rate of the final stream
-* - `Height`: The height of the final stream in pixels
-* - `Width`: The width of the final stream in pixels
-* - `ResizeMode`: Whether the client can crop and/or scale the stream to match the resolution (width, height). See [`JSCameraResizeMode`]
-* See More: [`MediaTrackConstraints`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints) [`Capabilities, constraints, and settings`](https://developer.mozilla.org/en-US/docs/Web/API/Media_Streams_API/Constraints)
-* # JS-WASM
-* This is exported as `CameraSupportedCapabilities`.
-*/
-export const CameraSupportedCapabilities = Object.freeze({ DeviceID:0,"0":"DeviceID",GroupID:1,"1":"GroupID",AspectRatio:2,"2":"AspectRatio",FacingMode:3,"3":"FacingMode",FrameRate:4,"4":"FrameRate",Height:5,"5":"Height",Width:6,"6":"Width",ResizeMode:7,"7":"ResizeMode", });
-/**
-* The Facing Mode of the camera
-* - Any: Make no particular choice.
-* - Environment: The camera that shows the user's environment, such as the back camera of a smartphone
-* - User: The camera that shows the user, such as the front camera of a smartphone
-* - Left: The camera that shows the user but to their left, such as a camera that shows a user but to their left shoulder
-* - Right: The camera that shows the user but to their right, such as a camera that shows a user but to their right shoulder
-* See More: [`facingMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode)
-* # JS-WASM
-* This is exported as `CameraFacingMode`.
-*/
-export const CameraFacingMode = Object.freeze({ Any:0,"0":"Any",Environment:1,"1":"Environment",User:2,"2":"User",Left:3,"3":"Left",Right:4,"4":"Right", });
-/**
-* Whether the browser can crop and/or scale to match the requested resolution.
-* - `Any`: Make no particular choice.
-* - `None`: Do not crop and/or scale.
-* - `CropAndScale`: Crop and/or scale to match the requested resolution.
-* See More: [`resizeMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#resizemode)
-* # JS-WASM
-* This is exported as `CameraResizeMode`.
-*/
-export const CameraResizeMode = Object.freeze({ Any:0,"0":"Any",None:1,"1":"None",CropAndScale:2,"2":"CropAndScale", });
-/**
-* Constraints to create a [`JSCamera`]
-*
-* If you want more options, see [`JSCameraConstraintsBuilder`]
-* # JS-WASM
-* This is exported as `CameraConstraints`.
-*/
-export class CameraConstraints {
-
-    static __wrap(ptr) {
-        const obj = Object.create(CameraConstraints.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_cameraconstraints_free(ptr);
-    }
-    /**
-    * Gets the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html)
-    * # JS-WASM
-    * This is exported as `get_MediaStreamConstraints`.
-    * @returns {any}
-    */
-    get MediaStreamConstraints() {
-        var ret = wasm.cameraconstraints_media_constraints(this.ptr);
-        return takeObject(ret);
-    }
-    /**
-    * Gets the minimum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `get_MinResolution`.
-    * @returns {Resolution | undefined}
-    */
-    get MinResolution() {
-        var ret = wasm.cameraconstraints_min_resolution(this.ptr);
-        return ret === 0 ? undefined : Resolution.__wrap(ret);
-    }
-    /**
-    * Gets the minimum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `set_MinResolution`.
-    * @param {Resolution} min_resolution
-    */
-    set MinResolution(min_resolution) {
-        _assertClass(min_resolution, Resolution);
-        var ptr0 = min_resolution.ptr;
-        min_resolution.ptr = 0;
-        wasm.cameraconstraints_set_min_resolution(this.ptr, ptr0);
-    }
-    /**
-    * Gets the internal [`Resolution`]
-    * # JS-WASM
-    * This is exported as `get_Resolution`.
-    * @returns {Resolution}
-    */
-    get Resolution() {
-        var ret = wasm.cameraconstraints_resolution(this.ptr);
-        return Resolution.__wrap(ret);
-    }
-    /**
-    * Sets the internal [`Resolution`]
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_Resolution`.
-    * @param {Resolution} preferred_resolution
-    */
-    set Resolution(preferred_resolution) {
-        _assertClass(preferred_resolution, Resolution);
-        var ptr0 = preferred_resolution.ptr;
-        preferred_resolution.ptr = 0;
-        wasm.cameraconstraints_set_resolution(this.ptr, ptr0);
-    }
-    /**
-    * Gets the maximum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `get_MaxResolution`.
-    * @returns {Resolution | undefined}
-    */
-    get MaxResolution() {
-        var ret = wasm.cameraconstraints_max_resolution(this.ptr);
-        return ret === 0 ? undefined : Resolution.__wrap(ret);
-    }
-    /**
-    * Gets the maximum [`Resolution`].
-    * # JS-WASM
-    * This is exported as `set_MaxResolution`.
-    * @param {Resolution} max_resolution
-    */
-    set MaxResolution(max_resolution) {
-        _assertClass(max_resolution, Resolution);
-        var ptr0 = max_resolution.ptr;
-        max_resolution.ptr = 0;
-        wasm.cameraconstraints_set_max_resolution(this.ptr, ptr0);
-    }
-    /**
-    * Gets the internal resolution exact.
-    * # JS-WASM
-    * This is exported as `get_ResolutionExact`.
-    * @returns {boolean}
-    */
-    get ResolutionExact() {
-        var ret = wasm.cameraconstraints_resolution_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal resolution exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_ResolutionExact`.
-    * @param {boolean} resolution_exact
-    */
-    set ResolutionExact(resolution_exact) {
-        wasm.cameraconstraints_set_resolution_exact(this.ptr, resolution_exact);
-    }
-    /**
-    * Gets the minimum aspect ratio of the [`JSCameraConstraints`].
-    * # JS-WASM
-    * This is exported as `get_MinAspectRatio`.
-    * @returns {number | undefined}
-    */
-    get MinAspectRatio() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_min_aspect_ratio(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getFloat64Memory0()[retptr / 8 + 1];
-            return r0 === 0 ? undefined : r1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the minimum aspect ratio of the [`JSCameraConstraints`].
-    * # JS-WASM
-    * This is exported as `set_MinAspectRatio`.
-    * @param {number} min_aspect_ratio
-    */
-    set MinAspectRatio(min_aspect_ratio) {
-        wasm.cameraconstraints_set_min_aspect_ratio(this.ptr, min_aspect_ratio);
-    }
-    /**
-    * Gets the internal aspect ratio.
-    * # JS-WASM
-    * This is exported as `get_AspectRatio`.
-    * @returns {number}
-    */
-    get AspectRatio() {
-        var ret = wasm.cameraconstraints_aspect_ratio(this.ptr);
-        return ret;
-    }
-    /**
-    * Sets the internal aspect ratio.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_AspectRatio`.
-    * @param {number} aspect_ratio
-    */
-    set AspectRatio(aspect_ratio) {
-        wasm.cameraconstraints_set_aspect_ratio(this.ptr, aspect_ratio);
-    }
-    /**
-    * Gets the maximum aspect ratio.
-    * # JS-WASM
-    * This is exported as `get_MaxAspectRatio`.
-    * @returns {number | undefined}
-    */
-    get MaxAspectRatio() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_max_aspect_ratio(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getFloat64Memory0()[retptr / 8 + 1];
-            return r0 === 0 ? undefined : r1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the maximum internal aspect ratio.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_MaxAspectRatio`.
-    * @param {number} max_aspect_ratio
-    */
-    set MaxAspectRatio(max_aspect_ratio) {
-        wasm.cameraconstraints_set_max_aspect_ratio(this.ptr, max_aspect_ratio);
-    }
-    /**
-    * Gets the internal aspect ratio exact.
-    * # JS-WASM
-    * This is exported as `get_AspectRatioExact`.
-    * @returns {boolean}
-    */
-    get AspectRatioExact() {
-        var ret = wasm.cameraconstraints_aspect_ratio_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal aspect ratio exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_AspectRatioExact`.
-    * @param {boolean} aspect_ratio_exact
-    */
-    set AspectRatioExact(aspect_ratio_exact) {
-        wasm.cameraconstraints_set_aspect_ratio_exact(this.ptr, aspect_ratio_exact);
-    }
-    /**
-    * Gets the internal [`JSCameraFacingMode`].
-    * # JS-WASM
-    * This is exported as `get_FacingMode`.
-    * @returns {number}
-    */
-    get FacingMode() {
-        var ret = wasm.cameraconstraints_facing_mode(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Sets the internal [`JSCameraFacingMode`]
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FacingMode`.
-    * @param {number} facing_mode
-    */
-    set FacingMode(facing_mode) {
-        wasm.cameraconstraints_set_facing_mode(this.ptr, facing_mode);
-    }
-    /**
-    * Gets the internal facing mode exact.
-    * # JS-WASM
-    * This is exported as `get_FacingModeExact`.
-    * @returns {boolean}
-    */
-    get FacingModeExact() {
-        var ret = wasm.cameraconstraints_facing_mode_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal facing mode exact
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FacingModeExact`.
-    * @param {boolean} facing_mode_exact
-    */
-    set FacingModeExact(facing_mode_exact) {
-        wasm.cameraconstraints_set_facing_mode_exact(this.ptr, facing_mode_exact);
-    }
-    /**
-    * Gets the minimum internal frame rate.
-    * # JS-WASM
-    * This is exported as `get_MinFrameRate`.
-    * @returns {number | undefined}
-    */
-    get MinFrameRate() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_min_frame_rate(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return r0 === 0 ? undefined : r1 >>> 0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the minimum internal frame rate
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_MinFrameRate`.
-    * @param {number} min_frame_rate
-    */
-    set MinFrameRate(min_frame_rate) {
-        wasm.cameraconstraints_set_min_frame_rate(this.ptr, min_frame_rate);
-    }
-    /**
-    * Gets the internal frame rate.
-    * # JS-WASM
-    * This is exported as `get_FrameRate`.
-    * @returns {number}
-    */
-    get FrameRate() {
-        var ret = wasm.cameraconstraints_frame_rate(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Sets the internal frame rate
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FrameRate`.
-    * @param {number} frame_rate
-    */
-    set FrameRate(frame_rate) {
-        wasm.cameraconstraints_set_frame_rate(this.ptr, frame_rate);
-    }
-    /**
-    * Gets the maximum internal frame rate.
-    * # JS-WASM
-    * This is exported as `get_MaxFrameRate`.
-    * @returns {number | undefined}
-    */
-    get MaxFrameRate() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_max_frame_rate(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return r0 === 0 ? undefined : r1 >>> 0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Sets the maximum internal frame rate
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_MaxFrameRate`.
-    * @param {number} max_frame_rate
-    */
-    set MaxFrameRate(max_frame_rate) {
-        wasm.cameraconstraints_set_max_frame_rate(this.ptr, max_frame_rate);
-    }
-    /**
-    * Gets the internal frame rate exact.
-    * # JS-WASM
-    * This is exported as `get_FrameRateExact`.
-    * @returns {boolean}
-    */
-    get FrameRateExact() {
-        var ret = wasm.cameraconstraints_frame_rate_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal frame rate exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_FrameRateExact`.
-    * @param {boolean} frame_rate_exact
-    */
-    set FrameRateExact(frame_rate_exact) {
-        wasm.cameraconstraints_set_frame_rate_exact(this.ptr, frame_rate_exact);
-    }
-    /**
-    * Gets the internal [`JSCameraResizeMode`].
-    * # JS-WASM
-    * This is exported as `get_ResizeMode`.
-    * @returns {number}
-    */
-    get ResizeMode() {
-        var ret = wasm.cameraconstraints_resize_mode(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Sets the internal [`JSCameraResizeMode`]
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_ResizeMode`.
-    * @param {number} resize_mode
-    */
-    set ResizeMode(resize_mode) {
-        wasm.cameraconstraints_set_resize_mode(this.ptr, resize_mode);
-    }
-    /**
-    * Gets the internal resize mode exact.
-    * # JS-WASM
-    * This is exported as `get_ResizeModeExact`.
-    * @returns {boolean}
-    */
-    get ResizeModeExact() {
-        var ret = wasm.cameraconstraints_resize_mode_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal resize mode exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_ResizeModeExact`.
-    * @param {boolean} resize_mode_exact
-    */
-    set ResizeModeExact(resize_mode_exact) {
-        wasm.cameraconstraints_set_resize_mode_exact(this.ptr, resize_mode_exact);
-    }
-    /**
-    * Gets the internal device id.
-    * # JS-WASM
-    * This is exported as `get_DeviceId`.
-    * @returns {string}
-    */
-    get DeviceId() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_device_id(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Sets the internal device ID.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_DeviceId`.
-    * @param {string} device_id
-    */
-    set DeviceId(device_id) {
-        var ptr0 = passStringToWasm0(device_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.cameraconstraints_set_device_id(this.ptr, ptr0, len0);
-    }
-    /**
-    * Gets the internal device id exact.
-    * # JS-WASM
-    * This is exported as `get_DeviceIdExact`.
-    * @returns {boolean}
-    */
-    get DeviceIdExact() {
-        var ret = wasm.cameraconstraints_device_id_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal device ID exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_DeviceIdExact`.
-    * @param {boolean} device_id_exact
-    */
-    set DeviceIdExact(device_id_exact) {
-        wasm.cameraconstraints_set_device_id_exact(this.ptr, device_id_exact);
-    }
-    /**
-    * Gets the internal group id.
-    * # JS-WASM
-    * This is exported as `get_GroupId`.
-    * @returns {string}
-    */
-    get GroupId() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cameraconstraints_group_id(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Sets the internal group ID.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_GroupId`.
-    * @param {string} group_id
-    */
-    set GroupId(group_id) {
-        var ptr0 = passStringToWasm0(group_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.cameraconstraints_set_group_id(this.ptr, ptr0, len0);
-    }
-    /**
-    * Gets the internal group id exact.
-    * # JS-WASM
-    * This is exported as `get_GroupIdExact`.
-    * @returns {boolean}
-    */
-    get GroupIdExact() {
-        var ret = wasm.cameraconstraints_group_id_exact(this.ptr);
-        return ret !== 0;
-    }
-    /**
-    * Sets the internal group ID exact.
-    * Note that this doesn't affect the internal [`MediaStreamConstraints`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStreamConstraints.html) until you call
-    * [`apply_constraints()`](crate::js_camera::JSCameraConstraints::apply_constraints)
-    * # JS-WASM
-    * This is exported as `set_GroupIdExact`.
-    * @param {boolean} group_id_exact
-    */
-    set GroupIdExact(group_id_exact) {
-        wasm.cameraconstraints_set_group_id_exact(this.ptr, group_id_exact);
-    }
-    /**
-    * Applies any modified constraints.
-    * # JS-WASM
-    * This is exported as `applyConstraints`.
-    */
-    applyConstraints() {
-        wasm.cameraconstraints_applyConstraints(this.ptr);
-    }
-}
-/**
-* A builder that builds a [`JSCameraConstraints`] that is used to construct a [`JSCamera`].
-* See More: [`Constraints MDN`](https://developer.mozilla.org/en-US/docs/Web/API/Media_Streams_API/Constraints), [`Properties of Media Tracks MDN`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints)
-* # JS-WASM
-* This is exported as `CameraConstraintsBuilder`.
-*/
-export class CameraConstraintsBuilder {
-
-    static __wrap(ptr) {
-        const obj = Object.create(CameraConstraintsBuilder.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_cameraconstraintsbuilder_free(ptr);
-    }
-    /**
-    * Constructs a default [`JSCameraConstraintsBuilder`].
-    * The constructed default [`JSCameraConstraintsBuilder`] has these settings:
-    * - 480x234 min, 640x360 ideal, 1920x1080 max
-    * - 10 FPS min, 15 FPS ideal, 30 FPS max
-    * - 1.0 aspect ratio min, 1.77777777778 aspect ratio ideal, 2.0 aspect ratio max
-    * - No `exact`s
-    * # JS-WASM
-    * This is exported as a constructor.
-    */
-    constructor() {
-        var ret = wasm.cameraconstraintsbuilder_new();
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the minimum resolution for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-    * # JS-WASM
-    * This is exported as `set_MinResolution`.
-    * @param {Resolution} min_resolution
-    * @returns {CameraConstraintsBuilder}
-    */
-    MinResolution(min_resolution) {
-        const ptr = this.__destroy_into_raw();
-        _assertClass(min_resolution, Resolution);
-        var ptr0 = min_resolution.ptr;
-        min_resolution.ptr = 0;
-        var ret = wasm.cameraconstraintsbuilder_MaxResolution(ptr, ptr0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the preferred resolution for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-    * # JS-WASM
-    * This is exported as `set_Resolution`.
-    * @param {Resolution} new_resolution
-    * @returns {CameraConstraintsBuilder}
-    */
-    Resolution(new_resolution) {
-        const ptr = this.__destroy_into_raw();
-        _assertClass(new_resolution, Resolution);
-        var ptr0 = new_resolution.ptr;
-        new_resolution.ptr = 0;
-        var ret = wasm.cameraconstraintsbuilder_Resolution(ptr, ptr0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the maximum resolution for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width) and [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height).
-    * # JS-WASM
-    * This is exported as `set_MaxResolution`.
-    * @param {Resolution} max_resolution
-    * @returns {CameraConstraintsBuilder}
-    */
-    MaxResolution(max_resolution) {
-        const ptr = this.__destroy_into_raw();
-        _assertClass(max_resolution, Resolution);
-        var ptr0 = max_resolution.ptr;
-        max_resolution.ptr = 0;
-        var ret = wasm.cameraconstraintsbuilder_MaxResolution(ptr, ptr0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the resolution fields ([`width`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/width), [`height`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/height)/[`resolution`](crate::js_camera::JSCameraConstraintsBuilder::resolution))
-    * should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * Note that this will make the builder ignore [`min_resolution`](crate::js_camera::JSCameraConstraintsBuilder::min_resolution) and [`max_resolution`](crate::js_camera::JSCameraConstraintsBuilder::max_resolution).
-    * # JS-WASM
-    * This is exported as `set_ResolutionExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    ResolutionExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_ResolutionExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the minimum aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-    * # JS-WASM
-    * This is exported as `set_MinAspectRatio`.
-    * @param {number} ratio
-    * @returns {CameraConstraintsBuilder}
-    */
-    MinAspectRatio(ratio) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MinAspectRatio(ptr, ratio);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-    * # JS-WASM
-    * This is exported as `set_AspectRatio`.
-    * @param {number} ratio
-    * @returns {CameraConstraintsBuilder}
-    */
-    AspectRatio(ratio) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_AspectRatio(ptr, ratio);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the maximum aspect ratio of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`aspectRatio`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/aspectRatio).
-    * # JS-WASM
-    * This is exported as `set_MaxAspectRatio`.
-    * @param {number} ratio
-    * @returns {CameraConstraintsBuilder}
-    */
-    MaxAspectRatio(ratio) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MaxAspectRatio(ptr, ratio);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::aspect_ratio) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * Note that this will make the builder ignore [`min_aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::min_aspect_ratio) and [`max_aspect_ratio`](crate::js_camera::JSCameraConstraintsBuilder::max_aspect_ratio).
-    * # JS-WASM
-    * This is exported as `set_AspectRatioExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    AspectRatioExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_AspectRatioExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the facing mode of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`facingMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode).
-    * # JS-WASM
-    * This is exported as `set_FacingMode`.
-    * @param {number} facing_mode
-    * @returns {CameraConstraintsBuilder}
-    */
-    FacingMode(facing_mode) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FacingMode(ptr, facing_mode);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`facing_mode`](crate::js_camera::JSCameraConstraintsBuilder::facing_mode) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_FacingModeExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    FacingModeExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FacingModeExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the minimum frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-    * # JS-WASM
-    * This is exported as `set_MinFrameRate`.
-    * @param {number} fps
-    * @returns {CameraConstraintsBuilder}
-    */
-    MinFrameRate(fps) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MinFrameRate(ptr, fps);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-    * # JS-WASM
-    * This is exported as `set_FrameRate`.
-    * @param {number} fps
-    * @returns {CameraConstraintsBuilder}
-    */
-    FrameRate(fps) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FrameRate(ptr, fps);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the maximum frame rate of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`frameRate`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/frameRate).
-    * # JS-WASM
-    * This is exported as `set_MaxFrameRate`.
-    * @param {number} fps
-    * @returns {CameraConstraintsBuilder}
-    */
-    MaxFrameRate(fps) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_MaxFrameRate(ptr, fps);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::frame_rate) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * Note that this will make the builder ignore [`min_frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::min_frame_rate) and [`max_frame_rate`](crate::js_camera::JSCameraConstraintsBuilder::max_frame_rate).
-    * # JS-WASM
-    * This is exported as `set_FrameRateExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    FrameRateExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_FrameRateExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the resize mode of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`resizeMode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#resizemode).
-    * # JS-WASM
-    * This is exported as `set_ResizeMode`.
-    * @param {number} resize_mode
-    * @returns {CameraConstraintsBuilder}
-    */
-    ResizeMode(resize_mode) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_ResizeMode(ptr, resize_mode);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`resize_mode`](crate::js_camera::JSCameraConstraintsBuilder::resize_mode) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_ResizeModeExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    ResizeModeExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_ResizeModeExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the device ID of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`deviceId`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/deviceId).
-    * # JS-WASM
-    * This is exported as `set_DeviceId`.
-    * @param {string} id
-    * @returns {CameraConstraintsBuilder}
-    */
-    DeviceId(id) {
-        const ptr = this.__destroy_into_raw();
-        var ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        var ret = wasm.cameraconstraintsbuilder_DeviceId(ptr, ptr0, len0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`device_id`](crate::js_camera::JSCameraConstraintsBuilder::device_id) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_DeviceIdExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    DeviceIdExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_DeviceIdExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets the group ID of the resulting constraint for the [`JSCameraConstraintsBuilder`].
-    *
-    * Sets [`groupId`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/groupId).
-    * # JS-WASM
-    * This is exported as `set_GroupId`.
-    * @param {string} id
-    * @returns {CameraConstraintsBuilder}
-    */
-    GroupId(id) {
-        const ptr = this.__destroy_into_raw();
-        var ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        var ret = wasm.cameraconstraintsbuilder_GroupId(ptr, ptr0, len0);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Sets whether the [`group_id`](crate::js_camera::JSCameraConstraintsBuilder::group_id) field should use [`exact`](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints#constraints).
-    * # JS-WASM
-    * This is exported as `set_GroupIdExact`.
-    * @param {boolean} value
-    * @returns {CameraConstraintsBuilder}
-    */
-    GroupIdExact(value) {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_GroupIdExact(ptr, value);
-        return CameraConstraintsBuilder.__wrap(ret);
-    }
-    /**
-    * Builds the [`JSCameraConstraints`]. Wrapper for [`build`](crate::js_camera::JSCameraConstraintsBuilder::build)
-    *
-    * Fields that use exact are marked `exact`, otherwise are marked with `ideal`. If min-max are involved, they will use `min` and `max` accordingly.
-    * # JS-WASM
-    * This is exported as `buildCameraConstraints`.
-    * @returns {CameraConstraints}
-    */
-    buildCameraConstraints() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.cameraconstraintsbuilder_buildCameraConstraints(ptr);
-        return CameraConstraints.__wrap(ret);
-    }
-}
-/**
-* Information about a Camera e.g. its name.
-* `description` amd `misc` may contain information that may differ from backend to backend. Refer to each backend for details.
-* `index` is a camera's index given to it by (usually) the OS usually in the order it is known to the system.
-* # JS-WASM
-* This is exported as a `CameraInfo`.
-*/
-export class CameraInfo {
-
-    static __wrap(ptr) {
-        const obj = Object.create(CameraInfo.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_camerainfo_free(ptr);
-    }
-    /**
-    * Create a new [`CameraInfo`].
-    * # JS-WASM
-    * This is exported as a constructor for [`CameraInfo`].
-    * @param {string} human_name
-    * @param {string} description
-    * @param {string} misc
-    * @param {number} index
-    */
-    constructor(human_name, description, misc, index) {
-        var ptr0 = passStringToWasm0(human_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        var ptr1 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = passStringToWasm0(misc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len2 = WASM_VECTOR_LEN;
-        var ret = wasm.camerainfo_new(ptr0, len0, ptr1, len1, ptr2, len2, index);
-        return CameraInfo.__wrap(ret);
-    }
-    /**
-    * Get a reference to the device info's human readable name.
-    * # JS-WASM
-    * This is exported as a `get_HumanReadableName`.
-    * @returns {string}
-    */
-    get HumanReadableName() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.camerainfo_human_name(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Set the device info's human name.
-    * # JS-WASM
-    * This is exported as a `set_HumanReadableName`.
-    * @param {string} human_name
-    */
-    set HumanReadableName(human_name) {
-        var ptr0 = passStringToWasm0(human_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.camerainfo_set_human_name(this.ptr, ptr0, len0);
-    }
-    /**
-    * Get a reference to the device info's description.
-    * # JS-WASM
-    * This is exported as a `get_Description`.
-    * @returns {string}
-    */
-    get Description() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.camerainfo_description(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Set the device info's description.
-    * # JS-WASM
-    * This is exported as a `set_Description`.
-    * @param {string} description
-    */
-    set Description(description) {
-        var ptr0 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.camerainfo_set_description(this.ptr, ptr0, len0);
-    }
-    /**
-    * Get a reference to the device info's misc.
-    * # JS-WASM
-    * This is exported as a `get_MiscString`.
-    * @returns {string}
-    */
-    get MiscString() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.camerainfo_misc(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Set the device info's misc.
-    * # JS-WASM
-    * This is exported as a `set_MiscString`.
-    * @param {string} misc
-    */
-    set MiscString(misc) {
-        var ptr0 = passStringToWasm0(misc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.camerainfo_set_misc(this.ptr, ptr0, len0);
-    }
-    /**
-    * Get a reference to the device info's index.
-    * # JS-WASM
-    * This is exported as a `get_Index`.
-    * @returns {number}
-    */
-    get Index() {
-        var ret = wasm.camerainfo_index(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Set the device info's index.
-    * # JS-WASM
-    * This is exported as a `set_Index`.
-    * @param {number} index
-    */
-    set Index(index) {
-        wasm.camerainfo_set_index(this.ptr, index);
-    }
-}
-/**
-* A wrapper around a [`MediaStream`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStream.html)
-* # JS-WASM
-* This is exported as `NokhwaCamera`.
-*/
-export class NokhwaCamera {
-
-    static __wrap(ptr) {
-        const obj = Object.create(NokhwaCamera.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_nokhwacamera_free(ptr);
-    }
-    /**
-    * Creates a new [`JSCamera`] using [`JSCameraConstraints`].
-    *
-    * # Errors
-    * This may error if permission is not granted, or the constraints are invalid.
-    * # JS-WASM
-    * This is the constructor for `NokhwaCamera`. It returns a promise and may throw an error.
-    * @param {CameraConstraints} constraints
-    */
-    constructor(constraints) {
-        _assertClass(constraints, CameraConstraints);
-        var ptr0 = constraints.ptr;
-        constraints.ptr = 0;
-        var ret = wasm.nokhwacamera_js_new(ptr0);
-        return takeObject(ret);
-    }
-    /**
-    * Gets the internal [`JSCameraConstraints`].
-    * Most likely, you will edit this value by taking ownership of it, then feed it back into [`set_constraints`](crate::js_camera::JSCamera::set_constraints).
-    * # JS-WASM
-    * This is exported as `get_Constraints`.
-    * @returns {CameraConstraints}
-    */
-    get Constraints() {
-        var ret = wasm.nokhwacamera_constraints(this.ptr);
-        return CameraConstraints.__wrap(ret);
-    }
-    /**
-    * Sets the [`JSCameraConstraints`]. This calls [`apply_constraints`](crate::js_camera::JSCamera::apply_constraints) internally.
-    *
-    * # Errors
-    * See [`apply_constraints`](crate::js_camera::JSCamera::apply_constraints).
-    * # JS-WASM
-    * This is exported as `set_Constraints`. It may throw an error.
-    * @param {CameraConstraints} constraints
-    */
-    set Constraints(constraints) {
-        _assertClass(constraints, CameraConstraints);
-        var ptr0 = constraints.ptr;
-        constraints.ptr = 0;
-        wasm.nokhwacamera_js_set_constraints(this.ptr, ptr0);
-    }
-    /**
-    * Gets the internal [`Resolution`].
-    *
-    * Note: This value is only updated after you call [`measure_resolution`](crate::js_camera::JSCamera::measure_resolution)
-    * # JS-WASM
-    * This is exported as `get_Resolution`.
-    * @returns {Resolution}
-    */
-    get Resolution() {
-        var ret = wasm.nokhwacamera_resolution(this.ptr);
-        return Resolution.__wrap(ret);
-    }
-    /**
-    * Measures the [`Resolution`] of the internal stream. You usually do not need to call this.
-    *
-    * # Errors
-    * If the camera fails to attach to the created `<video>`, this will error.
-    *
-    * # JS-WASM
-    * This is exported as `measureResolution`. It may throw an error.
-    */
-    measureResolution() {
-        wasm.nokhwacamera_measureResolution(this.ptr);
-    }
-    /**
-    * Applies any modified constraints.
-    * # Errors
-    * This function may return an error on failing to measure the resolution. Please check [`measure_resolution()`](crate::js_camera::JSCamera::measure_resolution) for details.
-    * # JS-WASM
-    * This is exported as `applyConstraints`. It may throw an error.
-    */
-    applyConstraints() {
-        wasm.nokhwacamera_applyConstraints(this.ptr);
-    }
-    /**
-    * Gets the internal [`MediaStream`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStream.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream)
-    * # JS-WASM
-    * This is exported as `MediaStream`.
-    * @returns {MediaStream}
-    */
-    get MediaStream() {
-        var ret = wasm.nokhwacamera_media_stream(this.ptr);
-        return takeObject(ret);
-    }
-    /**
-    * Captures an [`ImageData`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.ImageData.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/ImageData) by drawing the image to a non-existent canvas.
-    *
-    * # Errors
-    * If drawing to the canvas fails this will error.
-    * # JS-WASM
-    * This is exported as `captureImageData`. It may throw an error.
-    * @returns {ImageData}
-    */
-    captureImageData() {
-        var ret = wasm.nokhwacamera_captureImageData(this.ptr);
-        return takeObject(ret);
-    }
-    /**
-    * Captures an [`ImageData`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.ImageData.html) [`MDN`](https://developer.mozilla.org/en-US/docs/Web/API/ImageData) and then returns its `URL` as a string.
-    * - `mime_type`: The mime type of the resulting URI. It is `image/png` by default (lossless) but can be set to `image/jpeg` or `image/webp` (lossy). Anything else is ignored.
-    * - `image_quality`: A number between `0` and `1` indicating the resulting image quality in case you are using a lossy image mime type. The default value is 0.92, and all other values are ignored.
-    *
-    * # Errors
-    * If drawing to the canvas fails or URI generation is not supported or fails this will error.
-    * # JS-WASM
-    * This is exported as `captureImageURI`. It may throw an error
-    * @param {string} mime_type
-    * @param {number} image_quality
-    * @returns {string}
-    */
-    captureImageURI(mime_type, image_quality) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            var ptr0 = passStringToWasm0(mime_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            var len0 = WASM_VECTOR_LEN;
-            wasm.nokhwacamera_captureImageURI(retptr, this.ptr, ptr0, len0, image_quality);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(r0, r1);
-        }
-    }
-    /**
-    * Creates an off-screen canvas and a `<video>` element (if not already attached) and returns a raw `Cow<[u8]>` RGBA frame.
-    * # Errors
-    * If a cast fails, the camera fails to attach, the currently attached node is invalid, or writing/reading from the canvas fails, this will error.
-    * # JS-WASM
-    * This is exported as `captureFrameRawData`. This may throw an error.
-    * @returns {Uint8Array}
-    */
-    captureFrameRawData() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.nokhwacamera_captureFrameRawData(retptr, this.ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1);
-            return v0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Copies camera frame to a `html_id`(by-id, canvas).
-    *
-    * If `generate_new` is true, the generated element will have an Id of `html_id`+`-canvas`. For example, if you pass "nokhwaisbest" for `html_id`, the new `<canvas>`'s ID will be "nokhwaisbest-canvas".
-    * # Errors
-    * If the internal canvas is not here, drawing fails, or a cast fails, this will error.
-    * # JS-WASM
-    * This is exported as `copyToCanvas`. It may error.
-    * @param {string} html_id
-    * @param {boolean} generate_new
-    */
-    copyToCanvas(html_id, generate_new) {
-        var ptr0 = passStringToWasm0(html_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.nokhwacamera_copyToCanvas(this.ptr, ptr0, len0, generate_new);
-    }
-    /**
-    * Attaches camera to a `html_id`(by-id).
-    *
-    * If `generate_new` is true, the generated element will have an Id of `html_id`+`-video`. For example, if you pass "nokhwaisbest" for `html_id`, the new `<video>`'s ID will be "nokhwaisbest-video".
-    * # Errors
-    * If the camera fails to attach, fails to generate the video element, or a cast fails, this will error.
-    * # JS-WASM
-    * This is exported as `attachToElement`. It may throw an error.
-    * @param {string} html_id
-    * @param {boolean} generate_new
-    */
-    attachToElement(html_id, generate_new) {
-        var ptr0 = passStringToWasm0(html_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.nokhwacamera_attachToElement(this.ptr, ptr0, len0, generate_new);
-    }
-    /**
-    * Detaches the camera from the `<video>` node.
-    * # Errors
-    * If the casting fails (the stored node is not a `<video>`) this will error.
-    * # JS-WASM
-    * This is exported as `detachCamera`. This may throw an error.
-    */
-    detachCamera() {
-        wasm.nokhwacamera_detachCamera(this.ptr);
-    }
-    /**
-    * Stops all streams and detaches the camera.
-    * # Errors
-    * There may be an error while detaching the camera. Please see [`detach()`](crate::js_camera::JSCamera::detach) for more details.
-    */
-    stopAll() {
-        wasm.nokhwacamera_stopAll(this.ptr);
-    }
-}
-/**
-* Describes a Resolution.
-* This struct consists of a Width and a Height value (x,y). <br>
-* Note: the [`Ord`] implementation of this struct is flipped from highest to lowest.
-* # JS-WASM
-* This is exported as `Resolution`
-*/
-export class Resolution {
-
-    static __wrap(ptr) {
-        const obj = Object.create(Resolution.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_resolution_free(ptr);
-    }
-    /**
-    * @returns {number}
-    */
-    get width_x() {
-        var ret = wasm.__wbg_get_resolution_width_x(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * @param {number} arg0
-    */
-    set width_x(arg0) {
-        wasm.__wbg_set_resolution_width_x(this.ptr, arg0);
-    }
-    /**
-    * @returns {number}
-    */
-    get height_y() {
-        var ret = wasm.__wbg_get_resolution_height_y(this.ptr);
-        return ret >>> 0;
-    }
-    /**
-    * @param {number} arg0
-    */
-    set height_y(arg0) {
-        wasm.__wbg_set_resolution_height_y(this.ptr, arg0);
-    }
-    /**
-    * Create a new resolution from 2 image size coordinates.
-    * # JS-WASM
-    * This is exported as a constructor for [`Resolution`].
-    * @param {number} x
-    * @param {number} y
-    */
-    constructor(x, y) {
-        var ret = wasm.resolution_new(x, y);
-        return Resolution.__wrap(ret);
-    }
-    /**
-    * Get the width of Resolution
-    * # JS-WASM
-    * This is exported as `get_Width`.
-    * @returns {number}
-    */
-    get Width() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.resolution_width(ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Get the height of Resolution
-    * # JS-WASM
-    * This is exported as `get_Height`.
-    * @returns {number}
-    */
-    get Height() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.resolution_height(ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Get the x (width) of Resolution
-    * @returns {number}
-    */
-    x() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.resolution_width(ptr);
-        return ret >>> 0;
-    }
-    /**
-    * Get the y (height) of Resolution
-    * @returns {number}
-    */
-    y() {
-        const ptr = this.__destroy_into_raw();
-        var ret = wasm.resolution_height(ptr);
-        return ret >>> 0;
-    }
-}
-
-export function __wbindgen_string_new(arg0, arg1) {
-    var ret = getStringFromWasm0(arg0, arg1);
-    return addHeapObject(ret);
-};
-
-export function __wbg_nokhwacamera_new(arg0) {
-    var ret = NokhwaCamera.__wrap(arg0);
-    return addHeapObject(ret);
-};
-
-export function __wbindgen_object_drop_ref(arg0) {
-    takeObject(arg0);
-};
-
-export function __wbindgen_number_new(arg0) {
-    var ret = arg0;
-    return addHeapObject(ret);
-};
-
-export function __wbindgen_object_clone_ref(arg0) {
-    var ret = getObject(arg0);
-    return addHeapObject(ret);
-};
-
-export function __wbindgen_is_undefined(arg0) {
-    var ret = getObject(arg0) === undefined;
-    return ret;
-};
-
-export function __wbindgen_jsval_eq(arg0, arg1) {
-    var ret = getObject(arg0) === getObject(arg1);
-    return ret;
-};
-
-export function __wbindgen_cb_drop(arg0) {
-    const obj = takeObject(arg0).original;
-    if (obj.cnt-- == 1) {
-        obj.a = 0;
-        return true;
-    }
-    var ret = false;
-    return ret;
-};
-
-export function __wbg_camerainfo_new(arg0) {
-    var ret = CameraInfo.__wrap(arg0);
-    return addHeapObject(ret);
-};
-
-export function __wbg_instanceof_Window_11e25482011fc506(arg0) {
-    var ret = getObject(arg0) instanceof Window;
-    return ret;
-};
-
-export function __wbg_document_5aff8cd83ef968f5(arg0) {
-    var ret = getObject(arg0).document;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-};
-
-export function __wbg_navigator_5c90643c2a2b6cda(arg0) {
-    var ret = getObject(arg0).navigator;
-    return addHeapObject(ret);
-};
-
-export function __wbg_body_525168d9e773c3f8(arg0) {
-    var ret = getObject(arg0).body;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-};
-
-export function __wbg_createElement_ac65a6ce60c4812c() { return handleError(function (arg0, arg1, arg2) {
-    var ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_getElementById_b180ea4ada06a837(arg0, arg1, arg2) {
-    var ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-};
-
-export function __wbg_clone_907d18181dd9fdec(arg0) {
-    var ret = getObject(arg0).clone();
-    return addHeapObject(ret);
-};
-
-export function __wbg_getTracks_453d59960c6b0998(arg0) {
-    var ret = getObject(arg0).getTracks();
-    return addHeapObject(ret);
-};
-
-export function __wbg_getVideoTracks_c67b7117e61e6768(arg0) {
-    var ret = getObject(arg0).getVideoTracks();
-    return addHeapObject(ret);
-};
-
-export function __wbg_appendChild_6ed236bb79c198df() { return handleError(function (arg0, arg1) {
-    var ret = getObject(arg0).appendChild(getObject(arg1));
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_removeChild_f633f19eb895b696() { return handleError(function (arg0, arg1) {
-    var ret = getObject(arg0).removeChild(getObject(arg1));
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_instanceof_MediaDeviceInfo_cdf31c28bb9459ae(arg0) {
-    var ret = getObject(arg0) instanceof MediaDeviceInfo;
-    return ret;
-};
-
-export function __wbg_deviceId_52909f91167fa503(arg0, arg1) {
-    var ret = getObject(arg1).deviceId;
-    var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-};
-
-export function __wbg_kind_7f46301e232da76a(arg0) {
-    var ret = getObject(arg0).kind;
-    return addHeapObject(ret);
-};
-
-export function __wbg_groupId_f6b7aa74f6b78e09(arg0, arg1) {
-    var ret = getObject(arg1).groupId;
-    var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-};
-
-export function __wbg_enumerateDevices_fe5818b3c5c78822() { return handleError(function (arg0) {
-    var ret = getObject(arg0).enumerateDevices();
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_getSupportedConstraints_fa3e91cb9dd6da4c(arg0) {
-    var ret = getObject(arg0).getSupportedConstraints();
-    return addHeapObject(ret);
-};
-
-export function __wbg_getUserMedia_c7f57dc542dcd8c6() { return handleError(function (arg0, arg1) {
-    var ret = getObject(arg0).getUserMedia(getObject(arg1));
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_setid_cea8de140a58c4f1(arg0, arg1, arg2) {
-    getObject(arg0).id = getStringFromWasm0(arg1, arg2);
-};
-
-export function __wbg_setAttribute_27ca65e30a1c3c4a() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-    getObject(arg0).setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-}, arguments) };
-
-export function __wbg_log_9a99fb1af846153b(arg0) {
-    console.log(getObject(arg0));
-};
-
-export function __wbg_sethidden_4e6127e185ecf2df(arg0, arg1) {
-    getObject(arg0).hidden = arg1 !== 0;
-};
-
-export function __wbg_instanceof_CanvasRenderingContext2d_779e79c4121aa91b(arg0) {
-    var ret = getObject(arg0) instanceof CanvasRenderingContext2D;
-    return ret;
-};
-
-export function __wbg_drawImage_1edb91863f89d75c() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-    getObject(arg0).drawImage(getObject(arg1), arg2, arg3, arg4, arg5);
-}, arguments) };
-
-export function __wbg_drawImage_13e48c4e7b9bcf28() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-    getObject(arg0).drawImage(getObject(arg1), arg2, arg3, arg4, arg5);
-}, arguments) };
-
-export function __wbg_getImageData_b5842f1d6ce40388() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-    var ret = getObject(arg0).getImageData(arg1, arg2, arg3, arg4);
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_setsrcObject_340bcd93145a797b(arg0, arg1) {
-    getObject(arg0).srcObject = getObject(arg1);
-};
-
-export function __wbg_instanceof_HtmlCanvasElement_fd3cbbe3906d7792(arg0) {
-    var ret = getObject(arg0) instanceof HTMLCanvasElement;
-    return ret;
-};
-
-export function __wbg_setwidth_f3c88eb520ba8d47(arg0, arg1) {
-    getObject(arg0).width = arg1 >>> 0;
-};
-
-export function __wbg_setheight_5a1abba41e35c42a(arg0, arg1) {
-    getObject(arg0).height = arg1 >>> 0;
-};
-
-export function __wbg_getContext_813df131fcbd6e91() { return handleError(function (arg0, arg1, arg2) {
-    var ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_toDataURL_fa0138af5cf03aa2() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-    var ret = getObject(arg1).toDataURL(getStringFromWasm0(arg2, arg3), getObject(arg4));
-    var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-}, arguments) };
-
-export function __wbg_mediaDevices_b3973ebf40387065() { return handleError(function (arg0) {
-    var ret = getObject(arg0).mediaDevices;
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_instanceof_HtmlVideoElement_acfaf2202e3e0d29(arg0) {
-    var ret = getObject(arg0) instanceof HTMLVideoElement;
-    return ret;
-};
-
-export function __wbg_setwidth_4006f4b33b15224b(arg0, arg1) {
-    getObject(arg0).width = arg1 >>> 0;
-};
-
-export function __wbg_setheight_6a5930569b122df0(arg0, arg1) {
-    getObject(arg0).height = arg1 >>> 0;
-};
-
-export function __wbg_data_315524ada7b563f4(arg0, arg1) {
-    var ret = getObject(arg1).data;
-    var ptr0 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
-    var len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-};
-
-export function __wbg_label_21de6784a6632e75(arg0, arg1) {
-    var ret = getObject(arg1).label;
-    var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-};
-
-export function __wbg_getSettings_654b758d29aaf3ad(arg0) {
-    var ret = getObject(arg0).getSettings();
-    return addHeapObject(ret);
-};
-
-export function __wbg_stop_f96817735e68ad3d(arg0) {
-    getObject(arg0).stop();
-};
-
-export function __wbg_get_73c087db0a496c21(arg0, arg1) {
-    var ret = getObject(arg0)[arg1 >>> 0];
-    return addHeapObject(ret);
-};
-
-export function __wbg_length_c5fa152b8c3f311f(arg0) {
-    var ret = getObject(arg0).length;
-    return ret;
-};
-
-export function __wbg_new_ec75d0d5815be736() {
-    var ret = new Array();
-    return addHeapObject(ret);
-};
-
-export function __wbg_newnoargs_1a11e7e8c906996c(arg0, arg1) {
-    var ret = new Function(getStringFromWasm0(arg0, arg1));
-    return addHeapObject(ret);
-};
-
-export function __wbg_new_193281ce8fd4b1c8() {
-    var ret = new Map();
-    return addHeapObject(ret);
-};
-
-export function __wbg_call_e91f71ddf1f45cff() { return handleError(function (arg0, arg1) {
-    var ret = getObject(arg0).call(getObject(arg1));
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_new_4b48f9f8159fea77() {
-    var ret = new Object();
-    return addHeapObject(ret);
-};
-
-export function __wbg_from_28631399e1e647cb(arg0) {
-    var ret = Array.from(getObject(arg0));
-    return addHeapObject(ret);
-};
-
-export function __wbg_push_0daae9343162dbe7(arg0, arg1) {
-    var ret = getObject(arg0).push(getObject(arg1));
-    return ret;
-};
-
-export function __wbg_call_e3c72355d091d5d4() { return handleError(function (arg0, arg1, arg2) {
-    var ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_get_55c6cc12fb6a83f9(arg0, arg1) {
-    var ret = getObject(arg0).get(getObject(arg1));
-    return addHeapObject(ret);
-};
-
-export function __wbg_set_b9dad32fc360b408(arg0, arg1, arg2) {
-    var ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-    return addHeapObject(ret);
-};
-
-export function __wbg_assign_39a180d12d813399(arg0, arg1) {
-    var ret = Object.assign(getObject(arg0), getObject(arg1));
-    return addHeapObject(ret);
-};
-
-export function __wbg_entries_a3fad9ebd955672b(arg0) {
-    var ret = Object.entries(getObject(arg0));
-    return addHeapObject(ret);
-};
-
-export function __wbg_keys_9f3a5511f779059c(arg0) {
-    var ret = Object.keys(getObject(arg0));
-    return addHeapObject(ret);
-};
-
-export function __wbg_new_119f8177d8717c43(arg0, arg1) {
-    try {
-        var state0 = {a: arg0, b: arg1};
-        var cb0 = (arg0, arg1) => {
-            const a = state0.a;
-            state0.a = 0;
-            try {
-                return __wbg_adapter_240(a, state0.b, arg0, arg1);
-            } finally {
-                state0.a = a;
-            }
-        };
-        var ret = new Promise(cb0);
-        return addHeapObject(ret);
-    } finally {
-        state0.a = state0.b = 0;
-    }
-};
-
-export function __wbg_resolve_7161ec6fd5b1cd29(arg0) {
-    var ret = Promise.resolve(getObject(arg0));
-    return addHeapObject(ret);
-};
-
-export function __wbg_then_6d5072fec3fdb237(arg0, arg1) {
-    var ret = getObject(arg0).then(getObject(arg1));
-    return addHeapObject(ret);
-};
-
-export function __wbg_then_4f3c7f6f3d36634a(arg0, arg1, arg2) {
-    var ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
-    return addHeapObject(ret);
-};
-
-export function __wbg_self_b4546ea7b590539e() { return handleError(function () {
-    var ret = self.self;
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_window_c279fea81f426a68() { return handleError(function () {
-    var ret = window.window;
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_globalThis_038a6ea0ff17789f() { return handleError(function () {
-    var ret = globalThis.globalThis;
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_global_4f93ce884bcee597() { return handleError(function () {
-    var ret = global.global;
-    return addHeapObject(ret);
-}, arguments) };
-
-export function __wbg_set_d29a397c9cc5d746() { return handleError(function (arg0, arg1, arg2) {
-    var ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
-    return ret;
-}, arguments) };
-
-export function __wbindgen_number_get(arg0, arg1) {
-    const obj = getObject(arg1);
-    var ret = typeof(obj) === 'number' ? obj : undefined;
-    getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
-    getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
-};
-
-export function __wbindgen_string_get(arg0, arg1) {
-    const obj = getObject(arg1);
-    var ret = typeof(obj) === 'string' ? obj : undefined;
-    var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-};
-
-export function __wbindgen_debug_string(arg0, arg1) {
-    var ret = debugString(getObject(arg1));
-    var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-};
-
-export function __wbindgen_throw(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
-
-export function __wbindgen_rethrow(arg0) {
-    throw takeObject(arg0);
-};
-
-export function __wbindgen_closure_wrapper761(arg0, arg1, arg2) {
-    var ret = makeMutClosure(arg0, arg1, 65, __wbg_adapter_26);
-    return addHeapObject(ret);
-};
-
diff --git a/nokhwajs/nokhwa_bg.wasm b/nokhwajs/nokhwa_bg.wasm
deleted file mode 100644
index 3e52970..0000000
Binary files a/nokhwajs/nokhwa_bg.wasm and /dev/null differ
diff --git a/nokhwajs/nokhwa_bg.wasm.d.ts b/nokhwajs/nokhwa_bg.wasm.d.ts
deleted file mode 100644
index 3d9894c..0000000
--- a/nokhwajs/nokhwa_bg.wasm.d.ts
+++ /dev/null
@@ -1,115 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export const memory: WebAssembly.Memory;
-export function requestPermissions(): number;
-export function queryCameras(): number;
-export function queryConstraints(): number;
-export function __wbg_cameraconstraintsbuilder_free(a: number): void;
-export function cameraconstraintsbuilder_new(): number;
-export function cameraconstraintsbuilder_Resolution(a: number, b: number): number;
-export function cameraconstraintsbuilder_MaxResolution(a: number, b: number): number;
-export function cameraconstraintsbuilder_ResolutionExact(a: number, b: number): number;
-export function cameraconstraintsbuilder_MinAspectRatio(a: number, b: number): number;
-export function cameraconstraintsbuilder_AspectRatio(a: number, b: number): number;
-export function cameraconstraintsbuilder_MaxAspectRatio(a: number, b: number): number;
-export function cameraconstraintsbuilder_AspectRatioExact(a: number, b: number): number;
-export function cameraconstraintsbuilder_FacingMode(a: number, b: number): number;
-export function cameraconstraintsbuilder_FacingModeExact(a: number, b: number): number;
-export function cameraconstraintsbuilder_MinFrameRate(a: number, b: number): number;
-export function cameraconstraintsbuilder_FrameRate(a: number, b: number): number;
-export function cameraconstraintsbuilder_MaxFrameRate(a: number, b: number): number;
-export function cameraconstraintsbuilder_FrameRateExact(a: number, b: number): number;
-export function cameraconstraintsbuilder_ResizeMode(a: number, b: number): number;
-export function cameraconstraintsbuilder_ResizeModeExact(a: number, b: number): number;
-export function cameraconstraintsbuilder_DeviceId(a: number, b: number, c: number): number;
-export function cameraconstraintsbuilder_DeviceIdExact(a: number, b: number): number;
-export function cameraconstraintsbuilder_GroupId(a: number, b: number, c: number): number;
-export function cameraconstraintsbuilder_GroupIdExact(a: number, b: number): number;
-export function cameraconstraintsbuilder_buildCameraConstraints(a: number): number;
-export function __wbg_cameraconstraints_free(a: number): void;
-export function cameraconstraints_media_constraints(a: number): number;
-export function cameraconstraints_min_resolution(a: number): number;
-export function cameraconstraints_set_min_resolution(a: number, b: number): void;
-export function cameraconstraints_resolution(a: number): number;
-export function cameraconstraints_set_resolution(a: number, b: number): void;
-export function cameraconstraints_max_resolution(a: number): number;
-export function cameraconstraints_set_max_resolution(a: number, b: number): void;
-export function cameraconstraints_resolution_exact(a: number): number;
-export function cameraconstraints_set_resolution_exact(a: number, b: number): void;
-export function cameraconstraints_min_aspect_ratio(a: number, b: number): void;
-export function cameraconstraints_set_min_aspect_ratio(a: number, b: number): void;
-export function cameraconstraints_aspect_ratio(a: number): number;
-export function cameraconstraints_set_aspect_ratio(a: number, b: number): void;
-export function cameraconstraints_max_aspect_ratio(a: number, b: number): void;
-export function cameraconstraints_set_max_aspect_ratio(a: number, b: number): void;
-export function cameraconstraints_aspect_ratio_exact(a: number): number;
-export function cameraconstraints_set_aspect_ratio_exact(a: number, b: number): void;
-export function cameraconstraints_facing_mode(a: number): number;
-export function cameraconstraints_set_facing_mode(a: number, b: number): void;
-export function cameraconstraints_facing_mode_exact(a: number): number;
-export function cameraconstraints_set_facing_mode_exact(a: number, b: number): void;
-export function cameraconstraints_min_frame_rate(a: number, b: number): void;
-export function cameraconstraints_set_min_frame_rate(a: number, b: number): void;
-export function cameraconstraints_frame_rate(a: number): number;
-export function cameraconstraints_set_frame_rate(a: number, b: number): void;
-export function cameraconstraints_max_frame_rate(a: number, b: number): void;
-export function cameraconstraints_set_max_frame_rate(a: number, b: number): void;
-export function cameraconstraints_frame_rate_exact(a: number): number;
-export function cameraconstraints_set_frame_rate_exact(a: number, b: number): void;
-export function cameraconstraints_resize_mode(a: number): number;
-export function cameraconstraints_set_resize_mode(a: number, b: number): void;
-export function cameraconstraints_resize_mode_exact(a: number): number;
-export function cameraconstraints_set_resize_mode_exact(a: number, b: number): void;
-export function cameraconstraints_device_id(a: number, b: number): void;
-export function cameraconstraints_set_device_id(a: number, b: number, c: number): void;
-export function cameraconstraints_device_id_exact(a: number): number;
-export function cameraconstraints_set_device_id_exact(a: number, b: number): void;
-export function cameraconstraints_group_id(a: number, b: number): void;
-export function cameraconstraints_set_group_id(a: number, b: number, c: number): void;
-export function cameraconstraints_group_id_exact(a: number): number;
-export function cameraconstraints_set_group_id_exact(a: number, b: number): void;
-export function cameraconstraints_applyConstraints(a: number): void;
-export function __wbg_nokhwacamera_free(a: number): void;
-export function nokhwacamera_js_new(a: number): number;
-export function nokhwacamera_constraints(a: number): number;
-export function nokhwacamera_js_set_constraints(a: number, b: number): void;
-export function nokhwacamera_resolution(a: number): number;
-export function nokhwacamera_measureResolution(a: number): void;
-export function nokhwacamera_applyConstraints(a: number): void;
-export function nokhwacamera_media_stream(a: number): number;
-export function nokhwacamera_captureImageData(a: number): number;
-export function nokhwacamera_captureImageURI(a: number, b: number, c: number, d: number, e: number): void;
-export function nokhwacamera_captureFrameRawData(a: number, b: number): void;
-export function nokhwacamera_copyToCanvas(a: number, b: number, c: number, d: number): void;
-export function nokhwacamera_attachToElement(a: number, b: number, c: number, d: number): void;
-export function nokhwacamera_detachCamera(a: number): void;
-export function nokhwacamera_stopAll(a: number): void;
-export function cameraconstraintsbuilder_MinResolution(a: number, b: number): number;
-export function __wbg_jsresolution_free(a: number): void;
-export function __wbg_get_jsresolution_width_x(a: number): number;
-export function __wbg_set_jsresolution_width_x(a: number, b: number): void;
-export function __wbg_get_jsresolution_height_y(a: number): number;
-export function __wbg_set_jsresolution_height_y(a: number, b: number): void;
-export function jsresolution_width(a: number): number;
-export function jsresolution_height(a: number): number;
-export function __wbg_jscamerainfo_free(a: number): void;
-export function jscamerainfo_new(a: number, b: number, c: number, d: number, e: number, f: number, g: number): number;
-export function jscamerainfo_human_name(a: number, b: number): void;
-export function jscamerainfo_set_human_name(a: number, b: number, c: number): void;
-export function jscamerainfo_description(a: number, b: number): void;
-export function jscamerainfo_set_description(a: number, b: number, c: number): void;
-export function jscamerainfo_misc(a: number, b: number): void;
-export function jscamerainfo_set_misc(a: number, b: number, c: number): void;
-export function jscamerainfo_index(a: number): number;
-export function jscamerainfo_set_index(a: number, b: number): void;
-export function jsresolution_new(a: number, b: number): number;
-export function jsresolution_x(a: number): number;
-export function jsresolution_y(a: number): number;
-export function __wbindgen_malloc(a: number): number;
-export function __wbindgen_realloc(a: number, b: number, c: number): number;
-export const __wbindgen_export_2: WebAssembly.Table;
-export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4e37a62ffa13b731(a: number, b: number, c: number): void;
-export function __wbindgen_add_to_stack_pointer(a: number): number;
-export function __wbindgen_free(a: number, b: number): void;
-export function __wbindgen_exn_store(a: number): void;
-export function wasm_bindgen__convert__closures__invoke2_mut__h4d59381e7733ca36(a: number, b: number, c: number, d: number): void;
diff --git a/nokhwajs/package.json b/nokhwajs/package.json
deleted file mode 100644
index f0cf361..0000000
--- a/nokhwajs/package.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "name": "nokhwa",
-  "collaborators": [
-    "l1npengtul <l1npengtul@protonmail.com>"
-  ],
-  "description": "A Simple-to-use, cross-platform Rust Webcam Capture Library",
-  "version": "0.9.0",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/l1npengtul/nokhwa"
-  },
-  "files": [
-    "nokhwa_bg.wasm",
-    "nokhwa.js",
-    "nokhwa_bg.js",
-    "nokhwa.d.ts"
-  ],
-  "module": "nokhwa.js",
-  "types": "nokhwa.d.ts",
-  "sideEffects": false,
-  "keywords": [
-    "camera",
-    "webcam",
-    "capture",
-    "cross-platform"
-  ]
-}
diff --git a/src/backends/capture/avfoundation.rs b/src/backends/capture/avfoundation.rs
index 1374a6f..0dcefd8 100644
--- a/src/backends/capture/avfoundation.rs
+++ b/src/backends/capture/avfoundation.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,16 +14,26 @@
  * limitations under the License.
  */
 
-use crate::{
-    mjpeg_to_rgb888, yuyv422_to_rgb888, CameraControl, CameraFormat, CameraInfo, CaptureAPIBackend,
-    CaptureBackendTrait, FrameFormat, KnownCameraControls, NokhwaError, Resolution,
+use nokhwa_bindings_macos::{
+    AVCaptureDevice, AVCaptureDeviceInput, AVCaptureSession, AVCaptureVideoCallback,
+    AVCaptureVideoDataOutput,
 };
-use image::{ImageBuffer, Rgb};
-use nokhwa_bindings_macos::avfoundation::{
-    query_avfoundation, AVCaptureDevice, AVCaptureDeviceInput, AVCaptureSession,
-    AVCaptureVideoCallback, AVCaptureVideoDataOutput, AVFourCC,
+use nokhwa_core::{
+    buffer::Buffer,
+    error::NokhwaError,
+    traits::CaptureBackendTrait,
+    types::{
+        ApiBackend, CameraControl, CameraFormat, CameraIndex, CameraInfo, ControlValueSetter,
+        FrameFormat, KnownCameraControl, RequestedFormat, Resolution,
+    },
+};
+use std::collections::BTreeMap;
+use std::ffi::CString;
+use std::{
+    borrow::Cow,
+    collections::HashMap,
+    sync::{Arc, Mutex},
 };
-use std::{any::Any, borrow::Cow, collections::HashMap};
 
 /// The backend struct that interfaces with V4L2.
 /// To see what this does, please see [`CaptureBackendTrait`].
@@ -32,6 +42,7 @@ use std::{any::Any, borrow::Cow, collections::HashMap};
 /// - You **must** call [`nokhwa_initialize`](crate::nokhwa_initialize) **before** doing anything with `AVFoundation`.
 /// - This only works on 64 bit platforms.
 /// - FPS adjustment does not work.
+/// - If permission has not been granted and you call `init()` it will error.
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-avfoundation")))]
 pub struct AVFoundationCaptureDevice {
     device: AVCaptureDevice,
@@ -40,7 +51,9 @@ pub struct AVFoundationCaptureDevice {
     data_out: Option<AVCaptureVideoDataOutput>,
     data_collect: Option<AVCaptureVideoCallback>,
     info: CameraInfo,
+    buffer_name: CString,
     format: CameraFormat,
+    frame_buffer_lock: Arc<Mutex<(Vec<u8>, FrameFormat)>>,
 }
 
 impl AVFoundationCaptureDevice {
@@ -49,25 +62,22 @@ impl AVFoundationCaptureDevice {
     /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default.
     /// # Errors
     /// This function will error if the camera is currently busy or if `AVFoundation` can't read device information, or permission was not given by the user.
-    pub fn new(index: usize, camera_format: Option<CameraFormat>) -> Result<Self, NokhwaError> {
-        let camera_format = match camera_format {
-            Some(fmt) => fmt,
-            None => CameraFormat::default(),
-        };
-
-        let device_descriptor: CameraInfo = match query_avfoundation()?.into_iter().nth(index) {
-            Some(descriptor) => descriptor.into(),
-            None => {
-                return Err(NokhwaError::OpenDeviceError(
-                    index.to_string(),
-                    "No Device".to_string(),
-                ))
-            }
-        };
-
-        let mut device = AVCaptureDevice::from_id(&device_descriptor.misc())?;
+    pub fn new(index: &CameraIndex, req_fmt: RequestedFormat) -> Result<Self, NokhwaError> {
+        let mut device = AVCaptureDevice::new(index)?;
         device.lock()?;
-        device.set_all(camera_format.into())?;
+        let formats = device.supported_formats()?;
+        let camera_fmt = req_fmt.fulfill(&formats).ok_or_else(|| {
+            NokhwaError::OpenDeviceError("Cannot fulfill request".to_string(), req_fmt.to_string())
+        })?;
+        device.set_all(camera_fmt)?;
+        let device_descriptor = device.info().clone();
+        let buffername =
+            CString::new(format!("{}_INDEX{}_", device_descriptor, index)).map_err(|why| {
+                NokhwaError::StructureError {
+                    structure: "CString Buffername".to_string(),
+                    error: why.to_string(),
+                }
+            })?;
 
         Ok(AVFoundationCaptureDevice {
             device,
@@ -76,7 +86,9 @@ impl AVFoundationCaptureDevice {
             data_out: None,
             data_collect: None,
             info: device_descriptor,
-            format: camera_format,
+            buffer_name: buffername,
+            format: camera_fmt,
+            frame_buffer_lock: Arc::new(Mutex::new((vec![], FrameFormat::MJPEG))),
         })
     }
 
@@ -84,6 +96,8 @@ impl AVFoundationCaptureDevice {
     ///
     /// # Errors
     /// This function will error if the camera is currently busy or if `AVFoundation` can't read device information, or permission was not given by the user.
+    #[deprecated(since = "0.10.0", note = "please use `new` instead.")]
+    #[allow(clippy::cast_possible_truncation)]
     pub fn new_with(
         index: usize,
         width: u32,
@@ -91,26 +105,33 @@ impl AVFoundationCaptureDevice {
         fps: u32,
         fourcc: FrameFormat,
     ) -> Result<Self, NokhwaError> {
-        let camera_format = Some(CameraFormat::new_from(width, height, fourcc, fps));
-        AVFoundationCaptureDevice::new(index, camera_format)
+        let camera_format = CameraFormat::new_from(width, height, fourcc, fps);
+        AVFoundationCaptureDevice::new(
+            &CameraIndex::Index(index as u32),
+            RequestedFormat::Exact(camera_format),
+        )
     }
 }
 
 impl CaptureBackendTrait for AVFoundationCaptureDevice {
-    fn backend(&self) -> CaptureAPIBackend {
-        CaptureAPIBackend::AVFoundation
+    fn backend(&self) -> ApiBackend {
+        ApiBackend::AVFoundation
     }
 
     fn camera_info(&self) -> &CameraInfo {
         &self.info
     }
 
+    fn refresh_camera_format(&mut self) -> Result<(), NokhwaError> {
+        Ok(())
+    }
+
     fn camera_format(&self) -> CameraFormat {
         self.format
     }
 
     fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
-        self.device.set_all(new_fmt.into())?;
+        self.device.set_all(new_fmt)?;
         self.format = new_fmt;
         Ok(())
     }
@@ -121,23 +142,21 @@ impl CaptureBackendTrait for AVFoundationCaptureDevice {
         &mut self,
         fourcc: FrameFormat,
     ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
-        Ok(self
+        let supported_cfmt = self
             .device
             .supported_formats()?
             .into_iter()
-            .map(|fmt| {
-                (
-                    FrameFormat::from(fmt.fourcc),
-                    Resolution::from(fmt.resolution),
-                    (&fmt.fps_list)
-                        .iter()
-                        .map(|f| *f as u32)
-                        .collect::<Vec<u32>>(),
-                )
-            })
-            .filter(|x| (*x).0 == fourcc)
-            .map(|fmt| (fmt.1, fmt.2))
-            .collect::<HashMap<Resolution, Vec<u32>>>())
+            .filter(|x| x.format() != fourcc);
+        let mut res_list = HashMap::new();
+        for format in supported_cfmt {
+            match res_list.get_mut(&format.resolution()) {
+                Some(fpses) => Vec::push(fpses, format.frame_rate()),
+                None => {
+                    res_list.insert(format.resolution(), vec![format.frame_rate()]);
+                }
+            }
+        }
+        Ok(res_list)
     }
 
     fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
@@ -145,7 +164,7 @@ impl CaptureBackendTrait for AVFoundationCaptureDevice {
             .device
             .supported_formats()?
             .into_iter()
-            .map(|fmt| FrameFormat::from(fmt.fourcc))
+            .map(|fmt| fmt.format())
             .collect::<Vec<FrameFormat>>();
         formats.sort();
         formats.dedup();
@@ -182,40 +201,32 @@ impl CaptureBackendTrait for AVFoundationCaptureDevice {
         self.set_camera_format(format)
     }
 
-    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
-        Err(NokhwaError::NotImplementedError(
-            "Not Implemented".to_string(),
-        ))
+    fn camera_control(&self, control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
+        for ctrl in self.device.get_controls()? {
+            if ctrl.control() == control {
+                return Ok(ctrl);
+            }
+        }
+
+        return Err(NokhwaError::GetPropertyError {
+            property: control.to_string(),
+            error: "Not Found".to_string(),
+        });
     }
 
-    fn camera_control(&self, _: KnownCameraControls) -> Result<CameraControl, NokhwaError> {
-        Err(NokhwaError::NotImplementedError(
-            "Not Implemented".to_string(),
-        ))
+    fn camera_controls(&self) -> Result<Vec<CameraControl>, NokhwaError> {
+        self.device.get_controls()
     }
 
-    fn set_camera_control(&mut self, _: CameraControl) -> Result<(), NokhwaError> {
-        Err(NokhwaError::NotImplementedError(
-            "Not Implemented".to_string(),
-        ))
-    }
-
-    fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
-        Err(NokhwaError::NotImplementedError(
-            "Not Implemented".to_string(),
-        ))
-    }
-
-    fn raw_camera_control(&self, _: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
-        Err(NokhwaError::NotImplementedError(
-            "Not Implemented".to_string(),
-        ))
-    }
-
-    fn set_raw_camera_control(&mut self, _: &dyn Any, _: &dyn Any) -> Result<(), NokhwaError> {
-        Err(NokhwaError::NotImplementedError(
-            "Not Implemented".to_string(),
-        ))
+    fn set_camera_control(
+        &mut self,
+        id: KnownCameraControl,
+        value: ControlValueSetter,
+    ) -> Result<(), NokhwaError> {
+        self.device.lock()?;
+        let res = self.device.set_control(id, value);
+        self.device.unlock()?;
+        res
     }
 
     fn open_stream(&mut self) -> Result<(), NokhwaError> {
@@ -223,16 +234,19 @@ impl CaptureBackendTrait for AVFoundationCaptureDevice {
         let session = AVCaptureSession::new();
         session.begin_configuration();
         session.add_input(&input)?;
-        let callback = AVCaptureVideoCallback::new(self.info.index());
+
+        let frame_mutex = self.frame_buffer_lock.clone();
+        let bufname = &self.buffer_name;
+        let videocallback = AVCaptureVideoCallback::new(bufname, frame_mutex)?;
         let output = AVCaptureVideoDataOutput::new();
-        output.add_delegate(&callback)?;
+        output.add_delegate(&videocallback)?;
         session.add_output(&output)?;
         session.commit_configuration();
         session.start()?;
 
         self.dev_input = Some(input);
         self.session = Some(session);
-        self.data_collect = Some(callback);
+        self.data_collect = Some(videocallback);
         self.data_out = Some(output);
         Ok(())
     }
@@ -251,56 +265,37 @@ impl CaptureBackendTrait for AVFoundationCaptureDevice {
         }
     }
 
-    fn frame(&mut self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
-        let cam_fmt = self.camera_format();
-        let conv = self.frame_raw()?.to_vec();
-        let image_buf =
-            match ImageBuffer::from_vec(cam_fmt.width(), cam_fmt.height(), conv) {
-                Some(buf) => {
-                    let rgb_buf: ImageBuffer<Rgb<u8>, Vec<u8>> = buf;
-                    rgb_buf
-                }
-                None => return Err(NokhwaError::ReadFrameError(
-                    "ImageBuffer is not large enough! This is probably a bug, please report it!"
-                        .to_string(),
-                )),
-            };
-        Ok(image_buf)
+    fn frame(&mut self) -> Result<Buffer, NokhwaError> {
+        self.refresh_camera_format()?;
+        let cfmt = self.camera_format();
+        let buffer = Buffer::new(cfmt.resolution(), &self.frame_raw()?, cfmt.format());
+        Ok(buffer)
     }
 
     fn frame_raw(&mut self) -> Result<Cow<[u8]>, NokhwaError> {
-        match &self.session {
-            Some(session) => {
-                if !session.is_running() {
-                    return Err(NokhwaError::ReadFrameError(
-                        "Stream Not Started".to_string(),
-                    ));
+        let mut framebuffer_empty = match self.frame_buffer_lock.lock() {
+            Ok(f) => f.0.is_empty(),
+            Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
+        };
+
+        loop {
+            if framebuffer_empty {
+                match self.frame_buffer_lock.lock() {
+                    Ok(f) => framebuffer_empty = f.0.is_empty(),
+                    Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
                 }
-                if session.is_interrupted() {
-                    return Err(NokhwaError::ReadFrameError(
-                        "Stream Interrupted".to_string(),
-                    ));
-                }
-            }
-            None => {
-                return Err(NokhwaError::ReadFrameError(
-                    "Stream Not Started".to_string(),
-                ))
+            } else {
+                break;
             }
         }
 
-        match &self.data_collect {
-            Some(collector) => {
-                let data = collector.frame_to_slice()?;
-                let data = match data.1 {
-                    AVFourCC::YUV2 => Cow::from(yuyv422_to_rgb888(&data.0)?),
-                    AVFourCC::MJPEG => Cow::from(mjpeg_to_rgb888(&data.0)?),
-                };
-                Ok(data)
+        match self.frame_buffer_lock.lock() {
+            Ok(mut f) => {
+                let mut new_frame = vec![];
+                std::mem::swap(&mut new_frame, &mut f.0);
+                Ok(Cow::from(new_frame))
             }
-            None => Err(NokhwaError::ReadFrameError(
-                "Stream Not Started".to_string(),
-            )),
+            Err(why) => Err(NokhwaError::ReadFrameError(why.to_string())),
         }
     }
 
diff --git a/src/backends/capture/browser_backend.rs b/src/backends/capture/browser_backend.rs
new file mode 100644
index 0000000..f30f94d
--- /dev/null
+++ b/src/backends/capture/browser_backend.rs
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use crate::{
+    js_camera::JSCameraResizeMode,
+    js_camera::{query_js_cameras, JSCameraConstraintsBuilder},
+    ApiBackend, CameraControl, CameraFormat, CameraIndex, CameraInfo, CaptureBackendTrait,
+    FrameFormat, JSCamera, KnownCameraControl, NokhwaError, Resolution,
+};
+use image::{ImageBuffer, Rgb};
+use std::{any::Any, borrow::Cow, collections::HashMap};
+
+/// Captures using the Browser API. This internally wraps [`JSCamera`].
+///
+/// # Quirks
+/// - `FourCC` setting is ignored
+/// - Cannot get compatible resolution(s).
+/// - CameraControl(s) are not supported.
+/// - All frame capture is done by creating (then destorying) a canvas on the DOM.
+/// - Many methods are blocking on user input.
+pub struct BrowserCaptureDevice {
+    camera: JSCamera,
+    info: CameraInfo,
+}
+
+impl BrowserCaptureDevice {
+    // WARN: blocking on pass integer for index
+    /// Creates a new camera from an [`CameraIndex`]. It can take [`CameraIndex::Index`] or [`CameraIndex::String`] (NOTE: blocks on [`CameraIndex::Index`])
+    ///
+    /// # Errors
+    /// If the device is not found, browser not supported, or camera is over-constrained this will error.
+    pub fn new(index: &CameraIndex, cam_fmt: Option<CameraFormat>) -> Result<Self, NokhwaError> {
+        let (group_id, device_id) = match &index {
+            CameraIndex::Index(i) => {
+                let query_devices =
+                    wasm_rs_async_executor::single_threaded::block_on(query_js_cameras())?;
+                match query_devices.into_iter().nth(*i as usize) {
+                    Some(info) => {
+                        let ids = info
+                            .to_string()
+                            .split(' ')
+                            .map(ToString::to_string)
+                            .collect::<Vec<String>>();
+                        match (ids.get(0), ids.get(1)) {
+                            (Some(group_id), Some(device_id)) => {
+                                (group_id.clone(), device_id.clone())
+                            }
+                            (_, _) => {
+                                return Err(NokhwaError::OpenDeviceError(
+                                    "Invalid Index".to_string(),
+                                    index.to_string(),
+                                ))
+                            }
+                        }
+                    }
+                    None => {
+                        return Err(NokhwaError::OpenDeviceError(
+                            "Device not found".to_string(),
+                            index.to_string(),
+                        ))
+                    }
+                }
+            }
+            CameraIndex::String(id) => {
+                let ids = id
+                    .to_string()
+                    .split(' ')
+                    .map(ToString::to_string)
+                    .collect::<Vec<String>>();
+                match (ids.get(0), ids.get(1)) {
+                    (Some(group_id), Some(device_id)) => (group_id.clone(), device_id.clone()),
+                    (_, _) => {
+                        return Err(NokhwaError::OpenDeviceError(
+                            "Invalid Index".to_string(),
+                            index.to_string(),
+                        ))
+                    }
+                }
+            }
+        };
+
+        let camera_format = cam_fmt.unwrap_or_default();
+
+        let constraints = JSCameraConstraintsBuilder::new()
+            .frame_rate(camera_format.frame_rate())
+            .resolution(camera_format.resolution())
+            .aspect_ratio(f64::from(camera_format.width()) / f64::from(camera_format.height()))
+            .group_id(&group_id)
+            .group_id_exact(true)
+            .device_id(&device_id)
+            .device_id_exact(true)
+            .resize_mode(JSCameraResizeMode::Any)
+            .build();
+
+        let camera = wasm_rs_async_executor::single_threaded::block_on(JSCamera::new(constraints))?;
+
+        let info = (|| {
+            let cameras = wasm_rs_async_executor::single_threaded::block_on(query_js_cameras())?;
+            let giddid = format!("{} {}", group_id, device_id);
+            for cam in cameras {
+                if cam.misc() == giddid {
+                    return Ok(cam);
+                }
+            }
+            Ok(CameraInfo::new("", "videoinput", &giddid, index.clone()))
+        })()?;
+        Ok(BrowserCaptureDevice { camera, info })
+    }
+
+    /// Creates a new camera from an [`CameraIndex`] and raw parts. It can take [`CameraIndex::Index`] or [`CameraIndex::String`] (NOTE: blocks on [`CameraIndex::Index`])
+    ///
+    /// # Errors
+    /// If the device is not found, browser not supported, or camera is over-constrained this will error.
+    pub fn new_with(
+        index: &CameraIndex,
+        width: u32,
+        height: u32,
+        fps: u32,
+        fourcc: FrameFormat,
+    ) -> Result<Self, NokhwaError> {
+        Self::new(
+            index,
+            Some(CameraFormat::new(Resolution::new(width, height))),
+        )
+    }
+}
+
+impl CaptureBackendTrait for BrowserCaptureDevice {
+    fn backend(&self) -> ApiBackend {
+        ApiBackend::Browser
+    }
+
+    fn camera_info(&self) -> &CameraInfo {
+        &self.info
+    }
+
+    fn camera_format(&self) -> CameraFormat {
+        CameraFormat::new(self.camera.resolution())
+    }
+
+    fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
+        let current_constraints = self.camera.constraints();
+
+        let new_constraints = JSCameraConstraintsBuilder::new()
+            .resolution(new_fmt.resolution())
+            .aspect_ratio(f64::from(new_fmt.width()) / f64::from(new_fmt.height()))
+            .frame_rate(new_fmt.frame_rate())
+            .group_id(&current_constraints.group_id())
+            .device_id(&current_constraints.device_id())
+            .resize_mode(JSCameraResizeMode::Any)
+            .build();
+
+        let _constraint_err = self.camera.set_constraints(new_constraints);
+        match self.camera.apply_constraints() {
+            Ok(_) => Ok(()),
+            Err(why) => {
+                let _returnerr = self.camera.set_constraints(current_constraints); // swallow errors - revert
+                Err(why)
+            }
+        }
+    }
+
+    fn compatible_list_by_resolution(
+        &mut self,
+        _: FrameFormat,
+    ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not Implemented".to_string(),
+        ))
+    }
+
+    fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
+        Ok(vec![FrameFormat::MJPEG, FrameFormat::YUYV])
+    }
+
+    fn resolution(&self) -> Resolution {
+        self.camera.resolution()
+    }
+
+    fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError> {
+        let mut current_format = self.camera_format();
+        current_format.set_resolution(new_res);
+        self.set_camera_format(current_format)
+    }
+
+    fn frame_rate(&self) -> u32 {
+        self.camera.constraints().frame_rate()
+    }
+
+    fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError> {
+        let mut current_format = self.camera_format();
+        current_format.set_frame_rate(new_fps);
+        self.set_camera_format(current_format)
+    }
+
+    fn frame_format(&self) -> FrameFormat {
+        FrameFormat::MJPEG
+    }
+
+    fn set_frame_format(&mut self, _: FrameFormat) -> Result<(), NokhwaError> {
+        Ok(())
+    }
+
+    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControl>, NokhwaError> {
+        Ok(vec![])
+    }
+
+    fn camera_control(&self, _: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not Implemented".to_string(),
+        ))
+    }
+
+    fn set_camera_control(&mut self, _: CameraControl) -> Result<(), NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not Implemented".to_string(),
+        ))
+    }
+
+    fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
+        Ok(vec![])
+    }
+
+    fn raw_camera_control(&self, _: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not Implemented".to_string(),
+        ))
+    }
+
+    fn set_raw_camera_control(&mut self, _: &dyn Any, _: &dyn Any) -> Result<(), NokhwaError> {
+        Err(NokhwaError::NotImplementedError(
+            "Not Implemented".to_string(),
+        ))
+    }
+
+    fn open_stream(&mut self) -> Result<(), NokhwaError> {
+        Ok(())
+    }
+
+    fn is_stream_open(&self) -> bool {
+        self.camera.is_open()
+    }
+
+    fn frame(&mut self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
+        self.camera.frame()
+    }
+
+    fn frame_raw(&mut self) -> Result<Cow<[u8]>, NokhwaError> {
+        self.camera.frame_raw()
+    }
+
+    fn stop_stream(&mut self) -> Result<(), NokhwaError> {
+        self.camera.stop_all()
+    }
+}
diff --git a/src/backends/capture/gst_backend.rs b/src/backends/capture/gst_backend.rs
index 591d582..85911ba 100644
--- a/src/backends/capture/gst_backend.rs
+++ b/src/backends/capture/gst_backend.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,10 +15,9 @@
  */
 
 use crate::{
-    mjpeg_to_rgb888, yuyv422_to_rgb888, CameraControl, CameraFormat, CameraInfo, CaptureAPIBackend,
-    CaptureBackendTrait, FrameFormat, KnownCameraControls, NokhwaError, Resolution,
+    mjpeg_to_rgb, yuyv422_to_rgb, ApiBackend, CameraControl, CameraFormat, CameraInfo,
+    CaptureBackendTrait, FrameFormat, KnownCameraControl, NokhwaError, Resolution,
 };
-use flume::Receiver;
 use glib::Quark;
 use gstreamer::{
     element_error,
@@ -30,11 +29,11 @@ use gstreamer::{
 use gstreamer_app::{AppSink, AppSinkCallbacks};
 use gstreamer_video::{VideoFormat, VideoInfo};
 use image::{ImageBuffer, Rgb};
+use parking_lot::Mutex;
 use regex::Regex;
-use std::any::Any;
-use std::{borrow::Cow, collections::HashMap, str::FromStr};
+use std::{any::Any, borrow::Cow, collections::HashMap, str::FromStr, sync::Arc};
 
-type PipelineGenRet = (Element, AppSink, Receiver<ImageBuffer<Rgb<u8>, Vec<u8>>>);
+type PipelineGenRet = (Element, AppSink, Arc<Mutex<ImageBuffer<Rgb<u8>, Vec<u8>>>>);
 
 /// The backend struct that interfaces with `GStreamer`.
 /// To see what this does, please see [`CaptureBackendTrait`].
@@ -42,12 +41,16 @@ type PipelineGenRet = (Element, AppSink, Receiver<ImageBuffer<Rgb<u8>, Vec<u8>>>
 /// - `Drop`-ing this may cause a `panic`.
 /// - Setting controls is not supported.
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-gst")))]
+#[deprecated(
+    since = "0.10",
+    note = "Use one of the native backends instead(V4L, AVF, MSMF) or OpenCV"
+)]
 pub struct GStreamerCaptureDevice {
     pipeline: Element,
     app_sink: AppSink,
     camera_format: CameraFormat,
     camera_info: CameraInfo,
-    receiver: Receiver<ImageBuffer<Rgb<u8>, Vec<u8>>>,
+    image_lock: Arc<Mutex<ImageBuffer<Rgb<u8>, Vec<u8>>>>,
     caps: Option<Caps>,
 }
 
@@ -65,9 +68,11 @@ impl GStreamerCaptureDevice {
             None => CameraFormat::default(),
         };
 
+        let index = index.as_index()?;
+
         if let Err(why) = gstreamer::init() {
             return Err(NokhwaError::InitializeError {
-                backend: CaptureAPIBackend::GStreamer,
+                backend: ApiBackend::GStreamer,
                 error: why.to_string(),
             });
         }
@@ -99,7 +104,7 @@ impl GStreamerCaptureDevice {
                     error: format!("Not started, {}", why),
                 });
             }
-            let device = match device_monitor.devices().get(index) {
+            let device = match device_monitor.devices().get(index as usize) {
                 Some(dev) => dev.clone(),
                 None => {
                     return Err(NokhwaError::OpenDeviceError(
@@ -112,23 +117,23 @@ impl GStreamerCaptureDevice {
             let caps = device.caps();
             (
                 CameraInfo::new(
-                    DeviceExt::display_name(&device).to_string(),
-                    DeviceExt::device_class(&device).to_string(),
-                    "".to_string(),
+                    &DeviceExt::display_name(&device),
+                    &DeviceExt::device_class(&device),
+                    &"",
                     index,
                 ),
                 caps,
             )
         };
 
-        let (pipeline, app_sink, receiver) = generate_pipeline(camera_format, index)?;
+        let (pipeline, app_sink, receiver) = generate_pipeline(camera_format, index as usize)?;
 
         Ok(GStreamerCaptureDevice {
             pipeline,
             app_sink,
             camera_format,
             camera_info,
-            receiver,
+            image_lock: receiver,
             caps,
         })
     }
@@ -139,14 +144,14 @@ impl GStreamerCaptureDevice {
     /// # Errors
     /// This function will error if the camera is currently busy or if `GStreamer` can't read device information.
     pub fn new_with(index: usize, width: u32, height: u32, fps: u32) -> Result<Self, NokhwaError> {
-        let cam_fmt = CameraFormat::new(Resolution::new(width, height), FrameFormat::MJPEG, fps);
+        let cam_fmt = CameraFormat::new(Resolution::new(width, height));
         GStreamerCaptureDevice::new(index, Some(cam_fmt))
     }
 }
 
-impl CaptureBackendTrait for GStreamerCaptureDevice {
-    fn backend(&self) -> CaptureAPIBackend {
-        CaptureAPIBackend::GStreamer
+impl GStreamerCaptureDevice {
+    fn backend(&self) -> ApiBackend {
+        ApiBackend::GStreamer
     }
 
     fn camera_info(&self) -> &CameraInfo {
@@ -163,10 +168,11 @@ impl CaptureBackendTrait for GStreamerCaptureDevice {
             self.stop_stream()?;
             reopen = true;
         }
-        let (pipeline, app_sink, receiver) = generate_pipeline(new_fmt, self.camera_info.index())?;
+        let (pipeline, app_sink, receiver) =
+            generate_pipeline(new_fmt, self.camera_info.index_num()? as usize)?;
         self.pipeline = pipeline;
         self.app_sink = app_sink;
-        self.receiver = receiver;
+        self.image_lock = receiver;
         if reopen {
             self.open_stream()?;
         }
@@ -362,6 +368,11 @@ impl CaptureBackendTrait for GStreamerCaptureDevice {
                                     .insert(Resolution::new(width as u32, height as u32), fps_vec);
                             }
                         }
+                        unsupported => {
+                            return Err(NokhwaError::NotImplementedError(format!(
+                                "Not supported frame format {unsupported:?}"
+                            )))
+                        }
                     }
                 }
             }
@@ -428,37 +439,37 @@ impl CaptureBackendTrait for GStreamerCaptureDevice {
 
     fn set_frame_format(&mut self, _fourcc: FrameFormat) -> Result<(), NokhwaError> {
         Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::GStreamer,
+            ApiBackend::GStreamer,
         ))
     }
 
-    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
+    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControl>, NokhwaError> {
         Err(NokhwaError::NotImplementedError(
-            CaptureAPIBackend::GStreamer.to_string(),
+            ApiBackend::GStreamer.to_string(),
         ))
     }
 
-    fn camera_control(&self, _control: KnownCameraControls) -> Result<CameraControl, NokhwaError> {
+    fn camera_control(&self, _control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
         Err(NokhwaError::NotImplementedError(
-            CaptureAPIBackend::GStreamer.to_string(),
+            ApiBackend::GStreamer.to_string(),
         ))
     }
 
     fn set_camera_control(&mut self, _control: CameraControl) -> Result<(), NokhwaError> {
         Err(NokhwaError::NotImplementedError(
-            CaptureAPIBackend::GStreamer.to_string(),
+            ApiBackend::GStreamer.to_string(),
         ))
     }
 
     fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
         Err(NokhwaError::NotImplementedError(
-            CaptureAPIBackend::GStreamer.to_string(),
+            ApiBackend::GStreamer.to_string(),
         ))
     }
 
     fn raw_camera_control(&self, _control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
         Err(NokhwaError::NotImplementedError(
-            CaptureAPIBackend::GStreamer.to_string(),
+            ApiBackend::GStreamer.to_string(),
         ))
     }
 
@@ -468,7 +479,7 @@ impl CaptureBackendTrait for GStreamerCaptureDevice {
         _value: &dyn Any,
     ) -> Result<(), NokhwaError> {
         Err(NokhwaError::NotImplementedError(
-            CaptureAPIBackend::GStreamer.to_string(),
+            ApiBackend::GStreamer.to_string(),
         ))
     }
 
@@ -540,15 +551,7 @@ impl CaptureBackendTrait for GStreamerCaptureDevice {
             }
         }
 
-        match self.receiver.recv() {
-            Ok(msg) => Ok(Cow::from(msg.to_vec())),
-            Err(why) => {
-                return Err(NokhwaError::ReadFrameError(format!(
-                    "Receiver Error: {}",
-                    why
-                )));
-            }
-        }
+        Ok(Cow::from(self.image_lock.lock().to_vec()))
     }
 
     fn stop_stream(&mut self) -> Result<(), NokhwaError> {
@@ -564,7 +567,7 @@ impl CaptureBackendTrait for GStreamerCaptureDevice {
 
 impl Drop for GStreamerCaptureDevice {
     fn drop(&mut self) {
-        self.pipeline.set_state(State::Null).unwrap();
+        let _ = self.pipeline.set_state(State::Null);
     }
 }
 
@@ -577,6 +580,9 @@ fn webcam_pipeline(device: &str, camera_format: CameraFormat) -> String {
         FrameFormat::YUYV => {
             format!("autovideosrc location=/dev/video{} ! video/x-raw,format=YUY2,width={},height={},framerate={}/1 ! appsink name=appsink async=false sync=false", device, camera_format.width(), camera_format.height(), camera_format.frame_rate())
         }
+        _ => {
+            format!("unsupproted! if you see this, switch to something else!")
+        }
     }
 }
 
@@ -589,6 +595,9 @@ fn webcam_pipeline(device: &str, camera_format: CameraFormat) -> String {
         FrameFormat::YUYV => {
             format!("v4l2src device=/dev/video{} ! video/x-raw,format=YUY2,width={},height={},framerate={}/1 ! appsink name=appsink async=false sync=false", device, camera_format.width(), camera_format.height(), camera_format.frame_rate())
         }
+        _ => {
+            format!("unsupproted! if you see this, switch to something else!")
+        }
     }
 }
 
@@ -601,6 +610,9 @@ fn webcam_pipeline(device: &str, camera_format: CameraFormat) -> String {
         FrameFormat::YUYV => {
             format!("ksvideosrc device_index={} ! video/x-raw,format=YUY2,width={},height={},framerate={}/1 ! appsink name=appsink async=false sync=false", device, camera_format.width(), camera_format.height(), camera_format.frame_rate())
         }
+        _ => {
+            format!("unsupproted! if you see this, switch to something else!")
+        }
     }
 }
 
@@ -650,7 +662,8 @@ fn generate_pipeline(fmt: CameraFormat, index: usize) -> Result<PipelineGenRet,
 
     pipeline.set_state(State::Playing).unwrap();
 
-    let (sender, receiver) = flume::unbounded();
+    let image_lock = Arc::new(Mutex::new(ImageBuffer::default()));
+    let img_lck_clone = image_lock.clone();
 
     appsink.set_callbacks(
         AppSinkCallbacks::builder()
@@ -708,7 +721,7 @@ fn generate_pipeline(fmt: CameraFormat, index: usize) -> Result<PipelineGenRet,
 
                 let image_buffer = match video_info.format() {
                     VideoFormat::Yuy2 => {
-                        let mut decoded_buffer = match yuyv422_to_rgb888(&buffer_map) {
+                        let mut decoded_buffer = match yuyv422_to_rgb(&buffer_map, false) {
                             Ok(buf) => buf,
                             Err(why) => {
                                 element_error!(
@@ -770,7 +783,7 @@ fn generate_pipeline(fmt: CameraFormat, index: usize) -> Result<PipelineGenRet,
                     }
                     // MJPEG
                     VideoFormat::Encoded => {
-                        let mut decoded_buffer = match mjpeg_to_rgb888(&buffer_map) {
+                        let mut decoded_buffer = match mjpeg_to_rgb(&buffer_map, false) {
                             Ok(buf) => buf,
                             Err(why) => {
                                 element_error!(
@@ -816,13 +829,11 @@ fn generate_pipeline(fmt: CameraFormat, index: usize) -> Result<PipelineGenRet,
                     }
                 };
 
-                if sender.send(image_buffer).is_err() {
-                    return Err(FlowError::Error);
-                }
+                *img_lck_clone.lock() = image_buffer;
 
                 Ok(FlowSuccess::Ok)
             })
             .build(),
     );
-    Ok((pipeline, appsink, receiver))
+    Ok((pipeline, appsink, image_lock))
 }
diff --git a/src/backends/capture/mod.rs b/src/backends/capture/mod.rs
index 18188bf..3171ef2 100644
--- a/src/backends/capture/mod.rs
+++ b/src/backends/capture/mod.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,21 +16,21 @@
 
 #[cfg(all(feature = "input-v4l", target_os = "linux"))]
 // I'm too lazy to set up a skeleton facade for V4L so here it will stay
-mod v4l2;
+mod v4l2_backend;
 #[cfg(all(feature = "input-v4l", target_os = "linux"))]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-v4l")))]
-pub use v4l2::V4LCaptureDevice;
+pub use v4l2_backend::V4LCaptureDevice;
 #[cfg(any(
     all(feature = "input-msmf", target_os = "windows"),
     all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
 ))]
-mod msmf;
+mod msmf_backend;
 #[cfg(any(
     all(feature = "input-msmf", target_os = "windows"),
     all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
 ))]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-msmf")))]
-pub use msmf::MediaFoundationCaptureDevice;
+pub use msmf_backend::MediaFoundationCaptureDevice;
 #[cfg(any(
     all(
         feature = "input-avfoundation",
@@ -57,16 +57,28 @@ mod avfoundation;
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-avfoundation")))]
 pub use avfoundation::AVFoundationCaptureDevice;
 // FIXME: Fix Lifetime Issues
-// #[cfg(feature = "input-uvc")]
-// mod uvc_backend;
-// #[cfg(feature = "input-uvc")]
-// #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-uvc")))]
-// pub use uvc_backend::UVCCaptureDevice;
+#[cfg(feature = "input-uvc")]
+mod uvc_backend;
+#[cfg(feature = "input-uvc")]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-uvc")))]
+pub use uvc_backend::UVCCaptureDevice;
 #[cfg(feature = "input-gst")]
 mod gst_backend;
 #[cfg(feature = "input-gst")]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-gst")))]
 pub use gst_backend::GStreamerCaptureDevice;
+#[cfg(feature = "input-jscam")]
+mod browser_backend;
+#[cfg(feature = "input-jscam")]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-jscam")))]
+pub use browser_backend::BrowserCaptureDevice;
+/// A camera that uses `OpenCV` to access IP (rtsp/http) on the local network
+#[cfg(feature = "input-ipcam")]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-ipcam")))]
+mod network_camera;
+#[cfg(feature = "input-ipcam")]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-ipcam")))]
+pub use network_camera::NetworkCamera;
 #[cfg(feature = "input-opencv")]
 mod opencv_backend;
 #[cfg(feature = "input-opencv")]
diff --git a/src/backends/capture/msmf.rs b/src/backends/capture/msmf.rs
deleted file mode 100644
index 04f7078..0000000
--- a/src/backends/capture/msmf.rs
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use crate::{
-    all_known_camera_controls, mjpeg_to_rgb888, yuyv422_to_rgb888, CameraControl, CameraFormat,
-    CameraInfo, CaptureAPIBackend, CaptureBackendTrait, FrameFormat, KnownCameraControlFlag,
-    KnownCameraControls, NokhwaError, Resolution,
-};
-use image::{ImageBuffer, Rgb};
-use nokhwa_bindings_windows::{wmf::MediaFoundationDevice, MFControl, MediaFoundationControls};
-use std::{any::Any, borrow::Cow, collections::HashMap};
-
-/// The backend that deals with Media Foundation on Windows.
-/// To see what this does, please see [`CaptureBackendTrait`].
-///
-/// Note: This requires Windows 7 or newer to work.
-/// # Quirks
-/// - This does build on non-windows platforms, however when you do the backend will be empty and will return an error for any given operation.
-/// - Please check [`nokhwa-bindings-windows`](https://github.com/l1npengtul/nokhwa/tree/senpai/nokhwa-bindings-windows) source code to see the internal raw interface.
-/// - [`raw_supported_camera_controls()`](CaptureBackendTrait::raw_supported_camera_controls), [`raw_camera_control()`](CaptureBackendTrait::raw_camera_control), [`set_raw_camera_control()`](CaptureBackendTrait::set_raw_camera_control) is **not** supported.
-/// - The symbolic link for the device is listed in the `misc` attribute of the [`CameraInfo`].
-/// - The names may contain invalid characters since they were converted from UTF16.
-/// - When you call new or drop the struct, `initialize`/`de_initialize` will automatically be called.
-#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-msmf")))]
-pub struct MediaFoundationCaptureDevice<'a> {
-    inner: MediaFoundationDevice<'a>,
-    info: CameraInfo,
-}
-
-impl<'a> MediaFoundationCaptureDevice<'a> {
-    /// Creates a new capture device using the Media Foundation backend. Indexes are gives to devices by the OS, and usually numbered by order of discovery.
-    ///
-    /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default.
-    /// # Errors
-    /// This function will error if Media Foundation fails to get the device.
-    pub fn new(index: usize, camera_fmt: Option<CameraFormat>) -> Result<Self, NokhwaError> {
-        let format = camera_fmt.unwrap_or_default();
-        let mf_device = MediaFoundationDevice::new(index, format.into())?;
-
-        let info = CameraInfo::new(
-            mf_device.name(),
-            "MediaFoundation Camera Device".to_string(),
-            mf_device.symlink(),
-            mf_device.index(),
-        );
-
-        Ok(MediaFoundationCaptureDevice {
-            inner: mf_device,
-            info,
-        })
-    }
-
-    /// Create a new Media Foundation Device with desired settings.
-    /// # Errors
-    /// This function will error if Media Foundation fails to get the device.
-    pub fn new_with(
-        index: usize,
-        width: u32,
-        height: u32,
-        fps: u32,
-        fourcc: FrameFormat,
-    ) -> Result<Self, NokhwaError> {
-        let camera_format = Some(CameraFormat::new_from(width, height, fourcc, fps));
-        MediaFoundationCaptureDevice::new(index, camera_format)
-    }
-}
-
-impl<'a> CaptureBackendTrait for MediaFoundationCaptureDevice<'a> {
-    fn backend(&self) -> CaptureAPIBackend {
-        CaptureAPIBackend::MediaFoundation
-    }
-
-    fn camera_info(&self) -> &CameraInfo {
-        &self.info
-    }
-
-    fn camera_format(&self) -> CameraFormat {
-        self.inner.format().into()
-    }
-
-    fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
-        if let Err(why) = self.inner.set_format(new_fmt.into()) {
-            return Err(why.into());
-        }
-        Ok(())
-    }
-
-    fn compatible_list_by_resolution(
-        &mut self,
-        fourcc: FrameFormat,
-    ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
-        let mf_camera_format_list = self.inner.compatible_format_list()?;
-        let mut resolution_map: HashMap<Resolution, Vec<u32>> = HashMap::new();
-
-        for mf_camera_format in mf_camera_format_list {
-            let camera_format: CameraFormat = mf_camera_format.into();
-
-            // check fcc
-            if camera_format.format() != fourcc {
-                continue;
-            }
-
-            match resolution_map.get_mut(&camera_format.resolution()) {
-                Some(fps_list) => {
-                    fps_list.push(camera_format.frame_rate());
-                }
-                None => {
-                    if let Some(mut wtf_why_we_here_list) = resolution_map
-                        .insert(camera_format.resolution(), vec![camera_format.frame_rate()])
-                    {
-                        wtf_why_we_here_list.push(camera_format.frame_rate());
-                        resolution_map.insert(camera_format.resolution(), wtf_why_we_here_list);
-                    }
-                }
-            }
-        }
-        Ok(resolution_map)
-    }
-
-    fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
-        let mf_camera_format_list = self.inner.compatible_format_list()?;
-        let mut frame_format_list = vec![];
-
-        for mf_camera_format in mf_camera_format_list {
-            let camera_format: CameraFormat = mf_camera_format.into();
-
-            if !frame_format_list.contains(&camera_format.format()) {
-                frame_format_list.push(camera_format.format());
-            }
-
-            // TODO: Update as we get more frame formats!
-            if frame_format_list.len() == 2 {
-                break;
-            }
-        }
-        Ok(frame_format_list)
-    }
-
-    fn resolution(&self) -> Resolution {
-        self.camera_format().resolution()
-    }
-
-    fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError> {
-        let mut new_format = self.camera_format();
-        new_format.set_resolution(new_res);
-        self.set_camera_format(new_format)
-    }
-
-    fn frame_rate(&self) -> u32 {
-        self.camera_format().frame_rate()
-    }
-
-    fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError> {
-        let mut new_format = self.camera_format();
-        new_format.set_frame_rate(new_fps);
-        self.set_camera_format(new_format)
-    }
-
-    fn frame_format(&self) -> FrameFormat {
-        self.camera_format().format()
-    }
-
-    fn set_frame_format(&mut self, fourcc: FrameFormat) -> Result<(), NokhwaError> {
-        let mut new_format = self.camera_format();
-        new_format.set_format(fourcc);
-        self.set_camera_format(new_format)
-    }
-
-    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
-        let mut supported_camera_controls: Vec<KnownCameraControls> = vec![];
-
-        for camera_control in all_known_camera_controls() {
-            let msmf_camera_control: MediaFoundationControls = match camera_control {
-                KnownCameraControls::Brightness => MediaFoundationControls::Brightness,
-                KnownCameraControls::Contrast => MediaFoundationControls::Contrast,
-                KnownCameraControls::Hue => MediaFoundationControls::Hue,
-                KnownCameraControls::Saturation => MediaFoundationControls::Saturation,
-                KnownCameraControls::Sharpness => MediaFoundationControls::Sharpness,
-                KnownCameraControls::Gamma => MediaFoundationControls::Gamma,
-                KnownCameraControls::ColorEnable => MediaFoundationControls::ColorEnable,
-                KnownCameraControls::WhiteBalance => MediaFoundationControls::WhiteBalance,
-                KnownCameraControls::BacklightComp => MediaFoundationControls::BacklightComp,
-                KnownCameraControls::Gain => MediaFoundationControls::Gain,
-                KnownCameraControls::Pan => MediaFoundationControls::Pan,
-                KnownCameraControls::Tilt => MediaFoundationControls::Tilt,
-                KnownCameraControls::Roll => MediaFoundationControls::Roll,
-                KnownCameraControls::Zoom => MediaFoundationControls::Zoom,
-                KnownCameraControls::Exposure => MediaFoundationControls::Exposure,
-                KnownCameraControls::Iris => MediaFoundationControls::Iris,
-                KnownCameraControls::Focus => MediaFoundationControls::Focus,
-            };
-
-            if let Ok(supported) = self.inner.control(msmf_camera_control) {
-                supported_camera_controls.push(supported.control().into());
-            }
-        }
-
-        Ok(supported_camera_controls)
-    }
-
-    fn camera_control(&self, control: KnownCameraControls) -> Result<CameraControl, NokhwaError> {
-        let msmf_camera_control: MediaFoundationControls = match control {
-            KnownCameraControls::Brightness => MediaFoundationControls::Brightness,
-            KnownCameraControls::Contrast => MediaFoundationControls::Contrast,
-            KnownCameraControls::Hue => MediaFoundationControls::Hue,
-            KnownCameraControls::Saturation => MediaFoundationControls::Saturation,
-            KnownCameraControls::Sharpness => MediaFoundationControls::Sharpness,
-            KnownCameraControls::Gamma => MediaFoundationControls::Gamma,
-            KnownCameraControls::ColorEnable => MediaFoundationControls::ColorEnable,
-            KnownCameraControls::WhiteBalance => MediaFoundationControls::WhiteBalance,
-            KnownCameraControls::BacklightComp => MediaFoundationControls::BacklightComp,
-            KnownCameraControls::Gain => MediaFoundationControls::Gain,
-            KnownCameraControls::Pan => MediaFoundationControls::Pan,
-            KnownCameraControls::Tilt => MediaFoundationControls::Tilt,
-            KnownCameraControls::Roll => MediaFoundationControls::Roll,
-            KnownCameraControls::Zoom => MediaFoundationControls::Zoom,
-            KnownCameraControls::Exposure => MediaFoundationControls::Exposure,
-            KnownCameraControls::Iris => MediaFoundationControls::Iris,
-            KnownCameraControls::Focus => MediaFoundationControls::Focus,
-        };
-
-        let ctrl = match self.inner.control(msmf_camera_control) {
-            Ok(ctrl) => ctrl,
-            Err(why) => return Err(why.into()),
-        };
-
-        let flag = if ctrl.manual() {
-            KnownCameraControlFlag::Manual
-        } else {
-            KnownCameraControlFlag::Automatic
-        };
-
-        let min = MFControl::min(&ctrl);
-        let max = MFControl::max(&ctrl);
-
-        CameraControl::new(
-            control,
-            min,
-            max,
-            ctrl.current(),
-            ctrl.step(),
-            ctrl.default(),
-            flag,
-            ctrl.active(),
-        )
-    }
-
-    fn set_camera_control(&mut self, control: CameraControl) -> Result<(), NokhwaError> {
-        let ctrl = match control.control() {
-            KnownCameraControls::Brightness => MediaFoundationControls::Brightness,
-            KnownCameraControls::Contrast => MediaFoundationControls::Contrast,
-            KnownCameraControls::Hue => MediaFoundationControls::Hue,
-            KnownCameraControls::Saturation => MediaFoundationControls::Saturation,
-            KnownCameraControls::Sharpness => MediaFoundationControls::Sharpness,
-            KnownCameraControls::Gamma => MediaFoundationControls::Gamma,
-            KnownCameraControls::ColorEnable => MediaFoundationControls::ColorEnable,
-            KnownCameraControls::WhiteBalance => MediaFoundationControls::WhiteBalance,
-            KnownCameraControls::BacklightComp => MediaFoundationControls::BacklightComp,
-            KnownCameraControls::Gain => MediaFoundationControls::Gain,
-            KnownCameraControls::Pan => MediaFoundationControls::Pan,
-            KnownCameraControls::Tilt => MediaFoundationControls::Tilt,
-            KnownCameraControls::Roll => MediaFoundationControls::Roll,
-            KnownCameraControls::Zoom => MediaFoundationControls::Zoom,
-            KnownCameraControls::Exposure => MediaFoundationControls::Exposure,
-            KnownCameraControls::Iris => MediaFoundationControls::Iris,
-            KnownCameraControls::Focus => MediaFoundationControls::Focus,
-        };
-
-        let flag = match control.flag() {
-            KnownCameraControlFlag::Automatic => false,
-            KnownCameraControlFlag::Manual => true,
-        };
-
-        let msmf_camera_control = MFControl::new(
-            ctrl,
-            control.minimum_value(),
-            control.maximum_value(),
-            control.step(),
-            control.value(),
-            control.default(),
-            flag,
-            control.active(),
-        );
-
-        if let Err(why) = self.inner.set_control(msmf_camera_control) {
-            return Err(why.into());
-        }
-        Ok(())
-    }
-
-    fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::MediaFoundation,
-        ))
-    }
-
-    fn raw_camera_control(&self, _control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::MediaFoundation,
-        ))
-    }
-
-    fn set_raw_camera_control(
-        &mut self,
-        _control: &dyn Any,
-        _value: &dyn Any,
-    ) -> Result<(), NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::MediaFoundation,
-        ))
-    }
-
-    fn open_stream(&mut self) -> Result<(), NokhwaError> {
-        if let Err(why) = self.inner.start_stream() {
-            return Err(why.into());
-        }
-
-        Ok(())
-    }
-
-    fn is_stream_open(&self) -> bool {
-        self.inner.is_stream_open()
-    }
-
-    fn frame(&mut self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
-        let camera_format = self.camera_format();
-        let raw_data = self.frame_raw()?;
-        let conv = match camera_format.format() {
-            FrameFormat::MJPEG => mjpeg_to_rgb888(raw_data.as_ref())?,
-            FrameFormat::YUYV => yuyv422_to_rgb888(raw_data.as_ref())?,
-        };
-
-        let imagebuf =
-            match ImageBuffer::from_vec(camera_format.width(), camera_format.height(), conv) {
-                Some(buf) => {
-                    let rgbbuf: ImageBuffer<Rgb<u8>, Vec<u8>> = buf;
-                    rgbbuf
-                }
-                None => return Err(NokhwaError::ReadFrameError(
-                    "Imagebuffer is not large enough! This is probably a bug, please report it!"
-                        .to_string(),
-                )),
-            };
-
-        Ok(imagebuf)
-    }
-
-    fn frame_raw(&mut self) -> Result<Cow<[u8]>, NokhwaError> {
-        match self.inner.raw_bytes() {
-            Ok(data) => Ok(data),
-            Err(why) => Err(why.into()),
-        }
-    }
-
-    fn stop_stream(&mut self) -> Result<(), NokhwaError> {
-        self.inner.stop_stream();
-        Ok(())
-    }
-}
diff --git a/src/backends/capture/msmf_backend.rs b/src/backends/capture/msmf_backend.rs
new file mode 100644
index 0000000..bcfed65
--- /dev/null
+++ b/src/backends/capture/msmf_backend.rs
@@ -0,0 +1,303 @@
+/*
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+use nokhwa_bindings_windows::wmf::MediaFoundationDevice;
+use nokhwa_core::{
+    buffer::Buffer,
+    error::NokhwaError,
+    traits::CaptureBackendTrait,
+    types::{
+        all_known_camera_controls, ApiBackend, CameraControl, CameraFormat, CameraIndex,
+        CameraInfo, ControlValueSetter, FrameFormat, KnownCameraControl, RequestedFormat,
+        Resolution,
+    },
+};
+use std::{borrow::Cow, collections::HashMap};
+
+/// The backend that deals with Media Foundation on Windows.
+/// To see what this does, please see [`CaptureBackendTrait`].
+///
+/// Note: This requires Windows 7 or newer to work.
+/// # Quirks
+/// - This does build on non-windows platforms, however when you do the backend will be empty and will return an error for any given operation.
+/// - Please check [`nokhwa-bindings-windows`](https://github.com/l1npengtul/nokhwa/tree/senpai/nokhwa-bindings-windows) source code to see the internal raw interface.
+/// - [`raw_supported_camera_controls()`](CaptureBackendTrait::raw_supported_camera_controls), [`raw_camera_control()`](CaptureBackendTrait::raw_camera_control), [`set_raw_camera_control()`](CaptureBackendTrait::set_raw_camera_control) is **not** supported.
+/// - The symbolic link for the device is listed in the `misc` attribute of the [`CameraInfo`].
+/// - The names may contain invalid characters since they were converted from UTF16.
+/// - When you call new or drop the struct, `initialize`/`de_initialize` will automatically be called.
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-msmf")))]
+pub struct MediaFoundationCaptureDevice<'a> {
+    inner: MediaFoundationDevice<'a>,
+    info: CameraInfo,
+}
+
+impl<'a> MediaFoundationCaptureDevice<'a> {
+    /// Creates a new capture device using the Media Foundation backend. Indexes are gives to devices by the OS, and usually numbered by order of discovery.
+    /// # Errors
+    /// This function will error if Media Foundation fails to get the device.
+    pub fn new(index: &CameraIndex, camera_fmt: RequestedFormat) -> Result<Self, NokhwaError> {
+        let mut mf_device = MediaFoundationDevice::new(index.clone())?;
+
+        let info = CameraInfo::new(
+            &mf_device.name(),
+            &"MediaFoundation Camera Device".to_string(),
+            &mf_device.symlink(),
+            index.clone(),
+        );
+
+        let availible = mf_device
+            .compatible_format_list()?
+            .into_iter()
+            .map(|x| {
+                let cf: CameraFormat = x.into();
+                cf
+            })
+            .collect::<Vec<CameraFormat>>();
+
+        let desired = camera_fmt
+            .fufill(&availible)
+            .ok_or(NokhwaError::InitializeError {
+                backend: ApiBackend::MediaFoundation,
+                error: "Failed to fulfill requested format".to_string(),
+            })?;
+
+        mf_device.set_format(desired.into())?;
+
+        let mut new_cam = MediaFoundationCaptureDevice {
+            inner: mf_device,
+            info,
+        };
+        new_cam.refresh_camera_format()?;
+        Ok(new_cam)
+    }
+
+    /// Create a new Media Foundation Device with desired settings.
+    /// # Errors
+    /// This function will error if Media Foundation fails to get the device.
+    #[deprecated(since = "0.10", note = "please use `new` instead.")]
+    pub fn new_with(
+        index: &CameraIndex,
+        width: u32,
+        height: u32,
+        fps: u32,
+        fourcc: FrameFormat,
+    ) -> Result<Self, NokhwaError> {
+        let camera_format =
+            RequestedFormat::Exact(CameraFormat::new_from(width, height, fourcc, fps));
+        MediaFoundationCaptureDevice::new(index, camera_format)
+    }
+
+    /// Gets the list of supported [`KnownCameraControl`]s
+    /// # Errors
+    /// May error if there is an error from `MediaFoundation`.
+    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControl>, NokhwaError> {
+        let mut supported_camera_controls: Vec<KnownCameraControl> = vec![];
+
+        for camera_control in all_known_camera_controls() {
+            let msmf_camera_control: MediaFoundationControls = match camera_control {
+                KnownCameraControl::Brightness => MediaFoundationControls::Brightness,
+                KnownCameraControl::Contrast => MediaFoundationControls::Contrast,
+                KnownCameraControl::Hue => MediaFoundationControls::Hue,
+                KnownCameraControl::Saturation => MediaFoundationControls::Saturation,
+                KnownCameraControl::Sharpness => MediaFoundationControls::Sharpness,
+                KnownCameraControl::Gamma => MediaFoundationControls::Gamma,
+                KnownCameraControl::WhiteBalance => MediaFoundationControls::WhiteBalance,
+                KnownCameraControl::BacklightComp => MediaFoundationControls::BacklightComp,
+                KnownCameraControl::Gain => MediaFoundationControls::Gain,
+                KnownCameraControl::Pan => MediaFoundationControls::Pan,
+                KnownCameraControl::Tilt => MediaFoundationControls::Tilt,
+                KnownCameraControl::Zoom => MediaFoundationControls::Zoom,
+                KnownCameraControl::Exposure => MediaFoundationControls::Exposure,
+                KnownCameraControl::Iris => MediaFoundationControls::Iris,
+                KnownCameraControl::Focus => MediaFoundationControls::Focus,
+                KnownCameraControl::Other(id) => match id {
+                    0 => MediaFoundationControls::ColorEnable,
+                    1 => MediaFoundationControls::Roll,
+                    _ => continue,
+                },
+            };
+
+            if let Ok(supported) = self.inner.control(msmf_camera_control) {
+                supported_camera_controls.push(supported.control().into());
+            }
+        }
+
+        Ok(supported_camera_controls)
+    }
+}
+
+impl<'a> CaptureBackendTrait for MediaFoundationCaptureDevice<'a> {
+    fn backend(&self) -> ApiBackend {
+        ApiBackend::MediaFoundation
+    }
+
+    fn camera_info(&self) -> &CameraInfo {
+        &self.info
+    }
+
+    fn refresh_camera_format(&mut self) -> Result<(), NokhwaError> {
+        let _ = self.inner.format_refreshed()?;
+        Ok(())
+    }
+
+    fn camera_format(&self) -> CameraFormat {
+        self.inner.format().into()
+    }
+
+    fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
+        if let Err(why) = self.inner.set_format(new_fmt.into()) {
+            return Err(why.into());
+        }
+        Ok(())
+    }
+
+    fn compatible_list_by_resolution(
+        &mut self,
+        fourcc: FrameFormat,
+    ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
+        let mf_camera_format_list = self.inner.compatible_format_list()?;
+        let mut resolution_map: HashMap<Resolution, Vec<u32>> = HashMap::new();
+
+        for mf_camera_format in mf_camera_format_list {
+            let camera_format: CameraFormat = mf_camera_format.into();
+
+            // check fcc
+            if camera_format.format() != fourcc {
+                continue;
+            }
+
+            match resolution_map.get_mut(&camera_format.resolution()) {
+                Some(fps_list) => {
+                    fps_list.push(camera_format.frame_rate());
+                }
+                None => {
+                    if let Some(mut wtf_why_we_here_list) = resolution_map
+                        .insert(camera_format.resolution(), vec![camera_format.frame_rate()])
+                    {
+                        wtf_why_we_here_list.push(camera_format.frame_rate());
+                        resolution_map.insert(camera_format.resolution(), wtf_why_we_here_list);
+                    }
+                }
+            }
+        }
+        Ok(resolution_map)
+    }
+
+    fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
+        let mf_camera_format_list = self.inner.compatible_format_list()?;
+        let mut frame_format_list = vec![];
+
+        for mf_camera_format in mf_camera_format_list {
+            let camera_format: CameraFormat = mf_camera_format.into();
+
+            if !frame_format_list.contains(&camera_format.format()) {
+                frame_format_list.push(camera_format.format());
+            }
+
+            // TODO: Update as we get more frame formats!
+            if frame_format_list.len() == 2 {
+                break;
+            }
+        }
+        Ok(frame_format_list)
+    }
+
+    fn resolution(&self) -> Resolution {
+        self.camera_format().resolution()
+    }
+
+    fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError> {
+        let mut new_format = self.camera_format();
+        new_format.set_resolution(new_res);
+        self.set_camera_format(new_format)
+    }
+
+    fn frame_rate(&self) -> u32 {
+        self.camera_format().frame_rate()
+    }
+
+    fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError> {
+        let mut new_format = self.camera_format();
+        new_format.set_frame_rate(new_fps);
+        self.set_camera_format(new_format)
+    }
+
+    fn frame_format(&self) -> FrameFormat {
+        self.camera_format().format()
+    }
+
+    fn set_frame_format(&mut self, fourcc: FrameFormat) -> Result<(), NokhwaError> {
+        let mut new_format = self.camera_format();
+        new_format.set_format(fourcc);
+        self.set_camera_format(new_format)
+    }
+
+    fn camera_control(&self, control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
+        self.inner.control(control)
+    }
+
+    fn camera_controls(&self) -> Result<Vec<CameraControl>, NokhwaError> {
+        let mut camera_ctrls = Vec::with_capacity(15);
+        for ctrl_id in all_known_camera_controls() {
+            let ctrl = match self.camera_control(ctrl_id) {
+                Ok(v) => v,
+                Err(_) => continue,
+            };
+
+            camera_ctrls.push(ctrl);
+        }
+        camera_ctrls.shrink_to_fit();
+        Ok(camera_ctrls)
+    }
+
+    fn set_camera_control(
+        &mut self,
+        id: KnownCameraControl,
+        value: ControlValueSetter,
+    ) -> Result<(), NokhwaError> {
+        self.inner.set_control(id, value)
+    }
+
+    fn open_stream(&mut self) -> Result<(), NokhwaError> {
+        if let Err(why) = self.inner.start_stream() {
+            return Err(why.into());
+        }
+
+        Ok(())
+    }
+
+    fn is_stream_open(&self) -> bool {
+        self.inner.is_stream_open()
+    }
+
+    fn frame(&mut self) -> Result<Buffer, NokhwaError> {
+        self.refresh_camera_format()?;
+        let self_ctrl = self.camera_format();
+        Ok(Buffer::new(
+            self_ctrl.resolution(),
+            &self.inner.raw_bytes()?,
+            self_ctrl.format(),
+        ))
+    }
+
+    fn frame_raw(&mut self) -> Result<Cow<[u8]>, NokhwaError> {
+        self.inner.raw_bytes()
+    }
+
+    fn stop_stream(&mut self) -> Result<(), NokhwaError> {
+        self.inner.stop_stream();
+        Ok(())
+    }
+}
diff --git a/src/network_camera.rs b/src/backends/capture/network_camera.rs
similarity index 87%
rename from src/network_camera.rs
rename to src/backends/capture/network_camera.rs
index 3d1a1a8..5f0fa7f 100644
--- a/src/network_camera.rs
+++ b/src/backends/capture/network_camera.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-use crate::{backends::capture::OpenCvCaptureDevice, CaptureBackendTrait, NokhwaError};
+use crate::backends::capture::OpenCvCaptureDevice;
 use image::{buffer::ConvertBuffer, ImageBuffer, Rgb, RgbaImage};
-use std::cell::RefCell;
+use nokhwa_core::{error::NokhwaError, traits::CaptureBackendTrait};
+use std::{borrow::Cow, cell::RefCell, collections::HashMap};
 #[cfg(feature = "output-wgpu")]
 use wgpu::{
     Device as WgpuDevice, Extent3d, ImageCopyTexture, ImageDataLayout, Queue as WgpuQueue,
@@ -26,6 +27,10 @@ use wgpu::{
 
 /// A struct that supports IP Cameras via the `OpenCV` backend.
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-ipcam")))]
+#[deprecated(
+    since = "0.10.0",
+    note = "please use `Camera` with `CameraIndex::String` and `input-opencv` enabled."
+)]
 pub struct NetworkCamera {
     ip: String,
     opencv_backend: RefCell<OpenCvCaptureDevice>,
@@ -60,19 +65,19 @@ impl NetworkCamera {
     /// Opens stream.
     /// # Errors
     /// If the backend fails to capture the stream this will error
-    pub fn open_stream(&self) -> Result<(), NokhwaError> {
+    fn open_stream(&self) -> Result<(), NokhwaError> {
         self.opencv_backend.borrow_mut().open_stream()
     }
 
     /// Gets the frame decoded as a RGB24 frame
     /// # Errors
     /// If the backend fails to capture the stream, or if the decoding fails this will error
-    pub fn frame(&self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
+    fn frame(&self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
         self.opencv_backend.borrow_mut().frame()
     }
 
     /// The minimum buffer size needed to write the current frame (RGB24). If `rgba` is true, it will instead return the minimum size of the RGBA buffer needed.
-    pub fn min_buffer_size(&self, rgba: bool) -> usize {
+    fn min_buffer_size(&self, rgba: bool) -> usize {
         let resolution = self.opencv_backend.borrow().resolution();
         if rgba {
             return (resolution.width() * resolution.height() * 4) as usize;
@@ -82,11 +87,7 @@ impl NetworkCamera {
     /// Directly writes the current frame(RGB24) into said `buffer`. If `convert_rgba` is true, the buffer written will be written as an RGBA frame instead of a RGB frame. Returns the amount of bytes written on successful capture.
     /// # Errors
     /// If the backend fails to get the frame (e.g. already taken, busy, doesn't exist anymore), or [`open_stream()`](CaptureBackendTrait::open_stream()) has not been called yet, this will error.
-    pub fn frame_to_buffer(
-        &self,
-        buffer: &mut [u8],
-        convert_rgba: bool,
-    ) -> Result<usize, NokhwaError> {
+    fn frame_to_buffer(&self, buffer: &mut [u8], convert_rgba: bool) -> Result<usize, NokhwaError> {
         let frame = self.frame()?;
         let mut frame_data = frame.to_vec();
         if convert_rgba {
@@ -102,13 +103,13 @@ impl NetworkCamera {
     /// Directly copies a frame to a Wgpu texture. This will automatically convert the frame into a RGBA frame.
     /// # Errors
     /// If the frame cannot be captured or the resolution is 0 on any axis, this will error.
-    pub fn frame_texture<'a>(
+    fn frame_texture<'a>(
         &mut self,
         device: &WgpuDevice,
         queue: &WgpuQueue,
         label: Option<&'a str>,
     ) -> Result<WgpuTexture, NokhwaError> {
-        use std::{convert::TryFrom, num::NonZeroU32};
+        use std::num::NonZeroU32;
         let frame = self.frame()?;
         let rgba_frame: RgbaImage = frame.convert();
 
@@ -160,13 +161,13 @@ impl NetworkCamera {
     /// Will drop the stream.
     /// # Errors
     /// Please check the `Quirks` section of each backend.
-    pub fn stop_stream(&mut self) -> Result<(), NokhwaError> {
+    fn stop_stream(&mut self) -> Result<(), NokhwaError> {
         self.opencv_backend.borrow_mut().stop_stream()
     }
 }
 
 impl Drop for NetworkCamera {
     fn drop(&mut self) {
-        self.stop_stream().unwrap();
+        let _stop_stream_err = self.stop_stream();
     }
 }
diff --git a/src/backends/capture/opencv_backend.rs b/src/backends/capture/opencv_backend.rs
index 2963432..d9bb40e 100644
--- a/src/backends/capture/opencv_backend.rs
+++ b/src/backends/capture/opencv_backend.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,16 +14,22 @@
  * limitations under the License.
  */
 
-use crate::{
-    CameraControl, CameraFormat, CameraIndexType, CameraInfo, CaptureAPIBackend,
-    CaptureBackendTrait, FrameFormat, KnownCameraControls, NokhwaError, Resolution,
-};
 use image::{ImageBuffer, Rgb};
+use nokhwa_core::{
+    error::NokhwaError,
+    pixel_format::FormatDecoder,
+    traits::CaptureBackendTrait,
+    types::{
+        ApiBackend, CameraControl, CameraFormat, CameraIndex, CameraInfo, ControlValueDescription,
+        ControlValueSetter, FrameFormat, KnownCameraControl, RequestedFormat, Resolution,
+    },
+};
 use opencv::{
     core::{Mat, MatTraitConst, MatTraitConstManual, Vec3b},
     videoio::{
         VideoCapture, VideoCaptureTrait, VideoCaptureTraitConst, CAP_ANY, CAP_AVFOUNDATION,
-        CAP_MSMF, CAP_PROP_FPS, CAP_PROP_FRAME_HEIGHT, CAP_PROP_FRAME_WIDTH, CAP_V4L2,
+        CAP_MSMF, CAP_PROP_FOURCC, CAP_PROP_FPS, CAP_PROP_FRAME_HEIGHT, CAP_PROP_FRAME_WIDTH,
+        CAP_V4L2,
     },
 };
 use std::{any::Any, borrow::Cow, collections::HashMap};
@@ -50,7 +56,6 @@ macro_rules! tryinto_num {
     }};
 }
 
-// TODO: Define behaviour for IPCameras.
 /// The backend struct that interfaces with `OpenCV`. Note that an `opencv` matching the version that this was either compiled on must be present on the user's machine. (usually 4.5.2 or greater)
 /// For more information, please see [`opencv-rust`](https://github.com/twistedfall/opencv-rust) and [`OpenCV VideoCapture Docs`](https://docs.opencv.org/4.5.2/d8/dfe/classcv_1_1VideoCapture.html).
 ///
@@ -71,7 +76,7 @@ macro_rules! tryinto_num {
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-opencv")))]
 pub struct OpenCvCaptureDevice {
     camera_format: CameraFormat,
-    camera_location: CameraIndexType,
+    camera_location: CameraIndex,
     camera_info: CameraInfo,
     api_preference: i32,
     video_capture: VideoCapture,
@@ -79,7 +84,7 @@ pub struct OpenCvCaptureDevice {
 
 #[allow(clippy::must_use_candidate)]
 impl OpenCvCaptureDevice {
-    /// Creates a new capture device using the `OpenCV` backend. You can either use an [`Index`](CameraIndexType::Index) or [`IPCamera`](CameraIndexType::IPCamera).
+    /// Creates a new capture device using the `OpenCV` backend.
     ///
     /// Indexes are gives to devices by the OS, and usually numbered by order of discovery.
     ///
@@ -89,130 +94,70 @@ impl OpenCvCaptureDevice {
     /// ```
     /// , but please refer to the manufacturer for the actual IP format.
     ///
-    /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default if it is a index camera.
+    /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default if it is a index camera. This camera **cannot** resolve any request that is not
+    /// [`RequestedFormat::Exact`] or [`RequestedFormat::None`].
     /// # Errors
     /// If the backend fails to open the camera (e.g. Device does not exist at specified index/ip), Camera does not support specified [`CameraFormat`], and/or other `OpenCV` Error, this will error.
     /// # Panics
     /// If the API u32 -> i32 fails this will error
-    pub fn new(
-        camera_location: CameraIndexType,
-        cfmt: Option<CameraFormat>,
-        api_pref: Option<u32>,
-    ) -> Result<Self, NokhwaError> {
-        let api = if let Some(a) = api_pref {
-            tryinto_num!(i32, a)
+    pub fn new(index: &CameraIndex, cfmt: RequestedFormat) -> Result<Self, NokhwaError> {
+        let api_pref = if index.is_string() {
+            CAP_ANY
         } else {
-            tryinto_num!(i32, get_api_pref_int())
+            get_api_pref_int()
         };
 
-        let mut index = i32::MAX as u32;
+        let mut video_capture = match &index {
+            CameraIndex::Index(idx) => VideoCapture::new(*idx as i32, api_pref),
+            CameraIndex::String(ip) => VideoCapture::from_file(ip.as_str(), api_pref),
+        }
+        .map_err(|why| {
+            NokhwaError::OpenDeviceError(format!("Failed to open {}", index), why.to_string())
+        })?;
 
-        let camera_format = match cfmt {
-            Some(cam_fmt) => cam_fmt,
-            None => CameraFormat::default(),
+        let real = match cfmt {
+            RequestedFormat::Exact(e) => e,
+            RequestedFormat::None => CameraFormat::default(),
+            _ => return Err(NokhwaError::UnsupportedOperationError(ApiBackend::OpenCv)),
         };
 
-        let mut video_capture = match camera_location.clone() {
-            CameraIndexType::Index(idx) => {
-                let vid_cap = match VideoCapture::new(tryinto_num!(i32, idx), api) {
-                    Ok(vc) => {
-                        index = idx;
-                        vc
-                    }
-                    Err(why) => {
-                        return Err(NokhwaError::OpenDeviceError(
-                            idx.to_string(),
-                            why.to_string(),
-                        ))
-                    }
-                };
-                vid_cap
-            }
-            CameraIndexType::IPCamera(ip) => match VideoCapture::from_file(&*ip, CAP_ANY) {
-                Ok(vc) => vc,
-                Err(why) => return Err(NokhwaError::OpenDeviceError(ip, why.to_string())),
-            },
-        };
-
-        set_properties(&mut video_capture, camera_format, &camera_location)?;
+        set_properties(&mut video_capture, real)?;
 
         let camera_info = CameraInfo::new(
-            format!("OpenCV Capture Device {}", camera_location),
-            camera_location.to_string(),
-            "".to_string(),
-            index as usize,
+            format!("OpenCV Capture Device {}", index).as_str(),
+            index.to_string().as_str(),
+            "",
+            index.clone(),
         );
 
         Ok(OpenCvCaptureDevice {
             camera_format,
-            camera_location,
+            camera_location: index.clone(),
             camera_info,
             api_preference: api,
             video_capture,
         })
     }
 
-    /// Creates a new capture device using the `OpenCV` backend.
-    ///
-    /// `IPCameras` follow the format
-    /// ```.ignore
-    /// <protocol>://<IP>:<port>/
-    /// ```
-    /// , but please refer to the manufacturer for the actual IP format.
-    ///
-    /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default if it is a index camera.
-    /// # Errors
-    /// If the backend fails to open the camera (e.g. Device does not exist at specified index/ip), Camera does not support specified [`CameraFormat`], and/or other `OpenCV` Error, this will error.
-    pub fn new_ip_camera(ip: String) -> Result<Self, NokhwaError> {
-        let camera_location = CameraIndexType::IPCamera(ip);
-        OpenCvCaptureDevice::new(camera_location, None, None)
-    }
-
-    /// Creates a new capture device using the `OpenCV` backend.
-    /// Indexes are gives to devices by the OS, and usually numbered by order of discovery.
-    ///
-    /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default if it is a index camera.
-    /// # Errors
-    /// If the backend fails to open the camera (e.g. Device does not exist at specified index/ip), Camera does not support specified [`CameraFormat`], and/or other `OpenCV` Error, this will error.
-    pub fn new_index_camera(
-        index: usize,
-        cfmt: Option<CameraFormat>,
-        api_pref: Option<u32>,
-    ) -> Result<Self, NokhwaError> {
-        let camera_location = CameraIndexType::Index(tryinto_num!(u32, index));
-        OpenCvCaptureDevice::new(camera_location, cfmt, api_pref)
-    }
-
-    /// Creates a new capture device using the `OpenCV` backend.
-    /// Indexes are gives to devices by the OS, and usually numbered by order of discovery.
-    ///
-    /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default if it is a index camera.
-    /// # Errors
-    /// If the backend fails to open the camera (e.g. Device does not exist at specified index/ip), Camera does not support specified [`CameraFormat`], and/or other `OpenCV` Error, this will error.
-    pub fn new_autopref(index: usize, cfmt: Option<CameraFormat>) -> Result<Self, NokhwaError> {
-        let camera_location = CameraIndexType::Index(tryinto_num!(u32, index));
-        OpenCvCaptureDevice::new(camera_location, cfmt, None)
-    }
-
     /// Gets weather said capture device is an `IPCamera`.
     pub fn is_ip_camera(&self) -> bool {
         match self.camera_location {
-            CameraIndexType::Index(_) => false,
-            CameraIndexType::IPCamera(_) => true,
+            CameraIndex::Index(_) => false,
+            CameraIndex::String(_) => true,
         }
     }
 
     /// Gets weather said capture device is an OS-based indexed camera.
     pub fn is_index_camera(&self) -> bool {
         match self.camera_location {
-            CameraIndexType::Index(_) => true,
-            CameraIndexType::IPCamera(_) => false,
+            CameraIndex::Index(_) => true,
+            CameraIndex::String(_) => false,
         }
     }
 
     /// Gets the camera location
-    pub fn camera_location(&self) -> CameraIndexType {
-        self.camera_location.clone()
+    pub fn camera_location(&self) -> &CameraIndex {
+        &self.camera_location
     }
 
     /// Gets the `OpenCV` API Preference number. Please refer to [`OpenCV VideoCapture Flag Docs`](https://docs.opencv.org/4.5.2/d4/d15/group__videoio__flags__base.html).
@@ -339,14 +284,43 @@ impl OpenCvCaptureDevice {
 }
 
 impl CaptureBackendTrait for OpenCvCaptureDevice {
-    fn backend(&self) -> CaptureAPIBackend {
-        CaptureAPIBackend::OpenCv
+    fn backend(&self) -> ApiBackend {
+        ApiBackend::OpenCv
     }
 
     fn camera_info(&self) -> &CameraInfo {
         &self.camera_info
     }
 
+    fn refresh_camera_format(&mut self) -> Result<(), NokhwaError> {
+        let width = vc
+            .set(CAP_PROP_FRAME_WIDTH, camera_format.width() as f64)
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "Resolution Width".to_string(),
+                value: camera_format.to_string(),
+                error: why.to_string(),
+            })? as u32;
+        let height = vc
+            .set(CAP_PROP_FRAME_HEIGHT, camera_format.height() as f64)
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "Resolution Height".to_string(),
+                value: camera_format.to_string(),
+                error: why.to_string(),
+            })? as u32;
+        let fps = vc
+            .get(CAP_PROP_FPS, camera_format.frame_rate() as f64)
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "FPS".to_string(),
+                value: camera_format.to_string(),
+                error: why.to_string(),
+            })? as u32;
+
+        let ffmt = self.frame_format();
+        self.set_camera_format(CameraFormat::new_from(width, height, ffmt, fps))?;
+
+        Ok(())
+    }
+
     fn camera_format(&self) -> CameraFormat {
         self.camera_format
     }
@@ -365,7 +339,7 @@ impl CaptureBackendTrait for OpenCvCaptureDevice {
 
         self.camera_format = new_fmt;
 
-        if let Err(why) = set_properties(&mut self.video_capture, new_fmt, &self.camera_location) {
+        if let Err(why) = set_properties(&mut self.video_capture, new_fmt) {
             self.camera_format = current_format;
             return Err(why);
         }
@@ -385,15 +359,11 @@ impl CaptureBackendTrait for OpenCvCaptureDevice {
         &mut self,
         _fourcc: FrameFormat,
     ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::OpenCv,
-        ))
+        Err(NokhwaError::UnsupportedOperationError(ApiBackend::OpenCv))
     }
 
     fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::OpenCv,
-        ))
+        Err(NokhwaError::UnsupportedOperationError(ApiBackend::OpenCv))
     }
 
     fn resolution(&self) -> Resolution {
@@ -427,128 +397,105 @@ impl CaptureBackendTrait for OpenCvCaptureDevice {
         self.set_camera_format(current_fmt)
     }
 
-    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
-        ))
-    }
-
-    fn camera_control(&self, _control: KnownCameraControls) -> Result<CameraControl, NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
-        ))
-    }
-
-    fn set_camera_control(&mut self, _control: CameraControl) -> Result<(), NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
-        ))
-    }
-
-    fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
-        Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
-        ))
-    }
-
-    fn raw_camera_control(&self, control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
-        let id = match control.downcast_ref::<i32>() {
-            Some(id) => *id,
-            None => {
-                return Err(NokhwaError::StructureError {
-                    structure: "OpenCV ID".to_string(),
-                    error: "Failed Any Cast".to_string(),
-                })
-            }
-        };
-
-        match self.video_capture.get(id) {
-            Ok(v) => Ok(Box::new(v)),
-            Err(why) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: format!("OpenCV PROP ID {}", id),
-                    error: why.to_string(),
-                })
-            }
-        }
-    }
-
-    fn set_raw_camera_control(
-        &mut self,
-        control: &dyn Any,
-        value: &dyn Any,
-    ) -> Result<(), NokhwaError> {
-        let id = match control.downcast_ref::<i32>() {
-            Some(id) => *id,
-            None => {
-                return Err(NokhwaError::StructureError {
-                    structure: "OpenCV ID".to_string(),
-                    error: "Failed Any Cast".to_string(),
-                })
-            }
-        };
-
-        let value = match value.downcast_ref::<f64>() {
-            Some(id) => *id,
-            None => {
-                return Err(NokhwaError::StructureError {
-                    structure: "OpenCV Value".to_string(),
-                    error: "Failed Any Cast".to_string(),
-                })
-            }
-        };
-
-        match self.video_capture.set(id, value) {
-            Ok(b) => {
-                if b {
-                    return Ok(());
-                }
-                Err(NokhwaError::SetPropertyError {
-                    property: format!("OpenCV PROP ID {}", id),
-                    value: value.to_string(),
-                    error: "OpenCV returned false".to_string(),
-                })
-            }
-            Err(why) => Err(NokhwaError::SetPropertyError {
-                property: format!("OpenCV PROP ID {}", id),
-                value: value.to_string(),
+    fn camera_control(&self, control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
+        let id: i32 = control.into();
+        let current = self
+            .video_capture
+            .get(id)
+            .map_err(|x| NokhwaError::GetPropertyError {
+                property: id.to_string(),
                 error: why.to_string(),
-            }),
+            })?;
+        Ok(CameraControl::new(
+            control,
+            id.to_string(),
+            ControlValueDescription::Float {
+                value: current,
+                default: 0.0,
+                step: 0.0,
+            },
+            vec![],
+            true,
+        ))
+    }
+
+    fn camera_controls(&self) -> Result<Vec<CameraControl>, NokhwaError> {
+        Err(NokhwaError::UnsupportedOperationError(ApiBackend::OpenCv))
+    }
+
+    fn set_camera_control(
+        &mut self,
+        id: KnownCameraControl,
+        value: ControlValueSetter,
+    ) -> Result<(), NokhwaError> {
+        let control_val = match value {
+            ControlValueSetter::Integer(i) => i as f64,
+            ControlValueSetter::Float(f) => f,
+            ControlValueSetter::Boolean(b) => b as f64,
+            val => {
+                return Err(NokhwaError::SetPropertyError {
+                    property: "Camera Control".to_string(),
+                    value: val.to_string(),
+                    error: "unsupported value".to_string(),
+                })
+            }
+        };
+
+        if !self
+            .video_capture
+            .set(id.into(), control_val)
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "Camera Control".to_string(),
+                value: control_val.to_string(),
+                error: why.to_string(),
+            })?
+        {
+            return Err(NokhwaError::SetPropertyError {
+                property: "Camera Control".to_string(),
+                value: control_val.to_string(),
+                error: "false".to_string(),
+            });
         }
+
+        let set_value = self.camera_control(id)?.value();
+        if set_value != value {
+            return Err(NokhwaError::SetPropertyError {
+                property: "Camera Control".to_string(),
+                value: control_val.to_string(),
+                error: "failed to set value: rejected".to_string(),
+            });
+        }
+
+        Ok(())
     }
 
     #[allow(clippy::cast_possible_wrap)]
     fn open_stream(&mut self) -> Result<(), NokhwaError> {
         match self.camera_location.clone() {
-            CameraIndexType::Index(idx) => {
+            CameraIndex::Index(idx) => {
                 match self
                     .video_capture
                     .open_1(idx as i32, get_api_pref_int() as i32)
                 {
-                    Ok(_) => {}
-                    Err(why) => {
-                        return Err(NokhwaError::OpenDeviceError(
-                            idx.to_string(),
-                            format!("Failed to open device: {}", why),
+                    Ok(open) => {
+                        if open {
+                            return Ok(());
+                        }
+                        Err(NokhwaError::OpenStreamError(
+                            "Stream is not opened after stream open attempt opencv".to_string(),
                         ))
                     }
+                    Err(why) => Err(NokhwaError::OpenDeviceError(
+                        idx.to_string(),
+                        format!("Failed to open device: {}", why),
+                    )),
                 }
             }
-            CameraIndexType::IPCamera(ip) => {
-                match self
-                    .video_capture
-                    .open_file(&*ip, get_api_pref_int() as i32)
-                {
-                    Ok(_) => {}
-                    Err(why) => {
-                        return Err(NokhwaError::OpenDeviceError(
-                            ip,
-                            format!("Failed to open device: {}", why),
-                        ))
-                    }
-                }
-            }
-        };
+            CameraIndex::String(_) => Err(NokhwaError::OpenDeviceError(
+                "Cannot open".to_string(),
+                "String index not supported (try NetworkCamera instead)".to_string(),
+            )),
+        }?;
 
         match self.video_capture.is_opened() {
             Ok(open) => {
@@ -611,23 +558,59 @@ impl CaptureBackendTrait for OpenCvCaptureDevice {
     }
 }
 
-fn get_api_pref_int() -> u32 {
+fn get_api_pref_int() -> i32 {
     match std::env::consts::OS {
-        "linux" => CAP_V4L2 as u32,
-        "windows" => CAP_MSMF as u32,
-        "mac" => CAP_AVFOUNDATION as u32,
-        &_ => CAP_ANY as u32,
+        "linux" => CAP_V4L2,
+        "windows" => CAP_MSMF,
+        "mac" => CAP_AVFOUNDATION,
+        &_ => CAP_ANY,
     }
 }
 
-#[allow(clippy::cast_possible_wrap)]
-#[allow(clippy::unnecessary_wraps)]
 // I'm done. This stupid POS refuses to actually do anything useful with camera settings
 // If anyone else wants to tackle this monster, please do.
-fn set_properties(
-    _vc: &mut VideoCapture,
-    _camera_format: CameraFormat,
-    _camera_location: &CameraIndexType,
-) -> Result<(), NokhwaError> {
+fn set_properties(vc: &mut VideoCapture, camera_format: CameraFormat) -> Result<(), NokhwaError> {
+    if !vc
+        .set(CAP_PROP_FRAME_WIDTH, camera_format.width() as f64)
+        .map_err(|why| NokhwaError::SetPropertyError {
+            property: "Resolution Width".to_string(),
+            value: camera_format.to_string(),
+            error: why.to_string(),
+        })?
+    {
+        return Err(NokhwaError::SetPropertyError {
+            property: "Resolution Width".to_string(),
+            value: camera_format.to_string(),
+            error: "false".to_string(),
+        });
+    }
+    if !vc
+        .set(CAP_PROP_FRAME_HEIGHT, camera_format.height() as f64)
+        .map_err(|why| NokhwaError::SetPropertyError {
+            property: "Resolution Height".to_string(),
+            value: camera_format.to_string(),
+            error: why.to_string(),
+        })?
+    {
+        return Err(NokhwaError::SetPropertyError {
+            property: "Resolution Height".to_string(),
+            value: camera_format.to_string(),
+            error: "false".to_string(),
+        });
+    }
+    if !vc
+        .set(CAP_PROP_FPS, camera_format.frame_rate() as f64)
+        .map_err(|why| NokhwaError::SetPropertyError {
+            property: "FPS".to_string(),
+            value: camera_format.to_string(),
+            error: why.to_string(),
+        })?
+    {
+        return Err(NokhwaError::SetPropertyError {
+            property: "FPS".to_string(),
+            value: camera_format.to_string(),
+            error: "false".to_string(),
+        });
+    }
     Ok(())
 }
diff --git a/src/backends/capture/uvc_backend.rs b/src/backends/capture/uvc_backend.rs
index 829e914..b86ca18 100644
--- a/src/backends/capture/uvc_backend.rs
+++ b/src/backends/capture/uvc_backend.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,8 +17,8 @@
 #![allow(clippy::too_many_arguments)]
 
 use crate::{
-    CameraControl, CameraFormat, CameraInfo, CaptureAPIBackend, CaptureBackendTrait, FrameFormat,
-    KnownCameraControlFlag, KnownCameraControls, NokhwaError, Resolution,
+    ApiBackend, CameraControl, CameraFormat, CameraInfo, CaptureBackendTrait, FrameFormat,
+    KnownCameraControl, KnownCameraControlFlag, NokhwaError, Resolution,
 };
 use flume::{Receiver, Sender};
 use image::{ImageBuffer, Rgb};
@@ -54,9 +54,13 @@ use uvc::{
 /// - If internal variables `stream_handle_init` and `active_stream_init` become de-synchronized with the true reality (weather streamhandle/activestream is init or not) this will cause undefined behaviour.
 #[self_referencing]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-uvc")))]
+#[deprecated(
+    since = "0.10",
+    note = "Use one of the native backends instead(V4L, AVF, MSMF) or OpenCV"
+)]
 pub struct UVCCaptureDevice<'a> {
     camera_format: CameraFormat,
-    camera_info: CameraInfo,
+    camera_info: CameraInfo<'a>,
     frame_receiver: Receiver<Vec<u8>>,
     frame_sender: Sender<Vec<u8>>,
     stream_handle_init: Cell<bool>,
@@ -199,8 +203,8 @@ impl<'a> UVCCaptureDevice<'a> {
 // IDE Autocomplete ends here. Do not be afraid it your IDE does not show completion.
 // Here are some docs to help you out: https://docs.rs/ouroboros/0.9.3/ouroboros/attr.self_referencing.html
 impl<'a> CaptureBackendTrait for UVCCaptureDevice<'a> {
-    fn backend(&self) -> CaptureAPIBackend {
-        CaptureAPIBackend::UniversalVideoClass
+    fn backend(&self) -> ApiBackend {
+        ApiBackend::UniversalVideoClass
     }
 
     fn camera_info(&self) -> &CameraInfo {
@@ -325,16 +329,16 @@ impl<'a> CaptureBackendTrait for UVCCaptureDevice<'a> {
         self.set_camera_format(current_format)
     }
 
-    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
+    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControl>, NokhwaError> {
         Ok(vec![
-            KnownCameraControls::Exposure,
-            KnownCameraControls::Focus,
+            KnownCameraControl::Exposure,
+            KnownCameraControl::Focus,
         ])
     }
 
-    fn camera_control(&self, control: KnownCameraControls) -> Result<CameraControl, NokhwaError> {
+    fn camera_control(&self, control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
         match control {
-            KnownCameraControls::Focus => match self.with_device_handle(|x| x).exposure_rel() {
+            KnownCameraControl::Focus => match self.with_device_handle(|x| x).exposure_rel() {
                 Ok(v) => {
                     let v: i8 = v;
                     match CameraControl::new(
@@ -368,19 +372,19 @@ impl<'a> CaptureBackendTrait for UVCCaptureDevice<'a> {
 
     fn set_camera_control(&mut self, _control: CameraControl) -> Result<(), NokhwaError> {
         Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
+            ApiBackend::UniversalVideoClass,
         ))
     }
 
     fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
         Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
+            ApiBackend::UniversalVideoClass,
         ))
     }
 
     fn raw_camera_control(&self, _control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
         Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
+            ApiBackend::UniversalVideoClass,
         ))
     }
 
@@ -390,7 +394,7 @@ impl<'a> CaptureBackendTrait for UVCCaptureDevice<'a> {
         _value: &dyn Any,
     ) -> Result<(), NokhwaError> {
         Err(NokhwaError::UnsupportedOperationError(
-            CaptureAPIBackend::UniversalVideoClass,
+            ApiBackend::UniversalVideoClass,
         ))
     }
 
diff --git a/src/backends/capture/v4l2.rs b/src/backends/capture/v4l2.rs
deleted file mode 100644
index 0fd31b8..0000000
--- a/src/backends/capture/v4l2.rs
+++ /dev/null
@@ -1,723 +0,0 @@
-/*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use crate::{
-    error::NokhwaError,
-    mjpeg_to_rgb888,
-    utils::{CameraFormat, CameraInfo},
-    yuyv422_to_rgb888, CameraControl, CaptureAPIBackend, CaptureBackendTrait, FrameFormat,
-    KnownCameraControlFlag, KnownCameraControls, Resolution,
-};
-use image::{ImageBuffer, Rgb};
-use std::{borrow::Cow, collections::HashMap};
-use v4l::{
-    buffer::Type,
-    frameinterval::FrameIntervalEnum,
-    framesize::FrameSizeEnum,
-    io::traits::CaptureStream,
-    prelude::*,
-    video::{capture::Parameters, Capture},
-    Format, FourCC,
-};
-
-use std::any::Any;
-pub use v4l::control::{Control, Description, Flags};
-
-/// Generates a camera control from a device and a description of control
-/// # Error
-/// If the control is not supported, the value is invalid or string, or the control is write only/the control cannot be read from,
-/// this will error.
-#[allow(clippy::cast_possible_truncation)]
-#[allow(clippy::cast_lossless)]
-pub fn to_camera_control(
-    device: &Device,
-    value: &Description,
-) -> Result<CameraControl, NokhwaError> {
-    // make sure flags is valid
-    if value.flags.contains(Flags::from(0x0040)) {
-        return Err(NokhwaError::NotImplementedError(
-            "Control Write Only!".to_string(),
-        ));
-    }
-
-    let control: KnownCameraControls = match try_id_to_known_camera_control(value.id) {
-        Some(kcc) => kcc,
-        None => {
-            return Err(NokhwaError::StructureError {
-                structure: "KnownCameraControl".to_string(),
-                error: "Unsupported V4L2 ID".to_string(),
-            })
-        }
-    };
-
-    // value
-    let current_value = match device.control(value.id) {
-        Ok(val) => match val {
-            Control::Value(v) => v,
-            Control::Value64(v64) => {
-                if v64 <= i32::MAX as i64 {
-                    v64 as i32
-                } else {
-                    return Err(NokhwaError::GetPropertyError {
-                        property: format!("Control V4L2ID: {}", value.id),
-                        error: "Too large!".to_string(),
-                    });
-                }
-            }
-            Control::String(_) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: format!("Control V4L2ID: {}", value.id),
-                    error: "Unsupported Type String".to_string(),
-                })
-            }
-        },
-        Err(why) => {
-            return Err(NokhwaError::GetPropertyError {
-                property: format!("Control V4L2ID: {}", value.id),
-                error: why.to_string(),
-            })
-        }
-    };
-
-    let active =
-        value.flags.contains(Flags::from(0x0001)) || value.flags.contains(Flags::from(0x0010));
-
-    CameraControl::new(
-        control,
-        value.minimum,
-        value.maximum,
-        current_value,
-        value.step,
-        value.default,
-        KnownCameraControlFlag::Manual,
-        active,
-    )
-}
-
-/// Attempts to convert a [`KnownCameraControls`] into a V4L2 Control ID.
-/// If the associated control is not found, this will return `None` (`ColorEnable`, `Roll`)
-pub fn try_known_camera_control_to_id(ctrl: KnownCameraControls) -> Option<u32> {
-    match ctrl {
-        KnownCameraControls::Brightness => Some(9_963_776),
-        KnownCameraControls::Contrast => Some(9_963_777),
-        KnownCameraControls::Hue => Some(9_963_779),
-        KnownCameraControls::Saturation => Some(9_963_778),
-        KnownCameraControls::Sharpness => Some(9_963_803),
-        KnownCameraControls::Gamma => Some(9_963_792),
-        KnownCameraControls::WhiteBalance => Some(9_963_802),
-        KnownCameraControls::BacklightComp => Some(9_963_804),
-        KnownCameraControls::Gain => Some(9_963_795),
-        KnownCameraControls::Pan => Some(10_094_852),
-        KnownCameraControls::Tilt => Some(100_948_530),
-        KnownCameraControls::Zoom => Some(10_094_862),
-        KnownCameraControls::Exposure => Some(10_094_850),
-        KnownCameraControls::Iris => Some(10_094_866),
-        KnownCameraControls::Focus => Some(10_094_859),
-        _ => None,
-    }
-}
-
-/// Attempts to convert a [`u32`] V4L2 Control ID into a [`KnownCameraControls`]
-/// If the associated control is not found, this will return `None` (`ColorEnable`, `Roll`)
-pub fn try_id_to_known_camera_control(id: u32) -> Option<KnownCameraControls> {
-    match id {
-        9_963_776 => Some(KnownCameraControls::Brightness),
-        9_963_777 => Some(KnownCameraControls::Contrast),
-        9_963_779 => Some(KnownCameraControls::Hue),
-        9_963_778 => Some(KnownCameraControls::Saturation),
-        9_963_803 => Some(KnownCameraControls::Sharpness),
-        9_963_792 => Some(KnownCameraControls::Gamma),
-        9_963_802 => Some(KnownCameraControls::WhiteBalance),
-        9_963_804 => Some(KnownCameraControls::BacklightComp),
-        9_963_795 => Some(KnownCameraControls::Gain),
-        10_094_852 => Some(KnownCameraControls::Pan),
-        100_948_530 => Some(KnownCameraControls::Tilt),
-        10_094_862 => Some(KnownCameraControls::Zoom),
-        10_094_850 => Some(KnownCameraControls::Exposure),
-        10_094_866 => Some(KnownCameraControls::Iris),
-        10_094_859 => Some(KnownCameraControls::Focus),
-        _ => None,
-    }
-}
-
-fn clone_control(ctrl: &Control) -> Control {
-    match ctrl {
-        Control::Value(v) => Control::Value(*v),
-        Control::Value64(v) => Control::Value64(*v),
-        Control::String(v) => Control::String(v.clone()),
-    }
-}
-
-/// The backend struct that interfaces with V4L2.
-/// To see what this does, please see [`CaptureBackendTrait`].
-/// # Quirks
-/// - Calling [`set_resolution()`](CaptureBackendTrait::set_resolution), [`set_frame_rate()`](CaptureBackendTrait::set_frame_rate), or [`set_frame_format()`](CaptureBackendTrait::set_frame_format) each internally calls [`set_camera_format()`](CaptureBackendTrait::set_camera_format).
-/// - The `Any` return type for [`raw_supported_camera_controls()`](CaptureBackendTrait::raw_supported_camera_controls) is [`Description`]
-/// - The `Any` type for [`raw_camera_control()`](CaptureBackendTrait::raw_camera_control) is [`u32`], and its return `Any` is a [`Control`]
-/// - The `Any` type for `control` for [`set_raw_camera_control()`](CaptureBackendTrait::set_raw_camera_control) is [`u32`] and [`Control`]
-#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-v4l")))]
-pub struct V4LCaptureDevice<'a> {
-    camera_format: CameraFormat,
-    camera_info: CameraInfo,
-    device: Device,
-    stream_handle: Option<MmapStream<'a>>,
-}
-
-impl<'a> V4LCaptureDevice<'a> {
-    /// Creates a new capture device using the `V4L2` backend. Indexes are gives to devices by the OS, and usually numbered by order of discovery.
-    ///
-    /// If `camera_format` is `None`, it will be spawned with with 640x480@15 FPS, MJPEG [`CameraFormat`] default.
-    /// # Errors
-    /// This function will error if the camera is currently busy or if `V4L2` can't read device information.
-    pub fn new(index: usize, cam_fmt: Option<CameraFormat>) -> Result<Self, NokhwaError> {
-        let device = match Device::new(index) {
-            Ok(dev) => dev,
-            Err(why) => {
-                return Err(NokhwaError::OpenDeviceError(
-                    index.to_string(),
-                    format!("V4L2 Error: {}", why),
-                ))
-            }
-        };
-
-        let camera_info = match device.query_caps() {
-            Ok(caps) => CameraInfo::new(caps.card, "".to_string(), caps.driver, index),
-            Err(why) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "Capabilities".to_string(),
-                    error: why.to_string(),
-                })
-            }
-        };
-
-        let camera_format = match cam_fmt {
-            Some(c_fmt) => c_fmt,
-            None => CameraFormat::default(),
-        };
-
-        let fourcc = match camera_format.format() {
-            FrameFormat::MJPEG => FourCC::new(b"MJPG"),
-            FrameFormat::YUYV => FourCC::new(b"YUYV"),
-        };
-
-        let new_param = Parameters::with_fps(camera_format.frame_rate());
-        let new_v4l_fmt = Format::new(camera_format.width(), camera_format.height(), fourcc);
-
-        match Capture::set_format(&device, &new_v4l_fmt) {
-            Ok(v4l_fmt) => {
-                if v4l_fmt.height != new_v4l_fmt.height
-                    && v4l_fmt.width != new_v4l_fmt.width
-                    && v4l_fmt.fourcc != new_v4l_fmt.fourcc
-                {
-                    return Err(NokhwaError::SetPropertyError {
-                        property: "Format(V4L Resolution, FourCC)".to_string(),
-                        value: camera_format.to_string(),
-                        error: "Rejected".to_string(),
-                    });
-                }
-            }
-            Err(why) => {
-                return Err(NokhwaError::SetPropertyError {
-                    property: "Format(V4L Resolution, FourCC)".to_string(),
-                    value: camera_format.to_string(),
-                    error: why.to_string(),
-                })
-            }
-        }
-
-        match Capture::set_params(&device, &new_param) {
-            Ok(param) => {
-                if new_param.interval.denominator != param.interval.denominator {
-                    return Err(NokhwaError::SetPropertyError {
-                        property: "Parameter(V4L FPS)".to_string(),
-                        value: camera_format.frame_rate().to_string(),
-                        error: "Rejected".to_string(),
-                    });
-                }
-            }
-            Err(why) => {
-                return Err(NokhwaError::SetPropertyError {
-                    property: "Parameter(V4L FPS)".to_string(),
-                    value: camera_format.frame_rate().to_string(),
-                    error: why.to_string(),
-                })
-            }
-        }
-
-        Ok(V4LCaptureDevice {
-            camera_format,
-            camera_info,
-            device,
-            stream_handle: None,
-        })
-    }
-
-    /// Create a new `V4L2` Camera with desired settings.
-    /// # Errors
-    /// This function will error if the camera is currently busy or if `V4L2` can't read device information.
-    pub fn new_with(
-        index: usize,
-        width: u32,
-        height: u32,
-        fps: u32,
-        fourcc: FrameFormat,
-    ) -> Result<Self, NokhwaError> {
-        let camera_format = Some(CameraFormat::new_from(width, height, fourcc, fps));
-        V4LCaptureDevice::new(index, camera_format)
-    }
-
-    fn get_resolution_list(&self, fourcc: FrameFormat) -> Result<Vec<Resolution>, NokhwaError> {
-        let format = match fourcc {
-            FrameFormat::MJPEG => FourCC::new(b"MJPG"),
-            FrameFormat::YUYV => FourCC::new(b"YUYV"),
-        };
-
-        match v4l::video::Capture::enum_framesizes(&self.device, format) {
-            Ok(frame_sizes) => {
-                let mut resolutions = vec![];
-                for frame_size in frame_sizes {
-                    match frame_size.size {
-                        FrameSizeEnum::Discrete(dis) => {
-                            resolutions.push(Resolution::new(dis.width, dis.height));
-                        }
-                        FrameSizeEnum::Stepwise(step) => {
-                            resolutions.push(Resolution::new(step.min_width, step.min_height));
-                            resolutions.push(Resolution::new(step.max_width, step.max_height));
-                            // TODO: Respect step size
-                        }
-                    }
-                }
-                Ok(resolutions)
-            }
-            Err(why) => Err(NokhwaError::GetPropertyError {
-                property: "Resolutions".to_string(),
-                error: why.to_string(),
-            }),
-        }
-    }
-
-    /// Get the inner device (immutable) for e.g. Controls
-    #[allow(clippy::must_use_candidate)]
-    pub fn inner_device(&self) -> &Device {
-        &self.device
-    }
-
-    /// Get the inner device (mutable) for e.g. Controls
-    pub fn inner_device_mut(&mut self) -> &mut Device {
-        &mut self.device
-    }
-}
-
-impl<'a> CaptureBackendTrait for V4LCaptureDevice<'a> {
-    fn backend(&self) -> CaptureAPIBackend {
-        CaptureAPIBackend::Video4Linux
-    }
-
-    fn camera_info(&self) -> &CameraInfo {
-        &self.camera_info
-    }
-
-    fn camera_format(&self) -> CameraFormat {
-        self.camera_format
-    }
-
-    fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
-        let prev_format = match Capture::format(&self.device) {
-            Ok(fmt) => fmt,
-            Err(why) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "Resolution, FrameFormat".to_string(),
-                    error: why.to_string(),
-                })
-            }
-        };
-        let prev_fps = match Capture::params(&self.device) {
-            Ok(fps) => fps,
-            Err(why) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "Frame rate".to_string(),
-                    error: why.to_string(),
-                })
-            }
-        };
-
-        let format: Format = new_fmt.into();
-        let frame_rate = Parameters::with_fps(new_fmt.frame_rate());
-
-        if let Err(why) = Capture::set_format(&self.device, &format) {
-            return Err(NokhwaError::SetPropertyError {
-                property: "Resolution, FrameFormat".to_string(),
-                value: format.to_string(),
-                error: why.to_string(),
-            });
-        }
-        if let Err(why) = Capture::set_params(&self.device, &frame_rate) {
-            return Err(NokhwaError::SetPropertyError {
-                property: "Frame rate".to_string(),
-                value: frame_rate.to_string(),
-                error: why.to_string(),
-            });
-        }
-
-        if self.stream_handle.is_some() {
-            return match self.open_stream() {
-                Ok(_) => Ok(()),
-                Err(why) => {
-                    // undo
-                    if let Err(why) = Capture::set_format(&self.device, &prev_format) {
-                        return Err(NokhwaError::SetPropertyError {
-                            property: format!("Attempt undo due to stream acquisition failure with error {}. Resolution, FrameFormat", why),
-                            value: prev_format.to_string(),
-                            error: why.to_string(),
-                        });
-                    }
-                    if let Err(why) = Capture::set_params(&self.device, &prev_fps) {
-                        return Err(NokhwaError::SetPropertyError {
-                            property:
-                            format!("Attempt undo due to stream acquisition failure with error {}. Frame rate", why),
-                            value: prev_fps.to_string(),
-                            error: why.to_string(),
-                        });
-                    }
-                    Err(why)
-                }
-            };
-        }
-        self.camera_format = new_fmt;
-        Ok(())
-    }
-
-    fn compatible_list_by_resolution(
-        &mut self,
-        fourcc: FrameFormat,
-    ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
-        let resolutions = self.get_resolution_list(fourcc)?;
-        let format = match fourcc {
-            FrameFormat::MJPEG => FourCC::new(b"MJPG"),
-            FrameFormat::YUYV => FourCC::new(b"YUYV"),
-        };
-        let mut res_map = HashMap::new();
-        for res in resolutions {
-            let mut compatible_fps = vec![];
-            match Capture::enum_frameintervals(&self.device, format, res.width(), res.height()) {
-                Ok(intervals) => {
-                    for interval in intervals {
-                        match interval.interval {
-                            FrameIntervalEnum::Discrete(dis) => {
-                                compatible_fps.push(dis.denominator);
-                            }
-                            FrameIntervalEnum::Stepwise(step) => {
-                                compatible_fps.push(step.min.denominator);
-                                compatible_fps.push(step.max.denominator);
-                            }
-                        }
-                    }
-                }
-                Err(why) => {
-                    return Err(NokhwaError::GetPropertyError {
-                        property: "Frame rate".to_string(),
-                        error: why.to_string(),
-                    })
-                }
-            }
-            res_map.insert(res, compatible_fps);
-        }
-        Ok(res_map)
-    }
-
-    fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
-        match Capture::enum_formats(&self.device) {
-            Ok(formats) => {
-                let mut frame_format_vec = vec![];
-                for format in formats {
-                    let format_as_string = match format.fourcc.str() {
-                        Ok(s) => s,
-                        Err(why) => {
-                            return Err(NokhwaError::GetPropertyError {
-                                property: "FrameFormat".to_string(),
-                                error: why.to_string(),
-                            })
-                        }
-                    };
-                    match format_as_string {
-                        "YUYV" => frame_format_vec.push(FrameFormat::YUYV),
-                        "MJPG" => frame_format_vec.push(FrameFormat::MJPEG),
-                        _ => {}
-                    }
-                }
-                frame_format_vec.sort();
-                frame_format_vec.dedup();
-                Ok(frame_format_vec)
-            }
-            Err(why) => Err(NokhwaError::GetPropertyError {
-                property: "FrameFormat".to_string(),
-                error: why.to_string(),
-            }),
-        }
-    }
-
-    fn resolution(&self) -> Resolution {
-        self.camera_format.resolution()
-    }
-
-    fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError> {
-        let mut new_fmt = self.camera_format;
-        new_fmt.set_resolution(new_res);
-        self.set_camera_format(new_fmt)
-    }
-
-    fn frame_rate(&self) -> u32 {
-        self.camera_format.frame_rate()
-    }
-
-    fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError> {
-        let mut new_fmt = self.camera_format;
-        new_fmt.set_frame_rate(new_fps);
-        self.set_camera_format(new_fmt)
-    }
-
-    fn frame_format(&self) -> FrameFormat {
-        self.camera_format.format()
-    }
-
-    fn set_frame_format(&mut self, fourcc: FrameFormat) -> Result<(), NokhwaError> {
-        let mut new_fmt = self.camera_format;
-        new_fmt.set_format(fourcc);
-        self.set_camera_format(new_fmt)
-    }
-
-    fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
-        let v4l2_controls = match self.device.query_controls() {
-            Ok(controls) => controls,
-            Err(why) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "Controls".to_string(),
-                    error: why.to_string(),
-                })
-            }
-        };
-
-        let mut camera_controls = vec![];
-        for ctrl in v4l2_controls {
-            if let Ok(cam_control) = to_camera_control(&self.device, &ctrl) {
-                camera_controls.push(cam_control.control());
-            }
-        }
-        Ok(camera_controls)
-    }
-
-    fn camera_control(&self, control: KnownCameraControls) -> Result<CameraControl, NokhwaError> {
-        let id = match try_known_camera_control_to_id(control) {
-            Some(id) => id,
-            None => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "KnownCameraControls V4L2ID".to_string(),
-                    error: "Invalid".to_string(),
-                })
-            }
-        };
-
-        match self.device.control(id) {
-            Ok(_) => {
-                let v4l2_controls = match self.device.query_controls() {
-                    Ok(controls) => controls,
-                    Err(why) => {
-                        return Err(NokhwaError::GetPropertyError {
-                            property: "Controls".to_string(),
-                            error: why.to_string(),
-                        })
-                    }
-                };
-
-                for ctrl in v4l2_controls {
-                    if ctrl.id != id {
-                        continue;
-                    }
-
-                    if let Ok(cam_control) = to_camera_control(&self.device, &ctrl) {
-                        if Some(ctrl.id) == try_known_camera_control_to_id(cam_control.control()) {
-                            return Ok(cam_control);
-                        }
-                    }
-                }
-            }
-            Err(why) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "Camera Control".to_string(),
-                    error: why.to_string(),
-                })
-            }
-        }
-        Err(NokhwaError::GetPropertyError {
-            property: "Camera Control".to_string(),
-            error: "Not Found".to_string(),
-        })
-    }
-
-    fn set_camera_control(&mut self, control: CameraControl) -> Result<(), NokhwaError> {
-        let id = match try_known_camera_control_to_id(control.control()) {
-            Some(id) => id,
-            None => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "KnownCameraControls V4L2ID".to_string(),
-                    error: "Invalid".to_string(),
-                })
-            }
-        };
-
-        if let Err(why) = self.device.set_control(id, Control::Value(control.value())) {
-            return Err(NokhwaError::SetPropertyError {
-                property: format!("{} V4L2ID {}", control.control(), id),
-                value: control.value().to_string(),
-                error: why.to_string(),
-            });
-        }
-        Ok(())
-    }
-
-    fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
-        let v4l2_controls = match self.device.query_controls() {
-            Ok(controls) => controls,
-            Err(why) => {
-                return Err(NokhwaError::GetPropertyError {
-                    property: "Controls".to_string(),
-                    error: why.to_string(),
-                })
-            }
-        };
-
-        Ok(v4l2_controls
-            .into_iter()
-            .map(|c| {
-                let a: Box<dyn Any> = Box::new(c);
-                a
-            })
-            .collect())
-    }
-
-    fn raw_camera_control(&self, control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
-        let id = match control.downcast_ref::<u32>() {
-            Some(id) => *id,
-            None => {
-                return Err(NokhwaError::StructureError {
-                    structure: "V4L2 ID".to_string(),
-                    error: "Failed Any Cast".to_string(),
-                })
-            }
-        };
-
-        match self.device.control(id) {
-            Ok(v) => Ok(Box::new(v)),
-            Err(why) => Err(NokhwaError::GetPropertyError {
-                property: "Control V4L2".to_string(),
-                error: why.to_string(),
-            }),
-        }
-    }
-
-    fn set_raw_camera_control(
-        &mut self,
-        control: &dyn Any,
-        value: &dyn Any,
-    ) -> Result<(), NokhwaError> {
-        let id = match control.downcast_ref::<u32>() {
-            Some(id) => *id,
-            None => {
-                return Err(NokhwaError::StructureError {
-                    structure: "V4L2 ID".to_string(),
-                    error: "Failed Any Cast".to_string(),
-                })
-            }
-        };
-
-        let value = match value.downcast_ref::<Control>() {
-            Some(v) => match v {
-                Control::Value(v) => Control::Value(*v),
-                Control::Value64(v64) => Control::Value64(*v64),
-                Control::String(s) => Control::String(s.clone()),
-            },
-            None => {
-                return Err(NokhwaError::StructureError {
-                    structure: "V4L2 Control Value".to_string(),
-                    error: "Failed Any Cast".to_string(),
-                })
-            }
-        };
-
-        if let Err(why) = self.device.set_control(id, clone_control(&value)) {
-            return Err(NokhwaError::SetPropertyError {
-                property: format!("V4L2 Control ID {}", id),
-                value: format!("{:?}", value),
-                error: why.to_string(),
-            });
-        }
-
-        Ok(())
-    }
-
-    fn open_stream(&mut self) -> Result<(), NokhwaError> {
-        let stream = match MmapStream::new(&self.device, Type::VideoCapture) {
-            Ok(s) => s,
-            Err(why) => return Err(NokhwaError::OpenStreamError(why.to_string())),
-        };
-        self.stream_handle = Some(stream);
-        Ok(())
-    }
-
-    fn is_stream_open(&self) -> bool {
-        self.stream_handle.is_some()
-    }
-
-    fn frame(&mut self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
-        let cam_fmt = self.camera_format;
-        let raw_frame = self.frame_raw()?;
-        let conv = match cam_fmt.format() {
-            FrameFormat::MJPEG => mjpeg_to_rgb888(&raw_frame)?,
-            FrameFormat::YUYV => yuyv422_to_rgb888(&raw_frame)?,
-        };
-        let image_buf =
-            match ImageBuffer::from_vec(cam_fmt.width(), cam_fmt.height(), conv) {
-                Some(buf) => {
-                    let rgb_buf: ImageBuffer<Rgb<u8>, Vec<u8>> = buf;
-                    rgb_buf
-                }
-                None => return Err(NokhwaError::ReadFrameError(
-                    "ImageBuffer is not large enough! This is probably a bug, please report it!"
-                        .to_string(),
-                )),
-            };
-        Ok(image_buf)
-    }
-
-    fn frame_raw(&mut self) -> Result<Cow<[u8]>, NokhwaError> {
-        match &mut self.stream_handle {
-            Some(stream_handler) => match stream_handler.next() {
-                Ok((data, _)) => Ok(Cow::from(data)),
-                Err(why) => Err(NokhwaError::ReadFrameError(why.to_string())),
-            },
-            None => Err(NokhwaError::ReadFrameError(
-                "Stream not initialized! Please call \"open_stream()\" first!".to_string(),
-            )),
-        }
-    }
-
-    fn stop_stream(&mut self) -> Result<(), NokhwaError> {
-        if self.stream_handle.is_some() {
-            self.stream_handle = None;
-        }
-        Ok(())
-    }
-}
diff --git a/src/backends/capture/v4l2_backend.rs b/src/backends/capture/v4l2_backend.rs
new file mode 100644
index 0000000..2a9be6c
--- /dev/null
+++ b/src/backends/capture/v4l2_backend.rs
@@ -0,0 +1,757 @@
+/*
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use image::ImageBuffer;
+use nokhwa_core::types::{CameraFormat, CameraInfo};
+use nokhwa_core::{
+    buffer::Buffer,
+    error::NokhwaError,
+    traits::CaptureBackendTrait,
+    types::{
+        mjpeg_to_rgb, yuyv422_to_rgb, ApiBackend, CameraControl, CameraIndex,
+        ControlValueDescription, ControlValueSetter, FrameFormat, KnownCameraControl,
+        KnownCameraControlFlag, RequestedFormat, Resolution,
+    },
+};
+use std::{
+    borrow::Cow,
+    collections::HashMap,
+    fmt::format,
+    io::{self, ErrorKind},
+    iter::Repeat,
+};
+use v4l::io::mmap::Stream;
+use v4l::{
+    buffer::Type,
+    control::{Control, Flags, Value},
+    frameinterval::FrameIntervalEnum,
+    framesize::FrameSizeEnum,
+    io::traits::CaptureStream,
+    prelude::MmapStream,
+    video::{capture::Parameters, Capture},
+    Device, Format, FourCC, Fraction,
+};
+
+/// Attempts to convert a [`KnownCameraControl`] into a V4L2 Control ID.
+/// If the associated control is not found, this will return `None` (`ColorEnable`, `Roll`)
+pub fn known_camera_control_to_id(ctrl: KnownCameraControl) -> u32 {
+    match ctrl {
+        KnownCameraControl::Brightness => 9_963_776,
+        KnownCameraControl::Contrast => 9_963_777,
+        KnownCameraControl::Hue => 9_963_779,
+        KnownCameraControl::Saturation => 9_963_778,
+        KnownCameraControl::Sharpness => 9_963_803,
+        KnownCameraControl::Gamma => 9_963_792,
+        KnownCameraControl::WhiteBalance => 9_963_802,
+        KnownCameraControl::BacklightComp => 9_963_804,
+        KnownCameraControl::Gain => 9_963_795,
+        KnownCameraControl::Pan => 10_094_852,
+        KnownCameraControl::Tilt => 100_948_530,
+        KnownCameraControl::Zoom => 10_094_862,
+        KnownCameraControl::Exposure => 10_094_850,
+        KnownCameraControl::Iris => 10_094_866,
+        KnownCameraControl::Focus => 10_094_859,
+        KnownCameraControl::Other(id) => id as u32,
+    }
+}
+
+/// Attempts to convert a [`u32`] V4L2 Control ID into a [`KnownCameraControl`]
+/// If the associated control is not found, this will return `None` (`ColorEnable`, `Roll`)
+pub fn id_to_known_camera_control(id: u32) -> KnownCameraControl {
+    match id {
+        9_963_776 => KnownCameraControl::Brightness,
+        9_963_777 => KnownCameraControl::Contrast,
+        9_963_779 => KnownCameraControl::Hue,
+        9_963_778 => KnownCameraControl::Saturation,
+        9_963_803 => KnownCameraControl::Sharpness,
+        9_963_792 => KnownCameraControl::Gamma,
+        9_963_802 => KnownCameraControl::WhiteBalance,
+        9_963_804 => KnownCameraControl::BacklightComp,
+        9_963_795 => KnownCameraControl::Gain,
+        10_094_852 => KnownCameraControl::Pan,
+        100_948_530 => KnownCameraControl::Tilt,
+        10_094_862 => KnownCameraControl::Zoom,
+        10_094_850 => KnownCameraControl::Exposure,
+        10_094_866 => KnownCameraControl::Iris,
+        10_094_859 => KnownCameraControl::Focus,
+        id => KnownCameraControl::Other(id as u128),
+    }
+}
+
+/// The backend struct that interfaces with V4L2.
+/// To see what this does, please see [`CaptureBackendTrait`].
+/// # Quirks
+/// - Calling [`set_resolution()`](CaptureBackendTrait::set_resolution), [`set_frame_rate()`](CaptureBackendTrait::set_frame_rate), or [`set_frame_format()`](CaptureBackendTrait::set_frame_format) each internally calls [`set_camera_format()`](CaptureBackendTrait::set_camera_format).
+/// - The `Any` return type for [`raw_supported_camera_controls()`](CaptureBackendTrait::raw_supported_camera_controls) is [`Description`]
+/// - The `Any` type for [`raw_camera_control()`](CaptureBackendTrait::raw_camera_control) is [`u32`], and its return `Any` is a [`Control`]
+/// - The `Any` type for `control` for [`set_raw_camera_control()`](CaptureBackendTrait::set_raw_camera_control) is [`u32`] and [`Control`]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-v4l")))]
+pub struct V4LCaptureDevice<'a> {
+    initialized: bool,
+    camera_format: CameraFormat,
+    camera_info: CameraInfo,
+    device: Device,
+    stream_handle: Option<MmapStream<'a>>,
+}
+
+impl<'a> V4LCaptureDevice<'a> {
+    /// Creates a new capture device using the `V4L2` backend. Indexes are gives to devices by the OS, and usually numbered by order of discovery.
+    ///
+    /// If `camera_format` is `None`, it will be spawned with a random [`CameraFormat`] as determined by [`init()`](crate::CaptureBackendTrait::init).
+    ///
+    /// If `camera_format` is not `None`, the camera will try to use it when you call [`init()`](crate::CaptureBackendTrait::init).
+    /// # Errors
+    /// This function will error if the camera is currently busy or if `V4L2` can't read device information.
+    pub fn new(index: &CameraIndex, cam_fmt: RequestedFormat) -> Result<Self, NokhwaError> {
+        let mut device = match Device::new(index.as_index()? as usize) {
+            Ok(dev) => dev,
+            Err(why) => {
+                return Err(NokhwaError::OpenDeviceError(
+                    index.to_string(),
+                    format!("V4L2 Error: {}", why),
+                ))
+            }
+        };
+
+        // get all formats
+        // get all fcc
+        let mut camera_formats = vec![];
+
+        let frame_formats = match device.enum_formats() {
+            Ok(formats) => {
+                let mut frame_format_vec = vec![];
+                formats
+                    .iter()
+                    .for_each(|fmt| frame_format_vec.push(fmt.fourcc));
+                frame_format_vec.sort();
+                frame_format_vec.dedup();
+                Ok(frame_format_vec)
+            }
+            Err(why) => Err(NokhwaError::GetPropertyError {
+                property: "FrameFormat".to_string(),
+                error: why.to_string(),
+            }),
+        }?;
+
+        for ff in frame_formats {
+            let framefmt = match fourcc_to_frameformat(ff) {
+                Some(s) => s,
+                None => continue,
+            };
+            // i write unmaintainable blobs of code because i am so cute uwu~~
+            let mut formats = device
+                .enum_framesizes(ff)
+                .map_err(|why| NokhwaError::GetPropertyError {
+                    property: "ResolutionList".to_string(),
+                    error: why.to_string(),
+                })?
+                .into_iter()
+                .flat_map(|x| match x.size {
+                    FrameSizeEnum::Discrete(d) => Some(d).into_iter(),
+                    // we step over each step, getting a new resolution.
+                    FrameSizeEnum::Stepwise(s) => (s.min_width..s.max_width)
+                        .step_by(s.step_width as usize)
+                        .zip((s.min_height..s.max_height).step_by(s.step_height as usize))
+                        .map(|(x, y)| Resolution::new(x, y))
+                        .into_iter(),
+                })
+                .flat_map(|res| {
+                    device
+                        .enum_frameintervals(ff, res.x(), res.y())?
+                        .iter()
+                        .flat_map(|x| match &x.interval {
+                            FrameIntervalEnum::Discrete(dis) => {
+                                if dis.denominator == 1 {
+                                    Some(CameraFormat::new(
+                                        Resolution::new(x.width, x.height),
+                                        framefmt,
+                                        dis.numerator,
+                                    ))
+                                    .into_iter()
+                                } else {
+                                    None.into_iter()
+                                }
+                            }
+                            FrameIntervalEnum::Stepwise(step) => {
+                                let mut intvec = vec![];
+                                for fstep in (step.min.numerator..step.max.numerator)
+                                    .step_by(step.step.numerator as usize)
+                                {
+                                    if step.max.denominator != 1 || step.min.denominator != 1 {
+                                        intvec.push(CameraFormat::new(
+                                            Resolution::new(x.width, x.height),
+                                            framefmt,
+                                            fstep,
+                                        ))
+                                    }
+                                }
+                                intvec.into_iter()
+                            }
+                        })
+                })
+                .collect::<Result<Vec<CameraFormat>, NokhwaError>>()?;
+            camera_formats.append(&mut formats);
+        }
+
+        let format = cam_fmt
+            .fufill(&camera_formats)
+            .ok_or(NokhwaError::GetPropertyError {
+                property: "CameraFormat".to_string(),
+                error: "Failed to Fufill".to_string(),
+            })?;
+
+        if let Err(why) = device.set_format(&Format::new(
+            format.width(),
+            format.height(),
+            frameformat_to_fourcc(format.format()),
+        )) {
+            return Err(NokhwaError::SetPropertyError {
+                property: "Resolution, FrameFormat".to_string(),
+                value: format.to_string(),
+                error: why.to_string(),
+            });
+        }
+        if let Err(why) = device.set_params(&Parameters::with_fps(format.frame_rate())) {
+            return Err(NokhwaError::SetPropertyError {
+                property: "Frame rate".to_string(),
+                value: frame_rate.to_string(),
+                error: why.to_string(),
+            });
+        }
+
+        let mut v4l2 = V4LCaptureDevice {
+            initialized: false,
+            camera_format: format,
+            camera_info,
+            device,
+            stream_handle: None,
+        };
+
+        v4l2.force_refresh_camera_format()?;
+        if v4l2.camera_format() == format {
+            return Err(NokhwaError::SetPropertyError {
+                property: "CameraFormat".to_string(),
+                value: "".to_string(),
+                error: "Not same/Rejected".to_string(),
+            });
+        }
+
+        Ok(v4l2)
+    }
+
+    /// Create a new `V4L2` Camera with desired settings. This may or may not work.
+    /// # Errors
+    /// This function will error if the camera is currently busy or if `V4L2` can't read device information.
+    #[deprecated(since = "0.10.0", note = "please use `new` instead.")]
+    pub fn new_with(
+        index: CameraIndex,
+        width: u32,
+        height: u32,
+        fps: u32,
+        fourcc: FrameFormat,
+    ) -> Result<Self, NokhwaError> {
+        let camera_format = CameraFormat::new_from(width, height, fourcc, fps);
+        V4LCaptureDevice::new(index, RequestedFormat::Exact(camera_format))
+    }
+
+    fn get_resolution_list(&self, fourcc: FrameFormat) -> Result<Vec<Resolution>, NokhwaError> {
+        let format = frameformat_to_fourcc(fourcc);
+
+        // match Capture::enum_framesizes(&self.device, format) {
+        match self.device.enum_framesizes(format) {
+            Ok(frame_sizes) => {
+                let mut resolutions = vec![];
+                for frame_size in frame_sizes {
+                    match frame_size.size {
+                        FrameSizeEnum::Discrete(dis) => {
+                            resolutions.push(Resolution::new(dis.width, dis.height));
+                        }
+                        FrameSizeEnum::Stepwise(step) => {
+                            resolutions.push(Resolution::new(step.min_width, step.min_height));
+                            resolutions.push(Resolution::new(step.max_width, step.max_height));
+                            // TODO: Respect step size
+                        }
+                    }
+                }
+                Ok(resolutions)
+            }
+            Err(why) => Err(NokhwaError::GetPropertyError {
+                property: "Resolutions".to_string(),
+                error: why.to_string(),
+            }),
+        }
+    }
+
+    /// Get the inner device (immutable) for e.g. Controls
+    /// apps  bloodtests  contact  css  images  index  index.html  injectionsupplies  transfem  transmasc
+    #[allow(clippy::must_use_candidate)]
+    pub fn inner_device(&self) -> &Device {
+        &self.device
+    }
+
+    /// Get the inner device (mutable) for e.g. Controls
+    pub fn inner_device_mut(&mut self) -> &mut Device {
+        &mut self.device
+    }
+
+    /// Force refreshes the inner [`CameraFormat`] state.
+    pub fn force_refresh_camera_format(&mut self) -> Result<(), NokhwaError> {
+        match self.device.format() {
+            Ok(format) => {
+                let frame_format =
+                    fourcc_to_frameformat(format.fourcc).ok_or(NokhwaError::GetPropertyError {
+                        property: "FrameFormat".to_string(),
+                        error: "unsupported".to_string(),
+                    })?;
+
+                let fps = match self.device.params() {
+                    Ok(params) => {
+                        if params.interval.denominator != 1
+                            || params.interval.numerator % params.interval.denominator != 0
+                        {
+                            return Err(NokhwaError::GetPropertyError {
+                                property: "V4L2 FrameRate".to_string(),
+                                error: format!(
+                                    "Framerate not whole number: {} / {}",
+                                    params.interval.numerator, params.interval.denominator
+                                ),
+                            });
+                        }
+
+                        if params.interval.denominator != 1 {
+                            params.interval.numerator / params.interval.denominator
+                        } else {
+                            params.interval.numerator
+                        }
+                    }
+                    Err(why) => {
+                        return Err(NokhwaError::GetPropertyError {
+                            property: "V4L2 FrameRate".to_string(),
+                            error: why.to_string(),
+                        })
+                    }
+                };
+
+                self.camera_format = CameraFormat::new(
+                    Resolution::new(format.width, format.height),
+                    frame_format,
+                    fps,
+                );
+                Ok(())
+            }
+            Err(why) => Err(NokhwaError::GetPropertyError {
+                property: "parameters".to_string(),
+                error: why.to_string(),
+            }),
+        }
+    }
+}
+
+impl<'a> CaptureBackendTrait for V4LCaptureDevice<'a> {
+    fn backend(&self) -> ApiBackend {
+        ApiBackend::Video4Linux
+    }
+
+    fn camera_info(&self) -> &CameraInfo {
+        &self.camera_info
+    }
+
+    fn refresh_camera_format(&mut self) -> Result<(), NokhwaError> {
+        self.force_refresh_camera_format()
+    }
+
+    fn camera_format(&self) -> CameraFormat {
+        self.camera_format
+    }
+
+    fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
+        let prev_format = match Capture::format(&self.device) {
+            Ok(fmt) => fmt,
+            Err(why) => {
+                return Err(NokhwaError::GetPropertyError {
+                    property: "Resolution, FrameFormat".to_string(),
+                    error: why.to_string(),
+                })
+            }
+        };
+        let prev_fps = match Capture::params(&self.device) {
+            Ok(fps) => fps,
+            Err(why) => {
+                return Err(NokhwaError::GetPropertyError {
+                    property: "Frame rate".to_string(),
+                    error: why.to_string(),
+                })
+            }
+        };
+
+        let format: Format = new_fmt.into();
+        let frame_rate = Parameters::with_fps(new_fmt.frame_rate());
+
+        if let Err(why) = Capture::set_format(&self.device, &format) {
+            return Err(NokhwaError::SetPropertyError {
+                property: "Resolution, FrameFormat".to_string(),
+                value: format.to_string(),
+                error: why.to_string(),
+            });
+        }
+        if let Err(why) = Capture::set_params(&self.device, &frame_rate) {
+            return Err(NokhwaError::SetPropertyError {
+                property: "Frame rate".to_string(),
+                value: frame_rate.to_string(),
+                error: why.to_string(),
+            });
+        }
+
+        if self.stream_handle.is_some() {
+            return match self.open_stream() {
+                Ok(_) => Ok(()),
+                Err(why) => {
+                    // undo
+                    if let Err(why) = Capture::set_format(&self.device, &prev_format) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property: format!("Attempt undo due to stream acquisition failure with error {}. Resolution, FrameFormat", why),
+                            value: prev_format.to_string(),
+                            error: why.to_string(),
+                        });
+                    }
+                    if let Err(why) = Capture::set_params(&self.device, &prev_fps) {
+                        return Err(NokhwaError::SetPropertyError {
+                            property:
+                            format!("Attempt undo due to stream acquisition failure with error {}. Frame rate", why),
+                            value: prev_fps.to_string(),
+                            error: why.to_string(),
+                        });
+                    }
+                    Err(why)
+                }
+            };
+        }
+        self.camera_format = new_fmt;
+
+        self.force_refresh_camera_format()?;
+        if self.camera_format != new_fmt {
+            return Err(NokhwaError::SetPropertyError {
+                property: "CameraFormat".to_string(),
+                value: new_fmt.to_string(),
+                error: "Rejected".to_string(),
+            });
+        }
+
+        Ok(())
+    }
+
+    fn compatible_list_by_resolution(
+        &mut self,
+        fourcc: FrameFormat,
+    ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
+        let resolutions = self.get_resolution_list(fourcc)?;
+        let format = frameformat_to_fourcc(fourcc);
+        let mut res_map = HashMap::new();
+        for res in resolutions {
+            let mut compatible_fps = vec![];
+            match self.device.enum_frameintervals(format) {
+                Ok(intervals) => {
+                    for interval in intervals {
+                        match interval.interval {
+                            FrameIntervalEnum::Discrete(dis) => {
+                                compatible_fps.push(dis.denominator);
+                            }
+                            FrameIntervalEnum::Stepwise(step) => {
+                                for fstep in (step.min.numerator..step.max.numerator)
+                                    .step_by(step.step.numerator as usize)
+                                {
+                                    if step.max.denominator != 1 || step.min.denominator != 1 {
+                                        compatible_fps.push(fstep)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(why) => {
+                    return Err(NokhwaError::GetPropertyError {
+                        property: "Frame rate".to_string(),
+                        error: why.to_string(),
+                    })
+                }
+            }
+            res_map.insert(res, compatible_fps);
+        }
+        Ok(res_map)
+    }
+
+    fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
+        match self.device.enum_formats() {
+            Ok(formats) => {
+                let mut frame_format_vec = vec![];
+                for format in formats {
+                    match fourcc_to_frameformat(format.fourcc) {
+                        Some(ff) => frame_format_vec.push(ff),
+                        None => continue,
+                    }
+                }
+                frame_format_vec.sort();
+                frame_format_vec.dedup();
+                Ok(frame_format_vec)
+            }
+            Err(why) => Err(NokhwaError::GetPropertyError {
+                property: "FrameFormat".to_string(),
+                error: why.to_string(),
+            }),
+        }
+    }
+
+    fn resolution(&self) -> Resolution {
+        self.camera_format.resolution()
+    }
+
+    fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError> {
+        let mut new_fmt = self.camera_format;
+        new_fmt.set_resolution(new_res);
+        self.set_camera_format(new_fmt)
+    }
+
+    fn frame_rate(&self) -> u32 {
+        self.camera_format.frame_rate()
+    }
+
+    fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError> {
+        let mut new_fmt = self.camera_format;
+        new_fmt.set_frame_rate(new_fps);
+        self.set_camera_format(new_fmt)
+    }
+
+    fn frame_format(&self) -> FrameFormat {
+        self.camera_format.format()
+    }
+
+    fn set_frame_format(&mut self, fourcc: FrameFormat) -> Result<(), NokhwaError> {
+        let mut new_fmt = self.camera_format;
+        new_fmt.set_format(fourcc);
+        self.set_camera_format(new_fmt)
+    }
+
+    fn camera_control(&self, control: KnownCameraControl) -> Result<CameraControl, NokhwaError> {
+        let controls = self.camera_controls()?;
+        for supported_control in controls {
+            if supported_control.control() == control {
+                return Ok(supported_control);
+            }
+        }
+        Err(NokhwaError::GetPropertyError {
+            property: control.to_string(),
+            error: "not found/not supported".to_string(),
+        })
+    }
+
+    fn camera_controls(&self) -> Result<Vec<CameraControl>, NokhwaError> {
+        self.device
+            .query_controls()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "V4L2 Controls".to_string(),
+                error: why.to_string(),
+            })?
+            .into_iter()
+            .map(|desc| {
+                let id_as_kcc = id_to_known_camera_control(desc.id);
+                let ctrl_current = self.device.control(desc.id)?.value;
+
+                let ctrl_value_desc = match (desc.typ, ctrl_current) {
+                    (
+                        Type::Integer
+                        | Type::Integer64
+                        | Type::Menu
+                        | Type::U8
+                        | Type::U16
+                        | Type::U32
+                        | Type::IntegerMenu,
+                        Value::Integer(current),
+                    ) => ControlValueDescription::IntegerRange {
+                        min: desc.minimum as i64,
+                        max: desc.maximum,
+                        value: current,
+                        step: desc.step as i64,
+                        default: desc.default,
+                    },
+                    (Type::Boolean, Value::Boolean(current)) => ControlValueDescription::Boolean {
+                        value: current,
+                        default: desc.default != 0,
+                    },
+
+                    (Type::String, Value::String(current)) => ControlValueDescription::String {
+                        value: current,
+                        default: None,
+                    },
+                    _ => {
+                        return Err(io::Error::new(
+                            ErrorKind::Unsupported,
+                            "what is this?????? todo: support ig",
+                        ))
+                    }
+                };
+
+                let is_readonly = desc
+                    .flags
+                    .intersects(Flags::READ_ONLY)
+                    .then(|| KnownCameraControlFlag::ReadOnly);
+                let is_writeonly = desc
+                    .flags
+                    .intersects(Flags::WRITE_ONLY)
+                    .then(|| KnownCameraControlFlag::WriteOnly);
+                let is_disabled = desc
+                    .flags
+                    .intersects(Flags::DISABLED)
+                    .then(|| KnownCameraControlFlag::Disabled);
+                let is_volatile = desc
+                    .flags
+                    .intersects(Flags::VOLATILE)
+                    .then(|| KnownCameraControlFlag::Volatile);
+                let is_inactive = desc
+                    .flags
+                    .intersects(Flags::INACTIVE)
+                    .then(|| KnownCameraControlFlag::Inactive);
+                let flags_vec = vec![
+                    is_inactive,
+                    is_readonly,
+                    is_volatile,
+                    is_disabled,
+                    is_writeonly,
+                ]
+                .into_iter()
+                .filter(|x| x.is_some())
+                .collect::<Option<Vec<KnownCameraControlFlag>>>()
+                .unwrap_or_default();
+
+                Ok(CameraControl::new(
+                    id_as_kcc,
+                    desc.name,
+                    ctrl_value_desc,
+                    flags_vec,
+                    !desc.flags.intersects(Flags::INACTIVE),
+                ))
+            })
+            .filter(|x| x.is_ok())
+            .collect::<Result<Vec<CameraControl>, io::Error>>()
+            .map_err(|x| NokhwaError::GetPropertyError {
+                property: "www".to_string(),
+                error: x.to_string(),
+            })
+    }
+
+    fn set_camera_control(
+        &mut self,
+        id: KnownCameraControl,
+        value: ControlValueSetter,
+    ) -> Result<(), NokhwaError> {
+        let value = match value {
+            ControlValueSetter::None => Value::None,
+            ControlValueSetter::Integer(i) => Value::Integer(i),
+            ControlValueSetter::Float(f) => {
+                return Err(NokhwaError::SetPropertyError {
+                    property: id.to_string(),
+                    value: f.to_string(),
+                    error: "not supported".to_string(),
+                })
+            }
+            ControlValueSetter::Boolean(b) => Value::Boolean(b),
+            ControlValueSetter::String(s) => Value::String(s),
+            ControlValueSetter::Bytes(b) => Value::CompoundU8(b),
+        };
+        self.device
+            .set_control(Control {
+                id: known_camera_control_to_id(id),
+                value,
+            })
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: id.to_string(),
+                value: value.to_string(),
+                error: why.to_string(),
+            })?;
+        // verify
+
+        let control = self.camera_control(id)?;
+        if control.value() != value {
+            return Err(NokhwaError::SetPropertyError {
+                property: id.to_string(),
+                value: value.to_string(),
+                error: "Rejected".to_string(),
+            });
+        }
+        Ok(())
+    }
+
+    fn open_stream(&mut self) -> Result<(), NokhwaError> {
+        let stream = match MmapStream::new(&self.device, Type::VideoCapture) {
+            Ok(s) => s,
+            Err(why) => return Err(NokhwaError::OpenStreamError(why.to_string())),
+        };
+        self.stream_handle = Some(stream);
+        Ok(())
+    }
+
+    fn is_stream_open(&self) -> bool {
+        self.stream_handle.is_some()
+    }
+
+    fn frame(&mut self) -> Result<Buffer, NokhwaError> {
+        let cam_fmt = self.camera_format;
+        let raw_frame = self.frame_raw()?;
+        let conv = match cam_fmt.format() {
+            FrameFormat::MJPEG => mjpeg_to_rgb(&raw_frame, false)?,
+            FrameFormat::YUYV => yuyv422_to_rgb(&raw_frame, false)?,
+            FrameFormat::GRAY => raw_frame.to_vec(),
+        };
+        Ok(Buffer::new_with_vec(
+            cam_fmt.resolution(),
+            conv,
+            cam_fmt.format(),
+        ))
+    }
+
+    fn frame_raw(&mut self) -> Result<Cow<'a, [u8]>, NokhwaError> {
+        match &self.stream_handle {
+            Some(mut sh) => match sh.next() {
+                Ok((data, _)) => Ok(Cow::Borrowed(data)),
+                Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
+            },
+            None => {}
+        }
+    }
+
+    fn stop_stream(&mut self) -> Result<(), NokhwaError> {
+        if self.stream_handle.is_some() {
+            self.stream_handle = None;
+        }
+        Ok(())
+    }
+}
+
+fn fourcc_to_frameformat(fourcc: FourCC) -> Option<FrameFormat> {
+    match fourcc.str().ok()? {
+        "YUYV" => Some(FrameFormat::YUYV),
+        "MJPG" => Some(FrameFormat::MJPEG),
+        "GRAY" => Some(FrameFormat::GRAY),
+        _ => None,
+    }
+}
+
+fn frameformat_to_fourcc(fourcc: FrameFormat) -> FourCC {
+    match fourcc {
+        FrameFormat::MJPEG => FourCC::new(b"MJPG"),
+        FrameFormat::YUYV => FourCC::new(b"YUYV"),
+        FrameFormat::GRAY => FourCC::new(b"GRAY"),
+    }
+}
diff --git a/src/backends/mod.rs b/src/backends/mod.rs
index 9cc4531..2eadd1d 100644
--- a/src/backends/mod.rs
+++ b/src/backends/mod.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/camera.rs b/src/camera.rs
index d3c319d..3ee175e 100644
--- a/src/camera.rs
+++ b/src/camera.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,123 +14,161 @@
  * limitations under the License.
  */
 
-use crate::{
-    CameraControl, CameraFormat, CameraInfo, CaptureAPIBackend, CaptureBackendTrait, FrameFormat,
-    KnownCameraControls, NokhwaError, Resolution,
+use nokhwa_core::{
+    buffer::Buffer,
+    error::NokhwaError,
+    pixel_format::FormatDecoder,
+    traits::CaptureBackendTrait,
+    types::{
+        ApiBackend, CameraControl, CameraFormat, CameraIndex, CameraInfo, ControlValueSetter,
+        FrameFormat, KnownCameraControl, RequestedFormat, Resolution,
+    },
 };
-use image::{buffer::ConvertBuffer, ImageBuffer, Rgb, RgbaImage};
-use std::{any::Any, borrow::Cow, collections::HashMap};
+use std::{borrow::Cow, collections::HashMap};
 #[cfg(feature = "output-wgpu")]
-use wgpu::{
-    Device as WgpuDevice, Extent3d, ImageCopyTexture, ImageDataLayout, Queue as WgpuQueue,
-    Texture as WgpuTexture, TextureAspect, TextureDescriptor, TextureDimension, TextureFormat,
-    TextureUsages,
-};
+use wgpu::{Device as WgpuDevice, Queue as WgpuQueue, Texture as WgpuTexture};
 
 /// The main `Camera` struct. This is the struct that abstracts over all the backends, providing a simplified interface for use.
 pub struct Camera {
-    idx: usize,
-    backend: Box<dyn CaptureBackendTrait>,
-    backend_api: CaptureAPIBackend,
+    idx: CameraIndex,
+    api: ApiBackend,
+    device: Box<dyn CaptureBackendTrait>,
 }
 
-#[allow(clippy::nonminimal_bool)]
 impl Camera {
     /// Create a new camera from an `index` and `format`
     /// # Errors
     /// This will error if you either have a bad platform configuration (e.g. `input-v4l` but not on linux) or the backend cannot create the camera (e.g. permission denied).
-    pub fn new(index: usize, format: Option<CameraFormat>) -> Result<Self, NokhwaError> {
-        Camera::with_backend(index, format, CaptureAPIBackend::Auto)
+    pub fn new(index: CameraIndex, format: RequestedFormat) -> Result<Self, NokhwaError> {
+        Camera::with_backend(index, format, ApiBackend::Auto)
     }
 
     /// Create a new camera from an `index`, `format`, and `backend`. `format` can be `None`.
     /// # Errors
     /// This will error if you either have a bad platform configuration (e.g. `input-v4l` but not on linux) or the backend cannot create the camera (e.g. permission denied).
     pub fn with_backend(
-        index: usize,
-        format: Option<CameraFormat>,
-        backend: CaptureAPIBackend,
+        index: CameraIndex,
+        format: RequestedFormat,
+        backend: ApiBackend,
     ) -> Result<Self, NokhwaError> {
-        let camera_backend = init_camera(index, format, backend)?;
+        let camera_backend = init_camera(&index, format, backend)?;
 
         Ok(Camera {
             idx: index,
-            backend: camera_backend,
-            backend_api: backend,
+            api: backend,
+            device: camera_backend,
         })
     }
 
     /// Create a new `Camera` from raw values.
     /// # Errors
     /// This will error if you either have a bad platform configuration (e.g. `input-v4l` but not on linux) or the backend cannot create the camera (e.g. permission denied).
+    #[deprecated(since = "0.10.0", note = "please use `new` instead.")]
     pub fn new_with(
-        index: usize,
+        index: CameraIndex,
         width: u32,
         height: u32,
         fps: u32,
         fourcc: FrameFormat,
-        backend: CaptureAPIBackend,
+        backend: ApiBackend,
     ) -> Result<Self, NokhwaError> {
         let camera_format = CameraFormat::new_from(width, height, fourcc, fps);
-        Camera::with_backend(index, Some(camera_format), backend)
+        Camera::with_backend(index, RequestedFormat::Exact(camera_format), backend)
     }
 
     /// Gets the current Camera's index.
     #[must_use]
-    pub fn index(&self) -> usize {
-        self.idx
+    pub fn index(&self) -> &CameraIndex {
+        &self.idx
     }
 
     /// Sets the current Camera's index. Note that this re-initializes the camera.
     /// # Errors
     /// The Backend may fail to initialize.
-    pub fn set_index(&mut self, new_idx: usize) -> Result<(), NokhwaError> {
+    pub fn set_index(&mut self, new_idx: &CameraIndex) -> Result<(), NokhwaError> {
         {
-            self.backend.stop_stream()?;
+            self.device.stop_stream()?;
         }
-        let new_camera_format = self.backend.camera_format();
-        let new_camera = init_camera(new_idx, Some(new_camera_format), self.backend_api)?;
-        self.backend = new_camera;
+        let new_camera_format = self.device.camera_format();
+        let new_camera = init_camera(new_idx, RequestedFormat::Exact(new_camera_format), self.api)?;
+        self.device = new_camera;
         Ok(())
     }
 
     /// Gets the current Camera's backend
     #[must_use]
-    pub fn backend(&self) -> CaptureAPIBackend {
-        self.backend_api
+    pub fn backend(&self) -> ApiBackend {
+        self.api
     }
 
     /// Sets the current Camera's backend. Note that this re-initializes the camera.
     /// # Errors
     /// The new backend may not exist or may fail to initialize the new camera.
-    pub fn set_backend(&mut self, new_backend: CaptureAPIBackend) -> Result<(), NokhwaError> {
+    pub fn set_backend(&mut self, new_backend: ApiBackend) -> Result<(), NokhwaError> {
         {
-            self.backend.stop_stream()?;
+            self.device.stop_stream()?;
         }
-        let new_camera_format = self.backend.camera_format();
-        let new_camera = init_camera(self.idx, Some(new_camera_format), new_backend)?;
-        self.backend = new_camera;
+        let new_camera_format = self.device.camera_format();
+        let new_camera = init_camera(
+            &self.idx,
+            RequestedFormat::Exact(new_camera_format),
+            new_backend,
+        )?;
+        self.device = new_camera;
         Ok(())
     }
 
     /// Gets the camera information such as Name and Index as a [`CameraInfo`].
     #[must_use]
     pub fn info(&self) -> &CameraInfo {
-        self.backend.camera_info()
+        self.device.camera_info()
     }
 
     /// Gets the current [`CameraFormat`].
     #[must_use]
     pub fn camera_format(&self) -> CameraFormat {
-        self.backend.camera_format()
+        self.device.camera_format()
     }
 
+    /// Forcefully refreshes the stored camera format, bringing it into sync with "reality" (current camera state)
+    /// # Errors
+    /// If the camera can not get its most recent [`CameraFormat`]. this will error.
+    pub fn refresh_camera_format(&mut self) -> Result<CameraFormat, NokhwaError> {
+        self.device.refresh_camera_format()?;
+        Ok(self.device.camera_format())
+    }
+
+    /// Will set the current [`CameraFormat`], using a [`RequestedFormat.`]
+    /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
+    ///
+    /// This will return the new [`CameraFormat`]
+    /// # Errors
+    /// If nothing fits the requested criteria, this will return an error.
+    pub fn set_camera_requset(
+        &mut self,
+        request: RequestedFormat,
+    ) -> Result<CameraFormat, NokhwaError> {
+        let new_format = request
+            .fulfill(self.device.compatible_camera_formats()?.as_slice())
+            .ok_or(NokhwaError::GetPropertyError {
+                property: "Compatible Camera Format by request".to_string(),
+                error: "Failed to fufill".to_string(),
+            })?;
+        self.device.set_camera_format(new_format)?;
+        Ok(new_format)
+    }
+
+    #[deprecated(since = "0.10.0", note = "please use `set_camera_requset` instead.")]
     /// Will set the current [`CameraFormat`]
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new camera format, this will return an error.
     pub fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
-        self.backend.set_camera_format(new_fmt)
+        self.device.set_camera_format(new_fmt)
     }
 
     /// A hashmap of [`Resolution`]s mapped to framerates
@@ -140,80 +178,81 @@ impl Camera {
         &mut self,
         fourcc: FrameFormat,
     ) -> Result<HashMap<Resolution, Vec<u32>>, NokhwaError> {
-        self.backend.compatible_list_by_resolution(fourcc)
+        self.device.compatible_list_by_resolution(fourcc)
     }
 
     /// A Vector of compatible [`FrameFormat`]s.
     /// # Errors
     /// This will error if the camera is not queryable or a query operation has failed. Some backends will error this out as a [`UnsupportedOperationError`](crate::NokhwaError::UnsupportedOperationError).
     pub fn compatible_fourcc(&mut self) -> Result<Vec<FrameFormat>, NokhwaError> {
-        self.backend.compatible_fourcc()
+        self.device.compatible_fourcc()
     }
 
     /// A Vector of available [`CameraFormat`]s.
     /// # Errors
     /// This will error if the camera is not queryable or a query operation has failed. Some backends will error this out as a [`UnsupportedOperationError`](crate::NokhwaError::UnsupportedOperationError).
     pub fn compatible_camera_formats(&mut self) -> Result<Vec<CameraFormat>, NokhwaError> {
-        let mut camera_formats = Vec::with_capacity(64);
-        for foramt in self.compatible_fourcc()? {
-            let resolution_and_fps: HashMap<Resolution, Vec<u32>> =
-                self.compatible_list_by_resolution(foramt)?;
-            for (res, rates) in resolution_and_fps {
-                for fps in rates {
-                    camera_formats.push(CameraFormat::new(res, foramt, fps))
-                }
-            }
-        }
-        Ok(camera_formats)
+        self.device.compatible_camera_formats()
     }
 
-    /// Gets the current camera resolution (See: [`Resolution`], [`CameraFormat`]).
+    /// Gets the current camera resolution (See: [`Resolution`], [`CameraFormat`]). This will force refresh to the current latest if it has changed.
     #[must_use]
     pub fn resolution(&self) -> Resolution {
-        self.backend.resolution()
+        self.device.resolution()
     }
 
     /// Will set the current [`Resolution`]
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new resolution, this will return an error.
     pub fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError> {
-        self.backend.set_resolution(new_res)
+        self.device.set_resolution(new_res)
     }
 
     /// Gets the current camera framerate (See: [`CameraFormat`]).
     #[must_use]
     pub fn frame_rate(&self) -> u32 {
-        self.backend.frame_rate()
+        self.device.frame_rate()
     }
 
     /// Will set the current framerate
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new framerate, this will return an error.
     pub fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError> {
-        self.backend.set_frame_rate(new_fps)
+        self.device.set_frame_rate(new_fps)
     }
 
-    /// Gets the current camera's frame format (See: [`FrameFormat`], [`CameraFormat`]).
+    /// Gets the current camera's frame format (See: [`FrameFormat`], [`CameraFormat`]). This will force refresh to the current latest if it has changed.
     #[must_use]
     pub fn frame_format(&self) -> FrameFormat {
-        self.backend.frame_format()
+        self.device.frame_format()
     }
 
     /// Will set the current [`FrameFormat`]
     /// This will reset the current stream if used while stream is opened.
+    ///
+    /// This will also update the cache.
     /// # Errors
     /// If you started the stream and the camera rejects the new frame format, this will return an error.
     pub fn set_frame_format(&mut self, fourcc: FrameFormat) -> Result<(), NokhwaError> {
-        self.backend.set_frame_format(fourcc)
+        self.device.set_frame_format(fourcc)
     }
 
-    /// Gets the current supported list of [`KnownCameraControls`]
+    /// Gets the current supported list of [`KnownCameraControl`](crate::utils::KnownCameraControl)
     /// # Errors
     /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
-    pub fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
-        self.backend.supported_camera_controls()
+    pub fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControl>, NokhwaError> {
+        Ok(self
+            .device
+            .camera_controls()?
+            .iter()
+            .map(CameraControl::control)
+            .collect())
     }
 
     /// Gets the current supported list of [`CameraControl`]s keyed by its name as a `String`.
@@ -244,7 +283,7 @@ impl Camera {
             .collect::<Vec<(String, CameraControl)>>();
         let mut control_map = HashMap::with_capacity(maybe_camera_controls.len());
 
-        for (kc, cc) in maybe_camera_controls.into_iter() {
+        for (kc, cc) in maybe_camera_controls {
             control_map.insert(kc, cc);
         }
 
@@ -256,88 +295,59 @@ impl Camera {
     /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
     pub fn camera_controls_known_camera_controls(
         &self,
-    ) -> Result<HashMap<KnownCameraControls, CameraControl>, NokhwaError> {
+    ) -> Result<HashMap<KnownCameraControl, CameraControl>, NokhwaError> {
         let known_controls = self.supported_camera_controls()?;
         let maybe_camera_controls = known_controls
             .iter()
             .map(|x| (*x, self.camera_control(*x)))
             .filter(|(_, x)| x.is_ok())
             .map(|(c, x)| (c, Result::unwrap(x)))
-            .collect::<Vec<(KnownCameraControls, CameraControl)>>();
+            .collect::<Vec<(KnownCameraControl, CameraControl)>>();
         let mut control_map = HashMap::with_capacity(maybe_camera_controls.len());
 
-        for (kc, cc) in maybe_camera_controls.into_iter() {
+        for (kc, cc) in maybe_camera_controls {
             control_map.insert(kc, cc);
         }
 
         Ok(control_map)
     }
 
-    /// Gets the value of [`KnownCameraControls`].
+    /// Gets the value of [`KnownCameraControl`].
     /// # Errors
     /// If the `control` is not supported or there is an error while getting the camera control values (e.g. unexpected value, too high, etc)
     /// this will error.
     pub fn camera_control(
         &self,
-        control: KnownCameraControls,
+        control: KnownCameraControl,
     ) -> Result<CameraControl, NokhwaError> {
-        self.backend.camera_control(control)
+        self.device.camera_control(control)
     }
 
     /// Sets the control to `control` in the camera.
     /// Usually, the pipeline is calling [`camera_control()`](CaptureBackendTrait::camera_control), getting a camera control that way
-    /// then calling one of the methods to set the value: [`set_value()`](CameraControl::set_value()) or [`with_value()`](CameraControl::with_value()).
+    /// then calling [`set_value()`](CameraControl::set_value())
     /// # Errors
     /// If the `control` is not supported, the value is invalid (less than min, greater than max, not in step), or there was an error setting the control,
     /// this will error.
-    pub fn set_camera_control(&mut self, control: CameraControl) -> Result<(), NokhwaError> {
-        self.backend.set_camera_control(control)
-    }
-
-    /// Gets the current supported list of Controls as an `Any` from the backend.
-    /// The `Any`'s type is defined by the backend itself, please check each of the backend's documentation.
-    /// # Errors
-    /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
-    pub fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
-        self.backend.raw_supported_camera_controls()
-    }
-
-    /// Sets the control to `control` in the camera.
-    /// The control's type is defined the backend itself. It may be a string, or more likely its a integer ID.
-    /// The backend itself has documentation of the proper input/return values, please check each of the backend's documentation.
-    /// # Errors
-    /// If the `control` is not supported or there is an error while getting the camera control values (e.g. unexpected value, too high, wrong Any type)
-    /// this will error.
-    pub fn raw_camera_control(&self, control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
-        self.backend.raw_camera_control(control)
-    }
-
-    /// Sets the control to `control` in the camera.
-    /// The `control`/`value`'s type is defined the backend itself. It may be a string, or more likely its a integer ID/Value.
-    /// Usually, the pipeline is calling [`camera_control()`](CaptureBackendTrait::camera_control), getting a camera control that way
-    /// then calling one of the methods to set the value: [`set_value()`](CameraControl::set_value()) or [`with_value()`](CameraControl::with_value()).
-    /// # Errors
-    /// If the `control` is not supported, the value is invalid (wrong Any type, backend refusal), or there was an error setting the control,
-    /// this will error.
-    pub fn set_raw_camera_control(
+    pub fn set_camera_control(
         &mut self,
-        control: &dyn Any,
-        value: &dyn Any,
+        id: KnownCameraControl,
+        value: ControlValueSetter,
     ) -> Result<(), NokhwaError> {
-        self.backend.set_raw_camera_control(control, value)
+        self.device.set_camera_control(id, value)
     }
 
     /// Will open the camera stream with set parameters. This will be called internally if you try and call [`frame()`](CaptureBackendTrait::frame()) before you call [`open_stream()`](CaptureBackendTrait::open_stream()).
     /// # Errors
     /// If the specific backend fails to open the camera (e.g. already taken, busy, doesn't exist anymore) this will error.
     pub fn open_stream(&mut self) -> Result<(), NokhwaError> {
-        self.backend.open_stream()
+        self.device.open_stream()
     }
 
     /// Checks if stream if open. If it is, it will return true.
     #[must_use]
     pub fn is_stream_open(&self) -> bool {
-        self.backend.is_stream_open()
+        self.device.is_stream_open()
     }
 
     /// Will get a frame from the camera as a Raw RGB image buffer. Depending on the backend, if you have not called [`open_stream()`](CaptureBackendTrait::open_stream()) before you called this,
@@ -345,59 +355,28 @@ impl Camera {
     /// # Errors
     /// If the backend fails to get the frame (e.g. already taken, busy, doesn't exist anymore), the decoding fails (e.g. MJPEG -> u8), or [`open_stream()`](CaptureBackendTrait::open_stream()) has not been called yet,
     /// this will error.
-    pub fn frame(&mut self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
-        self.backend.frame()
+    pub fn frame(&mut self) -> Result<Buffer, NokhwaError> {
+        self.device.frame()
     }
 
     /// Will get a frame from the camera **without** any processing applied, meaning you will usually get a frame you need to decode yourself.
     /// # Errors
     /// If the backend fails to get the frame (e.g. already taken, busy, doesn't exist anymore), or [`open_stream()`](CaptureBackendTrait::open_stream()) has not been called yet, this will error.
     pub fn frame_raw(&mut self) -> Result<Cow<[u8]>, NokhwaError> {
-        match self.backend.frame_raw() {
+        match self.device.frame_raw() {
             Ok(f) => Ok(f),
             Err(why) => Err(why),
         }
     }
 
-    /// The minimum buffer size needed to write the current frame (RGB24). If `rgba` is true, it will instead return the minimum size of the RGBA buffer needed.
-    #[must_use]
-    pub fn min_buffer_size(&self, rgba: bool) -> usize {
-        let resolution = self.backend.resolution();
-        if rgba {
-            return (resolution.width() * resolution.height() * 4) as usize;
-        }
-        (resolution.width() * resolution.height() * 3) as usize
-    }
-
-    /// Directly writes the current frame(RGB24) into said `buffer`. If `convert_rgba` is true, the buffer written will be written as an RGBA frame instead of a RGB frame. Returns the amount of bytes written on successful capture.
+    /// Directly writes the current frame into said `buffer`.
     /// # Errors
     /// If the backend fails to get the frame (e.g. already taken, busy, doesn't exist anymore), or [`open_stream()`](CaptureBackendTrait::open_stream()) has not been called yet, this will error.
-    pub fn frame_to_buffer(
+    pub fn write_frame_to_buffer<F: FormatDecoder>(
         &mut self,
         buffer: &mut [u8],
-        convert_rgba: bool,
-    ) -> Result<usize, NokhwaError> {
-        let resolution = self.resolution();
-        let frame = self.frame_raw()?;
-        if convert_rgba {
-            let image_data =
-                match ImageBuffer::from_raw(resolution.width(), resolution.height(), frame) {
-                    Some(image) => {
-                        let image: ImageBuffer<Rgb<u8>, Cow<[u8]>> = image;
-                        image
-                    }
-                    None => {
-                        return Err(NokhwaError::ReadFrameError(
-                            "Frame Cow Too Small".to_string(),
-                        ))
-                    }
-                };
-            let rgba_image: RgbaImage = image_data.convert();
-            buffer.copy_from_slice(rgba_image.as_raw());
-            return Ok(rgba_image.len());
-        }
-        buffer.copy_from_slice(frame.as_ref());
-        Ok(frame.len())
+    ) -> Result<(), NokhwaError> {
+        self.device.frame()?.decode_image_to_buffer::<F>(buffer)
     }
 
     #[cfg(feature = "output-wgpu")]
@@ -405,66 +384,20 @@ impl Camera {
     /// Directly copies a frame to a Wgpu texture. This will automatically convert the frame into a RGBA frame.
     /// # Errors
     /// If the frame cannot be captured or the resolution is 0 on any axis, this will error.
-    pub fn frame_texture<'a>(
+    pub fn frame_texture<'a, F: FormatDecoder>(
         &mut self,
         device: &WgpuDevice,
         queue: &WgpuQueue,
         label: Option<&'a str>,
     ) -> Result<WgpuTexture, NokhwaError> {
-        use std::{convert::TryFrom, num::NonZeroU32};
-        let frame = self.frame()?;
-        let rgba_frame: RgbaImage = frame.convert();
-
-        let texture_size = Extent3d {
-            width: frame.width(),
-            height: frame.height(),
-            depth_or_array_layers: 1,
-        };
-
-        let texture = device.create_texture(&TextureDescriptor {
-            label,
-            size: texture_size,
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: TextureDimension::D2,
-            format: TextureFormat::Rgba8UnormSrgb,
-            usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
-        });
-
-        let width_nonzero = match NonZeroU32::try_from(4 * rgba_frame.width()) {
-            Ok(w) => Some(w),
-            Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
-        };
-
-        let height_nonzero = match NonZeroU32::try_from(rgba_frame.height()) {
-            Ok(h) => Some(h),
-            Err(why) => return Err(NokhwaError::ReadFrameError(why.to_string())),
-        };
-
-        queue.write_texture(
-            ImageCopyTexture {
-                texture: &texture,
-                mip_level: 0,
-                origin: wgpu::Origin3d::ZERO,
-                aspect: TextureAspect::All,
-            },
-            &rgba_frame.to_vec(),
-            ImageDataLayout {
-                offset: 0,
-                bytes_per_row: width_nonzero,
-                rows_per_image: height_nonzero,
-            },
-            texture_size,
-        );
-
-        Ok(texture)
+        self.device.frame_texture(device, queue, label)
     }
 
     /// Will drop the stream.
     /// # Errors
     /// Please check the `Quirks` section of each backend.
     pub fn stop_stream(&mut self) -> Result<(), NokhwaError> {
-        self.backend.stop_stream()
+        self.device.stop_stream()
     }
 }
 
@@ -476,23 +409,19 @@ impl Drop for Camera {
 
 // TODO: Update as we go
 #[allow(clippy::ifs_same_cond)]
-fn figure_out_auto() -> Option<CaptureAPIBackend> {
+fn figure_out_auto() -> Option<ApiBackend> {
     let platform = std::env::consts::OS;
-    let mut cap = CaptureAPIBackend::Auto;
+    let mut cap = ApiBackend::Auto;
     if cfg!(feature = "input-v4l") && platform == "linux" {
-        cap = CaptureAPIBackend::Video4Linux;
+        cap = ApiBackend::Video4Linux;
     } else if cfg!(feature = "input-msmf") && platform == "windows" {
-        cap = CaptureAPIBackend::MediaFoundation;
+        cap = ApiBackend::MediaFoundation;
     } else if cfg!(feature = "input-avfoundation") && (platform == "macos" || platform == "ios") {
-        cap = CaptureAPIBackend::AVFoundation;
-    } else if cfg!(feature = "input-uvc") {
-        cap = CaptureAPIBackend::UniversalVideoClass;
-    } else if cfg!(feature = "input-gst") {
-        cap = CaptureAPIBackend::GStreamer;
+        cap = ApiBackend::AVFoundation;
     } else if cfg!(feature = "input-opencv") {
-        cap = CaptureAPIBackend::OpenCv;
+        cap = ApiBackend::OpenCv;
     }
-    if cap == CaptureAPIBackend::Auto {
+    if cap == ApiBackend::Auto {
         return None;
     }
     Some(cap)
@@ -505,15 +434,15 @@ macro_rules! cap_impl_fn {
         $(
             paste::paste! {
                 #[cfg ($cfg) ]
-                fn [< init_ $backend_name>](idx: usize, setting: Option<CameraFormat>) -> Option<Result<Box<dyn CaptureBackendTrait>, NokhwaError>> {
+                fn [< init_ $backend_name>](idx: &CameraIndex, setting: RequestedFormat) -> Option<Result<Box<dyn CaptureBackendTrait>, NokhwaError>> {
                     use crate::backends::capture::$backend;
                     match <$backend>::$init_fn(idx, setting) {
-                        Ok(cap) => Some(Ok(Box::new(cap))),
+                        Ok(cap) => Some(Ok(cap.into())),
                         Err(why) => Some(Err(why)),
                     }
                 }
                 #[cfg(not( $cfg ))]
-                fn [< init_ $backend_name>](_idx: usize, _setting: Option<CameraFormat>) -> Option<Result<Box<dyn CaptureBackendTrait>, NokhwaError>> {
+                fn [< init_ $backend_name>](_idx: &CameraIndex, _setting: RequestedFormat) -> Option<Result<Box<dyn CaptureBackendTrait>, NokhwaError>> {
                     None
                 }
             }
@@ -530,10 +459,10 @@ macro_rules! cap_impl_matches {
             let i = $index;
             let s = $setting;
             match $use_backend {
-                CaptureAPIBackend::Auto => match figure_out_auto() {
+                ApiBackend::Auto => match figure_out_auto() {
                     Some(cap) => match cap {
                         $(
-                            CaptureAPIBackend::$backend => {
+                            ApiBackend::$backend => {
                                 match cfg!(feature = $feature) {
                                     true => {
                                         match $fn(i,s) {
@@ -569,7 +498,7 @@ macro_rules! cap_impl_matches {
                     }
                 }
                 $(
-                    CaptureAPIBackend::$backend => {
+                    ApiBackend::$backend => {
                         match cfg!(feature = $feature) {
                             true => {
                                 match $fn(i,s) {
@@ -604,8 +533,8 @@ macro_rules! cap_impl_matches {
 }
 
 cap_impl_fn! {
-    (GStreamerCaptureDevice, new, feature = "input-gst", gst),
-    (OpenCvCaptureDevice, new_autopref, feature = "input-opencv", opencv),
+    // (GStreamerCaptureDevice, new, feature = "input-gst", gst),
+    (OpenCvCaptureDevice, new, feature = "input-opencv", opencv),
     // (UVCCaptureDevice, create, feature = "input-uvc", uvc),
     (V4LCaptureDevice, new, all(feature = "input-v4l", target_os = "linux"), v4l),
     (MediaFoundationCaptureDevice, new, all(feature = "input-msmf", target_os = "windows"), msmf),
@@ -613,17 +542,15 @@ cap_impl_fn! {
 }
 
 fn init_camera(
-    index: usize,
-    format: Option<CameraFormat>,
-    backend: CaptureAPIBackend,
+    index: &CameraIndex,
+    format: RequestedFormat,
+    backend: ApiBackend,
 ) -> Result<Box<dyn CaptureBackendTrait>, NokhwaError> {
     let camera_backend = cap_impl_matches! {
             backend, index, format,
             ("input-v4l", Video4Linux, init_v4l),
             ("input-msmf", MediaFoundation, init_msmf),
             ("input-avfoundation", AVFoundation, init_avfoundation),
-            // ("input-uvc", UniversalVideoClass, init_uvc),
-            ("input-gst", GStreamer, init_gst),
             ("input-opencv", OpenCv, init_opencv)
     };
     Ok(camera_backend)
diff --git a/src/error.rs b/src/error.rs
deleted file mode 100644
index 7f776ff..0000000
--- a/src/error.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use crate::{CaptureAPIBackend, FrameFormat};
-use thiserror::Error;
-
-/// All errors in `nokhwa`.
-#[allow(clippy::module_name_repetitions)]
-#[derive(Error, Debug, Clone)]
-pub enum NokhwaError {
-    #[error("Could not initialize {backend}: {error}")]
-    InitializeError {
-        backend: CaptureAPIBackend,
-        error: String,
-    },
-    #[error("Could not shutdown {backend}: {error}")]
-    ShutdownError {
-        backend: CaptureAPIBackend,
-        error: String,
-    },
-    #[error("Error: {0}")]
-    GeneralError(String),
-    #[error("Could not generate required structure {structure}: {error}")]
-    StructureError { structure: String, error: String },
-    #[error("Could not open device {0}: {1}")]
-    OpenDeviceError(String, String),
-    #[error("Could not get device property {property}: {error}")]
-    GetPropertyError { property: String, error: String },
-    #[error("Could not set device property {property} with value {value}: {error}")]
-    SetPropertyError {
-        property: String,
-        value: String,
-        error: String,
-    },
-    #[error("Could not open device stream: {0}")]
-    OpenStreamError(String),
-    #[error("Could not capture frame: {0}")]
-    ReadFrameError(String),
-    #[error("Could not process frame {src} to {destination}: {error}")]
-    ProcessFrameError {
-        src: FrameFormat,
-        destination: String,
-        error: String,
-    },
-    #[error("Could not stop stream: {0}")]
-    StreamShutdownError(String),
-    #[error("This operation is not supported by backend {0}.")]
-    UnsupportedOperationError(CaptureAPIBackend),
-    #[error("This operation is not implemented yet: {0}")]
-    NotImplementedError(String),
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-use nokhwa_bindings_windows::BindingError;
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<BindingError> for NokhwaError {
-    fn from(err: BindingError) -> Self {
-        match err {
-            BindingError::InitializeError(error) => NokhwaError::InitializeError {
-                backend: CaptureAPIBackend::MediaFoundation,
-                error,
-            },
-            BindingError::DeInitializeError(error) => NokhwaError::ShutdownError {
-                backend: CaptureAPIBackend::MediaFoundation,
-                error,
-            },
-            BindingError::GUIDSetError(property, value, error) => NokhwaError::SetPropertyError {
-                property,
-                value,
-                error,
-            },
-            BindingError::GUIDReadError(property, error) => {
-                NokhwaError::GetPropertyError { property, error }
-            }
-            BindingError::AttributeError(error) => NokhwaError::StructureError {
-                structure: "IMFAttribute".to_string(),
-                error,
-            },
-            BindingError::EnumerateError(error) => NokhwaError::GetPropertyError {
-                property: "Devices".to_string(),
-                error,
-            },
-            BindingError::DeviceOpenFailError(device, error) => {
-                NokhwaError::OpenDeviceError(device, error)
-            }
-            BindingError::ReadFrameError(error) => NokhwaError::ReadFrameError(error),
-            BindingError::NotImplementedError => {
-                NokhwaError::NotImplementedError("Docs-Only MediaFoundation".to_string())
-            }
-        }
-    }
-}
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-use nokhwa_bindings_macos::AVFError;
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-impl From<AVFError> for NokhwaError {
-    fn from(avf_error: AVFError) -> Self {
-        match avf_error {
-            AVFError::InvalidType { expected, found } => NokhwaError::GetPropertyError {
-                property: format!("type of {}", expected),
-                error: format!("Invalid type, found {}", found),
-            },
-            AVFError::InvalidValue { found } => NokhwaError::GetPropertyError {
-                property: found,
-                error: "Invalid Value".to_string(),
-            },
-            AVFError::AlreadyBusy(why) => {
-                NokhwaError::GeneralError(format!("Already Busy: {}", why))
-            }
-            AVFError::FailedToOpenDevice { index, why } => {
-                NokhwaError::OpenDeviceError(index.to_string(), why)
-            }
-            AVFError::ConfigNotAccepted => NokhwaError::SetPropertyError {
-                property: "Configuration".to_string(),
-                value: "Invalid".to_string(),
-                error: "Rejected by AVFoundation".to_string(),
-            },
-            AVFError::General(why) => {
-                NokhwaError::GeneralError(format!("AVFoundation Error: {}", why))
-            }
-            AVFError::RejectedInput => {
-                NokhwaError::OpenStreamError("AVFoundation Input Rejection".to_string())
-            }
-            AVFError::RejectedOutput => {
-                NokhwaError::OpenStreamError("AVFoundation Output Rejection".to_string())
-            }
-            AVFError::StreamOpen(why) => NokhwaError::OpenStreamError(why),
-            AVFError::ReadFrame(why) => NokhwaError::ReadFrameError(why),
-            AVFError::NotSupported => {
-                NokhwaError::UnsupportedOperationError(CaptureAPIBackend::AVFoundation)
-            }
-        }
-    }
-}
diff --git a/src/init.rs b/src/init.rs
index 13e4266..61dc15a 100644
--- a/src/init.rs
+++ b/src/init.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@
     feature = "input-avfoundation",
     any(target_os = "macos", target_os = "ios")
 )))]
-fn init_avfoundation(callback: fn(bool)) {
+fn init_avfoundation(callback: impl Fn(bool) + Send + 'static) {
     callback(true);
 }
 
@@ -26,10 +26,11 @@ fn init_avfoundation(callback: fn(bool)) {
     feature = "input-avfoundation",
     any(target_os = "macos", target_os = "ios")
 ))]
-fn init_avfoundation(callback: fn(bool)) {
-    use nokhwa_bindings_macos::avfoundation::request_permission_with_callback;
+fn init_avfoundation(callback: impl Fn(bool) + Send + Sync + 'static) {
+    use nokhwa_bindings_macos::request_permission_with_callback;
 
-    request_permission_with_callback(callback);
+    let boxed: Box<dyn Fn(bool) + Send + Sync + 'static> = Box::new(callback);
+    request_permission_with_callback(boxed);
 }
 
 #[cfg(not(all(
@@ -45,9 +46,7 @@ fn status_avfoundation() -> bool {
     any(target_os = "macos", target_os = "ios")
 ))]
 fn status_avfoundation() -> bool {
-    use nokhwa_bindings_macos::avfoundation::{
-        current_authorization_status, AVAuthorizationStatus,
-    };
+    use nokhwa_bindings_macos::{current_authorization_status, AVAuthorizationStatus};
 
     matches!(
         current_authorization_status(),
@@ -60,7 +59,7 @@ fn status_avfoundation() -> bool {
 ///
 /// The `on_complete` is called after initialization (a.k.a User granted permission). The callback's argument
 /// is weather the initialization was successful or not
-pub fn nokhwa_initialize(on_complete: fn(bool)) {
+pub fn nokhwa_initialize(on_complete: impl Fn(bool) + Send + Sync + 'static) {
     init_avfoundation(on_complete);
 }
 
diff --git a/src/js_camera.rs b/src/js_camera.rs
index e7d8eaa..a56c65a 100644
--- a/src/js_camera.rs
+++ b/src/js_camera.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,19 +20,24 @@
 //!
 //! This assumes that you are running a modern browser on the desktop.
 
-use crate::{CameraInfo, NokhwaError, Resolution};
 use image::{buffer::ConvertBuffer, ImageBuffer, Rgb, RgbImage, Rgba};
+#[cfg(feature = "output-wasm")]
 use js_sys::{Array, JsString, Map, Object, Promise};
+use nokhwa_core::{
+    error::NokhwaError,
+    types::{CameraIndex, CameraInfo, Resolution},
+};
 use std::{
-    borrow::Cow,
+    borrow::{Borrow, Cow},
     convert::TryFrom,
     fmt::{Debug, Display, Formatter},
     ops::Deref,
 };
 #[cfg(feature = "output-wasm")]
-use wasm_bindgen::prelude::wasm_bindgen;
-use wasm_bindgen::{JsCast, JsValue};
+use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue};
+#[cfg(feature = "output-wasm")]
 use wasm_bindgen_futures::JsFuture;
+#[cfg(feature = "output-wasm")]
 use web_sys::{
     console::log_1, CanvasRenderingContext2d, Document, Element, HtmlCanvasElement,
     HtmlVideoElement, ImageData, MediaDeviceInfo, MediaDeviceKind, MediaDevices, MediaStream,
@@ -287,14 +292,18 @@ pub async fn query_js_cameras() -> Result<Vec<CameraInfo>, NokhwaError> {
                                                 MediaStreamTrack::from(first).label()
                                             };
                                             device_list.push(CameraInfo::new(
-                                                name,
-                                                format!("{:?}", media_device_info.kind()),
-                                                format!(
+                                                &name,
+                                                &format!("{:?}", media_device_info.kind()),
+                                                &format!(
                                                     "{} {}",
                                                     media_device_info.group_id(),
                                                     media_device_info.device_id()
                                                 ),
-                                                idx_device as usize,
+                                                CameraIndex::String(format!(
+                                                    "{} {}",
+                                                    media_device_info.group_id(),
+                                                    media_device_info.device_id()
+                                                )),
                                             ));
                                             tracks
                                                 .iter()
@@ -303,18 +312,22 @@ pub async fn query_js_cameras() -> Result<Vec<CameraInfo>, NokhwaError> {
                                     }
                                     Err(_) => {
                                         device_list.push(CameraInfo::new(
-                                            format!(
+                                            &format!(
                                                 "{:?}#{}",
                                                 media_device_info.kind(),
                                                 idx_device
                                             ),
-                                            format!("{:?}", media_device_info.kind()),
-                                            format!(
+                                            &format!("{:?}", media_device_info.kind()),
+                                            &format!(
                                                 "{} {}",
                                                 media_device_info.group_id(),
                                                 media_device_info.device_id()
                                             ),
-                                            idx_device as usize,
+                                            CameraIndex::String(format!(
+                                                "{} {}",
+                                                media_device_info.group_id(),
+                                                media_device_info.device_id()
+                                            )),
                                         ));
                                     }
                                 }
@@ -1666,6 +1679,7 @@ impl Deref for JSCameraConstraints {
 /// A wrapper around a [`MediaStream`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.MediaStream.html)
 /// # JS-WASM
 /// This is exported as `NokhwaCamera`.
+#[cfg(feature = "output-wasm")]
 #[cfg_attr(feature = "output-wasm", wasm_bindgen(js_name = NokhwaCamera))]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-jscam")))]
 pub struct JSCamera {
@@ -1678,6 +1692,7 @@ pub struct JSCamera {
     canvas_context: Option<CanvasRenderingContext2d>,
 }
 
+#[cfg(feature = "output-wasm")]
 #[cfg_attr(feature = "output-wasm", wasm_bindgen(js_class = NokhwaCamera))]
 impl JSCamera {
     /// Creates a new [`JSCamera`] using [`JSCameraConstraints`].
@@ -2544,7 +2559,7 @@ impl JSCamera {
         let resolution = self.resolution();
         let frame = self.frame_raw()?;
         if convert_rgba {
-            buffer.copy_from_slice(&frame);
+            buffer.copy_from_slice(frame.borrow());
             return Ok(frame.len());
         }
         let image = match ImageBuffer::from_raw(resolution.width(), resolution.height(), frame) {
@@ -2611,7 +2626,7 @@ impl JSCamera {
                 origin: wgpu::Origin3d::ZERO,
                 aspect: TextureAspect::All,
             },
-            &frame,
+            frame.borrow(),
             ImageDataLayout {
                 offset: 0,
                 bytes_per_row: width_nonzero,
@@ -2704,3 +2719,7 @@ impl Drop for JSCamera {
         self.stop_all().unwrap_or(()); // swallow errors
     }
 }
+
+// SAFETY: JSCamera is used in WASM, it will never be sent to a different thread. This is only done to satisfy the compiler.
+#[allow(clippy::non_send_fields_in_send_ty)]
+unsafe impl Send for JSCamera {}
diff --git a/src/lib.rs b/src/lib.rs
index 4773890..1042a08 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,8 @@
+#![deny(clippy::pedantic)]
+#![warn(clippy::all)]
+#![allow(clippy::module_name_repetitions)]
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +18,6 @@
  */
 #![cfg_attr(feature = "test-fail-warning", deny(warnings))]
 #![cfg_attr(feature = "docs-features", feature(doc_cfg))]
-
 //! # nokhwa
 //! A Simple-to-use, cross-platform Rust Webcam Capture Library
 //!
@@ -25,43 +27,57 @@
 //!
 //! Please read the README for more.
 
-#[cfg(feature = "small-wasm")]
-#[global_allocator]
-static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
-
 /// Raw access to each of Nokhwa's backends.
 pub mod backends;
 mod camera;
-mod camera_traits;
-mod error;
 mod init;
 /// A camera that uses native browser APIs meant for WASM applications.
 #[cfg(feature = "input-jscam")]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-jscam")))]
 pub mod js_camera;
-/// A camera that uses `OpenCV` to access IP (rtsp/http) on the local network
-#[cfg(feature = "input-ipcam")]
-#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-ipcam")))]
-pub mod network_camera;
+
+pub use nokhwa_core::pixel_format::FormatDecoder;
 mod query;
 /// A camera that runs in a different thread and can call your code based on callbacks.
 #[cfg(feature = "output-threaded")]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "output-threaded")))]
-mod threaded;
-mod utils;
+pub mod threaded;
 
+#[cfg(feature = "input-ipcam")]
+#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-ipcam")))]
+#[deprecated(
+    since = "0.10.0",
+    note = "please use `Camera` with `CameraIndex::String` and `input-opencv` enabled."
+)]
+pub use backends::capture::NetworkCamera;
 pub use camera::Camera;
-pub use camera_traits::*;
-pub use error::NokhwaError;
 pub use init::*;
 #[cfg(feature = "input-jscam")]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-jscam")))]
 pub use js_camera::JSCamera;
-#[cfg(feature = "input-ipcam")]
-#[cfg_attr(feature = "docs-features", doc(cfg(feature = "input-ipcam")))]
-pub use network_camera::NetworkCamera;
+pub use nokhwa_core::buffer::Buffer;
+pub use nokhwa_core::error::NokhwaError;
 pub use query::*;
 #[cfg(feature = "output-threaded")]
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "output-threaded")))]
-pub use threaded::ThreadedCamera;
-pub use utils::*;
+pub use threaded::CallbackCamera;
+
+pub mod utils {
+    pub use nokhwa_core::types::*;
+}
+
+pub mod error {
+    pub use nokhwa_core::error::NokhwaError;
+}
+
+pub mod camera_traits {
+    pub use nokhwa_core::traits::*;
+}
+
+pub mod pixel_format {
+    pub use nokhwa_core::pixel_format::*;
+}
+
+pub mod buffer {
+    pub use nokhwa_core::buffer::*;
+}
diff --git a/src/query.rs b/src/query.rs
index 3a8abd5..9bae283 100644
--- a/src/query.rs
+++ b/src/query.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,105 +14,83 @@
  * limitations under the License.
  */
 
-use crate::{CameraInfo, CaptureAPIBackend, NokhwaError};
-
-/// Query the system for a list of available devices.
-/// Usually the order goes Native -> UVC -> Gstreamer.
-/// # Quirks
-/// - Media Foundation: The symbolic link for the device is listed in the `misc` attribute of the [`CameraInfo`].
-/// - Media Foundation: The names may contain invalid characters since they were converted from UTF16.
-/// - AVFoundation: The ID of the device is stored in the `misc` attribute of the [`CameraInfo`].
-/// - AVFoundation: There is lots of miscellaneous info in the `desc` attribute.
-/// # Errors
-/// If you use an unsupported API (check the README or crate root for more info), incompatible backend for current platform, incompatible platform, or insufficient permissions, etc
-/// this will error.
-pub fn query() -> Result<Vec<CameraInfo>, NokhwaError> {
-    query_devices(CaptureAPIBackend::Auto)
-}
+use nokhwa_core::{
+    error::NokhwaError,
+    types::{ApiBackend, CameraInfo},
+};
 
 // TODO: Update as this goes
 /// Query the system for a list of available devices. Please refer to the API Backends that support `Query`) <br>
-/// Currently, these are `V4L`, `MediaFoundation`, `AVFoundation`, `UVC`, and `GST`. <br>
 /// Usually the order goes Native -> UVC -> Gstreamer.
 /// # Quirks
-/// - Media Foundation: The symbolic link for the device is listed in the `misc` attribute of the [`CameraInfo`].
-/// - Media Foundation: The names may contain invalid characters since they were converted from UTF16.
-/// - AVFoundation: The ID of the device is stored in the `misc` attribute of the [`CameraInfo`].
-/// - AVFoundation: There is lots of miscellaneous info in the `desc` attribute.
+/// - `Media Foundation`: The symbolic link for the device is listed in the `misc` attribute of the [`CameraInfo`].
+/// - `Media Foundation`: The names may contain invalid characters since they were converted from UTF16.
+/// - `AVFoundation`: The ID of the device is stored in the `misc` attribute of the [`CameraInfo`].
+/// - `AVFoundation`: There is lots of miscellaneous info in the `desc` attribute.
+/// - `WASM`: The `misc` field contains the device ID and group ID are seperated by a space (' ')
 /// # Errors
 /// If you use an unsupported API (check the README or crate root for more info), incompatible backend for current platform, incompatible platform, or insufficient permissions, etc
 /// this will error.
-#[allow(clippy::module_name_repetitions)]
-pub fn query_devices(api: CaptureAPIBackend) -> Result<Vec<CameraInfo>, NokhwaError> {
+pub fn query(api: ApiBackend) -> Result<Vec<CameraInfo>, NokhwaError> {
     match api {
-        CaptureAPIBackend::Auto => {
+        ApiBackend::Auto => {
             // determine platform
             match std::env::consts::OS {
                 "linux" => {
                     if cfg!(feature = "input-v4l") && cfg!(target_os = "linux") {
-                        query_devices(CaptureAPIBackend::Video4Linux)
-                    } else if cfg!(feature = "input-uvc") {
-                        query_devices(CaptureAPIBackend::UniversalVideoClass)
-                    } else if cfg!(feature = "input-gstreamer") {
-                        query_devices(CaptureAPIBackend::GStreamer)
+                        query(ApiBackend::Video4Linux)
                     } else if cfg!(feature = "input-opencv") {
-                        query_devices(CaptureAPIBackend::OpenCv)
+                        query(ApiBackend::OpenCv)
                     } else {
-                        Err(NokhwaError::UnsupportedOperationError(
-                            CaptureAPIBackend::Auto,
-                        ))
+                        dbg!("Error: No suitable Backends availible. Perhaps you meant to enable one of the backends such as `input-v4l`? (Please read the docs.)");
+                        Err(NokhwaError::UnsupportedOperationError(ApiBackend::Auto))
                     }
                 }
                 "windows" => {
                     if cfg!(feature = "input-msmf") && cfg!(target_os = "windows") {
-                        query_devices(CaptureAPIBackend::MediaFoundation)
-                    } else if cfg!(feature = "input-uvc") {
-                        query_devices(CaptureAPIBackend::UniversalVideoClass)
-                    } else if cfg!(feature = "input-gstreamer") {
-                        query_devices(CaptureAPIBackend::GStreamer)
+                        query(ApiBackend::MediaFoundation)
                     } else if cfg!(feature = "input-opencv") {
-                        query_devices(CaptureAPIBackend::OpenCv)
+                        query(ApiBackend::OpenCv)
                     } else {
-                        Err(NokhwaError::UnsupportedOperationError(
-                            CaptureAPIBackend::Auto,
-                        ))
+                        dbg!("Error: No suitable Backends availible. Perhaps you meant to enable one of the backends such as `input-msmf`? (Please read the docs.)");
+                        Err(NokhwaError::UnsupportedOperationError(ApiBackend::Auto))
                     }
                 }
                 "macos" => {
                     if cfg!(feature = "input-avfoundation") {
-                        query_devices(CaptureAPIBackend::AVFoundation)
-                    } else if cfg!(feature = "input-uvc") {
-                        query_devices(CaptureAPIBackend::UniversalVideoClass)
-                    } else if cfg!(feature = "input-gstreamer") {
-                        query_devices(CaptureAPIBackend::GStreamer)
+                        query(ApiBackend::AVFoundation)
                     } else if cfg!(feature = "input-opencv") {
-                        query_devices(CaptureAPIBackend::OpenCv)
+                        query(ApiBackend::OpenCv)
                     } else {
-                        Err(NokhwaError::UnsupportedOperationError(
-                            CaptureAPIBackend::Auto,
-                        ))
+                        dbg!("Error: No suitable Backends availible. Perhaps you meant to enable one of the backends such as `input-avfoundation`? (Please read the docs.)");
+                        Err(NokhwaError::UnsupportedOperationError(ApiBackend::Auto))
                     }
                 }
                 "ios" => {
                     if cfg!(feature = "input-avfoundation") {
-                        query_devices(CaptureAPIBackend::AVFoundation)
+                        query(ApiBackend::AVFoundation)
                     } else {
-                        Err(NokhwaError::UnsupportedOperationError(
-                            CaptureAPIBackend::Auto,
-                        ))
+                        dbg!("Error: No suitable Backends availible. Perhaps you meant to enable one of the backends such as `input-avfoundation`? (Please read the docs.)");
+                        Err(NokhwaError::UnsupportedOperationError(ApiBackend::Auto))
                     }
                 }
-                _ => Err(NokhwaError::UnsupportedOperationError(
-                    CaptureAPIBackend::Auto,
-                )),
+                _ => {
+                    dbg!("Error: No suitable Backends availible. You are on an unsupported platform.");
+                    Err(NokhwaError::NotImplementedError("Bad Platform".to_string()))
+                }
             }
         }
-        CaptureAPIBackend::AVFoundation => query_avfoundation(),
-        CaptureAPIBackend::Video4Linux => query_v4l(),
-        CaptureAPIBackend::UniversalVideoClass => query_uvc(),
-        CaptureAPIBackend::MediaFoundation => query_msmf(),
-        CaptureAPIBackend::GStreamer => query_gstreamer(),
-        CaptureAPIBackend::OpenCv => Err(NokhwaError::UnsupportedOperationError(api)),
+        ApiBackend::AVFoundation => query_avfoundation(),
+        ApiBackend::Video4Linux => query_v4l(),
+        #[allow(deprecated)]
+        ApiBackend::UniversalVideoClass => query_uvc(),
+        ApiBackend::MediaFoundation => query_msmf(),
+        #[allow(deprecated)]
+        ApiBackend::GStreamer => query_gstreamer(),
+        ApiBackend::OpenCv | ApiBackend::Network => {
+            Err(NokhwaError::UnsupportedOperationError(api))
+        }
+        ApiBackend::Browser => query_wasm(),
     }
 }
 
@@ -120,17 +98,20 @@ pub fn query_devices(api: CaptureAPIBackend) -> Result<Vec<CameraInfo>, NokhwaEr
 
 #[cfg(all(feature = "input-v4l", target_os = "linux"))]
 #[allow(clippy::unnecessary_wraps)]
+#[allow(clippy::cast_possible_truncation)]
 fn query_v4l() -> Result<Vec<CameraInfo>, NokhwaError> {
+    use crate::CameraIndex;
     Ok({
         let camera_info: Vec<CameraInfo> = v4l::context::enum_devices()
             .iter()
             .map(|node| {
                 CameraInfo::new(
-                    node.name()
+                    &node
+                        .name()
                         .unwrap_or(format!("{}", node.path().to_string_lossy())),
-                    format!("Video4Linux Device @ {}", node.path().to_string_lossy()),
-                    "".to_string(),
-                    node.index(),
+                    &format!("Video4Linux Device @ {}", node.path().to_string_lossy()),
+                    &"".to_string(),
+                    CameraIndex::Index(node.index() as u32),
                 )
             })
             .collect();
@@ -141,13 +122,15 @@ fn query_v4l() -> Result<Vec<CameraInfo>, NokhwaError> {
 #[cfg(any(not(feature = "input-v4l"), not(target_os = "linux")))]
 fn query_v4l() -> Result<Vec<CameraInfo>, NokhwaError> {
     Err(NokhwaError::UnsupportedOperationError(
-        CaptureAPIBackend::Video4Linux,
+        ApiBackend::Video4Linux,
     ))
 }
 
 #[cfg(feature = "input-uvc")]
 fn query_uvc() -> Result<Vec<CameraInfo>, NokhwaError> {
+    use crate::CameraIndex;
     use uvc::Device;
+
     let context = match uvc::Context::new() {
         Ok(ctx) => ctx,
         Err(why) => {
@@ -205,7 +188,7 @@ fn query_uvc() -> Result<Vec<CameraInfo>, NokhwaError> {
                             desc.product_id,
                             desc.serial_number.unwrap_or_else(|| "".to_string())
                         ),
-                        counter,
+                        CameraIndex::Index(counter as u32),
                     ));
                     counter += 1;
                 }
@@ -216,14 +199,16 @@ fn query_uvc() -> Result<Vec<CameraInfo>, NokhwaError> {
 }
 
 #[cfg(not(feature = "input-uvc"))]
+#[allow(deprecated)]
 fn query_uvc() -> Result<Vec<CameraInfo>, NokhwaError> {
     Err(NokhwaError::UnsupportedOperationError(
-        CaptureAPIBackend::UniversalVideoClass,
+        ApiBackend::UniversalVideoClass,
     ))
 }
 
 #[cfg(feature = "input-gst")]
 fn query_gstreamer() -> Result<Vec<CameraInfo>, NokhwaError> {
+    use crate::CameraIndex;
     use gstreamer::{
         prelude::{DeviceExt, DeviceMonitorExt, DeviceMonitorExtManual},
         Caps, DeviceMonitor,
@@ -269,12 +254,7 @@ fn query_gstreamer() -> Result<Vec<CameraInfo>, NokhwaError> {
             let name = DeviceExt::display_name(gst_dev);
             let class = DeviceExt::device_class(gst_dev);
             counter += 1;
-            CameraInfo::new(
-                name.to_string(),
-                class.to_string(),
-                "".to_string(),
-                counter - 1,
-            )
+            CameraInfo::new(&name, &class, "", CameraIndex::Index(counter - 1))
         })
         .collect();
     device_monitor.stop();
@@ -282,15 +262,16 @@ fn query_gstreamer() -> Result<Vec<CameraInfo>, NokhwaError> {
 }
 
 #[cfg(not(feature = "input-gst"))]
+#[allow(deprecated)]
 fn query_gstreamer() -> Result<Vec<CameraInfo>, NokhwaError> {
     Err(NokhwaError::UnsupportedOperationError(
-        CaptureAPIBackend::GStreamer,
+        ApiBackend::GStreamer,
     ))
 }
 
 // please refer to https://docs.microsoft.com/en-us/windows/win32/medfound/enumerating-video-capture-devices
 #[cfg(all(feature = "input-msmf", target_os = "windows"))]
-fn query_msmf() -> Result<Vec<CameraInfo>, NokhwaError> {
+fn query_msmf<'a>() -> Result<Vec<CameraInfo<'a>>, NokhwaError> {
     let list: Vec<CameraInfo> =
         match nokhwa_bindings_windows::wmf::query_media_foundation_descriptors() {
             Ok(l) => l
@@ -308,7 +289,7 @@ fn query_msmf() -> Result<Vec<CameraInfo>, NokhwaError> {
 #[cfg(any(not(feature = "input-msmf"), not(target_os = "windows")))]
 fn query_msmf() -> Result<Vec<CameraInfo>, NokhwaError> {
     Err(NokhwaError::UnsupportedOperationError(
-        CaptureAPIBackend::MediaFoundation,
+        ApiBackend::MediaFoundation,
     ))
 }
 
@@ -317,11 +298,10 @@ fn query_msmf() -> Result<Vec<CameraInfo>, NokhwaError> {
     any(target_os = "macos", target_os = "ios")
 ))]
 fn query_avfoundation() -> Result<Vec<CameraInfo>, NokhwaError> {
-    use nokhwa_bindings_macos::avfoundation::query_avfoundation as q_avf;
+    use nokhwa_bindings_macos::query_avfoundation;
 
-    Ok(q_avf()?
+    Ok(query_avfoundation()?
         .into_iter()
-        .map(CameraInfo::from)
         .collect::<Vec<CameraInfo>>())
 }
 
@@ -331,6 +311,19 @@ fn query_avfoundation() -> Result<Vec<CameraInfo>, NokhwaError> {
 )))]
 fn query_avfoundation() -> Result<Vec<CameraInfo>, NokhwaError> {
     Err(NokhwaError::UnsupportedOperationError(
-        CaptureAPIBackend::AVFoundation,
+        ApiBackend::AVFoundation,
     ))
 }
+
+#[cfg(feature = "input-jscam")]
+fn query_wasm() -> Result<Vec<CameraInfo>, NokhwaError> {
+    use crate::js_camera::query_js_cameras;
+    use wasm_rs_async_executor::single_threaded::block_on;
+
+    block_on(query_js_cameras())
+}
+
+#[cfg(not(feature = "input-jscam"))]
+fn query_wasm() -> Result<Vec<CameraInfo>, NokhwaError> {
+    Err(NokhwaError::UnsupportedOperationError(ApiBackend::Browser))
+}
diff --git a/src/threaded.rs b/src/threaded.rs
index 2046e32..ae4f5d3 100644
--- a/src/threaded.rs
+++ b/src/threaded.rs
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
+ * Copyright 2022 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,24 +14,37 @@
  * limitations under the License.
  */
 
-use crate::{
-    Camera, CameraControl, CameraFormat, CameraInfo, CaptureAPIBackend, FrameFormat,
-    KnownCameraControls, NokhwaError, Resolution,
-};
+use crate::Camera;
 use image::{ImageBuffer, Rgb};
-use parking_lot::FairMutex;
+use nokhwa_core::{
+    buffer::Buffer,
+    error::NokhwaError,
+    traits::CaptureBackendTrait,
+    types::{
+        ApiBackend, CameraControl, CameraFormat, CameraIndex, CameraInfo, ControlValueSetter,
+        FrameFormat, KnownCameraControl, RequestedFormat, Resolution,
+    },
+};
 use std::{
     any::Any,
     collections::HashMap,
-    ops::Deref,
     sync::{
         atomic::{AtomicBool, Ordering},
-        Arc,
+        Arc, Mutex,
     },
 };
 
+type AtomicLock<T> = Arc<Mutex<T>>;
+pub type CallbackFn = fn(
+    _camera: &Arc<Mutex<Camera>>,
+    _frame_callback: &Arc<Mutex<Option<Box<dyn FnMut(Buffer) + Send + 'static>>>>,
+    _last_frame_captured: &Arc<Mutex<Buffer>>,
+    _die_bool: &Arc<AtomicBool>,
+);
+type HeldCallbackType = Arc<Mutex<Box<dyn FnMut(Buffer) + Send + 'static>>>;
+
 /// Creates a camera that runs in a different thread that you can use a callback to access the frames of.
-/// It uses a `Arc` and a `FairMutex` to ensure that this feels like a normal camera, but callback based.
+/// It uses a `Arc` and a `Mutex` to ensure that this feels like a normal camera, but callback based.
 /// See [`Camera`] for more details on the camera itself.
 ///
 /// Your function is called every time there is a new frame. In order to avoid frame loss, it should
@@ -43,106 +56,39 @@ use std::{
 /// The `Mutex` guarantees exclusive access to the underlying camera struct. They should be safe to
 /// impl `Send` on.
 #[cfg_attr(feature = "docs-features", doc(cfg(feature = "output-threaded")))]
-#[derive(Clone)]
-pub struct ThreadedCamera {
-    camera: Arc<FairMutex<Camera>>,
-    frame_callback: Arc<FairMutex<Option<fn(ImageBuffer<Rgb<u8>, Vec<u8>>)>>>,
-    last_frame_captured: Arc<FairMutex<ImageBuffer<Rgb<u8>, Vec<u8>>>>,
+pub struct CallbackCamera {
+    camera: AtomicLock<Camera>,
+    frame_callback: HeldCallbackType,
+    last_frame_captured: AtomicLock<Buffer>,
     die_bool: Arc<AtomicBool>,
 }
 
-impl ThreadedCamera {
+impl CallbackCamera {
     /// Create a new `ThreadedCamera` from an `index` and `format`. `format` can be `None`.
     /// # Errors
     /// This will error if you either have a bad platform configuration (e.g. `input-v4l` but not on linux) or the backend cannot create the camera (e.g. permission denied).
-    pub fn new(index: usize, format: Option<CameraFormat>) -> Result<Self, NokhwaError> {
-        ThreadedCamera::with_backend(index, format, CaptureAPIBackend::Auto)
-    }
-
-    /// Create a new camera from an `index`, `format`, and `backend`. `format` can be `None`.
-    /// # Errors
-    /// This will error if you either have a bad platform configuration (e.g. `input-v4l` but not on linux) or the backend cannot create the camera (e.g. permission denied).
-    pub fn with_backend(
-        index: usize,
-        format: Option<CameraFormat>,
-        backend: CaptureAPIBackend,
+    pub fn new(
+        index: CameraIndex,
+        format: RequestedFormat,
+        callback: impl FnMut(Buffer) + Send + 'static,
     ) -> Result<Self, NokhwaError> {
-        Self::customized_all(index, format, backend, None)
-    }
-
-    /// Create a new `ThreadedCamera` from raw values.
-    /// # Errors
-    /// This will error if you either have a bad platform configuration (e.g. `input-v4l` but not on linux) or the backend cannot create the camera (e.g. permission denied).
-    pub fn new_with(
-        index: usize,
-        width: u32,
-        height: u32,
-        fps: u32,
-        fourcc: FrameFormat,
-        backend: CaptureAPIBackend,
-    ) -> Result<Self, NokhwaError> {
-        let camera_format = CameraFormat::new_from(width, height, fourcc, fps);
-        ThreadedCamera::with_backend(index, Some(camera_format), backend)
-    }
-
-    /// Create a new `ThreadedCamera` from raw values, including the raw capture function.
-    ///
-    /// **This is meant for advanced users only.**
-    ///
-    /// An example capture function can be found by clicking `[src]` and scrolling down to the bottom to function `camera_frame_thread_loop()`.
-    /// # Errors
-    /// This will error if you either have a bad platform configuration (e.g. `input-v4l` but not on linux) or the backend cannot create the camera (e.g. permission denied).
-    pub fn customized_all(
-        index: usize,
-        format: Option<CameraFormat>,
-        backend: CaptureAPIBackend,
-        func: Option<
-            fn(
-                _: Arc<FairMutex<Camera>>,
-                _: Arc<FairMutex<Option<fn(ImageBuffer<Rgb<u8>, Vec<u8>>)>>>,
-                _: Arc<FairMutex<ImageBuffer<Rgb<u8>, Vec<u8>>>>,
-                _: Arc<AtomicBool>,
-            ),
-        >,
-    ) -> Result<Self, NokhwaError> {
-        let camera = Arc::new(FairMutex::new(Camera::with_backend(
-            index, format, backend,
-        )?));
-        let format = match format {
-            Some(fmt) => fmt,
-            None => CameraFormat::default(),
-        };
-        let frame_callback = Arc::new(FairMutex::new(None));
-        let die_bool = Arc::new(AtomicBool::new(false));
-        let holding_cell = Arc::new(FairMutex::new(ImageBuffer::new(
-            format.width(),
-            format.height(),
-        )));
-
-        let die_clone = die_bool.clone();
-        let camera_clone = camera.clone();
-        let callback_clone = frame_callback.clone();
-        let holding_cell_clone = holding_cell.clone();
-        let func = match func {
-            Some(f) => f,
-            None => camera_frame_thread_loop,
-        };
-        std::thread::spawn(move || {
-            func(camera_clone, callback_clone, holding_cell_clone, die_clone)
-        });
-
-        Ok(ThreadedCamera {
-            camera,
-            frame_callback,
-            last_frame_captured: holding_cell,
-            die_bool,
+        let arc_camera = Arc::new(Mutex::new(Camera::new(index, format)?));
+        Ok(CallbackCamera {
+            camera: arc_camera,
+            frame_callback: Arc::new(Mutex::new(Box::new(callback))),
+            last_frame_captured: Arc::new(Mutex::new(Buffer::new_with_vec(
+                Resolution::new(0, 0),
+                &vec![],
+                FrameFormat::GRAY,
+            ))),
+            die_bool: Arc::new(Default::default()),
         })
     }
 
     /// Gets the current Camera's index.
     #[must_use]
     pub fn index(&self) -> usize {
-        self.camera.lock().index()
+        self.camera.lock().index().clone()
     }
 
     /// Sets the current Camera's index. Note that this re-initializes the camera.
@@ -154,14 +100,14 @@ impl ThreadedCamera {
 
     /// Gets the current Camera's backend
     #[must_use]
-    pub fn backend(&self) -> CaptureAPIBackend {
+    pub fn backend(&self) -> ApiBackend {
         self.camera.lock().backend()
     }
 
     /// Sets the current Camera's backend. Note that this re-initializes the camera.
     /// # Errors
     /// The new backend may not exist or may fail to initialize the new camera.
-    pub fn set_backend(&mut self, new_backend: CaptureAPIBackend) -> Result<(), NokhwaError> {
+    pub fn set_backend(&mut self, new_backend: ApiBackend) -> Result<(), NokhwaError> {
         self.camera.lock().set_backend(new_backend)
     }
 
@@ -172,8 +118,7 @@ impl ThreadedCamera {
     }
 
     /// Gets the current [`CameraFormat`].
-    #[must_use]
-    pub fn camera_format(&self) -> CameraFormat {
+    pub fn camera_format(&self) -> Result<CameraFormat, NokhwaError> {
         self.camera.lock().camera_format()
     }
 
@@ -182,7 +127,8 @@ impl ThreadedCamera {
     /// # Errors
     /// If you started the stream and the camera rejects the new camera format, this will return an error.
     pub fn set_camera_format(&mut self, new_fmt: CameraFormat) -> Result<(), NokhwaError> {
-        *self.last_frame_captured.lock() = ImageBuffer::new(new_fmt.width(), new_fmt.height());
+        *self.last_frame_captured.lock() =
+            Buffer::new(new_res, &Vec::default(), self.camera_format()?.format());
         self.camera.lock().set_camera_format(new_fmt)
     }
 
@@ -204,9 +150,15 @@ impl ThreadedCamera {
     }
 
     /// Gets the current camera resolution (See: [`Resolution`], [`CameraFormat`]).
-    #[must_use]
-    pub fn resolution(&self) -> Resolution {
-        self.camera.lock().resolution()
+    pub fn resolution(&self) -> Result<Resolution, NokhwaError> {
+        Ok(self
+            .camera
+            .lock()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "Resolution".to_string(),
+                error: why.to_string(),
+            })?
+            .resolution())
     }
 
     /// Will set the current [`Resolution`]
@@ -214,14 +166,28 @@ impl ThreadedCamera {
     /// # Errors
     /// If you started the stream and the camera rejects the new resolution, this will return an error.
     pub fn set_resolution(&mut self, new_res: Resolution) -> Result<(), NokhwaError> {
-        *self.last_frame_captured.lock() = ImageBuffer::new(new_res.width(), new_res.height());
-        self.camera.lock().set_resolution(new_res)
+        *self.last_frame_captured.lock() =
+            Buffer::new_with_vec(new_res, Vec::default(), self.camera_format()?.format());
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "Resolution".to_string(),
+                value: new_res.to_string(),
+                error: why.to_string(),
+            })?
+            .set_resolution(new_res)
     }
 
     /// Gets the current camera framerate (See: [`CameraFormat`]).
-    #[must_use]
-    pub fn frame_rate(&self) -> u32 {
-        self.camera.lock().frame_rate()
+    pub fn frame_rate(&self) -> Result<u32, NokhwaError> {
+        Ok(self
+            .camera
+            .lock()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "Framerate".to_string(),
+                error: why.to_string(),
+            })?
+            .frame_rate())
     }
 
     /// Will set the current framerate
@@ -229,13 +195,26 @@ impl ThreadedCamera {
     /// # Errors
     /// If you started the stream and the camera rejects the new framerate, this will return an error.
     pub fn set_frame_rate(&mut self, new_fps: u32) -> Result<(), NokhwaError> {
-        self.camera.lock().set_frame_rate(new_fps)
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "Framerate".to_string(),
+                value: new_fps.to_string(),
+                error: why.to_string(),
+            })?
+            .set_frame_rate(new_fps)
     }
 
     /// Gets the current camera's frame format (See: [`FrameFormat`], [`CameraFormat`]).
-    #[must_use]
-    pub fn frame_format(&self) -> FrameFormat {
-        self.camera.lock().frame_format()
+    pub fn frame_format(&self) -> Result<FrameFormat, NokhwaError> {
+        Ok(self
+            .camera
+            .lock()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "Frameformat".to_string(),
+                error: why.to_string(),
+            })?
+            .frame_format())
     }
 
     /// Will set the current [`FrameFormat`]
@@ -243,14 +222,27 @@ impl ThreadedCamera {
     /// # Errors
     /// If you started the stream and the camera rejects the new frame format, this will return an error.
     pub fn set_frame_format(&mut self, fourcc: FrameFormat) -> Result<(), NokhwaError> {
-        self.camera.lock().set_frame_format(fourcc)
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "Framerate".to_string(),
+                value: fourcc.to_string(),
+                error: why.to_string(),
+            })?
+            .set_frame_format(fourcc)
     }
 
-    /// Gets the current supported list of [`KnownCameraControls`]
+    /// Gets the current supported list of [`KnownCameraControl`]
     /// # Errors
     /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
-    pub fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControls>, NokhwaError> {
-        self.camera.lock().supported_camera_controls()
+    pub fn supported_camera_controls(&self) -> Result<Vec<KnownCameraControl>, NokhwaError> {
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "Supported Camera Controls".to_string(),
+                error: why.to_string(),
+            })
+            .supported_camera_controls()
     }
 
     /// Gets the current supported list of [`CameraControl`]s keyed by its name as a `String`.
@@ -281,7 +273,7 @@ impl ThreadedCamera {
             .collect::<Vec<(String, CameraControl)>>();
         let mut control_map = HashMap::with_capacity(maybe_camera_controls.len());
 
-        for (kc, cc) in maybe_camera_controls.into_iter() {
+        for (kc, cc) in maybe_camera_controls {
             control_map.insert(kc, cc);
         }
 
@@ -293,32 +285,38 @@ impl ThreadedCamera {
     /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
     pub fn camera_controls_known_camera_controls(
         &self,
-    ) -> Result<HashMap<KnownCameraControls, CameraControl>, NokhwaError> {
+    ) -> Result<HashMap<KnownCameraControl, CameraControl>, NokhwaError> {
         let known_controls = self.supported_camera_controls()?;
         let maybe_camera_controls = known_controls
             .iter()
             .map(|x| (*x, self.camera_control(*x)))
             .filter(|(_, x)| x.is_ok())
             .map(|(c, x)| (c, Result::unwrap(x)))
-            .collect::<Vec<(KnownCameraControls, CameraControl)>>();
+            .collect::<Vec<(KnownCameraControl, CameraControl)>>();
         let mut control_map = HashMap::with_capacity(maybe_camera_controls.len());
 
-        for (kc, cc) in maybe_camera_controls.into_iter() {
+        for (kc, cc) in maybe_camera_controls {
             control_map.insert(kc, cc);
         }
 
         Ok(control_map)
     }
 
-    /// Gets the value of [`KnownCameraControls`].
+    /// Gets the value of [`KnownCameraControl`].
     /// # Errors
     /// If the `control` is not supported or there is an error while getting the camera control values (e.g. unexpected value, too high, etc)
     /// this will error.
     pub fn camera_control(
         &self,
-        control: KnownCameraControls,
+        control: KnownCameraControl,
     ) -> Result<CameraControl, NokhwaError> {
-        self.camera.lock().camera_control(control)
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "Camera Control".to_string(),
+                error: why.to_string(),
+            })?
+            .camera_control(control)
     }
 
     /// Sets the control to `control` in the camera.
@@ -327,103 +325,114 @@ impl ThreadedCamera {
     /// # Errors
     /// If the `control` is not supported, the value is invalid (less than min, greater than max, not in step), or there was an error setting the control,
     /// this will error.
-    pub fn set_camera_control(&mut self, control: CameraControl) -> Result<(), NokhwaError> {
-        self.camera.lock().set_camera_control(control)
-    }
-
-    /// Gets the current supported list of Controls as an `Any` from the backend.
-    /// The `Any`'s type is defined by the backend itself, please check each of the backend's documentation.
-    /// # Errors
-    /// If the list cannot be collected, this will error. This can be treated as a "nothing supported".
-    pub fn raw_supported_camera_controls(&self) -> Result<Vec<Box<dyn Any>>, NokhwaError> {
-        self.camera.lock().raw_supported_camera_controls()
-    }
-
-    /// Sets the control to `control` in the camera.
-    /// The control's type is defined the backend itself. It may be a string, or more likely its a integer ID.
-    /// The backend itself has documentation of the proper input/return values, please check each of the backend's documentation.
-    /// # Errors
-    /// If the `control` is not supported or there is an error while getting the camera control values (e.g. unexpected value, too high, wrong Any type)
-    /// this will error.
-    pub fn raw_camera_control(&self, control: &dyn Any) -> Result<Box<dyn Any>, NokhwaError> {
-        self.camera.lock().raw_camera_control(control)
-    }
-
-    /// Sets the control to `control` in the camera.
-    /// The `control`/`value`'s type is defined the backend itself. It may be a string, or more likely its a integer ID/Value.
-    /// Usually, the pipeline is calling [`camera_control()`](crate::CaptureBackendTrait::camera_control()), getting a camera control that way
-    /// then calling one of the methods to set the value: [`set_value()`](CameraControl::set_value()) or [`with_value()`](CameraControl::with_value()).
-    /// # Errors
-    /// If the `control` is not supported, the value is invalid (wrong Any type, backend refusal), or there was an error setting the control,
-    /// this will error.
-    pub fn set_raw_camera_control(
+    pub fn set_camera_control(
         &mut self,
-        control: &dyn Any,
-        value: &dyn Any,
+        id: KnownCameraControl,
+        control: ControlValueSetter,
     ) -> Result<(), NokhwaError> {
-        self.camera.lock().set_raw_camera_control(control, value)
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "Camera Control".to_string(),
+                value: format!("{}: {}", id, control),
+                error: why.to_string(),
+            })?
+            .set_camera_control(id, control)
     }
 
     /// Will open the camera stream with set parameters. This will be called internally if you try and call [`frame()`](crate::Camera::frame()) before you call [`open_stream()`](crate::Camera::open_stream()).
     /// The callback will be called every frame.
     /// # Errors
     /// If the specific backend fails to open the camera (e.g. already taken, busy, doesn't exist anymore) this will error.
-    pub fn open_stream(
-        &mut self,
-        callback: fn(ImageBuffer<Rgb<u8>, Vec<u8>>),
-    ) -> Result<(), NokhwaError> {
-        *self.frame_callback.lock() = Some(callback);
-        self.camera.lock().open_stream()
+    pub fn open_stream(&mut self) -> Result<(), NokhwaError> {
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::SetPropertyError {
+                property: "camera".to_string(),
+                value: "callback".to_string(),
+                error: why.to_string(),
+            })?
+            .open_stream()
     }
 
     /// Sets the frame callback to the new specified function. This function will be called instead of the previous one(s).
-    pub fn set_callback(&mut self, callback: fn(ImageBuffer<Rgb<u8>, Vec<u8>>)) {
-        *self.frame_callback.lock() = Some(callback);
+    pub fn set_callback(
+        &mut self,
+        callback: impl FnMut(Buffer) + Send + 'static,
+    ) -> Result<(), NokhwaError> {
+        *self
+            .frame_callback
+            .lock()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "frame_callback".to_string(),
+                error: why.to_string(),
+            })? = Box::new(callback);
+        Ok(())
     }
 
     /// Polls the camera for a frame, analogous to [`Camera::frame`](crate::Camera::frame)
-    pub fn poll_frame(&mut self) -> Result<ImageBuffer<Rgb<u8>, Vec<u8>>, NokhwaError> {
-        let frame = self.camera.lock().frame()?;
+    /// # Errors
+    /// This will error if the camera fails to capture a frame.
+    pub fn poll_frame(&mut self) -> Result<Buffer, NokhwaError> {
+        let frame = self
+            .camera
+            .lock()
+            .map_err(|why| NokhwaError::ReadFrameError(why.to_string()))?
+            .frame()?;
         *self.last_frame_captured.lock() = frame.clone();
         Ok(frame)
     }
 
     /// Gets the last frame captured by the camera.
-    pub fn last_frame(&self) -> ImageBuffer<Rgb<u8>, Vec<u8>> {
-        self.last_frame_captured.lock().clone()
+    #[must_use]
+    pub fn last_frame(&self) -> Buffer {
+        self.last_frame_captured
+            .lock()
+            .map_err(|why| NokhwaError::ReadFrameError(why.to_string()))?
+            .clone()
     }
 
     /// Checks if stream if open. If it is, it will return true.
+    #[must_use]
     pub fn is_stream_open(&self) -> bool {
-        self.camera.lock().is_stream_open()
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::GetPropertyError {
+                property: "is stream open".to_string(),
+                error: why.to_string(),
+            })?
+            .is_stream_open()
     }
 
     /// Will drop the stream.
     /// # Errors
     /// Please check the `Quirks` section of each backend.
     pub fn stop_stream(&mut self) -> Result<(), NokhwaError> {
-        self.camera.lock().stop_stream()
+        self.camera
+            .lock()
+            .map_err(|why| NokhwaError::StreamShutdownError(why.to_string()))
+            .stop_stream()
     }
 }
 
-impl Drop for ThreadedCamera {
+impl Drop for CallbackCamera {
     fn drop(&mut self) {
-        let _ = self.stop_stream();
+        let _stop_stream_err = self.stop_stream();
         self.die_bool.store(true, Ordering::SeqCst);
     }
 }
 
 fn camera_frame_thread_loop(
-    camera: Arc<FairMutex<Camera>>,
-    callback: Arc<FairMutex<Option<fn(ImageBuffer<Rgb<u8>, Vec<u8>>)>>>,
-    holding_cell: Arc<FairMutex<ImageBuffer<Rgb<u8>, Vec<u8>>>>,
-    die_bool: Arc<AtomicBool>,
+    camera: &AtomicLock<Camera>,
+    frame_callback: &HeldCallbackType,
+    last_frame_captured: &AtomicLock<ImageBuffer<Rgb<u8>, Vec<u8>>>,
+    die_bool: &Arc<AtomicBool>,
 ) {
     loop {
-        if let Ok(img) = camera.lock().frame() {
-            *holding_cell.lock() = img.clone();
-            if let Some(cb) = callback.lock().deref() {
-                cb(img)
+        if let Ok(img) = camera.lock().fr {
+            *last_frame_captured.lock() = img.clone();
+            if let Some(cb) = (*frame_callback.lock()).as_mut() {
+                cb(img);
             }
         }
         if die_bool.load(Ordering::SeqCst) {
diff --git a/src/utils.rs b/src/utils.rs
deleted file mode 100644
index 239ceaa..0000000
--- a/src/utils.rs
+++ /dev/null
@@ -1,1342 +0,0 @@
-/*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * Copyright 2021 l1npengtul <l1npengtul@protonmail.com> / The Nokhwa Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use crate::NokhwaError;
-use std::{
-    cmp::Ordering,
-    fmt::{Display, Formatter},
-};
-#[cfg(feature = "output-wasm")]
-use wasm_bindgen::prelude::wasm_bindgen;
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-use nokhwa_bindings_macos::avfoundation::{
-    AVCaptureDeviceDescriptor, AVFourCC, AVVideoResolution, CaptureDeviceFormatDescriptor,
-};
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-use nokhwa_bindings_windows::{
-    MFCameraFormat, MFControl, MFFrameFormat, MFResolution, MediaFoundationControls,
-    MediaFoundationDeviceDescriptor,
-};
-#[cfg(feature = "input-uvc")]
-use uvc::StreamFormat;
-#[cfg(all(feature = "input-v4l", target_os = "linux"))]
-use v4l::{control::Description, Format, FourCC};
-
-/// Describes a frame format (i.e. how the bytes themselves are encoded). Often called `FourCC`.
-/// - YUYV is a mathematical color space. You can read more [here.](https://en.wikipedia.org/wiki/YCbCr)
-/// - MJPEG is a motion-jpeg compressed frame, it allows for high frame rates.
-/// # JS-WASM
-/// This is exported as `FrameFormat`
-#[derive(Copy, Clone, Debug, PartialEq, Hash, PartialOrd, Ord, Eq)]
-pub enum FrameFormat {
-    MJPEG,
-    YUYV,
-}
-
-impl Display for FrameFormat {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FrameFormat::MJPEG => {
-                write!(f, "MJPEG")
-            }
-            FrameFormat::YUYV => {
-                write!(f, "YUYV")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "input-uvc")]
-impl From<FrameFormat> for uvc::FrameFormat {
-    fn from(ff: FrameFormat) -> Self {
-        match ff {
-            FrameFormat::MJPEG => uvc::FrameFormat::MJPEG,
-            FrameFormat::YUYV => uvc::FrameFormat::YUYV,
-        }
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<MFFrameFormat> for FrameFormat {
-    fn from(mf_ff: MFFrameFormat) -> Self {
-        match mf_ff {
-            MFFrameFormat::MJPEG => FrameFormat::MJPEG,
-            MFFrameFormat::YUYV => FrameFormat::YUYV,
-        }
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<FrameFormat> for MFFrameFormat {
-    fn from(ff: FrameFormat) -> Self {
-        match ff {
-            FrameFormat::MJPEG => MFFrameFormat::MJPEG,
-            FrameFormat::YUYV => MFFrameFormat::YUYV,
-        }
-    }
-}
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-impl From<AVFourCC> for FrameFormat {
-    fn from(av_fcc: AVFourCC) -> Self {
-        match av_fcc {
-            AVFourCC::YUV2 => FrameFormat::YUYV,
-            AVFourCC::MJPEG => FrameFormat::MJPEG,
-        }
-    }
-}
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-impl From<FrameFormat> for AVFourCC {
-    fn from(ff: FrameFormat) -> Self {
-        match ff {
-            FrameFormat::MJPEG => AVFourCC::MJPEG,
-            FrameFormat::YUYV => AVFourCC::YUV2,
-        }
-    }
-}
-
-/// Describes a Resolution.
-/// This struct consists of a Width and a Height value (x,y). <br>
-/// Note: the [`Ord`] implementation of this struct is flipped from highest to lowest.
-/// # JS-WASM
-/// This is exported as `JSResolution`
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "output-wasm", wasm_bindgen(js_name = JSResolution))]
-pub struct Resolution {
-    pub width_x: u32,
-    pub height_y: u32,
-}
-
-#[cfg(not(target_feature = "output-wasm"))]
-impl Resolution {
-    /// Create a new resolution from 2 image size coordinates.
-    /// # JS-WASM
-    /// This is exported as a constructor for [`Resolution`].
-    #[must_use]
-    pub fn new(x: u32, y: u32) -> Self {
-        Resolution {
-            width_x: x,
-            height_y: y,
-        }
-    }
-
-    /// Get the width of Resolution
-    /// # JS-WASM
-    /// This is exported as `get_Width`.
-    #[must_use]
-    pub fn width(self) -> u32 {
-        self.width_x
-    }
-
-    /// Get the height of Resolution
-    /// # JS-WASM
-    /// This is exported as `get_Height`.
-    #[must_use]
-    pub fn height(self) -> u32 {
-        self.height_y
-    }
-
-    /// Get the x (width) of Resolution
-    #[must_use]
-    pub fn x(self) -> u32 {
-        self.width_x
-    }
-
-    /// Get the y (height) of Resolution
-    #[must_use]
-    pub fn y(self) -> u32 {
-        self.height_y
-    }
-}
-
-#[cfg(target_feature = "output-wasm")]
-impl Resolution {
-    /// Create a new resolution from 2 image size coordinates.
-    /// # JS-WASM
-    /// This is exported as a constructor for [`Resolution`].
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(constructor))]
-    pub fn new(x: u32, y: u32) -> Self {
-        Resolution {
-            width_x: x,
-            height_y: y,
-        }
-    }
-
-    /// Get the width of Resolution
-    /// # JS-WASM
-    /// This is exported as `get_Width`.
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Width))]
-    pub fn width(self) -> u32 {
-        self.width_x
-    }
-
-    /// Get the height of Resolution
-    /// # JS-WASM
-    /// This is exported as `get_Height`.
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Height))]
-    pub fn height(self) -> u32 {
-        self.height_y
-    }
-
-    /// Get the x (width) of Resolution
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(skip))]
-    pub fn x(self) -> u32 {
-        self.width_x
-    }
-
-    /// Get the y (height) of Resolution
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(skip))]
-    pub fn y(self) -> u32 {
-        self.height_y
-    }
-}
-
-impl Display for Resolution {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}x{}", self.x(), self.y())
-    }
-}
-
-impl PartialOrd for Resolution {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Resolution {
-    fn cmp(&self, other: &Self) -> Ordering {
-        match self.x().cmp(&other.x()) {
-            Ordering::Less => Ordering::Less,
-            Ordering::Equal => self.y().cmp(&other.y()),
-            Ordering::Greater => Ordering::Greater,
-        }
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<MFResolution> for Resolution {
-    fn from(mf_res: MFResolution) -> Self {
-        Resolution {
-            width_x: mf_res.width_x,
-            height_y: mf_res.height_y,
-        }
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<Resolution> for MFResolution {
-    fn from(res: Resolution) -> Self {
-        MFResolution {
-            width_x: res.width(),
-            height_y: res.height(),
-        }
-    }
-}
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-#[allow(clippy::cast_sign_loss)]
-impl From<AVVideoResolution> for Resolution {
-    fn from(res: AVVideoResolution) -> Self {
-        Resolution {
-            width_x: res.width as u32,
-            height_y: res.height as u32,
-        }
-    }
-}
-
-/// This is a convenience struct that holds all information about the format of a webcam stream.
-/// It consists of a [`Resolution`], [`FrameFormat`], and a frame rate(u8).
-#[derive(Copy, Clone, Debug, Hash, PartialEq)]
-pub struct CameraFormat {
-    resolution: Resolution,
-    format: FrameFormat,
-    frame_rate: u32,
-}
-
-impl CameraFormat {
-    /// Construct a new [`CameraFormat`]
-    #[must_use]
-    pub fn new(resolution: Resolution, format: FrameFormat, frame_rate: u32) -> Self {
-        CameraFormat {
-            resolution,
-            format,
-            frame_rate,
-        }
-    }
-
-    /// [`CameraFormat::new()`], but raw.
-    #[must_use]
-    pub fn new_from(res_x: u32, res_y: u32, format: FrameFormat, fps: u32) -> Self {
-        CameraFormat {
-            resolution: Resolution {
-                width_x: res_x,
-                height_y: res_y,
-            },
-            format,
-            frame_rate: fps,
-        }
-    }
-
-    /// Get the resolution of the current [`CameraFormat`]
-    #[must_use]
-    pub fn resolution(&self) -> Resolution {
-        self.resolution
-    }
-
-    /// Get the width of the resolution of the current [`CameraFormat`]
-    #[must_use]
-    pub fn width(&self) -> u32 {
-        self.resolution.width()
-    }
-
-    /// Get the height of the resolution of the current [`CameraFormat`]
-    #[must_use]
-    pub fn height(&self) -> u32 {
-        self.resolution.height()
-    }
-
-    /// Set the [`CameraFormat`]'s resolution.
-    pub fn set_resolution(&mut self, resolution: Resolution) {
-        self.resolution = resolution;
-    }
-
-    /// Get the frame rate of the current [`CameraFormat`]
-    #[must_use]
-    pub fn frame_rate(&self) -> u32 {
-        self.frame_rate
-    }
-
-    /// Set the [`CameraFormat`]'s frame rate.
-    pub fn set_frame_rate(&mut self, frame_rate: u32) {
-        self.frame_rate = frame_rate;
-    }
-
-    /// Get the [`CameraFormat`]'s format.
-    #[must_use]
-    pub fn format(&self) -> FrameFormat {
-        self.format
-    }
-
-    /// Set the [`CameraFormat`]'s format.
-    pub fn set_format(&mut self, format: FrameFormat) {
-        self.format = format;
-    }
-}
-
-#[cfg(feature = "input-uvc")]
-impl From<CameraFormat> for StreamFormat {
-    fn from(cf: CameraFormat) -> Self {
-        StreamFormat {
-            width: cf.width(),
-            height: cf.height(),
-            fps: cf.frame_rate(),
-            format: cf.format().into(),
-        }
-    }
-}
-
-impl Default for CameraFormat {
-    fn default() -> Self {
-        CameraFormat {
-            resolution: Resolution::new(640, 480),
-            format: FrameFormat::MJPEG,
-            frame_rate: 30,
-        }
-    }
-}
-
-impl Display for CameraFormat {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}@{}FPS, {} Format",
-            self.resolution, self.frame_rate, self.format
-        )
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<MFCameraFormat> for CameraFormat {
-    fn from(mf_cam_fmt: MFCameraFormat) -> Self {
-        CameraFormat {
-            resolution: mf_cam_fmt.resolution().into(),
-            format: mf_cam_fmt.format().into(),
-            frame_rate: mf_cam_fmt.frame_rate(),
-        }
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<CameraFormat> for MFCameraFormat {
-    fn from(cf: CameraFormat) -> Self {
-        MFCameraFormat::new(cf.resolution.into(), cf.format.into(), cf.frame_rate)
-    }
-}
-
-#[cfg(all(feature = "input-v4l", target_os = "linux"))]
-impl From<CameraFormat> for Format {
-    fn from(cam_fmt: CameraFormat) -> Self {
-        let pxfmt = match cam_fmt.format() {
-            FrameFormat::MJPEG => FourCC::new(b"MJPG"),
-            FrameFormat::YUYV => FourCC::new(b"YUYV"),
-        };
-
-        Format::new(cam_fmt.width(), cam_fmt.height(), pxfmt)
-    }
-}
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-#[allow(clippy::cast_possible_wrap)]
-#[allow(clippy::cast_lossless)]
-impl From<CameraFormat> for CaptureDeviceFormatDescriptor {
-    fn from(cf: CameraFormat) -> Self {
-        CaptureDeviceFormatDescriptor {
-            resolution: AVVideoResolution {
-                width: cf.width() as i32,
-                height: cf.height() as i32,
-            },
-            fps: cf.frame_rate(),
-            fourcc: cf.format().into(),
-        }
-    }
-}
-
-/// Information about a Camera e.g. its name.
-/// `description` amd `misc` may contain information that may differ from backend to backend. Refer to each backend for details.
-/// `index` is a camera's index given to it by (usually) the OS usually in the order it is known to the system.
-/// # JS-WASM
-/// This is exported as a `JSCameraInfo`.
-#[derive(Clone, Debug, Default, Hash, PartialEq, Eq)]
-#[cfg_attr(feature = "output-wasm", wasm_bindgen(js_name = JSCameraInfo))]
-pub struct CameraInfo {
-    human_name: String,
-    description: String,
-    misc: String,
-    index: usize,
-}
-
-#[cfg(not(target_feature = "output-wasm"))]
-impl CameraInfo {
-    /// Create a new [`CameraInfo`].
-    /// # JS-WASM
-    /// This is exported as a constructor for [`CameraInfo`].
-    #[must_use]
-    pub fn new(human_name: String, description: String, misc: String, index: usize) -> Self {
-        CameraInfo {
-            human_name,
-            description,
-            misc,
-            index,
-        }
-    }
-
-    /// Get a reference to the device info's human readable name.
-    /// # JS-WASM
-    /// This is exported as a `get_HumanReadableName`.
-    #[must_use]
-    pub fn human_name(&self) -> String {
-        self.human_name.clone()
-    }
-
-    /// Set the device info's human name.
-    /// # JS-WASM
-    /// This is exported as a `set_HumanReadableName`.
-    pub fn set_human_name(&mut self, human_name: String) {
-        self.human_name = human_name;
-    }
-
-    /// Get a reference to the device info's description.
-    /// # JS-WASM
-    /// This is exported as a `get_Description`.
-    #[must_use]
-    pub fn description(&self) -> String {
-        self.description.clone()
-    }
-
-    /// Set the device info's description.
-    /// # JS-WASM
-    /// This is exported as a `set_Description`.
-    pub fn set_description(&mut self, description: String) {
-        self.description = description;
-    }
-
-    /// Get a reference to the device info's misc.
-    /// # JS-WASM
-    /// This is exported as a `get_MiscString`.
-    #[must_use]
-    pub fn misc(&self) -> String {
-        self.misc.clone()
-    }
-
-    /// Set the device info's misc.
-    /// # JS-WASM
-    /// This is exported as a `set_MiscString`.
-    pub fn set_misc(&mut self, misc: String) {
-        self.misc = misc;
-    }
-
-    /// Get a reference to the device info's index.
-    /// # JS-WASM
-    /// This is exported as a `get_Index`.
-    #[must_use]
-    pub fn index(&self) -> usize {
-        self.index
-    }
-
-    /// Set the device info's index.
-    /// # JS-WASM
-    /// This is exported as a `set_Index`.
-    pub fn set_index(&mut self, index: usize) {
-        self.index = index;
-    }
-}
-
-#[cfg(target_feature = "output-wasm")]
-impl CameraInfo {
-    /// Create a new [`CameraInfo`].
-    /// # JS-WASM
-    /// This is exported as a constructor for [`CameraInfo`].
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(constructor))]
-    pub fn new(human_name: String, description: String, misc: String, index: usize) -> Self {
-        CameraInfo {
-            human_name,
-            description,
-            misc,
-            index,
-        }
-    }
-
-    /// Get a reference to the device info's human readable name.
-    /// # JS-WASM
-    /// This is exported as a `get_HumanReadableName`.
-    #[must_use]
-    #[cfg_attr(
-    feature = "output-wasm",
-    wasm_bindgen(getter = HumanReadableName)
-    )]
-    pub fn human_name(&self) -> String {
-        self.human_name.clone()
-    }
-
-    /// Set the device info's human name.
-    /// # JS-WASM
-    /// This is exported as a `set_HumanReadableName`.
-    #[cfg_attr(
-    feature = "output-wasm",
-    wasm_bindgen(setter = HumanReadableName)
-    )]
-    pub fn set_human_name(&mut self, human_name: String) {
-        self.human_name = human_name;
-    }
-
-    /// Get a reference to the device info's description.
-    /// # JS-WASM
-    /// This is exported as a `get_Description`.
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Description))]
-    pub fn description(&self) -> String {
-        self.description.clone()
-    }
-
-    /// Set the device info's description.
-    /// # JS-WASM
-    /// This is exported as a `set_Description`.
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(setter = Description))]
-    pub fn set_description(&mut self, description: String) {
-        self.description = description;
-    }
-
-    /// Get a reference to the device info's misc.
-    /// # JS-WASM
-    /// This is exported as a `get_MiscString`.
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = MiscString))]
-    pub fn misc(&self) -> String {
-        self.misc.clone()
-    }
-
-    /// Set the device info's misc.
-    /// # JS-WASM
-    /// This is exported as a `set_MiscString`.
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(setter = MiscString))]
-    pub fn set_misc(&mut self, misc: String) {
-        self.misc = misc;
-    }
-
-    /// Get a reference to the device info's index.
-    /// # JS-WASM
-    /// This is exported as a `get_Index`.
-    #[must_use]
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(getter = Index))]
-    pub fn index(&self) -> usize {
-        self.index
-    }
-
-    /// Set the device info's index.
-    /// # JS-WASM
-    /// This is exported as a `set_Index`.
-    #[cfg_attr(feature = "output-wasm", wasm_bindgen(setter = Index))]
-    pub fn set_index(&mut self, index: usize) {
-        self.index = index;
-    }
-}
-
-impl PartialOrd for CameraInfo {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for CameraInfo {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.index.cmp(&other.index)
-    }
-}
-
-impl Display for CameraInfo {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Name: {}, Description: {}, Extra: {}, Index: {}",
-            self.human_name, self.description, self.misc, self.index
-        )
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<MediaFoundationDeviceDescriptor<'_>> for CameraInfo {
-    fn from(dev_desc: MediaFoundationDeviceDescriptor<'_>) -> Self {
-        CameraInfo {
-            human_name: dev_desc.name_as_string(),
-            description: "Media Foundation Device".to_string(),
-            misc: dev_desc.link_as_string(),
-            index: dev_desc.index(),
-        }
-    }
-}
-
-#[cfg(any(
-    all(
-        feature = "input-avfoundation",
-        any(target_os = "macos", target_os = "ios")
-    ),
-    all(
-        feature = "docs-only",
-        feature = "docs-nolink",
-        feature = "input-avfoundation"
-    )
-))]
-#[allow(clippy::cast_possible_truncation)]
-impl From<AVCaptureDeviceDescriptor> for CameraInfo {
-    fn from(descriptor: AVCaptureDeviceDescriptor) -> Self {
-        CameraInfo {
-            human_name: descriptor.name,
-            description: descriptor.description,
-            misc: descriptor.misc,
-            index: descriptor.index as usize,
-        }
-    }
-}
-
-/// The list of known camera controls to the library. <br>
-/// These can control the picture brightness, etc. <br>
-/// Note that not all backends/devices support all these. Run [`supported_camera_controls()`](crate::CaptureBackendTrait::supported_camera_controls) to see which ones can be set.
-#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-pub enum KnownCameraControls {
-    Brightness,
-    Contrast,
-    Hue,
-    Saturation,
-    Sharpness,
-    Gamma,
-    ColorEnable,
-    WhiteBalance,
-    BacklightComp,
-    Gain,
-    Pan,
-    Tilt,
-    Roll,
-    Zoom,
-    Exposure,
-    Iris,
-    Focus,
-}
-
-/// All camera controls in an array.
-#[must_use]
-pub fn all_known_camera_controls() -> [KnownCameraControls; 17] {
-    [
-        KnownCameraControls::Brightness,
-        KnownCameraControls::Contrast,
-        KnownCameraControls::Hue,
-        KnownCameraControls::Saturation,
-        KnownCameraControls::Sharpness,
-        KnownCameraControls::Gamma,
-        KnownCameraControls::ColorEnable,
-        KnownCameraControls::WhiteBalance,
-        KnownCameraControls::BacklightComp,
-        KnownCameraControls::Gain,
-        KnownCameraControls::Pan,
-        KnownCameraControls::Tilt,
-        KnownCameraControls::Roll,
-        KnownCameraControls::Zoom,
-        KnownCameraControls::Exposure,
-        KnownCameraControls::Iris,
-        KnownCameraControls::Focus,
-    ]
-}
-
-impl Display for KnownCameraControls {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", &self)
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<MediaFoundationControls> for KnownCameraControls {
-    fn from(mf_c: MediaFoundationControls) -> Self {
-        match mf_c {
-            MediaFoundationControls::Brightness => KnownCameraControls::Brightness,
-            MediaFoundationControls::Contrast => KnownCameraControls::Contrast,
-            MediaFoundationControls::Hue => KnownCameraControls::Hue,
-            MediaFoundationControls::Saturation => KnownCameraControls::Saturation,
-            MediaFoundationControls::Sharpness => KnownCameraControls::Sharpness,
-            MediaFoundationControls::Gamma => KnownCameraControls::Gamma,
-            MediaFoundationControls::ColorEnable => KnownCameraControls::ColorEnable,
-            MediaFoundationControls::WhiteBalance => KnownCameraControls::WhiteBalance,
-            MediaFoundationControls::BacklightComp => KnownCameraControls::BacklightComp,
-            MediaFoundationControls::Gain => KnownCameraControls::Gain,
-            MediaFoundationControls::Pan => KnownCameraControls::Pan,
-            MediaFoundationControls::Tilt => KnownCameraControls::Tilt,
-            MediaFoundationControls::Roll => KnownCameraControls::Roll,
-            MediaFoundationControls::Zoom => KnownCameraControls::Zoom,
-            MediaFoundationControls::Exposure => KnownCameraControls::Exposure,
-            MediaFoundationControls::Iris => KnownCameraControls::Iris,
-            MediaFoundationControls::Focus => KnownCameraControls::Focus,
-        }
-    }
-}
-
-#[cfg(any(
-    all(feature = "input-msmf", target_os = "windows"),
-    all(feature = "docs-only", feature = "docs-nolink", feature = "input-msmf")
-))]
-impl From<MFControl> for KnownCameraControls {
-    fn from(mf_cc: MFControl) -> Self {
-        mf_cc.control().into()
-    }
-}
-
-#[cfg(all(feature = "input-v4l", target_os = "linux"))]
-impl std::convert::TryFrom<Description> for KnownCameraControls {
-    type Error = NokhwaError;
-
-    fn try_from(value: Description) -> Result<Self, Self::Error> {
-        Ok(match value.id {
-            9_963_776 => KnownCameraControls::Brightness,
-            9_963_777 => KnownCameraControls::Contrast,
-            9_963_779 => KnownCameraControls::Hue,
-            9_963_778 => KnownCameraControls::Saturation,
-            9_963_803 => KnownCameraControls::Sharpness,
-            9_963_792 => KnownCameraControls::Gamma,
-            9_963_802 => KnownCameraControls::WhiteBalance,
-            9_963_804 => KnownCameraControls::BacklightComp,
-            9_963_795 => KnownCameraControls::Gain,
-            10_094_852 => KnownCameraControls::Pan,
-            10_094_853 => KnownCameraControls::Tilt,
-            10_094_862 => KnownCameraControls::Zoom,
-            10_094_850 => KnownCameraControls::Exposure,
-            10_094_866 => KnownCameraControls::Iris,
-            10_094_859 => KnownCameraControls::Focus,
-            _ => {
-                return Err(NokhwaError::NotImplementedError(
-                    "Control not implemented!".to_string(),
-                ))
-            }
-        })
-    }
-}
-
-/// This tells you weather a [`KnownCameraControls`] is automatically managed by the OS/Driver
-/// or manually managed by you, the programmer.
-#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
-pub enum KnownCameraControlFlag {
-    Automatic,
-    Manual,
-}
-
-impl Display for KnownCameraControlFlag {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-/// This struct tells you everything about a particular [`KnownCameraControls`]. <br>
-/// However, you should never need to instantiate this struct, since its usually generated for you by `nokhwa`.
-/// The only time you should be modifying this struct is when you need to set a value and pass it back to the camera.
-/// NOTE: Assume the values for `min` and `max` as **non-inclusive**!.
-/// E.g. if the [`CameraControl`] says `min` is 100, the minimum is actually 101.
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-pub struct CameraControl {
-    control: KnownCameraControls,
-    min: i32,
-    max: i32,
-    value: i32,
-    step: i32,
-    default: i32,
-    flag: KnownCameraControlFlag,
-    active: bool,
-}
-
-impl CameraControl {
-    /// Creates a new [`CameraControl`]
-    /// # Errors
-    /// If the `value` is below `min`, above `max`, or is not divisible by `step`, this will error
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        control: KnownCameraControls,
-        minimum: i32,
-        maximum: i32,
-        value: i32,
-        step: i32,
-        default: i32,
-        flag: KnownCameraControlFlag,
-        active: bool,
-    ) -> Result<Self, NokhwaError> {
-        if value >= maximum {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Value too large".to_string(),
-            });
-        }
-        if value <= minimum {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Value too low".to_string(),
-            });
-        }
-        if value % step != 0 {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Not aligned with step".to_string(),
-            });
-        }
-
-        Ok(CameraControl {
-            control,
-            min: minimum,
-            max: maximum,
-            value,
-            step,
-            default,
-            flag,
-            active,
-        })
-    }
-
-    /// Gets the [`KnownCameraControls`] of this [`CameraControl`]
-    #[must_use]
-    pub fn control(&self) -> KnownCameraControls {
-        self.control
-    }
-
-    /// Gets the minimum value of this [`CameraControl`]
-    #[must_use]
-    pub fn minimum_value(&self) -> i32 {
-        self.min
-    }
-
-    /// Gets the maximum value of this [`CameraControl`]
-    #[must_use]
-    pub fn maximum_value(&self) -> i32 {
-        self.max
-    }
-
-    /// Gets the current value of this [`CameraControl`]
-    #[must_use]
-    pub fn value(&self) -> i32 {
-        self.value
-    }
-
-    /// Sets the value of this [`CameraControl`]
-    /// # Errors
-    /// If the `value` is below `min`, above `max`, or is not divisible by `step`, this will error
-    pub fn set_value(&mut self, value: i32) -> Result<(), NokhwaError> {
-        if value >= self.maximum_value() {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Value too large".to_string(),
-            });
-        }
-        if value <= self.minimum_value() {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Value too low".to_string(),
-            });
-        }
-        if value == self.minimum_value() || value == self.maximum_value() {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Values not inclusive".to_string(),
-            });
-        }
-        if value % self.step() != 0 {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Not aligned with step".to_string(),
-            });
-        }
-
-        self.value = value;
-        Ok(())
-    }
-
-    /// Creates a new [`CameraControl`] but with `value`
-    /// # Errors
-    /// If the `value` is below `min`, above `max`, or is not divisible by `step`, this will error
-    pub fn with_value(self, value: i32) -> Result<Self, NokhwaError> {
-        if value >= self.maximum_value() {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Value too large".to_string(),
-            });
-        }
-        if value <= self.minimum_value() {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Value too low".to_string(),
-            });
-        }
-        if value % self.step() != 0 {
-            return Err(NokhwaError::StructureError {
-                structure: "CameraControl".to_string(),
-                error: "Not aligned with step".to_string(),
-            });
-        }
-
-        Ok(CameraControl {
-            control: self.control(),
-            min: self.minimum_value(),
-            max: self.maximum_value(),
-            value,
-            step: self.step(),
-            default: self.default(),
-            flag: self.flag(),
-            active: true,
-        })
-    }
-
-    /// Gets the step value of this [`CameraControl`]
-    /// Note that `value` must be divisible by `step`
-    #[must_use]
-    pub fn step(&self) -> i32 {
-        self.step
-    }
-
-    /// Gets the default value of this [`CameraControl`]
-    #[must_use]
-    pub fn default(&self) -> i32 {
-        self.default
-    }
-
-    /// Gets the [`KnownCameraControlFlag`] of this [`CameraControl`],
-    /// telling you weather this control is automatically set or manually set.
-    #[must_use]
-    pub fn flag(&self) -> KnownCameraControlFlag {
-        self.flag
-    }
-
-    /// Gets `active` of this [`CameraControl`],
-    /// telling you weather this control is currently active(in-use).
-    #[must_use]
-    pub fn active(&self) -> bool {
-        self.active
-    }
-
-    /// Gets `active` of this [`CameraControl`],
-    /// telling you weather this control is currently active(in-use).
-    pub fn set_active(&mut self, active: bool) {
-        self.active = active;
-    }
-
-    /// Returns a list of i32s that are valid to be set.
-    #[allow(clippy::cast_sign_loss)]
-    #[must_use]
-    pub fn valid_values(&self) -> Vec<i32> {
-        (self.minimum_value()..=self.maximum_value())
-            .step_by(self.step() as usize)
-            .into_iter()
-            .collect()
-    }
-}
-
-impl Display for CameraControl {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Name: {}, Range: ({}~{}), Current: {}, Step: {}, Default: {}, Flag: {}, Active: {}",
-            self.control,
-            self.min,
-            self.max,
-            self.value,
-            self.step,
-            self.default,
-            self.flag,
-            self.active
-        )
-    }
-}
-
-impl PartialOrd for CameraControl {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for CameraControl {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.control().cmp(&other.control())
-    }
-}
-
-/// The list of known capture backends to the library. <br>
-/// - `AUTO` is special - it tells the Camera struct to automatically choose a backend most suited for the current platform.
-/// - `AVFoundation` - Uses `AVFoundation` on MacOSX
-/// - `V4L2` - `Video4Linux2`, a linux specific backend.
-/// - `UVC` - Universal Video Class (please check [libuvc](https://github.com/libuvc/libuvc)). Platform agnostic, although on linux it needs `sudo` permissions or similar to use.
-/// - `MediaFoundation` - Microsoft Media Foundation, Windows only,
-/// - `OpenCV` - Uses `OpenCV` to capture. Platform agnostic.
-/// - `GStreamer` - Uses `GStreamer` RTP to capture. Platform agnostic.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum CaptureAPIBackend {
-    Auto,
-    AVFoundation,
-    Video4Linux,
-    UniversalVideoClass,
-    MediaFoundation,
-    OpenCv,
-    GStreamer,
-}
-
-impl Display for CaptureAPIBackend {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let self_str = format!("{:?}", self);
-        write!(f, "{}", self_str)
-    }
-}
-
-/// The `OpenCV` backend supports both native cameras and IP Cameras, so this is an enum to differentiate them
-/// The `IPCamera`'s string follows the pattern
-/// ```.ignore
-/// <protocol>://<IP>:<port>/
-/// ```
-/// but please consult the manufacturer's specification for more details.
-/// The index is a standard webcam index.
-#[derive(Clone, Debug, PartialEq)]
-pub enum CameraIndexType {
-    Index(u32),
-    IPCamera(String),
-}
-
-impl Display for CameraIndexType {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            CameraIndexType::Index(idx) => {
-                write!(f, "{}", idx)
-            }
-            CameraIndexType::IPCamera(ip) => {
-                write!(f, "{}", ip)
-            }
-        }
-    }
-}
-
-/// Converts a MJPEG stream of [u8] into a Vec<u8> of RGB888. (R,G,B,R,G,B,...)
-/// # Errors
-/// If `mozjpeg` fails to read scanlines or setup the decompressor, this will error.
-/// # Safety
-/// This function uses `unsafe`. The caller must ensure that:
-/// - The input data is of the right size, does not exceed bounds, and/or the final size matches with the initial size.
-#[cfg(feature = "decoding")]
-#[cfg_attr(feature = "docs-features", doc(cfg(feature = "decoding")))]
-pub fn mjpeg_to_rgb888(data: &[u8]) -> Result<Vec<u8>, NokhwaError> {
-    use mozjpeg::Decompress;
-
-    let mut jpeg_decompress = match Decompress::new_mem(data) {
-        Ok(decompress) => match decompress.rgb() {
-            Ok(decompressor) => decompressor,
-            Err(why) => {
-                return Err(NokhwaError::ProcessFrameError {
-                    src: FrameFormat::MJPEG,
-                    destination: "RGB888".to_string(),
-                    error: why.to_string(),
-                })
-            }
-        },
-        Err(why) => {
-            return Err(NokhwaError::ProcessFrameError {
-                src: FrameFormat::MJPEG,
-                destination: "RGB888".to_string(),
-                error: why.to_string(),
-            })
-        }
-    };
-    let decompressed = match jpeg_decompress.read_scanlines::<[u8; 3]>() {
-        Some(pixels) => pixels,
-        None => {
-            return Err(NokhwaError::ProcessFrameError {
-                src: FrameFormat::MJPEG,
-                destination: "RGB888".to_string(),
-                error: "Failed to get read readlines into RGB888 pixels!".to_string(),
-            })
-        }
-    };
-
-    Ok(
-        unsafe { std::slice::from_raw_parts(decompressed.as_ptr().cast(), decompressed.len() * 3) }
-            .to_vec(),
-    )
-}
-
-// For those maintaining this, I recommend you read: https://docs.microsoft.com/en-us/windows/win32/medfound/recommended-8-bit-yuv-formats-for-video-rendering#yuy2
-// https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB
-// and this too: https://stackoverflow.com/questions/16107165/convert-from-yuv-420-to-imagebgr-byte
-// The YUY2(YUYV) format is a 16 bit format. We read 4 bytes at a time to get 6 bytes of RGB888.
-// First, the YUY2 is converted to YCbCr 4:4:4 (4:2:2 -> 4:4:4)
-// then it is converted to 6 bytes (2 pixels) of RGB888
-/// Converts a YUYV 4:2:2 datastream to a RGB888 Stream. [For further reading](https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB)
-/// # Errors
-/// This may error when the data stream size is not divisible by 4, a i32 -> u8 conversion fails, or it fails to read from a certain index.
-#[cfg(any(not(target_family = "wasm"), feature = "decoding"))]
-#[cfg_attr(feature = "docs-features", doc(cfg(feature = "decoding")))]
-#[inline]
-pub fn yuyv422_to_rgb888(data: &[u8]) -> Result<Vec<u8>, NokhwaError> {
-    use std::convert::TryFrom;
-
-    let mut rgb_vec: Vec<u8> = vec![];
-    if data.len() % 4 == 0 {
-        for px_idx in (0..data.len()).step_by(4) {
-            let y1 = match data.get(px_idx) {
-                Some(px) => match i32::try_from(*px) {
-                    Ok(i) => i,
-                    Err(why) => {
-                        return Err(NokhwaError::ProcessFrameError { src: FrameFormat::YUYV, destination: "RGB888".to_string(), error: format!("Failed to convert byte at {} to a i32 because {}, This shouldn't happen!", px_idx, why) });
-                    }
-                },
-                None => {
-                    return Err(NokhwaError::ProcessFrameError {
-                        src: FrameFormat::YUYV,
-                        destination: "RGB888".to_string(),
-                        error: format!(
-                            "Failed to get bytes at {}, this is probably a bug, please report!",
-                            px_idx
-                        ),
-                    });
-                }
-            };
-
-            let u = match data.get(px_idx + 1) {
-                Some(px) => match i32::try_from(*px) {
-                    Ok(i) => i,
-                    Err(why) => {
-                        return Err(NokhwaError::ProcessFrameError { src: FrameFormat::YUYV, destination: "RGB888".to_string(), error: format!("Failed to convert byte at {} to a i32 because {}, This shouldn't happen!", px_idx+1, why) });
-                    }
-                },
-                None => {
-                    return Err(NokhwaError::ProcessFrameError {
-                        src: FrameFormat::YUYV,
-                        destination: "RGB888".to_string(),
-                        error: format!(
-                            "Failed to get bytes at {}, this is probably a bug, please report!",
-                            px_idx + 1
-                        ),
-                    });
-                }
-            };
-
-            let y2 = match data.get(px_idx + 2) {
-                Some(px) => match i32::try_from(*px) {
-                    Ok(i) => i,
-                    Err(why) => {
-                        return Err(NokhwaError::ProcessFrameError { src: FrameFormat::YUYV, destination: "RGB888".to_string(), error: format!("Failed to convert byte at {} to a i32 because {}, This shouldn't happen!", px_idx+2, why) });
-                    }
-                },
-                None => {
-                    return Err(NokhwaError::ProcessFrameError {
-                        src: FrameFormat::YUYV,
-                        destination: "RGB888".to_string(),
-                        error: format!(
-                            "Failed to get bytes at {}, this is probably a bug, please report!",
-                            px_idx + 2
-                        ),
-                    });
-                }
-            };
-
-            let v = match data.get(px_idx + 3) {
-                Some(px) => match i32::try_from(*px) {
-                    Ok(i) => i,
-                    Err(why) => {
-                        return Err(NokhwaError::ProcessFrameError { src: FrameFormat::YUYV, destination: "RGB888".to_string(), error: format!("Failed to convert byte at {} to a i32 because {}, This shouldn't happen!", px_idx+3, why) });
-                    }
-                },
-                None => {
-                    return Err(NokhwaError::ProcessFrameError {
-                        src: FrameFormat::YUYV,
-                        destination: "RGB888".to_string(),
-                        error: format!(
-                            "Failed to get bytes at {}, this is probably a bug, please report!",
-                            px_idx + 3
-                        ),
-                    });
-                }
-            };
-
-            let pixel1 = yuyv444_to_rgb888(y1, u, v);
-            let pixel2 = yuyv444_to_rgb888(y2, u, v);
-            rgb_vec.append(&mut pixel1.to_vec());
-            rgb_vec.append(&mut pixel2.to_vec());
-        }
-        Ok(rgb_vec)
-    } else {
-        Err(NokhwaError::ProcessFrameError {
-            src: FrameFormat::YUYV,
-            destination: "RGB888".to_string(),
-            error: "Assertion failure, the YUV stream isn't 4:2:2! (wrong number of bytes)"
-                .to_string(),
-        })
-    }
-}
-
-// equation from https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB
-/// Convert `YCbCr` 4:4:4 to a RGB888. [For further reading](https://en.wikipedia.org/wiki/YUV#Converting_between_Y%E2%80%B2UV_and_RGB)
-#[allow(clippy::many_single_char_names)]
-#[allow(clippy::cast_possible_truncation)]
-#[allow(clippy::cast_sign_loss)]
-#[must_use]
-#[cfg(any(not(target_family = "wasm"), feature = "decoding"))]
-#[cfg_attr(feature = "docs-features", doc(cfg(feature = "decoding")))]
-#[inline]
-pub fn yuyv444_to_rgb888(y: i32, u: i32, v: i32) -> [u8; 3] {
-    let c298 = (y - 16) * 298;
-    let d = u - 128;
-    let e = v - 128;
-    let r = ((c298 + 409 * e + 128) >> 8).clamp(0, 255) as u8;
-    let g = ((c298 - 100 * d - 208 * e + 128) >> 8).clamp(0, 255) as u8;
-    let b = ((c298 + 516 * d + 128) >> 8).clamp(0, 255) as u8;
-    [r, g, b]
-}