objc2_core_media_io/generated/

CMIOExtensionStream.rs

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

use crate::*;

/// Constants indicating the direction of the stream.
///
/// Indicates that the stream is a source; i.e., provides sample buffers for capture.
///
/// Indicates that the stream is a sink; i.e., consumes sample buffers for playback.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/coremediaio/cmioextensionstreamdirection?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CMIOExtensionStreamDirection(pub NSInteger);
impl CMIOExtensionStreamDirection {
    #[doc(alias = "CMIOExtensionStreamDirectionSource")]
    pub const Source: Self = Self(0);
    #[doc(alias = "CMIOExtensionStreamDirectionSink")]
    pub const Sink: Self = Self(1);
}

unsafe impl Encode for CMIOExtensionStreamDirection {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

unsafe impl RefEncode for CMIOExtensionStreamDirection {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// Constants indicating the clock of the stream.
///
/// Indicates that the stream's clock is the host time clock.
///
/// Indicates that the stream's clock is the clock from the linked CoreAudio device.
///
/// Indicates that the stream's clock is specific to the device hosting the stream; this clock type cannot be set directly by the extension, but instead is set automatically when a  CMIOExtensionStreamCustomClockConfiguration is used when creating a CMIOExtensionStream.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/coremediaio/cmioextensionstreamclocktype?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CMIOExtensionStreamClockType(pub NSInteger);
impl CMIOExtensionStreamClockType {
    #[doc(alias = "CMIOExtensionStreamClockTypeHostTime")]
    pub const HostTime: Self = Self(0);
    #[doc(alias = "CMIOExtensionStreamClockTypeLinkedCoreAudioDeviceUID")]
    pub const LinkedCoreAudioDeviceUID: Self = Self(1);
    #[doc(alias = "CMIOExtensionStreamClockTypeCustom")]
    pub const Custom: Self = Self(2);
}

unsafe impl Encode for CMIOExtensionStreamClockType {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

unsafe impl RefEncode for CMIOExtensionStreamClockType {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// Constants indicating the state of a stream discontinuity.
///
/// Indicates that there is no stream discontinuity.
///
/// Indicates that there is a stream discontinuity of type unknown.
///
/// Indicates that there is a stream discontinuity of type time.
///
/// Indicates that there is a stream discontinuity of type dropped sample.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/coremediaio/cmioextensionstreamdiscontinuityflags?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CMIOExtensionStreamDiscontinuityFlags(pub u32);
bitflags::bitflags! {
    impl CMIOExtensionStreamDiscontinuityFlags: u32 {
        #[doc(alias = "CMIOExtensionStreamDiscontinuityFlagNone")]
        const None = 0;
        #[doc(alias = "CMIOExtensionStreamDiscontinuityFlagUnknown")]
        const Unknown = 1<<0;
        #[doc(alias = "CMIOExtensionStreamDiscontinuityFlagTime")]
        const Time = 1<<1;
        #[doc(alias = "CMIOExtensionStreamDiscontinuityFlagSampleDropped")]
        const SampleDropped = 1<<6;
    }
}

unsafe impl Encode for CMIOExtensionStreamDiscontinuityFlags {
    const ENCODING: Encoding = u32::ENCODING;
}

unsafe impl RefEncode for CMIOExtensionStreamDiscontinuityFlags {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern_class!(
    /// A CMIOExtensionStreamProperties describes a CoreMediaIO extension stream properties.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/coremediaio/cmioextensionstreamproperties?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct CMIOExtensionStreamProperties;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for CMIOExtensionStreamProperties {}
);

impl CMIOExtensionStreamProperties {
    extern_methods!(
        #[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 = "CMIOExtensionProperties")]
        /// Return a stream properties instance.
        ///
        /// Parameter `propertiesDictionary`: The dictionary of properties.
        ///
        /// Returns: A CMIOExtensionStreamProperties instance.
        ///
        /// # Safety
        ///
        /// `properties_dictionary` generic generic should be of the correct type.
        #[unsafe(method(streamPropertiesWithDictionary:))]
        #[unsafe(method_family = none)]
        pub unsafe fn streamPropertiesWithDictionary(
            properties_dictionary: &NSDictionary<CMIOExtensionProperty, CMIOExtensionPropertyState>,
        ) -> Retained<Self>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Initialize a stream properties instance.
        ///
        /// Parameter `propertiesDictionary`: The dictionary of properties.
        ///
        /// Returns: A CMIOExtensionStreamProperties instance.
        ///
        /// # Safety
        ///
        /// `properties_dictionary` generic generic should be of the correct type.
        #[unsafe(method(initWithDictionary:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDictionary(
            this: Allocated<Self>,
            properties_dictionary: &NSDictionary<CMIOExtensionProperty, CMIOExtensionPropertyState>,
        ) -> Retained<Self>;

