stream effects

★★★★by Ramon Santamaria (@raysan5)

There is no browser build of this example yet.

Is it the same as C?

Desktop:builds The Zig version builds, but it is not compared with C, because the C example does not give the same frame twice: self-nondeterministic under CPU load (C vs C 5/6): music progress bar from the audio thread.
Browser:not checked yet The browser comparison does not cover this example yet.

ZigC (original)

//! raylib [audio] example - stream effects
//!
//! Zig-API translation of examples/audio/audio_stream_effects.c (raylib 6.2).
//! Example licensed under an unmodified zlib/libpng license.
//! Copyright (c) 2022-2025 Ramon Santamaria (@raysan5)

const std = @import("std");
const rl = @import("raylib");

// Delay effect state, shared with the audio thread
var delay_buffer: []f32 = &.{};
var delay_read_index: usize = 2;
var delay_write_index: usize = 0;

pub fn main() !void {
    // Initialization
    const screen_width = 800;
    const screen_height = 450;

    rl.initWindow(screen_width, screen_height, "raylib [audio] example - stream effects");
    defer rl.closeWindow(); // Close window and OpenGL context

    // Allocate buffer for the delay effect: 1 second delay (device sampleRate*channels)
    // NOTE: Allocated before the audio device so it outlives the processors using it
    const allocator = std.heap.c_allocator;
    delay_buffer = try allocator.alloc(f32, 48000 * 2);
    @memset(delay_buffer, 0.0);
    defer allocator.free(delay_buffer); // Free delay buffer

    rl.initAudioDevice(); // Initialize audio device
    defer rl.closeAudioDevice(); // Close audio device (music streaming is automatically stopped)

    const music = try rl.loadMusicStream("resources/country.mp3");
    defer rl.unloadMusicStream(music); // Unload music stream buffers from RAM

    rl.playMusicStream(music);

    var time_played: f32 = 0.0; // Time played normalized [0.0f..1.0f]
    var pause = false; // Music playing paused

    var enable_effect_lpf = false; // Enable effect low-pass-filter
    var enable_effect_delay = false; // Enable effect delay (1 second)

    rl.setTargetFPS(60); // Set our game to run at 60 frames-per-second

    // Main game loop
    while (!rl.windowShouldClose()) { // Detect window close button or ESC key
        // Update
        rl.updateMusicStream(music); // Update music buffer with new stream data

        // Restart music playing (stop and play)
        if (rl.isKeyPressed(.space)) {
            rl.stopMusicStream(music);
            rl.playMusicStream(music);
        }

        // Pause/Resume music playing
        if (rl.isKeyPressed(.p)) {
            pause = !pause;

            if (pause) rl.pauseMusicStream(music) else rl.resumeMusicStream(music);
        }

        // Add/Remove effect: lowpass filter
        if (rl.isKeyPressed(.f)) {
            enable_effect_lpf = !enable_effect_lpf;
            if (enable_effect_lpf) {
                rl.attachAudioStreamProcessor(music.stream, audioProcessEffectLpf);
            } else {
                rl.detachAudioStreamProcessor(music.stream, audioProcessEffectLpf);
            }
        }

        // Add/Remove effect: delay
        if (rl.isKeyPressed(.d)) {
            enable_effect_delay = !enable_effect_delay;
            if (enable_effect_delay) {
                rl.attachAudioStreamProcessor(music.stream, audioProcessEffectDelay);
            } else {
                rl.detachAudioStreamProcessor(music.stream, audioProcessEffectDelay);
            }
        }

        // Get normalized time played for current music stream
        time_played = rl.getMusicTimePlayed(music) / rl.getMusicTimeLength(music);

        if (time_played > 1.0) time_played = 1.0; // Make sure time played is no longer than music

        // Draw
        rl.beginDrawing();
        defer rl.endDrawing();

        rl.clearBackground(.ray_white);

        rl.drawText("MUSIC SHOULD BE PLAYING!", 245, 150, 20, .light_gray);

        rl.drawRectangle(200, 180, 400, 12, .light_gray);
        rl.drawRectangle(200, 180, @intFromFloat(time_played * 400.0), 12, .maroon);
        rl.drawRectangleLines(200, 180, 400, 12, .gray);

        rl.drawText("PRESS SPACE TO RESTART MUSIC", 215, 230, 20, .light_gray);
        rl.drawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 260, 20, .light_gray);

        rl.drawText(rl.textFormat("PRESS F TO TOGGLE LPF EFFECT: {s}", .{onOff(enable_effect_lpf)}), 200, 320, 20, .gray);
        rl.drawText(rl.textFormat("PRESS D TO TOGGLE DELAY EFFECT: {s}", .{onOff(enable_effect_delay)}), 180, 350, 20, .gray);
    }
}

