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

auto_editor/edit.py

@@ -8,13 +8,11 @@ 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 auto_editor.ffwrapper import FileInfo, initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lib.contracts import is_int, is_str
 from auto_editor.make_layers import clipify, make_av, make_timeline
-from auto_editor.output import Ensure, parse_bitrate
 from auto_editor.render.audio import make_new_audio
 from auto_editor.render.subtitle import make_new_subtitles
 from auto_editor.render.video import render_av
@@ -83,21 +81,13 @@ 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:
+            cobj = bv.Codec(codec, "w")
+        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):
+        if cobj.id not in (bv.Codec(x, "w").id for x in ctr.vcodecs):
             log.error(codec_error.format(codec, out_ext))
 
     return codec
@@ -111,7 +101,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,21 +109,13 @@ 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:
+            cobj = bv.Codec(codec, "w")
+        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):
+        if cobj.id not in (bv.Codec(x, "w").id for x in ctr.acodecs):
             log.error(codec_error.format(codec, out_ext))
 
     return codec
@@ -177,6 +159,11 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
 def edit_media(paths: list[str], args: Args, log: Log) -> None:
     bar = initBar(args.progress)
     tl = None
+    src = 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()
@@ -184,30 +171,18 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
             from auto_editor.formats.fcp7 import fcp7_read_xml
 
             tl = fcp7_read_xml(paths[0], log)
-            assert tl.src is not None
-            sources: list[FileInfo] = [tl.src]
-            src: FileInfo | None = tl.src
-
         elif path_ext == ".mlt":
             from auto_editor.formats.shotcut import shotcut_read_mlt
 
             tl = shotcut_read_mlt(paths[0], log)
-            assert tl.src is not None
-            sources = [tl.src]
-            src = tl.src
-
         elif path_ext == ".json":
             from auto_editor.formats.json import read_json
 
             tl = read_json(paths[0], log)
-            sources = [] if tl.src is None else [tl.src]
-            src = tl.src
         else:
-            sources = [initFileInfo(path, log) for path in paths]
+            sources = [FileInfo.init(path, log) for path in paths]
             src = None if not sources else sources[0]
 
-    del paths
-
     output, export_ops = set_output(args.output, args.export, src, log)
     assert "export" in export_ops
     export = export_ops["export"]
@@ -268,7 +243,8 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         from auto_editor.formats.fcp11 import fcp11_write_xml
         from auto_editor.timeline import set_stream_to_0
 
-        set_stream_to_0(tl, log)
+        assert src is not None
+        set_stream_to_0(src, tl, log)
         fcp11_write_xml(export_ops["name"], 10, output, True, tl, log)
         return
 
@@ -281,7 +257,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     out_ext = splitext(output)[1].replace(".", "")
 
     # Check if export options make sense.
-    ctr = container_constructor(out_ext.lower())
+    ctr = container_constructor(out_ext.lower(), log)
 
     if ctr.samplerate is not None and args.sample_rate not in ctr.samplerate:
         log.error(f"'{out_ext}' container only supports samplerates: {ctr.samplerate}")
@@ -289,12 +265,7 @@ 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
-
         options = {}
         mov_flags = []
         if args.fragmented and not args.no_fragmented:
@@ -307,76 +278,59 @@ 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)
-
-        if ctr.default_sub != "none" and not args.sn:
-            sub_paths = make_new_subtitles(tl, log)
-        else:
-            sub_paths = []
-
-        if ctr.default_aud != "none":
-            ensure = Ensure(bar, samplerate, log)
-            audio_paths = make_new_audio(tl, ctr, ensure, args, bar, log)
-        else:
-            audio_paths = []
+        output = bv.open(output_path, "w", container_options=options)
 
         # Setup video
         if ctr.default_vid != "none" and tl.v:
             vframes = render_av(output, tl, args, log)
-            output_stream = next(vframes)
+            output_stream: bv.VideoStream | None
+            output_stream = next(vframes)  # type: ignore
         else:
             output_stream, vframes = None, iter([])
 
         # Setup audio
-        if audio_paths:
-            try:
-                audio_encoder = av.Codec(args.audio_codec, "w")
-            except av.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_inputs = []
-        audio_gen_frames = []
-        for i, audio_path in enumerate(audio_paths):
-            audio_stream = output.add_stream(
-                args.audio_codec,
-                format=audio_format,
-                rate=tl.sr,
-                time_base=Fraction(1, tl.sr),
-            )
-            if not isinstance(audio_stream, av.AudioStream):
-                log.error(f"Not a known audio codec: {args.audio_codec}")
+        try:
+            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.")
+        fmt = audio_encoder.audio_formats[0]
 
