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

auto_editor/ffwrapper.py

@@ -1,152 +1,74 @@
 from __future__ import annotations
 
-import os.path
-import subprocess
 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
+from subprocess import PIPE, Popen, run
 from typing import Any
 
 import av
 
-from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 
 
-class FFmpeg:
-    __slots__ = ("debug", "show_cmd", "path", "version")
-
-    def __init__(
-        self,
-        ff_location: str | None = None,
-        my_ffmpeg: bool = False,
-        show_cmd: bool = False,
-        debug: bool = False,
-    ):
-        def _set_ff_path(ff_location: str | None, my_ffmpeg: bool) -> str:
-            if ff_location is not None:
-                return ff_location
-            if my_ffmpeg:
-                return "ffmpeg"
-
-            try:
-                import ae_ffmpeg
-
-                return ae_ffmpeg.get_path()
-            except ImportError:
-                return "ffmpeg"
-
-        self.debug = debug
-        self.show_cmd = show_cmd
-        _path: str | None = _set_ff_path(ff_location, my_ffmpeg)
-
-        if _path == "ffmpeg":
-            _path = which("ffmpeg")
-
-        if _path is None:
-            Log().error("Did not find ffmpeg on PATH.")
-        self.path = _path
-
+def initFFmpeg(
+    log: Log, ff_location: str | None, my_ffmpeg: bool, show_cmd: bool, debug: bool
+) -> FFmpeg:
+    if ff_location is not None:
+        program = ff_location
+    elif my_ffmpeg:
+        program = "ffmpeg"
+    else:
         try:
-            _version = get_stdout([self.path, "-version"]).split("\n")[0]
-            self.version = _version.replace("ffmpeg version", "").strip().split(" ")[0]
-        except FileNotFoundError:
-            Log().error("ffmpeg must be installed and on PATH.")
+            import ae_ffmpeg
 
-    def print(self, message: str) -> None:
-        if self.debug:
-            sys.stderr.write(f"FFmpeg: {message}\n")
+            program = ae_ffmpeg.get_path()
+        except ImportError:
+            program = "ffmpeg"
 
-    def print_cmd(self, cmd: list[str]) -> None:
-        if self.show_cmd:
-            sys.stderr.write(f"{' '.join(cmd)}\n\n")
+    path: str | None = which(program)
+    if path is None:
+        log.error("Did not find ffmpeg on PATH.")
+
+    return FFmpeg(log, path, show_cmd, debug)
+
+
+@dataclass(slots=True)
+class FFmpeg:
+    log: Log
+    path: str
+    show_cmd: bool
+    debug: bool
 
     def run(self, cmd: list[str]) -> None:
         cmd = [self.path, "-hide_banner", "-y"] + cmd
         if not self.debug:
             cmd.extend(["-nostats", "-loglevel", "error"])
-        self.print_cmd(cmd)
-        subprocess.run(cmd)
-
-    def run_check_errors(
-        self,
-        cmd: list[str],
-        log: Log,
-        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):
-                log.error(check.group())
-
-        if path is not None and not os.path.isfile(path):
-            log.error(f"The file {path} was not created.")
-        elif show_out and not self.debug:
-            print(f"stderr: {output}")
+        if self.show_cmd:
+            sys.stderr.write(f"{' '.join(cmd)}\n\n")
+        run(cmd)
 
     def Popen(
         self, cmd: list[str], stdin: Any = None, stdout: Any = PIPE, stderr: Any = None
     ) -> Popen:
-        cmd = [self.path] + cmd
-        self.print_cmd(cmd)
-        return Popen(cmd, stdin=stdin, stdout=stdout, stderr=stderr)
-
-    def pipe(self, cmd: list[str]) -> str:
-        cmd = [self.path, "-y"] + cmd
-
-        self.print_cmd(cmd)
-        output = get_stdout(cmd)
-        self.print(output)
-        return output
+        if self.show_cmd:
+            sys.stderr.write(f"{self.path} {' '.join(cmd)}\n\n")
+        return Popen([self.path] + cmd, stdin=stdin, stdout=stdout, stderr=stderr)
 
 
-def mux(input: Path, output: Path, stream: int, codec: str | None = None) -> None:
+def mux(input: Path, output: Path, stream: int) -> None:
     input_container = av.open(input, "r")
     output_container = av.open(output, "w")
 
     input_audio_stream = input_container.streams.audio[stream]
