ffmpeg-normalize 1.37.4__tar.gz → 1.37.6__tar.gz

{ffmpeg_normalize-1.37.4 → ffmpeg_normalize-1.37.6}/PKG-INFO

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

{ffmpeg_normalize-1.37.4 → ffmpeg_normalize-1.37.6}/pyproject.toml

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

{ffmpeg_normalize-1.37.4 → ffmpeg_normalize-1.37.6}/src/ffmpeg_normalize/_media_file.py

@@ -880,17 +880,50 @@ class MediaFile:
                     "This can happen when normalization is skipped (e.g., with --lower-only)."
                 )
 
-        # warn if self.media_file.ffmpeg_normalize.dynamic == False and any of the second pass stats contain "normalization_type" == "dynamic"
+        # warn if dynamic == False and any of the second pass stats contain "normalization_type" == "dynamic"
         if self.ffmpeg_normalize.dynamic is False:
             for audio_stream in self.streams["audio"].values():
                 pass2_stats = audio_stream.get_stats()["ebu_pass2"]
                 if pass2_stats is None:
                     continue
                 if pass2_stats["normalization_type"] == "dynamic":
+                    pass1_stats = audio_stream.get_stats()["ebu_pass1"]
+
+                    reason = ""
+                    if pass1_stats is not None:
+                        linear_gain = (
+                            self.ffmpeg_normalize.target_level - pass1_stats["input_i"]
+                        )
+                        estimated_tp = pass1_stats["input_tp"] + linear_gain
+                        if estimated_tp > self.ffmpeg_normalize.true_peak:
+                            min_tp = estimated_tp
+                            max_target = (
+                                self.ffmpeg_normalize.true_peak
+                                - pass1_stats["input_tp"]
+                                + pass1_stats["input_i"]
+                            )
+                            reason = (
+                                f" Reason: the input true peak ({pass1_stats['input_tp']:.2f} dBTP) is too high — "
+                                f"after linear gain of {linear_gain:.2f} dB, "
+                                f"the estimated true peak would be {estimated_tp:.2f} dBTP, "
+                                f"exceeding the target of {self.ffmpeg_normalize.true_peak} dBTP. "
+                                f"To avoid this, raise --true-peak (-tp) to at least {min_tp:.1f}, "
+                                f"or lower the target level (-t) to at most {max_target:.1f}."
+                            )
+                        elif (
+                            pass1_stats["input_lra"]
+                            > self.ffmpeg_normalize.loudness_range_target
+                        ):
+                            reason = (
+                                f" Reason: the input loudness range ({pass1_stats['input_lra']:.2f} LU) "
+                                f"exceeds the target ({self.ffmpeg_normalize.loudness_range_target:.2f} LU). "
+                                "Consider raising the target loudness range or using "
+                                "--keep-loudness-range-target / --keep-lra-above-loudness-range-target."
+                            )
+
                     _logger.warning(
-                        "You specified linear normalization, but the loudnorm filter reverted to dynamic normalization. "
-                        "This may lead to unexpected results."
-                        "Consider your input settings, e.g. choose a lower target level or higher target loudness range."
+                        f"{self.input_file}: You specified linear normalization, but the loudnorm filter "
+                        f"reverted to dynamic normalization.{reason}"
                     )
 
         _logger.debug("Normalization finished")

{ffmpeg_normalize-1.37.4 → ffmpeg_normalize-1.37.6}/src/ffmpeg_normalize/_streams.py

@@ -201,7 +201,7 @@ class AudioStream(MediaStream):
             return f"pcm_s{self.bit_depth}le"
         else:
             _logger.warning(
-                f"Unsupported bit depth {self.bit_depth}, falling back to pcm_s16le"
+                f"{self.media_file.input_file}: Unsupported bit depth {self.bit_depth}, falling back to pcm_s16le"
             )
             return "pcm_s16le"
 
