From 3895c8eb81439b76474ec5e6e7d2b8626144c88b Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Sat, 31 Jul 2021 08:34:42 +0200
Subject: [PATCH 1/8] Initial WIP for in-place compatible processing

---
 atom/src/port.rs                        |  16 +++
 core/src/cell.rs                        | 173 ++++++++++++++++++++++++
 core/src/lib.rs                         |   1 +
 core/src/port.rs                        | 116 ++++++++++++++--
 core/tests/amp.rs                       |  10 +-
 docs/fifths/eg-fifths-rs.lv2/fifths.ttl |   2 +-
 6 files changed, 298 insertions(+), 20 deletions(-)
 create mode 100644 core/src/cell.rs

diff --git a/atom/src/port.rs b/atom/src/port.rs
index 633fbcb9..cab2601e 100644
--- a/atom/src/port.rs
+++ b/atom/src/port.rs
@@ -101,19 +101,35 @@ impl<'a> PortWriter<'a> {
 /// [See also the module documentation.](index.html)
 pub struct AtomPort;
 
+const ATOM_IN_PLACE_ERROR: &'static str = "Atom ports cannot be used in-place";
+
 impl PortType for AtomPort {
     type InputPortType = PortReader<'static>;
     type OutputPortType = PortWriter<'static>;
+    type InPlaceInputPortType = ();
+    type InPlaceOutputPortType = ();
 
+    #[inline]
     unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> PortReader<'static> {
         let space = Space::from_atom(pointer.cast().as_ref());
         PortReader::new(space)
     }
 
+    #[inline]
     unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> PortWriter<'static> {
         let space = RootMutSpace::from_atom(pointer.cast().as_mut());
         PortWriter::new(space)
     }
+
+    #[inline]
+    unsafe fn in_place_input_from_raw(_pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceInputPortType {
+        panic!("{}", ATOM_IN_PLACE_ERROR);
+    }
+
+    #[inline]
+    unsafe fn in_place_output_from_raw(_pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceOutputPortType {
+        panic!("{}", ATOM_IN_PLACE_ERROR);
+    }
 }
 
 #[cfg(test)]
diff --git a/core/src/cell.rs b/core/src/cell.rs
new file mode 100644
index 00000000..b52c802e
--- /dev/null
+++ b/core/src/cell.rs
@@ -0,0 +1,173 @@
+//! An utility module exposing `Cell`-like utilities for realtime overwritable buffers.
+//!
+//! Those type are useful to enforce the safety guarantees of e.g. audio buffers that are both the
+//! read-only input buffer and the write-only output buffer, i.e. for audio plugins that do in-place
+//! processing.
+
+use std::cell::Cell;
+
+/// A wrapper around `Cell<T>` that only allows reading a `Copy` value out of a buffer.
+///
+/// This type is useful to enforce the guarantees of a read-only buffer that may be overwritten at
+/// any time, such as a
+#[repr(transparent)]
+pub struct ReadCell<T: ?Sized> {
+    value: Cell<T>,
+}
+
+unsafe impl<T: ?Sized> Send for ReadCell<T> where T: Send {}
+
+impl<T> ReadCell<T> {
+    /// Creates a new `ReadCell` containing the given value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::ReadCell;
+    ///
+    /// let c = ReadCell::new(5);
+    /// ```
+    #[inline]
+    pub const fn new(value: T) -> ReadCell<T> {
+        ReadCell { value: Cell::new(value) }
+    }
+}
+
+impl<T: ?Sized> ReadCell<T> {
+    /// Returns a `&ReadCell<T>` from a `&T`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::ReadCell;
+    ///
+    /// let slice: &[i32] = &[1, 2, 3];
+    /// let cell_slice: &ReadCell<[i32]> = ReadCell::from_ref(slice);
+    /// let slice_cell: &[ReadCell<i32>] = cell_slice.as_slice_of_cells();
+    ///
+    /// assert_eq!(slice_cell.len(), 3);
+    /// ```
+    #[inline]
+    pub fn from_ref(t: &T) -> &ReadCell<T> {
+        // SAFETY: `&mut` ensures unique access.
+        unsafe { &*(t as *const T as  *const ReadCell<T>) }
+    }
+}
+
+impl<T: Copy> ReadCell<T> {
+    /// Returns a copy of the contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::ReadCell;
+    ///
+    /// let c = ReadCell::new(5);
+    ///
+    /// let five = c.get();
+    /// ```
+    #[inline]
+    pub fn get(&self) -> T {
+        self.value.get()
+    }
+}
+
+impl<T> ReadCell<[T]> {
+    /// Returns a `&[ReadCell<T>]` from a `&ReadCell<[T]>`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::ReadCell;
+    ///
+    /// let slice: &mut [i32] = &mut [1, 2, 3];
+    /// let cell_slice: &ReadCell<[i32]> = ReadCell::from_ref(slice);
+    /// let slice_cell: &[ReadCell<i32>] = cell_slice.as_slice_of_cells();
+    ///
+    /// assert_eq!(slice_cell.len(), 3);
+    /// ```
+    #[inline]
+    pub fn as_slice_of_cells(&self) -> &[ReadCell<T>] {
+        // SAFETY: `Cell<T>` has the same memory layout as `T`.
+        unsafe { &*(self as *const ReadCell<[T]> as *const [ReadCell<T>]) }
+    }
+}
+
+/// A wrapper around `Cell<T>` that only allows writing a value into a buffer.
+#[repr(transparent)]
+pub struct WriteCell<T: ?Sized> {
+    value: Cell<T>,
+}
+
+impl<T: ?Sized> WriteCell<T> {
+    /// Returns a `&WriteCell<T>` from a `&mut T`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::WriteCell;
+    ///
+    /// let slice: &mut [i32] = &mut [1, 2, 3];
+    /// let cell_slice: &WriteCell<[i32]> = WriteCell::from_mut(slice);
+    /// let slice_cell: &[WriteCell<i32>] = cell_slice.as_slice_of_cells();
+    ///
+    /// assert_eq!(slice_cell.len(), 3);
+    /// ```
+    #[inline]
+    pub fn from_mut(t: &mut T) -> &WriteCell<T> {
+        // SAFETY: `&mut` ensures unique access, and WriteCell<T> has the same memory layout as T.
+        unsafe { &*(t as *mut T as *const WriteCell<T>) }
+    }
+}
+
+impl<T> WriteCell<T> {
+    /// Creates a new `WriteCell` containing the given value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::WriteCell;
+    ///
+    /// let c = WriteCell::new(5);
+    /// ```
+    #[inline]
+    pub const fn new(value: T) -> WriteCell<T> {
+        WriteCell { value: Cell::new(value) }
+    }
+
+    /// Sets the contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::WriteCell;
+    ///
+    /// let c = WriteCell::new(5);
+    ///
+    /// c.set(10);
+    /// ```
+    #[inline]
+    pub fn set(&self, val: T) {
+        self.value.set(val);
+    }
+}
+
+impl<T> WriteCell<[T]> {
+    /// Returns a `&[WriteCell<T>]` from a `&WriteCell<[T]>`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lv2_core::cell::WriteCell;
+    ///
+    /// let slice: &mut [i32] = &mut [1, 2, 3];
+    /// let cell_slice: &WriteCell<[i32]> = WriteCell::from_mut(slice);
+    /// let slice_cell: &[WriteCell<i32>] = cell_slice.as_slice_of_cells();
+    ///
+    /// assert_eq!(slice_cell.len(), 3);
+    /// ```
+    pub fn as_slice_of_cells(&self) -> &[WriteCell<T>] {
+        // SAFETY: `Cell<T>` has the same memory layout as `T`.
+        unsafe { &*(self as *const WriteCell<[T]> as *const [WriteCell<T>]) }
+    }
+}
\ No newline at end of file
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 369b2245..1cb1f9f1 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -63,3 +63,4 @@ pub mod feature;
 pub mod plugin;
 pub mod port;
 pub mod prelude;
+pub mod cell;
diff --git a/core/src/port.rs b/core/src/port.rs
index 52eccbc3..9350ff46 100644
--- a/core/src/port.rs
+++ b/core/src/port.rs
@@ -7,6 +7,7 @@ use std::ptr::NonNull;
 use urid::UriBound;
 
 pub use lv2_core_derive::*;
+use crate::cell::{ReadCell, WriteCell};
 
 /// Generalization of port types.
 ///
@@ -17,6 +18,11 @@ pub trait PortType {
     /// The type of output reference created by the port.
     type OutputPortType: Sized;
 
+    /// The type of input read by the port.
+    type InPlaceInputPortType: Sized;
+    /// The type of output reference created by the port.
+    type InPlaceOutputPortType: Sized;
+
     /// Read data from the pointer or create a reference to the input.
     ///
     /// If the resulting data is a slice, `sample_count` is the length of the slice.
@@ -34,6 +40,9 @@ pub trait PortType {
     ///
     /// This method is unsafe because one needs to de-reference a raw pointer to implement this method.
     unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType;
+
+    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType;
+    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType;
 }
 
 /// Audio port type.
@@ -48,6 +57,8 @@ unsafe impl UriBound for Audio {
 impl PortType for Audio {
     type InputPortType = &'static [f32];
     type OutputPortType = &'static mut [f32];
+    type InPlaceInputPortType = &'static [ReadCell<f32>];
+    type InPlaceOutputPortType = &'static [WriteCell<f32>];
 
     #[inline]
     unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
@@ -58,6 +69,16 @@ impl PortType for Audio {
     unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
         std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
     }
+
+    #[inline]
+    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    }
+
+    #[inline]
+    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    }
 }
 
 /// Control value port type.
@@ -74,15 +95,28 @@ unsafe impl UriBound for Control {
 impl PortType for Control {
     type InputPortType = f32;
     type OutputPortType = &'static mut f32;
+    type InPlaceInputPortType = &'static ReadCell<f32>;
+    type InPlaceOutputPortType = &'static WriteCell<f32>;
 
     #[inline]
     unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> f32 {
         *(pointer.cast().as_ref())
     }
 
+    #[inline]
     unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> &'static mut f32 {
         (pointer.as_ptr() as *mut f32).as_mut().unwrap()
     }
+
+    #[inline]
+    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(&mut *(pointer.as_ptr() as *mut f32))
+    }
+
+    #[inline]
+    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
+    }
 }
 
 /// CV port type.
