Struct AudioBufferSourceNode 

pub struct AudioBufferSourceNode { /* private fields */ }

Implementations

impl AudioBufferSourceNode

pub fn try_set_buffer(&self, buffer: AudioBuffer) -> Result<(), GraphError>

pub fn clear_buffer(&self)

pub fn buffer_value(&self) -> Option<AudioBuffer>

pub fn playback_rate(&self) -> AudioParamHandle

pub fn detune(&self) -> AudioParamHandle

pub fn param(&self, name: &str) -> Option<AudioParamHandle>

pub fn parameter(&self, name: &str) -> Option<AudioParamHandle>

pub fn try_loop_range( &self, start_seconds: f64, end_seconds: f64, ) -> Result<(), GraphError>

pub fn try_loop_start(&self, start_seconds: f64) -> Result<(), GraphError>

pub fn try_loop_end(&self, end_seconds: f64) -> Result<(), GraphError>

pub fn set_looping(&self, enabled: bool)

pub fn looping_value(&self) -> bool

pub fn loop_range_value(&self) -> Option<(f64, f64)>

pub fn loop_start_value(&self) -> f64

pub fn loop_end_value(&self) -> f64

pub fn ended(&self) -> bool

pub fn try_start(&self, time: f64) -> Result<(), GraphError>

Examples found in repository

examples/webaudio_synth_lab.rs (line 104)

fn build_synth_lab(
    context: &mut AudioContext,
    stop_time: f64,
) -> Result<AnalyserNode, Box<dyn Error>> {
    let custom_wave = context.try_create_periodic_wave_with_options(
        [0.0, 0.0, 0.22, 0.12],
        [0.0, 1.0, 0.35, 0.18],
        PeriodicWaveOptions {
            disable_normalization: false,
        },
    )?;
    let carrier = context.try_create_oscillator_with_options(OscillatorOptions {
        oscillator_type: OscillatorType::Custom(custom_wave),
        frequency: 110.0,
        detune: -8.0,
    })?;
    carrier
        .frequency()
        .linear_ramp_to_value_at_time(146.83, 3.0)?;
    carrier.try_start(0.0)?;
    carrier.try_stop(stop_time)?;

    let overtone = context.try_create_oscillator_with_options(OscillatorOptions {
        oscillator_type: OscillatorType::Basic(Waveform::Triangle),
        frequency: 220.0,
        detune: 4.0,
    })?;
    overtone.try_start(0.0)?;
    overtone.try_stop(stop_time)?;

    let buffer = AudioBuffer::try_from_mono(
        SAMPLE_RATE,
        SAMPLE_RATE as usize / 2,
        (0..SAMPLE_RATE / 2).map(|i| {
            let t = i as f32 / SAMPLE_RATE as f32;
            let burst = (1.0 - t * 2.0).max(0.0);
            (t * std::f32::consts::TAU * 880.0).sin() * burst * 0.18
        }),
    )?;
    let buffer_source =
        context.try_create_buffer_source_with_options(AudioBufferSourceOptions {
            buffer: Some(buffer),
            playback_rate: 0.85,
            detune: 0.0,
            looping: false,
            loop_start: 0.0,
            loop_end: 0.5,
        })?;
    buffer_source.try_start(2.0)?;
    buffer_source.try_stop(3.2)?;

    let lfo =
        context.try_create_constant_source_with_options(ConstantSourceOptions { offset: 0.012 })?;
    lfo.try_start(0.0)?;
    lfo.try_stop(stop_time)?;

    let carrier_gain = context.try_create_gain_with_options(GainOptions { gain: 0.0 })?;
    carrier_gain.gain().set_value_at_time(0.0, 0.0)?;
    carrier_gain
        .gain()
        .linear_ramp_to_value_at_time(0.11, 0.18)?;
    carrier_gain
        .gain()
        .set_value_curve_at_time([0.11, 0.08, 0.13, 0.09, 0.12], 0.4, 2.8)?;
    carrier_gain.gain().set_target_at_time(0.07, 3.4, 0.55)?;
    carrier_gain
        .gain()
        .cancel_and_hold_at_time(stop_time - 0.35)?;
    carrier_gain
        .gain()
        .linear_ramp_to_value_at_time(0.0, stop_time)?;

    let burst_gain = context.try_create_gain_with_options(GainOptions { gain: 0.12 })?;
    let delay = context.try_create_delay_with_options(DelayOptions {
        max_delay_time: 0.75,
        delay_time: 0.08,
    })?;
    let biquad = context.try_create_biquad_filter_with_options(BiquadFilterOptions {
        filter_type: BiquadFilterType::Lowpass,
        frequency: 1_200.0,
        q: 0.9,
        ..Default::default()
    })?;
    biquad
        .frequency()
        .linear_ramp_to_value_at_time(2_400.0, 2.5)?;
    biquad.frequency().set_target_at_time(700.0, 3.5, 0.8)?;

    let iir = context.try_create_iir_filter_with_options(IirFilterOptions {
        feedforward: vec![0.55, 0.35],
        feedback: vec![1.0, -0.18],
    })?;
    let shaper = context.try_create_wave_shaper_with_options(WaveShaperOptions {
        curve: Some(vec![-1.0, -0.35, 0.0, 0.35, 1.0]),
        oversample: Oversample::TwoX,
    })?;
    let stereo =
        context.try_create_stereo_panner_with_options(StereoPannerOptions { pan: -0.15 })?;
    stereo.pan().linear_ramp_to_value_at_time(0.25, stop_time)?;
    let panner = context.try_create_panner_with_options(PannerOptions {
        position_x: 0.8,
        position_z: 1.5,
        ..Default::default()
    })?;
    let compressor =
        context.try_create_dynamics_compressor_with_options(DynamicsCompressorOptions {
            threshold: -20.0,
            knee: 18.0,
            ratio: 2.5,
            attack: 0.01,
            release: 0.22,
        })?;
    let convolver = context.try_create_convolver_with_options(ConvolverOptions {
        buffer: Some(AudioBuffer::try_from_mono(
            SAMPLE_RATE,
            8,
            [0.55, 0.28, 0.15, 0.08, 0.04, 0.02, 0.01, 0.005],
        )?),
        disable_normalization: true,
    })?;
    let analyser = context.try_create_analyser_with_options(AnalyserOptions {
        fft_size: 1024,
        min_decibels: -100.0,
        max_decibels: -12.0,
        smoothing_time_constant: 0.35,
    })?;
    let splitter = context.try_create_channel_splitter_with_options(ChannelSplitterOptions {
        number_of_outputs: 2,
    })?;
    let merger = context.try_create_channel_merger_with_options(ChannelMergerOptions {
        number_of_inputs: 2,
    })?;
    let output = context.try_create_gain_with_options(GainOptions { gain: 0.82 })?;

    context.connect(carrier, &carrier_gain)?;
    context.connect(overtone, &carrier_gain)?;
    context.connect(buffer_source, &burst_gain)?;
    context.connect(&carrier_gain, &delay)?;
    context.connect(&delay, &biquad)?;
    context.connect_param(lfo, delay.delay_time())?;
    context.connect(&biquad, &iir)?;
    context.connect(&iir, &shaper)?;
    context.connect(&shaper, &stereo)?;
    context.connect(&stereo, &panner)?;
    context.connect(&burst_gain, &splitter)?;
    context.connect_with_indices(&splitter, 0, &merger, 0)?;
    context.connect_with_indices(&splitter, 1, &merger, 1)?;
    context.connect(&panner, &compressor)?;
    context.connect(&merger, &compressor)?;
    context.connect(&compressor, &convolver)?;
    context.connect(&convolver, &output)?;
    context.connect(&output, &analyser)?;
    context.connect(&analyser, context.destination())?;

    println!("output node info: {:?}", context.node_info(&output)?);
    Ok(analyser)
}

