ffmpeg-normalize 1.42.1__tar.gz → 1.43.1__tar.gz

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.42.1
+Version: 1.43.1
 Summary: Normalize audio via ffmpeg
 Keywords: ffmpeg,normalize,audio
 Author: Werner Robitza
@@ -55,6 +55,7 @@ This program normalizes media files to a certain loudness level using the EBU R1
 - Peak normalization — Adjust audio to a specific peak level
 - Selective audio stream normalization — Normalize specific audio streams or only default streams
 - Skip files already at target — Avoid re-encoding files already within a threshold of the target level
+- Before/after summary — Print a table of input and output levels and the applied gain for all files with `--print-summary`
 - Self-documenting output — Optionally record the effective encoder settings as an `ENCODER_SETTINGS` tag
 - Video file support — Process video files while preserving video streams
 - Docker support — Run via Docker container

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/README.md

@@ -23,6 +23,7 @@ This program normalizes media files to a certain loudness level using the EBU R1
 - Peak normalization — Adjust audio to a specific peak level
 - Selective audio stream normalization — Normalize specific audio streams or only default streams
 - Skip files already at target — Avoid re-encoding files already within a threshold of the target level
+- Before/after summary — Print a table of input and output levels and the applied gain for all files with `--print-summary`
 - Self-documenting output — Optionally record the effective encoder settings as an `ENCODER_SETTINGS` tag
 - Video file support — Process video files while preserving video streams
 - Docker support — Run via Docker container

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ffmpeg-normalize"
-version = "1.42.1"
+version = "1.43.1"
 description = "Normalize audio via ffmpeg"
 readme = "README.md"
 license = "MIT"

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ffmpeg-normalize"
-version = "1.42.1"
+version = "1.43.1"
 description = "Normalize audio via ffmpeg"
 readme = "README.md"
 license = "MIT"

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/src/ffmpeg_normalize/__main__.py

@@ -23,7 +23,7 @@ __version__ = importlib.metadata.version("ffmpeg-normalize")
 _logger = logging.getLogger(__name__)
 
 
