Streaming RIR reverb (time domain convolution)

extensions/climiter.pxd

@@ -12,8 +12,27 @@ cdef extern from "limiter.h" nogil:
 
         string write_to_string() const
 
-        void limit_inplace(float * const, size_t)
+        void apply_inplace(float * const, size_t)
 
-        vector[float] limit(const float * const, size_t)
+        vector[float] apply(const float * const, size_t)
+
+        void reset()
+
+
+cdef extern from "reverb_rir.h" nogil:
+
+    cdef cppclass ReverbRIR:
+
+        ReverbRIR()
+
+        ReverbRIR(const float * const, const size_t)
+
+        ReverbRIR read_from_string(string data)
+
+        string write_to_string() const
+
+        void apply_inplace(float * const, const size_t)
+
+        vector[float] apply(const float * const, const size_t)
 
         void reset()

extensions/cylimiter.pyx

@@ -1,45 +1,95 @@
 #cython: language_level=3
 import warnings
+from typing import Optional, Sequence, Union
 
 from libcpp.memory cimport unique_ptr
 
 from extensions.climiter cimport CLimiter
+from extensions.climiter cimport ReverbRIR as CReverbRIR
 import numpy as np
 
 
 cdef class Limiter:
-    cdef unique_ptr[CLimiter] _limiter
+    cdef unique_ptr[CLimiter] _ptr
 
     def __init__(self, attack: float = 0.9, release: float = 0.9995, delay: int = 40, threshold: float = 0.95):
         assert 0 < attack < 1, "Permitted attack value range is (0 - 1)."
         assert 0 < release < 1, "Permitted release value range is (0 - 1)."
         assert 0 < threshold, "threshold has to be a float greater than zero."
         assert isinstance(delay, int) and delay > 0, "Delay has to be an integer greater than zero."
-        self._limiter.reset(new CLimiter(attack, release, delay, threshold))
+        self._ptr.reset(new CLimiter(attack, release, delay, threshold))
 
     def __setstate__(self, state: bytes) -> None:
         self.__init__()
-        self._limiter.get().read_from_string(state)
+        self._ptr.get().read_from_string(state)
 
     def __getstate__(self) -> bytes:
         return self.write_to_string()
 
     def write_to_string(self) -> bytes:
-        return self._limiter.get().write_to_string()
-
-    def limit_inplace(self, audio: np.ndarray) -> np.ndarray:
-        assert isinstance(audio, np.ndarray), "For in-place limiter, we only support Numpy arrays. Either convert your input to a 1D Numpy array, or use the non-in-place operation ('limiter.limit(arr)')."
-        assert audio.dtype == np.float32, "We only support np.float32 dtype for in-place operations."
-        assert audio.ndim == 1, "The input audio array has to be single-dimensional (only mono audio is supported)."
-        assert audio.flags['C_CONTIGUOUS'], "The input array has to be contiguous (you can use np.ascontiguousarray)."
+        return self._ptr.get().write_to_string()
 
+    def apply_inplace(self, audio: np.ndarray) -> None:
+        _check_array(audio)
         cdef float[:] audio_memview = audio
-        self._limiter.get().limit_inplace(&audio_memview[0], audio_memview.shape[0])
+        self._ptr.get().apply_inplace(&audio_memview[0], audio_memview.shape[0])
+
+    def apply(self, audio) -> np.ndarray:
+        audio_arr = np.copy(np.ascontiguousarray(audio, dtype=np.float32))
+        self.apply_inplace(audio_arr)
+        return audio_arr
+
+    def limit_inplace(self, audio: np.ndarray) -> None:
+        self.apply_inplace(audio)
 
     def limit(self, audio) -> np.ndarray:
+        return self.apply(audio)
+
+    def reset(self) -> None:
+        return self._ptr.get().reset()
+
+
+cdef class ReverbRIR:
+    cdef unique_ptr[CReverbRIR] _ptr
+
+    def __init__(self, rir: Optional[Union[Sequence[float], np.ndarray]] = None):
+        if rir is None:
+            self._ptr.reset(new CReverbRIR())
+        else:
+            self._init_from_rir(rir)
+
+    def _init_from_rir(self, rir):
+        # There will be two copies total, but it shouldn't be too bad...
+        rir = np.copy(np.ascontiguousarray(rir, dtype=np.float32))
+        cdef float[:] rir_memview = rir
+        self._ptr.reset(new CReverbRIR(&rir_memview[0], rir_memview.shape[0]))
+
+    def __setstate__(self, state: bytes) -> None:
+        self.__init__()
+        self._ptr.get().read_from_string(state)
+
+    def __getstate__(self) -> bytes:
+        return self.write_to_string()
+
+    def write_to_string(self) -> bytes:
+        return self._ptr.get().write_to_string()
+
+    def apply_inplace(self, audio: np.ndarray) -> None:
+        _check_array(audio)
+        cdef float[:] audio_memview = audio
+        self._ptr.get().apply_inplace(&audio_memview[0], audio_memview.shape[0])
+
+    def apply(self, audio) -> np.ndarray:
         audio_arr = np.copy(np.ascontiguousarray(audio, dtype=np.float32))
-        self.limit_inplace(audio_arr)
+        self.apply_inplace(audio_arr)
         return audio_arr
 
     def reset(self) -> None:
-        return self._limiter.get().reset()
+        return self._ptr.get().reset()
+
+
+def _check_array(arr) -> None:
+    assert isinstance(arr, np.ndarray), "For in-place operations, we only support Numpy arrays. Either convert your input to a 1D Numpy array, or use the non-in-place operation ('effect.apply(arr)')."
+    assert arr.dtype == np.float32, "We only support np.float32 dtype for in-place operations."
+    assert arr.ndim == 1, "The input array has to be single-dimensional (only mono audio is supported)."
+    assert arr.flags['C_CONTIGUOUS'], "The input array has to be contiguous (you can use np.ascontiguousarray)."

extensions/limiter.cpp

@@ -16,7 +16,7 @@ CLimiter::CLimiter(float attack, float release, int delay, float threshold)
     reset();
 }
 
-void CLimiter::limit_inplace(float * const audio, size_t num_samples) {
+void CLimiter::apply_inplace(float * const audio, const size_t num_samples) {
     for (size_t idx = 0; idx < num_samples; ++idx) {
         const auto sample = audio[idx];
         delay_line_[delay_index_] = sample;
@@ -38,10 +38,10 @@ void CLimiter::limit_inplace(float * const audio, size_t num_samples) {
     }
 }
 
-vector<float> CLimiter::limit(float const * const audio, size_t num_samples) {
+vector<float> CLimiter::apply(float const * const audio, const size_t num_samples) {
     vector<float> out;
     copy(audio, audio + num_samples, back_inserter(out));
-    limit_inplace(out.data(), out.size());
+    apply_inplace(out.data(), out.size());
     return out;
 }
 
@@ -65,7 +65,7 @@ void CLimiter::read_from_string(const string &data) {
     str >> envelope_;
     str >> gain_;
     float sample;
-    delay_line_.empty();
+    delay_line_.clear();
     while(str >> sample) {
         delay_line_.push_back(sample);
     }

extensions/limiter.h

@@ -10,8 +10,8 @@ class CLimiter {
     public:
         CLimiter(float attack, float release, int delay, float threshold);
 
-        void limit_inplace(float * const audio, std::size_t num_samples);
-        std::vector<float> limit(float const * const audio, std::size_t num_samples);
+        void apply_inplace(float * const audio, const std::size_t num_samples);
+        std::vector<float> apply(float const * const audio, const std::size_t num_samples);
         void reset();
 
         void read_from_string(const std::string &data);