fn onOff(enabled: bool) []const u8 {
    return if (enabled) "ON" else "OFF";
}

/// View an audio processor buffer as its interleaved stereo float samples.
fn stereoSamples(buffer: ?*anyopaque, frames: c_uint) [][2]f32 {
    const samples: [*][2]f32 = @ptrCast(@alignCast(buffer.?));
    return samples[0..frames];
}

/// Audio effect: lowpass filter
fn audioProcessEffectLpf(buffer: ?*anyopaque, frames: c_uint) callconv(.c) void {
    const S = struct {
        var low: [2]f32 = .{ 0.0, 0.0 };
    };
    const cutoff: f32 = 70.0 / 44100.0; // 70 Hz lowpass filter
    const k = cutoff / (cutoff + 0.1591549431); // RC filter formula

    for (stereoSamples(buffer, frames)) |*frame| {
        for (frame, &S.low) |*sample, *low| {
            low.* += k * (sample.* - low.*);
            sample.* = low.*;
        }
    }
}

/// Audio effect: delay
fn audioProcessEffectDelay(buffer: ?*anyopaque, frames: c_uint) callconv(.c) void {
    for (stereoSamples(buffer, frames)) |*frame| {
        const left_delay = delay_buffer[delay_read_index];
        const right_delay = delay_buffer[delay_read_index + 1];
        delay_read_index += 2;
        if (delay_read_index == delay_buffer.len) delay_read_index = 0;

        frame[0] = 0.5 * frame[0] + 0.5 * left_delay;
        frame[1] = 0.5 * frame[1] + 0.5 * right_delay;

        delay_buffer[delay_write_index] = frame[0];
        delay_buffer[delay_write_index + 1] = frame[1];
        delay_write_index += 2;
        if (delay_write_index == delay_buffer.len) delay_write_index = 0;
    }
}

/*******************************************************************************************
*
*   raylib [audio] example - stream effects
*
*   Example complexity rating: [★★★★] 4/4
*
*   Example originally created with raylib 4.2, last time updated with raylib 5.0
*
*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
*   BSD-like license that allows static linking with closed source software
*
*   Copyright (c) 2022-2025 Ramon Santamaria (@raysan5)
*
********************************************************************************************/

#include "raylib.h"

#include <stdlib.h> // Required for: NULL

//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
static float *delayBuffer = NULL;
static unsigned int delayBufferSize = 0;
static unsigned int delayReadIndex = 2;
static unsigned int delayWriteIndex = 0;

//------------------------------------------------------------------------------------
// Module Functions Declaration
//------------------------------------------------------------------------------------
static void AudioProcessEffectLPF(void *buffer, unsigned int frames);   // Audio effect: lowpass filter
static void AudioProcessEffectDelay(void *buffer, unsigned int frames); // Audio effect: delay

