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

/// Trait implemented for buffers that can be resized.
pub trait ResizableBuf {
    /// Ensure that the audio buffer has space for at least the given `capacity`
    /// of contiguous memory. The `capacity` is specified in number of
    /// [Samples][crate::Buf::Sample].
    ///
    /// This is a no-op unless the underlying buffer is contiguous in memory
    /// which can be ensured by requiring traits such as
    /// [InterleavedBufMut][crate::InterleavedBufMut].
    ///
    /// This returns a boolean indicating if we could successfully reserve the
    /// given amount of memory. The caller can only assume that a buffer is
    /// present up to the given number of samples if it returns `true`. This is
    /// important to observe if the code you're working on has safety
    /// implications.
    ///
    /// A typical approach in case a reservation fails is to either panic or
    /// return an error indicating that the provided buffer is not supported.
    fn try_reserve(&mut self, capacity: usize) -> bool;

    /// Resize the number of per-channel frames in the buffer.
    ///
    /// # Examples
    ///
    /// ```
    /// use audio::{Buf, ExactSizeBuf, ResizableBuf};
    ///
    /// fn test(mut buffer: impl ResizableBuf) {
    ///     buffer.resize_frames(4);
    /// }
    ///
    /// let mut buf = audio::interleaved![[0; 0]; 2];
    ///
    /// assert_eq!(buf.channels(), 2);
    /// assert_eq!(buf.frames(), 0);
    ///
    /// test(&mut buf);
    ///
    /// assert_eq!(buf.channels(), 2);
    /// assert_eq!(buf.frames(), 4);
    /// ```
    fn resize_frames(&mut self, frames: usize);

    /// Resize the buffer to match the given topology.
    ///
    /// # Examples
    ///
    /// ```
    /// use audio::ResizableBuf;
    ///
    /// fn test(mut buf: impl ResizableBuf) {
    ///     buf.resize_topology(2, 4);
    /// }
    ///
    /// let mut buf = audio::interleaved![[0; 0]; 4];
    ///
    /// test(&mut buf);
    ///
    /// assert_eq!(buf.channels(), 2);
    /// assert_eq!(buf.frames(), 4);
    /// ```
    fn resize_topology(&mut self, channels: usize, frames: usize);
}

impl<B> ResizableBuf for &mut B
where
    B: ?Sized + ResizableBuf,
{
    fn try_reserve(&mut self, capacity: usize) -> bool {
        (**self).try_reserve(capacity)
    }

    fn resize_frames(&mut self, frames: usize) {
        (**self).resize_frames(frames);
    }

    fn resize_topology(&mut self, channels: usize, frames: usize) {
        (**self).resize_topology(channels, frames);
    }
}