ffmpeg-normalize 1.32.5__py3-none-any.whl

ffmpeg_normalize/_cmd_utils.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import logging
+import os
+import re
+import shlex
+import subprocess
+from shutil import which
+from typing import Any, Iterator
+
+from ffmpeg_progress_yield import FfmpegProgress
+
+from ._errors import FFmpegNormalizeError
+
+_logger = logging.getLogger(__name__)
+
+DUR_REGEX = re.compile(
+    r"Duration: (?P<hour>\d{2}):(?P<min>\d{2}):(?P<sec>\d{2})\.(?P<ms>\d{2})"
+)
+
+
+class CommandRunner:
+    """
+    Wrapper for running ffmpeg commands
+    """
+
+    def __init__(self, dry: bool = False):
+        """Create a CommandRunner object
+
+        Args:
+            cmd: Command to run as a list of strings
+            dry: Dry run mode. Defaults to False.
+        """
+        self.dry = dry
+        self.output: str | None = None
+
+    @staticmethod
+    def prune_ffmpeg_progress_from_output(output: str) -> str:
+        """
+        Prune ffmpeg progress lines from output
+
+        Args:
+            output (str): Output from ffmpeg
+
+        Returns:
+            str: Output with progress lines removed
+        """
+        return "\n".join(
+            [
+                line
+                for line in output.splitlines()
+                if not any(
+                    key in line
+                    for key in [
+                        "bitrate=",
+                        "total_size=",
+                        "out_time_us=",
+                        "out_time_ms=",
+                        "out_time=",
+                        "dup_frames=",
+                        "drop_frames=",
+                        "speed=",
+                        "progress=",
+                    ]
+                )
+            ]
+        )
+
+    def run_ffmpeg_command(self, cmd: list[str]) -> Iterator[float]:
+        """
+        Run an ffmpeg command
+
+        Yields:
+            float: Progress percentage
+        """
+        # wrapper for 'ffmpeg-progress-yield'
+        _logger.debug(f"Running command: {shlex.join(cmd)}")
+        with FfmpegProgress(cmd, dry_run=self.dry) as ff:
+            yield from ff.run_command_with_progress()
+
+            self.output = ff.stderr
+
+        if _logger.getEffectiveLevel() == logging.DEBUG and self.output is not None:
+            _logger.debug(
+                f"ffmpeg output: {CommandRunner.prune_ffmpeg_progress_from_output(self.output)}"
+            )
+
+    def run_command(self, cmd: list[str]) -> CommandRunner:
+        """
+        Run a command with subprocess
+
+        Returns:
+            CommandRunner: itself
+
+        Raises:
+            RuntimeError: If command returns non-zero exit code
+        """
+        _logger.debug(f"Running command: {shlex.join(cmd)}")
+
+        if self.dry:
+            _logger.debug("Dry mode specified, not actually running command")
+            return self
+
+        p = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,  # Apply stdin isolation by creating separate pipe.
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=False,
+        )
+
+        stdout_bytes, stderr_bytes = p.communicate()
+
+        stdout = stdout_bytes.decode("utf8", errors="replace")
+        stderr = stderr_bytes.decode("utf8", errors="replace")
+
+        if p.returncode != 0:
+            raise RuntimeError(f"Error running command {shlex.join(cmd)}: {stderr}")
+
+        self.output = stdout + stderr
+        return self
+
+    def get_output(self) -> str:
+        if self.output is None:
+            raise FFmpegNormalizeError("Command has not been run yet")
+        return self.output
+
+
+def dict_to_filter_opts(opts: dict[str, Any]) -> str:
+    """
+    Convert a dictionary to a ffmpeg filter option string
+
+    Args:
+        opts (dict[str, Any]): Dictionary of options
+
+    Returns:
+        str: Filter option string
+    """
+    filter_opts = []
+    for k, v in opts.items():
+        filter_opts.append(f"{k}={v}")
+    return ":".join(filter_opts)
+
+
+def get_ffmpeg_exe() -> str:
+    """
+    Return path to ffmpeg executable
+
+    Returns:
+        str: Path to ffmpeg executable
+
+    Raises:
+        FFmpegNormalizeError: If ffmpeg is not found
+    """
+    if ff_path := os.getenv("FFMPEG_PATH"):
+        if os.sep in ff_path:
+            if not os.path.isfile(ff_path):
+                raise FFmpegNormalizeError(f"No file exists at {ff_path}")
+
+            return ff_path
+
+        ff_exe = which(ff_path)
+        if not ff_exe:
+            raise FFmpegNormalizeError(f"Could not find '{ff_path}' in your $PATH.")
+
+        return ff_exe
+
+    ff_path = which("ffmpeg")
+    if not ff_path:
+        raise FFmpegNormalizeError(
+            "Could not find ffmpeg in your $PATH or $FFMPEG_PATH. "
+            "Please install ffmpeg from http://ffmpeg.org"
+        )
+
+    return ff_path
+
+
+def ffmpeg_has_loudnorm() -> bool:
+    """
+    Run feature detection on ffmpeg to see if it supports the loudnorm filter.
+
+    Returns:
+        bool: True if loudnorm is supported, False otherwise
+    """
+    output = CommandRunner().run_command([get_ffmpeg_exe(), "-filters"]).get_output()
+    supports_loudnorm = "loudnorm" in output
+    if not supports_loudnorm:
+        _logger.error(
+            "Your ffmpeg does not support the 'loudnorm' filter. "
+            "Please make sure you are running ffmpeg v4.2 or above."
+        )
+    return supports_loudnorm

