gstreamer_vulkan/auto/

vulkan_instance.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT

use crate::{ffi, VulkanDevice};
#[cfg(feature = "v1_26")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
use glib::object::ObjectType as _;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `requested-api-major`
    ///  Readable | Writeable
    ///
    ///
    /// #### `requested-api-minor`
    ///  Readable | Writeable
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `name`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `parent`
    ///  The parent of the object. Please note, that when changing the 'parent'
    /// property, we don't emit [`notify`][struct@crate::glib::Object#notify] and [`deep-notify`][struct@crate::gst::Object#deep-notify]
    /// signals due to locking issues. In some cases one can use
    /// `GstBin::element-added` or `GstBin::element-removed` signals on the parent to
    /// achieve a similar effect.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `create-device`
    ///  Overrides the [`VulkanDevice`][crate::VulkanDevice] creation mechanism.
    /// It can be called from any thread.
    ///
    ///
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `deep-notify`
    ///  The deep notify signal is used to be notified of property changes. It is
    /// typically attached to the toplevel bin to receive notifications from all
    /// the elements contained in that bin.
    ///
    /// Detailed
    /// </details>
    ///
    /// # Implements
    ///
    /// [`VulkanInstanceExt`][trait@crate::prelude::VulkanInstanceExt], [`trait@gst::prelude::ObjectExt`], [`trait@glib::ObjectExt`]
    #[doc(alias = "GstVulkanInstance")]
    pub struct VulkanInstance(Object<ffi::GstVulkanInstance, ffi::GstVulkanInstanceClass>) @extends gst::Object;

    match fn {
        type_ => || ffi::gst_vulkan_instance_get_type(),
    }
}

impl VulkanInstance {
    pub const NONE: Option<&'static VulkanInstance> = None;

