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

ffmpeg_normalize/__main__.py

@@ -179,6 +179,24 @@ def create_parser() -> argparse.ArgumentParser:
         """
         ),
     )
+    group_normalization.add_argument(
+        "--batch",
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+        Preserve relative loudness between files (album mode).
+
+        When operating on a group of unrelated files, you usually want all of them at the same
+        level. However, a group of music files all from the same album is generally meant to be
+        listened to at the relative volumes they were recorded at. In batch mode, all the specified
+        files are considered to be part of a single album and their relative volumes are preserved.
+        This is done by averaging the loudness of all the files, computing a single adjustment from
+        that, and applying a relative adjustment to all the files.
+
+        Batch mode works with all normalization types (EBU, RMS, peak).
+        """
+        ),
+    )
 
     # group_normalization.add_argument(
     #     '--threshold',
@@ -315,6 +333,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 +609,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 +654,10 @@ def main() -> None:
         dry_run=cli_args.dry_run,
         progress=cli_args.progress,
         replaygain=cli_args.replaygain,
+        batch=cli_args.batch,
+        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,10 @@ 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.
+        batch (bool, optional): Preserve relative loudness between files (album mode). 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 +128,10 @@ class FFmpegNormalize:
         debug: bool = False,
         progress: bool = False,
         replaygain: bool = False,
+        batch: 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()
@@ -206,6 +214,12 @@ class FFmpegNormalize:
         self.debug = debug
         self.progress = progress
         self.replaygain = replaygain
+        self.batch = batch
+
+        # 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
@@ -221,6 +235,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
@@ -248,29 +275,172 @@ class FFmpegNormalize:
         self.media_files.append(MediaFile(self, input_file, output_file))
         self.file_count += 1
 
+    def _calculate_batch_reference(self) -> float | None:
+        """
+        Calculate the batch reference loudness by averaging measurements across all files.
+
+        Returns:
+            float | None: The batch reference loudness value, or None if no measurements found.
+
+        Note:
+            TODO: Add option to specify different averaging methods (duration-weighted,
+            use quietest/loudest track, etc.)
+        """
+        measurements: list[float] = []
+
+        for media_file in self.media_files:
+            # Access audio streams from the streams dict
+            audio_streams = media_file.streams.get("audio", {})
+            for stream in audio_streams.values():
+                if self.normalization_type == "ebu":
+                    # Get EBU integrated loudness from first pass
+                    ebu_stats = stream.loudness_statistics.get("ebu_pass1")
+                    if ebu_stats and "input_i" in ebu_stats:
+                        measurements.append(float(ebu_stats["input_i"]))
+                elif self.normalization_type == "rms":
+                    # Get RMS mean value
+                    mean = stream.loudness_statistics.get("mean")
+                    if mean is not None:
+                        measurements.append(float(mean))
+                elif self.normalization_type == "peak":
+                    # Get peak max value
+                    max_val = stream.loudness_statistics.get("max")
+                    if max_val is not None:
+                        measurements.append(float(max_val))
+
+        if not measurements:
+            _logger.warning(
+                "No loudness measurements found for batch reference calculation. "
+                "Batch mode will not be applied."
+            )
+            return None
+
+        # Simple average of all measurements
+        batch_reference = sum(measurements) / len(measurements)
+        _logger.debug(f"Batch mode: Measurements for batch reference: {measurements}")
+        _logger.info(
+            f"Batch mode: Calculated reference loudness = {batch_reference:.2f} "
+            f"({self.normalization_type.upper()}, averaged from {len(measurements)} stream(s))"
+        )
+
+        return batch_reference
+
     def run_normalization(self) -> None:
         """
-        Run the normalization procedures
+        Run the normalization procedures.
+
+        In batch mode, all files are analyzed first (first pass), then a batch reference
+        loudness is calculated, and finally all files are normalized (second pass) with
+        adjustments relative to the batch reference to preserve relative loudness.
+
+        In non-batch mode, each file is processed completely (both passes) before
+        moving to the next file.
         """
