Drop two redundant examples

process_all_f64 only differed from process_f64 by calling
process_all_into_buffer, which is now shown by a doc example on the method
itself. process_i16 duplicated process_f64 apart from wrapping the input in
an integer byte adapter, which audioadapter documents. Removing it also
drops the audioadapter-sample dev dependency.

Author: HEnquist

Cargo.toml

@@ -39,7 +39,6 @@ log = "0.4.18"
 approx = "0.5.1"
 test-log = "0.2.16"
 test-case = "3"
-audioadapter-sample = "5.1"
 waveadapter = "0.2"
 clap = { version = "4.6", features = ["derive"] }
 

examples/process_all_f64.rs

@@ -282,6 +282,39 @@ where
     /// [process_into_buffer](Resampler::process_into_buffer).
     ///
     /// Returns the lengths of the original input and the resampled output.
+    ///
+    /// # Example
+    ///
+    /// Resample one second of 44.1 kHz audio to 48 kHz, into a buffer allocated
+    /// up front. This is the variant to use when allocating during processing is
+    /// not acceptable, such as in a realtime thread. See
+    /// [process_all](Resampler::process_all) for the allocating counterpart.
+    ///
+    /// ```
+    /// use audioadapter_buffers::owned::InterleavedOwned;
+    /// use rubato::{Fft, FixedSync, Resampler};
+    ///
+    /// let channels = 2;
+    /// let input_len = 44100;
+    /// let input = InterleavedOwned::<f64>::new(0.0, channels, input_len);
+    ///
+    /// let mut resampler =
+    ///     Fft::<f64>::new(44100, 48000, 1024, channels, FixedSync::Both).unwrap();
+    ///
+    /// // Allocate an output buffer that is guaranteed to be big enough.
+    /// let needed_len = resampler.process_all_needed_output_len(input_len);
+    /// let mut output = InterleavedOwned::<f64>::new(0.0, channels, needed_len);
+    ///
+    /// let (consumed, produced) = resampler
+    ///     .process_all_into_buffer(&input, &mut output, input_len, None)
+    ///     .unwrap();
+    ///
+    /// // The resampled audio is the first `produced` frames of the buffer.
+    /// // The rest is padding, since the buffer is sized for the worst case.
+    /// assert_eq!(consumed, input_len);
+    /// assert!(produced >= 48000);
+    /// assert!(produced <= needed_len);
+    /// ```
     fn process_all_into_buffer(
         &mut self,
         buffer_in: &dyn Adapter<T>,