react-native-vision-camera/package/ios/Core/CameraConfiguration.swift
2023-12-14 10:54:19 +01:00

257 lines
8.7 KiB
Swift

//
// CameraConfiguration.swift
// VisionCamera
//
// Created by Marc Rousavy on 11.10.23.
// Copyright © 2023 mrousavy. All rights reserved.
//
import AVFoundation
import Foundation
// MARK: - CameraConfiguration
class CameraConfiguration {
// pragma MARK: Configuration Props
// Input
var cameraId: String?
// Outputs
var photo: OutputConfiguration<Photo> = .disabled
var video: OutputConfiguration<Video> = .disabled
var codeScanner: OutputConfiguration<CodeScanner> = .disabled
// Video Stabilization
var videoStabilizationMode: VideoStabilizationMode = .off
// Orientation
var orientation: Orientation = .portrait
// Format
var format: CameraDeviceFormat?
// Side-Props
var fps: Int32?
var enableLowLightBoost = false
var torch: Torch = .off
// Zoom
var zoom: CGFloat?
// Exposure
var exposure: Float?
// isActive (Start/Stop)
var isActive = false
// Audio Session
var audio: OutputConfiguration<Audio> = .disabled
init(copyOf other: CameraConfiguration?) {
if let other {
// copy over all values
cameraId = other.cameraId
photo = other.photo
video = other.video
codeScanner = other.codeScanner
videoStabilizationMode = other.videoStabilizationMode
orientation = other.orientation
format = other.format
fps = other.fps
enableLowLightBoost = other.enableLowLightBoost
torch = other.torch
zoom = other.zoom
exposure = other.exposure
isActive = other.isActive
audio = other.audio
} else {
// self will just be initialized with the default values.
}
}
// pragma MARK: Types
struct Difference {
let inputChanged: Bool
let outputsChanged: Bool
let videoStabilizationChanged: Bool
let orientationChanged: Bool
let formatChanged: Bool
let sidePropsChanged: Bool
let torchChanged: Bool
let zoomChanged: Bool
let exposureChanged: Bool
let audioSessionChanged: Bool
/**
Returns `true` when props that affect the AVCaptureSession configuration (i.e. props that require beginConfiguration()) have changed.
[`inputChanged`, `outputsChanged`, `orientationChanged`]
*/
var isSessionConfigurationDirty: Bool {
return inputChanged || outputsChanged || videoStabilizationChanged || orientationChanged
}
/**
Returns `true` when props that affect the AVCaptureDevice configuration (i.e. props that require lockForConfiguration()) have changed.
[`formatChanged`, `sidePropsChanged`, `zoomChanged`, `exposureChanged`]
*/
var isDeviceConfigurationDirty: Bool {
return isSessionConfigurationDirty || formatChanged || sidePropsChanged || zoomChanged || exposureChanged
}
init(between left: CameraConfiguration?, and right: CameraConfiguration) {
// cameraId
inputChanged = left?.cameraId != right.cameraId
// photo, video, codeScanner
outputsChanged = inputChanged || left?.photo != right.photo || left?.video != right.video || left?.codeScanner != right.codeScanner
// videoStabilizationMode
videoStabilizationChanged = outputsChanged || left?.videoStabilizationMode != right.videoStabilizationMode
// orientation
orientationChanged = outputsChanged || left?.orientation != right.orientation
// format (depends on cameraId)
formatChanged = inputChanged || left?.format != right.format
// side-props (depends on format)
sidePropsChanged = formatChanged || left?.fps != right.fps || left?.enableLowLightBoost != right.enableLowLightBoost
// torch (depends on isActive)
let wasInactiveAndNeedsToEnableTorchAgain = left?.isActive == false && right.isActive == true && right.torch == .on
torchChanged = inputChanged || wasInactiveAndNeedsToEnableTorchAgain || left?.torch != right.torch
// zoom (depends on format)
zoomChanged = formatChanged || left?.zoom != right.zoom
// exposure (depends on device)
exposureChanged = inputChanged || left?.exposure != right.exposure
// audio session
audioSessionChanged = left?.audio != right.audio
}
}
enum OutputConfiguration<T: Equatable>: Equatable {
case disabled
case enabled(config: T)
public static func == (lhs: OutputConfiguration, rhs: OutputConfiguration) -> Bool {
switch (lhs, rhs) {
case (.disabled, .disabled):
return true
case let (.enabled(a), .enabled(b)):
return a == b
default:
return false
}
}
}
/**
A Photo Output configuration
*/
struct Photo: Equatable {
var enableHighQualityPhotos = false
var enableDepthData = false
var enablePortraitEffectsMatte = false
}
/**
A Video Output configuration
*/
struct Video: Equatable {
var pixelFormat: PixelFormat = .native
var enableBufferCompression = false
var enableHdr = false
var enableFrameProcessor = false
}
/**
An Audio Output configuration
*/
struct Audio: Equatable {
// no props for audio at the moment
}
/**
A CodeScanner Output configuration
*/
struct CodeScanner: Equatable {
var options: CodeScannerOptions
}
}
extension CameraConfiguration.Video {
/**
Returns the pixel format that should be used for the given AVCaptureVideoDataOutput.
If HDR is enabled, this will return YUV 4:2:0 10-bit.
If HDR is disabled, this will return whatever the user specified as a pixelFormat, or the most efficient format as a fallback.
*/
func getPixelFormat(for videoOutput: AVCaptureVideoDataOutput) throws -> OSType {
// as per documentation, the first value is always the most efficient format
var defaultFormat = videoOutput.availableVideoPixelFormatTypes.first!
if enableBufferCompression {
// use compressed format instead if we enabled buffer compression
if defaultFormat == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange &&
videoOutput.availableVideoPixelFormatTypes.contains(kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarVideoRange) {
// YUV 4:2:0 8-bit (limited video colors; compressed)
defaultFormat = kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarVideoRange
}
if defaultFormat == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange &&
videoOutput.availableVideoPixelFormatTypes.contains(kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarFullRange) {
// YUV 4:2:0 8-bit (full video colors; compressed)
defaultFormat = kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarFullRange
}
}
// If the user enabled HDR, we can only use the YUV 4:2:0 10-bit pixel format.
if enableHdr == true {
guard pixelFormat == .native || pixelFormat == .yuv else {
throw CameraError.format(.incompatiblePixelFormatWithHDR)
}
var targetFormats = [kCVPixelFormatType_420YpCbCr10BiPlanarFullRange,
kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange]
if enableBufferCompression {
// If we enable buffer compression, try to use a lossy compressed YUV format first, otherwise fall back to the others.
targetFormats.insert(kCVPixelFormatType_Lossy_420YpCbCr10PackedBiPlanarVideoRange, at: 0)
}
// Find the best matching format
guard let format = videoOutput.findPixelFormat(firstOf: targetFormats) else {
throw CameraError.format(.invalidVideoHdr)
}
// YUV 4:2:0 10-bit (compressed/uncompressed)
return format
}
// If we don't use HDR, we can use any other custom pixel format.
switch pixelFormat {
case .yuv:
// YUV 4:2:0 8-bit (full/limited video colors; uncompressed)
var targetFormats = [kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange]
if enableBufferCompression {
// YUV 4:2:0 8-bit (full/limited video colors; compressed)
targetFormats.insert(kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarVideoRange, at: 0)
targetFormats.insert(kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarFullRange, at: 0)
}
guard let format = videoOutput.findPixelFormat(firstOf: targetFormats) else {
throw CameraError.device(.pixelFormatNotSupported)
}
return format
case .rgb:
// RGBA 8-bit (uncompressed)
var targetFormats = [kCVPixelFormatType_32BGRA]
if enableBufferCompression {
// RGBA 8-bit (compressed)
targetFormats.insert(kCVPixelFormatType_Lossy_32BGRA, at: 0)
}
guard let format = videoOutput.findPixelFormat(firstOf: targetFormats) else {
throw CameraError.device(.pixelFormatNotSupported)
}
return format
case .native:
return defaultFormat
case .unknown:
throw CameraError.parameter(.invalid(unionName: "pixelFormat", receivedValue: "unknown"))
}
}
}