Struct AVCaptureDeviceInput 

pub struct AVCaptureDeviceInput { /* private fields */ }

Available on crate feature AVCaptureInput only.

AVCaptureDeviceInput is a concrete subclass of AVCaptureInput that provides an interface for capturing media from an AVCaptureDevice.

Instances of AVCaptureDeviceInput are input sources for AVCaptureSession that provide media data from devices connected to the system, represented by instances of AVCaptureDevice.

See also Apple’s documentation

Implementations

impl AVCaptureDeviceInput

pub unsafe fn deviceInputWithDevice_error( device: &AVCaptureDevice, ) -> Result<Retained<Self>, Retained<NSError>>

Available on crate feature AVCaptureDevice only.

Returns an AVCaptureDeviceInput instance that provides media data from the given device.

Parameter device: An AVCaptureDevice instance to be used for capture.

Parameter outError: On return, if the given device cannot be used for capture, points to an NSError describing the problem.

Returns: An AVCaptureDeviceInput instance that provides data from the given device, or nil, if the device could not be used for capture.

This method returns an instance of AVCaptureDeviceInput that can be used to capture data from an AVCaptureDevice in an AVCaptureSession. This method attempts to open the device for capture, taking exclusive control of it if necessary. If the device cannot be opened because it is no longer available or because it is in use, for example, this method returns nil, and the optional outError parameter points to an NSError describing the problem.

pub unsafe fn initWithDevice_error( this: Allocated<Self>, device: &AVCaptureDevice, ) -> Result<Retained<Self>, Retained<NSError>>

Available on crate feature AVCaptureDevice only.

Creates an AVCaptureDeviceInput instance that provides media data from the given device.

Parameter device: An AVCaptureDevice instance to be used for capture.

Parameter outError: On return, if the given device cannot be used for capture, points to an NSError describing the problem.

Returns: An AVCaptureDeviceInput instance that provides data from the given device, or nil, if the device could not be used for capture.

This method creates an instance of AVCaptureDeviceInput that can be used to capture data from an AVCaptureDevice in an AVCaptureSession. This method attempts to open the device for capture, taking exclusive control of it if necessary. If the device cannot be opened because it is no longer available or because it is in use, for example, this method returns nil, and the optional outError parameter points to an NSError describing the problem.

pub unsafe fn device(&self) -> Retained<AVCaptureDevice>

Available on crate feature AVCaptureDevice only.

The device from which the receiver provides data.

The value of this property is the AVCaptureDevice instance that was used to create the receiver.

pub unsafe fn unifiedAutoExposureDefaultsEnabled(&self) -> bool

Specifies whether the source device should use the same default auto exposure behaviors for -[AVCaptureSession setSessionPreset:] and -[AVCaptureDevice setActiveFormat:].

AVCaptureDevice’s activeFormat property may be set two different ways. 1) You set it directly using one of the formats in the device’s -formats array, or 2) the AVCaptureSession sets it on your behalf when you set the AVCaptureSession’s sessionPreset property. Depending on the device and format, the default auto exposure behavior may be configured differently when you use one method or the other, resulting in non-uniform auto exposure behavior. Auto exposure defaults include min frame rate, max frame rate, and max exposure duration. If you wish to ensure that consistent default behaviors are applied to the device regardless of the API you use to configure the activeFormat, you may set the device input’s unifiedAutoExposureDefaultsEnabled property to YES. Default value for this property is NO.

Note that if you manually set the device’s min frame rate, max frame rate, or max exposure duration, your custom values will override the device defaults regardless of whether you’ve set this property to YES.

pub unsafe fn setUnifiedAutoExposureDefaultsEnabled( &self, unified_auto_exposure_defaults_enabled: bool, )

Setter for unifiedAutoExposureDefaultsEnabled.

pub unsafe fn portsWithMediaType_sourceDeviceType_sourceDevicePosition( &self, media_type: Option<&AVMediaType>, source_device_type: Option<&AVCaptureDeviceType>, source_device_position: AVCaptureDevicePosition, ) -> Retained<NSArray<AVCaptureInputPort>>

