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

auto_editor/__init__.py

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

auto_editor/__main__.py

@@ -3,6 +3,8 @@
 import platform as plat
 import re
 import sys
+from dataclasses import dataclass, field
+from fractions import Fraction
 from io import StringIO
 from os import environ
 from os.path import exists, isdir, isfile, lexists, splitext
@@ -12,21 +14,128 @@ import auto_editor
 from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
-    Args,
+    CoerceError,
     frame_rate,
-    margin,
+    natural,
     number,
     parse_color,
-    resolution,
-    sample_rate,
-    speed,
-    speed_range,
-    time_range,
+    split_num_str,
 )
 from auto_editor.vanparse import ArgumentParser
 
 
+@dataclass(slots=True)
+class Args:
+    input: list[str] = field(default_factory=list)
+    help: bool = False
+
+    # Editing Options
+    margin: tuple[str, str] = ("0.2s", "0.2s")
+    edit: str = "audio"
+    export: str | None = None
+    output: str | None = None
+    silent_speed: float = 99999.0
+    video_speed: float = 1.0
+    cut_out: list[tuple[str, str]] = field(default_factory=list)
+    add_in: list[tuple[str, str]] = field(default_factory=list)
+    set_speed_for_range: list[tuple[float, str, str]] = field(default_factory=list)
+
+    # Timeline Options
+    frame_rate: Fraction | None = None
+    sample_rate: int | None = None
+    resolution: tuple[int, int] | None = None
+    background: str = "#000000"
+
+    # URL download Options
+    yt_dlp_location: str = "yt-dlp"
+    download_format: str | None = None
+    output_format: str | None = None
+    yt_dlp_extras: str | None = None
+
+    # Display Options
+    progress: str = "modern"
+    debug: bool = False
+    quiet: bool = False
+    preview: bool = False
+
+    # Container Settings
+    sn: bool = False
+    dn: bool = False
+    faststart: bool = False
+    no_faststart: bool = False
+    fragmented: bool = False
+    no_fragmented: bool = False
+
+    # Video Rendering
+    video_codec: str = "auto"
+    video_bitrate: str = "auto"
+    vprofile: str | None = None
+    scale: float = 1.0
+    no_seek: bool = False
+
+    # Audio Rendering
+    audio_codec: str = "auto"
+    audio_bitrate: str = "auto"
+    mix_audio_streams: bool = False
+    keep_tracks_separate: bool = False
+    audio_normalize: str = "#f"
+
+    # Misc.
+    config: bool = False
+    no_cache: bool = False
+    no_open: bool = False
+    temp_dir: str | None = None
+    player: str | None = None
+    version: bool = False
+
+
 def main_options(parser: ArgumentParser) -> ArgumentParser:
+    def margin(val: str) -> tuple[str, str]:
+        vals = val.strip().split(",")
+        if len(vals) == 1:
+            vals.append(vals[0])
+        if len(vals) != 2:
+            raise CoerceError("--margin has too many arguments.")
+        return vals[0], vals[1]
+
+    def speed(val: str) -> float:
+        _s = number(val)
+        if _s <= 0 or _s > 99999:
+            return 99999.0
+        return _s
+
+    def resolution(val: str | None) -> tuple[int, int] | None:
+        if val is None:
+            return None
+        vals = val.strip().split(",")
+        if len(vals) != 2:
+            raise CoerceError(f"'{val}': Resolution takes two numbers")
+        return natural(vals[0]), natural(vals[1])
+
+    def sample_rate(val: str) -> int:
+        num, unit = split_num_str(val)
+        if unit in {"kHz", "KHz"}:
+            return natural(num * 1000)
+        if unit not in {"", "Hz"}:
+            raise CoerceError(f"Unknown unit: '{unit}'")
+        return natural(num)
+
+    def _comma_coerce(name: str, val: str, num_args: int) -> list[str]:
+        vals = val.strip().split(",")
+        if num_args > len(vals):
+            raise CoerceError(f"Too few arguments for {name}.")
+        if len(vals) > num_args:
+            raise CoerceError(f"Too many arguments for {name}.")
+        return vals
+
+    def time_range(val: str) -> tuple[str, str]:
+        a = _comma_coerce("time_range", val, 2)
+        return a[0], a[1]
+
+    def speed_range(val: str) -> tuple[float, str, str]:
+        a = _comma_coerce("speed_range", val, 3)
+        return number(a[0]), a[1], a[2]
+
     parser.add_required("input", nargs="*", metavar="[file | url ...] [options]")
     parser.add_text("Editing Options:")
     parser.add_argument(
@@ -41,6 +150,16 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="METHOD",
         help="Set an expression which determines how to make auto edits",
     )
+    parser.add_argument(
+        "--export", "-ex", metavar="EXPORT:ATTRS?", help="Choose the export mode"
+    )
+    parser.add_argument(
+        "--output",
+        "--output-file",
+        "-o",
+        metavar="FILE",
+        help="Set the name/path of the new output file",
+    )
     parser.add_argument(
         "--silent-speed",
         "-s",
@@ -111,12 +230,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="COLOR",
         help="Set the background as a solid RGB color",
     )
-    parser.add_argument(
-        "--add",
-        nargs="*",
-        metavar="OBJ:START,DUR,ATTRS?",
-        help="Insert an audio/video object to the timeline",
-    )
     parser.add_text("URL Download Options:")
     parser.add_argument(
         "--yt-dlp-location",
@@ -138,28 +251,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="CMD",
         help="Add extra options for yt-dlp. Must be in quotes",
     )
-    parser.add_text("Utility Options:")
-    parser.add_argument(
-        "--export", "-ex", metavar="EXPORT:ATTRS?", help="Choose the export mode"
-    )
-    parser.add_argument(
-        "--output-file",
-        "--output",
-        "-o",
-        metavar="FILE",
-        help="Set the name/path of the new output file",
-    )
-    parser.add_argument(
-        "--player", "-p", metavar="CMD", help="Set player to open output media files"
-    )
-    parser.add_argument(
-        "--no-open", flag=True, help="Do not open the output file after editing is done"
-    )
-    parser.add_argument(
-        "--temp-dir",
-        metavar="PATH",
-        help="Set where the temporary directory is located",
-    )
     parser.add_text("Display Options:")
     parser.add_argument(
         "--progress",
@@ -186,6 +277,16 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         flag=True,
         help="Disable the inclusion of data streams in the output file",
     )
+    parser.add_argument(
+        "--faststart",
+        flag=True,
+        help="Enable movflags +faststart, recommended for web (default)",
+    )
+    parser.add_argument(
+        "--no-faststart",
+        flag=True,
+        help="Disable movflags +faststart, will be faster for large files",
+    )
     parser.add_argument(
         "--fragmented",
         flag=True,
@@ -241,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",
@@ -258,6 +362,17 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     parser.add_argument(
         "--no-cache", flag=True, help="Don't look for or write a cache file"
     )
+    parser.add_argument(
+        "--no-open", flag=True, help="Do not open the output file after editing is done"
+    )
+    parser.add_argument(
+        "--temp-dir",
+        metavar="PATH",
+        help="Set where the temporary directory is located",
+    )
+    parser.add_argument(
+        "--player", "-p", metavar="CMD", help="Set player to open output media files"
+    )
     parser.add_argument("--version", "-V", flag=True, help="Display version and halt")
     return parser
 
@@ -337,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("------")