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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.43.0
+Version: 1.43.1
 Summary: Normalize audio via ffmpeg
 Keywords: ffmpeg,normalize,audio
 Author: Werner Robitza

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

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

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

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

{ffmpeg_normalize-1.43.0 → 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
         """
         ),
@@ -243,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).
         """
@@ -672,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:
@@ -707,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))
@@ -825,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":
@@ -843,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
@@ -867,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.43.0 → 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
@@ -385,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")
@@ -418,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. "
@@ -425,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
@@ -446,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(

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

@@ -784,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

{ffmpeg_normalize-1.43.0 → 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}")