File: Broken/Externals/FFmpeg.py¶

class FFmpegModuleBase(BrokenModel, ABC):
    model_config = ConfigDict(
        use_attribute_docstrings=True,
        validate_assignment=True,
    )

    @abstractmethod
    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        ...

class FFmpegInputPath(FFmpegModuleBase):
    type: Annotated[Literal["path"], BrokenTyper.exclude()] = "path"
    path: Path

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        return ("-i", self.path)

class FFmpegInputPipe(FFmpegModuleBase):
    type: Annotated[Literal["pipe"], BrokenTyper.exclude()] = "pipe"

    class Format(str, BrokenEnum):
        Rawvideo   = "rawvideo"
        Image2Pipe = "image2pipe"
        Null       = "null"

    format: Annotated[Optional[Format],
        Option("--format", "-f")] = \
        Field(Format.Rawvideo)

    class PixelFormat(str, BrokenEnum):
        YUV420P = "yuv420p"
        YUV444P = "yuv444p"
        RGB24   = "rgb24"
        RGBA    = "rgba"

    pixel_format: Annotated[PixelFormat,
        Option("--pixel-format", "-p")] = \
        Field(PixelFormat.RGB24)

    width: int = Field(1920, gt=0)
    height: int = Field(1080, gt=0)
    framerate: float = Field(60.0, ge=1.0)

    @field_validator("framerate", mode="plain")
    def validate_framerate(cls, value: Union[float, str]) -> float:
        return eval(str(value))

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        yield ("-f", denum(self.format))
        yield ("-s", f"{self.width}x{self.height}")
        yield ("-pix_fmt", denum(self.pixel_format))
        yield ("-r", self.framerate)
        yield ("-i", "-")

class FFmpegOutputPath(FFmpegModuleBase):
    type: Annotated[Literal["path"], BrokenTyper.exclude()] = "path"

    overwrite: Annotated[bool,
        Option("--overwrite", "-y", " /--no-overwrite", " /-n")] = \
        Field(True)

    path: Annotated[Path,
        typer.Argument(help="The output file path")] = \
        Field(...)

    class PixelFormat(str, BrokenEnum):
        YUV420P = "yuv420p"
        YUV444P = "yuv444p"

    pixel_format: Annotated[Optional[PixelFormat],
        Option("--pixel-format", "-p")] = \
        Field(PixelFormat.YUV420P)

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        yield every("-pix_fmt", denum(self.pixel_format))
        yield (self.path, self.overwrite*"-y")

class FFmpegOutputPipe(FFmpegModuleBase):
    type: Annotated[Literal["pipe"], BrokenTyper.exclude()] = "pipe"

    class Format(str, BrokenEnum):
        Rawvideo   = "rawvideo"
        Image2Pipe = "image2pipe"
        Matroska   = "matroska"
        Mpegts     = "mpegts"
        Null       = "null"

    format: Annotated[Optional[Format],
        Option("--format", "-f")] = \
        Field(None)

    class PixelFormat(str, BrokenEnum):
        RGB24 = "rgb24"
        RGBA  = "rgba"

    pixel_format: Annotated[Optional[PixelFormat],
        Option("--pixel-format", "-p")] = \
        Field(None)

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        yield every("-f", denum(self.format))
        yield every("-pix_fmt", denum(self.pixel_format))
        yield "-"

