easyrip 3.13.2__py3-none-any.whl → 4.9.1__py3-none-any.whl

easyrip/ripper/ripper.py

@@ -1,131 +1,64 @@
-import enum
 import os
 import re
 import shutil
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from datetime import datetime
 from itertools import zip_longest
 from pathlib import Path
 from threading import Thread
 from time import sleep
-from typing import Callable, Iterable, Self
+from typing import Final, Self, final
 
 from .. import easyrip_web
 from ..easyrip_log import log
 from ..easyrip_mlang import Global_lang_val, gettext, translate_subtitles
 from ..utils import get_base62_time
-from .font_subset import subset
-from .media_info import Media_info
+from .media_info import Media_info, Stream_error
+from .param import (
+    DEFAULT_PRESET_PARAMS,
+    FONT_SUFFIX_SET,
+    SUBTITLE_SUFFIX_SET,
+    X264_PARAMS_NAME,
+    X265_PARAMS_NAME,
+)
+from .sub_and_font import subset
 
 FF_PROGRESS_LOG_FILE = Path("FFProgress.log")
 FF_REPORT_LOG_FILE = Path("FFReport.log")
 
 
+@final
 class Ripper:
-    ripper_list: list["Ripper"] = []
+    ripper_list: Final[list["Ripper"]] = []
 
-    @staticmethod
+    @classmethod
     def add_ripper(
+        cls: type["Ripper"],
         input_path: Iterable[str | Path],
         output_prefix: Iterable[str | None],
         output_dir: str | None,
-        option: "Option | PresetName",
+        option: "Option | Preset_name",
         option_map: dict[str, str],
     ):
         try:
-            Ripper.ripper_list.append(
-                Ripper(input_path, output_prefix, output_dir, option, option_map)
+            cls.ripper_list.append(
+                cls(input_path, output_prefix, output_dir, option, option_map)
             )
         except Exception as e:
             log.error("Failed to add Ripper: {}", e, deep=True)
 
-    class PresetName(enum.Enum):
-        custom = "custom"
-
-        copy = "copy"
-
-        subset = "subset"
-
-        flac = "flac"
-
-        x264fast = "x264fast"
-        x264slow = "x264slow"
-
-        x265fast4 = "x265fast4"
-        x265fast3 = "x265fast3"
-        x265fast2 = "x265fast2"
-        x265fast = "x265fast"
-        x265slow = "x265slow"
-        x265full = "x265full"
-
-        svtav1 = "svtav1"
-
-        h264_amf = "h264_amf"
-        h264_nvenc = "h264_nvenc"
-        h264_qsv = "h264_qsv"
-
-        hevc_amf = "hevc_amf"
-        hevc_nvenc = "hevc_nvenc"
-        hevc_qsv = "hevc_qsv"
-
-        av1_amf = "av1_amf"
-        av1_nvenc = "av1_nvenc"
-        av1_qsv = "av1_qsv"
-
-        @classmethod
-        def _missing_(cls, value: object):
-            default = cls.custom
-            log.error(
-                "'{}' is not a valid '{}', set to default value '{}'. Valid options are: {}",
-                value,
-                cls.__name__,
-                default,
-                list(cls.__members__.keys()),
-            )
-            return default
-
-    class AudioCodec(enum.Enum):
-        copy = "copy"
-        libopus = "libopus"
-        flac = "flac"
-
-        @classmethod
-        def _missing_(cls, value: object):
-            default = cls.copy
-            log.error(
-                "'{}' is not a valid '{}', set to default value '{}'. Valid options are: {}",
-                value,
-                cls.__name__,
-                default,
-                list(cls.__members__.keys()),
-            )
-            return default
-
-    class Muxer(enum.Enum):
-        mp4 = "mp4"
-        mkv = "mkv"
-
-        @classmethod
-        def _missing_(cls, value: object):
-            default = cls.mkv
-            log.error(
-                "'{}' is not a valid '{}', set to default value '{}'. Valid options are: {}",
-                value,
-                cls.__name__,
-                default,
-                list(cls.__members__.keys()),
-            )
-            return default
+    from .param import Audio_codec, Muxer, Preset_name
 
     @dataclass(slots=True)
     class Option:
-        preset_name: "Ripper.PresetName"
+        preset_name: "Ripper.Preset_name"
         encoder_format_str: str
-        audio_encoder: "Ripper.AudioCodec | None"
+        audio_encoder: "Ripper.Audio_codec | None"
         muxer: "Ripper.Muxer | None"
         muxer_format_str: str
 
-        def __str__(self):
+        def __str__(self) -> str:
             return f"  preset_name = {self.preset_name}\n  option_format = {self.encoder_format_str}"
 
     input_path_list: list[Path]
@@ -134,7 +67,7 @@ class Ripper:
     option: Option
     option_map: dict[str, str]
 
-    preset_name: PresetName
+    preset_name: Preset_name
 
     media_info: Media_info
 
@@ -157,9 +90,9 @@ class Ripper:
         input_path: Iterable[str | Path],
         output_prefix: Iterable[str | None],
         output_dir: str | None,
-        option: Option | PresetName,
+        option: Option | Preset_name,
         option_map: dict[str, str],
-    ):
+    ) -> None:
         self.input_path_list = [Path(path) for path in input_path]
 
         self.media_info = Media_info.from_path(self.input_path_list[0])
@@ -182,16 +115,16 @@ class Ripper:
                 "The muxer must be 'mkv' when mux subtitle and font. Auto modified"
             )
 
-        if isinstance(option, Ripper.PresetName):
+        if isinstance(option, Ripper.Preset_name):
             self.preset_name = option
             self.option = self.preset_name_to_option(option)
         else:
-            self.preset_name = Ripper.PresetName.custom
+            self.preset_name = Ripper.Preset_name.custom
             self.option = option
 
-        self._progress = dict[str, int | float]()
+        self._progress: dict[str, int | float] = {}
 
