1use 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 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 (*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 (*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 (*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 let parent = if (*mem).mem.parent.is_null() {
238 mem
239 } else {
240 (*mem).mem.parent as *mut Memory
241 };
242
243 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 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 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 = (*mem1).mem.offset.wrapping_sub((*parent1).mem.offset);
296 }
297
298 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}