Skip to main content

gstreamer/subclass/
allocator.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::ptr;
4
5use glib::{prelude::*, subclass::prelude::*, translate::*};
6
7use super::prelude::*;
8use crate::{AllocationParams, Allocator, ffi};
9
10pub unsafe trait AllocatorImpl:
11    GstObjectImpl + ObjectSubclass<Type: IsA<Allocator>>
12{
13    unsafe fn alloc(&self, size: usize, params: &AllocationParams) -> *mut ffi::GstMemory {
14        unsafe { self.parent_alloc(size, params) }
15    }
16
17    unsafe fn free(&self, memory: *mut ffi::GstMemory) {
18        unsafe { self.parent_free(memory) }
19    }
20}
21
22pub trait AllocatorImplExt: AllocatorImpl {
23    unsafe fn parent_alloc(&self, size: usize, params: &AllocationParams) -> *mut ffi::GstMemory {
24        unsafe {
25            let data = Self::type_data();
26            let parent_class = data.as_ref().parent_class() as *mut ffi::GstAllocatorClass;
27
28            if let Some(f) = (*parent_class).alloc {
29                f(
30                    self.obj().unsafe_cast_ref::<Allocator>().to_glib_none().0,
31                    size,
32                    mut_override(params.to_glib_none().0),
33                )
34            } else {
35                ptr::null_mut()
36            }
37        }
38    }
39
40    unsafe fn parent_free(&self, memory: *mut ffi::GstMemory) {
41        unsafe {
42            let data = Self::type_data();
43            let parent_class = data.as_ref().parent_class() as *mut ffi::GstAllocatorClass;
44
45            if let Some(f) = (*parent_class).free {
46                f(
47                    self.obj().unsafe_cast_ref::<Allocator>().to_glib_none().0,
48                    memory,
49                )
50            }
51        }
52    }
53}
54
55impl<T: AllocatorImpl> AllocatorImplExt for T {}
56
57unsafe impl<T: AllocatorImpl> IsSubclassable<T> for Allocator {
58    fn class_init(klass: &mut glib::Class<Self>) {
59        Self::parent_class_init::<T>(klass);
60        let klass = klass.as_mut();
61        klass.alloc = Some(alloc::<T>);
62        klass.free = Some(free::<T>);
63    }
64}
65
66unsafe extern "C" fn alloc<T: AllocatorImpl>(
67    ptr: *mut ffi::GstAllocator,
68    size: usize,
69    params: *mut ffi::GstAllocationParams,
70) -> *mut ffi::GstMemory {
71    unsafe {
72        let instance = &*(ptr as *mut T::Instance);
73        let imp = instance.imp();
74
75        let params = &*(params as *mut AllocationParams);
76
77        imp.alloc(size, params)
78    }
79}
80
81unsafe extern "C" fn free<T: AllocatorImpl>(
82    ptr: *mut ffi::GstAllocator,
83    memory: *mut ffi::GstMemory,
84) {
85    unsafe {
86        debug_assert_eq!((*memory).mini_object.refcount, 0);
87
88        let instance = &*(ptr as *mut T::Instance);
89        let imp = instance.imp();
90
91        imp.free(memory);
92    }
93}
94
95#[cfg(test)]
96mod tests {
97    use super::*;
98    use crate::prelude::*;
99
100    // The test allocator below is basically replicating GStreamer's default
101    // sysmem allocator except that the memory allocation is separate from the
102    // memory struct for clarity.
103
104    pub mod imp {
105        use std::alloc;
106
107        use super::*;
108
109        #[repr(C)]
110        struct Memory {
111            mem: ffi::GstMemory,
112            layout: alloc::Layout,
113            data: *mut u8,
114        }
115
116        const LAYOUT: alloc::Layout = alloc::Layout::new::<Memory>();
117
118        #[derive(Default)]
119        pub struct TestAllocator;
120
121        impl ObjectImpl for TestAllocator {}
122        impl GstObjectImpl for TestAllocator {}
123        unsafe impl AllocatorImpl for TestAllocator {
124            unsafe fn alloc(&self, size: usize, params: &AllocationParams) -> *mut ffi::GstMemory {
125                unsafe {
126                    let Some(maxsize) = size
127                        .checked_add(params.prefix())
128                        .and_then(|s| s.checked_add(params.padding()))
129                    else {
130                        return ptr::null_mut();
131                    };
132
133                    let align = params.align() | crate::Memory::default_alignment();
134                    let Ok(layout) = alloc::Layout::from_size_align(maxsize, align + 1) else {
135                        return ptr::null_mut();
136                    };
137
138                    let mem = alloc::alloc(LAYOUT) as *mut Memory;
139
140                    let data = alloc::alloc(layout);
141
142                    if params.prefix() > 0
143                        && params.flags().contains(crate::MemoryFlags::ZERO_PREFIXED)
144                    {
145                        ptr::write_bytes(data, 0, params.prefix());
146                    }
147
148                    if params.flags().contains(crate::MemoryFlags::ZERO_PADDED) {
149                        ptr::write_bytes(data.add(params.prefix()).add(size), 0, params.padding());
150                    }
151
152                    ffi::gst_memory_init(
153                        ptr::addr_of_mut!((*mem).mem),
154                        params.flags().into_glib(),
155                        self.obj().as_ptr() as *mut ffi::GstAllocator,
156                        ptr::null_mut(),
157                        maxsize,
158                        params.align(),
159                        params.prefix(),
160                        size,
161                    );
162                    ptr::write(ptr::addr_of_mut!((*mem).layout), layout);
163                    ptr::write(ptr::addr_of_mut!((*mem).data), data);
164
165                    mem as *mut ffi::GstMemory
166                }
167            }
168
169            unsafe fn free(&self, mem: *mut ffi::GstMemory) {
170                unsafe {
171                    let mem = mem as *mut Memory;
172
173                    if (*mem).mem.parent.is_null() {
174                        alloc::dealloc((*mem).data, (*mem).layout);
175                        ptr::drop_in_place(ptr::addr_of_mut!((*mem).layout));
176                    }
177                    alloc::dealloc(mem as *mut u8, LAYOUT);
178                }
179            }
180        }
181
182        #[glib::object_subclass]
183        impl ObjectSubclass for TestAllocator {
184            const NAME: &'static str = "TestAllocator";
185            type Type = super::TestAllocator;
186            type ParentType = Allocator;
187
188            fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
189                static ALLOCATOR_TYPE: &[u8] = b"TestAllocatorMemory\0";
190
191                unsafe {
192                    let allocator = obj.as_ptr() as *mut ffi::GstAllocator;
193
194                    // TODO: This should all be in some kind of trait ideally
195                    (*allocator).mem_type = ALLOCATOR_TYPE.as_ptr() as *const _;
196                    (*allocator).mem_map = Some(TestAllocator::mem_map);
197                    (*allocator).mem_unmap = Some(TestAllocator::mem_unmap);
198                    // mem_copy not set because the fallback already does the right thing
199                    (*allocator).mem_share = Some(TestAllocator::mem_share);
200                    (*allocator).mem_is_span = Some(TestAllocator::mem_is_span);
201                }
202            }
203        }
204
205        impl TestAllocator {
206            unsafe extern "C" fn mem_map(
207                mem: *mut ffi::GstMemory,
208                _maxsize: usize,
209                _flags: ffi::GstMapFlags,
210            ) -> glib::ffi::gpointer {
211                unsafe {
212                    let mem = mem as *mut Memory;
213
214                    let parent = if (*mem).mem.parent.is_null() {
215                        mem
216                    } else {
217                        (*mem).mem.parent as *mut Memory
218                    };
219
220                    // `(*mem).offset` is added to the pointer by `gst_memory_map()`
221                    (*parent).data as *mut _
222                }
223            }
224
225            unsafe extern "C" fn mem_unmap(_mem: *mut ffi::GstMemory) {}
226
227            unsafe extern "C" fn mem_share(
228                mem: *mut ffi::GstMemory,
229                offset: isize,
230                size: isize,
231            ) -> *mut ffi::GstMemory {
232                unsafe {
233                    let mem = mem as *mut Memory;
234
235                    // Basically a re-implementation of _sysmem_share()
236
237                    let parent = if (*mem).mem.parent.is_null() {
238                        mem
239                    } else {
240                        (*mem).mem.parent as *mut Memory
241                    };
242
243                    // Offset and size are actually usizes and the API assumes that negative values simply wrap
244                    // around, so let's cast to usizes here and do wrapping arithmetic.
245                    let offset = offset as usize;
246                    let mut size = size as usize;
247
248                    let new_offset = (*mem).mem.offset.wrapping_add(offset);
249                    debug_assert!(new_offset < (*mem).mem.maxsize);
250
251                    if size == usize::MAX {
252                        size = (*mem).mem.size.wrapping_sub(offset);
253                    }
254                    debug_assert!(new_offset <= usize::MAX - size);
255                    debug_assert!(new_offset + size <= (*mem).mem.maxsize);
256
257                    let sub = alloc::alloc(LAYOUT) as *mut Memory;
258
259                    ffi::gst_memory_init(
260                        sub as *mut ffi::GstMemory,
261                        (*mem).mem.mini_object.flags | ffi::GST_MINI_OBJECT_FLAG_LOCK_READONLY,
262                        (*mem).mem.allocator,
263                        parent as *mut ffi::GstMemory,
264                        (*mem).mem.maxsize,
265                        (*mem).mem.align,
266                        new_offset,
267                        size,
268                    );
269                    // This is never actually accessed
270                    ptr::write(ptr::addr_of_mut!((*sub).data), ptr::null_mut());
271
272                    sub as *mut ffi::GstMemory
273                }
274            }
275
276            unsafe extern "C" fn mem_is_span(
277                mem1: *mut ffi::GstMemory,
278                mem2: *mut ffi::GstMemory,
279                offset: *mut usize,
280            ) -> glib::ffi::gboolean {
281                unsafe {
282                    let mem1 = mem1 as *mut Memory;
283                    let mem2 = mem2 as *mut Memory;
284
285                    // Same parent is checked by `gst_memory_is_span()` already
286                    let parent1 = (*mem1).mem.parent as *mut Memory;
287                    let parent2 = (*mem2).mem.parent as *mut Memory;
288                    debug_assert_eq!(parent1, parent2);
289
290                    if !offset.is_null() {
291                        // Offset that can be used on the parent memory to create a
292                        // shared memory that starts with `mem1`.
293                        //
294                        // This needs to use wrapping arithmetic too as in `mem_share()`.
295                        *offset = (*mem1).mem.offset.wrapping_sub((*parent1).mem.offset);
296                    }
297
298                    // Check if both memories are contiguous.
299                    let is_span = ((*mem1).mem.offset + ((*mem1).mem.size)) == (*mem2).mem.offset;
300
301                    is_span.into_glib()
302                }
303            }
304        }
305    }
306
307    glib::wrapper! {
308        pub struct TestAllocator(ObjectSubclass<imp::TestAllocator>) @extends Allocator, crate::Object;
309    }
310
311    impl Default for TestAllocator {
312        fn default() -> Self {
313            glib::Object::new()
314        }
315    }
316
317    #[test]
318    fn test_allocator_registration() {
319        crate::init().unwrap();
320
321        const TEST_ALLOCATOR_NAME: &str = "TestAllocator";
322
323        let allocator = TestAllocator::default();
324        Allocator::register(TEST_ALLOCATOR_NAME, allocator);
325
326        let allocator = Allocator::find(Some(TEST_ALLOCATOR_NAME));
327
328        assert!(allocator.is_some());
329    }
330
331    #[test]
332    fn test_allocator_alloc() {
333        crate::init().unwrap();
334
335        const SIZE: usize = 1024;
336
337        let allocator = TestAllocator::default();
338
339        let memory = allocator.alloc(SIZE, None).unwrap();
340
341        assert_eq!(memory.size(), SIZE);
342    }
343
344    #[test]
345    fn test_allocator_mem_ops() {
346        crate::init().unwrap();
347
348        let data = [0, 1, 2, 3, 4, 5, 6, 7];
349
350        let allocator = TestAllocator::default();
351
352        let mut memory = allocator.alloc(data.len(), None).unwrap();
353        assert_eq!(memory.size(), data.len());
354
355        {
356            let memory = memory.get_mut().unwrap();
357            let mut map = memory.map_writable().unwrap();
358            map.copy_from_slice(&data);
359        }
360
361        let copy = memory.copy();
362        assert!(copy.parent().is_none());
363
364        {
365            let map1 = memory.map_readable().unwrap();
366            let map2 = copy.map_readable().unwrap();
367            assert_eq!(map1.as_slice(), map2.as_slice());
368        }
369
370        let share = memory.share(..);
371        assert_eq!(share.parent().unwrap().as_ptr(), memory.as_ptr());
372
373        {
374            let map1 = memory.map_readable().unwrap();
375            let map2 = share.map_readable().unwrap();
376            assert_eq!(map1.as_slice(), map2.as_slice());
377        }
378
379        let sub1 = memory.share(..2);
380        assert_eq!(sub1.size(), 2);
381        assert_eq!(sub1.parent().unwrap().as_ptr(), memory.as_ptr());
382
383        {
384            let map = sub1.map_readable().unwrap();
385            assert_eq!(map.as_slice(), &data[..2]);
386        }
387
388        let sub2 = memory.share(2..);
389        assert_eq!(sub2.size(), 6);
390        assert_eq!(sub2.parent().unwrap().as_ptr(), memory.as_ptr());
391
392        {
393            let map = sub2.map_readable().unwrap();
394            assert_eq!(map.as_slice(), &data[2..]);
395        }
396
397        let offset = sub1.is_span(&sub2).unwrap();
398        assert_eq!(offset, 0);
399
400        let sub3 = sub2.share(2..);
401        assert_eq!(sub3.size(), 4);
402        assert_eq!(sub3.parent().unwrap().as_ptr(), memory.as_ptr());
403
404        {
405            let map = sub3.map_readable().unwrap();
406            assert_eq!(map.as_slice(), &data[4..]);
407        }
408    }
409}