1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// 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::AllocationParams;
use crate::Memory;
use crate::Object;
use glib::object::IsA;
use glib::translate::*;

glib::wrapper! {
    /// Memory is usually created by allocators with a [`crate::prelude::AllocatorExt::alloc()`]
    /// method call. When [`None`] is used as the allocator, the default allocator will
    /// be used.
    ///
    /// New allocators can be registered with [`Self::register()`].
    /// Allocators are identified by name and can be retrieved with
    /// [`Self::find()`]. [`crate::prelude::AllocatorExt::set_default()`] can be used to change the
    /// default allocator.
    ///
    /// New memory can be created with [`crate::Memory::new_wrapped()`] that wraps the memory
    /// allocated elsewhere.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`trait@crate::prelude::AllocatorExt`], [`trait@crate::prelude::GstObjectExt`], [`trait@glib::object::ObjectExt`]
    pub struct Allocator(Object<ffi::GstAllocator, ffi::GstAllocatorClass>) @extends Object;

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

impl Allocator {
    /// Find a previously registered allocator with `name`. When `name` is [`None`], the
    /// default allocator will be returned.
    /// ## `name`
    /// the name of the allocator
    ///
    /// # Returns
    ///
    /// a [`crate::Allocator`] or [`None`] when
    /// the allocator with `name` was not registered. Use [`crate::prelude::GstObjectExt::unref()`]
    /// to release the allocator after usage.
    #[doc(alias = "gst_allocator_find")]
    pub fn find(name: Option<&str>) -> Option<Allocator> {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gst_allocator_find(name.to_glib_none().0)) }
    }

    /// Registers the memory `allocator` with `name`. This function takes ownership of
    /// `allocator`.
    /// ## `name`
    /// the name of the allocator
    /// ## `allocator`
    /// [`crate::Allocator`]
    #[doc(alias = "gst_allocator_register")]
    pub fn register<P: IsA<Allocator>>(name: &str, allocator: &P) {
        skip_assert_initialized!();
        unsafe {
            ffi::gst_allocator_register(name.to_glib_none().0, allocator.as_ref().to_glib_full());
        }
    }
}

unsafe impl Send for Allocator {}
unsafe impl Sync for Allocator {}

pub const NONE_ALLOCATOR: Option<&Allocator> = None;

/// Trait containing all `Allocator` methods.
///
/// # Implementors
///
/// [`struct@crate::Allocator`]
pub trait AllocatorExt: 'static {
    /// Use `self` to allocate a new memory block with memory that is at least
    /// `size` big.
    ///
    /// The optional `params` can specify the prefix and padding for the memory. If
    /// [`None`] is passed, no flags, no extra prefix/padding and a default alignment is
    /// used.
    ///
    /// The prefix/padding will be filled with 0 if flags contains
    /// [`crate::MemoryFlags::ZeroPrefixed`] and [`crate::MemoryFlags::ZeroPadded`] respectively.
    ///
    /// When `self` is [`None`], the default allocator will be used.
    ///
    /// The alignment in `params` is given as a bitmask so that `align` + 1 equals
    /// the amount of bytes to align to. For example, to align to 8 bytes,
    /// use an alignment of 7.
    /// ## `size`
    /// size of the visible memory area
    /// ## `params`
    /// optional parameters
    ///
    /// # Returns
    ///
    /// a new [`crate::Memory`].
    #[doc(alias = "gst_allocator_alloc")]
    fn alloc(
        &self,
        size: usize,
        params: Option<&AllocationParams>,
    ) -> Result<Memory, glib::BoolError>;

    /// Set the default allocator. This function takes ownership of `self`.
    #[doc(alias = "gst_allocator_set_default")]
    fn set_default(&self);
}

impl<O: IsA<Allocator>> AllocatorExt for O {
    fn alloc(
        &self,
        size: usize,
        params: Option<&AllocationParams>,
    ) -> Result<Memory, glib::BoolError> {
        unsafe {
            Option::<_>::from_glib_full(ffi::gst_allocator_alloc(
                self.as_ref().to_glib_none().0,
                size,
                mut_override(params.to_glib_none().0),
            ))
            .ok_or_else(|| glib::bool_error!("Failed to allocate memory"))
        }
    }

    fn set_default(&self) {
        unsafe {
            ffi::gst_allocator_set_default(self.as_ref().to_glib_full());
        }
    }
}