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

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"]
@@ -153,36 +157,42 @@ class Runner:
     def desc(self):
         self.raw(["desc", "example.mp4"])
 
+    def test_movflags(self) -> None:
+        file = "resources/testsrc.mp4"
+        out = self.main([file], ["--faststart"]) + ".mp4"
+        fast = calculate_sha256(out)
+        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 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 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:
-            video = container.streams[0]
-            audio = container.streams[1]
-
-            assert isinstance(video, av.VideoStream)
-            assert isinstance(audio, av.AudioStream)
-            assert video.base_rate == 30
-            assert video.average_rate is not None
-            assert video.average_rate == 30, video.average_rate
-            assert (video.width, video.height) == (1280, 720)
-            assert video.codec.name == "h264"
-            assert video.language == "eng"
-            assert audio.codec.name == "aac"
-            assert audio.sample_rate == 48000
-            assert audio.language == "eng"
-
-        out1_sha = calculate_sha256(out)
+        with bv.open(out) as container:
+            assert container.duration is not None
+            assert container.duration > 17300000 and container.duration < 2 << 24
 
-        out = self.main(["example.mp4"], ["--fragmented"], output="example_ALTERED.mp4")
-        with av.open(out) as container:
             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 round(video.average_rate) == 30, video.average_rate
+            assert video.average_rate == 30, video.average_rate
             assert (video.width, video.height) == (1280, 720)
             assert video.codec.name == "h264"
             assert video.language == "eng"
@@ -190,8 +200,6 @@ class Runner:
             assert audio.sample_rate == 48000
             assert audio.language == "eng"
 
-        assert calculate_sha256(out) != out1_sha, "Fragmented output should be diff."
-
     # PR #260
     def test_high_speed(self):
         self.check(["example.mp4", "--video-speed", "99998"], "empty")
@@ -257,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):
@@ -353,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):
@@ -460,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")
@@ -642,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)
@@ -670,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:

auto_editor/edit.py

@@ -6,10 +6,10 @@ from fractions import Fraction
 from heapq import heappop, heappush
 from os.path import splitext
 from subprocess import run
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-import av
-from av import AudioResampler, Codec
+import bv
+from bv import AudioResampler, Codec
 
 from auto_editor.ffwrapper import FileInfo, initFileInfo
 from auto_editor.lib.contracts import is_int, is_str
@@ -24,7 +24,9 @@ from auto_editor.utils.chunks import Chunk, Chunks
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.container import Container, container_constructor
 from auto_editor.utils.log import Log