-            if args.audio_bitrate != "auto":
-                audio_stream.bit_rate = parse_bitrate(args.audio_bitrate, log)
-                log.debug(f"audio bitrate: {audio_stream.bit_rate}")
-            else:
-                log.debug(f"[auto] audio bitrate: {audio_stream.bit_rate}")
-            if i < len(src.audios) and src.audios[i].lang is not None:
-                audio_stream.metadata["language"] = src.audios[i].lang  # type: ignore
+        audio_streams: list[bv.AudioStream] = []
+
+        if ctr.default_aud == "none":
+            while len(tl.a) > 0:
+                tl.a.pop()
+        elif len(tl.a) > 1 and ctr.max_audios == 1:
+            log.warning("Dropping extra audio streams (container only allows one)")
 
-            audio_streams.append(audio_stream)
-            audio_input = av.open(audio_path)
-            audio_inputs.append(audio_input)
-            audio_gen_frames.append(audio_input.decode(audio=0))
+            while len(tl.a) > 1:
+                tl.a.pop()
+
+        if len(tl.a) > 0:
+            audio_streams, audio_gen_frames = make_new_audio(output, fmt, tl, args, log)
+        else:
+            audio_streams, audio_gen_frames = [], [iter([])]
 
         # 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]
             )
-            if i < len(src.subtitles) and src.subtitles[i].lang is not None:
-                subtitle_stream.metadata["language"] = src.subtitles[i].lang  # type: ignore
+            if i < len(tl.T.subtitles) and (lang := tl.T.subtitles[i].lang) is not None:
+                subtitle_stream.metadata["language"] = lang
 
             subtitle_streams.append(subtitle_stream)
             sub_gen_frames.append(subtitle_input.demux(subtitles=0))
@@ -473,13 +427,11 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 break
 
             if should_get_audio:
-                for audio_stream, audio_frame in zip(audio_streams, audio_frames):
-                    for reframe in resampler.resample(audio_frame):
-                        assert reframe.pts is not None
-                        heappush(
-                            frame_queue,
-                            Priority(reframe.pts, reframe, audio_stream),
-                        )
+                for audio_stream, aframe in zip(audio_streams, audio_frames):
+                    if aframe is None:
+                        continue
+                    assert aframe.pts is not None
+                    heappush(frame_queue, Priority(aframe.pts, aframe, audio_stream))
             if should_get_sub:
                 for subtitle_stream, packet in zip(subtitle_streams, subtitle_frames):
                     if packet and packet.pts is not None:
@@ -499,14 +451,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:
@@ -521,8 +473,6 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         bar.end()
 
         # Close resources
-        for audio_input in audio_inputs:
-            audio_input.close()
         for subtitle_input in subtitle_inputs:
             subtitle_input.close()
         output.close()