pub fn try_start_with_offset( &self, time: f64, offset: f64, ) -> Result<(), GraphError>

pub fn try_start_with_offset_and_duration( &self, time: f64, offset: f64, duration: f64, ) -> Result<(), GraphError>

pub fn try_stop(&self, time: f64) -> Result<(), GraphError>

Examples found in repository

examples/webaudio_synth_lab.rs (line 105)

fn build_synth_lab(
    context: &mut AudioContext,
    stop_time: f64,
) -> Result<AnalyserNode, Box<dyn Error>> {
    let custom_wave = context.try_create_periodic_wave_with_options(
        [0.0, 0.0, 0.22, 0.12],
        [0.0, 1.0, 0.35, 0.18],
        PeriodicWaveOptions {
            disable_normalization: false,
        },
    )?;
    let carrier = context.try_create_oscillator_with_options(OscillatorOptions {
        oscillator_type: OscillatorType::Custom(custom_wave),
        frequency: 110.0,
        detune: -8.0,
    })?;
    carrier
        .frequency()
        .linear_ramp_to_value_at_time(146.83, 3.0)?;
    carrier.try_start(0.0)?;
    carrier.try_stop(stop_time)?;

    let overtone = context.try_create_oscillator_with_options(OscillatorOptions {
        oscillator_type: OscillatorType::Basic(Waveform::Triangle),
        frequency: 220.0,
        detune: 4.0,
    })?;
    overtone.try_start(0.0)?;
    overtone.try_stop(stop_time)?;

    let buffer = AudioBuffer::try_from_mono(
        SAMPLE_RATE,
        SAMPLE_RATE as usize / 2,
        (0..SAMPLE_RATE / 2).map(|i| {
            let t = i as f32 / SAMPLE_RATE as f32;
            let burst = (1.0 - t * 2.0).max(0.0);
            (t * std::f32::consts::TAU * 880.0).sin() * burst * 0.18
        }),
    )?;
    let buffer_source =
        context.try_create_buffer_source_with_options(AudioBufferSourceOptions {
            buffer: Some(buffer),
            playback_rate: 0.85,
            detune: 0.0,
            looping: false,
            loop_start: 0.0,
            loop_end: 0.5,
        })?;
    buffer_source.try_start(2.0)?;
    buffer_source.try_stop(3.2)?;

    let lfo =
        context.try_create_constant_source_with_options(ConstantSourceOptions { offset: 0.012 })?;
    lfo.try_start(0.0)?;
    lfo.try_stop(stop_time)?;

    let carrier_gain = context.try_create_gain_with_options(GainOptions { gain: 0.0 })?;
    carrier_gain.gain().set_value_at_time(0.0, 0.0)?;
    carrier_gain
        .gain()
        .linear_ramp_to_value_at_time(0.11, 0.18)?;
    carrier_gain
        .gain()
        .set_value_curve_at_time([0.11, 0.08, 0.13, 0.09, 0.12], 0.4, 2.8)?;
    carrier_gain.gain().set_target_at_time(0.07, 3.4, 0.55)?;
    carrier_gain
        .gain()
        .cancel_and_hold_at_time(stop_time - 0.35)?;
    carrier_gain
        .gain()
        .linear_ramp_to_value_at_time(0.0, stop_time)?;

    let burst_gain = context.try_create_gain_with_options(GainOptions { gain: 0.12 })?;
    let delay = context.try_create_delay_with_options(DelayOptions {
        max_delay_time: 0.75,
        delay_time: 0.08,
    })?;
    let biquad = context.try_create_biquad_filter_with_options(BiquadFilterOptions {
        filter_type: BiquadFilterType::Lowpass,
        frequency: 1_200.0,
        q: 0.9,
        ..Default::default()
    })?;
    biquad
        .frequency()
        .linear_ramp_to_value_at_time(2_400.0, 2.5)?;
    biquad.frequency().set_target_at_time(700.0, 3.5, 0.8)?;

    let iir = context.try_create_iir_filter_with_options(IirFilterOptions {
        feedforward: vec![0.55, 0.35],
        feedback: vec![1.0, -0.18],
    })?;
    let shaper = context.try_create_wave_shaper_with_options(WaveShaperOptions {
        curve: Some(vec![-1.0, -0.35, 0.0, 0.35, 1.0]),
        oversample: Oversample::TwoX,
    })?;
    let stereo =
        context.try_create_stereo_panner_with_options(StereoPannerOptions { pan: -0.15 })?;
    stereo.pan().linear_ramp_to_value_at_time(0.25, stop_time)?;
    let panner = context.try_create_panner_with_options(PannerOptions {
        position_x: 0.8,
        position_z: 1.5,
        ..Default::default()
    })?;
    let compressor =
        context.try_create_dynamics_compressor_with_options(DynamicsCompressorOptions {
            threshold: -20.0,
            knee: 18.0,
            ratio: 2.5,
            attack: 0.01,
            release: 0.22,
        })?;
    let convolver = context.try_create_convolver_with_options(ConvolverOptions {
        buffer: Some(AudioBuffer::try_from_mono(
            SAMPLE_RATE,
            8,
            [0.55, 0.28, 0.15, 0.08, 0.04, 0.02, 0.01, 0.005],
        )?),
        disable_normalization: true,
    })?;
    let analyser = context.try_create_analyser_with_options(AnalyserOptions {
        fft_size: 1024,
        min_decibels: -100.0,
        max_decibels: -12.0,
        smoothing_time_constant: 0.35,
    })?;
    let splitter = context.try_create_channel_splitter_with_options(ChannelSplitterOptions {
        number_of_outputs: 2,
    })?;
    let merger = context.try_create_channel_merger_with_options(ChannelMergerOptions {
        number_of_inputs: 2,
    })?;
    let output = context.try_create_gain_with_options(GainOptions { gain: 0.82 })?;

    context.connect(carrier, &carrier_gain)?;
    context.connect(overtone, &carrier_gain)?;
    context.connect(buffer_source, &burst_gain)?;
    context.connect(&carrier_gain, &delay)?;
    context.connect(&delay, &biquad)?;
    context.connect_param(lfo, delay.delay_time())?;
    context.connect(&biquad, &iir)?;
    context.connect(&iir, &shaper)?;
    context.connect(&shaper, &stereo)?;
    context.connect(&stereo, &panner)?;
    context.connect(&burst_gain, &splitter)?;
    context.connect_with_indices(&splitter, 0, &merger, 0)?;
    context.connect_with_indices(&splitter, 1, &merger, 1)?;
    context.connect(&panner, &compressor)?;
    context.connect(&merger, &compressor)?;
    context.connect(&compressor, &convolver)?;
    context.connect(&convolver, &output)?;
    context.connect(&output, &analyser)?;
    context.connect(&analyser, context.destination())?;

    println!("output node info: {:?}", context.node_info(&output)?);
    Ok(analyser)
}

Trait Implementations

impl Clone for AudioBufferSourceNode

fn clone(&self) -> AudioBufferSourceNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AudioBufferSourceNode

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

Formats the value using the given formatter.