Use bv

Author: WyattBlue

auto_editor/__main__.py

@@ -454,13 +454,13 @@ def main() -> None:
         buf.write(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}\n")
         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 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,18 +72,18 @@ 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
 
     exact_size = (1 / tb) * sr
     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 @@ def audio(self, stream: int) -> NDArray[np.float32]:
         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
 
@@ -385,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/levels.py

@@ -5,7 +5,7 @@
 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 value_storing_generator() -> Iterator[np.float32]:
                 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,8 +1,8 @@
 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
@@ -26,7 +26,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     if args.json:
         data = {}
         for input_file in args.input:
-            container = av.open(input_file)
+            container = bv.open(input_file)
             for s in range(len(container.streams.subtitles)):
                 entry_data = []
 
@@ -61,7 +61,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         return
 
     for i, input_file in enumerate(args.input):
-        with av.open(input_file) as container:
+        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):

auto_editor/cmds/test.py

@@ -11,7 +11,7 @@
 from tempfile import mkdtemp
 from time import perf_counter
 
-import av
+import bv
 import numpy as np
 
 from auto_editor.ffwrapper import FileInfo, initFileInfo
@@ -161,35 +161,35 @@ def test_movflags(self) -> None:
         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
@@ -265,16 +265,16 @@ def test_input_extension(self):
         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"], []) + ".mov"

auto_editor/edit.py

@@ -8,8 +8,8 @@
 from subprocess import run
 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
@@ -86,7 +86,7 @@ def set_video_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):
@@ -103,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
@@ -114,7 +114,7 @@ def set_audio_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):
@@ -292,12 +292,12 @@ def make_media(tl: v3, output_path: str) -> None:
         if mov_flags:
             options["movflags"] = "+".join(mov_flags)
 
-        output = av.open(output_path, "w", container_options=options)
+        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: av.VideoStream | None
+            output_stream: bv.VideoStream | None
             output_stream = next(vframes)  # type: ignore
         else:
             output_stream, vframes = None, iter([])
@@ -315,15 +315,15 @@ def make_media(tl: v3, output_path: str) -> None:
 
         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):
@@ -333,7 +333,7 @@ def make_media(tl: v3, output_path: str) -> 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":
@@ -345,7 +345,7 @@ def make_media(tl: v3, output_path: str) -> 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))
 
@@ -360,7 +360,7 @@ def make_media(tl: v3, output_path: str) -> None:
         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]
@@ -489,14 +489,14 @@ def __eq__(self, other):
                         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: