auto-editor 26.3.3__py3-none-any.whl → 27.0.0__py3-none-any.whl

auto_editor/edit.py

@@ -8,8 +8,8 @@ from os.path import splitext
 from subprocess import run
 from typing import TYPE_CHECKING, Any
 
-import av
-from av import AudioResampler, Codec
+import bv
+from bv import AudioResampler, Codec
 
 from auto_editor.ffwrapper import FileInfo, initFileInfo
 from auto_editor.lib.contracts import is_int, is_str
@@ -83,18 +83,10 @@ def set_video_codec(
             return ctr.default_vid
         return codec
 
-    if codec == "copy":
-        log.deprecated("The `copy` codec is deprecated. auto-editor always re-encodes")
-        if src is None:
-            log.error("No input to copy its codec from.")
-        if not src.videos:
-            log.error("Input file does not have a video stream to copy codec from.")
-        codec = src.videos[0].codec
-
     if ctr.vcodecs is not None and codec not in ctr.vcodecs:
         try:
             cobj = Codec(codec, "w")
-        except av.codec.codec.UnknownCodecError:
+        except bv.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
         if cobj.id not in (Codec(x, "w").id for x in ctr.vcodecs):
@@ -111,7 +103,7 @@ def set_audio_codec(
             codec = "aac"
         else:
             codec = src.audios[0].codec
-            if av.Codec(codec, "w").audio_formats is None:
+            if bv.Codec(codec, "w").audio_formats is None:
                 codec = "aac"
         if codec not in ctr.acodecs and ctr.default_aud != "none":
             codec = ctr.default_aud
@@ -119,18 +111,10 @@ def set_audio_codec(
             codec = "aac"
         return codec
 
-    if codec == "copy":
-        log.deprecated("The `copy` codec is deprecated. auto-editor always re-encodes")
-        if src is None:
-            log.error("No input to copy its codec from.")
-        if not src.audios:
-            log.error("Input file does not have an audio stream to copy codec from.")
-        codec = src.audios[0].codec
-
     if ctr.acodecs is None or codec not in ctr.acodecs:
         try:
             cobj = Codec(codec, "w")
-        except av.codec.codec.UnknownCodecError:
+        except bv.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
         if cobj.id not in (Codec(x, "w").id for x in ctr.acodecs):
@@ -178,6 +162,10 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     bar = initBar(args.progress)
     tl = None
 
+    if args.keep_tracks_separate:
+        log.deprecated("--keep-tracks-separate is deprecated.")
+        args.keep_tracks_separate = False
+
     if paths:
         path_ext = splitext(paths[0])[1].lower()
         if path_ext == ".xml":
@@ -289,9 +277,6 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     args.video_codec = set_video_codec(args.video_codec, src, out_ext, ctr, log)
     args.audio_codec = set_audio_codec(args.audio_codec, src, out_ext, ctr, log)
 
-    if args.keep_tracks_separate and ctr.max_audios == 1:
-        log.warning(f"'{out_ext}' container doesn't support multiple audio tracks.")
-
     def make_media(tl: v3, output_path: str) -> None:
         assert src is not None
 
@@ -307,38 +292,38 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         if mov_flags:
             options["movflags"] = "+".join(mov_flags)
 
-        output = av.open(output_path, "w", container_options=options)
+        output = bv.open(output_path, "w", container_options=options)
 
-        if ctr.default_sub != "none" and not args.sn:
-            sub_paths = make_new_subtitles(tl, log)
+        # Setup video
+        if ctr.default_vid != "none" and tl.v:
+            vframes = render_av(output, tl, args, log)
+            output_stream: bv.VideoStream | None
+            output_stream = next(vframes)  # type: ignore
         else:
-            sub_paths = []
+            output_stream, vframes = None, iter([])
 
+        # Setup audio
         if ctr.default_aud != "none":
             ensure = Ensure(bar, samplerate, log)
             audio_paths = make_new_audio(tl, ctr, ensure, args, bar, log)
         else:
             audio_paths = []
 
-        # Setup video
-        if ctr.default_vid != "none" and tl.v:
-            vframes = render_av(output, tl, args, log)
-            output_stream = next(vframes)
-        else:
-            output_stream, vframes = None, iter([])
+        if len(audio_paths) > 1 and ctr.max_audios == 1:
+            log.warning("Dropping extra audio streams (container only allows one)")
+            audio_paths = audio_paths[0:1]
 
-        # Setup audio
         if audio_paths:
             try:
-                audio_encoder = av.Codec(args.audio_codec, "w")
-            except av.FFmpegError as e:
+                audio_encoder = bv.Codec(args.audio_codec, "w")
+            except bv.FFmpegError as e:
                 log.error(e)
             if audio_encoder.audio_formats is None:
                 log.error(f"{args.audio_codec}: No known audio formats avail.")
             audio_format = audio_encoder.audio_formats[0]
             resampler = AudioResampler(format=audio_format, layout="stereo", rate=tl.sr)
 
-        audio_streams: list[av.AudioStream] = []
+        audio_streams: list[bv.AudioStream] = []
         audio_inputs = []
         audio_gen_frames = []
         for i, audio_path in enumerate(audio_paths):
@@ -348,7 +333,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 rate=tl.sr,
                 time_base=Fraction(1, tl.sr),
             )
-            if not isinstance(audio_stream, av.AudioStream):
+            if not isinstance(audio_stream, bv.AudioStream):
                 log.error(f"Not a known audio codec: {args.audio_codec}")
 
             if args.audio_bitrate != "auto":
@@ -360,17 +345,22 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 audio_stream.metadata["language"] = src.audios[i].lang  # type: ignore
 
             audio_streams.append(audio_stream)
-            audio_input = av.open(audio_path)
+            audio_input = bv.open(audio_path)
             audio_inputs.append(audio_input)
             audio_gen_frames.append(audio_input.decode(audio=0))
 
         # Setup subtitles
+        if ctr.default_sub != "none" and not args.sn:
+            sub_paths = make_new_subtitles(tl, log)
+        else:
+            sub_paths = []
+
         subtitle_streams = []
         subtitle_inputs = []
         sub_gen_frames = []
 
         for i, sub_path in enumerate(sub_paths):
-            subtitle_input = av.open(sub_path)
+            subtitle_input = bv.open(sub_path)
             subtitle_inputs.append(subtitle_input)
             subtitle_stream = output.add_stream_from_template(
                 subtitle_input.streams.subtitles[0]
@@ -499,14 +489,14 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                         output.mux(item.stream.encode(item.frame))
                     elif frame_type == "subtitle":
                         output.mux(item.frame)
-                except av.error.ExternalError:
+                except bv.error.ExternalError:
                     log.error(
                         f"Generic error for encoder: {item.stream.name}\n"
                         f"at {item.index} time_base\nPerhaps video quality settings are too low?"
                     )
-                except av.FileNotFoundError:
+                except bv.FileNotFoundError:
                     log.error(f"File not found: {output_path}")
-                except av.FFmpegError as e:
+                except bv.FFmpegError as e:
                     log.error(e)
 
                 if bar_index:

auto_editor/ffwrapper.py

@@ -4,14 +4,14 @@ from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
 
-import av
+import bv
 
 from auto_editor.utils.log import Log
 
 
 def mux(input: Path, output: Path, stream: int) -> None:
-    input_container = av.open(input, "r")
-    output_container = av.open(output, "w")
+    input_container = bv.open(input, "r")
+    output_container = bv.open(output, "w")
 
     input_audio_stream = input_container.streams.audio[stream]
     output_audio_stream = output_container.add_stream("pcm_s16le")
@@ -92,12 +92,12 @@ class FileInfo:
 
 def initFileInfo(path: str, log: Log) -> FileInfo:
     try:
-        cont = av.open(path, "r")
-    except av.error.FileNotFoundError:
+        cont = bv.open(path, "r")
+    except bv.error.FileNotFoundError:
         log.error(f"Input file doesn't exist: {path}")
-    except av.error.IsADirectoryError:
+    except bv.error.IsADirectoryError:
         log.error(f"Expected a media file, but got a directory: {path}")
-    except av.error.InvalidDataError:
+    except bv.error.InvalidDataError:
         log.error(f"Invalid data when processing: {path}")
 
     videos: tuple[VideoStream, ...] = ()
@@ -126,7 +126,7 @@ def initFileInfo(path: str, log: Log) -> FileInfo:
             VideoStream(
                 v.width,
                 v.height,
-                v.name,
+                v.codec.canonical_name,
                 fps,
                 vdur,
                 sar,
@@ -167,7 +167,7 @@ def initFileInfo(path: str, log: Log) -> FileInfo:
 
     desc = cont.metadata.get("description", None)
     bitrate = 0 if cont.bit_rate is None else cont.bit_rate
-    dur = 0 if cont.duration is None else cont.duration / av.time_base
+    dur = 0 if cont.duration is None else cont.duration / bv.time_base
 
     cont.close()
 

auto_editor/formats/json.py

@@ -7,7 +7,7 @@ from fractions import Fraction
 from typing import Any
 
 from auto_editor.ffwrapper import FileInfo, initFileInfo
-from auto_editor.lang.json import Lexer, Parser, dump
+from auto_editor.json import dump, load
 from auto_editor.lib.err import MyError
 from auto_editor.timeline import (
     ASpace,
@@ -221,7 +221,7 @@ def read_v1(tl: Any, log: Log) -> v3:
 def read_json(path: str, log: Log) -> v3:
     with open(path, encoding="utf-8", errors="ignore") as f:
         try:
-            tl = Parser(Lexer(path, f)).expr()
+            tl = load(path, f)
         except MyError as e:
             log.error(e)
 

auto_editor/{lang/json.py → json.py}

@@ -11,29 +11,10 @@ if TYPE_CHECKING:
 
     from _typeshed import SupportsWrite
 
-
-class Token:
-    __slots__ = ("type", "value")
-
-    def __init__(self, type: int, value: object):
-        self.type = type
-        self.value = value
-
-    def __str__(self) -> str:
-        return f"{self.type=} {self.value=}"
-
-    __repr__ = __str__
+    Token = tuple[int, object]
 
 
 EOF, LCUR, RCUR, LBRAC, RBRAC, COL, COMMA, STR, VAL = range(9)
-table = {
-    "{": LCUR,
-    "}": RCUR,
-    "[": LBRAC,
-    "]": RBRAC,
-    ":": COL,
-    ",": COMMA,
-}
 str_escape = {
     "\\": "\\",
     "/": "/",
@@ -88,6 +69,12 @@ class Lexer:
             self.char = self.text[self.pos]
             self.column += 1
 
+    def rewind(self) -> None:
+        self.pos = 0
+        self.lineno = 1
+        self.column = 1
+        self.char = self.text[self.pos] if self.text else None
+
     def peek(self) -> str | None:
         peek_pos = self.pos + 1
         return None if peek_pos > len(self.text) - 1 else self.text[peek_pos]
@@ -142,7 +129,7 @@ class Lexer:
         result = buf.getvalue()
 
         try:
-            return Token(VAL, float(result) if has_dot else int(result))
+            return (VAL, float(result) if has_dot else int(result))
         except ValueError:
             self.error(f"`{result}` is not a valid JSON Number")
 
@@ -158,7 +145,7 @@ class Lexer:
 
             if self.char == '"':
                 self.advance()
-                return Token(STR, self.string())
+                return (STR, self.string())
 
             if self.char == "-":
                 _peek = self.peek()
@@ -168,10 +155,11 @@ class Lexer:
             if self.char in "0123456789.":
                 return self.number()
 
+            table = {"{": LCUR, "}": RCUR, "[": LBRAC, "]": RBRAC, ":": COL, ",": COMMA}
             if self.char in table:
                 key = table[self.char]
                 self.advance()
-                return Token(key, None)
+                return (key, None)
 
             keyword = ""
             for i in range(5):  # Longest valid keyword length
@@ -181,14 +169,14 @@ class Lexer:
                 self.advance()
 
             if keyword == "true":
-                return Token(VAL, True)
+                return (VAL, True)
             if keyword == "false":
-                return Token(VAL, False)
+                return (VAL, False)
             if keyword == "null":
-                return Token(VAL, None)
+                return (VAL, None)
 
             self.error(f"Invalid keyword: `{keyword}`")
-        return Token(EOF, None)
+        return (EOF, None)
 
 
 class Parser:
@@ -204,49 +192,49 @@ class Parser:
     def expr(self) -> Any:
         self.current_token
 
-        if self.current_token.type in {STR, VAL}:
-            val = self.current_token.value
+        if self.current_token[0] in {STR, VAL}:
+            val = self.current_token[1]
             self.eat()
             return val
 
-        if self.current_token.type == LCUR:
+        if self.current_token[0] == LCUR:
             self.eat()
 
             my_dic = {}
-            while self.current_token.type != RCUR:
-                if self.current_token.type != STR:
-                    if self.current_token.type in {LBRAC, VAL}:
+            while self.current_token[0] != RCUR:
+                if self.current_token[0] != STR:
+                    if self.current_token[0] in {LBRAC, VAL}:
                         self.lexer.error("JSON Objects only allow strings as keys")
                     self.lexer.error("Expected closing `}`")
-                key = self.current_token.value
+                key = self.current_token[1]
                 if key in my_dic:
                     self.lexer.error(f"Object has repeated key `{key}`")
                 self.eat()
-                if self.current_token.type != COL:
+                if self.current_token[0] != COL:
                     self.lexer.error("Expected `:`")
                 self.eat()
 
                 my_dic[key] = self.expr()
-                if self.current_token.type != RCUR:
-                    if self.current_token.type != COMMA:
+                if self.current_token[0] != RCUR:
+                    if self.current_token[0] != COMMA:
                         self.lexer.error("Expected `,` between Object entries")
                     self.eat()
-                    if self.current_token.type == RCUR:
+                    if self.current_token[0] == RCUR:
                         self.lexer.error("Trailing `,` in Object")
 
             self.eat()
             return my_dic
 
-        if self.current_token.type == LBRAC:
+        if self.current_token[0] == LBRAC:
             self.eat()
             my_arr = []
-            while self.current_token.type != RBRAC:
+            while self.current_token[0] != RBRAC:
                 my_arr.append(self.expr())
-                if self.current_token.type != RBRAC:
-                    if self.current_token.type != COMMA:
+                if self.current_token[0] != RBRAC:
+                    if self.current_token[0] != COMMA:
                         self.lexer.error("Expected `,` between array entries")
                     self.eat()
-                    if self.current_token.type == RBRAC:
+                    if self.current_token[0] == RBRAC:
                         self.lexer.error("Trailing `,` in array")
             self.eat()
             return my_arr
@@ -254,6 +242,14 @@ class Parser:
         raise MyError(f"Unknown token: {self.current_token}")
 
 
+def load(path: str, f: str | bytes | TextIOWrapper) -> dict[str, object]:
+    lexer = Lexer(path, f)
+    if lexer.get_next_token()[0] != LCUR:
+        raise MyError("Expected JSON Object")
+    lexer.rewind()
+    return Parser(lexer).expr()
+
+
 def dump(
     data: object, file: SupportsWrite[str], indent: int | None = None, level: int = 0
 ) -> None:

auto_editor/lang/palet.py

@@ -646,8 +646,8 @@ stack_trace_manager = StackTraceManager()
 
 
 def my_eval(env: Env, node: object) -> Any:
-    def make_trace(sym: Sym) -> str:
-        return f"  at {sym.val} ({sym.lineno}:{sym.column})"
+    def make_trace(sym: object) -> str:
+        return f"  at {sym.val} ({sym.lineno}:{sym.column})" if type(sym) is Sym else ""
 
     if type(node) is Sym:
         val = env.get(node.val)

auto_editor/lang/stdenv.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+import bv
+
 from auto_editor.analyze import mut_remove_large, mut_remove_small
 from auto_editor.lib.contracts import *
 from auto_editor.lib.data_structs import *
@@ -749,6 +751,13 @@ def make_standard_env() -> dict[str, Any]:
             raise MyError("@r: attribute must be an identifier")
 
         base = my_eval(env, node[1])
+
+        if hasattr(base, "__pyx_vtable__"):
+            try:
+                return getattr(base, node[2].val)
+            except AttributeError as e:
+                raise MyError(e)
+
         if type(base) is PaletClass:
             if type(name := node[2]) is not Sym:
                 raise MyError("@r: class attribute must be an identifier")
@@ -1171,6 +1180,9 @@ def make_standard_env() -> dict[str, Any]:
             "string->vector", lambda s: [Char(c) for c in s], (1, 1), is_str
         ),
         "range->vector": Proc("range->vector", list, (1, 1), is_range),
+        # av
+        "encoder": Proc("encoder", lambda x: bv.Codec(x, "w"), (1, 1), is_str),
+        "decoder": Proc("decoder", lambda x: bv.Codec(x), (1, 1), is_str),
         # reflexion
         "var-exists?": Proc("var-exists?", lambda sym: sym.val in env, (1, 1), is_symbol),
         "rename": Syntax(syn_rename),

auto_editor/output.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import os.path
 from dataclasses import dataclass, field
 
-import av
-from av.audio.resampler import AudioResampler
+import bv
+from bv.audio.resampler import AudioResampler
 
 from auto_editor.ffwrapper import FileInfo
 from auto_editor.utils.bar import Bar
@@ -53,8 +53,8 @@ class Ensure:
             bar = self._bar
             self.log.debug(f"Making external audio: {out_path}")
 
-            in_container = av.open(src.path, "r")
-            out_container = av.open(
+            in_container = bv.open(src.path, "r")
+            out_container = bv.open(
                 out_path, "w", format="wav", options={"rf64": "always"}
             )
             astream = in_container.streams.audio[stream]

auto_editor/render/audio.py

@@ -4,12 +4,12 @@ import io
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-import av
+import bv
 import numpy as np
-from av.filter.loudnorm import stats
+from bv.filter.loudnorm import stats
 
 from auto_editor.ffwrapper import FileInfo
-from auto_editor.lang.json import Lexer, Parser
+from auto_editor.json import load
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import andc, between_c, is_int_or_float
 from auto_editor.lib.err import MyError
@@ -61,12 +61,14 @@ def parse_norm(norm: str, log: Log) -> dict | None:
 
 def parse_ebu_bytes(norm: dict, stat: bytes, log: Log) -> tuple[str, str]:
     try:
-        parsed = Parser(Lexer("loudnorm", stat)).expr()
+        parsed = load("loudnorm", stat)
     except MyError:
         log.error(f"Invalid loudnorm stats.\n{stat!r}")
 
     for key in {"input_i", "input_tp", "input_lra", "input_thresh", "target_offset"}:
-        val = float(parsed[key])
+        val_ = parsed[key]
+        assert isinstance(val_, int | float | str | bytes)
+        val = float(val_)
         if val == float("-inf"):
             parsed[key] = -99
         elif val == float("inf"):
@@ -97,14 +99,14 @@ def apply_audio_normalization(
             f"i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:offset={norm['gain']}"
         )
         log.debug(f"audio norm first pass: {first_pass}")
-        with av.open(f"{pre_master}") as container:
+        with bv.open(f"{pre_master}") as container:
             stats_ = stats(first_pass, container.streams.audio[0])
 
         name, filter_args = parse_ebu_bytes(norm, stats_, log)
     else:
         assert "t" in norm
 
-        def get_peak_level(frame: av.AudioFrame) -> float:
+        def get_peak_level(frame: bv.AudioFrame) -> float:
             # Calculate peak level in dB
             # Should be equivalent to: -af astats=measure_overall=Peak_level:measure_perchannel=0
             max_amplitude = np.abs(frame.to_ndarray()).max()
@@ -112,7 +114,7 @@ def apply_audio_normalization(
                 return -20.0 * np.log10(max_amplitude)
             return -99.0
 
-        with av.open(pre_master) as container:
+        with bv.open(pre_master) as container:
             max_peak_level = -99.0
             assert len(container.streams.video) == 0
             for frame in container.decode(audio=0):
@@ -124,13 +126,13 @@ def apply_audio_normalization(
         log.print(f"peak adjustment: {adjustment:.3f}dB")
         name, filter_args = "volume", f"{adjustment}"
 
-    with av.open(pre_master) as container:
+    with bv.open(pre_master) as container:
         input_stream = container.streams.audio[0]
 
-        output_file = av.open(path, mode="w")
+        output_file = bv.open(path, mode="w")
         output_stream = output_file.add_stream("pcm_s16le", rate=input_stream.rate)
 
-        graph = av.filter.Graph()
+        graph = bv.filter.Graph()
         graph.link_nodes(
             graph.add_abuffer(template=input_stream),
             graph.add(name, filter_args),
@@ -141,9 +143,9 @@ def apply_audio_normalization(
             while True:
                 try:
                     aframe = graph.pull()
-                    assert isinstance(aframe, av.AudioFrame)
+                    assert isinstance(aframe, bv.AudioFrame)
                     output_file.mux(output_stream.encode(aframe))
-                except (av.BlockingIOError, av.EOFError):
+                except (bv.BlockingIOError, bv.EOFError):
                     break
 
         output_file.mux(output_stream.encode(None))
@@ -157,14 +159,14 @@ def process_audio_clip(
     write(input_buffer, sr, samp_list[samp_start:samp_end])
     input_buffer.seek(0)
 
-    input_file = av.open(input_buffer, "r")
+    input_file = bv.open(input_buffer, "r")
     input_stream = input_file.streams.audio[0]
 
     output_bytes = io.BytesIO()
-    output_file = av.open(output_bytes, mode="w", format="wav")
+    output_file = bv.open(output_bytes, mode="w", format="wav")
     output_stream = output_file.add_stream("pcm_s16le", rate=sr)
 
-    graph = av.filter.Graph()
+    graph = bv.filter.Graph()
     args = [graph.add_abuffer(template=input_stream)]
 
     if clip.speed != 1:
@@ -194,9 +196,9 @@ def process_audio_clip(
         while True:
             try:
                 aframe = graph.pull()
-                assert isinstance(aframe, av.AudioFrame)
+                assert isinstance(aframe, bv.AudioFrame)
                 output_file.mux(output_stream.encode(aframe))
-            except (av.BlockingIOError, av.EOFError):
+            except (bv.BlockingIOError, bv.EOFError):
                 break
 
     # Flush the stream
@@ -220,7 +222,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 
     # First pass: determine the maximum length
     for path in audio_paths:
-        container = av.open(path)
+        container = bv.open(path)
         stream = container.streams.audio[0]
 
         # Calculate duration in samples
@@ -232,10 +234,10 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 
     # Second pass: read and mix audio
     for path in audio_paths:
-        container = av.open(path)
+        container = bv.open(path)
         stream = container.streams.audio[0]
 
-        resampler = av.audio.resampler.AudioResampler(
+        resampler = bv.audio.resampler.AudioResampler(
             format="s16", layout="mono", rate=sr
         )
 
@@ -268,7 +270,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
         mixed_audio = mixed_audio * (32767 / max_val)
     mixed_audio = mixed_audio.astype(np.int16)  # type: ignore
 
-    output_container = av.open(output_path, mode="w")
+    output_container = bv.open(output_path, mode="w")
     output_stream = output_container.add_stream("pcm_s16le", rate=sr)
 
     chunk_size = sr  # Process 1 second at a time
@@ -276,7 +278,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
         # Shape becomes (1, samples) for mono
         chunk = np.array([mixed_audio[i : i + chunk_size]])
 
-        frame = av.AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
+        frame = bv.AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
         frame.rate = sr
         frame.pts = i  # Set presentation timestamp
 
@@ -370,7 +372,7 @@ def make_new_audio(
     except PermissionError:
         pass
 
-    if not (args.keep_tracks_separate and ctr.max_audios is None) and len(output) > 1:
+    if args.mix_audio_streams and len(output) > 1:
         new_a_file = f"{Path(temp, 'new_audio.wav')}"
         mix_audio_files(sr, output, new_a_file)
         return [new_a_file]