-
-    if codec is None:
-        codec = "pcm_s16le"
-
-    output_audio_stream = output_container.add_stream(codec)
-    assert isinstance(output_audio_stream, av.audio.AudioStream)
+    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/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/output.py

@@ -2,26 +2,37 @@ from __future__ import annotations
 
 import os.path
 from dataclasses import dataclass, field
-from fractions import Fraction
 
 import av
 from av.audio.resampler import AudioResampler
 
-from auto_editor.ffwrapper import FFmpeg, FileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.utils.bar import Bar
-from auto_editor.utils.container import Container
 from auto_editor.utils.log import Log
-from auto_editor.utils.types import Args
+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:
-    _ffmpeg: FFmpeg
     _bar: Bar
     _sr: int
     log: Log
     _audios: list[tuple[FileInfo, int]] = field(default_factory=list)
-    _subtitles: list[tuple[FileInfo, int, str]] = field(default_factory=list)
 
     def audio(self, src: FileInfo, stream: int) -> str:
         try:
@@ -52,193 +63,21 @@ class Ensure:
 
             bar.start(dur, "Extracting audio")
 
-            # PyAV always uses "stereo" layout, which is what we want.
-            output_astream = out_container.add_stream("pcm_s16le", rate=sample_rate)
-            assert isinstance(output_astream, av.audio.stream.AudioStream)
-
+            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):
-                    for packet in output_astream.encode(new_frame):
-                        out_container.mux_one(packet)
+                    out_container.mux(output_astream.encode(new_frame))
 
-            for packet in output_astream.encode():
-                out_container.mux_one(packet)
+            out_container.mux(output_astream.encode(None))
 
             out_container.close()
             in_container.close()
             bar.end()
 
         return out_path