-        for index, media_file in enumerate(
-            tqdm(self.media_files, desc="File", disable=not self.progress, position=0)
-        ):
+        if self.batch:
+            # Batch mode: analyze all files first, then normalize with relative adjustments
             _logger.info(
-                f"Normalizing file {media_file} ({index + 1} of {self.file_count})"
+                f"Batch mode enabled: processing {self.file_count} file(s) while preserving relative loudness"
             )
 
-            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
+            # Recommend RMS/Peak for album normalization instead of EBU
+            if self.normalization_type == "ebu":
+                _logger.warning(
+                    "Using EBU R128 normalization with --batch. For true album normalization where "
+                    "all tracks are shifted by the same amount, consider using --normalization-type rms "
+                    "or --normalization-type peak instead. EBU normalization applies different processing "
+                    "to each track based on its loudness characteristics, which may alter relative levels "
+                    "slightly due to psychoacoustic adjustments."
+                )
+
+            # Warn if using dynamic EBU mode with batch
+            if self.dynamic and self.normalization_type == "ebu":
+                _logger.warning(
+                    "ffmpeg uses dynamic EBU normalization. This may change relative "
+                    "loudness within a file. Use linear mode for true album normalization, or "
+                    "switch to --normalization-type peak or --normalization-type rms instead. "
+                    "To force linear mode, use --keep-lra-above-loudness-range-target or "
+                    "--keep-loudness-range-target."
+                )
+
+            # Phase 1: Run first pass on all files to collect measurements
+            _logger.info("Phase 1: Analyzing all files...")
+            for index, media_file in enumerate(
+                tqdm(
+                    self.media_files,
+                    desc="Analysis",
+                    disable=not self.progress,
+                    position=0,
+                )
+            ):
+                _logger.info(
+                    f"Analyzing file {media_file} ({index + 1} of {self.file_count})"
+                )
+
+                try:
+                    # Only run first pass if not in dynamic EBU mode
+                    if not (self.dynamic and self.normalization_type == "ebu"):
+                        media_file._first_pass()
+                    else:
+                        _logger.debug(
+                            "Dynamic EBU mode: First pass skipped for this file."
+                        )
+                except Exception as e:
+                    if len(self.media_files) > 1:
+                        _logger.error(
+                            f"Error analyzing input file {media_file}, will "
+                            f"continue batch-processing. Error was: {e}"
+                        )
+                    else:
+                        raise e
+
+            # Phase 2: Calculate batch reference loudness
+            batch_reference = self._calculate_batch_reference()
+
+            # Phase 3: Run second pass on all files with batch reference
+            _logger.info("Phase 2: Normalizing all files...")
+            for index, media_file in enumerate(
+                tqdm(
+                    self.media_files,
+                    desc="Normalization",
+                    disable=not self.progress,
+                    position=0,
+                )
+            ):
+                _logger.info(
+                    f"Normalizing file {media_file} ({index + 1} of {self.file_count})"
+                )
+
+                try:
+                    media_file.run_normalization(batch_reference=batch_reference)
+                except Exception as e:
+                    if len(self.media_files) > 1:
+                        _logger.error(
+                            f"Error processing input file {media_file}, will "
+                            f"continue batch-processing. Error was: {e}"
+                        )
+                    else:
+                        raise e
+        else:
+            # Non-batch mode: process each file completely before moving to the next
+            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:
+                        _logger.error(
+                            f"Error processing input file {media_file}, will "
+                            f"continue batch-processing. Error was: {e}"
+                        )
+                    else:
+                        raise e
 
         if self.print_stats:
             json.dump(

ffmpeg_normalize/_media_file.py

@@ -86,6 +86,7 @@ class MediaFile:
             self.output_ext = current_ext
         self.streams: StreamDict = {"audio": {}, "video": {}, "subtitle": {}}
         self.temp_file: Union[str, None] = None
+        self.batch_reference: float | None = None
 
         self.parse_streams()
 
@@ -136,6 +137,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 +168,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 +187,7 @@ class MediaFile:
                     sample_rate,
                     bit_depth,
                     duration,
+                    is_default,
                 )
 
             elif "Video" in line:
@@ -201,21 +219,82 @@ class MediaFile:
             self.streams["video"] = {}
             self.streams["subtitle"] = {}
 
