auto-editor 28.0.2__py3-none-any.whl → 28.1.0__py3-none-any.whl

auto_editor/exports/kdenlive.py

@@ -0,0 +1,322 @@
+import json
+import xml.etree.ElementTree as ET
+from os import getcwd
+from uuid import uuid4
+
+from auto_editor.timeline import Clip, v3
+from auto_editor.utils.func import aspect_ratio, to_timecode
+
+"""
+kdenlive uses the MLT timeline format
+
+See docs here:
+https://mltframework.org/docs/mltxml/
+
+kdenlive specifics:
+https://github.com/KDE/kdenlive/blob/master/dev-docs/fileformat.md
+"""
+
+
+def kdenlive_write(output: str, tl: v3) -> None:
+    mlt = ET.Element(
+        "mlt",
+        attrib={
+            "LC_NUMERIC": "C",
+            "version": "7.22.0",
+            "producer": "main_bin",
+            "root": f"{getcwd()}",
+        },
+    )
+
+    width, height = tl.res
+    num, den = aspect_ratio(width, height)
+    tb = tl.tb
+    seq_uuid = uuid4()
+
+    ET.SubElement(
+        mlt,
+        "profile",
+        attrib={
+            "description": "automatic",
+            "width": f"{width}",
+            "height": f"{height}",
+            "progressive": "1",
+            "sample_aspect_num": "1",
+            "sample_aspect_den": "1",
+            "display_aspect_num": f"{num}",
+            "display_aspect_den": f"{den}",
+            "frame_rate_num": f"{tb.numerator}",
+            "frame_rate_den": f"{tb.denominator}",
+            "colorspace": "709",
+        },
+    )
+
+    # Reserved producer0
+    global_out = to_timecode(len(tl) / tb, "standard")
+    producer = ET.SubElement(mlt, "producer", id="producer0")
+    ET.SubElement(producer, "property", name="length").text = global_out
+    ET.SubElement(producer, "property", name="eof").text = "continue"
+    ET.SubElement(producer, "property", name="resource").text = "black"
+    ET.SubElement(producer, "property", name="mlt_service").text = "color"
+    ET.SubElement(producer, "property", name="kdenlive:playlistid").text = "black_track"
+    ET.SubElement(producer, "property", name="mlt_image_format").text = "rgba"
+    ET.SubElement(producer, "property", name="aspect_ratio").text = "1"
+
+    # Get all clips
+    if tl.v:
+        clips = [clip for clip in tl.v[0] if isinstance(clip, Clip)]
+    elif tl.a:
+        clips = tl.a[0]
+    else:
+        clips = []
+
+    source_ids = {}
+    source_id = 4
+    clip_playlists = []
+    chains = 0
+    playlists = 0
+    producers = 1
+    a_channels = len(tl.a)
+    v_channels = len(tl.v)
+    warped_clips = [i for i, clip in enumerate(clips) if clip.speed != 1]
+
+    # create all producers for warped clips
+    for clip_idx in warped_clips:
+        for i in range(a_channels + v_channels):
+            clip = clips[clip_idx]
+            path = str(clip.src.path)
+
+            if path not in source_ids:
+                source_ids[path] = str(source_id)
+                source_id += 1
+
+            prod = ET.SubElement(
+                mlt,
+                "producer",
+                attrib={
+                    "id": f"producer{producers}",
+                    "in": "00:00:00.000",
+                    "out": global_out,
+                },
+            )
+            ET.SubElement(
+                prod, "property", name="resource"
+            ).text = f"{clip.speed}:{path}"
+            ET.SubElement(prod, "property", name="warp_speed").text = str(clip.speed)
+            ET.SubElement(prod, "property", name="warp_resource").text = path
+            ET.SubElement(prod, "property", name="warp_pitch").text = "0"
+            ET.SubElement(prod, "property", name="mlt_service").text = "timewarp"
+            ET.SubElement(prod, "property", name="kdenlive:id").text = source_ids[path]
+
+            if i < a_channels:
+                ET.SubElement(prod, "property", name="vstream").text = "0"
+                ET.SubElement(prod, "property", name="astream").text = str(
+                    a_channels - 1 - i
+                )
+                ET.SubElement(prod, "property", name="set.test_audio").text = "0"
+                ET.SubElement(prod, "property", name="set.test_video").text = "1"
+            else:
+                ET.SubElement(prod, "property", name="vstream").text = str(
+                    v_channels - 1 - (i - a_channels)
+                )
+                ET.SubElement(prod, "property", name="astream").text = "0"
+                ET.SubElement(prod, "property", name="set.test_audio").text = "1"
+                ET.SubElement(prod, "property", name="set.test_video").text = "0"
+
+            producers += 1
+
+    # create chains, playlists and tractors for audio channels
+    for i, audio in enumerate(tl.a):
+        path = str(audio[0].src.path)
+
+        if path not in source_ids:
+            source_ids[path] = str(source_id)
+            source_id += 1
+
+        chain = ET.SubElement(mlt, "chain", attrib={"id": f"chain{chains}"})
+        ET.SubElement(chain, "property", name="resource").text = path
+        ET.SubElement(
+            chain, "property", name="mlt_service"
+        ).text = "avformat-novalidate"
+        ET.SubElement(chain, "property", name="vstream").text = "0"
+        ET.SubElement(chain, "property", name="astream").text = str(a_channels - 1 - i)
+        ET.SubElement(chain, "property", name="set.test_audio").text = "0"
+        ET.SubElement(chain, "property", name="set.test_video").text = "1"
+        ET.SubElement(chain, "property", name="kdenlive:id").text = source_ids[path]
+
+        for _i in range(2):
+            playlist = ET.SubElement(mlt, "playlist", id=f"playlist{playlists}")
+            clip_playlists.append(playlist)
+            ET.SubElement(playlist, "property", name="kdenlive:audio_track").text = "1"
+            playlists += 1
+
+        tractor = ET.SubElement(
+            mlt,
+            "tractor",
+            attrib={"id": f"tractor{chains}", "in": "00:00:00.000", "out": global_out},
+        )
+        ET.SubElement(tractor, "property", name="kdenlive:audio_track").text = "1"
+        ET.SubElement(tractor, "property", name="kdenlive:timeline_active").text = "1"
+        ET.SubElement(tractor, "property", name="kdenlive:audio_rec")
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "video", "producer": f"playlist{playlists - 2}"},
+        )
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "video", "producer": f"playlist{playlists - 1}"},
+        )
+        chains += 1
+
+    # create chains, playlists and tractors for video channels
+    for i, video in enumerate(tl.v):
+        path = f"{video[0].src.path}"  # type: ignore
+
+        if path not in source_ids:
+            source_ids[path] = str(source_id)
+            source_id += 1
+
+        chain = ET.SubElement(mlt, "chain", attrib={"id": f"chain{chains}"})
+        ET.SubElement(chain, "property", name="resource").text = path
+        ET.SubElement(
+            chain, "property", name="mlt_service"
+        ).text = "avformat-novalidate"
+        ET.SubElement(chain, "property", name="vstream").text = str(v_channels - 1 - i)
+        ET.SubElement(chain, "property", name="astream").text = "0"
+        ET.SubElement(chain, "property", name="set.test_audio").text = "1"
+        ET.SubElement(chain, "property", name="set.test_video").text = "0"
+        ET.SubElement(chain, "property", name="kdenlive:id").text = source_ids[path]
+
+        for _i in range(2):
+            playlist = ET.SubElement(mlt, "playlist", id=f"playlist{playlists}")
+            clip_playlists.append(playlist)
+            playlists += 1
+
+        tractor = ET.SubElement(
+            mlt,
+            "tractor",
+            attrib={"id": f"tractor{chains}", "in": "00:00:00.000", "out": global_out},
+        )
+        ET.SubElement(tractor, "property", name="kdenlive:timeline_active").text = "1"
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "audio", "producer": f"playlist{playlists - 2}"},
+        )
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "audio", "producer": f"playlist{playlists - 1}"},
+        )
+        chains += 1
+
+    # final chain for the project bin
+    path = str(clips[0].src.path)
+    chain = ET.SubElement(mlt, "chain", attrib={"id": f"chain{chains}"})
+    ET.SubElement(chain, "property", name="resource").text = path
+    ET.SubElement(chain, "property", name="mlt_service").text = "avformat-novalidate"
+    ET.SubElement(chain, "property", name="audio_index").text = "1"
+    ET.SubElement(chain, "property", name="video_index").text = "0"
+    ET.SubElement(chain, "property", name="vstream").text = "0"
+    ET.SubElement(chain, "property", name="astream").text = "0"
+    ET.SubElement(chain, "property", name="kdenlive:id").text = source_ids[path]
+
+    groups = []
+    group_counter = 0
+    producers = 1
+
+    for clip in clips:
+        group_children: list[object] = []
+        _in = to_timecode(clip.offset / tb, "standard")
+        _out = to_timecode((clip.offset + clip.dur) / tb, "standard")
+        path = str(clip.src.path)
+
+        for i, playlist in enumerate(clip_playlists[::2]):
+            # adding 1 extra frame for each previous group to the start time works but feels hacky?
+            group_children.append(
+                {
+                    "data": f"{i}:{clip.start + group_counter}",
+                    "leaf": "clip",
+                    "type": "Leaf",
+                }
+            )
+            clip_prod = ""
+
+            if clip.speed == 1:
+                clip_prod = f"chain{i}"
+            else:
+                clip_prod = f"producer{producers}"
+                producers += 1
+
+            entry = ET.SubElement(
+                playlist,
+                "entry",
+                attrib={"producer": f"{clip_prod}", "in": _in, "out": _out},
+            )
+            ET.SubElement(entry, "property", name="kdenlive:id").text = source_ids[path]
+
+        groups.append({"children": group_children[:], "type": "Normal"})
+        group_counter += 1
+
+    # default sequence tractor
+    sequence = ET.SubElement(
+        mlt,
+        "tractor",
+        attrib={"id": f"{{{seq_uuid}}}", "in": "00:00:00.000", "out": "00:00:00.000"},
+    )
+    ET.SubElement(sequence, "property", name="kdenlive:uuid").text = f"{{{seq_uuid}}}"
+    ET.SubElement(sequence, "property", name="kdenlive:clipname").text = "Sequence 1"
+    ET.SubElement(
+        sequence, "property", name="kdenlive:sequenceproperties.groups"
+    ).text = json.dumps(groups, indent=4)
+    ET.SubElement(sequence, "track", producer="producer0")
+
+    for i in range(chains):
+        ET.SubElement(sequence, "track", producer=f"tractor{i}")
+
+    # main bin
+    playlist_bin = ET.SubElement(mlt, "playlist", id="main_bin")
+    ET.SubElement(
+        playlist_bin, "property", name="kdenlive:docproperties.uuid"
+    ).text = f"{{{seq_uuid}}}"
+    ET.SubElement(
+        playlist_bin, "property", name="kdenlive:docproperties.version"
+    ).text = "1.1"
+    ET.SubElement(playlist_bin, "property", name="xml_retain").text = "1"
+    ET.SubElement(
+        playlist_bin,
+        "entry",
+        attrib={
+            "producer": f"{{{seq_uuid}}}",
+            "in": "00:00:00.000",
+            "out": "00:00:00.000",
+        },
+    )
+    ET.SubElement(
+        playlist_bin,
+        "entry",
+        attrib={"producer": f"chain{chains}", "in": "00:00:00.000"},
+    )
+
+    # reserved last tractor for project
+    tractor = ET.SubElement(
+        mlt,
+        "tractor",
+        attrib={"id": f"tractor{chains}", "in": "00:00:00.000", "out": global_out},
+    )
+    ET.SubElement(tractor, "property", name="kdenlive:projectTractor").text = "1"
+    ET.SubElement(
+        tractor,
+        "track",
+        attrib={"producer": f"{{{seq_uuid}}}", "in": "00:00:00.000", "out": global_out},
+    )
+    tree = ET.ElementTree(mlt)
+
+    ET.indent(tree, space="\t", level=0)
+
+    if output == "-":
+        print(ET.tostring(mlt, encoding="unicode"))
+    else:
+        tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/ffwrapper.py

