ffmpeg-normalize 1.37.7__tar.gz → 1.38.0__tar.gz

{ffmpeg_normalize-1.37.7 → ffmpeg_normalize-1.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.37.7
+Version: 1.38.0
 Summary: Normalize audio via ffmpeg
 Keywords: ffmpeg,normalize,audio
 Author: Werner Robitza
@@ -14,7 +14,6 @@ Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
 Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -25,7 +24,7 @@ Requires-Dist: colorama>=0.4.6 ; sys_platform == 'win32'
 Requires-Dist: ffmpeg-progress-yield>=1.0.1
 Requires-Dist: colorlog==6.7.0
 Requires-Dist: mutagen>=1.47.0
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/slhck/ffmpeg-normalize
 Project-URL: Repository, https://github.com/slhck/ffmpeg-normalize
 Description-Content-Type: text/markdown
@@ -58,13 +57,15 @@ This program normalizes media files to a certain loudness level using the EBU R1
 
 ## 🚀 Quick Start
 
-1. Install a recent version of [ffmpeg](https://ffmpeg.org/download.html)
+1. Install a recent version of [ffmpeg](https://ffmpeg.org/download.html) and Python 3.10 or higher
 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.38.0 writes the normalized output  directly to the destination without using temporary files
+
 - 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:

{ffmpeg_normalize-1.37.7 → ffmpeg_normalize-1.38.0}/README.md

@@ -26,13 +26,15 @@ This program normalizes media files to a certain loudness level using the EBU R1
 
 ## 🚀 Quick Start
 
-1. Install a recent version of [ffmpeg](https://ffmpeg.org/download.html)
+1. Install a recent version of [ffmpeg](https://ffmpeg.org/download.html) and Python 3.10 or higher
 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.38.0 writes the normalized output  directly to the destination without using temporary files
+
 - 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:

{ffmpeg_normalize-1.37.7 → ffmpeg_normalize-1.38.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ffmpeg-normalize"
-version = "1.37.7"
+version = "1.38.0"
 description = "Normalize audio via ffmpeg"
 readme = "README.md"
 license = "MIT"
@@ -21,14 +21,13 @@ classifiers = [
     "Topic :: Multimedia :: Sound/Audio :: Conversion",
     "Natural Language :: English",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
     "tqdm>=4.64.1",
     "colorama>=0.4.6; platform_system=='Windows'",
@@ -50,7 +49,7 @@ package-data = {"ffmpeg_normalize" = ["data/**/*.json"]}
 
 [dependency-groups]
 dev = [
-    "pytest>=8.1.1,<9",
+    "pytest>=9.0.3",
     "ruff>=0.12.11",
     "types-tqdm",
     "shtab>=1.7.0",

{ffmpeg_normalize-1.37.7 → ffmpeg_normalize-1.38.0}/src/ffmpeg_normalize/__main__.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 import argparse
+
+# Import version from package
+import importlib.metadata
 import json
 import logging
 import os
@@ -15,9 +18,6 @@ from ._ffmpeg_normalize import NORMALIZATION_TYPES, FFmpegNormalize
 from ._logger import setup_cli_logger
 from ._presets import PresetManager
 
-# Import version from package
-import importlib.metadata
-
 __version__ = importlib.metadata.version("ffmpeg-normalize")
 
 _logger = logging.getLogger(__name__)
@@ -42,6 +42,7 @@ def create_parser() -> argparse.ArgumentParser:
               - `TMP` / `TEMP` / `TMPDIR`
                     Sets the path to the temporary directory in which files are
                     stored before being moved to the final output directory.
+                    Only valid for ReplayGain and when the input file == output file.
                     Note: You need to use full paths.
 
               - `FFMPEG_PATH`

{ffmpeg_normalize-1.37.7 → ffmpeg_normalize-1.38.0}/src/ffmpeg_normalize/_media_file.py

@@ -4,8 +4,8 @@ import logging
 import os
 import re
 import shlex
-from shutil import move, rmtree
-from tempfile import mkdtemp
+from shutil import rmtree
+from tempfile import mkdtemp, mkstemp
 from typing import TYPE_CHECKING, Iterable, Iterator, Literal, TypedDict, Union
 
 from mutagen.id3 import ID3, TXXX
@@ -297,14 +297,14 @@ class MediaFile:
                 f"Batch mode: Skipping first pass (already completed), using batch reference = {batch_reference:.2f}"
             )
 
-        # for second pass, create a temp file
-        temp_dir = mkdtemp()
-        self.temp_file = os.path.join(temp_dir, f"out.{self.output_ext}")
+        temp_dir = None
 
         if self.ffmpeg_normalize.replaygain:
             _logger.debug(
                 "ReplayGain mode: Second pass will run with temporary file to get stats."
             )
+            temp_dir = mkdtemp()
+            self.temp_file = os.path.join(temp_dir, f"out.{self.output_ext}")
             self.output_file = self.temp_file
 
         # run the second pass as a whole.
@@ -322,7 +322,7 @@ class MediaFile:
                 pass
 
         # 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):
+        if temp_dir and 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),
@@ -660,6 +660,14 @@ class MediaFile:
             if self.ffmpeg_normalize.pre_filter:
                 filter_chain.append(self.ffmpeg_normalize.pre_filter)
 
+            # Apply channel conversion before normalization so that the
+            # normalization filter operates on the same channel layout that
+            # was measured in the first pass. See issue #316.
+            if self.ffmpeg_normalize.audio_channels:
+                filter_chain.append(
+                    f"aformat=sample_fmts=fltp:channel_layouts={self.ffmpeg_normalize.audio_channels}c"
+                )
+
             filter_chain.append(normalization_filter)
 
             if self.ffmpeg_normalize.post_filter:
@@ -828,39 +836,44 @@ class MediaFile:
             yield 100
             return
 
-        # track temp_dir for cleanup
-        temp_dir = None
-        temp_file = None
+        is_in_place_overwrite = os.path.realpath(self.input_file) == os.path.realpath(
+            self.output_file
+        )
 
-        # special case: if output is a null device, write directly to it
-        if self.output_file == os.devnull:
-            cmd.append(self.output_file)
-        else:
-            temp_dir = mkdtemp()
-            temp_file = os.path.join(temp_dir, f"out.{self.output_ext}")
+        temp_file: Union[str, None] = None
+        if is_in_place_overwrite:
+            # need to create a temporary file because we cannot override
+            # the same input file
+            output_dir = os.path.dirname(self.output_file) or "."
+            fd, temp_file = mkstemp(
+                suffix=f".{self.output_ext}",
+                prefix=f".{os.path.splitext(os.path.basename(self.output_file))[0]}.",
+                dir=output_dir,
+            )
+            os.close(fd)
+            _logger.debug(
+                f"Output file is the same as the input file, "
+                f"encoding to temporary file {temp_file} first"
+            )
             cmd.append(temp_file)
+        else:
+            cmd.append(self.output_file)
 
         cmd_runner = CommandRunner()
         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}")
+            if temp_file and os.path.exists(temp_file):
+                os.remove(temp_file)
             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 temp_file
-                and not self.ffmpeg_normalize.replaygain
-            ):
+            # for in-place normalization, move the finished temp file over the input
+            if temp_file:
                 _logger.debug(
                     f"Moving temporary file from {temp_file} to {self.output_file}"
                 )
-                move(temp_file, self.output_file)
-        finally:
-            # clean up temp directory if it was created
-            if temp_dir and os.path.exists(temp_dir):
-                rmtree(temp_dir, ignore_errors=True)
+                os.replace(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

{ffmpeg_normalize-1.37.7 → ffmpeg_normalize-1.38.0}/src/ffmpeg_normalize/_streams.py

@@ -210,6 +210,10 @@ class AudioStream(MediaStream):
         Get a filter string for current_filter, with the pre-filter
         added before. Applies the input label before.
 
+        If a target channel count is set via ``audio_channels``, a channel
+        layout conversion is inserted before the analysis/normalization
+        filter so that measurements reflect the downmixed signal.
+
         Args:
             current_filter (str): The current filter.
 
@@ -220,10 +224,33 @@ class AudioStream(MediaStream):
         filter_chain = []
         if self.media_file.ffmpeg_normalize.pre_filter:
             filter_chain.append(self.media_file.ffmpeg_normalize.pre_filter)
+        channel_conversion = self._get_channel_conversion_filter()
+        if channel_conversion:
+            filter_chain.append(channel_conversion)
         filter_chain.append(current_filter)
         filter_str = input_label + ",".join(filter_chain)
         return filter_str
 
+    def _get_channel_conversion_filter(self) -> str | None:
+        """
+        Return an ``aformat`` filter string that downmixes/upmixes to the
+        requested channel count, or None if no conversion is configured.
+
+        The ``Nc`` channel-layout notation matches ffmpeg's default layout
+        selection for ``-ac N``, so the analysis pass measures the same
+        signal that the output will contain.
+
+        A float planar sample format is requested so the downmix is not
+        attenuated to fit an integer range. This is what the analysis
+        measurement should reflect, since the volume gain is applied in
+        the filter graph (where samples are also float) before being
+        written to the output codec.
+        """
+        audio_channels = self.media_file.ffmpeg_normalize.audio_channels
+        if not audio_channels:
+            return None
+        return f"aformat=sample_fmts=fltp:channel_layouts={audio_channels}c"
+
     def parse_astats(self) -> Iterator[float]:
         """
         Use ffmpeg with astats filter to get the mean (RMS) and max (peak) volume of the input file.