objc2_video_toolbox/generated/

VTFrameProcessor_MotionBlur.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ptr::NonNull;
#[cfg(feature = "objc2")]
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-foundation")]
use objc2_foundation::*;

use crate::*;

/// Configuration value you set to prioritize quality or performance.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/vtmotionblurconfigurationqualityprioritization?language=objc)
// NS_ENUM
#[cfg(feature = "objc2")]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct VTMotionBlurConfigurationQualityPrioritization(pub NSInteger);
#[cfg(feature = "objc2")]
impl VTMotionBlurConfigurationQualityPrioritization {
    #[doc(alias = "VTMotionBlurConfigurationQualityPrioritizationNormal")]
    pub const Normal: Self = Self(1);
    #[doc(alias = "VTMotionBlurConfigurationQualityPrioritizationQuality")]
    pub const Quality: Self = Self(2);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for VTMotionBlurConfigurationQualityPrioritization {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for VTMotionBlurConfigurationQualityPrioritization {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// Available algorithm revisions.
///
/// A new enum case with higher revision number is added when the processing algorithm is updated.
/// The ``VTMotionBlurConfiguration/defaultRevision`` property provides the default algorithm revision.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/vtmotionblurconfigurationrevision?language=objc)
// NS_ENUM
#[cfg(feature = "objc2")]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct VTMotionBlurConfigurationRevision(pub NSInteger);
#[cfg(feature = "objc2")]
impl VTMotionBlurConfigurationRevision {
    #[doc(alias = "VTMotionBlurConfigurationRevision1")]
    pub const Revision1: Self = Self(1);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for VTMotionBlurConfigurationRevision {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for VTMotionBlurConfigurationRevision {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// Indicates the order of input frames.
///
/// When submitting ``VTMotionBlurParameters`` to the processor, you need to provide one of these values based on how
/// the input frames are related to each other.
///
/// Use ``VTMotionBlurParametersSubmissionModeSequential`` to indicate that the current submission follows presentation
/// time order without jump or skip, when compared to previous submissions. This value provides better processor
/// performance than other values.
///
/// Use ``VTMotionBlurParametersSubmissionModeRandom`` to indicate that the current submission has no relation to the
/// previous submission. Typically, this indicates a jump or a skip in the frame sequence. The processor clears internal
/// caches when it receives this value in ``VTFrameProcessor/processWithParameters`` function call.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/vtmotionblurparameterssubmissionmode?language=objc)
// NS_ENUM
#[cfg(feature = "objc2")]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct VTMotionBlurParametersSubmissionMode(pub NSInteger);
#[cfg(feature = "objc2")]
impl VTMotionBlurParametersSubmissionMode {
    #[doc(alias = "VTMotionBlurParametersSubmissionModeRandom")]
    pub const Random: Self = Self(1);
    #[doc(alias = "VTMotionBlurParametersSubmissionModeSequential")]
    pub const Sequential: Self = Self(2);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for VTMotionBlurParametersSubmissionMode {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for VTMotionBlurParametersSubmissionMode {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

#[cfg(feature = "objc2")]
extern_class!(
    /// Configuration that you use to set up the motion blur processor.
    ///
    /// This configuration enables the motion blur on a `VTFrameProcessor` session.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/vtmotionblurconfiguration?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct VTMotionBlurConfiguration;
);

#[cfg(feature = "objc2")]
unsafe impl Send for VTMotionBlurConfiguration {}

#[cfg(feature = "objc2")]
unsafe impl Sync for VTMotionBlurConfiguration {}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for VTMotionBlurConfiguration {}
);

#[cfg(all(feature = "VTFrameProcessorConfiguration", feature = "objc2"))]
extern_conformance!(
    unsafe impl VTFrameProcessorConfiguration for VTMotionBlurConfiguration {}
);

#[cfg(feature = "objc2")]
impl VTMotionBlurConfiguration {
    extern_methods!(
        /// Creates a new motion blur configuration.
        ///
        /// Returns `nil` if dimensions are out of range or revision is unsupported.
        ///
        /// - Parameters:
        /// - frameWidth: Width of source frame in pixels; the maximum value is 8192 for macOS, and 4096 for iOS.
        /// - frameHeight: Height of source frame in pixels; the maximum value is 4320 for macOS, and 2160 for iOS.
        /// - usePrecomputedFlow: Boolean value that indicates whether you will provide optical flow; if false, this
        /// configuration computes the optical flow on the fly.
        /// - qualityPrioritization: A level you use to prioritize quality or performance; for more information about supported
        /// levels, see ``VTMotionBlurConfigurationQualityPrioritization``.
        /// - revision: The specific algorithm or configuration revision you use to perform the request.
        #[unsafe(method(initWithFrameWidth:frameHeight:usePrecomputedFlow:qualityPrioritization:revision:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithFrameWidth_frameHeight_usePrecomputedFlow_qualityPrioritization_revision(
            this: Allocated<Self>,
            frame_width: NSInteger,
            frame_height: NSInteger,
            use_precomputed_flow: bool,
            quality_prioritization: VTMotionBlurConfigurationQualityPrioritization,
            revision: VTMotionBlurConfigurationRevision,
        ) -> Option<Retained<Self>>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;

        /// Width of source frame in pixels.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(frameWidth))]
        #[unsafe(method_family = none)]
        pub unsafe fn frameWidth(&self) -> NSInteger;

        /// Height of source frame in pixels.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(frameHeight))]
        #[unsafe(method_family = none)]
        pub unsafe fn frameHeight(&self) -> NSInteger;

        /// Indicates that you provide optical flow.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(usePrecomputedFlow))]
        #[unsafe(method_family = none)]
        pub unsafe fn usePrecomputedFlow(&self) -> bool;

        /// A parameter you use to control quality and performance levels.
        ///
        /// For more information about supported levels, see ``VTMotionBlurConfigurationQualityPrioritization``.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(qualityPrioritization))]
        #[unsafe(method_family = none)]
        pub unsafe fn qualityPrioritization(
            &self,
        ) -> VTMotionBlurConfigurationQualityPrioritization;

        /// The specific algorithm or configuration revision you use to perform the request.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(revision))]
        #[unsafe(method_family = none)]
        pub unsafe fn revision(&self) -> VTMotionBlurConfigurationRevision;

        #[cfg(feature = "objc2-foundation")]
        /// Provides the collection of currently supported algorithms or configuration revisions for the class of configuration.
        ///
        /// A property you use to introspect at runtime which revisions are available for each configuration.
        #[unsafe(method(supportedRevisions))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportedRevisions() -> Retained<NSIndexSet>;

        /// Provides the default revision of a specific algorithm or configuration.
        #[unsafe(method(defaultRevision))]
        #[unsafe(method_family = none)]
        pub unsafe fn defaultRevision() -> VTMotionBlurConfigurationRevision;

        #[cfg(feature = "objc2-foundation")]
        /// Available supported pixel formats for source frames for current configuration.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(frameSupportedPixelFormats))]
        #[unsafe(method_family = none)]
        pub unsafe fn frameSupportedPixelFormats(&self) -> Retained<NSArray<NSNumber>>;

        #[cfg(feature = "objc2-foundation")]
        /// Pixel buffer attributes dictionary that describes requirements for pixel buffers which represent source frames and reference frames.
        ///
        /// Use ``CVPixelBufferCreateResolvedAttributesDictionary`` to combine this dictionary with your pixel buffer attributes dictionary.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(sourcePixelBufferAttributes))]
        #[unsafe(method_family = none)]
        pub unsafe fn sourcePixelBufferAttributes(
            &self,
        ) -> Retained<NSDictionary<NSString, AnyObject>>;

        #[cfg(feature = "objc2-foundation")]
        /// Pixel buffer attributes dictionary that describes requirements for pixel buffers which represent destination frames.
        ///
        /// Use ``CVPixelBufferCreateResolvedAttributesDictionary`` to combine this dictionary with your pixel buffer attributes dictionary.
        ///
        /// This property is not atomic.
        ///
        /// # Safety
        ///
        /// This might not be thread-safe.
        #[unsafe(method(destinationPixelBufferAttributes))]
        #[unsafe(method_family = none)]
        pub unsafe fn destinationPixelBufferAttributes(
            &self,
        ) -> Retained<NSDictionary<NSString, AnyObject>>;

        /// Reports whether the system supports this processor.
        #[unsafe(method(isSupported))]
        #[unsafe(method_family = none)]
        pub unsafe fn isSupported() -> bool;

        #[deprecated]
        #[unsafe(method(processorSupported))]
        #[unsafe(method_family = none)]
        pub unsafe fn processorSupported() -> Boolean;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// An object that contains both input and output parameters that the motion blur processor needs to run on a frame.
    ///
    /// Use this object in the `processWithParameters` call of `VTFrameProcessor` class. The output parameter for this class is `destinationFrame` where the processor returns the output frame (as `VTFrameProcessorFrame`) back to you once the `processWithParameters` completes.
    ///
    /// `VTMotionBlurParameters` are frame-level parameters.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/vtmotionblurparameters?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct VTMotionBlurParameters;
);

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for VTMotionBlurParameters {}
);

#[cfg(all(feature = "VTFrameProcessorParameters", feature = "objc2"))]
extern_conformance!(
    unsafe impl VTFrameProcessorParameters for VTMotionBlurParameters {}
);

#[cfg(feature = "objc2")]
impl VTMotionBlurParameters {
    extern_methods!(
        #[cfg(feature = "VTFrameProcessorFrame")]
        /// Creates a new motion blur parameters object.
        ///
        /// Returns `nil` if `sourceFrame` or `destinationFrame` is `nil`, `sourceFrame` and reference frames are different pixel
        /// formats, or `motionBlurStrength` is out of range.
        ///
        /// - Parameters:
        /// - sourceFrame: Current source frame; must be non `nil`.
        /// - nextFrame: Next source frame in presentation time order; for the last frame you can set this to `nil`.
        /// - previousFrame: Previous source frame in presentation time order; for the first frame you can set this to `nil`.
        /// - nextOpticalFlow: Optional `VTFrameProcessorOpticalFlow` object that contains forward and backward optical flow
        /// with `nextFrame`. You only need this object if optical flow is pre-computed. For the last frame this is always `nil`.
        /// - previousOpticalFlow: Optional VTFrameProcessorOpticalFlow object that contains forward and backward optical flow
        /// with `previousFrame`. You only need to use this if the optical flow is pre-computed. For the first frame this is always `nil`.
        /// - motionBlurStrength: Number that indicates the strength of blur applied by the processor. Range is from 1 to 100. Default value is 50.
        /// - submissionMode: Provides a hint to let the processor know whether you are submitting frames in presenatation
        /// sequence. For more information about supported modes see ``VTMotionBlurParametersSubmissionMode``.
        /// - destinationFrame: User-allocated pixel buffer that receives a frame with motion blur applied by the processor.
        #[unsafe(method(initWithSourceFrame:nextFrame:previousFrame:nextOpticalFlow:previousOpticalFlow:motionBlurStrength:submissionMode:destinationFrame:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceFrame_nextFrame_previousFrame_nextOpticalFlow_previousOpticalFlow_motionBlurStrength_submissionMode_destinationFrame(
            this: Allocated<Self>,
            source_frame: &VTFrameProcessorFrame,
            next_frame: Option<&VTFrameProcessorFrame>,
            previous_frame: Option<&VTFrameProcessorFrame>,
            next_optical_flow: Option<&VTFrameProcessorOpticalFlow>,
            previous_optical_flow: Option<&VTFrameProcessorOpticalFlow>,
            motion_blur_strength: NSInteger,
            submission_mode: VTMotionBlurParametersSubmissionMode,
            destination_frame: &VTFrameProcessorFrame,
        ) -> Option<Retained<Self>>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;

        #[cfg(feature = "VTFrameProcessorFrame")]
        /// Current source frame, which must be non `nil`.
        #[unsafe(method(sourceFrame))]
        #[unsafe(method_family = none)]
        pub unsafe fn sourceFrame(&self) -> Retained<VTFrameProcessorFrame>;

        #[cfg(feature = "VTFrameProcessorFrame")]
        /// The next source frame in presentation time order, which is `nil` for the last frame.
        #[unsafe(method(nextFrame))]
        #[unsafe(method_family = none)]
        pub unsafe fn nextFrame(&self) -> Option<Retained<VTFrameProcessorFrame>>;

        #[cfg(feature = "VTFrameProcessorFrame")]
        /// Previous source frame in presentation time order, which is `nil` for the first frame.
        #[unsafe(method(previousFrame))]
        #[unsafe(method_family = none)]
        pub unsafe fn previousFrame(&self) -> Option<Retained<VTFrameProcessorFrame>>;

        #[cfg(feature = "VTFrameProcessorFrame")]
        /// Optional frame processor optical flow object that contains forward and backward optical flow with next frame.
        ///
        /// You only need to use this object if the optical flow is pre-computed. For the last frame this is `nil`.
        #[unsafe(method(nextOpticalFlow))]
        #[unsafe(method_family = none)]
        pub unsafe fn nextOpticalFlow(&self) -> Option<Retained<VTFrameProcessorOpticalFlow>>;

        #[cfg(feature = "VTFrameProcessorFrame")]
        /// Optional frame processor optical flow object that contains forward and backward optical flow with previous frame.
        ///
        /// You only need to use this object if the optical flow is pre-computed. For the first frame this is `nil`.
        #[unsafe(method(previousOpticalFlow))]
        #[unsafe(method_family = none)]
        pub unsafe fn previousOpticalFlow(&self) -> Option<Retained<VTFrameProcessorOpticalFlow>>;

        /// Number that indicates the strength of motion blur.
        ///
        /// The range is from 1 to 100; the default value is 50.
        #[unsafe(method(motionBlurStrength))]
        #[unsafe(method_family = none)]
        pub unsafe fn motionBlurStrength(&self) -> NSInteger;

        /// Ordering of the input frames this submission related to the previous submission.
        #[unsafe(method(submissionMode))]
        #[unsafe(method_family = none)]
        pub unsafe fn submissionMode(&self) -> VTMotionBlurParametersSubmissionMode;

        #[cfg(feature = "VTFrameProcessorFrame")]
        /// Destination frame that contains user-allocated pixel buffer that receive a frame with motion blur applied by the processor.
        #[unsafe(method(destinationFrame))]
        #[unsafe(method_family = none)]
        pub unsafe fn destinationFrame(&self) -> Retained<VTFrameProcessorFrame>;
    );
}