@@ -97,6 +131,8 @@ unsafe impl UriBound for CV {
 impl PortType for CV {
     type InputPortType = &'static [f32];
     type OutputPortType = &'static mut [f32];
+    type InPlaceInputPortType = &'static [ReadCell<f32>];
+    type InPlaceOutputPortType = &'static [WriteCell<f32>];
 
     #[inline]
     unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
@@ -107,6 +143,16 @@ impl PortType for CV {
     unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
         std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
     }
+
+    #[inline]
+    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    }
+
+    #[inline]
+    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    }
 }
 
 /// Abstraction of safe port handles.
@@ -140,13 +186,9 @@ impl<T: PortType> Deref for InputPort<T> {
 impl<T: PortType> PortHandle for InputPort<T> {
     #[inline]
     unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
-        if let Some(pointer) = NonNull::new(pointer) {
-            Some(Self {
-                port: T::input_from_raw(pointer, sample_count),
-            })
-        } else {
-            None
-        }
+        Some(Self {
+            port: T::input_from_raw( NonNull::new(pointer)?, sample_count),
+        })
     }
 }
 
@@ -176,13 +218,9 @@ impl<T: PortType> DerefMut for OutputPort<T> {
 impl<T: PortType> PortHandle for OutputPort<T> {
     #[inline]
     unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
-        if let Some(pointer) = NonNull::new(pointer) {
-            Some(Self {
-                port: T::output_from_raw(pointer, sample_count),
-            })
-        } else {
-            None
-        }
+        Some(Self {
+            port: T::output_from_raw(NonNull::new(pointer)?, sample_count),
+        })
     }
 }
 
@@ -192,6 +230,56 @@ impl<T: PortHandle> PortHandle for Option<T> {
     }
 }
 
+/// Handle for input ports.
+///
+/// Fields of this type can be dereferenced to the input type of the port type.
+pub struct InPlaceInputPort<T: PortType> {
+    port: T::InPlaceInputPortType,
+}
+
+impl<T: PortType> Deref for InPlaceInputPort<T> {
+    type Target = T::InPlaceInputPortType;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.port
+    }
+}
+
+impl<T: PortType> PortHandle for InPlaceInputPort<T> {
+    #[inline]
+    unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
+        Some(Self {
+            port: T::in_place_input_from_raw(NonNull::new(pointer)?, sample_count),
+        })
+    }
+}
+
+/// Handle for output ports.
+///
+/// Fields of this type can be dereferenced to the output type of the port type.
+pub struct InPlaceOutputPort<T: PortType> {
+    port: T::InPlaceOutputPortType,
+}
+
+impl<T: PortType> Deref for InPlaceOutputPort<T> {
+    type Target = T::InPlaceOutputPortType;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.port
+    }
+}
+
+impl<T: PortType> PortHandle for InPlaceOutputPort<T> {
+    #[inline]
+    unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
+        Some(Self {
+            port: T::in_place_output_from_raw(NonNull::new(pointer)?, sample_count),
+        })
+    }
+}
+
 /// Collection of IO ports.
 ///
 /// Plugins do not handle port management on their own. Instead, they define a struct with all of the required ports. Then, the plugin instance will collect the port pointers from the host and create a `PortCollection` instance for every `run` call. Using this instance, plugins have access to all of their required ports.
