ffmpeg-normalize 1.37.1__tar.gz → 1.37.3__tar.gz

{ffmpeg_normalize-1.37.1 → ffmpeg_normalize-1.37.3}/PKG-INFO

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

{ffmpeg_normalize-1.37.1 → ffmpeg_normalize-1.37.3}/pyproject.toml

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

{ffmpeg_normalize-1.37.1 → ffmpeg_normalize-1.37.3}/src/ffmpeg_normalize/__main__.py

@@ -197,7 +197,7 @@ def create_parser() -> argparse.ArgumentParser:
         help=textwrap.dedent(
             """\
         Write ReplayGain tags to the original file without normalizing.
-        This mode will overwrite the input file and ignore other options.
+        This mode will overwrite the input file and ignore other options. It will strip all ReplayGain tags.
         Only works with EBU normalization, and only with .mp3, .mp4/.m4a, .ogg, .opus for now.
         """
         ),
@@ -607,13 +607,17 @@ def main() -> None:
     # Handle --list-presets
     preset_manager = PresetManager()
     if cli_args.list_presets:
-        presets = preset_manager.get_available_presets()
-        if presets:
+        presets_with_source = preset_manager.get_presets_with_source()
+        if presets_with_source:
             print("Available presets:")
-            for preset in presets:
-                print(f"  - {preset}")
+            for preset_name, source in presets_with_source:
+                source_label = "(user)" if source == "user" else "(builtin)"
+                print(f"  - {preset_name} {source_label}")
         else:
-            print(f"No presets found in {preset_manager.presets_dir}")
+            print("No presets found.")
+        print()
+        print(f"User presets directory: {preset_manager.presets_dir}")
+        print("Place custom .json preset files in this directory.")
         sys.exit(0)
 
     # Load and apply preset if specified

{ffmpeg_normalize-1.37.1 → ffmpeg_normalize-1.37.3}/src/ffmpeg_normalize/_media_file.py

@@ -332,8 +332,10 @@ class MediaFile:
                 "ReplayGain tagging is enabled. Proceeding with tag calculation/application."
             )
             self._run_replaygain()
-
-        if not self.ffmpeg_normalize.replaygain:
+        else:
+            # Strip any existing ReplayGain tags from the output file
+            # since they are no longer accurate after normalization
+            self._strip_replaygain_tags(self.output_file)
             _logger.info(f"Normalized file written to {self.output_file}")
 
     def _run_replaygain(self) -> None:
@@ -461,6 +463,103 @@ class MediaFile:
             f"Successfully wrote replaygain tags to input file {self.input_file}"
         )
 
+    def _strip_replaygain_tags(self, output_file: str) -> None:
+        """
+        Strip ReplayGain tags from the output file after normalization.
+
+        This ensures that old ReplayGain tags from the input are removed,
+        since they are no longer accurate after normalization.
+
+        Args:
+            output_file (str): Path to the output file to strip tags from
+        """
+        _logger.debug(f"Stripping ReplayGain tags from {output_file}")
+
+        output_file_ext = os.path.splitext(output_file)[1]
+        if output_file_ext == ".mp3":
+            try:
+                mp3 = MP3(output_file, ID3=ID3)
+                if not mp3.tags:
+                    return
+                # Remove REPLAYGAIN_* tags
+                tags_to_remove = [
+                    key for key in mp3.tags if key.startswith("TXXX:REPLAYGAIN_")
+                ]
+                for tag in tags_to_remove:
+                    del mp3.tags[tag]
+                if tags_to_remove:
+                    mp3.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} ReplayGain tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        elif output_file_ext in [".mp4", ".m4a", ".m4v", ".mov"]:
+            try:
+                mp4 = MP4(output_file)
+                if not mp4.tags:
+                    return
+                # Remove REPLAYGAIN_* tags
+                tags_to_remove = [
+                    key
+                    for key in mp4.tags
+                    if "REPLAYGAIN_" in key.upper() or "REPLAYGAIN" in key.upper()
+                ]
+                for tag in tags_to_remove:
+                    del mp4.tags[tag]
+                if tags_to_remove:
+                    mp4.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} ReplayGain tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        elif output_file_ext == ".ogg":
+            try:
+                ogg = OggVorbis(output_file)
+                # Remove REPLAYGAIN_* tags (case-insensitive)
+                tags_to_remove = [
+                    key for key in ogg.keys() if key.upper().startswith("REPLAYGAIN_")
+                ]
+                for tag in tags_to_remove:
+                    del ogg[tag]
+                if tags_to_remove:
+                    ogg.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} ReplayGain tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        elif output_file_ext == ".opus":
+            try:
+                opus = OggOpus(output_file)
+                # Remove R128_* tags (Opus uses R128 instead of REPLAYGAIN, case-insensitive)
+                tags_to_remove = [
+                    key for key in opus.keys() if key.upper().startswith("R128_")
+                ]
+                for tag in tags_to_remove:
+                    del opus[tag]
+                if tags_to_remove:
+                    opus.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} R128 tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        else:
+            # For other formats, we don't need to strip tags
+            _logger.debug(
+                f"Skipping ReplayGain tag stripping for {output_file_ext} (not supported/needed)"
+            )
+
     def _can_write_output_video(self) -> bool:
         """
         Determine whether the output file can contain video at all.

{ffmpeg_normalize-1.37.1 → ffmpeg_normalize-1.37.3}/src/ffmpeg_normalize/_presets.py

@@ -94,6 +94,37 @@ class PresetManager:
 
         return sorted(presets)
 
+    def get_presets_with_source(self) -> list[tuple[str, str]]:
+        """Get list of available presets with their source location.
+
+        Returns:
+            list[tuple[str, str]]: List of (preset_name, source) tuples where
+            source is either "user" or "builtin"
+        """
+        user_presets: set[str] = set()
+        builtin_presets: set[str] = set()
+
+        # Get presets from user config directory
+        if self.presets_dir.exists():
+            for file in self.presets_dir.glob("*.json"):
+                user_presets.add(file.stem)
+
+        # Get default presets from package
+        if self.default_presets_dir.exists():
+            for file in self.default_presets_dir.glob("*.json"):
+                builtin_presets.add(file.stem)
+
+        result = []
+        all_presets = sorted(user_presets | builtin_presets)
+        for preset in all_presets:
+            # User presets take precedence
+            if preset in user_presets:
+                result.append((preset, "user"))
+            else:
+                result.append((preset, "builtin"))
+
+        return result
+
     def load_preset(self, preset_name: str) -> dict[str, Any]:
         """Load a preset file by name.