auto-editor 25.3.0__py3-none-any.whl → 26.0.0__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "25.3.0"
+__version__ = "26.0.0"

auto_editor/__main__.py

@@ -1,15 +1,18 @@
 #!/usr/bin/env python3
 
+import re
 import sys
 from os import environ
+from os.path import exists, isdir, isfile, lexists, splitext
+from subprocess import run
 
 import auto_editor
 from auto_editor.edit import edit_media
-from auto_editor.ffwrapper import FFmpeg
+from auto_editor.ffwrapper import FFmpeg, initFFmpeg
+from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
     Args,
-    bitrate,
     color,
     frame_rate,
     margin,
@@ -20,7 +23,6 @@ from auto_editor.utils.types import (
     speed_range,
     time_range,
 )
-from auto_editor.validate_input import valid_input
 from auto_editor.vanparse import ArgumentParser
 
 
@@ -202,16 +204,8 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         "--video-bitrate",
         "-b:v",
         metavar="BITRATE",
-        type=bitrate,
         help="Set the number of bits per second for video",
     )
-    parser.add_argument(
-        "--video-quality-scale",
-        "-qscale:v",
-        "-q:v",
-        metavar="SCALE",
-        help="Set a value to the ffmpeg option -qscale:v",
-    )
     parser.add_argument(
         "--scale",
         type=number,
@@ -235,7 +229,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         "--audio-bitrate",
         "-b:a",
         metavar="BITRATE",
-        type=bitrate,
         help="Set the number of bits per second for audio",
     )
     parser.add_argument(
@@ -274,6 +267,50 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     return parser
 
 
+def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
+    log.conwrite("Downloading video...")
+
+    def get_domain(url: str) -> str:
+        t = __import__("urllib.parse", fromlist=["parse"]).urlparse(url).netloc
+        return ".".join(t.split(".")[-2:])
+
+    download_format = args.download_format
+    if download_format is None and get_domain(my_input) == "youtube.com":
+        download_format = "bestvideo[ext=mp4]+bestaudio[ext=m4a]"
+
+    if args.output_format is None:
+        output_format = re.sub(r"\W+", "-", splitext(my_input)[0]) + ".%(ext)s"
+    else:
+        output_format = args.output_format
+
+    yt_dlp_path = args.yt_dlp_location
+
+    cmd = ["--ffmpeg-location", ffmpeg.path]
+
+    if download_format is not None:
+        cmd.extend(["-f", download_format])
+
+    cmd.extend(["-o", output_format, my_input])
+
+    if args.yt_dlp_extras is not None:
+        cmd.extend(args.yt_dlp_extras.split(" "))
+
+    try:
+        location = get_stdout(
+            [yt_dlp_path, "--get-filename", "--no-warnings"] + cmd
+        ).strip()
+    except FileNotFoundError:
+        log.error("Program `yt-dlp` must be installed and on PATH.")
+
+    if not isfile(location):
+        run([yt_dlp_path] + cmd)
+
+    if not isfile(location):
+        log.error(f"Download file wasn't created: {location}")
+
+    return location
+
+
 def main() -> None:
     subcommands = ("test", "info", "levels", "subdump", "desc", "repl", "palet")
 
@@ -284,8 +321,7 @@ def main() -> None:
         obj.main(sys.argv[2:])
         return
 
-    ff_color = "AV_LOG_FORCE_NOCOLOR"
-    no_color = bool(environ.get("NO_COLOR")) or bool(environ.get(ff_color))
+    no_color = bool(environ.get("NO_COLOR") or environ.get("AV_LOG_FORCE_NOCOLOR"))
     log = Log(no_color=no_color)
 
     args = main_options(ArgumentParser("Auto-Editor")).parse_args(
@@ -327,13 +363,28 @@ def main() -> None:
     is_machine = args.progress == "machine"
     log = Log(args.debug, args.quiet, args.temp_dir, is_machine, no_color)
 
-    ffmpeg = FFmpeg(
+    ffmpeg = initFFmpeg(
+        log,
         args.ffmpeg_location,
         args.my_ffmpeg,
         args.show_ffmpeg_commands,
         args.show_ffmpeg_output,
     )
-    paths = valid_input(args.input, ffmpeg, args, log)
+    paths = []
+    for my_input in args.input:
+        if my_input.startswith("http://") or my_input.startswith("https://"):
+            paths.append(download_video(my_input, args, ffmpeg, log))
+        else:
+            if not splitext(my_input)[1]:
+                if isdir(my_input):
+                    log.error("Input must be a file or a URL, not a directory.")
+                if exists(my_input):
+                    log.error(f"Input file must have an extension: {my_input}")
+                if lexists(my_input):
+                    log.error(f"Input file is a broken symbolic link: {my_input}")
+                if my_input.startswith("-"):
+                    log.error(f"Option/Input file doesn't exist: {my_input}")
+            paths.append(my_input)
 
     try:
         edit_media(paths, ffmpeg, args, log)

auto_editor/analyze.py

@@ -14,13 +14,11 @@ from av.audio.fifo import AudioFifo
 from av.subtitles.subtitle import AssSubtitle
 
 from auto_editor import __version__
-from auto_editor.utils.subtitle_tools import convert_ass_to_text
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Sequence
     from fractions import Fraction
     from pathlib import Path
-    from typing import Any
 
     from numpy.typing import NDArray
 
@@ -156,10 +154,10 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
     container.close()
 
 
-def obj_tag(path: Path, kind: str, tb: Fraction, obj: dict[str, Any]) -> str:
+def obj_tag(path: Path, kind: str, tb: Fraction, obj: Sequence[object]) -> str:
     mod_time = int(path.stat().st_mtime)
     key = f"{path.name}:{mod_time:x}:{kind}:{tb}:"
-    return key + ",".join(f"{v}" for v in obj.values())
+    return key + ",".join(f"{v}" for v in obj)
 
 
 @dataclass(slots=True)
@@ -174,7 +172,7 @@ class Levels:
     @property
     def media_length(self) -> int:
         if self.src.audios:
-            if (arr := self.read_cache("audio", {"stream": 0})) is not None:
+            if (arr := self.read_cache("audio", (0,))) is not None:
                 return len(arr)
 
             result = sum(1 for _ in iter_audio(self.src, self.tb, 0))
@@ -202,7 +200,7 @@ class Levels:
     def all(self) -> NDArray[np.bool_]:
         return np.zeros(self.media_length, dtype=np.bool_)
 
-    def read_cache(self, kind: str, obj: dict[str, Any]) -> None | np.ndarray:
+    def read_cache(self, kind: str, obj: Sequence[object]) -> None | np.ndarray:
         if self.no_cache:
             return None
 
@@ -221,7 +219,7 @@ class Levels:
         self.log.debug("Using cache")
         return npzfile[key]
 
-    def cache(self, arr: np.ndarray, kind: str, obj: dict[str, Any]) -> np.ndarray:
+    def cache(self, arr: np.ndarray, kind: str, obj: Sequence[object]) -> np.ndarray:
         if self.no_cache:
             return arr
 
@@ -238,7 +236,7 @@ class Levels:
         if stream >= len(self.src.audios):
             raise LevelError(f"audio: audio stream '{stream}' does not exist.")
 
-        if (arr := self.read_cache("audio", {"stream": stream})) is not None:
+        if (arr := self.read_cache("audio", (stream,))) is not None:
             return arr
 
         with av.open(self.src.path, "r") as container:
@@ -265,13 +263,13 @@ class Levels:
             index += 1
 
         bar.end()
-        return self.cache(result[:index], "audio", {"stream": stream})
+        return self.cache(result[:index], "audio", (stream,))
 
     def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float32]:
         if stream >= len(self.src.videos):
             raise LevelError(f"motion: video stream '{stream}' does not exist.")
 
-        mobj = {"stream": stream, "width": width, "blur": blur}
+        mobj = (stream, width, blur)
         if (arr := self.read_cache("motion", mobj)) is not None:
             return arr
 
@@ -360,11 +358,10 @@ class Levels:
                 san_end = round((start + dur) * self.tb)
 
                 for sub in subset:
-                    if isinstance(sub, AssSubtitle):
-                        line = convert_ass_to_text(sub.ass.decode(errors="ignore"))
-                    else:
+                    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

auto_editor/edit.py

@@ -1,12 +1,18 @@
 from __future__ import annotations
 
 import os
+import sys
+from fractions import Fraction
+from subprocess import run
 from typing import Any
 
+import av
+from av import AudioResampler
+
 from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
 from auto_editor.lib.contracts import is_int, is_str
 from auto_editor.make_layers import make_timeline
-from auto_editor.output import Ensure, mux_quality_media
+from auto_editor.output import Ensure, parse_bitrate
 from auto_editor.render.audio import make_new_audio
 from auto_editor.render.subtitle import make_new_subtitles
 from auto_editor.render.video import render_av
@@ -15,7 +21,6 @@ from auto_editor.utils.bar import initBar
 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.func import open_with_system_default
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import Args
 
@@ -91,11 +96,19 @@ def set_audio_codec(
     codec: str, src: FileInfo | None, out_ext: str, ctr: Container, log: Log
 ) -> str:
     if codec == "auto":
-        codec = "aac" if (src is None or not src.audios) else src.audios[0].codec
+        if src is None or not src.audios:
+            codec = "aac"
+        else:
+            codec = src.audios[0].codec
+            ctx = av.Codec(codec)
+            if ctx.audio_formats is None:
+                codec = "aac"
         if codec not in ctr.acodecs and ctr.default_aud != "none":
-            return ctr.default_aud
+            codec = ctr.default_aud
         if codec == "mp3float":
-            return "mp3"
+            codec = "mp3"
+        if codec is None:
+            codec = "aac"
         return codec
 
     if codec == "copy":
@@ -105,9 +118,8 @@ def set_audio_codec(
             log.error("Input file does not have an audio stream to copy codec from.")
         codec = src.audios[0].codec
 
-    if codec != "unset":
-        if ctr.acodecs is None or codec not in ctr.acodecs:
-            log.error(codec_error.format(codec, out_ext))
+    if ctr.acodecs is None or codec not in ctr.acodecs:
+        log.error(codec_error.format(codec, out_ext))
 
     return codec
 
@@ -269,49 +281,150 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
     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: str) -> None:
+    def make_media(tl: v3, output_path: str) -> None:
         assert src is not None
 
-        visual_output = []
-        audio_output = []
-        sub_output = []
-        apply_later = False
+        output = av.open(output_path, "w")
 
-        ensure = Ensure(ffmpeg, bar, samplerate, log)
         if ctr.default_sub != "none" and not args.sn:
-            sub_output = make_new_subtitles(tl, ensure, log.temp)
+            sub_paths = make_new_subtitles(tl, log)
+        else:
+            sub_paths = []
 
         if ctr.default_aud != "none":
-            audio_output = make_new_audio(tl, ensure, args, ffmpeg, bar, log)
-
-        if ctr.default_vid != "none":
-            if tl.v:
-                out_path, apply_later = render_av(ffmpeg, tl, args, bar, ctr, log)
-                visual_output.append((True, out_path))
-
-            for v, vid in enumerate(src.videos, start=1):
-                if ctr.allow_image and vid.codec in ("png", "mjpeg", "webp"):
-                    out_path = os.path.join(log.temp, f"{v}.{vid.codec}")
-                    # fmt: off
-                    ffmpeg.run(["-i", f"{src.path}", "-map", "0:v", "-map", "-0:V",
-                        "-c", "copy", out_path])
-                    # fmt: on
-                    visual_output.append((False, out_path))
-
-        log.conwrite("Writing output file")
-        mux_quality_media(
-            ffmpeg,
-            visual_output,
-            audio_output,
-            sub_output,
-            apply_later,
-            ctr,
-            output,
-            tl.tb,
-            args,
-            src,
-            log,
-        )
+            ensure = Ensure(bar, samplerate, log)
+            audio_paths = make_new_audio(tl, ensure, args, ffmpeg, bar, log)
+            if (
+                not (args.keep_tracks_separate and ctr.max_audios is None)
+                and len(audio_paths) > 1
+            ):
+                # Merge all the audio a_tracks into one.
+                new_a_file = os.path.join(log.temp, "new_audio.wav")
+                new_cmd = []
+                for path in audio_paths:
+                    new_cmd.extend(["-i", path])
+                new_cmd.extend(
+                    [
+                        "-filter_complex",
+                        f"amix=inputs={len(audio_paths)}:duration=longest",
+                        "-ac",
+                        "2",
+                        new_a_file,
+                    ]
+                )
+                ffmpeg.run(new_cmd)
+                audio_paths = [new_a_file]
+        else:
+            audio_paths = []
+
+        # Setup audio
+        if audio_paths:
+            try:
+                audio_encoder = av.Codec(args.audio_codec)
+            except av.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_inputs = []
+        audio_gen_frames = []
+        for i, audio_path in enumerate(audio_paths):
+            audio_stream = output.add_stream(
+                args.audio_codec,
+                format=audio_format,
+                rate=tl.sr,
+                time_base=Fraction(1, tl.sr),
+            )
+            if not isinstance(audio_stream, av.AudioStream):
+                log.error(f"Not a known audio codec: {args.audio_codec}")
+
+            if args.audio_bitrate != "auto":
+                audio_stream.bit_rate = parse_bitrate(args.audio_bitrate, log)
+                log.debug(f"audio bitrate: {audio_stream.bit_rate}")
+            else:
+                log.debug(f"[auto] audio bitrate: {audio_stream.bit_rate}")
+            if i < len(src.audios) and src.audios[i].lang is not None:
+                audio_stream.metadata["language"] = src.audios[i].lang  # type: ignore
+
+            audio_streams.append(audio_stream)
+            audio_input = av.open(audio_path)
+            audio_inputs.append(audio_input)
+            audio_gen_frames.append(audio_input.decode(audio=0))
+
+        # Setup subtitles
+        subtitle_streams = []
+        subtitle_inputs = []
+        sub_gen_frames = []
+
+        for i, sub_path in enumerate(sub_paths):
+            subtitle_input = av.open(sub_path)
+            subtitle_inputs.append(subtitle_input)
+            subtitle_stream = output.add_stream(
+                template=subtitle_input.streams.subtitles[0]
+            )
+            if i < len(src.subtitles) and src.subtitles[i].lang is not None:
+                subtitle_stream.metadata["language"] = src.subtitles[i].lang  # type: ignore
+
+            subtitle_streams.append(subtitle_stream)
+            sub_gen_frames.append(subtitle_input.demux(subtitles=0))
+
+        # Setup video
+        if ctr.default_vid != "none" and tl.v:
+            vframes = render_av(output, tl, args, bar, log)
+            output_stream = next(vframes)
+        else:
+            output_stream, vframes = None, iter([])
+
+        # Process frames
+        while True:
+            audio_frames = [next(frames, None) for frames in audio_gen_frames]
+            video_frame = next(vframes, None)
+            subtitle_frames = [next(packet, None) for packet in sub_gen_frames]
+
+            if (
+                all(frame is None for frame in audio_frames)
+                and video_frame is None
+                and all(packet is None for packet in subtitle_frames)
+            ):
+                break
+
+            for audio_stream, audio_frame in zip(audio_streams, audio_frames):
+                if audio_frame:
+                    for reframe in resampler.resample(audio_frame):
+                        output.mux(audio_stream.encode(reframe))
+
+            for subtitle_stream, packet in zip(subtitle_streams, subtitle_frames):
+                if not packet or packet.dts is None:
+                    continue
+                packet.stream = subtitle_stream
+                output.mux(packet)
+
+            if video_frame:
+                try:
+                    output.mux(output_stream.encode(video_frame))
+                except av.error.ExternalError:
+                    log.error(
+                        f"Generic error for encoder: {output_stream.name}\n"
+                        "Perhaps video quality settings are too low?"
+                    )
+                except av.FFmpegError as e:
+                    log.error(e)
+
+        # Flush streams
+        if output_stream is not None:
+            output.mux(output_stream.encode(None))
+        for audio_stream in audio_streams:
+            output.mux(audio_stream.encode(None))
+
+        # Close resources
+        for audio_input in audio_inputs:
+            audio_input.close()
+        for subtitle_input in subtitle_inputs:
+            subtitle_input.close()
+        output.close()
 
     if export == "clip-sequence":
         if tl.v1 is None:
@@ -328,7 +441,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         total_frames = tl.v1.chunks[-1][1] - 1
         clip_num = 0
         for chunk in tl.v1.chunks:
-            if chunk[2] == 99999:
+            if chunk[2] == 0 or chunk[2] >= 99999:
                 continue
 
             padded_chunks = pad_chunk(chunk, total_frames)
@@ -354,11 +467,23 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
 
     log.stop_timer()
 
-    if not args.no_open and export in ("default", "audio", "clip-sequence"):
+    if not args.no_open and export in ("default", "audio"):
         if args.player is None:
-            open_with_system_default(output, log)
+            if sys.platform == "win32":
+                try:
+                    os.startfile(output)
+                except OSError:
+                    log.warning(f"Could not find application to open file: {output}")
+            else:
+                try:  # MacOS case
+                    run(["open", output])
+                except Exception:
+                    try:  # WSL2 case
+                        run(["cmd.exe", "/C", "start", output])
+                    except Exception:
+                        try:  # Linux case
+                            run(["xdg-open", output])
+                        except Exception:
+                            log.warning(f"Could not open output file: {output}")
         else:
-            import subprocess
-            from shlex import split
-
-            subprocess.run(split(args.player) + [output])
+            run(__import__("shlex").split(args.player) + [output])