-    def run_normalization(self) -> None:
+    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, batch_reference: float | None = None) -> None:
         """
         Run the normalization process for this file.
+
+        Args:
+            batch_reference (float | None, optional): Reference loudness for batch mode.
+                If provided, the first pass is skipped (assumed already done) and this
+                reference is used to calculate relative adjustments. Defaults to None.
         """
         _logger.debug(f"Running normalization for {self.input_file}")
 
-        # run the first pass to get loudness stats, unless in dynamic EBU mode
-        if not (
-            self.ffmpeg_normalize.dynamic
-            and self.ffmpeg_normalize.normalization_type == "ebu"
-        ):
-            self._first_pass()
+        # Store batch reference for use in second pass
+        self.batch_reference = batch_reference
+
+        # run the first pass to get loudness stats, unless in dynamic EBU mode or batch mode
+        # (in batch mode, first pass is already done in FFmpegNormalize.run_normalization)
+        if batch_reference is None:
+            if not (
+                self.ffmpeg_normalize.dynamic
+                and self.ffmpeg_normalize.normalization_type == "ebu"
+            ):
+                self._first_pass()
+            else:
+                _logger.debug(
+                    "Dynamic EBU mode: First pass will not run, as it is not needed."
+                )
         else:
             _logger.debug(
-                "Dynamic EBU mode: First pass will not run, as it is not needed."
+                f"Batch mode: Skipping first pass (already completed), using batch reference = {batch_reference:.2f}"
             )
 
         # for second pass, create a temp file
@@ -400,7 +479,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 +491,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 +510,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":
@@ -461,9 +544,13 @@ class MediaFile:
                 normalization_filter = "acopy"
             else:
                 if self.ffmpeg_normalize.normalization_type == "ebu":
-                    normalization_filter = audio_stream.get_second_pass_opts_ebu()
+                    normalization_filter = audio_stream.get_second_pass_opts_ebu(
+                        batch_reference=self.batch_reference
+                    )
                 else:
-                    normalization_filter = audio_stream.get_second_pass_opts_peakrms()
+                    normalization_filter = audio_stream.get_second_pass_opts_peakrms(
+                        batch_reference=self.batch_reference
+                    )
 
             input_label = f"[0:{audio_stream.stream_id}]"
             output_label = f"[norm{audio_stream.stream_id}]"
@@ -551,29 +638,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}"])
+
+        # Track output audio stream index for codec assignment
+        output_audio_idx = 0
 
-        # other audio options (if any)
+        # 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 +707,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 +770,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(
@@ -441,9 +444,14 @@ class AudioStream(MediaStream):
                         )
         return result
 
-    def get_second_pass_opts_ebu(self) -> str:
+    def get_second_pass_opts_ebu(self, batch_reference: float | None = None) -> str:
         """
         Return second pass loudnorm filter options string for ffmpeg
+
+        Args:
+            batch_reference (float | None, optional): Reference loudness for batch mode.
+                When provided, the target level is adjusted to preserve relative loudness.
+                Defaults to None.
         """
 
         # In dynamic mode, we can do everything in one pass, and we do not have first pass stats
@@ -549,6 +557,19 @@ class AudioStream(MediaStream):
 
         stats = self.loudness_statistics["ebu_pass1"]
 