-
-    def subtitle(self, src: FileInfo, stream: int, ext: str) -> str:
-        try:
-            self._subtitles.index((src, stream, ext))
-            first_time = False
-        except ValueError:
-            self._subtitles.append((src, stream, ext))
-            first_time = True
-
-        out_path = os.path.join(self.log.temp, f"{stream}s.{ext}")
-
-        if first_time:
-            self.log.debug(f"Making external subtitle: {out_path}")
-            self.log.conwrite("Extracting subtitle")
-            self._ffmpeg.run(["-i", f"{src.path}", "-map", f"0:s:{stream}", out_path])
-
-        return out_path
-
-
-def _ffset(option: str, value: str | None) -> list[str]:
-    if value is None or value == "unset" or value == "reserved":
-        return []
-    return [option] + [value]
-
-
-def video_quality(args: Args) -> list[str]:
-    return (
-        _ffset("-b:v", args.video_bitrate)
-        + ["-c:v", args.video_codec]
-        + _ffset("-qscale:v", args.video_quality_scale)
-        + ["-movflags", "faststart"]
-    )
-
-
-def mux_quality_media(
-    ffmpeg: FFmpeg,
-    visual_output: list[tuple[bool, str]],
-    audio_output: list[str],
-    sub_output: list[str],
-    apply_v: bool,
-    ctr: Container,
-    output_path: str,
-    tb: Fraction,
-    args: Args,
-    src: FileInfo,
-    log: Log,
-) -> None:
-    v_tracks = len(visual_output)
-    a_tracks = len(audio_output)
-    s_tracks = 0 if args.sn else len(sub_output)
-
-    cmd = ["-hide_banner", "-y", "-i", f"{src.path}"]
-
-    same_container = src.path.suffix == os.path.splitext(output_path)[1]
-
-    for is_video, path in visual_output:
-        if is_video or ctr.allow_image:
-            cmd.extend(["-i", path])
-        else:
-            v_tracks -= 1
-
-    if a_tracks > 0:
-        if args.keep_tracks_separate and ctr.max_audios is None:
-            for path in audio_output:
-                cmd.extend(["-i", path])
-        else:
-            # Merge all the audio a_tracks into one.
-            new_a_file = os.path.join(log.temp, "new_audio.wav")
-            if a_tracks > 1:
-                new_cmd = []
-                for path in audio_output:
-                    new_cmd.extend(["-i", path])
-                new_cmd.extend(
-                    [
-                        "-filter_complex",
-                        f"amix=inputs={a_tracks}:duration=longest",
-                        "-ac",
-                        "2",
-                        new_a_file,
-                    ]
-                )
-                ffmpeg.run(new_cmd)
-                a_tracks = 1
-            else:
-                new_a_file = audio_output[0]
-            cmd.extend(["-i", new_a_file])
-
-    for subfile in sub_output:
-        cmd.extend(["-i", subfile])
-
-    for i in range(v_tracks + s_tracks + a_tracks):
-        cmd.extend(["-map", f"{i+1}:0"])
-
-    cmd.extend(["-map_metadata", "0"])
-
-    track = 0
-    for is_video, path in visual_output:
-        if is_video:
-            if apply_v:
-                cmd += video_quality(args)
-            else:
-                # Real video is only allowed on track 0
-                cmd += ["-c:v:0", "copy"]
-
-            if float(tb).is_integer():
-                cmd += ["-video_track_timescale", f"{tb}"]
-
-        elif ctr.allow_image:
-            ext = os.path.splitext(path)[1][1:]
-            cmd += [f"-c:v:{track}", ext, f"-disposition:v:{track}", "attached_pic"]
-
-        track += 1
-    del track
-
-    for i, vstream in enumerate(src.videos):
-        if i > v_tracks:
-            break
-        if vstream.lang is not None:
-            cmd.extend([f"-metadata:s:v:{i}", f"language={vstream.lang}"])
-    for i, astream in enumerate(src.audios):
-        if i > a_tracks:
-            break
-        if astream.lang is not None:
-            cmd.extend([f"-metadata:s:a:{i}", f"language={astream.lang}"])
-    for i, sstream in enumerate(src.subtitles):
-        if i > s_tracks:
-            break
-        if sstream.lang is not None:
-            cmd.extend([f"-metadata:s:s:{i}", f"language={sstream.lang}"])
-
-    if s_tracks > 0:
-        scodec = src.subtitles[0].codec
-        if same_container:
-            cmd.extend(["-c:s", scodec])
-        elif ctr.scodecs is not None:
-            if scodec not in ctr.scodecs:
-                scodec = ctr.default_sub
-            cmd.extend(["-c:s", scodec])
-
-    if a_tracks > 0:
-        cmd += _ffset("-c:a", args.audio_codec) + _ffset("-b:a", args.audio_bitrate)
-
-    if same_container and v_tracks > 0:
-        color_range = src.videos[0].color_range
-        colorspace = src.videos[0].color_space
-        color_prim = src.videos[0].color_primaries
-        color_trc = src.videos[0].color_transfer
-
-        if color_range == 1 or color_range == 2:
-            cmd.extend(["-color_range", f"{color_range}"])
-        if colorspace in (0, 1) or (colorspace >= 3 and colorspace < 16):
-            cmd.extend(["-colorspace", f"{colorspace}"])
-        if color_prim == 1 or (color_prim >= 4 and color_prim < 17):
-            cmd.extend(["-color_primaries", f"{color_prim}"])
-        if color_trc == 1 or (color_trc >= 4 and color_trc < 22):
-            cmd.extend(["-color_trc", f"{color_trc}"])
-
-    if args.extras is not None:
-        cmd.extend(args.extras.split(" "))
-    cmd.extend(["-strict", "-2"])  # Allow experimental codecs.
-
-    if s_tracks > 0:
-        cmd.extend(["-map", "0:t?"])  # Add input attachments to output.
-
-    if not args.dn:
-        cmd.extend(["-map", "0:d?"])
-
-    cmd.append(output_path)
-    ffmpeg.run_check_errors(cmd, log, path=output_path)

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(
@@ -180,7 +187,6 @@ def process_audio_clip(
     output_bytes = io.BytesIO()
     output_file = av.open(output_bytes, mode="w", format="wav")
     output_stream = output_file.add_stream("pcm_s16le", rate=sr)
-    assert isinstance(output_stream, av.audio.AudioStream)
 
     graph = av.filter.Graph()
     args = [graph.add_abuffer(template=input_stream)]
@@ -212,20 +218,23 @@ def process_audio_clip(
         while True:
             try:
                 aframe = graph.pull()
-                assert isinstance(aframe, av.audio.AudioFrame)
-                for packet in output_stream.encode(aframe):
-                    output_file.mux(packet)
+                assert isinstance(aframe, av.AudioFrame)
+                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]