-def create_parser() -> argparse.ArgumentParser:
+def create_parser(suppress_defaults: bool = False) -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="ffmpeg-normalize",
         description=textwrap.dedent(
@@ -76,6 +76,9 @@ def create_parser() -> argparse.ArgumentParser:
         will be written to the default output folder with the name `<input>.<ext>`,
         where `<ext>` is the output extension (see `-ext` option).
 
+        Output paths must be distinct and cannot overwrite another input in the same run,
+        even with --force. Normalizing a file in place is allowed.
+
         Example: ffmpeg-normalize 1.wav 2.wav -o 1n.wav 2n.wav
         """
         ),
@@ -204,6 +207,23 @@ def create_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Print loudness statistics for both passes formatted as JSON to stdout.",
     )
+    group_normalization.add_argument(
+        "--print-summary",
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+        Print a before/after summary table to stderr after processing.
+
+        For each file and audio stream, the table lists the input level, the
+        output level, the output peak, the applied gain, and the status. The
+        level is the integrated loudness for EBU, the RMS level for RMS, and the
+        peak level for peak normalization. Values that are not available are
+        shown as `-`.
+
+        Can be combined with `--print-stats`, which writes JSON to stdout.
+        """
+        ),
+    )
     group_normalization.add_argument(
         "--replaygain",
         action="store_true",
@@ -226,8 +246,9 @@ def create_parser() -> argparse.ArgumentParser:
         level. However, a group of music files all from the same album is generally meant to be
         listened to at the relative volumes they were recorded at. In batch mode, all the specified
         files are considered to be part of a single album and their relative volumes are preserved.
-        This is done by averaging the loudness of all the files, computing a single adjustment from
-        that, and applying a relative adjustment to all the files.
+        RMS mode targets the average level, reducing the shared gain if needed to avoid sample
+        clipping. Peak mode sets the loudest sample across the album to the target level.
+        With --lower-only, the shared gain cannot be positive.
 
         Batch mode works with all normalization types (EBU, RMS, peak).
         """
@@ -655,11 +676,16 @@ def create_parser() -> argparse.ArgumentParser:
         ),
         default=FFmpegNormalize.DEFAULTS["extension"],
     )
+    if suppress_defaults:
+        for action in parser._actions:
+            action.default = argparse.SUPPRESS
     return parser
 
 
 def main() -> None:
-    cli_args = create_parser().parse_args()
+    explicit_args = create_parser(suppress_defaults=True).parse_args()
+    cli_args = create_parser().parse_args([])
+    vars(cli_args).update(vars(explicit_args))
     setup_cli_logger(arguments=cli_args)
 
     def error(message: object) -> NoReturn:
@@ -690,7 +716,9 @@ def main() -> None:
         try:
             preset_data = preset_manager.load_preset(cli_args.preset)
             _logger.debug(f"Loaded preset '{cli_args.preset}': {preset_data}")
-            preset_manager.merge_preset_with_args(preset_data, cli_args)
+            preset_manager.merge_preset_with_args(
+                preset_data, cli_args, set(vars(explicit_args))
+            )
             _logger.info(f"Applied preset '{cli_args.preset}'")
         except (FileNotFoundError, json.JSONDecodeError, ValueError) as e:
             error(str(e))
@@ -739,6 +767,7 @@ def main() -> None:
         normalization_type=cli_args.normalization_type,
         target_level=cli_args.target_level,
         print_stats=cli_args.print_stats,
+        print_summary=cli_args.print_summary,
         threshold=cli_args.threshold,
         loudness_range_target=cli_args.loudness_range_target,
         keep_loudness_range_target=cli_args.keep_loudness_range_target,
@@ -807,6 +836,7 @@ def main() -> None:
             "Please fix the issues above and try again."
         )
 
+    output_files: list[str] = []
     for index, input_file in enumerate(input_files):
         if cli_args.output is not None and index < len(cli_args.output):
             if cli_args.output_folder and cli_args.output_folder != "normalized":
@@ -825,12 +855,15 @@ def main() -> None:
                 + "."
                 + cli_args.extension,
             )
-            if not os.path.isdir(cli_args.output_folder) and not cli_args.dry_run:
-                _logger.warning(
-                    f"Output directory '{cli_args.output_folder}' does not exist, will create"
-                )
-                os.makedirs(cli_args.output_folder, exist_ok=True)
+        output_files.append(output_file)
 
+    try:
+        if not cli_args.replaygain:
+            FFmpegNormalize.validate_output_files(input_files, output_files)
+    except FFmpegNormalizeError as e:
+        error(e)
+
+    for input_file, output_file in zip(input_files, output_files):
         if (
             os.path.exists(output_file)
             and not cli_args.force
@@ -849,6 +882,10 @@ def main() -> None:
             _logger.warning(f"Input file '{input_file}' is not a file, skipping")
             continue
 
+        output_dir = os.path.dirname(output_file)
+        if output_dir and not cli_args.dry_run:
+            os.makedirs(output_dir, exist_ok=True)
+
         try:
             ffmpeg_normalize.add_media_file(input_file, output_file)
         except FFmpegNormalizeError as e:

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/src/ffmpeg_normalize/_ffmpeg_normalize.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import logging
+import math
 import os
 import sys
 from itertools import chain
@@ -21,7 +22,7 @@ from ._errors import FFmpegNormalizeError
 from ._media_file import MediaFile
 
 if TYPE_CHECKING:
-    from ._streams import LoudnessStatisticsWithMetadata
+    from ._streams import LoudnessStatisticsWithMetadata, SummaryRow
 
 _logger = logging.getLogger(__name__)
 
@@ -60,6 +61,7 @@ class FFmpegNormalize:
         normalization_type (str, optional): Normalization type. Defaults to "ebu".
         target_level (float, optional): Target level. Defaults to -23.0.
         print_stats (bool, optional): Print loudnorm stats. Defaults to False.
+        print_summary (bool, optional): Print a before/after summary table to stderr after processing. Defaults to False.
         threshold (float, optional): When set to a positive value, skip normalization when the input is already within this many dB/LU of the target level, copying it through unchanged. Defaults to 0 (disabled, always normalize).
         loudness_range_target (float, optional): Loudness range target. Defaults to 7.0.
         keep_loudness_range_target (bool, optional): Keep loudness range target. Defaults to False.
@@ -108,6 +110,7 @@ class FFmpegNormalize:
         "normalization_type": "ebu",
         "target_level": -23.0,
         "print_stats": False,
+        "print_summary": False,
         "threshold": 0.0,
         "loudness_range_target": 7.0,
         "keep_loudness_range_target": False,
@@ -153,6 +156,7 @@ class FFmpegNormalize:
         normalization_type: Literal["ebu", "rms", "peak"] = "ebu",
         target_level: float = -23.0,
         print_stats: bool = False,
+        print_summary: bool = False,
         threshold: float = 0.0,
         loudness_range_target: float = 7.0,
         keep_loudness_range_target: bool = False,
@@ -212,6 +216,7 @@ class FFmpegNormalize:
             self.target_level = check_range(target_level, -99, 0, name="target_level")
 
         self.print_stats = print_stats
+        self.print_summary = print_summary
 
         self.threshold = check_range(threshold, 0, 99, name="threshold")
 
@@ -381,23 +386,68 @@ class FFmpegNormalize:
                 errors.append(error_msg)
         return errors
 
+    @staticmethod
+    def validate_output_files(input_files: list[str], output_files: list[str]) -> None:
+        """Reject duplicate destinations and outputs that overwrite another input.
+
+        Resolve symlinks and existing hard links, while allowing each file to be
+        normalized in place and multiple outputs to the null device.
+        """
+
+        def path_keys(path: str) -> list[str | tuple[int, int]]:
+            keys: list[str | tuple[int, int]] = [
+                os.path.normcase(os.path.realpath(path))
+            ]
+            if os.path.exists(path):
+                stat = os.stat(path)
+                keys.append((stat.st_dev, stat.st_ino))
+            return keys
+
+        input_owners: dict[str | tuple[int, int], set[int]] = {}
+        for index, path in enumerate(input_files):
+            for key in path_keys(path):
+                input_owners.setdefault(key, set()).add(index)
+
+        output_owners: dict[str | tuple[int, int], str] = {}
+        for index, path in enumerate(output_files):
+            if os.path.realpath(path) == os.path.realpath(os.devnull):
+                continue
+            for key in path_keys(path):
+                if key in output_owners:
+                    raise FFmpegNormalizeError(
+                        f"Output collision: '{path}' and '{output_owners[key]}' "
+                        "refer to the same destination. Specify distinct output paths."
+                    )
+                if input_owners.get(key, set()) - {index}:
+                    raise FFmpegNormalizeError(
+                        f"Output '{path}' would overwrite another input file. "
+                        "Specify a different output path."
+                    )
+                output_owners[key] = path
+
     def _calculate_batch_reference(self) -> float | None:
         """
-        Calculate the batch reference loudness by averaging measurements across all files.
+        Calculate a shared reference from the selected streams' measurements.
+
+        Peak mode uses the highest sample peak. RMS mode uses the average RMS,
+        with gain capped by the highest sample peak. EBU uses average LUFS.
 
         Returns:
             float | None: The batch reference loudness value, or None if no measurements found.
 
         Note:
-            TODO: Add option to specify different averaging methods (duration-weighted,
-            use quietest/loudest track, etc.)
+            RMS and EBU averages weight each selected stream equally.
         """
         measurements: list[float] = []
+        peaks: list[float] = []
 
         for media_file in self.media_files:
-            # Access audio streams from the streams dict
-            audio_streams = media_file.streams.get("audio", {})
-            for stream in audio_streams.values():
+            if media_file.status == "error":
+                continue
+            for stream in media_file._get_streams_to_normalize():
+                peak = stream.loudness_statistics.get("max")
+                if peak is not None and math.isfinite(peak):
+                    peaks.append(float(peak))
                 if self.normalization_type == "ebu":
                     # Get EBU integrated loudness from first pass
                     ebu_stats = stream.loudness_statistics.get("ebu_pass1")
@@ -414,6 +464,7 @@ class FFmpegNormalize:
                     if max_val is not None:
                         measurements.append(float(max_val))
 
+        measurements = [value for value in measurements if math.isfinite(value)]
         if not measurements:
             _logger.warning(
                 "No loudness measurements found for batch reference calculation. "
@@ -421,12 +472,27 @@ class FFmpegNormalize:
             )
             return None
 
-        # Simple average of all measurements
-        batch_reference = sum(measurements) / len(measurements)
+        # Peak mode targets the loudest sample in the album. RMS mode targets
+        # the average level, but limits the shared gain to available headroom.
+        batch_reference = (
+            max(measurements)
+            if self.normalization_type == "peak"
+            else sum(measurements) / len(measurements)
+        )
+        if self.normalization_type == "rms" and peaks:
+            safe_reference = self.target_level + max(peaks)
+            if safe_reference > batch_reference:
+                _logger.warning(
+                    "Reducing album gain to avoid sample clipping; "
+                    "the requested RMS target will not be reached."
+                )
+                batch_reference = safe_reference
+        if self.lower_only and self.normalization_type in ("peak", "rms"):
+            batch_reference = max(batch_reference, self.target_level)
         _logger.debug(f"Batch mode: Measurements for batch reference: {measurements}")
         _logger.info(
             f"Batch mode: Calculated reference loudness = {batch_reference:.2f} "
-            f"({self.normalization_type.upper()}, averaged from {len(measurements)} stream(s))"
+            f"({self.normalization_type.upper()}, based on {len(measurements)} stream(s))"
         )
 
         return batch_reference
@@ -442,6 +508,11 @@ class FFmpegNormalize:
         In non-batch mode, each file is processed completely (both passes) before
         moving to the next file.
         """
+        if not self.replaygain:
+            self.validate_output_files(
+                [media_file.input_file for media_file in self.media_files],
+                [media_file.output_file for media_file in self.media_files],
+            )
         if self.batch:
             # Batch mode: analyze all files first, then normalize with relative adjustments
             _logger.info(
@@ -555,3 +626,97 @@ class FFmpegNormalize:
                 indent=4,
             )
             print()
+
+        if self.print_summary:
+            print(self.format_summary(), file=sys.stderr)
+
+    def get_summary(self) -> list[SummaryRow]:
+        """
+        Return the before/after summary for all audio streams of all files.
+
+        Each entry contains the input level, output level, output peak and the
+        applied gain in dB. The level is the integrated loudness for EBU, the
+        RMS level for RMS, and the peak level for peak normalization. The
+        output peak is the true peak for EBU and the sample peak otherwise.
+        Values that are not available are None.
+
+        Returns:
+            list[SummaryRow]: One summary entry per audio stream
+        """
+        return list(
+            chain.from_iterable(
+                media_file.get_summary() for media_file in self.media_files
+            )
+        )
+
+    def format_summary(self) -> str:
+        """
+        Return the before/after summary as a human-readable table.
+
+        Returns:
+            str: The formatted table, including a header line with the target
+        """
+        if self.normalization_type == "ebu":
+            header = (
+                f"EBU R128 normalization, target: {self.target_level:.1f} LUFS, "
+                f"true peak: {self.true_peak:.1f} dBTP"
+            )
+            if self.dynamic:
+                header += ", dynamic mode"
+            columns = ["Input (LUFS)", "Output (LUFS)", "True peak (dBTP)", "Gain (dB)"]
+        elif self.normalization_type == "rms":
+            header = f"RMS normalization, target: {self.target_level:.1f} dBFS"
+            columns = [
+                "Input RMS (dBFS)",
+                "Output RMS (dBFS)",
+                "Peak (dBFS)",
+                "Gain (dB)",
+            ]
+        else:
+            header = f"Peak normalization, target: {self.target_level:.1f} dBFS"
+            columns = ["Input peak (dBFS)", "Output peak (dBFS)", "Gain (dB)"]
+
+        if self.batch:
+            header += ", batch mode (relative loudness preserved)"
+        if self.dry_run:
+            header += ", dry run"
+
+        rows = self.get_summary()
+        if not rows:
+            return f"Summary ({header}): no files processed"
+
+        def fmt(value: float | None, signed: bool = False) -> str:
+            if value is None:
+                return "-"
+            return f"{value:+.1f}" if signed else f"{value:.1f}"
+
+        table: list[list[str]] = []
+        for row in rows:
+            values = [fmt(row["input_level"]), fmt(row["output_level"])]
+            if self.normalization_type != "peak":
+                values.append(fmt(row["output_peak"]))
+            values.append(fmt(row["gain"], signed=True))
+            table.append(
+                [row["input_file"], str(row["stream_id"]), *values, row["status"]]
+            )
+
+        headings = ["File", "Stream", *columns, "Status"]
+        widths = [
+            max(len(headings[i]), *(len(line[i]) for line in table))
+            for i in range(len(headings))
+        ]
+
+        def fmt_line(cells: list[str]) -> str:
+            # Left-align the file name and status, right-align everything else
+            parts = [
+                cell.ljust(widths[i])
+                if i in (0, len(cells) - 1)
+                else cell.rjust(widths[i])
+                for i, cell in enumerate(cells)
+            ]
+            return "  ".join(parts).rstrip()
+
+        lines = [f"Summary ({header}):", "", fmt_line(headings)]
+        lines.append(fmt_line(["-" * w for w in widths]))
+        lines.extend(fmt_line(line) for line in table)
+        return "\n".join(lines)

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/src/ffmpeg_normalize/_media_file.py

@@ -27,6 +27,7 @@ from ._streams import (
     AudioStream,
     LoudnessStatisticsWithMetadata,
     SubtitleStream,
+    SummaryRow,
     VideoStream,
 )
 
@@ -783,7 +784,10 @@ class MediaFile:
             list[str]: the filters, in application order
         """
         skip_normalization = False
-        if self.ffmpeg_normalize.lower_only:
+        if self.ffmpeg_normalize.lower_only and not (
+            self.batch_reference is not None
+            and self.ffmpeg_normalize.normalization_type in ("peak", "rms")
+        ):
             if self.ffmpeg_normalize.normalization_type == "ebu":
                 if (
                     audio_stream.loudness_statistics["ebu_pass1"] is not None
@@ -811,6 +815,7 @@ class MediaFile:
                 f"Stream {audio_stream.stream_id} had measured input loudness lower than target, skipping normalization."
             )
             normalization_filter = "acopy"
+            audio_stream.applied_gain = 0.0
         else:
             if self.ffmpeg_normalize.normalization_type == "ebu":
                 normalization_filter = audio_stream.get_second_pass_opts_ebu(
@@ -1223,3 +1228,23 @@ class MediaFile:
         return (
             audio_stream.get_stats() for audio_stream in self.streams["audio"].values()
         )
+
+    def get_summary(self) -> list[SummaryRow]:
+        """
+        Return the before/after summary for each analyzed audio stream.
+
+        Streams without any measurement (e.g. streams not selected for
+        normalization) are left out, unless the file failed to process.
+
+        Returns:
+            list[SummaryRow]: One summary entry per audio stream
+        """
+        rows = [
+            audio_stream.get_summary()
+            for audio_stream in self.streams["audio"].values()
+        ]
+        return [
+            row
+            for row in rows
+            if row["status"] == "error" or row["input_level"] is not None
+        ]

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/src/ffmpeg_normalize/_presets.py

@@ -9,8 +9,6 @@ import shutil
 from pathlib import Path
 from typing import Any
 
-from ._ffmpeg_normalize import FFmpegNormalize
-
 _logger = logging.getLogger(__name__)
 
 
@@ -171,60 +169,23 @@ class PresetManager:
         return preset_data
 
     def merge_preset_with_args(
-        self, preset_data: dict[str, Any], cli_args: Any
+        self, preset_data: dict[str, Any], cli_args: Any, explicit_args: set[str]
     ) -> None:
-        """Merge preset data with CLI arguments, giving precedence to CLI args.
+        """Apply preset values only to options omitted from the command line.
 
         Args:
-            preset_data: Dictionary of preset configuration
-            cli_args: Parsed CLI arguments (argparse Namespace object)
-
-        The CLI arguments take precedence over preset values. This function modifies
-        cli_args in place by setting attributes that were not explicitly provided
-        on the command line.
+            preset_data: Preset configuration.
+            cli_args: Parsed arguments, including defaults; modified in place.
+            explicit_args: Argument destinations explicitly supplied by the user.
         """
         for key, value in preset_data.items():
-            # Convert hyphens to underscores to match argparse attribute names
             attr_name = key.replace("-", "_")
-
-            # Check if this attribute exists in cli_args
             if not hasattr(cli_args, attr_name):
                 _logger.warning(
                     f"Preset option '{key}' is not a valid ffmpeg-normalize option. Skipping."
                 )
                 continue
-
-            # Get the current value
-            current_value = getattr(cli_args, attr_name)
-
-            # Check if this was explicitly set by the user
-            # For most types, we can infer this by checking against the defaults:
-            # - None values were not explicitly set
-            # - Empty lists were not explicitly set
-            # - False boolean flags were not explicitly set
-            # - Default numeric values (specific to each option) need special handling
-
-            should_apply = False
-
-            if isinstance(value, bool):
-                # For boolean flags, apply preset only if currently False (not set)
-                should_apply = not current_value
-            elif isinstance(current_value, list):
-                # For lists (like output), apply preset only if empty
-                should_apply = not current_value
-            elif current_value is None:
-                # For None values, always apply preset (not explicitly set)
-                should_apply = True
-            else:
-                # For other values (numbers, strings), check if they match known defaults
-                # This is conservative: only override if the value is a known default
-                if (
-                    attr_name in FFmpegNormalize.DEFAULTS
-                    and current_value == FFmpegNormalize.DEFAULTS[attr_name]
-                ):
-                    should_apply = True
-
-            if should_apply:
+            if attr_name not in explicit_args:
                 setattr(cli_args, attr_name, value)
                 _logger.debug(f"Applied preset option '{key}' = {value}")
 

{ffmpeg_normalize-1.42.1 → ffmpeg_normalize-1.43.1}/src/ffmpeg_normalize/_streams.py

@@ -59,6 +59,17 @@ class LoudnessStatistics(TypedDict):
     max: float | None
 
 
+class SummaryRow(TypedDict):
+    input_file: str
+    output_file: str
+    stream_id: int
+    status: str
+    input_level: float | None
+    output_level: float | None
+    output_peak: float | None
+    gain: float | None
+
+
 class _OptionalStatisticsMetadata(TypedDict, total=False):
     error: str
 
@@ -150,6 +161,11 @@ class AudioStream(MediaStream):
             "max": None,
         }
 