class FFmpegVideoCodecH264(FFmpegModuleBase):
    """Use [bold orange3][link=https://www.videolan.org/developers/x264.html]VideoLAN's[/link][/] [blue][link=https://trac.ffmpeg.org/wiki/Encode/H.264]libx264[/link][/]"""
    type: Annotated[Literal["h264"], BrokenTyper.exclude()] = "h264"

    class Preset(str, BrokenEnum):
        None_     = None
        UltraFast = "ultrafast"
        SuperFast = "superfast"
        VeryFast  = "veryfast"
        Faster    = "faster"
        Fast      = "fast"
        Medium    = "medium"
        Slow      = "slow"
        Slower    = "slower"
        VerySlow  = "veryslow"

    preset: Annotated[Optional[Preset],
        Option("--preset", "-p")] = \
        Field(Preset.Slow)
    """How much time to spend on encoding. Slower options gives better compression
    [blue link=https://trac.ffmpeg.org/wiki/Encode/H.264#Preset]→ Documentation[/]"""

    class Tune(str, BrokenEnum):
        None_       = None
        Film        = "film"
        Animation   = "animation"
        Grain       = "grain"
        StillImage  = "stillimage"
        FastDecode  = "fastdecode"
        ZeroLatency = "zerolatency"

    tune: Annotated[Optional[Tune],
        Option("--tune", "-t")] = \
        Field(None)
    """Tune x264 to keep and optimize for certain aspects of the input media
    [blue link=https://trac.ffmpeg.org/wiki/Encode/H.264#Tune]→ Documentation[/]"""

    class Profile(str, BrokenEnum):
        None_    = None
        Baseline = "baseline"
        Main     = "main"
        High     = "high"
        High10   = "high10"
        High422  = "high422"
        High444p = "high444p"

    profile: Annotated[Optional[Profile],
        Option("--profile", "-p")] = \
        Field(None)
    """How many features the encoder can use, the playback device must support them
    [blue link=https://trac.ffmpeg.org/wiki/Encode/H.264#Profile]→ Documentation[/]"""

    faststart: Annotated[bool,
        Option("--faststart", " /--no-faststart", hidden=True)] = \
        Field(True)
    """Move the index (moov atom) to the beginning of the file for faster initial playback"""

    rgb: Annotated[bool,
        Option("--rgb", " /--yuv")] = \
        Field(False)
    """Use RGB colorspace instead of YUV"""

    crf: int = Field(20, ge=0, le=51)
    """Constant Rate Factor. 0 is lossless, 51 is the worst quality
    [blue link=https://trac.ffmpeg.org/wiki/Encode/H.264#a1.ChooseaCRFvalue]→ Documentation[/]"""

    crf: Annotated[int,
        Option("--crf", "-c", min=0, max=51)] = \
        Field(20, ge=0, le=51)
    """Constant Rate Factor. 0 is lossless, 51 is the worst quality
    [blue link=https://trac.ffmpeg.org/wiki/Encode/H.264#a1.ChooseaCRFvalue]→ Documentation[/]"""

    bitrate: Annotated[Optional[int],
        Option("--bitrate", "-b", min=0)] = \
        Field(None, ge=0)
    """Bitrate in kilobits per second, the higher the better quality and file size"""

    x264params: Annotated[Optional[list[str]],
        Option("--x264-params", hidden=True)] = \
        Field(None)
    """Additional options to pass to x264"""

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        yield every("-c:v", "libx264rgb" if self.rgb else "libx264")
        yield every("-movflags", "+faststart"*self.faststart)
        yield every("-profile", denum(self.profile))
        yield every("-preset", denum(self.preset))
        yield every("-tune", denum(self.tune))
        yield every("-b:v", self.bitrate)
        yield every("-crf", self.crf)
        yield every("-x264opts", ":".join(self.x264params or []))