        /// The active format index.
        ///
        /// The property key is CMIOExtensionPropertyStreamActiveFormatIndex.
        #[unsafe(method(activeFormatIndex))]
        #[unsafe(method_family = none)]
        pub unsafe fn activeFormatIndex(&self) -> Option<Retained<NSNumber>>;

        /// Setter for [`activeFormatIndex`][Self::activeFormatIndex].
        #[unsafe(method(setActiveFormatIndex:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setActiveFormatIndex(&self, active_format_index: Option<&NSNumber>);

        /// The frame duration.
        ///
        /// The property key is CMIOExtensionPropertyStreamFrameDuration.
        /// The dictionary needs to be a dictionary representing a CMTime struct that is consistent with the frame duration specification provided by the current active format.
        #[unsafe(method(frameDuration))]
        #[unsafe(method_family = none)]
        pub unsafe fn frameDuration(&self) -> Option<Retained<NSDictionary>>;

        /// Setter for [`frameDuration`][Self::frameDuration].
        ///
        /// # Safety
        ///
        /// `frame_duration` generic should be of the correct type.
        #[unsafe(method(setFrameDuration:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFrameDuration(&self, frame_duration: Option<&NSDictionary>);

        /// The maximum frame duration.
        ///
        /// The property key is CMIOExtensionPropertyStreamMaxFrameDuration.
        /// The dictionary needs to be a dictionary representing a CMTime struct that is consistent with the frame duration specification provided by the current active format.
        #[unsafe(method(maxFrameDuration))]
        #[unsafe(method_family = none)]
        pub unsafe fn maxFrameDuration(&self) -> Option<Retained<NSDictionary>>;

        /// Setter for [`maxFrameDuration`][Self::maxFrameDuration].
        ///
        /// # Safety
        ///
        /// `max_frame_duration` generic should be of the correct type.
        #[unsafe(method(setMaxFrameDuration:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaxFrameDuration(&self, max_frame_duration: Option<&NSDictionary>);

        /// The sink stream property buffer queue size.
        ///
        /// The property key is CMIOExtensionPropertyStreamSinkBufferQueueSize.
        #[unsafe(method(sinkBufferQueueSize))]
        #[unsafe(method_family = none)]
        pub unsafe fn sinkBufferQueueSize(&self) -> Option<Retained<NSNumber>>;

        /// Setter for [`sinkBufferQueueSize`][Self::sinkBufferQueueSize].
        #[unsafe(method(setSinkBufferQueueSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSinkBufferQueueSize(&self, sink_buffer_queue_size: Option<&NSNumber>);

        /// The sink stream property for number of buffers required for startup.
        ///
        /// The property key is CMIOExtensionPropertyStreamSinkBuffersRequiredForStartup.
        #[unsafe(method(sinkBuffersRequiredForStartup))]
        #[unsafe(method_family = none)]
        pub unsafe fn sinkBuffersRequiredForStartup(&self) -> Option<Retained<NSNumber>>;