@@ -552,11 +502,9 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 tl.v1.source, [clipify(padded_chunks, tl.v1.source)]
             )
             my_timeline = v3(
-                tl.v1.source,
                 tl.tb,
-                tl.sr,
-                tl.res,
                 "#000",
+                tl.template,
                 vspace,
                 aspace,
                 v1(tl.v1.source, padded_chunks),

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")
@@ -86,89 +86,93 @@ class FileInfo:
             return self.audios[0].samplerate
         return 48000
 
+    @classmethod
+    def init(self, path: str, log: Log) -> FileInfo:
+        try:
+            cont = bv.open(path, "r")
+        except bv.error.FileNotFoundError:
+            log.error(f"Input file doesn't exist: {path}")
+        except bv.error.IsADirectoryError:
+            log.error(f"Expected a media file, but got a directory: {path}")
+        except bv.error.InvalidDataError:
+            log.error(f"Invalid data when processing: {path}")
+
+        videos: tuple[VideoStream, ...] = ()
+        audios: tuple[AudioStream, ...] = ()
+        subtitles: tuple[SubtitleStream, ...] = ()
+
+        for v in cont.streams.video:
+            if v.duration is not None and v.time_base is not None:
+                vdur = float(v.duration * v.time_base)
+            else:
+                vdur = 0.0
+
+            fps = v.average_rate
+            if (fps is None or fps < 1) and v.name in {"png", "mjpeg", "webp"}:
+                fps = Fraction(25)
+            if fps is None or fps == 0:
+                fps = Fraction(30)
+
+            if v.sample_aspect_ratio is None:
+                sar = Fraction(1)
+            else:
+                sar = v.sample_aspect_ratio
+
+            cc = v.codec_context
+
+            if v.name is None:
+                log.error(f"Can't detect codec for video stream {v}")
+
+            videos += (
+                VideoStream(
+                    v.width,
+                    v.height,
+                    v.codec.canonical_name,
+                    fps,
+                    vdur,
+                    sar,
+                    v.time_base,
+                    getattr(v.format, "name", None),
+                    cc.color_range,
+                    cc.colorspace,
+                    cc.color_primaries,
+                    cc.color_trc,
+                    0 if v.bit_rate is None else v.bit_rate,
+                    v.language,
+                ),
+            )
+
+        for a in cont.streams.audio:
+            adur = 0.0
+            if a.duration is not None and a.time_base is not None:
+                adur = float(a.duration * a.time_base)
+
+            a_cc = a.codec_context
+            audios += (
+                AudioStream(
+                    a_cc.codec.canonical_name,
+                    0 if a_cc.sample_rate is None else a_cc.sample_rate,
+                    a.layout.name,
+                    a_cc.channels,
+                    adur,
+                    0 if a_cc.bit_rate is None else a_cc.bit_rate,
+                    a.language,
+                ),
+            )
+
+        for s in cont.streams.subtitles:
+            codec = s.codec_context.name
+            sub_exts = {"mov_text": "srt", "ass": "ass", "webvtt": "vtt"}
+            ext = sub_exts.get(codec, "vtt")
+            subtitles += (SubtitleStream(codec, ext, s.language),)
+
+        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 / bv.time_base
+
+        cont.close()
+
+        return FileInfo(Path(path), bitrate, dur, desc, videos, audios, subtitles)
+
     def __repr__(self) -> str:
         return f"@{self.path.name}"
-
-
-def initFileInfo(path: str, log: Log) -> FileInfo:
-    try:
-        cont = av.open(path, "r")
-    except av.error.FileNotFoundError:
-        log.error(f"Input file doesn't exist: {path}")
-    except av.error.IsADirectoryError:
-        log.error(f"Expected a media file, but got a directory: {path}")
-    except av.error.InvalidDataError:
-        log.error(f"Invalid data when processing: {path}")
-
-    videos: tuple[VideoStream, ...] = ()
-    audios: tuple[AudioStream, ...] = ()
-    subtitles: tuple[SubtitleStream, ...] = ()
-
-    for v in cont.streams.video:
-        if v.duration is not None and v.time_base is not None:
-            vdur = float(v.duration * v.time_base)
-        else:
-            vdur = 0.0
-
-        fps = v.average_rate
-        if (fps is None or fps < 1) and v.name in {"png", "mjpeg", "webp"}:
-            fps = Fraction(25)
-        if fps is None or fps == 0:
-            fps = Fraction(30)
-
-        sar = Fraction(1) if v.sample_aspect_ratio is None else v.sample_aspect_ratio
-        cc = v.codec_context
-
-        if v.name is None:
-            log.error(f"Can't detect codec for video stream {v}")
-
-        videos += (
-            VideoStream(
-                v.width,
-                v.height,
-                v.name,
-                fps,
-                vdur,
-                sar,
-                v.time_base,
-                getattr(v.format, "name", None),
-                cc.color_range,
-                cc.colorspace,
-                cc.color_primaries,
-                cc.color_trc,
-                0 if v.bit_rate is None else v.bit_rate,
-                v.language,
-            ),
-        )
-
-    for a in cont.streams.audio:
-        adur = 0.0
-        if a.duration is not None and a.time_base is not None:
-            adur = float(a.duration * a.time_base)
-
-        a_cc = a.codec_context
-        audios += (
-            AudioStream(
-                a_cc.codec.canonical_name,
-                0 if a_cc.sample_rate is None else a_cc.sample_rate,
-                a.layout.name,
-                a_cc.channels,
-                adur,
-                0 if a_cc.bit_rate is None else a_cc.bit_rate,
-                a.language,
-            ),
-        )
-
-    for s in cont.streams.subtitles:
-        codec = s.codec_context.name
-        sub_exts = {"mov_text": "srt", "ass": "ass", "webvtt": "vtt"}
-        ext = sub_exts.get(codec, "vtt")
-        subtitles += (SubtitleStream(codec, ext, s.language),)
-
-    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
-
-    cont.close()
-
-    return FileInfo(Path(path), bitrate, dur, desc, videos, audios, subtitles)

auto_editor/formats/fcp11.py

@@ -59,13 +59,6 @@ def fcp11_write_xml(
             return "0s"
         return f"{val * tl.tb.denominator}/{tl.tb.numerator}s"
 
-    src = tl.src
-    assert src is not None
-
-    proj_name = src.path.stem
-    src_dur = int(src.duration * tl.tb)
-    tl_dur = src_dur if resolve else tl.out_len()
-
     if version == 11:
         ver_str = "1.11"
     elif version == 10:
@@ -76,7 +69,16 @@ def fcp11_write_xml(
     fcpxml = Element("fcpxml", version=ver_str)
     resources = SubElement(fcpxml, "resources")
 
+    src_dur = 0
+    tl_dur = 0 if resolve else tl.out_len()
+
     for i, one_src in enumerate(tl.unique_sources()):
+        if i == 0:
+            proj_name = one_src.path.stem
+            src_dur = int(one_src.duration * tl.tb)
+            if resolve:
+                tl_dur = src_dur
+
         SubElement(
             resources,
             "format",
@@ -113,7 +115,7 @@ def fcp11_write_xml(
         format="r1",
         tcStart="0s",
         tcFormat="NDF",
-        audioLayout="mono" if src.audios and src.audios[0].channels == 1 else "stereo",
+        audioLayout=tl.T.layout,
         audioRate="44.1k" if tl.sr == 44100 else "48k",
     )
     spine = SubElement(sequence, "spine")

auto_editor/formats/fcp7.py

@@ -7,8 +7,8 @@ from math import ceil
 from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
 
-from auto_editor.ffwrapper import FileInfo, initFileInfo
-from auto_editor.timeline import ASpace, TlAudio, TlVideo, VSpace, v3
+from auto_editor.ffwrapper import FileInfo
+from auto_editor.timeline import ASpace, Template, TlAudio, TlVideo, VSpace, v3
 
 from .utils import Validator, show
 
@@ -282,7 +282,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                     fileobj = valid.parse(clipitem["file"], {"pathurl": str})
 
                     if "pathurl" in fileobj:
-                        sources[file_id] = initFileInfo(
+                        sources[file_id] = FileInfo.init(
                             uri_to_path(fileobj["pathurl"]),
                             log,
                         )
@@ -317,7 +317,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                 file_id = clipitem["file"].attrib["id"]
                 if file_id not in sources:
                     fileobj = valid.parse(clipitem["file"], {"pathurl": str})
-                    sources[file_id] = initFileInfo(
+                    sources[file_id] = FileInfo.init(
                         uri_to_path(fileobj["pathurl"]), log
                     )
 
@@ -336,10 +336,8 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                     )
                 )
 
-    primary_src = sources[next(iter(sources))]
-    assert type(primary_src) is FileInfo
-
-    return v3(primary_src, tb, sr, res, "#000", vobjs, aobjs, v1=None)
+    T = Template.init(sources[next(iter(sources))], sr, res=res)
+    return v3(tb, "#000", T, vobjs, aobjs, v1=None)
 
 
 def media_def(
@@ -424,13 +422,14 @@ def resolve_write_audio(audio: Element, make_filedef, tl: v3) -> None:
                 clipitem.append(speedup(aclip.speed * 100))
 
 
-def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) -> None:
+def premiere_write_audio(audio: Element, make_filedef, tl: v3) -> None:
     ET.SubElement(audio, "numOutputChannels").text = "2"
     aformat = ET.SubElement(audio, "format")
     aschar = ET.SubElement(aformat, "samplecharacteristics")
     ET.SubElement(aschar, "depth").text = DEPTH
     ET.SubElement(aschar, "samplerate").text = f"{tl.sr}"
 
+    has_video = tl.v and tl.v[0]
     t = 0
     for aclips in tl.a:
         for channelcount in range(0, 2):  # Because "stereo" is hardcoded.
@@ -442,7 +441,7 @@ def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) ->
                 premiereTrackType="Stereo",
             )
 
-            if src.videos:
+            if has_video:
                 ET.SubElement(track, "outputchannelindex").text = f"{channelcount + 1}"
 
             for j, aclip in enumerate(aclips):
@@ -453,7 +452,7 @@ def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) ->
                 _in = f"{aclip.offset}"
                 _out = f"{aclip.offset + aclip.dur}"
 
-                if not src.videos:
+                if not has_video:
                     clip_item_num = j + 1
                 else:
                     clip_item_num = len(aclips) + 1 + j + (t * len(aclips))
@@ -579,7 +578,7 @@ def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3) -> None:
     if resolve:
         resolve_write_audio(audio, make_filedef, tl)
     else:
-        premiere_write_audio(audio, make_filedef, src, tl)
+        premiere_write_audio(audio, make_filedef, tl)
 
     tree = ET.ElementTree(xmeml)
     ET.indent(tree, space="  ", level=0)