ffmpeg-normalize 1.34.0__tar.gz → 1.35.0__tar.gz

{ffmpeg_normalize-1.34.0 → ffmpeg_normalize-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.34.0
+Version: 1.35.0
 Summary: Normalize audio via ffmpeg
 Keywords: ffmpeg,normalize,audio
 Author: Werner Robitza
@@ -46,12 +46,48 @@ This program normalizes media files to a certain loudness level using the EBU R1
 
 ## ✨ Features
 
-- EBU R128 loudness normalization (two-pass by default, with an option for one-pass dynamic normalization)
-- RMS-based normalization
-- Peak normalization
-- Video file support
-- Docker support
-- Python API
+- EBU R128 loudness normalization — Two-pass by default, with an option for one-pass dynamic normalization
+- RMS-based normalization — Adjust audio to a specific RMS level
+- Peak normalization — Adjust audio to a specific peak level
+- Selective audio stream normalization — Normalize specific audio streams or only default streams
+- Video file support — Process video files while preserving video streams
+- Docker support — Run via Docker container
+- Python API — Use programmatically in your Python projects
+- Shell completions — Available for bash, zsh, and fish
+- Album Batch normalization – Process files jointy, preserving relative loudness
+
+## 🆕 What's New
+
+- Version 1.35.0 has **batch/album normalization** with `--batch`. It preserves relative loudness between files! Perfect for music albums where you want to shift all tracks by the same amount.
+
+    Example:
+
+    ```bash
+    ffmpeg-normalize album/*.flac --batch -nt rms -t -20
+    ```
+
+    shifts the entire album so the average RMS is -20 dB, preserving the original relative loudness as mastered.
+
+- Version 1.34.0 brings **selective audio stream normalization**! You can now:
+
+  - Normalize specific audio streams with `-as/--audio-streams` (e.g., `-as 1,2` to normalize only streams 1 and 2)
+  - Normalize only default audio streams with `--audio-default-only` (useful for files with multiple language tracks)
+  - Keep other streams unchanged with `--keep-other-audio` (copy non-selected streams without normalization)
+
+    Example:
+
+    ```bash
+    ffmpeg-normalize input.mkv -as 1 --keep-other-audio
+    ```
+
+    normalizes stream 1 and copies all other audio streams unchanged.
+
+Other recent additions:
+
+- **Shell completions** (v1.31.0) — Tab completion for bash, zsh, and fish shells. See the [installation guide](https://slhck.info/ffmpeg-normalize/getting-started/installation/#shell-completions) for setup instructions.
+- **`--lower-only` option** — Prevent audio from increasing in loudness, only lower it if needed (works with all normalization types).
+
+See the [full changelog](https://github.com/slhck/ffmpeg-normalize/blob/master/CHANGELOG.md) for all updates.
 
 ## 🚀 Quick Start
 

{ffmpeg_normalize-1.34.0 → ffmpeg_normalize-1.35.0}/README.md

@@ -14,12 +14,48 @@ This program normalizes media files to a certain loudness level using the EBU R1
 
 ## ✨ Features
 
-- EBU R128 loudness normalization (two-pass by default, with an option for one-pass dynamic normalization)
-- RMS-based normalization
-- Peak normalization
-- Video file support
-- Docker support
-- Python API
+- EBU R128 loudness normalization — Two-pass by default, with an option for one-pass dynamic normalization
+- RMS-based normalization — Adjust audio to a specific RMS level
+- Peak normalization — Adjust audio to a specific peak level
+- Selective audio stream normalization — Normalize specific audio streams or only default streams
+- Video file support — Process video files while preserving video streams
+- Docker support — Run via Docker container
+- Python API — Use programmatically in your Python projects
+- Shell completions — Available for bash, zsh, and fish
+- Album Batch normalization – Process files jointy, preserving relative loudness
+
+## 🆕 What's New
+
+- Version 1.35.0 has **batch/album normalization** with `--batch`. It preserves relative loudness between files! Perfect for music albums where you want to shift all tracks by the same amount.
+
+    Example:
+
+    ```bash
+    ffmpeg-normalize album/*.flac --batch -nt rms -t -20
+    ```
+
+    shifts the entire album so the average RMS is -20 dB, preserving the original relative loudness as mastered.
+
+- Version 1.34.0 brings **selective audio stream normalization**! You can now:
+
+  - Normalize specific audio streams with `-as/--audio-streams` (e.g., `-as 1,2` to normalize only streams 1 and 2)
+  - Normalize only default audio streams with `--audio-default-only` (useful for files with multiple language tracks)
+  - Keep other streams unchanged with `--keep-other-audio` (copy non-selected streams without normalization)
+
+    Example:
+
+    ```bash
+    ffmpeg-normalize input.mkv -as 1 --keep-other-audio
+    ```
+
+    normalizes stream 1 and copies all other audio streams unchanged.
+
+Other recent additions:
+
+- **Shell completions** (v1.31.0) — Tab completion for bash, zsh, and fish shells. See the [installation guide](https://slhck.info/ffmpeg-normalize/getting-started/installation/#shell-completions) for setup instructions.
+- **`--lower-only` option** — Prevent audio from increasing in loudness, only lower it if needed (works with all normalization types).
+
+See the [full changelog](https://github.com/slhck/ffmpeg-normalize/blob/master/CHANGELOG.md) for all updates.
 
 ## 🚀 Quick Start
 

{ffmpeg_normalize-1.34.0 → ffmpeg_normalize-1.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ffmpeg-normalize"
-version = "1.34.0"
+version = "1.35.0"
 description = "Normalize audio via ffmpeg"
 readme = "README.md"
 license = "MIT"
@@ -53,6 +53,7 @@ dev = [
     "ruff>=0.12.11",
     "mypy>=1.0.0",
     "types-tqdm",
+    "shtab>=1.7.0",
 ]
 
 [tool.mypy]

{ffmpeg_normalize-1.34.0 → ffmpeg_normalize-1.35.0}/src/ffmpeg_normalize/__main__.py

@@ -179,6 +179,24 @@ def create_parser() -> argparse.ArgumentParser:
         """
         ),
     )
+    group_normalization.add_argument(
+        "--batch",
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+        Preserve relative loudness between files (album mode).
+
+        When operating on a group of unrelated files, you usually want all of them at the same
+        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.
+
+        Batch mode works with all normalization types (EBU, RMS, peak).
+        """
+        ),
+    )
 
     # group_normalization.add_argument(
     #     '--threshold',
@@ -636,6 +654,7 @@ def main() -> None:
         dry_run=cli_args.dry_run,
         progress=cli_args.progress,
         replaygain=cli_args.replaygain,
+        batch=cli_args.batch,
         audio_streams=audio_streams,
         audio_default_only=cli_args.audio_default_only,
         keep_other_audio=cli_args.keep_other_audio,

{ffmpeg_normalize-1.34.0 → ffmpeg_normalize-1.35.0}/src/ffmpeg_normalize/_ffmpeg_normalize.py

@@ -84,6 +84,7 @@ class FFmpegNormalize:
         debug (bool, optional): Debug. Defaults to False.
         progress (bool, optional): Progress. Defaults to False.
         replaygain (bool, optional): Write ReplayGain tags without normalizing. Defaults to False.
+        batch (bool, optional): Preserve relative loudness between files (album mode). Defaults to False.
         audio_streams (list[int] | None, optional): List of audio stream indices to normalize. Defaults to None (all streams).
         audio_default_only (bool, optional): Only normalize audio streams with default disposition. Defaults to False.
         keep_other_audio (bool, optional): Keep non-selected audio streams in output (copy without normalization). Defaults to False.
@@ -127,6 +128,7 @@ class FFmpegNormalize:
         debug: bool = False,
         progress: bool = False,
         replaygain: bool = False,
+        batch: bool = False,
         audio_streams: list[int] | None = None,
         audio_default_only: bool = False,
         keep_other_audio: bool = False,
@@ -212,6 +214,7 @@ class FFmpegNormalize:
         self.debug = debug
         self.progress = progress
         self.replaygain = replaygain
+        self.batch = batch
 
         # Stream selection options
         self.audio_streams = audio_streams
@@ -272,29 +275,172 @@ class FFmpegNormalize:
         self.media_files.append(MediaFile(self, input_file, output_file))
         self.file_count += 1
 
+    def _calculate_batch_reference(self) -> float | None:
+        """
+        Calculate the batch reference loudness by averaging measurements across all files.
+
+        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.)
+        """
+        measurements: 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 self.normalization_type == "ebu":
+                    # Get EBU integrated loudness from first pass
+                    ebu_stats = stream.loudness_statistics.get("ebu_pass1")
+                    if ebu_stats and "input_i" in ebu_stats:
+                        measurements.append(float(ebu_stats["input_i"]))
+                elif self.normalization_type == "rms":
+                    # Get RMS mean value
+                    mean = stream.loudness_statistics.get("mean")
+                    if mean is not None:
+                        measurements.append(float(mean))
+                elif self.normalization_type == "peak":
+                    # Get peak max value
+                    max_val = stream.loudness_statistics.get("max")
+                    if max_val is not None:
+                        measurements.append(float(max_val))
+
+        if not measurements:
+            _logger.warning(
+                "No loudness measurements found for batch reference calculation. "
+                "Batch mode will not be applied."
+            )
+            return None
+
+        # Simple average of all measurements
+        batch_reference = sum(measurements) / len(measurements)
+        _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))"
+        )
+
+        return batch_reference
+
     def run_normalization(self) -> None:
         """
-        Run the normalization procedures
+        Run the normalization procedures.
+
+        In batch mode, all files are analyzed first (first pass), then a batch reference
+        loudness is calculated, and finally all files are normalized (second pass) with
+        adjustments relative to the batch reference to preserve relative loudness.
+
+        In non-batch mode, each file is processed completely (both passes) before
+        moving to the next file.
         """
-        for index, media_file in enumerate(
-            tqdm(self.media_files, desc="File", disable=not self.progress, position=0)
-        ):
+        if self.batch:
+            # Batch mode: analyze all files first, then normalize with relative adjustments
             _logger.info(
-                f"Normalizing file {media_file} ({index + 1} of {self.file_count})"
+                f"Batch mode enabled: processing {self.file_count} file(s) while preserving relative loudness"
             )
 
-            try:
-                media_file.run_normalization()
-            except Exception as e:
-                if len(self.media_files) > 1:
-                    # simply warn and do not die
-                    _logger.error(
-                        f"Error processing input file {media_file}, will "
-                        f"continue batch-processing. Error was: {e}"
-                    )
-                else:
-                    # raise the error so the program will exit
-                    raise e
+            # Recommend RMS/Peak for album normalization instead of EBU
+            if self.normalization_type == "ebu":
+                _logger.warning(
+                    "Using EBU R128 normalization with --batch. For true album normalization where "
+                    "all tracks are shifted by the same amount, consider using --normalization-type rms "
+                    "or --normalization-type peak instead. EBU normalization applies different processing "
+                    "to each track based on its loudness characteristics, which may alter relative levels "
+                    "slightly due to psychoacoustic adjustments."
+                )
+
+            # Warn if using dynamic EBU mode with batch
+            if self.dynamic and self.normalization_type == "ebu":
+                _logger.warning(
+                    "ffmpeg uses dynamic EBU normalization. This may change relative "
+                    "loudness within a file. Use linear mode for true album normalization, or "
+                    "switch to --normalization-type peak or --normalization-type rms instead. "
+                    "To force linear mode, use --keep-lra-above-loudness-range-target or "
+                    "--keep-loudness-range-target."
+                )
+
+            # Phase 1: Run first pass on all files to collect measurements
+            _logger.info("Phase 1: Analyzing all files...")
+            for index, media_file in enumerate(
+                tqdm(
+                    self.media_files,
+                    desc="Analysis",
+                    disable=not self.progress,
+                    position=0,
+                )
+            ):
+                _logger.info(
+                    f"Analyzing file {media_file} ({index + 1} of {self.file_count})"
+                )
+
+                try:
+                    # Only run first pass if not in dynamic EBU mode
+                    if not (self.dynamic and self.normalization_type == "ebu"):
+                        media_file._first_pass()
+                    else:
+                        _logger.debug(
+                            "Dynamic EBU mode: First pass skipped for this file."
+                        )
+                except Exception as e:
+                    if len(self.media_files) > 1:
+                        _logger.error(
+                            f"Error analyzing input file {media_file}, will "
+                            f"continue batch-processing. Error was: {e}"
+                        )
+                    else:
+                        raise e
+
+            # Phase 2: Calculate batch reference loudness
+            batch_reference = self._calculate_batch_reference()
+
+            # Phase 3: Run second pass on all files with batch reference
+            _logger.info("Phase 2: Normalizing all files...")
+            for index, media_file in enumerate(
+                tqdm(
+                    self.media_files,
+                    desc="Normalization",
+                    disable=not self.progress,
+                    position=0,
+                )
+            ):
+                _logger.info(
+                    f"Normalizing file {media_file} ({index + 1} of {self.file_count})"
+                )
+
+                try:
+                    media_file.run_normalization(batch_reference=batch_reference)
+                except Exception as e:
+                    if len(self.media_files) > 1:
+                        _logger.error(
+                            f"Error processing input file {media_file}, will "
+                            f"continue batch-processing. Error was: {e}"
+                        )
+                    else:
+                        raise e
+        else:
+            # Non-batch mode: process each file completely before moving to the next
+            for index, media_file in enumerate(
+                tqdm(
+                    self.media_files, desc="File", disable=not self.progress, position=0
+                )
+            ):
+                _logger.info(
+                    f"Normalizing file {media_file} ({index + 1} of {self.file_count})"
+                )
+
+                try:
+                    media_file.run_normalization()
+                except Exception as e:
+                    if len(self.media_files) > 1:
+                        _logger.error(
+                            f"Error processing input file {media_file}, will "
+                            f"continue batch-processing. Error was: {e}"
+                        )
+                    else:
+                        raise e
 
         if self.print_stats:
             json.dump(

{ffmpeg_normalize-1.34.0 → ffmpeg_normalize-1.35.0}/src/ffmpeg_normalize/_media_file.py

@@ -86,6 +86,7 @@ class MediaFile:
             self.output_ext = current_ext
         self.streams: StreamDict = {"audio": {}, "video": {}, "subtitle": {}}
         self.temp_file: Union[str, None] = None
+        self.batch_reference: float | None = None
 
         self.parse_streams()
 
@@ -265,21 +266,35 @@ class MediaFile:
             # Normalize all streams (default behavior)
             return all_audio_streams
 
-    def run_normalization(self) -> None:
+    def run_normalization(self, batch_reference: float | None = None) -> None:
         """
         Run the normalization process for this file.
+
+        Args:
+            batch_reference (float | None, optional): Reference loudness for batch mode.
+                If provided, the first pass is skipped (assumed already done) and this
+                reference is used to calculate relative adjustments. Defaults to None.
         """
         _logger.debug(f"Running normalization for {self.input_file}")
 
-        # run the first pass to get loudness stats, unless in dynamic EBU mode
-        if not (
-            self.ffmpeg_normalize.dynamic
-            and self.ffmpeg_normalize.normalization_type == "ebu"
-        ):
-            self._first_pass()
+        # Store batch reference for use in second pass
+        self.batch_reference = batch_reference
+
+        # run the first pass to get loudness stats, unless in dynamic EBU mode or batch mode
+        # (in batch mode, first pass is already done in FFmpegNormalize.run_normalization)
+        if batch_reference is None:
+            if not (
+                self.ffmpeg_normalize.dynamic
+                and self.ffmpeg_normalize.normalization_type == "ebu"
+            ):
+                self._first_pass()
+            else:
+                _logger.debug(
+                    "Dynamic EBU mode: First pass will not run, as it is not needed."
+                )
         else:
             _logger.debug(
-                "Dynamic EBU mode: First pass will not run, as it is not needed."
+                f"Batch mode: Skipping first pass (already completed), using batch reference = {batch_reference:.2f}"
             )
 
         # for second pass, create a temp file
@@ -529,9 +544,13 @@ class MediaFile:
                 normalization_filter = "acopy"
             else:
                 if self.ffmpeg_normalize.normalization_type == "ebu":
-                    normalization_filter = audio_stream.get_second_pass_opts_ebu()
+                    normalization_filter = audio_stream.get_second_pass_opts_ebu(
+                        batch_reference=self.batch_reference
+                    )
                 else:
-                    normalization_filter = audio_stream.get_second_pass_opts_peakrms()
+                    normalization_filter = audio_stream.get_second_pass_opts_peakrms(
+                        batch_reference=self.batch_reference
+                    )
 
             input_label = f"[0:{audio_stream.stream_id}]"
             output_label = f"[norm{audio_stream.stream_id}]"

{ffmpeg_normalize-1.34.0 → ffmpeg_normalize-1.35.0}/src/ffmpeg_normalize/_streams.py

@@ -444,9 +444,14 @@ class AudioStream(MediaStream):
                         )
         return result
 
-    def get_second_pass_opts_ebu(self) -> str:
+    def get_second_pass_opts_ebu(self, batch_reference: float | None = None) -> str:
         """
         Return second pass loudnorm filter options string for ffmpeg
+
+        Args:
+            batch_reference (float | None, optional): Reference loudness for batch mode.
+                When provided, the target level is adjusted to preserve relative loudness.
+                Defaults to None.
         """
 
         # In dynamic mode, we can do everything in one pass, and we do not have first pass stats
@@ -552,6 +557,19 @@ class AudioStream(MediaStream):
 
         stats = self.loudness_statistics["ebu_pass1"]
 
+        # Adjust target level for batch mode to preserve relative loudness
+        if batch_reference is not None:
+            input_i = float(stats["input_i"])
+            # Formula: adjusted_target = target_level + (input_i - batch_reference)
+            # If track is quieter than average (input_i < batch_ref), offset is negative → quieter target
+            # If track is louder than average (input_i > batch_ref), offset is positive → louder target
+            adjusted_target = target_level + (input_i - batch_reference)
+            _logger.info(
+                f"Batch mode: Adjusting target from {target_level:.2f} to {adjusted_target:.2f} LUFS "
+                f"(input_i={input_i:.2f}, batch_ref={batch_reference:.2f}, offset={input_i - batch_reference:.2f})"
+            )
+            target_level = adjusted_target
+
         opts = {
             "i": target_level,
             "lra": self.media_file.ffmpeg_normalize.loudness_range_target,
@@ -576,11 +594,16 @@ class AudioStream(MediaStream):
 
         return "loudnorm=" + dict_to_filter_opts(opts)
 
-    def get_second_pass_opts_peakrms(self) -> str:
+    def get_second_pass_opts_peakrms(self, batch_reference: float | None = None) -> str:
         """
         Set the adjustment gain based on chosen option and mean/max volume,
         return the matching ffmpeg volume filter.
 
+        Args:
+            batch_reference (float | None, optional): Reference loudness for batch mode.
+                When provided, the target level is adjusted to preserve relative loudness.
+                Defaults to None.
+
         Returns:
             str: ffmpeg volume filter string
         """
@@ -595,6 +618,27 @@ class AudioStream(MediaStream):
         normalization_type = self.media_file.ffmpeg_normalize.normalization_type
         target_level = self.media_file.ffmpeg_normalize.target_level
 
+        # Adjust target level for batch mode to preserve relative loudness
+        if batch_reference is not None:
+            if normalization_type == "peak":
+                measured_level = float(self.loudness_statistics["max"])
+            elif normalization_type == "rms":
+                measured_level = float(self.loudness_statistics["mean"])
+            else:
+                raise FFmpegNormalizeError(
+                    "Can only set adjustment for peak and RMS normalization"
+                )
+
+            # Formula: adjusted_target = target_level + (measured_level - batch_reference)
+            # If track is quieter than average (measured < batch_ref), offset is negative → quieter target
+            # If track is louder than average (measured > batch_ref), offset is positive → louder target
+            adjusted_target = target_level + (measured_level - batch_reference)
+            _logger.info(
+                f"Batch mode: Adjusting target from {target_level:.2f} to {adjusted_target:.2f} dB "
+                f"(measured={measured_level:.2f}, batch_ref={batch_reference:.2f}, offset={measured_level - batch_reference:.2f})"
+            )
+            target_level = adjusted_target
+
         if normalization_type == "peak":
             adjustment = 0 + target_level - self.loudness_statistics["max"]
         elif normalization_type == "rms":