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

auto_editor/render/video.py

@@ -3,15 +3,14 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-import av
+import bv
 import numpy as np
 
-from auto_editor.output import parse_bitrate
 from auto_editor.timeline import TlImage, TlRect, TlVideo
+from auto_editor.utils.func import parse_bitrate
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
-    from typing import Any
 
     from auto_editor.__main__ import Args
     from auto_editor.ffwrapper import FileInfo
@@ -25,15 +24,12 @@ class VideoFrame:
     src: FileInfo
 
 
-allowed_pix_fmt = av.video.frame.supported_np_pix_fmts
-
-
-def make_solid(width: int, height: int, pix_fmt: str, bg: str) -> av.VideoFrame:
+def make_solid(width: int, height: int, pix_fmt: str, bg: str) -> bv.VideoFrame:
     hex_color = bg.lstrip("#").upper()
     rgb_color = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
 
     rgb_array = np.full((height, width, 3), rgb_color, dtype=np.uint8)
-    rgb_frame = av.VideoFrame.from_ndarray(rgb_array, format="rgb24")
+    rgb_frame = bv.VideoFrame.from_ndarray(rgb_array, format="rgb24")
     return rgb_frame.reformat(format=pix_fmt)
 
 
@@ -42,11 +38,11 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
     for clip in tl.v:
         for obj in clip:
             if isinstance(obj, TlImage) and (obj.src, obj.width) not in img_cache:
-                with av.open(obj.src.path) as cn:
+                with bv.open(obj.src.path) as cn:
                     my_stream = cn.streams.video[0]
                     for frame in cn.decode(my_stream):
                         if obj.width != 0:
-                            graph = av.filter.Graph()
+                            graph = bv.filter.Graph()
                             graph.link_nodes(
                                 graph.add_buffer(template=my_stream),
                                 graph.add("scale", f"{obj.width}:-1"),
@@ -61,17 +57,16 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
 
 
 def render_av(
-    output: av.container.OutputContainer, tl: v3, args: Args, log: Log
-) -> Any:
-    from_ndarray = av.VideoFrame.from_ndarray
+    output: bv.container.OutputContainer, tl: v3, args: Args, log: Log
+) -> Iterator[tuple[int, bv.VideoFrame]]:
+    from_ndarray = bv.VideoFrame.from_ndarray
 
-    src = tl.src
-    cns: dict[FileInfo, av.container.InputContainer] = {}
-    decoders: dict[FileInfo, Iterator[av.VideoFrame]] = {}
+    cns: dict[FileInfo, bv.container.InputContainer] = {}
+    decoders: dict[FileInfo, Iterator[bv.VideoFrame]] = {}
     seek_cost: dict[FileInfo, int] = {}
     tous: dict[FileInfo, int] = {}
 
-    target_pix_fmt = "yuv420p"  # Reasonable default
+    pix_fmt = "yuv420p"  # Reasonable default
     target_fps = tl.tb  # Always constant
     img_cache = make_image_cache(tl)
 
