ffmpeg-normalize 1.35.0__py3-none-any.whl → 1.36.1__py3-none-any.whl

ffmpeg_normalize/__main__.py

@@ -13,6 +13,7 @@ from typing import NoReturn
 from ._errors import FFmpegNormalizeError
 from ._ffmpeg_normalize import NORMALIZATION_TYPES, FFmpegNormalize
 from ._logger import setup_cli_logger
+from ._presets import PresetManager
 
 # Import version from package
 import importlib.metadata
@@ -50,7 +51,7 @@ def create_parser() -> argparse.ArgumentParser:
 
             Author: Werner Robitza
             License: MIT
-            Homepage / Issues: https://github.com/slhck/ffmpeg-normalize
+            Website / Issues: https://github.com/slhck/ffmpeg-normalize
             """
         ),
     )
@@ -90,7 +91,7 @@ def create_parser() -> argparse.ArgumentParser:
             name specified.
         """
         ),
-        default="normalized",
+        default=FFmpegNormalize.DEFAULTS["output_folder"],
     )
 
     group_general = parser.add_argument_group("General Options")
@@ -124,6 +125,28 @@ def create_parser() -> argparse.ArgumentParser:
         version=f"%(prog)s v{__version__}",
         help="Print version and exit",
     )
+    group_general.add_argument(
+        "--preset",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Load options from a preset file.
+
+        Preset files are JSON files located in the presets directory.
+        The directory location depends on your OS:
+        - Linux/macOS: ~/.config/ffmpeg-normalize/presets/
+        - Windows: %%APPDATA%%/ffmpeg-normalize/presets/
+
+        Use --list-presets to see available presets.
+        CLI options specified on the command line take precedence over preset values.
+        """
+        ),
+    )
+    group_general.add_argument(
+        "--list-presets",
+        action="store_true",
+        help="List all available presets and exit",
+    )
 
     group_normalization = parser.add_argument_group("Normalization")
     group_normalization.add_argument(
@@ -144,15 +167,15 @@ def create_parser() -> argparse.ArgumentParser:
         Peak normalization brings the signal to the specified peak level.
         """
         ),
-        default="ebu",
+        default=FFmpegNormalize.DEFAULTS["normalization_type"],
     )
     group_normalization.add_argument(
         "-t",
         "--target-level",
         type=float,
         help=textwrap.dedent(
-            """\
-        Normalization target level in dB/LUFS (default: -23).
+            f"""\
+        Normalization target level in dB/LUFS (default: {FFmpegNormalize.DEFAULTS["target_level"]}).
 
         For EBU normalization, it corresponds to Integrated Loudness Target
         in LUFS. The range is -70.0 - -5.0.
@@ -160,7 +183,7 @@ def create_parser() -> argparse.ArgumentParser:
         Otherwise, the range is -99 to 0.
         """
         ),
-        default=-23.0,
+        default=FFmpegNormalize.DEFAULTS["target_level"],
     )
     group_normalization.add_argument(
         "-p",
@@ -215,12 +238,12 @@ def create_parser() -> argparse.ArgumentParser:
         "--loudness-range-target",
         type=float,
         help=textwrap.dedent(
-            """\
-        EBU Loudness Range Target in LUFS (default: 7.0).
+            f"""\
+        EBU Loudness Range Target in LUFS (default: {FFmpegNormalize.DEFAULTS["loudness_range_target"]}).
         Range is 1.0 - 50.0.
         """
         ),
-        default=7.0,
+        default=FFmpegNormalize.DEFAULTS["loudness_range_target"],
     )
 
     group_ebu.add_argument(
@@ -249,26 +272,26 @@ def create_parser() -> argparse.ArgumentParser:
         "--true-peak",
         type=float,
         help=textwrap.dedent(
-            """\
-        EBU Maximum True Peak in dBTP (default: -2.0).
+            f"""\
+        EBU Maximum True Peak in dBTP (default: {FFmpegNormalize.DEFAULTS["true_peak"]}).
         Range is -9.0 - +0.0.
         """
         ),
-        default=-2.0,
+        default=FFmpegNormalize.DEFAULTS["true_peak"],
     )
 
     group_ebu.add_argument(
         "--offset",
         type=float,
         help=textwrap.dedent(
-            """\
-        EBU Offset Gain (default: 0.0).
+            f"""\
+        EBU Offset Gain (default: {FFmpegNormalize.DEFAULTS["offset"]}).
         The gain is applied before the true-peak limiter in the first pass only.
         The offset for the second pass will be automatically determined based on the first pass statistics.
         Range is -99.0 - +99.0.
         """
         ),
-        default=0.0,
+        default=FFmpegNormalize.DEFAULTS["offset"],
     )
 
     group_ebu.add_argument(
@@ -471,7 +494,7 @@ def create_parser() -> argparse.ArgumentParser:
         Will attempt to copy video codec by default.
         """
         ),
-        default="copy",
+        default=FFmpegNormalize.DEFAULTS["video_codec"],
     )
     group_vcodec.add_argument(
         "-sn",
@@ -565,7 +588,7 @@ def create_parser() -> argparse.ArgumentParser:
         specified. (Default: `mkv`)
         """
         ),