Available on crate features AVCaptureDevice and AVMediaFormat only.

An accessor method used to retrieve a virtual device’s constituent device ports for use in an AVCaptureMultiCamSession.

Parameter mediaType: The AVMediaType of the port for which you’re searching, or nil if all media types should be considered.

Parameter sourceDeviceType: The AVCaptureDeviceType of the port for which you’re searching, or nil if source device type is irrelevant.

Parameter sourceDevicePosition: The AVCaptureDevicePosition of the port for which you’re searching. AVCaptureDevicePositionUnspecified is germane to audio devices, indicating omnidirectional audio. For other types of capture devices (e.g. cameras), AVCaptureDevicePositionUnspecified means all positions should be considered in the search.

Returns: An array of AVCaptureInputPorts satisfying the search criteria, or an empty array could be found.

When using AVCaptureMultiCamSession, multiple devices may be run simultaneously. You may also run simultaneous streams from a virtual device such as the Dual Camera. By inspecting a virtual device’s constituentDevices property, you can find its underlying physical devices and, using this method, search for ports originating from one of those constituent devices. Note that the AVCaptureInput.ports array does not include constituent device ports for virtual devices. You must use this accessor method to discover the ports for which you’re specifically looking. These constituent device ports may be used to make connections to outputs for use with an AVCaptureMultiCamSession. Using the Dual Camera as an example, the AVCaptureInput.ports property exposes only those ports supported by the virtual device (it switches automatically between wide and telephoto cameras according to the zoom factor). You may use this method to find the video ports for the constituentDevices.

AVCaptureInputPort *wideVideoPort = [dualCameraInput portsWithMediaType:AVMediaTypeVideo sourceDeviceType:AVCaptureDeviceTypeBuiltInWideAngleCamera sourceDevicePosition:AVCaptureDevicePositionBack].firstObject; AVCaptureInputPort *teleVideoPort = [dualCameraInput portsWithMediaType:AVMediaTypeVideo sourceDeviceType:AVCaptureDeviceTypeBuiltInTelephotoCamera sourceDevicePosition:AVCaptureDevicePositionBack].firstObject;

These ports may be used to create connections, say, to two AVCaptureVideoDataOutput instances, allowing for synchronized full frame rate delivery of both wide and telephoto streams.

As of iOS 13, constituent device ports may not be connected to AVCapturePhotoOutput instances. Clients who wish to capture multiple photos from a virtual device should use AVCapturePhotoOutput’s virtualDeviceConstituentPhotoDeliveryEnabled feature.

When used in conjunction with an audio device, this method allows you to discover microphones in different AVCaptureDevicePositions. When you intend to work with an AVCaptureMultiCamSession, you may use these ports to make connections and simultaneously capture both front facing and back facing audio simultaneously to two different outputs. When used with an AVCaptureMultiCamSession, the audio device port whose sourceDevicePosition is AVCaptureDevicePositionUnspecified produces omnidirectional sound.

pub unsafe fn videoMinFrameDurationOverride(&self) -> CMTime

Available on crate feature objc2-core-media only.

A property that acts as a modifier to the AVCaptureDevice’s activeVideoMinFrameDuration property. Default value is kCMTimeInvalid.

An AVCaptureDevice’s activeVideoMinFrameDuration property is the reciprocal of its active maximum frame rate. To limit the max frame rate of the capture device, clients may set the device’s activeVideoMinFrameDuration to a value supported by the receiver’s activeFormat (see AVCaptureDeviceFormat’s videoSupportedFrameRateRanges property). Changes you make to the device’s activeVideoMinFrameDuration property take effect immediately without disrupting preview. Therefore, the AVCaptureSession must always allocate sufficient resources to allow the device to run at its activeFormat’s max allowable frame rate. If you wish to use a particular device format but only ever run it at lower frame rates (for instance, only run a 1080p240 fps format at a max frame rate of 60), you can set the AVCaptureDeviceInput’s videoMinFrameDurationOverride property to the reciprocal of the max frame rate you intend to use before starting the session (or within a beginConfiguration / commitConfiguration block while running the session).