@@ -4,14 +4,14 @@ from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
 
-import bv
+import av
 
 from auto_editor.utils.log import Log
 
 
 def mux(input: Path, output: Path, stream: int) -> None:
-    input_container = bv.open(input, "r")
-    output_container = bv.open(output, "w")
+    input_container = av.open(input, "r")
+    output_container = av.open(output, "w")
 
     input_audio_stream = input_container.streams.audio[stream]
     output_audio_stream = output_container.add_stream("pcm_s16le")
@@ -89,12 +89,12 @@ class FileInfo:
     @classmethod
     def init(self, path: str, log: Log) -> FileInfo:
         try:
-            cont = bv.open(path, "r")
-        except bv.error.FileNotFoundError:
+            cont = av.open(path, "r")
+        except av.error.FileNotFoundError:
             log.error(f"Input file doesn't exist: {path}")
-        except bv.error.IsADirectoryError:
+        except av.error.IsADirectoryError:
             log.error(f"Expected a media file, but got a directory: {path}")
-        except bv.error.InvalidDataError:
+        except av.error.InvalidDataError:
             log.error(f"Invalid data when processing: {path}")
 
         videos: tuple[VideoStream, ...] = ()
@@ -177,7 +177,7 @@ class FileInfo:
 
         timecode = get_timecode()
         bitrate = 0 if cont.bit_rate is None else cont.bit_rate
