EBU R128

Prev Next

The EBU R128 operator measures the loudness of your audio in real time. Loudness describes how “loud” the sound feels to a listener, not just its technical volume level. This operator is purely analytical: it does not change or process the audio in any way — it only measures and reports values.

Why is this important?

Without control, some parts of your audio stream may sound much louder or quieter than others. This can be distracting for your audience and is not allowed in professional broadcasting.

The EBU R128 standard was created to solve this problem. It ensures that:

  • Different parts of your production sound balanced and consistent.

  • Your audio follows the loudness rules required in broadcasting.

  • Listeners don’t need to keep adjusting the volume when switching between programs.

With the EBU R128 operator in Composer, you can easily monitor whether your broadcast audio is consistent, comfortable to listen to, and compliant with broadcast standards.

Settings

  • Autostart when loaded - When checked (default), the EBU R128 operator will start automatically when the project is loaded.

Real-Time Loudness (LUFS)

What is LUFS?

LUFS (Loudness Units relative to Full Scale) is the standard way of measuring how loud audio feels to listeners. Unlike simple volume, LUFS is designed to match human hearing.

  • Momentary (Last 400ms) - A quick snapshot of what’s happening right now.Useful for catching sudden peaks such as shouts or drum hits.

  • Short-Term (Last 3sec) - Loudness averaged over the last 3 seconds of audio. This smooths out fast ups and downs, making it easier to follow the loudness of speech or music passages.

Integrated Loudness (LUFS)

  • Enable - Enables integrated loudness measurement.

  • Integrated Loudness - Shows the average loudness across the entire broadcast.

    Unlike momentary or short-term values, this covers the full duration from start to finish and is the key value for official loudness compliance.

    The value is automatically updated when the operator is stopped.

  • Update Value - Retrieves the current integrated loudness based on audio history from the start of measurement until now.

Note!

Integrated loudness builds its value by keeping track of all audio that has been played since you started measuring. This provides high accuracy for long-term compliance but may use more memory during extended sessions.

Loudness Range (LU)

What is LU?

LU (Loudness Units) describes differences in loudness. Loudness Range shows how much the volume changes over time:

  • A small range = the sound stays fairly even.

  • A large range = bigger differences between quiet and loud parts.

  • Enable - Enables loudness range measurement.

  • Loudness Range (LU) - Measures how much the loudness varies throughout the broadcast.
    The value is automatically updated when the operator is stopped.

  • Update Value - Retrieves the current loudness range from the start of measurement until now.

Note!

Loudness Range analyzes all audio since you started measuring. Like integrated loudness, this provides a long-term view but may use a little more memory during long sessions.

True Peak (dBTP)

  • Enable - Enables true peak measurement.

  • Left / Right channel - Shows the maximum level your audio reaches when reconstructed in the digital-to-analog process.

    This is important because even if your digital signal looks safe, the reconstructed audio can still clip and distort. Monitoring the true peak helps prevent distortion in broadcasts and playback devices.

What is dBTP?

dBTP (Decibels True Peak) measures the absolute peak level of your audio.

It is more precise than regular peak meters because it detects peaks between digital samples — the ones that can cause distortion on playback systems.

Action

  • Start - Starts measuring loudness in real time.

  • Stop - Stops loudness measurement.

Script Engine - Example

The Script Engine in Composer allows you to automate and customize behavior using JavaScript.

Important!

The examples below are not meant for production use. These are simple demonstrations showing how values can be retrieved and used in logic. You can adapt them to build your own automation, control other operators, or create custom workflows inside Composer.

Tip - Control Composer Remotely

You can control Composer from anywhere, trigger workflows, and execute scripts remotely. See:

Example: Adjust the gain of an Input in real-time based on short-term loudness (LUFS)

This script shows how to read short-term loudness from the EBU R128 operator and adjust input gain in real time.

  1. Add an input with audio

  2. Add the input to a Scene Layer

  3. Add an EBU R128 operator

  4. Enable Composer´s Audio Mixer view

  5. From the main menu, select Script Engine → Create Script

  6. Save and reload the project

  7. From the main menu, select Script Engine → Edit Script

  8. Add the following to your JavaScript:

// Get the EBU R128 operator (measures loudness levels in real time)
const ebuOperator = Project.GetLayerOperatorByName("Scene", "<name_of_layer_with_the_EBU_operator>", "EBU R128");

// Get the input object we want to control
const audioInput = Project.GetInputByName("<name_of_the_input>");

// Target loudness in LUFS (what we’re aiming for overall)
const targetLoudness = -23;

// Acceptable deviation around the target (prevents tiny, constant corrections)
const tolerance = 1.0; // +/- 1 LUFS

// Step size: how much to adjust the gain on each update.
// Note: At high frame rates, corrections may stack up quickly.
// You can lower adjustmentStep or add a cooldown if needed.
const adjustmentStep = 0.05; // dB

// Safety limits: the gain will never go below/above these values
const minGain = -12.0; // dB minimum
const maxGain = 12.0;  // dB maximum

// Anything quieter than this is treated as silence (no adjustments made)
const silenceThreshold = -50; // LUFS

// The OnRenderFrame function will be executed at every frame
function OnRenderFrame() {   
    // Read the current short-term loudness from the EBU operator
    const currentLoudness = ebuOperator.ShortTerm;

    // Skip adjustments during silence (avoids boosting quiet gaps)
    if (currentLoudness < silenceThreshold) {
        return;
    }

    // If loudness is too low (below target - tolerance), increase gain
    if (currentLoudness < targetLoudness - tolerance) {
        audioInput.StereoGainDb = Math.min(audioInput.StereoGainDb + adjustmentStep, maxGain);
    }
    // If loudness is too high (above target + tolerance), decrease gain
    else if (currentLoudness > targetLoudness + tolerance) {
        audioInput.StereoGainDb = Math.max(audioInput.StereoGainDb - adjustmentStep, minGain);
    }
}

Example: Retrieve integrated loudness (LUFS) when a clip stops playing.

This script shows how to retrieve the integrated loudness value once playback ends.

  1. Add a Video File Input

  2. Activate the input´s Advanced Options

  3. Enter the name of a JavaScript function in the “On End-Of-File” option (e.g., OnVideoEnd)

  4. Add the video input to a Scene Layer

  5. Add the EBU R128 operator

  6. Enable Integrated Loudness

  7. From the main menu, select Script Engine → Create Script

  8. Save and reload the project

  9. From the main menu, select Script Engine → Edit Script

  10. Add the following to your JavaScript:

// Get the EBU R128 operator (measures loudness levels in real time)
const ebuOperator = Project.GetLayerOperatorByName("Scene", "<name_of_layer_with_the_EBU_operator>", "EBU R128");

function OnVideoEnd() {

    // Stop the EBU operator by triggering stop button
    Project.ExecuteOperatorCommand(ebuOperator, "StopCommand");

    // Get the integrated loudness (average LUFS) measured across the whole stream
    let averageLufs = ebuOperator.IntegratedLoudnessLufs;

    // Print to the Composer log:
    Logger.Debug(`EBU integrated loudness (average) value of the total broadcast: {averageLufs} (LUFS)`);
}