-    def __str__(self):
+    def __str__(self) -> str:
         return (
             f"-i {self.input_path_list[0]} -o {self.output_prefix_list[0]} -o:dir {self.output_dir} -preset {self.option.preset_name.value} {' '.join((f'-{key} {val}' for key, val in self.option_map.items()))}\n"
             "  option:  {\n"
@@ -200,7 +133,7 @@ class Ripper:
             f"  option_map: {self.option_map}"
         )
 
-    def preset_name_to_option(self, preset_name: PresetName) -> Option:
+    def preset_name_to_option(self, preset_name: Preset_name) -> Option:
         if (
             force_fps := self.option_map.get("r") or self.option_map.get("fps")
         ) == "auto":
@@ -228,10 +161,7 @@ class Ripper:
         is_pipe_input = bool(self.input_path_list[0].suffix == ".vpy" or vpy_pathname)
 
         ff_input_option: list[str]
-        if is_pipe_input:
-            ff_input_option = ["-"]
-        else:
-            ff_input_option = ['"{input}"']
+        ff_input_option = ["-"] if is_pipe_input else ['"{input}"']
         ff_stream_option: list[str] = ["0:v"]
         ff_vf_option: list[str] = (
             s.split(",") if (s := self.option_map.get("vf")) else []
@@ -242,29 +172,66 @@ class Ripper:
             ff_vf_option.append(f"ass={sub_pathname}")
 
         # Audio
-        if audio_encoder := self.option_map.get("c:a"):
-            _audio_encoder_str = audio_encoder
-            audio_encoder = Ripper.AudioCodec(audio_encoder)
+        if audio_encoder_str := self.option_map.get("c:a"):
+            if (
+                not self.media_info.audio_info
+                and self.preset_name != Ripper.Preset_name.subset
+            ):
+                raise Stream_error(
+                    "There is no audio stream in the video, so '-c:a' cannot be used"
+                )
+
+            if audio_encoder_str not in Ripper.Audio_codec._member_map_:
+                raise ValueError(
+                    gettext("Unsupported '{}' param: {}", "-c:a", audio_encoder_str)
+                )
+
+            audio_encoder = Ripper.Audio_codec[audio_encoder_str]
+
+            # 通知别名映射
+            if audio_encoder_str not in Ripper.Audio_codec._member_names_:
+                log.info(
+                    "Auto mapping encoder name: {} -> {}",
+                    audio_encoder_str,
+                    audio_encoder.name,
+                )
+
             if is_pipe_input:
                 ff_input_option.append('"{input}"')
                 ff_stream_option.append("1:a")
             else:
                 ff_stream_option.append("0:a")
 
-            _encoder_str = (
-                ""
-                if audio_encoder == Ripper.AudioCodec.copy
-                and self.preset_name == Ripper.PresetName.copy
-                else "-an "
-                if audio_encoder == Ripper.AudioCodec.flac
-                else f"-c:a {_audio_encoder_str} "
-            )
+            match audio_encoder:
+                case Ripper.Audio_codec.copy:
+                    _encoder_str = (
+                        ""
+                        if self.preset_name == Ripper.Preset_name.copy
+                        else "-c:a copy "
+                    )
+                case Ripper.Audio_codec.flac:
+                    _encoder_str = "-an "
+                case Ripper.Audio_codec.libopus:
+                    _encoder_str = "-c:a libopus "
+                    for opt in (
+                        "application",
+                        "frame_duration",
+                        "packet_loss",
+                        "fec",
+                        "vbr",
+                        "mapping_family",
+                        "apply_phase_inv",
+                    ):
+                        if (val := self.option_map.get(opt)) is not None:
+                            _encoder_str += f"-{opt} {val} "
+
             _bitrate_str = (
                 ""
-                if audio_encoder in {Ripper.AudioCodec.copy, Ripper.AudioCodec.flac}
-                else f"-b:a {self.option_map.get('b:a') or '160k'}"
+                if audio_encoder in {Ripper.Audio_codec.copy, Ripper.Audio_codec.flac}
+                else f"-b:a {self.option_map.get('b:a') or '160k'} "
             )
-            audio_option = f"{_encoder_str}{_bitrate_str} "
+
+            audio_option = _encoder_str + _bitrate_str
 
         else:
             audio_encoder = None
@@ -285,7 +252,7 @@ class Ripper:
                         )
                         + (
                             ""
-                            if self.preset_name == Ripper.PresetName.flac
+                            if self.preset_name == Ripper.Preset_name.flac
                             else (
                                 "&& mp4fpsmod "
                                 + (f"-r 0:{force_fps}" if force_fps else "")
@@ -324,22 +291,13 @@ class Ripper:
                                     )
                                     == 1
                                     else "--attach-file "
-                                    if _file.suffix in {".otf", ".ttf", ".ttc"}
+                                    if _file.suffix in FONT_SUFFIX_SET
                                     else f"--language 0:{affixes[1]} --track-name 0:{Global_lang_val.language_tag_to_local_str(affixes[1])} "
                                 )
                                 + f'"{_file.absolute()}"'
                                 for _file in only_mux_sub_path.iterdir()
                                 if _file.suffix
-                                in {
-                                    ".srt",
-                                    ".ass",
-                                    ".ssa",
-                                    ".sup",
-                                    ".idx",
-                                    ".otf",
-                                    ".ttf",
-                                    ".ttc",
-                                }
+                                in (SUBTITLE_SUFFIX_SET | FONT_SUFFIX_SET)
                             )
                             if only_mux_sub_path
                             else ""
@@ -355,9 +313,9 @@ class Ripper:
         pipe_gvar_list = [
             s for s in self.option_map.get("pipe:gvar", "").split(":") if s
         ]
-        pipe_gvar_dict = {
-            s.split("=")[0]: s.split("=")[1] for s in pipe_gvar_list if "=" in s
-        }
+        pipe_gvar_dict = dict(
+            s.split("=", maxsplit=1) for s in pipe_gvar_list if "=" in s
+        )
         if sub_pathname:
             pipe_gvar_dict["subtitle"] = sub_pathname
 