@@ -483,7 +483,7 @@ class AudioStream(MediaStream):
 
         if float(self.loudness_statistics["ebu_pass1"]["input_i"]) > 0:
             _logger.warning(
-                "Input file had measured input loudness greater than zero "
+                f"{self.media_file.input_file}: Input file had measured input loudness greater than zero "
                 f"({self.loudness_statistics['ebu_pass1']['input_i']}), capping at 0"
             )
             self.loudness_statistics["ebu_pass1"]["input_i"] = 0
@@ -497,7 +497,7 @@ class AudioStream(MediaStream):
             input_lra = self.loudness_statistics["ebu_pass1"]["input_lra"]
             if input_lra < 1 or input_lra > 50:
                 _logger.warning(
-                    "Input file had measured loudness range outside of [1,50] "
+                    f"{self.media_file.input_file}: Input file had measured loudness range outside of [1,50] "
                     f"({input_lra}), capping to allowed range"
                 )
 
@@ -527,7 +527,7 @@ class AudioStream(MediaStream):
             and not will_use_dynamic_mode
         ):
             _logger.warning(
-                f"Input file had loudness range of {self.loudness_statistics['ebu_pass1']['input_lra']}. "
+                f"{self.media_file.input_file}: Input file had loudness range of {self.loudness_statistics['ebu_pass1']['input_lra']}. "
                 f"This is larger than the loudness range target ({self.media_file.ffmpeg_normalize.loudness_range_target}). "
                 "Normalization will revert to dynamic mode. Choose a higher target loudness range if you want linear normalization. "
                 "Alternatively, use the --keep-loudness-range-target or --keep-lra-above-loudness-range-target option to keep the target loudness range from "
@@ -552,11 +552,35 @@ class AudioStream(MediaStream):
             if safe_target < self.ffmpeg_normalize.target_level:
                 target_level = safe_target
                 _logger.warning(
-                    f"Using loudness target {target_level} because --auto-lower-loudness-target given.",
+                    f"{self.media_file.input_file}: Using loudness target {target_level} because --auto-lower-loudness-target given.",
                 )
 
         stats = self.loudness_statistics["ebu_pass1"]
 
+        # Check if the true peak constraint will force dynamic mode.
+        # In linear mode, a uniform gain of (target - input_i) is applied.
+        # If that would leave the true peak above the TP limit, loudnorm
+        # cannot satisfy both constraints linearly and will fall back to
+        # dynamic processing.
+        if not will_use_dynamic_mode:
+            linear_gain = target_level - stats["input_i"]
+            estimated_tp = stats["input_tp"] + linear_gain
+            if estimated_tp > self.media_file.ffmpeg_normalize.true_peak:
+                min_tp = estimated_tp
+                max_target = (
+                    self.media_file.ffmpeg_normalize.true_peak
+                    - stats["input_tp"]
+                    + stats["input_i"]
+                )
+                _logger.warning(
+                    f"{self.media_file.input_file}: Linear normalization would result in an estimated true peak of "
+                    f"{estimated_tp:.2f} dBTP (input true peak {stats['input_tp']:.2f} dBTP + gain of {linear_gain:.2f} dB), "
+                    f"which exceeds the target true peak of {self.media_file.ffmpeg_normalize.true_peak} dBTP. "
+                    "The loudnorm filter will likely use dynamic mode instead. "
+                    f"To avoid this, raise --true-peak (-tp) to at least {min_tp:.1f}, "
+                    f"or lower the target level (-t) to at most {max_target:.1f}."
+                )
+
         # Adjust target level for batch mode to preserve relative loudness
         if batch_reference is not None:
             input_i = float(stats["input_i"])
@@ -654,6 +678,8 @@ class AudioStream(MediaStream):
 
         clip_amount = self.loudness_statistics["max"] + adjustment
         if clip_amount > 0:
-            _logger.warning(f"Adjusting will lead to clipping of {clip_amount} dB")
+            _logger.warning(
+                f"{self.media_file.input_file}: Adjusting will lead to clipping of {clip_amount} dB"
+            )
 
         return f"volume={adjustment}dB"