WebAudio

@inject Bit.Butil.WebAudio webAudio

var isSupported = await webAudio.IsSupported();

await webAudio.Resume();  // call from a click handler to satisfy autoplay policies

await webAudio.Suspend(); // silence everything without tearing the context down

// one-shot beep, stops itself after 600 ms:
await webAudio.PlayTone(440, durationMs: 600, waveform: "sine", startGain: 0.5);

// open-ended tone you stop manually:
var handle = await webAudio.PlayTone(220, durationMs: 0, waveform: "sawtooth");
// ...
await handle.Stop();

@inject HttpClient httpClient
@inject Bit.Butil.WebAudio webAudio

@code {
    private async Task Play()
    {
        // Any encoded format the browser can decode - the file itself is the sample, and it lives in
        // wwwroot like any other static asset.
        byte[] bytes = await httpClient.GetByteArrayAsync("music/chime.wav");

        var handle = await webAudio.PlayBuffer(bytes, startGain: 1.0, loop: false);

        await handle!.SetGain(0.3); // duck the volume while it plays
        await handle.Stop();
    }
}

await webAudio.SetMasterGain(0.5); // half volume for everything

await webAudio.SetMasterGain(0);   // mute

var state = await webAudio.GetState();          // Suspended until a gesture resumes it
var now = await webAudio.GetCurrentTime();      // seconds, on the audio clock
var rate = await webAudio.GetSampleRate();      // 48000 on most devices

var buffer = await webAudio.DecodeAudioData(bytes);
// buffer.Duration, buffer.SampleRate, buffer.NumberOfChannels

var source = await webAudio.CreateBufferSource(buffer!, loop: false, playbackRate: 1);
await source!.ConnectToDestination();
await source.Start();

await source.SetParam("playbackRate", 1.5);   // faster, and higher in pitch
await source.Stop(whenSeconds: 2);            // scheduled on the audio thread

var osc = await webAudio.CreateOscillator(AudioOscillatorType.Sawtooth, 110);
var filter = await webAudio.CreateBiquadFilter(BiquadFilterType.Lowpass, frequency: 300, q: 12);
var gain = await webAudio.CreateGain(0.0001);

await osc!.Connect(filter!);
await filter.Connect(gain!);
await gain.ConnectToDestination();

await osc.Start();
await gain.RampParam("gain", 0.3, overSeconds: 0.05, exponential: true);   // no click
await filter.RampParam("frequency", 4000, overSeconds: 2);                 // the sweep

@inject Bit.Butil.WebAudio webAudio

@code {
    // Whatever is making the sound - an oscillator, a decoded buffer, a media element or the
    // microphone. An analyser reads what passes through it and changes nothing.
    private AudioNodeHandle? source;

    private async Task Watch()
    {
        var analyser = await webAudio.CreateAnalyser(fftSize: 1024, smoothingTimeConstant: 0.8);
        await source!.Connect(analyser!);      // in addition to whatever else source feeds

        var spectrum = await analyser!.GetByteFrequencyData();   // fftSize / 2 bins, 0-255
        var wave = await analyser.GetByteTimeDomainData();       // fftSize samples around 128
    }
}

@inject Bit.Butil.WebAudio webAudio

@code {
    private AudioNodeHandle? source;   // whatever is making the sound

    private async Task Place()
    {
        var panner = await webAudio.CreatePanner(new AudioPannerOptions
        {
            PanningModel = AudioPanningModel.Hrtf,
            DistanceModel = AudioDistanceModel.Inverse,
            PositionX = 2, PositionZ = -3,
            RefDistance = 1, RolloffFactor = 1
        });

        await source!.Connect(panner!);
        await panner!.ConnectToDestination();

        await panner.SetParam("positionX", -2);                       // jump
        await panner.RampParam("positionX", 2, overSeconds: 4);       // or glide across
        await webAudio.SetListener(0, 0, 0);                          // where the ears are
    }
}

var delay = await webAudio.CreateDelay(maxDelaySeconds: 1, delaySeconds: 0.25);
var feedback = await webAudio.CreateGain(0.4);
await delay!.Connect(feedback!);
await feedback.Connect(delay);          // the cycle that makes it an echo
await delay.ConnectToDestination();

var compressor = await webAudio.CreateDynamicsCompressor(threshold: -30, ratio: 12);
var shaper = await webAudio.CreateWaveShaper(curve, oversample: "4x");
var reverb = await webAudio.CreateConvolver(impulseResponseBuffer!);

@inject Bit.Butil.WebAudio webAudio
@inject Bit.Butil.MediaDevices mediaDevices
@inject Bit.Butil.MediaRecorder mediaRecorder

<audio @ref="audioElement" src="music/chime.wav" controls></audio>

@code {
    private ElementReference audioElement;

    private async Task Route()
    {
        var elementSource = await webAudio.CreateMediaElementSource(audioElement);
        var filter = await webAudio.CreateBiquadFilter(BiquadFilterType.Lowpass, 800);
        await elementSource!.Connect(filter!);
        await filter!.ConnectToDestination();    // without this, the element is now silent

        var mic = await mediaDevices.GetUserMedia(audio: true, video: false);
        var micSource = await webAudio.CreateMediaStreamSource(mic!);   // do not connect this to the speakers

        var destination = await webAudio.CreateMediaStreamDestination();
        await filter.Connect(destination!);
        await mediaRecorder.Start(destination!.GetStream());            // records the processed signal
    }
}