auto-editor 25.3.1__tar.gz → 26.0.0__tar.gz

{auto_editor-25.3.1 → auto_editor-26.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 25.3.1
+Version: 26.0.0
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense

auto_editor-26.0.0/auto_editor/__init__.py

@@ -0,0 +1 @@
+__version__ = "26.0.0"

{auto_editor-25.3.1 → auto_editor-26.0.0}/auto_editor/__main__.py

@@ -13,7 +13,6 @@ 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,
@@ -205,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,
@@ -238,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(
@@ -281,7 +271,7 @@ 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.urlparse(url).netloc
+        t = __import__("urllib.parse", fromlist=["parse"]).urlparse(url).netloc
         return ".".join(t.split(".")[-2:])
 
     download_format = args.download_format

{auto_editor-25.3.1 → auto_editor-26.0.0}/auto_editor/edit.py

@@ -2,13 +2,17 @@ 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
@@ -92,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":
@@ -106,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
 
@@ -270,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:

{auto_editor-25.3.1 → auto_editor-26.0.0}/auto_editor/ffwrapper.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
-import os.path
 import sys
 from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
-from re import search
 from shutil import which
 from subprocess import PIPE, Popen, run
 from typing import Any
@@ -52,41 +50,6 @@ class FFmpeg:
             sys.stderr.write(f"{' '.join(cmd)}\n\n")
         run(cmd)
 
-    def run_check_errors(
-        self, cmd: list[str], show_out: bool = False, path: str | None = None
-    ) -> None:
-        process = self.Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
-        _, stderr = process.communicate()
-
-        if process.stdin is not None:
-            process.stdin.close()
-        output = stderr.decode("utf-8", "replace")
-
-        error_list = (
-            r"Unknown encoder '.*'",
-            r"-q:v qscale not available for encoder\. Use -b:v bitrate instead\.",
-            r"Specified sample rate .* is not supported",
-            r'Unable to parse option value ".*"',
-            r"Error setting option .* to value .*\.",
-            r"Undefined constant or missing '.*' in '.*'",
-            r"DLL .* failed to open",
-            r"Incompatible pixel format '.*' for codec '[A-Za-z0-9_]*'",
-            r"Unrecognized option '.*'",
-            r"Permission denied",
-        )
-
-        if self.debug:
-            print(f"stderr: {output}")
-
-        for item in error_list:
-            if check := search(item, output):
-                self.log.error(check.group())
-
-        if path is not None and not os.path.isfile(path):
-            self.log.error(f"The file {path} was not created.")
-        if show_out and not self.debug:
-            print(f"stderr: {output}")
-
     def Popen(
         self, cmd: list[str], stdin: Any = None, stdout: Any = PIPE, stderr: Any = None
     ) -> Popen:
@@ -103,13 +66,9 @@ def mux(input: Path, output: Path, stream: int) -> None:
     output_audio_stream = output_container.add_stream("pcm_s16le")
 
     for frame in input_container.decode(input_audio_stream):
-        packet = output_audio_stream.encode(frame)
-        if packet:
-            output_container.mux(packet)
+        output_container.mux(output_audio_stream.encode(frame))
 
-    packet = output_audio_stream.encode(None)
-    if packet:
-        output_container.mux(packet)
+    output_container.mux(output_audio_stream.encode(None))
 
     output_container.close()
     input_container.close()

{auto_editor-25.3.1 → auto_editor-26.0.0}/auto_editor/help.py

@@ -148,11 +148,12 @@ Beware that the temp directory can get quite big.
         "--my-ffmpeg": "This is equivalent to `--ffmpeg-location ffmpeg`.",
         "--audio-bitrate": """
 `--audio-bitrate` sets the target bitrate for the audio encoder.
-The value accepts a natural number and the units: ``, `k`, `K`, and `M`.
-The special value `unset` may also be used, and means: Don't pass any value to ffmpeg, let it choose a default bitrate.
+By default, the value is `auto` (let the encoder decide).
+It can be set to a natural number with units: ``, `k`, `K`, `M`, or `G`.
+
 """.strip(),
         "--video-bitrate": """
-`--video-bitrate` sets the target bitrate for the video encoder. It accepts the same format as `--audio-bitrate` and the special `unset` value is allowed.
+`--video-bitrate` sets the target bitrate for the video encoder. `auto` is set as the default. It accepts the same format as `--audio-bitrate`
 """.strip(),
         "--margin": """
 Default value: 0.2s,0.2s

auto_editor-26.0.0/auto_editor/output.py

@@ -0,0 +1,83 @@
+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:
+    val, unit = _split_num_str(input_)
+
+    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

{auto_editor-25.3.1 → auto_editor-26.0.0}/auto_editor/render/audio.py

@@ -35,8 +35,6 @@ norm_types = {
     ),
 }
 
-file_null = "NUL" if system() in ("Windows", "cli") else "/dev/null"
-
 
 def parse_norm(norm: str, log: Log) -> dict | None:
     if norm == "#f":
@@ -58,7 +56,7 @@ def parse_norm(norm: str, log: Log) -> dict | None:
         log.error(e)
 
 
-def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> list[str]:
+def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> tuple[str, str]:
     start = end = 0
     lines = stderr.splitlines()
 
@@ -78,13 +76,7 @@ def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> list[str]:
     except MyError:
         log.error(f"Invalid loudnorm stats.\n{start=},{end=}\n{stderr!r}")
 
-    for key in (
-        "input_i",
-        "input_tp",
-        "input_lra",
-        "input_thresh",
-        "target_offset",
-    ):
+    for key in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset"):
         val = float(parsed[key])
         if val == float("-inf"):
             parsed[key] = -99
@@ -100,31 +92,12 @@ def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> list[str]:
     m_thresh = parsed["input_thresh"]
     target_offset = parsed["target_offset"]
 
-    return [
-        "-af",
-        f"loudnorm=i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:offset={target_offset}"
+    filter = (
+        f"i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:offset={target_offset}"
         f":measured_i={m_i}:measured_lra={m_lra}:measured_tp={m_tp}"
-        f":measured_thresh={m_thresh}:linear=true:print_format=json",
-    ]
-
-
-def parse_peak_bytes(t: float, stderr: bytes, log: Log) -> list[str]:
-    peak_level = None
-    for line in stderr.splitlines():
-        if line.startswith(b"[Parsed_astats_0") and b"Peak level dB:" in line:
-            try:
-                peak_level = float(line.split(b":")[1])
-            except Exception:
-                log.error(f"Invalid `astats` stats.\n{stderr!r}")
-            break
-
-    if peak_level is None:
-        log.error(f"Invalid `astats` stats.\n{stderr!r}")
-
-    adjustment = t - peak_level
-    log.debug(f"current peak level: {peak_level}")
-    log.print(f"peak adjustment: {adjustment}")
-    return ["-af", f"volume={adjustment}"]
+        f":measured_thresh={m_thresh}:linear=true:print_format=json"
+    )
+    return "loudnorm", filter
 
 
 def apply_audio_normalization(
@@ -135,13 +108,9 @@ def apply_audio_normalization(
             f"loudnorm=i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:"
             f"offset={norm['gain']}:print_format=json"
         )
-    else:
-        first_pass = "astats=measure_overall=Peak_level:measure_perchannel=0"
-
-    log.debug(f"audio norm first pass: {first_pass}")
-
-    stderr = ffmpeg.Popen(
-        [
+        log.debug(f"audio norm first pass: {first_pass}")
+        file_null = "NUL" if system() in ("Windows", "cli") else "/dev/null"
+        cmd = [
             "-hide_banner",
             "-i",
             f"{pre_master}",
@@ -152,19 +121,57 @@ def apply_audio_normalization(
             "-f",
             "null",
             file_null,
-        ],
-        stdin=PIPE,
-        stdout=PIPE,
-        stderr=PIPE,
-    ).communicate()[1]
-
-    if norm["tag"] == "ebu":
-        cmd = parse_ebu_bytes(norm, stderr, log)
+        ]
+        process = ffmpeg.Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        stderr = process.communicate()[1]
+        name, filter_args = parse_ebu_bytes(norm, stderr, log)
     else:
         assert "t" in norm
-        cmd = parse_peak_bytes(norm["t"], stderr, log)
 
-    ffmpeg.run(["-i", f"{pre_master}"] + cmd + [f"{path}"])
+        def get_peak_level(frame: av.AudioFrame) -> float:
+            # Calculate peak level in dB
+            # Should be equivalent to: -af astats=measure_overall=Peak_level:measure_perchannel=0
+            max_amplitude = np.abs(frame.to_ndarray()).max()
+            if max_amplitude > 0.0:
+                return -20.0 * np.log10(max_amplitude)
+            return -99.0
+
+        with av.open(pre_master) as container:
+            max_peak_level = -99.0
+            assert len(container.streams.video) == 0
+            for frame in container.decode(audio=0):
+                peak_level = get_peak_level(frame)
+                max_peak_level = max(max_peak_level, peak_level)
+
+        adjustment = norm["t"] - max_peak_level
+        log.debug(f"current peak level: {max_peak_level}")
+        log.print(f"peak adjustment: {adjustment:.3f}dB")
+        name, filter_args = "volume", f"{adjustment}"
+
+    with av.open(pre_master) as container:
+        input_stream = container.streams.audio[0]
+
+        output_file = av.open(path, mode="w")
+        output_stream = output_file.add_stream("pcm_s16le", rate=input_stream.rate)
+
+        graph = av.filter.Graph()
+        graph.link_nodes(
+            graph.add_abuffer(template=input_stream),
+            graph.add(name, filter_args),
+            graph.add("abuffersink"),
+        ).configure()
+        for frame in container.decode(input_stream):
+            graph.push(frame)
+            while True:
+                try:
+                    aframe = graph.pull()
+                    assert isinstance(aframe, av.AudioFrame)
+                    output_file.mux(output_stream.encode(aframe))
+                except (av.BlockingIOError, av.EOFError):
+                    break
+
+        output_file.mux(output_stream.encode(None))
+        output_file.close()
 
 
 def process_audio_clip(
@@ -212,19 +219,22 @@ def process_audio_clip(
             try:
                 aframe = graph.pull()
                 assert isinstance(aframe, av.AudioFrame)
-                for packet in output_stream.encode(aframe):
-                    output_file.mux(packet)
+                output_file.mux(output_stream.encode(aframe))
             except (av.BlockingIOError, av.EOFError):
                 break
 
     # Flush the stream
-    for packet in output_stream.encode(None):
-        output_file.mux(packet)
+    output_file.mux(output_stream.encode(None))
 
     input_file.close()
     output_file.close()
 
     output_bytes.seek(0)
+    has_filesig = output_bytes.read(4)
+    output_bytes.seek(0)
+    if not has_filesig:  # Can rarely happen when clip is extremely small
+        return np.empty((0, 2), dtype=np.int16)
+
     return read(output_bytes)[1]