    ///
    /// # Returns
    ///
    /// a new uninitialized [`VulkanInstance`][crate::VulkanInstance]
    #[doc(alias = "gst_vulkan_instance_new")]
    pub fn new() -> VulkanInstance {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gst_vulkan_instance_new()) }
    }

    /// If a [`VulkanInstance`][crate::VulkanInstance] is requested in `query`, sets `instance` as the reply.
    ///
    /// Intended for use with element query handlers to respond to `GST_QUERY_CONTEXT`
    /// for a [`VulkanInstance`][crate::VulkanInstance].
    /// ## `element`
    /// a [`gst::Element`][crate::gst::Element]
    /// ## `query`
    /// a [`gst::Query`][crate::gst::Query] of type `GST_QUERY_CONTEXT`
    /// ## `instance`
    /// the [`VulkanInstance`][crate::VulkanInstance]
    ///
    /// # Returns
    ///
    /// whether `query` was responded to with `instance`
    #[doc(alias = "gst_vulkan_instance_handle_context_query")]
    pub fn handle_context_query(
        element: &impl IsA<gst::Element>,
        query: &gst::Query,
        instance: Option<&impl IsA<VulkanInstance>>,
    ) -> bool {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::gst_vulkan_instance_handle_context_query(
                element.as_ref().to_glib_none().0,
                query.to_glib_none().0,
                instance.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gst_vulkan_instance_run_context_query")]
    //pub fn run_context_query(element: &impl IsA<gst::Element>, instance: impl IsA<VulkanInstance>) -> bool {
    //    unsafe { TODO: call ffi:gst_vulkan_instance_run_context_query() }
    //}
}

impl Default for VulkanInstance {
    fn default() -> Self {
        Self::new()
    }
}

unsafe impl Send for VulkanInstance {}
unsafe impl Sync for VulkanInstance {}

/// Trait containing all [`struct@VulkanInstance`] methods.
///
/// # Implementors
///
/// [`VulkanInstance`][struct@crate::VulkanInstance]
pub trait VulkanInstanceExt: IsA<VulkanInstance> + 'static {
    /// ## `major`
    /// the API major version to check
    /// ## `minor`
    /// the API minor version to check
    /// ## `patch`
    /// the API patch version to check
    ///
    /// # Returns
    ///
    /// whether the [`VulkanInstance`][crate::VulkanInstance] supports the version specified
    ///  by `major`, `minor` and `patch`.
    #[cfg(feature = "v1_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
    #[doc(alias = "gst_vulkan_instance_check_api_version")]
    fn check_api_version(&self, major: u32, minor: u32, patch: u32) -> bool {
        unsafe {
            from_glib(ffi::gst_vulkan_instance_check_api_version(
                self.as_ref().to_glib_none().0,
                major,
                minor,
                patch,
            ))
        }
    }

    /// Check if the configured vulkan instance supports the specified version.
    /// Will not work prior to opening the instance with [`open()`][Self::open()].
    /// If a specific version is requested, the `patch` level is ignored.
    /// ## `major`
    /// major version
    /// ## `minor`
    /// minor version
    /// ## `patch`
    /// patch version
    ///
    /// # Returns
    ///
    /// whether `self` is at least the requested version.
    #[doc(alias = "gst_vulkan_instance_check_version")]
    fn check_version(&self, major: u32, minor: u32, patch: u32) -> bool {
        unsafe {
            from_glib(ffi::gst_vulkan_instance_check_version(
                self.as_ref().to_glib_none().0,
                major,
                minor,
                patch,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// a new [`VulkanDevice`][crate::VulkanDevice]
    #[doc(alias = "gst_vulkan_instance_create_device")]
    fn create_device(&self) -> Result<VulkanDevice, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret =
                ffi::gst_vulkan_instance_create_device(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// ## `device_index`
    /// the device index to create the new [`VulkanDevice`][crate::VulkanDevice] from
    ///
    /// # Returns
    ///
    /// a new [`VulkanDevice`][crate::VulkanDevice]
    #[cfg(feature = "v1_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
    #[doc(alias = "gst_vulkan_instance_create_device_with_index")]
    fn create_device_with_index(&self, device_index: u32) -> Result<VulkanDevice, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::gst_vulkan_instance_create_device_with_index(
                self.as_ref().to_glib_none().0,
                device_index,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Disable an Vulkan extension by `name`. Disabling an extension will only have
    /// an effect before the call to [`open()`][Self::open()].
    /// ## `name`
    /// extension name to enable
    ///
    /// # Returns
    ///
    /// whether the Vulkan extension could be disabled.
    #[doc(alias = "gst_vulkan_instance_disable_extension")]
    fn disable_extension(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::gst_vulkan_instance_disable_extension(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    /// Enable an Vulkan extension by `name`. Extensions cannot be enabled until
    /// [`fill_info()`][Self::fill_info()] has been called. Enabling an extension will
    /// only have an effect before the call to [`open()`][Self::open()].
    /// ## `name`
    /// extension name to enable
    ///
    /// # Returns
    ///
    /// whether the Vulkan extension could be enabled.
    #[doc(alias = "gst_vulkan_instance_enable_extension")]
    fn enable_extension(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::gst_vulkan_instance_enable_extension(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    /// Enable an Vulkan layer by `name`. Layer cannot be enabled until
    /// [`fill_info()`][Self::fill_info()] has been called. Enabling a layer will
    /// only have an effect before the call to [`open()`][Self::open()].
    /// ## `name`
    /// layer name to enable
    ///
    /// # Returns
    ///
    /// whether the Vulkan layer could be enabled.
    #[doc(alias = "gst_vulkan_instance_enable_layer")]
    fn enable_layer(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::gst_vulkan_instance_enable_layer(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    /// Retrieve as much information about the available Vulkan instance without
    /// actually creating an Vulkan instance. Will not do anything while `self`
    /// is open.
    ///
    /// # Returns
    ///
    /// whether the instance information could be retrieved
    #[doc(alias = "gst_vulkan_instance_fill_info")]
    fn fill_info(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok =
                ffi::gst_vulkan_instance_fill_info(self.as_ref().to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the vulkan API version configured when constructing the
    /// [`VulkanInstance`][crate::VulkanInstance]. This value can be any valid Vulkan API version and may
    /// not match [`version()`][Self::version()] in any way. This version is the
    /// maximum allowed vulkan API to be used in any capacity.
    ///
    /// This will not return valid values until [`open()`][Self::open()] has been
    /// called.
    ///
    /// # Returns
    ///
    ///
    /// ## `major`
    /// major version
    ///
    /// ## `minor`
    /// minor version
    ///
    /// ## `patch`
    /// patch version
    #[cfg(feature = "v1_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
    #[doc(alias = "gst_vulkan_instance_get_api_version")]
    #[doc(alias = "get_api_version")]
    fn api_version(&self) -> (u32, u32, u32) {
        unsafe {
            let mut major = std::mem::MaybeUninit::uninit();
            let mut minor = std::mem::MaybeUninit::uninit();
            let mut patch = std::mem::MaybeUninit::uninit();
            ffi::gst_vulkan_instance_get_api_version(
                self.as_ref().to_glib_none().0,
                major.as_mut_ptr(),
                minor.as_mut_ptr(),
                patch.as_mut_ptr(),
            );
            (
                major.assume_init(),
                minor.assume_init(),
                patch.assume_init(),
            )
        }
    }

    /// Retrieves information about an extension.
    ///
    /// Will not find any extensions before [`fill_info()`][Self::fill_info()] has been
    /// called.
    /// ## `name`
    /// the layer name to look for
    ///
    /// # Returns
    ///
    /// whether extension `name` is available
    ///
    /// ## `spec_version`
    /// return value for the layer specification version
    #[doc(alias = "gst_vulkan_instance_get_extension_info")]
    #[doc(alias = "get_extension_info")]
    fn extension_info(&self, name: &str) -> Option<u32> {
        unsafe {
            let mut spec_version = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gst_vulkan_instance_get_extension_info(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                spec_version.as_mut_ptr(),
            ));
            if ret {
                Some(spec_version.assume_init())
            } else {
                None
            }
        }
    }

    /// Retrieves information about a layer.
    ///
    /// Will not find any layers before [`fill_info()`][Self::fill_info()] has been
    /// called.
    /// ## `name`
    /// the layer name to look for
    ///
    /// # Returns
    ///
    /// whether layer `name` is available
    ///
    /// ## `description`
    /// return value for the layer description or [`None`]
    ///
    /// ## `spec_version`
    /// return value for the layer specification version
    ///
    /// ## `implementation_version`
    /// return value for the layer implementation version
    #[doc(alias = "gst_vulkan_instance_get_layer_info")]
    #[doc(alias = "get_layer_info")]
    fn layer_info(&self, name: &str) -> Option<(Option<glib::GString>, u32, u32)> {
        unsafe {
            let mut description = std::ptr::null_mut();
            let mut spec_version = std::mem::MaybeUninit::uninit();
            let mut implementation_version = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gst_vulkan_instance_get_layer_info(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                &mut description,
                spec_version.as_mut_ptr(),
                implementation_version.as_mut_ptr(),
            ));
            if ret {
                Some((
                    from_glib_full(description),
                    spec_version.assume_init(),
                    implementation_version.assume_init(),
                ))
            } else {
                None
            }
        }
    }

    //#[doc(alias = "gst_vulkan_instance_get_proc_address")]
    //#[doc(alias = "get_proc_address")]
    //fn proc_address(&self, name: &str) -> /*Unimplemented*/Option<Basic: Pointer> {
    //    unsafe { TODO: call ffi:gst_vulkan_instance_get_proc_address() }
    //}

    /// Retrieve the vulkan instance supported version. Only returns the supported
    /// API version by the instance without taking into account the requested API
    /// version. This means [`check_version()`][Self::check_version()] will return
    /// different values if a specific version has been requested (which is the
    /// default) than a version check that is performed manually by retrieving the
    /// version with this function.
    ///
    /// # Returns
    ///
    ///
    /// ## `major`
    /// major version
    ///
    /// ## `minor`
    /// minor version
    ///
    /// ## `patch`
    /// patch version
    #[doc(alias = "gst_vulkan_instance_get_version")]
    #[doc(alias = "get_version")]
    fn version(&self) -> (u32, u32, u32) {
        unsafe {
            let mut major = std::mem::MaybeUninit::uninit();
            let mut minor = std::mem::MaybeUninit::uninit();
            let mut patch = std::mem::MaybeUninit::uninit();
            ffi::gst_vulkan_instance_get_version(
                self.as_ref().to_glib_none().0,
                major.as_mut_ptr(),
                minor.as_mut_ptr(),
                patch.as_mut_ptr(),
            );
            (
                major.assume_init(),
                minor.assume_init(),
                patch.assume_init(),
            )
        }
    }

    /// ## `name`
    /// extension name
    ///
    /// # Returns
    ///
    /// whether extension `name` is enabled
    #[doc(alias = "gst_vulkan_instance_is_extension_enabled")]
    fn is_extension_enabled(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::gst_vulkan_instance_is_extension_enabled(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    /// ## `name`
    /// layer name
    ///
    /// # Returns
    ///
    /// whether layer `name` is enabled
    #[doc(alias = "gst_vulkan_instance_is_layer_enabled")]
    fn is_layer_enabled(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::gst_vulkan_instance_is_layer_enabled(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// whether the instance could be created
    #[doc(alias = "gst_vulkan_instance_open")]
    fn open(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gst_vulkan_instance_open(self.as_ref().to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "requested-api-major")]
    fn requested_api_major(&self) -> u32 {
        ObjectExt::property(self.as_ref(), "requested-api-major")
    }

    #[doc(alias = "requested-api-major")]
    fn set_requested_api_major(&self, requested_api_major: u32) {
        ObjectExt::set_property(self.as_ref(), "requested-api-major", requested_api_major)
    }

    #[doc(alias = "requested-api-minor")]
    fn requested_api_minor(&self) -> u32 {
        ObjectExt::property(self.as_ref(), "requested-api-minor")
    }

    #[doc(alias = "requested-api-minor")]
    fn set_requested_api_minor(&self, requested_api_minor: u32) {
        ObjectExt::set_property(self.as_ref(), "requested-api-minor", requested_api_minor)
    }

    /// Overrides the [`VulkanDevice`][crate::VulkanDevice] creation mechanism.
    /// It can be called from any thread.
    /// ## `device_index`
    /// the index of the device
    ///
    /// # Returns
    ///
    /// the newly created [`VulkanDevice`][crate::VulkanDevice].
    #[cfg(feature = "v1_26")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
    #[doc(alias = "create-device")]
    fn connect_create_device<F: Fn(&Self, u32) -> VulkanDevice + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn create_device_trampoline<
            P: IsA<VulkanInstance>,
            F: Fn(&P, u32) -> VulkanDevice + Send + Sync + 'static,
        >(
            this: *mut ffi::GstVulkanInstance,
            device_index: std::ffi::c_uint,
            f: glib::ffi::gpointer,
        ) -> *mut ffi::GstVulkanDevice {
            let f: &F = &*(f as *const F);
            f(
                VulkanInstance::from_glib_borrow(this).unsafe_cast_ref(),
                device_index,
            )
            .to_glib_full()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"create-device".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    create_device_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "requested-api-major")]
    fn connect_requested_api_major_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_requested_api_major_trampoline<
            P: IsA<VulkanInstance>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstVulkanInstance,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(VulkanInstance::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::requested-api-major".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_requested_api_major_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "requested-api-minor")]
    fn connect_requested_api_minor_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_requested_api_minor_trampoline<
            P: IsA<VulkanInstance>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstVulkanInstance,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(VulkanInstance::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::requested-api-minor".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_requested_api_minor_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<VulkanInstance>> VulkanInstanceExt for O {}