-        dur = 0 if cont.duration is None else cont.duration / bv.time_base
+        dur = 0 if cont.duration is None else cont.duration / av.time_base
 
         cont.close()
 

auto_editor/help.py

@@ -78,6 +78,7 @@ Export Methods:
  - final-cut-pro  ; Export as an XML timeline file for Final Cut Pro
     - name : "Auto-Editor Media Group"
  - shotcut ; Export as an XML timeline file for Shotcut
+ - kdenlive ; Export as an XML timeline file for kdenlive
  - v3 ; Export as an auto-editor v3 timeline file
  - v1 ; Export as an auto-editor v1 timeline file
  - clip-sequence  ; Export as multiple numbered media files

auto_editor/lang/stdenv.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 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 *
@@ -1169,9 +1167,6 @@ 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/make_layers.py

@@ -299,9 +299,9 @@ def make_timeline(
 
     if len(sources) == 1 and inp is not None:
         chunks = chunkify(speed_index, speed_hash)
-        v1_compatiable = v1(inp, chunks)
+        v1_compatible = v1(inp, chunks)
     else:
-        v1_compatiable = None
+        v1_compatible = None
 
     if len(vtl) == 0 and len(atl) == 0:
         log.error("Timeline is empty, nothing to do.")
@@ -312,4 +312,4 @@ def make_timeline(
     else:
         template = Template.init(inp, sr, args.audio_layout, res)
 
-    return v3(tb, args.background, template, vtl, atl, v1_compatiable)
+    return v3(tb, args.background, template, vtl, atl, v1_compatible)

auto_editor/render/audio.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from fractions import Fraction
 from io import BytesIO
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
-import bv
+import av
 import numpy as np
-from bv import AudioFrame
-from bv.filter.loudnorm import stats
+from av import AudioFrame
+from av.filter.loudnorm import stats
 
 from auto_editor.ffwrapper import FileInfo
 from auto_editor.json import load
@@ -22,7 +22,6 @@ from auto_editor.utils.log import Log
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
-    from typing import Any
 
     from auto_editor.__main__ import Args
 
@@ -102,7 +101,7 @@ 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 bv.open(f"{pre_master}") as container:
+        with av.open(f"{pre_master}") as container:
             stats_ = stats(first_pass, container.streams.audio[0])
 
         name, filter_args = parse_ebu_bytes(norm, stats_, log)
@@ -117,7 +116,7 @@ def apply_audio_normalization(
                 return -20.0 * np.log10(max_amplitude)
             return -99.0
 
-        with bv.open(pre_master) as container:
+        with av.open(pre_master) as container:
             max_peak_level = -99.0
             assert len(container.streams.video) == 0
             for frame in container.decode(audio=0):
@@ -129,13 +128,13 @@ def apply_audio_normalization(
         log.print(f"peak adjustment: {adjustment:.3f}dB")
         name, filter_args = "volume", f"{adjustment}"
 
-    with bv.open(pre_master) as container:
+    with av.open(pre_master) as container:
         input_stream = container.streams.audio[0]
 
-        output_file = bv.open(path, mode="w")
+        output_file = av.open(path, mode="w")
         output_stream = output_file.add_stream("pcm_s16le", rate=input_stream.rate)
 
-        graph = bv.filter.Graph()
+        graph = av.filter.Graph()
         graph.link_nodes(
             graph.add_abuffer(template=input_stream),
             graph.add(name, filter_args),
@@ -148,7 +147,7 @@ def apply_audio_normalization(
                     aframe = graph.pull()
                     assert isinstance(aframe, AudioFrame)
                     output_file.mux(output_stream.encode(aframe))
-                except (bv.BlockingIOError, bv.EOFError):
+                except (av.BlockingIOError, av.EOFError):
                     break
 
         output_file.mux(output_stream.encode(None))
@@ -156,10 +155,10 @@ def apply_audio_normalization(
 
 
 def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.ndarray:
-    to_s16 = bv.AudioResampler(format="s16", layout="stereo", rate=sr)
+    to_s16 = av.AudioResampler(format="s16", layout="stereo", rate=sr)
     input_buffer = BytesIO()
 
-    with bv.open(input_buffer, "w", format="wav") as container:
+    with av.open(input_buffer, "w", format="wav") as container:
         output_stream = container.add_stream(
             "pcm_s16le", sample_rate=sr, format="s16", layout="stereo"
         )
@@ -173,10 +172,10 @@ def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.nd
 
     input_buffer.seek(0)
 
-    input_file = bv.open(input_buffer, "r")
+    input_file = av.open(input_buffer, "r")
     input_stream = input_file.streams.audio[0]
 
-    graph = bv.filter.Graph()
+    graph = av.filter.Graph()
     args = [graph.add_abuffer(template=input_stream)]
 
     if clip.speed != 1:
@@ -202,7 +201,7 @@ def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.nd
     graph.link_nodes(*args).configure()
 
     all_frames = []
-    resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=sr)
+    resampler = av.AudioResampler(format="s16p", layout="stereo", rate=sr)
 
     for frame in input_file.decode(input_stream):
         graph.push(frame)
@@ -214,7 +213,7 @@ def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.nd
                 for resampled_frame in resampler.resample(aframe):
                     all_frames.append(resampled_frame.to_ndarray())
 
-            except (bv.BlockingIOError, bv.EOFError):
+            except (av.BlockingIOError, av.EOFError):
                 break
 
     if not all_frames:
@@ -229,7 +228,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 = bv.open(path)
+        container = av.open(path)
         stream = container.streams.audio[0]
 
         # Calculate duration in samples
@@ -241,14 +240,11 @@ 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 = bv.open(path)
+        container = av.open(path)
         stream = container.streams.audio[0]
 
-        resampler = bv.audio.resampler.AudioResampler(
-            format="s16", layout="mono", rate=sr
-        )
-
         audio_array: list[np.ndarray] = []
+        resampler = av.AudioResampler(format="s16", layout="mono", rate=sr)
         for frame in container.decode(audio=0):
             frame.pts = None
             resampled = resampler.resample(frame)[0]
@@ -277,7 +273,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)
 
-    output_container = bv.open(output_path, mode="w")
+    output_container = av.open(output_path, mode="w")
     output_stream = output_container.add_stream("pcm_s16le", rate=sr)
 
     chunk_size = sr  # Process 1 second at a time
@@ -298,9 +294,9 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 def file_to_ndarray(src: FileInfo, stream: int, sr: int) -> np.ndarray:
     all_frames = []
 
-    resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=sr)
+    resampler = av.AudioResampler(format="s16p", layout="stereo", rate=sr)
 
-    with bv.open(src.path) as container:
+    with av.open(src.path) as container:
         for frame in container.decode(audio=stream):
             for resampled_frame in resampler.resample(frame):
                 all_frames.append(resampled_frame.to_ndarray())
@@ -311,10 +307,10 @@ def file_to_ndarray(src: FileInfo, stream: int, sr: int) -> np.ndarray:
 def ndarray_to_file(audio_data: np.ndarray, rate: int, out: str | Path) -> None:
     layout = "stereo"
 
-    with bv.open(out, mode="w") as output:
+    with av.open(out, mode="w") as output:
         stream = output.add_stream("pcm_s16le", rate=rate, format="s16", layout=layout)
 
-        frame = bv.AudioFrame.from_ndarray(audio_data, format="s16p", layout=layout)
+        frame = AudioFrame.from_ndarray(audio_data, format="s16p", layout=layout)
         frame.rate = rate
 
         output.mux(stream.encode(frame))
@@ -322,11 +318,11 @@ def ndarray_to_file(audio_data: np.ndarray, rate: int, out: str | Path) -> None:
 
 
 def ndarray_to_iter(
-    audio_data: np.ndarray, fmt: bv.AudioFormat, layout: str, rate: int
+    audio_data: np.ndarray, fmt: av.AudioFormat, layout: str, rate: int
 ) -> Iterator[AudioFrame]:
     chunk_size = rate // 4  # Process 0.25 seconds at a time
 
-    resampler = bv.AudioResampler(rate=rate, format=fmt, layout=layout)
+    resampler = av.AudioResampler(rate=rate, format=fmt, layout=layout)
     for i in range(0, audio_data.shape[1], chunk_size):
         chunk = audio_data[:, i : i + chunk_size]
 
@@ -338,15 +334,15 @@ def ndarray_to_iter(
 
 
 def make_new_audio(
-    output: bv.container.OutputContainer,
-    audio_format: bv.AudioFormat,
+    output: av.container.OutputContainer,
+    audio_format: av.AudioFormat,
     tl: v3,
     args: Args,
     log: Log,
-) -> tuple[list[bv.AudioStream], list[Iterator[AudioFrame]]]:
+) -> tuple[list[av.AudioStream], list[Iterator[AudioFrame]]]:
     audio_inputs = []
     audio_gen_frames = []
-    audio_streams: list[bv.AudioStream] = []
+    audio_streams: list[av.AudioStream] = []
     audio_paths = _make_new_audio(tl, audio_format, args, log)
 
     for i, audio_path in enumerate(audio_paths):
@@ -357,7 +353,7 @@ def make_new_audio(
             layout=tl.T.layout,
             time_base=Fraction(1, tl.sr),
         )
-        if not isinstance(audio_stream, bv.AudioStream):
+        if not isinstance(audio_stream, av.AudioStream):
             log.error(f"Not a known audio codec: {args.audio_codec}")
 
         if args.audio_bitrate != "auto":
@@ -372,7 +368,7 @@ def make_new_audio(
         audio_streams.append(audio_stream)
 
         if isinstance(audio_path, str):
-            audio_input = bv.open(audio_path)
+            audio_input = av.open(audio_path)
             audio_inputs.append(audio_input)
             audio_gen_frames.append(audio_input.decode(audio=0))
         else:
@@ -385,7 +381,7 @@ class Getter:
     __slots__ = ("container", "stream", "rate")
 
     def __init__(self, path: Path, stream: int, rate: int):
-        self.container = bv.open(path)
+        self.container = av.open(path)
         self.stream = self.container.streams.audio[stream]
         self.rate = rate
 
@@ -394,7 +390,7 @@ class Getter:
 
         container = self.container
         stream = self.stream
-        resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=self.rate)
+        resampler = av.AudioResampler(format="s16p", layout="stereo", rate=self.rate)
 
         time_base = stream.time_base
         assert time_base is not None
@@ -436,10 +432,12 @@ class Getter:
         return result  # Return NumPy array with shape (channels, samples)
 
 
-def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[Any]:
+def _make_new_audio(
+    tl: v3, fmt: av.AudioFormat, args: Args, log: Log
+) -> list[str | Iterator[AudioFrame]]:
     sr = tl.sr
     tb = tl.tb
-    output: list[Any] = []
+    output: list[str | Iterator[AudioFrame]] = []
     samples: dict[tuple[FileInfo, int], Getter] = {}
 
     norm = parse_norm(args.audio_normalize, log)
@@ -449,7 +447,7 @@ def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[A
 
     layout = tl.T.layout
     try:
-        bv.AudioLayout(layout)
+        av.AudioLayout(layout)
     except ValueError:
         log.error(f"Invalid audio layout: {layout}")
 
@@ -511,7 +509,9 @@ def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[A
 
     if args.mix_audio_streams and len(output) > 1:
         new_a_file = f"{Path(log.temp, 'new_audio.wav')}"
-        mix_audio_files(sr, output, new_a_file)
+        # When mix_audio_streams is True, output only contains strings
+        audio_paths = cast(list[str], output)
+        mix_audio_files(sr, audio_paths, new_a_file)
         return [new_a_file]
 
     return output