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

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "26.3.3"
+__version__ = "27.0.0"

auto_editor/__main__.py

@@ -76,6 +76,7 @@ class Args:
     # Audio Rendering
     audio_codec: str = "auto"
     audio_bitrate: str = "auto"
+    mix_audio_streams: bool = False
     keep_tracks_separate: bool = False
     audio_normalize: str = "#f"
 
@@ -341,10 +342,13 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="BITRATE",
         help="Set the number of bits per second for audio",
     )
+    parser.add_argument(
+        "--mix-audio-streams", flag=True, help="Mix all audio streams together into one"
+    )
     parser.add_argument(
         "--keep-tracks-separate",
         flag=True,
-        help="Don't mix all audio tracks into one when exporting",
+        help="Don't mix all audio streams into one when exporting (default)",
     )
     parser.add_argument(
         "--audio-normalize",
@@ -448,15 +452,15 @@ def main() -> None:
     if args.debug and not args.input:
         buf = StringIO()
         buf.write(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}\n")
-        buf.write(f"Python: {plat.python_version()}\nPyAV: ")
+        buf.write(f"Python: {plat.python_version()}\nAV: ")
         try:
-            import av
+            import bv
         except (ModuleNotFoundError, ImportError):
             buf.write("not found")
         else:
             try:
-                buf.write(f"{av.__version__} ")
-                license = av._core.library_meta["libavcodec"]["license"]
+                buf.write(f"{bv.__version__} ")
+                license = bv._core.library_meta["libavcodec"]["license"]
                 buf.write(f"({license})")
             except AttributeError:
                 buf.write("error")

auto_editor/analyze.py

@@ -9,10 +9,10 @@ from math import ceil
 from tempfile import gettempdir
 from typing import TYPE_CHECKING
 
-import av
+import bv
 import numpy as np
-from av.audio.fifo import AudioFifo
-from av.subtitles.subtitle import AssSubtitle
+from bv.audio.fifo import AudioFifo
+from bv.subtitles.subtitle import AssSubtitle
 
 from auto_editor import __version__
 
@@ -72,7 +72,7 @@ def mut_remove_large(
             active = False
 
 
-def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float32]:
+def iter_audio(audio_stream: bv.AudioStream, tb: Fraction) -> Iterator[np.float32]:
     fifo = AudioFifo()
     sr = audio_stream.rate
 
@@ -80,10 +80,10 @@ def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float3
     accumulated_error = Fraction(0)
 
     # Resample so that audio data is between [-1, 1]
-    resampler = av.AudioResampler(av.AudioFormat("flt"), audio_stream.layout, sr)
+    resampler = bv.AudioResampler(bv.AudioFormat("flt"), audio_stream.layout, sr)
 
     container = audio_stream.container
-    assert isinstance(container, av.container.InputContainer)
+    assert isinstance(container, bv.container.InputContainer)
 
     for frame in container.decode(audio_stream):
         frame.pts = None  # Skip time checks
@@ -103,7 +103,7 @@ def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float3
 
 
 def iter_motion(
-    video: av.VideoStream, tb: Fraction, blur: int, width: int
+    video: bv.VideoStream, tb: Fraction, blur: int, width: int
 ) -> Iterator[np.float32]:
     video.thread_type = "AUTO"
 
@@ -113,7 +113,7 @@ def iter_motion(
     index = 0
     prev_index = -1
 
-    graph = av.filter.Graph()
+    graph = bv.filter.Graph()
     graph.link_nodes(
         graph.add_buffer(template=video),
         graph.add("scale", f"{width}:-1"),
@@ -123,7 +123,7 @@ def iter_motion(
     ).configure()
 
     container = video.container
-    assert isinstance(container, av.container.InputContainer)
+    assert isinstance(container, bv.container.InputContainer)
 
     for unframe in container.decode(video):
         if unframe.pts is None:
@@ -154,7 +154,7 @@ def iter_motion(
 
 @dataclass(slots=True)
 class Levels:
-    container: av.container.InputContainer
+    container: bv.container.InputContainer
     name: str
     mod_time: int
     tb: Fraction
@@ -258,7 +258,7 @@ class Levels:
         if audio.duration is not None and audio.time_base is not None:
             inaccurate_dur = int(audio.duration * audio.time_base * self.tb)
         elif container.duration is not None:
-            inaccurate_dur = int(container.duration / av.time_base * self.tb)
+            inaccurate_dur = int(container.duration / bv.time_base * self.tb)
         else:
             inaccurate_dur = 1024
 
@@ -343,15 +343,9 @@ class Levels:
         for packet in container.demux(subtitle_stream):
             if packet.pts is None or packet.duration is None:
                 continue
-            for subset in packet.decode():
-                # See definition of `AVSubtitle`
-                # in: https://ffmpeg.org/doxygen/trunk/avcodec_8h_source.html
-                start = float(packet.pts * subtitle_stream.time_base)
-                dur = float(packet.duration * subtitle_stream.time_base)
-
-                end = round((start + dur) * self.tb)
-                sub_length = max(sub_length, end)
+            sub_length = max(sub_length, packet.pts + packet.duration)
 
+        sub_length = round(sub_length * subtitle_stream.time_base * self.tb)
         result = np.zeros((sub_length), dtype=np.bool_)
         del sub_length
 
@@ -363,25 +357,25 @@ class Levels:
                 continue
             if early_exit:
                 break
-            for subset in packet.decode():
-                if max_count is not None and count >= max_count:
-                    early_exit = True
-                    break
 
-                start = float(packet.pts * subtitle_stream.time_base)
-                dur = float(packet.duration * subtitle_stream.time_base)
+            if max_count is not None and count >= max_count:
+                early_exit = True
+                break
+
+            start = float(packet.pts * subtitle_stream.time_base)
+            dur = float(packet.duration * subtitle_stream.time_base)
 
-                san_start = round(start * self.tb)
-                san_end = round((start + dur) * self.tb)
+            san_start = round(start * self.tb)
+            san_end = round((start + dur) * self.tb)
 
-                for sub in subset:
-                    if not isinstance(sub, AssSubtitle):
-                        continue
+            for sub in packet.decode():
+                if not isinstance(sub, AssSubtitle):
+                    continue
 
-                    line = sub.dialogue.decode(errors="ignore")
-                    if line and re.search(re_pattern, line):
-                        result[san_start:san_end] = 1
-                        count += 1
+                line = sub.dialogue.decode(errors="ignore")
+                if line and re.search(re_pattern, line):
+                    result[san_start:san_end] = 1
+                    count += 1
 
         container.seek(0)
         return result
@@ -391,8 +385,8 @@ def initLevels(
     src: FileInfo, tb: Fraction, bar: Bar, no_cache: bool, log: Log
 ) -> Levels:
     try:
-        container = av.open(src.path)
-    except av.FFmpegError as e:
+        container = bv.open(src.path)
+    except bv.FFmpegError as e:
         log.error(e)
 
     mod_time = int(src.path.stat().st_mtime)

auto_editor/cmds/info.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass, field
 from typing import Any, Literal, TypedDict
 
 from auto_editor.ffwrapper import initFileInfo
-from auto_editor.lang.json import dump
+from auto_editor.json import dump
 from auto_editor.make_layers import make_sane_timebase
 from auto_editor.timeline import v3
 from auto_editor.utils.func import aspect_ratio

auto_editor/cmds/levels.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from fractions import Fraction
 from typing import TYPE_CHECKING
 
-import av
+import bv
 import numpy as np
 
 from auto_editor.analyze import *
@@ -134,7 +134,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                 if (arr := levels.read_cache("audio", (obj["stream"],))) is not None:
                     print_arr(arr)
                 else:
-                    container = av.open(src.path, "r")
+                    container = bv.open(src.path, "r")
                     audio_stream = container.streams.audio[obj["stream"]]
 
                     values = []
@@ -155,7 +155,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                 if (arr := levels.read_cache("motion", mobj)) is not None:
                     print_arr(arr)
                 else:
-                    container = av.open(src.path, "r")
+                    container = bv.open(src.path, "r")
                     video_stream = container.streams.video[obj["stream"]]
 
                     values = []

auto_editor/cmds/subdump.py

@@ -1,18 +1,72 @@
 import sys
+from dataclasses import dataclass, field
 
-import av
-from av.subtitles.subtitle import AssSubtitle
+import bv
+from bv.subtitles.subtitle import AssSubtitle
+
+from auto_editor.json import dump
+from auto_editor.vanparse import ArgumentParser
+
+
+@dataclass(slots=True)
+class SubdumpArgs:
+    help: bool = False
+    input: list[str] = field(default_factory=list)
+    json: bool = False
 
 
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    for i, input_file in enumerate(sys_args):
-        with av.open(input_file) as container:
+    parser = ArgumentParser("subdump")
+    parser.add_required("input", nargs="*")
+    parser.add_argument("--json", flag=True)
+    args = parser.parse_args(SubdumpArgs, sys_args)
+
+    do_filter = True
+
+    if args.json:
+        data = {}
+        for input_file in args.input:
+            container = bv.open(input_file)
             for s in range(len(container.streams.subtitles)):
-                print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")
-                for subset in container.decode(subtitles=s):
-                    for sub in subset:
+                entry_data = []
+
+                input_stream = container.streams.subtitles[s]
+                assert input_stream.time_base is not None
+                for packet in container.demux(input_stream):
+                    if (
+                        packet.dts is None
+                        or packet.pts is None
+                        or packet.duration is None
+                    ):
+                        continue
+
+                    start = packet.pts * input_stream.time_base
+                    end = start + packet.duration * input_stream.time_base
+
+                    startf = round(float(start), 3)
+                    endf = round(float(end), 3)
+
+                    if do_filter and endf - startf <= 0.02:
+                        continue
+
+                    for sub in packet.decode():
                         if isinstance(sub, AssSubtitle):
-                            print(sub.ass.decode("utf-8", errors="ignore"))
+                            content = sub.dialogue.decode("utf-8", errors="ignore")
+                            entry_data.append([startf, endf, content])
+
+                data[f"{input_file}:{s}"] = entry_data
+            container.close()
+
+        dump(data, sys.stdout, indent=4)
+        return
+
+    for i, input_file in enumerate(args.input):
+        with bv.open(input_file) as container:
+            for s in range(len(container.streams.subtitles)):
+                print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")
+                for sub2 in container.decode(subtitles=s):
+                    if isinstance(sub2, AssSubtitle):
+                        print(sub2.ass.decode("utf-8", errors="ignore"))
         print("------")
 
 

auto_editor/cmds/test.py

@@ -11,7 +11,7 @@ from hashlib import sha256
 from tempfile import mkdtemp
 from time import perf_counter
 
-import av
+import bv
 import numpy as np
 
 from auto_editor.ffwrapper import FileInfo, initFileInfo
@@ -73,6 +73,10 @@ def calculate_sha256(filename: str) -> str:
     return sha256_hash.hexdigest()
 
 
+class SkipTest(Exception):
+    pass
+
+
 class Runner:
     def __init__(self) -> None:
         self.program = [sys.executable, "-m", "auto_editor"]
@@ -157,35 +161,35 @@ class Runner:
         file = "resources/testsrc.mp4"
         out = self.main([file], ["--faststart"]) + ".mp4"
         fast = calculate_sha256(out)
-        with av.open(out) as container:
-            assert isinstance(container.streams[0], av.VideoStream)
-            assert isinstance(container.streams[1], av.AudioStream)
+        with bv.open(out) as container:
+            assert isinstance(container.streams[0], bv.VideoStream)
+            assert isinstance(container.streams[1], bv.AudioStream)
 
         out = self.main([file], ["--no-faststart"]) + ".mp4"
         nofast = calculate_sha256(out)
-        with av.open(out) as container:
-            assert isinstance(container.streams[0], av.VideoStream)
-            assert isinstance(container.streams[1], av.AudioStream)
+        with bv.open(out) as container:
+            assert isinstance(container.streams[0], bv.VideoStream)
+            assert isinstance(container.streams[1], bv.AudioStream)
 
         out = self.main([file], ["--fragmented"]) + ".mp4"
         frag = calculate_sha256(out)
-        with av.open(out) as container:
-            assert isinstance(container.streams[0], av.VideoStream)
-            assert isinstance(container.streams[1], av.AudioStream)
+        with bv.open(out) as container:
+            assert isinstance(container.streams[0], bv.VideoStream)
+            assert isinstance(container.streams[1], bv.AudioStream)
 
         assert fast != nofast, "+faststart is not being applied"
         assert frag not in (fast, nofast), "fragmented output should diff."
 
     def test_example(self) -> None:
         out = self.main(["example.mp4"], [], output="example_ALTERED.mp4")
-        with av.open(out) as container:
+        with bv.open(out) as container:
             assert container.duration is not None
             assert container.duration > 17300000 and container.duration < 2 << 24
 
             video = container.streams[0]
             audio = container.streams[1]
-            assert isinstance(video, av.VideoStream)
-            assert isinstance(audio, av.AudioStream)
+            assert isinstance(video, bv.VideoStream)
+            assert isinstance(audio, bv.AudioStream)
             assert video.base_rate == 30
             assert video.average_rate is not None
             assert video.average_rate == 30, video.average_rate
@@ -261,19 +265,19 @@ class Runner:
         self.check([path, "--no-open"], "must have an extension")
 
     def test_silent_threshold(self):
-        with av.open("resources/new-commentary.mp3") as container:
-            assert container.duration / av.time_base == 6.732
+        with bv.open("resources/new-commentary.mp3") as container:
+            assert container.duration / bv.time_base == 6.732
 
         out = self.main(
             ["resources/new-commentary.mp3"], ["--edit", "audio:threshold=0.1"]
         )
         out += ".mp3"
 
-        with av.open(out) as container:
-            assert container.duration / av.time_base == 6.552
+        with bv.open(out) as container:
+            assert container.duration / bv.time_base == 6.552
 
     def test_track(self):
-        out = self.main(["resources/multi-track.mov"], ["--keep_tracks_seperate"], "te")
+        out = self.main(["resources/multi-track.mov"], []) + ".mov"
         assert len(fileinfo(out).audios) == 2
 
     def test_export_json(self):
@@ -357,30 +361,24 @@ class Runner:
             ["--edit", "audio:stream=1"],
             "multi-track_ALTERED.mov",
         )
-        assert len(fileinfo(out).audios) == 1
+        assert len(fileinfo(out).audios) == 2
 
     def test_concat(self):
         out = self.main(["example.mp4"], ["--cut-out", "0,171"], "hmm.mp4")
         self.main(["example.mp4", out], ["--debug"])
 
     def test_concat_mux_tracks(self):
-        out = self.main(
-            ["example.mp4", "resources/multi-track.mov"], [], "concat_mux.mov"
-        )
+        inputs = ["example.mp4", "resources/multi-track.mov"]
+        out = self.main(inputs, ["--mix-audio-streams"], "concat_mux.mov")
         assert len(fileinfo(out).audios) == 1
 
     def test_concat_multi_tracks(self):
         out = self.main(
-            ["resources/multi-track.mov", "resources/multi-track.mov"],
-            ["--keep-tracks-separate"],
-            "out.mov",
+            ["resources/multi-track.mov", "resources/multi-track.mov"], [], "out.mov"
         )
         assert len(fileinfo(out).audios) == 2
-        out = self.main(
-            ["example.mp4", "resources/multi-track.mov"],
-            ["--keep-tracks-separate"],
-            "out.mov",
-        )
+        inputs = ["example.mp4", "resources/multi-track.mov"]
+        out = self.main(inputs, [], "out.mov")
         assert len(fileinfo(out).audios) == 2
 
     def test_frame_rate(self):
@@ -464,6 +462,21 @@ class Runner:
         out2 = self.main([out], ["-c:v", "prores"], "prores2.mkv")
         assert fileinfo(out2).videos[0].pix_fmt == "yuv422p10le"
 
+    def test_decode_hevc(self):
+        out = self.main(["resources/testsrc-hevc.mp4"], ["-c:v", "h264"]) + ".mp4"
+        output = fileinfo(out)
+        assert output.videos[0].codec == "h264"
+        assert output.videos[0].pix_fmt == "yuv420p"
+
+    def test_encode_hevc(self):
+        if os.environ.get("GITHUB_ACTIONS") == "true":
+            raise SkipTest()
+
+        out = self.main(["resources/testsrc.mp4"], ["-c:v", "hevc"], "out.mkv")
+        output = fileinfo(out)
+        assert output.videos[0].codec == "hevc"
+        assert output.videos[0].pix_fmt == "yuv420p"
+
     #  Issue 280
     def test_SAR(self):
         out = self.main(["resources/SAR-2by3.mp4"], [], "2by3_out.mp4")
@@ -646,16 +659,21 @@ def run_tests(runner: Runner, tests: list[Callable], args: TestArgs) -> None:
 
     def timed_test(test_func):
         start_time = perf_counter()
+        skipped = False
         try:
             test_func()
             success = True
+        except SkipTest:
+            skipped = True
         except Exception as e:
             success = False
             exception = e
         end_time = perf_counter()
         duration = end_time - start_time
 
-        if success:
+        if skipped:
+            return (SkipTest, duration, None)
+        elif success:
             return (True, duration, None)
         else:
             return (False, duration, exception)
@@ -674,17 +692,15 @@ def run_tests(runner: Runner, tests: list[Callable], args: TestArgs) -> None:
             total_time += dur
             index += 1
 
-            if success:
+            msg = f"{name:<26} ({index}/{total})  {round(dur, 2):<5} secs  "
+            if success == SkipTest:
                 passed += 1
-                print(
-                    f"{name:<26} ({index}/{total})  {round(dur, 2):<4} secs  [\033[1;32mPASSED\033[0m]",
-                    flush=True,
-                )
+                print(f"{msg}[\033[38;2;125;125;125;mSKIPPED\033[0m]", flush=True)
+            elif success:
+                passed += 1
+                print(f"{msg}[\033[1;32mPASSED\033[0m]", flush=True)
             else:
-                print(
-                    f"{name:<26} ({index}/{total})  {round(dur, 2):<4} secs  \033[1;31m[FAILED]\033[0m",
-                    flush=True,
-                )
+                print(f"{msg}\033[1;31m[FAILED]\033[0m", flush=True)
                 if args.no_fail_fast:
                     print(f"\n{exception}")
                 else: