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
/// A trait describing a buffer that is interleaved and mutable. /// /// This allows for accessing the raw underlying interleaved buffer. pub trait AsInterleavedMut<T> { /// Access the underlying interleaved mutable buffer. /// /// # Examples /// /// ```rust /// use rotary::{Channels, AsInterleaved, AsInterleavedMut}; /// use rotary::wrap; /// /// fn test<B>(mut buffer: B) where B: Channels<i16> + AsInterleavedMut<i16> { /// buffer.as_interleaved_mut().copy_from_slice(&[1, 1, 2, 2, 3, 3, 4, 4]); /// /// assert_eq! { /// buffer.channel(0).iter().collect::<Vec<_>>(), /// &[1, 2, 3, 4], /// }; /// /// assert_eq! { /// buffer.channel(1).iter().collect::<Vec<_>>(), /// &[1, 2, 3, 4], /// }; /// /// assert_eq!(buffer.as_interleaved(), &[1, 1, 2, 2, 3, 3, 4, 4]); /// } /// /// test(rotary::interleaved![[0; 4]; 2]); /// let mut buf = [0; 8]; /// test(wrap::interleaved(&mut buf, 2)); /// ``` fn as_interleaved_mut(&mut self) -> &mut [T]; /// Access a pointer to the underlying interleaved mutable buffer. /// /// The length of the buffer is unspecified, unless preceded by a call to /// [reserve_frames]. Assuming the call doesn't panic, the pointed to buffer /// is guaranteed to be both allocated and initialized up until the number /// of frames as specified as argument to [reserve_frames]. /// /// [reserve_frames]: crate::InterleavedBuf::reserve_frames /// /// # Examples /// /// ```rust /// use rotary::{AsInterleavedMut, InterleavedBuf, Channels}; /// # unsafe fn fill_with_ones(buf: *mut i16, len: usize) -> (usize, usize) { /// # let buf = std::slice::from_raw_parts_mut(buf, len); /// # /// # for (o, b) in buf.iter_mut().zip(std::iter::repeat(1)) { /// # *o = b; /// # } /// # /// # (2, len / 2) /// # } /// /// fn test<B>(mut buffer: B) where B: InterleavedBuf + AsInterleavedMut<i16> { /// buffer.reserve_frames(16); /// // Note: call fills the buffer with ones. /// // Safety: We've initialized exactly 16 frames before calling this /// // function. /// let (channels, frames) = unsafe { fill_with_ones(buffer.as_interleaved_mut_ptr(), 16) }; /// buffer.set_topology(channels, frames); /// } /// /// let mut buf = rotary::Interleaved::new(); /// test(&mut buf); /// /// assert_eq! { /// buf.channel(0).iter().collect::<Vec<_>>(), /// &[1, 1, 1, 1, 1, 1, 1, 1], /// }; /// assert_eq! { /// buf.channel(1).iter().collect::<Vec<_>>(), /// &[1, 1, 1, 1, 1, 1, 1, 1], /// }; /// ``` fn as_interleaved_mut_ptr(&mut self) -> *mut T { self.as_interleaved_mut().as_mut_ptr() } } impl<B, T> AsInterleavedMut<T> for &mut B where B: ?Sized + AsInterleavedMut<T>, { fn as_interleaved_mut(&mut self) -> &mut [T] { (**self).as_interleaved_mut() } fn as_interleaved_mut_ptr(&mut self) -> *mut T { (**self).as_interleaved_mut_ptr() } }