//------------------------------------------------------------------------------------
// Program main entry point
//------------------------------------------------------------------------------------
int main(void)
{
    // Initialization
    //--------------------------------------------------------------------------------------
    const int screenWidth = 800;
    const int screenHeight = 450;

    InitWindow(screenWidth, screenHeight, "raylib [audio] example - stream effects");

    InitAudioDevice();              // Initialize audio device

    Music music = LoadMusicStream("resources/country.mp3");

    // Allocate buffer for the delay effect
    delayBufferSize = 48000*2;      // 1 second delay (device sampleRate*channels)
    delayBuffer = (float *)RL_CALLOC(delayBufferSize, sizeof(float));

    PlayMusicStream(music);

    float timePlayed = 0.0f;        // Time played normalized [0.0f..1.0f]
    bool pause = false;             // Music playing paused

    bool enableEffectLPF = false;   // Enable effect low-pass-filter
    bool enableEffectDelay = false; // Enable effect delay (1 second)

    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
    //--------------------------------------------------------------------------------------

    // Main game loop
    while (!WindowShouldClose())    // Detect window close button or ESC key
    {
        // Update
        //----------------------------------------------------------------------------------
        UpdateMusicStream(music);   // Update music buffer with new stream data

        // Restart music playing (stop and play)
        if (IsKeyPressed(KEY_SPACE))
        {
            StopMusicStream(music);
            PlayMusicStream(music);
        }

        // Pause/Resume music playing
        if (IsKeyPressed(KEY_P))
        {
            pause = !pause;

            if (pause) PauseMusicStream(music);
            else ResumeMusicStream(music);
        }

        // Add/Remove effect: lowpass filter
        if (IsKeyPressed(KEY_F))
        {
            enableEffectLPF = !enableEffectLPF;
            if (enableEffectLPF) AttachAudioStreamProcessor(music.stream, AudioProcessEffectLPF);
            else DetachAudioStreamProcessor(music.stream, AudioProcessEffectLPF);
        }

        // Add/Remove effect: delay
        if (IsKeyPressed(KEY_D))
        {
            enableEffectDelay = !enableEffectDelay;
            if (enableEffectDelay) AttachAudioStreamProcessor(music.stream, AudioProcessEffectDelay);
            else DetachAudioStreamProcessor(music.stream, AudioProcessEffectDelay);
        }

        // Get normalized time played for current music stream
        timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music);

        if (timePlayed > 1.0f) timePlayed = 1.0f;   // Make sure time played is no longer than music
        //----------------------------------------------------------------------------------

        // Draw
        //----------------------------------------------------------------------------------
        BeginDrawing();

            ClearBackground(RAYWHITE);

            DrawText("MUSIC SHOULD BE PLAYING!", 245, 150, 20, LIGHTGRAY);

            DrawRectangle(200, 180, 400, 12, LIGHTGRAY);
            DrawRectangle(200, 180, (int)(timePlayed*400.0f), 12, MAROON);
            DrawRectangleLines(200, 180, 400, 12, GRAY);

            DrawText("PRESS SPACE TO RESTART MUSIC", 215, 230, 20, LIGHTGRAY);
            DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 260, 20, LIGHTGRAY);

            DrawText(TextFormat("PRESS F TO TOGGLE LPF EFFECT: %s", enableEffectLPF? "ON" : "OFF"), 200, 320, 20, GRAY);
            DrawText(TextFormat("PRESS D TO TOGGLE DELAY EFFECT: %s", enableEffectDelay? "ON" : "OFF"), 180, 350, 20, GRAY);

        EndDrawing();
        //----------------------------------------------------------------------------------
    }

    // De-Initialization
    //--------------------------------------------------------------------------------------
    UnloadMusicStream(music);   // Unload music stream buffers from RAM

    CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)

    RL_FREE(delayBuffer);       // Free delay buffer

    CloseWindow();              // Close window and OpenGL context
    //--------------------------------------------------------------------------------------

    return 0;
}

//------------------------------------------------------------------------------------
// Module Functions Definition
//------------------------------------------------------------------------------------
// Audio effect: lowpass filter
static void AudioProcessEffectLPF(void *buffer, unsigned int frames)
{
    static float low[2] = { 0.0f, 0.0f };
    static const float cutoff = 70.0f/44100.0f; // 70 Hz lowpass filter
    const float k = cutoff/(cutoff + 0.1591549431f); // RC filter formula

    // Converts the buffer data before using it
    float *bufferData = (float *)buffer;
    for (unsigned int i = 0; i < frames*2; i += 2)
    {
        const float l = bufferData[i];
        const float r = bufferData[i + 1];

        low[0] += k*(l - low[0]);
        low[1] += k*(r - low[1]);
        bufferData[i] = low[0];
        bufferData[i + 1] = low[1];
    }
}

// Audio effect: delay
static void AudioProcessEffectDelay(void *buffer, unsigned int frames)
{
    for (unsigned int i = 0; i < frames*2; i += 2)
    {
        float leftDelay = delayBuffer[delayReadIndex++];    // ERROR: Reading buffer -> WHY??? Maybe thread related???
        float rightDelay = delayBuffer[delayReadIndex++];

        if (delayReadIndex == delayBufferSize) delayReadIndex = 0;

        ((float *)buffer)[i] = 0.5f*((float *)buffer)[i] + 0.5f*leftDelay;
        ((float *)buffer)[i + 1] = 0.5f*((float *)buffer)[i + 1] + 0.5f*rightDelay;

        delayBuffer[delayWriteIndex++] = ((float *)buffer)[i];
        delayBuffer[delayWriteIndex++] = ((float *)buffer)[i + 1];
        if (delayWriteIndex == delayBufferSize) delayWriteIndex = 0;
    }
}

From raylib 6.2. The original on GitHub.