        /// Setter for [`sinkBuffersRequiredForStartup`][Self::sinkBuffersRequiredForStartup].
        #[unsafe(method(setSinkBuffersRequiredForStartup:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSinkBuffersRequiredForStartup(
            &self,
            sink_buffers_required_for_startup: Option<&NSNumber>,
        );

        /// The sink stream property buffer underrun count.
        ///
        /// The property key is CMIOExtensionPropertyStreamSinkBufferUnderrunCount.
        #[unsafe(method(sinkBufferUnderrunCount))]
        #[unsafe(method_family = none)]
        pub unsafe fn sinkBufferUnderrunCount(&self) -> Option<Retained<NSNumber>>;

        /// Setter for [`sinkBufferUnderrunCount`][Self::sinkBufferUnderrunCount].
        #[unsafe(method(setSinkBufferUnderrunCount:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSinkBufferUnderrunCount(
            &self,
            sink_buffer_underrun_count: Option<&NSNumber>,
        );

        /// The sink stream property end of data.
        ///
        /// The property key is CMIOExtensionPropertyStreamSinkEndOfData.
        #[unsafe(method(sinkEndOfData))]
        #[unsafe(method_family = none)]
        pub unsafe fn sinkEndOfData(&self) -> Option<Retained<NSNumber>>;

        /// Setter for [`sinkEndOfData`][Self::sinkEndOfData].
        #[unsafe(method(setSinkEndOfData:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSinkEndOfData(&self, sink_end_of_data: Option<&NSNumber>);

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Set the property value.
        ///
        /// Parameter `propertyState`: The property state.
        ///
        /// Parameter `property`: The property key.
        ///
        /// Setting nil to propertyState does remove the property.
        ///
        /// # Safety
        ///
        /// `property_state` generic should be of the correct type.
        #[unsafe(method(setPropertyState:forProperty:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPropertyState_forProperty(
            &self,
            property_state: Option<&CMIOExtensionPropertyState>,
            property: &CMIOExtensionProperty,
        );

        #[cfg(feature = "CMIOExtensionProperties")]
        /// The dictionary of properties.
        ///
        /// The dictionary containing all keys and values.
        #[unsafe(method(propertiesDictionary))]
        #[unsafe(method_family = none)]
        pub unsafe fn propertiesDictionary(
            &self,
        ) -> Retained<NSDictionary<CMIOExtensionProperty, CMIOExtensionPropertyState>>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Setter for [`propertiesDictionary`][Self::propertiesDictionary].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        ///
        /// # Safety
        ///
        /// `properties_dictionary` generic generic should be of the correct type.
        #[unsafe(method(setPropertiesDictionary:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPropertiesDictionary(
            &self,
            properties_dictionary: &NSDictionary<CMIOExtensionProperty, CMIOExtensionPropertyState>,
        );
    );
}