-from auto_editor.utils.types import Args
+
+if TYPE_CHECKING:
+    from auto_editor.__main__ import Args
 
 
 def set_output(
@@ -81,18 +83,10 @@ def set_video_codec(
             return ctr.default_vid
         return codec
 
-    if codec == "copy":
-        log.deprecated("The `copy` codec is deprecated. auto-editor always re-encodes")
-        if src is None:
-            log.error("No input to copy its codec from.")
-        if not src.videos:
-            log.error("Input file does not have a video stream to copy codec from.")
-        codec = src.videos[0].codec
-
     if ctr.vcodecs is not None and codec not in ctr.vcodecs:
         try:
             cobj = Codec(codec, "w")
-        except av.codec.codec.UnknownCodecError:
+        except bv.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
         if cobj.id not in (Codec(x, "w").id for x in ctr.vcodecs):
@@ -109,7 +103,7 @@ def set_audio_codec(
             codec = "aac"
         else:
             codec = src.audios[0].codec
-            if av.Codec(codec, "w").audio_formats is None:
+            if bv.Codec(codec, "w").audio_formats is None:
                 codec = "aac"
         if codec not in ctr.acodecs and ctr.default_aud != "none":
             codec = ctr.default_aud
@@ -117,18 +111,10 @@ def set_audio_codec(
             codec = "aac"
         return codec
 
-    if codec == "copy":
-        log.deprecated("The `copy` codec is deprecated. auto-editor always re-encodes")
-        if src is None:
-            log.error("No input to copy its codec from.")
-        if not src.audios:
-            log.error("Input file does not have an audio stream to copy codec from.")
-        codec = src.audios[0].codec
-
     if ctr.acodecs is None or codec not in ctr.acodecs:
         try:
             cobj = Codec(codec, "w")
-        except av.codec.codec.UnknownCodecError:
+        except bv.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
         if cobj.id not in (Codec(x, "w").id for x in ctr.acodecs):
@@ -176,6 +162,10 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     bar = initBar(args.progress)
     tl = None
 
+    if args.keep_tracks_separate:
+        log.deprecated("--keep-tracks-separate is deprecated.")
+        args.keep_tracks_separate = False
+
     if paths:
         path_ext = splitext(paths[0])[1].lower()
         if path_ext == ".xml":
@@ -206,7 +196,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
 
     del paths
 
-    output, export_ops = set_output(args.output_file, args.export, src, log)
+    output, export_ops = set_output(args.output, args.export, src, log)
     assert "export" in export_ops
     export = export_ops["export"]
 
@@ -219,10 +209,6 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         if os.path.isdir(output):
             log.error("Output path already has an existing directory!")
 
-        if os.path.isfile(output) and src is not None and src.path != output:  # type: ignore
-            log.debug(f"Removing already existing file: {output}")
-            os.remove(output)
-
     if args.sample_rate is None:
         if tl is None:
             samplerate = 48000 if src is None else src.get_sr()
@@ -291,52 +277,53 @@ 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:
-            log.debug("Enabling fragmented mp4/mov")
-            options = {
-                "movflags": "+default_base_moof+faststart+frag_keyframe+separate_moof",
-                "frag_duration": "0.2",
-            }
-        else:
-            options = {"movflags": "faststart"}
-        output = av.open(output_path, "w", options=options)
+            mov_flags.extend(["default_base_moof", "frag_keyframe", "separate_moof"])
+            options["frag_duration"] = "0.2"
+            if args.faststart:
+                log.warning("Fragmented is enabled, will not apply faststart.")
+        elif not args.no_faststart:
+            mov_flags.append("faststart")
+        if mov_flags:
+            options["movflags"] = "+".join(mov_flags)
 
-        if ctr.default_sub != "none" and not args.sn:
-            sub_paths = make_new_subtitles(tl, log)
+        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: bv.VideoStream | None
+            output_stream = next(vframes)  # type: ignore
         else:
-            sub_paths = []
+            output_stream, vframes = None, iter([])
 
+        # Setup audio
         if ctr.default_aud != "none":
             ensure = Ensure(bar, samplerate, log)
             audio_paths = make_new_audio(tl, ctr, ensure, args, bar, log)
         else:
             audio_paths = []
 
-        # Setup video
-        if ctr.default_vid != "none" and tl.v:
-            vframes = render_av(output, tl, args, log)
-            output_stream = next(vframes)
-        else:
-            output_stream, vframes = None, iter([])
+        if len(audio_paths) > 1 and ctr.max_audios == 1:
+            log.warning("Dropping extra audio streams (container only allows one)")
+            audio_paths = audio_paths[0:1]
 
-        # Setup audio
         if audio_paths:
             try:
-                audio_encoder = av.Codec(args.audio_codec, "w")
-            except av.FFmpegError as e:
+                audio_encoder = bv.Codec(args.audio_codec, "w")
+            except bv.FFmpegError as e:
                 log.error(e)
             if audio_encoder.audio_formats is None:
                 log.error(f"{args.audio_codec}: No known audio formats avail.")
             audio_format = audio_encoder.audio_formats[0]
             resampler = AudioResampler(format=audio_format, layout="stereo", rate=tl.sr)
 
-        audio_streams: list[av.AudioStream] = []
+        audio_streams: list[bv.AudioStream] = []
         audio_inputs = []
         audio_gen_frames = []
         for i, audio_path in enumerate(audio_paths):
@@ -346,7 +333,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 rate=tl.sr,
                 time_base=Fraction(1, tl.sr),
             )
-            if not isinstance(audio_stream, av.AudioStream):
+            if not isinstance(audio_stream, bv.AudioStream):
                 log.error(f"Not a known audio codec: {args.audio_codec}")
 
             if args.audio_bitrate != "auto":
@@ -358,17 +345,22 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 audio_stream.metadata["language"] = src.audios[i].lang  # type: ignore
 
             audio_streams.append(audio_stream)
-            audio_input = av.open(audio_path)
+            audio_input = bv.open(audio_path)
             audio_inputs.append(audio_input)
             audio_gen_frames.append(audio_input.decode(audio=0))
 
         # Setup subtitles
+        if ctr.default_sub != "none" and not args.sn:
+            sub_paths = make_new_subtitles(tl, log)
+        else:
+            sub_paths = []
+
         subtitle_streams = []
         subtitle_inputs = []
         sub_gen_frames = []
 
         for i, sub_path in enumerate(sub_paths):
-            subtitle_input = av.open(sub_path)
+            subtitle_input = bv.open(sub_path)
             subtitle_inputs.append(subtitle_input)
             subtitle_stream = output.add_stream_from_template(
                 subtitle_input.streams.subtitles[0]
@@ -497,14 +489,14 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                         output.mux(item.stream.encode(item.frame))
                     elif frame_type == "subtitle":
                         output.mux(item.frame)
-                except av.error.ExternalError:
+                except bv.error.ExternalError:
                     log.error(
                         f"Generic error for encoder: {item.stream.name}\n"
                         f"at {item.index} time_base\nPerhaps video quality settings are too low?"
                     )
-                except av.FileNotFoundError:
+                except bv.FileNotFoundError:
                     log.error(f"File not found: {output_path}")
-                except av.FFmpegError as e:
+                except bv.FFmpegError as e:
                     log.error(e)
 
                 if bar_index:

auto_editor/ffwrapper.py

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

auto_editor/formats/json.py

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