ffmpeg-normalize 1.32.1__py2.py3-none-any.whl → 1.32.2__py2.py3-none-any.whl

ffmpeg_normalize/_media_file.py

@@ -6,7 +6,7 @@ import re
 import shlex
 from shutil import move, rmtree
 from tempfile import mkdtemp
-from typing import TYPE_CHECKING, Iterable, Iterator, Literal, TypedDict
+from typing import TYPE_CHECKING, Iterable, Iterator, Literal, TypedDict, Union
 
 from mutagen.id3 import ID3, TXXX
 from mutagen.mp3 import MP3
@@ -75,10 +75,17 @@ class MediaFile:
         current_ext = os.path.splitext(output_file)[1][1:]
         # we need to check if it's empty, e.g. /dev/null or NUL
         if current_ext == "" or self.output_file == os.devnull:
+            _logger.debug(
+                f"Current extension is unset, or output file is a null device, using extension: {self.ffmpeg_normalize.extension}"
+            )
             self.output_ext = self.ffmpeg_normalize.extension
         else:
+            _logger.debug(
+                f"Current extension is set from output file, using extension: {current_ext}"
+            )
             self.output_ext = current_ext
         self.streams: StreamDict = {"audio": {}, "video": {}, "subtitle": {}}
+        self.temp_file: Union[str, None] = None
 
         self.parse_streams()
 
@@ -203,12 +210,17 @@ class MediaFile:
         # run the first pass to get loudness stats
         self._first_pass()
 
-        # shortcut to apply replaygain
+        # for second pass, create a temp file
+        temp_dir = mkdtemp()
+        self.temp_file = os.path.join(temp_dir, f"out.{self.output_ext}")
+
         if self.ffmpeg_normalize.replaygain:
-            self._run_replaygain()
-            return
+            _logger.debug(
+                "ReplayGain mode: Second pass will run with temporary file to get stats."
+            )
+            self.output_file = self.temp_file
 