-        default="mkv",
+        default=FFmpegNormalize.DEFAULTS["extension"],
     )
     return parser
 
@@ -581,6 +604,28 @@ def main() -> None:
             _logger.error(message)
         sys.exit(1)
 
+    # Handle --list-presets
+    preset_manager = PresetManager()
+    if cli_args.list_presets:
+        presets = preset_manager.get_available_presets()
+        if presets:
+            print("Available presets:")
+            for preset in presets:
+                print(f"  - {preset}")
+        else:
+            print(f"No presets found in {preset_manager.presets_dir}")
+        sys.exit(0)
+
+    # Load and apply preset if specified
+    if cli_args.preset:
+        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)
+            _logger.info(f"Applied preset '{cli_args.preset}'")
+        except (FileNotFoundError, json.JSONDecodeError, ValueError) as e:
+            error(str(e))
+
     def _split_options(opts: str) -> list[str]:
         """
         Parse extra options (input or output) into a list.
@@ -678,6 +723,18 @@ def main() -> None:
     if not input_files:
         error("No input files specified. Use positional arguments or --input-list.")
 
+    # Validate all input files upfront before processing
+    _logger.debug("Validating all input files before processing...")
+    validation_errors = FFmpegNormalize.validate_input_files(input_files)
+    if validation_errors:
+        _logger.error("Validation failed for the following files:")
+        for err in validation_errors:
+            _logger.error(f"  - {err}")
+        error(
+            f"Validation failed for {len(validation_errors)} file(s). "
+            "Please fix the issues above and try again."
+        )
+
     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":

ffmpeg_normalize/_cmd_utils.py

@@ -190,3 +190,76 @@ def ffmpeg_has_loudnorm() -> bool:
             "Please make sure you are running ffmpeg v4.2 or above."
         )
     return supports_loudnorm
+
+
+def validate_input_file(input_file: str) -> tuple[bool, str | None]:
+    """
+    Validate that an input file exists, is readable, and contains audio streams.
+
+    This function performs a lightweight probe of the file using ffmpeg to check
+    if it can be read and contains at least one audio stream.
+
+    Args:
+        input_file: Path to the input file to validate
+
+    Returns:
+        tuple: (is_valid, error_message)
+            - is_valid: True if the file is valid, False otherwise
+            - error_message: None if valid, otherwise a descriptive error message
+    """
+    # Check if file exists
+    if not os.path.exists(input_file):
+        return False, f"File does not exist: {input_file}"
+
+    # Check if it's actually a file (not a directory)
+    if not os.path.isfile(input_file):
+        return False, f"Path is not a file: {input_file}"
+
+    # Check if file is readable
+    if not os.access(input_file, os.R_OK):
+        return False, f"File is not readable (permission denied): {input_file}"
+
+    # Check if file has audio streams using ffmpeg probe
+    ffmpeg_exe = get_ffmpeg_exe()
+    cmd = [
+        ffmpeg_exe,
+        "-i",
+        input_file,
+        "-c",
+        "copy",
+        "-t",
+        "0",
+        "-map",
+        "0",
+        "-f",
+        "null",
+        os.devnull,
+    ]
+
+    try:
+        output = CommandRunner().run_command(cmd).get_output()
+    except RuntimeError as e:
+        error_str = str(e)
+        # Extract a cleaner error message from ffmpeg output
+        if "Invalid data found" in error_str:
+            return False, f"Invalid or corrupted media file: {input_file}"
+        if "No such file or directory" in error_str:
+            return False, f"File not found or cannot be opened: {input_file}"
+        if "Permission denied" in error_str:
+            return False, f"Permission denied when reading file: {input_file}"
+        if "does not contain any stream" in error_str:
+            return False, f"File contains no media streams: {input_file}"
+        # Generic error for other ffmpeg failures
+        return False, f"Cannot read media file: {input_file}"
+
+    # Check for audio streams in the output
+    has_audio = False
+    for line in output.split("\n"):
+        if line.strip().startswith("Stream") and "Audio" in line:
+            has_audio = True
+            break
+
+    if not has_audio:
+        return False, f"File does not contain any audio streams: {input_file}"
+
+    return True, None

ffmpeg_normalize/_ffmpeg_normalize.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, Literal
 
 from tqdm import tqdm
 
-from ._cmd_utils import ffmpeg_has_loudnorm, get_ffmpeg_exe
+from ._cmd_utils import ffmpeg_has_loudnorm, get_ffmpeg_exe, validate_input_file
 from ._errors import FFmpegNormalizeError
 from ._media_file import MediaFile
 
@@ -93,6 +93,48 @@ class FFmpegNormalize:
         FFmpegNormalizeError: If the ffmpeg executable is not found or does not support the loudnorm filter.
     """
 