When a device input is added to a session, this property reverts back to the default of kCMTimeInvalid (no override).

pub unsafe fn setVideoMinFrameDurationOverride( &self, video_min_frame_duration_override: CMTime, )

Available on crate feature objc2-core-media only.

Setter for videoMinFrameDurationOverride.

pub unsafe fn isLockedVideoFrameDurationSupported(&self) -> bool

Indicates whether the device input supports locked frame durations.

See AVCaptureDeviceInput/activeLockedVideoFrameDuration for more information on video frame duration locking.

pub unsafe fn activeLockedVideoFrameDuration(&self) -> CMTime

Available on crate feature objc2-core-media only.

The receiver’s locked frame duration (the reciprocal of its frame rate). Setting this property guarantees the intra-frame duration delivered by the device input is precisely the frame duration you request.

Set this property to run the receiver’s associated AVCaptureDevice at precisely your provided frame rate (expressed as a duration). Query AVCaptureDevice/minSupportedLockedVideoFrameDuration to find the minimum value supported by this AVCaptureDeviceInput. In order to disable locked video frame duration, set this property to kCMTimeInvalid. This property resets itself to kCMTimeInvalid when the receiver’s attached AVCaptureDevice/activeFormat changes. When you set this property, its value is also reflected in the receiver’s AVCaptureDevice/activeVideoMinFrameDuration and AVCaptureDevice/activeVideoMaxFrameDuration.

• Note: Locked frame duration availability may change depending on the device configuration. For example, locked frame duration is unsupported when AVCaptureDevice/autoVideoFrameRateEnabled or AVCaptureMovieFileOutput/spatialVideoCaptureEnabled is set to true.

• Note: Only one AVCaptureDeviceInput added to an AVCaptureMultiCamSession can follow an external sync device or run at a locked frame duration.

• Note: Setting this property may cause a lengthy reconfiguration of the receiver, similar to setting AVCaptureDevice/activeFormat or AVCaptureSession/sessionPreset.

• Important: If you set this property to a valid value while the receiver’s AVCaptureDevice/minSupportedLockedVideoFrameDuration is kCMTimeInvalid, it throws an NSInvalidArgumentException.

• Important: If you set this property while the receiver’s lockedVideoFrameDurationSupported property returns false, it throws an NSInvalidArgumentException.

pub unsafe fn setActiveLockedVideoFrameDuration( &self, active_locked_video_frame_duration: CMTime, )

Available on crate feature objc2-core-media only.

Setter for activeLockedVideoFrameDuration.

pub unsafe fn isExternalSyncSupported(&self) -> bool

Indicates whether the device input supports being configured to follow an external sync device.

See AVCaptureDeviceInput/followExternalSyncDevice:videoFrameDuration:delegate: for more information on external sync.

pub unsafe fn followExternalSyncDevice_videoFrameDuration_delegate( &self, external_sync_device: &AVExternalSyncDevice, frame_duration: CMTime, delegate: Option<&ProtocolObject<dyn AVExternalSyncDeviceDelegate>>, )

Available on crate features AVExternalSyncDevice and objc2-core-media only.

Configures the the device input to follow an external sync device at the given frame duration.

• Parameter externalSyncDevice: The AVExternalSyncDevice hardware to follow.
• Parameter videoFrameDuration: The frame duration to which the AVExternalSyncDevice is calibrated.
• Parameter delegate: The delegate to notify when the connection status changes, or an error occurs.

Call this method to direct your AVCaptureDeviceInput to follow the external sync pulse from a sync device at the given frame duration.

Your provided videoFrameDuration value must match the sync pulse duration of the external sync device. If it does not, the request times out, the external sync device’s status returns to AVExternalSyncDeviceStatusReady, and your session stops running, posting a AVCaptureSessionRuntimeErrorNotification with AVErrorFollowExternalSyncDeviceTimedOut.

The ability to follow an external sync device may change depending on the device configuration. For example, followExternalSyncDevice:videoFrameDuration:delegate: cannot be used when AVCaptureDevice/autoVideoFrameRateEnabled is true.

To stop following an external pulse, call unfollowExternalSyncDevice. External sync device following is also disabled when your device’s AVCaptureDeviceFormat changes.

Your provided delegate’s AVExternalSyncDeviceDelegate/externalSyncDeviceStatusDidChange: method is called with a status of AVExternalSyncDeviceStatusReady if the external pulse signal is not close enough to the provided videoFrameDuration for successful calibration.

Once your AVExternalSyncDevice/status changes to AVExternalSyncDeviceStatusActiveSync, your input’s AVCaptureInput/activeExternalSyncVideoFrameDuration property reports the up-to-date frame duration. AVCaptureInput/activeExternalSyncVideoFrameDuration is also reflected in the AVCaptureDevice/activeVideoMinFrameDuration and AVCaptureDevice/activeVideoMaxFrameDuration of your input’s associated device.

• Note: Calling this method may cause a lengthy reconfiguration of the receiver, similar to setting a new active format or AVCaptureSession/sessionPreset.

• Important: Calling this method throws an NSInvalidArgumentException if AVCaptureDeviceInput/externalSyncSupported returns false.

• Important: The provided external sync device’s status must be AVExternalSyncDeviceStatusReady when you call this method, otherwise an NSInvalidArgumentException is thrown.

pub unsafe fn activeExternalSyncVideoFrameDuration(&self) -> CMTime

Available on crate feature objc2-core-media only.

The receiver’s external sync frame duration (the reciprocal of its frame rate) when being driven by an external sync device.

Set up your input to follow an external sync device by calling followExternalSyncDevice:videoFrameDuration:delegate:.

• Note: The value of this readonly property is kCMTimeInvalid unless the AVExternalSyncDevice is actively driving the AVCaptureDeviceInput. This is reflected by the AVExternalSyncDevice/status being either AVExternalSyncDeviceStatusActiveSync or AVExternalSyncDeviceStatusFreeRunSync.

pub unsafe fn externalSyncDevice( &self, ) -> Option<Retained<AVExternalSyncDevice>>

Available on crate feature AVExternalSyncDevice only.

The external sync device currently being followed by this input.

This readonly property returns the AVExternalSyncDevice instance you provided in followExternalSyncDevice:videoFrameDuration:delegate:. This property returns nil when an external sync device is disconnected or fails to calibrate.

pub unsafe fn unfollowExternalSyncDevice(&self)

Discontinues external sync.

This method stops your input from syncing to the external sync device you specified in followExternalSyncDevice:videoFrameDuration:delegate:.

pub unsafe fn isMultichannelAudioModeSupported( &self, multichannel_audio_mode: AVCaptureMultichannelAudioMode, ) -> bool

Returns whether the receiver supports the given multichannel audio mode.

Parameter multichannelAudioMode: An AVCaptureMultichannelAudioMode to be checked.

Returns: YES if the receiver supports the given multichannel audio mode, NO otherwise.

The receiver’s multichannelAudioMode property can only be set to a certain mode if this method returns YES for that mode.

Multichannel audio modes are not supported when used in conjunction with AVCaptureMultiCamSession.

pub unsafe fn multichannelAudioMode(&self) -> AVCaptureMultichannelAudioMode

Indicates the multichannel audio mode to apply when recording audio.

This property only takes effect when audio is being routed through the built-in microphone, and is ignored if an external microphone is in use.

The default value is AVCaptureMultichannelAudioModeNone, in which case the default single channel audio recording is used.

pub unsafe fn setMultichannelAudioMode( &self, multichannel_audio_mode: AVCaptureMultichannelAudioMode, )

Setter for multichannelAudioMode.

pub unsafe fn isWindNoiseRemovalSupported(&self) -> bool

Returns whether or not the device supports wind noise removal during audio capture.

YES if the device supports wind noise removal, NO otherwise.

pub unsafe fn isWindNoiseRemovalEnabled(&self) -> bool

Specifies whether or not wind noise is removed during audio capture.

Wind noise removal is available when the AVCaptureDeviceInput multichannelAudioMode property is set to any value other than AVCaptureMultichannelAudioModeNone.

