ffmpeg-normalize 1.33.4__py3-none-any.whl → 1.34.0__py3-none-any.whl

ffmpeg_normalize/__main__.py

@@ -315,6 +315,44 @@ def create_parser() -> argparse.ArgumentParser:
         ),
     )
 
+    group_stream_selection = parser.add_argument_group("Audio Stream Selection")
+    group_stream_selection.add_argument(
+        "-as",
+        "--audio-streams",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Select specific audio streams to normalize by stream index (comma-separated).
+        Example: --audio-streams 0,2 will normalize only streams 0 and 2.
+
+        By default, all audio streams are normalized.
+        """
+        ),
+    )
+    group_stream_selection.add_argument(
+        "--audio-default-only",
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+        Only normalize audio streams with the 'default' disposition flag.
+        This is useful for files with multiple audio tracks where only the main track
+        should be normalized (e.g., keeping commentary tracks unchanged).
+        """
+        ),
+    )
+    group_stream_selection.add_argument(
+        "--keep-other-audio",
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+        Keep non-selected audio streams in the output file (copy without normalization).
+        Only applies when --audio-streams or --audio-default-only is used.
+
+        By default, only selected streams are included in the output.
+        """
+        ),
+    )
+
     group_acodec = parser.add_argument_group("Audio Encoding")
     group_acodec.add_argument(
         "-c:a",
@@ -553,6 +591,18 @@ def main() -> None:
     extra_input_options = _split_options(cli_args.extra_input_options)
     extra_output_options = _split_options(cli_args.extra_output_options)
 
+    # parse audio streams selection
+    audio_streams = None
+    if cli_args.audio_streams:
+        try:
+            audio_streams = [int(s.strip()) for s in cli_args.audio_streams.split(",")]
+        except ValueError:
+            error("Invalid audio stream indices. Must be comma-separated integers.")
+
+    # validate stream selection options
+    if cli_args.audio_default_only and cli_args.audio_streams:
+        error("Cannot use both --audio-default-only and --audio-streams together.")
+
     ffmpeg_normalize = FFmpegNormalize(
         normalization_type=cli_args.normalization_type,
         target_level=cli_args.target_level,
@@ -586,6 +636,9 @@ def main() -> None:
         dry_run=cli_args.dry_run,
         progress=cli_args.progress,
         replaygain=cli_args.replaygain,
+        audio_streams=audio_streams,
+        audio_default_only=cli_args.audio_default_only,
+        keep_other_audio=cli_args.keep_other_audio,
     )
 
     if cli_args.output and len(cli_args.input) > len(cli_args.output):

ffmpeg_normalize/_ffmpeg_normalize.py

@@ -84,6 +84,9 @@ class FFmpegNormalize:
         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.
+        audio_streams (list[int] | None, optional): List of audio stream indices to normalize. Defaults to None (all streams).
+        audio_default_only (bool, optional): Only normalize audio streams with default disposition. Defaults to False.
+        keep_other_audio (bool, optional): Keep non-selected audio streams in output (copy without normalization). Defaults to False.
 
     Raises:
         FFmpegNormalizeError: If the ffmpeg executable is not found or does not support the loudnorm filter.
@@ -124,6 +127,9 @@ class FFmpegNormalize:
         debug: bool = False,
         progress: bool = False,
         replaygain: bool = False,
+        audio_streams: list[int] | None = None,
+        audio_default_only: bool = False,
+        keep_other_audio: bool = False,
     ):
         self.ffmpeg_exe = get_ffmpeg_exe()
         self.has_loudnorm_capabilities = ffmpeg_has_loudnorm()
@@ -207,6 +213,11 @@ class FFmpegNormalize:
         self.progress = progress
         self.replaygain = replaygain
 
+        # Stream selection options
+        self.audio_streams = audio_streams
+        self.audio_default_only = audio_default_only
+        self.keep_other_audio = keep_other_audio
+
         if (
             self.audio_codec is None or "pcm" in self.audio_codec
         ) and self.output_format in PCM_INCOMPATIBLE_FORMATS:
@@ -221,6 +232,19 @@ class FFmpegNormalize:
                 "ReplayGain only works for EBU normalization type for now."
             )
 
+        # Validate stream selection options
+        if self.audio_streams is not None and self.audio_default_only:
+            raise FFmpegNormalizeError(
+                "Cannot use both audio_streams and audio_default_only together."
+            )
+
+        if self.keep_other_audio and self.keep_original_audio:
+            raise FFmpegNormalizeError(
+                "Cannot use both --keep-other-audio and --keep-original-audio together. "
+                "Use --keep-original-audio to keep all original streams alongside normalized ones, "
+                "or --keep-other-audio to keep only non-selected streams as passthrough."
+            )
+
         self.stats: list[LoudnessStatisticsWithMetadata] = []
         self.media_files: list[MediaFile] = []
         self.file_count = 0

ffmpeg_normalize/_media_file.py

@@ -136,6 +136,18 @@ class MediaFile:
 
         output_lines = [line.strip() for line in output.split("\n")]
 
+        # First pass: parse disposition flags for each stream
+        stream_dispositions: dict[int, bool] = {}
+
+        for line in output_lines:
+            if line.startswith("Stream"):
+                if stream_id_match := re.search(r"#0:([\d]+)", line):
+                    stream_id = int(stream_id_match.group(1))
+                    # Check if (default) appears on the Stream line
+                    is_default = "(default)" in line
+                    stream_dispositions[stream_id] = is_default
+
+        # Second pass: parse stream information
         duration = None
         for line in output_lines:
             if "Duration" in line:
@@ -155,8 +167,12 @@ class MediaFile:
             else:
                 continue
 
+            is_default = stream_dispositions.get(stream_id, False)
+
             if "Audio" in line:
-                _logger.debug(f"Found audio stream at index {stream_id}")
+                _logger.debug(
+                    f"Found audio stream at index {stream_id} (default: {is_default})"
+                )
                 sample_rate_match = re.search(r"(\d+) Hz", line)
                 sample_rate = (
                     int(sample_rate_match.group(1)) if sample_rate_match else None
@@ -170,6 +186,7 @@ class MediaFile:
                     sample_rate,
                     bit_depth,
                     duration,
+                    is_default,
                 )
 
             elif "Video" in line:
@@ -201,6 +218,53 @@ class MediaFile:
             self.streams["video"] = {}
             self.streams["subtitle"] = {}
 
+    def _get_streams_to_normalize(self) -> list[AudioStream]:
+        """
+        Determine which audio streams to normalize based on configuration.
+
+        Returns:
+            list[AudioStream]: List of audio streams to normalize
+        """
+        all_audio_streams = list(self.streams["audio"].values())
+
+        if self.ffmpeg_normalize.audio_streams is not None:
+            # User specified specific stream indices
+            selected_streams = [
+                stream
+                for stream in all_audio_streams
+                if stream.stream_id in self.ffmpeg_normalize.audio_streams
+            ]
+            if not selected_streams:
+                _logger.warning(
+                    f"No audio streams found matching indices {self.ffmpeg_normalize.audio_streams}. "
+                    f"Available streams: {[s.stream_id for s in all_audio_streams]}"
+                )
+            else:
+                _logger.info(
+                    f"Normalizing selected audio streams: {[s.stream_id for s in selected_streams]}"
+                )
+            return selected_streams
+
+        elif self.ffmpeg_normalize.audio_default_only:
+            # Only normalize streams with default disposition
+            default_streams = [
+                stream for stream in all_audio_streams if stream.is_default
+            ]
+            if not default_streams:
+                _logger.warning(
+                    "No audio streams with 'default' disposition found. "
+                    f"Available streams: {[s.stream_id for s in all_audio_streams]}"
+                )
+            else:
+                _logger.info(
+                    f"Normalizing default audio streams: {[s.stream_id for s in default_streams]}"
+                )
+            return default_streams
+
+        else:
+            # Normalize all streams (default behavior)
+            return all_audio_streams
+
     def run_normalization(self) -> None:
         """
         Run the normalization process for this file.
@@ -400,7 +464,9 @@ class MediaFile:
         """
         _logger.debug(f"Parsing normalization info for {self.input_file}")
 
-        for index, audio_stream in enumerate(self.streams["audio"].values()):
+        streams_to_normalize = self._get_streams_to_normalize()
+
+        for index, audio_stream in enumerate(streams_to_normalize):
             if self.ffmpeg_normalize.normalization_type == "ebu":
                 fun = getattr(audio_stream, "parse_loudnorm_stats")
             else:
@@ -410,7 +476,7 @@ class MediaFile:
                 with tqdm(
                     total=100,
                     position=1,
-                    desc=f"Stream {index + 1}/{len(self.streams['audio'].values())}",
+                    desc=f"Stream {index + 1}/{len(streams_to_normalize)}",
                     bar_format=TQDM_BAR_FORMAT,
                 ) as pbar:
                     for progress in fun():
@@ -429,7 +495,9 @@ class MediaFile:
         filter_chains = []
         output_labels = []
 
-        for audio_stream in self.streams["audio"].values():
+        streams_to_normalize = self._get_streams_to_normalize()
+
+        for audio_stream in streams_to_normalize:
             skip_normalization = False
             if self.ffmpeg_normalize.lower_only:
                 if self.ffmpeg_normalize.normalization_type == "ebu":
@@ -551,29 +619,66 @@ class MediaFile:
                         f"The chosen output extension {self.output_ext} does not support video/cover art. It will be disabled."
                     )
 
+        # Determine streams to normalize and passthrough
+        streams_to_normalize = self._get_streams_to_normalize()
+        all_audio_streams = list(self.streams["audio"].values())
+
+        # Determine which streams to passthrough
+        if self.ffmpeg_normalize.keep_other_audio and (
+            self.ffmpeg_normalize.audio_streams is not None
+            or self.ffmpeg_normalize.audio_default_only
+        ):
+            streams_to_passthrough = [
+                s for s in all_audio_streams if s not in streams_to_normalize
+            ]
+        else:
+            streams_to_passthrough = []
+
         # ... and map the output of the normalization filters
         for ol in output_labels:
             cmd.extend(["-map", ol])
 
-        # set audio codec (never copy)
-        if self.ffmpeg_normalize.audio_codec:
-            cmd.extend(["-c:a", self.ffmpeg_normalize.audio_codec])
-        else:
-            for index, (_, audio_stream) in enumerate(self.streams["audio"].items()):
-                cmd.extend([f"-c:a:{index}", audio_stream.get_pcm_codec()])
+        # ... and map passthrough audio streams (copy without normalization)
+        for stream in streams_to_passthrough:
+            cmd.extend(["-map", f"0:{stream.stream_id}"])
 
-        # other audio options (if any)
+        # Track output audio stream index for codec assignment
+        output_audio_idx = 0
+
+        # set audio codec for normalized streams
+        for audio_stream in streams_to_normalize:
+            if self.ffmpeg_normalize.audio_codec:
+                codec = self.ffmpeg_normalize.audio_codec
+            else:
+                codec = audio_stream.get_pcm_codec()
+            cmd.extend([f"-c:a:{output_audio_idx}", codec])
+            output_audio_idx += 1
+
+        # set audio codec for passthrough streams (always copy)
+        for _ in streams_to_passthrough:
+            cmd.extend([f"-c:a:{output_audio_idx}", "copy"])
+            output_audio_idx += 1
+
+        # other audio options (if any) - only apply to normalized streams
         if self.ffmpeg_normalize.audio_bitrate:
             if self.ffmpeg_normalize.audio_codec == "libvorbis":
                 # libvorbis takes just a "-b" option, for some reason
                 # https://github.com/slhck/ffmpeg-normalize/issues/277
                 cmd.extend(["-b", str(self.ffmpeg_normalize.audio_bitrate)])
             else:
-                cmd.extend(["-b:a", str(self.ffmpeg_normalize.audio_bitrate)])
+                # Only apply to normalized streams
+                for idx in range(len(streams_to_normalize)):
+                    cmd.extend(
+                        [f"-b:a:{idx}", str(self.ffmpeg_normalize.audio_bitrate)]
+                    )
         if self.ffmpeg_normalize.sample_rate:
-            cmd.extend(["-ar", str(self.ffmpeg_normalize.sample_rate)])
+            # Only apply to normalized streams
+            for idx in range(len(streams_to_normalize)):
+                cmd.extend([f"-ar:a:{idx}", str(self.ffmpeg_normalize.sample_rate)])
         if self.ffmpeg_normalize.audio_channels:
-            cmd.extend(["-ac", str(self.ffmpeg_normalize.audio_channels)])
+            # Only apply to normalized streams
+            for idx in range(len(streams_to_normalize)):
+                cmd.extend([f"-ac:a:{idx}", str(self.ffmpeg_normalize.audio_channels)])
 
         # ... and subtitles
         if not self.ffmpeg_normalize.subtitle_disable:
@@ -583,10 +688,11 @@ class MediaFile:
             cmd.extend(["-c:s", "copy"])
 
         if self.ffmpeg_normalize.keep_original_audio:
-            highest_index = len(self.streams["audio"])
+            # Map all original audio streams after normalized and passthrough streams
             for index, _ in enumerate(self.streams["audio"].items()):
                 cmd.extend(["-map", f"0:a:{index}"])
-                cmd.extend([f"-c:a:{highest_index + index}", "copy"])
+                cmd.extend([f"-c:a:{output_audio_idx}", "copy"])
+                output_audio_idx += 1
 
         # extra options (if any)
         if self.ffmpeg_normalize.extra_output_options:
@@ -645,13 +751,14 @@ class MediaFile:
             ebu_pass_2_stats = list(
                 AudioStream.prune_and_parse_loudnorm_output(output).values()
             )
-            # Only set second pass stats if they exist (they might not if all streams were skipped with --lower-only)
-            if len(ebu_pass_2_stats) == len(self.streams["audio"]):
-                for idx, audio_stream in enumerate(self.streams["audio"].values()):
+            # Only set second pass stats for streams that were actually normalized
+            streams_to_normalize = self._get_streams_to_normalize()
+            if len(ebu_pass_2_stats) == len(streams_to_normalize):
+                for idx, audio_stream in enumerate(streams_to_normalize):
                     audio_stream.set_second_pass_stats(ebu_pass_2_stats[idx])
             else:
                 _logger.debug(
-                    f"Expected {len(self.streams['audio'])} EBU pass 2 statistics but got {len(ebu_pass_2_stats)}. "
+                    f"Expected {len(streams_to_normalize)} EBU pass 2 statistics but got {len(ebu_pass_2_stats)}. "
                     "This can happen when normalization is skipped (e.g., with --lower-only)."
                 )
 

ffmpeg_normalize/_streams.py

@@ -99,6 +99,7 @@ class AudioStream(MediaStream):
         sample_rate: int | None,
         bit_depth: int | None,
         duration: float | None,
+        is_default: bool = False,
     ):
         """
         Create an AudioStream object.
@@ -110,6 +111,7 @@ class AudioStream(MediaStream):
             sample_rate (int): sample rate in Hz
             bit_depth (int): bit depth in bits
             duration (float): duration in seconds
+            is_default (bool): Whether this stream has the default disposition flag
         """
         super().__init__(ffmpeg_normalize, media_file, "audio", stream_id)
 
@@ -124,6 +126,7 @@ class AudioStream(MediaStream):
         self.bit_depth = bit_depth
 
         self.duration = duration
+        self.is_default = is_default
 
     @staticmethod
     def _constrain(

{ffmpeg_normalize-1.33.4.dist-info → ffmpeg_normalize-1.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.33.4
+Version: 1.34.0
 Summary: Normalize audio via ffmpeg
 Keywords: ffmpeg,normalize,audio
 Author: Werner Robitza
@@ -33,7 +33,7 @@ Description-Content-Type: text/markdown
 # ffmpeg-normalize
 
 [![PyPI version](https://img.shields.io/pypi/v/ffmpeg-normalize.svg)](https://pypi.org/project/ffmpeg-normalize)
-![Docker Image Version](https://img.shields.io/docker/v/slhck/ffmpeg-normalize?sort=semver&label=Docker%20image)
+[![Docker Image Version](https://img.shields.io/docker/v/slhck/ffmpeg-normalize?sort=semver&label=Docker%20image)](https://hub.docker.com/r/slhck/ffmpeg-normalize)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/slhck/ffmpeg-normalize/python-package.yml)
 
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->

ffmpeg_normalize-1.34.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+ffmpeg_normalize/__init__.py,sha256=l0arjiMMBNbiH3IH67gT6SdZjPGAVLAdorUx38dNtvE,508
+ffmpeg_normalize/__main__.py,sha256=pn5OePgr7-P5ajO3HxTMe4yQ1NR7wru5mGMHDklkbQI,22901
+ffmpeg_normalize/_cmd_utils.py,sha256=1JspVpguAPsq7DqvyvjUNzHhVv8J3X93xNOMwito_jY,5284
+ffmpeg_normalize/_errors.py,sha256=brTQ4osJ4fTA8wnyMPVVYfGwJ0wqeShRFydTEwi_VEY,48
+ffmpeg_normalize/_ffmpeg_normalize.py,sha256=ThIglofVOXxPMZcIrrYQ03HchlIOKmVSn41qILQNgg4,13193
+ffmpeg_normalize/_logger.py,sha256=3Ap4Fxg7xGrzz7h4IGuNEf0KKstx0Rq_eLbHPrHzcrI,1841
+ffmpeg_normalize/_media_file.py,sha256=Dz5vBDOelD1-GnlKX6830UbnlwvARFo3O_O-8Zyqlmw,31214
+ffmpeg_normalize/_streams.py,sha256=V5MnTjSnvQa6BNPSoFrUu0zg6mM-b9qaZE0ltGS2FV0,22329
+ffmpeg_normalize/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ffmpeg_normalize-1.34.0.dist-info/licenses/LICENSE.md,sha256=ig-_YggmJGbPQC_gUgBNFa0_XMsuHTpocivFnlOF4tE,1082
+ffmpeg_normalize-1.34.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+ffmpeg_normalize-1.34.0.dist-info/entry_points.txt,sha256=1bdrW7-kJRc8tctjnGcfe_Fwx39z5JOm0yZnJHnmwl8,69
+ffmpeg_normalize-1.34.0.dist-info/METADATA,sha256=yoBY7Ig4p2ijd91p1NcT96URVZKZPaDWb0A0XyysIQY,11425
+ffmpeg_normalize-1.34.0.dist-info/RECORD,,

{ffmpeg_normalize-1.33.4.dist-info → ffmpeg_normalize-1.34.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.16
+Generator: uv 0.8.24
 Root-Is-Purelib: true
 Tag: py3-none-any

ffmpeg_normalize-1.33.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-ffmpeg_normalize/__init__.py,sha256=l0arjiMMBNbiH3IH67gT6SdZjPGAVLAdorUx38dNtvE,508
-ffmpeg_normalize/__main__.py,sha256=UJIaAel7DSWd0eJr0FlZupsaHvj4wwrQsWd7fmBWB8s,20965
-ffmpeg_normalize/_cmd_utils.py,sha256=1JspVpguAPsq7DqvyvjUNzHhVv8J3X93xNOMwito_jY,5284
-ffmpeg_normalize/_errors.py,sha256=brTQ4osJ4fTA8wnyMPVVYfGwJ0wqeShRFydTEwi_VEY,48
-ffmpeg_normalize/_ffmpeg_normalize.py,sha256=_ZK2P3kAM0mnxY3iCYH61T6jhMndTdO2Rqh03vJo7rY,11852
-ffmpeg_normalize/_logger.py,sha256=3Ap4Fxg7xGrzz7h4IGuNEf0KKstx0Rq_eLbHPrHzcrI,1841
-ffmpeg_normalize/_media_file.py,sha256=eJt9uNXmJheSH4B0ZZARFPMOwN0BGGXOELhcDpWmeew,26860
-ffmpeg_normalize/_streams.py,sha256=XPM539yS220cOrCz0aAiKgoIcStbBUvR4-E0J-7uyOg,22174
-ffmpeg_normalize/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ffmpeg_normalize-1.33.4.dist-info/licenses/LICENSE.md,sha256=ig-_YggmJGbPQC_gUgBNFa0_XMsuHTpocivFnlOF4tE,1082
-ffmpeg_normalize-1.33.4.dist-info/WHEEL,sha256=F3mArEuDT3LDFEqo9fCiUx6ISLN64aIhcGSiIwtu4r8,79
-ffmpeg_normalize-1.33.4.dist-info/entry_points.txt,sha256=1bdrW7-kJRc8tctjnGcfe_Fwx39z5JOm0yZnJHnmwl8,69
-ffmpeg_normalize-1.33.4.dist-info/METADATA,sha256=01HzoufSfqquEDkixSDTGiOWZq0FsU0ZmGZhM-kG_Mg,11374
-ffmpeg_normalize-1.33.4.dist-info/RECORD,,