class FFmpegVideoCodecH264_NVENC(FFmpegModuleBase):
    """Use [bold green][link=https://en.wikipedia.org/wiki/Nvidia_NVENC]NVIDIA[/link][/] [blue][link=https://trac.ffmpeg.org/wiki/HWAccelIntro]NVENC H.264[/link][/]"""
    type: Annotated[Literal["h264-nvenc"], BrokenTyper.exclude()] = "h264-nvenc"

    class Preset(str, BrokenEnum):
        None_                     = None
        HighQuality2Passes        = "slow"
        HighQuality1Pass          = "medium"
        HighPerformance1Pass      = "fast"
        HighPerformance           = "hp"
        HighQuality               = "hq"
        Balanced                  = "bd"
        LowLatency                = "ll"
        LowLatencyHighQuality     = "llhq"
        LowLatencyHighPerformance = "llhp"
        Lossless                  = "lossless"
        LosslessHighPerformance   = "losslesshp"
        Fastest                   = "p1"
        Faster                    = "p2"
        Fast                      = "p3"
        Medium                    = "p4"
        Slow                      = "p5"
        Slower                    = "p6"
        Slowest                   = "p7"

    preset: Annotated[Optional[Preset],
        Option("--preset", "-p")] = \
        Field(Preset.Medium)
    """How much time to spend on encoding. Slower options gives better compression"""

    class Tune(str, BrokenEnum):
        None_           = None
        HighQuality     = "hq"
        LowLatency      = "ll"
        UltraLowLatency = "ull"
        Lossless        = "lossless"

    tune: Annotated[Optional[Tune],
        Option("--tune", "-t")] = \
        Field(Tune.HighQuality)
    """Tune the encoder for a specific tier of performance"""

    class Profile(str, BrokenEnum):
        None_    = None
        Baseline = "baseline"
        Main     = "main"
        High     = "high"
        High444p = "high444p"

    profile: Annotated[Optional[Profile],
        Option("--profile", "-p")] = \
        Field(Profile.High)
    """How many features the encoder can use, the playback device must support them"""

    class RateControl(str, BrokenEnum):
        None_ = None
        ConstantQuality = "constqp"
        VariableBitrate = "vbr"
        ConstantBitrate = "cbr"

    rate_control: Annotated[Optional[RateControl],
        Option("--rc", "-r", hidden=True)] = \
        Field(RateControl.VariableBitrate)
    """Rate control mode of the bitrate"""

    rc_lookahead: Annotated[Optional[int],
        Option("--rc-lookahead", "-l", hidden=True, min=0)] = \
        Field(32, ge=0)
    """Number of frames to look ahead for the rate control"""

    cbr: Annotated[bool,
        Option("--cbr", "-c", " /--no-cbr", " /-nc", hidden=True)] = \
        Field(False)
    """Enable Constant Bitrate mode"""

    gpu: Annotated[Optional[int],
        Option("--gpu", "-g", min=-1)] = \
        Field(-1, ge=-1)
    """Use the Nth NVENC capable GPU for encoding, -1 to pick the first device available"""

    cq: Annotated[Optional[int],
        Option("--cq", "-q", min=0)] = \
        Field(25, ge=0)
    """(VBR) Similar to CRF, 0 is automatic, 1 is 'lossless', 51 is the worst quality"""

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        yield every("-c:v", "h264_nvenc")
        yield every("-b:v", 0)
        yield every("-preset", denum(self.preset))
        yield every("-tune", denum(self.tune))
        yield every("-profile:v", denum(self.profile))
        yield every("-rc", denum(self.rate_control))
        yield every("-rc-lookahead", self.rc_lookahead)
        yield every("-cbr", int(self.cbr))
        yield every("-cq", self.cq)
        yield every("-gpu", self.gpu)

class FFmpegVideoCodecH264_QSV(FFmpegModuleBase):
    ... # Todo

class FFmpegVideoCodecH264_AMF(FFmpegModuleBase):
    ... # Todo

class FFmpegVideoCodecH265(FFmpegModuleBase):
    """Use [bold orange3][link=https://www.videolan.org/developers/x265.html]VideoLAN's[/link][/] [blue][link=https://trac.ffmpeg.org/wiki/Encode/H.265]libx265[/link][/]"""
    type: Annotated[Literal["h265"], BrokenTyper.exclude()] = "h265"

    crf: Annotated[Optional[int],
        Option("--crf", "-c", min=0, max=51)] = \
        Field(25, ge=0, le=51)
    """Constant Rate Factor (perceptual quality). 0 is lossless, 51 is the worst quality"""

    bitrate: Annotated[Optional[int],
        Option("--bitrate", "-b", min=0)] = \
        Field(None, ge=1)
    """Bitrate in kilobits per second, the higher the better quality and file size"""

    class Preset(str, BrokenEnum):
        None_     = None
        UltraFast = "ultrafast"
        SuperFast = "superfast"
        VeryFast  = "veryfast"
        Faster    = "faster"
        Fast      = "fast"
        Medium    = "medium"
        Slow      = "slow"
        Slower    = "slower"
        VerySlow  = "veryslow"

    preset: Annotated[Optional[Preset],
        Option("--preset", "-p")] = \
        Field(Preset.Slow)
    """How much time to spend on encoding. Slower options gives better compression"""

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        yield every("-c:v", "libx265")
        yield every("-preset", denum(self.preset))
        yield every("-crf", self.crf)
        yield every("-b:v", self.bitrate)

