Enum screech::core::Signal

pub enum Signal {
    Mono(Point),
    Stereo(Point, Point),
}

Most fundamental type for carrying signals throughout the library. Each component that has a sound source should be sampleable and be able to produce a Signal

Variants

Mono(Point)

Mono signal containing one stream

Tuple Fields of Mono

0: Point

Stereo(Point, Point)

Stereo signal containing two streams, left and right respectively

Tuple Fields of Stereo

0: Point1: Point

Implementations

impl Signal

pub fn silence() -> Self

Generate a silent signal

use screech::core::Signal;

assert_eq!(Signal::silence(), Signal::Mono(0.0));

pub fn point(point: Point) -> Self

Generate a mono signal from a point

use screech::core::Signal;

assert_eq!(Signal::point(0.0), Signal::Mono(0.0));

pub fn points(left: Point, right: Point) -> Self

Generate a stereo signal from two points

use screech::core::Signal;

assert_eq!(Signal::points(0.1, 0.2), Signal::Stereo(0.1, 0.2));

pub fn map<F>(self, f: F) -> Self where
    F: Fn(Point) -> Point, 

Transform inner points, technically this is not a real map, since you can only manipulate the point to another point

use screech::core::Signal;

let mono = Signal::point(0.1).map(|p| p * 2.0);
let stereo = Signal::points(0.1, 0.2).map(|p| p * 2.0);

assert_eq!(mono, Signal::Mono(0.2));
assert_eq!(stereo, Signal::Stereo(0.2, 0.4));

pub fn map_stereo<L, R>(self, l: L, r: R) -> Self where
    L: Fn(Point) -> Point,
    R: Fn(Point) -> Point, 

Transform inner pointss for left and right channels individually. When given a mono channel it applies the transformation only to the left channel

use screech::core::Signal;

let signal = Signal::points(0.1, 0.2)
    .map_stereo(|left| left * 2.0, |right| right / 2.0);

assert_eq!(signal, Signal::Stereo(0.2, 0.1));

pub fn map_to_stereo<F>(self, f: F) -> Self where
    F: Fn(Point, Point) -> (Point, Point), 

Transform inner pointss for left and right channels individually. When given a mono channel it converts it to stereo by cloning left onto right

use screech::core::Signal;

let signal = Signal::point(0.2)
    .map_to_stereo(|left, right| (left * 2.0, right / 2.0));

assert_eq!(signal, Signal::Stereo(0.4, 0.1));

pub fn mix_into(self, signals: &[&Signal]) -> Self

Mix signals into existing signal

note on mono channels will sum the right channel to the left

use screech::core::Signal;

let signals = [
    &Signal::point(0.1),
    &Signal::points(0.4, 0.6),
];

let signal = Signal::point(0.4).mix_into(&signals);

assert_eq!(signal, Signal::Mono(1.0));

pub fn mix(signals: &[&Signal]) -> Self

Mix signals together into a new signal, if only supplied mono signals it stays mono, otherwise it switches the signal to stereo putting mono signals across both channels

use screech::core::Signal;

let signal = Signal::mix(&[
    &Signal::point(0.1),
    &Signal::point(0.2),
    &Signal::Stereo(0.3, 0.2),
]);

assert_eq!(signal, Signal::Stereo(0.6, 0.5))

pub fn match_channels(self, signal: &Signal) -> Self

match channels for current Signal based on passed Signal using Signal::sum_to_mono for stereo to mono conversion

use screech::core::Signal;

let mono_signal = Signal::silence();
let stereo_signal = Signal::silence().to_stereo();

assert_eq!(Signal::silence().match_channels(&mono_signal).is_mono(), true);
assert_eq!(Signal::silence().match_channels(&stereo_signal).is_stereo(), true);

pub fn is_mono(&self) -> bool

Returns true if the enum instance is of Signal::Mono type

use screech::core::Signal;

let mono_signal = Signal::silence();
let stereo_signal = Signal::silence().to_stereo();

assert_eq!(mono_signal.is_mono(), true);
assert_eq!(stereo_signal.is_mono(), false);

pub fn is_stereo(&self) -> bool

Returns true if the enum instance is of Signal::Stereo type

use screech::core::Signal;

let mono_signal = Signal::silence();
let stereo_signal = Signal::silence().to_stereo();

assert_eq!(mono_signal.is_stereo(), false);
assert_eq!(stereo_signal.is_stereo(), true);

pub fn sum_to_mono(self) -> Self

Convert a stereo point to mono by summing the left and right channel

use screech::traits::FromPoints;
use screech::core::{Signal, Stream};

let stereo_signal = Signal::Stereo(0.1, -0.1);

assert_eq!(
    stereo_signal.sum_to_mono(),
    Signal::Mono(0.0),
)

pub fn to_mono(self) -> Self

Convert a stereo point to mono by ditching the right channel

use screech::core::Signal;

let stereo_signal = Signal::points(0.1, 0.2);

assert_eq!(
    stereo_signal.to_mono(),
    Signal::Mono(0.1),
)

pub fn to_stereo(self) -> Self

Convert a mono stream to stereo by cloning the signal to both channels

use screech::core::Signal;

let mono_signal = Signal::point(0.1);

assert_eq!(
    mono_signal.to_stereo(),
    Signal::Stereo(0.1, 0.1),
)

pub fn get_point(&self) -> &Point

Get the inner point, or the left point if it is a stereo signal

pub fn sum_points(&self) -> Point

Get the inner point if mono, and sum left and right together (after -3dB) for stereo signals

pub fn get_right_point(&self) -> Option<&Point>

Get the inner right point if available

pub fn from_points(points: Vec<Point>) -> Vec<Signal>

Utility function to easily construct a vec of mono signals from a Vec<Point>

Trait Implementations

impl Clone for Signal

fn clone(&self) -> Signal

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Signal

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Signal> for Signal

fn eq(&self, other: &Signal) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Signal) -> bool

This method tests for !=.

impl Copy for Signal

impl StructuralPartialEq for Signal