pub unsafe fn setWindNoiseRemovalEnabled( &self, wind_noise_removal_enabled: bool, )

Setter for isWindNoiseRemovalEnabled.

pub unsafe fn isCinematicVideoCaptureSupported(&self) -> bool

A BOOL value specifying whether Cinematic Video capture is supported.

With Cinematic Video capture, you get a simulated depth-of-field effect that keeps your subjects (people, pets, and more) in sharp focus while applying a pleasing blur to the background (or foreground). Depending on the focus mode (see AVCaptureCinematicVideoFocusMode for detail), the camera either uses machine learning to automatically detect and focus on subjects in the scene, or it fixes focus on a subject until it exits the scene. Cinematic Videos can be played back and edited using the Cinematic framework.

You can adjust the video’s simulated aperture before starting a recording using the simulatedAperture property. With Cinematic Video specific focus methods on AVCaptureDevice, you can dynamically control focus transitions.

Movie files captured with Cinematic Video enabled can be played back and edited with the [Cinematic framework] (https://developer.apple.com/documentation/cinematic/playing-and-editing-cinematic-mode-video?language=objc).

This property returns true if the session’s current configuration allows Cinematic Video capture. When switching cameras or formats, this property may change. When this property changes from true to false, cinematicVideoCaptureEnabled also reverts to false. If you’ve previously opted in for Cinematic Video capture and then change configuration, you may need to set cinematicVideoCaptureEnabled to true again. This property is key-value observable.

• Note: AVCaptureDepthDataOutput is not supported when cinematicVideoCaptureEnabled is set to true. Running an AVCaptureSession with both of these features throws an NSInvalidArgumentException.

pub unsafe fn isCinematicVideoCaptureEnabled(&self) -> bool

A BOOL value specifying whether the Cinematic Video effect is being applied to any movie file output, video data output, metadata output, or video preview layer added to the capture session.

Default is false. Set to true to enable support for Cinematic Video capture.

When you set this property to true, your input’s associated AVCaptureDevice/focusMode changes to AVCaptureFocusModeContinuousAutoFocus. While Cinematic Video capture is enabled, you are not permitted to change your device’s focus mode, and any attempt to do so results in an NSInvalidArgumentException. You may only set this property to true if cinematicVideoCaptureSupported is true.

• Note: Enabling Cinematic Video capture requires a lengthy reconfiguration of the capture render pipeline, so if you intend to capture Cinematic Video, you should set this property to true before calling AVCaptureSession/startRunning or within AVCaptureSession/beginConfiguration and AVCaptureSession/commitConfiguration while running.

pub unsafe fn setCinematicVideoCaptureEnabled( &self, cinematic_video_capture_enabled: bool, )

Setter for isCinematicVideoCaptureEnabled.

pub unsafe fn simulatedAperture(&self) -> c_float

Shallow depth of field simulated aperture.

When capturing a Cinematic Video, use this property to control the amount of blur in the simulated depth of field effect.

This property only takes effect when cinematicVideoCaptureEnabled is set to true.

• Important: Setting this property to a value less than the AVCaptureDevice/activeFormat/minSimulatedAperture or greater than the AVCaptureDevice/activeFormat/maxSimulatedAperture throws an NSRangeException. you may only set this property if AVCaptureDevice/activeFormat/minSimulatedAperture returns a non-zero value, otherwise an NSInvalidArgumentException is thrown. You must set this property before starting a Cinematic Video capture. If you attempt to set it while a recording is in progress, an NSInvalidArgumentException is thrown.

This property is initialized to the associated AVCaptureDevice/activeFormat/defaultSimulatedAperture.

This property is key-value observable.

pub unsafe fn setSimulatedAperture(&self, simulated_aperture: c_float)

Setter for simulatedAperture.

impl AVCaptureDeviceInput

Methods declared on superclass AVCaptureInput.

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

pub unsafe fn new() -> Retained<Self>

Methods from Deref<Target = AVCaptureInput>

pub unsafe fn ports(&self) -> Retained<NSArray<AVCaptureInputPort>>

The ports owned by the receiver.

The value of this property is an array of AVCaptureInputPort objects, each exposing an interface to a single stream of media data provided by an input.

Methods from Deref<Target = NSObject>

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T

where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}