-        # run the second pass as a whole
+        # run the second pass as a whole.
         if self.ffmpeg_normalize.progress:
             with tqdm(
                 total=100,
@@ -222,7 +234,20 @@ class MediaFile:
             for _ in self._second_pass():
                 pass
 
-        _logger.info(f"Normalized file written to {self.output_file}")
+        # remove temp dir; this will remove the temp file as well if it has not been renamed (e.g. for replaygain)
+        if os.path.exists(temp_dir):
+            rmtree(temp_dir, ignore_errors=True)
+
+        # This will use stats from ebu_pass2 if available (from the main second pass),
+        # or fall back to ebu_pass1.
+        if self.ffmpeg_normalize.replaygain:
+            _logger.debug(
+                "ReplayGain tagging is enabled. Proceeding with tag calculation/application."
+            )
+            self._run_replaygain()
+
+        if not self.ffmpeg_normalize.replaygain:
+            _logger.info(f"Normalized file written to {self.output_file}")
 
     def _run_replaygain(self) -> None:
         """
@@ -233,13 +258,32 @@ class MediaFile:
         # get the audio streams
         audio_streams = list(self.streams["audio"].values())
 
-        # get the loudnorm stats from the first pass
-        loudnorm_stats = audio_streams[0].loudness_statistics["ebu_pass1"]
+        # Attempt to use EBU pass 2 statistics, which account for pre-filters.
+        # These are populated by the main second pass if it runs (not a dry run)
+        # and normalization_type is 'ebu'.
+        loudness_stats_source = "ebu_pass2"
+        loudnorm_stats = audio_streams[0].loudness_statistics.get("ebu_pass2")
+
+        if loudnorm_stats is None:
+            _logger.warning(
+                "ReplayGain: Second pass EBU statistics (ebu_pass2) not found. "
+                "Falling back to first pass EBU statistics (ebu_pass1). "
+                "This may not account for pre-filters if any are used."
+            )
+            loudness_stats_source = "ebu_pass1"
+            loudnorm_stats = audio_streams[0].loudness_statistics.get("ebu_pass1")
 
         if loudnorm_stats is None:
-            _logger.error("no loudnorm stats available in first pass stats!")
+            _logger.error(
+                f"ReplayGain: No loudness statistics available from {loudness_stats_source} (and fallback) for stream 0. "
+                "Cannot calculate ReplayGain tags."
+            )
             return
 
+        _logger.debug(
+            f"Using statistics from {loudness_stats_source} for ReplayGain calculation."
+        )
+
         # apply the replaygain tag from the first audio stream (to all audio streams)
         if len(audio_streams) > 1:
             _logger.warning(
@@ -249,23 +293,31 @@ class MediaFile:
             )
 
         target_level = self.ffmpeg_normalize.target_level
-        input_i = loudnorm_stats["input_i"]  # Integrated loudness
-        input_tp = loudnorm_stats["input_tp"]  # True peak
+        # Use 'input_i' and 'input_tp' from the chosen stats.
+        # For ebu_pass2, these are measurements *after* pre-filter but *before* loudnorm adjustment.
+        input_i = loudnorm_stats.get("input_i")
+        input_tp = loudnorm_stats.get("input_tp")
 
         if input_i is None or input_tp is None:
-            _logger.error("no input_i or input_tp available in first pass stats!")
+            _logger.error(
+                f"ReplayGain: 'input_i' or 'input_tp' missing from {loudness_stats_source} statistics. "
+                "Cannot calculate ReplayGain tags."
+            )
             return
 
         track_gain = -(input_i - target_level)  # dB
         track_peak = 10 ** (input_tp / 20)  # linear scale
 
-        _logger.debug(f"Track gain: {track_gain} dB")
-        _logger.debug(f"Track peak: {track_peak}")
+        _logger.debug(f"Calculated Track gain: {track_gain:.2f} dB")
+        _logger.debug(f"Calculated Track peak: {track_peak:.2f}")
 
-        if not self.ffmpeg_normalize.dry_run:
+        if not self.ffmpeg_normalize.dry_run:  # This uses the overall dry_run state
             self._write_replaygain_tags(track_gain, track_peak)
         else:
-            _logger.warning("Dry run used, not actually writing replaygain tags")
+            _logger.warning(
+                "Overall dry_run is enabled, not actually writing ReplayGain tags to the file. "
+                "Tag calculation based on available stats was performed."
+            )
 
     def _write_replaygain_tags(self, track_gain: float, track_peak: float) -> None:
         """
@@ -554,33 +606,27 @@ class MediaFile:
 
         cmd_runner = CommandRunner()
         try:
-            try:
-                yield from cmd_runner.run_ffmpeg_command(cmd)
-            except Exception as e:
-                _logger.error(
-                    f"Error while running command {shlex.join(cmd)}! Error: {e}"
-                )
-                raise e
-            else:
-                if self.output_file != os.devnull:
-                    _logger.debug(
-                        f"Moving temporary file from {temp_file} to {self.output_file}"
-                    )
-                    move(temp_file, self.output_file)
-                    rmtree(temp_dir, ignore_errors=True)
+            yield from cmd_runner.run_ffmpeg_command(cmd)
         except Exception as e:
-            if self.output_file != os.devnull:
-                rmtree(temp_dir, ignore_errors=True)
+            _logger.error(f"Error while running command {shlex.join(cmd)}! Error: {e}")
             raise e
+        else:
+            # only move the temp file if it's not a null device and ReplayGain is not enabled!
+            if self.output_file != os.devnull and not self.ffmpeg_normalize.replaygain:
+                _logger.debug(
+                    f"Moving temporary file from {temp_file} to {self.output_file}"
+                )
+                move(temp_file, self.output_file)
 
         output = cmd_runner.get_output()
         # in the second pass, we do not normalize stream-by-stream, so we set the stats based on the
         # overall output (which includes multiple loudnorm stats)
         if self.ffmpeg_normalize.normalization_type == "ebu":
-            all_stats = AudioStream.prune_and_parse_loudnorm_output(output)
-            for stream_id, audio_stream in self.streams["audio"].items():
-                if stream_id in all_stats:
-                    audio_stream.set_second_pass_stats(all_stats[stream_id])
+            ebu_pass_2_stats = list(
+                AudioStream.prune_and_parse_loudnorm_output(output).values()
+            )
+            for idx, audio_stream in enumerate(self.streams["audio"].values()):
+                audio_stream.set_second_pass_stats(ebu_pass_2_stats[idx])
 
         # warn if self.media_file.ffmpeg_normalize.dynamic == False and any of the second pass stats contain "normalization_type" == "dynamic"
         if self.ffmpeg_normalize.dynamic is False:

ffmpeg_normalize/_streams.py

@@ -65,6 +65,9 @@ class MediaStream:
         self.media_file = media_file
         self.stream_type = stream_type
         self.stream_id = stream_id
+        _logger.debug(
+            f"Created MediaStream for {self.media_file.input_file}, {self.stream_type} stream {self.stream_id}"
+        )
 
     def __repr__(self) -> str:
         return (
@@ -175,6 +178,9 @@ class AudioStream(MediaStream):
         Args:
             stats (dict): The EBU loudness statistics.
         """
+        _logger.debug(
+            f"Setting second pass stats for stream {self.stream_id} from {stats}"
+        )
         self.loudness_statistics["ebu_pass2"] = stats
 
     def get_pcm_codec(self) -> str:
@@ -339,8 +345,9 @@ class AudioStream(MediaStream):
             output (str): The output from ffmpeg.
 
         Returns:
-            list: The EBU loudness statistics.
+            dict[int, EbuLoudnessStatistics]: The EBU loudness statistics.
         """
+        _logger.debug("Parsing loudnorm stats from output")
         pruned_output = CommandRunner.prune_ffmpeg_progress_from_output(output)
         output_lines = [line.strip() for line in pruned_output.split("\n")]
         return AudioStream._parse_loudnorm_output(output_lines)
@@ -359,7 +366,7 @@ class AudioStream(MediaStream):
             FFmpegNormalizeError: When the output could not be parsed.
 
         Returns:
-            EbuLoudnessStatistics: The EBU loudness statistics, if found.
+            dict[int, EbuLoudnessStatistics]: stream index and the EBU loudness statistics, if found.
         """
         result = dict[int, EbuLoudnessStatistics]()
         stream_index = -1

ffmpeg_normalize/_version.py

@@ -1 +1 @@
-__version__ = "1.32.1"
+__version__ = "1.32.2"

{ffmpeg_normalize-1.32.1.dist-info → ffmpeg_normalize-1.32.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ffmpeg-normalize
-Version: 1.32.1
+Version: 1.32.2
 Summary: Normalize audio via ffmpeg
 Home-page: https://github.com/slhck/ffmpeg-normalize
 Author: Werner Robitza
@@ -119,6 +119,13 @@ The only reason this project exists in its current form is because [@benjaoming]
 # Changelog
 
 
+## v1.32.2 (2025-05-08)
+
+* Docs: reference changelog.
+
+* Fix: make replaygain use second pass stats.
+
+
 ## v1.32.1 (2025-05-08)
 
 * Fix missing mutagen requirement, fixes #283.

{ffmpeg_normalize-1.32.1.dist-info → ffmpeg_normalize-1.32.2.dist-info}/RECORD

@@ -4,13 +4,13 @@ ffmpeg_normalize/_cmd_utils.py,sha256=iGzO3iOylDUOnx-FCKd84BMxiIhmIthxU1tg7kvf4S
 ffmpeg_normalize/_errors.py,sha256=brTQ4osJ4fTA8wnyMPVVYfGwJ0wqeShRFydTEwi_VEY,48
 ffmpeg_normalize/_ffmpeg_normalize.py,sha256=79wzFR4ZOgy-Wn0ywi8PNJzsrxiDSMKtJ6_auHxiQvo,11762
 ffmpeg_normalize/_logger.py,sha256=3Ap4Fxg7xGrzz7h4IGuNEf0KKstx0Rq_eLbHPrHzcrI,1841
-ffmpeg_normalize/_media_file.py,sha256=aQcVWTMwbTtb23yAHyBsbnDx4R5l3_bsPflhkYxKTEA,23354
-ffmpeg_normalize/_streams.py,sha256=C0b8GT4EK0W02x8pM99H1-BjjO-pLxYFNvZ4R7gu4CM,20223
-ffmpeg_normalize/_version.py,sha256=IiCFW8nXLS3OVDl5yCPVb9Rfxn41n84KaeKd1Mtuxls,23
+ffmpeg_normalize/_media_file.py,sha256=E1PugUYf-SyOAbtPkJ3UHNfrJR3Ed5KaO8OOT9UHh8k,25737
+ffmpeg_normalize/_streams.py,sha256=w-gzAFUbnoLiRABckUgYqdhVgidtEATNd3di-jiP9fU,20599
+ffmpeg_normalize/_version.py,sha256=WdfJcWchCw6txwQmjH_WAwImubvfgUZlGyLcv7_k8f4,23
 ffmpeg_normalize/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ffmpeg_normalize-1.32.1.dist-info/LICENSE,sha256=mw5RQE6v4UXG_d2gYIQw9rq6jYWQCtzIs3fSm5sBSrs,1076
-ffmpeg_normalize-1.32.1.dist-info/METADATA,sha256=LXVL1zdmfILSOHbJSnvh5GY7J8DJHjBPbBfPUBrb4_M,32655
-ffmpeg_normalize-1.32.1.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
-ffmpeg_normalize-1.32.1.dist-info/entry_points.txt,sha256=X0EC5ptb0iGOxrk3Aa65dVQtvUixngLd_2-iAtSixdc,68
-ffmpeg_normalize-1.32.1.dist-info/top_level.txt,sha256=wnUkr17ckPrrU1JsxZQiXbEBUnHKsC64yck-MemEBuI,17
-ffmpeg_normalize-1.32.1.dist-info/RECORD,,
+ffmpeg_normalize-1.32.2.dist-info/LICENSE,sha256=mw5RQE6v4UXG_d2gYIQw9rq6jYWQCtzIs3fSm5sBSrs,1076
+ffmpeg_normalize-1.32.2.dist-info/METADATA,sha256=mZweBzs3rrgkjaVbr3H3jzaU4H3bMUO8MN0COu15ZTM,32758
+ffmpeg_normalize-1.32.2.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
+ffmpeg_normalize-1.32.2.dist-info/entry_points.txt,sha256=X0EC5ptb0iGOxrk3Aa65dVQtvUixngLd_2-iAtSixdc,68
+ffmpeg_normalize-1.32.2.dist-info/top_level.txt,sha256=wnUkr17ckPrrU1JsxZQiXbEBUnHKsC64yck-MemEBuI,17
+ffmpeg_normalize-1.32.2.dist-info/RECORD,,