diff --git a/core/tests/amp.rs b/core/tests/amp.rs
index 25c9e94d..8534918a 100644
--- a/core/tests/amp.rs
+++ b/core/tests/amp.rs
@@ -13,8 +13,8 @@ struct Amp {
 #[derive(PortCollection)]
 struct AmpPorts {
     gain: InputPort<Control>,
-    input: InputPort<Audio>,
-    output: OutputPort<Audio>,
+    input: InPlaceInputPort<Audio>,
+    output: InPlaceOutputPort<Audio>,
 }
 
 #[derive(FeatureCollection)]
@@ -59,10 +59,10 @@ impl Plugin for Amp {
         let coef = *(ports.gain);
 
         let input = ports.input.iter();
-        let output = ports.output.iter_mut();
+        let output = ports.output.iter();
 
         for (input_sample, output_sample) in input.zip(output) {
-            *output_sample = (*input_sample) * coef;
+            output_sample.set(input_sample.get() * coef);
         }
     }
 
@@ -150,6 +150,6 @@ fn test_plugin() {
 
     // Verifying the data.
     for i in 0..128 {
-        assert!((input[i] * gain - output[i]).abs() < std::f32::EPSILON);
+        assert!((input[i] * gain - output[i]).abs() < f32::EPSILON);
     }
 }
diff --git a/docs/fifths/eg-fifths-rs.lv2/fifths.ttl b/docs/fifths/eg-fifths-rs.lv2/fifths.ttl
index f1fc9e13..2f011016 100644
--- a/docs/fifths/eg-fifths-rs.lv2/fifths.ttl
+++ b/docs/fifths/eg-fifths-rs.lv2/fifths.ttl
@@ -9,7 +9,7 @@
 	doap:name "Example Fifths (Rust Edition)" ;
 	doap:license <http://opensource.org/licenses/isc> ;
     lv2:project <https://github.com/RustAudio/rust-lv2> ;
-	lv2:requiredFeature urid:map , lv2:inPlaceBroken ;
+	lv2:requiredFeature urid:map ;
 	lv2:optionalFeature lv2:hardRTCapable ;
 	lv2:port [
 		a lv2:InputPort ,

From 7d7b772afcc38c635fffd266679a7984e191e24b Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Sat, 31 Jul 2021 08:46:07 +0200
Subject: [PATCH 2/8] Move in-place port methods into its own trait so that
 each port type can implement it or not (eg. Atom).

---
 atom/src/port.rs | 14 -------
 core/src/port.rs | 99 +++++++++++++++++++++++++++---------------------
 2 files changed, 55 insertions(+), 58 deletions(-)

diff --git a/atom/src/port.rs b/atom/src/port.rs
index cab2601e..d8f3dd67 100644
--- a/atom/src/port.rs
+++ b/atom/src/port.rs
@@ -101,13 +101,9 @@ impl<'a> PortWriter<'a> {
 /// [See also the module documentation.](index.html)
 pub struct AtomPort;
 
-const ATOM_IN_PLACE_ERROR: &'static str = "Atom ports cannot be used in-place";
-
 impl PortType for AtomPort {
     type InputPortType = PortReader<'static>;
     type OutputPortType = PortWriter<'static>;
-    type InPlaceInputPortType = ();
-    type InPlaceOutputPortType = ();
 
     #[inline]
     unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> PortReader<'static> {
@@ -120,16 +116,6 @@ impl PortType for AtomPort {
         let space = RootMutSpace::from_atom(pointer.cast().as_mut());
         PortWriter::new(space)
     }
-
-    #[inline]
-    unsafe fn in_place_input_from_raw(_pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceInputPortType {
-        panic!("{}", ATOM_IN_PLACE_ERROR);
-    }
-
-    #[inline]
-    unsafe fn in_place_output_from_raw(_pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceOutputPortType {
-        panic!("{}", ATOM_IN_PLACE_ERROR);
-    }
 }
 
 #[cfg(test)]
diff --git a/core/src/port.rs b/core/src/port.rs
index 9350ff46..b4f6fffd 100644
--- a/core/src/port.rs
+++ b/core/src/port.rs
@@ -18,11 +18,6 @@ pub trait PortType {
     /// The type of output reference created by the port.
     type OutputPortType: Sized;
 
-    /// The type of input read by the port.
-    type InPlaceInputPortType: Sized;
-    /// The type of output reference created by the port.
-    type InPlaceOutputPortType: Sized;
-
     /// Read data from the pointer or create a reference to the input.
     ///
     /// If the resulting data is a slice, `sample_count` is the length of the slice.
@@ -40,6 +35,13 @@ pub trait PortType {
     ///
     /// This method is unsafe because one needs to de-reference a raw pointer to implement this method.
     unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType;
+}
+
+pub trait InPlacePortType: PortType {
+    /// The type of input read by the port.
+    type InPlaceInputPortType: Sized;
+    /// The type of output reference created by the port.
+    type InPlaceOutputPortType: Sized;
 
     unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType;
     unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType;
@@ -54,30 +56,33 @@ unsafe impl UriBound for Audio {
     const URI: &'static [u8] = ::lv2_sys::LV2_CORE__AudioPort;
 }
 
-impl PortType for Audio {
-    type InputPortType = &'static [f32];
-    type OutputPortType = &'static mut [f32];
+impl InPlacePortType for Audio {
     type InPlaceInputPortType = &'static [ReadCell<f32>];
     type InPlaceOutputPortType = &'static [WriteCell<f32>];
 
     #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
+    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
     }
 
     #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
+    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
     }
+}
+
+impl PortType for Audio {
+    type InputPortType = &'static [f32];
+    type OutputPortType = &'static mut [f32];
 
     #[inline]
-    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
     }
 }
 
@@ -92,30 +97,33 @@ unsafe impl UriBound for Control {
     const URI: &'static [u8] = ::lv2_sys::LV2_CORE__ControlPort;
 }
 
-impl PortType for Control {
-    type InputPortType = f32;
-    type OutputPortType = &'static mut f32;
+impl InPlacePortType for Control {
     type InPlaceInputPortType = &'static ReadCell<f32>;
     type InPlaceOutputPortType = &'static WriteCell<f32>;
 
     #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> f32 {
-        *(pointer.cast().as_ref())
+    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(&mut *(pointer.as_ptr() as *mut f32))
     }
 
     #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> &'static mut f32 {
-        (pointer.as_ptr() as *mut f32).as_mut().unwrap()
+    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
     }
+}
+
+impl PortType for Control {
+    type InputPortType = f32;
+    type OutputPortType = &'static mut f32;
 
     #[inline]
-    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(&mut *(pointer.as_ptr() as *mut f32))
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> f32 {
+        *(pointer.cast().as_ref())
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> &'static mut f32 {
+        (pointer.as_ptr() as *mut f32).as_mut().unwrap()
     }
 }
 
@@ -128,30 +136,33 @@ unsafe impl UriBound for CV {
     const URI: &'static [u8] = ::lv2_sys::LV2_CORE__CVPort;
 }
 
-impl PortType for CV {
-    type InputPortType = &'static [f32];
-    type OutputPortType = &'static mut [f32];
+impl InPlacePortType for CV {
     type InPlaceInputPortType = &'static [ReadCell<f32>];
     type InPlaceOutputPortType = &'static [WriteCell<f32>];
 
     #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
+    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
     }
 
     #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
+    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
     }
+}
+
+impl PortType for CV {
+    type InputPortType = &'static [f32];
+    type OutputPortType = &'static mut [f32];
 
     #[inline]
-    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
     }
 }
 
@@ -233,11 +244,11 @@ impl<T: PortHandle> PortHandle for Option<T> {
 /// Handle for input ports.
 ///
 /// Fields of this type can be dereferenced to the input type of the port type.
-pub struct InPlaceInputPort<T: PortType> {
+pub struct InPlaceInputPort<T: InPlacePortType> {
     port: T::InPlaceInputPortType,
 }
 
-impl<T: PortType> Deref for InPlaceInputPort<T> {
+impl<T: InPlacePortType> Deref for InPlaceInputPort<T> {
     type Target = T::InPlaceInputPortType;
 
     #[inline]
@@ -246,7 +257,7 @@ impl<T: PortType> Deref for InPlaceInputPort<T> {
     }
 }
 
-impl<T: PortType> PortHandle for InPlaceInputPort<T> {
+impl<T: InPlacePortType> PortHandle for InPlaceInputPort<T> {
     #[inline]
     unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
         Some(Self {
@@ -258,11 +269,11 @@ impl<T: PortType> PortHandle for InPlaceInputPort<T> {
 /// Handle for output ports.
 ///
 /// Fields of this type can be dereferenced to the output type of the port type.
-pub struct InPlaceOutputPort<T: PortType> {
+pub struct InPlaceOutputPort<T: InPlacePortType> {
     port: T::InPlaceOutputPortType,
 }
 
-impl<T: PortType> Deref for InPlaceOutputPort<T> {
+impl<T: InPlacePortType> Deref for InPlaceOutputPort<T> {
     type Target = T::InPlaceOutputPortType;
 
     #[inline]
@@ -271,7 +282,7 @@ impl<T: PortType> Deref for InPlaceOutputPort<T> {
     }
 }
 
-impl<T: PortType> PortHandle for InPlaceOutputPort<T> {
+impl<T: InPlacePortType> PortHandle for InPlaceOutputPort<T> {
     #[inline]
     unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
         Some(Self {

From da81539e85675b41ceb843babcc7fbf698332a0c Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Sat, 31 Jul 2021 13:25:57 +0200
Subject: [PATCH 3/8] Rustfmt, and fix warnings

---
 core/src/cell.rs             | 12 ++++---
 core/src/lib.rs              |  2 +-
 core/src/port.rs             | 68 ++++++++++++++++++++++++++++--------
 urid/derive/src/uri_bound.rs |  8 ++---
 4 files changed, 67 insertions(+), 23 deletions(-)

diff --git a/core/src/cell.rs b/core/src/cell.rs
index b52c802e..c03407cb 100644
--- a/core/src/cell.rs
+++ b/core/src/cell.rs
@@ -29,7 +29,9 @@ impl<T> ReadCell<T> {
     /// ```
     #[inline]
     pub const fn new(value: T) -> ReadCell<T> {
-        ReadCell { value: Cell::new(value) }
+        ReadCell {
+            value: Cell::new(value),
+        }
     }
 }
 
@@ -50,7 +52,7 @@ impl<T: ?Sized> ReadCell<T> {
     #[inline]
     pub fn from_ref(t: &T) -> &ReadCell<T> {
         // SAFETY: `&mut` ensures unique access.
-        unsafe { &*(t as *const T as  *const ReadCell<T>) }
+        unsafe { &*(t as *const T as *const ReadCell<T>) }
     }
 }
 
@@ -132,7 +134,9 @@ impl<T> WriteCell<T> {
     /// ```
     #[inline]
     pub const fn new(value: T) -> WriteCell<T> {
-        WriteCell { value: Cell::new(value) }
+        WriteCell {
+            value: Cell::new(value),
+        }
     }
 
     /// Sets the contained value.
@@ -170,4 +174,4 @@ impl<T> WriteCell<[T]> {
         // SAFETY: `Cell<T>` has the same memory layout as `T`.
         unsafe { &*(self as *const WriteCell<[T]> as *const [WriteCell<T>]) }
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 1cb1f9f1..1127243c 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -58,9 +58,9 @@
 //! ```
 extern crate lv2_sys as sys;
 
+pub mod cell;
 pub mod extension;
 pub mod feature;
 pub mod plugin;
 pub mod port;
 pub mod prelude;
-pub mod cell;
diff --git a/core/src/port.rs b/core/src/port.rs
index b4f6fffd..fa922905 100644
--- a/core/src/port.rs
+++ b/core/src/port.rs
@@ -6,8 +6,8 @@ use std::ops::{Deref, DerefMut};
 use std::ptr::NonNull;
 use urid::UriBound;
 
-pub use lv2_core_derive::*;
 use crate::cell::{ReadCell, WriteCell};
+pub use lv2_core_derive::*;
 
 /// Generalization of port types.
 ///
@@ -43,8 +43,14 @@ pub trait InPlacePortType: PortType {
     /// The type of output reference created by the port.
     type InPlaceOutputPortType: Sized;
 
-    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType;
-    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType;
+    unsafe fn in_place_input_from_raw(
+        pointer: NonNull<c_void>,
+        sample_count: u32,
+    ) -> Self::InPlaceInputPortType;
+    unsafe fn in_place_output_from_raw(
+        pointer: NonNull<c_void>,
+        sample_count: u32,
+    ) -> Self::InPlaceOutputPortType;
 }
 
 /// Audio port type.
@@ -61,13 +67,27 @@ impl InPlacePortType for Audio {
     type InPlaceOutputPortType = &'static [WriteCell<f32>];
 
     #[inline]
-    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn in_place_input_from_raw(
+        pointer: NonNull<c_void>,
+        sample_count: u32,
+    ) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn in_place_output_from_raw(
+        pointer: NonNull<c_void>,
+        sample_count: u32,
+    ) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
     }
 }
 
@@ -102,12 +122,18 @@ impl InPlacePortType for Control {
     type InPlaceOutputPortType = &'static WriteCell<f32>;
 
     #[inline]
-    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceInputPortType {
+    unsafe fn in_place_input_from_raw(
+        pointer: NonNull<c_void>,
+        _sample_count: u32,
+    ) -> Self::InPlaceInputPortType {
         ReadCell::from_ref(&mut *(pointer.as_ptr() as *mut f32))
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InPlaceOutputPortType {
+    unsafe fn in_place_output_from_raw(
+        pointer: NonNull<c_void>,
+        _sample_count: u32,
+    ) -> Self::InPlaceOutputPortType {
         WriteCell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
     }
 }
@@ -141,13 +167,27 @@ impl InPlacePortType for CV {
     type InPlaceOutputPortType = &'static [WriteCell<f32>];
 
     #[inline]
-    unsafe fn in_place_input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn in_place_input_from_raw(
+        pointer: NonNull<c_void>,
+        sample_count: u32,
+    ) -> Self::InPlaceInputPortType {
+        ReadCell::from_ref(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)).as_slice_of_cells()
+    unsafe fn in_place_output_from_raw(
+        pointer: NonNull<c_void>,
+        sample_count: u32,
+    ) -> Self::InPlaceOutputPortType {
+        WriteCell::from_mut(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
     }
 }
 
@@ -198,7 +238,7 @@ impl<T: PortType> PortHandle for InputPort<T> {
     #[inline]
     unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
         Some(Self {
-            port: T::input_from_raw( NonNull::new(pointer)?, sample_count),
+            port: T::input_from_raw(NonNull::new(pointer)?, sample_count),
         })
     }
 }
diff --git a/urid/derive/src/uri_bound.rs b/urid/derive/src/uri_bound.rs
index a90696f6..d30cd0bf 100644
--- a/urid/derive/src/uri_bound.rs
+++ b/urid/derive/src/uri_bound.rs
@@ -15,11 +15,11 @@ fn get_type_ident(item: TokenStream) -> Ident {
         Item::Struct(definition) => (definition.ident, definition.generics),
         Item::Type(definition) => (definition.ident, definition.generics),
         Item::Union(definition) => (definition.ident, definition.generics),
-        _ => panic!(PARSING_ERROR),
+        _ => panic!("{}", PARSING_ERROR),
     };
 
     if !generics.params.is_empty() {
-        panic!("The uri attribute does not support generic types");
+        panic!("{}", "The uri attribute does not support generic types");
     }
     ident
 }
@@ -31,12 +31,12 @@ fn get_uri(attr: TokenStream) -> Literal {
     const PARSING_ERROR: &str = "A URI has to be a string literal";
 
     if parse::<Literal>(attr.clone()).is_err() {
-        panic!(PARSING_ERROR);
+        panic!("{}", PARSING_ERROR);
     }
     //check if it's a litteral string
     let attr = attr.to_string();
     if !attr.starts_with('"') || !attr.ends_with('"') {
-        panic!(PARSING_ERROR);
+        panic!("{}", PARSING_ERROR);
     }
     //Remove the enclosing "" to get the uri
     let uri = String::from(attr.get(1..attr.len() - 1).expect(PARSING_ERROR));

From 1c6afff5da3787abda19fa1079396b5b2beff447 Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Sat, 31 Jul 2021 21:44:42 +0200
Subject: [PATCH 4/8] Remove custom Cells and only use standard Cell types

---
 core/src/cell.rs | 177 -----------------------------------------------
 core/src/lib.rs  |   1 -
 core/src/port.rs |  26 +++----
 3 files changed, 13 insertions(+), 191 deletions(-)
 delete mode 100644 core/src/cell.rs

diff --git a/core/src/cell.rs b/core/src/cell.rs
deleted file mode 100644
index c03407cb..00000000
--- a/core/src/cell.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-//! An utility module exposing `Cell`-like utilities for realtime overwritable buffers.
-//!
-//! Those type are useful to enforce the safety guarantees of e.g. audio buffers that are both the
-//! read-only input buffer and the write-only output buffer, i.e. for audio plugins that do in-place
-//! processing.
-
-use std::cell::Cell;
-
-/// A wrapper around `Cell<T>` that only allows reading a `Copy` value out of a buffer.
-///
-/// This type is useful to enforce the guarantees of a read-only buffer that may be overwritten at
-/// any time, such as a
-#[repr(transparent)]
-pub struct ReadCell<T: ?Sized> {
-    value: Cell<T>,
-}
-
-unsafe impl<T: ?Sized> Send for ReadCell<T> where T: Send {}
-
-impl<T> ReadCell<T> {
-    /// Creates a new `ReadCell` containing the given value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::ReadCell;
-    ///
-    /// let c = ReadCell::new(5);
-    /// ```
-    #[inline]
-    pub const fn new(value: T) -> ReadCell<T> {
-        ReadCell {
-            value: Cell::new(value),
-        }
-    }
-}
-
-impl<T: ?Sized> ReadCell<T> {
-    /// Returns a `&ReadCell<T>` from a `&T`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::ReadCell;
-    ///
-    /// let slice: &[i32] = &[1, 2, 3];
-    /// let cell_slice: &ReadCell<[i32]> = ReadCell::from_ref(slice);
-    /// let slice_cell: &[ReadCell<i32>] = cell_slice.as_slice_of_cells();
-    ///
-    /// assert_eq!(slice_cell.len(), 3);
-    /// ```
-    #[inline]
-    pub fn from_ref(t: &T) -> &ReadCell<T> {
-        // SAFETY: `&mut` ensures unique access.
-        unsafe { &*(t as *const T as *const ReadCell<T>) }
-    }
-}
-
-impl<T: Copy> ReadCell<T> {
-    /// Returns a copy of the contained value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::ReadCell;
-    ///
-    /// let c = ReadCell::new(5);
-    ///
-    /// let five = c.get();
-    /// ```
-    #[inline]
-    pub fn get(&self) -> T {
-        self.value.get()
-    }
-}
-
-impl<T> ReadCell<[T]> {
-    /// Returns a `&[ReadCell<T>]` from a `&ReadCell<[T]>`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::ReadCell;
-    ///
-    /// let slice: &mut [i32] = &mut [1, 2, 3];
-    /// let cell_slice: &ReadCell<[i32]> = ReadCell::from_ref(slice);
-    /// let slice_cell: &[ReadCell<i32>] = cell_slice.as_slice_of_cells();
-    ///
-    /// assert_eq!(slice_cell.len(), 3);
-    /// ```
-    #[inline]
-    pub fn as_slice_of_cells(&self) -> &[ReadCell<T>] {
-        // SAFETY: `Cell<T>` has the same memory layout as `T`.
-        unsafe { &*(self as *const ReadCell<[T]> as *const [ReadCell<T>]) }
-    }
-}
-
-/// A wrapper around `Cell<T>` that only allows writing a value into a buffer.
-#[repr(transparent)]
-pub struct WriteCell<T: ?Sized> {
-    value: Cell<T>,
-}
-
-impl<T: ?Sized> WriteCell<T> {
-    /// Returns a `&WriteCell<T>` from a `&mut T`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::WriteCell;
-    ///
-    /// let slice: &mut [i32] = &mut [1, 2, 3];
-    /// let cell_slice: &WriteCell<[i32]> = WriteCell::from_mut(slice);
-    /// let slice_cell: &[WriteCell<i32>] = cell_slice.as_slice_of_cells();
-    ///
-    /// assert_eq!(slice_cell.len(), 3);
-    /// ```
-    #[inline]
-    pub fn from_mut(t: &mut T) -> &WriteCell<T> {
-        // SAFETY: `&mut` ensures unique access, and WriteCell<T> has the same memory layout as T.
-        unsafe { &*(t as *mut T as *const WriteCell<T>) }
-    }
-}
-
-impl<T> WriteCell<T> {
-    /// Creates a new `WriteCell` containing the given value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::WriteCell;
-    ///
-    /// let c = WriteCell::new(5);
-    /// ```
-    #[inline]
-    pub const fn new(value: T) -> WriteCell<T> {
-        WriteCell {
-            value: Cell::new(value),
-        }
-    }
-
-    /// Sets the contained value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::WriteCell;
-    ///
-    /// let c = WriteCell::new(5);
-    ///
-    /// c.set(10);
-    /// ```
-    #[inline]
-    pub fn set(&self, val: T) {
-        self.value.set(val);
-    }
-}
-
-impl<T> WriteCell<[T]> {
-    /// Returns a `&[WriteCell<T>]` from a `&WriteCell<[T]>`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lv2_core::cell::WriteCell;
-    ///
-    /// let slice: &mut [i32] = &mut [1, 2, 3];
-    /// let cell_slice: &WriteCell<[i32]> = WriteCell::from_mut(slice);
-    /// let slice_cell: &[WriteCell<i32>] = cell_slice.as_slice_of_cells();
-    ///
-    /// assert_eq!(slice_cell.len(), 3);
-    /// ```
-    pub fn as_slice_of_cells(&self) -> &[WriteCell<T>] {
-        // SAFETY: `Cell<T>` has the same memory layout as `T`.
-        unsafe { &*(self as *const WriteCell<[T]> as *const [WriteCell<T>]) }
-    }
-}
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 1127243c..369b2245 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -58,7 +58,6 @@
 //! ```
 extern crate lv2_sys as sys;
 
-pub mod cell;
 pub mod extension;
 pub mod feature;
 pub mod plugin;
diff --git a/core/src/port.rs b/core/src/port.rs
index fa922905..3a91dc59 100644
--- a/core/src/port.rs
+++ b/core/src/port.rs
@@ -6,8 +6,8 @@ use std::ops::{Deref, DerefMut};
 use std::ptr::NonNull;
 use urid::UriBound;
 
-use crate::cell::{ReadCell, WriteCell};
 pub use lv2_core_derive::*;
+use std::cell::Cell;
 
 /// Generalization of port types.
 ///
@@ -63,15 +63,15 @@ unsafe impl UriBound for Audio {
 }
 
 impl InPlacePortType for Audio {
-    type InPlaceInputPortType = &'static [ReadCell<f32>];
-    type InPlaceOutputPortType = &'static [WriteCell<f32>];
+    type InPlaceInputPortType = &'static [Cell<f32>];
+    type InPlaceOutputPortType = &'static [Cell<f32>];
 
     #[inline]
     unsafe fn in_place_input_from_raw(
         pointer: NonNull<c_void>,
         sample_count: u32,
     ) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(std::slice::from_raw_parts_mut(
+        Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
         ))
@@ -83,7 +83,7 @@ impl InPlacePortType for Audio {
         pointer: NonNull<c_void>,
         sample_count: u32,
     ) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(std::slice::from_raw_parts_mut(
+        Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
         ))
@@ -118,15 +118,15 @@ unsafe impl UriBound for Control {
 }
 
 impl InPlacePortType for Control {
-    type InPlaceInputPortType = &'static ReadCell<f32>;
-    type InPlaceOutputPortType = &'static WriteCell<f32>;
+    type InPlaceInputPortType = &'static Cell<f32>;
+    type InPlaceOutputPortType = &'static Cell<f32>;
 
     #[inline]
     unsafe fn in_place_input_from_raw(
         pointer: NonNull<c_void>,
         _sample_count: u32,
     ) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(&mut *(pointer.as_ptr() as *mut f32))
+        Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
     }
 
     #[inline]
@@ -134,7 +134,7 @@ impl InPlacePortType for Control {
         pointer: NonNull<c_void>,
         _sample_count: u32,
     ) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
+        Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
     }
 }
 
@@ -163,15 +163,15 @@ unsafe impl UriBound for CV {
 }
 
 impl InPlacePortType for CV {
-    type InPlaceInputPortType = &'static [ReadCell<f32>];
-    type InPlaceOutputPortType = &'static [WriteCell<f32>];
+    type InPlaceInputPortType = &'static [Cell<f32>];
+    type InPlaceOutputPortType = &'static [Cell<f32>];
 
     #[inline]
     unsafe fn in_place_input_from_raw(
         pointer: NonNull<c_void>,
         sample_count: u32,
     ) -> Self::InPlaceInputPortType {
-        ReadCell::from_ref(std::slice::from_raw_parts_mut(
+        Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
         ))
@@ -183,7 +183,7 @@ impl InPlacePortType for CV {
         pointer: NonNull<c_void>,
         sample_count: u32,
     ) -> Self::InPlaceOutputPortType {
-        WriteCell::from_mut(std::slice::from_raw_parts_mut(
+        Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
         ))

From 2dda76c724e10538205db2a288ad85a45c86df87 Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Mon, 2 Aug 2021 02:56:20 +0200
Subject: [PATCH 5/8] Replace InPlacePortType with InPlaceAudio, InPlaceCV and
 InPlaceControl

---
 core/src/port.rs  | 209 ++++++++++++++++++----------------------------
 core/tests/amp.rs |   8 +-
 2 files changed, 85 insertions(+), 132 deletions(-)

diff --git a/core/src/port.rs b/core/src/port.rs
index 3a91dc59..95a755cc 100644
--- a/core/src/port.rs
+++ b/core/src/port.rs
@@ -37,22 +37,6 @@ pub trait PortType {
     unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType;
 }
 
-pub trait InPlacePortType: PortType {
-    /// The type of input read by the port.
-    type InPlaceInputPortType: Sized;
-    /// The type of output reference created by the port.
-    type InPlaceOutputPortType: Sized;
-
-    unsafe fn in_place_input_from_raw(
-        pointer: NonNull<c_void>,
-        sample_count: u32,
-    ) -> Self::InPlaceInputPortType;
-    unsafe fn in_place_output_from_raw(
-        pointer: NonNull<c_void>,
-        sample_count: u32,
-    ) -> Self::InPlaceOutputPortType;
-}
-
 /// Audio port type.
 ///
 /// Audio ports are the most common type of input/output ports: Their input is a slice of audio samples, as well as their output.
@@ -62,15 +46,36 @@ unsafe impl UriBound for Audio {
     const URI: &'static [u8] = ::lv2_sys::LV2_CORE__AudioPort;
 }
 
-impl InPlacePortType for Audio {
-    type InPlaceInputPortType = &'static [Cell<f32>];
-    type InPlaceOutputPortType = &'static [Cell<f32>];
+impl PortType for Audio {
+    type InputPortType = &'static [f32];
+    type OutputPortType = &'static mut [f32];
+
+    #[inline]
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
+    }
+
+    #[inline]
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
+    }
+}
+
+pub struct InPlaceAudio;
+
+unsafe impl UriBound for InPlaceAudio {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__AudioPort;
+}
+
+impl PortType for InPlaceAudio {
+    type InputPortType = &'static [Cell<f32>];
+    type OutputPortType = &'static [Cell<f32>];
 
     #[inline]
-    unsafe fn in_place_input_from_raw(
+    unsafe fn input_from_raw(
         pointer: NonNull<c_void>,
         sample_count: u32,
-    ) -> Self::InPlaceInputPortType {
+    ) -> Self::InputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
@@ -79,10 +84,10 @@ impl InPlacePortType for Audio {
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(
+    unsafe fn output_from_raw(
         pointer: NonNull<c_void>,
         sample_count: u32,
-    ) -> Self::InPlaceOutputPortType {
+    ) -> Self::OutputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
@@ -91,86 +96,99 @@ impl InPlacePortType for Audio {
     }
 }
 
-impl PortType for Audio {
-    type InputPortType = &'static [f32];
-    type OutputPortType = &'static mut [f32];
+/// Control value port type.
+///
+/// Control ports in general are used to control the behaviour of the plugin. These control value ports only have one value per `run` call and therefore don't have a fixed sampling rate.
+///
+/// Therefore, their input is a floating-point number and their output is a mutable reference to a floating-point number.
+pub struct Control;
+
+unsafe impl UriBound for Control {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__ControlPort;
+}
+
+impl PortType for Control {
+    type InputPortType = f32;
+    type OutputPortType = &'static mut f32;
 
     #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> f32 {
+        *(pointer.cast().as_ref())
     }
 
     #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> &'static mut f32 {
+        (pointer.as_ptr() as *mut f32).as_mut().unwrap()
     }
 }
 
-/// Control value port type.
-///
-/// Control ports in general are used to control the behaviour of the plugin. These control value ports only have one value per `run` call and therefore don't have a fixed sampling rate.
-///
-/// Therefore, their input is a floating-point number and their output is a mutable reference to a floating-point number.
-pub struct Control;
+pub struct InPlaceControl;
 
-unsafe impl UriBound for Control {
+unsafe impl UriBound for InPlaceControl {
     const URI: &'static [u8] = ::lv2_sys::LV2_CORE__ControlPort;
 }
 
-impl InPlacePortType for Control {
-    type InPlaceInputPortType = &'static Cell<f32>;
-    type InPlaceOutputPortType = &'static Cell<f32>;
+impl PortType for InPlaceControl {
+    type InputPortType = &'static Cell<f32>;
+    type OutputPortType = &'static Cell<f32>;
 
     #[inline]
-    unsafe fn in_place_input_from_raw(
+    unsafe fn input_from_raw(
         pointer: NonNull<c_void>,
         _sample_count: u32,
-    ) -> Self::InPlaceInputPortType {
+    ) -> Self::InputPortType {
         Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(
+    unsafe fn output_from_raw(
         pointer: NonNull<c_void>,
         _sample_count: u32,
-    ) -> Self::InPlaceOutputPortType {
+    ) -> Self::OutputPortType {
         Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
     }
 }
 
-impl PortType for Control {
-    type InputPortType = f32;
-    type OutputPortType = &'static mut f32;
+
+/// CV port type.
+///
+/// Control ports in general are used to control the behaviour of the plugin. CV ports are sampled just like [audio data](struct.Audio.html). This means that audio data is often valid CV data, but CV data generally is not audio data, because it may not be within the audio bounds of -1.0 to 1.0.
+pub struct CV;
+
+unsafe impl UriBound for CV {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__CVPort;
+}
+
+impl PortType for CV {
+    type InputPortType = &'static [f32];
+    type OutputPortType = &'static mut [f32];
 
     #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> f32 {
-        *(pointer.cast().as_ref())
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
     }
 
     #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> &'static mut f32 {
-        (pointer.as_ptr() as *mut f32).as_mut().unwrap()
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
     }
 }
 
-/// CV port type.
-///
-/// Control ports in general are used to control the behaviour of the plugin. CV ports are sampled just like [audio data](struct.Audio.html). This means that audio data is often valid CV data, but CV data generally is not audio data, because it may not be within the audio bounds of -1.0 to 1.0.
-pub struct CV;
+pub struct InPlaceCV;
 
-unsafe impl UriBound for CV {
+unsafe impl UriBound for InPlaceCV {
     const URI: &'static [u8] = ::lv2_sys::LV2_CORE__CVPort;
 }
 
-impl InPlacePortType for CV {
-    type InPlaceInputPortType = &'static [Cell<f32>];
-    type InPlaceOutputPortType = &'static [Cell<f32>];
+impl PortType for InPlaceCV {
+    type InputPortType = &'static [Cell<f32>];
+    type OutputPortType = &'static [Cell<f32>];
 
     #[inline]
-    unsafe fn in_place_input_from_raw(
+    unsafe fn input_from_raw(
         pointer: NonNull<c_void>,
         sample_count: u32,
-    ) -> Self::InPlaceInputPortType {
+    ) -> Self::InputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
@@ -179,10 +197,10 @@ impl InPlacePortType for CV {
     }
 
     #[inline]
-    unsafe fn in_place_output_from_raw(
+    unsafe fn output_from_raw(
         pointer: NonNull<c_void>,
         sample_count: u32,
-    ) -> Self::InPlaceOutputPortType {
+    ) -> Self::OutputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
@@ -191,21 +209,6 @@ impl InPlacePortType for CV {
     }
 }
 
-impl PortType for CV {
-    type InputPortType = &'static [f32];
-    type OutputPortType = &'static mut [f32];
-
-    #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
-    }
-
-    #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
-    }
-}
-
 /// Abstraction of safe port handles.
 pub trait PortHandle: Sized {
     /// Try to create a port handle from a port connection pointer and the sample count.
@@ -281,56 +284,6 @@ impl<T: PortHandle> PortHandle for Option<T> {
     }
 }
 
-/// Handle for input ports.
-///
-/// Fields of this type can be dereferenced to the input type of the port type.
-pub struct InPlaceInputPort<T: InPlacePortType> {
-    port: T::InPlaceInputPortType,
-}
-
-impl<T: InPlacePortType> Deref for InPlaceInputPort<T> {
-    type Target = T::InPlaceInputPortType;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.port
-    }
-}
-
-impl<T: InPlacePortType> PortHandle for InPlaceInputPort<T> {
-    #[inline]
-    unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
-        Some(Self {
-            port: T::in_place_input_from_raw(NonNull::new(pointer)?, sample_count),
-        })
-    }
-}
-
-/// Handle for output ports.
-///
-/// Fields of this type can be dereferenced to the output type of the port type.
-pub struct InPlaceOutputPort<T: InPlacePortType> {
-    port: T::InPlaceOutputPortType,
-}
-
-impl<T: InPlacePortType> Deref for InPlaceOutputPort<T> {
-    type Target = T::InPlaceOutputPortType;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.port
-    }
-}
-
-impl<T: InPlacePortType> PortHandle for InPlaceOutputPort<T> {
-    #[inline]
-    unsafe fn from_raw(pointer: *mut c_void, sample_count: u32) -> Option<Self> {
-        Some(Self {
-            port: T::in_place_output_from_raw(NonNull::new(pointer)?, sample_count),
-        })
-    }
-}
-
 /// Collection of IO ports.
 ///
 /// Plugins do not handle port management on their own. Instead, they define a struct with all of the required ports. Then, the plugin instance will collect the port pointers from the host and create a `PortCollection` instance for every `run` call. Using this instance, plugins have access to all of their required ports.
diff --git a/core/tests/amp.rs b/core/tests/amp.rs
index 8534918a..3643ab03 100644
--- a/core/tests/amp.rs
+++ b/core/tests/amp.rs
@@ -12,9 +12,9 @@ struct Amp {
 
 #[derive(PortCollection)]
 struct AmpPorts {
-    gain: InputPort<Control>,
-    input: InPlaceInputPort<Audio>,
-    output: InPlaceOutputPort<Audio>,
+    gain: InputPort<InPlaceControl>,
+    input: InputPort<InPlaceAudio>,
+    output: OutputPort<InPlaceAudio>,
 }
 
 #[derive(FeatureCollection)]
@@ -62,7 +62,7 @@ impl Plugin for Amp {
         let output = ports.output.iter();
 
         for (input_sample, output_sample) in input.zip(output) {
-            output_sample.set(input_sample.get() * coef);
+            output_sample.set(input_sample.get() * coef.get());
         }
     }
 

From 9046c6fc49a3fc7fc9da4ff1ad491cda1f378e58 Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Mon, 2 Aug 2021 02:58:47 +0200
Subject: [PATCH 6/8] rustfmt

---
 core/src/port.rs | 26 +++++---------------------
 1 file changed, 5 insertions(+), 21 deletions(-)

diff --git a/core/src/port.rs b/core/src/port.rs
index 95a755cc..d47440d0 100644
--- a/core/src/port.rs
+++ b/core/src/port.rs
@@ -72,10 +72,7 @@ impl PortType for InPlaceAudio {
     type OutputPortType = &'static [Cell<f32>];
 
     #[inline]
-    unsafe fn input_from_raw(
-        pointer: NonNull<c_void>,
-        sample_count: u32,
-    ) -> Self::InputPortType {
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
@@ -84,10 +81,7 @@ impl PortType for InPlaceAudio {
     }
 
     #[inline]
-    unsafe fn output_from_raw(
-        pointer: NonNull<c_void>,
-        sample_count: u32,
-    ) -> Self::OutputPortType {
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
@@ -133,10 +127,7 @@ impl PortType for InPlaceControl {
     type OutputPortType = &'static Cell<f32>;
 
     #[inline]
-    unsafe fn input_from_raw(
-        pointer: NonNull<c_void>,
-        _sample_count: u32,
-    ) -> Self::InputPortType {
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InputPortType {
         Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
     }
 
@@ -149,7 +140,6 @@ impl PortType for InPlaceControl {
     }
 }
 
-
 /// CV port type.
 ///
 /// Control ports in general are used to control the behaviour of the plugin. CV ports are sampled just like [audio data](struct.Audio.html). This means that audio data is often valid CV data, but CV data generally is not audio data, because it may not be within the audio bounds of -1.0 to 1.0.
@@ -185,10 +175,7 @@ impl PortType for InPlaceCV {
     type OutputPortType = &'static [Cell<f32>];
 
     #[inline]
-    unsafe fn input_from_raw(
-        pointer: NonNull<c_void>,
-        sample_count: u32,
-    ) -> Self::InputPortType {
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,
@@ -197,10 +184,7 @@ impl PortType for InPlaceCV {
     }
 
     #[inline]
-    unsafe fn output_from_raw(
-        pointer: NonNull<c_void>,
-        sample_count: u32,
-    ) -> Self::OutputPortType {
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
         Cell::from_mut(std::slice::from_raw_parts_mut(
             pointer.as_ptr() as *mut f32,
             sample_count as usize,

From 19fa30436deca7c343c03e6183a673945c7a965f Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Tue, 3 Aug 2021 03:23:51 +0200
Subject: [PATCH 7/8] Split port Audio, Control and CV types into their own
 files, and add documentation to both normal and InPlace core port types.

---
 core/src/port.rs         | 168 ++----------------------------------
 core/src/port/audio.rs   | 155 +++++++++++++++++++++++++++++++++
 core/src/port/control.rs | 148 ++++++++++++++++++++++++++++++++
 core/src/port/cv.rs      | 181 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 493 insertions(+), 159 deletions(-)
 create mode 100644 core/src/port/audio.rs
 create mode 100644 core/src/port/control.rs
 create mode 100644 core/src/port/cv.rs

diff --git a/core/src/port.rs b/core/src/port.rs
index d47440d0..76c8a3f1 100644
--- a/core/src/port.rs
+++ b/core/src/port.rs
@@ -1,13 +1,19 @@
 //! Types to declare derivable port collections.
 //!
 //! Every plugin has a type of [`PortCollection`](trait.PortCollection.html) which is used to handle input/output ports. In order to make the creation of these port collection types easier, `PortCollection` can simply be derived. However, the macro that implements `PortCollection` requires the fields of the struct to have specific types. These types are provided in this module.
+mod audio;
+mod control;
+mod cv;
+
+pub use audio::*;
+pub use control::*;
+pub use cv::*;
+
 use std::ffi::c_void;
 use std::ops::{Deref, DerefMut};
 use std::ptr::NonNull;
-use urid::UriBound;
 
 pub use lv2_core_derive::*;
-use std::cell::Cell;
 
 /// Generalization of port types.
 ///
@@ -37,162 +43,6 @@ pub trait PortType {
     unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType;
 }
 
-/// Audio port type.
-///
-/// Audio ports are the most common type of input/output ports: Their input is a slice of audio samples, as well as their output.
-pub struct Audio;
-
-unsafe impl UriBound for Audio {
-    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__AudioPort;
-}
-
-impl PortType for Audio {
-    type InputPortType = &'static [f32];
-    type OutputPortType = &'static mut [f32];
-
-    #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
-    }
-
-    #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
-    }
-}
-
-pub struct InPlaceAudio;
-
-unsafe impl UriBound for InPlaceAudio {
-    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__AudioPort;
-}
-
-impl PortType for InPlaceAudio {
-    type InputPortType = &'static [Cell<f32>];
-    type OutputPortType = &'static [Cell<f32>];
-
-    #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        Cell::from_mut(std::slice::from_raw_parts_mut(
-            pointer.as_ptr() as *mut f32,
-            sample_count as usize,
-        ))
-        .as_slice_of_cells()
-    }
-
-    #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        Cell::from_mut(std::slice::from_raw_parts_mut(
-            pointer.as_ptr() as *mut f32,
-            sample_count as usize,
-        ))
-        .as_slice_of_cells()
-    }
-}
-
-/// Control value port type.
-///
-/// Control ports in general are used to control the behaviour of the plugin. These control value ports only have one value per `run` call and therefore don't have a fixed sampling rate.
-///
-/// Therefore, their input is a floating-point number and their output is a mutable reference to a floating-point number.
-pub struct Control;
-
-unsafe impl UriBound for Control {
-    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__ControlPort;
-}
-
-impl PortType for Control {
-    type InputPortType = f32;
-    type OutputPortType = &'static mut f32;
-
-    #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> f32 {
-        *(pointer.cast().as_ref())
-    }
-
-    #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> &'static mut f32 {
-        (pointer.as_ptr() as *mut f32).as_mut().unwrap()
-    }
-}
-
-pub struct InPlaceControl;
-
-unsafe impl UriBound for InPlaceControl {
-    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__ControlPort;
-}
-
-impl PortType for InPlaceControl {
-    type InputPortType = &'static Cell<f32>;
-    type OutputPortType = &'static Cell<f32>;
-
-    #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InputPortType {
-        Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
-    }
-
-    #[inline]
-    unsafe fn output_from_raw(
-        pointer: NonNull<c_void>,
-        _sample_count: u32,
-    ) -> Self::OutputPortType {
-        Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
-    }
-}
-
-/// CV port type.
-///
-/// Control ports in general are used to control the behaviour of the plugin. CV ports are sampled just like [audio data](struct.Audio.html). This means that audio data is often valid CV data, but CV data generally is not audio data, because it may not be within the audio bounds of -1.0 to 1.0.
-pub struct CV;
-
-unsafe impl UriBound for CV {
-    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__CVPort;
-}
-
-impl PortType for CV {
-    type InputPortType = &'static [f32];
-    type OutputPortType = &'static mut [f32];
-
-    #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
-    }
-
-    #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
-    }
-}
-
-pub struct InPlaceCV;
-
-unsafe impl UriBound for InPlaceCV {
-    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__CVPort;
-}
-
-impl PortType for InPlaceCV {
-    type InputPortType = &'static [Cell<f32>];
-    type OutputPortType = &'static [Cell<f32>];
-
-    #[inline]
-    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
-        Cell::from_mut(std::slice::from_raw_parts_mut(
-            pointer.as_ptr() as *mut f32,
-            sample_count as usize,
-        ))
-        .as_slice_of_cells()
-    }
-
-    #[inline]
-    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
-        Cell::from_mut(std::slice::from_raw_parts_mut(
-            pointer.as_ptr() as *mut f32,
-            sample_count as usize,
-        ))
-        .as_slice_of_cells()
-    }
-}
-
 /// Abstraction of safe port handles.
 pub trait PortHandle: Sized {
     /// Try to create a port handle from a port connection pointer and the sample count.
@@ -287,7 +137,7 @@ impl<T: PortHandle> PortHandle for Option<T> {
 ///         optional_control_input: Option<InputPort<Control>>,
 ///     }
 ///
-/// Please note that port indices are mapped in the order of occurence; In our example, the implementation will treat `audio_input` as port `0`, `audio_output` as port `1` and so on. Therefore, your plugin definition and your port collection have to match. Otherwise, undefined behaviour will occur.
+/// Please note that port indices are mapped in the order of occurrence; In our example, the implementation will treat `audio_input` as port `0`, `audio_output` as port `1` and so on. Therefore, your plugin definition and your port collection have to match. Otherwise, undefined behaviour will occur.
 pub trait PortCollection: Sized {
     /// The type of the port pointer cache.
     ///
diff --git a/core/src/port/audio.rs b/core/src/port/audio.rs
new file mode 100644
index 00000000..ac755e90
--- /dev/null
+++ b/core/src/port/audio.rs
@@ -0,0 +1,155 @@
+use crate::port::PortType;
+use std::cell::Cell;
+use std::ffi::c_void;
+use std::ptr::NonNull;
+use urid::UriBound;
+
+/// A port connected to an array of float audio samples. Using this port **requires** the `inPlaceBroken` feature.
+///
+/// Ports of this type are connected to a buffer of float audio samples, represented as a slice.
+///
+/// Audio samples are normalized between -1.0 and 1.0, though there is no requirement for samples to be strictly within this range.
+///
+/// See the [LV2 reference](https://lv2plug.in/ns/lv2core#AudioPort) for more information.
+///
+/// # Example
+///
+/// This very simple amplifier plugin multiplies the input sample by 2 and outputs the result.
+///
+/// ```
+/// # use lv2_core::prelude::*;
+/// # use urid::*;
+/// # #[uri("http://lv2plug.in/plugins.rs/simple_amp")]
+/// # struct SimpleAmp;
+/// #[derive(PortCollection)]
+/// struct SimpleAmpPorts {
+///     input: InputPort<Audio>,
+///     output: OutputPort<Audio>,
+/// }
+///
+/// impl Plugin for SimpleAmp {
+///     type Ports = SimpleAmpPorts;
+/// # type InitFeatures = ();
+/// # type AudioFeatures = ();
+/// # fn new(plugin_info: &PluginInfo,features: &mut Self::InitFeatures) -> Option<Self> {
+/// #         unimplemented!()
+/// # }
+///     // some implementation details elided…
+///
+///     fn run(&mut self, ports: &mut SimpleAmpPorts, _: &mut (), _: u32) {
+///         // Input and Output dereference to `&[f32]` and `&mut [f32]`, respectively.
+///         let input = ports.input.iter();
+///         let output = ports.output.iter_mut();
+///
+///         for (input_sample, output_sample) in input.zip(output) {
+///             *output_sample = *input_sample * 2.0;
+///         }
+///     }
+/// }
+///
+///
+/// ```
+///
+/// # Safety
+///
+/// Using this port type requires the `inPlaceBroken` LV2 feature in your plugin. Because this port
+/// type uses shared (`&[f32]`) and exclusive (`&mut [f32]`) references to its data, LV2 hosts
+/// MUST NOT use the same buffer for both the input and the output.
+/// However, do note that some hosts (Ardour, Zrythm, etc.) do not support `inPlaceBroken` plugins.
+///
+/// Use [`InPlaceAudio`] instead if you do not want to enforce this restriction on hosts,
+/// and do not need references pointing into the buffer's contents.
+pub struct Audio;
+
+unsafe impl UriBound for Audio {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__AudioPort;
+}
+
+impl PortType for Audio {
+    type InputPortType = &'static [f32];
+    type OutputPortType = &'static mut [f32];
+
+    #[inline]
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
+    }
+
+    #[inline]
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
+    }
+}
+
+/// A port connected to an array of float audio samples. This port type can safely operate on shared input and output buffers.
+///
+/// Ports of this type are connected to a buffer of float audio samples, represented as a slice of [`Cell`s](std::cell::Cell).
+///
+/// Audio samples are normalized between -1.0 and 1.0, though there is no requirement for samples to be strictly within this range.
+///
+/// See the [LV2 reference](https://lv2plug.in/ns/lv2core#AudioPort) for more information.
+///
+/// # Example
+///
+/// This very simple amplifier plugin multiplies the input sample by 2 and outputs the result.
+///
+/// ```
+/// # use lv2_core::prelude::*;
+/// # use urid::*;
+/// # #[uri("http://lv2plug.in/plugins.rs/simple_amp")]
+/// # struct SimpleAmp;
+/// #[derive(PortCollection)]
+/// struct SimpleAmpPorts {
+///     input: InputPort<InPlaceAudio>,
+///     output: OutputPort<InPlaceAudio>,
+/// }
+///
+/// impl Plugin for SimpleAmp {
+///     type Ports = SimpleAmpPorts;
+/// # type InitFeatures = ();
+/// # type AudioFeatures = ();
+/// # fn new(plugin_info: &PluginInfo,features: &mut Self::InitFeatures) -> Option<Self> {
+/// #         unimplemented!()
+/// # }
+///     // some implementation details elided…
+///
+///     fn run(&mut self, ports: &mut SimpleAmpPorts, _: &mut (), _: u32) {
+///         // Input and Output both dereference to `&[Cell<f32>]`.
+///         let input = ports.input.iter();
+///         let output = ports.output.iter();
+///
+///         for (input_sample, output_sample) in input.zip(output) {
+///             output_sample.set(input_sample.get() * 2.0);
+///         }
+///     }
+/// }
+///
+///
+/// ```
+pub struct InPlaceAudio;
+
+unsafe impl UriBound for InPlaceAudio {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__AudioPort;
+}
+
+impl PortType for InPlaceAudio {
+    type InputPortType = &'static [Cell<f32>];
+    type OutputPortType = &'static [Cell<f32>];
+
+    #[inline]
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        Cell::from_mut(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
+    }
+
+    #[inline]
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        Cell::from_mut(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
+    }
+}
diff --git a/core/src/port/control.rs b/core/src/port/control.rs
new file mode 100644
index 00000000..d5829de3
--- /dev/null
+++ b/core/src/port/control.rs
@@ -0,0 +1,148 @@
+use crate::port::PortType;
+use std::cell::Cell;
+use std::ffi::c_void;
+use std::ptr::NonNull;
+use urid::UriBound;
+
+/// A port connected to a single float ([`f32`]). Using this port **requires** the `inPlaceBroken` feature.
+///
+/// See the [LV2 reference](https://lv2plug.in/ns/lv2core#ControlPort) for more information.
+///
+/// # Example
+///
+/// This very simple amplifier plugin multiplies the input sample by the input control value and outputs the result.
+///
+/// ```
+/// # use lv2_core::prelude::*;
+/// # use urid::*;
+/// # #[uri("http://lv2plug.in/plugins.rs/simple_amp")]
+/// # struct ControlAmp;
+/// #[derive(PortCollection)]
+/// struct ControlAmpPorts {
+///     factor: InputPort<Control>,
+///     input: InputPort<Audio>,
+///     output: OutputPort<Audio>,
+/// }
+///
+/// impl Plugin for ControlAmp {
+///     type Ports = ControlAmpPorts;
+/// # type InitFeatures = ();
+/// # type AudioFeatures = ();
+/// # fn new(plugin_info: &PluginInfo,features: &mut Self::InitFeatures) -> Option<Self> {
+/// #         unimplemented!()
+/// # }
+///     // some implementation details elided…
+///
+///     fn run(&mut self, ports: &mut ControlAmpPorts, _: &mut (), _: u32) {
+///         // Input and Output dereference to `&f32` and `&mut f32`, respectively.
+///         let factor = *ports.factor;
+///
+///         let input = ports.input.iter();
+///         let output = ports.output.iter_mut();
+///
+///         for (input_sample, output_sample) in input.zip(output) {
+///             *output_sample = *input_sample * *factor;
+///         }
+///     }
+/// }
+///
+///
+/// ```
+///
+/// # Safety
+///
+/// Using this port type requires the `inPlaceBroken` LV2 feature in your plugin. Because this port
+/// type uses shared (`&f32`) and exclusive (`&mut f32`) references to its data, LV2 hosts
+/// MUST NOT use the same buffer for both the input and the output.
+/// However, do note that some hosts (Ardour, Zrythm, etc.) do not support `inPlaceBroken` plugins.
+///
+/// Use [`InPlaceControl`] instead if you do not want to enforce this restriction on hosts,
+/// and do not need references pointing into the buffer's contents.
+pub struct Control;
+
+unsafe impl UriBound for Control {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__ControlPort;
+}
+
+impl PortType for Control {
+    type InputPortType = f32;
+    type OutputPortType = &'static mut f32;
+
+    #[inline]
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> f32 {
+        *(pointer.cast().as_ref())
+    }
+
+    #[inline]
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> &'static mut f32 {
+        (pointer.as_ptr() as *mut f32).as_mut().unwrap()
+    }
+}
+
+/// A port connected to a single float ([`f32`]). This port type can safely operate on shared input and output buffers.
+///
+/// See the [LV2 reference](https://lv2plug.in/ns/lv2core#ControlPort) for more information.
+///
+/// # Example
+///
+/// This very simple amplifier plugin multiplies the input sample by the input control value and outputs the result.
+///
+/// ```
+/// # use lv2_core::prelude::*;
+/// # use urid::*;
+/// # #[uri("http://lv2plug.in/plugins.rs/simple_amp")]
+/// # struct ControlAmp;
+/// #[derive(PortCollection)]
+/// struct ControlAmpPorts {
+///     factor: InputPort<InPlaceControl>,
+///     input: InputPort<InPlaceAudio>,
+///     output: OutputPort<InPlaceAudio>,
+/// }
+///
+/// impl Plugin for ControlAmp {
+///     type Ports = ControlAmpPorts;
+/// # type InitFeatures = ();
+/// # type AudioFeatures = ();
+/// # fn new(plugin_info: &PluginInfo,features: &mut Self::InitFeatures) -> Option<Self> {
+/// #         unimplemented!()
+/// # }
+///     // some implementation details elided…
+///
+///     fn run(&mut self, ports: &mut ControlAmpPorts, _: &mut (), _: u32) {
+///         // Input and Output dereference to `&Cell<f32>`.
+///         let factor = ports.factor.get();
+///
+///         let input = ports.input.iter();
+///         let output = ports.output.iter();
+///
+///         for (input_sample, output_sample) in input.zip(output) {
+///             output_sample.set(input_sample.get()) * factor;
+///         }
+///     }
+/// }
+///
+///
+/// ```
+pub struct InPlaceControl;
+
+unsafe impl UriBound for InPlaceControl {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__ControlPort;
+}
+
+impl PortType for InPlaceControl {
+    type InputPortType = &'static Cell<f32>;
+    type OutputPortType = &'static Cell<f32>;
+
+    #[inline]
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, _sample_count: u32) -> Self::InputPortType {
+        Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
+    }
+
+    #[inline]
+    unsafe fn output_from_raw(
+        pointer: NonNull<c_void>,
+        _sample_count: u32,
+    ) -> Self::OutputPortType {
+        Cell::from_mut(&mut *(pointer.as_ptr() as *mut f32))
+    }
+}
diff --git a/core/src/port/cv.rs b/core/src/port/cv.rs
new file mode 100644
index 00000000..32a38b92
--- /dev/null
+++ b/core/src/port/cv.rs
@@ -0,0 +1,181 @@
+use crate::port::PortType;
+use std::cell::Cell;
+use std::ffi::c_void;
+use std::ptr::NonNull;
+use urid::UriBound;
+
+/// A port connected to an array of float control values. Using this port **requires** the `inPlaceBroken` feature.
+///
+/// Ports of this type are connected to a buffer of float control values, represented as a slice.
+/// They have the same buffer format as [`Audio`](crate::port::Audio) ports, except the buffer represents
+/// audio-rate control data rather than audio.
+/// Like a [`Control`](crate::port::Control) port, a CV port SHOULD have properties describing its value, in particular minimum, maximum, and default.
+///
+/// Hosts may present CV ports to users as controls in the same way as control ports.
+/// Conceptually, aside from the buffer format, a CV port is the same as a control port, so hosts can use all the same properties and expectations.
+///
+/// In particular, this port type does not imply any range, unit, or meaning for its values.
+/// However, if there is no inherent unit to the values, for example if the port is used to modulate some other value, then plugins SHOULD use a normalized range, either from -1.0 to 1.0, or from 0.0 to 1.0.
+///
+/// It is generally safe to connect an audio output to a CV input, but not vice-versa.
+/// Hosts must take care to prevent data from a CVPort port from being used as audio.
+///
+/// See the [LV2 reference](https://lv2plug.in/ns/lv2core#CVPort) for more information.
+///
+/// # Example
+///
+/// This very simple amplifier plugin multiplies the input sample by the input CV signal and outputs the result.
+///
+/// ```
+/// # use lv2_core::prelude::*;
+/// # use urid::*;
+/// # #[uri("http://lv2plug.in/plugins.rs/simple_amp")]
+/// # struct CVAmp;
+/// #[derive(PortCollection)]
+/// struct CVAmpPorts {
+///     factor: InputPort<CV>,
+///     input: InputPort<Audio>,
+///     output: OutputPort<Audio>,
+/// }
+///
+/// impl Plugin for CVAmp {
+///     type Ports = CVAmpPorts;
+/// # type InitFeatures = ();
+/// # type AudioFeatures = ();
+/// # fn new(plugin_info: &PluginInfo,features: &mut Self::InitFeatures) -> Option<Self> {
+/// #         unimplemented!()
+/// # }
+///     // some implementation details elided…
+///
+///     fn run(&mut self, ports: &mut CVAmpPorts, _: &mut (), _: u32) {
+///         // Input and Output dereference to `&[f32]` and `&mut [f32]`, respectively.
+///         let factor = ports.factor.iter();
+///
+///         let input = ports.input.iter();
+///         let output = ports.output.iter_mut();
+///
+///         for ((input_sample, output_sample), amp_factor) in input.zip(output).zip(factor) {
+///             *output_sample = *input_sample * *amp_factor;
+///         }
+///     }
+/// }
+///
+///
+/// ```
+///
+/// # Safety
+///
+/// Using this port type requires the `inPlaceBroken` LV2 feature in your plugin. Because this port
+/// type uses shared (`&[f32]`) and exclusive (`&mut [f32]`) references to its data, LV2 hosts
+/// MUST NOT use the same buffer for both the input and the output.
+/// However, do note that some hosts (Ardour, Zrythm, etc.) do not support `inPlaceBroken` plugins.
+///
+/// Use [`InPlaceCV`] instead if you do not want to enforce this restriction on hosts,
+/// and do not need references pointing into the buffer's contents.
+pub struct CV;
+
+unsafe impl UriBound for CV {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__CVPort;
+}
+
+impl PortType for CV {
+    type InputPortType = &'static [f32];
+    type OutputPortType = &'static mut [f32];
+
+    #[inline]
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        std::slice::from_raw_parts(pointer.as_ptr() as *const f32, sample_count as usize)
+    }
+
+    #[inline]
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        std::slice::from_raw_parts_mut(pointer.as_ptr() as *mut f32, sample_count as usize)
+    }
+}
+
+/// A port connected to an array of float control values. This port type can safely operate on shared input and output buffers.
+///
+/// Ports of this type are connected to a buffer of float control values, represented as a slice of [`Cell`s](std::cell::Cell).
+/// They have the same buffer format as [`InPlaceAudio`](crate::port::InPlaceAudio) ports, except the buffer represents
+/// audio-rate control data rather than audio.
+/// Like a [`InPlaceControl`](crate::port::InPlaceControl) port, a CV port SHOULD have properties describing its value, in particular minimum, maximum, and default.
+///
+/// Hosts may present CV ports to users as controls in the same way as control ports.
+/// Conceptually, aside from the buffer format, a CV port is the same as a control port, so hosts can use all the same properties and expectations.
+///
+/// In particular, this port type does not imply any range, unit, or meaning for its values.
+/// However, if there is no inherent unit to the values, for example if the port is used to modulate some other value, then plugins SHOULD use a normalized range, either from -1.0 to 1.0, or from 0.0 to 1.0.
+///
+/// It is generally safe to connect an audio output to a CV input, but not vice-versa.
+/// Hosts must take care to prevent data from a CVPort port from being used as audio.
+///
+/// See the [LV2 reference](https://lv2plug.in/ns/lv2core#CVPort) for more information.
+///
+/// # Example
+///
+/// This very simple amplifier plugin multiplies the input sample by the input CV signal and outputs the result.
+///
+/// ```
+/// # use lv2_core::prelude::*;
+/// # use urid::*;
+/// # #[uri("http://lv2plug.in/plugins.rs/simple_amp")]
+/// # struct CVAmp;
+/// #[derive(PortCollection)]
+/// struct CVAmpPorts {
+///     factor: InputPort<InPlaceCV>,
+///     input: InputPort<InPlaceAudio>,
+///     output: OutputPort<InPlaceAudio>,
+/// }
+///
+/// impl Plugin for CVAmp {
+///     type Ports = CVAmpPorts;
+/// # type InitFeatures = ();
+/// # type AudioFeatures = ();
+/// # fn new(plugin_info: &PluginInfo,features: &mut Self::InitFeatures) -> Option<Self> {
+/// #         unimplemented!()
+/// # }
+///     // some implementation details elided…
+///
+///     fn run(&mut self, ports: &mut CVAmpPorts, _: &mut (), _: u32) {
+///         // Input and Output dereference to `&[Cell<f32>]`.
+///         let factor = ports.factor.iter();
+///
+///         let input = ports.input.iter();
+///         let output = ports.output.iter();
+///
+///         for ((input_sample, output_sample), amp_factor) in input.zip(output).zip(factor) {
+///             output_sample.set(input_sample * amp_factor);
+///         }
+///     }
+/// }
+///
+///
+/// ```
+pub struct InPlaceCV;
+
+unsafe impl UriBound for InPlaceCV {
+    const URI: &'static [u8] = ::lv2_sys::LV2_CORE__CVPort;
+}
+
+impl PortType for InPlaceCV {
+    type InputPortType = &'static [Cell<f32>];
+    type OutputPortType = &'static [Cell<f32>];
+
+    #[inline]
+    unsafe fn input_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::InputPortType {
+        Cell::from_mut(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
+    }
+
+    #[inline]
+    unsafe fn output_from_raw(pointer: NonNull<c_void>, sample_count: u32) -> Self::OutputPortType {
+        Cell::from_mut(std::slice::from_raw_parts_mut(
+            pointer.as_ptr() as *mut f32,
+            sample_count as usize,
+        ))
+        .as_slice_of_cells()
+    }
+}

From 39cb5f55a42fd51eae4f5a44fe970feef03575f8 Mon Sep 17 00:00:00 2001
From: Adrien Prokopowicz <adrien.prokopowicz@gmail.com>
Date: Tue, 3 Aug 2021 03:29:03 +0200
Subject: [PATCH 8/8] Fix tests

---
 core/src/port/control.rs | 4 ++--
 core/src/port/cv.rs      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/port/control.rs b/core/src/port/control.rs
index d5829de3..4f9c953f 100644
--- a/core/src/port/control.rs
+++ b/core/src/port/control.rs
@@ -41,7 +41,7 @@ use urid::UriBound;
 ///         let output = ports.output.iter_mut();
 ///
 ///         for (input_sample, output_sample) in input.zip(output) {
-///             *output_sample = *input_sample * *factor;
+///             *output_sample = *input_sample * factor;
 ///         }
 ///     }
 /// }
@@ -116,7 +116,7 @@ impl PortType for Control {
 ///         let output = ports.output.iter();
 ///
 ///         for (input_sample, output_sample) in input.zip(output) {
-///             output_sample.set(input_sample.get()) * factor;
+///             output_sample.set(input_sample.get() * factor);
 ///         }
 ///     }
 /// }
diff --git a/core/src/port/cv.rs b/core/src/port/cv.rs
index 32a38b92..9455aa0c 100644
--- a/core/src/port/cv.rs
+++ b/core/src/port/cv.rs
@@ -144,7 +144,7 @@ impl PortType for CV {
 ///         let output = ports.output.iter();
 ///
 ///         for ((input_sample, output_sample), amp_factor) in input.zip(output).zip(factor) {
-///             output_sample.set(input_sample * amp_factor);
+///             output_sample.set(input_sample.get() * amp_factor.get());
 ///         }
 ///     }
 /// }