@@ -373,19 +331,19 @@ class Ripper:
         ffparams_ff = self.option_map.get("ff-params:ff") or self.option_map.get(
             "ff-params", ""
         )
-        ffparams_in = self.option_map.get("ff-params:in", "")
-        ffparams_out = self.option_map.get("ff-params:out", "")
+        ffparams_in = self.option_map.get("ff-params:in", "") + " "
+        ffparams_out = self.option_map.get("ff-params:out", "") + " "
         if _ss := self.option_map.get("ss"):
-            ffparams_in += f" -ss {_ss}"
+            ffparams_in += f"-ss {_ss} "
         if _t := self.option_map.get("t"):
-            ffparams_out += f" -t {_t}"
+            ffparams_out += f"-t {_t} "
         if _preset := self.option_map.get("v:preset"):
-            ffparams_out += f" -preset {_preset}"
+            ffparams_out += f"-preset {_preset} "
 
         FFMPEG_HEADER = f"ffmpeg {'-hide_banner ' if self.option_map.get('_sub_ripper_num') else ''}-progress {FF_PROGRESS_LOG_FILE} -report {ffparams_ff} {ffparams_in}"
 
         match preset_name:
-            case Ripper.PresetName.custom:
+            case Ripper.Preset_name.custom:
                 if not (
                     encoder_format_str := self.option_map.get(
                         "custom:format",
@@ -412,7 +370,7 @@ class Ripper:
                         )
                     )
 
-            case Ripper.PresetName.copy:
+            case Ripper.Preset_name.copy:
                 hwaccel = (
                     f"-hwaccel {hwaccel}"
                     if (hwaccel := self.option_map.get("hwaccel"))
@@ -421,9 +379,10 @@ class Ripper:
 
                 encoder_format_str = (
                     f"{FFMPEG_HEADER} {hwaccel} "
-                    + '-i "{input}" -c copy '
-                    + f"{' '.join(f'-map {s}' for s in ff_stream_option)} "
-                    + f"{audio_option} {ffparams_out} "
+                    '-i "{input}" -c copy '
+                    f"{' '.join(f'-map {s}' for s in ff_stream_option)} "
+                    + audio_option
+                    + ffparams_out
                     + '"{output}"'
                 )
 
@@ -444,10 +403,10 @@ class Ripper:
                             else 'mkvmerge -o "{output}" "{input}"'
                         )
 
-            case Ripper.PresetName.flac:
+            case Ripper.Preset_name.flac:
                 _ff_encode_str: str = ""
                 _flac_encode_str: str = ""
-                _mux_flac_input_list = list[str]()
+                _mux_flac_input_list: list[str] = []
                 # _mux_flac_map_str: str = ""
                 _del_flac_str: str = ""
 
@@ -505,7 +464,7 @@ class Ripper:
                     case _:
                         _mux_str = (
                             f"mp4box -add {' -add '.join(_mux_flac_input_list)}"
-                            + ' -new "{output}" '
+                            ' -new "{output}" '
                             if muxer == Ripper.Muxer.mp4
                             else 'mkvmerge -o "{output}" '
                             + " ".join(_mux_flac_input_list)
@@ -516,395 +475,108 @@ class Ripper:
                             f"&& {_mux_str} " + _del_flac_str
                         )
 
-            case Ripper.PresetName.x264fast | Ripper.PresetName.x264slow:
-                match preset_name:
-                    case Ripper.PresetName.x264fast:
-                        _option_map = {
-                            "threads": self.option_map.get("threads", "auto"),
-                            # Select
-                            "crf": self.option_map.get("crf", "20"),
-                            "psy-rd": self.option_map.get("psy-rd", "0.6,0.15"),
-                            "qcomp": self.option_map.get("qcomp", "0.66"),
-                            "keyint": self.option_map.get("keyint", "250"),
-                            "deblock": self.option_map.get("deblock", "0,0"),
-                            # Default
-                            "qpmin": self.option_map.get("qpmin", "8"),
-                            "qpmax": self.option_map.get("qpmax", "32"),
-                            "bframes": self.option_map.get("bframes", "8"),
-                            "ref": self.option_map.get("ref", "4"),
-                            "subme": self.option_map.get("subme", "5"),
-                            "me": self.option_map.get("me", "hex"),
-                            "merange": self.option_map.get("merange", "16"),
-                            "aq-mode": self.option_map.get("aq-mode", "1"),
-                            "rc-lookahead": self.option_map.get("rc-lookahead", "60"),
-                            "min-keyint": self.option_map.get("min-keyint", "2"),
-                            "trellis": self.option_map.get("trellis", "1"),
-                            "fast-pskip": self.option_map.get("fast-pskip", "1"),
-                            # No change
-                            "weightb": "1",
-                            **{
-                                k: v
-                                for k, v in [
-                                    s.split("=")
-                                    for s in str(
-                                        self.option_map.get("x264-params", "")
-                                    ).split(":")
-                                    if s != ""
-                                ]
-                            },
-                        }
-                    case Ripper.PresetName.x264slow:
-                        _option_map = {
-                            "threads": self.option_map.get("threads", "auto"),
-                            # Select
-                            "crf": self.option_map.get("crf", "21"),
-                            "psy-rd": self.option_map.get("psy-rd", "0.6,0.15"),
-                            "qcomp": self.option_map.get("qcomp", "0.66"),
-                            "keyint": self.option_map.get("keyint", "250"),
-                            "deblock": self.option_map.get("deblock", "-1,-1"),
-                            # Default
-                            "qpmin": self.option_map.get("qpmin", "8"),
-                            "qpmax": self.option_map.get("qpmax", "32"),
-                            "bframes": self.option_map.get("bframes", "16"),
-                            "ref": self.option_map.get("ref", "8"),
-                            "subme": self.option_map.get("subme", "7"),
-                            "me": self.option_map.get("me", "umh"),
-                            "merange": self.option_map.get("merange", "24"),
-                            "aq-mode": self.option_map.get("aq-mode", "3"),
-                            "rc-lookahead": self.option_map.get("rc-lookahead", "120"),
-                            "min-keyint": self.option_map.get("min-keyint", "2"),
-                            "trellis": self.option_map.get("trellis", "2"),
-                            "fast-pskip": self.option_map.get("fast-pskip", "0"),
-                            # No change
-                            "weightb": "1",
-                            **{
-                                k: v
-                                for k, v in [
-                                    s.split("=")
-                                    for s in str(
-                                        self.option_map.get("x264-params", "")
-                                    ).split(":")
-                                    if s != ""
-                                ]
-                            },
-                        }
+            case (
+                Ripper.Preset_name.x264
+                | Ripper.Preset_name.x264fast
+                | Ripper.Preset_name.x264slow
+            ):
+                _custom_option_map: dict[str, str] = {
+                    k: v
+                    for k, v in {
+                        **{
+                            _param_name: self.option_map.get(_param_name)
+                            for _param_name in X264_PARAMS_NAME
+                        },
+                        **dict(
+                            s.split("=", maxsplit=1)
+                            for s in str(self.option_map.get("x264-params", "")).split(
+                                ":"
+                            )
+                            if s
+                        ),
+                    }.items()
+                    if v is not None
+                }
+
+                _option_map = (
+                    DEFAULT_PRESET_PARAMS.get(preset_name, {}) | _custom_option_map
+                )
 
                 if (
                     (_crf := _option_map.get("crf"))
                     and (_qpmin := _option_map.get("qpmin"))
                     and (_qpmax := _option_map.get("qpmax"))
-                    and not (_qpmin <= _crf <= _qpmax)
+                    and not (float(_qpmin) <= float(_crf) <= float(_qpmax))
                 ):
                     log.warning("The CRF is not between QPmin and QPmax")
 