+        # Adjust target level for batch mode to preserve relative loudness
+        if batch_reference is not None:
+            input_i = float(stats["input_i"])
+            # Formula: adjusted_target = target_level + (input_i - batch_reference)
+            # If track is quieter than average (input_i < batch_ref), offset is negative → quieter target
+            # If track is louder than average (input_i > batch_ref), offset is positive → louder target
+            adjusted_target = target_level + (input_i - batch_reference)
+            _logger.info(
+                f"Batch mode: Adjusting target from {target_level:.2f} to {adjusted_target:.2f} LUFS "
+                f"(input_i={input_i:.2f}, batch_ref={batch_reference:.2f}, offset={input_i - batch_reference:.2f})"
+            )
+            target_level = adjusted_target
+
         opts = {
             "i": target_level,
             "lra": self.media_file.ffmpeg_normalize.loudness_range_target,
@@ -573,11 +594,16 @@ class AudioStream(MediaStream):
 
         return "loudnorm=" + dict_to_filter_opts(opts)
 
-    def get_second_pass_opts_peakrms(self) -> str:
+    def get_second_pass_opts_peakrms(self, batch_reference: float | None = None) -> str:
         """
         Set the adjustment gain based on chosen option and mean/max volume,
         return the matching ffmpeg volume filter.
 
+        Args:
+            batch_reference (float | None, optional): Reference loudness for batch mode.
+                When provided, the target level is adjusted to preserve relative loudness.
+                Defaults to None.
+
         Returns:
             str: ffmpeg volume filter string
         """
@@ -592,6 +618,27 @@ class AudioStream(MediaStream):
         normalization_type = self.media_file.ffmpeg_normalize.normalization_type
         target_level = self.media_file.ffmpeg_normalize.target_level
 
+        # Adjust target level for batch mode to preserve relative loudness
+        if batch_reference is not None:
+            if normalization_type == "peak":
+                measured_level = float(self.loudness_statistics["max"])
+            elif normalization_type == "rms":
+                measured_level = float(self.loudness_statistics["mean"])
+            else:
+                raise FFmpegNormalizeError(
+                    "Can only set adjustment for peak and RMS normalization"
+                )
+
+            # Formula: adjusted_target = target_level + (measured_level - batch_reference)
+            # If track is quieter than average (measured < batch_ref), offset is negative → quieter target
+            # If track is louder than average (measured > batch_ref), offset is positive → louder target
+            adjusted_target = target_level + (measured_level - batch_reference)
+            _logger.info(
+                f"Batch mode: Adjusting target from {target_level:.2f} to {adjusted_target:.2f} dB "
+                f"(measured={measured_level:.2f}, batch_ref={batch_reference:.2f}, offset={measured_level - batch_reference:.2f})"
+            )
+            target_level = adjusted_target
+
         if normalization_type == "peak":
             adjustment = 0 + target_level - self.loudness_statistics["max"]
         elif normalization_type == "rms":

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.33.4
+Version: 1.35.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 -->
@@ -46,12 +46,48 @@ This program normalizes media files to a certain loudness level using the EBU R1
 
 ## ✨ Features
 
-- EBU R128 loudness normalization (two-pass by default, with an option for one-pass dynamic normalization)
-- RMS-based normalization
-- Peak normalization
-- Video file support
-- Docker support
-- Python API
+- EBU R128 loudness normalization — Two-pass by default, with an option for one-pass dynamic normalization
+- RMS-based normalization — Adjust audio to a specific RMS level
+- Peak normalization — Adjust audio to a specific peak level
+- Selective audio stream normalization — Normalize specific audio streams or only default streams
+- Video file support — Process video files while preserving video streams
+- 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
+
+## 🆕 What's New
+
+- 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:
+
+    ```bash
+    ffmpeg-normalize album/*.flac --batch -nt rms -t -20
+    ```
+
+    shifts the entire album so the average RMS is -20 dB, preserving the original relative loudness as mastered.
+
+- Version 1.34.0 brings **selective audio stream normalization**! You can now:
+
+  - Normalize specific audio streams with `-as/--audio-streams` (e.g., `-as 1,2` to normalize only streams 1 and 2)
+  - Normalize only default audio streams with `--audio-default-only` (useful for files with multiple language tracks)
+  - Keep other streams unchanged with `--keep-other-audio` (copy non-selected streams without normalization)
+
+    Example:
+
+    ```bash
+    ffmpeg-normalize input.mkv -as 1 --keep-other-audio
+    ```
+
+    normalizes stream 1 and copies all other audio streams unchanged.
+
+Other recent additions:
+
+- **Shell completions** (v1.31.0) — Tab completion for bash, zsh, and fish shells. See the [installation guide](https://slhck.info/ffmpeg-normalize/getting-started/installation/#shell-completions) for setup instructions.
+- **`--lower-only` option** — Prevent audio from increasing in loudness, only lower it if needed (works with all normalization types).
+
+See the [full changelog](https://github.com/slhck/ffmpeg-normalize/blob/master/CHANGELOG.md) for all updates.
 
 ## 🚀 Quick Start
 

ffmpeg_normalize-1.35.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+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,,

{ffmpeg_normalize-1.33.4.dist-info → ffmpeg_normalize-1.35.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,,