+        # Gain in dB applied by the second pass volume filter (peak/RMS), or 0
+        # when normalization is skipped for this stream (e.g. with lower_only).
+        # Stays None for EBU, where the gain is derived from the second pass stats.
+        self.applied_gain: float | None = None
+
         self.sample_rate = sample_rate
         self.bit_depth = bit_depth
 
@@ -208,6 +224,78 @@ class AudioStream(MediaStream):
             stats["error"] = self.media_file.error
         return stats
 
+    def get_summary(self) -> SummaryRow:
+        """
+        Return the before/after levels and the applied gain for the stream.
+
+        For EBU, the input level and true peak come from the first pass (or the
+        second pass in dynamic mode), and the output level, output true peak and
+        gain come from the second pass. For RMS and peak, the input level is the
+        measured RMS or peak level, and the output values are computed from the
+        applied gain. Values that are not available are None.
+
+        Returns:
+            dict: A dictionary with the summary values.
+        """
+        normalization_type = self.ffmpeg_normalize.normalization_type
+        status = self.media_file.status
+
+        input_level: float | None = None
+        input_peak: float | None = None
+        output_level: float | None = None
+        output_peak: float | None = None
+        gain: float | None = None
+
+        if normalization_type == "ebu":
+            pass1 = self.loudness_statistics["ebu_pass1"]
+            pass2 = self.loudness_statistics["ebu_pass2"]
+            input_stats = pass1 if pass1 is not None else pass2
+            if input_stats is not None:
+                input_level = float(input_stats["input_i"])
+                input_peak = float(input_stats["input_tp"])
+            if pass2 is not None:
+                output_level = float(pass2["output_i"])
+                output_peak = float(pass2["output_tp"])
+                # Input and output of the same pass, as the first pass input
+                # measurement can differ slightly from the second pass one
+                gain = output_level - float(pass2["input_i"])
+        else:
+            measured = (
+                self.loudness_statistics["mean"]
+                if normalization_type == "rms"
+                else self.loudness_statistics["max"]
+            )
+            if measured is not None:
+                input_level = float(measured)
+            if self.loudness_statistics["max"] is not None:
+                input_peak = float(self.loudness_statistics["max"])
+
+        applied_gain = 0.0 if status == "skipped" else self.applied_gain
+        if (
+            status != "error"
+            and output_level is None
+            and applied_gain is not None
+            and input_level is not None
+        ):
+            gain = applied_gain
+            output_level = input_level + applied_gain
+            if input_peak is not None:
+                output_peak = input_peak + applied_gain
+
+        if status == "error":
+            output_level = output_peak = gain = None
+
+        return {
+            "input_file": self.media_file.input_file,
+            "output_file": self.media_file.output_file,
+            "stream_id": self.stream_id,
+            "status": status,
+            "input_level": input_level,
+            "output_level": output_level,
+            "output_peak": output_peak,
+            "gain": gain,
+        }
+
     def set_second_pass_stats(self, stats: EbuLoudnessStatistics) -> None:
         """
         Set the EBU loudness statistics for the second pass.
@@ -815,6 +903,8 @@ class AudioStream(MediaStream):
             f"Adjusting stream {self.stream_id} by {adjustment} dB to reach {target_level}"
         )
 
+        self.applied_gain = float(adjustment)
+
         clip_amount = self.loudness_statistics["max"] + adjustment
         if clip_amount > 0:
             _logger.warning(