Trait Implementations

impl AsRef<AVCaptureDeviceInput> for AVCaptureDeviceInput

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<AVCaptureInput> for AVCaptureDeviceInput

fn as_ref(&self) -> &AVCaptureInput

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<AnyObject> for AVCaptureDeviceInput

fn as_ref(&self) -> &AnyObject

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<NSObject> for AVCaptureDeviceInput

fn as_ref(&self) -> &NSObject

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<AVCaptureInput> for AVCaptureDeviceInput

fn borrow(&self) -> &AVCaptureInput

Immutably borrows from an owned value.

impl Borrow<AnyObject> for AVCaptureDeviceInput

fn borrow(&self) -> &AnyObject

Immutably borrows from an owned value.

impl Borrow<NSObject> for AVCaptureDeviceInput

fn borrow(&self) -> &NSObject

Immutably borrows from an owned value.

impl ClassType for AVCaptureDeviceInput

const NAME: &'static str = "AVCaptureDeviceInput"

The name of the Objective-C class that this type represents.

type Super = AVCaptureInput

The superclass of this class.

type ThreadKind = <<AVCaptureDeviceInput as ClassType>::Super as ClassType>::ThreadKind

Whether the type can be used from any thread, or from only the main thread.

fn class() -> &'static AnyClass

Get a reference to the Objective-C class that this type represents.

fn as_super(&self) -> &Self::Super

Get an immutable reference to the superclass.

impl Debug for AVCaptureDeviceInput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for AVCaptureDeviceInput

type Target = AVCaptureInput

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Hash for AVCaptureDeviceInput

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Message for AVCaptureDeviceInput

fn retain(&self) -> Retained<Self>

where Self: Sized,

Increment the reference count of the receiver.

impl NSObjectProtocol for AVCaptureDeviceInput

fn isEqual(&self, other: Option<&AnyObject>) -> bool

where Self: Sized + Message,

Check whether the object is equal to an arbitrary other object.

fn hash(&self) -> usize

where Self: Sized + Message,

An integer that can be used as a table address in a hash table structure.

fn isKindOfClass(&self, cls: &AnyClass) -> bool

where Self: Sized + Message,

Check if the object is an instance of the class, or one of its subclasses.

fn is_kind_of<T>(&self) -> bool

where T: ClassType, Self: Sized + Message,

👎Deprecated: use isKindOfClass directly, or cast your objects with AnyObject::downcast_ref

Check if the object is an instance of the class type, or one of its subclasses.

fn isMemberOfClass(&self, cls: &AnyClass) -> bool

where Self: Sized + Message,

Check if the object is an instance of a specific class, without checking subclasses.

fn respondsToSelector(&self, aSelector: Sel) -> bool

where Self: Sized + Message,

Check whether the object implements or inherits a method with the given selector.

fn conformsToProtocol(&self, aProtocol: &AnyProtocol) -> bool

where Self: Sized + Message,

Check whether the object conforms to a given protocol.

fn description(&self) -> Retained<NSObject>

where Self: Sized + Message,

A textual representation of the object.

fn debugDescription(&self) -> Retained<NSObject>

where Self: Sized + Message,

A textual representation of the object to use when debugging.

fn isProxy(&self) -> bool

where Self: Sized + Message,

Check whether the receiver is a subclass of the NSProxy root class instead of the usual NSObject.

fn retainCount(&self) -> usize

where Self: Sized + Message,

The reference count of the object.

impl PartialEq for AVCaptureDeviceInput

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RefEncode for AVCaptureDeviceInput

const ENCODING_REF: Encoding = <AVCaptureInput as ::objc2::RefEncode>::ENCODING_REF

The Objective-C type-encoding for a reference of this type.

impl DowncastTarget for AVCaptureDeviceInput

impl Eq for AVCaptureDeviceInput