extern_protocol!(
    /// [Apple's documentation](https://developer.apple.com/documentation/coremediaio/cmioextensionstreamsource?language=objc)
    pub unsafe trait CMIOExtensionStreamSource: NSObjectProtocol {
        #[cfg(feature = "CMIOExtensionProperties")]
        /// The supported formats for the stream.
        ///
        /// formats should not change during the life cycle of the associated stream.
        #[unsafe(method(formats))]
        #[unsafe(method_family = none)]
        unsafe fn formats(&self) -> Retained<NSArray<CMIOExtensionStreamFormat>>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// The set of available properties.
        ///
        /// The availableProperties should not change during the life cycle of the associated stream.
        #[unsafe(method(availableProperties))]
        #[unsafe(method_family = none)]
        unsafe fn availableProperties(&self) -> Retained<NSSet<CMIOExtensionProperty>>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Get the state of properties.
        ///
        /// Parameter `properties`: The addresses of properties from which to get the state.
        ///
        /// Parameter `outError`: An error return on failure.
        ///
        /// Returns: A stream properties instance containing the properties states.
        #[unsafe(method(streamPropertiesForProperties:error:_))]
        #[unsafe(method_family = none)]
        unsafe fn streamPropertiesForProperties_error(
            &self,
            properties: &NSSet<CMIOExtensionProperty>,
        ) -> Result<Retained<CMIOExtensionStreamProperties>, Retained<NSError>>;

        /// Set the provider properties.
        ///
        /// Parameter `streamProperties`: The stream properties instance containing the properties states.
        ///
        /// Parameter `outError`: An error return on failure.
        ///
        /// Returns: Return YES on success, NO otherwise.
        ///
        /// The property attributes associated with a property state are always nil in setter.
        /// In case of error, it is highly advisable to pass more detailed information regarding the property or properties that failed in the localizedDescription of the NSError.
        #[unsafe(method(setStreamProperties:error:_))]
        #[unsafe(method_family = none)]
        unsafe fn setStreamProperties_error(
            &self,
            stream_properties: &CMIOExtensionStreamProperties,
        ) -> Result<(), Retained<NSError>>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Accept or reject streaming for a client.
        ///
        /// Parameter `client`: The client.
        ///
        /// Returns: Return YES to accept streaming to a client, NO otherwise.
        #[unsafe(method(authorizedToStartStreamForClient:))]
        #[unsafe(method_family = none)]
        unsafe fn authorizedToStartStreamForClient(&self, client: &CMIOExtensionClient) -> bool;

        /// Start streaming media.
        ///
        /// Parameter `outError`: An error return on failure.
        ///
        /// Returns: Return YES on success, NO otherwise.
        #[unsafe(method(startStreamAndReturnError:_))]
        #[unsafe(method_family = none)]
        unsafe fn startStreamAndReturnError(&self) -> Result<(), Retained<NSError>>;

        /// Stop streaming media.
        ///
        /// Parameter `outError`: An error return on failure.
        ///
        /// Returns: Return YES on success, NO otherwise.
        #[unsafe(method(stopStreamAndReturnError:_))]
        #[unsafe(method_family = none)]
        unsafe fn stopStreamAndReturnError(&self) -> Result<(), Retained<NSError>>;
    }
);

extern_class!(
    /// A CMIOExtensionStream describes a stream of media data.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/coremediaio/cmioextensionstream?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct CMIOExtensionStream;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for CMIOExtensionStream {}
);

