Oddio

https://docs.rs/oddio/0.7.4
Admin
Oddio is a lightweight Rust library for game audio that provides spatial sound mixing, dynamic...
Tokens:105,312
Snippets:751
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example: Get First Element of Array

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates retrieving the first element of an array using .first(). Returns an Option<&T>.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### Example: Check if Array is Empty

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates checking if an array is empty using the .is_empty() method. Shows examples for both non-empty and empty arrays.

```rust
let a = [1, 2, 3];
assert!(!a.is_empty());

let b: &[i32] = &[];
assert!(b.is_empty());
```

--------------------------------

### Example: Array Length

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates how to get the length of an array using the .len() method. This is a basic Rust array operation.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Basic Oddio Usage Example

Source: https://docs.rs/oddio/0.7.4/src/oddio/lib.rs.html

Demonstrates setting up a SpatialScene, playing audio frames, and updating spatial properties. This is useful for integrating game audio with spatialization.

```rust
let (mut scene_handle, mut scene) = oddio::SpatialScene::new();

// In audio callback:
# let data = &mut [][..];
# let output_sample_rate = 44100;
let out_frames = oddio::frame_stereo(data);
oddio::run(&mut scene, output_sample_rate, out_frames);

// In game logic:
# let frames = [];
# let sample_rate = 44100;
# let position = [0.0, 0.0, 0.0].into();
# let velocity = [0.0, 0.0, 0.0].into();
let frames = oddio::FramesSignal::from(oddio::Frames::from_slice(sample_rate, &frames));
let mut handle = scene_handle
    .play(frames, oddio::SpatialOptions { position, velocity, ..Default::default() });

// When position/velocity changes:
handle.set_motion(position, velocity, false);
```

--------------------------------

### Example: Get First Chunk of Array

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates getting a fixed-size array reference to the first N elements of a slice using .first_chunk::<N>(). Returns None if the slice is too short.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### FramesSignal::new

Source: https://docs.rs/oddio/0.7.4/oddio/struct.FramesSignal.html

Creates a new FramesSignal from a sequence of samples, with an adjustable start time.

```APIDOC
## impl<T> FramesSignal<T>

### pub fn new( data: Arc<Frames<T>>, start_seconds: f64, ) -> (FramesSignalControl, Self)

#### Description
Create an audio signal from some samples
`start_seconds` adjusts the initial playback position, and may be negative.
```

--------------------------------

### Example: Split First and Rest of Array

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates splitting an array slice into its first element and the rest of the slice using .split_first(). Returns an Option containing a tuple.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

--------------------------------

### Sine::new

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Sine.html

Constructs a new Sine wave generator with a specific starting phase and frequency.

```APIDOC
## Sine::new

### Description
Constructs a sine wave that begins at `phase` radians and cycles `frequency_hz` times per second.

### Parameters
#### Arguments
- **phase** (f32) - Required - Starting phase in radians.
- **frequency_hz** (f32) - Required - Frequency of the sine wave in cycles per second.
```

--------------------------------

### Check slice prefix

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Determines if a slice starts with a given prefix.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### Example: Split First and Rest Mutably

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates splitting a mutable array slice into its first element and the rest mutably using .split_first_mut(). Allows modification of both parts.

```rust
let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_mut() {
    *first = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[3, 4, 5]);
```

--------------------------------

### MonoToStereo Test Case

Source: https://docs.rs/oddio/0.7.4/src/oddio/signal.rs.html

Example usage of MonoToStereo with a custom counting signal.

```rust
struct CountingSignal(u32);

impl Signal for CountingSignal {
    type Frame = Sample;
    fn sample(&mut self, _: f32, out: &mut [Sample]) {
        for x in out {
            let i = self.0;
            *x = i as f32;
            self.0 = i + 1;
        }
    }
}

#[test]
fn mono_to_stereo() {
    let mut signal = MonoToStereo::new(CountingSignal(0));
    let mut buf = [[0.0; 2]; 4];
    signal.sample(1.0, (&mut buf[..]).into());
    assert_eq!(buf, [[0.0, 0.0], [1.0, 1.0], [2.0, 2.0], [3.0, 3.0]]);
}
```

--------------------------------

### Initialize FramesSignal

Source: https://docs.rs/oddio/0.7.4/src/oddio/frames.rs.html

Creates a new FramesSignal with a specified starting time and associated control object. The start_seconds parameter can be negative.

```rust
pub fn new(data: Arc<Frames<T>>, start_seconds: f64) -> (FramesSignalControl, Self) {
        let samples = data.len();
        let signal = Self {
            t: start_seconds,
            sample_t: Arc::new(AtomicIsize::new((start_seconds * data.rate) as isize)),
            data,
        };
        let control = FramesSignalControl {
            samples,
            sample_position: signal.sample_t.clone(),
            rate: signal.data.rate,
        };
        (control, signal)
    }
```

--------------------------------

### Get Runtime in Seconds

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Calculates and returns the total runtime of the audio frames in seconds.

```rust
pub fn runtime(&self) -> f64
```

--------------------------------

### Example: Split Last and Rest of Array

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates splitting an array slice into its last element and the preceding elements using .split_last(). Returns an Option containing a tuple.

```rust
let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}
```

--------------------------------

### Seek Implementation for FixedGain

Source: https://docs.rs/oddio/0.7.4/oddio/struct.FixedGain.html

Allows seeking within the FixedGain signal. Shifts the starting point of the next sample call by the specified number of seconds.

```rust
fn seek(&mut self, seconds: f32)
```

--------------------------------

### Example: Get First Chunk Mutably

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates getting a mutable fixed-size array reference to the first N elements of a slice using .first_chunk_mut::<N>(). Returns None if the slice is too short.

```rust
let x = &mut [0, 1, 2];

if let Some(first_two) = x.first_chunk_mut::<2>() {
    first_two[0] = 5;
    first_two[1] = 6;
}
assert_eq!(x, &[5, 6, 2]);
```

--------------------------------

### Adapt Struct and Configuration

Source: https://docs.rs/oddio/0.7.4/src/oddio/adapt.rs.html

Documentation for the Adapt struct, its constructor, and configuration options.

```APIDOC
## Adapt Struct

Smoothly adjusts gain over time to keep average (RMS) signal level within a target range.

Useful for allowing both quiet and loud sounds to be heard without severe distortion.

Rapid changes in input amplitude can cause the output to rise above 1. If a hard limit on output is required, a stateless compressor like `Reinhard` should be chained afterwards.

This filter is configured in terms of signal root mean square values. For reference, the RMS value of a sine wave is `amplitude / 2.0f32.sqrt()`. Note that these are linear units, whereas perception of loudness is logarithmic.

### Fields
- `options` (AdaptOptions): Configuration options for the Adapt filter.
- `avg_squared` (f32): Internal state for tracking the average squared signal level.
- `inner` (T): The inner signal being processed.

### Methods
#### `new(signal: T, initial_rms: f32, options: AdaptOptions) -> Self`

Applies adaptation to the given `signal`.

Initialized as if an infinite signal with root mean squared level `initial_rms` had been processed.

### `AdaptOptions` Struct

Configuration for an `Adapt` filter, passed to `Adapt::new`.

#### Fields
- `tau` (f32): How smoothly the filter should respond. Smaller values reduce time spent outside the target range, at the cost of lower perceived dynamic range. 0.1 is a good place to start.
- `max_gain` (f32): Maximum linear gain to apply regardless of input signal.
- `low` (f32): When the average RMS level is below this, the gain will increase over time, up to at most `max_gain`.
- `high` (f32): When the average RMS level is above this, the gain will decrease over time. This should usually be set lower than your desired maximum peak output to avoid clipping of transient spikes.

### Default Implementation for `AdaptOptions`

Provides default values for `tau`, `max_gain`, `low`, and `high`.
```

--------------------------------

### Initialize and Run Spatial Scene in oddio

Source: https://docs.rs/oddio/0.7.4/oddio/index.html

Sets up a spatial scene and processes audio output. This is typically done once at initialization and then within the audio callback.

```rust
let (mut scene_handle, mut scene) = oddio::SpatialScene::new();

// In audio callback:
let out_frames = oddio::frame_stereo(data);
oddio::run(&mut scene, output_sample_rate, out_frames);
```

--------------------------------

### Example: Get Last Element of Array

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates retrieving the last element of an array using .last(). Returns an Option<&T>.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Initialize and Control Spatial Audio

Source: https://docs.rs/oddio/0.7.4/index.html

Demonstrates setting up a spatial scene, playing a signal, and updating its motion parameters.

