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

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]
 
 

auto_editor/render/subtitle.py

@@ -1,18 +1,23 @@
 from __future__ import annotations
 
+import io
 import os
 import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+import av
+
 from auto_editor.utils.func import to_timecode
 
 if TYPE_CHECKING:
     from fractions import Fraction
 
-    from auto_editor.output import Ensure
     from auto_editor.timeline import v3
     from auto_editor.utils.chunks import Chunks
+    from auto_editor.utils.log import Log
+
+    Input = av.container.InputContainer
 
 
 @dataclass(slots=True)
@@ -26,7 +31,6 @@ class SerialSub:
 
 class SubtitleParser:
     def __init__(self, tb: Fraction) -> None:
-        self.supported_codecs = ("ass", "webvtt", "mov_text")
         self.tb = tb
         self.contents: list[SerialSub] = []
         self.header = ""
@@ -125,24 +129,79 @@ class SubtitleParser:
             file.write(self.footer)
 
 
-def make_new_subtitles(tl: v3, ensure: Ensure, temp: str) -> list[str]:
+def make_srt(input_: Input, stream: int) -> str:
+    output_bytes = io.StringIO()
+    input_stream = input_.streams.subtitles[stream]
+    assert input_stream.time_base is not None
+    s = 1
+    for packet in input_.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
+
+        for subset in packet.decode():
+            start_time = to_timecode(start, "srt")
+            end_time = to_timecode(end, "srt")
+
+            sub = subset[0]
+            assert len(subset) == 1
+            assert isinstance(sub, av.subtitles.subtitle.AssSubtitle)
+
+            output_bytes.write(f"{s}\n{start_time} --> {end_time}\n")
+            output_bytes.write(sub.dialogue.decode("utf-8", errors="ignore") + "\n\n")
+            s += 1
+
+    output_bytes.seek(0)
+    return output_bytes.getvalue()
+
+
+def _ensure(input_: Input, format: str, stream: int, log: Log) -> str:
+    output_bytes = io.BytesIO()
+    output = av.open(output_bytes, "w", format=format)
+
+    in_stream = input_.streams.subtitles[stream]
+    out_stream = output.add_stream(template=in_stream)
+
+    for packet in input_.demux(in_stream):
+        if packet.dts is None:
+            continue
+        packet.stream = out_stream
+        output.mux(packet)
+
+    output.close()
+    output_bytes.seek(0)
+    return output_bytes.getvalue().decode("utf-8", errors="ignore")
+
+
+def make_new_subtitles(tl: v3, log: Log) -> list[str]:
     if tl.v1 is None:
         return []
 
+    input_ = av.open(tl.v1.source.path)
     new_paths = []
 
     for s, sub in enumerate(tl.v1.source.subtitles):
-        new_path = os.path.join(temp, f"new{s}s.{sub.ext}")
-        parser = SubtitleParser(tl.tb)
+        if sub.codec == "mov_text":
+            continue
 
-        ext = sub.ext if sub.codec in parser.supported_codecs else "vtt"
-        file_path = ensure.subtitle(tl.v1.source, s, ext)
-
-        with open(file_path, encoding="utf-8") as file:
-            parser.parse(file.read(), sub.codec)
+        parser = SubtitleParser(tl.tb)
+        if sub.codec in ("webvtt", "ass", "ssa"):
+            format = sub.codec
+        else:
+            log.error(f"Unknown subtitle codec: {sub.codec}")
 
+        if sub.codec == "mov_text":
+            ret = make_srt(input_, s)
+        else:
+            ret = _ensure(input_, format, s, log)
+        parser.parse(ret, sub.codec)
         parser.edit(tl.v1.chunks)
+
+        new_path = os.path.join(log.temp, f"new{s}s.{sub.ext}")
         parser.write(new_path)
         new_paths.append(new_path)
 
+    input_.close()
     return new_paths