auto-editor 25.2.0__py3-none-any.whl → 25.3.1__py3-none-any.whl

auto_editor/output.py

@@ -46,9 +46,9 @@ class Ensure:
             astream = in_container.streams.audio[stream]
 
             if astream.duration is None or astream.time_base is None:
-                dur = 1
+                dur = 1.0
             else:
-                dur = int(astream.duration * astream.time_base)
+                dur = float(astream.duration * astream.time_base)
 
             bar.start(dur, "Extracting audio")
 
@@ -58,8 +58,8 @@ class Ensure:
 
             resampler = AudioResampler(format="s16", layout="stereo", rate=sample_rate)
             for i, frame in enumerate(in_container.decode(astream)):
-                if i % 1500 == 0:
-                    bar.tick(0 if frame.time is None else frame.time)
+                if i % 1500 == 0 and frame.time is not None:
+                    bar.tick(frame.time)
 
                 for new_frame in resampler.resample(frame):
                     for packet in output_astream.encode(new_frame):
@@ -237,8 +237,8 @@ def mux_quality_media(
     if s_tracks > 0:
         cmd.extend(["-map", "0:t?"])  # Add input attachments to output.
 
-    # This was causing a crash for 'example.mp4 multi-track.mov'
-    # cmd.extend(["-map", "0:d?"])
+    if not args.dn:
+        cmd.extend(["-map", "0:d?"])
 
     cmd.append(output_path)
-    ffmpeg.run_check_errors(cmd, log, path=output_path)
+    ffmpeg.run_check_errors(cmd, path=output_path)

auto_editor/preview.py

@@ -7,7 +7,7 @@ from typing import TextIO
 
 from auto_editor.analyze import Levels
 from auto_editor.timeline import v3
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.func import to_timecode
 from auto_editor.utils.log import Log
 
@@ -65,7 +65,7 @@ def preview(tl: v3, log: Log) -> None:
 
     in_len = 0
     for src in all_sources:
-        in_len += Levels(src, tb, Bar("none"), False, log, False).media_length
+        in_len += Levels(src, tb, initBar("none"), False, log, False).media_length
 
     out_len = tl.out_len()
 

auto_editor/render/audio.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import io
 from pathlib import Path
 from platform import system
 from subprocess import PIPE
 
+import av
 import numpy as np
 
 from auto_editor.ffwrapper import FFmpeg, FileInfo
@@ -12,7 +14,7 @@ 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
 from auto_editor.output import Ensure
-from auto_editor.timeline import v3
+from auto_editor.timeline import TlAudio, v3
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.log import Log
@@ -165,6 +167,67 @@ def apply_audio_normalization(
     ffmpeg.run(["-i", f"{pre_master}"] + cmd + [f"{path}"])
 
 
+def process_audio_clip(
+    clip: TlAudio, samp_list: AudioData, samp_start: int, samp_end: int, sr: int
+) -> AudioData:
+    input_buffer = io.BytesIO()
+    write(input_buffer, sr, samp_list[samp_start:samp_end])
+    input_buffer.seek(0)
+
+    input_file = av.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_stream = output_file.add_stream("pcm_s16le", rate=sr)
+
+    graph = av.filter.Graph()
+    args = [graph.add_abuffer(template=input_stream)]
+
+    if clip.speed != 1:
+        if clip.speed > 10_000:
+            for _ in range(3):
+                args.append(graph.add("atempo", f"{clip.speed ** (1/3)}"))
+        elif clip.speed > 100:
+            for _ in range(2):
+                args.append(graph.add("atempo", f"{clip.speed ** 0.5}"))
+        elif clip.speed >= 0.5:
+            args.append(graph.add("atempo", f"{clip.speed}"))
+        else:
+            start = 0.5
+            while start * 0.5 > clip.speed:
+                start *= 0.5
+                args.append(graph.add("atempo", "0.5"))
+            args.append(graph.add("atempo", f"{clip.speed / start}"))
+
+    if clip.volume != 1:
+        args.append(graph.add("volume", f"{clip.volume}"))
+
+    args.append(graph.add("abuffersink"))
+    graph.link_nodes(*args).configure()
+
+    for frame in input_file.decode(input_stream):
+        graph.push(frame)
+        while True:
+            try:
+                aframe = graph.pull()
+                assert isinstance(aframe, av.AudioFrame)
+                for packet in output_stream.encode(aframe):
+                    output_file.mux(packet)
+            except (av.BlockingIOError, av.EOFError):
+                break
+
+    # Flush the stream
+    for packet in output_stream.encode(None):
+        output_file.mux(packet)
+
+    input_file.close()
+    output_file.close()
+
+    output_bytes.seek(0)
+    return read(output_bytes)[1]
+
+
 def make_new_audio(
     tl: v3, ensure: Ensure, args: Args, ffmpeg: FFmpeg, bar: Bar, log: Log
 ) -> list[str]:
@@ -175,7 +238,6 @@ def make_new_audio(
 
     norm = parse_norm(args.audio_normalize, log)
 
-    af_tick = 0
     temp = log.temp
 
     if not tl.a or not tl.a[0]:
@@ -191,7 +253,8 @@ def make_new_audio(
         for c, clip in enumerate(layer):
             if (clip.src, clip.stream) not in samples:
                 audio_path = ensure.audio(clip.src, clip.stream)
-                samples[(clip.src, clip.stream)] = read(audio_path)[1]
+                with open(audio_path, "rb") as file:
+                    samples[(clip.src, clip.stream)] = read(file)[1]
 
             if arr is None:
                 leng = max(round((layer[-1].start + layer[-1].dur) * sr / tb), sr // tb)
@@ -214,42 +277,10 @@ def make_new_audio(
             if samp_end > len(samp_list):
                 samp_end = len(samp_list)
 
-            filters: list[str] = []
-
-            if clip.speed != 1:
-                if clip.speed > 10_000:
-                    filters.extend([f"atempo={clip.speed}^.33333"] * 3)
-                elif clip.speed > 100:
-                    filters.extend(
-                        [f"atempo=sqrt({clip.speed})", f"atempo=sqrt({clip.speed})"]
-                    )
-                elif clip.speed >= 0.5:
-                    filters.append(f"atempo={clip.speed}")
-                else:
-                    start = 0.5
-                    while start * 0.5 > clip.speed:
-                        start *= 0.5
-                        filters.append("atempo=0.5")
-                    filters.append(f"atempo={clip.speed / start}")
-
-            if clip.volume != 1:
-                filters.append(f"volume={clip.volume}")
-
-            if not filters:
-                clip_arr = samp_list[samp_start:samp_end]
+            if clip.speed != 1 or clip.volume != 1:
+                clip_arr = process_audio_clip(clip, samp_list, samp_start, samp_end, sr)
             else:
-                af = Path(temp, f"af{af_tick}.wav")
-                af_out = Path(temp, f"af{af_tick}_out.wav")
-
-                # Windows can't replace a file that's already in use, so we have to
-                # cycle through file names.
-                af_tick = (af_tick + 1) % 3
-
-                with open(af, "wb") as fid:
-                    write(fid, sr, samp_list[samp_start:samp_end])
-
-                ffmpeg.run(["-i", f"{af}", "-af", ",".join(filters), f"{af_out}"])
-                clip_arr = read(f"{af_out}")[1]
+                clip_arr = samp_list[samp_start:samp_end]
 
             # Mix numpy arrays
             start = clip.start * sr // tb

auto_editor/render/subtitle.py

@@ -112,13 +112,15 @@ class SubtitleParser:
         self.contents = new_content
 
     def write(self, file_path: str) -> None:
+        codec = self.codec
         with open(file_path, "w", encoding="utf-8") as file:
             file.write(self.header)
             for c in self.contents:
                 file.write(
-                    f"{c.before}{to_timecode(c.start / self.tb, self.codec)}"
-                    f"{c.middle}{to_timecode(c.end / self.tb, self.codec)}"
-                    f"{c.after}"
+                    f"{c.before}{to_timecode(c.start / self.tb, codec)}"
+                    + f"{c.middle}{to_timecode(c.end / self.tb, codec)}"
+                    + c.after
+                    + ("\n" if codec == "webvtt" else "")
                 )
             file.write(self.footer)
 

auto_editor/render/video.py

@@ -339,7 +339,7 @@ def render_av(
         process2.wait()
     except (OSError, BrokenPipeError):
         bar.end()
-        ffmpeg.run_check_errors(cmd, log, True)
+        ffmpeg.run_check_errors(cmd, True)
         log.error("FFmpeg Error!")
 
     log.debug(f"Total frames saved seeking: {frames_saved}")

auto_editor/subcommands/levels.py

@@ -11,7 +11,7 @@ from auto_editor.analyze import LevelError, Levels, iter_audio, iter_motion
 from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import is_bool, is_nat, is_nat1, is_str, is_void, orc
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.cmdkw import (
     ParserError,
     Required,
@@ -83,7 +83,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     parser = levels_options(ArgumentParser("levels"))
     args = parser.parse_args(LevelArgs, sys_args)
 
-    bar = Bar("none")
+    bar = initBar("none")
     log = Log(quiet=True)
 
     sources = [initFileInfo(path, log) for path in args.input]

auto_editor/subcommands/repl.py

@@ -11,7 +11,7 @@ from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lang.stdenv import make_standard_env
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import frame_rate
 from auto_editor.vanparse import ArgumentParser
@@ -64,9 +64,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         sources = [initFileInfo(path, log) for path in args.input]
         src = sources[0]
         tb = src.get_fps() if args.timebase is None else args.timebase
-        bar = Bar("modern")
         env["timebase"] = tb
-        env["@levels"] = Levels(src, tb, bar, False, log, strict)
+        env["@levels"] = Levels(src, tb, initBar("modern"), False, log, strict)
 
     env.update(make_standard_env())
     print(f"Auto-Editor {auto_editor.__version__}")

auto_editor/subcommands/test.py

@@ -186,7 +186,7 @@ def main(sys_args: list[str] | None = None):
         "wav/pcm-f32le.wav",
         "wav/pcm-s32le.wav",
         "multi-track.mov",
-        "subtitle.mp4",
+        "mov_text.mp4",
         "testsrc.mkv",
     )
 
@@ -222,7 +222,8 @@ def main(sys_args: list[str] | None = None):
         run.raw(["levels", "resources/new-commentary.mp3"])
 
     def subdump():
-        run.raw(["subdump", "resources/subtitle.mp4"])
+        run.raw(["subdump", "resources/mov_text.mp4"])
+        run.raw(["subdump", "resources/webvtt.mkv"])
 
     def desc():
         run.raw(["desc", "example.mp4"])
@@ -357,7 +358,13 @@ def main(sys_args: list[str] | None = None):
         run.main(["example.mp4"], ["--export", 'premiere:name="Foo Bar"'])
 
     def export_subtitles():
-        cn = fileinfo(run.main(["resources/subtitle.mp4"], []))
+        cn = fileinfo(run.main(["resources/mov_text.mp4"], []))
+
+        assert len(cn.videos) == 1
+        assert len(cn.audios) == 1
+        assert len(cn.subtitles) == 1
+
+        cn = fileinfo(run.main(["resources/webvtt.mkv"], []))
 
         assert len(cn.videos) == 1
         assert len(cn.audios) == 1
@@ -405,7 +412,8 @@ def main(sys_args: list[str] | None = None):
             test_file = f"resources/{test_name}"
             results.add(run.main([test_file], []))
             run.main([test_file], ["--edit", "none"])
-            results.add(run.main([test_file], ["-exf"]))
+            results.add(run.main([test_file], ["--export", "final-cut-pro:version=10"]))
+            results.add(run.main([test_file], ["--export", "final-cut-pro:version=11"]))
             results.add(run.main([test_file], ["-exs"]))
             results.add(run.main([test_file], ["--export_as_clip_sequence"]))
             run.main([test_file], ["--stats"])

auto_editor/timeline.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from auto_editor.ffwrapper import initFileInfo, mux
 from auto_editor.lib.contracts import *
 from auto_editor.utils.cmdkw import Required, pAttr, pAttrs
 from auto_editor.utils.types import color, natural, number, threshold
@@ -10,10 +11,12 @@ from auto_editor.utils.types import color, natural, number, threshold
 if TYPE_CHECKING:
     from collections.abc import Iterator
     from fractions import Fraction
+    from pathlib import Path
     from typing import Any
 
     from auto_editor.ffwrapper import FileInfo
     from auto_editor.utils.chunks import Chunks
+    from auto_editor.utils.log import Log
 
 
 @dataclass(slots=True)
@@ -241,6 +244,13 @@ video\n"""
             for a in aclips:
                 yield a.src
 
+    def unique_sources(self) -> Iterator[FileInfo]:
+        seen = set()
+        for source in self.sources:
+            if source.path not in seen:
+                seen.add(source.path)
+                yield source
+
     def _duration(self, layer: Any) -> int:
         total_dur = 0
         for clips in layer:
@@ -276,3 +286,38 @@ video\n"""
             "v": v,
             "a": a,
         }
+
+
+def make_tracks_dir(path: Path) -> Path:
+    from os import mkdir
+    from shutil import rmtree
+
+    tracks_dir = path.parent / f"{path.stem}_tracks"
+
+    try:
+        mkdir(tracks_dir)
+    except OSError:
+        rmtree(tracks_dir)
+        mkdir(tracks_dir)
+
+    return tracks_dir
+
+
+def set_stream_to_0(tl: v3, log: Log) -> None:
+    src = tl.src
+    assert src is not None
+    fold = make_tracks_dir(src.path)
+    cache: dict[Path, FileInfo] = {}
+
+    def make_track(i: int, path: Path) -> FileInfo:
+        newtrack = fold / f"{path.stem}_{i}.wav"
+        if newtrack not in cache:
+            mux(path, output=newtrack, stream=i)
+            cache[newtrack] = initFileInfo(f"{newtrack}", log)
+        return cache[newtrack]
+
+    for alayer in tl.a:
+        for aobj in alayer:
+            if aobj.stream > 0:
+                aobj.src = make_track(aobj.stream, aobj.src.path)
+                aobj.stream = 0

auto_editor/utils/bar.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import sys
+from dataclasses import dataclass
 from math import floor
 from shutil import get_terminal_size
 from time import localtime, time
@@ -8,39 +9,50 @@ from time import localtime, time
 from .func import get_stdout_bytes
 
 
-class Bar:
-    def __init__(self, bar_type: str) -> None:
-        self.machine = False
-        self.hide = False
+def initBar(bar_type: str) -> Bar:
+    icon = "⏳"
+    chars: tuple[str, ...] = (" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█")
+    brackets = ("|", "|")
+    machine = hide = False
+
+    if bar_type == "classic":
+        icon = "⏳"
+        chars = ("░", "█")
+        brackets = ("[", "]")
+    if bar_type == "ascii":
+        icon = "& "
+        chars = ("-", "#")
+        brackets = ("[", "]")
+    if bar_type == "machine":
+        machine = True
+    if bar_type == "none":
+        hide = True
+
+    part_width = len(chars) - 1
+
+    ampm = True
+    if sys.platform == "darwin" and bar_type in ("modern", "classic", "ascii"):
+        try:
+            date_format = get_stdout_bytes(
+                ["defaults", "read", "com.apple.menuextra.clock", "Show24Hour"]
+            )
+            ampm = date_format == b"0\n"
+        except FileNotFoundError:
+            pass
 
-        self.icon = "⏳"
-        self.chars: tuple[str, ...] = (" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█")
-        self.brackets = ("|", "|")
+    return Bar(icon, chars, brackets, machine, hide, part_width, ampm, [])
 
-        if bar_type == "classic":
-            self.icon = "⏳"
-            self.chars = ("░", "█")
-            self.brackets = ("[", "]")
-        if bar_type == "ascii":
-            self.icon = "& "
-            self.chars = ("-", "#")
-            self.brackets = ("[", "]")
-        if bar_type == "machine":
-            self.machine = True
-        if bar_type == "none":
-            self.hide = True
-
-        self.part_width = len(self.chars) - 1
-
-        self.ampm = True
-        if sys.platform == "darwin" and bar_type in ("modern", "classic", "ascii"):
-            try:
-                date_format = get_stdout_bytes(
-                    ["defaults", "read", "com.apple.menuextra.clock", "Show24Hour"]
-                )
-                self.ampm = date_format == b"0\n"
-            except FileNotFoundError:
-                pass
+
+@dataclass(slots=True)
+class Bar:
+    icon: str
+    chars: tuple[str, ...]
+    brackets: tuple[str, str]
+    machine: bool
+    hide: bool
+    part_width: int
+    ampm: bool
+    stack: list[tuple[str, int, float, float]]
 
     @staticmethod
     def pretty_time(my_time: float, ampm: bool) -> str:
@@ -62,28 +74,25 @@ class Bar:
         if self.hide:
             return
 
-        progress = 0.0 if self.total == 0 else min(1, max(0, index / self.total))
-        rate = 0.0 if progress == 0 else (time() - self.begin_time) / progress
+        title, len_title, total, begin = self.stack[-1]
+        progress = 0.0 if total == 0 else min(1, max(0, index / total))
+        rate = 0.0 if progress == 0 else (time() - begin) / progress
 
         if self.machine:
-            index = min(index, self.total)
-            secs_til_eta = round(self.begin_time + rate - time(), 2)
-            print(
-                f"{self.title}~{index}~{self.total}~{secs_til_eta}",
-                end="\r",
-                flush=True,
-            )
+            index = min(index, total)
+            secs_til_eta = round(begin + rate - time(), 2)
+            print(f"{title}~{index}~{total}~{secs_til_eta}", end="\r", flush=True)
             return
 
-        new_time = self.pretty_time(self.begin_time + rate, self.ampm)
+        new_time = self.pretty_time(begin + rate, self.ampm)
 
         percent = round(progress * 100, 1)
         p_pad = " " * (4 - len(str(percent)))
         columns = get_terminal_size().columns
-        bar_len = max(1, columns - (self.len_title + 32))
+        bar_len = max(1, columns - (len_title + 32))
         bar_str = self._bar_str(progress, bar_len)
 
-        bar = f"  {self.icon}{self.title} {bar_str} {p_pad}{percent}%  ETA {new_time}"
+        bar = f"  {self.icon}{title} {bar_str} {p_pad}{percent}%  ETA {new_time}"
 
         if len(bar) > columns - 2:
             bar = bar[: columns - 2]
@@ -93,10 +102,7 @@ class Bar:
         sys.stdout.write(bar + "\r")
 
     def start(self, total: float, title: str = "Please wait") -> None:
-        self.title = title
-        self.len_title = len(title)
-        self.total = total
-        self.begin_time = time()
+        self.stack.append((title, len(title), total, time()))
 
         try:
             self.tick(0)
@@ -124,6 +130,7 @@ class Bar:
         )
         return line
 
-    @staticmethod
-    def end() -> None:
+    def end(self) -> None:
         sys.stdout.write(" " * (get_terminal_size().columns - 2) + "\r")
+        if self.stack:
+            self.stack.pop()

auto_editor/utils/func.py

@@ -10,8 +10,6 @@ if TYPE_CHECKING:
 
     from numpy.typing import NDArray
 
-    from auto_editor.utils.log import Log
-
     BoolList = NDArray[np.bool_]
     BoolOperand = Callable[[BoolList, BoolList], BoolList]
 
@@ -135,30 +133,6 @@ def human_readable_time(time_in_secs: float) -> str:
     return f"{time_in_secs} {units}"
 
 
-def open_with_system_default(path: str, log: Log) -> None:
-    import sys
-    from subprocess import run
-
-    if sys.platform == "win32":
-        from os import startfile
-
-        try:
-            startfile(path)
-        except OSError:
-            log.warning("Could not find application to open file.")
-    else:
-        try:  # MacOS case
-            run(["open", path])
-        except Exception:
-            try:  # WSL2 case
-                run(["cmd.exe", "/C", "start", path])
-            except Exception:
-                try:  # Linux case
-                    run(["xdg-open", path])
-                except Exception:
-                    log.warning("Could not open output file.")
-
-
 def append_filename(path: str, val: str) -> str:
     from os.path import splitext
 

auto_editor/utils/types.py

@@ -224,6 +224,7 @@ class Args:
     scale: float = 1.0
     extras: str | None = None
     sn: bool = False
+    dn: bool = False
     no_seek: bool = False
     cut_out: list[tuple[str, str]] = field(default_factory=list)
     add_in: list[tuple[str, str]] = field(default_factory=list)