ffmpeg_normalize/_errors.py

@@ -0,0 +1,2 @@
+class FFmpegNormalizeError(Exception):
+    pass

ffmpeg_normalize/_ffmpeg_normalize.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+from itertools import chain
+from typing import TYPE_CHECKING, Literal
+
+from tqdm import tqdm
+
+from ._cmd_utils import ffmpeg_has_loudnorm, get_ffmpeg_exe
+from ._errors import FFmpegNormalizeError
+from ._media_file import MediaFile
+
+if TYPE_CHECKING:
+    from ._streams import LoudnessStatisticsWithMetadata
+
+_logger = logging.getLogger(__name__)
+
+NORMALIZATION_TYPES = ("ebu", "rms", "peak")
+PCM_INCOMPATIBLE_FORMATS = {"flac", "mp3", "mp4", "ogg", "oga", "opus", "webm"}
+PCM_INCOMPATIBLE_EXTS = {"flac", "mp3", "mp4", "m4a", "ogg", "oga", "opus", "webm"}
+
+
+def check_range(number: object, min_r: float, max_r: float, name: str = "") -> float:
+    """
+    Checks if "number" is an int or float and is between min_r (inclusive)
+    and max_r (inclusive).
+
+    Args:
+        number (object): Number to check
+        min_r (float): Minimum range
+        max_r (float): Maximum range
+        name (str): Name of object being checked
+
+    Returns:
+        float: within given range
+
+    Raises:
+        FFmpegNormalizeError: If number is wrong type or not within range
+    """
+    if not isinstance(number, (float, int)):
+        raise FFmpegNormalizeError(f"{name} must be an int or float")
+    if number < min_r or number > max_r:
+        raise FFmpegNormalizeError(f"{name} must be within [{min_r},{max_r}]")
+    return number
+
+
+class FFmpegNormalize:
+    """
+    ffmpeg-normalize class.
+
+    Args:
+        normalization_type (str, optional): Normalization type. Defaults to "ebu".
+        target_level (float, optional): Target level. Defaults to -23.0.
+        print_stats (bool, optional): Print loudnorm stats. Defaults to False.
+        loudness_range_target (float, optional): Loudness range target. Defaults to 7.0.
+        keep_loudness_range_target (bool, optional): Keep loudness range target. Defaults to False.
+        keep_lra_above_loudness_range_target (bool, optional): Keep input loudness range above loudness range target. Defaults to False.
+        true_peak (float, optional): True peak. Defaults to -2.0.
+        offset (float, optional): Offset. Defaults to 0.0.
+        lower_only (bool, optional): Whether the audio should not increase in loudness. Defaults to False.
+        auto_lower_loudness_target (bool, optional): Automatically lower EBU Integrated Loudness Target.
+        dual_mono (bool, optional): Dual mono. Defaults to False.
+        dynamic (bool, optional): Use dynamic EBU R128 normalization. This is a one-pass algorithm and skips the initial media scan. Defaults to False.
+        audio_codec (str, optional): Audio codec. Defaults to "pcm_s16le".
+        audio_bitrate (float, optional): Audio bitrate. Defaults to None.
+        sample_rate (int, optional): Sample rate. Defaults to None.
+        audio_channels (int | None, optional): Audio channels. Defaults to None.
+        keep_original_audio (bool, optional): Keep original audio. Defaults to False.
+        pre_filter (str, optional): Pre filter. Defaults to None.
+        post_filter (str, optional): Post filter. Defaults to None.
+        video_codec (str, optional): Video codec. Defaults to "copy".
+        video_disable (bool, optional): Disable video. Defaults to False.
+        subtitle_disable (bool, optional): Disable subtitles. Defaults to False.
+        metadata_disable (bool, optional): Disable metadata. Defaults to False.
+        chapters_disable (bool, optional): Disable chapters. Defaults to False.
+        extra_input_options (list, optional): Extra input options. Defaults to None.
+        extra_output_options (list, optional): Extra output options. Defaults to None.
+        output_format (str, optional): Output format. Defaults to None.
+        extension (str, optional): Output file extension to use for output files that were not explicitly specified. Defaults to "mkv".
+        dry_run (bool, optional): Dry run. Defaults to False.
+        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.
+
+    Raises:
+        FFmpegNormalizeError: If the ffmpeg executable is not found or does not support the loudnorm filter.
+    """
+
+    def __init__(
+        self,
+        normalization_type: Literal["ebu", "rms", "peak"] = "ebu",
+        target_level: float = -23.0,
+        print_stats: bool = False,
+        # threshold=0.5,
+        loudness_range_target: float = 7.0,
+        keep_loudness_range_target: bool = False,
+        keep_lra_above_loudness_range_target: bool = False,
+        true_peak: float = -2.0,
+        offset: float = 0.0,
+        lower_only: bool = False,
+        auto_lower_loudness_target: bool = False,
+        dual_mono: bool = False,
+        dynamic: bool = False,
+        audio_codec: str = "pcm_s16le",
+        audio_bitrate: float | None = None,
+        sample_rate: float | int | None = None,
+        audio_channels: int | None = None,
+        keep_original_audio: bool = False,
+        pre_filter: str | None = None,
+        post_filter: str | None = None,
+        video_codec: str = "copy",
+        video_disable: bool = False,
+        subtitle_disable: bool = False,
+        metadata_disable: bool = False,
+        chapters_disable: bool = False,
+        extra_input_options: list[str] | None = None,
+        extra_output_options: list[str] | None = None,
+        output_format: str | None = None,
+        extension: str = "mkv",
+        dry_run: bool = False,
+        debug: bool = False,
+        progress: bool = False,
+        replaygain: bool = False,
+    ):
+        self.ffmpeg_exe = get_ffmpeg_exe()
+        self.has_loudnorm_capabilities = ffmpeg_has_loudnorm()
+
+        if normalization_type not in NORMALIZATION_TYPES:
+            raise FFmpegNormalizeError(
+                "Normalization type must be: 'ebu', 'rms', or 'peak'"
+            )
+        self.normalization_type = normalization_type
+
+        if not self.has_loudnorm_capabilities and self.normalization_type == "ebu":
+            raise FFmpegNormalizeError(
+                "Your ffmpeg does not support the 'loudnorm' EBU R128 filter. "
+                "Please install ffmpeg v4.2 or above, or choose another normalization type."
+            )
+
+        if self.normalization_type == "ebu":
+            self.target_level = check_range(target_level, -70, -5, name="target_level")
+        else:
+            self.target_level = check_range(target_level, -99, 0, name="target_level")
+
+        self.print_stats = print_stats
+
+        # self.threshold = float(threshold)
+
+        self.loudness_range_target = check_range(
+            loudness_range_target, 1, 50, name="loudness_range_target"
+        )
+
+        self.keep_loudness_range_target = keep_loudness_range_target
+
+        if self.keep_loudness_range_target and loudness_range_target != 7.0:
+            _logger.warning(
+                "Setting --keep-loudness-range-target will override your set loudness range target value! "
+                "Remove --keep-loudness-range-target or remove the --lrt/--loudness-range-target option."
+            )
+
+        self.keep_lra_above_loudness_range_target = keep_lra_above_loudness_range_target
+
+        if (
+            self.keep_loudness_range_target
+            and self.keep_lra_above_loudness_range_target
+        ):
+            raise FFmpegNormalizeError(
+                "Options --keep-loudness-range-target and --keep-lra-above-loudness-range-target are mutually exclusive! "
+                "Please choose just one of the two options."
+            )
+
+        self.true_peak = check_range(true_peak, -9, 0, name="true_peak")
+        self.offset = check_range(offset, -99, 99, name="offset")
+        self.lower_only = lower_only
+        self.auto_lower_loudness_target = auto_lower_loudness_target
+
+        # Ensure library user is passing correct types
+        assert isinstance(dual_mono, bool), "dual_mono must be bool"
+        assert isinstance(dynamic, bool), "dynamic must be bool"
+
+        self.dual_mono = dual_mono
+        self.dynamic = dynamic
+        self.sample_rate = None if sample_rate is None else int(sample_rate)
+        self.audio_channels = None if audio_channels is None else int(audio_channels)
+
+        self.audio_codec = audio_codec
+        self.audio_bitrate = audio_bitrate
+        self.keep_original_audio = keep_original_audio
+        self.video_codec = video_codec
+        self.video_disable = video_disable
+        self.subtitle_disable = subtitle_disable
+        self.metadata_disable = metadata_disable
+        self.chapters_disable = chapters_disable
+
+        self.extra_input_options = extra_input_options
+        self.extra_output_options = extra_output_options
+        self.pre_filter = pre_filter
+        self.post_filter = post_filter
+
+        self.output_format = output_format
+        self.extension = extension
+        self.dry_run = dry_run
+        self.debug = debug
+        self.progress = progress
+        self.replaygain = replaygain
+
+        if (
+            self.audio_codec is None or "pcm" in self.audio_codec
+        ) and self.output_format in PCM_INCOMPATIBLE_FORMATS:
+            raise FFmpegNormalizeError(
+                f"Output format {self.output_format} does not support PCM audio. "
+                "Please choose a suitable audio codec with the -c:a option."
+            )
+
+        # replaygain only works for EBU for now
+        if self.replaygain and self.normalization_type != "ebu":
+            raise FFmpegNormalizeError(
+                "ReplayGain only works for EBU normalization type for now."
+            )
+
+        self.stats: list[LoudnessStatisticsWithMetadata] = []
+        self.media_files: list[MediaFile] = []
+        self.file_count = 0
+
+    def add_media_file(self, input_file: str, output_file: str) -> None:
+        """
+        Add a media file to normalize
+
+        Args:
+            input_file (str): Path to input file
+            output_file (str): Path to output file
+        """
+        if not os.path.exists(input_file):
+            raise FFmpegNormalizeError(f"file {input_file} does not exist")
+
+        ext = os.path.splitext(output_file)[1][1:]
+        if (
+            self.audio_codec is None or "pcm" in self.audio_codec
+        ) and ext in PCM_INCOMPATIBLE_EXTS:
+            raise FFmpegNormalizeError(
+                f"Output extension {ext} does not support PCM audio. "
+                "Please choose a suitable audio codec with the -c:a option."
+            )
+
+        self.media_files.append(MediaFile(self, input_file, output_file))
+        self.file_count += 1
+
+    def run_normalization(self) -> None:
+        """
+        Run the normalization procedures
+        """
+        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:
+                    # 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
+
+        if self.print_stats:
+            json.dump(
+                list(
+                    chain.from_iterable(
+                        media_file.get_stats() for media_file in self.media_files
+                    )
+                ),
+                sys.stdout,
+                indent=4,
+            )
+            print()