@@ -81,7 +76,7 @@ def render_av(
             first_src = src
 
         if src not in cns:
-            cns[src] = av.open(f"{src.path}")
+            cns[src] = bv.open(f"{src.path}")
 
     for src, cn in cns.items():
         if len(cn.streams.video) > 0:
@@ -101,30 +96,30 @@ def render_av(
             decoders[src] = cn.decode(stream)
 
             if src == first_src and stream.pix_fmt is not None:
-                target_pix_fmt = stream.pix_fmt
+                pix_fmt = stream.pix_fmt
 
     log.debug(f"Tous: {tous}")
     log.debug(f"Clips: {tl.v}")
 
-    codec = av.Codec(args.video_codec, "w")
+    codec = bv.Codec(args.video_codec, "w")
+
+    need_valid_fmt = True
+    if codec.video_formats is not None:
+        for video_format in codec.video_formats:
+            if pix_fmt == video_format.name:
+                need_valid_fmt = False
+                break
 
-    if codec.canonical_name == "gif":
-        if codec.video_formats is not None and target_pix_fmt in (
-            f.name for f in codec.video_formats
-        ):
-            target_pix_fmt = target_pix_fmt
+    if need_valid_fmt:
+        if codec.canonical_name == "gif":
+            pix_fmt = "rgb8"
+        elif codec.canonical_name == "prores":
+            pix_fmt = "yuv422p10le"
         else:
-            target_pix_fmt = "rgb8"
-    elif codec.canonical_name == "prores":
-        target_pix_fmt = "yuv422p10le"
-    else:
-        target_pix_fmt = (
-            target_pix_fmt if target_pix_fmt in allowed_pix_fmt else "yuv420p"
-        )
+            pix_fmt = "yuv420p"
 
     del codec
-    ops = {"mov_flags": "faststart"}
-    output_stream = output.add_stream(args.video_codec, rate=target_fps, options=ops)
+    output_stream = output.add_stream(args.video_codec, rate=target_fps)
 
     cc = output_stream.codec_context
     if args.vprofile is not None:
@@ -136,8 +131,8 @@ def render_av(
 
         cc.profile = args.vprofile.title()
 
-    yield output_stream
-    if not isinstance(output_stream, av.VideoStream):
+    yield output_stream  # type: ignore
+    if not isinstance(output_stream, bv.VideoStream):
         log.error(f"Not a known video codec: {args.video_codec}")
     if src.videos and src.videos[0].lang is not None:
         output_stream.metadata["language"] = src.videos[0].lang
@@ -148,10 +143,10 @@ def render_av(
     else:
         target_width = max(round(tl.res[0] * args.scale), 2)
         target_height = max(round(tl.res[1] * args.scale), 2)
-        scale_graph = av.filter.Graph()
+        scale_graph = bv.filter.Graph()
         scale_graph.link_nodes(
             scale_graph.add(
-                "buffer", video_size="1x1", time_base="1/1", pix_fmt=target_pix_fmt
+                "buffer", video_size="1x1", time_base="1/1", pix_fmt=pix_fmt
             ),
             scale_graph.add("scale", f"{target_width}:{target_height}"),
             scale_graph.add("buffersink"),
@@ -159,7 +154,7 @@ def render_av(
 
     output_stream.width = target_width
     output_stream.height = target_height
-    output_stream.pix_fmt = target_pix_fmt
+    output_stream.pix_fmt = pix_fmt
     output_stream.framerate = target_fps
 
     color_range = src.videos[0].color_range
@@ -191,7 +186,7 @@ def render_av(
     frames_saved = 0
 
     bg = args.background
-    null_frame = make_solid(target_width, target_height, target_pix_fmt, bg)
+    null_frame = make_solid(target_width, target_height, pix_fmt, bg)
     frame_index = -1
 
     for index in range(tl.end):
@@ -250,7 +245,7 @@ def render_av(
 
                 if (frame.width, frame.height) != tl.res:
                     width, height = tl.res
-                    graph = av.filter.Graph()
+                    graph = bv.filter.Graph()
                     graph.link_nodes(
                         graph.add_buffer(template=my_stream),
                         graph.add(
@@ -262,7 +257,7 @@ def render_av(
                     ).vpush(frame)
                     frame = graph.vpull()
             elif isinstance(obj, TlRect):
-                graph = av.filter.Graph()
+                graph = bv.filter.Graph()
                 x, y = obj.x, obj.y
                 graph.link_nodes(
                     graph.add_buffer(template=my_stream),
@@ -308,9 +303,9 @@ def render_av(
             scale_graph.vpush(frame)
             frame = scale_graph.vpull()
 
-        if frame.format.name != target_pix_fmt:
-            frame = frame.reformat(format=target_pix_fmt)
-
-        yield (index, from_ndarray(frame.to_ndarray(), format=frame.format.name))
+        frame = frame.reformat(format=pix_fmt)
+        frame.pts = None  # type: ignore
+        frame.time_base = 0  # type: ignore
+        yield (index, frame)
 
     log.debug(f"Total frames saved seeking: {frames_saved}")

auto_editor/timeline.py

@@ -3,7 +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.ffwrapper import FileInfo, mux
 from auto_editor.lib.contracts import *
 from auto_editor.utils.cmdkw import Required, pAttr, pAttrs
 from auto_editor.utils.types import CoerceError, natural, number, parse_color
@@ -187,13 +187,52 @@ ALayer = list[TlAudio]
 ASpace = list[ALayer]
 
 
+@dataclass(slots=True)
+class AudioTemplate:
+    lang: str | None
+
+
+@dataclass(slots=True)
+class SubtitleTemplate:
+    lang: str | None
+
+
+@dataclass(slots=True)
+class Template:
+    sr: int
+    layout: str
+    res: tuple[int, int]
+    audios: list[AudioTemplate]
+    subtitles: list[SubtitleTemplate]
+
+    @classmethod
+    def init(
+        self,
+        src: FileInfo,
+        sr: int | None = None,
+        layout: str | None = None,
+        res: tuple[int, int] | None = None,
+    ) -> Template:
+        alist = [AudioTemplate(x.lang) for x in src.audios]
+        slist = [SubtitleTemplate(x.lang) for x in src.subtitles]
+
+        if sr is None:
+            sr = src.get_sr()
+
+        if layout is None:
+            layout = "stereo" if not src.audios else src.audios[0].layout
+
+        if res is None:
+            res = src.get_res()
+
+        return Template(sr, layout, res, alist, slist)
+
+
 @dataclass
 class v3:
-    src: FileInfo | None  # Used as a template for timeline settings
     tb: Fraction
-    sr: int
-    res: tuple[int, int]
     background: str
+    template: Template
     v: VSpace
     a: ASpace
     v1: v1 | None  # Is it v1 compatible (linear and only one source)?
@@ -286,14 +325,27 @@ video\n"""
 
         return {
             "version": "3",
-            "resolution": self.res,
             "timebase": f"{self.tb.numerator}/{self.tb.denominator}",
-            "samplerate": self.sr,
             "background": self.background,
+            "resolution": self.T.res,
+            "samplerate": self.T.sr,
+            "layout": self.T.layout,
             "v": v,
             "a": a,
         }
 
+    @property
+    def T(self) -> Template:
+        return self.template
+
+    @property
+    def res(self) -> tuple[int, int]:
+        return self.T.res
+
+    @property
+    def sr(self) -> int:
+        return self.T.sr
+
 
 def make_tracks_dir(path: Path) -> Path:
     from os import mkdir
@@ -310,9 +362,7 @@ def make_tracks_dir(path: Path) -> Path:
     return tracks_dir
 
 
-def set_stream_to_0(tl: v3, log: Log) -> None:
-    src = tl.src
-    assert src is not None
+def set_stream_to_0(src: FileInfo, tl: v3, log: Log) -> None:
     fold = make_tracks_dir(src.path)
     cache: dict[Path, FileInfo] = {}
 
@@ -320,7 +370,7 @@ def set_stream_to_0(tl: v3, log: Log) -> None:
         newtrack = fold / f"{path.stem}_{i}.wav"
         if newtrack not in cache:
             mux(path, output=newtrack, stream=i)
-            cache[newtrack] = initFileInfo(f"{newtrack}", log)
+            cache[newtrack] = FileInfo.init(f"{newtrack}", log)
         return cache[newtrack]
 
     for alayer in tl.a:

auto_editor/utils/container.py

@@ -3,8 +3,10 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TypedDict
 
-import av
-from av.codec import Codec
+import bv
+from bv.codec import Codec
+
+from auto_editor.utils.log import Log
 
 
 class DictContainer(TypedDict, total=False):
@@ -60,18 +62,23 @@ def codec_type(x: str) -> str:
         return ""
 
 
-def container_constructor(ext: str) -> Container:
-    with av.open(f".{ext}", "w") as container:
-        codecs = container.supported_codecs
-        if ext == "webm":
-            vdefault = "vp9"
-        else:
-            vdefault = container.default_video_codec
-        adefault = container.default_audio_codec
-        sdefault = container.default_subtitle_codec
-        if sdefault == "none" and ext == "mp4":
-            sdefault = "srt"
-
+def container_constructor(ext: str, log: Log) -> Container:
+    try:
+        container = bv.open(f".{ext}", "w")
+    except ValueError:
+        log.error(f"Could not find a suitable format for extension: {ext}")
+
+    codecs = container.supported_codecs
+    if ext == "webm":
+        vdefault = "vp9"
+    else:
+        vdefault = container.default_video_codec
+    adefault = container.default_audio_codec
+    sdefault = container.default_subtitle_codec
+    if sdefault == "none" and ext == "mp4":
+        sdefault = "srt"
+
+    container.close()
     vcodecs = set()
     acodecs = set()
     scodecs = set()

auto_editor/utils/func.py

@@ -4,6 +4,9 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 
+from auto_editor.utils.log import Log
+from auto_editor.utils.types import split_num_str
+
 if TYPE_CHECKING:
     from collections.abc import Callable
     from fractions import Fraction
@@ -105,3 +108,21 @@ def aspect_ratio(width: int, height: int) -> tuple[int, int]:
 
     c = gcd(width, height)
     return width // c, height // c
+
+
+def parse_bitrate(input_: str, log: Log) -> int:
+    try:
+        val, unit = split_num_str(input_)
+    except Exception as e:
+        log.error(e)
+
+    if unit.lower() == "k":
+        return int(val * 1000)
+    if unit == "M":
+        return int(val * 1_000_000)
+    if unit == "G":
+        return int(val * 1_000_000_000)
+    if unit == "":
+        return int(val)
+
+    log.error(f"Unknown bitrate: {input_}")

{auto_editor-26.3.3.dist-info → auto_editor-27.1.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: auto-editor
-Version: 26.3.3
+Version: 27.1.0
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
-License: Unlicense
+License-Expression: Unlicense
 Project-URL: Bug Tracker, https://github.com/WyattBlue/auto-editor/issues
 Project-URL: Source Code, https://github.com/WyattBlue/auto-editor
 Project-URL: homepage, https://auto-editor.com
@@ -11,8 +11,9 @@ Keywords: video,audio,media,editor,editing,processing,nonlinear,automatic,silenc
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<3.0,>=1.24
-Requires-Dist: pyav==14.2.*
+Requires-Dist: numpy<3.0,>=2
+Requires-Dist: basswood-av<16,>=15.0.0
+Dynamic: license-file
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
 
@@ -175,9 +176,9 @@ auto-editor --margin --help
 
 ## Articles
  - [How to Install Auto-Editor](https://auto-editor.com/installing)
- - [All the Options (And What They Do)](https://auto-editor.com/options)
+ - [All the Options (And What They Do)](https://auto-editor.com/ref/options)
  - [Docs](https://auto-editor.com/docs)
- - [Blog](https://auto-editor.com/blog)
+ - [Blog](https://basswood-io.com/blog/)
 
 ## Copyright
 Auto-Editor is under the [Public Domain](https://github.com/WyattBlue/auto-editor/blob/master/LICENSE) and includes all directories besides the ones listed below. Auto-Editor was created by [these people.](https://auto-editor.com/blog/thank-you-early-testers)

auto_editor-27.1.0.dist-info/RECORD

@@ -0,0 +1,54 @@
+auto_editor/__init__.py,sha256=GyXI0pHyyPF89C9QtYg4zFjEDtSMUJMNUdrc74jh27A,23
+auto_editor/__main__.py,sha256=WfNtjKwx5fDMPpfSNLarigXD3Jp0My98FpzQqSAxQZ8,15807
+auto_editor/analyze.py,sha256=CeJG0LI9wXZk1R-QPrNGPS4za-_Avd8y7H-D437DqLg,12300
+auto_editor/edit.py,sha256=UbKG5jhl5K3kCx9wIB_-Con6PF-4H0-Du0yVln3B5Qc,18921
+auto_editor/ffwrapper.py,sha256=Wet6B5nohgnjpBX7o20Zq0rYr-H9mUuOqHrbQAPPj38,5128
+auto_editor/help.py,sha256=CzfDTsL4GuGu596ySHKj_wKnxGR9h8B0KUdkZpo33oE,8044
+auto_editor/json.py,sha256=8IVhZJSLx2IVqJsbR5YKDvbHOhgIOvdQmYNpMdMG_xA,9332
+auto_editor/make_layers.py,sha256=nSEeCHysMot2eze23q05g2HFDuskN_4Jk108xlk2Rw8,10102
+auto_editor/preview.py,sha256=cqQdozM2IB-5qXHNxeqiSrSdEIzlMfjD4SU-NX9sYZ0,3052
+auto_editor/timeline.py,sha256=Ku6BdDDzdboO0DisO_KLDjAyxJLQVDybWVgFbGCcsmY,9416
+auto_editor/vanparse.py,sha256=Ug5A2QaRqGiw4l55Z_h9T2QU1x0WqRibR7yY5rQ0WTk,10002
+auto_editor/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/cmds/cache.py,sha256=bViYbtVXefTeEIUvSanDfA6cG35ep1N_Jvtz7ZjgIkY,1959
+auto_editor/cmds/desc.py,sha256=DSAWPKt8PS9soBTgzpsFIEWoTe4gPTWwjXpNL-p3WsI,866
+auto_editor/cmds/info.py,sha256=VA2WkTBbQPvrVHjDaJyqryoVMtiiN6cguiUMdWgBJfU,7002
+auto_editor/cmds/levels.py,sha256=2Hbvoy6wMbRRoHdZf25PMqq1uvhRKyPcITNPMpZFo7s,5632
+auto_editor/cmds/palet.py,sha256=ONzTqemaQq9YEfIOsDRNnwzfqnEMUMSXIQrETxyroRU,749
+auto_editor/cmds/repl.py,sha256=HSUTDaVykPb5Bd-v_jz_8R7HvFmKOcT_ZVmP-d0AbUY,3247
+auto_editor/cmds/subdump.py,sha256=kHg8nfUi6I6VeJjEgMxupPa666qsYUh7ZEUxint7Gqo,2443
+auto_editor/cmds/test.py,sha256=UNN1r6J69-woqA6QU7TeY0WlPxukQzwCRl5DGBTLK8g,28837
+auto_editor/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/formats/fcp11.py,sha256=uaJbLiwiVxqoVy5JCA14wZj-m1wqZIzWh7rS-BsnSQM,5219
+auto_editor/formats/fcp7.py,sha256=rHjXXjpJ5YQQvCxor7FpUaqaAreqjCas4uLpiTdFclc,20255
+auto_editor/formats/json.py,sha256=UUBhFR_79vn4Lxu73B0cVBFgw4qytrmMP-TiCmDFMd0,7666
+auto_editor/formats/shotcut.py,sha256=-ES854LLFCMCBe100JRJedDmuk8zPev17aQMTrzPv-g,4923
+auto_editor/formats/utils.py,sha256=LYXDiqOk9WwUorLGw2D0M7In9BNDkoKikNawuks7hqE,1648
+auto_editor/lang/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/lang/libintrospection.py,sha256=6H1rGp0wqaCud5IPaoEmzULGnYt6ec7_0h32ATcw2oY,261
+auto_editor/lang/libmath.py,sha256=z33A161Oe6vYYK7R6pgYjdZZe63dQkN38Qf36TL3prg,847
+auto_editor/lang/palet.py,sha256=RQjyIZMJSWnzDkHTu-5mt74o9_4zO4VrcH-wLojCF7A,24113
+auto_editor/lang/stdenv.py,sha256=o7kFu7EbaH71XPFGxJUXYGxSeZ8O3i1_C5Hmi9uya4Q,44150
+auto_editor/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/lib/contracts.py,sha256=lExGQymcQUmwG5lC1lO4qm4GY8W0q_yzK_miTaAoPA4,7586
+auto_editor/lib/data_structs.py,sha256=Hnzl5gWvo-geTU0g-lGejj6HQW3VvPv0NBEj2XoGskY,7089
+auto_editor/lib/err.py,sha256=UlszQJdzMZwkbT8x3sY4GkCV_5x9yrd6uVVUzvA8iiI,35
+auto_editor/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/render/audio.py,sha256=ejV_NIvrmxMJt6mf7nPNIzlPHOumNhcIO2J-irHO-k8,17427
+auto_editor/render/subtitle.py,sha256=F27T8OsAojUIGTGBWqTdH36h0BnHXSExxIqzOtqyZoE,6129
+auto_editor/render/video.py,sha256=uIrYzF4bDZ3vwfX2F6TdR6F73GI4yruGssto9xEQ-AA,11999
+auto_editor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/utils/bar.py,sha256=Ky9JRf37JTgLyvNuIXDfucaUE8H1vBbCqKLjttmsmmo,4156
+auto_editor/utils/chunks.py,sha256=J-eGKtEz68gFtRrj1kOSgH4Tj_Yz6prNQ7Xr-d9NQJw,52
+auto_editor/utils/cmdkw.py,sha256=aUGBvBel2Ko1o6Rwmr4rEL-BMc5hEnzYLbyZ1GeJdcY,5729
+auto_editor/utils/container.py,sha256=CNHChHbhzIrjmDdWw6UzMqscrr9u7A-ZqKWejGjJwYE,2628
+auto_editor/utils/func.py,sha256=ODyjXnzSDatEu08w398K8_xBKYdXMY3IPHiJpGRZDyQ,3250
+auto_editor/utils/log.py,sha256=wPNf6AabV-0cnoS_bPLv1Lh7llQBtNqPKeh07einOuc,3701
+auto_editor/utils/types.py,sha256=j2hd4zMQ9EftDy41Ji2_PFru_7HEZObd9yKA0BJxFaY,7616
+auto_editor-27.1.0.dist-info/licenses/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
+docs/build.py,sha256=g1uc1H9T_naGaermUiVMMwUpbT0IWElRhjgT0fvCh8w,1914
+auto_editor-27.1.0.dist-info/METADATA,sha256=JU6SgcQLr3thOG27aQRkt2r3INzU0q306BeK79qkwGs,6176
+auto_editor-27.1.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+auto_editor-27.1.0.dist-info/entry_points.txt,sha256=UAsTc7qJQbnAzHd7KWg-ALo_X9Hj2yDs3M9I2DV3eyI,212
+auto_editor-27.1.0.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
+auto_editor-27.1.0.dist-info/RECORD,,

{auto_editor-26.3.3.dist-info → auto_editor-27.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

docs/build.py

@@ -19,13 +19,22 @@ def main():
     parser = main_options(parser)
 
     with open("src/ref/options.html", "w") as file:
-        file.write(
-            '{{ headerdesc "Options" "These are the options and flags that auto-editor uses." }}\n'
-            "<body>\n"
-            "{{ nav }}\n"
-            '<section class="section">\n'
-            '<div class="container">\n'
-        )
+        file.write("""\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+{{ init_head }}
+{{ headerdesc "Options" "These are the options and flags that auto-editor uses." }}
+{{ head_icon }}
+<style>
+{{ core_style }}
+</style>
+<body>
+{{ nav }}
+<section class="section">
+<div class="container">
+""")
+
         for op in parser.args:
             if isinstance(op, OptionText):
                 file.write(f"<h2>{escape(op.text)}</h2>\n")

auto_editor/output.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import os.path
-from dataclasses import dataclass, field
-
-import av
-from av.audio.resampler import AudioResampler
-
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.utils.bar import Bar
-from auto_editor.utils.log import Log
-from auto_editor.utils.types import split_num_str
-
-
-def parse_bitrate(input_: str, log: Log) -> int:
-    try:
-        val, unit = split_num_str(input_)
-    except Exception as e:
-        log.error(e)
-
-    if unit.lower() == "k":
-        return int(val * 1000)
-    if unit == "M":
-        return int(val * 1_000_000)
-    if unit == "G":
-        return int(val * 1_000_000_000)
-    if unit == "":
-        return int(val)
-
-    log.error(f"Unknown bitrate: {input_}")
-
-
-@dataclass(slots=True)
-class Ensure:
-    _bar: Bar
-    _sr: int
-    log: Log
-    _audios: list[tuple[FileInfo, int]] = field(default_factory=list)
-
-    def audio(self, src: FileInfo, stream: int) -> str:
-        try:
-            label = self._audios.index((src, stream))
-            first_time = False
-        except ValueError:
-            self._audios.append((src, stream))
-            label = len(self._audios) - 1
-            first_time = True
-
-        out_path = os.path.join(self.log.temp, f"{label:x}.wav")
-
-        if first_time:
-            sample_rate = self._sr
-            bar = self._bar
-            self.log.debug(f"Making external audio: {out_path}")
-
-            in_container = av.open(src.path, "r")
-            out_container = av.open(
-                out_path, "w", format="wav", options={"rf64": "always"}
-            )
-            astream = in_container.streams.audio[stream]
-
-            if astream.duration is None or astream.time_base is None:
-                dur = 1.0
-            else:
-                dur = float(astream.duration * astream.time_base)
-
-            bar.start(dur, "Extracting audio")
-
-            output_astream = out_container.add_stream(
-                "pcm_s16le", layout="stereo", rate=sample_rate
-            )
-            resampler = AudioResampler(format="s16", layout="stereo", rate=sample_rate)
-            for i, frame in enumerate(in_container.decode(astream)):
-                if i % 1500 == 0 and frame.time is not None:
-                    bar.tick(frame.time)
-
-                for new_frame in resampler.resample(frame):
-                    out_container.mux(output_astream.encode(new_frame))
-
-            out_container.mux(output_astream.encode(None))
-
-            out_container.close()
-            in_container.close()
-            bar.end()
-
-        return out_path