```rust
let (mut scene_handle, mut scene) = oddio::SpatialScene::new();

// In audio callback:
let out_frames = oddio::frame_stereo(data);
oddio::run(&mut scene, output_sample_rate, out_frames);

// In game logic:
let frames = oddio::FramesSignal::from(oddio::Frames::from_slice(sample_rate, &frames));
let mut handle = scene_handle
    .play(frames, oddio::SpatialOptions { position, velocity, ..Default::default() });

// When position/velocity changes:
handle.set_motion(position, velocity, false);
```

--------------------------------

### Example: Split Last and Rest Mutably

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates splitting a mutable array slice into its last element and the preceding elements mutably using .split_last_mut(). Allows modification of both parts.

```rust
let x = &mut [0, 1, 2];

if let Some((last, elements)) = x.split_last_mut() {
    *last = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[4, 5, 3]);
```

--------------------------------

### FramesSignal Initialization and Sampling

Source: https://docs.rs/oddio/0.7.4/src/oddio/frames.rs.html

Provides details on creating a FramesSignal and how it samples audio data.

```APIDOC
## FramesSignal

### Description
Represents an audio signal derived from a sequence of frames. It allows for playback with adjustable start times and interpolation between samples.

### Methods

#### `new(data: Arc<Frames<T>>, start_seconds: f64) -> (FramesSignalControl, Self)`

Creates a new `FramesSignal` and its associated control structure.

- **data** (Arc<Frames<T>>): Shared reference to the audio frames.
- **start_seconds** (f64): The initial playback position in seconds. Can be negative.

Returns a tuple containing `FramesSignalControl` and `FramesSignal`.

#### `sample(&mut self, interval: f32, out: &mut [T])`

Samples the signal at a given interval and fills the output buffer.

- **interval** (f32): The time interval between samples in seconds.
- **out** (&mut [T]): The buffer to fill with sampled frames.

### Signal Trait Implementation

#### `sample(&mut self, interval: f32, out: &mut [T])`

Implements the `sample` method from the `Signal` trait. It calculates the sample points based on the current time `t` and the frame rate, performing linear interpolation between samples.

#### `is_finished(&self) -> bool`

Implements the `is_finished` method from the `Signal` trait. Checks if the playback has reached the end of the frames.

### Seek Trait Implementation

#### `seek(&mut self, seconds: f32)`

Implements the `seek` method from the `Seek` trait. Adjusts the playback time by the specified number of seconds.

- **seconds** (f32): The amount of time to seek forward or backward.

### From Trait Implementation

#### `from(samples: Arc<Frames<T>>) -> Self`

Implements the `From` trait for `Arc<Frames<T>>`. Creates a `FramesSignal` starting at 0.0 seconds.
```

--------------------------------

### Get Playback Position from FramesSignalControl

Source: https://docs.rs/oddio/0.7.4/src/oddio/frames.rs.html

Retrieves the current playback position in seconds from the FramesSignalControl. The position can be negative if the signal started with a negative time.

```rust
pub fn playback_position(&self) -> f64 {
        self.sample_position.load(Ordering::Relaxed) as f64 / self.rate
    }
```

--------------------------------

### Oddio Core Concepts and Usage

Source: https://docs.rs/oddio/0.7.4/oddio/index.html

Illustrates the basic usage of oddio for audio playback and spatialization, including key primitives.

```APIDOC
## Oddio Core Concepts and Usage

### Description
This section provides a high-level overview and usage examples for the oddio crate, focusing on its core primitives for audio manipulation and playback.

### Key Primitives:
*   `Frames`: Stores static audio data.
*   `Mixer`: Allows concurrent playback of multiple signals.
*   `SpatialScene`: A mixer that spatializes signals.
*   `run`: Writes frames from a `Signal` into an output buffer.

### Example Usage:
```rust
let (mut scene_handle, mut scene) = oddio::SpatialScene::new();

// In audio callback:
let out_frames = oddio::frame_stereo(data);
oddio::run(&mut scene, output_sample_rate, out_frames);

// In game logic:
let frames = oddio::FramesSignal::from(oddio::Frames::from_slice(sample_rate, &frames));
let mut handle = scene_handle
    .play(frames, oddio::SpatialOptions { position, velocity, ..Default::default() });

// When position/velocity changes:
handle.set_motion(position, velocity, false);
```

For detailed examples, refer to the `examples` subdirectory in the crate source.
```

--------------------------------

### Oddio Core Functionality

Source: https://docs.rs/oddio/0.7.4/index.html

Demonstrates the basic usage of oddio for audio playback and spatialization.

```APIDOC
## Oddio Core Functionality

### Description
This snippet shows how to initialize a spatial scene, process audio output, and play audio frames with spatial options.

### Method
N/A (Illustrative Code)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```rust
let (mut scene_handle, mut scene) = oddio::SpatialScene::new();

// In audio callback:
let out_frames = oddio::frame_stereo(data);
oddio::run(&mut scene, output_sample_rate, out_frames);

// In game logic:
let frames = oddio::FramesSignal::from(oddio::Frames::from_slice(sample_rate, &frames));
let mut handle = scene_handle
    .play(frames, oddio::SpatialOptions { position, velocity, ..Default::default() });

// When position/velocity changes:
handle.set_motion(position, velocity, false);
```

### Response
N/A
```

--------------------------------

### Example: Get Last Element Mutably

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates modifying the last element of a mutable array slice using .last_mut(). Returns an Option<&mut T>.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

--------------------------------

### Example: Get First Element Mutably

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Demonstrates modifying the first element of a mutable array slice using .first_mut(). Returns an Option<&mut T>.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());
```

--------------------------------

### Common::new

Source: https://docs.rs/oddio/0.7.4/src/oddio/spatial.rs.html

Constructor for Common.

```APIDOC
## fn new(
    radius: f32,
    position: mint::Point3<f32>,
    velocity: mint::Vector3<f32>,
) -> (swap::Sender<Motion>, Arc<AtomicBool>, Self)

### Description
Creates a new `Common` data structure.

### Parameters
- **radius** (f32) - The audible radius.
- **position** (mint::Point3<f32>) - The initial position.
- **velocity** (mint::Vector3<f32>) - The initial velocity.

### Returns
A tuple containing:
- A `swap::Sender<Motion>` for sending motion updates.
- An `Arc<AtomicBool>` indicating if the signal is stopped.
- The newly created `Common` instance.
```

--------------------------------

### Get Element Offset for Unaligned Element

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Illustrates `element_offset` returning `None` when an element reference is not aligned with the start of an element in the slice. This occurs when the reference points between elements. Requires nightly Rust.

```rust
#![feature(substr_range)]

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

--------------------------------

### SpatialScene::new

Source: https://docs.rs/oddio/0.7.4/src/oddio/spatial.rs.html

Initializes a new SpatialScene and its corresponding control handle.

```APIDOC
## SpatialScene::new

### Description
Creates a new SpatialScene instance for spatializing mono signals for stereo output, returning both the control handle and the scene itself.

### Method
Rust Function

### Response
- **(SpatialSceneControl, SpatialScene)** - A tuple containing the control handle for the scene and the scene instance.
```

--------------------------------

### Function: run

Source: https://docs.rs/oddio/0.7.4/oddio/fn.run.html

A convenience wrapper for Signal::sample that populates an output buffer with frames from a signal at a specified sample rate.

```APIDOC
## Function: run

### Description
Populate `out` with frames from `signal` at `sample_rate`. This is a convenience wrapper for `Signal::sample`.

### Signature
`pub fn run<S: Signal + ?Sized>(signal: &mut S, sample_rate: u32, out: &mut [S::Frame])`

### Parameters
- **signal** (&mut S) - Required - The signal source implementing the Signal trait.
- **sample_rate** (u32) - Required - The sample rate at which to process the signal.
- **out** (&mut [S::Frame]) - Required - The output buffer to be populated with frames.
```

--------------------------------

### strip_prefix

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If the slice does not start with `prefix`, returns `None`.

```APIDOC
## strip_prefix

### Description
Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

### Method
`strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>` where `P: SlicePattern<Item = T> + ?Sized`, `T: PartialEq`

### Endpoint
N/A (Method on slice type)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

### Response
#### Success Response (200)
`Some(subslice)` if the prefix matches, `None` otherwise.

#### Response Example
```json
{
  "example": "Some(&[40, 30][..])"
}
```
```

--------------------------------

### Create and Initialize Fader

Source: https://docs.rs/oddio/0.7.4/src/oddio/fader.rs.html

Creates a new Fader instance, wrapping an initial signal. Returns a control handle and the Fader signal itself. Use this when setting up audio processing chains.

```rust
pub fn new(inner: T) -> (FaderControl<T>, Self) {
        let (send, recv) = swap::swap(|| None);
        let signal = Self {
            progress: 1.0,
            next: recv,
            inner,
        };
        let control = FaderControl(send);
        (control, signal)
    }
```

--------------------------------

### trim_prefix

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns a subslice with the optional prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix. If the slice does not start with `prefix`, returns the original slice.

```APIDOC
## trim_prefix

### Description
Returns a subslice with the optional prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix. If `prefix` is empty or the slice does not start with `prefix`, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice.

### Method
`trim_prefix<P>(&self, prefix: &P) -> &[T]` where `P: SlicePattern<Item = T> + ?Sized`, `T: PartialEq`

### Endpoint
N/A (Method on slice type)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = &[10, 40, 30];
assert_eq!(v.trim_prefix(&[10]), &[40, 30]);
assert_eq!(v.trim_prefix(&[10, 40]), &[30]);
assert_eq!(v.trim_prefix(&[10, 40, 30]), &[]);
assert_eq!(v.trim_prefix(&[50]), &[10, 40, 30]); // No prefix match, returns original slice
assert_eq!(v.trim_prefix(&[]), &[10, 40, 30]); // Empty prefix, returns original slice
```

### Response
#### Success Response (200)
The subslice with the prefix removed, or the original slice if the prefix does not match.

#### Response Example
```json
{
  "example": "&[40, 30]"
}
```
```

--------------------------------

### Constructor: Adapt::new

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Adapt.html

Creates a new Adapt instance to apply gain adaptation to a signal.

```APIDOC
## pub fn new(signal: T, initial_rms: f32, options: AdaptOptions) -> Self

### Description
Apply adaptation to a signal. The instance is initialized as if an infinite signal with a specific root mean squared level had been processed.

### Parameters
- **signal** (T) - Required - The input signal to be adapted.
- **initial_rms** (f32) - Required - The initial root mean squared level for the signal.
- **options** (AdaptOptions) - Required - Configuration options for the adaptation process.
```

--------------------------------

### Get Last Element of Slice (Immutable)

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Use `split_off_last` to remove and get an immutable reference to the last element of a slice. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

--------------------------------

### Implement Signal for Stream

Source: https://docs.rs/oddio/0.7.4/src/oddio/stream.rs.html

Provides the `sample` and `is_finished` methods for the `Stream` struct, allowing it to be used as an audio signal source. The `sample` method fills an output buffer with audio data, and `is_finished` indicates if the stream has completed.

```rust
impl<T: Frame + Copy> Signal for Stream<T> {
    type Frame = T;

    fn sample(&mut self, interval: f32, out: &mut [T]) {
        self.inner.update();
        if self.inner.is_closed() {
            self.stopping = true;
        }
        let s0 = self.t;
        let ds = interval * self.rate as f32;

        for (i, o) in out.iter_mut().enumerate() {
            *o = self.sample_single(s0 + ds * i as f32);
        }
        self.advance(interval * out.len() as f32);
    }

    #[allow(clippy::float_cmp)]
    fn is_finished(&self) -> bool {
        self.stopping && self.t == self.inner.len() as f32
    }
}
```

--------------------------------

### Get First Element of Slice (Immutable)

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Use `split_off_first` to remove and get an immutable reference to the first element of a slice. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

--------------------------------

### Get Last Element of Slice (Mutable)

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Use `split_off_last_mut` to remove and get a mutable reference to the last element of a mutable slice. Returns `None` if the slice is empty. The element can be modified in place.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'d');
```

--------------------------------

### Get First Element of Slice (Mutable)

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Use `split_off_first_mut` to remove and get a mutable reference to the first element of a mutable slice. Returns `None` if the slice is empty. The element can be modified in place.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

--------------------------------

### Oddio Key Primitives

Source: https://docs.rs/oddio/0.7.4/index.html

Overview of the main building blocks provided by the oddio crate.

```APIDOC
## Oddio Key Primitives

### Description
Key primitives in oddio for managing audio data and playback.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **Frames** (struct) - Stores static audio data.
- **Mixer** (struct) - Allows concurrent playback of multiple signals.
- **SpatialScene** (struct) - Mixes signals and spatializes them for stereo output.
- **run** (function) - Writes frames from a `Signal` into an output buffer.
- **FramesSignal** (struct) - An audio signal backed by static samples.

### Response Example
N/A
```

--------------------------------

### Interpolate values with Smoothed

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Smoothed.html

Demonstrates initializing a Smoothed value, setting targets, and advancing the interpolation over time.

```rust
let mut value = oddio::Smoothed::new(0.0);
assert_eq!(value.get(), 0.0);
// Changes only take effect after time passes
value.set(1.0);
assert_eq!(value.get(), 0.0);
value.advance(0.5);
assert_eq!(value.get(), 0.5);
// A new value can be supplied mid-interpolation without causing a discontinuity
value.set(1.5);
value.advance(0.5);
assert_eq!(value.get(), 1.0);
value.advance(0.5);
assert_eq!(value.get(), 1.5);
// Interpolation halts once the target value is reached
value.advance(0.5);
assert_eq!(value.get(), 1.5);
```

--------------------------------

### get

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Safely retrieves an element or subslice by index or range.

```APIDOC
## get<I>

### Description
Returns a reference to an element or subslice depending on the type of index. If given a position, returns a reference to the element at that position or `None` if out of bounds. If given a range, returns the subslice corresponding to that range, or `None` if out of bounds.

### Method
`get`

### Endpoint
N/A (Method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

### Response
#### Success Response (200)
`Option<&<I as SliceIndex<[T]>>::Output>`: An optional reference to the element or subslice, or `None` if the index is out of bounds.

#### Response Example
```rust
// Example of a successful response structure for index 1
// Some(&40)
// Example of a successful response structure for range 0..2
// Some(&[10, 40])
```
```

--------------------------------

### oddio::run

Source: https://docs.rs/oddio/0.7.4/src/oddio/lib.rs.html

Populates an output buffer with frames from a signal at a specified sample rate.

```APIDOC
## oddio::run

### Description
Convenience wrapper for Signal::sample that writes frames from a signal into an output buffer.

### Parameters
- **signal** (&mut S) - Required - The audio signal to sample.
- **sample_rate** (u32) - Required - The sample rate in Hz.
- **out** (&mut [S::Frame]) - Required - The output buffer to populate.

### Request Example
oddio::run(&mut scene, 44100, out_frames);
```

--------------------------------

### iter

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns an iterator over the slice, yielding elements from start to end.

```APIDOC
## GET /iter

### Description
Returns an iterator that yields references to the elements of the slice in order from the beginning to the end.

### Method
GET

### Endpoint
/iter

### Parameters
(No parameters are required for this operation.)

### Request Body
(No request body is required for this operation.)

### Response
#### Success Response (200)
Returns an iterator object. The elements can be accessed by calling `.next()` on the iterator.

#### Response Example
(The response is an iterator, not a static JSON object. Example usage involves iterating over the elements.)
```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```
```

--------------------------------

### Cycle::new

Source: https://docs.rs/oddio/0.7.4/src/oddio/cycle.rs.html

Constructs a new Cycle instance from a set of audio frames.

```APIDOC
## Cycle::new

### Description
Creates a new Cycle instance that will loop the provided audio frames.

### Parameters
- **frames** (Arc<Frames<T>>) - Required - The audio frames to be looped.
```

--------------------------------

### Mixer::new

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Mixer.html

Constructs a new mixer, returning a control handle and the mixer itself.

```APIDOC
## Mixer::new()

### Description
Construct a new mixer.

### Method
`pub fn new() -> (MixerControl<T>, Self)`

### Returns
A tuple containing a `MixerControl<T>` and the `Mixer<T>` instance.
```

--------------------------------

### Constructor: Speed::new

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Speed.html

Creates a new Speed instance and a corresponding control handle to dynamically adjust the playback rate of an audio signal.

```APIDOC
## pub fn new(signal: T) -> (SpeedControl, Self)

### Description
Initializes a new Speed processor for the provided signal. Returns a tuple containing a SpeedControl handle for dynamic adjustments and the Speed instance itself.

### Parameters
- **signal** (T) - Required - The audio signal to be processed.

### Response
- **(SpeedControl, Self)** - A tuple containing the control handle and the initialized Speed struct.
```

--------------------------------

### Iterate over slice elements

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns an iterator over the slice yielding items from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

--------------------------------

### Implement CloneToUninit (Nightly)

Source: https://docs.rs/oddio/0.7.4/oddio/struct.SpatialOptions.html

Performs copy-assignment from self to a raw pointer destination. This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Initialize Gain with Signal

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Gain.html

Creates a new Gain instance with an initial signal. Returns a GainControl and the Gain struct itself. Use this to apply dynamic amplification.

```rust
pub fn new(signal: T) -> (GainControl, Self)
```

--------------------------------

### Get Type ID

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Fader.html

Retrieves the `TypeId` of the current type. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Create MonoToStereo Instance

Source: https://docs.rs/oddio/0.7.4/oddio/struct.MonoToStereo.html

Constructor for MonoToStereo. Adapts the given mono signal to stereo.

```rust
pub fn new(signal: T) -> Self>
```

--------------------------------

### Sine::seek

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Sine.html

Shifts the starting point of the next sample call by a specified number of seconds.

```APIDOC
## Sine::seek

### Description
Shift the starting point of the next `sample` call by `seconds`.

### Parameters
#### Arguments
- **seconds** (f32) - Required - The amount of time to shift the signal forward.
```

--------------------------------

### Signal::sample

Source: https://docs.rs/oddio/0.7.4/src/oddio/cycle.rs.html

Samples the repeating signal into the provided output buffer.

```APIDOC
## Signal::sample

### Description
Generates audio samples from the looped frames into the output buffer.

### Parameters
- **interval** (f32) - Required - The time interval between samples.
- **out** (&mut [T]) - Required - The buffer to store the generated samples.
```

--------------------------------

### Signal Implementation for Adapt

Source: https://docs.rs/oddio/0.7.4/src/oddio/adapt.rs.html

Documentation for the `Signal` trait implementation for the `Adapt` struct, detailing its `sample` and `is_finished` methods.

```APIDOC
## `impl Signal for Adapt<T>`

Implements the `Signal` trait for the `Adapt` struct, allowing it to process audio frames.

### Methods
#### `sample(&mut self, interval: f32, out: &mut [T::Frame])`

Processes a block of audio frames, applying the adaptation gain.

- `interval` (f32): The time interval for this sample block.
- `out` (&mut [T::Frame]): The buffer to write the processed audio frames to.

This method calculates the adaptation gain based on the current average RMS level of the signal and applies it to each frame. It updates the internal `avg_squared` state.

#### `is_finished(&self) -> bool`

Checks if the inner signal has finished processing.

Returns `true` if the inner signal is finished, `false` otherwise.
```

--------------------------------

### Get Slice Length

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns the number of elements (samples) in the slice. This is a standard slice operation.

```rust
pub fn len(&self) -> usize
```

--------------------------------

### Get Sample Rate

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns the sample rate (number of samples per second) of the Frames.

```rust
pub fn rate(&self) -> u32
```

--------------------------------

### Get Number of Available Elements

Source: https://docs.rs/oddio/0.7.4/src/oddio/spsc.rs.html

Returns the current number of elements available to be read from the receiver.

```rust
pub fn len(&self) -> usize {
    self.len
}
```

--------------------------------

### pub fn rchunks

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

```APIDOC
## rchunks

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the slice, the last chunk will be smaller.

### Parameters
#### Query Parameters
- **chunk_size** (usize) - Required - The size of each chunk. Panics if zero.
```

--------------------------------

### Stream::new

Source: https://docs.rs/oddio/0.7.4/src/oddio/stream.rs.html

Constructs a new stream of dynamic audio and its associated control handle.

```APIDOC
## POST /Stream/new

### Description
Construct a stream of dynamic audio. Samples can be appended to the stream through its StreamControl, allowing streaming audio to be obtained from external sources without interfering with low-latency audio output.

### Parameters
#### Request Body
- **rate** (u32) - Required - The stream's sample rate.
- **size** (usize) - Required - The maximum number of buffered frames.

### Response
#### Success Response (200)
- **StreamControl<T>** - Thread-safe control handle for the stream.
- **Stream<T>** - The audio stream instance.
```

--------------------------------

### pub fn rchunks_exact

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Returns an iterator over chunk_size elements of the slice at a time, starting at the end, omitting the remainder.

```APIDOC
## rchunks_exact

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. If `chunk_size` does not divide the length, the remainder is omitted and can be retrieved via the iterator.

### Parameters
#### Query Parameters
- **chunk_size** (usize) - Required - The size of each chunk. Panics if zero.
```

--------------------------------

### Access Sample Channels

Source: https://docs.rs/oddio/0.7.4/oddio/type.Sample.html

Methods for accessing and mutably accessing the frame's channels.

```rust
fn channels(&self) -> &[Sample]
```

```rust
fn channels_mut(&mut self) -> &mut [Sample]
```

--------------------------------

### Define the Seek trait

Source: https://docs.rs/oddio/0.7.4/oddio/trait.Seek.html

The trait definition requires implementing the seek method to shift the starting point of the signal.

```rust
pub trait Seek: Signal {
    // Required method
    fn seek(&mut self, seconds: f32);
}
```

--------------------------------

### SpatialSignal::new

Source: https://docs.rs/oddio/0.7.4/src/oddio/spatial.rs.html

Constructor for SpatialSignal.

```APIDOC
## fn new(
    inner: T,
    position: mint::Point3<f32>,
    velocity: mint::Vector3<f32>,
    radius: f32,
) -> (swap::Sender<Motion>, Arc<AtomicBool>, Self)

### Description
Creates a new `SpatialSignal`.

### Parameters
- **inner** (T) - The inner signal.
- **position** (mint::Point3<f32>) - The initial position of the signal.
- **velocity** (mint::Vector3<f32>) - The initial velocity of the signal.
- **radius** (f32) - The audible radius of the signal.

### Returns
A tuple containing:
- A `swap::Sender<Motion>` for updating the signal's motion.
- An `Arc<AtomicBool>` indicating if the signal has finished.
- The newly created `SpatialSignal` instance.
```

--------------------------------

### Seek Implementation for FixedGain

Source: https://docs.rs/oddio/0.7.4/oddio/struct.FixedGain.html

Implementation of the Seek trait for FixedGain, allowing manipulation of the signal's starting point.

```APIDOC
## impl<T: Seek + ?Sized> Seek for FixedGain<T>

### Description
Provides seeking capabilities for `FixedGain` when the underlying signal `T` also implements `Seek`.

### Method
`fn seek(&mut self, seconds: f32)`

### Description
Shift the starting point of the next `sample` call by `seconds`.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Example usage would go here if available
```

### Response
#### Success Response (200)
None (this is a method that modifies state)

#### Response Example
```json
// No JSON response example available for this method
```
```

--------------------------------

### Sine::sample

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Sine.html

Generates audio frames for the sine wave signal.

```APIDOC
## Sine::sample

### Description
Sample frames separated by `interval` seconds each.

### Parameters
#### Arguments
- **interval** (f32) - Required - Time interval between samples.
- **out** (&mut [Sample]) - Required - Buffer to store the generated frames.
```

--------------------------------

### Struct AdaptOptions

Source: https://docs.rs/oddio/0.7.4/oddio/struct.AdaptOptions.html

Configuration for an Adapt filter, passed to Adapt::new.

```APIDOC
## Struct AdaptOptions

### Description
Configuration for an `Adapt` filter, passed to `Adapt::new`.

### Fields
- **tau** (f32) - How smoothly the filter should respond. Smaller values reduce time spent outside the target range, at the cost of lower perceived dynamic range. 0.1 is a good place to start.
- **max_gain** (f32) - Maximum linear gain to apply regardless of input signal.
- **low** (f32) - When the average RMS level is below this, the gain will increase over time, up to at most `max_gain`.
- **high** (f32) - When the average RMS level is above this, the gain will decrease over time. This should usually be set lower than your desired maximum peak output to avoid clipping of transient spikes.
```

--------------------------------

### rsplit_mut

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Splits a mutable slice into subslices separated by elements that match a predicate, starting from the end. The matched element is not included.

```APIDOC
## pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F>

### Description
Returns an iterator over mutable subslices separated by elements that match `pred`, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

### Method
`rsplit_mut`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let mut v = [100, 400, 300, 200, 600, 500];

let mut count = 0;
for group in v.rsplit_mut(|num| *num % 3 == 0) {
    count += 1;
    group[0] = count;
}
assert_eq!(v, [3, 400, 300, 2, 600, 1]);
```

### Response
#### Success Response (200)
Iterator over mutable subslices.

#### Response Example
None provided.
```

--------------------------------

### Run signal processing

Source: https://docs.rs/oddio/0.7.4/oddio/fn.run.html

Populates the output buffer with frames from the provided signal at the specified sample rate.

```rust
pub fn run<S: Signal + ?Sized>(
    signal: &mut S,
    sample_rate: u32,
    out: &mut [S::Frame],
)
```

--------------------------------

### rsplit

Source: https://docs.rs/oddio/0.7.4/oddio/struct.Frames.html

Splits a slice into subslices separated by elements that match a predicate, starting from the end. The matched element is not included in the subslices.

```APIDOC
## pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F>

### Description
Returns an iterator over subslices separated by elements that match `pred`, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

### Method
`rsplit`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

### Response
#### Success Response (200)
Iterator over subslices.

#### Response Example
None provided.
```
Tokens:
Raw