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

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "25.3.1"
+__version__ = "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/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/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/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, path=output_path)