class FFmpegVideoCodecH265_NVENC(FFmpegVideoCodecH265):
    """Use [bold green][link=https://en.wikipedia.org/wiki/Nvidia_NVENC]NVIDIA[/link][/] [blue][link=https://trac.ffmpeg.org/wiki/HWAccelIntro]NVENC H.265[/link][/]"""
    type: Annotated[Literal["h265-nvenc"], BrokenTyper.exclude()] = "h265-nvenc"

    class Preset(str, BrokenEnum):
        HighQuality2Passes        = "slow"
        HighQuality1Pass          = "medium"
        HighPerformance1Pass      = "fast"
        HighPerformance           = "hp"
        HighQuality               = "hq"
        Balanced                  = "bd"
        LowLatency                = "ll"
        LowLatencyHighQuality     = "llhq"
        LowLatencyHighPerformance = "llhp"
        Lossless                  = "lossless"
        LosslessHighPerformance   = "losslesshp"
        Fastest                   = "p1"
        Faster                    = "p2"
        Fast                      = "p3"
        Medium                    = "p4"
        Slow                      = "p5"
        Slower                    = "p6"
        Slowest                   = "p7"

    preset: Annotated[Preset,
        Option("--preset", "-p")] = \
        Field(Preset.Medium)
    """How much time to spend on encoding. Slower options gives better compression"""

    class Tune(str, BrokenEnum):
        None_           = None
        HighQuality     = "hq"
        LowLatency      = "ll"
        UltraLowLatency = "ull"
        Lossless        = "lossless"

    tune: Annotated[Optional[Tune],
        Option("--tune", "-t")] = \
        Field(Tune.HighQuality)

    class Profile(str, BrokenEnum):
        None_  = None
        Main   = "main"
        Main10 = "main10"
        ReXT   = "rext"

    profile: Annotated[Optional[Profile],
        Option("--profile", "-p")] = \
        Field(Profile.Main)

    class Tier(str, BrokenEnum):
        None_ = None
        Main  = "main"
        High  = "high"

    tier: Annotated[Optional[Tier],
        Option("--tier", "-t")] = \
        Field(Tier.High)

    class RateControl(str, BrokenEnum):
        None_           = None
        ConstantQuality = "constqp"
        VariableBitrate = "vbr"
        ConstantBitrate = "cbr"

    rate_control: Annotated[Optional[RateControl],
        Option("--rc", "-r", hidden=True)] = \
        Field(RateControl.VariableBitrate)

    rc_lookahead: Annotated[Optional[int],
        Option("--rc-lookahead", "-l", hidden=True)] = \
        Field(10, ge=1)
    """Number of frames to look ahead for the rate control"""

    cbr: Annotated[bool,
        Option("--cbr", "-c", " /--vbr", " /-v", hidden=True)] = \
        Field(False)
    """Use Constant Bitrate mode"""

    gpu: Annotated[Optional[int],
        Option("--gpu", "-g", min=-1)] = \
        Field(-1, ge=-1)
    """Use the Nth NVENC capable GPU for encoding, -1 to pick the first device available"""

    cq: Annotated[int,
        Option("--cq", "-q", min=0)] = \
        Field(25, ge=0)
    """(VBR) Similar to CRF, 0 is automatic, 1 is 'lossless', 51 is the worst quality"""

    def command(self, ffmpeg: BrokenFFmpeg) -> Iterable[str]:
        yield every("-c:v", "hevc_nvenc")
        yield every("-preset", denum(self.preset))
        yield every("-tune", denum(self.tune))
        yield every("-profile:v", denum(self.profile))
        yield every("-tier", denum(self.tier))
        yield every("-rc", denum(self.rate_control))
        yield every("-rc-lookahead", self.rc_lookahead)
        yield every("-cbr", int(self.cbr))
        yield every("-cq", self.cq)
        yield every("-gpu", self.gpu)