Fix input callback buffer resizing

This is related to #90.

I have an issue on the iOS simulator with `kAudio_ParamError` validation
errors complaining about mismatches in the buffer sizes.

I have identified an issue around `buffer.mDataByteSize` not matching
the input frames parameter.

```rust
// render_callback.rs # 638
let ptr = buffer.mData as *mut u8;
let len = buffer.mDataByteSize as usize;
let cap = len;
let mut vec = Vec::from_raw_parts(ptr, len, cap);
match len.cmp(&data_byte_size) {
    Ordering::Greater => {
        vec.truncate(data_byte_size);
    }
    Ordering::Less => {
        vec.reserve_exact(data_byte_size - len);
    }
    Ordering::Equal => {}
}
mem::forget(vec);
```

Additionally, the`Vec::truncate` and `Vec::reserve_exact` don't seem
will do good things.

* `Vec::truncate` will only run the destructors for the extra entries;
  since it's a `Vec<u8>` it should noop. I believe this can be deleted
* `Vec::reserve_exact` would de-allocate the buffer, which would cause
  use after free somewhere when `mData` is used

On this same file `mData: data.as_mut_ptr() as *mut _,` the audio buffer
pointer is set to the internal `Vec` pointer. That pointer will be
deallocated on reserve/resize if the Vec is under capacity.

`Vec::from_raw_parts` `cap` is reset to `len` every time, which doesn't
seem right. If the buffer shrinks then grows (which is what seems to
happen for me using the iOS simulator), then this block is always
allocating a new buffer (while the one actually in use is dangling).

When `Vec::from_raw_parts(ptr, len, cap).reserve(10000)` is called, that
`mData` pointer is now dangling.

This commit modifies this block so that _if the buffers are resized_:

* `mData` pointer is updated to point at a valid memory location
* `mDataByteSize` is updated with the current frame count
* Capacity is preserved between runs so that the buffer isn't
  re-allocated often
  - Note, this depends on a single `buffer_capacity`, so this code
    assumes there's only 1 buffer to resize

Author: yamadapc

src/audio_unit/render_callback.rs

@@ -1,7 +1,6 @@
 use super::audio_format::LinearPcmFlags;
 use super::{AudioUnit, Element, Scope};
 use crate::error::{self, Error};
-use std::cmp::Ordering;
 use std::mem;
 use std::os::raw::c_void;
 use std::slice;
@@ -580,12 +579,14 @@ impl AudioUnit {
 
         let data_byte_size = buffer_frame_size * sample_bytes as u32 * n_channels;
         let mut data = vec![0u8; data_byte_size as usize];
+        let mut buffer_capacity = data_byte_size as usize;
         let audio_buffer = sys::AudioBuffer {
             mDataByteSize: data_byte_size,
             mNumberChannels: n_channels,
             mData: data.as_mut_ptr() as *mut _,
         };
         // Relieve ownership of the `Vec` until we're ready to drop the `AudioBufferList`.
+        // TODO: This leaks the len & capacity fields, since only the buffer pointer is released
         mem::forget(data);
 
         let audio_buffer_list = Box::new(sys::AudioBufferList {
@@ -627,24 +628,21 @@ impl AudioUnit {
                     let n_channels = stream_format.channels;
                     let data_byte_size =
                         in_number_frames as usize * sample_bytes * n_channels as usize;
-                    let ptr = (*audio_buffer_list_ptr).mBuffers.as_ptr() as *const sys::AudioBuffer;
+                    let ptr = (*audio_buffer_list_ptr).mBuffers.as_ptr() as *mut sys::AudioBuffer;
                     let len = (*audio_buffer_list_ptr).mNumberBuffers as usize;
 
-                    let buffers: &[sys::AudioBuffer] = slice::from_raw_parts(ptr, len);
-                    for &buffer in buffers {
-                        let ptr = buffer.mData as *mut u8;
-                        let len = buffer.mDataByteSize as usize;
-                        let cap = len;
-                        let mut vec = Vec::from_raw_parts(ptr, len, cap);
-                        match len.cmp(&data_byte_size) {
-                            Ordering::Greater => {
-                                vec.truncate(data_byte_size);
-                            }
-                            Ordering::Less => {
-                                vec.reserve_exact(data_byte_size - len);
-                            }
-                            Ordering::Equal => {}
-                        }
+                    let buffers: &mut [sys::AudioBuffer] = slice::from_raw_parts_mut(ptr, len);
+                    let old_capacity = buffer_capacity;
+                    for buffer in buffers {
+                        let current_len = buffer.mDataByteSize as usize;
+                        let audio_buffer_ptr = buffer.mData as *mut u8;
+                        let mut vec: Vec<u8> =
+                            Vec::from_raw_parts(audio_buffer_ptr, current_len, old_capacity);
+                        vec.resize(data_byte_size, 0u8);
+
+                        buffer_capacity = vec.capacity();
+                        buffer.mData = vec.as_mut_ptr() as *mut _;
+                        buffer.mDataByteSize = data_byte_size as u32;
                         mem::forget(vec);
                     }
                 }