impl CMIOExtensionStream {
    extern_methods!(
        #[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>;

        /// Returns a stream instance.
        ///
        /// Parameter `localizedName`: The localized name of the stream.
        ///
        /// Parameter `streamID`: The stream identifier.
        ///
        /// Parameter `direction`: The stream direction.
        ///
        /// Parameter `clockType`: The stream clock type.
        ///
        /// Parameter `source`: The stream source.
        ///
        /// Returns: A CMIOExtensionStream instance that provides data.
        ///
        /// Note that the clockType parameter may not be CMIOExtensionStreamClockTypeCustom; that value is reserved for streams created with a custom clock configuration. For streams that have a custom clock, use streamWithLocalizedName:streamID:direction:customClockConfiguration:source:.
        #[unsafe(method(streamWithLocalizedName:streamID:direction:clockType:source:))]
        #[unsafe(method_family = none)]
        pub unsafe fn streamWithLocalizedName_streamID_direction_clockType_source(
            localized_name: &NSString,
            stream_id: &NSUUID,
            direction: CMIOExtensionStreamDirection,
            clock_type: CMIOExtensionStreamClockType,
            source: &ProtocolObject<dyn CMIOExtensionStreamSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Returns a stream instance.
        ///
        /// Parameter `localizedName`: The localized name of the stream.
        ///
        /// Parameter `streamID`: The stream identifier.
        ///
        /// Parameter `direction`: The stream direction.
        ///
        /// Parameter `customClockConfiguration`: A CMIOExtensionStreamCustomClockConfiguration object that defines the custom clock configuration.
        ///
        /// Parameter `source`: The stream source.
        ///
        /// Returns: A CMIOExtensionStream instance that provides data.
        #[unsafe(method(streamWithLocalizedName:streamID:direction:customClockConfiguration:source:))]
        #[unsafe(method_family = none)]
        pub unsafe fn streamWithLocalizedName_streamID_direction_customClockConfiguration_source(
            localized_name: &NSString,
            stream_id: &NSUUID,
            direction: CMIOExtensionStreamDirection,
            custom_clock_configuration: &CMIOExtensionStreamCustomClockConfiguration,
            source: &ProtocolObject<dyn CMIOExtensionStreamSource>,
        ) -> Retained<Self>;

        /// Initialize a stream instance.
        ///
        /// Parameter `localizedName`: The localized name of the stream.
        ///
        /// Parameter `streamID`: The stream identifier.
        ///
        /// Parameter `direction`: The stream direction.
        ///
        /// Parameter `clockType`: The stream clock type.
        ///
        /// Parameter `source`: The stream source.
        ///
        /// Returns: A CMIOExtensionStream instance that provides data.
        ///
        /// Note that the clockType parameter may not be CMIOExtensionStreamClockTypeCustom; that value is reserved for streams created with a custom clock configuration. For streams that have a custom clock, use streamWithLocalizedName:streamID:direction:customClockConfiguration:source:.
        #[unsafe(method(initWithLocalizedName:streamID:direction:clockType:source:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLocalizedName_streamID_direction_clockType_source(
            this: Allocated<Self>,
            localized_name: &NSString,
            stream_id: &NSUUID,
            direction: CMIOExtensionStreamDirection,
            clock_type: CMIOExtensionStreamClockType,
            source: &ProtocolObject<dyn CMIOExtensionStreamSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Initialize a stream instance.
        ///
        /// Parameter `localizedName`: The localized name of the stream.
        ///
        /// Parameter `streamID`: The stream identifier.
        ///
        /// Parameter `direction`: The stream direction.
        ///
        /// Parameter `customClockConfiguration`: A CMIOExtensionStreamCustomClockConfiguration object that defines the custom clock configuration.
        ///
        /// Parameter `source`: The stream source.
        ///
        /// Returns: A CMIOExtensionStream instance that provides data.
        #[unsafe(method(initWithLocalizedName:streamID:direction:customClockConfiguration:source:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLocalizedName_streamID_direction_customClockConfiguration_source(
            this: Allocated<Self>,
            localized_name: &NSString,
            stream_id: &NSUUID,
            direction: CMIOExtensionStreamDirection,
            custom_clock_configuration: &CMIOExtensionStreamCustomClockConfiguration,
            source: &ProtocolObject<dyn CMIOExtensionStreamSource>,
        ) -> Retained<Self>;

        /// The localized name of the stream.
        #[unsafe(method(localizedName))]
        #[unsafe(method_family = none)]
        pub unsafe fn localizedName(&self) -> Retained<NSString>;

        /// The stream identifier.
        #[unsafe(method(streamID))]
        #[unsafe(method_family = none)]
        pub unsafe fn streamID(&self) -> Retained<NSUUID>;

        /// The stream direction.
        #[unsafe(method(direction))]
        #[unsafe(method_family = none)]
        pub unsafe fn direction(&self) -> CMIOExtensionStreamDirection;

        /// The stream clock type.
        ///
        /// If the stream was specified with a custom clock configuration, the returned value will be CMIOExtensionStreamClockTypeCustom.
        #[unsafe(method(clockType))]
        #[unsafe(method_family = none)]
        pub unsafe fn clockType(&self) -> CMIOExtensionStreamClockType;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Custom clock configuration.
        ///
        /// If the stream was specified using a clockType, the returned value will be nil.
        #[unsafe(method(customClockConfiguration))]
        #[unsafe(method_family = none)]
        pub unsafe fn customClockConfiguration(
            &self,
        ) -> Option<Retained<CMIOExtensionStreamCustomClockConfiguration>>;

        /// The stream source.
        #[unsafe(method(source))]
        #[unsafe(method_family = none)]
        pub unsafe fn source(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn CMIOExtensionStreamSource>>>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// The array of streaming clients.
        ///
        /// This property is key-value observable.
        #[unsafe(method(streamingClients))]
        #[unsafe(method_family = none)]
        pub unsafe fn streamingClients(&self) -> Retained<NSArray<CMIOExtensionClient>>;

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Notify client(s) of stream properties changes.
        ///
        /// Parameter `propertyStates`: The dictionary of properties having changed.
        ///
        /// # Safety
        ///
        /// `property_states` generic generic should be of the correct type.
        #[unsafe(method(notifyPropertiesChanged:))]
        #[unsafe(method_family = none)]
        pub unsafe fn notifyPropertiesChanged(
            &self,
            property_states: &NSDictionary<CMIOExtensionProperty, CMIOExtensionPropertyState>,
        );

        #[cfg(feature = "objc2-core-media")]
        /// Send media sample to client(s).
        ///
        /// Parameter `sampleBuffer`: The sample buffer containing media data.
        ///
        /// Parameter `discontinuity`: The discontinuity flag indicating if the sample buffer represents a discontinuity boundary.
        ///
        /// Parameter `hostTimeInNanoseconds`: The host time in nanoseconds when the buffer was captured.
        ///
        /// The sample will be deliver to clients whose media type authorization status is authorized.
        /// The sample buffer timestamps should be relative to the clock timebase specified with clockType.
        /// Attempting to send a sample buffer on a sink stream will throw an exception.
        #[unsafe(method(sendSampleBuffer:discontinuity:hostTimeInNanoseconds:))]
        #[unsafe(method_family = none)]
        pub unsafe fn sendSampleBuffer_discontinuity_hostTimeInNanoseconds(
            &self,
            sample_buffer: &CMSampleBuffer,
            discontinuity: CMIOExtensionStreamDiscontinuityFlags,
            host_time_in_nanoseconds: u64,
        );

        #[cfg(all(
            feature = "CMIOExtensionProperties",
            feature = "block2",
            feature = "objc2-core-media"
        ))]
        /// Consume a sample buffer from a client.
        ///
        /// Parameter `client`: The client.
        ///
        /// Parameter `completionHandler`: A block that will be called when the operation is completed.
        /// If the capture request is successful, the "sampleBuffer" parameter contains a valid CMSampleBuffer, the "sampleBufferSequenceNumber" parameter is the sample buffer sequence number,
        /// the "discontinuity" parameter is the discontinuity flag, the "hasMoreSampleBuffers" parameter indicates whether or not more sample buffers are available, the "error" parameter is nil.
        #[unsafe(method(consumeSampleBufferFromClient:completionHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn consumeSampleBufferFromClient_completionHandler(
            &self,
            client: &CMIOExtensionClient,
            completion_handler: &block2::DynBlock<
                dyn Fn(
                    *mut CMSampleBuffer,
                    u64,
                    CMIOExtensionStreamDiscontinuityFlags,
                    Bool,
                    *mut NSError,
                ),
            >,
        );

        #[cfg(feature = "CMIOExtensionProperties")]
        /// Notify client(s) when a particular buffer was output.
        ///
        /// Parameter `scheduledOutput`: The stream scheduled output.
        #[unsafe(method(notifyScheduledOutputChanged:))]
        #[unsafe(method_family = none)]
        pub unsafe fn notifyScheduledOutputChanged(
            &self,
            scheduled_output: &CMIOExtensionScheduledOutput,
        );
    );
}