-                _param = ":".join((f"{key}={val}" for key, val in _option_map.items()))
+                _param = ":".join(f"{key}={val}" for key, val in _option_map.items())
 
                 encoder_format_str = (
                     f"{vspipe_input} {FFMPEG_HEADER} {hwaccel} {' '.join(f'-i {s}' for s in ff_input_option)} {' '.join(f'-map {s}' for s in ff_stream_option)} "
-                    + f"{audio_option} -c:v libx264 {'' if is_pipe_input else '-pix_fmt yuv420p'} -x264-params "
+                    + audio_option
+                    + f"-c:v libx264 {'' if is_pipe_input else '-pix_fmt yuv420p'} -x264-params "
                     + f'"{_param}" {ffparams_out} '
-                    + (f' -vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
-                    + ' "{output}"'
+                    + (f'-vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
+                    + '"{output}"'
                 )
 
             case (
-                Ripper.PresetName.x265fast4
-                | Ripper.PresetName.x265fast3
-                | Ripper.PresetName.x265fast2
-                | Ripper.PresetName.x265fast
-                | Ripper.PresetName.x265slow
-                | Ripper.PresetName.x265full
+                Ripper.Preset_name.x265
+                | Ripper.Preset_name.x265fast4
+                | Ripper.Preset_name.x265fast3
+                | Ripper.Preset_name.x265fast2
+                | Ripper.Preset_name.x265fast
+                | Ripper.Preset_name.x265slow
+                | Ripper.Preset_name.x265full
             ):
-                _default_option_map = {
-                    "crf": "20",
-                    "qpmin": "6",
-                    "qpmax": "32",
-                    "rd": "3",
-                    "psy-rd": "2",
-                    "rdoq-level": "0",
-                    "psy-rdoq": "0",
-                    "qcomp": "0.68",
-                    "keyint": "250",
-                    "min-keyint": "2",
-                    "deblock": "0,0",
-                    "me": "umh",
-                    "merange": "57",
-                    "hme": "1",
-                    "hme-search": "hex,hex,hex",
-                    "hme-range": "16,57,92",
-                    "aq-mode": "2",
-                    "aq-strength": "1",
-                    "tu-intra-depth": "1",
-                    "tu-inter-depth": "1",
-                    "limit-tu": "0",
-                    "bframes": "16",
-                    "ref": "8",
-                    "subme": "2",
-                    "open-gop": "1",
-                    "gop-lookahead": "0",
-                    "rc-lookahead": "20",
-                    "rect": "0",
-                    "amp": "0",
-                    "cbqpoffs": "0",
-                    "crqpoffs": "0",
-                    "ipratio": "1.4",
-                    "pbratio": "1.3",
-                    "early-skip": "1",
-                    "ctu": "64",
-                    "min-cu-size": "8",
-                    "max-tu-size": "32",
-                    "level-idc": "0",
-                    "sao": "0",
-                    "weightb": "1",
-                    "info": "1",
-                }
-                _custom_option_map: dict[str, str | None] = {
-                    "crf": self.option_map.get("crf"),
-                    "qpmin": self.option_map.get("qpmin"),
-                    "qpmax": self.option_map.get("qpmax"),
-                    "psy-rd": self.option_map.get("psy-rd"),
-                    "rd": self.option_map.get("rd"),
-                    "rdoq-level": self.option_map.get("rdoq-level"),
-                    "psy-rdoq": self.option_map.get("psy-rdoq"),
-                    "qcomp": self.option_map.get("qcomp"),
-                    "keyint": self.option_map.get("keyint"),
-                    "min-keyint": self.option_map.get("min-keyint"),
-                    "deblock": self.option_map.get("deblock"),
-                    "me": self.option_map.get("me"),
-                    "merange": self.option_map.get("merange"),
-                    "hme": self.option_map.get("hme"),
-                    "hme-search": self.option_map.get("hme-search"),
-                    "hme-range": self.option_map.get("hme-range"),
-                    "aq-mode": self.option_map.get("aq-mode"),
-                    "aq-strength": self.option_map.get("aq-strength"),
-                    "tu-intra-depth": self.option_map.get("tu-intra-depth"),
-                    "tu-inter-depth": self.option_map.get("tu-inter-depth"),
-                    "limit-tu": self.option_map.get("limit-tu"),
-                    "bframes": self.option_map.get("bframes"),
-                    "ref": self.option_map.get("ref"),
-                    "subme": self.option_map.get("subme"),
-                    "open-gop": self.option_map.get("open-gop"),
-                    "gop-lookahead": self.option_map.get("gop-lookahead"),
-                    "rc-lookahead": self.option_map.get("rc-lookahead"),
-                    "rect": self.option_map.get("rect"),
-                    "amp": self.option_map.get("amp"),
-                    "cbqpoffs": self.option_map.get("cbqpoffs"),
-                    "crqpoffs": self.option_map.get("crqpoffs"),
-                    "ipratio": self.option_map.get("ipratio"),
-                    "pbratio": self.option_map.get("pbratio"),
-                    "early-skip": self.option_map.get("early-skip"),
-                    "ctu": self.option_map.get("ctu"),
-                    "min-cu-size": self.option_map.get("min-cu-size"),
-                    "max-tu-size": self.option_map.get("max-tu-size"),
-                    "level-idc": self.option_map.get("level-idc"),
-                    "sao": self.option_map.get("sao"),
-                    **{
-                        k: v
-                        for k, v in [
-                            s.split("=")
+                _custom_option_map: dict[str, str] = {
+                    k: v
+                    for k, v in {
+                        **{
+                            _param_name: self.option_map.get(_param_name)
+                            for _param_name in X265_PARAMS_NAME
+                        },
+                        **dict(
+                            s.split("=", maxsplit=1)
                             for s in str(self.option_map.get("x265-params", "")).split(
                                 ":"
                             )
-                            if s != ""
-                        ]
-                    },
-                }
-                _custom_option_map = {
-                    k: v for k, v in _custom_option_map.items() if v is not None
+                            if s
+                        ),
+                    }.items()
+                    if v is not None
                 }
 
-                match preset_name:
-                    case Ripper.PresetName.x265fast4:
-                        _option_map = {
-                            "crf": "18",
-                            "qpmin": "12",
-                            "qpmax": "28",
-                            "rd": "2",
-                            "rdoq-level": "1",
-                            "me": "hex",
-                            "merange": "57",
-                            "hme-search": "hex,hex,hex",
-                            "hme-range": "16,32,48",
-                            "aq-mode": "1",
-                            "tu-intra-depth": "1",
-                            "tu-inter-depth": "1",
-                            "limit-tu": "4",
-                            "bframes": "8",
-                            "ref": "6",
-                            "subme": "3",
-                            "open-gop": "0",
-                            "gop-lookahead": "0",
-                            "rc-lookahead": "48",
-                            "cbqpoffs": "-1",
-                            "crqpoffs": "-1",
-                            "pbratio": "1.28",
-                        }
-                    case Ripper.PresetName.x265fast3:
-                        _option_map = {
-                            "crf": "18",
-                            "qpmin": "12",
-                            "qpmax": "28",
-                            "rdoq-level": "1",
-                            "deblock": "-0.5,-0.5",
-                            "me": "hex",
-                            "merange": "57",
-                            "hme-search": "hex,hex,hex",
-                            "hme-range": "16,32,57",
-                            "aq-mode": "3",
-                            "tu-intra-depth": "2",
-                            "tu-inter-depth": "2",
-                            "limit-tu": "4",
-                            "bframes": "12",
-                            "ref": "6",
-                            "subme": "3",
-                            "open-gop": "0",
-                            "gop-lookahead": "0",
-                            "rc-lookahead": "120",
-                            "cbqpoffs": "-1",
-                            "crqpoffs": "-1",
-                            "pbratio": "1.27",
-                        }
-                    case Ripper.PresetName.x265fast2:
-                        _option_map = {
-                            "crf": "18",
-                            "qpmin": "12",
-                            "qpmax": "28",
-                            "rdoq-level": "2",
-                            "deblock": "-1,-1",
-                            "me": "hex",
-                            "merange": "57",
-                            "hme-search": "hex,hex,hex",
-                            "hme-range": "16,57,92",
-                            "aq-mode": "3",
-                            "tu-intra-depth": "3",
-                            "tu-inter-depth": "2",
-                            "limit-tu": "4",
-                            "ref": "6",
-                            "subme": "4",
-                            "open-gop": "0",
-                            "gop-lookahead": "0",
-                            "rc-lookahead": "192",
-                            "cbqpoffs": "-1",
-                            "crqpoffs": "-1",
-                            "pbratio": "1.25",
-                        }
-                    case Ripper.PresetName.x265fast:
-                        _option_map = {
-                            "crf": "18",
-                            "qpmin": "12",
-                            "qpmax": "28",
-                            "psy-rd": "1.8",
-                            "rdoq-level": "2",
-                            "psy-rdoq": "0.4",
-                            "keyint": "312",
-                            "deblock": "-1,-1",
-                            "me": "umh",
-                            "merange": "57",
-                            "hme-search": "umh,hex,hex",
-                            "hme-range": "16,57,92",
-                            "aq-mode": "4",
-                            "tu-intra-depth": "4",
-                            "tu-inter-depth": "3",
-                            "limit-tu": "4",
-                            "subme": "5",
-                            "gop-lookahead": "8",
-                            "rc-lookahead": "216",
-                            "cbqpoffs": "-2",
-                            "crqpoffs": "-2",
-                            "pbratio": "1.2",
-                        }
-                    case Ripper.PresetName.x265slow:
-                        _option_map = {
-                            "crf": "17.5",
-                            "qpmin": "12",
-                            "qpmax": "28",
-                            "rd": "5",
-                            "psy-rd": "1.8",
-                            "rdoq-level": "2",
-                            "psy-rdoq": "0.4",
-                            "qcomp": "0.7",
-                            "keyint": "312",
-                            "deblock": "-1,-1",
-                            "me": "umh",
-                            "merange": "57",
-                            "hme-search": "umh,hex,hex",
-                            "hme-range": "16,57,184",
-                            "aq-mode": "4",
-                            "aq-strength": "1",
-                            "tu-intra-depth": "4",
-                            "tu-inter-depth": "3",
-                            "limit-tu": "2",
-                            "subme": "6",
-                            "gop-lookahead": "14",
-                            "rc-lookahead": "250",
-                            "rect": "1",
-                            "min-keyint": "2",
-                            "cbqpoffs": "-2",
-                            "crqpoffs": "-2",
-                            "pbratio": "1.2",
-                            "early-skip": "0",
-                        }
-                    case Ripper.PresetName.x265full:
-                        _option_map = {
-                            "crf": "17",
-                            "qpmin": "3",
-                            "qpmax": "21.5",
-                            "psy-rd": "2.2",
-                            "rd": "5",
-                            "rdoq-level": "2",
-                            "psy-rdoq": "1.6",
-                            "qcomp": "0.72",
-                            "keyint": "266",
-                            "min-keyint": "2",
-                            "deblock": "-1,-1",
-                            "me": "umh",
-                            "merange": "160",
-                            "hme-search": "full,umh,hex",
-                            "hme-range": "16,92,320",
-                            "aq-mode": "4",
-                            "aq-strength": "1.2",
-                            "tu-intra-depth": "4",
-                            "tu-inter-depth": "4",
-                            "limit-tu": "2",
-                            "subme": "7",
-                            "open-gop": "1",
-                            "gop-lookahead": "14",
-                            "rc-lookahead": "250",
-                            "rect": "1",
-                            "amp": "1",
-                            "cbqpoffs": "-3",
-                            "crqpoffs": "-3",
-                            "ipratio": "1.43",
-                            "pbratio": "1.2",
-                            "early-skip": "0",
-                        }
-
-                _option_map = _default_option_map | _option_map | _custom_option_map
+                _option_map = (
+                    DEFAULT_PRESET_PARAMS.get(preset_name, {}) | _custom_option_map
+                )
 
                 # HEVC 规范
-                if self.option_map.get("hevc-strict", "1") == "1":
-                    if self.media_info.width * self.media_info.height >= (
-                        _RESOLUTION := 1920 * 1080 * 4
-                    ):
-                        if _option_map.get("hme", "0") == "1":
-                            _option_map["hme"] = "0"
-                            log.warning(
-                                "The resolution {} * {} >= {}, auto close HME",
-                                self.media_info.width,
-                                self.media_info.height,
-                                _RESOLUTION,
-                            )
+                if self.option_map.get(
+                    "hevc-strict", "1"
+                ) != "0" and self.media_info.width * self.media_info.height >= (
+                    _RESOLUTION := 1920 * 1080 * 4
+                ):
+                    if _option_map.get("hme", "0") == "1":
+                        _option_map["hme"] = "0"
+                        log.warning(
+                            "The resolution {} * {} >= {}, auto close HME",
+                            self.media_info.width,
+                            self.media_info.height,
+                            _RESOLUTION,
+                        )
 
-                        if int(_option_map.get("ref") or "3") > (_NEW_REF := 6):
-                            _option_map["ref"] = str(_NEW_REF)
-                            log.warning(
-                                "The resolution {} * {} >= {}, auto reduce {} to {}",
-                                self.media_info.width,
-                                self.media_info.height,
-                                _RESOLUTION,
-                                _option_map.get("ref"),
-                                _NEW_REF,
-                            )
+                    if int(_option_map.get("ref") or "3") > (_NEW_REF := 6):
+                        _option_map["ref"] = str(_NEW_REF)
+                        log.warning(
+                            "The resolution {} * {} >= {}, auto reduce {} to {}",
+                            self.media_info.width,
+                            self.media_info.height,
+                            _RESOLUTION,
+                            _option_map.get("ref"),
+                            _NEW_REF,
+                        )
 
                 # 低版本 x265 不支持 -hme 0 主动关闭 HME
                 if _option_map.get("hme", "0") == "0":
@@ -915,7 +587,7 @@ class Ripper:
                     (_crf := _option_map.get("crf"))
                     and (_qpmin := _option_map.get("qpmin"))
                     and (_qpmax := _option_map.get("qpmax"))
-                    and not (_qpmin <= _crf <= _qpmax)
+                    and not (float(_qpmin) <= float(_crf) <= float(_qpmax))
                 ):
                     log.warning("The CRF is not between QPmin and QPmax")
 
@@ -924,22 +596,22 @@ class Ripper:
                 encoder_format_str = (
                     f"{vspipe_input} {FFMPEG_HEADER} {hwaccel} {' '.join(f'-i {s}' for s in ff_input_option)} {' '.join(f'-map {s}' for s in ff_stream_option)} "
                     + audio_option
-                    + f" -c:v libx265 {'' if is_pipe_input else '-pix_fmt yuv420p10le'} -x265-params "
-                    + f' "{_param}" {ffparams_out} '
-                    + (f' -vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
-                    + ' "{output}"'
+                    + f"-c:v libx265 {'' if is_pipe_input else '-pix_fmt yuv420p10le'} -x265-params "
+                    + f'"{_param}" {ffparams_out} '
+                    + (f'-vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
+                    + '"{output}"'
                 )
 
             case (
-                Ripper.PresetName.h264_amf
-                | Ripper.PresetName.h264_nvenc
-                | Ripper.PresetName.h264_qsv
-                | Ripper.PresetName.hevc_amf
-                | Ripper.PresetName.hevc_nvenc
-                | Ripper.PresetName.hevc_qsv
-                | Ripper.PresetName.av1_amf
-                | Ripper.PresetName.av1_nvenc
-                | Ripper.PresetName.av1_qsv
+                Ripper.Preset_name.h264_amf
+                | Ripper.Preset_name.h264_nvenc
+                | Ripper.Preset_name.h264_qsv
+                | Ripper.Preset_name.hevc_amf
+                | Ripper.Preset_name.hevc_nvenc
+                | Ripper.Preset_name.hevc_qsv
+                | Ripper.Preset_name.av1_amf
+                | Ripper.Preset_name.av1_nvenc
+                | Ripper.Preset_name.av1_qsv
             ):
                 _option_map = {
                     "q:v": self.option_map.get("q:v"),
@@ -948,9 +620,9 @@ class Ripper:
                 }
                 match preset_name:
                     case (
-                        Ripper.PresetName.h264_qsv
-                        | Ripper.PresetName.hevc_qsv
-                        | Ripper.PresetName.av1_qsv
+                        Ripper.Preset_name.h264_qsv
+                        | Ripper.Preset_name.hevc_qsv
+                        | Ripper.Preset_name.av1_qsv
                     ):
                         _option_map["qsv_params"] = self.option_map.get("qsv_params")
 
@@ -961,17 +633,19 @@ class Ripper:
                 encoder_format_str = (
                     f"{vspipe_input} {FFMPEG_HEADER} {hwaccel} {' '.join(f'-i {s}' for s in ff_input_option)} {' '.join(f'-map {s}' for s in ff_stream_option)} "
                     + audio_option
-                    + f" -c:v {preset_name.value} "
-                    + f" {_param} {ffparams_out} "
+                    + f"-c:v {preset_name.value} "
+                    + f"{_param} {ffparams_out} "
                     + (f' -vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
                     + ' "{output}"'
                 )
 
-            case Ripper.PresetName.svtav1:
+            case Ripper.Preset_name.svtav1:
                 _option_map = {
                     "crf": self.option_map.get("crf"),
                     "qp": self.option_map.get("qp"),
-                    "pix_fmt": self.option_map.get("pix_fmt"),
+                    "pix_fmt": self.option_map.get(
+                        "pix_fmt", None if is_pipe_input else "yuv420p10le"
+                    ),
                     "preset:v": self.option_map.get("preset:v"),
                     "svtav1-params": self.option_map.get("svtav1-params"),
                 }
@@ -983,13 +657,36 @@ class Ripper:
                 encoder_format_str = (
                     f"{vspipe_input} {FFMPEG_HEADER} {hwaccel} {' '.join(f'-i {s}' for s in ff_input_option)} {' '.join(f'-map {s}' for s in ff_stream_option)} "
                     + audio_option
-                    + " -c:v libsvtav1 "
-                    + f" {_param} {ffparams_out} "
-                    + (f' -vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
+                    + "-c:v libsvtav1 "
+                    + f"{_param} {ffparams_out} "
+                    + (f'-vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
                     + ' "{output}"'
                 )
 
-            case Ripper.PresetName.subset:
+            case Ripper.Preset_name.vvenc:
+                _option_map = {
+                    "qp": self.option_map.get("qp"),
+                    "pix_fmt": self.option_map.get(
+                        "pix_fmt", None if is_pipe_input else "yuv420p10le"
+                    ),
+                    "preset:v": self.option_map.get("preset:v"),
+                    "vvenc-params": self.option_map.get("vvenc-params"),
+                }
+
+                _param = " ".join(
+                    (f"-{key} {val}" for key, val in _option_map.items() if val)
+                )
+
+                encoder_format_str = (
+                    f"{vspipe_input} {FFMPEG_HEADER} {hwaccel} {' '.join(f'-i {s}' for s in ff_input_option)} {' '.join(f'-map {s}' for s in ff_stream_option)} "
+                    + audio_option
+                    + "-c:v libvvenc "
+                    + f"{_param} {ffparams_out} "
+                    + (f'-vf "{",".join(ff_vf_option)}" ' if len(ff_vf_option) else "")
+                    + ' "{output}"'
+                )
+
+            case Ripper.Preset_name.subset:
                 encoder_format_str = ""
 
         return Ripper.Option(
@@ -1026,17 +723,14 @@ class Ripper:
                 log.error(e)
                 continue
 
-            res = {
-                line[0]: line[1]
-                for line in (line.strip().split("=") for line in buffer[-12:])
-            }
+            res = dict(line.strip().split("=", maxsplit=1) for line in buffer[-12:])
 
             if p := res.get("progress"):
-                out_time_us = res.get("out_time_us", "")
-                speed = res.get("speed", "").rstrip("x")
+                out_time_us = res.get("out_time_us", -1)
+                speed = res.get("speed", "-1").rstrip("x")
 
-                self._progress["frame"] = int(res.get("frame", ""))
-                self._progress["fps"] = float(res.get("fps", ""))
+                self._progress["frame"] = int(res.get("frame", -1))
+                self._progress["fps"] = float(res.get("fps", -1))
                 self._progress["out_time_us"] = (
                     int(out_time_us) if out_time_us != "N/A" else 0
                 )
@@ -1066,12 +760,14 @@ class Ripper:
 
         # 生成临时名
         basename = self.output_prefix_list[0]
-        temp_name = f"{basename}-{datetime.now().strftime('%Y-%m-%d_%H：%M：%S')}"
+        temp_name = (
+            f"{basename}-{datetime.now().strftime('%Y-%m-%d_%H：%M：%S.%f')[:-4]}"
+        )
         suffix: str
 
         # 根据格式判断
         match self.option.preset_name:
-            case Ripper.PresetName.custom:
+            case Ripper.Preset_name.custom:
                 suffix = (
                     f".{_suffix}"
                     if (_suffix := self.option_map.get("custom:suffix"))
@@ -1085,7 +781,7 @@ class Ripper:
                     }
                 )
 
-            case Ripper.PresetName.flac:
+            case Ripper.Preset_name.flac:
                 if self.option.muxer is not None or len(self.media_info.audio_info) > 1:
                     suffix = f".flac.{'mp4' if self.option.muxer == Ripper.Muxer.mp4 else 'mkv'}"
                     temp_name = temp_name + suffix
@@ -1105,12 +801,12 @@ class Ripper:
                         }
                     )
 
-            case Ripper.PresetName.subset:
+            case Ripper.Preset_name.subset:
                 _output_dir = Path(self.output_dir) / basename
                 _output_dir.mkdir(parents=True, exist_ok=True)
 
-                _ass_list = list[Path]()
-                _other_sub_list = list[Path]()
+                _ass_list: list[Path] = []
+                _other_sub_list: list[Path] = []
 
                 for path in self.input_path_list:
                     if path.suffix == ".ass":
@@ -1249,13 +945,13 @@ class Ripper:
 
         self._progress["frame_count"] = 0
         self._progress["duration"] = 0
-        if not self.input_path_list[0].suffix == ".vpy":
+        if self.input_path_list[0].suffix != ".vpy":
             self._progress["frame_count"] = self.media_info.nb_frames
             self._progress["duration"] = self.media_info.duration
 
         Thread(target=self._flush_progress, args=(1,), daemon=True).start()
 
-        if self.preset_name is not Ripper.PresetName.custom:
+        if self.preset_name is not Ripper.Preset_name.custom:
             os.environ["FFREPORT"] = f"file={FF_REPORT_LOG_FILE}:level=31"
 
         log.info(cmd)
@@ -1279,8 +975,8 @@ class Ripper:
         else:  # 多文件合成
             # flac 音频轨合成
             if (
-                self.preset_name != Ripper.PresetName.flac
-                and self.option.audio_encoder == Ripper.AudioCodec.flac
+                self.preset_name != Ripper.Preset_name.flac
+                and self.option.audio_encoder == Ripper.Audio_codec.flac
             ):
                 _flac_basename = f"flac_temp_{get_base62_time()}"
                 _flac_fullname = _flac_basename + ".flac.mkv"
@@ -1288,7 +984,7 @@ class Ripper:
                     [self.input_path_list[0]],
                     [_flac_basename],
                     self.output_dir,
-                    Ripper.PresetName.flac,
+                    Ripper.Preset_name.flac,
                     {
                         k: v
                         for k, v in (
@@ -1324,7 +1020,7 @@ class Ripper:
                         (_mux_temp_name,),
                         (Path(temp_name).stem,),
                         self.output_dir,
-                        Ripper.PresetName.copy,
+                        Ripper.Preset_name.copy,
                         {
                             k: v
                             for k, v in dict[str, str | None](
@@ -1355,6 +1051,7 @@ class Ripper:
                 # 处理 soft-sub
                 soft_sub_list: list[Path]
                 soft_sub_map_list: list[str] = soft_sub.split(":")
+
                 if soft_sub_map_list[0] == "auto":
                     soft_sub_list = []
 
@@ -1368,14 +1065,7 @@ class Ripper:
                     for _file_basename in os.listdir(self.output_dir):
                         _file_basename_list = os.path.splitext(_file_basename)
                         if (
-                            _file_basename_list[1]
-                            in {
-                                ".srt",
-                                ".ass",
-                                ".ssa",
-                                ".sup",
-                                ".idx",
-                            }
+                            _file_basename_list[1] in SUBTITLE_SUFFIX_SET
                             and _file_basename_list[0].startswith(_input_prefix)
                             and (
                                 len(soft_sub_map_list) == 1
@@ -1385,9 +1075,8 @@ class Ripper:
                                 in soft_sub_map_list[1:]
                             )
                         ):
-                            soft_sub_list.append(
-                                Path(os.path.join(self.output_dir, _file_basename))
-                            )
+                            soft_sub_list.append(Path(self.output_dir) / _file_basename)
+
                 else:
                     soft_sub_list = [Path(s) for s in soft_sub.split("?")]
 
@@ -1395,10 +1084,10 @@ class Ripper:
                 log.info("-soft-sub list = {}", soft_sub_list)
 
                 # 临时翻译
-                add_tr_files = list[Path]()
+                add_tr_files: Final[list[Path]] = []
                 if translate_sub := self.option_map.get("translate-sub"):
                     _tr = translate_sub.split(":")
-                    if not len(_tr) == 2:
+                    if len(_tr) != 2:
                         log.error("{} param illegal", "-translate-sub")
                     else:
                         try:
@@ -1406,9 +1095,7 @@ class Ripper:
                                 Path(self.output_dir),
                                 _tr[0],
                                 _tr[1],
-                                file_intersection_selector=(
-                                    Path(s) for s in soft_sub_list
-                                ),
+                                file_intersection_selector=soft_sub_list,
                             )
                         except Exception as e:
                             log.error(e, is_format=False)
@@ -1431,7 +1118,7 @@ class Ripper:
                     soft_sub_list + add_tr_files,
                     (subset_folder.name,),
                     self.output_dir,
-                    Ripper.PresetName.subset,
+                    Ripper.Preset_name.subset,
                     self.option_map,
                 ).run():
                     # 合成 MKV
@@ -1445,7 +1132,7 @@ class Ripper:
                         [new_full_name],
                         [os.path.splitext(org_full_name)[0]],
                         self.output_dir,
-                        Ripper.PresetName.copy,
+                        Ripper.Preset_name.copy,
                         {
                             k: v
                             for k, v in dict[str, str | None](
@@ -1465,9 +1152,8 @@ class Ripper:
                             ).items()
                             if v
                         },
-                    ).run():
-                        if os.path.exists(new_full_name):
-                            os.remove(new_full_name)
+                    ).run() and os.path.exists(new_full_name):
+                        os.remove(new_full_name)
                 else:
                     log.error("Subset faild, cancel mux")