ffmpeg_normalize/_logger.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+import colorlog
+from tqdm import tqdm
+
+from ffmpeg_normalize import __module_name__ as LOGGER_NAME
+
+
+# https://stackoverflow.com/questions/38543506/
+class TqdmLoggingHandler(logging.StreamHandler):
+    def __init__(self) -> None:
+        super().__init__(sys.stderr)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+            set_mp_lock()
+            tqdm.write(msg, file=sys.stderr)
+            self.flush()
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            self.handleError(record)
+
+
+def set_mp_lock() -> None:
+    try:
+        from multiprocessing import Lock
+
+        tqdm.set_lock(Lock())
+    except (ImportError, OSError):
+        # Some python environments do not support multiprocessing
+        # See: https://github.com/slhck/ffmpeg-normalize/issues/156
+        pass
+
+
+def setup_cli_logger(arguments: argparse.Namespace) -> None:
+    """Configurs the CLI logger.
+
+    Args:
+        arguments (argparse.Namespace): The CLI arguments.
+    """
+
+    logger = colorlog.getLogger(LOGGER_NAME)
+
+    handler = TqdmLoggingHandler()
+    handler.setFormatter(
+        colorlog.ColoredFormatter(
+            "%(log_color)s%(levelname)s: %(message)s",
+            log_colors={
+                "DEBUG": "cyan",
+                "INFO": "green",
+                "WARNING": "yellow",
+                "ERROR": "red",
+                "CRITICAL": "red,bg_white",
+            },
+        )
+    )
+    logger.addHandler(handler)
+
+    logger.setLevel(logging.WARNING)
+
+    if arguments.quiet:
+        logger.setLevel(logging.ERROR)
+    elif arguments.debug:
+        logger.setLevel(logging.DEBUG)
+    elif arguments.verbose:
+        logger.setLevel(logging.INFO)