+    # Default parameter values - single source of truth for all defaults
+    # Note: output_folder is a CLI-level option and not passed to FFmpegNormalize.__init__
+    DEFAULTS = {
+        "normalization_type": "ebu",
+        "target_level": -23.0,
+        "print_stats": False,
+        "loudness_range_target": 7.0,
+        "keep_loudness_range_target": False,
+        "keep_lra_above_loudness_range_target": False,
+        "true_peak": -2.0,
+        "offset": 0.0,
+        "lower_only": False,
+        "auto_lower_loudness_target": False,
+        "dual_mono": False,
+        "dynamic": False,
+        "audio_codec": "pcm_s16le",
+        "audio_bitrate": None,
+        "sample_rate": None,
+        "audio_channels": None,
+        "keep_original_audio": False,
+        "pre_filter": None,
+        "post_filter": None,
+        "video_codec": "copy",
+        "video_disable": False,
+        "subtitle_disable": False,
+        "metadata_disable": False,
+        "chapters_disable": False,
+        "extra_input_options": None,
+        "extra_output_options": None,
+        "output_format": None,
+        "output_folder": "normalized",
+        "extension": "mkv",
+        "dry_run": False,
+        "debug": False,
+        "progress": False,
+        "replaygain": False,
+        "batch": False,
+        "audio_streams": None,
+        "audio_default_only": False,
+        "keep_other_audio": False,
+    }
+
     def __init__(
         self,
         normalization_type: Literal["ebu", "rms", "peak"] = "ebu",
@@ -275,6 +317,28 @@ class FFmpegNormalize:
         self.media_files.append(MediaFile(self, input_file, output_file))
         self.file_count += 1
 
+    @staticmethod
+    def validate_input_files(input_files: list[str]) -> list[str]:
+        """
+        Validate all input files before processing.
+
+        This method checks that each input file exists, is readable, and contains
+        at least one audio stream. All files are validated upfront so that users
+        can fix all issues before rerunning the batch.
+
+        Args:
+            input_files: List of input file paths to validate
+
+        Returns:
+            list: List of error messages for invalid files. Empty if all files are valid.
+        """
+        errors = []
+        for input_file in input_files:
+            is_valid, error_msg = validate_input_file(input_file)
+            if not is_valid and error_msg:
+                errors.append(error_msg)
+        return errors
+
     def _calculate_batch_reference(self) -> float | None:
         """
         Calculate the batch reference loudness by averaging measurements across all files.

ffmpeg_normalize/_presets.py

@@ -0,0 +1,256 @@
+"""Preset management for ffmpeg-normalize."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+from ._ffmpeg_normalize import FFmpegNormalize
+
+_logger = logging.getLogger(__name__)
+
+
+def get_config_dir() -> Path:
+    """Get the platform-specific config directory for ffmpeg-normalize.
+
+    Returns:
+        Path: Configuration directory for presets
+
+    On Linux/macOS:
+        - XDG_CONFIG_HOME/ffmpeg-normalize (if XDG_CONFIG_HOME is set)
+        - ~/.config/ffmpeg-normalize (otherwise)
+
+    On Windows:
+        - %APPDATA%/ffmpeg-normalize
+    """
+    if os.name == "nt":  # Windows
+        appdata = os.getenv("APPDATA")
+        if appdata:
+            config_dir = Path(appdata) / "ffmpeg-normalize"
+        else:
+            config_dir = Path.home() / "AppData" / "Roaming" / "ffmpeg-normalize"
+    else:  # Linux/macOS
+        xdg_config = os.getenv("XDG_CONFIG_HOME")
+        if xdg_config:
+            config_dir = Path(xdg_config) / "ffmpeg-normalize"
+        else:
+            config_dir = Path.home() / ".config" / "ffmpeg-normalize"
+
+    return config_dir
+
+
+def get_presets_dir() -> Path:
+    """Get the presets directory.
+
+    Returns:
+        Path: Directory containing preset files
+    """
+    return get_config_dir() / "presets"
+
+
+def get_default_presets_dir() -> Path:
+    """Get the package default presets directory.
+
+    Returns:
+        Path: Directory containing default preset files bundled with the package
+    """
+    # Get the directory where this module is located
+    module_dir = Path(__file__).parent
+    return module_dir / "data" / "presets"
+
+
+class PresetManager:
+    """Manages loading and merging of presets with CLI arguments."""
+
+    def __init__(self) -> None:
+        """Initialize the preset manager."""
+        self.presets_dir = get_presets_dir()
+        self.default_presets_dir = get_default_presets_dir()
+
+    def get_available_presets(self) -> list[str]:
+        """Get list of available preset names.
+
+        Includes both user-installed presets and default presets from the package.
+        User presets take precedence if they have the same name.
+
+        Returns:
+            list[str]: List of available preset names (without .json extension)
+        """
+        presets = set()
+
+        # Get presets from user config directory
+        if self.presets_dir.exists():
+            for file in self.presets_dir.glob("*.json"):
+                presets.add(file.stem)
+
+        # Get default presets from package
+        if self.default_presets_dir.exists():
+            for file in self.default_presets_dir.glob("*.json"):
+                presets.add(file.stem)
+
+        return sorted(presets)
+
+    def load_preset(self, preset_name: str) -> dict[str, Any]:
+        """Load a preset file by name.
+
+        Checks user config directory first, then falls back to package defaults.
+
+        Args:
+            preset_name: Name of the preset (without .json extension)
+
+        Returns:
+            dict[str, Any]: Preset configuration as a dictionary
+
+        Raises:
+            FileNotFoundError: If preset file doesn't exist
+            json.JSONDecodeError: If preset file is invalid JSON
+        """
+        # Try user config directory first
+        preset_path = self.presets_dir / f"{preset_name}.json"
+
+        # Fall back to package default presets
+        if not preset_path.exists():
+            preset_path = self.default_presets_dir / f"{preset_name}.json"
+
+        if not preset_path.exists():
+            raise FileNotFoundError(
+                f"Preset '{preset_name}' not found. "
+                f"Available presets: {', '.join(self.get_available_presets()) or 'none'}"
+            )
+
+        try:
+            with open(preset_path, "r") as f:
+                preset_data = json.load(f)
+        except json.JSONDecodeError as e:
+            raise json.JSONDecodeError(
+                f"Invalid JSON in preset '{preset_name}': {e.msg}",
+                e.doc,
+                e.pos,
+            )
+
+        if not isinstance(preset_data, dict):
+            raise ValueError(
+                f"Preset must be a JSON object, got {type(preset_data).__name__}"
+            )
+
+        return preset_data
+
+    def merge_preset_with_args(
+        self, preset_data: dict[str, Any], cli_args: Any
+    ) -> None:
+        """Merge preset data with CLI arguments, giving precedence to CLI args.
+
+        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.
+        """
+        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:
+                setattr(cli_args, attr_name, value)
+                _logger.debug(f"Applied preset option '{key}' = {value}")
+
+    def validate_preset(self, preset_name: str) -> tuple[bool, str]:
+        """Validate that a preset file exists and is valid.
+
+        Args:
+            preset_name: Name of the preset to validate
+
+        Returns:
+            tuple[bool, str]: (is_valid, message)
+        """
+        try:
+            self.load_preset(preset_name)
+            return True, f"Preset '{preset_name}' is valid"
+        except FileNotFoundError as e:
+            return False, str(e)
+        except (json.JSONDecodeError, ValueError) as e:
+            return False, f"Error loading preset '{preset_name}': {e}"
+
+    def install_default_presets(self, force: bool = False) -> tuple[bool, str]:
+        """Install default presets to user config directory.
+
+        Args:
+            force: If True, overwrite existing presets
+
+        Returns:
+            tuple[bool, str]: (success, message)
+        """
+        try:
+            # Create presets directory if it doesn't exist
+            self.presets_dir.mkdir(parents=True, exist_ok=True)
+
+            if not self.default_presets_dir.exists():
+                return (
+                    False,
+                    f"Default presets directory not found at {self.default_presets_dir}",
+                )
+
+            # Copy all default presets
+            installed = []
+            skipped = []
+
+            for preset_file in self.default_presets_dir.glob("*.json"):
+                dest_file = self.presets_dir / preset_file.name
+
+                if dest_file.exists() and not force:
+                    skipped.append(preset_file.name)
+                else:
+                    shutil.copy2(preset_file, dest_file)
+                    installed.append(preset_file.name)
+
+            message = f"Installed {len(installed)} preset(s) to {self.presets_dir}"
+            if skipped:
+                message += f" ({len(skipped)} skipped, use --force to overwrite)"
+
+            return True, message
+
+        except Exception as e:
+            return False, f"Error installing default presets: {e}"

ffmpeg_normalize/data/presets/music.json

@@ -0,0 +1,6 @@
+{
+  "normalization-type": "rms",
+  "target-level": -20.0,
+  "batch": true,
+  "progress": true
+}

ffmpeg_normalize/data/presets/podcast.json

@@ -0,0 +1,7 @@
+{
+  "normalization-type": "ebu",
+  "target-level": -16.0,
+  "loudness-range-target": 7.0,
+  "true-peak": -2.0,
+  "progress": true
+}

ffmpeg_normalize/data/presets/streaming-video.json

@@ -0,0 +1,7 @@
+{
+  "normalization-type": "ebu",
+  "target-level": -14.0,
+  "loudness-range-target": 7.0,
+  "true-peak": -2.0,
+  "progress": true
+}

{ffmpeg_normalize-1.35.0.dist-info → ffmpeg_normalize-1.36.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.35.0
+Version: 1.36.1
 Summary: Normalize audio via ffmpeg
 Keywords: ffmpeg,normalize,audio
 Author: Werner Robitza
@@ -54,10 +54,27 @@ This program normalizes media files to a certain loudness level using the EBU R1
 - 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
+- Album Batch normalization – Process files jointly, preserving relative loudness
+
+## 🚀 Quick Start
+
+1. Install a recent version of [ffmpeg](https://ffmpeg.org/download.html)
+2. Run `pip3 install ffmpeg-normalize` and `ffmpeg-normalize /path/to/your/file.mp4`, alternatively install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) and run `uvx ffmpeg-normalize /path/to/your/file.mp4`
+3. Done! 🎧 (the normalized file will be called `normalized/file.mkv`)
+
 
 ## 🆕 What's New
 
+- Version 1.36.0 introduces **presets** with `--preset`! Save and reuse your favorite normalization configurations for different use cases. Comes with three built-in presets: `podcast` (AES standard), `music` (RMS-based batch normalization), and `streaming-video` (video content). Create custom presets too!
+
+    Example:
+
+    ```bash
+    ffmpeg-normalize input.mp3 --preset podcast
+    ```
+
+    applies the podcast preset (EBU R128, -16 LUFS) to your file. Learn more in the [presets guide](https://slhck.info/ffmpeg-normalize/usage/presets/).
+
 - 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:
@@ -89,12 +106,6 @@ Other recent additions:
 
 See the [full changelog](https://github.com/slhck/ffmpeg-normalize/blob/master/CHANGELOG.md) for all updates.
 
-## 🚀 Quick Start
-
-1. Install a recent version of [ffmpeg](https://ffmpeg.org/download.html)
-2. Run `pip3 install ffmpeg-normalize` and `ffmpeg-normalize /path/to/your/file.mp4`, alternatively install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) and run `uvx ffmpeg-normalize /path/to/your/file.mp4`
-3. Done! 🎧 (the normalized file will be called `normalized/file.mkv`)
-
 ## 📓 Documentation
 
 Check out our [documentation](https://slhck.info/ffmpeg-normalize/) for more info!

ffmpeg_normalize-1.36.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+ffmpeg_normalize/__init__.py,sha256=l0arjiMMBNbiH3IH67gT6SdZjPGAVLAdorUx38dNtvE,508
+ffmpeg_normalize/__main__.py,sha256=U77hAgn7_w2QErUEocf6tal-7v-lJR7GbUQW8L-FmC0,26357
+ffmpeg_normalize/_cmd_utils.py,sha256=nJwnV606CXZmuM8YMGZqTsgRwupSkJZn4iwXHjB8n60,7748
+ffmpeg_normalize/_errors.py,sha256=brTQ4osJ4fTA8wnyMPVVYfGwJ0wqeShRFydTEwi_VEY,48
+ffmpeg_normalize/_ffmpeg_normalize.py,sha256=tcO_nJvsNiucsCJJcMESYsb8GbThcyhniIl21JmxNn0,22190
+ffmpeg_normalize/_logger.py,sha256=3Ap4Fxg7xGrzz7h4IGuNEf0KKstx0Rq_eLbHPrHzcrI,1841
+ffmpeg_normalize/_media_file.py,sha256=awznS5C8ph6Mjy5dzwT-ubBpB3MXwbO94QFcn7mBejY,32197
+ffmpeg_normalize/_presets.py,sha256=AffqFzAHvy0GxCuJl_qd3xknncPJUQx7OXbSfYAw2xg,8852
+ffmpeg_normalize/_streams.py,sha256=4Dnzuunhqz2qsOhlDv0dKML-lLjmPmUmM7M4dpn66Ow,24910
+ffmpeg_normalize/data/presets/music.json,sha256=rKtIKAD7jlMvnGRsx6QAyPHvrGu-Ecq4M5OcZgwNphA,96
+ffmpeg_normalize/data/presets/podcast.json,sha256=spMBZ_tbfU81NF6o7ZUMyQmQ7kPz3jJ1GKH-hcRmt4s,132
+ffmpeg_normalize/data/presets/streaming-video.json,sha256=Uy4QR0kSla4vXEqctZj26-8f_eS4SQxQWQ9zI_x5QBw,132
+ffmpeg_normalize/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ffmpeg_normalize-1.36.1.dist-info/licenses/LICENSE.md,sha256=ig-_YggmJGbPQC_gUgBNFa0_XMsuHTpocivFnlOF4tE,1082
+ffmpeg_normalize-1.36.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+ffmpeg_normalize-1.36.1.dist-info/entry_points.txt,sha256=1bdrW7-kJRc8tctjnGcfe_Fwx39z5JOm0yZnJHnmwl8,69
+ffmpeg_normalize-1.36.1.dist-info/METADATA,sha256=6oOuG-z2hUURUJ0fKQAd_Oi0-3r7bHrNcZq_JSgeeUg,13935
+ffmpeg_normalize-1.36.1.dist-info/RECORD,,

ffmpeg_normalize-1.35.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-ffmpeg_normalize/__init__.py,sha256=l0arjiMMBNbiH3IH67gT6SdZjPGAVLAdorUx38dNtvE,508
-ffmpeg_normalize/__main__.py,sha256=ooM9MZRI4BfyF2G8eioY5KcumZ3jELRBkGNNchmF_ck,23788
-ffmpeg_normalize/_cmd_utils.py,sha256=1JspVpguAPsq7DqvyvjUNzHhVv8J3X93xNOMwito_jY,5284
-ffmpeg_normalize/_errors.py,sha256=brTQ4osJ4fTA8wnyMPVVYfGwJ0wqeShRFydTEwi_VEY,48
-ffmpeg_normalize/_ffmpeg_normalize.py,sha256=NvFhiiYHLJz8M78WGEIit4Qbe-XsjLlrXvzKuNMW7v8,19973
-ffmpeg_normalize/_logger.py,sha256=3Ap4Fxg7xGrzz7h4IGuNEf0KKstx0Rq_eLbHPrHzcrI,1841
-ffmpeg_normalize/_media_file.py,sha256=awznS5C8ph6Mjy5dzwT-ubBpB3MXwbO94QFcn7mBejY,32197
-ffmpeg_normalize/_streams.py,sha256=4Dnzuunhqz2qsOhlDv0dKML-lLjmPmUmM7M4dpn66Ow,24910
-ffmpeg_normalize/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ffmpeg_normalize-1.35.0.dist-info/licenses/LICENSE.md,sha256=ig-_YggmJGbPQC_gUgBNFa0_XMsuHTpocivFnlOF4tE,1082
-ffmpeg_normalize-1.35.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-ffmpeg_normalize-1.35.0.dist-info/entry_points.txt,sha256=1bdrW7-kJRc8tctjnGcfe_Fwx39z5JOm0yZnJHnmwl8,69
-ffmpeg_normalize-1.35.0.dist-info/METADATA,sha256=Z4VJQhRECSX51YKaJFQkgY5CqaPxlgd6GIlyNYRFmSU,13387
-ffmpeg_normalize-1.35.0.dist-info/RECORD,,